refactoring

Author: PTaylor-us

examples/nrf52_dk/main.rs

@@ -3,7 +3,6 @@
 
 extern crate panic_rtt;
 
-use core::borrow::Borrow;
 use cortex_m::mutex::CriticalSectionMutex as Mutex;
 use cortex_m_rt::entry;
 use embedded_time::{self as time, Clock, Instant, Period, TimeInt};
@@ -16,13 +15,13 @@ pub mod nrf52 {
         target::{self as pac, Peripherals},
     };
 
-    pub struct Timer64 {
+    pub struct Clock64 {
         low: pac::TIMER0,
         high: pac::TIMER1,
         capture_task: pac::EGU0,
     }
 
-    impl Timer64 {
+    impl Clock64 {
         pub fn take(low: pac::TIMER0, high: pac::TIMER1, capture_task: pac::EGU0) -> Self {
             Self {
                 low,
@@ -45,16 +44,16 @@ impl time::Clock for SysClock {
     const PERIOD: Period = Period::new(1, 16_000_000);
 
     fn now() -> Instant<Self> {
-        let ticks = (&SYSTEM_TICKS).lock(|timer64| match timer64 {
-            Some(timer64) => timer64.read(),
+        let ticks = (&CLOCK64).lock(|clock| match clock {
+            Some(clock) => clock.read(),
             None => 0,
         });
 
         Instant::new(ticks as Self::Rep)
     }
 }
 
-static SYSTEM_TICKS: Mutex<Option<nrf52::Timer64>> = Mutex::new(None);
+static CLOCK64: Mutex<Option<nrf52::Clock64>> = Mutex::new(None);
 
 #[entry]
 fn main() -> ! {
@@ -76,35 +75,21 @@ fn main() -> ! {
 
     unsafe {
         device.PPI.ch[0].eep.write(|w| {
-            w.bits(
-                device.TIMER0.events_compare[1].borrow() as *const nrf52::pac::generic::Reg<_, _>
-                    as u32,
-            )
+            w.bits(&device.TIMER0.events_compare[1] as *const nrf52::pac::generic::Reg<_, _> as u32)
         });
         device.PPI.ch[0].tep.write(|w| {
-            w.bits(
-                device.TIMER1.tasks_count.borrow() as *const nrf52::pac::generic::Reg<_, _> as u32,
-            )
+            w.bits(&device.TIMER1.tasks_count as *const nrf52::pac::generic::Reg<_, _> as u32)
         });
         device.PPI.chen.modify(|_, w| w.ch0().enabled());
 
         device.PPI.ch[1].eep.write(|w| {
-            w.bits(
-                device.EGU0.events_triggered[0].borrow() as *const nrf52::pac::generic::Reg<_, _>
-                    as u32,
-            )
+            w.bits(&device.EGU0.events_triggered[0] as *const nrf52::pac::generic::Reg<_, _> as u32)
         });
         device.PPI.ch[1].tep.write(|w| {
-            w.bits(
-                device.TIMER0.tasks_capture[0].borrow() as *const nrf52::pac::generic::Reg<_, _>
-                    as u32,
-            )
+            w.bits(&device.TIMER0.tasks_capture[0] as *const nrf52::pac::generic::Reg<_, _> as u32)
         });
         device.PPI.fork[1].tep.write(|w| {
-            w.bits(
-                device.TIMER1.tasks_capture[0].borrow() as *const nrf52::pac::generic::Reg<_, _>
-                    as u32,
-            )
+            w.bits(&device.TIMER1.tasks_capture[0] as *const nrf52::pac::generic::Reg<_, _> as u32)
         });
         device.PPI.chen.modify(|_, w| w.ch1().enabled());
     }
@@ -118,8 +103,11 @@ fn main() -> ! {
         .tasks_start
         .write(|write| unsafe { write.bits(1) });
 
-    let timer64 = nrf52::Timer64::take(device.TIMER0, device.TIMER1, device.EGU0);
-    (&SYSTEM_TICKS).lock(|ticks| *ticks = Some(timer64));
+    // 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 port0 = nrf52::gpio::p0::Parts::new(device.P0);
 

src/clock.rs

@@ -13,10 +13,8 @@ pub trait Clock: Sized {
     fn now() -> Instant<Self>;
 
     /// Blocking delay
-    fn delay<Dur>(dur: Dur)
+    fn delay<Dur: Duration>(dur: Dur)
     where
-        Dur: Duration,
-        Dur::Rep: TimeInt,
         Self::Rep: TryFrom<Dur::Rep>,
     {
         let start = Self::now();

src/lib.rs

@@ -13,7 +13,7 @@
 //! [`Milliseconds`]: units::Milliseconds
 //!
 //! ## Definitions
-//! **Clock**: Any entity that periodically counts (ie a hardware timer peripheral). Generally,
+//! **Clock**: Any entity that periodically counts (ie a hardware timer/counter peripheral). Generally,
 //! this needs to be monotonic. A wrapping clock is considered monotonic in this context as long as
 //! it fulfills the other requirements.
 //!