Merge pull request #183 from jamwaffles/embedded-time

Migrate crate over to embedded-time

CHANGELOG.md

@@ -30,6 +30,8 @@ the linker instead of having a default for the whole sub-family. ([#173])
 
 ### Breaking Changes
 
+- Migrate from custom `Hertz` implementation to [`embedded-time`](https://crates.io/crates/embedded-time) ([#183])
+
 - Add `enable` to `GeneralPurposeTimer`
 
 - `Instance::clock_frequency` is now an associated function and doesn't take `&self` anymore.
@@ -119,6 +121,7 @@ _Not yet tracked in this changelog._
 
 <!-- Links to pull requests and issues. Note that you can use "issues"
 in the URL for both issues and pull requests. -->
+[#183]: https://github.com/stm32-rs/stm32l0xx-hal/issues/183
 [#148]: https://github.com/stm32-rs/stm32l0xx-hal/issues/148
 [#145]: https://github.com/stm32-rs/stm32l0xx-hal/issues/145
 [#144]: https://github.com/stm32-rs/stm32l0xx-hal/issues/144

Cargo.toml

@@ -35,6 +35,7 @@ cortex-m =  "0.7.0"
 cortex-m-rt = "0.6.8"
 cortex-m-semihosting = "0.3.2"
 nb = "1.0.0"
+embedded-time = "0.12.0"
 
 [dependencies.cast]
 version = "0.2.2"

examples/adc_pwm.rs

@@ -19,7 +19,7 @@ fn main() -> ! {
     let gpioa = dp.GPIOA.split(&mut rcc);
 
     // Configure the timer as PWM on PA1.
-    let pwm = pwm::Timer::new(dp.TIM2, 1.khz(), &mut rcc);
+    let pwm = pwm::Timer::new(dp.TIM2, 1_000.Hz(), &mut rcc);
     let mut pwm = pwm.channel2.assign(gpioa.pa1);
     let max_duty = pwm.get_max_duty() / 4095;
     pwm.enable();

examples/button.rs

@@ -31,8 +31,8 @@ fn main() -> ! {
 
     loop {
         let wait = match button.is_high() {
-            Ok(true) => 300.ms(),
-            Ok(false) => 100.ms(),
+            Ok(true) => 300.milliseconds(),
+            Ok(false) => 100.milliseconds(),
             _ => unreachable!(),
         };
         delay.delay(wait);

examples/lptim.rs

@@ -46,7 +46,7 @@ fn main() -> ! {
     blink(&mut led);
 
     // 1 seconds of regular run mode
-    lptim.start(1.hz());
+    lptim.start(1.Hz());
     block!(lptim.wait()).unwrap();
 
     Exti::unpend(exti_line);

examples/pwm.rs

@@ -24,7 +24,7 @@ fn main() -> ! {
     let gpioa = dp.GPIOA.split(&mut rcc);
 
     // Initialize TIM2 for PWM
-    let pwm = pwm::Timer::new(dp.TIM2, 10.khz(), &mut rcc);
+    let pwm = pwm::Timer::new(dp.TIM2, 10_000.Hz(), &mut rcc);
 
     #[cfg(feature = "stm32l0x1")]
     let mut pwm = pwm.channel2.assign(gpioa.pa1);

examples/serial_dma.rs

@@ -31,7 +31,7 @@ fn main() -> ! {
         .usart(
             gpioa.pa2,
             gpioa.pa3,
-            serial::Config::default().baudrate(115_200.bps()),
+            serial::Config::default().baudrate(115_200.Bd()),
             &mut rcc,
         )
         .unwrap()

examples/serial_dma_async.rs

@@ -49,7 +49,7 @@ fn main() -> ! {
         .usart(
             gpioa.pa2,
             gpioa.pa3,
-            serial::Config::default().baudrate(115_200.bps()),
+            serial::Config::default().baudrate(115_200.Bd()),
             &mut rcc,
         )
         .unwrap()

examples/spi.rs

@@ -26,7 +26,7 @@ fn main() -> ! {
     // Initialise the SPI peripheral.
     let mut spi = dp
         .SPI1
-        .spi((sck, miso, mosi), spi::MODE_0, 100_000.hz(), &mut rcc);
+        .spi((sck, miso, mosi), spi::MODE_0, 100_000.Hz(), &mut rcc);
 
     loop {
         nss.set_low().unwrap();

examples/spi_dma.rs

@@ -36,7 +36,7 @@ fn main() -> ! {
     // Initialise the SPI peripheral.
     let mut spi = dp
         .SPI1
-        .spi((sck, miso, mosi), spi::MODE_0, 100_000.hz(), &mut rcc);
+        .spi((sck, miso, mosi), spi::MODE_0, 100_000.Hz(), &mut rcc);
 
     let mut scb = cp.SCB;
     let mut dma = DMA::new(dp.DMA1, &mut rcc);

examples/timer.rs

@@ -36,7 +36,7 @@ fn main() -> ! {
     let led = gpioa.pa1.into_push_pull_output();
 
     // Configure the timer.
-    let mut timer = dp.TIM2.timer(1.hz(), &mut rcc);
+    let mut timer = dp.TIM2.timer(1.Hz(), &mut rcc);
     timer.listen();
 
     // Store the LED and timer in mutex refcells to make them available from the

examples/timer_interrupt_rtic.rs

@@ -30,7 +30,7 @@ const APP: () = {
         let led = gpioa.pa1.into_push_pull_output().downgrade();
 
         // Configure the timer.
-        let mut timer = device.TIM2.timer(1.hz(), &mut rcc);
+        let mut timer = device.TIM2.timer(1.Hz(), &mut rcc);
         timer.listen();
 
         // Return the initialised resources.

examples/watchdog.rs

@@ -24,7 +24,7 @@ fn main() -> ! {
     let mut watchdog = dp.IWDG.watchdog();
 
     // Start a watchdog with a 100ms period.
-    watchdog.start(100.ms());
+    watchdog.start(10.Hz());
 
     let mut counter = 50;
     loop {

src/delay.rs

@@ -1,10 +1,12 @@
 //! Delays
+
 use crate::hal::blocking::delay::{DelayMs, DelayUs};
 use crate::rcc::Clocks;
-use crate::time::MicroSeconds;
 use cast::u32;
+use core::convert::TryInto;
 use cortex_m::peripheral::syst::SystClkSource;
 use cortex_m::peripheral::SYST;
+use embedded_time::duration::{Extensions, Microseconds};
 
 pub trait DelayExt {
     fn delay(self, clocks: Clocks) -> Delay;
@@ -31,11 +33,17 @@ impl Delay {
         let ticks_per_us = freq / 1_000_000_u32;
         Delay { ticks_per_us, syst }
     }
+
+    /// Wait for the given time.
+    ///
+    /// Note that durations above `u32::MAX` microseconds will be clamped at `u32::MAX`.
     pub fn delay<T>(&mut self, delay: T)
     where
-        T: Into<MicroSeconds>,
+        T: TryInto<Microseconds>,
     {
-        self.delay_us(delay.into().0)
+        let delay = delay.try_into().unwrap_or_else(|_| u32::MAX.microseconds());
+
+        self.delay_us(delay.0)
     }
 
     /// Releases the system timer (SysTick) resource

src/i2c.rs

@@ -15,8 +15,8 @@ use crate::pac::i2c1::{
     RegisterBlock,
 };
 use crate::rcc::Rcc;
-use crate::time::Hertz;
 use cast::u8;
+use embedded_time::rate::Hertz;
 
 // I²C traits
 use crate::hal::blocking::i2c::{Read, Write, WriteRead};

src/lib.rs

@@ -61,7 +61,6 @@ pub mod serial;
 pub mod signature;
 pub mod spi;
 pub mod syscfg;
-pub mod time;
 pub mod timer;
 #[cfg(all(
     feature = "stm32-usbd",

src/lptim.rs

@@ -5,10 +5,11 @@ use crate::hal;
 use crate::pac::LPTIM;
 use crate::pwr::PWR;
 use crate::rcc::Rcc;
-use crate::time::{Hertz, MicroSeconds};
 use cast::{u32, u64};
 use core::convert::TryFrom;
 use core::marker::PhantomData;
+use embedded_time::duration::Microseconds;
+use embedded_time::rate::Hertz;
 use void::Void;
 
 mod sealed {
@@ -85,7 +86,7 @@ pub struct Interrupts {
 /// The timer can be initialized either in one-shot mode or in periodic mode, using `init_oneshot`
 /// or `init_periodic` respectively. In periodic mode, the embedded-hal `Periodic` marker trait is
 /// implemented and the `CountDown` implementation uses `Hertz` as the time unit. In one-shot mode,
-/// the `CountDown` implementation instead uses `MicroSeconds`, allowing for a multi-second timeout
+/// the `CountDown` implementation instead uses `Microseconds`, allowing for a multi-second timeout
 /// to be configured (with the tradeoff being a larger code size due to use of 64-bit arithmetic).
 pub struct LpTimer<M: CountMode> {
     lptim: LPTIM,
@@ -365,11 +366,11 @@ impl hal::timer::CountDown for LpTimer<Periodic> {
 impl hal::timer::Periodic for LpTimer<Periodic> {}
 
 impl hal::timer::CountDown for LpTimer<OneShot> {
-    type Time = MicroSeconds;
+    type Time = Microseconds;
 
     fn start<T>(&mut self, period: T)
     where
-        T: Into<MicroSeconds>,
+        T: Into<Microseconds>,
     {
         self.configure(TimeConf::calculate_period(self.input_freq, period.into()));
 
@@ -435,7 +436,7 @@ impl TimeConf {
 
     /// Calculates prescaler and autoreload value for producing overflows after every
     /// `output_period`.
-    fn calculate_period(input_freq: Hertz, output_period: MicroSeconds) -> Self {
+    fn calculate_period(input_freq: Hertz, output_period: Microseconds) -> Self {
         // Here, the `output_period` can be very long, resulting in an output frequency of < 1 Hz.
 
         // Fi  = Frequency of input clock
@@ -484,7 +485,6 @@ impl TimeConf {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::time::U32Ext;
 
     /// Test-only methods.
     impl TimeConf {
@@ -498,8 +498,8 @@ mod tests {
             Hertz(input_freq.0 / u32(self.psc()) / u32(self.arr))
         }
 
-        fn output_period(&self, input_freq: Hertz) -> MicroSeconds {
-            MicroSeconds(
+        fn output_period(&self, input_freq: Hertz) -> Microseconds {
+            Microseconds(
                 u32(u64(self.psc()) * u64(self.arr) * 1_000_000 / u64(input_freq.0)).unwrap(),
             )
         }

src/prelude.rs

@@ -15,11 +15,15 @@ pub use crate::{
     pwr::PowerMode as _,
     rcc::RccExt as _,
     spi::SpiExt as _,
-    time::U32Ext as _,
     timer::TimerExt as _,
     watchdog::{IndependedWatchdogExt as _, WindowWatchdogExt as _},
 };
 
+// Make items like `.Hz()`, `.microseconds()` available from embedded-time
+pub use embedded_time::{
+    duration::Extensions as DurationExtensions, rate::Extensions as RateExtensions,
+};
+
 #[cfg(any(
     feature = "io-STM32L021",
     feature = "io-STM32L031",

src/pwm.rs

@@ -1,15 +1,13 @@
-use core::marker::PhantomData;
-use core::ops::Deref;
-
-use cortex_m::interrupt;
-
 use crate::gpio::gpioa::{PA0, PA1, PA2, PA3};
 use crate::gpio::{AltMode, PinMode};
 use crate::hal;
 use crate::pac::{tim2, TIM2, TIM3};
 use crate::rcc::Rcc;
-use crate::time::Hertz;
 use cast::{u16, u32};
+use core::marker::PhantomData;
+use core::ops::Deref;
+use cortex_m::interrupt;
+use embedded_time::rate::Hertz;
 
 #[cfg(any(feature = "stm32l0x2", feature = "stm32l0x3"))]
 use crate::gpio::{
@@ -43,7 +41,9 @@ where
     I: Instance,
 {
     /// Create new timer instance that is automatically started with given frequency
-    pub fn new(timer: I, frequency: Hertz, rcc: &mut Rcc) -> Self {
+    pub fn new(timer: I, frequency: impl Into<Hertz>, rcc: &mut Rcc) -> Self {
+        let frequency = frequency.into();
+
         timer.enable(rcc);
 
         let mut tim = Self {
@@ -72,7 +72,8 @@ where
     /// In order to do this operation properly the function stop the timer and then starts it again.
     /// The duty cycle that was set before for given pin needs to adjusted according to the
     /// frequency
-    pub fn set_frequency(&mut self, frequency: Hertz, rcc: &Rcc) {
+    pub fn set_frequency(&mut self, frequency: impl Into<Hertz>, rcc: &Rcc) {
+        let frequency = frequency.into();
         self.stop();
         let (psc, arr) = get_clock_config(frequency.0, I::clock_frequency(rcc));
         self.instance.psc.write(|w| w.psc().bits(psc));
@@ -268,7 +269,7 @@ where
 {
     /// This allows to dynamically change the frequency of the underlying PWM timer.
     ///
-    /// **WARNING:**  
+    /// **WARNING:**
     /// This changes the frequency for all channels associated with the PWM timer.
     pub fn set_frequency(&mut self, frequency: Hertz, rcc: &Rcc) {
         let (psc, arr) = get_clock_config(frequency.0, I::clock_frequency(rcc));

src/rcc.rs

@@ -2,7 +2,7 @@ use crate::mco;
 use crate::pac::rcc::cfgr::{MCOPRE_A, MCOSEL_A};
 use crate::pac::RCC;
 use crate::pwr::PWR;
-use crate::time::{Hertz, U32Ext};
+use embedded_time::rate::{Extensions, Hertz};
 
 #[cfg(any(feature = "stm32l0x2", feature = "stm32l0x3"))]
 use crate::{pac::CRS, syscfg::SYSCFG};
@@ -340,7 +340,7 @@ impl RccExt for RCC {
                     PLLDiv::Div3 => freq / 3,
                     PLLDiv::Div4 => freq / 4,
                 };
-                assert!(freq <= 32.mhz().0);
+                assert!(freq <= 32_u32.MHz().0);
 
                 self.cfgr.write(move |w| unsafe {
                     w.pllmul()
@@ -393,12 +393,12 @@ impl RccExt for RCC {
 
         let clocks = Clocks {
             source: cfgr.mux,
-            sys_clk: sys_clk.hz(),
-            ahb_clk: ahb_freq.hz(),
-            apb1_clk: apb1_freq.hz(),
-            apb2_clk: apb2_freq.hz(),
-            apb1_tim_clk: apb1_tim_freq.hz(),
-            apb2_tim_clk: apb2_tim_freq.hz(),
+            sys_clk: sys_clk.Hz(),
+            ahb_clk: ahb_freq.Hz(),
+            apb1_clk: apb1_freq.Hz(),
+            apb2_clk: apb2_freq.Hz(),
+            apb1_tim_clk: apb1_tim_freq.Hz(),
+            apb2_tim_clk: apb2_tim_freq.Hz(),
         };
 
         Rcc { rb: self, clocks }

src/rtc.rs

@@ -2,14 +2,14 @@
 //!
 //! See STM32L0x2 reference manual, chapter 26.
 
+use embedded_time::rate::Extensions;
 use void::Void;
 
 use crate::{
     hal::timer::{self, Cancel as _},
     pac,
     pwr::PWR,
     rcc::Rcc,
-    time::U32Ext,
 };
 
 /// Entry point to the RTC API
@@ -57,7 +57,7 @@ impl RTC {
         });
 
         let apb1_clk = rcc.clocks.apb1_clk();
-        let rtc_clk = 32_768u32.hz(); // LSE crystal frequency
+        let rtc_clk = 32_768u32.Hz(); // LSE crystal frequency
 
         // The APB1 clock must not be slower than the RTC clock.
         if apb1_clk < rtc_clk {