211113 Atelier 2: feux tricolores, feux piéton, bouton passage piéton
but à atteindre:
réaliser un feux tricolore voiture, un feu piéton et un bouton passage piéton
on utilisera une breadboard ou mini breadboard si possible en utilisant le minimum de connecteurs
Pour le bouton poussoir, en l’abscence de matériel 
,
on peut se contenter de faire contact manuellement entre une broche et la masse.
J’ai choisi la facilité d’utiliser un kit feux tricolores afin d’éviter les fils et les résistances protégeant les leds. Pour le feu piéton on utilisera la led verte et rouge uniquement.
Néanmoins ces choix vont se heurter aux réalités du terrain.
D’abord le brochage impose 4 pin dans un sens précis:
ground/terre, Rouge, jaune, vert.
Et comme nous utiliserons 2 kit, cette contrainte va peser sur le choix du micro controleur.
Pour cet atelier, j’ai privilégié l’ESP12E et le classique Arduino UNO:
pour l’Arduino Uno, j’ai tordu la broche Ground/terre.
Elément de programmation Arduino
il faut utiliser les instructions concernant les 2 éléments physiques attachés au micro controleur: led et bouton poussoir.
comment connaitre les instructions disponibles? il suffit d’ouvrir les exemples fournis dans l’IDE Arduino, toutefois un peu au hasard(1).
Ainsi
LED:
- digitalWrite(broche_led, HIGH/LOW); dans la fonction boucle loop() mais avant il faut
- pinMode(broche_led, OUTPUT); dans la fonction setup()
Bouton poussoir:
- digitalRead(buttonPin); dans la fonction boucle loop() mais avant il faut
- pinMode(buttonPin, INPUT); dans la fonction setup()
mais le plus simple est de faire une recherche sur Internet pour guider vers un programme et on trouve :
digitalRead : https://www.ihm3d.fr/httpwww-ihm3d-frle-bouton-poussoir.html avec
/*Tutoriel IHM-3D */
int bouton = 2; // création de la variable "bouton" connectée à la broche 2 de la carte.
int etatbouton = 0; // variable qui servira à mémoriser la position du bouton.
void setup() {
Serial.begin (9600);
pinMode (bouton, INPUT_PULLUP); // on annonce que la variable bouton connectée sur la PIN 2 est une entrée avec la résistance de PULLUP activée.
Serial.println ("Bienvenue sur les tutoriels d'IHM-3D");
}
void loop() {
etatbouton = digitalRead(bouton);//la variable etatbouton mémorise la position du bouton
if (etatbouton == LOW) {
// si la variable etatbouton est à LOW
// Attention l'état est inversé lorsque l'on utilise
// une résistance de PULLUP.
Serial.println ("J'appuie sur le bouton");
}//alors cela voudra dire que j'appuie sur le bouton
else {
Serial.println ("Je n'appuie pas sur le bouton");
//sinon je n'appuie pas sur le bouton.
}
}
/*********************FIN DU PROGRAMME***************************/
ou
analogRead : https://www.aranacorp.com/fr/gestion-dun-bouton-poussoir-avec-arduino/ avec
//Parameters
const int btnPin = A0;
//Variables
int btnVal = 0;
void setup(){
//Init Serial USB
Serial.begin(9600);
Serial.println(F("Initialize System"));
//Init btn
pinMode(btnPin,INPUT_PULLUP);
}
void loop() {
////Read pushbutton
btnVal=analogRead(btnPin);
Serial.print(btnVal);
Serial.print(F("-->"));
if(btnVal<200){
Serial.println(F("Button is pressed"));
}else{
Serial.println(F("Button is released"));
}
delay(100);
}
je laisse Nicolas expliquer la notion de Pullup vue en 2020
je choisis :
- pinMode(bouton, INPUT); dans la fonction setup
- etatBouton = digitalRead(bouton); dans la fonction boucle loop(); les valeurs seront HIGH ou LOW
Test si boutton appuyé : si/alors
- enfin if/else _ si/alors_
// check if the pushbutton is pressed.
// If it is, the buttonState is HIGH:
if (buttonState == HIGH) {
// turn LED on:
digitalWrite(ledPin, HIGH);
} else {
// turn LED off:
digitalWrite(ledPin, LOW);
}
programme Arduino final:
il faut définir les variables, les broches en entrée ou sortie qui seront différentes selon le microprocesseur.
On supposera que le piéton appuiera sur le bouton uniquement quand le feu tricolore voiture est vert.
/*
TP S02 Feu tricolore + Feu Piétons
voiture:
* Une LED rouge sur la broche 15
* Une LED orange sur la broche 3
* Une LED verte sur la broche 1
piéton:
* Une LED rouge sur la broche 13
* Une LED verte sur la broche 14
* Bouton poussoir branché sur la broche 2 depuis +5V
* Une résistance de 1KΩ branché sur la broche 2 depuis GND
*/
/*
// Arduino
const int rougeVoiture = 7;
const int orangeVoiture = 6;
const int verteVoiture = 5;
const int rougePieton = 11;
const int vertePieton = 13;
*/
// ESP
const int rougeVoiture = 15; //grande led 1
const int orangeVoiture = 3;
const int verteVoiture = 1; //grande led 15
const int rougePieton = 13;
const int vertePieton = 14;
// temps durée feux
const int T_normal = 3000; //3s
const int T_lent = 1000; //1s
// Numéro broche du bouton poussoir
const int bouton = 2;
// Déclaration des variables :
int etatBouton = 0;
// execution unique
void setup() {
// broches des LED en sorties :
pinMode(rougeVoiture, OUTPUT);
pinMode(orangeVoiture, OUTPUT);
pinMode(verteVoiture, OUTPUT);
pinMode(rougePieton, OUTPUT);
pinMode(vertePieton, OUTPUT);
// broche bouton en entrée :
pinMode(bouton, INPUT);
}
// boucle infinie
void loop() {
// normallement le feu piéton est toujours rouge
digitalWrite(rougePieton, HIGH);
// feu voiture Vert allumé 3s
digitalWrite(verteVoiture, HIGH);
delay(3000);
digitalWrite(verteVoiture, LOW);
// l'état du bouton stocké dans etatBouton :
etatBouton = digitalRead(bouton);
// le bouton est appuyé si etatBouton = HIGH
if (etatBouton == HIGH) {
digitalWrite(orangeVoiture, HIGH);
delay(1000);
digitalWrite(orangeVoiture, LOW);
digitalWrite(rougeVoiture, HIGH);
// feu piéton passe au vert pendant 5s
digitalWrite(rougePieton, LOW);
digitalWrite(vertePieton, HIGH);
delay(5000);
// feu piéton redevient rouge
digitalWrite(rougePieton, HIGH);
digitalWrite(vertePieton, LOW);
// feu voiture Rouge est éteint
// avant retour au déroulement normal
digitalWrite(rougeVoiture, LOW);
}
else {
// Fonctionnement normal du feu voiture:
// orange 1s, rouge 3s
digitalWrite(orangeVoiture, HIGH);
delay(1000);
digitalWrite(orangeVoiture, LOW);
digitalWrite(rougeVoiture, HIGH);
delay(3000);
digitalWrite(rougeVoiture, LOW);
}
}
surprise !
sans acheter du matériel on peut aller beaucoup plus loin en conception avec Tinkercad