set_arr_unchecked

Author: burrbull

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

@@ -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,14 +114,14 @@ 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> {
+    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)
-            self.tim.set_auto_reload(reload)?;
+            unsafe { self.tim.set_auto_reload_unchecked(reload); }
 
             // Trigger update event (UEV) in the event generation register (EGR)
             // in order to immediately apply the config
@@ -134,8 +134,6 @@ impl<TIM: Instance, const FREQ: u32> FDelay<TIM, FREQ> {
             // Wait for CEN bit to clear
             while self.tim.is_counter_enabled() { /* wait */ }
         }
-
-        Ok(())
     }
 
     pub fn max_delay(&self) -> TimerDurationU32<FREQ> {
@@ -154,6 +152,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(())
     }
 }