Feu de Signalisation LED Arduino : du Tricolore au Carrefour Intelligent

Avenue Habib Bourguiba à Sfax, 7h45 du matin, un mardi de mars. Le feu tricolore au croisement avec la rue Hédi Chaker passe au vert pour les véhicules venant du sud. Pendant 47 secondes, les voitures s’écoulent. Puis vient le jaune, 4 secondes. Puis le rouge, 53 secondes — pendant que les piétons traversent et que la rue Hédi Chaker reçoit son tour. Un cycle complet dure environ 1 minute 44. Multiplié par les milliers de feux du pays, c’est l’algorithme le plus exécuté de Tunisie après le clignotant de votre voiture.

Ce feu, dans son apparente banalité, est en réalité une machine à états finie d’une élégance redoutable. Quatre états (vert, jaune, rouge, rouge+bouton piéton), des transitions temporisées, des entrées asynchrones (bouton piéton, détecteur de véhicule), parfois une synchronisation entre plusieurs feux. Quand vous l’aborderez en TP de robotique à l’ISET ou à l’INSAT, vous serez surpris par la profondeur algorithmique qu’on peut y mettre. C’est pourquoi le projet “feu de signalisation” est un classique absolu de l’enseignement Arduino — et pourquoi cet article va le décortiquer en cinq versions, du débutant au carrefour intelligent.

Version 1 : feu tricolore avec delay()

La version originelle, celle qu’on trouve dans tous les tutos en 5 minutes. Trois LEDs, trois résistances, trois delay(). Ça marche, c’est satisfaisant, et c’est la pire base de code possible pour quoi que ce soit de sérieux.

Câblage

• LED rouge → broche D2 (avec résistance 220 Ω vers GND)
• LED jaune → broche D3 (avec résistance 220 Ω vers GND)
• LED verte → broche D4 (avec résistance 220 Ω vers GND)

Pourquoi 220 Ω ? Une LED standard tombe environ 2 V (3,2 V pour une LED bleue ou blanche). L’Arduino sort 5 V. Reste 3 V à dissiper. À 15 mA (courant sûr pour la LED et l’Arduino), R = U/I = 3 / 0,015 = 200 Ω. On arrondit à 220 Ω, valeur standard.

Code minimum viable

const uint8_t PIN_ROUGE = 2;
const uint8_t PIN_JAUNE = 3;
const uint8_t PIN_VERT = 4;

void setup() {
  pinMode(PIN_ROUGE, OUTPUT);
  pinMode(PIN_JAUNE, OUTPUT);
  pinMode(PIN_VERT, OUTPUT);
}

void loop() {
  // Phase verte
  digitalWrite(PIN_VERT, HIGH);
  digitalWrite(PIN_JAUNE, LOW);
  digitalWrite(PIN_ROUGE, LOW);
  delay(30000);  // 30 s vert
  
  // Phase jaune
  digitalWrite(PIN_VERT, LOW);
  digitalWrite(PIN_JAUNE, HIGH);
  delay(4000);  // 4 s jaune
  
  // Phase rouge
  digitalWrite(PIN_JAUNE, LOW);
  digitalWrite(PIN_ROUGE, HIGH);
  delay(30000);  // 30 s rouge
}

Le problème fondamental de delay()

Quand l’Arduino exécute delay(30000), il ne fait absolument rien pendant 30 secondes. Il ne peut pas lire un bouton, pas répondre à un capteur, pas envoyer un message série, pas mettre à jour un écran. C’est un sommeil profond bloquant. Pour un feu isolé qui n’attend rien d’autre, ça suffit. Pour un feu avec bouton piéton, c’est rédhibitoire.

Version 2 : ajout du bouton piéton

On ajoute un bouton poussoir sur D5 (avec pull-up interne) et une LED piétonne (rouge/verte) sur D6/D7. L’objectif : si le piéton appuie pendant la phase verte des véhicules, on raccourcit la phase verte et on passe au cycle piéton.

Première approche naïve : sonder le bouton entre les delay(). Vous découvrez vite que c’est inutilisable — le piéton appuie pendant delay(30000), et l’Arduino ne s’en aperçoit qu’après 30 secondes, soit le temps qu’il faut pour traverser à pied une avenue. Inacceptable.

Deuxième approche : utiliser une interruption externe.

const uint8_t PIN_BOUTON = 2; // D2 = INT0 sur UNO
volatile bool demandePieton = false;

