Timestamped detection loop

src/adc.rs

···
 use embassy_rp::{
+    Peri,
     adc::{self, Adc, AdcPin, Async, Config},
     dma,
     peripherals::ADC,
-    Peri,
 };
 use embassy_sync::{blocking_mutex::raw::RawMutex, mutex::Mutex};
 
···
     /// it tries again until the sampling succeeds.
     pub async fn sample(&self, buf: &mut [u16]) {
         // Gain a lock to the inner ADC state, then do a read.
-        self.inner.lock().await.read_many(buf.as_mut()).await;
+        self.inner.lock().await.read_many(buf).await;
     }
 
     pub async fn sample_average(&self, buf: &mut [u16]) -> u16 {

src/detector.rs

···
 mod analysis;
 mod data;
 
-use core::cell::{Cell, RefCell, RefMut};
+use core::cell::Cell;
 
 use alloc::vec::Vec;
-use defmt::{info, unwrap};
+use chrono::TimeDelta;
+use sachy_fmt::{info, unwrap};
 
 use embassy_futures::select::select3;
 use embassy_rp::peripherals::DMA_CH1;
···
 use crate::{
     adc::AdcDriver,
     pwm::PwmDriver,
+    rtc::GlobalRtc,
     state::{DEVICE_STATE, DeviceState},
     updates::{NET_CHANNEL, NetDataSender},
-    utils::{static_alloc, try_buffer, try_static_block_vecs},
+    utils::{static_alloc, try_buffer, try_static_timestamped_block_vecs},
 };
 
 #[embassy_executor::task]
 pub async fn detector_task(
     adc: AdcDriver<'static, NoopRawMutex, DMA_CH1>,
     pwm: PwmDriver<'static>,
+    rtc: GlobalRtc<'static>,
 ) {
+    while !rtc.is_running().await {
+        info!("Waiting for RTC to start running");
+        Timer::after_secs(2).await;
+    }
     let net_data = NET_CHANNEL.sender();
     info!("Allocating detector resources");
 
     let blocks = unwrap!(
-        try_static_block_vecs(4, 512),
+        try_static_timestamped_block_vecs(4, 512),
         "Couldn't allocate block buffers"
     );
 
-    let buf_channel: &mut ZChannel<NoopRawMutex, Vec<u16>> = static_alloc(ZChannel::new(blocks));
+    let buf_channel: &mut ZChannel<NoopRawMutex, (i64, Vec<u16>)> =
+        static_alloc(ZChannel::new(blocks));
 
     let (mut sender, mut receiver) = buf_channel.split();
 
···
         let average = detector.tune(samples.as_mut_slice()).await;
 
         select3(
-            detector.sample(&mut sender),
+            detector.sample(&mut sender, rtc),
             detector.analyse(&mut receiver, average, &mut peaks),
-            detector.tick(),
+            detector.tick(rtc),
         )
         .await;
     }
···
     adc: AdcDriver<'device, NoopRawMutex, DMA_CH1>,
     pwm: PwmDriver<'device>,
     state: DetectorState,
-    net_data: RefCell<NetDataSender>,
+    net_data: NetDataSender,
 }
 
 #[derive(Debug)]
···
         Self {
             adc,
             pwm,
-            net_data: RefCell::new(net_data),
+            net_data,
             state: DetectorState::default(),
         }
     }
···
         self.adc.sample_average(samples).await
     }
 
