mpll

Cargo.toml

@@ -33,7 +33,7 @@ socket2 = "0.6.0"
 idsp = "0.20"
 dsp-process = "0.1.0"
 rustfft = "6.1.0"
-rand = { version = "0.9.0", features = ["small_rng"] }
+rand = "0.10.0"
 derive_builder = "0.20.0"
 
 [profile.release]

src/bin/psd.rs

@@ -171,14 +171,14 @@ fn main() -> Result<()> {
         loop {
             match source.get() {
                 Ok(traces) => {
-                    for (i, (name, trace)) in traces.iter().enumerate() {
+                    for (i, (name, trace)) in traces.into_iter().enumerate() {
                         if dec.len() <= i {
                             let mut p = PsdCascade::<{ 1 << 9 }>::default();
                             p.set_detrend(acq.detrend);
                             p.set_avg(acq.avg_opts());
-                            dec.push((*name, p));
+                            dec.push((name, p));
                         }
-                        dec[i].1.process(trace);
+                        dec[i].1.process(&trace);
                     }
                 }
                 Err(e) => log::warn!("source: {}", e),

src/de/data.rs

@@ -1,5 +1,5 @@
 use super::Error;
-use core::fmt::Debug;
+use core::{f32, fmt::Debug};
 
 pub trait Payload<'a>: Debug {
     fn new(batches: usize, data: &'a [u8]) -> Result<Self, Error>
@@ -20,9 +20,7 @@ impl<'a> Payload<'a> for AdcDac<'a> {
     /// * `batch_size` - The size of each batch in samples.
     /// * `data` - The binary data composing the stream frame.
     fn new(batches: usize, data: &'a [u8]) -> Result<Self, Error> {
-        const CHANNELS: usize = 4;
-        const BATCH_SIZE: usize = 8;
-        let data: &[[[[u8; 2]; BATCH_SIZE]; CHANNELS]] = bytemuck::try_cast_slice(data)?;
+        let data = bytemuck::try_cast_slice(data)?;
         assert_eq!(data.len(), batches);
         Ok(Self { data })
     }
@@ -90,7 +88,7 @@ pub struct Fls<'a> {
 
 impl<'a> Payload<'a> for Fls<'a> {
     fn new(batches: usize, data: &'a [u8]) -> Result<Self, Error> {
-        let data: &[[[[u8; 4]; 7]; 2]] = bytemuck::try_cast_slice(data)?;
+        let data = bytemuck::try_cast_slice(data)?;
         // demod_re, demod_im, phase[2], ftw, pow_amp, pll
         assert_eq!(batches, data.len());
         Ok(Self { data })
@@ -148,7 +146,7 @@ pub struct ThermostatEem<'a> {
 
 impl<'a> Payload<'a> for ThermostatEem<'a> {
     fn new(batches: usize, data: &'a [u8]) -> Result<Self, Error> {
-        let data: &[[[u8; 4]; 16 + 4]] = bytemuck::try_cast_slice(data)?;
+        let data = bytemuck::try_cast_slice(data)?;
         assert_eq!(batches, data.len());
         Ok(Self { data })
     }
@@ -164,3 +162,51 @@ impl<'a> Payload<'a> for ThermostatEem<'a> {
             .collect())
     }
 }
+
+#[derive(Clone, Debug)]
+pub struct Mpll<'a> {
+    data: &'a [[[u8; 4]; 6]],
+}
+
+impl<'a> Payload<'a> for Mpll<'a> {
+    fn new(batches: usize, data: &'a [u8]) -> Result<Self, Error> {
+        let data = bytemuck::try_cast_slice(data)?;
+        assert_eq!(batches, data.len());
+        Ok(Self { data })
+    }
+
+    fn traces(&self) -> Result<Vec<(&'static str, Vec<f32>)>, Error> {
+        Ok(vec![
+            (
+                "phase (rad)",
+                self.data
+                    .iter()
+                    .map(|b| {
+                        i32::from_le_bytes(b[4]) as f32 * (f32::consts::TAU / (1u64 << 32) as f32)
+                    })
+                    .collect(),
+            ),
+            (
+                "frequency (kHz)",
+                self.data
+                    .iter()
+                    .map(|b| {
+                        i32::from_le_bytes(b[5]) as f32 * (1.0 / 1.28e-3 / (1u64 << 32) as f32)
+                    })
+                    .collect(),
+            ),
+            (
+                "amplitude (V/G10)",
+                self.data
+                    .iter()
+                    .map(|b| {
+                        ((i32::from_le_bytes(b[0]) as f32).powi(2)
+                            + (i32::from_le_bytes(b[1]) as f32).powi(2))
+                        .sqrt()
+                            * (10.24 / 10.0 * 2.0 * 2.0 / (1u64 << 32) as f32)
+                    })
+                    .collect(),
+            ),
+        ])
+    }
+}

src/de/frame.rs

@@ -54,6 +54,7 @@ impl<'a> Frame<'a> {
             Format::AdcDac => Box::new(data::AdcDac::new(batches, data)?),
             Format::Fls => Box::new(data::Fls::new(batches, data)?),
             Format::ThermostatEem => Box::new(data::ThermostatEem::new(batches, data)?),
+            Format::Mpll => Box::new(data::Mpll::new(header.batches as _, data)?),
         };
         Ok(Self { header, payload })
     }