void surAppui() {
  demandePieton = true;
}

void setup() {
  // ... pinMode des LEDs comme avant ...
  pinMode(PIN_BOUTON, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(PIN_BOUTON),
                  surAppui, FALLING);
}

Mieux, mais l’interruption ne fait que lever un flag. Pendant delay(), le programme principal ne lit toujours pas ce flag. Conclusion : delay() doit disparaître. Place à millis().

Version 3 : passage en non-bloquant avec millis()

La fonction millis() retourne le nombre de millisecondes écoulées depuis le démarrage de l’Arduino (overflow après 49 jours environ — gérable avec une soustraction unsigned). On l’utilise pour mesurer le temps écoulé sans bloquer.

Pattern fondamental

unsigned long debutPhase = 0;
int phaseCourante = 0;

void loop() {
  unsigned long maintenant = millis();
  
  if (phaseCourante == 0 && (maintenant - debutPhase) >= 30000) {
    // 30s écoulées, on passe à la phase suivante
    phaseCourante = 1;
    debutPhase = maintenant;
  }
  // ... autres phases ...
  
  // ICI on peut lire un bouton, un capteur, etc.
  if (digitalRead(PIN_BOUTON) == LOW) {
    demandePieton = true;
  }
}

Chaque tour de loop() prend moins d’une milliseconde. L’Arduino lit le bouton 1000 fois par seconde. Le délai de réaction est imperceptible.

Implémentation complète en machine à états

enum Etat {
  VERT,
  JAUNE,
  ROUGE,
  ROUGE_AVEC_PIETON
};

Etat etat = ROUGE;
unsigned long debutEtat = 0;
bool demandePieton = false;

const unsigned long DUREE_VERT = 30000;
const unsigned long DUREE_JAUNE = 4000;
const unsigned long DUREE_ROUGE = 30000;
const unsigned long DUREE_PIETON = 15000;

void setup() {
  pinMode(PIN_ROUGE, OUTPUT);
  pinMode(PIN_JAUNE, OUTPUT);
  pinMode(PIN_VERT, OUTPUT);
  pinMode(PIN_BOUTON, INPUT_PULLUP);
  pinMode(PIN_LED_PIETON_R, OUTPUT);
  pinMode(PIN_LED_PIETON_V, OUTPUT);
  
  passerA(ROUGE);
}

void passerA(Etat e) {
  etat = e;
  debutEtat = millis();
  
  // Activation des bonnes LEDs selon l'etat
  digitalWrite(PIN_ROUGE, etat == ROUGE || etat == ROUGE_AVEC_PIETON);
  digitalWrite(PIN_JAUNE, etat == JAUNE);
  digitalWrite(PIN_VERT, etat == VERT);
  digitalWrite(PIN_LED_PIETON_V, etat == ROUGE_AVEC_PIETON);
  digitalWrite(PIN_LED_PIETON_R, etat != ROUGE_AVEC_PIETON);
}

void loop() {
  // Lecture bouton avec anti-rebond logiciel
  static unsigned long dernierAppui = 0;
  if (digitalRead(PIN_BOUTON) == LOW
      && (millis() - dernierAppui) > 250) {
    demandePieton = true;
    dernierAppui = millis();
  }
  
  unsigned long ecoule = millis() - debutEtat;
  
  switch (etat) {
    case VERT:
      // Si piéton demande, on raccourcit le vert a 5s min
      if ((demandePieton && ecoule >= 5000)
          || ecoule >= DUREE_VERT) {
        passerA(JAUNE);
      }
      break;
    
    case JAUNE:
      if (ecoule >= DUREE_JAUNE) {
        if (demandePieton) {
          demandePieton = false;
          passerA(ROUGE_AVEC_PIETON);
        } else {
          passerA(ROUGE);
        }
      }
      break;
    
    case ROUGE_AVEC_PIETON:
      if (ecoule >= DUREE_PIETON) {
        passerA(ROUGE);
      }
      break;
    
    case ROUGE:
      if (ecoule >= DUREE_ROUGE) {
        passerA(VERT);
      }
      break;
  }
}

Anti-rebond logiciel

Un bouton poussoir mécanique “rebondit” : ses contacts oscillent pendant 5 à 50 ms avant de se stabiliser. Sans précaution, l’Arduino lit 5, 10, parfois 50 appuis pour une seule pression du doigt. La condition (millis() - dernierAppui) > 250 filtre cela : un nouvel appui n’est considéré qu’après 250 ms de silence.

