la fonction (map()) et des bibliothèques intégrées sur Arduino.

 découvrir et comprendre l'utilisation des servomoteurs, de la fonction de mise à l'échelle (map()) et des bibliothèques intégrées sur Arduino.

Les servomoteurs sont un type particulier de moteur qui ne tournent pas en cercle complet, mais se déplacent vers une position spécifique et y restent jusqu'à ce que vous leur demandiez de bouger à nouveau. Les servomoteurs ne pivotent généralement que de 180 degrés (la moitié d'un cercle). En combinant l'un de ces moteurs avec un petit bricolage en carton, vous pourrez faire savoir aux gens s'ils doivent venir vous demander de l'aide pour leur prochain projet ou non.

De la même manière que vous avez utilisé des impulsions pour appliquer une modulation PWM à une LED dans le projet de la lampe de mélange des couleurs, les servomoteurs s'attendent à recevoir un certain nombre d'impulsions qui leur indiquent l'angle à atteindre. Les impulsions arrivent toujours à des intervalles de temps réguliers, mais leur largeur varie entre 1 000 et 2 000 microsecondes. Bien qu'il soit possible d'écrire du code pour générer ces impulsions, le logiciel Arduino comprend une bibliothèque qui vous permet de contrôler facilement le moteur. Étant donné que le servomoteur ne tourne que de 180 degrés et que votre entrée analogique va de 0 à 1023, vous devrez utiliser une fonction appelée map() pour modifier l'échelle des valeurs provenant du potentiomètre.

L'un des grands avantages de la communauté Arduino réside dans les personnes talentueuses qui étendent ses fonctionnalités grâce à des logiciels supplémentaires. N'importe qui peut écrire des bibliothèques pour étendre les fonctionnalités d'Arduino. Il existe des bibliothèques pour une grande variété de capteurs, d'actionneurs et d'autres appareils que les utilisateurs ont partagés avec la communauté. Une bibliothèque logicielle étend les fonctionnalités d'un environnement de programmation. Le logiciel Arduino est fourni avec un certain nombre de bibliothèques utiles pour travailler avec du matériel ou des données. L'une des bibliothèques incluses est conçue spécifiquement pour être utilisée avec les servomoteurs. Dans votre code, vous importerez la bibliothèque, et toutes ses fonctionnalités seront à votre disposition.

 Schéma électrique de circuit:

1--Connectez le 5V et la masse (GND) de l'Arduino d'un côté de votre plaque d'essai (breadboard).

2--Placez un potentiomètre sur la plaque d'essai (breadboard), connectez un côté au 5V et l'autre à la masse (ground). Un potentiomètre est un type diviseur de tension. En tournant le bouton, vous modifiez le rapport de tension entre la broche du milieu et l'alimentation. Vous pouvez lire ce changement sur une entrée analogique. Connectez la broche du milieu à la broche analogique 0. Cela permettra de contrôler la position de votre servomoteur.

3--Le servomoteur possède trois fils. L'un est l'alimentation (rouge), un autre est la masse (ground, noir), et le troisième (blanc) est la ligne de commande qui recevra les informations de l'Arduino. Branchez trois broches mâles (headers) dans les extrémités femelles des fils du servomoteur (voir Fig. 3). Connectez ces broches à votre plaque d'essai (breadboard) de manière à ce que chaque broche soit sur une rangée différente. Connectez le 5V au fil rouge, la masse au fil noir et le fil blanc à la broche 9.

4--Lorsqu'un servomoteur commence à bouger, il consomme plus de courant que s'il était déjà en mouvement. Cela provoquera une baisse de tension sur votre carte. En plaçant un condensateur de 100 µF entre l'alimentation et la masse, juste à côté des broches mâles comme indiqué, vous pouvez lisser les variations de tension qui pourraient survenir. Vous pouvez également placer un condensateur entre l'alimentation et la masse alimentant votre potentiomètre. On les appelle des condensateurs de découplage parce qu'ils réduisent, ou découplent, les variations causées par les composants du reste du circuit. Veillez à bien connecter la cathode à la masse (c'est le côté avec une bande noire) et l'anode à l'alimentation. Si vous branchez les condensateurs à l'envers, ils risquent d'exploser.

