Arduino UNO Q - Feu de Circulation
Dans ce tutoriel, vous apprendrez à contrôler un module de feu de circulation en utilisant l'Arduino UNO Q. Nous couvrirons plusieurs approches de codage — d'une séquence simple basée sur delay() à une version non-bloquante avec millis() — puis nous étendrons le projet pour permettre le contrôle à distance des durées des feux via Telegram.
Dans ce tutoriel, vous apprendrez :
- Comment câbler un module de feu de circulation à l'Arduino UNO Q
- Comment programmer le MCU de l'Arduino UNO Q pour faire défiler les feux rouge, jaune et vert
- Comment utiliser une approche basée sur millis() pour un contrôle de feu de circulation non-bloquant
- Comment ajuster à distance les durées des feux via Telegram
Matériel Requis
Ou vous pouvez acheter les kits suivants:
| 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
Brochage
Un module de feu de circulation a 4 broches :
- Broche GND : Connecter à GND sur l'Arduino UNO Q
- Broche R : Contrôle le feu rouge — connecter à une sortie numérique
- Broche Y : Contrôle le feu jaune — connecter à une sortie numérique
- Broche G : Contrôle le feu vert — connecter à une sortie numérique
Schéma de Câblage
Cette image a été créée avec Fritzing. Cliquez pour agrandir l'image.
Comment Programmer un Module de Feu de Circulation
Définir les broches de signal comme sorties numériques :
pinMode(PIN_RED, OUTPUT);
pinMode(PIN_YELLOW, OUTPUT);
pinMode(PIN_GREEN, OUTPUT);
Activer le feu rouge :
digitalWrite(PIN_RED, HIGH); // turn RED on
digitalWrite(PIN_YELLOW, LOW); // turn YELLOW off
digitalWrite(PIN_GREEN, LOW); // turn GREEN off
delay(RED_TIME); // hold RED for the defined duration
Code MCU — Feu de Circulation (basique)
L'Arduino UNO Q possède deux processeurs : le MCU STM32 (gère le contrôle matériel en temps réel) et le MPU Qualcomm (exécute Debian Linux). Dans cette section, seul le MCU STM32 est programmé — le côté Linux reste inactif. Une section ultérieure montrera comment les deux processeurs fonctionnent ensemble.
Cet exemple fait défiler les feux rouge, jaune et vert en utilisant delay() :
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q 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/arduino-uno-q/arduino-uno-q-traffic-light
*/
#define PIN_RED 2 // The Arduino UNO Q pin connected to R pin of traffic light module
#define PIN_YELLOW 3 // The Arduino UNO Q pin connected to Y pin of traffic light module
#define PIN_GREEN 4 // The Arduino UNO Q pin 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
- Première utilisation d'Arduino UNO Q ? Suivez le tutoriel Démarrer avec Arduino UNO Q pour préparer votre environnement de développement avant de continuer.
- Câbler le module : Connectez le module de feu de circulation aux broches 2, 3 et 4 selon le schéma de câblage.
- Connecter : Branchez l'Arduino UNO Q à votre ordinateur avec un câble USB-C.
- Ouvrir Arduino App Lab : Lancez Arduino App Lab et attendez qu'il détecte votre Arduino UNO Q.
- Créer une nouvelle application : Cliquez sur le bouton Créer une nouvelle application.
- Donnez un nom à l'application, par exemple : DIYables_TrafficLight
- Cliquez sur Créer pour confirmer.
- Vous verrez un ensemble de dossiers et fichiers générés dans votre nouvelle application.
- Trouvez le fichier sketch/sketch.ino — c'est ici que vous collerez le sketch MCU.
Coller le sketch : Copiez le code MCU ci-dessus et collez-le dans le fichier sketch. Laissez les autres fichiers par défaut.
- Install the library: Click the Add sketch library button (the open book icon with a + sign) in the left sidebar.
- Search for Arduino_RouterBridge created by Arduino and click the Install button.
Bricks
No bricks added...
Sketch Libraries
No sketch libra...
Files
python
sketch
.gitignore
README.md
app.yaml
sketch.ino
- Téléverser : Cliquez sur le bouton Exécuter dans Arduino App Lab pour compiler et téléverser vers le STM32.
- Vérifier le module : Le module de feu de circulation devrait faire défiler : rouge → jaune → vert → rouge, en répétant.
- Conseil Pro : Les durées des feux de circulation varient selon l'emplacement et le carrefour. Ajustez les valeurs RED_TIME, YELLOW_TIME et GREEN_TIME pour correspondre au comportement souhaité.
Code MCU — Version Plus Propre avec une Fonction
Utiliser une fonction d'aide rend le code plus court et plus facile à gérer :
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q 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/arduino-uno-q/arduino-uno-q-traffic-light
*/
#define PIN_RED 2 // The Arduino UNO Q pin connected to R pin of traffic light module
#define PIN_YELLOW 3 // The Arduino UNO Q pin connected to Y pin of traffic light module
#define PIN_GREEN 4 // The Arduino UNO Q pin 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() {
trafic_light_on(RED);
delay(times[RED]); // keep red light on during a period of time
trafic_light_on(YELLOW);
delay(times[YELLOW]); // keep yellow light on during a period of time
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
}
}
- Conseil Pro : La fonction trafic_light_on(int light) allume exactement un feu et éteint les autres — propre et réutilisable.
Code MCU — Version Non-Bloquante avec millis()
La fonction delay() bloque tout autre code pendant qu'elle attend. Pour des programmes réactifs (ex. : lire des boutons ou des capteurs pendant que le feu de circulation fonctionne), utilisez millis() à la place :
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q 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/arduino-uno-q/arduino-uno-q-traffic-light
*/
#define PIN_RED 2 // The Arduino UNO Q pin connected to R pin of traffic light module
#define PIN_YELLOW 3 // The Arduino UNO Q pin connected to Y pin of traffic light module
#define PIN_GREEN 4 // The Arduino UNO Q pin connected to G pin of traffic light module
#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 };
int times[] = { 2000, 1000, 2000 }; // RED, YELLOW, GREEN durations in ms
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();
}
void loop() {
if ((millis() - last_time) > (unsigned long)times[light]) {
light++;
if (light >= 3)
light = RED; // new cycle
trafic_light_on(light);
last_time = millis();
}
// TO DO: your other code here
}
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
}
}
- Conseil Pro : Avec millis(), vous pouvez ajouter du code de bouton ou de capteur dans loop() en parallèle avec la logique du feu de circulation — ils s'exécutent simultanément sans se bloquer mutuellement.
Programmation Bridge Linux + MCU
L'Arduino UNO Q possède deux processeurs qui fonctionnent ensemble : le MPU (Qualcomm, exécute Debian Linux) et le MCU (STM32, exécute Zephyr OS avec votre sketch Arduino). Ils communiquent via RPC grâce à la bibliothèque Arduino_RouterBridge — jamais via des ports série bruts.
- Le module de feu de circulation est connecté au MCU (STM32) — câblé aux broches de sortie numériques du STM32. Le MCU fait défiler les feux en utilisant le minutage non-bloquant millis().
- Le MPU ne peut pas contrôler directement les feux — il doit envoyer des commandes au MCU via Bridge.call(). Le MCU exécute les fonctions Bridge.provide() enregistrées.
- Le MPU dispose du Wi-Fi — parce que le MPU exécute Debian Linux complet avec Wi-Fi, il peut recevoir des commandes Telegram et mettre à jour les durées des feux à distance.
- Communication : Bridge.call() côté Linux invoque les fonctions Bridge.provide() côté MCU
- ⚠️ Réservé : /dev/ttyHS1 (Linux) et Serial1 (MCU) sont utilisés par le routeur Arduino — ne les ouvrez jamais directement
En résumé : Le MPU envoie des commandes de minutage → le MCU les reçoit → le MCU met à jour les durées des feux en temps réel.
Sketch MCU — feu de circulation avec contrôle de minutage Bridge :
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q 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/arduino-uno-q/arduino-uno-q-traffic-light
*/
#include "Arduino_RouterBridge.h"
#define PIN_RED 2
#define PIN_YELLOW 3
#define PIN_GREEN 4
#define RED 0
#define YELLOW 1
#define GREEN 2
const int pins[] = { PIN_RED, PIN_YELLOW, PIN_GREEN };
int times[] = { 2000, 1000, 2000 }; // RED, YELLOW, GREEN durations in ms
unsigned long last_time = 0;
int current_light = RED;
const char* light_names[] = { "RED", "YELLOW", "GREEN" };
void trafic_light_on(int light) {
for (int i = RED; i <= GREEN; i++) {
if (i == light)
digitalWrite(pins[i], HIGH);
else
digitalWrite(pins[i], LOW);
}
Monitor.println("Light changed to: " + String(light_names[light]));
}
void set_timing(int red_ms, int yellow_ms, int green_ms) {
times[RED] = red_ms;
times[YELLOW] = yellow_ms;
times[GREEN] = green_ms;
Monitor.println("Timings updated: RED=" + String(red_ms) + "ms, YELLOW=" + String(yellow_ms) + "ms, GREEN=" + String(green_ms) + "ms");
}
void get_status() {
Monitor.println("Current light: " + String(light_names[current_light]));
}
void setup() {
pinMode(PIN_RED, OUTPUT);
pinMode(PIN_YELLOW, OUTPUT);
pinMode(PIN_GREEN, OUTPUT);
Bridge.begin();
Monitor.begin();
Bridge.provide("set_timing", set_timing);
Bridge.provide("get_status", get_status);
trafic_light_on(current_light);
last_time = millis();
Monitor.println("Traffic Light Bridge ready");
}
void loop() {
if ((millis() - last_time) > (unsigned long)times[current_light]) {
current_light++;
if (current_light >= 3)
current_light = RED;
trafic_light_on(current_light);
last_time = millis();
}
}
Script Python (Arduino App Lab) — contrôler le minutage des feux depuis Linux :
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q 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/arduino-uno-q/arduino-uno-q-traffic-light
*/
from arduino.app_utils import *
import time
def loop():
print("Setting normal timing: RED=3s, YELLOW=1s, GREEN=3s")
Bridge.call("set_timing", 3000, 1000, 3000)
time.sleep(10)
print("Setting fast timing: RED=1s, YELLOW=0.5s, GREEN=1s")
Bridge.call("set_timing", 1000, 500, 1000)
time.sleep(8)
print("Restoring default timing: RED=2s, YELLOW=1s, GREEN=2s")
Bridge.call("set_timing", 2000, 1000, 2000)
App.run(user_loop=loop)
- Note : Assurez-vous que Bridge.begin() est appelé dans le sketch MCU et que le sketch est téléversé avant d'exécuter le script Python côté Linux.
- ⚠️ Avertissement : N'ouvrez jamais directement /dev/ttyHS1 (sur Linux) ou n'utilisez pas Serial1 (sur MCU) dans votre code — ceux-ci sont réservés par le routeur Arduino et y accéder cassera le Bridge.
Étapes Rapides
- Téléverser le sketch MCU : Ouvrez Arduino App Lab, créez une nouvelle application, collez le sketch MCU Bridge ci-dessus dans sketch/sketch.ino, conservez les bibliothèques par défaut (aucune bibliothèque supplémentaire nécessaire) et cliquez sur Exécuter.
- Ajouter le script Python : Collez le code Python ci-dessus dans l'onglet Python de la même application.
- Exécuter l'application : Cliquez sur Exécuter — le côté Python ajuste automatiquement le minutage du feu de circulation.
- Vérifier la console : Ouvrez l'onglet Console → sous-onglet Console Python pour voir les mises à jour de minutage.
- Conseil Pro : Modifiez le script Python pour changer les minutages selon un planning (ex. : cycle plus court la nuit).
Sortie de la Console App Lab
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
Setting normal timing: RED=3s, YELLOW=1s, GREEN=3s
Setting fast timing: RED=1s, YELLOW=0.5s, GREEN=1s
Restoring default timing: RED=2s, YELLOW=1s, GREEN=2s
Intégration Telegram
Vous pouvez ajuster le minutage du feu de circulation à distance via Telegram — changez la durée d'allumage de chaque feu depuis n'importe où.
Si vous n'avez pas encore de bot Telegram, consultez Arduino UNO Q - Bot Telegram pour obtenir votre token de bot avant de continuer.
Cette section couvre :
- L'exécution d'un script Python côté Linux de l'Arduino UNO Q pour écouter les messages Telegram
- Le transfert des commandes de minutage au MCU via Bridge.call()
- L'envoi d'une réponse de confirmation en retour à Telegram
Sketch MCU : Conservez le même sketch MCU de la section Bridge précédente — aucune modification nécessaire. Assurez-vous qu'il est déjà téléversé et en cours d'exécution sur le STM32 avant de continuer.
Script Python (Arduino App Lab) — bot Telegram pour le contrôle du feu de circulation :
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q 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/arduino-uno-q/arduino-uno-q-traffic-light
*/
from arduino.app_utils import *
import requests
import time
BOT_TOKEN = "YOUR_BOT_TOKEN"
API_URL = f"https://api.telegram.org/bot{BOT_TOKEN}"
last_update_id = 0
def send_message(chat_id, text):
requests.post(f"{API_URL}/sendMessage", json={"chat_id": chat_id, "text": text})
def get_updates():
global last_update_id
resp = requests.get(f"{API_URL}/getUpdates", params={"offset": last_update_id + 1, "timeout": 5})
return resp.json().get("result", [])
def loop():
global last_update_id
updates = get_updates()
for update in updates:
last_update_id = update["update_id"]
msg = update.get("message", {})
chat_id = msg.get("chat", {}).get("id")
text = msg.get("text", "").strip()
if text.startswith("/timing "):
parts = text.split()
try:
red_ms = int(parts[1])
yellow_ms = int(parts[2])
green_ms = int(parts[3])
Bridge.call("set_timing", red_ms, yellow_ms, green_ms)
send_message(chat_id, f"Timings set: RED={red_ms}ms, YELLOW={yellow_ms}ms, GREEN={green_ms}ms")
except (ValueError, IndexError):
send_message(chat_id, "Usage: /timing <red_ms> <yellow_ms> <green_ms>\nExample: /timing 3000 1000 3000")
elif text == "/status":
Bridge.call("get_status")
send_message(chat_id, "Status requested — check the MCU monitor console")
else:
send_message(chat_id, "Commands:\n/timing <red_ms> <yellow_ms> <green_ms> — set light durations\n/status — check current light\n\nExample: /timing 3000 1000 3000")
time.sleep(1)
App.run(user_loop=loop)
- Note : Remplacez YOUR_BOT_TOKEN par le token obtenu de @BotFather sur Telegram.
- Envoyez /timing 3000 1000 3000 pour définir ROUGE=3s, JAUNE=1s, VERT=3s.
- Envoyez /status pour vérifier quel feu est actuellement allumé (statut enregistré dans le monitor MCU).
Étapes Rapides
- Téléverser le sketch MCU : Utilisez le sketch MCU Bridge de la section précédente (téléversez-le d'abord s'il ne l'est pas déjà).
- Coller le script Telegram : Copiez le code Python ci-dessus dans l'onglet Python de votre application dans Arduino App Lab.
- Définir votre token : Remplacez YOUR_BOT_TOKEN dans le script par votre vrai token de bot.
- Exécuter l'application : Cliquez sur Exécuter — le bot commence à écouter les messages Telegram immédiatement.
- Tester : Envoyez /timing 1000 500 1000 pour un cycle rapide, ou /timing 5000 2000 5000 pour un cycle lent.
- Conseil Pro : Ajoutez une commande de mode nuit qui applique un feu jaune clignotant lent — idéal pour les heures de faible trafic.
Sortie de la Console App Lab
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-29 12:00:01] Telegram: /timing 3000 1000 3000
[2026-04-29 12:00:01] Timings set: RED=3000ms, YELLOW=1000ms, GREEN=3000ms
[2026-04-29 12:05:20] Telegram: /timing 1000 500 1000
[2026-04-29 12:05:20] Timings set: RED=1000ms, YELLOW=500ms, GREEN=1000ms
Telegram
12:45
Welcome to Telegram!
ArduinoBot
10:19
Chatting with Arduino...
BotFather
Yesterday
Your bot has been created.
ArduinoBot
bot
Intégration d'OpenClaw
Vous pouvez adapter OpenClaw à ce tutoriel en vous référant aux instructions du tutoriel Arduino UNO Q - OpenClaw.
Idées d'Applications/Projets
Voici quelques idées de projets que vous pouvez réaliser avec un module de feu de circulation et l'Arduino UNO Q :
- Simulation de passage piéton : Ajoutez un bouton — appuyer dessus déclenche un signal de marche après la fin de la phase verte
- Carrefour contrôlé par Telegram : Définissez le minutage à distance pour simuler différentes densités de trafic
- Planning horaire : Utilisez l'horloge Linux du MPU pour basculer entre le minutage de jour (cycle court) et le minutage de nuit (rouge/vert plus long)
- Passage de train miniature : Utilisez le feu de circulation pour bloquer un train miniature — vert quand le train est loin, rouge pendant qu'il passe
- Indicateur d'état de laboratoire : Utilisez rouge/jaune/vert pour afficher l'état de disponibilité d'une salle de laboratoire
Défiez-Vous
Essayez ces défis avec le module de feu de circulation et l'Arduino UNO Q :
- Facile : Changez le minutage pour que la phase jaune dure seulement 500ms et la phase verte 4 secondes
- Moyen : Étendez le sketch Bridge pour exposer une fonction force_light(int light) qui bascule immédiatement vers un feu spécifique (0=rouge, 1=jaune, 2=vert) depuis Python
- Avancé : Construisez un bot Telegram qui prend en charge une commande /schedule day et /schedule night, chacune appliquant automatiquement un ensemble différent de minutages