Using Micropython for STM32F411: Timer in Interrupt Mode

In this guide, we will explore how to use MicroPython on the STM32F411 Nucleo board for embedded development. We will specifically focus on configuring a hardware timer interrupt to execute tasks at precise intervals.

In this guide, we shall cover the following:

• What is timer interrupt.
• Micropython firmware development.
• Results.

1. What is Timer Interrupt:

A timer interrupt in a microcontroller is a mechanism where the microcontroller generates an interrupt signal based on events associated with a timer peripheral. These events can include reaching a specific count, an overflow, or a match between the timer count and a predefined value. The timer interrupt allows the microcontroller to execute a specific task (Interrupt Service Routine, ISR) in response to the timer event without continuously polling the timer status.

How Timer Interrupt Works

1. Timer Peripheral:

• A timer is a hardware module in the microcontroller that increments or decrements a counter at a fixed rate, derived from the system clock or a prescaled clock.

2. Event Generation:

• As the timer runs, it can trigger events such as:

• Overflow (counter rolls back to zero).

• Match with a specific compare value.

• A trigger input or external signal.

3. Interrupt Request (IRQ):

• When the specified event occurs, the timer generates an interrupt request (IRQ) to the CPU.

4. Interrupt Service Routine (ISR):

• The microcontroller pauses its main program to execute a small function (ISR) associated with the timer interrupt.

5. Return to Main Program:

• After the ISR finishes, the CPU resumes executing the main program from where it left off.

Why Use Timer Interrupts?

1. Precise Timing:

• Timer interrupts provide highly accurate timing, independent of the program’s execution state.

2. Non-blocking Delays:

• Unlike software delays, a timer interrupt allows the microcontroller to perform other tasks while waiting for the timer event.

3. Periodic Tasks:

• Execute tasks at regular intervals (e.g., sampling a sensor every 1 ms).

4. Event Timing:

• Measure durations or count specific events (e.g., pulses in an encoder).

Key Components of Timer Interrupts

1. Timer Counter:

• The main register that counts up or down based on the timer’s clock.

2. Prescaler:

• Divides the clock frequency to adjust the timer’s counting speed.

3. Compare Registers:

• Define specific count values that trigger interrupts.

4. Interrupt Flags:

• Indicate the occurrence of a timer event and need to be cleared in the ISR.

5. NVIC (Nested Vectored Interrupt Controller):

• Manages the priority and execution of interrupts.

Applications of Timer Interrupts

1. Real-Time Clock:

• Generate accurate time intervals (e.g., 1-second ticks).

2. PWM Generation:

• Create precise Pulse Width Modulation signals for motor control or LED dimming.

3. Frequency Measurement:

• Measure signal frequency by counting pulses within a fixed time.

4. Sensor Sampling:

• Read data from sensors at regular intervals.

5. Debouncing:

• Avoid false triggers in button presses by implementing debouncing logic.

6. Communication Protocols:

• Time-critical operations like UART bit sampling or SPI communication.

2. Micropython Firmware Development:

First, we need to configure Thonny to work with STM32F411 Nucleo-64. Please refer to this guide for how to install and configure Thonny.

After the setup has been completed, we start a new project.

Start by improting pyb and machine as following:

import pyb
import machine

Next declare two variable to handle state of the LED and if the timer has been triggered or not.

Next, configure PA5 and output and name it LED:

led = machine.Pin("PA5", machine.Pin.OUT)  # Define PA5 as output

Next, timer interrupt callback function:

# Define the interrupt callback function
def timer_callback(t):
    global state,Triggered
    state = not state
    Triggered=True
    led.value(state)

The function shall do the following:

• Not the current state (0 to 1 and 1 to 0).
• Set triggered to 1.
• Set the LED according to the state.

Remember, to use global with the variable declared to be handled in the callback.

Next, create timer object using timer2 of the STM32 with frequency of 1Hz as following:

# Create Timer object (using Timer 2)
tim = pyb.Timer(2, freq=1)  # 1 Hz (triggers every 1 second)

Next, attach the callback function to the timer:

# Attach the callback function to the timer
tim.callback(timer_callback)

In while 1 loop:

while True:
    if Triggered == True:
        Triggered = False
        print(f"State value = {state}")
        
    pyb.delay(1)

Just print the state value each time the timer interrupt has been triggered.

Hence, the code as following:

import pyb
import machine

state=0
Triggered=False

led = machine.Pin("PA5", machine.Pin.OUT)  # Define PA5 as output

# Define the interrupt callback function
def timer_callback(t):
    global state,Triggered
    state = not state
    Triggered=True
    led.value(state)
    
    


# Create Timer object (using Timer 2)
tim = pyb.Timer(2, freq=1)  # 1 Hz (triggers every 1 second)

# Attach the callback function to the timer
tim.callback(timer_callback)

while True:
    if Triggered == True:
        Triggered = False
        print(f"State value = {state}")
        
    pyb.delay(1)

Thats all for the driver.

Click on run as following:

3. Results:

In the shell, you should notice that state is being printed each 1 second as following:

Also, you should notice the LD2 on the board blink each second as following:

Happy coding 😉