Bouton poussoir

Les pattes en diagonale du bouton poussoir ne sont forcément pas connectées entre elles. Donc pour ne jamais vous trompez de sens utilisez 2 pattes en diagonale. (Nous utiliserons cette technique dans tous nos montages)

Astuce « beauté »

Vous pouvez aussi choisir la couleur de vos boutons grâce à ce kit.

Ou encore, vous pouvez en choisir de différentes tailles comme ceux-là.

Récupérer l’état d’un bouton poussoir

Les résistances de pull-up et pull down permet de tirer l’état du bouton poussoir à l’état haut (pull up) ou l’état bas (pull down) quand le bouton poussoir n’est pas appuyé. Ceci permet de ne pas avoir d’état indéfini (dit état Z) qui pourrait donner des valeurs incohérentes pour la valeur lue.

1) En utilisant une résistance pull-up externe

La résistance de pull-up permet de “tirer” la tension lue par la carte Arduino au 5V quand le bouton poussoir n’est pas appuyé. Quand l’utilisateur appuiera sur le bouton poussoir alors la valeur lue sera à l’état bas (0V). Quand le bouton poussoir sera relaché la valeur sera à l’état haut (5V).

Afin de faire circuler le courant dans le bouton poussoir, on le branche entre l’alimentation (5V) et la masse (GND). Puis pour récupérer l’état de l’interrupteur on branche le bouton au pin digital 2.

Si l’interrupteur est maintenu alors le moniteur en série affiche 0. Dans le cas contraire il affichera 1.

const int pin_INTERRUPTEUR = 2; // L’interrupteur est attaché au pin 2

void setup() {
    Serial.begin(9600); // Initialisation de la communication avec le moniteur série
    pinMode(pin_INTERRUPTEUR,INPUT);
}

void loop() {
    delay(1000) ; // Attente de 1000 ms
    boolean etatBouton = digitalRead(pin_INTERRUPTEUR) ; // Récupère l’état du bouton
    Serial.println(etatBouton) ; // Affiche l’état du bouton sur le moniteur
}

2) En utilisant une résistance pull-down externe

La résistance de pull-down a le rôle inverse de la résistance de pull-up : il permet de “tirer” la tension lue par la carte Arduino au GND quand le bouton poussoir n’est pas appuyé. Quand l’utilisateur appuiera sur le bouton poussoir alors la valeur lue sera à l’état haut (5V). Quand le bouton poussoir sera relâché la valeur sera à l’état bas (GND).

Si l’interrupteur est maintenu alors le moniteur en série affiche 1. Dans le cas contraire il affichera 0.

Le programme est le même que celui pour la résistance de pull-up.

3) En utilisant une résistance pull-up interne

Afin de simplifier les montages, il est possible de modifier le code pour que le pull-up s’effectue dans la carte Arduino.

const int pin_INTERRUPTEUR = 2; // L’interrupteur est attaché au pin 2

void setup() {
    Serial.begin(9600); //Initialisation de la communication avec le moniteur série
    pinMode(pin_INTERRUPTEUR, INPUT_PULLUP);
}

void loop() {
    delay(1000) ; // Attente de 1000 ms
    boolean etatBouton = digitalRead(pin_INTERRUPTEUR) ; // Récupère l’état du bouton
    Serial.println(etatBouton) ; // Affiche l’état du bouton sur le moniteur
}

pinMode(2, INPUT_PULLUP) permet d’initialisez la broche numérique 2 en tant qu’entrée avec la résistance de rappel interne.

Allumer une led avec un bouton poussoir

Lorsque l’on appuie sur le bouton le courant passe, la led s’allume. Lorsqu’on le relâche le courant ne passe plus, donc la led s’éteint.

Pourquoi est-ce important de mettre une résistance ?

La tension de sortie de l’arduino étant en 5V, il est nécessaire de mettre une résistance pour ne pas griller la led. Ici il est conseillé d’utiliser une résistance de 220 ohms.

Pour savoir quelle valeur fait votre résistance aller voir notre cours sur le sujet : ici.

Comment faire un éclairage ?

Alors c’est bien d’arriver à allumer une led, mais ce n’est pas vraiment pratique de devoir maintenir un bouton en permanence pour être éclairé. Pour résoudre ce problème vous pouvez utiliser un interrupteur. En effet l’interrupteur va garder sa position (il ne faut pas garder le doigt dessus pour que le courant passe) contrairement au bouton poussoir.

