SENSOREN/AKTOREN

ESP32 S3 - Ampel

Dieses Tutorial zeigt Ihnen, wie Sie mit dem ESP32 S3 ein Ampelmodul steuern. Sie lernen, wie Sie das Modul verdrahten, den ESP32 S3 so programmieren, dass er die Ampelphasen durchläuft, und den Code anschließend mithilfe von Funktionen und des nicht blockierenden millis()-Ansatzes optimieren.

Was Sie bauen werden:

Ein Ampelmodul mit der ESP32-S3-Platine verdrahten
Den ESP32 S3 so programmieren, dass rotes, gelbes und grünes Licht nacheinander durchlaufen werden
Den Code mit einer eigenen Steuerfunktion für eine übersichtlichere Logik umstrukturieren
Eine nicht blockierende Version mit millis() statt delay() umsetzen

Erforderliche Hardware

1	×	ESP32 S3 WROOM N16R8
1	×	(Alternativ) ESP32 S3 SuperMini Dev Module
1	×	(Alternativ) ESP32 S3 Uno-form Board
1	×	(Alternativ) ESP32 S3 Camera Board
1	×	USB-Kabel Typ-A zu Typ-C (für USB-A PC)
1	×	USB-Kabel Typ-C zu Typ-C (für USB-C PC)
1	×	Ampel-Modul
1	×	Verbindungskabel
1	×	(Empfohlen) Screw Terminal Expansion Board for ESP32 S3
1	×	(Empfohlen) Breakout Expansion Board for ESP32 S3
1	×	(Empfohlen) Power Splitter for ESP32 S3

Oder Sie können die folgenden Kits kaufen:

1	×	DIYables ESP32 S3 Starter-Kit (ESP32 S3 enthalten)
1	×	DIYables Sensor-Kit (18 Sensoren/Displays)

Offenlegung: Einige der in diesem Abschnitt bereitgestellten Links sind Amazon-Affiliate-Links. Wir können eine Provision für Käufe erhalten, die über diese Links getätigt werden, ohne zusätzliche Kosten für Sie. Wir schätzen Ihre Unterstützung.

Überblick über Traffic Light Module

Ein Ampelmodul vereint drei farbige LEDs – Rot, Gelb und Grün – in einem einzigen kompakten Bauteil, das sich leicht verdrahten und programmieren lässt. Es wird häufig in Embedded-Projekten eingesetzt, um Kreuzungssignale zu simulieren, Ablauflogik zu vermitteln und die GPIO-Ausgangssteuerung an Mikrocontrollern wie dem ESP32 S3 zu demonstrieren. Das Modul übernimmt die Strombegrenzung intern, daher sind keine externen Widerstände erforderlich.

Wichtige Spezifikationen

Betriebsspannung: 3,3 V–5 V (kompatibel mit dem GPIO-Ausgang des ESP32 S3)
Pins: GND, R (Rot), Y (Gelb), G (Grün)
Integrierte Vorwiderstände für jede LED

Pinbelegung

Ein Ampelmodul hat 4 Pins:

GND-Pin: Der Masse-Pin, verbinden Sie diesen Pin mit GND des ESP32 S3.
R-Pin: Der Pin zur Steuerung des roten Lichts, verbinden Sie diesen Pin mit einem digitalen Ausgang des ESP32 S3.
Y-Pin: Der Pin zur Steuerung des gelben Lichts, verbinden Sie diesen Pin mit einem digitalen Ausgang des ESP32 S3.
G-Pin: Der Pin zur Steuerung des grünen Lichts, verbinden Sie diesen Pin mit einem digitalen Ausgang des ESP32 S3.

Verdrahtungsdiagramm

Schließen Sie das Ampelmodul an den ESP32 S3 an, indem Sie jeden Signalpin (R, Y, G) mit einem separaten GPIO-Ausgangspin und den GND-Pin mit einem beliebigen Masseanschluss der Platine verbinden. Verwenden Sie Jumperkabel für eine saubere und zuverlässige Verbindung zwischen dem Modul und den Stiftleisten des ESP32 S3.

Sicherheitshinweise

Das Ampelmodul enthält integrierte Vorwiderstände, daher sind zwischen dem Modul und den GPIO-Pins des ESP32 S3 keine zusätzlichen Widerstände nötig. Halten Sie die Verdrahtung ordentlich und prüfen Sie die GND-Verbindung, bevor Sie die Platine mit Strom versorgen, um unregelmäßiges LED-Verhalten zu vermeiden.

Dieses Bild wurde mit Fritzing erstellt. Klicken Sie, um das Bild zu vergrößern.

GPIO-Pin	Ampelmodul
GPIO 40	R (Rot)
GPIO 41	Y (Gelb)
GPIO 42	G (Grün)
GND	GND

