Updated detector rpc configuration

Cargo.lock

···
 checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"
 
 [[package]]
+name = "base64ct"
+version = "1.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06"
+
+[[package]]
 name = "bit-set"
 version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 [[package]]
 name = "embassy-strike-driver"
 version = "0.1.0"
-source = "git+https://tangled.org/sachy.dev/strike-sensor#99f235f794688d6f7756f64b4e0224571421b9a1"
+source = "git+https://tangled.org/sachy.dev/strike-sensor#20f871621244db023615d50c3a1be42470e7c73a"
 dependencies = [
  "defmt 1.0.1",
  "embassy-rp",
···
 
 [[package]]
 name = "jiff"
-version = "0.2.21"
+version = "0.2.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b3e3d65f018c6ae946ab16e80944b97096ed73c35b221d1c478a6c81d8f57940"
+checksum = "1a3546dc96b6d42c5f24902af9e2538e82e39ad350b0c766eb3fbf2d8f3d8359"
 dependencies = [
  "jiff-static",
  "portable-atomic",
···
 
 [[package]]
 name = "jiff-static"
-version = "0.2.21"
+version = "0.2.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a17c2b211d863c7fde02cbea8a3c1a439b98e109286554f2860bdded7ff83818"
+checksum = "2a8c8b344124222efd714b73bb41f8b5120b27a7cc1c75593a6ff768d9d05aa4"
 dependencies = [
  "proc-macro2",
  "quote",
···
 
 [[package]]
 name = "libc"
-version = "0.2.182"
+version = "0.2.183"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6800badb6cb2082ffd7b6a67e6125bb39f18782f793520caee8cb8846be06112"
+checksum = "b5b646652bf6661599e1da8901b3b9522896f01e736bad5f723fe7a3a27f899d"
 
 [[package]]
 name = "linux-raw-sys"
···
 
 [[package]]
 name = "pin-project-lite"
-version = "0.2.16"
+version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b"
+checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
 
 [[package]]
 name = "pio"
···
 
 [[package]]
 name = "quote"
-version = "1.0.44"
+version = "1.0.45"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21b2ebcf727b7760c461f091f9f0f539b77b8e87f2fd88131e7f1b433b3cece4"
+checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
 dependencies = [
  "proc-macro2",
 ]
···
 [[package]]
 name = "sachy-config"
 version = "0.1.0"
-source = "git+https://tangled.org/sachy.dev/sachy-embed-core#7f489f3300e0769817b6b8f7394eb36c8e3f8a03"
+source = "git+https://tangled.org/sachy.dev/sachy-embed-core#ee60e727e6d412cd13009809eb08f51a9b441b44"
 dependencies = [
+ "base64ct",
  "miette",
  "toml_edit",
 ]
···
 [[package]]
 name = "sachy-fmt"
 version = "0.1.0"
-source = "git+https://tangled.org/sachy.dev/sachy-embed-core#7f489f3300e0769817b6b8f7394eb36c8e3f8a03"
+source = "git+https://tangled.org/sachy.dev/sachy-embed-core#ee60e727e6d412cd13009809eb08f51a9b441b44"
 dependencies = [
  "defmt 1.0.1",
 ]
···
 [[package]]
 name = "sachy-mdns"
 version = "0.1.0"
-source = "git+https://tangled.org/sachy.dev/sachy-embed-core#7f489f3300e0769817b6b8f7394eb36c8e3f8a03"
+source = "git+https://tangled.org/sachy.dev/sachy-embed-core#ee60e727e6d412cd13009809eb08f51a9b441b44"
 dependencies = [
  "defmt 1.0.1",
  "embassy-time",
···
 [[package]]
 name = "sachy-sntp"
 version = "0.1.0"
-source = "git+https://tangled.org/sachy.dev/sachy-embed-core#7f489f3300e0769817b6b8f7394eb36c8e3f8a03"
+source = "git+https://tangled.org/sachy.dev/sachy-embed-core#ee60e727e6d412cd13009809eb08f51a9b441b44"
 dependencies = [
  "defmt 1.0.1",
  "embassy-net",
···
 [[package]]
 name = "striker-proto"
 version = "0.1.0"
-source = "git+https://tangled.org/sachy.dev/striker#9ba3ebbda1208b254b6677d7c385cf79de61bad6"
+source = "git+https://tangled.org/sachy.dev/striker#c4fbeb50a975419c7034ea3523fc3cf05d14008c"
 dependencies = [
  "postcard",
  "serde",
···
 
 [[package]]
 name = "toml_datetime"
-version = "0.7.5+spec-1.1.0"
+version = "1.0.0+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "92e1cfed4a3038bc5a127e35a2d360f145e1f4b971b551a2ba5fd7aedf7e1347"
+checksum = "32c2555c699578a4f59f0cc68e5116c8d7cabbd45e1409b989d4be085b53f13e"
 dependencies = [
  "serde_core",
 ]
 
 [[package]]
 name = "toml_edit"
-version = "0.24.1+spec-1.1.0"
+version = "0.25.4+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "01f2eadbbc6b377a847be05f60791ef1058d9f696ecb51d2c07fe911d8569d8e"
+checksum = "7193cbd0ce53dc966037f54351dbbcf0d5a642c7f0038c382ef9e677ce8c13f2"
 dependencies = [
  "indexmap",
  "toml_datetime",
···
 
 [[package]]
 name = "winnow"
-version = "0.7.14"
+version = "0.7.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a5364e9d77fcdeeaa6062ced926ee3381faa2ee02d3eb83a5c27a8825540829"
+checksum = "df79d97927682d2fd8adb29682d1140b343be4ac0f08fd68b7765d9c059d3945"
 dependencies = [
  "memchr",
 ]
 
 [[package]]
 name = "zerocopy"
-version = "0.8.39"
+version = "0.8.40"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db6d35d663eadb6c932438e763b262fe1a70987f9ae936e60158176d710cae4a"
+checksum = "a789c6e490b576db9f7e6b6d661bcc9799f7c0ac8352f56ea20193b2681532e5"
 dependencies = [
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.8.39"
+version = "0.8.40"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4122cd3169e94605190e77839c9a40d40ed048d305bfdc146e7df40ab0f3e517"
+checksum = "f65c489a7071a749c849713807783f70672b28094011623e200cb86dcb835953"
 dependencies = [
  "proc-macro2",
  "quote",

src/detector.rs

···
 use alloc::vec::Vec;
 use sachy_fmt::{info, unwrap};
 
-use embassy_futures::select::select3;
+use embassy_futures::select::select4;
 use embassy_rp::peripherals::DMA_CH1;
 use embassy_strike_driver::{
-    DetectorConfig, DetectorDriver, ZeroCopyChannel,
+    DetectorDriver, ZeroCopyChannel,
     drivers::rp::{AdcDriver, PwmDriver},
+    traits::{AdcSource, PwmSource, TimeSource},
 };
 use embassy_sync::{blocking_mutex::raw::NoopRawMutex, zerocopy_channel::Channel as ZChannel};
 use embassy_time::Timer;
 
 use crate::{
-    constants::{BLIP_SIZE, BLIP_THRESHOLD, BLOCK_SIZE},
+    constants::BLOCK_SIZE,
     rtc::GlobalRtc,
-    updates::UpdateConnection,
+    updates::{DetectorConfigurationHandle, UpdateConnection},
     utils::{static_alloc, try_buffer, try_static_timestamped_block_vecs},
 };
 
···
 
     let (mut sender, mut receiver) = buf_channel.split();
 
-    let config = DetectorConfig::new(BLIP_THRESHOLD, BLIP_SIZE);
+    let config = DetectorConfigurationHandle::get_config();
     let mut detector = DetectorDriver::new(config, rtc.track_time().await, pwm, adc);
     let mut samples = unwrap!(try_buffer(64), "Failed to allocate sample buffer");
     let mut peaks = Vec::new();
···
     loop {
         detector.tune(samples.as_mut_slice()).await;
 
-        select3(
+        select4(
+            update_detector_config(&detector),
             detector.sample_with_zerocopy(&mut sender),
             detector.detect_with_zerocopy(
                 &mut receiver,
···
         detector.reset_timer_source(rtc).await;
     }
 }
+
+async fn update_detector_config<T, P, A>(detector: &DetectorDriver<T, P, A>)
+where
+    T: TimeSource,
+    P: PwmSource,
+    A: AdcSource,
+{
+    loop {
+        let update = DetectorConfigurationHandle::get_updated_config().await;
+
+        detector.set_config(update);
+    }
+}

src/locks.rs

···
 pub type RtcLock = SpinlockRawMutex<1>;
 pub type ConnectionStatusLock = SpinlockRawMutex<2>;
 pub type NetDataLock = SpinlockRawMutex<3>;
+pub type ConfigUpdateLock = SpinlockRawMutex<4>;

src/rpc.rs

···
-use alloc::string::ToString;
 use striker_proto::{Request, Response, StrikerRequest, StrikerResponse};
 
-use crate::constants::{BLIP_SIZE, BLIP_THRESHOLD};
+use crate::updates::{DetectorConfigUpdate, DetectorConfigurationHandle};
 
 pub struct RpcServer;
 
···
     pub async fn handle_request(req: StrikerRequest) -> Option<StrikerResponse> {
         match req.request {
             Request::Ping => Some(StrikerResponse::Response(Response::Pong)),
-            Request::DetectorInfo => Some(StrikerResponse::Response(Response::DetectorInfo {
-                blip_threshold: BLIP_THRESHOLD as usize,
-                blip_size: BLIP_SIZE,
-                max_duty: 100,
-                duty: 0,
-            })),
-            Request::SetDetectorConfig { .. } => {
+            Request::DetectorInfo => {
+                let config = DetectorConfigurationHandle::get_config();
+
+                Some(StrikerResponse::Response(Response::DetectorInfo {
+                    blip_threshold: config.blip_threshold(),
+                    blip_size: config.blip_size(),
+                }))
+            }
+            Request::SetDetectorConfig {
+                blip_size,
+                blip_threshold,
+            } => {
+                DetectorConfigurationHandle::set_config(DetectorConfigUpdate {
+                    blip_threshold,
+                    blip_size,
+                });
+
                 Some(StrikerResponse::Response(Response::SetDetectorConfig {
-                    success: false,
-                    message: Some("NOT IMPLEMENTED".to_string()),
+                    success: true,
+                    message: None,
                 }))
             }
         }

src/state.rs

···
 use core::cell::Cell;
 
-use embassy_sync::blocking_mutex::Mutex;
+use embassy_strike_driver::DetectorConfig;
+use embassy_sync::{blocking_mutex::Mutex, signal::Signal};
 
-use crate::locks::ConnectionStatusLock;
+use crate::{
+    constants::{BLIP_SIZE, BLIP_THRESHOLD},
+    locks::{ConfigUpdateLock, ConnectionStatusLock},
+};
 
 pub static DEVICE_STATE: Mutex<ConnectionStatusLock, Cell<DeviceState>> =
     Mutex::new(Cell::new(DeviceState::Disconnected));
···
     Disconnected,
     Connected,
 }
+
+pub static DETECTOR_CONFIG_UPDATES: Signal<ConfigUpdateLock, DetectorConfig> = Signal::new();
+
+pub static DETECTOR_CONFIG: Mutex<ConfigUpdateLock, DetectorConfig> =
+    Mutex::new(DetectorConfig::new(BLIP_THRESHOLD, BLIP_SIZE));

src/updates.rs

···
-use embassy_strike_driver::DetectorUpdate;
+use embassy_strike_driver::{DetectorConfig, DetectorUpdate};
 use embassy_sync::channel::{Channel, Receiver, Sender};
 use sachy_fmt::info;
 use striker_proto::{StrikerResponse, Update};
 
 use crate::{
     locks::NetDataLock,
-    state::{DEVICE_STATE, DeviceState},
+    state::{DETECTOR_CONFIG, DETECTOR_CONFIG_UPDATES, DEVICE_STATE, DeviceState},
 };
 
 pub type NetDataChannel = Channel<NetDataLock, StrikerResponse, 8>;
···
         };
     }
 }
+
+pub struct DetectorConfigUpdate {
+    pub blip_threshold: Option<u16>,
+    pub blip_size: Option<usize>,
+}
+
+pub struct DetectorConfigurationHandle;
+
+impl DetectorConfigurationHandle {
+    pub fn set_config(update: DetectorConfigUpdate) {
+        let update = DETECTOR_CONFIG.lock(|config| {
+            if let Some(size) = update.blip_size {
+                config.set_blip_size(size);
+            }
+
+            if let Some(threshold) = update.blip_threshold {
+                config.set_blip_threshold(threshold);
+            }
+
+            config.clone()
+        });
+        DETECTOR_CONFIG_UPDATES.signal(update);
+    }
+
+    pub fn get_config() -> DetectorConfig {
+        DETECTOR_CONFIG.lock(Clone::clone)
+    }
+
+    pub async fn get_updated_config() -> DetectorConfig {
+        DETECTOR_CONFIG_UPDATES.wait().await
+    }
+}