Wenn du am Cheap Yellow Display mehrere Taster anschließen möchtest, aber keine freien GPIOs mehr zur Verfügung hast, gibt es eine elegante Lösung: Du kannst mehrere Taster an nur einem einzigen GPIO betreiben – mithilfe einer Widerstandsleiter und dem ADC des verbauten ESP32.
Im letzten Beitrag habe ich dir gezeigt, wie du die freien GPIOs auf der Rückseite des Cheap Yellow Display (ESP32-2432S028) nutzt, um externe Taster direkt anzuschließen und per INPUT_PULLUP auszuwerten.
Doch gerade bei komplexeren Projekten – etwa mit Menüführung, mehreren Funktionen oder zusätzlicher Hardware – reichen diese freien Pins oft nicht mehr aus. Spätestens dann stellt sich die Frage: Wie lassen sich weitere Taster anschließen, ohne zusätzliche Hardware wie Portexpander oder I²C-Module einzusetzen?
In diesem Beitrag zeige ich dir eine elegante Lösung:
Mit einer sogenannten Widerstandsleiter lassen sich mehrere Taster an nur einem einzigen GPIO betreiben. Konkret schließen wir fünf Taster an den Analog-Pin GPIO35 des ESP32 an und werten die unterschiedlichen Spannungspegel im Programm aus.
So kannst du die Anzahl der Eingabetaster deutlich erhöhen, ohne zusätzliche Hardware wie Portexpander oder I²C-Erweiterungen einsetzen zu müssen.
Wichtiger Hinweis: Die hier gezeigte Schaltung funktioniert nicht nur am Cheap Yellow Display.
Du kannst dieses Prinzip mit der Widerstandsleiter grundsätzlich bei jedem ESP32 einsetzen – ebenso bei einem Arduino (z. B. Nano oder UNO) oder einem Raspberry Pi Pico, sofern ein analoger Eingang (ADC) vorhanden ist.
Das Konzept ist also nicht auf das CYD beschränkt, sondern lässt sich universell in vielen Mikrocontroller-Projekten verwenden.
Prinzip: Mehrere Taster an einem Analog-Pin (Widerstandsleiter)
Der ESP32 kann viele seiner GPIOs nicht nur digital, sondern auch als Analog-Eingang (ADC) verwenden. Genau diese Eigenschaft machen wir uns zunutze.
Das Grundprinzip ist einfach:
- Am ADC-Pin liegt eine Referenzspannung von 3,3 V an.
- Jeder Taster schaltet einen anderen Widerstand in einen Spannungsteiler.
- Dadurch entsteht – je nach gedrücktem Taster – eine unterschiedliche Spannung am Analog-Pin.
- Diese Spannung wird mit
analogRead()als Zahlenwert eingelesen und kann im Programm eindeutig ausgewertet werden.
So lassen sich – abhängig von Widerstandswerten und Toleranzen – typischerweise 3 bis 8 Taster an nur einem einzigen GPIO betreiben.
Die grundsätzliche Idee inklusive Schaltungsbeispiel habe ich bereits hier ausführlich erklärt:
https://draeger-it.blog/arduino-lektion-115-mehrere-taster-an-einem-analogen-pin-betreiben/
Wichtige Hinweise für den ESP32 / das Cheap Yellow Display
Bevor wir zur konkreten Schaltung kommen, sind einige Punkte wichtig:
- Der ESP32 arbeitet mit 3,3 V Logik.
Es dürfen keine 5 V an den ADC-Pin angelegt werden. - Nutze einen ADC-fähigen GPIO.
Nicht jeder Pin des ESP32 kann analog gelesen werden. - Plane Toleranzen ein.
Widerstände mit 1 % Toleranz liefern stabilere Ergebnisse als 5 %-Typen.
Zusätzlich solltest du im Code mit Schwellwert-Bereichen (Fenstern) arbeiten. - Werden mehrere Taster gleichzeitig gedrückt, entstehen Mischspannungen.
Das Konzept funktioniert daher am besten nach dem Prinzip:
👉 „Immer nur ein Taster gleichzeitig“.
Am Cheap Yellow Display liegt an den Pins neben den GPIOs auch eine 3,3 V-Versorgung an. Diese kann direkt für den Spannungsteiler genutzt werden.
Schaltung: 5 Taster an einem ADC-Pin (GPIO35)
Grundaufbau
Wir erzeugen am ADC-Pin unterschiedliche Spannungen, abhängig davon, welcher Taster gedrückt wird.
Der Aufbau erfolgt über einen klassischen Spannungsteiler:
Jeder Taster besitzt einen anderen Widerstandswert nach GND.
Dadurch entsteht je nach gedrücktem Taster eine andere Spannung – und somit ein anderer ADC-Wert.
Formel des Spannungsteilers
Die Spannung am ADC-Pin berechnet sich nach der bekannten Formel:
Dabei gilt:
- R1 = Widerstand oben (zwischen 3,3 V und ADC-Knoten, z. B. Pullup)
- R2 = Widerstand unten (zwischen ADC-Knoten und GND – je nach gedrücktem
- Vin = Eingangsspannung (bei uns 3,3 V)
Konkrete Verdrahtung am ESP32 / Cheap Yellow Display
Nachdem wir das Prinzip der Widerstandsleiter verstanden haben, schauen wir uns nun den konkreten Aufbau an.
Wir verwenden:
- GPIO35 als Analog-Eingang (ADC)
- die 3,3 V-Versorgung des Boards
- einen festen Pullup-Widerstand von 10 kΩ
- fünf Taster mit unterschiedlichen Widerständen nach GND
- Taster 1 – 18 kOhm
- Taster 2 – 10 kOhm
- Taster 3 – 4,7 kOhm
- Taster 4 – 2,2 kOhm
- Taster 5 – 1 kOhm
Die Schaltung können wir fast beliebig erweitern und damit mehr als die hier verwendetne 5 Taster anschließen.
Anschlusskabel für das Cheap Yellow Display
Wie erwähnt liegt dem Cheap Yellow Display ein Anschlusskabel bei, für die Schaltung benötigen wir jedoch zwei Kabel da wir die 3.3V vom anderen Sockel abgreifen müssen.
Diese Kabel gibt es günstig bei zbsp. Aliexpress.com jedoch dort mit langer Lieferzeit, wenn du wie ich nicht so lange warten möchtest so kannst du dieses für „ein paar Euro mehr“ bei Amazon.de kaufen.
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!
In meinem Fall habe ich das Anschlusskabel mit einer Seite mit offenen Kontakten gewählt und mit eine kleine Lochrasterplatine mit 90° 4Pin Steckerleiste und 4fach Schraubklemme einen kleinen Adapter gebaut. Leider habe ich kein Kabel gefunden welches auf Breadboardstecker oder Buchse geht.
Programmieren der Taster / auslesen der analogen Werte
Wie man einen Taster digital also 1/0 HIGH/LOW kanst du mit der Funktion digitalRead auslesen. Für unseren Fall benötigen wir jedoch den analogen Wert welcher zwischen 0 und 4095 liegt. Je nach Taster schwankt dieser in einer Range welche wir später beachten müssen.
#define pin 35
void setup() {
Serial.begin(9600);
analogReadResolution(12);
analogSetAttenuation(ADC_11db);
}
void loop() {
int analogValue = analogRead(pin);
if (analogValue > 0) {
Serial.print("analogValue: ");
Serial.println(analogValue);
}
delay(50);
}
Im seriellen Monitor wird hier der Wert ausgegeben welcher am aktuellen ADC Pin 35 anliegt. Der GPIO35 ist ein reiner INPUT Pin und am Cheap Yellow Display der einzige Pin welcher dafür verwendet werden kann.
Taster auswerten
Nachdem wir die Werte bzw. die Range der Taster ermittelt haben, erzeugen wir uns daraus ein kleines Objekt wo wir diese speichern können.
struct Taster {
int min_analog;
int max_analog;
const char* bezeichnung;
};
In meinem Fall haben sich folgende Werte ergeben welche ich gleich in ein Array zusammenfassen.
Taster taster[] = {
{1220, 1240, "Taster 1"},
{1780, 1800, "Taster 2"},
{2490, 2600, "Taster 3"},
{3100, 3120, "Taster 4"},
{3660, 3675, "Taster 5"}
};
Du könntest die Zuweisung auch deutlich lesbarer gestalten indem du die Werte den Variablen des strucs einen Taster-Objekts zuweist und später zu einem Array zusammenführst:
Taster taster1 = {1220, 1240, "Taster 1"};
Taster taster[] = { taster1, ...};
Mittelwert berechnen
Da der Wert am ADC wie du aus der obigen Ausgabe sehen kannst sehr schwankt bilden wir hier aus 10 Werten den Mittelwert.
// Mittelwertbildung für stabilere ADC-Werte
int average() {
long sum = 0;
for (int i = 0; i < 10; i++) {
sum += analogRead(pin);
delay(2);
}
return sum / 10;
}
Daraus ergibt sich dann in meinem Fall folgende Werte, bei dir können bzw. werden diese Werte sich unterscheiden da hier min. zwei Faktoren einfließen:
- Stabilität der 3.3V,
- Toleranz der Widerstände und deren Werte
| Taster | R2 (nach GND) | ADC-Wert (0–4095) |
|---|---|---|
| T1 | 18 kΩ | ~1225 |
| T2 | 10 kΩ | ~1785 |
| T3 | 4,7 kΩ | ~2502 |
| T4 | 2,2 kΩ | ~3111 |
| T5 | 1 kΩ | ~3666 |
| keiner | — | 0 |
/*
------------------------------------------------------------
Mehr als vier Taster am ESP32 / Cheap Yellow Display
------------------------------------------------------------
Beschreibung:
In diesem Beispiel werden fünf Taster über eine Widerstands-
leiter an nur einem einzigen ADC-Pin (GPIO35) des ESP32
betrieben. Je nach gedrücktem Taster entsteht eine
unterschiedliche Spannung am Analog-Eingang, die im Code
ausgewertet wird.
Die Erkennung erfolgt über definierte ADC-Wertebereiche
(Fenster). Zusätzlich wird ein Mittelwert aus mehreren
Messungen gebildet, um ADC-Schwankungen zu reduzieren.
Wichtig:
- Externer 10k Pullup-Widerstand erforderlich
- Nur 3,3V verwenden (keine 5V am ADC!)
- GPIO35 ist ein reiner INPUT-Pin
Autor:
Stefan Draeger
Ausführlicher Blogartikel:
https://draeger-it.blog/mehr-als-vier-taster-am-cheap-yellow-display-so-nutzt-du-nur-einen-gpio/
------------------------------------------------------------
*/
#define pin 35 // ADC-Pin (GPIO35 ist input-only)
struct Taster {
int min_analog;
int max_analog;
const char* bezeichnung;
};
// ADC-Fenster (aus realen Messwerten ermittelt)
Taster taster[] = {
{1220, 1240, "Taster 1"},
{1780, 1800, "Taster 2"},
{2490, 2600, "Taster 3"},
{3100, 3120, "Taster 4"},
{3660, 3675, "Taster 5"}
};
const int ANZAHL_TASTER = sizeof(taster) / sizeof(taster[0]);
const int NO_PRESS_THRESHOLD = 200; // darunter: kein Tastendruck (ggf. anpassen)
// Mittelwertbildung für stabilere ADC-Werte
int average() {
long sum = 0;
for (int i = 0; i < 10; i++) {
sum += analogRead(pin);
delay(2);
}
return sum / 10;
}
const char* lastButton = nullptr;
void setup() {
Serial.begin(115200);
// ESP32 ADC konfigurieren (12 Bit: 0–4095, 11dB: ca. 0–3.3V Bereich)
analogReadResolution(12);
analogSetAttenuation(ADC_11db);
}
void loop() {
int analogValue = average();
// Kein Tastendruck → Status zurücksetzen
if (analogValue < NO_PRESS_THRESHOLD) {
lastButton = nullptr;
delay(50);
return;
}
const char* currentButton = nullptr;
int minV = 0, maxV = 0;
// Passenden Taster anhand des Fensters finden
for (int i = 0; i < ANZAHL_TASTER; i++) {
if (analogValue >= taster[i].min_analog && analogValue <= taster[i].max_analog) {
currentButton = taster[i].bezeichnung;
minV = taster[i].min_analog;
maxV = taster[i].max_analog;
break;
}
}
// Ausgabe nur bei Wechsel (verhindert Spam im seriellen Monitor)
if (currentButton && currentButton != lastButton) {
Serial.print(currentButton);
Serial.print("\t|\t(");
Serial.print(minV);
Serial.print(" - ");
Serial.print(maxV);
Serial.print(")\t|\t");
Serial.println(analogValue);
lastButton = currentButton;
}
delay(50);
}
Im seriellen Monitor wird neben der Bezeichnung des erkannten Tasters auch der definierte Wertebereich (Range) sowie der aktuell gemessene ADC-Wert ausgegeben. Dabei handelt es sich um den zuvor gebildeten Durchschnittswert aus mehreren Messungen, um Schwankungen des ESP32-ADCs zu reduzieren.
Fazit
Mit einer Widerstandsleiter lassen sich am ESP32 mehrere Taster an einem GPIO betreiben – eine elegante und zugleich sehr kostengünstige Lösung, wenn die freien Pins knapp werden. Gerade beim Cheap Yellow Display (ESP32-2432S028) ist das ein echter Vorteil, da nur wenige frei zugängliche GPIOs vorhanden sind.
Durch die Nutzung des ADC kannst du mit nur einem einzigen Pin mehrere Eingaben zuverlässig unterscheiden. Wichtig ist dabei:
- saubere Widerstandswerte (idealerweise 1 % Toleranz),
- klar definierte Schwellwertbereiche im Code,
- und das Prinzip „nur ein Taster gleichzeitig“.
Der Ansatz funktioniert nicht nur am CYD, sondern grundsätzlich mit jedem ESP32 – und sogar mit Arduino-Boards oder dem Raspberry Pi Pico, sofern ein Analog-Eingang vorhanden ist.
FAQ – Mehrere Taster an einem GPIO (ESP32 / CYD)
Wie viele Taster kann ich an einem GPIO betreiben?
In der Praxis sind 3 bis 8 Taster realistisch.
Entscheidend sind:
- die Wahl der Widerstandswerte
- die Toleranz der Widerstände (1 % empfohlen)
- stabile ADC-Messwerte
Je enger die Spannungsbereiche beieinanderliegen, desto höher ist das Risiko für Fehlauslösungen.
Funktioniert das nur am Cheap Yellow Display?
Nein.
Die Schaltung funktioniert mit:
- jedem ESP32
- Arduino-Boards mit ADC
- Raspberry Pi Pico
- generell jedem Mikrocontroller mit Analog-Eingang
Wichtig ist nur, dass der Controller mit 3,3 V oder 5 V Logik korrekt betrieben wird – und dass du die Referenzspannung im Code berücksichtigst.
Warum brauche ich einen festen Pullup-Widerstand (z. B. 10 kΩ)?
Der Pullup-Widerstand sorgt dafür, dass am ADC-Pin im Ruhezustand eine definierte Spannung anliegt.
Ohne ihn „schwebt“ der Eingang (Floating Input) und liefert unkontrollierbare Werte.
Warum schwanken die ADC-Werte?
Das ist beim ESP32 normal. Gründe:
- ADC ist nicht hochpräzise
- leichte Spannungsschwankungen
- Widerstandstoleranzen
Lösung:
- hochwertige Widerstände (1 %)
- Mittelwertbildung (wie im Beispiel mit
average()) - mit Schwellwert-Fenstern arbeiten
Was passiert, wenn ich zwei Taster gleichzeitig drücke?
Dann entstehen Mischspannungen, da mehrere Widerstände parallel wirken.
Das System erkennt dann keinen eindeutigen Taster.
Kann ich statt 3,3 V auch 5 V verwenden?
Am ESP32: Nein!
Der ESP32 arbeitet mit 3,3 V Logik.
5 V am ADC können den Mikrocontroller dauerhaft beschädigen.
Bei 5 V-Systemen (z. B. klassischer Arduino Uno) muss die Schaltung entsprechend angepasst werden.
Ist diese Lösung besser als ein I²C-Portexpander?
Das kommt auf dein Projekt an:
| Widerstandsleiter | Portexpander |
|---|---|
| sehr günstig | zusätzliche Hardware |
| nur 1 GPIO nötig | mehrere GPIOs möglich |
| nur ein Taster gleichzeitig | mehrere gleichzeitig möglich |
| einfache Lösung | flexibler |
Für einfache Bedienfelder ist die Widerstandsleiter perfekt.
Für komplexe Eingabesysteme ist ein Portexpander oft sinnvoller.
Letzte Aktualisierung am: 19. Februar 2026