Wie man das Ampelmodul programmiert

Konfigurieren Sie die Pins des ESP32 S3 mit der Funktion pinMode() als digitale Ausgänge

pinMode(PIN_RED, OUTPUT); pinMode(PIN_YELLOW, OUTPUT); pinMode(PIN_GREEN, OUTPUT);

Programmieren Sie das Einschalten des roten Lichts mit der Funktion digitalWrite():

digitalWrite(PIN_RED, HIGH); // turn on RED digitalWrite(PIN_YELLOW, LOW); digitalWrite(PIN_GREEN, LOW); delay(RED_TIME); // keep red LED on during a period of time

ESP32-S3-Code

Der folgende Code zeigt, wie Sie das Ampelmodul mit dem ESP32 S3 über einfache digitalWrite()-Aufrufe und delay() für das Timing steuern. Jede Phase des Ampelzyklus – Rot, Gelb und Grün – wird nacheinander aktiviert, indem der entsprechende Pin auf HIGH gesetzt wird, während die anderen auf LOW bleiben. Laden Sie diesen Code auf Ihre ESP32-S3-Platine hoch, um die Ampelsequenz direkt nach dem Start ablaufen zu sehen.

/* * Dieser ESP32 S3 Code wurde von newbiely.de entwickelt * Dieser ESP32 S3 Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt. * Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte: * https://newbiely.de/tutorials/esp32-s3/esp32-s3-traffic-light */ /* * This ESP32-S3 code is created by esp32io.com * * This ESP32-S3 code is released in the public domain * * For more detail (instruction and wiring diagram), visit https://esp32io.com/tutorials/esp32-s3-traffic-light */ #define PIN_RED 40 // The ESP32-S3 pin GPIO40 connected to R pin of traffic light module #define PIN_YELLOW 41 // The ESP32-S3 pin GPIO41 connected to Y pin of traffic light module #define PIN_GREEN 42 // The ESP32-S3 pin GPIO42 connected to G pin of traffic light module #define RED_TIME 4000 // RED time in millisecond #define YELLOW_TIME 4000 // YELLOW time in millisecond #define GREEN_TIME 4000 // GREEN time in millisecond void setup() { pinMode(PIN_RED, OUTPUT); pinMode(PIN_YELLOW, OUTPUT); pinMode(PIN_GREEN, OUTPUT); } // the loop function runs over and over again forever void loop() { // red light on digitalWrite(PIN_RED, HIGH); // turn on digitalWrite(PIN_YELLOW, LOW); // turn off digitalWrite(PIN_GREEN, LOW); // turn off delay(RED_TIME); // keep red light on during a period of time // yellow light on digitalWrite(PIN_RED, LOW); // turn off digitalWrite(PIN_YELLOW, HIGH); // turn on digitalWrite(PIN_GREEN, LOW); // turn off delay(YELLOW_TIME); // keep yellow light on during a period of time // green light on digitalWrite(PIN_RED, LOW); // turn off digitalWrite(PIN_YELLOW, LOW); // turn off digitalWrite(PIN_GREEN, HIGH); // turn on delay(GREEN_TIME); // keep green light on during a period of time }

Schnelle Schritte

Neu beim ESP32 S3? Arbeiten Sie zuerst unsere Anleitung Erste Schritte mit dem ESP32 S3 durch.
Führen Sie die Verdrahtung wie im obigen Schaltplan gezeigt durch.
Verbinden Sie die ESP32-S3-Platine über ein USB-Typ-C-Kabel mit Ihrem PC.
Öffnen Sie die Arduino IDE auf Ihrem PC.
Wählen Sie die richtige ESP32-S3-Platine (z. B. ESP32S3 Dev Module) und den COM-Port aus.
Kopieren Sie den obigen Code und fügen Sie ihn in die Arduino IDE ein.
Klicken Sie in der Arduino IDE auf die Schaltfläche Upload, um den Code auf den ESP32 S3 hochzuladen.
Beobachten Sie, wie das Ampelmodul Rot, Gelb und Grün durchläuft.
Profi-Tipp: Passen Sie die Konstanten RED_TIME, YELLOW_TIME und GREEN_TIME am Anfang des Sketches an, um unterschiedliche Kreuzungs-Timings aus Ihrer Region zu simulieren.

Beachten Sie, dass die genaue Funktionsweise einer Ampel je nach Design und Technologie in verschiedenen Regionen und an verschiedenen Kreuzungen variieren kann. Die oben beschriebenen Prinzipien vermitteln ein allgemeines Verständnis davon, wie Ampeln den Verkehr regeln und die Sicherheit auf den Straßen erhöhen.

Der obige Code zeigt die Steuerung einzelner Lichter. Nun verbessern wir den Code für eine bessere Optimierung.

