Leçons · Leçon K2 · Les bases du code · 20 min
Entrées, sorties et si
Lis un bouton, allume une DEL et un buzzer, et laisse ton code décider quoi faire. Environ 20 minutes, avec un bouton virtuel à presser.
Deux sens
Dans la leçon K1, ton code envoyait un signal : digitalWrite() allumait et éteignait une DEL. Cette leçon ajoute l’autre sens. Une broche peut fonctionner de deux façons [1][3] :
- Sortie : la carte décide du niveau de la broche, haut ou bas, pour commander quelque chose comme une DEL ou un buzzer.
- Entrée : la carte écoute le niveau de la broche, pour savoir ce que fait le monde extérieur, par exemple si un bouton est pressé.
Tu choisis le sens avec pinMode(), une seule fois, dans setup() : OUTPUT pour envoyer, INPUT (ou l’un de ses cousins plus bas) pour écouter [1][3]. Ensuite, digitalWrite(broche, HIGH ou LOW) règle une sortie, et digitalRead(broche) te donne le niveau d’une entrée, HIGH ou LOW [1].
Le circuit du jour utilise trois broches. On garde la GPIO 26 pour la DEL de K1, et on ajoute un bouton sur la GPIO 27 et un buzzer sur la GPIO 25.
Le problème de la broche flottante
Imagine une broche d’entrée à laquelle rien n’est relié. Si ton code la lit, que voit-il ? Personne ne peut le dire. La broche est flottante : elle peut dériver vers le haut ou vers le bas, et changer toute seule [5].
Le remède : donner à la broche un niveau par défaut. Une résistance de rappel vers le haut (pull-up) relie la broche à la tension d’alimentation à travers une résistance, de sorte que la broche lit « haut » quand rien d’autre ne se passe. Une résistance de rappel vers le bas (pull-down) fait la même chose vers la masse [5].
Le ressort de la porte. Pense à une porte équipée d’un ressort qui la garde fermée. Personne ne la touche, elle reste fermée : c’est la résistance de rappel qui maintient la broche en haut. Pousse la porte et tu vaincs le ressort : c’est le bouton qui relie la broche à la masse. Tu lâches, et le ressort ramène la porte.
Là où l’image s’arrête. Un ressort pousse avec une force. Une résistance de rappel est une résistance : quand tu presses le bouton, un petit courant la traverse vers la masse, et plus sa valeur est grande, moins le courant est fort [5].
Aucune pièce en plus : la résistance de rappel intégrée
L’ESP32 a des résistances de rappel à l’intérieur de la puce, d’environ 45 kΩ chacune [3]. Tu en actives une depuis le code avec un mode spécial :
pinMode(27, INPUT_PULLUP);
INPUT_PULLUP veut dire « entrée, avec la résistance de rappel interne activée » [3][6].
Branche le bouton : une patte à la GPIO 27, la patte en diagonale à GND. Sur un bouton à 4 pattes, deux pattes sont toujours reliées à l’intérieur : les coins en diagonale sont donc les deux côtés de l’interrupteur. Rien d’autre, pas de résistance [4][6].
Voici ce que ton code lit alors [4][6] :
| Bouton | Broche reliée à | digitalRead(27) |
|---|---|---|
| Pas pressé | la résistance de rappel (haut) | HIGH (1) |
| Pressé | GND | LOW (0) |
Oui, ça paraît à l’envers : pressé = LOW. On appelle ça la logique inversée, et on s’y habitue vite [4].
Choisir la broche. Toutes les broches de l’ESP32 ne conviennent pas à ce rôle. Les GPIO 34 à 39 sont uniquement des entrées et n’ont ni résistance de rappel haute ni basse, donc elles ne peuvent pas faire ce qu’il nous faut [8]. Les GPIO 0, 2, 5, 12 et 15 participent au choix de la façon dont la puce démarre (ce sont des « broches de strapping ») : n’y relie ni bouton ni fil pour l’instant [8][9]. La GPIO 12, par exemple, règle la tension de la mémoire flash au démarrage : un bouton à cet endroit peut empêcher la carte de démarrer [9]. La GPIO 27 est un choix sûr sur la DevKitC.
Un rappel sur la tension. L’ESP32 utilise une logique 3,3 V, et ses broches ne supportent en général pas 5 V [10]. Tout dans cette leçon reste à 3,3 V.
Fais glisser le dessin sur le côté pour tout voir.
Le buzzer actif
Un buzzer transforme un signal électrique en son. Il en existe deux sortes. Un simple élément piézo a besoin que tu lui envoies un signal qui change très vite pour faire du bruit. Un buzzer actif contient un petit circuit de commande. Donne-lui du courant et il sonne à une hauteur fixe (environ 2 kHz pour le modèle qu’Adafruit décrit), et tu ne peux pas changer cette hauteur [7].
C’est facile à utiliser : pour ton code, il se comporte exactement comme la DEL. HIGH veut dire son, LOW veut dire silence. Le modèle qu’Adafruit décrit fonctionne de 3 V à 5 V [7], donc une broche à 3,3 V entre dans sa plage.
Choisis le bon buzzer. Une broche d’ESP32 est prévue pour fournir environ 20 mA à elle seule [13]. Prends donc un buzzer actif prévu pour 3,3 V (ou « 3-5 V ») dont la page produit indique un courant de 20 mA ou moins. On en vend deux sortes :
- Buzzer actif à 2 broches (un petit cylindre noir, souvent avec un autocollant dessus) : la patte marquée + (en général la plus longue) à la GPIO 25, l’autre patte à GND.
- Module buzzer à 3 broches (une petite carte marquée VCC, GND et I/O ou S) : VCC à 3V3, GND à GND, I/O à la GPIO 25. Le module a son propre transistor, donc la broche n’a qu’un petit signal à envoyer. Certains modules sonnent quand la broche est à LOW au lieu de HIGH (« déclenchement par niveau bas »). Si le tien sonne quand le bouton est relâché, échange
HIGHetLOWsur les deux lignes du buzzer dans le programme.
Si tu ne sais pas ce que tu as, prends un module à 3 broches prévu pour 3,3 V.
Plus tard, la leçon A1 présente les buzzers passifs et la façon de jouer des notes.
Décider avec if / else
La carte sait maintenant ce que dit le bouton. Pour agir en conséquence, ton code doit faire un choix. C’est le rôle de if (« si ») :
if (reading == LOW) {
// le bouton est pressé : fais ceci
} else {
// sinon : fais cela
}
Lis-le comme une phrase : « Si la lecture est égale à LOW, exécute le premier bloc. Sinon, exécute le second. » Un seul bloc s’exécute à chaque fois [4].
Deux détails qui piègent beaucoup de débutants :
==pose une question,=donne un ordre.reading == LOWvérifie si deux choses sont égales, et c’est ce que fait le test de notre programme [4]. Un seul=range une valeur, comme dansint ledPin = 13;[11]. Dans unif, écris deux signes égal.if (reading = LOW)est accepté par le compilateur, mais il range LOW au lieu de comparer : la DEL ne s’allume donc jamais.- Les accolades
{ }entourent les lignes qui appartiennent à chaque branche.
Comme loop() tourne sans arrêt, la décision est prise encore et encore, plusieurs fois par seconde. C’est comme ça que la DEL a l’air de suivre ton doigt.
Fais glisser le dessin sur le côté pour tout voir.
Le programme complet
Téléverse celui-ci, avec le circuit monté et la carte branchée comme dans la leçon K1 :
// Tinker Mission, leçon K2 : bouton -> DEL + buzzer actif, décidé avec if/else
// Câblage :
// Bouton : une patte sur la GPIO 27, la patte en diagonale sur GND (pas de résistance nécessaire)
// DEL : GPIO 26 -> 220 ohms -> patte longue de la DEL ; patte courte -> GND
// Buzzer actif : patte + sur la GPIO 25, autre patte sur GND (module à 3 broches : VCC sur 3V3, GND sur GND, I/O sur GPIO 25)
const int BUTTON_PIN = 27;
const int LED_PIN = 26;
const int BUZZER_PIN = 25;
void setup() {
Serial.begin(115200);
pinMode(BUTTON_PIN, INPUT_PULLUP); // entrée, avec la résistance de rappel de la carte activée
pinMode(LED_PIN, OUTPUT);
pinMode(BUZZER_PIN, OUTPUT);
}
void loop() {
int reading = digitalRead(BUTTON_PIN); // 1 (HIGH) = pas pressé, 0 (LOW) = pressé
if (reading == LOW) {
// pressé
digitalWrite(LED_PIN, HIGH);
digitalWrite(BUZZER_PIN, HIGH);
} else {
// pas pressé
digitalWrite(LED_PIN, LOW);
digitalWrite(BUZZER_PIN, LOW);
}
Serial.println(reading);
delay(50); // courte pause pour que le moniteur série reste lisible
}
Télécharger le dossier du croquis (.zip)
int reading = ... crée une variable, un endroit nommé où ranger un nombre. Elle s’appelle reading, elle contient un nombre entier (int), et elle reçoit ce que digitalRead() a renvoyé [11].
Ouvre le moniteur série à 115200 baud. Tu dois voir défiler des 1, et des 0 tant que tu maintiens le bouton [4].
Dépannage.
- La DEL et le buzzer restent allumés tout le temps et le moniteur affiche 0 : la broche est maintenue à la masse. Vérifie le câblage du bouton avec le schéma : une patte sur la GPIO 27, la patte en diagonale sur GND. Avec deux pattes du même côté, le bouton peut être toujours fermé.
- Le moniteur n’affiche que des 1, même quand tu appuies : le bouton n’est pas vraiment relié. Vérifie le fil sur la GPIO 27 et celui sur GND, et que les pattes du bouton sont bien enfoncées dans la plaque d’essai [3][4].
- Le moniteur saute tout seul entre 0 et 1 : la broche est flottante. Vérifie que
setup()contientINPUT_PULLUPet nonINPUT[5][12]. - Pas de son, mais la DEL fonctionne : vérifie la patte + du buzzer, et lis sa fiche technique pour connaître la tension dont il a besoin. Un module à 3 broches a besoin de son VCC sur 3V3.
- Le buzzer sonne quand le bouton est relâché et s’arrête quand tu appuies : ton module se déclenche à LOW. Échange
HIGHetLOWsur les deux lignes du buzzer.
Fais tes propres modifications
Change une seule chose, téléverse, observe.
- Inverse. Fais allumer la DEL quand le bouton n’est pas pressé. Quel test du
ifchanges-tu ? - Mode silencieux. Retire les deux lignes du buzzer dans la branche « pressé ». Que reste-t-il ?
- Des mots, pas des nombres. Remplace
Serial.println(reading);par l’affichage de « pressed » ou « released », choisi avec le mêmeif.
Vérifie-toi
Trois petites questions. Rien n’est enregistré, prends ton temps.
Un bouton est branché entre une broche et GND, et la broche utilise INPUT_PULLUP. Que renvoie digitalRead() tant que le bouton n’est PAS pressé ?
- LOW (0)
- HIGH (1)
- Rien, c’est indéterminé
Dans le programme, tu veux que la DEL s’allume tant que le bouton est pressé. Quel test mets-tu dans le if ?
- reading == HIGH
- reading == LOW
- reading = LOW
De quoi un buzzer actif a-t-il besoin de la part de ton code pour émettre son son ?
- D’un signal qui change très vite et que tu fabriques toi-même
- D’alimentation seulement : digitalWrite HIGH l’allume
- D’une résistance vers GND sur chaque patte
Voir la réponse
D’alimentation seulement : digitalWrite HIGH l’allume. Un buzzer actif contient son propre circuit de commande : il n’a pas besoin d’un signal alternatif de ta part, et sa hauteur de son est fixe [7].
Sources
Voir les 13 sources
- Espressif, documentation Arduino-ESP32, « GPIO » (modes entrée et sortie ; pinMode, digitalWrite, digitalRead ; INPUT_PULLUP) — https://docs.espressif.com/projects/arduino-esp32/en/latest/api/gpio.html
- Arduino, exemple « Input Pullup Serial » (quand le bouton est ouvert, la broche lit HIGH ; fermé, relié à la masse, elle lit LOW) — https://docs.arduino.cc/built-in-examples/digital/InputPullupSerial/
- Espressif, documentation Arduino-ESP32, « GPIO » (les résistances de rappel haute et basse internes font environ 45 kΩ ; sans mode de rappel, la broche reste en haute impédance) — https://docs.espressif.com/projects/arduino-esp32/en/latest/api/gpio.html
- Arduino, exemples « Input Pullup Serial » et « Digital Input Pull-Up Resistor » (bouton branché entre une broche et la masse sans résistance ; HIGH quand ouvert, LOW quand fermé ; la logique est inversée ; if/else sur la lecture ; comparaison
==dans le programme) — https://docs.arduino.cc/built-in-examples/digital/InputPullupSerial/ et https://docs.arduino.cc/tutorials/generic/digital-input-pullup/ - SparkFun, « Pull-up Resistors » (une broche flottante a un état inconnu ; pull-up et pull-down ; une résistance de rappel haute lit « haut » bouton relâché et « bas » bouton pressé ; valeur externe typique de 10 kΩ ; résistances de rappel internes) — https://learn.sparkfun.com/tutorials/pull-up-resistors
- Arduino, « Digital Pins » (INPUT_PULLUP inverse le comportement de INPUT ; avec un simple interrupteur vers la masse, la broche lit HIGH ouvert et LOW pressé) — https://docs.arduino.cc/learn/microcontrollers/digital-pins/
- Adafruit, « Buzzer 5V - Breadboard friendly », produit 1536 (3 V à 5 V ; pas besoin de signal alternatif ; piézo plus circuit de commande ; 2 kHz fixe ; fréquence non modifiable) — https://www.adafruit.com/product/1536
- Espressif, ESP-IDF Programming Guide, « GPIO & RTC GPIO » (les GPIO 34 à 39 sont uniquement des entrées et n’ont ni rappel haut ni bas activable par logiciel ; les GPIO 0, 2, 5, 12 et 15 sont des broches de strapping) — https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/peripherals/gpio.html
- Espressif, documentation esptool, « Boot Mode Selection » (GPIO 0 maintenue à l’état bas au reset = bootloader série ; GPIO 2 doit être flottante ou basse pour cela) — https://docs.espressif.com/projects/esptool/en/latest/esp32/advanced-topics/boot-mode-selection.html
- Adafruit, « Adafruit HUZZAH32 ESP32 Feather: Pinouts » (alimentation et logique 3,3 V ; les broches GPIO ne tolèrent pas 5 V sauf mention contraire) — https://learn.adafruit.com/adafruit-huzzah32-esp32-feather/pinouts
- Arduino, « Arduino Sketches » (une variable est un endroit nommé pour ranger une donnée, avec un type et une valeur ;
int) — https://docs.arduino.cc/learn/programming/sketches/ - Arduino, « Digital Pins » (une broche d’entrée sans rien de relié signale des changements apparemment aléatoires) — https://docs.arduino.cc/learn/microcontrollers/digital-pins/
- Espressif, fiche technique ESP32 Series Datasheet, caractéristiques DC et force de sortie de l’IO MUX (la force par défaut est d’environ 20 mA par broche ; le réglage le plus élevé, d’environ 40 mA) — https://www.espressif.com/sites/default/files/documentation/esp32_datasheet_en.pdf