Use fugit for time related types to make the crate more consistent with stm32g0xx-hal

usbalbin · usbalbin · commit d2aa379feaaf · 2023-04-22T00:10:26.000+02:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -18,6 +18,7 @@ paste = "1.0"
 bitflags = "1.2"
 vcell = "0.1"
 static_assertions = "1.1"
+fugit = "0.3.5"
 
 [dependencies.cortex-m]
 version = "0.7.7"
diff --git a/examples/blinky_delay.rs b/examples/blinky_delay.rs
@@ -8,6 +8,7 @@ use hal::prelude::*;
 use hal::rcc::Config;
 use hal::stm32;
 use hal::timer::Timer;
+use hal::time::ExtU32;
 use stm32g4xx_hal as hal;
 
 use cortex_m_rt::entry;
@@ -34,13 +35,13 @@ fn main() -> ! {
 
     info!("Init Timer2 delay");
     let timer2 = Timer::new(dp.TIM2, &rcc.clocks);
-    let mut delay_tim2 = DelayFromCountDownTimer::new(timer2.start_count_down(100.ms()));
+    let mut delay_tim2 = DelayFromCountDownTimer::new(timer2.start_count_down(100.millis()));
 
     loop {
         info!("Toggle");
         led.toggle().unwrap();
         info!("SYST delay");
-        delay_syst.delay(1000.ms());
+        delay_syst.delay(1000.millis());
         info!("Toggle");
         led.toggle().unwrap();
         info!("TIM2 delay");
diff --git a/examples/can-echo.rs b/examples/can-echo.rs
@@ -7,7 +7,7 @@ use crate::hal::{
     nb::block,
     rcc::{Config, RccExt, SysClockSrc},
     stm32::Peripherals,
-    time::U32Ext,
+    time::RateExtU32,
 };
 use fdcan::{
     config::NominalBitTiming,
@@ -47,7 +47,7 @@ fn main() -> ! {
     let dp = Peripherals::take().unwrap();
     let _cp = cortex_m::Peripherals::take().expect("cannot take core peripherals");
     let rcc = dp.RCC.constrain();
-    let mut rcc = rcc.freeze(Config::new(SysClockSrc::HSE(24.mhz())));
+    let mut rcc = rcc.freeze(Config::new(SysClockSrc::HSE(24.MHz())));
 
     info!("Split GPIO");
 
diff --git a/examples/i2c-bme680.rs b/examples/i2c-bme680.rs
@@ -12,6 +12,7 @@ use hal::prelude::*;
 use hal::stm32;
 use hal::timer::Timer;
 use stm32g4xx_hal as hal;
+use hal::time::{ExtU32, RateExtU32};
 
 use cortex_m_rt::entry;
 use log::info;
@@ -32,11 +33,11 @@ fn main() -> ! {
     let sda = gpiob.pb9.into_alternate_open_drain();
     let scl = gpiob.pb8.into_alternate_open_drain();
 
-    let i2c = dp.I2C1.i2c(sda, scl, Config::new(100.khz()), &mut rcc);
+    let i2c = dp.I2C1.i2c(sda, scl, Config::new(100.kHz()), &mut rcc);
 
     let mut delayer = cp.SYST.delay(&rcc.clocks);
     let timer2 = Timer::new(dp.TIM2, &rcc.clocks);
-    let mut delay = DelayFromCountDownTimer::new(timer2.start_count_down(100.ms()));
+    let mut delay = DelayFromCountDownTimer::new(timer2.start_count_down(100.millis()));
 
     let mut dev =
         Bme680::init(i2c, &mut delayer, I2CAddress::Secondary).expect("Init function failed");
diff --git a/examples/i2c-mpu6050.rs b/examples/i2c-mpu6050.rs
@@ -7,6 +7,7 @@ use hal::i2c::Config;
 use hal::prelude::*;
 use hal::stm32;
 use stm32g4xx_hal as hal;
+use hal::time::{ExtU32, RateExtU32};
 
 use cortex_m_rt::entry;
 use log::info;
@@ -28,7 +29,7 @@ fn main() -> ! {
     let sda = gpiob.pb9.into_alternate_open_drain();
     let scl = gpiob.pb8.into_alternate_open_drain();
 
-    let i2c = dp.I2C1.i2c(sda, scl, Config::new(100.khz()), &mut rcc);
+    let i2c = dp.I2C1.i2c(sda, scl, Config::new(100.kHz()), &mut rcc);
 
     let mut mpu = Mpu6050::new(i2c);
     let mut delay = cp.SYST.delay(&rcc.clocks);
@@ -39,6 +40,6 @@ fn main() -> ! {
         let gyro = mpu.get_gyro().expect("cannot read gyro");
         let temp = mpu.get_temp().expect("cannot read temperature");
         info!("acc: {:?}, gyro: {:?}, temp: {:?}C", acc, gyro, temp);
-        delay.delay(250.ms());
+        delay.delay(250.millis());
     }
 }
diff --git a/examples/i2c.rs b/examples/i2c.rs
@@ -7,6 +7,7 @@ use hal::i2c::Config;
 use hal::prelude::*;
 use hal::stm32;
 use stm32g4xx_hal as hal;
+use hal::time::RateExtU32;
 
 use cortex_m_rt::entry;
 use log::info;
@@ -25,7 +26,7 @@ fn main() -> ! {
     let sda = gpiob.pb9.into_alternate_open_drain();
     let scl = gpiob.pb8.into_alternate_open_drain();
 
-    let mut i2c = dp.I2C1.i2c(sda, scl, Config::new(40.khz()), &mut rcc);
+    let mut i2c = dp.I2C1.i2c(sda, scl, Config::new(40.kHz()), &mut rcc);
     // Alternatively, it is possible to specify the exact timing as follows (see the documentation
     // of with_timing() for an explanation of the constant):
     //let mut i2c = dp
diff --git a/examples/pwm.rs b/examples/pwm.rs
@@ -9,6 +9,7 @@ use hal::gpio::AF6;
 use hal::prelude::*;
 use hal::stm32;
 use stm32g4xx_hal as hal;
+use hal::time::RateExtU32;
 mod utils;
 extern crate cortex_m_rt as rt;
 
@@ -19,7 +20,7 @@ fn main() -> ! {
     let gpioa = dp.GPIOA.split(&mut rcc);
     let pin: PA8<Alternate<AF6>> = gpioa.pa8.into_alternate();
 
-    let mut pwm = dp.TIM1.pwm(pin, 100.hz(), &mut rcc);
+    let mut pwm = dp.TIM1.pwm(pin, 100.Hz(), &mut rcc);
 
     pwm.set_duty(pwm.get_max_duty() / 2);
     pwm.enable();
diff --git a/examples/spi-example.rs b/examples/spi-example.rs
@@ -7,7 +7,7 @@
 
 use crate::hal::{
     block, delay::DelayFromCountDownTimer, gpio::gpioa::PA5, gpio::gpioa::PA6, gpio::gpioa::PA7,
-    gpio::Alternate, gpio::AF5, prelude::*, rcc::Config, spi, stm32::Peripherals, timer::Timer,
+    gpio::Alternate, gpio::AF5, prelude::*, rcc::Config, spi, stm32::Peripherals, timer::Timer, time::{ExtU32, RateExtU32}
 };
 
 use cortex_m_rt::entry;
@@ -25,7 +25,7 @@ fn main() -> ! {
     let rcc = dp.RCC.constrain();
     let mut rcc = rcc.freeze(Config::hsi());
     let timer2 = Timer::new(dp.TIM2, &rcc.clocks);
-    let mut delay_tim2 = DelayFromCountDownTimer::new(timer2.start_count_down(100.ms()));
+    let mut delay_tim2 = DelayFromCountDownTimer::new(timer2.start_count_down(100.millis()));
 
     let gpioa = dp.GPIOA.split(&mut rcc);
     let sclk: PA5<Alternate<AF5>> = gpioa.pa5.into_alternate();
@@ -34,7 +34,7 @@ fn main() -> ! {
 
     let mut spi = dp
         .SPI1
-        .spi((sclk, miso, mosi), spi::MODE_0, 400.khz(), &mut rcc);
+        .spi((sclk, miso, mosi), spi::MODE_0, 400.kHz(), &mut rcc);
     let mut cs = gpioa.pa8.into_push_pull_output();
     cs.set_high().unwrap();
 
diff --git a/examples/spi-sd.rs b/examples/spi-sd.rs
@@ -18,6 +18,7 @@ use hal::stm32;
 use hal::stm32::Peripherals;
 use hal::timer::Timer;
 use stm32g4xx_hal as hal;
+use hal::time::RateExtU32;
 
 use embedded_sdmmc::{
     Block, BlockCount, BlockDevice, BlockIdx, Controller, Error, Mode, TimeSource, Timestamp,
@@ -50,7 +51,7 @@ fn main() -> ! {
 
     let mut spi = dp
         .SPI2
-        .spi((sck, miso, mosi), spi::MODE_0, 400.khz(), &mut rcc);
+        .spi((sck, miso, mosi), spi::MODE_0, 400.kHz(), &mut rcc);
 
     struct Clock;
 
diff --git a/examples/uart-dma.rs b/examples/uart-dma.rs
@@ -12,6 +12,7 @@ use hal::prelude::*;
 use hal::serial::*;
 use hal::{rcc, stm32};
 use stm32g4xx_hal as hal;
+use hal::time::ExtU32;
 
 use cortex_m_rt::entry;
 use log::info;
@@ -70,7 +71,7 @@ fn main() -> ! {
     loop {
         while !transfer.get_transfer_complete_flag() {}
 
-        delay_syst.delay(1000.ms());
+        delay_syst.delay(1000.millis());
         led.toggle().unwrap();
         transfer.restart(|_tx| {});
     }
diff --git a/src/delay.rs b/src/delay.rs
@@ -42,19 +42,22 @@ pub use cortex_m::delay::*;
 use cortex_m::peripheral::SYST;
 
 use crate::nb::block;
-use crate::time::{Hertz, U32Ext};
+use crate::time::ExtU32;
 use embedded_hal::{
     blocking::delay::{DelayMs, DelayUs},
-    timer::CountDown,
 };
 
+pub trait CountDown: embedded_hal::timer::CountDown {
+    fn max_period(&self) -> MicroSecond;
+}
+
 pub trait SYSTDelayExt {
     fn delay(self, clocks: &Clocks) -> Delay;
 }
 
 impl SYSTDelayExt for SYST {
     fn delay(self, clocks: &Clocks) -> Delay {
-        Delay::new(self, clocks.ahb_clk.0)
+        Delay::new(self, clocks.ahb_clk.raw())
     }
 }
 
@@ -69,7 +72,7 @@ impl DelayExt for Delay {
     where
         T: Into<MicroSecond>,
     {
-        self.delay_us(delay.into().0)
+        self.delay_us(delay.into().ticks())
     }
 }
 
@@ -94,36 +97,41 @@ macro_rules! impl_delay_from_count_down_timer  {
 
             impl<T> $Delay<u32> for DelayFromCountDownTimer<T>
             where
-                T: CountDown<Time = Hertz>,
+                T: CountDown<Time = MicroSecond>,
             {
                 fn $delay(&mut self, t: u32) {
-                    let mut time_left = t;
-
-                    // Due to the LpTimer having only a 3 bit scaler, it is
-                    // possible that the max timeout we can set is
-                    // (128 * 65536) / clk_hz milliseconds.
-                    // Assuming the fastest clk_hz = 480Mhz this is roughly ~17ms,
-                    // or a frequency of ~57.2Hz. We use a 60Hz frequency for each
-                    // loop step here to ensure that we stay within these bounds.
-                    let looping_delay = $num / 60;
-                    let looping_delay_hz = Hertz($num / looping_delay);
-
-                    self.0.start(looping_delay_hz);
-                    while time_left > looping_delay {
-                        block!(self.0.wait()).ok();
-                        time_left -= looping_delay;
+                    let mut time_left_us = t as u64 * $num;
+
+                    let max_sleep = self.0.max_period();
+                    let max_sleep_us = max_sleep.to_micros() as u64;
+
+                    if time_left_us > max_sleep_us {
+                        self.0.start(max_sleep);
+
+                        // Process the time one max_sleep duration at a time
+                        // to avoid overflowing both u32 and the timer
+                        for _ in 0..(time_left_us / max_sleep_us) {
+                            block!(self.0.wait()).ok();
+                            time_left_us -= max_sleep_us;
+                        }
                     }
 
-                    if time_left > 0 {
-                        self.0.start(($num / time_left).hz());
+                    assert!(time_left_us <= u32::MAX as u64);
+                    assert!(time_left_us <= max_sleep_us);
+
+                    let time_left: MicroSecond = (time_left_us as u32).micros();
+                    
+                    // Only sleep
+                    if time_left.ticks() > 0 {
+                        self.0.start(time_left);
                         block!(self.0.wait()).ok();
                     }
                 }
             }
 
             impl<T> $Delay<u16> for DelayFromCountDownTimer<T>
             where
-                T: CountDown<Time = Hertz>,
+                T: CountDown<Time = MicroSecond>,
             {
                 fn $delay(&mut self, t: u16) {
                     self.$delay(t as u32);
@@ -132,7 +140,7 @@ macro_rules! impl_delay_from_count_down_timer  {
 
             impl<T> $Delay<u8> for DelayFromCountDownTimer<T>
             where
-                T: CountDown<Time = Hertz>,
+                T: CountDown<Time = MicroSecond>,
             {
                 fn $delay(&mut self, t: u8) {
                     self.$delay(t as u32);
@@ -144,5 +152,5 @@ macro_rules! impl_delay_from_count_down_timer  {
 
 impl_delay_from_count_down_timer! {
     (DelayMs, delay_ms, 1_000),
-    (DelayUs, delay_us, 1_000_000)
+    (DelayUs, delay_us, 1)
 }
diff --git a/src/i2c.rs b/src/i2c.rs
@@ -75,16 +75,16 @@ impl Config {
             return bits;
         }
         let speed = self.speed.unwrap();
-        let (psc, scll, sclh, sdadel, scldel) = if speed.0 <= 100_000 {
+        let (psc, scll, sclh, sdadel, scldel) = if speed.raw() <= 100_000 {
             let psc = 3;
-            let scll = cmp::min((((i2c_clk.0 >> 1) / (psc + 1)) / speed.0) - 1, 255);
+            let scll = cmp::min((((i2c_clk.raw() >> 1) / (psc + 1)) / speed.raw()) - 1, 255);
             let sclh = scll - 4;
             let sdadel = 2;
             let scldel = 4;
             (psc, scll, sclh, sdadel, scldel)
         } else {
             let psc = 1;
-            let scll = cmp::min((((i2c_clk.0 >> 1) / (psc + 1)) / speed.0) - 1, 255);
+            let scll = cmp::min((((i2c_clk.raw() >> 1) / (psc + 1)) / speed.raw()) - 1, 255);
             let sclh = scll - 6;
             let sdadel = 1;
             let scldel = 3;
diff --git a/src/pwm.rs b/src/pwm.rs
@@ -195,7 +195,7 @@ use crate::stm32::TIM5;
 use crate::stm32::{TIM1, TIM15, TIM16, TIM17, TIM2, TIM3, TIM4, TIM8};
 
 use crate::rcc::{Enable, GetBusFreq, Rcc, Reset};
-use crate::time::{Hertz, NanoSecond, U32Ext};
+use crate::time::{Hertz, NanoSecond, ExtU32, RateExtU32};
 
 #[cfg(any(
     feature = "stm32g471",
@@ -1029,13 +1029,13 @@ pins! {
 // Returns (arr, psc)
 fn calculate_frequency_32bit(base_freq: Hertz, freq: Hertz, alignment: Alignment) -> (u32, u16) {
     let divisor = if let Alignment::Center = alignment {
-        freq.0 * 2
+        freq * 2
     } else {
-        freq.0
+        freq
     };
 
     // Round to the nearest period
-    let arr = (base_freq.0 + (divisor >> 1)) / divisor - 1;
+    let arr = (base_freq + (divisor / 2)) / divisor - 1;
 
     (arr, 0)
 }
@@ -1071,7 +1071,7 @@ fn calculate_deadtime(base_freq: Hertz, deadtime: NanoSecond) -> (u8, u8) {
     // Cortex-M7 has 32x32->64 multiply but no 64-bit divide
     // Divide by 100000 then 10000 by multiplying and shifting
     // This can't overflow because both values being multiplied are u32
-    let deadtime_ticks = deadtime.0 as u64 * base_freq.0 as u64;
+    let deadtime_ticks = deadtime.ticks() as u64 * base_freq.raw() as u64;
     // Make sure we won't overflow when multiplying; DTG is max 1008 ticks and CKD is max prescaler of 4
     // so deadtimes over 4032 ticks are impossible (4032*10^9 before dividing)
     assert!(deadtime_ticks <= 4_032_000_000_000u64);
@@ -1210,7 +1210,7 @@ macro_rules! tim_hal {
                         $TIMX::reset(rcc_ptr);
                     }
 
-                    let clk = $TIMX::get_timer_frequency(&rcc.clocks).0;
+                    let clk = $TIMX::get_timer_frequency(&rcc.clocks).raw();
 
                     PwmBuilder {
                         _tim: PhantomData,
@@ -1219,12 +1219,12 @@ macro_rules! tim_hal {
                         _fault: PhantomData,
                         _comp: PhantomData,
                         alignment: Alignment::Left,
-                        base_freq: clk.hz(),
+                        base_freq: clk.Hz(),
                         count: CountSettings::Explicit { period: 65535, prescaler: 0, },
                         bkin_enabled: false,
                         bkin2_enabled: false,
                         fault_polarity: Polarity::ActiveLow,
-                        deadtime: 0.ns(),
+                        deadtime: 0.nanos(),
                     }
                 }
             }
@@ -1786,8 +1786,7 @@ macro_rules! lptim_hal {
                     $TIMX::reset(rcc_ptr);
                 }
 
-                let clk = $TIMX::get_timer_frequency(&rcc.clocks).0;
-                let freq = freq.0;
+                let clk = $TIMX::get_timer_frequency(&rcc.clocks);
                 let reload = clk / freq;
                 assert!(reload < 128 * (1 << 16));
 
diff --git a/src/rcc/mod.rs b/src/rcc/mod.rs
diff --git a/src/serial/usart.rs b/src/serial/usart.rs
diff --git a/src/spi.rs b/src/spi.rs
diff --git a/src/time.rs b/src/time.rs
diff --git a/src/timer.rs b/src/timer.rs