comment fonction le code?

Pour utiliser la bibliothèque Servo, vous devez d'abord l'importer. Cela rend les fonctionnalités de la bibliothèque disponibles pour votre croquis (sketch). Pour faire référence au servomoteur, vous devez créer une instance nommée de la bibliothèque Servo dans une variable. C'est ce qu'on appelle un objet. De cette façon, vous créez un nom unique qui disposera de toutes les fonctions et capacités offertes par la bibliothèque Servo. À partir de ce moment dans le programme, chaque fois que vous ferez référence à myServo, vous vous adresserez à l'objet servomoteur.

Définissez une constante nommée pour la broche à laquelle le potentiomètre est connecté, ainsi que des variables pour stocker la valeur de l'entrée analogique et l'angle vers lequel vous souhaitez déplacer le servomoteur.

Dans la fonction setup(), vous devez indiquer à l'Arduino sur quelle broche votre servomoteur est branché. Ajoutez une connexion série pour pouvoir vérifier les valeurs provenant du potentiomètre et voir comment elles correspondent aux angles sur le servomoteur.

Dans la fonction loop(), lisez l'entrée analogique et affichez la valeur dans le moniteur série. Pour obtenir une valeur exploitable par le servomoteur à partir de votre entrée analogique, le plus simple est d'utiliser la fonction map(). Cette fonction pratique met à l'échelle les nombres pour vous. Dans ce cas, elle convertira des valeurs comprises entre 0 et 1023 en des valeurs comprises entre 0 et 179. Elle prend cinq arguments : le nombre à mettre à l'échelle (ici potVal), la valeur minimale de l'entrée (0), la valeur maximale de l'entrée (1023), la valeur minimale de la sortie (0) et la valeur maximale de la sortie (179). Stockez cette nouvelle valeur dans la variable angle.

Ensuite, affichez la valeur mise à l'échelle dans le moniteur série.

Enfin, il est temps de faire bouger le servomoteur. La commande servo.write() déplace le moteur à l'angle que vous spécifiez. À la fin de la boucle loop(), ajoutez un délai (delay) pour laisser au servomoteur le temps d'atteindre sa nouvelle position."

#include <Servo.h>

Servo myServo;

int const potPin = A0; 

int potVal; int angle;

void setup() {

myServo.attach(9);

Serial.begin(9600); 

}

void loop() {

potVal = analogRead(potPin);

Serial.print(“potVal: “);

Serial.print(potVal);

angle = map(potVal, 0, 1023, 0, 179); 

Serial.print(“, angle: “); 

Serial.println(angle);

myServo.write(angle); 

delay(15);

}

Une fois votre Arduino programmé et alimenté, ouvrez le moniteur série. Vous devriez voir un flux de valeurs similaire à celui-ci : potVal : 1023, angle : 179 potVal : 1023, angle : 179 Lorsque vous tournez le potentiomètre, les chiffres doivent changer. Plus important encore, vous devriez voir votre servomoteur se déplacer vers une nouvelle position. Observez la relation entre la valeur de potVal et de l'angle dans le moniteur série, ainsi que la position du servomoteur. Vous devriez obtenir des résultats constants en tournant le potentiomètre.

Un des avantages d'utiliser des potentiomètres comme entrées analogiques est qu'ils fournissent une plage complète de valeurs entre 0 et 1023. Cela les rend très utiles pour tester des projets qui utilisent une entrée analogique.

cours sur les résistances variable:https://solutionmeca.blogspot.com/2025/12/les-resistances-variables.html

conclusion.

En réalisant ce montage, vous avez appris à combiner plusieurs concepts fondamentaux de l'électronique et de la programmation Arduino :

• Lecture analogique et conversion : Vous avez capturé un signal analogique issu d'un potentiomètre (valeurs de 0 à 1023) et utilisé la fonction map() pour le convertir en un angle précis (de 0° à 180°).

• Utilisation des bibliothèques (Servo.h) : L'importation d'une bibliothèque simplifie grandement l'envoi de signaux de commande au servomoteur via la méthode servo.write().

• Gestion de l'alimentation et sécurité : L'ajout de condensateurs de découplage de $100\,\mu\text{F}$ permet de stabiliser la tension et de protéger le circuit contre les chocs de courant provoqués par le moteur au démarrage.

En maîtrisant cette chaîne (Capteur \rightarrow Traitement/Mapping \rightarrow  Actionneur), vous disposez désormais des bases nécessaires pour concevoir des systèmes interactifs plus avancés, comme des bras robotiques ou des systèmes de commande à distance.

Entrées et Sorties Numériques (Digital Input & Output).

 Maintenant que vous maîtrisez les bases de l'électricité, il est temps de passer au contrôle de composants avec votre Arduino. Dans ce projet, vous allez construire quelque chose qui aurait pu être l'interface d'un vaisseau spatial dans un film de science-fiction des années 1970. Vous fabriquerez un panneau de commande sympathique doté d'un interrupteur et de voyants qui s'allument lorsque vous l'actionnez. Vous pouvez décider si les voyants signifient « Activer l'hyperpropulsion » ou « Feu sur les lasers ! ». Une LED verte restera allumée jusqu'à ce que vous appuyiez sur un bouton. Lorsque l'Arduino reçoit un signal provenant du bouton, la lumière verte s'éteint et deux autres voyants se mettent à clignoter.

Les broches numériques de l'Arduino ne peuvent lire que deux états : lorsqu'il y a de la tension sur une broche d'entrée, et lorsqu'il n'y en a pas. Ce type d'entrée est généralement appelé numérique (ou parfois binaire, pour deux états). Ces états sont communément désignés par les termes HIGH et LOW. HIGH revient à dire « il y a de la tension ici ! » et LOW signifie « il n'y a pas de tension sur cette broche ! ». Lorsque vous mettez une broche de SORTIE (OUTPUT) à l'état HIGH à l'aide d'une commande appelée digitalWrite(), vous l'activez. Si vous mesurez la tension entre la broche et la masse, vous obtiendrez 5 volts. Lorsque vous mettez une broche de SORTIE à l'état LOW, vous la désactivez.

Les broches numériques de l'Arduino peuvent agir à la fois comme des entrées et des sorties. Dans votre code, vous les configurerez en fonction de ce que vous souhaitez qu'elles fassent. Lorsque les broches sont des sorties, vous pouvez piloter des composants tels que des LED. Si vous configurez les broches comme des entrées, vous pouvez vérifier si un interrupteur est enfoncé ou non. Étant donné que les broches 0 et 1 sont utilisées pour communiquer avec l'ordinateur, il est préférable de commencer à partir de la broche 2.

1-Connectez votre plaque d'essai aux connexions 5V et de masse de l'Arduino, tout comme dans le projet précédent. Placez les deux LED rouges et une LED verte sur la plaque d'essai. Raccordez la cathode (patte courte) de chaque LED à la masse par l'intermédiaire d'une résistance de 220 ohms. Connectez l'anode (patte longue) de la LED verte à la broche 3. Connectez les anodes des LED rouges respectivement aux broches 4 et 5.

2-Placez l'interrupteur sur la plaque d'essai tout comme vous l'avez fait dans le projet précédent. Connectez un côté à l'alimentation et l'autre côté à la broche numérique 2 de l'Arduino. Vous devrez également ajouter une résistance de 10 kilo-ohms allant de la masse à la broche de l'interrupteur qui se connecte à l'Arduino. Cette résistance de tirage (pull-down) connecte la broche à la masse lorsque l'interrupteur est ouvert, de sorte qu'elle indique LOW lorsqu'aucune tension ne provient de l'interrupteur.

Quelles sont vos notes ou instructions avant que l'on ne commence ?

Chaque programme Arduino comporte deux fonctions principales. Les fonctions sont des parties d'un programme informatique qui exécutent des commandes spécifiques. Les fonctions ont des noms uniques et sont « appelées » en cas besoin. Les fonctions nécessaires dans un programme Arduino s'appellent setup() et loop(). Ces fonctions doivent être déclarées, ce qui signifie que vous devez dire à l'Arduino ce que ces fonctions vont faire. setup() et loop() sont déclarées comme vous le voyez à droite.

Dans ce programme, vous allez créer une variable avant d'entrer dans la partie principale du programme. Les variables sont des noms que vous donnez à des emplacements dans la mémoire de l'Arduino afin de pouvoir suivre ce qui se passe. Ces valeurs peuvent changer en fonction des instructions de votre programme. Les noms de variables doivent décrire la valeur qu'ils stockent. Par exemple, une variable nommée switchState indique ce qu'elle stocke : l'état d'un interrupteur. En revanche, une variable nommée « x » ne vous dit pas grand-chose sur ce qu'elle stocke.

Pour créer une variable, vous devez déclarer de quel type elle est. Le type de données int contiendra un nombre entier (également appelé entier) ; c'est-à-dire n'importe quel nombre sans point décimal. Lorsque vous déclarez une variable, vous lui donnez généralement aussi une valeur initiale. La déclaration de la variable, comme chaque instruction, doit se terminer par un point-virgule (;).

La fonction setup() s'exécute une seule fois, lorsque l'Arduino est mis sous tension pour la première fois. C'est ici que vous configurez les broches numériques pour qu'elles soient soit des entrées, soit des sorties à l'aide d'une fonction nommée pinMode(). Les broches connectées aux LED seront des sorties (OUTPUT) et la broche de l'interrupteur sera une entrée (INPUT).

La fonction loop() s'exécute en continu après la fin de setup(). C'est dans loop() que vous vérifiez la présence de tension sur les entrées et que vous activez ou désactivez les sorties. Pour vérifier le niveau de tension sur une entrée numérique, vous utilisez la fonction digitalRead() qui vérifie la présence de tension sur la broche choisie. Pour savoir quelle broche vérifier, digitalRead() attend un argument.

Les arguments sont des informations que vous transmettez aux fonctions, leur indiquant comment faire leur travail. Par exemple, digitalRead() a besoin d'un seul argument : quelle broche vérifier. Dans votre programme, digitalRead() va vérifier l'état de

void setup(){

}

void loop(){

}

int switchState = 0;

void setup(){

pinMode(3,OUTPUT);

pinMode(4,OUTPUT);

pinMode(5,OUTPUT);

pinMode(2,INPUT);

}

void loop(){

switchState = digitaRead(2);

la broche 2 et stocke la valeur dans la variable switchState. S'il y a de la tension sur la broche lorsque digitalRead() est appelé, la variable switchState prend la valeur HIGH (ou 1). S'il n'y a pas de tension sur la broche, switchState prend la valeur LOW (ou 0).

Plus haut, vous avez utilisé le mot if pour vérifier l'état de quelque chose (à savoir, la position de l'interrupteur). Une instruction if() en programmation compare deux éléments et détermine si la comparaison est vraie ou fausse. Ensuite, elle exécute les actions que vous lui demandez. Lorsque vous comparez deux éléments en programmation, vous utilisez deux signes Égal ==. Si vous utilisez un seul signe, vous attribuerez (définirez) une valeur au lieu de la comparer.

digitalWrite() est la commande qui vous permet d'envoyer 5V ou 0V à une broche de sortie. digitalWrite() prend deux arguments : quelle broche contrôler, et quelle valeur définir pour cette broche (HIGH ou LOW). Si vous souhaitez allumer les LED rouges et éteindre la LED verte à l'intérieur de votre instruction if(), votre code ressemblera à ceci.

Vous avez indiqué à l'Arduino quoi faire lorsque l'interrupteur est ouvert. Définissez maintenant ce qui se passe lorsque l'interrupteur est fermé. L'instruction if() possède un composant optionnel else (sinon) qui permet de réaliser une action si la condition initiale n'est pas remplie. Dans ce cas, puisque vous avez vérifié si l'interrupteur était à l'état LOW, écrivez le code pour la condition HIGH après l'instruction else.

Pour faire clignoter les LED rouges lorsque le bouton est enfoncé, vous devrez éteindre et rallumer les voyants dans l'instruction else que vous venez d'écrire. Pour ce faire, modifiez le code afin qu'il ressemble à ceci.

