feat(Clock): Allow Clock impls to be stateful

Author: PTaylor-us

CHANGELOG.md

@@ -8,6 +8,7 @@
 
 ### Changed
 
+- Add `&mut self` to `Clock` functions (make stateful, or at least allow stateful implementations)
 - Refactor `examples/nrf52_dk`
 
 [unreleased]: https://github.com/FluenTech/embedded-time/compare/v0.5.2...HEAD

examples/nrf52_dk/main.rs

@@ -3,58 +3,51 @@
 
 extern crate panic_rtt;
 
-use cortex_m::mutex::CriticalSectionMutex as Mutex;
 use cortex_m_rt::entry;
 use embedded_time::{self as time, Clock, Instant, Period, TimeInt};
-use mutex_trait::Mutex as _;
 
 pub mod nrf52 {
     pub use nrf52832_hal::{
         gpio,
         prelude::*,
         target::{self as pac, Peripherals},
     };
+}
 
-    pub struct Clock64 {
-        low: pac::TIMER0,
-        high: pac::TIMER1,
-        capture_task: pac::EGU0,
-    }
-
-    impl Clock64 {
-        pub fn take(low: pac::TIMER0, high: pac::TIMER1, capture_task: pac::EGU0) -> Self {
-            Self {
-                low,
-                high,
-                capture_task,
-            }
-        }
+pub struct SysClock {
+    low: nrf52::pac::TIMER0,
+    high: nrf52::pac::TIMER1,
+    capture_task: nrf52::pac::EGU0,
+}
 
-        pub(crate) fn read(&mut self) -> u64 {
-            self.capture_task.tasks_trigger[0].write(|write| unsafe { write.bits(1) });
-            self.low.cc[0].read().bits() as u64 | ((self.high.cc[0].read().bits() as u64) << 32)
+impl SysClock {
+    pub fn take(
+        low: nrf52::pac::TIMER0,
+        high: nrf52::pac::TIMER1,
+        capture_task: nrf52::pac::EGU0,
+    ) -> Self {
+        Self {
+            low,
+            high,
+            capture_task,
         }
     }
 }
 
-pub struct SysClock;
-
 impl time::Clock for SysClock {
     type Rep = i64;
     const PERIOD: Period = Period::new(1, 16_000_000);
 
-    fn now() -> Instant<Self> {
-        let ticks = (&CLOCK64).lock(|clock| match clock {
-            Some(clock) => clock.read(),
-            None => 0,
-        });
+    fn now(&mut self) -> Instant<Self> {
+        self.capture_task.tasks_trigger[0].write(|write| unsafe { write.bits(1) });
+
+        let ticks =
+            self.low.cc[0].read().bits() as u64 | ((self.high.cc[0].read().bits() as u64) << 32);
 
         Instant::new(ticks as Self::Rep)
     }
 }
 
-static CLOCK64: Mutex<Option<nrf52::Clock64>> = Mutex::new(None);
-
 #[entry]
 fn main() -> ! {
     let device = nrf52::pac::Peripherals::take().unwrap();
@@ -106,8 +99,7 @@ fn main() -> ! {
     // This moves these peripherals to prevent conflicting usage, however not the entire EGU0 is
     // used. A ref to EGU0 could be sent instead, although that provides no protection for the
     // fields that are being used by Clock64.
-    let clock64 = nrf52::Clock64::take(device.TIMER0, device.TIMER1, device.EGU0);
-    (&CLOCK64).lock(|ticks| *ticks = Some(clock64));
+    let mut clock = SysClock::take(device.TIMER0, device.TIMER1, device.EGU0);
 
     let port0 = nrf52::gpio::p0::Parts::new(device.P0);
 
@@ -136,6 +128,7 @@ fn main() -> ! {
         &mut led2.degrade(),
         &mut led3.degrade(),
         &mut led4.degrade(),
+        &mut clock,
     )
     .unwrap();
 
@@ -147,6 +140,7 @@ fn run<Led>(
     led2: &mut Led,
     led3: &mut Led,
     led4: &mut Led,
+    clock: &mut SysClock,
 ) -> Result<(), <Led as nrf52::OutputPin>::Error>
 where
     Led: nrf52::OutputPin,
@@ -156,12 +150,12 @@ where
         led2.set_high()?;
         led3.set_high()?;
         led4.set_low()?;
-        SysClock::delay(250.milliseconds());
+        clock.delay(250.milliseconds());
 
         led1.set_high()?;
         led2.set_low()?;
         led3.set_low()?;
         led4.set_high()?;
-        SysClock::delay(250.milliseconds());
+        clock.delay(250.milliseconds());
     }
 }

src/clock.rs

@@ -10,15 +10,15 @@ pub trait Clock: Sized {
     const PERIOD: Period;
 
     /// Get the current Instant
-    fn now() -> Instant<Self>;
+    fn now(&mut self) -> Instant<Self>;
 
     /// Blocking delay
-    fn delay<Dur: Duration>(dur: Dur)
+    fn delay<Dur: Duration>(&mut self, dur: Dur)
     where
         Self::Rep: TryFrom<Dur::Rep>,
     {
-        let start = Self::now();
+        let start = self.now();
         let end = start + dur;
-        while Self::now() < end {}
+        while self.now() < end {}
     }
 }

src/instant.rs

@@ -33,7 +33,7 @@ impl<Clock: crate::Clock> Instant<Clock> {
     ///     type Rep = i32;
     ///     const PERIOD: Period = Period::new(1, 1_000);
     ///     // ...
-    /// # fn now() -> Instant<Self> {unimplemented!()}
+    /// # fn now(&mut self) -> Instant<Self> {unimplemented!()}
     /// }
     ///
     /// let diff: Option<Milliseconds<_>> = Instant::<Clock>::new(5).duration_since(&Instant::<Clock>::new(3));
@@ -99,7 +99,7 @@ impl<Clock: crate::Clock> PartialOrd for Instant<Clock> {
     ///     type Rep = i32;
     ///     const PERIOD: Period = Period::new(1, 1_000);
     ///     // ...
-    /// # fn now() -> Instant<Self> {unimplemented!()}
+    /// # fn now(&mut self) -> Instant<Self> {unimplemented!()}
     /// }
     ///
     /// assert!(Instant::<Clock>::new(5) > Instant::<Clock>::new(3));
@@ -138,7 +138,7 @@ where
     ///     type Rep = i32;
     ///     const PERIOD: Period = Period::new(1, 1_000);
     ///     // ...
-    /// # fn now() -> Instant<Self> {unimplemented!()}
+    /// # fn now(&mut self) -> Instant<Self> {unimplemented!()}
     /// }
     ///
     /// Instant::<Clock>::new(1) + Seconds(i32::MAX);
@@ -154,7 +154,7 @@ where
     ///     type Rep = i32;
     ///     const PERIOD: Period = Period::new(1, 1_000);
     ///     // ...
-    /// # fn now() -> Instant<Self> {unimplemented!()}
+    /// # fn now(&mut self) -> Instant<Self> {unimplemented!()}
     /// }
     ///
     /// assert_eq!(Instant::<Clock>::new(1) + Seconds(3), Instant::<Clock>::new(3_001));
@@ -190,7 +190,7 @@ where
     ///     type Rep = i32;
     ///     const PERIOD: Period = Period::new(1, 1_000);
     ///     // ...
-    /// # fn now() -> Instant<Self> {unimplemented!()}
+    /// # fn now(&mut self) -> Instant<Self> {unimplemented!()}
     /// }
     ///
     /// Instant::<Clock>::new(1) - Seconds(i32::MAX);
@@ -206,7 +206,7 @@ where
     ///     type Rep = i32;
     ///     const PERIOD: Period = Period::new(1, 1_000);
     ///     // ...
-    /// # fn now() -> Instant<Self> {unimplemented!()}
+    /// # fn now(&mut self) -> Instant<Self> {unimplemented!()}
     /// }
     ///
     /// assert_eq!(Instant::<Clock>::new(1) - Seconds(3), Instant::<Clock>::new(-2_999));

src/lib.rs

@@ -46,15 +46,16 @@
 //!     type Rep = i64;
 //!     const PERIOD: Period = Period::new(1, 16_000_000);
 //!
-//!     fn now() -> Instant<Self> {
+//!     fn now(&mut self) -> Instant<Self> {
 //!         // ...
 //! #         unimplemented!()
 //!     }
 //! }
 //!
-//! let instant1 = SomeClock::now();
+//! let mut clock = SomeClock;
+//! let instant1 = clock.now();
 //! // ...
-//! let instant2 = SomeClock::now();
+//! let instant2 = clock.now();
 //! assert!(instant1 < instant2);    // instant1 is *before* instant2
 //!
 //! // duration is the difference between the instances
@@ -117,7 +118,7 @@ mod tests {
         type Rep = i64;
         const PERIOD: time::Period = time::Period::new(1, 64_000_000);
 
-        fn now() -> time::Instant<Self> {
+        fn now(&mut self) -> time::Instant<Self> {
             time::Instant::new(128_000_000)
         }
     }
@@ -129,25 +130,25 @@ mod tests {
         type Rep = i32;
         const PERIOD: time::Period = time::Period::new(1, 16_000_000);
 
-        fn now() -> time::Instant<Self> {
+        fn now(&mut self) -> time::Instant<Self> {
             time::Instant::new(32_000_000)
         }
     }
 
-    fn get_time<M>()
-    where
-        M: time::Clock,
-    {
-        assert_eq!(M::now().duration_since_epoch(), Some(Seconds(2)));
+    fn get_time(clock: &mut impl time::Clock) {
+        assert_eq!(clock.now().duration_since_epoch(), Some(Seconds(2)));
     }
 
     #[test]
     fn common_types() {
-        let then = MockClock32::now();
-        let now = MockClock32::now();
+        let then = MockClock32.now();
+        let now = MockClock32.now();
+
+        let mut clock64 = MockClock64 {};
+        let mut clock32 = MockClock32 {};
 
-        get_time::<MockClock64>();
-        get_time::<MockClock32>();
+        get_time(&mut clock64);
+        get_time(&mut clock32);
 
         let then = then - Seconds(1);
         assert_ne!(then, now);