3.10. GPIO-ingang

Het uitlezen van een schakelaar (of een willekeurig digitaal signaal) van een GPIO-pin verloopt opnieuw via machine.Pin, dit keer geconfigureerd als ingang. De interface is symmetrisch met de uitgang: configureer de modus en peil vervolgens de waarde van de pin in de hoofdlus, of registreer een interrupt-handler die afgaat wanneer de waarde verandert.

3.10.1. Een ingang configureren

Geef Pin.IN door aan de constructor, en optioneel een pull-weerstand:

from machine import Pin

button = Pin("P0", Pin.IN, Pin.PULL_UP)

Dat configureert P0 als ingang met de interne pull-up-weerstand van de MCU ingeschakeld. Zonder iets aangesloten op de pin houdt de pull-up hem hoog; het sluiten van een schakelaar van de pin naar massa trekt hem laag.

3.10.2. De waarde uitlezen

value() zonder argumenten retourneert de huidige toestand – 0 voor laag, 1 voor hoog:

if button.value() == 0:
    print("button pressed")
else:
    print("button released")

In het hoofdluspatroon ziet polling er als volgt uit:

while True:
    if button.value() == 0:
        do_action()
    time.sleep_ms(50)

De sleep van 50 ms voorkomt dat de lus op volle CPU draait.

3.10.3. Interrupt-gestuurde ingang

Polling werkt, maar elke iteratie van de hoofdlus kost CPU-tijd. Voor ingangen die zelden veranderen – een knopdruk eens per minuut, een alarmsignaal – registreert irq() een handler die alleen draait wanneer de pin verandert.

De handler draait in interrupt-context, wat beperkt wat hij kan doen:

  • Geen geheugenallocatie. Het aanmaken van nieuwe objecten – lijsten, strings, excepties, geformatteerde strings – kan mislukken binnen een ISR omdat de heap is vergrendeld. Pre-alloceer eventuele buffers die de handler nodig heeft op moduleniveau.

  • Geen langdurig werk. De handler moet doorgeven en terugkeren. Echte tijd doorbrengen binnen een ISR vertraagt al het andere (andere interrupts, de hoofdlus, USB-verkeer).

  • Niet printen in een strakke ISR. print() alloceert, blokkeert op de UART, en is een van de duurste dingen die een handler kan doen.

Het standaardpatroon is dat de ISR het echte werk inplant via micropython.schedule(), die een functie in de wachtrij zet om terug te draaien in de hoofdcontext op het volgende veilige punt:

import micropython

def handle_press(pin):
    print("button pressed")

def on_press(pin):
    micropython.schedule(handle_press, pin)

button.irq(handler=on_press, trigger=Pin.IRQ_FALLING)

De ISR is één regel: zet de callback in de wachtrij en keer terug. handle_press draait dan in de normale context, waar allocatie, print() en trage I/O allemaal weer veilig zijn.

Het trigger-argument selecteert welke rand afgaat: