CAPTEURS/ACTIONNEURS

ESP32 S3 - Feu de circulation

Ce tutoriel vous montre comment utiliser l'ESP32 S3 pour contrôler un module de feu de circulation. Vous apprendrez à câbler le module, à programmer l'ESP32 S3 pour parcourir les états du feu de circulation, puis à optimiser le code en utilisant des fonctions et l'approche non bloquante millis().

Ce que vous allez construire :

Câbler un module de feu de circulation à la carte ESP32 S3
Programmer l'ESP32 S3 pour faire passer les feux rouge, jaune et vert en séquence
Refactoriser le code en utilisant une fonction de contrôle dédiée pour une logique plus propre
Implémenter une version non bloquante utilisant millis() au lieu de delay()

Matériel requis

1	×	ESP32 S3 WROOM N16R8
1	×	Alternativement: ESP32 S3 SuperMini Dev Module
1	×	Alternativement: ESP32 S3 Uno-form Board
1	×	Alternativement: ESP32 S3 Camera Board
1	×	Câble USB Type-A vers Type-C (pour PC USB-A)
1	×	Câble USB Type-C vers Type-C (pour PC USB-C)
1	×	Module feu de circulation
1	×	Fils de connexion
1	×	Recommandé: Screw Terminal Expansion Board for ESP32 S3
1	×	Recommandé: Breakout Expansion Board for ESP32 S3
1	×	Recommandé: Power Splitter for ESP32 S3

Ou vous pouvez acheter les kits suivants:

1	×	Kit de Démarrage DIYables ESP32 S3 (ESP32 S3 inclus)
1	×	Kit de Capteurs DIYables (18 capteurs/écrans)

Divulgation : Certains des liens fournis dans cette section sont des liens affiliés Amazon. Nous pouvons recevoir une commission pour tout achat effectué via ces liens, sans coût supplémentaire pour vous. Nous vous remercions de votre soutien.

À propos du module de feu de circulation

Un module de feu de circulation intègre trois LED colorées — rouge, jaune et verte — dans un seul boîtier compact facile à câbler et à programmer. Il est couramment utilisé dans les projets embarqués pour simuler des signaux de carrefour, enseigner la logique de séquencement, et démontrer le contrôle de sortie GPIO sur des microcontrôleurs comme l'ESP32 S3. Le module gère en interne la limitation de courant, donc aucune résistance externe n'est nécessaire.

Caractéristiques principales

