Le bouton poussoir

Dans ce tutoriel nous allons comprendre comment le bouton poussoir peut intéragir de différentes façons avec une carte microcontrôleur.

Le bouton poussoir ou interrupteur poussoir, est la base de l'interactivité, entre l'homme et la machine. Il permet de commander un objet, une machine ou simplement une lumière.

Il existe deux types de boutons poussoir, le normalement ouvert dit "NO" et le normalement fermé dit "NF".
Lorsque l'on appuie sur le bouton poussoir, celui-ci laisse passer le courant, et lorsqu'il revient à sa position initiale (simplement en lâchant la pression), il ne laissera plus passer le courant. C'est un bouton poussoir de type "NO".
Et inversement, lorsque l'on appuie sur le bouton, celui-ci ne laisse pas passer le courant, lorsque l'on relâche celui-ci laisse passer le courant. Il est de type "NC".

Il existe une subtilité lorsque l'on connecte un bouton poussoir en entrée du microcontrôleur. En effet le signal d'entrée de la carte sera perturbé par l'environnement dans lequel il se trouve. Ce sont des parasites qui peuvent provenir de vos téléphones, lumières, appareils électriques... Ainsi, l'Arduino captera une valeur erronée de la part de son bouton poussoir qui sera dans une position de potentiel flottant.

Pour palier à ce problème, il existe deux méthodes :
- Soit rajouter une résistance d'au moins 10 kΩ en série du bouton.
- Soit activer la résistance de "PULLUP" dans la carte Arduino à l'aide d'une fonction dans sa programmation. Cette interne à la carte et cela permet d'ajouter une résistance de 20 kΩ en série du bouton.

Dans les prochains essais, nous utiliserons la seconde méthode. Vous pouvez donc ranger vos résistances de 10 kΩ.

Passons à la pratique!

Le but de ce premier programme, sera d'afficher sur le moniteur série du logiciel IDE ARDUINO, si l'on appuie ou pas sur le bouton poussoir.

Lorsque vous appuyez sur le bouton, il est noté dans le moniteur série "j'appuie sur le bouton" et lorsque vous n'appuyez pas sur le bouton, il est noté "je n'appuie pas sur le bouton".

Le montage précédent présente des limites. En effet, lorsque l'on reste appuyé sur le bouton, le moniteur série affiche en continu "J'appuie sur le bouton", et lorsque je n'appuie pas sur ce dernier, le moniteur série affiche en continu "Je n'appuie pas sur le bouton".
Cela a pour effet de saturer le moniteur série et notre carte, mais aussi de causer beaucoup de problèmes pour effectuer des tâches en parallèles. De plus il n 'y aura pas d'auto-maintiens.
La programme suivant, nous permettra donc :

- D'inscrire une seule fois l'état du bouton dans le moniteur série
- De gérer plus facilement plusieurs tâches dans le programme.

Nous garderons le même montage que précédemment.

/*Tutoriel par IHM-3D */

int bouton = 2; // déclaration du bouton

int boutonappui = 0; // variable lorsque j'appuie sur le bouton
int etatbouton = 0; // etat dans lequel se trouve le bouton
int bouton_pasappui = 0;// variable lorsque je n'appuie pas sur le bouton

void setup() {

pinMode(bouton, INPUT_PULLUP);// déclaration du bouton en entrée avec la résistance pullup

Serial.begin(9600);// mon port de communication
Serial.println ("Bienvenue sur les tutoriels d'IHM-3D");
}
void loop() {

etatbouton = digitalRead(bouton);//etatbouton est égale à la lecture du bouton

if (etatbouton != bouton_pasappui) {// si etatbouton est différent de bouton pas_appui, simplement si j'appuie sur le bouton

if (etatbouton == LOW) {// et que la position du bouton est à LOW (inversé avec la résistance de PULLUP)
Serial.println("J'appuie sur le bouton");// Je note dans le moniteur que j'appuie sur le bouton

} else {
Serial.println("Je n'appuie pas sur le bouton");//et lorsque je n'appuie sur le bouton, je l'inscris dans le moniteur
}
delay(50);
}
bouton_pasappui = etatbouton;
}
/**********************FIN DU PROGRAMME***************************/

