STM32 Timers + Rust: Leveraging Interrupts to Extend Pulse Width Measurement Duration

 1#![no_std]
 2#![no_main]
 3
 4use core::sync::atomic::{AtomicU32, Ordering};
 5
 6use defmt_rtt as _;
 7use panic_probe as _;
 8
 9use cortex_m_rt::entry;
10use stm32f1xx_hal::{
11    flash::FlashExt,
12    pac::{self, interrupt},
13    prelude::*,
14    rcc::{Config, RccExt},
15    time::Hertz,
16    timer::{Event, Timer},
17};

As usual, we instruct the Rust compiler not to use the standard library and to ensure the program does not run on top of an operating system.

We also define the libraries that will be used in the project:

• The atomic library is used to define global variables so they can be accessed from both the main loop block and the interrupt function.
• The cortex_m_rt library/crate is used to define the program’s entry point and handle the startup process.
• defmt_rtt is used to send logging data to a PC or laptop via the Real-Time Transfer (RTT) protocol.
• The stm32f1xx_hal library allows us to access the STM32F103C8 microcontroller’s peripherals safely.
• panic_probe is used to handle runtime errors and will automatically send error logs to the host PC or laptop.

1static NUMB_OVERFLOW: AtomicU32 = AtomicU32::new(0);

Create a global variable named NUMB_OVERFLOW to store the number of times the timer overflows. Here, we use the AtomicU32 variable type so that it can be accessed from both the main loop block and the interrupt function block (Interrupt Service Routine/ISR).

1defmt::println!("STM32F103C8 Timer Interrupt with Input Capture");

Sending a message to the PC/laptop to indicate that the program is a timer with interrupts.

 1let dp = pac::Peripherals::take().unwrap();
 2
 3let mut flash = dp.FLASH.constrain();
 4
 5let rcc = dp.RCC.constrain();
 6
 7let clock_config = Config::default()
 8    .use_hse(Hertz::MHz(8))
 9    .sysclk(Hertz::MHz(72))
10    .hclk(Hertz::MHz(72))
11    .pclk1(Hertz::MHz(36));
12
13let mut clocks = rcc.freeze(clock_config, &mut flash.acr);

ust as in the previous article, we configure the clocks to use an 8 MHz external clock (HSE). We then set the System Clock to 72 MHz, the Advanced High-performance Bus (AHB) peripheral clock to 72 MHz, and the Advanced Peripheral Bus 1 (APB1) clock to 36 MHz. Consequently, the Timer 2 clock frequency will be 72 MHz.

1let mut gpioa = dp.GPIOA.split(&mut clocks);
2
3let channel_1 = gpioa.pa0.into_pull_down_input(&mut gpioa.crl);

Access the GPIOA peripheral and configure the PA0 pin as a pull-down input. In the next step, we will connect the PA0 pin to Channel 1 of Timer 2.

1let timer2 = Timer::new(dp.TIM2, &mut clocks);
2unsafe {
3        pac::NVIC::unmask(interrupt::TIM2);
4}

Access the Timer 2 peripheral and enable the Timer 2 interrupt within the NVIC (Nested Vectored Interrupt Controller).

1let mut counter = timer2.counter_hz();

The Timer 2 counter is enabled to allow it to start counting increments based on the configured clock.

1counter.listen(Event::Update);

Enable the Update Event interrupt for Timer 2 on the STM32F103C8.

1let timer_register = unsafe { &*pac::TIM2::ptr() };

Directly accessing the Timer 2 register pointer of the STM32F103C8.

1timer_register.ccmr1_input().modify(|_, w| w.cc1s().ti1());

Configure Channel 1 of Timer 2 as an input and map Timer 2 Channel 1 to the PA0 pin.

1timer_register
2    .ccmr1_input()
3    .modify(|_, w| w.ic1f().fck_int_n8());

Enable the digital filter for Timer 2 Channel 1 to reduce debouncing effects.

1timer_register.ccer().modify(|_, w| w.cc1e().set_bit());

Enable the Input Capture on Timer 2 Channel 1.

1    timer_register.ccer().modify(|_, w| w.cc1p().clear_bit());

Configure Timer 2 Channel 1 to detect the Rising Edge.

1  counter.start_raw(7199, 65535);

Run Timer 2 with a prescaler of 7199 and an Auto-Reload register value of 65535.

1let mut start_press_tick = 0u16;
2
3let mut is_pressed = false;

Create variables to store the tick value when the push button is first pressed and to store the current status of the push button.

1loop {
2    if counter.get_interrupt().contains(Event::C1) {
3        // Capture channel 1 interupt
4    }
5}

Inside the loop block, we check for a capture/compare event on channel 1. If a capture/compare event occurs on channel 1, the CPU will execute the code below. Unlike the previous article, where we directly read the CC1IF bit of the TIM2_SR register, in this tutorial, we utilize the get_interrupt method provided by the stm32f1xx_hal crate. Both methods serve the same purpose.

 1let captured_tick = timer_register.ccr1().read().ccr().bits() as u16;
 2
 3let pin_is_high = channel_1.is_high();
 4
 5if pin_is_high && !is_pressed {
 6    start_press_tick = captured_tick;
 7    NUMB_OVERFLOW.store(0, Ordering::SeqCst);
 8    timer_register.ccer().modify(|_, w| w.cc1p().set_bit());
 9
10    is_pressed = true;
11    defmt::println!("--- Button Pressed ---");
12    defmt::println!("start: {}", start_press_tick);
13} else if !pin_is_high && is_pressed {
14    // ELSE
15}
16
17counter.clear_interrupt(Event::C1);

If a capture/compare event occurs, retrieve the value from the Timer 2 Capture/Compare register. Next, check the status of the PA0 pin. If the PA0 pin is HIGH and the is_pressed variable is false (indicating a Rising edge), update the start_press_tick variable with the captured tick value. Then, reset the NUMB_OVERFLOW global variable to 0, configure channel 1 to detect a Falling edge, and set the is_pressed variable to true. Finally, do not forget to clear the channel 1 capture/compare interrupt flag, even though it is typically cleared automatically.

 1timer_register.ccer().modify(|_, w| w.cc1p().clear_bit());
 2
 3let total_overflow = NUMB_OVERFLOW.load(Ordering::SeqCst);
 4
 5let total_tick =
 6    (total_overflow * 65536) + captured_tick as u32 - start_press_tick as u32;
 7
 8defmt::println!(
 9    "end: {} | total_overflow: {}",
10    captured_tick,
11    total_overflow
12);
13defmt::println!("press long: {} ms", total_tick as f32 / 10f32);
14defmt::println!("----------------------");
15is_pressed = false;

If the PA0 pin is LOW and the is_pressed variable is true (indicating a Falling edge), we will calculate the total ticks elapsed while the push button was pressed. Next, use the total ticks to calculate the duration of the button press and set the is_pressed variable to false. At this point, we also reconfigure the channel 1 input capture mode back to rising edge.

 1
 2#[interrupt]
 3fn TIM2() {
 4    let timer_register = unsafe { &*pac::TIM2::ptr() };
 5
 6    // check update interrupt flag
 7    if timer_register.sr().read().uif().bit_is_set() {
 8        // Increment overflow count
 9        NUMB_OVERFLOW.fetch_add(1, Ordering::SeqCst);
10        // Clear update interrupt flag
11        timer_register.sr().modify(|_, w| w.uif().clear_bit());
12    }
13}

Create an interrupt function (ISR) for Timer 2. Inside this function, we check the update interrupt flag. If the interrupt was triggered by an update event, we increment the NUMB_OVERFLOW global variable by 1, and subsequently clear the update interrupt flag bit.