add support for extending the cycle counter to u64

This enables tracking time intervals of more than a couple seconds on
modern processors.

Author: jordens

CHANGELOG.md

@@ -10,6 +10,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 ### Added
 
 - CI changelog entry enforcer
+- New feature `extend` to track DWT cycle counter overflows and extend
+  the range to `u64`.
 
 ## [v1.0.0] - 2021-12-25
 

Cargo.toml

@@ -4,6 +4,7 @@ version = "1.0.0"
 authors = [
   "The Real-Time Interrupt-driven Concurrency developers",
   "Emil Fresk <[email protected]>",
+  "Robert Jördens <[email protected]>",
 ]
 categories = ["concurrency", "embedded", "no-std"]
 description = "RTIC Monotonic implemenation based on Systick and DWT"
@@ -15,9 +16,13 @@ edition = "2021"
 [lib]
 name = "dwt_systick_monotonic"
 
+[features]
+extend = []
+
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
 cortex-m = "0.7"
 rtic-monotonic = "1.0.0"
 fugit = "0.3.0"
+cfg-if = "1.0"

src/lib.rs

@@ -3,22 +3,33 @@
 #![no_std]
 
 use cortex_m::peripheral::{syst::SystClkSource, DCB, DWT, SYST};
-pub use fugit::{self, ExtU32};
+pub use fugit::{self, ExtU32, ExtU64};
 use rtic_monotonic::Monotonic;
 
-/// DWT and Systick combination implementing `embedded_time::Clock` and `rtic_monotonic::Monotonic`
+/// DWT and Systick combination implementing `rtic_monotonic::Monotonic`.
+///
+/// This implementation is tickless. It does not use periodic interrupts to count
+/// "ticks" (like `systick-monotonic`) but only to obtain actual desired compare
+/// events and to manage overflows.
 ///
 /// The frequency of the DWT and SysTick is encoded using the parameter `TIMER_HZ`.
+/// They must be equal.
+///
+/// Note that the SysTick interrupt must not be disabled longer than half the
+/// cycle counter overflow period (typically a couple seconds).
 pub struct DwtSystick<const TIMER_HZ: u32> {
     dwt: DWT,
     systick: SYST,
+    #[cfg(feature = "extend")]
+    last: u64,
 }
 
 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.
+    /// so the speed calculated at runtime and the declared speed (generic parameter
+    /// `TIMER_HZ`) can be compared.
     #[inline(always)]
     pub fn new(dcb: &mut DCB, dwt: DWT, systick: SYST, sysclk: u32) -> Self {
         assert!(TIMER_HZ == sysclk);
@@ -30,19 +41,49 @@ impl<const TIMER_HZ: u32> DwtSystick<TIMER_HZ> {
 
         // We do not start the counter here, it is started in `reset`.
 
-        DwtSystick { dwt, systick }
+        DwtSystick {
+            dwt,
+            systick,
+            #[cfg(feature = "extend")]
+            last: 0,
+        }
     }
 }
 
 impl<const TIMER_HZ: u32> Monotonic for DwtSystick<TIMER_HZ> {
-    const DISABLE_INTERRUPT_ON_EMPTY_QUEUE: bool = true;
-
-    type Instant = fugit::TimerInstantU32<TIMER_HZ>;
-    type Duration = fugit::TimerDurationU32<TIMER_HZ>;
-
-    #[inline(always)]
-    fn now(&mut self) -> Self::Instant {
-        Self::Instant::from_ticks(self.dwt.cyccnt.read())
+    cfg_if::cfg_if! {
+        if #[cfg(not(feature = "extend"))] {
+            const DISABLE_INTERRUPT_ON_EMPTY_QUEUE: bool = true;
+
+            type Instant = fugit::TimerInstantU32<TIMER_HZ>;
+            type Duration = fugit::TimerDurationU32<TIMER_HZ>;
+
+            #[inline(always)]
+            fn now(&mut self) -> Self::Instant {
+                Self::Instant::from_ticks(self.dwt.cyccnt.read())
+            }
+        } else {
+            // Need to detect and track overflows.
+            const DISABLE_INTERRUPT_ON_EMPTY_QUEUE: bool = false;
+
+            type Instant = fugit::TimerInstantU64<TIMER_HZ>;
+            type Duration = fugit::TimerDurationU64<TIMER_HZ>;
+
+            #[inline(always)]
+            fn now(&mut self) -> Self::Instant {
+                let mut high = (self.last >> 32) as u32;
+                let low = self.last as u32;
+                let now = self.dwt.cyccnt.read();
+
+                // Detect CYCCNT overflow
+                if now.wrapping_sub(low) >= 1 << 31 {
+                    high = high.wrapping_add(1);
+                }
+                self.last = ((high as u64) << 32) | (now as u64);
+
+                Self::Instant::from_ticks(self.last)
+            }
+        }
     }
 
     unsafe fn reset(&mut self) {
@@ -71,7 +112,7 @@ impl<const TIMER_HZ: u32> Monotonic for DwtSystick<TIMER_HZ> {
             Some(x) => max.min(x.ticks()).max(1),
         };
 
-        self.systick.set_reload(dur);
+        self.systick.set_reload(dur as u32);
         self.systick.clear_current();
     }
 
@@ -84,4 +125,11 @@ impl<const TIMER_HZ: u32> Monotonic for DwtSystick<TIMER_HZ> {
     fn clear_compare_flag(&mut self) {
         // NOOP with SysTick interrupt
     }
+
+    #[cfg(feature = "extend")]
+    fn on_interrupt(&mut self) {
+        // Ensure `now()` is called regularly to track overflows.
+        // Since SysTick is narrower than CYCCNT, this is sufficient.
+        self.now();
+    }
 }