Merge pull request #2 from rtic-rs/new-trait-and-time-lib

Updated to new monotonic trait

Author: korken89

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "dwt-systick-monotonic"
-version = "0.1.0-rc.1"
+version = "0.1.0-rc.2"
 authors = [
   "The Real-Time Interrupt-driven Concurrency developers",
   "Emil Fresk <[email protected]>",
@@ -19,4 +19,5 @@ name = "dwt_systick_monotonic"
 
 [dependencies]
 cortex-m = "0.7"
-rtic-monotonic = "0.1.0-rc.1"
+rtic-monotonic = "0.1.0-rc.2"
+fugit = "0.3.0"

src/lib.rs

@@ -3,26 +3,25 @@
 #![no_std]
 
 use cortex_m::peripheral::{syst::SystClkSource, DCB, DWT, SYST};
-use rtic_monotonic::{
-    embedded_time::{clock::Error, fraction::Fraction},
-    Clock, Instant, Monotonic,
-};
+pub use fugit::{self, ExtU32};
+use rtic_monotonic::Monotonic;
 
 /// DWT and Systick combination implementing `embedded_time::Clock` and `rtic_monotonic::Monotonic`
 ///
-/// The frequency of the DWT and SysTick is encoded using the parameter `FREQ`.
-pub struct DwtSystick<const FREQ: u32> {
+/// The frequency of the DWT and SysTick is encoded using the parameter `TIMER_HZ`.
+pub struct DwtSystick<const TIMER_HZ: u32> {
     dwt: DWT,
     systick: SYST,
 }
 
-impl<const FREQ: u32> DwtSystick<FREQ> {
+impl<const TIMER_HZ: u32> DwtSystick<TIMER_HZ> {
     /// Enable the DWT and provide a new `Monotonic` based on DWT and SysTick.
     ///
     /// Note that the `sysclk` parameter should come from e.g. the HAL's clock generation function
     /// so the real speed and the declared speed can be compared.
+    #[inline(always)]
     pub fn new(dcb: &mut DCB, dwt: DWT, systick: SYST, sysclk: u32) -> Self {
-        assert!(FREQ == sysclk);
+        assert!(TIMER_HZ == sysclk);
 
         dcb.enable_trace();
         DWT::unlock();
@@ -35,19 +34,16 @@ impl<const FREQ: u32> DwtSystick<FREQ> {
     }
 }
 
-impl<const FREQ: u32> Clock for DwtSystick<FREQ> {
-    type T = u32;
+impl<const TIMER_HZ: u32> Monotonic for DwtSystick<TIMER_HZ> {
+    const DISABLE_INTERRUPT_ON_EMPTY_QUEUE: bool = true;
 
-    const SCALING_FACTOR: Fraction = Fraction::new(1, FREQ);
+    type Instant = fugit::TimerInstantU32<TIMER_HZ>;
+    type Duration = fugit::TimerDurationU32<TIMER_HZ>;
 
-    fn try_now(&self) -> Result<Instant<Self>, Error> {
-        // The instant is always valid when the DWT is not reset
-        Ok(Instant::new(self.dwt.cyccnt.read()))
+    #[inline(always)]
+    fn now(&mut self) -> Self::Instant {
+        Self::Instant::from_ticks(self.dwt.cyccnt.read())
     }
-}
-
-impl<const FREQ: u32> Monotonic for DwtSystick<FREQ> {
-    const DISABLE_INTERRUPT_ON_EMPTY_QUEUE: bool = true;
 
     unsafe fn reset(&mut self) {
         self.dwt.enable_cycle_counter();
@@ -58,27 +54,33 @@ impl<const FREQ: u32> Monotonic for DwtSystick<FREQ> {
         self.dwt.cyccnt.write(0);
     }
 
-    fn set_compare(&mut self, val: &Instant<Self>) {
+    fn set_compare(&mut self, val: Self::Instant) {
         // The input `val` is in the timer, but the SysTick is a down-counter.
         // We need to convert into its domain.
-        let now: Instant<Self> = Instant::new(self.dwt.cyccnt.read());
+        let now = self.now();
 
         let max = 0x00ff_ffff;
 
-        let dur = match val.checked_duration_since(&now) {
+        let dur = match val.checked_duration_since(now) {
             None => 1, // In the past
 
             // ARM Architecture Reference Manual says:
             // "Setting SYST_RVR to zero has the effect of
             // disabling the SysTick counter independently
             // of the counter enable bit.", so the min is 1
-            Some(x) => max.min(x.integer()).max(1),
+            Some(x) => max.min(x.ticks()).max(1),
         };
 
         self.systick.set_reload(dur);
         self.systick.clear_current();
     }
 
+    #[inline(always)]
+    fn zero() -> Self::Instant {
+        Self::Instant::from_ticks(0)
+    }
+
+    #[inline(always)]
     fn clear_compare_flag(&mut self) {
         // NOOP with SysTick interrupt
     }