Bouton poussoir
Le bouton poussoir permet de couper ou laisser passer le passage du courant dans un circuit.
Il existe deux types de boutons poussoirs :
Normalement ouvert (NO) : quand on appuie le courant passe
Normalement fermé(NF) : quand on appuie le courant ne passe plus
Un Bouton poussoir a quatre pattes (A,B,C,D) :
A et B sont reliées entre elles
C et D sont reliées entre elles
Pour un NO :
Au repos, les deux paires sont séparées
Quand on appuie les quatre pattes se retrouvent reliées.
Pour ne pas confondre les pattes, on peut utiliser deux pattes sur une diagonale. On est sûr qu'elles sont séparées.
Définition : Principe
La broche d'un composant lorsqu'elle n'est pas reliée à la masse ou au Vcc est dans un état indéterminé.
Pour lire une tension sur une des entrées de l'Arduino, il faut donc la relier à la masse (GND) ou à l'alimentation (Vcc).
Pour cela on peut utiliser un montage PullDown (résistance qui tire vers le bas, reliée en bas vers la masse 0V) ou PullUp (résistance qui tire vers le haut, reliée vers le haut au Vcc 5V).
Définition : PULLDOWN
Une patte du bouton est relié au Vcc.
Une autre à une résistance de rappel et à la sortie (ici broche 7).
Dans le montage PullDown, la résistance de rappel est reliée à la masse.
Quand le bouton est relâché, le circuit est ouvert. La broche 7 est reliée au GND par l'intermédiaire de la résistance. La tension est de 0 V.
Quand le bouton est appuyé, le circuit est fermé. La broche 7 est directement reliée au Vcc. La tension est de 5 V.
Dans le croquis, on définit la broche 7 en entrée (INPUT). On utilise digitalRead() pour lire la valeur de l'entrée (5V = 1, 0V = 0).
const int BP = 7;
void setup() {
Serial.begin(9600);
pinMode(BP, INPUT);
}
void loop() {
int etat = digitalRead(BP);
Serial.println(etat);
}
Quand le bouton est relâché, Le moniteur affiche 0.
Quand le bouton est appuyé, Le moniteur affiche 1.
Définition : PULLUP
Une patte du bouton est relié à la masse.
Une autre à une résistance de rappel et à la sortie (ici broche 7).
Dans le montage PulUp, la résistance de rappel est reliée au Vcc.
Quand le bouton est relâché, le circuit est ouvert. La broche 7 est relié au Vcc. Il n'y a pas de courant qui circule. La tension est de 5 V.
Quand le bouton est appuyé, le circuit est fermé. La broche 7 est relié au GND. La tension est de 0 V.
Dans le croquis, on définit la broche 7 en entrée (INPUT). On utilise digitalRead() pour lire la valeur de l'entrée (5V = 1, 0V = 0).
const int BP = 7;
void setup() {
Serial.begin(9600);
pinMode(BP, INPUT);
}
void loop() {
int etat = digitalRead(BP);
Serial.println(etat);
}
Quand le bouton est relâché, Le moniteur affiche 1.
Quand le bouton est appuyé, Le moniteur affiche 0.
Définition : INPUT_PULLUP
L'utilisation de résistance de rappel étant souvent utilisé, Arduino a intégré un système d'activation d'un PullUp sur ses entrées.
Mais, pour utiliser ces PullUp vous devez remplacer INPUT par INPUT_PULLUP dans la fonction pinMode.
const int BP = 7;
void setup() {
Serial.begin(9600);
pinMode(BP, INPUT_PULLUP);
}
void loop() {
int etat = digitalRead(BP);
Serial.println(etat);
}
Définition : Exemple
Allumer une LED avec un bouton poussoir.
const int LED = 4;
const int BP = 7;
void setup() {
pinMode(LED, OUTPUT);
pinMode(BP, INPUT_PULLUP);
}
void loop() {
int etat = digitalRead(BP);
digitalWrite(LED,!etat);
}
!etat permet de mettre à 1 quand le bouton est appuyé.
Définition : Anti-Rebond
Lorsque l'on clique sur un bouton, il y a une période transitoire très courte pendant laquelle pour des raisons physiques, le contact oscille entre fermé et ouvert.
On dit qu'il y a des rebonds.
Le problème est que l'Arduino est plus rapide que cette période et pense que l'on a appuyé et relâché le bouton plusieurs fois.
La solution consiste à "ralentir" l'Arduino en lui demandant de valider un changement que s'il s'est passé un certain temps entre deux changements.
const int LED1 = 3;
const int LED2 = 4;
const int BP = 7;
int etatOld = 1;
int signal1 = LOW;
int signal2 = LOW;
int interval = 10;
unsigned long tpsOld = millis();
void setup() {
pinMode(LED1, OUTPUT);
pinMode(LED2, OUTPUT);
pinMode(BP, INPUT_PULLUP);
Serial.begin(9600);
}
void loop() {
int etatNew = digitalRead(BP);
unsigned long tpsNew = millis();
// changement if(etatNew != etatOld && tpsNew - tpsOld > interval){
etatOld = etatNew;
tpsOld = tpsNew;
// changement à l'appuiif(etatNew == LOW){
signal1 = !signal1;
}
// chagement au relachementif(etatNew == HIGH){
signal2 = !signal2;
}
}
digitalWrite(LED1,signal1);
digitalWrite(LED2,signal2);
Serial.println(etatNew);
}
tpsOld : temps du dernier changement
tpsNew : temps actuel
interval : temps minimal ente deux changements
etatOld : ancien état du bouton (1 relâché, 0 appuyé)
etatNew : état actuel du bouton
signale1 : état LED1
signale1 : état LED2
Définition : Bounce2.h
Avec la bibliothèque Bounce2.h
const int LED1 = 3;
const int LED2 = 4;
const int BP = 7;
int signal1 = 0;
int signal2 = 0;
Bounce bouton = Bounce();
void setup() {
pinMode(LED1, OUTPUT);
pinMode(LED2, OUTPUT);
bouton.attach(BP ,INPUT_PULLUP);
bouton.interval(10);
Serial.begin(9600);
}
void loop() {
bouton.update();
if(bouton.changed()){
// changement à l'appuiif(bouton.read() == 0){
signal1 = !signal1;
}
// chagement au relachementif(bouton.read() == 1){
signal2 = !signal2;
}
}
digitalWrite(LED1,signal1);
digitalWrite(LED2,signal2);
Serial.println(bouton.read());
}
bouton : instance de la classe Bounce
attach : permet de lier la broche du bouton
interval : temps minimal ente deux changements
update : met à jour à chaque loop
changed : booléen vrai en cas de changement
read : valeur du bouton (1 relâché, 0 appuyé)