Der ESP32 ist klein, günstig und trotzdem erstaunlich leistungsfähig. Mit ihm lassen sich LEDs steuern, Taster auslesen, Temperaturen messen, Motoren bewegen oder Geräte über WLAN miteinander verbinden.
Das Beste daran:
Für den Einstieg sind weder Programmierkenntnisse noch umfangreiche Elektronikkenntnisse notwendig.
In diesem Beitrag werden die wichtigsten Grundlagen Schritt für Schritt erklärt.
Nach diesem Einstieg ist klar:
- was ein ESP32 ist
- was ein Mikrocontroller macht
- was GPIO-Pins sind
- welche Hardware benötigt wird
- wie der ESP32 mit dem Computer verbunden wird
- wie ein erstes Programm funktioniert
- was
setup()undloop()bedeuten - wie Ein- und Ausgänge funktionieren
- was beim Anschluss von Bauteilen beachtet werden muss
- welche Projekte sich für den Einstieg eignen
Was ist ein ESP32?
Der ESP32 ist ein Mikrocontroller.
Das klingt komplizierter, als es ist.
Vereinfacht kann man sich einen Mikrocontroller wie einen winzigen Computer vorstellen.
Ein normaler Computer besitzt:
- Bildschirm
- Tastatur
- Maus
- Festplatte
- viele Anschlüsse
Der ESP32 benötigt das alles nicht.
Stattdessen besitzt er kleine Anschlüsse, sogenannte Pins.
An diese Pins können elektronische Bauteile angeschlossen werden.
Zum Beispiel:
- LEDs
- Taster
- Schalter
- Temperatursensoren
- Abstandssensoren
- Displays
- Bewegungsmelder
- Relais
- Servomotoren
Ein Programm bestimmt anschließend, was der ESP32 mit diesen Bauteilen machen soll.
Das wichtigste Prinzip: Eingabe → Verarbeitung → Ausgabe
Fast jedes Mikrocontroller-Projekt funktioniert nach demselben Prinzip:
Eingabe → Verarbeitung → Ausgabe
Ein einfaches Beispiel:
Ein Taster wird gedrückt.
Eingabe:
Der ESP32 erkennt den gedrückten Taster.
Verarbeitung:
Das Programm prüft:
Ist der Taster gedrückt?
Ausgabe:
Der ESP32 schaltet eine LED ein.
Das war es eigentlich schon.
Natürlich können Projekte später deutlich komplizierter werden. Das Grundprinzip bleibt aber fast immer gleich.
Was macht den ESP32 besonders?
Mikrocontroller gibt es schon sehr lange.
Bekannte Beispiele sind:
- Arduino Uno
- Arduino Nano
- Arduino Mega
Der ESP32 bietet zusätzlich einige Funktionen, die ihn besonders interessant machen.
Dazu gehören vor allem:
WLAN
Der ESP32 kann sich mit einem WLAN verbinden.
Dadurch kann er beispielsweise:
- Messwerte übertragen
- Webseiten bereitstellen
- Daten aus dem Internet abrufen
- mit Smart-Home-Systemen kommunizieren
Bluetooth
Auch Bluetooth ist bereits integriert.
Damit kann der ESP32 beispielsweise mit anderen Geräten kommunizieren.
Für die ersten Projekte benötigen wir WLAN und Bluetooth allerdings noch gar nicht.
Wir beginnen deutlich einfacher.
Was benötigen wir für den Einstieg?
Für die ersten Versuche wird nicht viel benötigt.
Grundausstattung
- ESP32 Development Board
- passendes USB-Kabel
- Computer
- Arduino IDE
- Breadboard
- Jumper-Kabel
- LEDs
- Widerstände
- Taster
Für die ersten Programmierübungen reichen sogar:
ESP32 + USB-Kabel + Computer
Was ist ein Breadboard?
Ein Breadboard wird auch Steckbrett genannt.
Damit können elektronische Schaltungen aufgebaut werden, ohne die Bauteile miteinander zu verlöten.
Bauteil hineinstecken.
Kabel hineinstecken.
Programm ausprobieren.
Funktioniert etwas nicht?
Kabel wieder herausziehen und die Schaltung verändern.
Das macht Breadboards ideal zum Lernen und Experimentieren.
Die Arduino IDE
Der ESP32 muss wissen, was er machen soll.
Dafür schreiben wir ein Programm.
Eine sehr einfache Möglichkeit dafür ist die Arduino IDE.
IDE bedeutet:
Integrated Development Environment
Das müssen wir uns aber nicht merken.
Vereinfacht gesagt ist die Arduino IDE einfach:
Das Programm auf dem Computer, mit dem wir unseren ESP32 programmieren.
In der Arduino IDE schreiben wir unseren Programmcode.
Anschließend wird das Programm über USB auf den ESP32 übertragen.
ESP32 für die Arduino IDE vorbereiten
Bevor das erste Programm übertragen werden kann, muss die Arduino IDE für den ESP32 eingerichtet werden.
Danach wird das verwendete ESP32-Board ausgewählt.
Bei vielen klassischen ESP32-Entwicklungsboards ist das beispielsweise:
ESP32 Dev Module
Zusätzlich muss der richtige USB-Anschluss ausgewählt werden.
Danach können Programme auf den ESP32 übertragen werden.
Unser erstes ESP32-Programm
Programme für Arduino und ESP32 werden häufig Sketch genannt.
Fast jeder Sketch besitzt zwei wichtige Bereiche:
void setup() {
}
void loop() {
}
Diese beiden Bereiche sind so wichtig, dass man sie direkt kennenlernen sollte.
setup() einfach erklärt
setup() bedeutet sinngemäß:
Vorbereitung
Alles innerhalb von setup() wird beim Start einmal ausgeführt.
Zum Beispiel:
void setup() {
Serial.begin(9600);
}
Damit starten wir die Kommunikation zwischen ESP32 und Computer.
Wichtig ist:
setup() wird nur einmal ausgeführt.
loop() einfach erklärt
Danach kommt:
void loop() {
}
loop bedeutet:
Schleife
Alles innerhalb von loop() wird immer wieder ausgeführt.
Der ESP32 arbeitet beispielsweise:
Aufgabe 1
↓
Aufgabe 2
↓
Aufgabe 3
↓
wieder Aufgabe 1
↓
Aufgabe 2
↓
Aufgabe 3
↓
...
Und das passiert sehr schnell.
Solange der ESP32 eingeschaltet ist.
Hello World mit dem ESP32
Beim Programmieren ist das erste Programm traditionell häufig:
Hello World!
Damit testen wir, ob unsere Programmierumgebung funktioniert.
Beim ESP32 können wir den Text über die serielle Schnittstelle an den Computer schicken.
void setup() {
Serial.begin(9600);
Serial.println("Hello World!");
}
void loop() {
}
Nach dem Hochladen öffnen wir den Serial Monitor.
Dort sollte erscheinen:
Hello World!
Herzlichen Glückwunsch.
Der ESP32 führt das erste eigene Programm aus.
Was ist der Serial Monitor?
Der Serial Monitor ist eines der wichtigsten Werkzeuge beim Programmieren eines ESP32.
Der ESP32 besitzt schließlich keinen eigenen Bildschirm.
Trotzdem möchten wir wissen, was innerhalb unseres Programms passiert.
Dafür kann der ESP32 Informationen an den Computer senden.
Zum Beispiel:
Serial.println("Taster gedrückt");
Oder:
Serial.println(temperatur);
Der Serial Monitor kann dann beispielsweise anzeigen:
21
22
22
23
23
24
Damit können wir später Messwerte beobachten und Fehler in unseren Programmen finden.
Was sind die Pins am ESP32?
An den Seiten des ESP32 befinden sich viele kleine Anschlüsse.
Diese werden Pins genannt.
Einige davon sind sogenannte:
GPIO-Pins
GPIO steht für:
General Purpose Input/Output
Das bedeutet vereinfacht:
Anschlüsse, die wir für verschiedene Aufgaben verwenden können.
Ein GPIO kann beispielsweise einen Taster auslesen oder eine LED steuern.
Eingang und Ausgang
Dabei müssen wir zwei grundlegende Begriffe unterscheiden.
INPUT
INPUT bedeutet:
Eingang
Der ESP32 bekommt eine Information.
Beispiele:
- Taster gedrückt?
- Tür geöffnet?
- Bewegung erkannt?
- Sensor aktiv?
OUTPUT
OUTPUT bedeutet:
Ausgang
Der ESP32 steuert etwas.
Beispiele:
- LED einschalten
- Summer aktivieren
- Relais schalten
- Signal ausgeben
Damit sind wir wieder bei unserem Grundprinzip:
INPUT → Verarbeitung → OUTPUT
Die erste LED
Eine der klassischen Übungen besteht darin, eine LED blinken zu lassen.
Dafür benötigen wir beispielsweise:
- ESP32
- LED
- passenden Vorwiderstand
- Breadboard
- Jumper-Kabel
Eine externe LED benötigt einen passenden Vorwiderstand. Ein häufig verwendeter Wert für einfache Versuche ist beispielsweise 220 Ω. Auch Newbiely verwendet für sein ESP32-Blink-Beispiel eine LED mit 220-Ω-Widerstand.
Der genaue GPIO hängt davon ab, wie die Schaltung aufgebaut wird.
Angenommen, unsere LED ist mit GPIO 21 verbunden:
#define LED_PIN 21
void setup() {
pinMode(LED_PIN, OUTPUT);
}
void loop() {
digitalWrite(LED_PIN, HIGH);
delay(1000);
digitalWrite(LED_PIN, LOW);
delay(1000);
}
Was passiert hier?
pinMode()
Diese Zeile:
pinMode(LED_PIN, OUTPUT);
bedeutet:
Verwende diesen Anschluss als Ausgang.
Damit weiß der ESP32:
Über diesen Pin soll etwas gesteuert werden.
digitalWrite()
Mit:
digitalWrite(LED_PIN, HIGH);
schalten wir den Ausgang ein.
Vereinfacht:
HIGH = EIN
Anschließend:
digitalWrite(LED_PIN, LOW);
Vereinfacht:
LOW = AUS
Damit können wir die LED ein- und ausschalten.
delay()
Jetzt fehlt noch:
delay(1000);
delay() bedeutet:
Warte.
Die Zahl wird in Millisekunden angegeben.
Deshalb gilt:
1000 ms = 1 Sekunde
Unser Programm macht also:
LED EIN
↓
1 Sekunde warten
↓
LED AUS
↓
1 Sekunde warten
↓
LED EIN
↓
...
Die LED blinkt.
Damit wurde bereits ein echter Ausgang des Mikrocontrollers programmiert.
Jetzt kommt ein Eingang: der Taster
Eine LED ist ein Ausgang.
Ein Taster ist dagegen ein typischer Eingang.
Der ESP32 soll erkennen:
gedrückt oder nicht gedrückt?
Dafür gibt es:
digitalRead()
Ein Taster kann beispielsweise an einen GPIO und GND angeschlossen werden.
Der ESP32 besitzt interne Pull-up-Widerstände. Dadurch können wir bei vielen einfachen Taster-Schaltungen auf einen zusätzlichen Widerstand verzichten.
Im Programm verwenden wir:
pinMode(BUTTON_PIN, INPUT_PULLUP);
Wichtig:
Bei dieser Schaltung ist die Logik zunächst etwas ungewohnt.
Taster nicht gedrückt → HIGH
Taster gedrückt → LOW
Das wirkt zunächst falsch herum, ist aber völlig normal.
Taster auslesen
Ein einfaches Programm könnte so aussehen:
#define BUTTON_PIN 21
void setup() {
Serial.begin(9600);
pinMode(BUTTON_PIN, INPUT_PULLUP);
}
void loop() {
int buttonState = digitalRead(BUTTON_PIN);
Serial.println(buttonState);
}
Im Serial Monitor können wir jetzt beobachten:
1
1
1
1
0
0
0
1
1
Dabei gilt:
1 = Taster nicht gedrückt
0 = Taster gedrückt
Damit können wir bereits Informationen aus der echten Welt in unser Programm einlesen.
Variablen einfach erklärt
Im letzten Programm gab es diese Zeile:
int buttonState;
Was bedeutet das?
Eine Variable kann man sich wie eine kleine beschriftete Kiste vorstellen.
Die Kiste heißt:
buttonState
Darin können wir einen Wert speichern.
Zum Beispiel:
int alter = 16;
Wir haben eine Kiste mit der Beschriftung:
alter
und legen dort hinein:
16
Später können wir den Inhalt wieder verwenden.
Entscheidungen treffen mit if
Jetzt wird es interessant.
Der ESP32 kann Entscheidungen treffen.
Zum Beispiel:
Wenn der Taster gedrückt wird, schalte die LED ein.
Dafür verwenden wir:
if
if bedeutet:
wenn
Zum Beispiel:
if (buttonState == LOW) {
digitalWrite(LED_PIN, HIGH);
}
Das können wir fast wie einen deutschen Satz lesen:
WENN der Taster gedrückt ist, DANN schalte die LED ein.
Zusätzlich gibt es:
else
Das bedeutet:
ansonsten
Damit können wir schreiben:
if (buttonState == LOW) {
digitalWrite(LED_PIN, HIGH);
}
else {
digitalWrite(LED_PIN, LOW);
}
Jetzt gilt:
Taster gedrückt → LED an
Taster losgelassen → LED aus
Damit haben wir bereits eine kleine Steuerung programmiert.
Digitale und analoge Signale
Bisher haben wir digitale Signale verwendet.
Digital
Digital bedeutet vereinfacht:
Es gibt zwei Zustände.
Zum Beispiel:
EIN / AUS
HIGH / LOW
1 / 0
Ein Taster ist dafür ein gutes Beispiel.
Analog
Manche Sensoren liefern aber nicht nur EIN oder AUS.
Ein Helligkeitssensor könnte beispielsweise liefern:
100
250
500
750
1000
Dadurch können wir erkennen, wie hell es ist.
Solche Messwerte können mit geeigneten ESP32-Pins über einen Analog-Digital-Wandler eingelesen werden.
Im Programm begegnet uns dafür beispielsweise:
analogRead()
Damit können wir später Sensorwerte verarbeiten.
Sensoren: Die Augen und Ohren des ESP32
Sensoren kann man sich als die Sinnesorgane des ESP32 vorstellen.
Mit Sensoren kann der ESP32 beispielsweise erkennen:
- Temperatur
- Luftfeuchtigkeit
- Helligkeit
- Bewegung
- Entfernung
- Regen
- Berührung
- Bodenfeuchtigkeit
Der Sensor liefert Informationen.
Der ESP32 verarbeitet diese Informationen.
Anschließend kann etwas passieren.
Aktoren: Der ESP32 macht etwas
Ein Aktor macht genau das Gegenteil.
Er führt eine Aktion aus.
Beispiele:
- LED
- Summer
- Relais
- Servomotor
- Motor
- Display
Damit entsteht wieder unser wichtigstes Schema:
SENSOR
↓
ESP32
↓
PROGRAMM
↓
AKTOR
Beispiel:
Temperatursensor
↓
ESP32
↓
Temperatur > 30 °C?
↓
JA
↓
Lüfter einschalten
Damit haben wir eine kleine automatische Steuerung.
Die richtige Stromversorgung
Bei einfachen Versuchen wird der ESP32 normalerweise über seinen USB-Anschluss mit Strom versorgt.
Das reicht für:
- ESP32
- LEDs
- Taster
- einige kleine Sensoren
Bei größeren Verbrauchern sieht das anders aus.
Motoren, Displays oder andere leistungsstärkere Komponenten sollten nicht einfach über einen GPIO-Pin versorgt werden.
Für solche Verbraucher wird eine geeignete externe Stromversorgung benötigt.
Newbiely empfiehlt bei größeren Aufbauten ebenfalls, externe Komponenten separat zu versorgen.
Wichtig ist dabei häufig eine gemeinsame Masse:
GND des ESP32 und GND der externen Schaltung werden miteinander verbunden.
Achtung: Der ESP32 arbeitet mit 3,3 Volt
Ein besonders wichtiger Unterschied zu manchen klassischen Arduino-Boards:
Die GPIOs des ESP32 arbeiten mit 3,3-V-Logik.
Deshalb darf nicht einfach jedes 5-V-Signal an einen GPIO angeschlossen werden.
Vor dem Anschluss eines unbekannten Moduls sollte immer geprüft werden:
- Welche Versorgungsspannung benötigt das Modul?
- Welche Signalspannung liefert es?
- Verträgt der ESP32 diese Spannung?
- Wie viel Strom benötigt das Bauteil?
Das schützt sowohl den ESP32 als auch die angeschlossenen Bauteile.
Was kann man mit dem ESP32 bauen?
Jetzt wird es spannend.
Newbiely führt eine sehr große Zahl unterschiedlicher ESP32-Projekte auf. Dazu gehören unter anderem Taster, LEDs, Potentiometer, Drehencoder, Motoren, Servos, Bodenfeuchtesensoren, Ultraschallsensoren, Bewegungsmelder, Relais, GPS, LED-Streifen, SD-Karten und Joysticks.
Damit sind beispielsweise Projekte möglich wie:
Ampel
Mehrere LEDs werden nacheinander geschaltet.
Abstandsmesser
Ein Ultraschallsensor misst die Entfernung.
Bewegungsmelder
Ein Sensor erkennt Bewegung und schaltet eine LED oder einen Summer.
Wetterstation
Temperatur und Luftfeuchtigkeit werden gemessen und auf einem Display angezeigt.
Pflanzenbewässerung
Ein Bodenfeuchtesensor erkennt trockene Erde und eine Pumpe bewässert die Pflanze.
Roboter
Motoren und Sensoren ermöglichen den Bau eines kleinen Roboters.
Smart Home
Über WLAN können Sensorwerte übertragen oder Geräte gesteuert werden.
WLAN: Die Superkraft des ESP32
Eine der interessantesten Eigenschaften des ESP32 ist das eingebaute WLAN.
Dadurch kann aus einer einfachen elektronischen Schaltung ein vernetztes Gerät werden.
Der ESP32 kann beispielsweise:
- eine Webseite bereitstellen
- Messwerte über WLAN übertragen
- Geräte über einen Browser steuern
- mit anderen ESP32 kommunizieren
- MQTT verwenden
- Daten an einen Server senden
Damit eignet sich der ESP32 hervorragend für IoT-Projekte.
IoT bedeutet:
Internet of Things
also:
Internet der Dinge
Die häufigsten Anfängerfehler
Wenn etwas nicht funktioniert:
Keine Panik.
Sehr häufig liegt es an einer Kleinigkeit.
Falsches Board
In der Arduino IDE wurde das falsche ESP32-Board ausgewählt.
Falscher Port
Der falsche USB-Anschluss wurde ausgewählt.
Falsches USB-Kabel
Manche USB-Kabel können nur Strom übertragen.
Zum Programmieren wird ein Datenkabel benötigt.
Kabel falsch gesteckt
Die Schaltung noch einmal Pin für Pin überprüfen.
GND vergessen
Viele Schaltungen benötigen eine gemeinsame Masseverbindung.
Falscher GPIO
Im Programm steht beispielsweise:
#define LED_PIN 21
Die LED steckt aber an einem anderen GPIO.
Dann kann das Programm nicht funktionieren.
HIGH und LOW verwechselt
Besonders bei Tastern mit INPUT_PULLUP gilt häufig:
nicht gedrückt = HIGH
gedrückt = LOW
Stromversorgung ungeeignet
Motoren oder andere größere Verbraucher sollten nicht direkt über einen GPIO versorgt werden.
Eine sinnvolle Reihenfolge zum Lernen
Der ESP32 kann unglaublich viel.
Genau das kann am Anfang aber auch überfordern.
Deshalb gilt:
Nicht alles gleichzeitig lernen.
Eine sinnvolle Reihenfolge ist:
1. ESP32 vorbereiten
Arduino IDE installieren und ESP32 einrichten.
2. Hello World
Erstes Programm übertragen und Serial Monitor kennenlernen.
3. Code-Struktur
setup() und loop() verstehen.
4. LED
Ersten digitalen Ausgang programmieren.
5. Taster
Ersten digitalen Eingang auslesen.
6. Taster + LED
Eingabe und Ausgabe miteinander verbinden.
7. Potentiometer
Analoge Werte kennenlernen.
8. Sensor
Echte Messwerte erfassen.
9. Display
Messwerte anzeigen.
10. WLAN
ESP32 mit dem Netzwerk verbinden.
11. Webserver
ESP32 über einen Browser steuern.
12. Eigenes Projekt
Jetzt werden mehrere Funktionen miteinander kombiniert.
Die wichtigsten Befehle für den Einstieg
Für die ersten Projekte reichen überraschend wenige Befehle.
pinMode()
Legt fest, ob ein Pin beispielsweise als Eingang oder Ausgang verwendet wird.
digitalWrite()
Schaltet einen digitalen Ausgang.
digitalRead()
Liest einen digitalen Eingang.
analogRead()
Liest einen analogen Wert.
delay()
Wartet eine bestimmte Zeit.
Serial.begin()
Startet die serielle Kommunikation.
Serial.print()
Gibt Informationen aus.
Serial.println()
Gibt Informationen aus und beginnt danach eine neue Zeile.
if
Prüft eine Bedingung.
else
Bestimmt, was ansonsten passieren soll.
Mit diesen wenigen Grundlagen lassen sich bereits viele kleine ESP32-Projekte programmieren.
Das Wichtigste in 60 Sekunden
Der ESP32 ist ein programmierbarer Mikrocontroller.
Er besitzt Anschlüsse, sogenannte GPIOs.
Daran können beispielsweise angeschlossen werden:
Taster und Sensoren
als Eingänge
und
LEDs, Displays oder Steuerungen
als Ausgänge.
Das wichtigste Prinzip lautet:
Eingabe → Verarbeitung → Ausgabe
Ein ESP32-Programm besteht normalerweise mindestens aus:
void setup() {
}
void loop() {
}
setup() läuft einmal beim Start.
loop() läuft anschließend immer wieder.
Programme werden beispielsweise mit der Arduino IDE geschrieben und über USB auf den ESP32 übertragen.
Und später kommt die besondere Stärke des ESP32 hinzu:
WLAN und Bluetooth.
Damit können aus einfachen Elektronikprojekten vernetzte IoT-Geräte entstehen.
Wie geht es weiter?
Für Einsteiger bietet sich eine kleine Lernserie an:
Teil 1: ESP32 kennenlernen und einrichten
Arduino IDE, Hardware, USB und erstes Programm
Teil 2: ESP32 programmieren lernensetup(), loop(), Variablen, Bedingungen und Serial Monitor
Teil 3: Elektronik mit dem ESP32
GPIO, LED, Taster, Potentiometer und Sensoren
Teil 4: ESP32 und WLAN
WLAN-Verbindung, Webserver und erste IoT-Projekte
Danach ist die Grundlage geschaffen, um eigene Projekte umzusetzen.
Alle Beiträge dieser Serie
- Teil 1: ESP32 kennenlernen (Aktuell)
- Teil 2: ESP32 programmieren
- Teil 3: GPIO verstehen
- Teil 4: Taster anschließen und entprellen
- Teil 5: LEDs steuern
- Teil 6: Analoge Werte und ADC
Add your first comment to this post