How to use interrupts in MicroPython with a Pico RPi?

A skeleton Python script to follow

This example script in MicroPython allows you to use a signal received by your Pi Pico to activate an external interrupt.

from machine import Pin

pin_button = Pin(14, mode=Pin.IN, pull=Pin.PULL_UP)

def interruption_handler(pin):
    ...

pin_button.irq(trigger=Pin.IRQ_FALLING,handler=interruption_handler)

while True:
    ...

The code uses the Pin.irq() function, which takes a signal from a pin_button and converts it into an interrupt request.

When an interrupt is enabled, interruption_handler() is called with the pin where the event occurred as the input argument.

It is essential to write an interrupt function (isr ) quickly to avoid interrupting the main program. For example, sending data via I2C or SPI directly from an interrupt is not recommended. A better approach is to use a boolean flag to store the detection of an event and then handle it in the main loop.

Example: Turn on an LED when a push button is pressed

RPI Pi Pico

uPesy RP2040 DevKit

This is the code you need to run to detect when a button is pressed and turn on an LED using an interrupt:

import time
from machine import Pin

pin_button = Pin(14, mode=Pin.IN, pull=Pin.PULL_UP)
pin_led    = Pin(16, mode=Pin.OUT)


def button_isr(pin):
  pin_led.value(not pin_led.value())

pin_button.irq(trigger=Pin.IRQ_FALLING,handler=button_isr)

while True:
  ...

pin_button.irq(trigger=Pin.IRQ_FALLING | Pin.IRQ_RISING,handler=button_isr)

Here are some functions that may be useful to you:

• irq.init() : Re-initialize the interrupt. It will be automatically reactivated.

• irq.enable() : Enable the interrupt.

• irq.disable() : Disable the interrupt.

• irq() : Manually launch the call of the interrupt routine.

• irq.flags() to know the type of event that triggered the interrupt. It can only be used in the isr .

  def pin_handler(pin):
      print('Interrupt from pin {}'.format(pin.id()))
      flags = pin.irq().flags()
      if flags & Pin.IRQ_RISING:
          # handle rising edge
      else:
          # handle falling edge
      # disable the interrupt
      pin.irq().deinit()
  

To take advantage of these features, you must use the pin variable associated with an interrupt - such as pin_button.irq().enable() .

A basic understanding of interrupts in MicroPython is essential. Suppose you want to take full advantage of their features, such as setting priorities between multiple interrupts firing simultaneously. In that case, it is recommended that you consult the official documentation . If you are looking for tips and optimization techniques, you can find them in the advanced section of the documentation. 😎

Use global variables to manage events in the main program

Limiting the number of actions performed within an interrupt is recommended to avoid overloading the system. A common practice is incrementing a variable within the ISR (Interrupt Service Routine) and completing the long tasks in the main code according to the value of this variable. For example, here is code that counts the number of times a button is pressed.

import time
from machine import Pin

button_pressed_count = 0 # global variable
pin_button = Pin(14, mode=Pin.IN, pull=Pin.PULL_UP)

def button_isr(pin):
    global button_pressed_count
    button_pressed_count += 1


if __name__ == "__main__":
    button_pressed_count_old = 0
    pin_button.irq(trigger=Pin.IRQ_FALLING,handler=button_isr)

    While True:
        if button_pressed_count_old != button_pressed_count:
           print('Button value:', button_pressed_count)
           button_pressed_count_old = button_pressed_count

        if button_pressed_count > 10: # heavy task here
            ...

We use a global variable to write to it inside the interrupt routine.

When we run our MicroPython code, we see a bigger increase than when the button was pressed. This is confusing! The not-so-smooth changes of the logic levels at the button level are why.