Mastering MicroPython Timers: A Comprehensive Guide

MicroPython is a lean and efficient implementation of the Python 3 programming language that includes a small subset of the Python standard library and is optimized to run on microcontrollers and constrained systems. One of the extremely useful features in MicroPython is the timer functionality. Timers in MicroPython allow you to schedule tasks to run at specific intervals or after a certain delay, which is crucial for many applications such as sensor data polling, motor control, and periodic communication. In this blog, we will explore the fundamental concepts of MicroPython timers, how to use them, common practices, and best practices.

Table of Contents#

  1. Fundamental Concepts of MicroPython Timers
  2. Usage Methods
    • Initializing a Timer
    • Setting Timer Modes
    • Attaching a Callback Function
  3. Common Practices
    • Periodic Task Execution
    • One - Shot Delayed Execution
  4. Best Practices
    • Resource Management
    • Error Handling
  5. Conclusion
  6. References

Fundamental Concepts of MicroPython Timers#

A timer in MicroPython is a hardware or software-based mechanism that can be used to generate interrupts at specified intervals. These interrupts can then trigger the execution of a user-defined function, known as a callback function.

There are two main types of timer modes in MicroPython:

  • Periodic Mode: In this mode, the timer will generate an interrupt at a fixed interval. For example, you can set a timer to generate an interrupt every 100 milliseconds.
  • One - Shot Mode: In one - shot mode, the timer generates a single interrupt after a specified delay. Once the interrupt is generated, the timer stops.

Usage Methods#

Initializing a Timer#

To use a timer in MicroPython, you first need to import the machine module, which provides access to the hardware resources of the microcontroller. Then, you can initialize a timer object.

import machine
 
# Initialize Timer 0
timer = machine.Timer(0)

Setting Timer Modes#

You can set the timer mode using the init method of the timer object. The init method takes several parameters, including the mode (machine.Timer.PERIODIC or machine.Timer.ONE_SHOT), the period (in milliseconds), and the callback function.

import machine
 
# Initialize Timer 0
timer = machine.Timer(0)
 
# Set the timer to periodic mode with a period of 1000 milliseconds
timer.init(mode=machine.Timer.PERIODIC, period=1000)

Attaching a Callback Function#

A callback function is a function that will be executed when the timer generates an interrupt. You can attach a callback function to the timer using the init method.

import machine
 
# Define a callback function
def callback(timer):
    print("Timer interrupt occurred!")
 
# Initialize Timer 0
timer = machine.Timer(0)
 
# Set the timer to periodic mode with a period of 1000 milliseconds and attach the callback function
timer.init(mode=machine.Timer.PERIODIC, period=1000, callback=callback)

Common Practices#

Periodic Task Execution#

Periodic task execution is one of the most common use cases for MicroPython timers. For example, you can use a timer to periodically read sensor data.

import machine
import time
 
# Simulate a sensor
sensor_value = 0
 
# Define a callback function to read sensor data
def read_sensor(timer):
    global sensor_value
    sensor_value += 1
    print(f"Sensor value: {sensor_value}")
 
# Initialize Timer 0
timer = machine.Timer(0)
 
# Set the timer to periodic mode with a period of 2000 milliseconds and attach the callback function
timer.init(mode=machine.Timer.PERIODIC, period=2000, callback=read_sensor)
 
try:
    while True:
        time.sleep(1)
except KeyboardInterrupt:
    timer.deinit()
    print("Timer stopped.")

One - Shot Delayed Execution#

One - shot delayed execution is useful when you want to execute a task after a certain delay. For example, you can use a timer to turn on an LED after 5 seconds.

import machine
import time
 
# Initialize an LED pin
led = machine.Pin(2, machine.Pin.OUT)
 
# Define a callback function to turn on the LED
def turn_on_led(timer):
    led.value(1)
    print("LED turned on!")
 
# Initialize Timer 0
timer = machine.Timer(0)
 
# Set the timer to one - shot mode with a delay of 5000 milliseconds and attach the callback function
timer.init(mode=machine.Timer.ONE_SHOT, period=5000, callback=turn_on_led)
 
try:
    while True:
        time.sleep(1)
except KeyboardInterrupt:
    timer.deinit()
    led.value(0)
    print("Timer stopped and LED turned off.")

Best Practices#

Resource Management#

When using timers, it is important to manage resources properly. Make sure to deinitialize the timer when it is no longer needed to free up hardware resources. You can use the deinit method of the timer object to do this.

import machine
import time
 
# Define a callback function
def callback(timer):
    print("Timer interrupt occurred!")
 
# Initialize Timer 0
timer = machine.Timer(0)
 
# Set the timer to periodic mode with a period of 1000 milliseconds and attach the callback function
timer.init(mode=machine.Timer.PERIODIC, period=1000, callback=callback)
 
try:
    while True:
        time.sleep(1)
except KeyboardInterrupt:
    timer.deinit()
    print("Timer stopped.")

Error Handling#

Error handling is crucial when using timers. Make sure to handle exceptions properly to prevent your program from crashing. For example, you can use a try - except block to catch KeyboardInterrupt exceptions and deinitialize the timer.

Conclusion#

MicroPython timers are a powerful and versatile tool for scheduling tasks in microcontroller applications. By understanding the fundamental concepts, usage methods, common practices, and best practices, you can effectively use timers to improve the efficiency and functionality of your MicroPython projects. Remember to manage resources properly and handle errors to ensure the stability of your programs.

References#

  • MicroPython official documentation: https://docs.micropython.org/
  • Microcontroller datasheets for specific hardware details related to timer functionality.
2025-10