Merge #337

337: Timer rework r=therealprof a=burrbull



Co-authored-by: Andrey Zgarbul <[email protected]>
Co-authored-by: Zgarbul Andrey <[email protected]>

Author: bors[bot]

CHANGELOG.md

@@ -42,6 +42,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ### Changed
 
+- [breaking-change] `Timer::new` now just initializes peripheral.
+  Use `.start_count_down` to start count, `pwm` or `delay` on `Timer` struct.
 - Add `Spi::new`, `I2s::new, `spi::Instance` and deprecate `Spi:spix`,
   deprecate `Serial::usartx`, remove deprecated `I2c::i2cx`
 - Deprecate `free` in favour of `release`

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));
 
@@ -116,7 +117,7 @@ fn main() -> ! {
 
     let dc = gpioe.pe3.into_push_pull_output();
     let mut ss = gpioe.pe4.into_push_pull_output();
-    let mut delay = hal::delay::Delay::new(cp.SYST, clocks);
+    let mut delay = hal::delay::Delay::new(cp.SYST, &clocks);
 
     ss.set_high();
     delay.delay_ms(100_u32);
@@ -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::new(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::new(dp.TIM2, &clocks).start_count_down(1.hz());
 
     // Generate an interrupt when the timer expires
     timer.listen(Event::TimeOut);

examples/delay-syst-blinky.rs

@@ -28,7 +28,7 @@ fn main() -> ! {
         let clocks = rcc.cfgr.sysclk(48.mhz()).freeze();
 
         // Create a delay abstraction based on SysTick
-        let mut delay = hal::delay::Delay::new(cp.SYST, clocks);
+        let mut delay = hal::delay::Delay::new(cp.SYST, &clocks);
 
         loop {
             // On for 1s, off for 1s.

examples/delay-timer-blinky.rs

@@ -28,7 +28,7 @@ fn main() -> ! {
         let clocks = rcc.cfgr.sysclk(48.mhz()).freeze();
 
         // Create a delay abstraction based on general-pupose 32-bit timer TIM5
-        let mut delay = hal::delay::Delay::tim5(dp.TIM5, clocks);
+        let mut delay = hal::delay::Delay::tim5(dp.TIM5, &clocks);
 
         loop {
             // On for 1s, off for 1s.

examples/f413disco_lcd_ferris.rs

@@ -746,7 +746,7 @@ fn main() -> ! {
         gpioe.pe5.into_push_pull_output().set_high();
 
         // Get delay provider
-        let mut delay = Delay::new(cp.SYST, clocks);
+        let mut delay = Delay::new(cp.SYST, &clocks);
 
         // Set up timing
         let write_timing = Timing::default().data(3).address_setup(3).bus_turnaround(0);

examples/i2s-audio-out-dma.rs

@@ -103,7 +103,7 @@ fn main() -> ! {
     let gpioc = dp.GPIOC.split();
     let gpiod = dp.GPIOD.split();
 
-    let mut delay = Delay::new(cp.SYST, clocks);
+    let mut delay = Delay::new(cp.SYST, &clocks);
 
     let i2c = I2c::new(
         dp.I2C1,

examples/i2s-audio-out.rs

@@ -100,7 +100,7 @@ fn main() -> ! {
     // The 86 MHz frequency can be divided to get a sample rate very close to 48 kHz.
     let clocks = rcc.cfgr.use_hse(8.mhz()).i2s_clk(86.mhz()).freeze();
 
-    let mut delay = Delay::new(cp.SYST, clocks);
+    let mut delay = Delay::new(cp.SYST, &clocks);
 
     let i2c = I2c::new(
         dp.I2C1,

examples/pwm.rs

@@ -6,19 +6,19 @@
 use panic_halt as _;
 
 use cortex_m_rt::entry;
-use stm32f4xx_hal::{prelude::*, pwm, stm32};
+use stm32f4xx_hal::{pac, prelude::*, timer::Timer};
 
 #[entry]
 fn main() -> ! {
-    if let Some(dp) = stm32::Peripherals::take() {
+    if let Some(dp) = pac::Peripherals::take() {
         // Set up the system clock.
         let rcc = dp.RCC.constrain();
         let clocks = rcc.cfgr.freeze();
 
         let gpioa = dp.GPIOA.split();
         let channels = (gpioa.pa8.into_alternate(), gpioa.pa9.into_alternate());
 
-        let pwm = pwm::tim1(dp.TIM1, channels, clocks, 20u32.khz());
+        let pwm = Timer::new(dp.TIM1, &clocks).pwm(channels, 20u32.khz());
         let (mut ch1, _ch2) = pwm;
         let max_duty = ch1.get_max_duty();
         ch1.set_duty(max_duty / 2);

examples/qei.rs

@@ -32,7 +32,7 @@ fn main() -> ! {
     let clocks = rcc.cfgr.freeze();
 
     // Create a delay abstraction based on SysTick.
-    let mut delay = Delay::new(cp.SYST, clocks);
+    let mut delay = Delay::new(cp.SYST, &clocks);
 
     let gpioa = dp.GPIOA.split();