Tout le monde n’a pas d’interrupteur, alors voici une manière simple de programmer votre bouton poussoir pour qu’il agisse comme tel.

Transformer un bouton poussoir en interrupteur

const int pin_INTERRUPTEUR = 2;
const int pin_LED = 4;
boolean ledAllumer = 0;
boolean boutonAppuyer = 0;

void setup() {
    pinMode(pin_INTERRUPTEUR, INPUT_PULLUP);
    pinMode(pin_LED, OUTPUT);
    Serial.begin(9600); //Initialisation de la communication avec le moniteur série
}

void loop() {
    boolean etatBouton = digitalRead(pin_INTERRUPTEUR) ; // Récupère l’état du bouton
    if(etatBouton == 0 and boutonAppuyer == 0) { // On appuie sur le bouton
        boutonAppuyer = 1;
        if(ledAllumer == 0) { // Si la led est éteinte on l’allume
            digitalWrite(pin_LED, HIGH);
            Serial.println('allume') ;
            ledAllumer = 1;
        }
        else { // Si la led est allumée on l’éteint
            digitalWrite(pin_LED, LOW);
            ledAllumer = 0;
            Serial.println('eteint');
        }
    }
    if(etatBouton == 1 and boutonAppuyer == 1) { //On arrête d’appuyer sur le bouton
        boutonAppuyer = 0;
    }
    delay(10) ; // Attente de 10 ms
}

Faire un digicode avec des boutons poussoirs

Un bouton poussoir à des fonctionnalités insoupçonnées, il faut juste trouver comment les exploiter. Par exemple on peut utiliser les boutons poussoirs comme digicode.

Pour voir si le code tapé par l’utilisateur est le bon il faut regarder le moniteur en série.

int code[] = {1,1,1,1}; // Code (le code doit être uniquement composé de 0 et de 1)

int tab_pin[]={2,3,4,5}; //tableau pour stocker les pins des 4 boutons poussoirs
int tab_val[]={0,0,0,0}; //tableau pour lire l’état des 4 boutons poussoirs
int tab_val_stock[]={0,0,0,0}; //tableau pour stocker l’état des 4 boutons poussoirs
int changement = 0; // = 0 si aucun bouton n’a changé d’état
int bouton = -1;
int a = 0; //variable pour vérifier que le code est bon
int b = 0; //variable qui permet d’écrire “code réussi” plusieurs fois

void setup() {
    Serial.begin(9600);
    for (int i=0 ; i<4 ; i++) { //boucle qui initialise les ports des 4 boutons poussoirs
        pinMode(tab_pin[i], INPUT);
    }
}

void loop() {
    for(int i=0 ; i<4 ; i++) {
        tab_val[i] = digitalRead(tab_pin[i]); //stocke l’état du bouton poussoir
        if(tab_val[i] == 1 and bouton != i){
            changement = 1;
            bouton = i;
            if(tab_val_stock[i] == 0){
                tab_val_stock[i] = 1;
            }
            else {
                tab_val_stock[i] = 0;
            }
        }
    } // end for
    if(tab_val[bouton] == 0){
        bouton = -1;
    }
    // Affiche l’état de tous les boutons si au moins un seul change d’état ——
    if(changement == 1){
        Serial.println('==');
        b = 0;
        for(int i=0 ; i<4 ; i++) {
            Serial.println(tab_val_stock[i]) ;
        }
        changement = 0;
    }
    
    // Permet de vérifier le code ———————————————–
    for(int i=0 ; i<4 ; i++){
        if(tab_val_stock[i] != code[i]){
            a = 1;
        }
    }
    if(a == 0 and b == 0){
        Serial.println('code réussi') ;
        b = 1;
    }
    a = 0;

}

Pour aller plus loin

Pour simplifier les montages vous pouvez acheter un module matriciel à 16 boutons.

Si le principe de digicode vous plait et que vous souhaitez améliorer le système de code je vous conseille d’acheter un clavier matriciel Arduino et d’aller consulter notre cours.

Si vous préférez un digicode à l’aspect plus professionnel nous vous conseillons celui-ci.

FAQ

Est-ce qu'un bouton poussoir est un dipôle ?

Attention, même si le bouton poussoir possède 4 pattes, il s’agit d’un dipôle. En effet ses pattes sont reliées deux à deux.

Comment bien brancher un bouton poussoir ?

Les pattes en diagonale du bouton poussoir ne sont forcément pas connectées entre elles. Donc pour ne jamais vous trompez de sens utilisez 2 pattes en diagonale.