ESP32 Unterricht erste Stunde: Checkliste und 40-Minuten-Ablauf

Wenn du die erste ESP32-Stunde im Unterricht planst, reduziere sie auf ein einziges Ziel: Am Ende hat jede Gruppe Code auf ihren eigenen ESP32 geladen und eine LED zum Leuchten gebracht. WLAN, Sensoren und Steuerung per Handy kommen in späteren Stunden. Ob 40 Minuten reichen, entscheidet weniger das, was du in der Stunde tust, als das, was du vorher erledigst: Ist der USB-Seriell-Treiber installiert, ist das ESP32-Board-Paket in der Arduino IDE, und überträgt das Kabel auf dem Tisch wirklich Daten? Sind diese drei Punkte erledigt, ist der erste Upload in fünf Minuten geschafft; wenn nicht, vergeht die halbe Stunde mit "Ich sehe keinen Port".

Hier bekommst du ein Paket, das du morgen mit in die Klasse nehmen kannst: eine kopierbare Checkliste für eine Woche vorher, den Vortag und den Morgen der Stunde, eine Materialtabelle, einen Ablauf Minute für Minute, zwei kompilierbare Sketche, fünf Unterschiede zwischen ESP32 und Arduino Uno, Ein-Minuten-Lösungen für die acht häufigsten Probleme und Abschlussfragen. Angenommen, du hast eine Klasse mit 24 Schülerinnen und Schülern und teilst sie in 8 Dreiergruppen; alle Zahlen beziehen sich darauf. Bei einer 45-Minuten-Stunde bleiben dir 5 Minuten Puffer. Falls der ESP32 für dich noch neu ist, lies zuerst Was ist der ESP32.

Ziel der ersten Stunde: warum nur eine LED?

In der ersten ESP32-Stunde hast du zwei Möglichkeiten: ein beeindruckendes WLAN-Projekt vorführen oder alle mit eigenen Händen etwas Kleines zum Laufen bringen lassen. Das Zweite bringt viel mehr. Um eine LED einzuschalten, muss jede Schülerin und jeder Schüler die ganze Kette einmal komplett durchlaufen: Code öffnen, Board und Port wählen, kompilieren, hochladen, Schaltung aufbauen, Ergebnis sehen, dann einen Wert ändern und neu hochladen. Funktioniert diese Kette einmal, kommen in späteren Stunden nur neue Bauteile dazu. Springst du vorher zum WLAN, stapeln sich Netzwerkpasswort, Treiber und Kabel übereinander, und welcher Teil den Fehler verursacht, lässt sich kaum noch auseinanderhalten. Deshalb gibt es in diesem Plan in der ersten Stunde kein Netzwerk: erst die interne LED des Boards, dann eine einzelne externe LED auf dem Steckbrett, und für schnelle Gruppen beide abwechselnd.

Checkliste zur Vorbereitung

Teile die Vorbereitung in drei Zeitpunkte auf. Du kannst die Liste kopieren, ausdrucken oder an die IT-Betreuung der Schule weitergeben; Aufgaben mit Administratorrechten wie Treiber- und Programminstallationen laufen an den meisten Schulen über sie. Eine Woche vorher:

• Boards zählen und Modell prüfen. Dieser Plan ist für das ESP32 DevKit mit 30 Pins (mit ESP32-WROOM-32-Modul) geschrieben; bei Boards mit 38 Pins ist der Code gleich, nur die Pinreihenfolge ist anders.
• Den kleinen Chip neben der USB-Buchse lesen: CP2102, CH340 oder CH9102? Davon hängt ab, welcher Treiber nötig ist.
• Arduino IDE 2 auf den Unterrichtsrechnern installieren lassen. Schulrechner brauchen dafür meist Administratorrechte, also einen Termin mit der IT vereinbaren.
• In der Arduino IDE über den Boardverwalter das Paket esp32 by Espressif Systems installieren. Es lädt mehrere hundert Megabyte herunter; im Schulnetz reichen 40 Minuten dafür womöglich nicht.
• Den USB-Seriell-Treiber installieren, ein Board anstecken und prüfen, ob unter Werkzeuge > Port ein neuer Port erscheint.
• Kabel testen: mit jedem Kabel einmal auf ein Board hochladen, reine Ladekabel aussortieren, Datenkabel mit farbigem Klebeband markieren.
• Einen ESP32 auf ein Steckbrett stecken und schauen, ob auf beiden Seiten noch Löcher frei bleiben. Wenn nicht, bekommt jede Gruppe zwei Steckbretter.
• Die Einschränkungen des Schulnetzes klären: Der ESP32 verbindet sich nur mit 2,4-GHz-WLAN, und Unternehmensnetze mit Benutzername und Passwort sind schwierig. In der ersten Stunde nutzt du kein WLAN, für spätere Stunden brauchst du diese Information aber schon jetzt.

