Peripheral Interrupt Experiment

1. Peripheral Interrupt Overview

The previous experiment used polling to detect the button — the CPU continuously reads the GPIO state. Polling is simple but inefficient: the CPU idles most of the time. Interrupts are another paradigm: the CPU executes the main loop normally, and when the GPIO level changes, the hardware automatically pauses the current code, jumps to the ISR (Interrupt Service Routine) to handle the event, then returns to the breakpoint and continues.

External Interrupt (EXTI) is the hardware mechanism by which an MCU responds to external asynchronous events. When the GPIO pin detects a specified edge (rising edge / falling edge / any edge), the hardware automatically pauses the current program execution, jumps to the preset Interrupt Service Routine (ISR) to handle the event, and returns to the original program to continue after completion.

This experiment demonstrates GPIO external interrupts: the falling edge of the BOOT button (GPIO0) triggers the interrupt, the ISR sets a flag, and the main loop toggles the LED after detecting the flag.

Polling vs Interrupt comparison:

2. Core Concepts

2.1 Interrupt Trigger Modes

The button experiment uses Pin.IRQ_FALLING: pressing the button (1→0) triggers once, releasing does not trigger.

2.2 ISR Design Principles

MicroPython ISRs run in the hardware interrupt context and have the following constraints:

Golden rule: the ISR only sets a flag, and the main loop does the actual processing. print() inside the ISR may cause the board to crash.

2.3 Software Debouncing

The interrupt captures the moment of level change, but it may still trigger multiple times in succession due to bounce. The handling approach is the same as polling: ISR sets a flag → main loop delays 20ms → double-check.

2.4 Core API

key.irq(trigger=Pin.IRQ_FALLING, handler=key_isr)

3. Hardware Dependencies

4. Project Architecture and Flow

xxxxxxxxxx
Script execution (single-file .py)
  │
  ├─ led = Pin(44, Pin.OUT, value=0)               // LED initially on (common-anode: 0=on)
  ├─ key = Pin(0, Pin.IN, Pin.PULL_UP)             // button input + pull-up
  ├─ led_state = False, key_flag = False           // global state (led_state=False → 0=on)
  ├─ def key_isr(pin): key_flag = True             // ISR: only sets a flag
  ├─ key.irq(trigger=FALLING, handler=key_isr)     // bind the interrupt
  │
  └─ while True:                                   // main loop
       ├─ if key_flag:                              // detect flag
       │    ├─ key_flag = False                     // clear flag
       │    ├─ sleep_ms(20)                         // debounce
       │    ├─ if key.value() == 0:                 // double-check
       │    │    ├─ led_state ^= 1
       │    │    └─ led.value(led_state)
       └─ sleep_ms(10)                              // idle, reduce usage

5. Source Code Details

Full source code: 5.Source Code → MicroPython → 1.Basic Peripherals → 3.KEY_NVIC → 3.KEY_NVIC.py

5.1 Pins and Global Variables

​x
from machine import Pin  # Pin class: GPIO control
import time              # delay functions

LED_PIN = 44  # onboard LED
KEY_PIN = 0   # BOOT button

led_state = False  # LED state, initially on (0=on)
key_flag = False   # interrupt flag

5.2 Interrupt Service Routine (ISR)

xxxxxxxxxx
led = Pin(LED_PIN, Pin.OUT, value=0)      # LED default on, common-anode: 0=on
key = Pin(KEY_PIN, Pin.IN, Pin.PULL_UP)   # button input + pull-up

def key_isr(pin):  # interrupt callback
    global key_flag
    key_flag = True  # only set the flag, no blocking operations

key.irq(trigger=Pin.IRQ_FALLING, handler=key_isr)  # falling edge trigger

The ISR only does key_flag = True; it does not delay, print, or toggle the LED inside.

5.3 Main Loop — Flag Handling + Debounce

xxxxxxxxxx
while True:
    if key_flag:                    # interrupt fired
        key_flag = False            # clear flag
        time.sleep_ms(20)           # debounce
        if key.value() == 0:        # confirm the button is still pressed
            led_state = not led_state  # toggle LED state
            led.value(led_state)

    time.sleep_ms(10)  # main loop idle, reduce CPU usage

6. Operation Procedure

6.1 Flashing and Running

Thonny IDE steps: See the 1. Before Development → 3.Thonny IDE chapter.

6.2 Normal Phenomenon

• After power-up, the LED is on and the CPU is idle (no busy-waiting polling loop)

• Press BOOT once → LED off

• Press again → LED on

6.3 Verification Methods

7. Common Problems