ESP32 Tutorial: Taster-Interrupt mit Entprellung

Bei vielen Projekten mit dem ESP32 ist es sinnvoll, bestimmte Aktionen – wie z. B. einen Updatevorgang – nur bei Bedarf und klar getrennt von der eigentlichen Programmlogik auszuführen. Anstatt regelmäßig auf einen Taster zu prüfen, bietet sich die Verwendung eines Interrupts mit Entprellung an.

In diesem Beitrag zeige ich dir, wie du mit MicroPython einen Taster via Interrupt abfragst und dabei eine einfache Zeitprüfung zur Entprellung integrierst. Dadurch wird sichergestellt, dass ein Tasterdruck nicht mehrfach ausgelöst wird, selbst wenn der Kontakt mechanisch prellt.

Dieses Video auf YouTube ansehen.

Die eigentliche Programmlogik – hier symbolisch durch ein einfaches Wechselblinken zweier LEDs dargestellt – läuft dabei unabhängig weiter. So lässt sich der Taster sauber als externer Trigger verwenden, z. B. für einen Updatevorgang, der in einem separaten Beitrag behandelt wird.

Inhaltsverzeichnis

Jeder GPIO kann ein Interruptpin sein
Kompakte Schaltung mit dem ESP32-C3 Super Mini
- Benötigte Teile
Taster per Interrupt anbinden – so geht’s

Jeder GPIO kann ein Interruptpin sein

Einer der großen Vorteile beim ESP32 ist die Flexibilität der verfügbaren GPIOs: Nahezu jeder freie GPIO-Pin kann als Interruptquelle genutzt werden. Im Gegensatz zu manchen älteren Mikrocontroller-Plattformen, bei denen nur bestimmte Pins Interrupts unterstützen, erlaubt der ESP32 in MicroPython die Verwendung beliebiger Eingänge für Interrupts – solange sie nicht durch Sonderfunktionen blockiert sind (z. B. Flash, Boot-Modus etc.).

Das bedeutet konkret: Du kannst deinen Taster einfach an einen freien digitalen Eingang anschließen und diesen Pin mit einer sogenannten Interrupt-Service-Routine (ISR) verknüpfen. Diese ISR wird automatisch aufgerufen, sobald sich der Zustand des Pins ändert – z. B. bei einem Tasterdruck.

Dabei lassen sich verschiedene Triggerarten verwenden:

Pin.IRQ_FALLING → löst aus, wenn das Signal von HIGH auf LOW fällt
(typisch bei Taster mit Pull-Up)
Pin.IRQ_RISING → löst aus, wenn das Signal von LOW auf HIGH wechselt
Pin.IRQ_RISING | Pin.IRQ_FALLING → löst bei jeder Änderung aus
(steigende oder fallende Flanke)

So lässt sich der ESP32 sehr flexibel und effizient steuern – insbesondere bei Projekten, in denen Benutzeraktionen sofort und ohne Verzögerung erkannt werden sollen.

Kompakte Schaltung mit dem ESP32-C3 Super Mini

Für dieses Beispiel verwende ich den ESP32-C3 Super Mini, der sich durch seine kompakte Bauweise und vollständige GPIO-Ausführung besonders gut für einfache Demonstrationsschaltungen eignet. Trotz der geringen Größe stehen alle wichtigen Funktionen des ESP32-C3 zur Verfügung – inklusive Interrupt-Fähigkeit, WLAN und geringem Stromverbrauch.

Natürlich lässt sich dieses Projekt genauso gut mit jedem anderen ESP32-Modul (z. B. DevKitC, NodeMCU oder ESP32-S3) umsetzen. Die Pinbelegung muss lediglich entsprechend angepasst werden.

In der folgenden Schaltung wird ein Taster an GPIO 21 angeschlossen, um per Interrupt einen Befehl auszulösen. Zwei LEDs (blau und grün) sind zusätzlich an GPIO 10 und GPIO 1 angeschlossen und dienen als einfache Aktivitätsanzeige.

Schaltung - ESP32-C3 Mini mit LEDs und Taster über PullUp Widerstand — Schaltung – ESP32-C3 Mini mit LEDs und Taster über PullUp Widerstand

Benötigte Teile

Für den Nachbau dieser kleinen Beispielschaltung brauchst du nur wenige, leicht erhältliche Bauteile. Ideal für Einsteiger und Bastelprojekte:

ESP32 Mikrocontroller*
Zum Beispiel der kompakte ESP32-C3 Super Mini* – andere Varianten funktionieren ebenso.
Printtaster* (12×12 mm)
Ein ganz normaler Drucktaster für Breadboards. Optional mit farbiger Tasterkappe.
Widerstand 10 kΩ*
Als Pull-Up-Widerstand, wenn kein interner genutzt wird oder zur Sicherheit bei mechanisch prellenden Tastern.
Breadboard* (Steckbrett)
Für schnellen und flexiblen Aufbau ohne Löten.
Breadboardkabel* (Dupont-Kabel)
Einige Jumper-Kabel zum Verbinden von Mikrocontroller, Taster und LEDs.

Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung!

Taster per Interrupt anbinden – so geht’s

Die Programmierung eines Taster-Interrupts mit MicroPython ist unkompliziert. Der Taster wird an einen freien GPIO angeschlossen – in diesem Beispiel an GPIO 21 – und anschließend mit einer Interrupt-Service-Routine (ISR) verknüpft:

# Taster an GPIO 21 (z. B. mit externem Pull-Up-Widerstand oder internem PullUp)
taster = Pin(21, Pin.IN)
taster.irq(trigger=Pin.IRQ_FALLING, handler=taster_auswertung)

⚠️ Achte darauf, wie der Taster beschaltet ist!
Damit ein stabiler HIGH-Pegel im Ruhezustand anliegt, ist ein Pull-Up-Widerstand erforderlich. Beim Drücken des Tasters wird der Pin gegen GND gezogen (LOW), wodurch der Interrupt ausgelöst wird.

Du hast zwei Möglichkeiten:

✅ Externer Pull-Up-Widerstand (z. B. 10 kΩ zwischen GPIO und 3.3 V): Sicherste Variante, funktioniert an jedem Pin.
✅ Interner Pull-Up aktivieren (nur wenn der verwendete GPIO dies unterstützt):

taster = Pin(21, Pin.IN, Pin.PULL_UP)

🚫 Aber Vorsicht: Nicht alle GPIOs des ESP32 unterstützen interne Pull-Ups. Prüfe im Datenblatt oder in der GPIO-Referenz deines Moduls, ob der gewählte Pin einen internen Pull-Up unterstützt, bevor du darauf vertraust.

# =============================================
# Titel: Wechselblinkende LEDs und Taster-Interrupt mit Entprellung am ESP32
# Beschreibung:
# In diesem Beispiel wird gezeigt, wie zwei LEDs abwechselnd blinken, 
# während ein Taster über einen Interrupt ausgewertet wird. Eine Entprellung 
# erfolgt softwareseitig durch zeitgesteuerte Prüfung innerhalb der Interruptfunktion.
# 
# Autor: Stefan Draeger
# Webseite: https://draeger-it.blog
# =============================================

from machine import Pin
import time

# Letzter gültiger Tastendruck (für Entprellung)
letzter_ausloeser = 0
sperrzeit_ms = 500  # Mindestabstand zwischen zwei Auslösungen in Millisekunden

# Interrupt-Service-Routine für den Taster
def taster_auswertung(pin):
    global letzter_ausloeser
    aktuelle_zeit = time.ticks_ms()
    
    # Nur auslösen, wenn Sperrzeit überschritten wurde
    if time.ticks_diff(aktuelle_zeit, letzter_ausloeser) > sperrzeit_ms:
        letzter_ausloeser = aktuelle_zeit
        print("Taster gedrückt – Aktion ausgelöst!")

# Taster an GPIO 21 (z. B. mit externem Pull-Up-Widerstand oder internem PullUp)
taster = Pin(21, Pin.IN)
taster.irq(trigger=Pin.IRQ_FALLING, handler=taster_auswertung)

# LEDs an GPIO 10 und GPIO 1
led_blau = Pin(10, Pin.OUT)
led_gruen = Pin(1, Pin.OUT)

# Intervall für das Wechselblinken in Millisekunden
blink_intervall = 500

# Startzustand für Blinksteuerung
letzter_wechsel = time.ticks_ms()
zustand = False  # False = LED blau an, grün aus

# Hauptprogramm
while True:
    aktuelle_zeit = time.ticks_ms()
    
    # Wechseln, wenn Intervall abgelaufen ist
    if time.ticks_diff(aktuelle_zeit, letzter_wechsel) > blink_intervall:
        zustand = not zustand
        led_blau.value(zustand)
        led_gruen.value(not zustand)
        letzter_wechsel = aktuelle_zeit

    # Kurze Pause, um CPU-Auslastung zu reduzieren (nicht blockierend)
    time.sleep(0.05)