delay: temporary DelayNs impl (μs-resolution)

Author: techmccat

examples/blinky_delay.rs

@@ -11,6 +11,7 @@ use hal::stm32;
 use hal::time::ExtU32;
 use hal::timer::Timer;
 use stm32g4xx_hal as hal;
+use embedded_hal_one::delay::DelayNs;
 
 use cortex_m_rt::entry;
 use utils::logger::info;
@@ -47,6 +48,6 @@ fn main() -> ! {
         info!("Toggle");
         led.toggle().unwrap();
         info!("TIM2 delay");
-        delay_tim2.delay_ms(1000_u16);
+        DelayNs::delay_ms(&mut delay_tim2, 1000);
     }
 }

src/delay.rs

@@ -40,10 +40,12 @@ use crate::rcc::Clocks;
 use crate::time::MicroSecond;
 pub use cortex_m::delay::*;
 use cortex_m::peripheral::SYST;
+use fugit::ExtU32Ceil;
 
 use crate::nb::block;
 use crate::time::ExtU32;
 use embedded_hal::blocking::delay::{DelayMs, DelayUs};
+use embedded_hal_one::delay::DelayNs;
 
 pub trait CountDown: embedded_hal::timer::CountDown {
     fn max_period(&self) -> MicroSecond;
@@ -132,7 +134,7 @@ macro_rules! impl_delay_from_count_down_timer  {
                 T: CountDown<Time = MicroSecond>,
             {
                 fn $delay(&mut self, t: u16) {
-                    self.$delay(t as u32);
+                    $Delay::$delay(self, t as u32);
                 }
             }
 
@@ -141,7 +143,7 @@ macro_rules! impl_delay_from_count_down_timer  {
                 T: CountDown<Time = MicroSecond>,
             {
                 fn $delay(&mut self, t: u8) {
-                    self.$delay(t as u32);
+                    $Delay::$delay(self, t as u32);
                 }
             }
         )+
@@ -152,3 +154,34 @@ impl_delay_from_count_down_timer! {
     (DelayMs, delay_ms, 1_000),
     (DelayUs, delay_us, 1)
 }
+
+// TODO: decouple the timer API from embedded-hal 0.2, stm32f4xx-hal with constant timer
+// frequencies looks like a good example
+impl<T: CountDown<Time = MicroSecond>> DelayNs for DelayFromCountDownTimer<T> {
+    // From a quick look at the clock diagram timer resolution can go down to ~3ns on most timers
+    // 170MHz (PLL-R as SysClk) / 1 (AHB Prescaler) / 1 (APBx prescaler) * 2 = 340MHz timer clock
+    // TODO: the current fallback to 1us resolution is a stopgap until the module is reworked
+    fn delay_ns(&mut self, ns: u32) {
+        DelayNs::delay_us(self, ns.div_ceil(1000))
+    }
+    fn delay_us(&mut self, mut us: u32) {
+        let max_sleep = self.0.max_period();
+        let max_us = max_sleep.to_micros();
+
+        while us > max_us {
+            self.0.start(max_us.micros_at_least());
+            let _ = nb::block!(self.0.wait());
+            us -= max_us;
+        }
+        self.0.start(us.micros_at_least());
+        let _ = nb::block!(self.0.wait());
+    }
+    fn delay_ms(&mut self, mut ms: u32) {
+        const MAX_MILLIS: u32 = u32::MAX / 1000;
+        while ms > MAX_MILLIS {
+            ms -= MAX_MILLIS;
+            DelayNs::delay_us(self, MAX_MILLIS * 1000);
+        }
+        DelayNs::delay_us(self, ms * 1000);
+    }
+}

src/time.rs

@@ -101,17 +101,17 @@ impl U32Ext for u32 {
     }
 }
 
-pub fn duration(hz: Hertz, cycles: u32) -> MicroSecond {
+pub fn duration<const NOM: u32, const DENOM: u32>(hz: Hertz, cycles: u32) -> Duration<u32, NOM, DENOM> {
     let cycles = cycles as u64;
     let clk = hz.raw() as u64;
-    let us = cycles.saturating_mul(1_000_000_u64) / clk;
-    MicroSecond::from_ticks(us as u32)
+    let us = cycles.saturating_mul(DENOM as u64) / clk / NOM as u64;
+    Duration::<u32, NOM, DENOM>::from_ticks(us as u32)
 }
 
-pub fn cycles(ms: MicroSecond, clk: Hertz) -> u32 {
+pub fn cycles<const NOM: u32, const DENOM: u32>(ms: Duration<u32, NOM, DENOM>, clk: Hertz) -> u32 {
     assert!(ms.ticks() > 0);
     let clk = clk.raw() as u64;
     let period = ms.ticks() as u64;
-    let cycles = clk.saturating_mul(period) / 1_000_000_u64;
+    let cycles = clk.saturating_mul(period).saturating_mul(NOM as u64) / DENOM as u64;
     cycles as u32
 }