feat: TimerSource tweaks, Config API

Cargo.lock

···
 
 [[package]]
 name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "bitflags"
 version = "2.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "812e12b5285cc515a9c72a5c1d3b6d46a19dac5acfef5265968c166106e31dd3"
···
 checksum = "f578e8e2c440e7297e008bb5486a3a8a194775224bbc23729b0dbdfaeebf162e"
 
 [[package]]
+name = "defmt"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "548d977b6da32fa1d1fda2876453da1e7df63ad0304c8b3dae4dbe7b96f39b78"
+dependencies = [
+ "bitflags 1.3.2",
+ "defmt-macros",
+]
+
+[[package]]
+name = "defmt-macros"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d4fc12a85bcf441cfe44344c4b72d58493178ce635338a3f3b78943aceb258e"
+dependencies = [
+ "defmt-parser",
+ "proc-macro-error2",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "defmt-parser"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "10d60334b3b2e7c9d91ef8150abfb6fa4c1c39ebbcf4a81c2e346aad939fee3e"
+dependencies = [
+ "thiserror",
+]
+
+[[package]]
 name = "digest"
 version = "0.10.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 version = "0.1.0"
 dependencies = [
  "critical-section",
+ "defmt",
  "embassy-rp",
  "embassy-sync",
  "embassy-time",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
 dependencies = [
- "bitflags",
+ "bitflags 2.10.0",
 ]
 
 [[package]]
···
 checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755"
 dependencies = [
  "winapi-util",
+]
+
+[[package]]
+name = "thiserror"
+version = "2.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "2.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
 ]
 
 [[package]]

embassy-strike-driver/Cargo.toml

···
 
 [features]
 default = []
+debug = ["defmt"]
 alloc = []
 heapless = ["dep:heapless"]
+defmt = ["dep:defmt"]
 rp2040 = ["dep:embassy-rp", "embassy-rp/rp2040"]
 rp235xa = ["dep:embassy-rp", "embassy-rp/rp235xa"]
 rp235xb = ["dep:embassy-rp", "embassy-rp/rp235xb"]
···
 embassy-sync.workspace = true
 embassy-rp = { workspace = true, optional = true }
 heapless = { version = "0.9.2", optional = true }
+defmt = { workspace = true, optional = true }
 
 [dev-dependencies]
 embassy-time = { workspace = true, features = ["mock-driver", "generic-queue-8"] }

embassy-strike-driver/src/drivers.rs

···
         dma: Peri<'device, T>,
     }
 
-    pub struct RpAdcDriver<'device, M: RawMutex, T: dma::Channel> {
+    pub struct AdcDriver<'device, M: RawMutex, T: dma::Channel> {
         inner: Mutex<M, AdcInner<'device, T>>,
     }
 
···
         }
     }
 
