Hey there! I get where you're coming from—switching from bare-metal C microcontroller programming to Python on Raspberry Pi can feel like a bit of a paradigm shift when it comes to interrupts. Let's break down your questions and clear things up:

1. Python GPIO中断 vs 你熟悉的C语言微控制器中断 #

First off, let's address the core difference:

• In C on microcontrollers, interrupts are hardware-level, preemptive events—they'll immediately pause whatever code the CPU is executing, jump to the interrupt service routine (ISR), run it, then jump back. No ifs, ands, or buts.
• In Python (using libraries like RPi.GPIO or gpiozero), interrupts are still tied to hardware GPIO edge detection, but they're handled by user-space threads or event loops. That said, they will trigger even if your main program is in an infinite loop—you don't have to be "waiting" for them explicitly. The infinite loop is just there to keep your Python script running (if you don't have it, the script would set up the interrupts and then exit immediately).

2. Binding all keys to a single callback method #

This is actually a smart approach, and totally doable. The key is using the callback's built-in parameter to identify which pin triggered the interrupt. Here's a quick example with RPi.GPIO:

import RPi.GPIO as GPIO
import time

# Define your key pins with friendly names
KEY_PINS = {
    "UP": 17,
    "DOWN": 27,
    "OK": 22
}

def handle_key_press(channel):
    # Figure out which key was pressed by matching the triggered pin
    for key_name, pin in KEY_PINS.items():
        if pin == channel:
            print(f"Pressed {key_name} key!")
            # Add your LCD update logic here (e.g. write to display)
            break

# GPIO setup
GPIO.setmode(GPIO.BCM)
for pin in KEY_PINS.values():
    # Set pin as input with pull-up resistor, detect falling edge (key press)
    GPIO.setup(pin, GPIO.IN, pull_up_down=GPIO.PUD_UP)
    # Attach interrupt with debounce to avoid false triggers
    GPIO.add_event_detect(pin, GPIO.FALLING, callback=handle_key_press, bouncetime=200)

# Keep the program alive
try:
    while True:
        time.sleep(1)  # Sleep reduces CPU load vs a tight empty loop
except KeyboardInterrupt:
    GPIO.cleanup()  # Reset GPIO pins on exit

A few key notes here:

• The channel parameter passed to handle_key_press is the exact GPIO pin that triggered the interrupt—this is how you tell which key was pressed.
• bouncetime=200 handles mechanical key bounce (those tiny, rapid on/off signals when a key is pressed/released).
• The infinite loop with time.sleep(1) keeps the script running without hogging CPU resources.

3. Common pitfalls to watch out for #

• GIL Limitations: Python's Global Interpreter Lock (GIL) means your callback can't run in true parallel with the main loop, but it will still interrupt the main loop's execution (the GIL is released during waits like time.sleep, so callbacks run smoothly).
• Keep Callbacks Short: Don't put heavy, slow code in your interrupt callback—keep it minimal (e.g. set a flag, log the press). Handle complex logic in the main loop instead.
• Always Clean Up: Use GPIO.cleanup() when exiting (like in the KeyboardInterrupt handler) to reset GPIO pins to their default state and avoid issues in future runs.

内容的提问来源于stack exchange，提问作者jakubek278