Après avoir réglé les LED sur un certain état, vous voudrez que l'Arduino fasse une pause d'un instant avant de les modifier à nouveau. Si vous n'attendez pas, les voyants alterneront si rapidement qu'ils auront l'air simplement un peu tamisés, et non pas allumés et éteints. Cela s'explique par le fait que l'Arduino exécute sa boucle loop() des milliers de fois par seconde, et que la LED sera allumée et éteinte plus rapidement que notre perception ne peut le saisir.

La fonction delay() vous permet d'empêcher l'Arduino d'exécuter quoi que ce soit pendant une période donnée. delay() prend un argument qui détermine le nombre de millisecondes avant d'exécuter la série d'instructions suivante. Il y a 1 000 millisecondes dans une seconde. delay(250) fera une pause d'un quart de seconde.

if (switchState == LOW) {

// the button is not pressed

digitalWrite(3, HIGH); // green LED

digitalWrite(4, LOW); digitalWrite(5, LOW);

// red LED// red LED

}

else { // the button is pressed digitalWrite(3, LOW); digitalWrite(4, LOW); digitalWrite(5, HIGH);

delay(250); // wait for a quarter second

// toggle the LEDs

digitalWrite(4, HIGH); digitalWrite(5, LOW);

delay(250); // wait for a quarter second

}

} // go back to the beginning of the loop

Projet 1 : Entrées et sorties de l’ESP32 (Inputs/Outputs).

  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.

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.

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.

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
buttonPin = 4	Le bouton est connecté au GPIO 4.
ledPin = 5	La LED est connectée au GPIO 5.
pinMode(buttonPin, INPUT)	Configure le bouton comme entrée.
pinMode(ledPin, OUTPUT)	Configure la LED comme sortie.
digitalRead(buttonPin)	Lit l'état du bouton.
digitalWrite(ledPin, HIGH)	Allume la LED.
digitalWrite(ledPin, LOW)	Éteint la LED.
Serial.println(buttonState)	Affiche 0 ou 1 dans le moniteur série.

Comment fonctionne le projet ?

1. Vous appuyez sur le bouton-poussoir.

2. L'ESP32 lit l'état du bouton sur le GPIO 4.

3. Si l'état est HIGH, la LED connectée au GPIO 5 s'allume.

4. 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 :

1. Cliquez sur le bouton Téléverser (Upload) dans l’IDE Arduino.

2. Attendez que les points de connexion (Connecting...) commencent à apparaître.

3. Appuyez sur le bouton BOOT situé sur la carte ESP32 et maintenez-le enfoncé.

4. Lorsque le téléversement commence, relâchez le bouton BOOT.

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

Installation du module complémentaire ESP32 dans l’IDE Arduino.

 

Pour installer la carte ESP32 dans l’IDE Arduino, suivez les instructions suivantes :

1. Dans l’IDE Arduino, allez dans Fichier → Préférences (File → Preferences).

2. Saisissez l’adresse suivante dans le champ « URL supplémentaires de gestionnaire de cartes » (Additional Board Manager URLs) :

https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json

 Ensuite, cliquez sur le bouton « OK » pour valider.

Remarque : si vous avez déjà ajouté l’URL des cartes ESP8266, vous pouvez séparer les deux adresses par une virgule, comme indiqué ci-dessous :

https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json,

http://arduino.esp8266.com/stable/package_esp8266com_index.json

 3. Ouvrez le Gestionnaire de cartes.

Dans l’IDE Arduino, allez dans Outils → Type de carte → Gestionnaire de cartes… (Tools → Board → Boards Manager…).

4. Recherchez ESP32 et cliquez sur le bouton « Installer » en face de « ESP32 by Espressif Systems » (ESP32 par Espressif Systems)

Téléverser le code de test.

Branchez la carte ESP32 à votre ordinateur. Une fois l’IDE Arduino ouvert, suivez les étapes suivantes.

1. Sélectionnez votre carte dans le menu Outils → Type de carte.

Dans mon cas, il s’agit de la carte DOIT ESP32 DEVKIT V1.

2. Sélectionnez le port de communication (Port COM).

