Merge #452

452: extend 16-bit Delay's to 32 r=burrbull a=burrbull



Co-authored-by: Andrey Zgarbul <[email protected]>

Author: bors[bot]

CHANGELOG.md

@@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ### Changed
 
+- Extend timers to 32bit on `Delay`
 - Move `MonoTimer` from `timer` to dwt mode [#448]
 - Unify serial trait impls for embedded-hal 0.2 & 1.0 [#447]
 - Add possibility to select Timer master mode

examples/delay-timer-blinky.rs

@@ -37,7 +37,7 @@ fn main() -> ! {
             delay.delay_ms(1000_u32);
             led.set_low();
             // or use `fugit::ExtU32` trait
-            delay.delay(3.secs()).unwrap();
+            delay.delay(3.secs());
         }
     }
 

examples/rtc.rs

@@ -43,6 +43,6 @@ fn main() -> ! {
     // rtc.set_seconds(50).unwrap();
     loop {
         rprintln!("{}", rtc.get_datetime());
-        delay.delay(500.millis()).unwrap();
+        delay.delay(500.millis());
     }
 }

examples/serial.rs

@@ -36,6 +36,6 @@ fn main() -> ! {
         // print some value every 500 ms, value will overflow after 255
         writeln!(tx, "value: {:02}\r", value).unwrap();
         value = value.wrapping_add(1);
-        delay.delay(2.secs()).unwrap();
+        delay.delay(2.secs());
     }
 }

examples/ws2812_spi.rs

@@ -34,15 +34,15 @@ fn main() -> ! {
     let mut data = [RGB8::default(); NUM_LEDS];
 
     // Wait before start write for syncronization
-    delay.delay(200.micros()).unwrap();
+    delay.delay(200.micros());
 
     loop {
         for j in 0..(256 * 5) {
             for (i, b) in data.iter_mut().enumerate() {
                 *b = wheel((((i * 256) as u16 / NUM_LEDS as u16 + j as u16) & 255) as u8);
             }
             ws.write(brightness(data.iter().cloned(), 32)).unwrap();
-            delay.delay(10.millis()).unwrap();
+            delay.delay(10.millis());
         }
     }
 }

src/timer.rs