-    async fn sample(&self, data: &mut Sender<'static, NoopRawMutex, Vec<u16>>) {
+    async fn sample(
+        &self,
+        data: &mut Sender<'static, NoopRawMutex, (i64, Vec<u16>)>,
+        rtc: GlobalRtc<'static>,
+    ) {
+        let time = unwrap!(rtc.get_timestamp().await, "Unable to get timestamp").and_utc();
+        let now = Instant::now();
+
         loop {
-            let buf = data.send().await;
+            let (timestamp, buf) = data.send().await;
+            let elapsed = now.elapsed().as_micros() as i64;
+            *timestamp = (time + TimeDelta::microseconds(elapsed)).timestamp();
             self.adc.sample(buf).await;
             data.send_done();
         }
···
 
     async fn analyse(
         &self,
-        data: &mut Receiver<'static, NoopRawMutex, Vec<u16>>,
+        data: &mut Receiver<'static, NoopRawMutex, (i64, Vec<u16>)>,
         mut average: u16,
         peaks: &mut Vec<u16>,
     ) {
         loop {
             peaks.clear();
 
-            let buf = data.receive().await;
+            let (timestamp, buf) = data.receive().await;
 
             let new_avg =
                 analysis::analyse_buffer_by_stepped_windows(buf.as_slice(), average, peaks);
···
                     .set(self.state.strikes.get().saturating_add(32));
 
                 if let Some(net_data) = self.get_data_channel() {
-                    data::transmit_strike(buf.as_slice(), peaks.as_slice(), average, net_data);
+                    data::transmit_strike(
+                        *timestamp,
+                        buf.as_slice(),
+                        peaks.as_slice(),
+                        average,
+                        net_data,
+                    );
                 }
 
                 info!(
···
         }
     }
 
-    async fn tick(&self) {
+    async fn tick(&self, rtc: GlobalRtc<'static>) {
         let mut inactive: Option<Instant> = None;
         let mut interval = Ticker::every(Duration::from_secs(1));
 
···
                 }
                 None => {
                     if let Some(net_data) = self.get_data_channel() {
-                        data::transmit_level_update(decay, net_data);
+                        let now = unwrap!(rtc.get_timestamp().await, "Unable to get timestamp");
+                        data::transmit_level_update(now.and_utc().timestamp(), decay, net_data);
                     }
                 }
                 _ => continue,
···
         }
     }
 
-    fn get_data_channel(&self) -> Option<RefMut<'_, NetDataSender>> {
+    fn get_data_channel(&self) -> Option<&NetDataSender> {
         let can_send_data = DEVICE_STATE.lock(|x| x.get() == DeviceState::Connected);
 
-        can_send_data
-            .then(|| self.net_data.try_borrow_mut().ok())
-            .flatten()
+        can_send_data.then_some(&self.net_data)
     }
 }

src/detector/analysis.rs

···
 /// needs to be a consistent drop over more than the threshold over a minimum amount of time.
 const BLIP_THRESHOLD: u16 = 5;
 
-pub(super) fn analyse_buffer_by_stepped_windows(buf: &[u16], average: u16, peaks: &mut Vec<u16>) -> u16 {
+pub(super) fn analyse_buffer_by_stepped_windows(
+    buf: &[u16],
+    average: u16,
+    peaks: &mut Vec<u16>,
+) -> u16 {
     const CHUNK_SIZE: usize = BLOCK_SIZE / 32;
     const CHUNK_STEP: usize = CHUNK_SIZE / 2;
 

src/detector/data.rs

···
-use core::cell::RefMut;
-
 use crate::updates::NetDataSender;
 
-pub(super) fn transmit_level_update(warn_level: u16, net_data: RefMut<'_, NetDataSender>) {
+pub(super) fn transmit_level_update(timestamp: i64, warn_level: u16, net_data: &NetDataSender) {
     net_data
-        .try_send(crate::updates::Update::Warning(warn_level))
+        .try_send(crate::updates::Update::Warning {
+            timestamp,
+            level: warn_level,
+        })
         .ok();
 }
 
 pub(super) fn transmit_strike(
+    timestamp: i64,
     samples: &[u16],
     peaks: &[u16],
     average: u16,
-    net_data: RefMut<'_, NetDataSender>,
+    net_data: &NetDataSender,
 ) {
     net_data
         .try_send(crate::updates::Update::Strike {
+            timestamp,
             peaks: peaks.to_vec(),
             samples: samples.to_vec(),
             average,

src/main.rs

···
 
         EXECUTOR1.init_with(Executor::new).run(|spawner| {
             info!("Spawning Detector task");
-            spawner.must_spawn(detector::detector_task(adc, pwm));
+            spawner.must_spawn(detector::detector_task(adc, pwm, rtc));
         })
     });
 

src/net.rs

···
 use sachy_mdns::{GROUP_ADDR_V4, GROUP_SOCK_V4, MDNS_PORT, MdnsAction, MdnsService, Service};
 use sachy_sntp::SntpSocket;
 
-use crate::{rtc::GlobalRtc, state::DEVICE_STATE, updates::{NetDataReceiver, NET_CHANNEL}};
+use crate::{
+    rtc::GlobalRtc,
+    state::DEVICE_STATE,
+    updates::{NET_CHANNEL, NetDataReceiver},
+};
 
 #[embassy_executor::task]
 pub async fn udp_stack(stack: embassy_net::Stack<'static>, rtc: GlobalRtc<'static>) {

src/pwm.rs

···
 use embassy_rp::{
-    pwm::{ChannelBPin, Config as PwmConfig, Pwm, Slice}, Peri,
+    Peri,
+    pwm::{ChannelBPin, Config as PwmConfig, Pwm, Slice},
 };
 
 pub struct PwmDriver<'device> {

src/rtc.rs

···
 #![allow(dead_code)]
 
-use chrono::{Datelike, Timelike};
+use chrono::{Datelike, NaiveDate, NaiveDateTime, NaiveTime, Timelike};
 use embassy_rp::{
     peripherals,
     rtc::{DateTime, DateTimeError, DayOfWeek, Rtc, RtcError},
···
         rtc.is_running()
     }
 
-    pub async fn get_timestamp(&self) -> Result<DateTime, RtcError> {
+    pub async fn get_timestamp(&self) -> Result<NaiveDateTime, RtcError> {
         let rtc = self.0.lock().await;
 
-        rtc.now()
+        let now = rtc.now()?;
+
+        let date = unwrap!(NaiveDate::from_ymd_opt(
+            now.year as i32,
+            now.month as u32,
+            now.day as u32
+        ));
+        let time = unwrap!(NaiveTime::from_hms_opt(
+            now.hour as u32,
+            now.minute as u32,
+            now.second as u32
+        ));
+
+        Ok(NaiveDateTime::new(date, time))
     }
 
     pub async fn set_rtc_datetime(&self, timestamp: SntpTimestamp) -> Result<(), RtcError> {

src/state.rs

···
 pub enum DeviceState {
     Disconnected,
     Connected,
-}
+}

src/updates.rs

···
 
 #[derive(Debug, serde::Serialize)]
 pub enum Update {
-    Warning(u16),
+    Warning {
+        timestamp: i64,
+        level: u16,
+    },
     Strike {
+        timestamp: i64,
         peaks: Vec<u16>,
         samples: Vec<u16>,
         average: u16,

src/utils.rs

···
     Ok(buffer)
 }
 
-pub fn try_static_block_vecs<T: Default + Copy>(
+pub fn try_static_timestamped_block_vecs<T: Default>(
     block_num: usize,
     block_capacity: usize,
-) -> Result<&'static mut [Vec<T>], TryReserveError> {
+) -> Result<&'static mut [(i64, Vec<T>)], TryReserveError> {
     let mut blocks = Vec::new();
 
     blocks.try_reserve_exact(block_num)?;
···
     for _ in 0..block_num {
         let block = try_buffer(block_capacity)?;
 
-        blocks.push(block);
+        blocks.push((0, block));
     }
 
     Ok(blocks.leak())