ESP32-S3-Code-Optimierung

Verbessern wir den Code, indem wir eine Funktion zur Lichtsteuerung einführen.

/* * Dieser ESP32 S3 Code wurde von newbiely.de entwickelt * Dieser ESP32 S3 Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt. * Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte: * https://newbiely.de/tutorials/esp32-s3/esp32-s3-traffic-light */ /* * This ESP32-S3 code is created by esp32io.com * * This ESP32-S3 code is released in the public domain * * For more detail (instruction and wiring diagram), visit https://esp32io.com/tutorials/esp32-s3-traffic-light */ #define PIN_RED 40 // The ESP32-S3 pin GPIO40 connected to R pin of traffic light module #define PIN_YELLOW 41 // The ESP32-S3 pin GPIO41 connected to Y pin of traffic light module #define PIN_GREEN 42 // The ESP32-S3 pin GPIO42 connected to G pin of traffic light module #define RED_TIME 2000 // RED time in millisecond #define YELLOW_TIME 1000 // YELLOW time in millisecond #define GREEN_TIME 2000 // GREEN time in millisecond #define RED 0 // Index in array #define YELLOW 1 // Index in array #define GREEN 2 // Index in array const int pins[] = { PIN_RED, PIN_YELLOW, PIN_GREEN }; const int times[] = { RED_TIME, YELLOW_TIME, GREEN_TIME }; void setup() { pinMode(PIN_RED, OUTPUT); pinMode(PIN_YELLOW, OUTPUT); pinMode(PIN_GREEN, OUTPUT); } // the loop function runs over and over again forever void loop() { // red light on trafic_light_on(RED); delay(times[RED]); // keep red light on during a period of time // yellow light on trafic_light_on(YELLOW); delay(times[YELLOW]); // keep yellow light on during a period of time // green light on trafic_light_on(GREEN); delay(times[GREEN]); // keep green light on during a period of time } void trafic_light_on(int light) { for (int i = RED; i <= GREEN; i++) { if (i == light) digitalWrite(pins[i], HIGH); // turn on else digitalWrite(pins[i], LOW); // turn off } }

Verbessern wir den Code mithilfe einer for-Schleife.

/* * Dieser ESP32 S3 Code wurde von newbiely.de entwickelt * Dieser ESP32 S3 Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt. * Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte: * https://newbiely.de/tutorials/esp32-s3/esp32-s3-traffic-light */ /* * This ESP32-S3 code is created by esp32io.com * * This ESP32-S3 code is released in the public domain * * For more detail (instruction and wiring diagram), visit https://esp32io.com/tutorials/esp32-s3-traffic-light */ #define PIN_RED 40 // The ESP32-S3 pin GPIO40 connected to R pin of traffic light module #define PIN_YELLOW 41 // The ESP32-S3 pin GPIO41 connected to Y pin of traffic light module #define PIN_GREEN 42 // The ESP32-S3 pin GPIO42 connected to G pin of traffic light module #define RED_TIME 2000 // RED time in millisecond #define YELLOW_TIME 1000 // YELLOW time in millisecond #define GREEN_TIME 2000 // GREEN time in millisecond #define RED 0 // Index in array #define YELLOW 1 // Index in array #define GREEN 2 // Index in array const int pins[] = {PIN_RED, PIN_YELLOW, PIN_GREEN}; const int times[] = {RED_TIME, YELLOW_TIME, GREEN_TIME}; void setup() { pinMode(PIN_RED, OUTPUT); pinMode(PIN_YELLOW, OUTPUT); pinMode(PIN_GREEN, OUTPUT); } // the loop function runs over and over again forever void loop() { for (int light = RED; light <= GREEN; light ++) { trafic_light_on(light); delay(times[light]); // keep light on during a period of time } } void trafic_light_on(int light) { for (int i = RED; i <= GREEN; i ++) { if (i == light) digitalWrite(pins[i], HIGH); // turn on else digitalWrite(pins[i], LOW); // turn off } }

Verbessern wir den Code, indem wir die Funktion millis() statt delay() verwenden.

