refactor: Signal detection algorithm tweaks

Cargo.lock

···
  "embassy-time",
  "heapless 0.9.2",
  "pollster",
+ "rand",
+ "wyrand",
 ]
 
 [[package]]
···
 dependencies = [
  "typenum",
  "version_check",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi",
+ "wasip2",
 ]
 
 [[package]]
···
 ]
 
 [[package]]
+name = "ppv-lite86"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
 name = "precomputed-hash"
 version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
+[[package]]
+name = "rand"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
+dependencies = [
+ "rand_chacha",
+ "rand_core 0.9.5",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.9.5",
+]
+
+[[package]]
 name = "rand_core"
 version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c"
+dependencies = [
+ "getrandom",
+]
 
 [[package]]
 name = "redox_syscall"
···
 ]
 
 [[package]]
+name = "wasip2"
+version = "1.0.2+wasi-0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
 name = "winapi-util"
 version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
 dependencies = [
  "windows-link",
+]
+
+[[package]]
+name = "wit-bindgen"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5"
+
+[[package]]
+name = "wyrand"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "15e0359b0b8d9cdef235a1fd4a8c5d02e4c9204e9fac861c14c229a8e803d1a6"
+dependencies = [
+ "rand_core 0.9.5",
 ]
 
 [[package]]

embassy-strike-driver/Cargo.toml

···
 embassy-time = { workspace = true, features = ["mock-driver", "generic-queue-8"] }
 critical-section = { version = "1.1", features = ["std"] }
 pollster = { version = "0.4", features = ["macro"] }
+rand = "0.9"
+wyrand = "0.3"

embassy-strike-driver/src/analysis.rs

···
 use crate::{BLOCK_SIZE, traits::BufferMut};
 