Version 4 : carrefour 4 voies synchronisé

On passe au monde réel : un carrefour en croix avec 4 directions (Nord, Sud, Est, Ouest). En Tunisie comme partout, le pattern standard est :

1. Nord+Sud verts, Est+Ouest rouges (30 s)
2. Nord+Sud jaunes, Est+Ouest rouges (4 s)
3. Tous rouges (2 s — phase de sécurité “all-red”)
4. Est+Ouest verts, Nord+Sud rouges (30 s)
5. Est+Ouest jaunes, Nord+Sud rouges (4 s)
6. Tous rouges (2 s)
7. Retour à l’étape 1

Code propre avec arrays

La pire chose à faire serait de gérer 12 LEDs avec 12 variables et 12 digitalWrite() par phase. Au lieu de cela, organisons en arrays :

// Indices : 0=Nord, 1=Sud, 2=Est, 3=Ouest
const uint8_t pinRouge[4] = {2, 5, 8, 11};
const uint8_t pinJaune[4] = {3, 6, 9, 12};
const uint8_t pinVert[4]  = {4, 7, 10, 13};

// Phases : pour chaque etat, pour chaque direction,
//          quelle LED allumer (R, J, V)
enum Couleur { R, J, V };
struct Phase {
  unsigned long duree;
  Couleur couleurs[4]; // Nord, Sud, Est, Ouest
};

const Phase phases[] = {
  { 30000, {V, V, R, R} }, // N+S vert
  {  4000, {J, J, R, R} }, // N+S jaune
  {  2000, {R, R, R, R} }, // all-red securite
  { 30000, {R, R, V, V} }, // E+O vert
  {  4000, {R, R, J, J} }, // E+O jaune
  {  2000, {R, R, R, R} }  // all-red securite
};
const uint8_t NB_PHASES = sizeof(phases) / sizeof(phases[0]);

uint8_t phaseCourante = 0;
unsigned long debutPhase = 0;

void setup() {
  for (uint8_t d = 0; d < 4; d++) {
    pinMode(pinRouge[d], OUTPUT);
    pinMode(pinJaune[d], OUTPUT);
    pinMode(pinVert[d], OUTPUT);
  }
  appliquerPhase(0);
}

void appliquerPhase(uint8_t p) {
  for (uint8_t d = 0; d < 4; d++) {
    digitalWrite(pinRouge[d], phases[p].couleurs[d] == R);
    digitalWrite(pinJaune[d], phases[p].couleurs[d] == J);
    digitalWrite(pinVert[d],  phases[p].couleurs[d] == V);
  }
  debutPhase = millis();
  phaseCourante = p;
}

void loop() {
  if (millis() - debutPhase >= phases[phaseCourante].duree) {
    appliquerPhase((phaseCourante + 1) % NB_PHASES);
  }
}

Le code total tient en 35 lignes, fonctionne pour n’importe quel pattern de phases, et est trivialement modifiable. Ajouter une 7e phase ? Une ligne dans le tableau. Inverser une direction ? Un caractère. C’est ça, la différence entre code amateur et code propre.

Version 5 : feu intelligent avec détection de véhicule

Dans les villes modernes, les feux ne sont plus toujours temporisés bêtement. Ils adaptent leur cycle selon le trafic : si aucune voiture n’attend dans une direction, on raccourcit son vert pour libérer la direction où il y a la file. C’est ce qu’on appelle l’actuation des feux.

Capteurs de détection

Pour détecter un véhicule à proximité du feu :

• LDR (photorésistance) : enterrée dans la chaussée, détecte l’ombre d’un véhicule. Solution pédagogique simple, peu fiable en pratique (météo).
• Capteur infrarouge actif (HC-SR501 ou IR break-beam) : émetteur d’un côté de la voie, récepteur de l’autre. Plus fiable.
• Capteur à boucle inductive : ce qui est utilisé en vrai sous l’asphalte. Détecte la masse métallique d’un véhicule. Pas réaliste à reproduire en TP.
• Capteur ultrasonique HC-SR04 : pointé vers la voie, détecte par écho. Simple, peu coûteux, idéal en pédagogie.
• Caméra avec traitement d’image : ESP32-CAM ou Raspberry Pi Camera + OpenCV. Plus ambitieux.