src/de/mod.rs

@@ -13,6 +13,7 @@ pub enum Format {
     AdcDac = 1,
     Fls = 2,
     ThermostatEem = 3,
+    Mpll = 4,
 }
 
 #[derive(Debug, Clone, Error)]

src/loss.rs

@@ -15,7 +15,7 @@ impl Loss {
             self.dropped += missing;
             if missing > 0 {
                 log::warn!(
-                    "Lost {} batches: {:#08X} -> {:#08X}",
+                    "Lost {} batches {:#08X}..{:#08X}",
                     missing,
                     seq,
                     frame.header.seq,

src/source.rs

@@ -2,7 +2,7 @@ use crate::{Frame, Loss};
 use anyhow::Result;
 use clap::Parser;
 use dsp_process::Process;
-use rand::{rngs::SmallRng, Rng, SeedableRng};
+use rand::{rngs::SmallRng, RngExt, SeedableRng};
 use socket2::{Domain, Protocol, Socket, Type};
 use std::{
     fs::File,
@@ -106,7 +106,7 @@ impl Source {
                     "noise",
                     rng.sample_iter(rand::distr::Open01)
                         .map(|mut x| {
-                            x = (x - 0.5) * 12.0f32.sqrt(); // zero mean, RMS = 1
+                            x = (x - 0.5) * 12f32.sqrt(); // zero mean, RMS = 1
                             state.iter_mut().fold(x, |mut x, s| {
                                 // TODO: branch optimization barrier
                                 (x, *s) = if *diff { (x - *s, x) } else { (*s, x + *s) };
@@ -148,17 +148,13 @@ impl Source {
             },
             Data::Raw(fil) => loop {
                 let mut buf = [0u8; 2048];
-                match fil.read(&mut buf[..]) {
-                    Ok(len) => {
-                        if len == 0 && self.opts.repeat {
-                            fil.seek(std::io::SeekFrom::Start(0))?;
-                            continue;
-                        }
-                        let v: &[[u8; 4]] = bytemuck::cast_slice(&buf[..len / 4 * 4]);
-                        break vec![("raw", v.iter().map(|b| f32::from_le_bytes(*b)).collect())];
-                    }
-                    Err(e) => Err(e)?,
+                let len = fil.read(&mut buf[..])?;
+                if len == 0 && self.opts.repeat {
+                    fil.seek(std::io::SeekFrom::Start(0))?;
+                    continue;
                 }
+                let v: &[[u8; 4]] = bytemuck::cast_slice(&buf[..len / 4 * 4]);
+                break vec![("raw", v.iter().map(|b| f32::from_le_bytes(*b)).collect())];
             },
             Data::Udp(socket) => {
                 let mut buf = [0u8; 2048];