-pub fn analyse_buffer_by_stepped_windows<B: BufferMut<usize>>(
+pub fn analyse_buffer_by_stepped_windows<B: BufferMut<(usize, u16)>>(
     threshold: u16,
     buf: &[u16],
     average: u16,
···
     let mut len = 0u32;
 
     for (i, window) in buf.windows(CHUNK_SIZE).enumerate().step_by(CHUNK_STEP) {
-        let window_total = window.iter().copied().sum::<u16>();
-        let window_avg = window_total / CHUNK_SIZE as u16;
-        let diff = average.saturating_sub(window_avg);
+        let (window_total, window_diff) =
+            window
+                .iter()
+                .copied()
+                .fold((0, 0), |(total, diff), sample| {
+                    (
+                        total + sample,
+                        diff + ((average as i16) - sample as i16).unsigned_abs(),
+                    )
+                });
+
+        let diff = window_diff / CHUNK_SIZE as u16;
 
         if diff > threshold {
-            peaks.push(i);
+            peaks.push((i, diff));
         } else {
             total += window_total as u32;
             len += CHUNK_SIZE as u32;

embassy-strike-driver/src/lib.rs

···
     Detection {
         timestamp: i64,
         samples: &'a [u16],
-        peaks: &'a [usize],
+        peaks: &'a [(usize, u16)],
     },
 }
 
···
     }
 
     pub async fn tune(&mut self, samples: &mut [u16]) {
-        // info!("Tuning Detector for correct voltage settings");
         let mut duty = 0;
         self.pwm.set_duty(duty);
         Timer::after_secs(2).await;
         let mut act_value = self.adc.sample_average(samples).await;
-
-        // info!("initial ACT: {}", act_value);
 
         while act_value < 1364 {
             duty += 2;
···
                 self.pwm.set_duty(duty);
                 Timer::after_secs(2).await;
                 act_value = self.adc.sample_average(samples).await;
-                // info!("Restarting tuning");
                 continue;
             }
             self.pwm.set_duty(duty);
             Timer::after_millis(250).await;
             act_value = self.adc.sample_average(samples).await;
-            // info!("ACT: {}, Duty: {}", act_value, duty);
         }
         self.state.max_duty.set(duty as u8);
-        duty = (duty / 3) * 2;
+        duty = (duty / 6) * 5;
         self.pwm.set_duty(duty);
         self.state.duty.set(duty as u8);
-        // info!("Set detection duty to: {}", duty);
         // Allow voltage level to stabilize after tuning
         Timer::after_secs(2).await;
         let avg = self.adc.sample_average(samples).await;
···
         peaks: &mut B,
         update: F,
     ) where
-        B: BufferMut<usize>,
+        B: BufferMut<(usize, u16)>,
         F: Fn(DetectorUpdate<'_>),
     {
         peaks.clear();
···
         peaks: &'d mut B,
         update: F,
     ) where
-        B: BufferMut<usize>,
+        B: BufferMut<(usize, u16)>,
         F: Fn(DetectorUpdate<'_>),
     {
         loop {
···
 
 #[cfg(test)]
 mod tests {
-    use core::future::poll_fn;
+    use core::{future::poll_fn, ops::RangeBounds, slice::SliceIndex};
     use embassy_time::MockDriver;
+    use rand::{Rng, distr::uniform::SampleRange};
 
     #[cfg(not(feature = "alloc"))]
     extern crate alloc;
···
     }
 
     #[cfg(not(feature = "alloc"))]
-    impl BufferMut<usize> for alloc::vec::Vec<usize> {
-        fn push(&mut self, value: usize) {
+    impl BufferMut<(usize, u16)> for alloc::vec::Vec<(usize, u16)> {
+        fn push(&mut self, value: (usize, u16)) {
             self.push(value);
         }
 
···
             self.is_empty()
         }
 
-        fn as_slice(&self) -> &[usize] {
+        fn as_slice(&self) -> &[(usize, u16)] {
             self
         }
     }
···
         .await;
     }
 
-    fn generate_signal(samples: &mut [u16]) {
+    fn generate_noisy_signal<
+        I: SliceIndex<[u16], Output = [u16]> + RangeBounds<usize>,
+        S: RangeBounds<i16> + SampleRange<i16> + Clone,
+    >(
+        samples: &mut [u16],
+        amplitude: S,
+        range: I,
+    ) {
+        let mut noise = wyrand::WyRand::new(141);
+
+        let samples = samples
+            .get_mut(range)
+            .expect("Range to be sized the same or smaller than the slice");
+
+        for sample in samples.iter_mut() {
+            *sample = ((*sample as i16) - noise.random_range(amplitude.clone())) as u16;
+        }
+    }
+
+    fn generate_drop_signal(samples: &mut [u16]) {
         // Example voltage drop signal
         samples[5] -= 60;
         samples[6] -= 55;
···
         tune_detector_manually(&mut detector, &mut buf, driver).await;
 
         assert_eq!(detector.state.max_duty.get(), 98);
-        assert_eq!(detector.state.duty.get(), 64);
-        assert_eq!(detector.adc.sample_average(&mut buf).await, 896);
+        assert_eq!(detector.state.duty.get(), 80);
+        assert_eq!(detector.adc.sample_average(&mut buf).await, 1120);
     }
 
     #[pollster::test]
···
 
         let mut peaks = alloc::vec::Vec::with_capacity(512);
 
-        let update = |_update: DetectorUpdate<'_>| {
+        detector.detect_from_sample(0, &samples, &mut peaks, |_| {
             panic!("This update function shouldn't be called");
-        };
-
-        detector.detect_from_sample(0, &samples, &mut peaks, update);
+        });
 
         assert_eq!(peaks.len(), 0);
 
-        generate_signal(&mut samples);
+        generate_drop_signal(&mut samples);
 
-        let expected_peaks = alloc::vec![0, 8];
+        let expected_peaks = alloc::vec![(0, 25), (8, 21)];
         let called = Cell::new(false);
 
-        let update = |update: DetectorUpdate<'_>| {
+        detector.detect_from_sample(0, &samples, &mut peaks, |update: DetectorUpdate<'_>| {
             called.set(true);
             assert_eq!(
                 update,
···
                     peaks: expected_peaks.as_slice()
                 }
             )
-        };
+        });
+
+        assert_eq!(peaks.len(), 2);
+        assert!(called.get());
+
+        called.set(false);
+
+        let mut samples = alloc::vec![0; BLOCK_SIZE];
+        let expected_peaks = alloc::vec![(16, 15), (24, 19), (32, 18)];
 
-        detector.detect_from_sample(0, &samples, &mut peaks, update);
+        detector.adc.sample(&mut samples).await;
+        generate_noisy_signal(&mut samples, -40..=40, 20..55);
 
-        assert_eq!(peaks.len(), 2);
+        detector.detect_from_sample(0, &samples, &mut peaks, |update| {
+            called.set(true);
+            assert_eq!(
+                update,
+                DetectorUpdate::Detection {
+                    timestamp: 0,
+                    samples: &samples,
+                    peaks: expected_peaks.as_slice()
+                }
+            )
+        });
+
+        assert_eq!(peaks.len(), 3);
         assert!(called.get());
     }
 
···
         detector.state.avg.set(896);
 
         let mut samples = alloc::vec![0; BLOCK_SIZE];
-        let mut peaks: alloc::vec::Vec<usize> = alloc::vec::Vec::with_capacity(BLOCK_SIZE);
+        let mut peaks = alloc::vec::Vec::with_capacity(BLOCK_SIZE);
 
         // Require bigger size blips.
         detector.config.blip_size.set(3);
 
         detector.adc.sample(&mut samples).await;
-        generate_signal(&mut samples);
+        generate_drop_signal(&mut samples);
 
         detector.detect_from_sample(0, &samples, &mut peaks, |_update| {
             panic!("Update shouldn't be called");