Si le port COM n’apparaît pas dans l’IDE Arduino, vous devez installer les pilotes CP210x USB vers UART (VCP).

Ces pilotes permettent à votre ordinateur de communiquer avec la carte ESP32 via le câble USB.

3. Ouvrez l’exemple suivant :

Dans l’IDE Arduino, allez dans Fichier → Exemples → WiFi (ESP32) → WiFiScan.

Ce programme permet à votre carte ESP32 de rechercher les réseaux Wi-Fi disponibles à proximité.

Un nouveau sketch (programme) s’ouvre dans votre IDE Arduino.

5. Cliquez sur le bouton Téléverser (Upload) dans l’IDE Arduino. Attendez quelques secondes pendant que le code est compilé et transféré vers votre carte ESP32.

6. Si tout se déroule correctement, le message « Done uploading » (Téléversement terminé) s’affichera.

7. Ouvrez le Moniteur série de l’IDE Arduino et réglez la vitesse de transmission sur 115200 bauds.

8. Appuyez sur le bouton EN (Enable) situé sur la carte ESP32. Vous devriez alors voir apparaître dans le Moniteur série la liste des réseaux Wi-Fi disponibles à proximité de votre ESP32.

Dépannage (résolution des problèmes)

Si vous essayez de téléverser un nouveau programme sur votre ESP32 et que le message d’erreur suivant apparaît :

« A fatal error occurred: Failed to connect to ESP32: Timed out… Connecting… »

Cela signifie que votre ESP32 n’est pas en mode de programmation (téléversement).

Après avoir sélectionné le bon modèle de carte et le bon port COM, suivez les étapes suivantes :

- Maintenez le bouton « BOOT » enfoncé sur votre carte ESP32

- Cliquez sur le bouton « Téléverser » (Upload) dans l’IDE Arduino pour transférer votre programme vers la carte ESP32.

- Lorsque le message « Connecting… » (Connexion en cours…) apparaît dans l’IDE Arduino, relâchez le bouton « BOOT ».

- Après cela, le message « Done uploading » (Téléversement terminé) devrait apparaître.

C’est terminé ! Votre ESP32 devrait maintenant exécuter le nouveau programme téléversé.

Appuyez sur le bouton « ENABLE » de votre carte ESP32 pour la redémarrer et lancer le nouveau programme.

Vous devrez également répéter cette séquence de boutons chaque fois que vous souhaiterez téléverser un nouveau programme.

Synchronisation de l’état des sorties avec un serveur web.

 Ce projet montre comment contrôler les sorties d’un ESP32 ou ESP8266 à l’aide d’un serveur web et d’un bouton physique, simultanément.

L’état de la sortie est mis à jour sur la page web, qu’il soit modifié à l’aide du bouton physique ou directement depuis le serveur web

Présentation du projet

-L’ESP32 ou l’ESP8266 héberge un serveur web qui vous permet de contrôler l’état d’une sortie (par exemple, allumer ou éteindre une LED)

- L’état actuel de la sortie est affiché sur la page du serveur web.

- L’ESP32 ou l’ESP8266 est également connecté à un bouton-poussoir physique qui permet de contrôler cette même sortie.

- Si vous modifiez l’état de la sortie à l’aide du bouton-poussoir physique, son état actuel est également mis à jour sur la page du serveur web.

En résumé : ce projet permet de contrôler une même sortie simultanément à l’aide d’un serveur web et d’un bouton-poussoir physique. Chaque fois que l’état de la sortie change, la page web est mise à jour afin d’afficher son nouvel état.

Matériel nécessaire

Voici la liste des composants nécessaires pour réaliser le circuit :

• Carte ESP32 DEVKIT V1

• LED de 5 mm

• Résistance de 220 Ω

• Bouton-poussoir

• Résistance de 10 kΩ

• Plaque d’essai (breadboard)

• Fils de connexion (jumpers)

Le schéma électrique du projet.

Installation des bibliothèques pour ESP32.

Pour réaliser ce serveur web, nous utilisons deux bibliothèques : ESPAsyncWebServer et AsyncTCP. Si vous avez déjà installé ces bibliothèques, vous pouvez passer à l’étape suivante.

