Taster mit Callback Funktion beim Raspberry Pi

Importieren der Bibliotheken

Zunächst wird die, für die Ausführung des folgenden Codes erforderlichen Bibliothek RPI.GPIO zum einfacheren Ansprechen mit der Klausel as als simpleres GPIO importiert.

import RPi.GPIO as GPIO

Anschließend wird die Konvention für das verwendete Bezeichnungsschema festgelegt. Wir verwenden das häufiger benutze BCM-Schema.

GPIO.setmode(GPIO.BCM)

Pull Down Widerstand

Da der Taster an einer Seite mit einem dauerhaften 3,3 V Pin des Raspberry Pis verbunden ist, ist es nur erforderlich einen einzelnen Pin Softwareseitig abzufragen. In unserem Beispiel verwenden wir dafür BCM-Pin 23. Dieser wird als Eingang definiert.
Im Unterschied zu dem vorangegangenen Artikel der LED gibt es einen Unterschied: Es wird ein, in der Hardware des Raspberry Pi eingebauter Pull-Down-Widerstand zwischen dem Pin und Masse mit dem Parameter pull_up_down = GPIO.PUD_DOWN gesetzt. Da der Taster den Stromkreis standartmäßig nur in dem Moment schließt, in welchem er mechanisch betätigt wird, hängt der Part bis zum BCM-Pin 23 „in der Luft“. Es liegt kein definiertes Spannungsniveau an, bis auf dem Moment der Betätigung. Dies führt dazu, dass von der Leitung Spannungen des umliegendes Elektromagnetfeldes wie durch eine Antenne aufgenommen werden. Dabei kann es zu dem Umstand kommen, dass der Wert des BCM-Pins 23 zwischen den Wert

GPIO.setup(23, GPIO.IN, pull_up_down = GPIO.PUD_DOWN)

Nun folgt der Teil des Programms, der Ausgeführt werden soll, wenn der Taster betätigt wird. Dazu deklarieren wir uns eine Funktion. Dies erfolgt in Python nach folgender Syntax:
def funktionsname(Parameterliste):
…

Callback Funktion

In unserem Fall soll der Taster lediglich den Satz „Interrupt aufgerufen durch Pin 23“ in der Python Shell bzw. Konsole hervorrufen. Als Parameter wird die Variable pin in die Runde Klammer der Funktion callback_funktion platziert. Diese wird später von dem Interrupt Handler übergeben.

def callback_funktion(pin):
    print("Interrupt aufgerufen durch Pin ", pin)

Signalflanken eines Tasters

Wird ein Taster mechanisch betätigt, sinkt der Widerstand, der durch den Abstand der Kontakte gegeben ist. Durch diesen Umstand springt der Strom nicht zwischen den Zuständen High und Low, sondern in einem steigendenden Übergang, bis sich die Kontakte gänzlich berühren. Ebenso tritt dieser Effekt umgekehrt beim Loslassen des Tasters auf. Es wird von steigenden bzw. fallenden (Signal-)Flanken gesprochen. In der Zeit des Übergangs ist der Zustand nicht definiert. Auch tritt dabei eine kleine Totzeit auf, die das Signal zeitlich ein wenig verschiebt.

Interrupt Handling

Ein Interrupt ist eine vorübergehende Unterbrechung des laufenden Programms zu Gunsten eines anderes Programmteils, welcher während dessen ausgeführt wird. Diese klassische Definition ist in unserem Fall allerdings nicht ganz korrekt. Es wird zwar ein anderer Programmteil, die callback_funktion ausgeführt. Jedoch als so genannter Thread parallel zum laufenden Programmcode (Mehr zum Thema Threading hier).
Der Interrupt-Handler wird durch die Methode (Funktion) GPIO.add_event_detect() dargestellt. Die Parameter lauten:

GPIO.add_event_detect(
    23,
    GPIO.RISING,
    callback = callback_funktion,
    bouncetime = 200)

Die 23 steht dabei für den Pin, an welchem das Signal abgefragt werden soll.
Eine steigende Flanke wird mit dem nächsten Parameter GPIO.RISING abgefragt.
Mit dem Parameter callback wird die, zuvor deklarierte, Funktion callback_funktion aufgerufen.
Schließlich ist eine bouncetime von 200 Millisekunden definiert. Diese entprellt den Taster. Ein Störeffekt, der beim Betätigen kurzzeitig ein mehrfaches Schließen und Öffnen des Kontakts hervorruft. So werden nach der ersten steigenden Flanke, alle weiteren in einem Zeitfenster von 200 Millisekunden ignoriert.

Der Code in seiner vollen Gänze

# Erforderliche Bibliotheken importieren
import RPi.GPIO as GPIO

# try-except Ausnahme, die bei der Tastenkombination [Strg] + [C]
# verwendete Pins zurücksetzt und Warnmeldung beim Neustart vermeidet
try:
    # Konvention für Pinnummerierung festlegen (BCM bzw. Board)
    GPIO.setmode(GPIO.BCM)
    # Pin 23 als Eingangspin deklarieren. Pull-Up-Widerstand einschalten,
    # um Störsignale zu filtern
    GPIO.setup(23, GPIO.IN, pull_up_down = GPIO.PUD_DOWN)

    # Funktion mit dem Parameter "pin" (Pin 23) erstellen
    # Funktionen werden erst beim Aufrufen ausgeführt
    def callback_funktion(pin):
        print("Interrupt aufgerufen durch Pin ", pin)

    # Interrupt-Handler
    GPIO.add_event_detect(
        23,
        GPIO.RISING,
        callback = callback_funktion,
        bouncetime = 200)
except KeyboardInterrupt:
    GPIO.cleanup()

Bildquellen