Ouvrez votre moniteur série, appuyez sur le bouton et constatez ce qu'il se passe. Celui-ci affiche une seule fois l'information. Si le bouton change d'état, la seconde information s'affichera

Pour gérer l'interaction entre l'homme et la machine, il est plus sympathique de pouvoir commander un objet électronique que de lire des lignes sur un moniteur série, c'est pour cela que je vous proposes de mettre en application ce que l'on a vu précédemment :
Nous allons remplacer les inscriptions dans le moniteur série, par une LED.

- Une carte type UNO

- Un bouton poussoir

- Une led électronique

- Une résistance de 100Ω au minimum

- Une bread-board

- Des fils de connexion

/* TUTORIELS IHM 3D*/

int bouton = 2; // déclaration du bouton
int led = 3;// ajout d'une led en PIN 3

int boutonappui = 0; // variable lorsque j'appuie sur le bouton
int etatbouton = 0; // etat dans lequel se trouve le bouton
int bouton_pasappui = 0;// variable lorsque je n'appuie pas sur le bouton

void setup() {

pinMode(bouton, INPUT_PULLUP);// déclaration du bouton en entrée avec la résistance pullup
pinMode (led, OUTPUT);// déclaration de la la LED en sortie

Serial.begin(9600);// ouverture port de communication
}

void loop() {

etatbouton = digitalRead(bouton);//etatbouton est égale à la lecture du bouton

if (etatbouton != bouton_pasappui) {// si etatbouton est différent de bouton pas_appui, simplement si j'appuie sur le bouton

if (etatbouton == LOW) {// et que la position du bouton est à LOW (inversé avec la résistance de PULLUP)

digitalWrite (led, HIGH);
Serial.println("La LED est allumée");

} else {

digitalWrite (led, LOW);
Serial.println("La LED est éteinte");
}
delay(50);
}
bouton_pasappui = etatbouton;
}
/**************************FIN DU PROGRAMME******************************/

Ouvrez votre moniteur série, appuyez sur le bouton. La led s'allume, c'est aussi inscrit dans le moniteur. Maintenant relâchez le bouton, la led s'éteint.

Lorsque j'appuie sur le bouton poussoir et que je relâche celui-ci par la suite, la LED reste allumée. Si j'appuie une seconde fois sur le bouton poussoir, la LED s'éteint. Cela fonctionnera comme un interrupteur.

Nous gardons le même montage que le paragraphe précédent, seul le programme va changer.

/*TUTORIEL IHM 3D*/

int bouton = 2;// bouton sur la PIN 2
int led = 3;// bouton sur la PIN 3

int etatbouton = 0; // variable etat bouton (appuie ou non appuie
int dernieretatbouton = 0;// variable memoire derniere position du bouton
int etatled = 0;// varibale de la led, soit éteinte soit allumée

void setup() {

Serial.begin (9600);
pinMode(bouton, INPUT_PULLUP);
pinMode(led, OUTPUT);
}

void loop() {

//stockage de la position du bouton dans la variable etatbouton
etatbouton = digitalRead(bouton);

if (etatbouton != dernieretatbouton) {

if (!etatbouton) {//si etatbouton est différent de 1 (je rappelle que les états sont inversés dûs à la résistance de PULLUP

if (etatled)//et que si etatled est à 1

etatled = 0;//nous passons etatled à

else

etatled = 1;//sinon nous le passons à 1
}
dernieretatbouton = etatbouton;
}
Serial.println (etatled);
digitalWrite(led, etatled);
delay(20);
}
/***********************FIN DU PROGRAMME**************************/

Lorsque j'appuie sur le bouton puis le relâche par la suite, la led reste allumée. Si j'appuie une seconde fois sur ce dernier, elle s'éteint. On appelle ceci un auto-maintiens.

Le but de ce dernier chapitre sera à l'aide de trois boutons poussoirs, de choisir le nombre de clignotements de la LED :

- Un bouton pour l'incrémentation.
- Un bouton pour la décrémentation.
- Un bouton pour valider le départ du nombre de clignotement.

- Une carte de type UNO

- 3 boutons poussoirs NO

- Une led électronique

- Une résistance de 100Ω au minimum

- Une bread board

- Des fils de connexion

- La led et la résistance en série connectées sur PIN3 de la carte.

- Le bouton de décrémentation sur la PIN 2 de la carte.

- Le bouton d'incrémentation sur la PIN 5 de la carte.

- Le bouton de validation sur la PIN 4 de la carte.

/*TUTORIELS IHM 3D*/
 
int bouton1 = 2;//décrémentation du comptage
int bouton2 = 4;//bouton de validation du comptage
int bouton3 = 5;//incrémentation du comptage
 
int LED = 3;//pin de la led
 
int comptage = 0, Memoire = LOW; // variable de stockage du comptage et des boutons poussoir
 
int ETATBP1;//variable etat bouton
int ETATBP2;//variable etat bouton
int ETATBP3;//variable etat bouton
 
int BP2_ACTIVE = 0;// lecture de l'état du bouton 2
 
void setup() {
 
  Serial.begin(9600);
 
  Serial.println ("Bienvenue sur les tutoriels d'IHM-3D");
 
  pinMode (bouton1, INPUT_PULLUP);//ne pas oublié la résistance de PULLUP
  pinMode (bouton2, INPUT_PULLUP);
  pinMode (bouton3, INPUT_PULLUP);
 
  pinMode (LED, OUTPUT);
}
 
void loop() {
 
  ETATBP1 = digitalRead(bouton1);
 
  if ((ETATBP1 != Memoire) && (ETATBP1 == HIGH))
  {
    comptage++;
 
    Serial.println(comptage);
    delay(200);
 
  }
  Memoire = ETATBP1;
  boutonvalidation();//fonction du bouton de validation du comptage led
  bouton301();//fonction incrémentation du bouton
}
 
void boutonvalidation() {
 
  int i;
 
  ETATBP2 = digitalRead(bouton2);
 
/* Si j'appuie sur ce bouton, alors la LED clignotera le nombre de fois le nombre, stockée dans la variable "comptage"*/
 
  if (ETATBP2 == BP2_ACTIVE) {
 
    for (i = 0; i <= comptage -1; i++) {
     
      /*le "-1" situé au niveau de "comptage -1" enlève une incrémentation.
      En effet celle-ci démarre à partir de 0. Si le -1 était absent, la LED clignotera une fois de plus.*/
 
      digitalWrite (LED, HIGH);
      delay(500);
      digitalWrite (LED, LOW);
      delay(500);
    }
    Serial.println ("Ma LED a bien clignoté :");
    Serial.print (comptage);
    Serial.println (" fois");
  }
}
 
void bouton301() {
 
  ETATBP3 = digitalRead(bouton3);
 
  if ((ETATBP3 != Memoire) && (ETATBP3 == HIGH))
  {
    comptage--;
 
    Serial.println(comptage);
    delay(200);
  }
  Memoire = ETATBP3;
}

J'appuie sur les boutons poussoirs d'incrémentation et de décrémentation pour atteindre le nombre de clignotements voulus.

J'appuie sur le bouton de validation pour commencer le cycle.

Une fois celui-ci terminé, le système me confirme que ma led a clignoté le nombre de fois voulu (5 fois pour l'exemple).

Tout est indiqué dans le moniteur série de l'ARDUINO.

Ce tutoriel est maintenant terminé. Il est très important de bien comprendre le fonctionnement du bouton poussoir, il permettra d'ouvrir des portes à énormément d'applications. N'hésitez pas à parcourir le site d'IHM-3D, de poser vos questions à l'adresse située en bas. Merci de votre attention.