1. Installer la bibliothèque ESPAsyncWebServer.

Suivez les étapes suivantes pour installer la bibliothèque ESPAsyncWebServer :

1. Cliquez sur le lien de téléchargement de la bibliothèque ESPAsyncWebServer. Vous obtiendrez un fichier compressé au format .zip dans votre dossier Téléchargements.

2. Décompressez le fichier ZIP. Vous obtiendrez un dossier nommé ESPAsyncWebServer-master.

3. Renommez ce dossier en ESPAsyncWebServer.

4. Déplacez le dossier dans le répertoire des bibliothèques de votre installation Arduino IDE.

Autre méthode : dans Arduino IDE, accédez au menu Croquis (Sketch) → Inclure une bibliothèque (Include Library) → Ajouter la bibliothèque .ZIP (Add .ZIP Library…), puis sélectionnez le fichier ZIP que vous avez téléchargé.

2. Installer la bibliothèque AsyncTCP pour ESP32.

La bibliothèque ESPAsyncWebServer nécessite également la bibliothèque AsyncTCP pour fonctionner avec l’ESP32.

Suivez les étapes suivantes :

1. Cliquez sur le lien de téléchargement de la bibliothèque AsyncTCP. Vous obtiendrez un fichier compressé au format .zip dans votre dossier Téléchargements.

2. Décompressez le fichier ZIP. Vous obtiendrez un dossier nommé AsyncTCP-master.

3. Renommez ce dossier en AsyncTCP.

4. Déplacez le dossier AsyncTCP dans le répertoire des bibliothèques de votre installation Arduino IDE.

5. Enfin, redémarrez Arduino IDE pour que les bibliothèques soient correctement prises en compte.

Autre méthode : dans Arduino IDE, accédez au menu Croquis → Inclure une bibliothèque → Ajouter la bibliothèque .ZIP, puis sélectionnez le fichier ZIP de la bibliothèque AsyncTCP.

Remarque : ces instructions concernent l’ESP32. Pour une carte ESP8266, la bibliothèque réseau correspondante est généralement ESPAsyncTCP, et non AsyncTCP.

CODE.

Nous allons programmer l’ESP32 à l’aide de l’Arduino IDE. Assurez-vous donc que le module complémentaire ESP32 est installé avant de poursuivre. Si vous avez déjà effectué cette étape, vous pouvez passer à la suivante.

Installation du module ESP32 dans Arduino IDE

Après avoir installé les bibliothèques nécessaires, ouvrez le fichier 

Avant de téléverser le code sur votre carte ESP32, n’oubliez pas de renseigner vos identifiants Wi-Fi (nom du réseau et mot de passe) afin que l’ESP32 puisse se connecter à votre réseau local.

Fonctionnement du code

Le programme permet de contrôler une LED connectée à l’ESP32 à l’aide d’un serveur web et d’un bouton-poussoir physique. Les deux commandes agissent sur la même LED et son état est actualisé sur la page web.

La variable ledState mémorise l’état de la sortie de la LED. Par défaut, au démarrage du serveur web, sa valeur est LOW, ce qui signifie que la LED est éteinte.

Les variables buttonState et lastButtonState sont utilisées pour détecter si le bouton-poussoir a été appuyé ou non. Elles permettent de suivre l’état du bouton et de détecter un changement d’état afin de contrôler la LED.

Bouton de commande (serveur web)

Nous n’avons pas inclus le code HTML permettant de créer le bouton dans la variable index_html.

Cela s’explique par le fait que nous voulons pouvoir modifier ce bouton en fonction de l’état actuel de la LED, qui peut également être modifié à l’aide du bouton-poussoir.

Nous avons donc créé un espace réservé appelé %BUTTONPLACEHOLDER%. Celui-ci sera remplacé plus tard dans le code par du texte HTML permettant de créer le bouton. Cette opération est réalisée dans la fonction processor().




La fonction processor() remplace les espaces réservés présents dans le code HTML par leurs valeurs réelles.

Tout d’abord, elle vérifie si le texte HTML contient un espace réservé appelé %BUTTONPLACEHOLDER%.




