CountDownTimer

Author: burrbull

examples/analog-stopwatch-with-spi-ssd1306.rs

@@ -17,7 +17,7 @@ use crate::hal::{
     rcc::{Clocks, Rcc},
     spi::Spi,
     stm32,
-    timer::{Event, Timer},
+    timer::{CountDownTimer, Event, Timer},
 };
 
 use arrayvec::ArrayString;
@@ -47,7 +47,8 @@ use ssd1306::{prelude::*, Builder};
 // Set up global state. It's all mutexed up for concurrency safety.
 static ELAPSED_MS: Mutex<Cell<u32>> = Mutex::new(Cell::new(0u32));
 static ELAPSED_RESET_MS: Mutex<Cell<u32>> = Mutex::new(Cell::new(0u32));
-static TIMER_TIM2: Mutex<RefCell<Option<Timer<stm32::TIM2>>>> = Mutex::new(RefCell::new(None));
+static TIMER_TIM2: Mutex<RefCell<Option<CountDownTimer<stm32::TIM2>>>> =
+    Mutex::new(RefCell::new(None));
 static STATE: Mutex<Cell<StopwatchState>> = Mutex::new(Cell::new(StopwatchState::Ready));
 static BUTTON: Mutex<RefCell<Option<PA0<Input<PullDown>>>>> = Mutex::new(RefCell::new(None));
 
