impl countdown

Author: andrewgazelka

src/delay.rs

@@ -37,14 +37,15 @@
 use cast::u32;
 use cortex_m::peripheral::syst::SystClkSource;
 use cortex_m::peripheral::SYST;
-
-use crate::nb::block;
-use crate::rcc::CoreClocks;
-use crate::time::{Hertz, U32Ext};
 use embedded_hal::{
     blocking::delay::{DelayMs, DelayUs},
     timer::CountDown,
 };
+use void::Void;
+
+use crate::nb::block;
+use crate::rcc::CoreClocks;
+use crate::time::{Hertz, U32Ext};
 
 pub trait DelayExt {
     fn delay(self, clocks: CoreClocks) -> Delay;
@@ -62,6 +63,89 @@ pub struct Delay {
     syst: SYST,
 }
 
+/// Implements [CountDown](embedded_hal::timer::CountDown) for the System timer (SysTick).
+/// Time is measured in microseconds
+pub struct CountdownUs<'a> {
+    clocks: CoreClocks,
+    syst: &'a mut SYST,
+    total_rvr: u64,
+    finished: bool,
+}
+
+impl<'a> CountdownUs<'a> {
+    /// Create a new [CountDown] measured in microseconds.
+    pub fn new(syst: &'a mut SYST, clocks: CoreClocks) -> Self {
+        Self {
+            syst,
+            clocks,
+            total_rvr: 0,
+            finished: true,
+        }
+    }
+
+    /// start a wait cycle and sets finished to true if [CountdownUs] is done waiting.
+    fn start_wait(&mut self) {
+        // The SysTick Reload Value register supports values between 1 and 0x00FFFFFF.
+        const MAX_RVR: u32 = 0x00FF_FFFF;
+
+        if self.total_rvr != 0 {
+            self.finished = false;
+            let current_rvr = if self.total_rvr <= MAX_RVR.into() {
+                self.total_rvr as u32
+            } else {
+                MAX_RVR
+            };
+
+            self.syst.set_reload(current_rvr);
+            self.syst.clear_current();
+            self.syst.enable_counter();
+
+            self.total_rvr -= current_rvr as u64;
+        } else {
+            self.finished = true;
+        }
+    }
+}
+
+impl<'a> CountDown for CountdownUs<'a> {
+    type Time = u32;
+
+    fn start<T>(&mut self, count: T)
+    where
+        T: Into<Self::Time>,
+    {
+        let us = count.into();
+
+        // With c_ck up to 480e6, we need u64 for delays > 8.9s
+
+        self.total_rvr = if cfg!(not(feature = "revision_v")) {
+            // See errata ES0392 §2.2.3. Revision Y does not have the /8 divider
+            u64::from(us) * u64::from(self.clocks.c_ck().0 / 1_000_000)
+        } else if cfg!(feature = "cm4") {
+            // CM4 dervived from HCLK
+            u64::from(us) * u64::from(self.clocks.hclk().0 / 8_000_000)
+        } else {
+            // Normally divide by 8
+            u64::from(us) * u64::from(self.clocks.c_ck().0 / 8_000_000)
+        };
+
+        self.start_wait();
+    }
+
+    fn wait(&mut self) -> nb::Result<(), Void> {
+        if self.finished {
+            return Ok(());
+        }
+
+        if self.syst.has_wrapped() {
+            self.syst.disable_counter();
+            self.start_wait();
+        }
+
+        Err(nb::Error::WouldBlock)
+    }
+}
+
 impl Delay {
     /// Configures the system timer (SysTick) as a delay provider
     pub fn new(mut syst: SYST, clocks: CoreClocks) -> Self {