Les feux de circulation sont des dispositifs de signalisation routière qui permettent aux conducteurs de savoir quand ils peuvent avancer ou s’arrêter. Ils sont composés de 6 Leds qui s’allument et s’éteignent selon des règles précises. Ces feux sont indispensables pour assurer la sécurité des usagers de la route et réguler la circulation. Dans cet article, nous allons examiner en détail le fonctionnement des feux de circulation à 6 Leds et leur importance pour la sécurité routière.
Les feux de circulation (6 Leds)
1. Présentation
Ce programme simple simule les feux de circulation sur 2 groupes de 3 leds rouge-jaune-vert. Un bon exercice pour se familiariser avec l’utilisation des broches en sortie et des temporisations simple.
Ce programme pourra aussi servir de base pour des modélistes qui souhaiteraient animer simplement leur maquette.
2. Matériel Nécessaire
2.1 L’espace de développement Arduino
- … pour éditer, compiler le programme et programmer la carte Arduino.
2.2 Le matériel suivant pour réaliser le montage associé
- une plaque d’essai pour montage sans soudures,
- des straps,
- deux LED rouges 5mm,
- deux LED jaunes 5mm,
- deux LED vertes 5mm,
- 6 résistances 1/4w de 300 Ohms environ,
3. Instructions de montage
- Connecter sur la broche 2 (configurée en sortie) une LED rouge connectée en série avec sa résistance au 0V
- Connecter sur la broche 3 (configurée en sortie) une LED jaune connectée en série avec sa résistance au 0V
- Connecter sur la broche 4 (configurée en sortie) une LED verte connectée en série avec sa résistance au 0V
- Connecter sur la broche 5 (configurée en sortie) une LED rouge connectée en série avec sa résistance au 0V
- Connecter sur la broche 6 (configurée en sortie) une LED jaune connectée en série avec sa résistance au 0V
- Connecter sur la broche 7 (configurée en sortie) une LED verte connectée en série avec sa résistance au 0V
4. Le schéma théorique du montage
Le schéma théorique du montage
5. Le circuit du montage
Le schéma du montage à réaliser
6. Explication du programme
6.1 Structure globale du programme
Ce programme simple comprend :
- une entête déclarative
- une partie « configuration » qui ne sera exécutée qu’une fois (fonction setup( ) )
- une partie constituée d’une boucle sans fin que le programme répètera à l’infini ( fonction loop( ) ) : c’est le coeur du programme.
6.2 Déroulement du programme
Le programme se déroule de la façon suivante :
- Après avoir pris en compte les instructions de la partie déclarative,
- puis après avoir exécuté la partie configuration ( fonction setup( ) ),
- le programme bouclera sans fin ( fonction loop ( ) ), exécutant de façon répétée le code compris dans la boucle sans fin.
Le déroulement du programme
7. Au niveau de la partie déclarative :
Déclaration des constantes de broches
- Déclaration des constantes pour les broches utilisées dans le programme : on renomme les 6 broches utilisées avec les LEDs.
const int ORANGE_1=3; //declaration constante de broche
const int VERT_1=4; //declaration constante de broche
const int ROUGE_2=5; //declaration constante de broche
const int ORANGE_2=6; //declaration constante de broche
const int VERT_2=7; //declaration constante de broche
8. Au niveau de la fonction d’initialisation setup( ) :
configuration des broches utilisées :
- Configuration des broches en sortie : on configure les 6 broches utilisées en sortie à l’aide de l’instruction pinMode :
pinMode(ORANGE_1, OUTPUT); //met la broche en sortie
pinMode(VERT_1, OUTPUT); //met la broche en sortie
pinMode(ROUGE_2, OUTPUT); //met la broche en sortie
pinMode(ORANGE_2, OUTPUT); //met la broche en sortie
pinMode(VERT_2, OUTPUT); //met la broche en sortie
Initialisation des fonctionnalités utilisées :
- On initialise les LEDs avec le rouge du feu 1 allumé et le vert du feu 2 allumé à l’aide de l’instruction digitalWrite suivi d’une pause avec l’instruction delay :
digitalWrite(ROUGE_1,HIGH); // met la broche au niveau HAUT
digitalWrite(VERT_1,LOW); // met la broche au niveau BAS
digitalWrite(ORANGE_1,LOW); // met la broche au niveau BAS
digitalWrite(ROUGE_2,LOW); // met la broche au niveau BAS
digitalWrite(VERT_2,HIGH); // met la broche au niveau HAUT
digitalWrite(ORANGE_2,LOW); // met la broche au niveau BAS
delay(5000); // pause de 5 secondes
9. Au niveau de la boucle principale, la fonction loop ( ) :
- on réalise la séquence d’allumage / extinction des 6 LEDs de façon à obtenir la simulatin du fonctionnement de 2 feux tricolores :
digitalWrite(VERT_2,LOW); // éteint vert feu 2
digitalWrite(ORANGE_2,HIGH); // allume orange feu 2
delay (2000); // pause 2 secondes
//— le feu 2 passe au rouge
digitalWrite(ORANGE_2,LOW); // éteint orange feu 2
digitalWrite(ROUGE_2,HIGH); // allume rouge feu 2
delay (1000); // pause courte 1 seconde
//— le feu 1 passe au vert
digitalWrite(ROUGE_1,LOW); // éteint rouge feu 1
digitalWrite(VERT_1,HIGH); // allume vert feu 1
delay (5000); // pause longue 5 secondes
//— le feu 1 passe à l’orange
digitalWrite(VERT_1,LOW); // éteint vert feu 1
digitalWrite(ORANGE_1,HIGH); // allume orange feu 1
delay (2000); // pause 2 secondes
//— le feu 1 passe au rouge
digitalWrite(ORANGE_1,LOW); // éteint orange feu 1
digitalWrite(ROUGE_1,HIGH); // allume rouge feu 1
delay (1000); // pause courte 1 seconde
//— le feu 2 passe au vert
digitalWrite(ROUGE_2,LOW); // éteint rouge feu 2
digitalWrite(VERT_2,HIGH); // allume vert feu 2
delay (5000); // pause longue 5 secondes
- Le programme recommence en boucle les instructions de la fonction loop( ).
Se reporter aux commentaires présents dans le programme pour plus de détails.
10. Mise en oeuvre du programme
10.1 Préparation du montage et programmation de la carte Arduino :
- Commencer par réaliser le montage indiqué sur plaque d’expérimentation
- Ensuite, programmer la carte Arduino avec ce programme (en bas de page) selon la procédure habituelle
10.2 Fonctionnement
- Les LEDs s’allument successivement réalisant la séquence des feux de circulation.
11. Le programme complet en langage Arduino :
A copier/coller directement dans l’éditeur Arduino
// Copyright X. HINAULT – Créé le 14/04/2010
// www.mon-club-elec.fr
// Code sous licence GNU GPL :
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
// — Que fait ce programme ? —
/* Simule les feux de circulation sur 2 groupes de 3 leds rouge-jaune-vert. */
// — Fonctionnalités utilisées —
// — Circuit à réaliser —
// Connecter sur la broche 2 (configurée en sortie) une LED rouge connectée en série avec sa résistance au 0V
// Connecter sur la broche 3 (configurée en sortie) une LED jaune connectée en série avec sa résistance au 0V
// Connecter sur la broche 4 (configurée en sortie) une LED verte connectée en série avec sa résistance au 0V
// Connecter sur la broche 5 (configurée en sortie) une LED rouge connectée en série avec sa résistance au 0V
// Connecter sur la broche 6 (configurée en sortie) une LED jaune connectée en série avec sa résistance au 0V
// Connecter sur la broche 7 (configurée en sortie) une LED verte connectée en série avec sa résistance au 0V
//**************** Entête déclarative *******
// A ce niveau sont déclarées les librairies incluses, les constantes, les variables…
// — Inclusion des librairies utilisées —
// — Déclaration des constantes —
// — constantes des broches —
const int ROUGE_1=2; //declaration constante de broche
const int ORANGE_1=3; //declaration constante de broche
const int VERT_1=4; //declaration constante de broche
const int ROUGE_2=5; //declaration constante de broche
const int ORANGE_2=6; //declaration constante de broche
const int VERT_2=7; //declaration constante de broche
// — Déclaration des variables globales —
// — Déclaration des objets utiles pour les fonctionnalités utilisées —
//**************** FONCTION SETUP = Code d’initialisation *****
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme
void setup() { // debut de la fonction setup()
// — ici instructions à exécuter au démarrage —
// ——- Broches en sortie ——-
pinMode(ROUGE_1, OUTPUT); //met la broche en sortie
pinMode(VERT_1, OUTPUT); //met la broche en sortie
pinMode(ORANGE_1, OUTPUT); //met la broche en sortie
pinMode(ROUGE_2, OUTPUT); //met la broche en sortie
pinMode(VERT_2, OUTPUT); //met la broche en sortie
pinMode(ORANGE_2, OUTPUT); //met la broche en sortie
//——- initialisation des LEDs au début = feu 1 au rouge et feu 2 au vert
digitalWrite(ROUGE_1,HIGH); // met la broche au niveau HAUT
digitalWrite(VERT_1,LOW); // met la broche au niveau BAS
digitalWrite(ORANGE_1,LOW); // met la broche au niveau BAS
digitalWrite(ROUGE_2,LOW); // met la broche au niveau BAS
digitalWrite(VERT_2,HIGH); // met la broche au niveau HAUT
digitalWrite(ORANGE_2,LOW); // met la broche au niveau BAS
delay(5000); // pause de 5 secondes
} // fin de la fonction setup()
// ********************************************************************************
//*************** FONCTION LOOP = Boucle sans fin = coeur du programme *************
// la fonction loop() s’exécute sans fin en boucle aussi longtemps que l’Arduino est sous tension
void loop(){ // debut de la fonction loop()
//— le feu 2 passe à l’orange
digitalWrite(VERT_2,LOW); // éteint vert feu 2
digitalWrite(ORANGE_2,HIGH); // allume orange feu 2
delay (2000); // pause 2 secondes
//— le feu 2 passe au rouge
digitalWrite(ORANGE_2,LOW); // éteint orange feu 2
digitalWrite(ROUGE_2,HIGH); // allume rouge feu 2
delay (1000); // pause courte 1 seconde
//— le feu 1 passe au vert
digitalWrite(ROUGE_1,LOW); // éteint rouge feu 1
digitalWrite(VERT_1,HIGH); // allume vert feu 1
delay (5000); // pause longue 5 secondes
//— le feu 1 passe à l’orange
digitalWrite(VERT_1,LOW); // éteint vert feu 1
digitalWrite(ORANGE_1,HIGH); // allume orange feu 1
delay (2000); // pause 2 secondes
//— le feu 1 passe au rouge
digitalWrite(ORANGE_1,LOW); // éteint orange feu 1
digitalWrite(ROUGE_1,HIGH); // allume rouge feu 1
delay (1000); // pause courte 1 seconde
//— le feu 2 passe au vert
digitalWrite(ROUGE_2,LOW); // éteint rouge feu 2
digitalWrite(VERT_2,HIGH); // allume vert feu 2
delay (5000); // pause longue 5 secondes
} // fin de la fonction loop() – le programme recommence au début de la fonction loop sans fin
// ********************************************************************************
//*************** Autres Fonctions du programme *************
// — Fin programme —