Am Vortag sollte jeder Rechner unterrichtsbereit sein; Ziel ist, dass in der Stunde kein Installationsschritt zum ersten Mal passiert. Plane auch am Morgen der Stunde zehn Minuten ein. Beide Listen stehen hier zusammen:

• Vortag: Auf jedem Rechner einen Test-Upload machen. Board anstecken, ESP32 Dev Module und den Port wählen, den Sketch für die interne LED hochladen und das Blinken prüfen. Das erste Kompilieren kann über eine Minute dauern; der Test beschleunigt auch spätere Durchläufe.
• Vortag: Unter Windows die Portnummer (COM3, COM5 usw.) auf ein Etikett schreiben und seitlich an den Rechner kleben. Dasselbe Board an derselben USB-Buchse bekommt meist dieselbe Nummer.
• Vortag: Gruppenkisten packen: Board, Kabel, Steckbrett, zwei LEDs, zwei 220-Ω-Widerstände, vier Jumperkabel. Den Ersatzsatz auf dem Lehrertisch lassen.
• Vortag: Beide Sketche auf dem Desktop jedes Rechners speichern; wird das Internet langsam, öffnet die Klasse den Code von dort.
• Vortag: Prüfen, ob sich das Projekt ESP32 Interne LED Blinken in BlueGrays über den Beamer öffnen lässt.
• Morgen der Stunde: Rechner und Arduino IDE starten und prüfen, ob als Board noch ESP32 Dev Module eingestellt ist.
• Morgen der Stunde: Eine einfache Skizze des Boards an die Tafel zeichnen: USB-Buchse, BOOT, EN, GND, 3V3 und GPIO5 (auf dem Board steht D5).
• Morgen der Stunde: In eine Ecke der Tafel einen Satz schreiben: "Hängt es bei Connecting...? BOOT gedrückt halten."
• Morgen der Stunde: LEDs und Widerstände in den Kisten ein letztes Mal zählen und die Kabel obendrauf legen.

Treiber, Board-Paket und BOOT: Details, die du kennen solltest

Im Boardverwalter der Arduino IDE siehst du eventuell zwei ESP32-Pakete. Für Schulboards ist das Paket esp32 von Espressif das richtige; "Arduino ESP32 Boards" ist für Arduinos eigenes Nano ESP32 gedacht. Nach der Installation wählst du unter Werkzeuge > Board > esp32 das ESP32 Dev Module. Erscheint das Paket nicht in der Liste, musst du in den Voreinstellungen bei den zusätzlichen Boardverwalter-URLs die Paketadresse von Espressif eintragen; die Schritte findest du in Was ist der ESP32. ESP32-Sketche kompilieren länger als Uno-Sketche; selbst bei einer Blink-LED kann das erste Kompilieren über eine Minute dauern. Sag das der Klasse vorher, sonst wird bei scheinbar stehendem Fortschrittsbalken immer wieder auf Hochladen geklickt. Welcher Treiber nötig ist, hängt vom USB-Seriell-Chip ab:

Der BOOT-Taster ist mit GPIO0 des ESP32 verbunden. Beim Start eines Uploads muss das Board in den Programmiermodus wechseln; die meisten DevKits erledigen das selbst über zwei Signale des USB-Seriell-Chips. Bei manchen Kombinationen aus Board und Kabel klappt dieser automatische Wechsel nicht: Die Punkte hinter "Connecting..." werden immer mehr, und am Ende steht "Failed to connect to ESP32". Die Lösung: BOOT gedrückt halten, sobald "Connecting..." erscheint, und loslassen, wenn die Fortschrittszeilen mit "Writing at" durchlaufen. Der EN-Taster startet das Board neu; ist der Upload fertig, der Code scheint aber nicht zu laufen, genügt ein Druck auf EN. Tritt das Problem am selben Board immer wieder auf, hilft es meist, im Menü Werkzeuge die Upload Speed von 921600 auf 115200 zu senken. Unter macOS beginnt der Portname meist mit cu.usbserial oder cu.SLAB_USBtoUART.

Materialliste: pro Gruppe und für eine Klasse mit 24

Teilst du 24 Schülerinnen und Schüler in Dreiergruppen, ergeben sich 8 Gruppen; mit einem Ersatzsatz bereitest du 9 Sätze vor. Bei Zweiergruppen brauchst du 12 Gruppen plus Ersatz, also 13 Sätze, und entsprechend mehr Rechner. Kein Bauteil muss gelötet werden. Zwei LEDs und zwei Widerstände pro Gruppe haben einen einfachen Grund: Eine verkehrt herum gesteckte LED oder ein abgebrochenes Beinchen kommt in der ersten Stunde sehr oft vor, und keine Gruppe soll warten müssen.

