Add type for indicating whether any measurement in the last chunk matched

Author: hdoordt

cli/src/main.rs

@@ -2,7 +2,7 @@ use anyhow::Result;
 use clap::Parser;
 use ppk2::{
     types::{DevicePower, MeasurementMode, SourceVoltage, LogicPortPins, Level},
-    Ppk2, try_find_ppk2_port,
+    Ppk2, try_find_ppk2_port, measurement::MeasurementMatch,
 };
 
 use std::{
@@ -94,14 +94,14 @@ fn main() -> Result<()> {
     let r: Result<()> = loop {
         let rcv_res = rx.recv_timeout(Duration::from_millis(2000));
         count += 1;
-        let now = Instant::now();
-        if now.duration_since(start) > Duration::from_secs(10) {
-            break Ok(());
-        }
+        use MeasurementMatch::*;
         match rcv_res {
-            Ok(m) => {
+            Ok(Match(m)) => {
                 debug!("Last: {:.4} μA", m.micro_amps);
             }
+            Ok(NoMatch) => {
+                debug!("No match");
+            }
             Err(RecvTimeoutError::Disconnected) => break Ok(()),
             Err(e) => {
                 error!("Error receiving data: {e:?}");

ppk2/src/lib.rs

@@ -1,7 +1,7 @@
 #![doc = include_str!("../../README.md")]
 #![deny(missing_docs)]
 
-use measurement::{Measurement, MeasurementAccumulator, MeasurementIterExt};
+use measurement::{Measurement, MeasurementAccumulator, MeasurementIterExt, MeasurementMatch};
 use serialport::{ClearBuffer::Input, FlowControl, SerialPort};
 use std::str::Utf8Error;
 use std::sync::mpsc::{self, Receiver, SendError, TryRecvError};
@@ -39,7 +39,7 @@ pub enum Error {
     #[error("Parse error in \"{0}\"")]
     Parse(String),
     #[error("Error sending measurement: {0}")]
-    SendMeasurement(#[from] SendError<Measurement>),
+    SendMeasurement(#[from] SendError<MeasurementMatch>),
     #[error("Error sending stop signal: {0}")]
     SendStopSignal(#[from] SendError<()>),
     #[error("Worker thread signal error: {0}")]
@@ -114,15 +114,12 @@ impl Ppk2 {
         mut self,
         pins: LogicPortPins,
         sps: usize,
-    ) -> Result<(
-        Receiver<measurement::Measurement>,
-        impl FnOnce() -> Result<Self>,
-    )> {
+    ) -> Result<(Receiver<MeasurementMatch>, impl FnOnce() -> Result<Self>)> {
         // Stuff needed to communicate with the main thread
         // ready allows main thread to signal worker when serial input buf is cleared.
         let ready = Arc::new((Mutex::new(false), Condvar::new()));
         // This channel is for sending measurements to the main thread.
-        let (meas_tx, meas_rx) = mpsc::channel::<measurement::Measurement>();
+        let (meas_tx, meas_rx) = mpsc::channel::<MeasurementMatch>();
         // This channel allows the main thread to notify that the worker thread can stop
         // parsing data.
         let (sig_tx, sig_rx) = mpsc::channel::<()>();
@@ -145,7 +142,6 @@ impl Ppk2 {
                 let mut buf = [0u8; 1024];
                 let mut measurement_buf = VecDeque::with_capacity(SPS_MAX);
                 let mut missed = 0;
-                let mut did_get_matches = false;
                 loop {
                     // Check whether the main thread has signaled
                     // us to stop
@@ -161,17 +157,7 @@ impl Ppk2 {
                     let len = measurement_buf.len();
                     if len >= SPS_MAX / sps {
                         let measurement = measurement_buf.drain(..).combine_matching(missed, pins);
-                        match measurement {
-                            Some(m) => {
-                                meas_tx.send(m)?;
-                                did_get_matches = true;
-                            }
-                            None if did_get_matches => {
-                                break Ok(());
-                            },
-                            _ => {/* No matching measurements yet, wait for them to come up */},
-                        }
-
+                        meas_tx.send(measurement)?;
                         missed = 0;
                     }
                 }

ppk2/src/measurement.rs

@@ -2,7 +2,7 @@
 
 use std::collections::VecDeque;
 
-use crate::types::{LogicPortPins, Metadata};
+use crate::{types::{LogicPortPins, Metadata}};
 
 const ADC_MULTIPLIER: f32 = 1.8 / 163840.;
 const SPIKE_FILTER_ALPHA: f32 = 0.18;
@@ -86,7 +86,7 @@ impl MeasurementAccumulator {
             }
 
             let adc_result = get_adc(raw) * 4;
-            let bits = get_logic(raw).into();
+            let pins = get_logic(raw).into();
             let micro_amps = get_adc_result(
                 &self.metadata,
                 &mut self.state,
@@ -99,7 +99,7 @@ impl MeasurementAccumulator {
 
             buf.push_back(Measurement {
                 micro_amps,
-                pins: bits,
+                pins,
             })
         }
         self.buf.drain(..end);
@@ -165,17 +165,27 @@ fn get_adc_result(
     adc
 }
 
+
+/// Indicates whether a set of [Measurement]s matched
+#[derive(Debug)]
+pub enum MeasurementMatch {
+    /// A set of [Measurement]s did match
+    Match(Measurement),
+    /// No matching [Measurement]s in the last chunk
+    NoMatch,
+}
+
 /// Extension trait for VecDeque<Measurement>
 pub trait MeasurementIterExt {
     /// Combine items into a single [Measurement], if there are items.
-    fn combine(self, missed: usize) -> Option<Measurement>;
+    fn combine(self, missed: usize) -> MeasurementMatch;
 
     /// Combine items with matching logic port pins into a single [Measurement], if any.
-    fn combine_matching(self, missed: usize, matching_pins: LogicPortPins) -> Option<Measurement>;
+    fn combine_matching(self, missed: usize, matching_pins: LogicPortPins) -> MeasurementMatch;
 }
 
 impl<I: Iterator<Item = Measurement>> MeasurementIterExt for I {
-    fn combine(self, missed: usize) -> Option<Measurement> {
+    fn combine(self, missed: usize) -> MeasurementMatch {
         let mut pin_high_count = [0usize; 8];
         let mut count = 0;
         let mut sum = 0f32;
@@ -192,7 +202,7 @@ impl<I: Iterator<Item = Measurement>> MeasurementIterExt for I {
 
         if count == 0 {
             // No measurements
-            return None;
+            return MeasurementMatch::NoMatch;
         }
 
         let mut pins = [false; 8];
@@ -203,13 +213,13 @@ impl<I: Iterator<Item = Measurement>> MeasurementIterExt for I {
             .for_each(|(i, _)| pins[i] = true);
         let avg = sum / (count - missed) as f32;
 
-        Some(Measurement {
+        MeasurementMatch::Match(Measurement {
             micro_amps: avg,
             pins: pins.into(),
         })
     }
 
-    fn combine_matching(self, missed: usize, matching_pins: LogicPortPins) -> Option<Measurement> {
+    fn combine_matching(self, missed: usize, matching_pins: LogicPortPins) -> MeasurementMatch {
         let iter = self.filter(|m| {
             m.pins
                 .inner()

ppk2/src/types.rs

@@ -137,13 +137,14 @@ impl FromStr for DevicePower {
 }
 
 /// Logic level for logic port pins
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, Default)]
 pub enum Level {
     /// Low level
     Low,
     /// High level
     High,
     /// Either level. Used for matching only.
+    #[default]
     Either,
 }
 
@@ -181,12 +182,18 @@ impl Level {
 }
 
 /// Logic port state
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, Default)]
 pub struct LogicPortPins {
     pin_levels: [Level; 8],
 }
 
 impl LogicPortPins {
+    /// Set a pin level
+    pub fn set_level(mut self, pin: usize, level: Level) -> Self {
+        self.pin_levels[pin] = level;
+        self
+    }
+
     /// Set up a new [LogicPortPins] with given [Level]s
     pub fn with_levels(pin_levels: [Level; 8]) -> Self {
         Self { pin_levels }