Merge #129

129: Add a set_timeout method for timers r=hargoniX a=dflemstr

I have a use-case where I need to set a specific timer timeout (using interrupts).

Of course it would be possible to convert the delay into a frequency, but then it would involve one division (delay -> Hz) and another one back (Hz -> delay).  It seemed more natural to support duration delays directly.

It might also make sense to use `CountDown<Time=Duration>` as well, but since there is already a `CountDown<Time=Hz>` I couldn't add a conflicting one.  However it might make sense to reconsider whether it makes sense to measure a duration in Hz, as is currently the case in this crate?

Co-authored-by: David Flemström <[email protected]>
Co-authored-by: Richard Meadows <[email protected]>

Author: 3 people

src/time.rs

@@ -1,6 +1,7 @@
 //! Time units
 
 use core::fmt;
+use core::time::Duration;
 use cortex_m::peripheral::DWT;
 
 /// Bits per second
@@ -130,6 +131,13 @@ impl Into<Hertz> for MilliSeconds {
     }
 }
 
+// Into core::time::Duration
+impl Into<Duration> for MilliSeconds {
+    fn into(self) -> Duration {
+        Duration::from_millis(self.0 as u64)
+    }
+}
+
 // /// A monotonic nondecreasing timer
 // #[derive(Clone, Copy)]
 // pub struct MonoTimer {

src/timer.rs

@@ -3,6 +3,7 @@
 // TODO: on the h7x3 at least, only TIM2, TIM3, TIM4, TIM5 can support 32 bits.
 // TIM1 is 16 bit.
 
+use core::convert::TryFrom;
 use core::marker::PhantomData;
 
 use crate::hal::timer::{CountDown, Periodic};
@@ -227,6 +228,43 @@ macro_rules! hal {
                     let frequency = self.timeout.0;
                     let ticks = clk / frequency;
 
+                    self.set_timeout_ticks(ticks);
+                }
+
+                /// Sets the timer period from a time duration
+                ///
+                /// ```
+                /// // Set timeout to 100ms
+                /// timer.set_timeout(100.ms());
+                /// ```
+                ///
+                /// Alternatively, the duration can be set using the
+                /// core::time::Duration type
+                ///
+                /// ```
+                /// let duration = core::time::Duration::from_nanos(2_500);
+                ///
+                /// // Set timeout to 2.5µs
+                /// timer.set_timeout(duration);
+                /// ```
+                pub fn set_timeout<T>(&mut self, timeout: T)
+                where
+                    T: Into<core::time::Duration>
+                {
+                    const NANOS_PER_SECOND: u64 = 1_000_000_000;
+                    let timeout = timeout.into();
+
+                    let clk = self.clk as u64;
+                    let ticks = u32::try_from(
+                        clk * timeout.as_secs() +
+                        clk * u64::from(timeout.subsec_nanos()) / NANOS_PER_SECOND,
+                    )
+                    .unwrap_or(u32::max_value());
+
+                    self.set_timeout_ticks(ticks.max(1));
+                }
+
+                fn set_timeout_ticks(&mut self, ticks: u32) {
                     let psc = u16((ticks - 1) / (1 << 16)).unwrap();
                     self.tim.psc.write(|w| { w.psc().bits(psc) });