if (var == "BUTTONPLACEHOLDER") {

Ensuite, nous appelons la fonction outputState(), qui renvoie l’état actuel de la sortie. Nous enregistrons cette valeur dans la variable outputStateValue.

String outputStateValue = outputState();

Après cela, nous utilisons cette valeur pour créer le code HTML permettant d’afficher le bouton avec l’état approprié :

buttons += "<h4>Sortie - GPIO 2 - État <span id=\"outputState\"></span></h4>"
           "<label class=\"switch\"><input type=\"checkbox\" onchange=\"toggleCheckbox(this)\" id=\"output\" "
           + outputStateValue + "><span class=\"slider\"></span></label>";

Requête HTTP GET pour modifier l’état de la sortie (JavaScript)

Lorsque vous appuyez sur le bouton, la fonction toggleCheckbox() est appelée. Cette fonction envoie une requête vers différentes URL afin d’allumer ou d’éteindre la LED.

function toggleCheckbox(element) {
  var xhr = new XMLHttpRequest();

  if (element.checked) {
    xhr.open("GET", "/update?state=1", true);
  } else {
    xhr.open("GET", "/update?state=0", true);
  }

  xhr.send();
}

Pour allumer la LED, une requête est envoyée à l’URL /update?state=1 :

if (element.checked) {
  xhr.open("GET", "/update?state=1", true);
}

Sinon, une requête est envoyée à l’URL /update?state=0 pour éteindre la LED.

Requête HTTP GET pour mettre à jour l’état (JavaScript)

Pour maintenir à jour l’état de la sortie sur le serveur Web, nous appelons la fonction suivante. Elle envoie une nouvelle requête à l’URL /state toutes les secondes.

setInterval(function () {
  var xhttp = new XMLHttpRequest();

  xhttp.onreadystatechange = function () {
    if (this.readyState == 4 && this.status == 200) {
      var inputChecked;
      var outputStateM;

      if (this.responseText == 1) {
        inputChecked = true;
        outputStateM = "Allumée";
      } else {
        inputChecked = false;
        outputStateM = "Éteinte";
      }

      document.getElementById("output").checked = inputChecked;
      document.getElementById("outputState").innerHTML = outputStateM;
    }
  };

  xhttp.open("GET", "/state", true);
  xhttp.send();
}, 1000);

Gestion des requêtes

Ensuite, nous devons définir ce qui se passe lorsque l’ESP32 ou l’ESP8266 reçoit des requêtes sur ces URL.

Lorsqu’une requête est reçue à l’adresse principale /, nous envoyons la page HTML ainsi que la fonction processor.

server.on("/", HTTP_GET, [](AsyncWebServerRequest *request) {
  request->send_P(200, "text/html", index_html, processor);
});

Les lignes suivantes vérifient si une requête a été reçue à l’adresse /update?state=1 ou /update?state=0, puis modifient la variable ledState en conséquence.

server.on("/update", HTTP_GET, [](AsyncWebServerRequest *request) {
  String inputMessage;
  String inputParam;

  // Récupérer la valeur du paramètre input1
  // depuis <ESP_IP>/update?state=<inputMessage>

  if (request->hasParam(PARAM_INPUT_1)) {
    inputMessage = request->getParam(PARAM_INPUT_1)->value();
    inputParam = PARAM_INPUT_1;

    digitalWrite(output, inputMessage.toInt());
    ledState = !ledState;
  } else {
    inputMessage = "Aucun message envoyé";
    inputParam = "none";
  }

  Serial.println(inputMessage);
  request->send(200, "text/plain", "OK");
});

Lorsqu’une requête est reçue à l’adresse /state, nous envoyons l’état actuel de la sortie :

server.on("/state", HTTP_GET, [](AsyncWebServerRequest *request) {
  request->send(200, "text/plain",
                String(digitalRead(output)).c_str());
});

Fonction loop()

Dans la fonction loop(), nous éliminons les rebonds du bouton-poussoir (debouncing) et allumons ou éteignons la LED en fonction de la valeur de la variable ledState.

digitalWrite(output, ledState);