/* * Dieser ESP32 S3 Code wurde von newbiely.de entwickelt * Dieser ESP32 S3 Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt. * Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte: * https://newbiely.de/tutorials/esp32-s3/esp32-s3-traffic-light */ /* * This ESP32-S3 code is created by esp32io.com * * This ESP32-S3 code is released in the public domain * * For more detail (instruction and wiring diagram), visit https://esp32io.com/tutorials/esp32-s3-traffic-light */ #define PIN_RED 40 // The ESP32-S3 pin GPIO40 connected to R pin of traffic light module #define PIN_YELLOW 41 // The ESP32-S3 pin GPIO41 connected to Y pin of traffic light module #define PIN_GREEN 42 // The ESP32-S3 pin GPIO42 connected to G pin of traffic light module #define RED_TIME 2000 // RED time in millisecond #define YELLOW_TIME 1000 // YELLOW time in millisecond #define GREEN_TIME 2000 // GREEN time in millisecond #define RED 0 // Index in array #define YELLOW 1 // Index in array #define GREEN 2 // Index in array const int pins[] = { PIN_RED, PIN_YELLOW, PIN_GREEN }; const int times[] = { RED_TIME, YELLOW_TIME, GREEN_TIME }; unsigned long last_time = 0; int light = RED; // start with RED light void setup() { pinMode(PIN_RED, OUTPUT); pinMode(PIN_YELLOW, OUTPUT); pinMode(PIN_GREEN, OUTPUT); trafic_light_on(light); last_time = millis(); } // the loop function runs over and over again forever void loop() { if ((millis() - last_time) > times[light]) { light++; if (light >= 3) light = RED; // new circle trafic_light_on(light); last_time = millis(); } // TO DO: your other code } void trafic_light_on(int light) { for (int i = RED; i <= GREEN; i++) { if (i == light) digitalWrite(pins[i], HIGH); // turn on else digitalWrite(pins[i], LOW); // turn off } }

Ausgabe im Seriellen Monitor

Öffnen Sie den Seriellen Monitor mit 9600 Baud, um Laufzeitmeldungen des ESP32 S3 zu beobachten. Im Folgenden sehen Sie Beispielausgaben, die im Betrieb erscheinen können:

Newbiely | Arduino IDE 2.3.8

──

☐

Newbiely.ino

···

8 Serial.println("Hello World!");

Output

Serial Monitor

Message (Enter to send message to 'ESP32S3 Dev Module' on 'COM15')

New Line

9600 baud

[2026-06-16 10:00:00] Traffic light started [2026-06-16 10:00:00] RED ON [2026-06-16 10:00:05] YELLOW ON [2026-06-16 10:00:07] GREEN ON

Ln 11, Col 1

ESP32S3 Dev Module on COM15

Anwendungen

Die Steuerung eines Ampelmoduls mit dem ESP32 S3 vermittelt Fähigkeiten in Ablaufsteuerung und GPIO-Ausgangsverwaltung, die sich direkt auf viele praktische Embedded-Systeme übertragen lassen. Hier einige Anwendungsfälle aus der Praxis:

Kreuzungssimulation: Bauen Sie eine echte Ampelsteuerung für Kreuzungen mit konfigurierbarem Timing für jede Lichtphase nach.
Industrielles Statuspanel: Verwenden Sie die drei Farben zur Darstellung von Maschinenzuständen wie Leerlauf (Grün), Warnung (Gelb) und Störung (Rot).
Fußgängerampel: Fügen Sie dem ESP32 S3 einen Taster als Eingang hinzu, damit ein Fußgänger bei Bedarf Grün anfordern kann.
Fertigungslinien-Anzeige: Signalisieren Sie Arbeitsschritte an einem Fließband, indem Sie die roten, gelben und grünen Ausgänge als Prozesszustandsanzeigen nutzen.
Lehrdemonstration: Veranschaulichen Sie Studierenden, die Embedded-Programmierung lernen, Konzepte von Zustandsautomaten und nicht blockierende Timing-Techniken.

Video Tutorial

Wir erwägen die Erstellung von Video-Tutorials. Wenn Sie Video-Tutorials für wichtig halten, abonnieren Sie bitte unseren YouTube-Kanal , um uns zu motivieren, die Videos zu erstellen.

Sehen Sie sich unten die Schritt-für-Schritt-Videoanleitung für dieses ESP32-S3-Projekt an.

Herausforderungen

Das Üben von Varianten dieses Projekts vertieft Ihr Verständnis von GPIO-Ablaufsteuerung und Timing auf dem ESP32 S3. Probieren Sie die folgenden Übungen aus, um Ihre Fähigkeiten zu erweitern:

Anfänger: Ändern Sie die Timing-Konstanten so, dass das gelbe Licht 3 Sekunden und das grüne Licht 8 Sekunden lang leuchtet, laden Sie den Code erneut hoch und beobachten Sie den Unterschied.
Fortgeschritten: Fügen Sie einen Taster am ESP32 S3 hinzu, der beim Drücken die Ampel sofort auf Rot schaltet und diese 10 Sekunden lang hält, bevor der normale Zyklus fortgesetzt wird.
Experte: Schreiben Sie die Ampelsteuerung als endlichen Zustandsautomaten (FSM) mit millis() neu, sodass die Sequenz vollständig nicht blockierend ist und der ESP32 S3 andere Aufgaben – etwa das Auslesen eines Sensors – erledigen kann, während die Lichter unabhängig durchlaufen.