Étape 1 / 3

digitalRead et INPUT_PULLUP

Lire l'état d'un bouton — pourquoi un pin flottant capte n'importe quoi.

Chapitres précédents non terminés

Pour un apprentissage optimal, termine d'abord : Boucles et tableaux

Lire un bouton avec digitalRead()

Jusqu'ici, l'Arduino envoyait des signaux (allumer des LEDs). Maintenant, il va recevoir des signaux — en lisant l'état d'un bouton poussoir.

Dans ce chapitre : tu vas apprendre à lire un bouton, créer un interrupteur intelligent, puis construire un vrai feu tricolore avec bouton piéton !

Le problème : le pin flottant

Si tu branches un bouton entre un pin et le GND, que lit le pin quand le bouton est relâché ? Ni HIGH, ni LOW — le pin flotte et capte du bruit électrique au hasard.

Analogie : un pin non connecté, c'est comme une antenne radio — il capte n'importe quel signal parasite autour de lui. Le résultat : des lectures aléatoires entre HIGH et LOW.

Pin flottant (pas de pull-up)

Signal aléatoire — inutilisable !

Avec INPUT_PULLUP

Stable HIGH au repos — LOW quand on appuie.

La solution : INPUT_PULLUP

L'Arduino a une résistance interne qu'on peut activer avec INPUT_PULLUP. Elle « tire » le signal vers HIGH quand le bouton est relâché :

void setup() {
  pinMode(2, INPUT_PULLUP);  // Active la pull-up interne
}

void loop() {
  int etat = digitalRead(2);
  // etat = HIGH → bouton relâché
  // etat = LOW  → bouton appuyé
}

HIGH

Bouton relâché (repos)

LOW

Bouton appuyé (contact GND)

Attention : avec INPUT_PULLUP, la logique est inversée ! LOW = appuyé, HIGH = relâché. C'est le piège classique des débutants.

Comment fonctionne le bouton 4 pattes ?

Le bouton poussoir a 4 pattes, mais seulement 2 circuits internes. C'est le piège classique du débutant : si tu branches tes fils sur les mauvaises pattes, le circuit est toujours fermé (ou toujours ouvert) et le bouton ne fait rien !

Paire A-D (haut) : les pattes A et D sont toujours connectées entre elles, même sans appuyer.

Paire B-C (bas) : les pattes B et C sont toujours connectées entre elles aussi.

Appui : quand tu appuies, la paire A-D se connecte à la paire B-C → le courant passe.

Piège : si tu branches tes 2 fils sur des pattes de la même paire (ex : A et D), le circuit est toujours fermé, le bouton ne coupe jamais ! Il faut toujours brancher un fil sur la paire A-D et l'autre sur la paire B-C.

Astuce breadboard : en plaçant le bouton à cheval sur le fossé central, la paire du haut est dans la section supérieure (rangées a-e) et la paire du bas dans la section inférieure (rangées f-j). C'est comme ça qu'on le câble dans nos montages.

Schéma du circuit : bouton + LED

Le bouton est branché entre le pin D2 et le GND. Quand on appuie, le pin passe à LOW. La LED sur le pin D7 s'allume pour confirmer l'appui.

D2 → Bouton → GND | D7 → R 220Ω → LED → GND

Montage pas à pas

Bouton poussoir à cheval sur le fossé (colonne 8). Câble bleu du pin D2 vers la rangée d. Cavalier de la rangée g vers le rail − GND.

100%

Code : allumer la LED au bouton

const int BTN = 2;
const int LED = 7;

void setup() {
  pinMode(BTN, INPUT_PULLUP);
  pinMode(LED, OUTPUT);
}

void loop() {
  if (digitalRead(BTN) == LOW) {
    digitalWrite(LED, HIGH);  // Bouton appuyé → LED ON
  } else {
    digitalWrite(LED, LOW);   // Bouton relâché → LED OFF
  }
}

Exercice : complète le code

Remplis les trous pour configurer le bouton et lire son état :

1. Quel mode pour activer la résistance pull-up interne ?

pinMode(2, );

2. Quelle fonction Arduino pour LIRE l'état d'un pin ?

int etat = (2);

3. Avec INPUT_PULLUP, quelle valeur quand le bouton est APPUYÉ ?

if (etat == ) { // Bouton appuyé !

À retenir

digitalRead(pin) lit l'état d'un pin : HIGH ou LOW.
INPUT_PULLUP active une résistance interne qui stabilise le signal à HIGH au repos.
Avec pull-up : LOW = appuyé, HIGH = relâché (logique inversée).
Un pin non connecté (flottant) lit des valeurs aléatoires — toujours utiliser une résistance pull-up ou pull-down.

Valide cette étape quand tu as terminé la lecture et la manipulation.

Première étape du chapitre Exo 8 : Interrupteur intelligent →