Algorithme adaptatif

const unsigned long VERT_MIN = 8000;   // 8 s vert minimum
const unsigned long VERT_MAX = 45000;  // 45 s vert maximum
const unsigned long EXTENSION = 5000;  // +5 s par vehicule detecte
const unsigned long TIMEOUT_DETECT = 3000; // 3s sans detection = fin

unsigned long dernierVehicule = 0;

void loop() {
  if (vehiculeDetecteSurVoieVerte()) {
    dernierVehicule = millis();
  }
  
  if (etat == VERT) {
    unsigned long ecoule = millis() - debutEtat;
    
    // Pas avant le minimum
    if (ecoule < VERT_MIN) return;
    
    // Apres le maximum, on force le passage
    if (ecoule >= VERT_MAX) {
      passerA(JAUNE);
      return;
    }
    
    // Entre les deux : on continue tant que des vehicules passent
    if ((millis() - dernierVehicule) > TIMEOUT_DETECT) {
      passerA(JAUNE);
    }
  }
}

Cette logique garantit que le feu reste vert si du trafic est détecté en continu (jusqu’à 45 s max pour ne pas affamer les autres directions), mais bascule rapidement au jaune si la voie se vide. Algorithme utilisé dans toutes les villes intelligentes du monde.

Durées réelles d’un feu tunisien

Pour un projet pédagogique crédible, il est utile de connaître les ordres de grandeur réels appliqués par la Direction Générale des Transports Routiers en Tunisie :

Notez que le jaune fait toujours 3 à 4 secondes — c’est une norme de sécurité internationale calée sur le temps moyen de réaction d’un conducteur (1 s) plus le temps de freinage à 50 km/h (2-3 s). Faire un jaune de 1 s, c’est garantir des accidents.

La machine à états en détail

Le diagramme d’états d’un feu avec bouton piéton se représente classiquement ainsi :

      ┌──────────────┐
      │ ROUGE (init) │◄──────────────────────┐
      └──────┬───────┘                       │
             │ 30s écoulées                  │
             ▼                               │
      ┌──────────────┐                       │
      │     VERT     │                       │
      └──┬───────────┘                       │
         │     ▲ bouton piéton (rapide)      │
         │     │                             │
         │ 30s OU bouton+5s minimum          │
         ▼                                   │
      ┌──────────────┐                       │
      │    JAUNE     │                       │
      └──┬───────────┘                       │
         │ 4s, bouton actif ?                │
         │     ┌─────────────────────────┐   │
         │     ▼                         │   │
         │ ┌──────────────────┐          │   │
         │ │ROUGE_AVEC_PIETON │──15s─────┤   │
         │ └──────────────────┘          │   │
         │                               │   │
         └───────────────────────────────┴───┘
              non                30s

Cette représentation visuelle est précieuse au moment de la conception. Avant d’écrire une ligne de code, dessinez votre machine à états sur papier. Vous identifierez les transitions impossibles, les états absorbants, les conditions de course. Tous les bugs de logique se révèlent au tableau, pas au moniteur série.

Buzzer pour piétons malvoyants

Dans les pays développés, et de plus en plus en Tunisie (autour des écoles, hôpitaux, gares), les feux piétons sont équipés d’un signal sonore. La norme française NF S 32-002, souvent reprise en Tunisie, prévoit :

• Pendant le vert piéton : son périodique aigu (440 Hz environ, équivalent au La 4 musical) à raison de 2 bips par seconde, audible à 10 m mais pas perçant au-delà de 30 m.
• Pendant le rouge piéton : silence ou son grave intermittent espacé (signale aux malvoyants où se trouve le poteau).
• Volume réglable selon le bruit ambiant (5 dB au-dessus du bruit de fond, mesuré toutes les minutes).

Implémentation en Arduino avec buzzer piezo passif :

const uint8_t PIN_BUZZER = 8;
const int FREQ_TRAVERSEE = 440;
const int FREQ_POTEAU = 220;

