Use duration::Generic instead of Hertz for Timer impl

Author: Sh3Rm4n

src/timer.rs

@@ -16,7 +16,7 @@ use void::Void;
 use crate::hal::timer::{CountDown, Periodic};
 use crate::pac::{Interrupt, RCC};
 use crate::rcc::{Clocks, APB1, APB2};
-use crate::time::rate::*;
+use crate::time::{duration, fixed_point::FixedPoint, rate::Hertz};
 
 pub mod interrupts;
 
@@ -224,21 +224,23 @@ impl<TIM> CountDown for Timer<TIM>
 where
     TIM: Instance,
 {
-    type Time = Hertz;
+    type Time = duration::Generic<u32>;
 
     fn start<T>(&mut self, timeout: T)
     where
         T: Into<Self::Time>,
     {
         self.stop();
 
-        let ticks = TIM::clock(&self.clocks).0 / timeout.into().0;
-        let psc = crate::unwrap!(u16::try_from((ticks - 1) / (1 << 16)).ok());
+        let timeout: Self::Time = timeout.into();
+        let clock = TIM::clock(&self.clocks);
+
+        let ticks = clock.integer() * *timeout.scaling_factor() * timeout.integer();
 
+        let psc = crate::unwrap!(u16::try_from((ticks - 1) / (1 << 16)).ok());
         self.tim.set_psc(psc);
 
         let arr = crate::unwrap!(u16::try_from(ticks / u32::from(psc + 1)).ok());
-
         self.tim.set_arr(arr);
 
         // Ensure that the below procedure does not create an unexpected interrupt.

testsuite/tests/timer.rs

@@ -71,15 +71,20 @@ mod tests {
         let freqcyc = state.mono_timer.frequency().integer();
 
         let instant = state.mono_timer.now();
-        timer.start(1.Hz());
+        timer.start(1.seconds());
         assert!(!timer.is_event_triggered(Event::Update));
         unwrap!(nb::block!(timer.wait()).ok());
         let elapsed = instant.elapsed();
 
         defmt::info!("elapsed: {}", elapsed);
         // TODO: Test multiple frequencies and change the cycle counter window to a percentage
         // to measure the overhead of start?
-        assert!(((freqcyc - 1000)..(freqcyc + 1000)).contains(&elapsed));
+
+        // Differentiate between releas and debug build.
+        #[cfg(not(debug_assertions))]
+        assert!(((freqcyc - 500)..(freqcyc + 500)).contains(&elapsed));
+        #[cfg(debug_assertions)]
+        assert!(((freqcyc - 2000)..(freqcyc + 2000)).contains(&elapsed));
 
         state.timer = Some(timer);
     }
@@ -96,7 +101,7 @@ mod tests {
 
         assert!(!INTERRUPT_FIRED.load(Ordering::SeqCst));
         timer.enable_interrupt(Event::Update);
-        timer.start(100_000.Hz());
+        timer.start(1.milliseconds());
 
         while !INTERRUPT_FIRED.load(Ordering::SeqCst) {}