Introduction

bouton poussoir arduino

L’utilisation d’un bouton poussoir, va vous amener à comprendre comment fonctionnent les entrées sur la carte Arduino.

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.

Astuce pour ne plus jamais mal le brancher

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

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

résistance pull-up externe
résistance pull-up externe

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. On ne doit pas relier directement l’alimentation avec la masse donc on rajoute une résistance.

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

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

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

voidloop() {
    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-up interne

résistance pull-up interne
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.

constint 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);
}

voidloop() {
    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

Allumer une led avec un bouton poussoir

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

const int pin_LED = 2; // La led est attachée au pin 2

void setup() {
    pinMode(pin_LED, OUTPUT); // Initialise la led
}
voidloop(){
}

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.

Pourquoi pinMode(2, OUTPUT) ?

On initialise la led sur le port 2 de la carte Arduino. La led étant une sortie on marque « OUTPUT ».

 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

Transformer un bouton poussoir en interrupteur
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
}

voidloop() {
    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(“allumé”) ;
            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

faire un digicode arduino

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], OUTPUT);
    }
}

voidloop() {
    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.

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