@@ -101,15 +101,15 @@ pub trait TimerExt: Sized {
     fn delay<const FREQ: u32>(self, clocks: &Clocks) -> FDelay<Self, FREQ>;
     /// Blocking [Delay] with fixed precision of 1 ms (1 kHz sampling)
     ///
-    /// Can wait from 2 ms to 65 sec for 16-bit timer and from 2 ms to 49 days for 32-bit timer.
+    /// Can wait from 2 ms to 49 days.
     ///
     /// NOTE: don't use this if your system frequency more than 65 MHz
     fn delay_ms(self, clocks: &Clocks) -> DelayMs<Self> {
         self.delay::<1_000>(clocks)
     }
     /// Blocking [Delay] with fixed precision of 1 μs (1 MHz sampling)
     ///
-    /// Can wait from 2 μs to 65 ms for 16-bit timer and from 2 μs to 71 min for 32-bit timer.
+    /// Can wait from 2 μs to 71 min.
     fn delay_us(self, clocks: &Clocks) -> DelayUs<Self> {
         self.delay::<1_000_000>(clocks)
     }
@@ -224,6 +224,7 @@ mod sealed {
     pub trait General {
         type Width: Into<u32> + From<u16>;
         fn max_auto_reload() -> u32;
+        unsafe fn set_auto_reload_unchecked(&mut self, arr: u32);
         fn set_auto_reload(&mut self, arr: u32) -> Result<(), super::Error>;
         fn read_auto_reload() -> u32;
         fn enable_preload(&mut self, b: bool);
@@ -282,11 +283,15 @@ macro_rules! hal {
                     <$bits>::MAX as u32
                 }
                 #[inline(always)]
+                unsafe fn set_auto_reload_unchecked(&mut self, arr: u32) {
+                    self.arr.write(|w| w.bits(arr))
+                }
+                #[inline(always)]
                 fn set_auto_reload(&mut self, arr: u32) -> Result<(), Error> {
                     // Note: Make it impossible to set the ARR value to 0, since this
                     // would cause an infinite loop.
                     if arr > 0 && arr <= Self::max_auto_reload() {
-                        Ok(self.arr.write(|w| unsafe { w.bits(arr) }))
+                        Ok(unsafe { self.set_auto_reload_unchecked(arr) })
                     } else {
                         Err(Error::WrongAutoReload)
                     }

src/timer/delay.rs

@@ -114,22 +114,28 @@ pub type DelayMs<TIM> = FDelay<TIM, 1_000>;
 
 impl<TIM: Instance, const FREQ: u32> FDelay<TIM, FREQ> {
     /// Sleep for given time
-    pub fn delay(&mut self, time: TimerDurationU32<FREQ>) -> Result<(), Error> {
-        // Write Auto-Reload Register (ARR)
-        self.tim.set_auto_reload(time.ticks() - 1)?;
-
-        // Trigger update event (UEV) in the event generation register (EGR)
-        // in order to immediately apply the config
-        self.tim.trigger_update();
+    pub fn delay(&mut self, time: TimerDurationU32<FREQ>) {
+        let mut ticks = time.ticks() - 1;
+        while ticks > 0 {
+            let reload = ticks.min(TIM::max_auto_reload());
+            ticks -= reload;
+
+            // Write Auto-Reload Register (ARR)
+            unsafe {
+                self.tim.set_auto_reload_unchecked(reload);
+            }
 
-        // Configure the counter in one-pulse mode (counter stops counting at
-        // the next updateevent, clearing the CEN bit) and enable the counter.
-        self.tim.start_one_pulse();
+            // Trigger update event (UEV) in the event generation register (EGR)
+            // in order to immediately apply the config
+            self.tim.trigger_update();
 
-        // Wait for CEN bit to clear
-        while self.tim.is_counter_enabled() { /* wait */ }
+            // Configure the counter in one-pulse mode (counter stops counting at
+            // the next updateevent, clearing the CEN bit) and enable the counter.
+            self.tim.start_one_pulse();
 
-        Ok(())
+            // Wait for CEN bit to clear
+            while self.tim.is_counter_enabled() { /* wait */ }
+        }
     }
 
     pub fn max_delay(&self) -> TimerDurationU32<FREQ> {
@@ -148,6 +154,7 @@ impl<TIM: Instance, const FREQ: u32> fugit_timer::Delay<FREQ> for FDelay<TIM, FR
     type Error = Error;
 
     fn delay(&mut self, duration: TimerDurationU32<FREQ>) -> Result<(), Self::Error> {
-        self.delay(duration)
+        self.delay(duration);
+        Ok(())
     }
 }

src/timer/hal_02.rs

@@ -297,40 +297,40 @@ where
 impl<TIM: Instance, const FREQ: u32> DelayUs<u32> for FDelay<TIM, FREQ> {
     /// Sleep for `us` microseconds
     fn delay_us(&mut self, us: u32) {
-        self.delay(us.micros()).unwrap()
+        self.delay(us.micros())
     }
 }
 
 impl<TIM: Instance, const FREQ: u32> DelayMs<u32> for FDelay<TIM, FREQ> {
     /// Sleep for `ms` milliseconds
     fn delay_ms(&mut self, ms: u32) {
-        self.delay(ms.millis()).unwrap()
+        self.delay(ms.millis())
     }
 }
 
 impl<TIM: Instance, const FREQ: u32> DelayUs<u16> for FDelay<TIM, FREQ> {
     /// Sleep for `us` microseconds
     fn delay_us(&mut self, us: u16) {
-        self.delay((us as u32).micros()).unwrap()
+        self.delay((us as u32).micros())
     }
 }
 impl<TIM: Instance, const FREQ: u32> DelayMs<u16> for FDelay<TIM, FREQ> {
     /// Sleep for `ms` milliseconds
     fn delay_ms(&mut self, ms: u16) {
-        self.delay((ms as u32).millis()).unwrap()
+        self.delay((ms as u32).millis())
     }
 }
 
 impl<TIM: Instance, const FREQ: u32> DelayUs<u8> for FDelay<TIM, FREQ> {
     /// Sleep for `us` microseconds
     fn delay_us(&mut self, us: u8) {
-        self.delay((us as u32).micros()).unwrap()
+        self.delay((us as u32).micros())
     }
 }
 impl<TIM: Instance, const FREQ: u32> DelayMs<u8> for FDelay<TIM, FREQ> {
     /// Sleep for `ms` milliseconds
     fn delay_ms(&mut self, ms: u8) {
-        self.delay((ms as u32).millis()).unwrap()
+        self.delay((ms as u32).millis())
     }
 }
 

src/timer/hal_1.rs

@@ -102,10 +102,12 @@ impl<TIM: Instance, const FREQ: u32> DelayUs for FDelay<TIM, FREQ> {
     type Error = Error;
 
     fn delay_us(&mut self, us: u32) -> Result<(), Self::Error> {
-        self.delay(us.micros())
+        self.delay(us.micros());
+        Ok(())
     }
 
     fn delay_ms(&mut self, ms: u32) -> Result<(), Self::Error> {
-        self.delay(ms.millis())
+        self.delay(ms.millis());
+        Ok(())
     }
 }