merge counter & syscounter mods, rm old Delay

Author: burrbull

CHANGELOG.md

@@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ### Changed
 
+- Rename `Delay<SYST>` to SysDelay, remove old `Delay<TIM2>`
 - Extend timers to 32bit on `Delay`
 - Move `MonoTimer` from `timer` to dwt mode [#448]
 - Unify serial trait impls for embedded-hal 0.2 & 1.0 [#447]

Cargo.toml

@@ -37,7 +37,6 @@ synopsys-usb-otg = { version = "0.2.0", features = ["cortex-m"], optional = true
 sdio-host = { version = "0.5.0", optional = true }
 embedded-dma = "0.2.0"
 bare-metal = { version = "1" }
-cast = { default-features = false, version = "0.3.0" }
 void = { default-features = false, version = "1.0.2" }
 embedded-hal = { features = ["unproven"], version = "0.2.7" }
 display-interface = { version = "0.4.1", optional = true }

src/timer.rs

@@ -16,8 +16,6 @@ use fugit::HertzU32 as Hertz;
 
 pub mod counter;
 pub use counter::*;
-pub mod syscounter;
-pub use syscounter::*;
 pub mod delay;
 pub use delay::*;
 mod pins;
@@ -98,7 +96,7 @@ pub trait TimerExt: Sized {
     fn counter_hz(self, clocks: &Clocks) -> CounterHz<Self>;
 
     /// Blocking [Delay] with custom fixed precision
-    fn delay<const FREQ: u32>(self, clocks: &Clocks) -> FDelay<Self, FREQ>;
+    fn delay<const FREQ: u32>(self, clocks: &Clocks) -> Delay<Self, FREQ>;
     /// Blocking [Delay] with fixed precision of 1 ms (1 kHz sampling)
     ///
     /// Can wait from 2 ms to 49 days.
@@ -113,8 +111,6 @@ pub trait TimerExt: Sized {
     fn delay_us(self, clocks: &Clocks) -> DelayUs<Self> {
         self.delay::<1_000_000>(clocks)
     }
-    /// Blocking [Delay]
-    fn delay_dyn(self, clocks: &Clocks) -> Delay<Self>;
 }
 
 impl<TIM: Instance> TimerExt for TIM {
@@ -124,12 +120,9 @@ impl<TIM: Instance> TimerExt for TIM {
     fn counter_hz(self, clocks: &Clocks) -> CounterHz<Self> {
         Timer::new(self, clocks).counter_hz()
     }
-    fn delay<const FREQ: u32>(self, clocks: &Clocks) -> FDelay<Self, FREQ> {
+    fn delay<const FREQ: u32>(self, clocks: &Clocks) -> Delay<Self, FREQ> {
         FTimer::new(self, clocks).delay()
     }
-    fn delay_dyn(self, clocks: &Clocks) -> Delay<Self> {
-        Timer::new(self, clocks).delay()
-    }
 }
 
 pub trait SysTimerExt: Sized {
@@ -143,7 +136,7 @@ pub trait SysTimerExt: Sized {
         self.counter::<1_000_000>(clocks)
     }
     /// Blocking [Delay] with custom precision
-    fn delay(self, clocks: &Clocks) -> Delay<Self>;
+    fn delay(self, clocks: &Clocks) -> SysDelay;
 }
 
 impl SysTimerExt for SYST {
@@ -153,7 +146,7 @@ impl SysTimerExt for SYST {
     fn counter<const FREQ: u32>(self, clocks: &Clocks) -> SysCounter<FREQ> {
         Timer::syst(self, clocks).counter()
     }
-    fn delay(self, clocks: &Clocks) -> Delay<Self> {
+    fn delay(self, clocks: &Clocks) -> SysDelay {
         Timer::syst_external(self, clocks).delay()
     }
 }
@@ -688,8 +681,8 @@ impl<TIM: Instance, const FREQ: u32> FTimer<TIM, FREQ> {
     }
 
     /// Creates `Delay` that imlements [embedded_hal::blocking::delay] traits
-    pub fn delay(self) -> FDelay<TIM, FREQ> {
-        FDelay(self)
+    pub fn delay(self) -> Delay<TIM, FREQ> {
+        Delay(self)
     }
 
     /// Releases the TIM peripheral

src/timer/counter.rs

@@ -1,6 +1,7 @@
-use super::{compute_arr_presc, Error, Event, FTimer, Instance, Timer};
+use super::{compute_arr_presc, Error, Event, FTimer, Instance, SysEvent, Timer};
+use crate::pac::SYST;
 use core::ops::{Deref, DerefMut};
-use fugit::HertzU32 as Hertz;
+use fugit::{HertzU32 as Hertz, TimerDurationU32, TimerInstantU32};
 
 /// Hardware timers
 pub struct CounterHz<TIM>(pub(super) Timer<TIM>);
@@ -66,7 +67,6 @@ impl<TIM: Instance> CounterHz<TIM> {
         Ok(())
     }
 }
-use fugit::{TimerDurationU32, TimerInstantU32};
 
 /// Periodic non-blocking timer that imlements [embedded_hal::timer::CountDown]
 pub struct Counter<TIM, const FREQ: u32>(pub(super) FTimer<TIM, FREQ>);
@@ -160,3 +160,158 @@ impl<TIM: Instance, const FREQ: u32> fugit_timer::Timer<FREQ> for Counter<TIM, F
         self.wait()
     }
 }
+
+impl Timer<SYST> {
+    /// Creates [SysCounterHz] which takes [Hertz] as Duration
+    pub fn counter_hz(self) -> SysCounterHz {
+        SysCounterHz(self)
+    }
+
+    /// Creates [SysCounter] with custom precision (core frequency recommended is known)
+    pub fn counter<const FREQ: u32>(self) -> SysCounter<FREQ> {
+        SysCounter(self)
+    }
+
+    /// Creates [SysCounter] 1 microsecond precision
+    pub fn counter_us(self) -> SysCounterUs {
+        SysCounter(self)
+    }
+}
+
+/// Hardware timers
+pub struct SysCounterHz(Timer<SYST>);
+
+impl Deref for SysCounterHz {
+    type Target = Timer<SYST>;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for SysCounterHz {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl SysCounterHz {
+    pub fn start(&mut self, timeout: Hertz) -> Result<(), Error> {
+        let rvr = self.clk.raw() / timeout.raw() - 1;
+
+        if rvr >= (1 << 24) {
+            return Err(Error::WrongAutoReload);
+        }
+
+        self.tim.set_reload(rvr);
+        self.tim.clear_current();
+        self.tim.enable_counter();
+
+        Ok(())
+    }
+
+    pub fn wait(&mut self) -> nb::Result<(), Error> {
+        if self.tim.has_wrapped() {
+            Ok(())
+        } else {
+            Err(nb::Error::WouldBlock)
+        }
+    }
+
+    pub fn cancel(&mut self) -> Result<(), Error> {
+        if !self.tim.is_counter_enabled() {
+            return Err(Error::Disabled);
+        }
+
+        self.tim.disable_counter();
+        Ok(())
+    }
+}
+
+pub type SysCounterUs = SysCounter<1_000_000>;
+
+/// SysTick timer with precision of 1 μs (1 MHz sampling)
+pub struct SysCounter<const FREQ: u32>(Timer<SYST>);
+
+impl<const FREQ: u32> Deref for SysCounter<FREQ> {
+    type Target = Timer<SYST>;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<const FREQ: u32> DerefMut for SysCounter<FREQ> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl<const FREQ: u32> SysCounter<FREQ> {
+    /// Starts listening for an `event`
+    pub fn listen(&mut self, event: SysEvent) {
+        match event {
+            SysEvent::Update => self.tim.enable_interrupt(),
+        }
+    }
+
+    /// Stops listening for an `event`
+    pub fn unlisten(&mut self, event: SysEvent) {
+        match event {
+            SysEvent::Update => self.tim.disable_interrupt(),
+        }
+    }
+
+    pub fn now(&self) -> TimerInstantU32<FREQ> {
+        TimerInstantU32::from_ticks(SYST::get_current() / (self.clk.raw() / FREQ))
+    }
+
+    pub fn start(&mut self, timeout: TimerDurationU32<FREQ>) -> Result<(), Error> {
+        let rvr = timeout.ticks() * (self.clk.raw() / FREQ) - 1;
+
+        if rvr >= (1 << 24) {
+            return Err(Error::WrongAutoReload);
+        }
+
+        self.tim.set_reload(rvr);
+        self.tim.clear_current();
+        self.tim.enable_counter();
+
+        Ok(())
+    }
+
+    pub fn wait(&mut self) -> nb::Result<(), Error> {
+        if self.tim.has_wrapped() {
+            Ok(())
+        } else {
+            Err(nb::Error::WouldBlock)
+        }
+    }
+
+    pub fn cancel(&mut self) -> Result<(), Error> {
+        if !self.tim.is_counter_enabled() {
+            return Err(Error::Disabled);
+        }
+
+        self.tim.disable_counter();
+        Ok(())
+    }
+}
+
+impl<const FREQ: u32> fugit_timer::Timer<FREQ> for SysCounter<FREQ> {
+    type Error = Error;
+
+    fn now(&mut self) -> TimerInstantU32<FREQ> {
+        Self::now(self)
+    }
+
+    fn start(&mut self, duration: TimerDurationU32<FREQ>) -> Result<(), Self::Error> {
+        self.start(duration)
+    }
+
+    fn wait(&mut self) -> nb::Result<(), Self::Error> {
+        self.wait()
+    }
+
+    fn cancel(&mut self) -> Result<(), Self::Error> {
+        self.cancel()
+    }
+}