Auf dem ESP32 befinden sich jede Menge kleine Anschlüsse.
Aber wofür sind die eigentlich da?
Über diese Anschlüsse kann der ESP32 mit der Außenwelt kommunizieren.
Er kann zum Beispiel erkennen, ob ein Taster gedrückt wurde, und daraufhin eine LED einschalten.
Das klingt simpel, ist aber eine wichtige Grundlage:
Fast jedes ESP32-Projekt besteht daraus, Informationen einzulesen, zu verarbeiten und anschließend etwas zu steuern.
In diesem Beitrag schauen wir uns deshalb die GPIO-Pins des ESP32 genauer an.
Ganz einfach und ohne unnötige Fachbegriffe.
Was bedeutet GPIO?
Die Abkürzung GPIO steht für:
General Purpose Input/Output
Auf Deutsch ungefähr:
Allgemein verwendbarer Ein- und Ausgang
Das klingt kompliziert.
Gemeint ist aber einfach ein Anschluss des ESP32, der für unterschiedliche Aufgaben verwendet werden kann.
Ein GPIO kann beispielsweise als Eingang verwendet werden.
Dann kann der ESP32 etwas erkennen.
Zum Beispiel:
- Taster gedrückt
- Schalter eingeschaltet
- Bewegung erkannt
- Tür geöffnet
- Sensor aktiv
Oder ein GPIO wird als Ausgang verwendet.
Dann kann der ESP32 etwas steuern.
Zum Beispiel:
- LED einschalten
- Summer aktivieren
- Relais ansteuern
- Signal ausgeben
Damit kommen wir wieder zu unserem wichtigsten Grundprinzip:
Eingabe → Verarbeitung → Ausgabe
Was ist ein Eingang?
Beginnen wir mit dem Eingang.
Auf Englisch:
INPUT
Ein Eingang liefert dem ESP32 eine Information.
Ein einfaches Beispiel ist ein Taster.
TASTER
↓
ESP32
Der ESP32 möchte wissen:
Ist der Taster gedrückt?
Dafür wird ein GPIO als Eingang eingestellt.
Zum Beispiel:
pinMode(21, INPUT);
Damit sagen wir:
GPIO 21 soll als Eingang verwendet werden.
Anschließend können wir den Zustand dieses Eingangs auslesen.
Dafür gibt es:
digitalRead(21);
digitalRead() bedeutet vereinfacht:
Lies den Zustand dieses Pins.
Was ist ein Ausgang?
Das Gegenteil eines Eingangs ist ein Ausgang.
Auf Englisch:
OUTPUT
Hier bekommt der ESP32 keine Information.
Stattdessen gibt er etwas aus.
Zum Beispiel:
ESP32
↓
LED
Der ESP32 entscheidet:
LED einschalten.
Oder:
LED ausschalten.
Dafür wird der GPIO zunächst als Ausgang eingestellt:
pinMode(21, OUTPUT);
Anschließend können wir den Ausgang steuern:
digitalWrite(21, HIGH);
oder:
digitalWrite(21, LOW);
HIGH und LOW einfach erklärt
Jetzt tauchen zwei Begriffe auf, die beim ESP32 ständig vorkommen:
HIGH
und
LOW
Für den Anfang kann man sich merken:
HIGH = 1
LOW = 0
Bei einem digitalen Ausgang kann man sich zusätzlich vereinfacht vorstellen:
HIGH = EIN
LOW = AUS
Bei unserer LED bedeutet das beispielsweise:
digitalWrite(21, HIGH);
LED einschalten
und:
digitalWrite(21, LOW);
LED ausschalten
Ganz so einfach ist HIGH = EIN und LOW = AUS technisch nicht immer. Für den Einstieg ist diese Vorstellung aber zunächst sehr hilfreich.
Was bedeutet digital?
Warum sprechen wir eigentlich von einem digitalen Eingang oder digitalen Ausgang?
Digital bedeutet hier:
Es gibt zwei Zustände.
Zum Beispiel:
0 oder 1
LOW oder HIGH
AUS oder EIN
Ein Taster ist ein gutes Beispiel.
Er kann vereinfacht zwei Zustände besitzen:
nicht gedrückt
oder
gedrückt
Eine LED ebenfalls:
aus
oder
an
Das sind digitale Zustände.
Unsere erste Ausgangsschaltung: eine LED
Eine LED ist perfekt, um einen Ausgang zu verstehen.
Wir benötigen:
- ESP32
- Breadboard
- LED
- Vorwiderstand
- Jumper-Kabel
Für ein einfaches Experiment kann beispielsweise ein 220-Ω-Widerstand verwendet werden. Auch Newbiely verwendet bei seinem ESP32-LED-Beispiel einen entsprechenden Vorwiderstand.
Der Widerstand ist wichtig, weil er den Strom durch die LED begrenzt.
Warum braucht die LED einen Widerstand?
Eine LED sollte nicht einfach direkt zwischen einen GPIO und GND gesteckt werden.
Ohne geeignete Strombegrenzung könnte zu viel Strom fließen.
Das kann die LED beschädigen und im ungünstigen Fall auch den ESP32 belasten.
Deshalb verwenden wir einen Vorwiderstand.
Vereinfacht:
GPIO
│
│
Widerstand
│
│
LED
│
│
GND
Der Widerstand begrenzt den Strom.
Achtung bei der LED: Plus und Minus
Eine normale LED besitzt eine Richtung.
Sie hat:
Anode = Plus-Seite
und
Kathode = Minus-Seite
Bei vielen bedrahteten LEDs erkennt man:
langes Bein → Anode
kurzes Bein → Kathode
Außerdem ist das LED-Gehäuse auf der Kathodenseite häufig abgeflacht.
Wird eine LED falsch herum eingebaut, leuchtet sie normalerweise nicht.
LED an den ESP32 anschließen
Für unser Beispiel verwenden wir:
GPIO 21
Die Schaltung besteht vereinfacht aus:
GPIO 21
│
│
Widerstand
│
│
LED
│
│
GND
Damit kann der ESP32 die LED über GPIO 21 steuern.
Das erste LED-Programm
Jetzt brauchen wir ein Programm.
#define LED_PIN 21
void setup() {
pinMode(LED_PIN, OUTPUT);
}
void loop() {
digitalWrite(LED_PIN, HIGH);
}
Schauen wir uns die wichtigen Stellen an.
Einen Namen für den GPIO vergeben
Diese Zeile:
#define LED_PIN 21
bedeutet:
Unsere LED ist mit GPIO 21 verbunden.
Statt später überall:
21
zu schreiben, verwenden wir:
LED_PIN
Das macht den Code verständlicher.
Den GPIO als Ausgang festlegen
Jetzt kommt:
pinMode(LED_PIN, OUTPUT);
Damit teilen wir dem ESP32 mit:
Dieser GPIO wird als Ausgang verwendet.
Diese Einstellung muss nur einmal erfolgen.
Deshalb steht sie in:
setup()
LED einschalten
Jetzt kommt:
digitalWrite(LED_PIN, HIGH);
Damit wird der Ausgang auf HIGH gesetzt.
Unsere LED leuchtet.
Möchten wir sie ausschalten, verwenden wir:
digitalWrite(LED_PIN, LOW);
Das ist bereits die grundlegende Steuerung eines digitalen Ausgangs.
Die LED blinken lassen
Jetzt können wir daraus eine kleine Schleife machen:
#define LED_PIN 21
void setup() {
pinMode(LED_PIN, OUTPUT);
}
void loop() {
digitalWrite(LED_PIN, HIGH);
delay(1000);
digitalWrite(LED_PIN, LOW);
delay(1000);
}
Das Programm macht:
LED EIN
↓
1 Sekunde warten
↓
LED AUS
↓
1 Sekunde warten
↓
wieder von vorne
Die LED blinkt.
Damit haben wir unseren ersten digitalen OUTPUT verstanden.
Jetzt brauchen wir einen Eingang
Eine blinkende LED ist nett.
Interessanter wird es aber, wenn der ESP32 auf seine Umgebung reagieren kann.
Dafür brauchen wir einen Eingang.
Unser einfachstes Beispiel:
ein Taster
Der ESP32 soll erkennen:
Wurde der Taster gedrückt?
Wie funktioniert ein Taster?
Ein Taster ist eigentlich nur ein einfacher Schalter.
Nicht gedrückt:
────── ──────
Die Verbindung ist unterbrochen.
Gedrückt:
──────────────
Die Verbindung ist geschlossen.
Das kann der ESP32 erkennen.
Warum haben viele Taster vier Beine?
Ein kleiner Breadboard-Taster besitzt häufig vier Anschlüsse.
Das kann zunächst verwirrend sein.
Eigentlich werden aber nur zwei elektrische Anschlüsse benötigt.
Jeweils zwei Pins sind intern bereits miteinander verbunden. Die vier Beine sorgen unter anderem dafür, dass der Taster stabil auf einer Platine sitzt.
Deshalb ist es wichtig, den Taster auf dem Breadboard richtig herum einzusetzen.
Der Taster am ESP32
Wir machen es uns einfach.
Eine Seite des Tasters verbinden wir mit:
GPIO 21
Die andere Seite mit:
GND
Vereinfacht:
GPIO 21
│
│
TASTER
│
│
GND
Jetzt fehlt allerdings noch etwas.
Das Problem mit einem offenen Eingang
Ist der Taster gedrückt, wird GPIO 21 mit GND verbunden.
Das ist eindeutig.
Aber was passiert, wenn der Taster nicht gedrückt wird?
Dann hängt der Eingang praktisch in der Luft.
Der ESP32 kann dann möglicherweise keine eindeutige HIGH- oder LOW-Information erkennen.
Das nennt man einen:
Floating Input
oder auf Deutsch:
schwebenden Eingang.
Das wollen wir vermeiden.
Der Pull-up-Widerstand
Dafür gibt es sogenannte:
Pull-up-Widerstände
Der Widerstand sorgt dafür, dass der Eingang einen definierten Zustand besitzt, solange der Taster nicht gedrückt wird.
Praktischerweise besitzt der ESP32 solche Widerstände bereits intern.
Wir müssen deshalb für diese einfache Taster-Schaltung keinen zusätzlichen Widerstand einbauen.
Wir schreiben:
pinMode(21, INPUT_PULLUP);
Damit sagen wir:
Verwende GPIO 21 als Eingang und aktiviere zusätzlich den internen Pull-up-Widerstand.
Newbiely empfiehlt für einfache ESP32-Tasterprojekte ebenfalls die Verwendung des internen Pull-up-Widerstands, da dadurch die Schaltung einfacher wird.
Jetzt passiert etwas scheinbar Seltsames
Bei unserer Schaltung gilt:
Taster NICHT gedrückt
→ HIGH
und:
Taster gedrückt
→ LOW
Moment.
Ist das nicht genau falsch herum?
Es wirkt zunächst so.
Aber durch den Pull-up-Widerstand ist das völlig normal.
Man kann sich merken:
INPUT_PULLUP + Taster gegen GND
nicht gedrückt = HIGH
gedrückt = LOW
Das begegnet einem bei Mikrocontroller-Projekten sehr häufig.
Taster programmieren
Jetzt können wir unseren Taster auslesen.
#define BUTTON_PIN 21
void setup() {
Serial.begin(115200);
pinMode(BUTTON_PIN, INPUT_PULLUP);
}
void loop() {
int buttonState = digitalRead(BUTTON_PIN);
Serial.println(buttonState);
delay(100);
}
Was passiert hier?
Tasterzustand lesen
Diese Zeile:
int buttonState = digitalRead(BUTTON_PIN);
liest den Zustand des Eingangs.
Das Ergebnis wird in der Variable:
buttonState
gespeichert.
Der Wert kann sein:
HIGH
oder:
LOW
Zustand im Serial Monitor anzeigen
Mit:
Serial.println(buttonState);
zeigen wir den Wert im Serial Monitor an.
Ohne gedrückten Taster sehen wir beispielsweise:
1
1
1
1
1
1
Drücken wir den Taster:
0
0
0
0
0
Lassen wir ihn wieder los:
1
1
1
1
1
Dabei gilt:
1 = HIGH = nicht gedrückt
0 = LOW = gedrückt
Damit haben wir unseren ersten digitalen INPUT.
Jetzt verbinden wir Eingang und Ausgang
Jetzt kommt der interessante Teil.
Wir verwenden:
einen Taster als Eingang
und:
eine LED als Ausgang
Unser ESP32 soll:
Die LED einschalten, wenn der Taster gedrückt wird.
Damit haben wir eine vollständige kleine Steuerung:
TASTER
↓
INPUT
↓
ESP32
↓
PROGRAMM
↓
OUTPUT
↓
LED
Das Programm
Wir verwenden beispielsweise:
GPIO 21 für die LED
und:
GPIO 18 für den Taster
#define LED_PIN 21
#define BUTTON_PIN 18
void setup() {
pinMode(LED_PIN, OUTPUT);
pinMode(BUTTON_PIN, INPUT_PULLUP);
}
void loop() {
int buttonState = digitalRead(BUTTON_PIN);
if (buttonState == LOW) {
digitalWrite(LED_PIN, HIGH);
}
else {
digitalWrite(LED_PIN, LOW);
}
}
Jetzt passiert:
Taster nicht gedrückt
↓
HIGH
↓
LED AUS
und:
Taster gedrückt
↓
LOW
↓
LED EIN
Damit haben wir bereits eine echte kleine Steuerung gebaut.
INPUT und OUTPUT im Vergleich
Die beiden wichtigsten GPIO-Betriebsarten lassen sich einfach zusammenfassen:
| Einstellung | Aufgabe | Beispiel |
|---|---|---|
| INPUT | Information einlesen | Sensor |
| INPUT_PULLUP | Eingang mit internem Pull-up | Taster |
| OUTPUT | etwas steuern | LED |
Für viele erste Projekte reichen diese drei Einstellungen bereits aus.
digitalRead() und digitalWrite()
Auch diese beiden Befehle sollte man auseinanderhalten.
digitalRead()
digitalRead()
bedeutet:
lesen
Beispiel:
digitalRead(BUTTON_PIN);
Der ESP32 möchte wissen:
Welchen Zustand hat der Taster?
digitalWrite()
digitalWrite()
bedeutet:
schreiben bzw. Ausgang setzen
Beispiel:
digitalWrite(LED_PIN, HIGH);
Der ESP32 sagt:
Schalte den Ausgang auf HIGH.
Als Eselsbrücke:
READ → ESP32 bekommt Information
WRITE → ESP32 gibt Information aus
GND: Ein unscheinbarer, aber wichtiger Anschluss
Bei fast jeder Schaltung taucht die Abkürzung:
GND
auf.
GND steht für:
Ground
oder:
Masse
Vereinfacht kann man sich GND als gemeinsamen Bezugspunkt der Schaltung vorstellen.
Viele Komponenten müssen denselben Bezugspunkt besitzen.
Deshalb sieht man bei ESP32-Schaltungen sehr häufig Verbindungen zu GND.
Fehlt diese Verbindung, funktioniert eine Schaltung möglicherweise nicht oder verhält sich merkwürdig.
3,3 Volt: Beim ESP32 besonders wichtig
Der klassische ESP32 arbeitet an seinen GPIOs mit 3,3-V-Logik.
Das ist ein wichtiger Punkt.
Ein HIGH-Signal entspricht also nicht einfach automatisch den 5 Volt, die vielleicht von klassischen Arduino-Projekten bekannt sind.
Deshalb gilt:
Nicht einfach jedes 5-V-Signal mit einem ESP32-GPIO verbinden.
Vor dem Anschluss eines Sensors oder Moduls sollte geprüft werden:
- Welche Versorgungsspannung benötigt das Modul?
- Welche Signalspannung gibt das Modul aus?
- Ist diese Spannung für den ESP32 geeignet?
Das ist besonders wichtig, wenn Module eigentlich für 5-V-Systeme gedacht sind.
GPIO ist nicht gleich Stromversorgung
Ein weiterer wichtiger Punkt:
Ein GPIO ist zum Steuern von Signalen gedacht.
Er ist keine kleine Steckdose.
Eine normale LED mit geeignetem Vorwiderstand ist für ein erstes Experiment geeignet.
Größere Verbraucher gehören aber nicht direkt an einen GPIO.
Zum Beispiel:
- Motor
- Pumpe
- Heizdraht
- starke Lampe
- leistungsstarker LED-Streifen
- Magnetventil
Solche Verbraucher benötigen eine geeignete Treiberschaltung.
Dafür können beispielsweise verwendet werden:
- Transistoren
- MOSFETs
- Motortreiber
- Relaismodule
und häufig:
eine externe Stromversorgung
Kann jeder GPIO für alles verwendet werden?
Nein.
Und das ist beim ESP32 wichtig.
Auf einem ESP32-Board befinden sich viele Pins, aber nicht jeder Pin eignet sich für jede Aufgabe.
Einige Pins können besondere Funktionen besitzen oder während des Startvorgangs des ESP32 eine Rolle spielen.
Andere Pins können je nach ESP32-Variante Einschränkungen haben.
Deshalb sollte vor einer eigenen Schaltung immer die Pinbelegung des verwendeten ESP32-Boards geprüft werden.
Denn:
ESP32 ist nicht automatisch gleich ESP32.
Es gibt verschiedene Chips und unterschiedliche Development Boards.
Die Beschriftung auf dem eigenen Board ist deshalb wichtig.
Typische Anfängerfehler bei GPIO
Wenn eine Schaltung nicht funktioniert, liegt es häufig an einer Kleinigkeit.
INPUT statt OUTPUT
Die LED soll gesteuert werden, aber im Programm steht:
pinMode(LED_PIN, INPUT);
Für unsere LED benötigen wir:
pinMode(LED_PIN, OUTPUT);
Falscher GPIO
Im Programm steht:
#define LED_PIN 21
Die LED wurde aber an GPIO 18 angeschlossen.
Programm und Schaltung müssen zusammenpassen.
LED falsch herum
LEDs besitzen eine Polarität.
Ist die LED verkehrt herum eingebaut, leuchtet sie nicht.
Vorwiderstand vergessen
Eine externe Standard-LED sollte mit einem geeigneten Vorwiderstand betrieben werden.
GND vergessen
Ohne gemeinsamen Bezugspunkt funktioniert die Schaltung möglicherweise nicht richtig.
INPUT_PULLUP nicht verstanden
Bei unserer Taster-Schaltung gilt:
gedrückt = LOW
Das wirkt am Anfang falsch herum, ist aber korrekt.
5 Volt an einen GPIO
Der ESP32 arbeitet mit 3,3-V-Logik.
Deshalb müssen Signalspannungen angeschlossener Komponenten geprüft werden.
Eine einfache Eselsbrücke
Die wichtigsten Begriffe dieses Beitrags lassen sich sehr einfach merken:
GPIO
│
├── INPUT
│ ↓
│ ESP32 hört zu
│
└── OUTPUT
↓
ESP32 spricht
Oder noch einfacher:
INPUT = hinein
OUTPUT = heraus
Dazu:
digitalRead() = lesen
digitalWrite() = ausgeben
Das Wichtigste in 60 Sekunden
Die GPIOs sind die Verbindung zwischen dem ESP32 und der Außenwelt.
Ein GPIO kann beispielsweise als Eingang verwendet werden:
pinMode(BUTTON_PIN, INPUT_PULLUP);
Dann können wir seinen Zustand lesen:
digitalRead(BUTTON_PIN);
Oder wir verwenden einen GPIO als Ausgang:
pinMode(LED_PIN, OUTPUT);
Dann können wir ihn steuern:
digitalWrite(LED_PIN, HIGH);
oder:
digitalWrite(LED_PIN, LOW);
Für digitale Signale gilt:
HIGH = 1
LOW = 0
Bei einem Taster mit INPUT_PULLUP gilt häufig:
nicht gedrückt = HIGH
gedrückt = LOW
Und damit können wir bereits:
Taster → ESP32 → LED
programmieren.
Das ist eine der wichtigsten Grundlagen für fast alle weiteren ESP32-Projekte.
Wie geht es weiter?
Jetzt kennen wir die wichtigsten GPIO-Grundlagen.
Als nächstes lohnt es sich, einen der wichtigsten Eingänge genauer anzuschauen:
den Taster.
Im nächsten Beitrag geht es deshalb um:
ESP32 und Taster: Anschließen, auslesen und richtig programmieren
Dabei schauen wir uns unter anderem an:
- wie ein Taster funktioniert
- warum viele Taster vier Anschlüsse haben
- was
INPUT_PULLUPmacht - warum ein Taster manchmal scheinbar mehrfach auslöst
- was Tasterprellen bedeutet
- wie ein Tastendruck erkannt wird
- wie zwischen Drücken und Loslassen unterschieden wird
- wie eine LED per Tastendruck ein- und ausgeschaltet werden kann
Alle Beiträge dieser Serie
- Teil 1: ESP32 kennenlernen
- Teil 2: ESP32 programmieren
- Teil 3: GPIO verstehen (Aktuell)
- Teil 4: Taster anschließen und entprellen
- Teil 5: LEDs steuern
- Teil 6: Analoge Werte und ADC
Add your first comment to this post