Merge pull request #179 from burrbull/counter

Port timers from f4xx-hal

Author: eldruin

Cargo.toml

@@ -29,6 +29,9 @@ rand_core = "0.6"
 bxcan = "0.6"
 bare-metal = "1.0"
 fugit = "0.3.5"
+fugit-timer = "0.1.3"
+bitflags = "1.3.2"
+rtic-monotonic = { version = "1.0", optional = true }
 
 [dependencies.time]
 version = "0.3"
@@ -104,6 +107,8 @@ has-can = []
 gpioj = []
 gpiok = []
 
+rtic = ["rt", "rtic-monotonic"]
+
 [profile.dev]
 incremental = false
 codegen-units = 1
@@ -114,12 +119,16 @@ debug = true
 lto = true
 
 [[example]]
-name = "blinky_delay"
-required-features = ["stm32f746", "rt"]
+name = "blinky"
+required-features = ["device-selected", "rt"]
 
 [[example]]
-name = "blinky"
-required-features = ["stm32f746", "rt"]
+name = "delay-syst-blinky"
+required-features = ["device-selected"]
+
+[[example]]
+name = "delay-timer-blinky"
+required-features = ["device-selected"]
 
 [[example]]
 name = "flash"
@@ -134,15 +143,15 @@ name = "hello"
 required-features = ["stm32f746", "rt"]
 
 [[example]]
-name = "serial_delay"
-required-features = ["stm32f746", "rt"]
+name = "rtic-tick"
+required-features = ["device-selected", "rtic"]
 
 [[example]]
-name = "serial_echo"
+name = "serial_delay"
 required-features = ["stm32f746", "rt"]
 
 [[example]]
-name = "timer"
+name = "serial_echo"
 required-features = ["stm32f746", "rt"]
 
 [[example]]

examples/blinky-timer-irq.rs

@@ -0,0 +1,100 @@
+//! blinky timer using interrupts on TIM2, adapted from blinky_timer_irq.rs example from
+//! stm32f1xx-hal
+//!
+//! This assumes that a LED is connected to pa5 (sck/d13) as is the case on most nucleo board.
+
+#![no_main]
+#![no_std]
+
+use panic_halt as _;
+
+use stm32f7xx_hal as hal;
+
+use crate::hal::{
+    gpio::{self, Output, PushPull},
+    pac::{interrupt, Interrupt, Peripherals, TIM2},
+    prelude::*,
+    timer::{CounterUs, Event},
+};
+
+use core::cell::RefCell;
+use cortex_m::interrupt::Mutex;
+use cortex_m_rt::entry;
+
+// NOTE You can uncomment 'hprintln' here and in the code below for a bit more
+// verbosity at runtime, at the cost of throwing off the timing of the blink
+// (using 'semihosting' for printing debug info anywhere slows program
+// execution down)
+//use cortex_m_semihosting::hprintln;
+
+// A type definition for the GPIO pin to be used for our LED
+// For the onboard nucleo LED, use PA5 or PB13 depending your model
+type LedPin = gpio::PA5<Output<PushPull>>;
+
+// Make LED pin globally available
+static G_LED: Mutex<RefCell<Option<LedPin>>> = Mutex::new(RefCell::new(None));
+
+// Make timer interrupt registers globally available
+static G_TIM: Mutex<RefCell<Option<CounterUs<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<CounterUs<TIM2>> = None;
+
+    let led = LED.get_or_insert_with(|| {
+        cortex_m::interrupt::free(|cs| {
+            // Move LED pin here, leaving a None in its place
+            G_LED.borrow(cs).replace(None).unwrap()
+        })
+    });
+
+    let tim = TIM.get_or_insert_with(|| {
+        cortex_m::interrupt::free(|cs| {
+            // Move LED pin here, leaving a None in its place
+            G_TIM.borrow(cs).replace(None).unwrap()
+        })
+    });
+
+    let _ = led.toggle();
+    let _ = tim.wait();
+}
+
+#[entry]
+fn main() -> ! {
+    let dp = Peripherals::take().unwrap();
+
+    let rcc = dp.RCC.constrain();
+    let clocks = rcc.cfgr.sysclk(16.MHz()).pclk1(8.MHz()).freeze();
+
+    // Configure PA5 pin to blink LED
+    let gpioa = dp.GPIOA.split();
+    let mut led = gpioa.pa5.into_push_pull_output();
+    let _ = led.set_high(); // Turn off
+
+    // Move the pin into our global storage
+    cortex_m::interrupt::free(|cs| *G_LED.borrow(cs).borrow_mut() = Some(led));
+
+    // Set up a timer expiring after 1s
+    let mut timer = dp.TIM2.counter(&clocks);
+    timer.start(1.secs()).unwrap();
+
+    // Generate an interrupt when the timer expires
+    timer.listen(Event::Update);
+
+    // Move the timer into our global storage
+    cortex_m::interrupt::free(|cs| *G_TIM.borrow(cs).borrow_mut() = Some(timer));
+
+    //enable TIM2 interrupt
+    unsafe {
+        cortex_m::peripheral::NVIC::unmask(Interrupt::TIM2);
+    }
+
+    #[allow(clippy::empty_loop)]
+    loop {
+        // Uncomment if you want to make controller sleep
+        // cortex_m::asm::wfi();
+    }
+}

