English

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].

La résistance de rappel : l'idée du ressort de porte Deux états du même circuit. Une alimentation de 3,3 V alimente une résistance de rappel qui descend vers un nœud relié à la broche GPIO 27 ; un bouton-poussoir va de ce nœud à la masse. À gauche, bouton relâché : aucun courant ne circule, la résistance de rappel maintient la broche à 3,3 V et digitalRead renvoie 1, HIGH. À droite, bouton pressé : la broche est reliée à la masse, elle lit 0, LOW, et un petit courant traverse la résistance vers la masse. En dessous, l'analogie : un ressort garde la porte fermée quand personne ne pousse ; ta poussée vainc le ressort. L'image s'arrête là : une résistance n'est pas une force, et plus elle est grande, plus le courant est faible. FIG. 1 — RAPPEL = RESSORT DE PORTEaBouton relâché3V3rappel≈ 45 kΩGPIO 27boutonla broche lit1HIGHLe rappel tient la broche à 3,3 V.Aucun courant ne circule.ressortportePersonne ne pousse : la porte reste fermée.bBouton pressé3V3rappel≈ 45 kΩGPIO 27boutonla broche lit0LOWIBroche reliée à GND : 0 V.Un petit courant I part vers la masse.ressortta pousséeTu pousses : tu vaincs le ressort.
Touche le schéma pour l’ouvrir en plein écran.

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.

Bouton virtuel sur la GPIO 27 avec rappel
Bouton virtuel sur la GPIO 27 avec rappel Interactif. Appuie sur le gros bouton et maintiens-le. Relâché, la résistance de rappel tient la GPIO 27 à 3,3 V : la broche lit 1, digitalRead(27) renvoie HIGH, et le ressort garde la porte fermée. Pressé, la broche est reliée à GND : elle lit 0, LOW, et ta poussée vainc le ressort. Une ligne en bas trace le niveau de la broche sur les dernières secondes. FIG. W2 — BOUTON VIRTUELappuie et maintiensressortporterappel = ressortGPIO 271broche à 3,3 VdigitalRead(27)→ HIGH10temps →

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 HIGH et LOW sur 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.

Câblage K2 : buzzer sur 25, DEL sur 26, bouton sur 27 Plaque d'essai vue de dessus, DevKitC à cheval sur la rainure, USB à gauche, broches 25, 26, 27 et GND sur la rangée du haut, colonne j libre. Huit fils numérotés. 1 noir : broche GND vers le rail moins du haut. 2 orange : GPIO 25 vers la rangée 22, patte plus du buzzer actif ; son autre patte est en rangée 25 ; 3 noir : rangée 25 vers le rail moins du haut. 4 vert : GPIO 26 vers la rangée 28 ; la résistance de 220 ohms relie les rangées 28 et 32 ; la patte longue de la DEL est en rangée 32, la courte en rangée 33 ; 5 noir : rangée 33 vers le rail moins du haut. 6 bleu : GPIO 27 vers la rangée 37, une patte du bouton, à cheval sur la rainure sur les rangées 37 et 39 ; 7 noir : la patte opposée, rangée 39 moitié basse, vers le rail moins du bas ; 8 noir : rail moins du bas vers rail moins du haut, pour que les deux rails soient à GND. FIG. 2 — CÂBLAGE, VUE PLAQUE D'ESSAI+−−+jihgfedcba15101522252832373944ENBOOT5VCMDD3D213GND121427262533323534VNVPEN3V3++24613578buzzer actif220 ΩDELbouton1noir : broche GND → rail − du haut2orange : GPIO 25 → + du buzzer (rangée 22)3noir : − du buzzer (rangée 25) → rail −4vert : GPIO 26 → 220 Ω (rangée 28)5noir : − de la DEL (rangée 33) → rail −6bleu : GPIO 27 → bouton (rangée 37)7noir : bouton, patte opposée → rail − du bas8noir : rail − du bas → rail − du hautLa partie DEL est celle de K1, décalée. Le bouton n'a pas besoin de résistance : INPUT_PULLUP.
Touche le schéma pour l’ouvrir en plein écran.
Le circuit K2 en schéma Schéma IEC. Dans l'ESP32, en pointillés, une résistance de rappel interne d'environ 45 kilohms relie la GPIO 27 au 3,3 V quand le code dit INPUT_PULLUP. La GPIO 27 passe par un bouton-poussoir jusqu'à la masse : pressé, elle lit LOW. La GPIO 26 commande une résistance de 220 ohms et une DEL vers la masse : HIGH l'allume. La GPIO 25 commande la broche plus d'un buzzer actif dont l'autre broche va à la masse : HIGH le fait sonner. FIG. 3 — SCHÉMA (IEC)ESP32GPIO 27GPIO 26GPIO 253V3rappel ≈ 45 kΩdans la puce :INPUT_PULLUPboutonpressé → lit LOW220 ΩDELHIGH → allumée+−buzzer actifHIGH → son
Touche le schéma pour l’ouvrir en plein écran.

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 == LOW vérifie si deux choses sont égales, et c’est ce que fait le test de notre programme [4]. Un seul = range une valeur, comme dans int ledPin = 13; [11]. Dans un if, é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.