Der 40-Minuten-Ablauf

Der Ablauf baut auf zwei kostenlosen BlueGrays-Projekten auf: zuerst ESP32 Interne LED Blinken (keine Schaltung, nur Board und Kabel), dann LED Blinken mit ESP32 (GPIO5, ein 220-Ω-Widerstand und eine LED). Bei beiden Projekten sind Bauteilliste, Schaltplan, Code, Blöcke und Code verstehen kostenlos freigeschaltet. Verteile in jeder Gruppe drei Rollen und wechsle sie in jeder Phase: eine Person an der Tastatur, eine baut die Schaltung, eine liest Schaltplan und Code vom Handy oder Beamer vor. So schaut niemand 40 Minuten lang nur zu.

Der Code: interne LED und externe LED

Die beiden Sketche unten verwenden dieselben Pins und Zeiten wie die Projekte in der App und lassen sich mit ausgewähltem ESP32 Dev Module direkt in der Arduino IDE kompilieren. Der erste lässt die LED auf dem Board im Sekundentakt blinken. Bei den meisten ESP32 DevKits ist diese blaue LED mit GPIO2 verbunden. Beim Arduino Uno lag die interne LED an Pin 13; wer schon mit dem Uno gearbeitet hat, tippt aus Gewohnheit vielleicht 13, also weise früh auf den Unterschied hin.

1// ESP32 Dahili LED Yakma / ESP32 built-in LED blink
2// Çoğu ESP32 DevKit kartında dahili LED GPIO2'dedir / On most ESP32 DevKit boards the built-in LED is on GPIO2
3int BUILTIN_LED_PIN = 2;   // Kartına göre değişebilir / May differ on your board
4
5void setup() {
6  pinMode(BUILTIN_LED_PIN, OUTPUT);   // Pini çıkış yap / Set the pin as output
7}
8
9void loop() {
10  digitalWrite(BUILTIN_LED_PIN, HIGH);   // LED'i yak / Turn the LED on
11  delay(1000);                           // 1 saniye bekle / Wait 1 second
12  digitalWrite(BUILTIN_LED_PIN, LOW);    // LED'i söndür / Turn the LED off
13  delay(1000);                           // 1 saniye bekle / Wait 1 second
14}
15

Die Schaltung für den zweiten Sketch: von GPIO5 zu einem Ende des 220-Ω-Widerstands, vom anderen Ende des Widerstands zum langen Beinchen der LED (Anode), vom kurzen Beinchen (Kathode) zu GND. Der ESP32-Pin liefert 3,3 V; an einer roten LED fallen etwa 2 V ab, die restlichen 1,3 V treiben über 220 Ω rund 6 mA. Das reicht für eine gut sichtbare LED und belastet den Pin nicht. Nimmst du eine andere Farbe, prüfe den Widerstand mit dem LED-Vorwiderstandsrechner. In der Mini-Aufgabe kombinieren schnelle Gruppen beide Sketche: In setup() werden beide Pins Ausgänge, in loop() wird einer auf HIGH gesetzt, während der andere LOW ist.

1// ESP32 ile LED Yakma: harici LED / ESP32 external LED blink
2// Bağlantı: GPIO5 -> 220 Ω direnç -> LED uzun bacak (+), kısa bacak (-) -> GND
3// Wiring: GPIO5 -> 220 ohm resistor -> LED long leg (+), short leg (-) -> GND
4const int LED_PIN = 5;   // Harici LED pini (kartta D5) / External LED pin (D5 on the board)
5
6void setup() {
7  pinMode(LED_PIN, OUTPUT);   // Pini çıkış yap / Set the pin as output
8}
9
10void loop() {
11  digitalWrite(LED_PIN, HIGH);   // Pin 3,3 V verir, LED yanar / Pin outputs 3.3 V, LED on
12  delay(500);                    // Yarım saniye bekle / Wait half a second
13  digitalWrite(LED_PIN, LOW);    // Pin 0 V verir, LED söner / Pin outputs 0 V, LED off
14  delay(500);                    // Yarım saniye bekle / Wait half a second
15}
16

5 Unterschiede zwischen ESP32 und Arduino Uno

Einige in deiner Klasse kennen vielleicht schon den Arduino Uno. Der Code wird in derselben Arduino-Sprache geschrieben, setup() und loop() sind an ihrem Platz, aber die Hardware ist anders, und die meisten Fehler der ersten Stunde kommen genau daher. Die fünf Punkte unten erklärst du in wenigen Minuten, während ihr das Board kennenlernt. Einen ausführlicheren Vergleich findest du in Arduino oder ESP32.