examples/blinky_delay.rs

@@ -0,0 +1,43 @@
+//! Demonstrate the use of a blocking `Delay` using the SYST (sysclock) timer.
+
+#![deny(unsafe_code)]
+#![allow(clippy::empty_loop)]
+#![no_main]
+#![no_std]
+
+// Halt on panic
+use panic_halt as _; // panic handler
+
+use cortex_m_rt::entry;
+use stm32f7xx_hal as hal;
+
+use crate::hal::{pac, prelude::*};
+
+#[entry]
+fn main() -> ! {
+    if let (Some(dp), Some(cp)) = (
+        pac::Peripherals::take(),
+        cortex_m::peripheral::Peripherals::take(),
+    ) {
+        // Set up the LED. On the Nucleo-446RE it's connected to pin PA5.
+        let gpioa = dp.GPIOA.split();
+        let mut led = gpioa.pa5.into_push_pull_output();
+
+        // Set up the system clock. We want to run at 48MHz for this one.
+        let rcc = dp.RCC.constrain();
+        let clocks = rcc.cfgr.sysclk(48.MHz()).freeze();
+
+        // Create a delay abstraction based on SysTick
+        let mut delay = cp.SYST.delay(&clocks);
+
+        loop {
+            // On for 1s, off for 1s.
+            led.set_high();
+            delay.delay_ms(1000_u32);
+            led.set_low();
+            delay.delay_ms(1000_u32);
+        }
+    }
+
+    loop {}
+}

examples/delay-syst-blinky.rs

@@ -0,0 +1,53 @@
+//! Demonstrate the use of a blocking `Delay` using TIM5 general-purpose timer.
+
+#![deny(unsafe_code)]
+#![allow(clippy::empty_loop)]
+#![no_main]
+#![no_std]
+
+// Halt on panic
+use panic_halt as _; // panic handler
+
+use cortex_m_rt::entry;
+use stm32f7xx_hal as hal;
+
+use crate::hal::{
+    pac,
+    prelude::*,
+    rcc::{HSEClock, HSEClockMode},
+};
+
+#[entry]
+fn main() -> ! {
+    if let (Some(dp), Some(_cp)) = (
+        pac::Peripherals::take(),
+        cortex_m::peripheral::Peripherals::take(),
+    ) {
+        // Set up the LED. On the Mini-F4 it's connected to pin PC13.
+        let gpioc = dp.GPIOC.split();
+        let mut led = gpioc.pc13.into_push_pull_output();
+
+        // Set up the system clock. We want to run at 48MHz for this one.
+        let rcc = dp.RCC.constrain();
+        let clocks = rcc
+            .cfgr
+            .hse(HSEClock::new(25.MHz(), HSEClockMode::Bypass))
+            .sysclk(48.MHz())
+            .freeze();
+
+        // Create a delay abstraction based on general-pupose 32-bit timer TIM5
+        let mut delay = dp.TIM5.delay_us(&clocks);
+
+        loop {
+            // On for 1s, off for 3s.
+            led.set_high();
+            // Use `embedded_hal::DelayMs` trait
+            delay.delay_ms(1000_u32);
+            led.set_low();
+            // or use `fugit::ExtU32` trait
+            delay.delay(3.secs());
+        }
+    }
+
+    loop {}
+}