if / else, pas à pas
if / else, pas à pas Interactif. Appuie sur le bouton virtuel à gauche. L'organigramme de loop() lit le bouton dans reading, puis demande si reading est égal à LOW. Pressé, reading vaut 0 : la branche oui s'allume, la DEL et le buzzer se mettent en marche. Relâché, reading vaut 1 : la branche non s'allume, les deux s'arrêtent. Une seule branche est active à la fois. FIG. W3 — IF / ELSE, PAS À PASappuie et maintiensGPIO 27reading = 1DEL éteintebuzzer coupéloop() commencereading = digitalRead(27);1 = relâché0 = presséreading == LOW ?oui : pressé (0)digitalWrite(…, HIGH);DEL alluméebuzzer en marchenon : relâché (1)digitalWrite(…, LOW);DEL éteintebuzzer coupéSerial.println(reading);delay(50);↻ loop() recommence, plusieurs fois par seconde

Fais glisser le dessin sur le côté pour tout voir.

Organigramme de loop() avec if / else Organigramme. loop() commence, puis lit le bouton : reading reçoit digitalRead de la broche 27, 1 relâché, 0 pressé. Un losange demande : reading est-il égal à LOW ? Oui, pressé : digitalWrite HIGH, DEL allumée et buzzer en marche. Non, relâché : digitalWrite LOW, DEL éteinte et buzzer coupé. Une seule branche s'exécute à chaque fois. Les deux chemins se rejoignent, la valeur est affichée, une pause de 50 millisecondes suit, et une flèche revient au début : loop() recommence, plusieurs fois par seconde. FIG. 4 — ORGANIGRAMME DE LOOP()loop() commencereading = digitalRead(27);1 = relâché0 = presséreading == LOW ?oui : pressé (0)digitalWrite(…, HIGH);DEL alluméebuzzer en marchenon : relâché (1)digitalWrite(…, LOW);DEL éteintebuzzer coupéSerial.println(reading);delay(50);↻ loop() recommence, plusieurs fois par seconde
Touche le schéma pour l’ouvrir en plein écran.

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() contient INPUT_PULLUP et non INPUT [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 HIGH et LOW sur les deux lignes du buzzer.

Fais tes propres modifications

Change une seule chose, téléverse, observe.

  1. Inverse. Fais allumer la DEL quand le bouton n’est pas pressé. Quel test du if changes-tu ?
  2. Mode silencieux. Retire les deux lignes du buzzer dans la branche « pressé ». Que reste-t-il ?
  3. Des mots, pas des nombres. Remplace Serial.println(reading); par l’affichage de « pressed » ou « released », choisi avec le même if.

Vérifie-toi

Trois petites questions. Rien n’est enregistré, prends ton temps.

  1. 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é
    Voir la réponse

    HIGH (1). La résistance de rappel (pull-up) maintient la broche au niveau haut tant que le bouton est ouvert. Presser le bouton relie la broche à la masse, et la lecture tombe à LOW [2][4].

  2. 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
    Voir la réponse

    reading == LOW. Avec une résistance de rappel, « pressé » veut dire LOW [4]. Le test du programme utilise un double signe égal pour comparer deux valeurs [4].

  3. 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
  1. 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
  2. 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/
  3. 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
  4. 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/
  5. 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
  6. 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/
  7. 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
  8. 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
  9. 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
  10. 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
  11. 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/
  12. 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/
  13. 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

Pince ou touche deux fois pour zoomer, glisse pour changer de schéma.Molette avec Ctrl ou double-clic pour zoomer. Les flèches changent de schéma.