Implement Cancel trait for Timer<TIM> (#148)

* Implement Cancel trait for Timer<TIM>

Author: marcoieni

CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+### Added
+
+- Implement `timer::Cancel` trait for `Timer<TIM>`.
+
 ## [v0.8.0] - 2020-04-30
 
 ### Changed

examples/timer-periph.rs

@@ -0,0 +1,63 @@
+//! Start and stop a periodic peripheral 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-periph
+//! ```
+
+#![no_std]
+#![no_main]
+
+extern crate panic_halt;
+
+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 rcc = dp.RCC.constrain();
+    let clocks = rcc.cfgr.sysclk(24.mhz()).freeze();
+
+    // Create a timer based on SysTick
+    let mut timer = Timer::tim1(dp.TIM1, 1.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(1.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

@@ -274,6 +274,22 @@ macro_rules! hal {
                 }
             }
 
+            impl Cancel for Timer<$TIM>
+            {
+                type Error = Error;
+
+                fn cancel(&mut self) -> Result<(), Self::Error> {
+                    let is_counter_enabled = self.tim.cr1.read().cen().is_enabled();
+                    if !is_counter_enabled {
+                        return Err(Self::Error::Disabled);
+                    }
+
+                    // disable counter
+                    self.tim.cr1.modify(|_, w| w.cen().clear_bit());
+                    Ok(())
+                }
+            }
+
             impl Periodic for Timer<$TIM> {}
         )+
     }