examples/delay-timer-blinky.rs

@@ -21,7 +21,7 @@ use core::{mem, slice};
 use cortex_m_rt::entry;
 use cortex_m_semihosting::hprintln;
 use stm32_fmc::devices::is42s16400j_7;
-use stm32f7xx_hal::{delay::Delay, gpio::Speed, pac, prelude::*};
+use stm32f7xx_hal::{gpio::Speed, pac, prelude::*};
 
 /// Configure pins for the FMC controller
 macro_rules! fmc_pins {
@@ -43,8 +43,8 @@ fn main() -> ! {
     let dp = pac::Peripherals::take().unwrap();
 
     // Get the delay provider.
-    let clocks = dp.RCC.constrain().cfgr.sysclk(216_000_000.Hz()).freeze();
-    let mut delay = Delay::new(cp.SYST, &clocks);
+    let clocks = dp.RCC.constrain().cfgr.sysclk(216.MHz()).freeze();
+    let mut delay = cp.SYST.delay(&clocks);
 
     // IO
     let gpioc = dp.GPIOC.split();

examples/fmc.rs

@@ -0,0 +1,75 @@
+#![deny(unsafe_code)]
+#![no_main]
+#![no_std]
+
+// Halt on panic
+use panic_halt as _;
+
+use core::f32::consts::FRAC_PI_2;
+use cortex_m_rt::entry;
+use micromath::F32Ext;
+use stm32f7xx_hal::{
+    pac,
+    prelude::*,
+    rcc::{HSEClock, HSEClockMode},
+    timer::Channel,
+};
+
+#[entry]
+fn main() -> ! {
+    if let Some(dp) = pac::Peripherals::take() {
+        // Set up the system clock.
+        let rcc = dp.RCC.constrain();
+        let clocks = rcc
+            .cfgr
+            .hse(HSEClock::new(25.MHz(), HSEClockMode::Bypass))
+            .freeze();
+
+        let gpioa = dp.GPIOA.split();
+        let channels = (gpioa.pa8.into_alternate(), gpioa.pa9.into_alternate());
+
+        let mut pwm = dp.TIM1.pwm_us(channels, 100.micros(), &clocks);
+        let mut counter = dp.TIM2.counter_us(&clocks);
+        let max_duty = pwm.get_max_duty();
+
+        const N: usize = 50;
+        let mut sin_a = [0_u16; N + 1];
+        // Fill sinus array
+        let a = FRAC_PI_2 / (N as f32);
+        for (i, b) in sin_a.iter_mut().enumerate() {
+            let angle = a * (i as f32);
+            *b = (angle.sin() * (max_duty as f32)) as u16;
+        }
+
+        counter.start(100.micros()).unwrap();
+        pwm.enable(Channel::C1);
+        pwm.enable(Channel::C2);
+        let mut i = 0;
+        loop {
+            if i == 0 {
+                pwm.set_duty(Channel::C2, 0);
+            }
+            if i == 2 * N {
+                pwm.set_duty(Channel::C1, 0);
+            }
+            if i < N {
+                pwm.set_duty(Channel::C1, sin_a[i]);
+            } else if i < 2 * N {
+                pwm.set_duty(Channel::C1, sin_a[2 * N - i]);
+            } else if i < 3 * N {
+                pwm.set_duty(Channel::C2, sin_a[i - 2 * N]);
+            } else {
+                pwm.set_duty(Channel::C2, sin_a[4 * N - i]);
+            }
+            nb::block!(counter.wait()).unwrap();
+            i += 1;
+            if i == 4 * N {
+                i -= 4 * N;
+            }
+        }
+    }
+
+    loop {
+        cortex_m::asm::nop();
+    }
+}