void gererBuzzer(Etat e) {
  static unsigned long dernier = 0;
  static bool sonActif = false;
  unsigned long maintenant = millis();
  
  if (e == ROUGE_AVEC_PIETON) {
    // 2 bips par seconde, durée 100 ms
    if (!sonActif && (maintenant - dernier) >= 400) {
      tone(PIN_BUZZER, FREQ_TRAVERSEE);
      sonActif = true;
      dernier = maintenant;
    } else if (sonActif && (maintenant - dernier) >= 100) {
      noTone(PIN_BUZZER);
      sonActif = false;
      dernier = maintenant;
    }
  } else {
    // Son discret du poteau toutes les 2s
    if (!sonActif && (maintenant - dernier) >= 2000) {
      tone(PIN_BUZZER, FREQ_POTEAU);
      sonActif = true;
      dernier = maintenant;
    } else if (sonActif && (maintenant - dernier) >= 80) {
      noTone(PIN_BUZZER);
      sonActif = false;
      dernier = maintenant;
    }
  }
}

Projet maquette pour école primaire

Le projet “feu de signalisation” est aussi un magnifique support pédagogique pour les écoles primaires tunisiennes : code de la route, sciences électriques, programmation visuelle. Voici un kit clé en main pour réaliser une maquette de carrefour didactique destinée à des enfants de 8-12 ans.

Cahier des charges adapté

• Maquette en plexiglas découpé au laser (FabLab Sfax peut faire la découpe) représentant un carrefour avec routes peintes, trottoirs, passages piétons.
• 4 feux véhicules (mâts en tube PVC blanc avec LEDs 5mm encastrées dans des perles décoratives translucides).
• 4 feux piétons (LEDs rouge/verte).
• 4 boutons piétons placés sur les trottoirs.
• Programmation Arduino avec interrupteur “mode automatique” ou “mode interactif” (les enfants pilotent eux-mêmes les feux).
• Petits véhicules en bois ou impression 3D pour mise en situation.
• Mode “démonstration” qui parle (via module DFPlayer Mini et MP3) : “Le feu est rouge, les voitures s’arrêtent”.

Pédagogie associée

1. Séance 1 : observation du carrefour réel, prise de notes des phases observées avec chronomètre.
2. Séance 2 : montage électrique (les enfants insèrent les LEDs et résistances dans une breadboard pré-câblée).
3. Séance 3 : programmation visuelle (Scratch for Arduino ou MakerBlock) pour modifier les durées des phases.
4. Séance 4 : règle d’or du jaune, traversée piétonne, sécurité routière.
5. Séance 5 : présentation aux autres classes, démonstration du carrefour intelligent qui détecte les voitures.

Coût du kit chez Didactico : moins de 100 DT pour le matériel électronique. L’effet sur des enfants qui voient leur maquette s’animer, c’est inestimable.

FAQ

Conclusion

Le projet feu de signalisation est l’un des plus beaux outils pédagogiques de l’écosystème Arduino. Il commence par trois LEDs et trois delay() que tout débutant maîtrise en une heure. Il finit par une machine à états multi-direction synchronisée avec détection de véhicules en temps réel — un projet de niveau ingénieur. Entre les deux, vous traversez la quasi-totalité des concepts fondamentaux de la programmation embarquée : machines à états, programmation non-bloquante, anti-rebond, interruptions, organisation par arrays.

Chez Didactico, vous trouverez tout le nécessaire : Arduino UNO ou Mega, LEDs 5 mm rouge/jaune/vert en kit de 100, résistances 220 Ω en sachet, boutons poussoirs, breadboards, jumpers. Pour les enseignants, des packs spécifiques “feu de signalisation” sont disponibles. Livraison sous 24 à 48 heures partout en Tunisie depuis Sfax. Le FabLab Sfax est aussi un excellent endroit pour faire découper au laser un boîtier élégant qui transformera votre breadboard en maquette présentable.

Que vous soyez étudiant à l’ENIT, à l’INSAT, à l’ISBS, à l’ISET, ou enseignant en école primaire, le feu de signalisation reste l’archétype du projet qui enseigne plus que ce qu’il montre.

🛒 Matériel nécessaire pour ce guide

Tout le matériel de ce tutoriel est disponible chez Didactico — livraison 24-48h partout en Tunisie, paiement à la livraison.

Led Verte 5mm Haute luminosité0,130 TNDCarte Arduino UNO R3 - Meilleure carte Arduino en Tunisie31,000 TND

Voir toute la catégorie « Composants électroniques » →

📘 Guides liés : Bouton Poussoir Arduino : Débounce, Pull-up et Interruptions en Tunisie · Potentiomètre Arduino PWM : Contrôler une LED, un Servo et un Moteur