Die 8 häufigsten Probleme im Unterricht und Ein-Minuten-Lösungen

Abschlussfragen und Ausblick auf die zweite Stunde

1. Welchen Pin auf dem Board meint die Zahl 5 im Code? Warum steht neben diesem Pin vielleicht "D5"?
2. Was hat sich an der LED geändert, als ihr delay(200) statt delay(1000) geschrieben habt? Wie oft pro Sekunde blinkt die LED jetzt?
3. Warum hat die LED nicht geleuchtet, als sie verkehrt herum steckte? Welches Beinchen der LED kommt auf die Seite des Widerstands?
4. Welche Spannung liefern die Pins des ESP32? Warum sollten wir eine LED oder ein Modul nicht direkt an den 5V-Pin anschließen?

Die Antworten zeigen dir, welcher Begriff in der zweiten Stunde wiederholt werden muss; wer bei der zweiten Frage 2,5 sagt, hat das Timing verstanden. In der zweiten Stunde kommt ein Taster zur selben Schaltung: Beim Projekt ESP32 LED-Steuerung mit Drucktaste (Push) leuchtet die LED, solange der Taster gedrückt ist, bei ESP32 LED Steuerung mit Taster (Toggle) wechselt sie bei jedem Druck ihren Zustand. Beide sind kostenlos und haben Blöcke; die Klasse liest zum ersten Mal einen Eingang und entscheidet mit if. In der dritten oder vierten Stunde kannst du zum WLAN übergehen; halte dafür die Statuscode-Tabelle aus ESP32 verbindet sich nicht mit WLAN bereit. Die WLAN-Projekte für den ESP32 sind in BlueGrays Premium; wenn deine Klasse damit weitermachen soll, erklären wir in Premium-Codes für die Klasse, wie du statt einzelner Abos jedem einen Code aus einem Lehrer-Paket gibst.

Wie nutzt du BlueGrays im Unterricht?

• Projekt finden: In Entdecken › Projekte mit Filtern die Plattform ESP32 und beim Preisstatus kostenlos wählen. ESP32-Projekte für die ersten Stunden wie LED, Taster, Ampel, Lichtsensor und Abstandssensor sind komplett freigeschaltet.
• Benötigte Bauteile und Schaltplan: Die Bauteilliste ist mit Stückzahlen fertig. Den Schaltplan kannst du vergrößern und an den Beamer bringen oder mit In Galerie speichern sichern und ausdrucken.
• Quellcode: Mit Kopieren landet der Code in der Zwischenablage. Hat jemand das Projekt auf dem Handy geöffnet, liefert Link kopieren einen Link, um den Code am Rechner zu öffnen, sodass niemand abtippen muss.
• Code verstehen: Zuerst die Zusammenfassung Was macht dieser Code?, dann die Erklärung Schritt für Schritt, der Abschnitt Wenn du nicht weiterkommst und die Aufgabe Probier es selbst. Ein fertiger nächster Schritt für Gruppen, die früh mit der Mini-Aufgabe fertig sind.
• Als Blöcke zeigen: Alle kostenlosen ESP32-Projekte haben eine Blockansicht. Schaltest du sie ein, erscheinen statt des Codes die Blöcke desselben Programms, und der Tab heißt Blöcke verstehen. Die Blöcke sind zum Lesen da; sie werden in der App nicht bearbeitet und nicht auf das Board geladen, aufs Board kommt immer der echte Code.
• Lass es uns zusammen bauen: Ein geführter Modus mit den Schritten Bauteile bereitlegen, Schaltung aufbauen, Code hochladen sowie Starten und testen. Der Bildschirm bleibt an, sodass die Gruppe den Schritten folgen kann, während das Handy auf dem Tisch liegt; am Ende markiert Gebaut das Projekt als erledigt.

Die erste Stunde sieht vielleicht nur nach einer LED aus, aber in diesen 40 Minuten erleben alle einmal Kompilieren, Hochladen, Pinnummern, die 3,3-V-Grenze und Fehlersuche, und jede weitere ESP32-Stunde baut darauf auf. Alle Bereiche der Projektseite erklären wir ausführlich im Leitfaden zur Projektseite. Wenn du beide Projekte vor der Stunde einmal selbst bauen willst, öffne in der BlueGrays-App das Projekt ESP32 Interne LED Blinken; Schaltplan, Code, Blöcke und Code verstehen sind fertig, und deine Generalprobe dauert keine zehn Minuten.