@@ -129,7 +130,7 @@ fn main() -> ! {
     disp.flush().unwrap();
 
     // Create a 1ms periodic interrupt from TIM2
-    let mut timer = Timer::tim2(dp.TIM2, 1.khz(), clocks);
+    let mut timer = Timer::tim2(dp.TIM2, &clocks).start_count_down(1.hz());
     timer.listen(Event::TimeOut);
 
     free(|cs| {

examples/blinky-timer-irq.rs

@@ -14,7 +14,7 @@ use crate::hal::{
     gpio::{gpioa, Output, PushPull},
     prelude::*,
     stm32::{interrupt, Interrupt, Peripherals, TIM2},
-    timer::{Event, Timer},
+    timer::{CountDownTimer, Event, Timer},
 };
 
 use core::cell::RefCell;
@@ -36,14 +36,14 @@ type LEDPIN = gpioa::PA5<Output<PushPull>>;
 static G_LED: Mutex<RefCell<Option<LEDPIN>>> = Mutex::new(RefCell::new(None));
 
 // Make timer interrupt registers globally available
-static G_TIM: Mutex<RefCell<Option<Timer<TIM2>>>> = Mutex::new(RefCell::new(None));
+static G_TIM: Mutex<RefCell<Option<CountDownTimer<TIM2>>>> = Mutex::new(RefCell::new(None));
 
 // Define an interupt handler, i.e. function to call when interrupt occurs.
 // This specific interrupt will "trip" when the timer TIM2 times out
 #[interrupt]
 fn TIM2() {
     static mut LED: Option<LEDPIN> = None;
-    static mut TIM: Option<Timer<TIM2>> = None;
+    static mut TIM: Option<CountDownTimer<TIM2>> = None;
 
     let led = LED.get_or_insert_with(|| {
         cortex_m::interrupt::free(|cs| {
@@ -79,7 +79,7 @@ fn main() -> ! {
     cortex_m::interrupt::free(|cs| *G_LED.borrow(cs).borrow_mut() = Some(led));
 
     // Set up a timer expiring after 1s
-    let mut timer = Timer::tim2(dp.TIM2, 1.hz(), &clocks);
+    let mut timer = Timer::tim2(dp.TIM2, &clocks).start_count_down(1.hz());
 
     // Generate an interrupt when the timer expires
     timer.listen(Event::TimeOut);

examples/stopwatch-with-ssd1306-and-interrupts.rs

@@ -28,7 +28,7 @@ use crate::hal::{
     prelude::*,
     rcc::{Clocks, Rcc},
     stm32,
-    timer::{Event, Timer},
+    timer::{CountDownTimer, Event, Timer},
 };
 use arrayvec::ArrayString;
 use core::cell::{Cell, RefCell};
@@ -46,7 +46,8 @@ use ssd1306::{prelude::*, Builder, I2CDIBuilder};
 
 // Set up global state. It's all mutexed up for concurrency safety.
 static ELAPSED_MS: Mutex<Cell<u32>> = Mutex::new(Cell::new(0u32));
-static TIMER_TIM2: Mutex<RefCell<Option<Timer<stm32::TIM2>>>> = Mutex::new(RefCell::new(None));
+static TIMER_TIM2: Mutex<RefCell<Option<CountDownTimer<stm32::TIM2>>>> =
+    Mutex::new(RefCell::new(None));
 static STATE: Mutex<Cell<StopwatchState>> = Mutex::new(Cell::new(StopwatchState::Ready));
 static BUTTON: Mutex<RefCell<Option<PC13<Input<PullUp>>>>> = Mutex::new(RefCell::new(None));
 
@@ -88,7 +89,7 @@ fn main() -> ! {
         disp.flush().unwrap();
 
         // Create a 1ms periodic interrupt from TIM2
-        let mut timer = Timer::tim2(dp.TIM2, 1.khz(), &clocks);
+        let mut timer = Timer::tim2(dp.TIM2, &clocks).start_count_down(1.hz());
         timer.listen(Event::TimeOut);
 
         free(|cs| {

examples/timer-periph.rs

@@ -29,7 +29,7 @@ fn main() -> ! {
     let clocks = rcc.cfgr.sysclk(24.mhz()).freeze();
 
     // Create a timer based on SysTick
-    let mut timer = Timer::tim1(dp.TIM1, 1.hz(), &clocks);
+    let mut timer = Timer::tim1(dp.TIM1, &clocks).start_count_down(1.hz());
 
     hprintln!("hello!").unwrap();
     // wait until timer expires

examples/timer-syst.rs

@@ -30,7 +30,7 @@ fn main() -> ! {
     let clocks = rcc.cfgr.sysclk(24.mhz()).freeze();
 
     // Create a timer based on SysTick
-    let mut timer = Timer::syst(cp.SYST, 24.hz(), &clocks);
+    let mut timer = Timer::syst(cp.SYST, &clocks).start_count_down(24.hz());
 
     hprintln!("hello!").unwrap();
     // wait until timer expires

src/timer.rs

@@ -14,39 +14,57 @@ use crate::pac::RCC;
 use crate::rcc::{Clocks, Enable, Reset};
 use crate::time::Hertz;
 
-/// Hardware timers
+/// Timer wrapper
 pub struct Timer<TIM> {
+    pub(crate) tim: TIM,
+    pub(crate) clk: Hertz,
+}
+
+/// Hardware timers
+pub struct CountDownTimer<TIM> {
     clk: Hertz,
     tim: TIM,
 }
 
 /// Interrupt events
 pub enum Event {
-    /// Timer timed out / count down ended
+    /// CountDownTimer timed out / count down ended
     TimeOut,
 }
 
 #[derive(Debug, Eq, PartialEq, Copy, Clone)]
 pub enum Error {
-    /// Timer is disabled
+    /// CountDownTimer is disabled
     Disabled,
 }
 
 impl Timer<SYST> {
+    /// Initialize timer
+    pub fn syst(mut syst: SYST, clocks: &Clocks) -> Self {
+        syst.set_clock_source(SystClkSource::Core);
+        Self {
+            tim: syst,
+            clk: clocks.sysclk(),
+        }
+    }
+
     /// Configures the SYST clock as a periodic count down timer
-    pub fn syst<T>(mut syst: SYST, timeout: T, clocks: &Clocks) -> Self
+    pub fn start_count_down<T>(self, timeout: T) -> CountDownTimer<SYST>
     where
         T: Into<Hertz>,
     {
-        syst.set_clock_source(SystClkSource::Core);
-        let mut timer = Self {
-            tim: syst,
-            clk: clocks.sysclk(),
-        };
+        let Self { tim, clk } = self;
+        let mut timer = CountDownTimer { tim, clk };
         timer.start(timeout);
         timer
     }
 
+    pub fn release(self) -> SYST {
+        self.tim
+    }
+}
+
+impl CountDownTimer<SYST> {
     /// Starts listening for an `event`
     pub fn listen(&mut self, event: Event) {
         match event {
@@ -62,7 +80,7 @@ impl Timer<SYST> {
     }
 }
 
-impl CountDown for Timer<SYST> {
+impl CountDown for CountDownTimer<SYST> {
     type Time = Hertz;
 
     fn start<T>(&mut self, timeout: T)
@@ -87,7 +105,7 @@ impl CountDown for Timer<SYST> {
     }
 }
 
-impl Cancel for Timer<SYST> {
+impl Cancel for CountDownTimer<SYST> {
     type Error = Error;
 
     fn cancel(&mut self) -> Result<(), Self::Error> {
@@ -100,7 +118,7 @@ impl Cancel for Timer<SYST> {
     }
 }
 
-impl Periodic for Timer<SYST> {}
+impl Periodic for CountDownTimer<SYST> {}
 
 /// A monotonic non-decreasing timer
 ///
@@ -157,11 +175,8 @@ macro_rules! hal {
     ($($TIM:ty: ($tim:ident, $pclk:ident, $ppre:ident),)+) => {
         $(
             impl Timer<$TIM> {
-                /// Configures a TIM peripheral as a periodic count down timer
-                pub fn $tim<T>(tim: $TIM, timeout: T, clocks: &Clocks) -> Self
-                where
-                    T: Into<Hertz>,
-                {
+                /// Initialize timer
+                pub fn $tim(tim: $TIM, clocks: &Clocks) -> Self {
                     unsafe {
                         //NOTE(unsafe) this reference will only be used for atomic writes with no side effects
                         let rcc = &(*RCC::ptr());
@@ -172,15 +187,25 @@ macro_rules! hal {
 
                     let pclk_mul = if clocks.$ppre() == 1 { 1 } else { 2 };
 
-                    let mut timer = Self {
+                    Self {
                         clk: Hertz(clocks.$pclk().0 * pclk_mul),
                         tim,
-                    };
-                    timer.start(timeout);
+                    }
+                }
 
+                /// Starts timer in count down mode at a given frequency
+                pub fn start_count_down<T>(self, timeout: T) -> CountDownTimer<$TIM>
+                where
+                    T: Into<Hertz>,
+                {
+                    let Self { tim, clk } = self;
+                    let mut timer = CountDownTimer { tim, clk };
+                    timer.start(timeout);
                     timer
                 }
 
+            }
+            impl CountDownTimer<$TIM> {
                 /// Starts listening for an `event`
                 ///
                 /// Note, you will also have to enable the TIM2 interrupt in the NVIC to start
@@ -225,7 +250,7 @@ macro_rules! hal {
                 }
             }
 
-            impl CountDown for Timer<$TIM> {
+            impl CountDown for CountDownTimer<$TIM> {
                 type Time = Hertz;
 
                 fn start<T>(&mut self, timeout: T)
@@ -265,7 +290,7 @@ macro_rules! hal {
                 }
             }
 
-            impl Cancel for Timer<$TIM>
+            impl Cancel for CountDownTimer<$TIM>
             {
                 type Error = Error;
 
@@ -281,7 +306,7 @@ macro_rules! hal {
                 }
             }
 
-            impl Periodic for Timer<$TIM> {}
+            impl Periodic for CountDownTimer<$TIM> {}
         )+
     }
 }