-    impl<'device, M: RawMutex, T: dma::Channel> RpAdcDriver<'device, M, T> {
+    impl<'device, M: RawMutex, T: dma::Channel> AdcDriver<'device, M, T> {
         pub fn new(
             inner: Peri<'device, ADC>,
             pin: Peri<'device, impl AdcPin + 'device>,
···
         }
     }
 
-    impl<'device, M: RawMutex, T: dma::Channel> AdcSource for RpAdcDriver<'device, M, T> {
+    impl<'device, M: RawMutex, T: dma::Channel> AdcSource for AdcDriver<'device, M, T> {
         async fn sample_average(&self, samples: &mut [u16]) -> u16 {
             self.sample(samples).await;
 

embassy-strike-driver/src/lib.rs

···
 
 use core::cell::Cell;
 
+#[cfg(feature = "debug")]
+use defmt::info;
 use embassy_sync::{
     blocking_mutex::raw::NoopRawMutex,
     zerocopy_channel::{Channel, Receiver, Sender},
···
 pub type ZeroCopyChannel<'device> = Channel<'device, NoopRawMutex, (i64, [u16; BLOCK_SIZE])>;
 
 #[derive(Debug)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 struct DetectorState {
     max_duty: Cell<u8>,
     duty: Cell<u8>,
···
 }
 
 #[derive(Debug)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub struct DetectorConfig {
     blip_threshold: Cell<u16>,
     blip_size: Cell<usize>,
 }
 
-impl Default for DetectorConfig {
-    fn default() -> Self {
+impl DetectorConfig {
+    pub const fn new(blip_threshold: u16, blip_size: usize) -> Self {
         Self {
-            blip_threshold: Cell::new(14),
-            blip_size: Cell::new(2),
+            blip_threshold: Cell::new(blip_threshold),
+            blip_size: Cell::new(blip_size),
         }
+    }
+
+    pub const fn blip_threshold(&self) -> u16 {
+        self.blip_threshold.get()
+    }
+
+    pub const fn blip_size(&self) -> usize {
+        self.blip_size.get()
+    }
+
+    pub fn set_blip_threshold(&self, blip_threshold: u16) {
+        self.blip_threshold.set(blip_threshold);
+    }
+
+    pub fn set_blip_size(&self, blip_size: usize) {
+        self.blip_size.set(blip_size);
+    }
+}
+
+impl Default for DetectorConfig {
+    fn default() -> Self {
+        Self::new(14, 2)
     }
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 pub enum DetectorUpdate<'a> {
     Tick {
         timestamp: i64,
···
 pub struct DetectorDriver<T: TimeSource, P: PwmSource, A: AdcSource> {
     state: DetectorState,
     config: DetectorConfig,
-    timer_source: T,
+    timer: T,
     pwm: P,
     adc: A,
 }
···
     P: PwmSource,
     A: AdcSource,
 {
-    pub fn new(config: DetectorConfig, timer_source: T, pwm: P, adc: A) -> Self {
+    pub fn new(config: DetectorConfig, timer: T, pwm: P, adc: A) -> Self {
         Self {
             state: Default::default(),
             config,
-            timer_source,
+            timer,
             pwm,
             adc,
         }
     }
 
-    pub fn reset_timer_source(&mut self) {
-        self.timer_source = T::get_source();
+    pub fn reset_timer_source(&mut self, timer_source: T::Source) {
+        self.timer.reset_from_source(timer_source);
     }
 
     pub fn get_timestamp(&self) -> i64 {
-        self.timer_source.timestamp()
+        self.timer.timestamp()
     }
 
     pub fn set_blip_threshold(&self, threshold: u16) {
···
         self.pwm.set_duty(duty);
         Timer::after_secs(2).await;
         let mut act_value = self.adc.sample_average(samples).await;
+        #[cfg(feature = "debug")]
+        info!("START: {}", act_value);
 
         while act_value < 1364 {
             duty += 2;
             if duty >= 256 {
+                #[cfg(feature = "debug")]
+                info!("RESET: {} @ Duty {}", act_value, duty);
                 duty = 0;
                 self.pwm.set_duty(duty);
                 Timer::after_secs(2).await;
···
             self.pwm.set_duty(duty);
             Timer::after_millis(250).await;
             act_value = self.adc.sample_average(samples).await;
+            #[cfg(feature = "debug")]
+            info!("UPDATE: {} @ Duty {}", act_value, duty);
         }
         self.state.max_duty.set(duty as u8);
         duty = (duty / 6) * 5;
···
         // Allow voltage level to stabilize after tuning
         Timer::after_secs(2).await;
         let avg = self.adc.sample_average(samples).await;
+        #[cfg(feature = "debug")]
+        info!("SET: {} @ Duty {}/{}", avg, duty, self.state.max_duty.get());
         self.state.avg.set(avg);
     }
 
···
     ) {
         loop {
             let (time, samples) = dma.send().await;
-            *time = self.timer_source.timestamp();
+            *time = self.get_timestamp();
             self.adc.sample(samples).await;
             dma.send_done();
         }
···
                 }
                 None => {
                     update(DetectorUpdate::Tick {
-                        timestamp: self.timer_source.timestamp(),
+                        timestamp: self.get_timestamp(),
                         level: warn_level - 255,
                     });
                 }
···
     struct MockTimeSource;
 
     impl TimeSource for MockTimeSource {
-        fn get_source() -> Self {
-            Self
-        }
+        type Source = ();
+
+        fn reset_from_source(&mut self, _source: Self::Source) {}
+
         fn timestamp(&self) -> i64 {
             0
         }
···
             )
         });
 
-        assert_eq!(peaks.len(), 3);
         assert!(called.get());
+        assert_eq!(peaks.len(), 3);
 
         detector.adc.sample(&mut samples).await;
 

embassy-strike-driver/src/traits.rs

···
 pub trait TimeSource {
+    type Source;
+
     fn timestamp(&self) -> i64;
-    fn get_source() -> Self;
+    fn reset_from_source(&mut self, source: Self::Source);
 }
 
 pub trait AdcSource {