Tension de fonctionnement : 3,3V–5V (compatible avec la sortie GPIO de l'ESP32 S3)
Broches : GND, R (rouge), Y (jaune), G (vert)
Résistances limiteuses de courant intégrées pour chaque LED

Brochage

Un module de feu de circulation comprend 4 broches :

Broche GND : La broche de masse, connectez cette broche à GND de l'ESP32 S3.
Broche R : La broche pour contrôler le feu rouge, connectez cette broche à une sortie numérique de l'ESP32 S3.
Broche Y : La broche pour contrôler le feu jaune, connectez cette broche à une sortie numérique de l'ESP32 S3.
Broche G : La broche pour contrôler le feu vert, connectez cette broche à une sortie numérique de l'ESP32 S3.

Schéma de câblage

Connectez le module de feu de circulation à l'ESP32 S3 en reliant chaque broche de signal (R, Y, G) à une broche de sortie GPIO séparée et la broche GND à n'importe quelle masse de la carte. Utilisez des fils de liaison pour établir une connexion propre et fiable entre le module et les connecteurs de l'ESP32 S3.

Consignes de sécurité

Le module de feu de circulation inclut des résistances limiteuses de courant intégrées, donc aucune résistance supplémentaire n'est nécessaire entre le module et les broches GPIO de l'ESP32 S3. Gardez le câblage bien rangé et vérifiez bien la connectivité GND avant de mettre la carte sous tension pour éviter un comportement erratique des LED.

Schéma de câblage feu de circulation ESP32 S3

Cette image a été créée avec Fritzing. Cliquez pour agrandir l'image.

Broche GPIO	Module de feu de circulation
GPIO 40	R (Rouge)
GPIO 41	Y (Jaune)
GPIO 42	G (Vert)
GND	GND

Comment programmer pour le module de feu de circulation

Configurez les broches de l'ESP32 S3 en mode sortie numérique en utilisant la fonction pinMode()

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

Programmez pour allumer le feu rouge en utilisant la fonction 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

Code ESP32 S3

Le code suivant illustre comment contrôler le module de feu de circulation avec l'ESP32 S3 en utilisant de simples appels digitalWrite() et delay() pour le minutage. Chaque étape du cycle de circulation — rouge, jaune et vert — est activée tour à tour en mettant la broche appropriée à HIGH tout en gardant les autres à LOW. Téléversez ce code sur votre carte ESP32 S3 pour voir la séquence du feu de circulation s'exécuter immédiatement après le démarrage.

/* * Ce code ESP32 S3 a été développé par newbiely.fr * Ce code ESP32 S3 est mis à disposition du public sans aucune restriction. * Pour des instructions complètes et des schémas de câblage, veuillez visiter: * https://newbiely.fr/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 }

Étapes rapides

Nouveau sur l'ESP32 S3 ? Suivez d'abord notre guide ESP32 S3 - Premiers pas.
Effectuez le câblage comme indiqué sur le schéma ci-dessus.
Connectez la carte ESP32 S3 à votre PC via un câble USB Type-C.
Ouvrez l'Arduino IDE sur votre PC.
Sélectionnez la bonne carte ESP32 S3 (par exemple ESP32S3 Dev Module) et le port COM.
Copiez le code ci-dessus et collez-le dans l'Arduino IDE.
Cliquez sur le bouton Upload de l'Arduino IDE pour téléverser le code sur l'ESP32 S3.
Observez le module de feu de circulation passer par le rouge, le jaune et le vert.
Astuce : Ajustez les constantes RED_TIME, YELLOW_TIME et GREEN_TIME en haut du sketch pour simuler différents minutages de carrefour utilisés dans votre région.

Il est important de noter que le fonctionnement exact d'un feu de circulation peut varier selon la conception spécifique et la technologie utilisée dans différentes régions et différents carrefours. Les principes décrits ci-dessus donnent une compréhension générale du fonctionnement des feux de circulation pour gérer la circulation et améliorer la sécurité sur les routes.

Le code ci-dessus illustre le contrôle individuel des feux. Maintenant, améliorons le code pour une meilleure optimisation.

Optimisation du code ESP32 S3

Améliorons le code en implémentant une fonction pour le contrôle des feux.

/* * Ce code ESP32 S3 a été développé par newbiely.fr * Ce code ESP32 S3 est mis à disposition du public sans aucune restriction. * Pour des instructions complètes et des schémas de câblage, veuillez visiter: * https://newbiely.fr/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 } }

Améliorons le code en utilisant une boucle for.

/* * Ce code ESP32 S3 a été développé par newbiely.fr * Ce code ESP32 S3 est mis à disposition du public sans aucune restriction. * Pour des instructions complètes et des schémas de câblage, veuillez visiter: * https://newbiely.fr/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 } }

Améliorons le code en utilisant la fonction millis() au lieu de delay().

/* * Ce code ESP32 S3 a été développé par newbiely.fr * Ce code ESP32 S3 est mis à disposition du public sans aucune restriction. * Pour des instructions complètes et des schémas de câblage, veuillez visiter: * https://newbiely.fr/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 } }

Résultat sur le moniteur série

Ouvrez le moniteur série à 9600 bauds pour observer les messages d'exécution de l'ESP32 S3. Voici des exemples de relevés que vous pourriez voir pendant le fonctionnement :

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

Applications

Contrôler un module de feu de circulation avec l'ESP32 S3 enseigne des compétences de séquencement et de gestion de sortie GPIO qui s'appliquent directement à de nombreux systèmes embarqués pratiques. Voici quelques cas d'usage réels :

Simulation de carrefour : Recréez un contrôleur de carrefour réel avec un minutage configurable pour chaque phase de feu.
Panneau d'état industriel : Utilisez les trois couleurs pour représenter des états de machine comme inactif (vert), avertissement (jaune) et défaut (rouge).
Signal de passage piéton : Ajoutez une entrée bouton à l'ESP32 S3 pour permettre à un piéton de demander un feu vert à la demande.
Indicateur de ligne de production : Signalez les étapes de flux de travail sur une chaîne de montage en utilisant les sorties rouge, jaune et verte comme indicateurs d'état de processus.
Démo éducative : Démontrez les concepts de machine à états et les techniques de minutage non bloquant aux étudiants apprenant la programmation embarquée.

Vidéo

Regardez ci-dessous le tutoriel vidéo étape par étape pour ce projet ESP32 S3.

Défis

Pratiquer des variations de ce projet approfondira votre compréhension du séquencement GPIO et du contrôle de minutage sur l'ESP32 S3. Essayez les exercices suivants pour étendre vos compétences :

Débutant : Changez les constantes de minutage pour que le feu jaune reste allumé 3 secondes et le feu vert reste allumé 8 secondes, puis retéléversez et observez la différence.
Intermédiaire : Ajoutez un bouton poussoir connecté à l'ESP32 S3 qui, une fois pressé, fait immédiatement passer le feu au rouge et le maintient pendant 10 secondes avant de reprendre le cycle normal.
Avancé : Réécrivez le contrôleur de feu de circulation en utilisant une machine à états finis (FSM) avec millis() afin que la séquence soit entièrement non bloquante, permettant à l'ESP32 S3 de gérer d'autres tâches — comme lire un capteur — pendant que les feux tournent indépendamment.

Références des fonctions

Commentaires

Tutoriels connexes

※ NOS MESSAGES

N'hésitez pas à partager le lien de ce tutoriel. Cependant, veuillez ne pas utiliser notre contenu sur d'autres sites web. Nous avons investi beaucoup d'efforts et de temps pour créer ce contenu, veuillez respecter notre travail !