Dans ce guide de démarrage, vous apprendrez à lire des entrées numériques, comme un bouton-poussoir ou un interrupteur, et à commander des sorties numériques, comme une LED, à l’aide de l’ESP32 et de l’IDE Arduino.
.pdf%20-%20Foxit%20PDF%20Reader.png)
Prérequis
Nous allons programmer l’ESP32 à l’aide de l’IDE Arduino. Assurez-vous donc que le module complémentaire ESP32 est installé avant de poursuivre.
https://solutionmeca.blogspot.com/2026/10/installation-du-module-complementaire.html
Contrôler les sorties numériques de l’ESP32.
Tout d’abord, vous devez configurer la broche GPIO que vous souhaitez commander comme une sortie (OUTPUT). Pour cela, utilisez la fonction pinMode() de la manière suivante :
pinMode(GPIO, OUTPUT);Pour commander une sortie numérique, il suffit d’utiliser la fonction digitalWrite(). Cette fonction accepte deux arguments : le numéro de la broche GPIO concernée et son état, qui peut être HIGH (niveau haut) ou LOW (niveau bas).
digitalWrite(GPIO, STATE);Toutes les broches GPIO peuvent être utilisées comme sorties, à l’exception des broches suivantes :
GPIO 6 à GPIO 11 : elles sont généralement connectées à la mémoire Flash SPI intégrée.
GPIO 34, 35, 36 et 39 : elles peuvent être utilisées uniquement comme entrées sur les modèles ESP32 classiques concernés.
Exemple pratique : pour allumer une LED connectée à la broche GPIO 2, configurez cette broche en sortie, puis utilisez digitalWrite(2, HIGH). Pour éteindre la LED, utilisez digitalWrite(2, LOW).
Lire les entrées numériques de l’ESP32
Tout d’abord, configurez la broche GPIO que vous souhaitez lire en mode INPUT (entrée) à l’aide de la fonction pinMode(), comme suit :
pinMode(GPIO, INPUT);Pour lire une entrée numérique, comme un bouton-poussoir, utilisez la fonction digitalRead(). Cette fonction accepte comme argument le numéro de la broche GPIO que vous souhaitez lire.
digitalRead(GPIO);Toutes les broches GPIO de l’ESP32 peuvent être utilisées comme entrées, à l’exception des GPIO 6 à 11, qui sont connectées à la mémoire Flash SPI intégrée.
Exemple pratique : lire un bouton-poussoir.
const int bouton = 4;
void setup() {
Serial.begin(115200);
pinMode(bouton, INPUT);
}
void loop() {
int etatBouton = digitalRead(bouton);
Serial.println(etatBouton);
delay(200);
}Explication du code :
pinMode(bouton, INPUT);: configure le GPIO 4 comme une entrée.digitalRead(bouton);: lit l’état du bouton.Serial.println(etatBouton);: affiche le résultat dans le moniteur série.
Le résultat affiché est généralement :
0: état bas (LOW).1: état haut (HIGH).
Remarque : avec INPUT, prévoyez un câblage adapté pour éviter que l’entrée ne flotte. Vous pouvez aussi utiliser INPUT_PULLUP avec un bouton connecté entre le GPIO 4 et GND. Dans ce cas, le bouton relâché donne HIGH et le bouton appuyé donne LOW.
Exemple de projet
Pour vous montrer comment utiliser les entrées numériques et les sorties numériques, nous allons réaliser un projet simple avec un bouton-poussoir et une LED.
Nous allons lire l’état du bouton-poussoir et allumer la LED en conséquence, comme illustré dans la figure suivante.
.pdf%20-%20Foxit%20PDF%20Reader.png)
Matériel nécessaire
Voici la liste des composants nécessaires pour réaliser le circuit :
ESP32 DEVKIT V1
LED de 5 mm
Résistance de 220 ohms (Ω)
Bouton-poussoir
Résistance de 10 kΩ
Plaque d’expérimentation (breadboard)
Fils de connexion (jumpers)
Schéma de câblage
Avant de continuer, vous devez assembler un circuit comprenant une LED et un bouton-poussoir.
Nous allons connecter :
La LED au GPIO 5 de l’ESP32.
Le bouton-poussoir au GPIO 4 de l’ESP32.
.pdf%20-%20Foxit%20PDF%20Reader.png)
Code – Projet 1 : Entrées et sorties numériques de l’ESP32
Ouvrez le fichier Project_1_ESP32_Inputs_Outputs.ino dans l’IDE Arduino.
Le code ci-dessous est corrigé pour pouvoir être compilé et téléversé sur votre ESP32.
const int buttonPin = 4; // Numéro de la broche du bouton-poussoir
const int ledPin = 5; // Numéro de la broche de la LED
// Variable pour mémoriser l'état du bouton
int buttonState = 0;
void setup() {
Serial.begin(115200);
pinMode(buttonPin, INPUT); // Configurer le bouton en entrée
pinMode(ledPin, OUTPUT); // Configurer la LED en sortie
}
void loop() {
// Lire l'état du bouton-poussoir
buttonState = digitalRead(buttonPin);
// Afficher l'état du bouton dans le moniteur série
Serial.println(buttonState);
// Vérifier si le bouton est appuyé
if (buttonState == HIGH) {
digitalWrite(ledPin, HIGH); // Allumer la LED
} else {
digitalWrite(ledPin, LOW); // Éteindre la LED
}
}
Explication du programme
Instruction | Explication |
|---|---|
| Le bouton est connecté au GPIO 4. |
| La LED est connectée au GPIO 5. |
| Configure le bouton comme entrée. |
| Configure la LED comme sortie. |
| Lit l'état du bouton. |
| Allume la LED. |
| Éteint la LED. |
| Affiche |
Comment fonctionne le projet ?
Vous appuyez sur le bouton-poussoir.
L'ESP32 lit l'état du bouton sur le GPIO 4.
Si l'état est
HIGH, la LED connectée au GPIO 5 s'allume.Si l'état est
LOW, la LED s'éteint.
Attention au câblage : avec INPUT, la résistance de 10 kΩ doit maintenir l'entrée à un niveau stable. Pour un montage simple, vous pouvez connecter le bouton entre le GPIO 4 et GND et remplacer INPUT par INPUT_PULLUP. Dans cette configuration, il faudra inverser la condition du if, car un bouton appuyé donne LOW.
Téléverser le code sur l’ESP32
Avant de cliquer sur le bouton de téléversement, suivez les étapes suivantes dans l’IDE Arduino.
1. Sélectionner la carte : allez dans Outils (Tools) → Type de carte (Board), puis sélectionnez DOIT ESP32 DEVKIT V1.
2. Sélectionner le port : allez dans Outils (Tools) → Port, puis choisissez le port COM auquel votre ESP32 est connecté (par exemple, COM3 ou COM7).
3. Téléverser le programme : cliquez sur le bouton Téléverser (Upload) et attendez la fin du processus.
4. Vérifier le résultat : attendez l’apparition du message « Done uploading » (Téléversement terminé).
Votre programme est alors téléversé sur l’ESP32.
Remarque : si le téléversement échoue avec le message Failed to connect to ESP32, essayez de maintenir le bouton BOOT de la carte enfoncé pendant le démarrage du téléversement, puis relâchez le lorsque la connexion commence.
Remarque : résolution des problèmes (Troubleshooting)
Si vous voyez de nombreux points (connecting…__…__) dans la fenêtre de débogage et que le message suivant apparaît :
Failed to connect to ESP32: Timed out waiting for packet header
Cela signifie que l’IDE Arduino n’arrive pas à établir correctement la connexion avec l’ESP32 pour téléverser le programme.
Solution :
Cliquez sur le bouton Téléverser (Upload) dans l’IDE Arduino.
Attendez que les points de connexion (
Connecting...) commencent à apparaître.Appuyez sur le bouton BOOT situé sur la carte ESP32 et maintenez-le enfoncé.
Lorsque le téléversement commence, relâchez le bouton BOOT.
Attendez que le message « Done uploading » apparaisse.
Autres vérifications en cas d’échec
Vérifiez que la bonne carte est sélectionnée : DOIT ESP32 DEVKIT V1.
Vérifiez que le bon port COM est sélectionné.
Vérifiez que le câble USB permet le transfert de données, et pas seulement la recharge.
Fermez le Moniteur série si le port est déjà utilisé par un autre programme.
Conseil : cette manipulation avec le bouton BOOT est particulièrement utile sur certaines cartes ESP32 lorsque le mode de programmation ne s’active pas automatiquement.
.pdf%20-%20Foxit%20PDF%20Reader.png)
.pdf%20-%20Foxit%20PDF%20Reader.png)
.pdf%20-%20Foxit%20PDF%20Reader.png)
.pdf%20-%20Foxit%20PDF%20Reader.png)
.pdf%20-%20Foxit%20PDF%20Reader.png)
.pdf%20-%20Foxit%20PDF%20Reader.png)
.pdf%20-%20Foxit%20PDF%20Reader.png)
.pdf%20-%20Foxit%20PDF%20Reader.png)
.pdf%20-%20Foxit%20PDF%20Reader.png)
.pdf%20-%20Foxit%20PDF%20Reader.png)
%20-%20Foxit%20PD.png)
%20-%20Foxit%20PD.png)
%20-%20Foxit%20PD.png)
%20-%20Foxit%20PD.png)
.pdf%20-%20Foxit%20PDF%20Reader.png)
.pdf%20-%20Foxit%20PDF%20Reader.png)
.pdf%20-%20Foxit%20PDF%20Reader.png)