3.10. GPIO-ingång

Att läsa en strömställare (eller vilken digital signal som helst) från ett GPIO-stift går återigen genom machine.Pin, denna gång konfigurerad som ingång. Gränssnittet är symmetriskt med utgång: konfigurera läget och avsök sedan antingen stiftets värde i huvudslingan eller registrera en avbrottshanterare som utlöses när värdet ändras.

3.10.1. Konfigurera en ingång

Skicka Pin.IN till konstruktorn, och valfritt ett pull-motstånd:

from machine import Pin

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

Det konfigurerar P0 som en ingång med MCU:ns interna pull-up-motstånd aktiverat. Utan något anslutet till stiftet håller pull-up:en det högt; att sluta en strömställare från stiftet till jord drar det lågt.

3.10.2. Läsa värdet

value() utan argument returnerar det aktuella tillståndet – 0 för lågt, 1 för högt:

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

I huvudslingemönstret ser avsökningen ut så här:

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

Vilan på 50 ms hindrar slingan från att köra på full CPU.

3.10.3. Avbrottsdriven ingång

Avsökning fungerar, men varje iteration av huvudslingan kostar CPU-tid. För ingångar som ändras sällan – en knapptryckning en gång i minuten, en larmsignal – registrerar irq() en hanterare som körs endast när stiftet ändras.

Hanteraren körs i avbrottskontext, vilket begränsar vad den kan göra:

  • Ingen minnesallokering. Att skapa nya objekt – listor, strängar, undantag, formaterade strängar – kan misslyckas inuti en ISR eftersom heapen är låst. Förallokera alla buffertar hanteraren behöver på modulnivå.

  • Inget långvarigt arbete. Hanteraren bör lämna över och returnera. Att spendera verklig tid inuti en ISR fördröjer allt annat (andra avbrott, huvudslingan, USB-trafik).

  • Ingen utskrift i en snäv ISR. print() allokerar, blockerar på UART:en och är en av de mest kostsamma sakerna en hanterare kan göra.

Standardmönstret är att ISR-rutinen schemalägger det verkliga arbetet via micropython.schedule(), som köar en funktion att köra tillbaka i huvudkontexten vid nästa säkra punkt:

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)

ISR-rutinen är en rad: köa återanropet och returnera. handle_press körs sedan i normal kontext, där allokering, print() och långsam I/O alla är säkra igen.

Argumentet trigger väljer vilken kant som utlöser: