Der ESP32 lässt sich nicht nur sehr komfortabel in der Arduino IDE mit C/C++ programmieren, sondern unterstützt ebenso MicroPython – eine moderne und leicht verständliche Programmiersprache, mit der sich sowohl kleine Experimente als auch größere Projekte schnell und übersichtlich umsetzen lassen.
Gerade die Hardware-Funktionen des ESP32 werden in MicroPython sehr gut unterstützt. Dazu zählen unter anderem GPIOs, ADCs, PWM-Ausgänge – und auch die kapazitiven Touch-Pins. Viele Abläufe, die in C/C++ etwas mehr Boilerplate erfordern, lassen sich in MicroPython mit deutlich weniger Code realisieren.
ESP32 Touch mit MicroPython: Schalten & Steuern ohne Taster
In diesem Beitrag knüpfen wir an die vorherigen Touch-Beispiele an und setzen diese konsequent in MicroPython um. Als Einstieg zeige ich dir zunächst, wie sich zwei LEDs per Touch umschalten lassen – ganz ohne mechanischen Taster. Dabei nutzen wir dieselbe Logik wie zuvor: Touch als Ereignis, Statusverwaltung im Code und ein Zeitfenster, um Mehrfachauslösungen zu vermeiden.
Das Beispiel ist bewusst einfach gehalten und eignet sich ideal, um ein Gefühl für Touch-Eingaben in MicroPython zu bekommen und diese anschließend auf eigene Projekte zu übertragen.
Bevor wir den ESP32 mit MicroPython programmieren können, muss zunächst die passende MicroPython-Firmware auf den Mikrocontroller geflasht werden. Wie dieser Schritt beim ESP32 im Detail durchgeführt wird, habe ich bereits in einem separaten Beitrag ausführlich beschrieben: MicroPython mit dem ESP32 – Einführung in den ESP32 D1 R32
Dort zeige ich Schritt für Schritt, wie die Firmware installiert wird und wie du den ESP32 anschließend per USB ansprechen kannst.
Solltest du später wieder zurück zur Arduino IDE wechseln wollen, ist das erfreulich unkompliziert. In folgendem Beitrag erkläre ich, wie du MicroPython mit nur einem Schritt entfernst und den ESP32 wieder ganz normal mit Arduino programmierst: ESP32: Zurück von MicroPython zur Arduino IDE – in nur einem Schritt
Damit kannst du jederzeit flexibel zwischen beiden Entwicklungsumgebungen wechseln.
Aufbau der Schaltung
Für dieses Beispiel bleibt der Hardware-Aufbau vollständig unverändert. Wir wechseln lediglich die Programmiersprache von C/C++ (Arduino IDE) zu MicroPython – die elektrischen Eigenschaften und Funktionen der GPIOs des ESP32 ändern sich dadurch nicht.
Touch-Pins, digitale Ausgänge für LEDs sowie analoge Eingänge verhalten sich hardwareseitig identisch, unabhängig davon, ob der ESP32 mit Arduino-Code oder mit MicroPython programmiert wird. Das bedeutet: Wenn du die Schaltung bereits aus dem vorherigen Arduino-Beispiel aufgebaut hast, kannst du sie ohne Anpassungen weiterverwenden.
Touchpins am Wemos D1 R32Touchpins am ESP32-WROOM-32D Mikrocontroller
Gerade dieser Punkt macht MicroPython besonders attraktiv für Experimente: Die Hardware bleibt gleich, während sich Logik und Code sehr schnell anpassen oder erweitern lassen.
Benötigte Komponenten
Für den Aufbau der Schaltung verwende ich folgende Komponenten:
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!
Es gibt ESP32-Module (z. B. ESP-WROOM-32D), die breiter als ein einzelnes 400-Pin Breadboard sind. Je nach Ausführung passen sie entweder gar nicht oder blockieren eine komplette Pinreihe. In diesem Fall ist es sinnvoll, zwei Breadboards nebeneinander zu verwenden, um alle Pins weiterhin bequem erreichen zu können (siehe Grafik).
ESP-WROOM-32D auf 400 Pin Breadboard
Pinbelegung der Schaltung
Funktion
ESP32 Pin
Hinweis
Touch-Eingang
GPIO 4
Touch-Pin T0
LED (blau)
GPIO 18
Digitaler Ausgang
LED (grün)
GPIO 19
Digitaler Ausgang
50 kOhm Drehpotentiometer
GPIO35
Analoger Eingang
GND
GND
Gemeinsame Masse
Versorgung
5 V / USB
Über Micro-USB
Schaltung – ESP32 mit Touchfunktion – wechselschalten von zwei LEDs
MicroPython: LEDs per Touch umschalten
In MicroPython wird der Touch-Pin über TouchPad(Pin(...)) angesprochen. Anders als bei einem Taster liefert der Pin keinen festen Zustand, sondern einen Messwert. Sobald dieser Wert unter einen Schwellwert fällt, interpretieren wir das als Touchevent.
Damit eine Berührung nicht mehrfach hintereinander erkannt wird, setzen wir – wie im Arduino-Beispiel – ein Zeitfenster (Pause). Erst wenn dieses abgelaufen ist, wird ein neuer Touch akzeptiert.
Erstes Beispiel: Touch-Pin in MicroPython auslesen
Bevor wir mit Schwellwerten, LEDs oder Zustandslogik arbeiten, schauen wir uns zuerst an, welche Werte ein Touch-Pin überhaupt liefert. Denn – genau wie in der Arduino-IDE – gibt der ESP32 auch in MicroPython keinen festen „Touch = true/false“-Zustand zurück, sondern einen Messwert, der von der kapazitiven Veränderung abhängt.
Dieses Minimalbeispiel liest einen Touch-Pin zyklisch aus und gibt den aktuellen Wert über die serielle Schnittstelle aus. So bekommst du ein Gefühl dafür, wie sich Berührungen, Annäherungen oder unterschiedliche Touchflächen auf den Messwert auswirken.
MicroPython: Touch-Wert auslesen
from machine import TouchPad, Pin
import time
# Touch-Pin initialisieren (T0 = GPIO4)
touch = TouchPad(Pin(4))
while True:
value = touch.read()
print("Touch-Wert:", value)
time.sleep(0.2)
Der Code erzeugt die Ausgabe in der Shell welche den gelesenen kapazitiven Wert vom Touchpin wiederspiegelt. Dieser ändert sich je nachdem wo wir am verbundenen Draht anfassen und wie der eigene Körper geerdet ist.
Thonny – Micropython mit ESP32 – Ausgabe der Touch-Werte
Quellcode – Touch als Schalter (Toggle) für zwei LEDs
Der Touch-Pin des ESP32 liefert keinen festen Ein/Aus-Zustand, sondern einen Messwert, der sich je nach Berührung und Aufbau verändert. Um flexibel festzulegen, ab welchem Wert ein Touchevent erkannt wird, verwende ich ein Drehpotentiometer.
verschiedene Drehpotentiometer
Das Potentiometer liefert einen ADC-Wert zwischen 0 und 4095, der im Code auf den typischen Touch-Wertebereich umgerechnet wird. So lässt sich der Schwellwert jederzeit per Dreh einstellen – ohne den Code neu flashen zu müssen.
from machine import Pin, TouchPad, ADC
import time
# -----------------------------
# Pinbelegung
# -----------------------------
LED_BLAU_PIN = 18
LED_GRUEN_PIN = 19
TOUCH_PIN = 4 # T0 (GPIO4) beim ESP-WROOM-32
POTI_PIN = 35 # ADC (GPIO35)
# -----------------------------
# Wertebereiche (ggf. anpassen)
# -----------------------------
TOUCH_MIN = 0
TOUCH_MAX = 1600
ADC_MIN = 0
ADC_MAX = 4095 # MicroPython ADC liefert meist 0..4095
# -----------------------------
# Hardware-Setup
# -----------------------------
led_blau = Pin(LED_BLAU_PIN, Pin.OUT)
led_gruen = Pin(LED_GRUEN_PIN, Pin.OUT)
touch = TouchPad(Pin(TOUCH_PIN))
adc = ADC(Pin(POTI_PIN))
# Optional (je nach Firmware/Port verfügbar):
# adc.atten(ADC.ATTN_11DB) # Messbereich bis ca. 3.3V
# adc.width(ADC.WIDTH_12BIT) # 0..4095
# -----------------------------
# Timing / Entprellung
# -----------------------------
PAUSE_MS = 500
last_action = time.ticks_ms()
# Status: False -> grün aktiv, True -> blau aktiv
active = False
led_gruen.value(1)
led_blau.value(0)
def map_value(x, in_min, in_max, out_min, out_max):
"""Einfaches Mapping wie Arduino map()."""
if x < in_min:
x = in_min
if x > in_max:
x = in_max
return int((x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min)
# -----------------------------
# Loop
# -----------------------------
while True:
touch_value = touch.read() # Touch-Messwert
poti_raw = adc.read() # ADC-Rohwert (0..4095)
threshold = map_value(poti_raw, ADC_MIN, ADC_MAX, TOUCH_MIN, TOUCH_MAX)
now = time.ticks_ms()
# Debug-Ausgaben (hilft beim Einstellen)
print("Touch:", touch_value, "| Poti:", poti_raw, "| Threshold:", threshold)
# Touch erkannt + Pause eingehalten?
if (touch_value is not None) and (touch_value < threshold) and (time.ticks_diff(now, last_action) > PAUSE_MS):
last_action = now
active = not active # Toggle
led_blau.value(1 if active else 0)
led_gruen.value(0 if active else 1)
time.sleep_ms(50)
Fazit
Mit MicroPython lassen sich die kapazitiven Touch-Pins des ESP32 schnell, übersichtlich und praxisnah einsetzen. Die Beispiele in diesem Beitrag zeigen, dass Touch weit mehr ist als ein netter Zusatz: Mit etwas Logik im Code wird daraus ein vollwertiges Eingabekonzept – ganz ohne mechanische Taster.
Besonders hilfreich ist dabei die Kombination aus Messwert + einstellbarem Schwellwert. Da Touch-Werte stark vom Aufbau, der Touchfläche und sogar von der eigenen Erdung abhängen, ist ein per Drehpotentiometer anpassbarer Schwellwert deutlich robuster als eine fest im Code hinterlegte Zahl. Genau hier spielt MicroPython seine Stärke aus: Änderungen lassen sich schnell testen, anpassen und erweitern.
Das Umschalten von LEDs per Touch zeigt anschaulich, wie sich Zustände verwalten lassen, während das einfache Auslesen des Touch-Pins ein gutes Gefühl für die gelieferten Messwerte vermittelt. Diese Grundlagen sind essenziell, um Touch später zuverlässig in größeren Projekten einzusetzen.
In den nächsten Schritten lassen sich die gezeigten Konzepte problemlos erweitern – etwa um:
mehrere Touchflächen mit unterschiedlichen Funktionen
Touch-Menüs oder Gesten
die Kombination mit Displays, Motoren oder Sensoren
Touch-Eingaben am ESP32 sind damit keine Spielerei, sondern eine ernstzunehmende Alternative zu klassischen Tastern – besonders für kompakte, robuste oder minimalistische Projekte. MicroPython macht den Einstieg dabei angenehm einfach und lädt zum Experimentieren ein.
FAQ – Häufige Fragen zur ESP32 Touch-Steuerung mit MicroPython
Welche ESP32-Modelle unterstützen kapazitive Touch-Pins?
Nicht alle ESP32-Varianten verfügen über Touch-Hardware. Kapazitive Touch-Pins sind nur bei bestimmten Modellen vorhanden, z. B. beim ESP-WROOM-32 oder ESP32-S2. Varianten wie ESP32-C3, ESP32-S3 oder ESP32-H2 besitzen keine integrierten Touch-Pins. In diesen Fällen lassen sich Touch-Funktionen nur über externe Touch-Controller oder alternative Eingabekonzepte umsetzen.
Liefert ein Touch-Pin ein echtes Ein/Aus-Signal?
Nein. Der ESP32 liefert keinen digitalen Touch-Zustand, sondern einen Messwert, der sich durch kapazitive Veränderungen ändert. Erst durch den Vergleich mit einem Schwellwert entscheidest du im Code, ob ein Touchevent vorliegt oder nicht.
Warum schwanken die Touch-Werte so stark?
Touch-Werte hängen von mehreren Faktoren ab, unter anderem:
Größe und Form der Touchfläche
Länge und Material des angeschlossenen Drahts
Erdung des Körpers (z. B. Schuhe, Untergrund)
Umgebungseinflüsse
Diese Schwankungen sind normal und kein Fehler. Genau deshalb ist ein einstellbarer Schwellwert so wichtig.
Warum verwende ich ein Drehpotentiometer für den Schwellwert?
Ein fest im Code definierter Schwellwert funktioniert oft nur unter idealen Bedingungen. Mit einem Drehpotentiometer kannst du den Schwellwert zur Laufzeit anpassen, ohne den Code neu flashen zu müssen. Das macht die Touch-Erkennung deutlich robuster – besonders bei wechselnden Nutzern oder Umgebungen.
Kann ich mehrere Touch-Pins gleichzeitig verwenden?
Ja, das ist problemlos möglich – sofern dein ESP32-Modell genügend Touch-Pins bereitstellt. Jeder Touch-Pin liefert einen eigenen Messwert und kann unabhängig ausgewertet werden, z. B. für:
Mehrstufige Eingaben
Vor / Zurück
Menü-Navigation
Ist Touch in MicroPython langsamer oder ungenauer als in der Arduino IDE?
Nein. Die Touch-Messung erfolgt hardwareseitig im ESP32. Ob du Arduino (C/C++) oder MicroPython verwendest, hat keinen Einfluss auf die Messgenauigkeit. MicroPython macht den Code lediglich kompakter und leichter verständlich.
Kann ich Touch-Pins mit anderen Funktionen kombinieren?
Teilweise. Einige Touch-Pins sind gleichzeitig GPIOs, können aber durch Touch-Funktionen oder Boot-Strapping eingeschränkt sein. Vor allem bei fertigen Development-Boards solltest du prüfen, ob ein Touch-Pin bereits anderweitig belegt ist.
Eignet sich Touch für produktive Projekte oder nur für Experimente?
Touch eignet sich sehr gut für produktive Projekte, wenn:
Schwellwerte sauber gewählt sind
Entprellung bzw. Zeitfenster genutzt werden
ausreichend große Touchflächen vorhanden sind
Gerade für kompakte Gehäuse, einfache Bedienkonzepte oder Projekte ohne mechanische Teile ist Touch eine sehr robuste Lösung.
Wie kann ich die Touch-Erkennung weiter verbessern?
Bewährte Maßnahmen sind:
größere Touchflächen (z. B. Kupfer, Alufolie, Leiterflächen)
Wir verwenden Technologien wie Cookies, um Geräteinformationen zu speichern und/oder darauf zuzugreifen. Wir tun dies, um das Surferlebnis zu verbessern und um personalisierte Werbung anzuzeigen. Wenn Sie diesen Technologien zustimmen, können wir Daten wie das Surfverhalten oder eindeutige IDs auf dieser Website verarbeiten. Wenn Sie Ihre Zustimmung nicht erteilen oder zurückziehen, können bestimmte Funktionen beeinträchtigt werden.
Funktional
Immer aktiv
Die technische Speicherung oder der Zugang ist unbedingt erforderlich für den rechtmäßigen Zweck, die Nutzung eines bestimmten Dienstes zu ermöglichen, der vom Teilnehmer oder Nutzer ausdrücklich gewünscht wird, oder für den alleinigen Zweck, die Übertragung einer Nachricht über ein elektronisches Kommunikationsnetz durchzuführen.
Vorlieben
Die technische Speicherung oder der Zugriff ist für den rechtmäßigen Zweck der Speicherung von Präferenzen erforderlich, die nicht vom Abonnenten oder Benutzer angefordert wurden.
Statistiken
Die technische Speicherung oder der Zugriff, der ausschließlich zu statistischen Zwecken erfolgt.Die technische Speicherung oder der Zugriff, der ausschließlich zu anonymen statistischen Zwecken verwendet wird. Ohne eine Vorladung, die freiwillige Zustimmung deines Internetdienstanbieters oder zusätzliche Aufzeichnungen von Dritten können die zu diesem Zweck gespeicherten oder abgerufenen Informationen allein in der Regel nicht dazu verwendet werden, dich zu identifizieren.
Marketing
Die technische Speicherung oder der Zugriff ist erforderlich, um Nutzerprofile zu erstellen, um Werbung zu versenden oder um den Nutzer auf einer Website oder über mehrere Websites hinweg zu ähnlichen Marketingzwecken zu verfolgen.
