Implement Cancel trait for Timer<SYST> (#137)

Implement Cancel trait for Timer<SYST>

Partially solves issue #106

Author: marcoieni

CHANGELOG.md

@@ -11,6 +11,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 - Wait 16 cycles after setting prescalers for some clock domains to follow manual.
 
+### Added
+
+- Implement `timer::Cancel` trait for `Timer<SYST>`.
+
 ## [v0.7.0] - 2020-03-07
 
 ### Changed

examples/timer-syst.rs

@@ -0,0 +1,65 @@
+//! Start and stop a periodic system timer.
+//!
+//! This example should run on all stm32f4xx boards but it was tested with
+//! stm32f4-discovery board (model STM32F407G-DISC1).
+//!
+//! ```bash
+//! cargo run --release --features stm32f407,rt  --example timer-syst
+//! ```
+
+#![no_std]
+#![no_main]
+
+extern crate panic_halt;
+
+use cortex_m;
+use cortex_m_rt::entry;
+use cortex_m_semihosting::hprintln;
+
+use embedded_hal::timer::Cancel;
+use hal::timer;
+use hal::timer::Timer;
+use nb;
+use stm32f4xx_hal as hal;
+
+use crate::hal::{prelude::*, stm32};
+
+#[entry]
+fn main() -> ! {
+    let dp = stm32::Peripherals::take().unwrap();
+    let cp = cortex_m::peripheral::Peripherals::take().unwrap();
+    let rcc = dp.RCC.constrain();
+    let clocks = rcc.cfgr.sysclk(24.mhz()).freeze();
+
+    // Create a timer based on SysTick
+    let mut timer = Timer::syst(cp.SYST, 24.hz(), clocks);
+
+    hprintln!("hello!").unwrap();
+    // wait until timer expires
+    nb::block!(timer.wait()).unwrap();
+    hprintln!("timer expired 1").unwrap();
+
+    // the function syst() creates a periodic timer, so it is automatically
+    // restarted
+    nb::block!(timer.wait()).unwrap();
+    hprintln!("timer expired 2").unwrap();
+
+    // cancel current timer
+    timer.cancel().unwrap();
+
+    // start it again
+    timer.start(24.hz());
+    nb::block!(timer.wait()).unwrap();
+    hprintln!("timer expired 3").unwrap();
+
+    timer.cancel().unwrap();
+    let cancel_outcome = timer.cancel();
+    assert_eq!(cancel_outcome, Err(timer::Error::Disabled));
+    hprintln!("ehy, you cannot cancel a timer two times!").unwrap();
+    // this time the timer was not restarted, therefore this function should
+    // wait forever
+    nb::block!(timer.wait()).unwrap();
+    // you should never see this print
+    hprintln!("if you see this there is something wrong").unwrap();
+    panic!();
+}

src/timer.rs

@@ -3,7 +3,7 @@
 use cast::{u16, u32};
 use cortex_m::peripheral::syst::SystClkSource;
 use cortex_m::peripheral::SYST;
-use embedded_hal::timer::{CountDown, Periodic};
+use embedded_hal::timer::{Cancel, CountDown, Periodic};
 use void::Void;
 
 use crate::stm32::RCC;
@@ -97,6 +97,12 @@ pub enum Event {
     TimeOut,
 }
 
+#[derive(Debug, PartialEq)]
+pub enum Error {
+    /// Timer is disabled
+    Disabled,
+}
+
 impl Timer<SYST> {
     /// Configures the SYST clock as a periodic count down timer
     pub fn syst<T>(mut syst: SYST, timeout: T, clocks: Clocks) -> Self
@@ -149,6 +155,19 @@ impl CountDown for Timer<SYST> {
     }
 }
 
+impl Cancel for Timer<SYST> {
+    type Error = Error;
+
+    fn cancel(&mut self) -> Result<(), Self::Error> {
+        if !self.tim.is_counter_enabled() {
+            return Err(Self::Error::Disabled);
+        }
+
+        self.tim.disable_counter();
+        Ok(())
+    }
+}
+
 impl Periodic for Timer<SYST> {}
 
 macro_rules! hal {