ESP32 servomoteur Wi-Fi : piloter un servo depuis ton téléphone
Piloter un servomoteur en Wi-Fi avec l'ESP32 : bibliothèque ESP32Servo, curseur web avec fetch, choix de broche, alimentation et masse commune, pan-tilt.
Le plus amusant avec un servomoteur, l'ESP32 et le Wi-Fi, c'est de faire tourner le servo en temps réel avec un curseur (slider) sur ton téléphone : tu glisses le doigt et le servo suit, sans installer la moindre application. Dans ce guide, on transforme l'ESP32 en serveur web, on envoie la valeur du curseur de la page ouverte dans le navigateur à l'ESP32 avec la commande JavaScript fetch, et on amène le servo à cet angle avec la bibliothèque ESP32Servo.
En plus du code, on détaille la partie matérielle, car la plupart des projets de servo en Wi-Fi échouent à cause de l'alimentation et non du logiciel : le servo tremble, l'ESP32 redémarre ou la connexion saute. Tu verras pas à pas quelle broche choisir, comment alimenter le servo, pourquoi une masse commune est indispensable, comment éviter les tremblements et, pour finir, comment monter un système pan-tilt à deux servos.

Comment ça marche : du curseur au servo
- Le navigateur du téléphone ouvre l'adresse IP de l'ESP32, qui renvoie une petite page HTML contenant un curseur.
- Quand tu bouges le curseur, le JavaScript de la page envoie l'angle avec fetch à une adresse comme /set?angle=120 ; la page ne se recharge pas.
- Le serveur web de l'ESP32 reçoit la requête, lit l'angle et le limite à la plage 0–180.
- La bibliothèque ESP32Servo convertit l'angle en largeur d'impulsion : environ 500 µs pour 0 degré et 2400 µs pour 180 degrés, envoyées 50 fois par seconde.
- La carte de commande à l'intérieur du servo lit l'impulsion, amène le moteur à cet angle et l'y maintient.
On a expliqué le fonctionnement d'un servo et le lien entre largeur d'impulsion et angle dans Qu'est-ce qu'un servomoteur ? Ce qu'il faut retenir ici : la bibliothèque Servo standard d'Arduino ne fonctionne pas sur l'ESP32, car celui-ci génère le PWM avec un autre matériel (LEDC). On utilise donc la bibliothèque ESP32Servo, qui propose les mêmes commandes attach() et write() et fonctionne avec les cores ESP32 2.x et 3.x.
Le matériel nécessaire
- Une carte de développement ESP32 (DevKit, NodeMCU-32S ou équivalent)
- Un servo SG90 ou MG90S (deux servos et un support pan-tilt pour la version pan-tilt)
- Une alimentation externe 5 V : un adaptateur d'au moins 2 A ou un boîtier pour 4 piles AA
- Un condensateur électrolytique de 470 à 1000 µF (au moins 10 V)
- Une plaque d'essai et des fils de connexion
- Le paquet de cartes ESP32 installé dans l'IDE Arduino et la bibliothèque ESP32Servo installée depuis le gestionnaire de bibliothèques
Choix de la broche : sur quel GPIO brancher le servo ?
Presque toutes les broches de sortie de l'ESP32 peuvent produire du PWM, mais elles ne se valent pas toutes pour un servo. Certaines émettent de brefs signaux au démarrage et font sursauter le servo à chaque mise sous tension ; d'autres ne sont que des entrées. Tu trouves le brochage complet de ta carte dans l'outil Pinout :
| Broches | Pour un servo | Pourquoi |
|---|---|---|
| GPIO 13, 25, 26, 27, 32, 33 | Recommandées | Silencieuses au démarrage, chacune peut produire du PWM (LEDC) |
| GPIO 4, 16, 17, 18, 19, 21, 22, 23 | Convenables | Broches d'usage général sûres ; garde-les libres si tu utilises l'I2C (21, 22) ou le SPI (18, 19, 23) |
| GPIO 2, 5, 12, 14, 15 | À éviter | Broches de démarrage (strapping) ou PWM au démarrage ; le servo peut sursauter ou la carte ne pas démarrer |
| GPIO 34–39 | Inutilisables | Entrées seules, impossible d'y produire du PWM |
| GPIO 6–11 | Inutilisables | Reliées à la mémoire flash interne |
| GPIO 1 et 3 | Inutilisables | Ligne série de l'USB (TX, RX) |
Alimentation du servo et masse commune
Au repos, un SG90 consomme environ 10 mA, mais dès qu'il démarre ou maintient une charge, le courant grimpe à 500–700 mA. L'ESP32, lui, tire des pointes d'environ 250 mA quand il émet en Wi-Fi. Si tu alimentes les deux par la même ligne USB trop faible, la tension s'effondre et l'ESP32 redémarre avec le message "Brownout detector was triggered". La solution : alimenter le servo avec une source 5 V séparée et relier les masses des deux circuits :
| Fil du servo | Branchement | Remarque |
|---|---|---|
| Marron ou noir (GND) | Borne négative de l'alimentation externe et broche GND de l'ESP32 | La masse commune est obligatoire : c'est la référence du signal |
| Rouge (V+) | Alimentation externe 5 V (4,8–6 V) | Jamais sur la broche 3V3 de l'ESP32 |
| Orange ou jaune (signal) | GPIO 13 | Un signal de 3,3 V suffit pour le SG90 et le MG90S |
| Montage | Alimentation conseillée | Remarque |
|---|---|---|
| 1 SG90, essai à vide | Broche 5V (VIN) de la carte ESP32, via l'USB | Pour de courts essais seulement ; des brownouts sont possibles avec le Wi-Fi |
| 2 SG90 (pan-tilt) | Adaptateur 5 V d'au moins 2 A | Ajoute un condensateur de 470 à 1000 µF sur l'alimentation |
| 1 ou 2 MG996R | 5–6 V, au moins 3 A | Le courant de blocage peut atteindre 2,5 A par servo |
| Projet portable | 4 piles AA (alcalines, 6 V) | Des accus NiMH donnent 4,8 V, ce qui suffit aussi |
Étape 1 : premier essai avec ESP32Servo
Avant de passer au Wi-Fi, vérifie que le servo et son alimentation fonctionnent correctement. Cherche ESP32Servo dans le gestionnaire de bibliothèques, installe celle de Kevin Harrington et John K. Bennett, puis téléverse le croquis ci-dessous. Le servo doit aller et venir lentement entre 0 et 180 degrés ; sinon, le problème vient du câblage ou de l'alimentation, pas du logiciel.
1#include <ESP32Servo.h>
2
3const int SERVO_PIN = 13; // açılışta sessiz, güvenli pin / quiet at boot, safe pin
4Servo servo;
5
6void setup() {
7 servo.setPeriodHertz(50); // standart servo 50 Hz / standard servo, 50 Hz
8 servo.attach(SERVO_PIN, 500, 2400); // 0° = 500 µs, 180° = 2400 µs (SG90)
9}
10
11void loop() {
12 for (int a = 0; a <= 180; a += 2) { // 0 → 180°
13 servo.write(a);
14 delay(15);
15 }
16 for (int a = 180; a >= 0; a -= 2) { // 180 → 0°
17 servo.write(a);
18 delay(15);
19 }
20}Étape 2 : piloter le servo avec un curseur sur la page web
Passons au projet principal. Le croquis ci-dessous connecte l'ESP32 à ton réseau domestique, sert une page avec un curseur et écrit dans le servo l'angle reçu à l'adresse /set. La page HTML se trouve dans le code sous forme de texte brut (raw string), tu n'as donc aucun fichier séparé à téléverser. Indique le nom et le mot de passe de ton Wi-Fi, téléverse le croquis, puis ouvre dans le navigateur de ton téléphone l'adresse IP affichée dans le moniteur série.
1#include <WiFi.h>
2#include <WebServer.h>
3#include <ESP32Servo.h>
4
5const char* WIFI_SSID = "AgAdi"; // Wi-Fi adın / your Wi-Fi name
6const char* WIFI_PASS = "Sifre123"; // Wi-Fi şifren / your Wi-Fi password
7const int SERVO_PIN = 13;
8
9WebServer server(80);
10Servo servo;
11int currentAngle = 90; // açılışta ortada / centred at start
12
13// Telefonda açılan sayfa / page opened on the phone
14const char PAGE[] PROGMEM = R"rawliteral(
15<!DOCTYPE html><html><head><meta charset="utf-8">
16<meta name="viewport" content="width=device-width,initial-scale=1">
17<title>ESP32 Servo</title>
18<style>
19body{font-family:sans-serif;text-align:center;margin-top:40px}
20input{width:85%;height:40px}
21#v{font-size:56px;font-weight:bold}
22</style></head><body>
23<h2>ESP32 Servo</h2>
24<p><span id="v">%ANGLE%</span>°</p>
25<input type="range" id="s" min="0" max="180" value="%ANGLE%">
26<script>
27const s = document.getElementById('s');
28const v = document.getElementById('v');
29let last = 0, timer = null;
30function send() {
31 fetch('/set?angle=' + s.value); // açıyı gönder / send the angle
32 last = Date.now();
33}
34s.addEventListener('input', () => {
35 v.textContent = s.value;
36 clearTimeout(timer);
37 if (Date.now() - last > 100) send(); // en fazla 10 istek/sn / at most 10 requests/s
38 else timer = setTimeout(send, 100); // son değer mutlaka gider / the last value always goes out
39});
40</script></body></html>
41)rawliteral";
42
43void handleRoot() {
44 String html = PAGE;
45 html.replace("%ANGLE%", String(currentAngle)); // slider doğru yerde başlar / slider starts at the right spot
46 server.send(200, "text/html", html);
47}
48
49void handleSet() {
50 if (!server.hasArg("angle")) {
51 server.send(400, "text/plain", "angle?");
52 return;
53 }
54 int angle = constrain(server.arg("angle").toInt(), 0, 180); // güvenli aralık / safe range
55 if (angle != currentAngle) { // aynı açıyı tekrar yazma / don't rewrite the same angle
56 servo.write(angle);
57 currentAngle = angle;
58 }
59 server.send(200, "text/plain", String(currentAngle));
60}
61
62void setup() {
63 Serial.begin(115200);
64 servo.setPeriodHertz(50);
65 servo.attach(SERVO_PIN, 500, 2400);
66 servo.write(currentAngle);
67
68 WiFi.mode(WIFI_STA);
69 WiFi.begin(WIFI_SSID, WIFI_PASS);
70 while (WiFi.status() != WL_CONNECTED) { // bağlanana kadar bekle / wait until connected
71 delay(500);
72 Serial.print(".");
73 }
74 Serial.println();
75 Serial.print("IP: ");
76 Serial.println(WiFi.localIP()); // bu adresi telefonda aç / open this address on your phone
77
78 server.on("/", handleRoot);
79 server.on("/set", handleSet);
80 server.begin();
81}
82
83void loop() {
84 server.handleClient();
85}Deux points du code sont essentiels. D'abord, le JavaScript n'envoie pas une requête à chaque mouvement du curseur : il attend au moins 100 ms entre deux requêtes et envoie toujours la dernière valeur quand tu lèves le doigt. Un curseur peut produire 60 événements par seconde ; tous les envoyer engorge le serveur web de l'ESP32 et fait avancer le servo par à-coups. Ensuite, côté serveur, constrain() limite l'angle à 0–180 : même si quelqu'un tape une valeur erronée dans la barre d'adresse, le servo n'est pas forcé.
À chaque ouverture de la page, l'espace réservé %ANGLE% est remplacé par l'angle actuel du servo, si bien que le curseur démarre à la bonne position même après avoir fermé et rouvert le navigateur. Plusieurs téléphones peuvent se connecter en même temps ; c'est le dernier angle envoyé qui compte. Pour une interface en direct qui se met à jour instantanément sur tous les téléphones, passe à la méthode de Serveur web asynchrone ESP32 et WebSocket.
Pas de box ? L'ESP32 crée son propre réseau Wi-Fi
Si tu utilises le projet dans une fête de la science, au jardin ou dans un endroit sans réseau, fais fonctionner l'ESP32 en point d'accès (mode AP). Dans setup(), remplace les lignes WiFi.mode et WiFi.begin ainsi que la boucle qui attend la connexion par les lignes ci-dessous ; il te suffit ensuite de connecter ton téléphone au réseau ESP32-Servo et d'ouvrir 192.168.4.1 dans le navigateur :
1// Router yoksa: ESP32 kendi ağını kurar / No router: the ESP32 creates its own network
2WiFi.softAP("ESP32-Servo", "12345678"); // şifre en az 8 karakter / password, at least 8 characters
3Serial.print("IP: ");
4Serial.println(WiFi.softAPIP()); // genellikle 192.168.4.1 / usually 192.168.4.1Éviter les tremblements du servo
- Alimentation séparée et masse commune : une alimentation trop faible est la cause numéro un des tremblements ; alimente le servo avec une source 5 V d'au moins 2 A et relie les masses.
- Condensateur : place un condensateur électrolytique de 470 à 1000 µF sur les fils d'alimentation, près du servo ; il amortit la chute de tension au démarrage. Tu peux décoder les marquages des condensateurs avec l'outil code des condensateurs.
- Limite les requêtes : n'envoie pas chaque événement du curseur ; la limite de 100 ms du code soulage à la fois le réseau et le servo.
- N'écris pas deux fois le même angle : le test if (angle != currentAngle) du code évite les écritures inutiles.
- La bonne plage d'impulsion : si le servo grésille aux extrémités, il force contre sa butée ; resserre la plage de attach() ou les limites d'angle.
- Fil de signal court : au-delà de 30 cm de câble, fais passer le signal et la masse côte à côte, idéalement torsadés.
- En dernier recours, detach() : si tu appelles detach() une fois la position atteinte, le signal est coupé et le tremblement cesse, mais le servo ne maintient plus la charge.
Si le problème persiste, consulte Servo qui tremble : causes et solutions, où l'on passe en revue toutes les causes avec des mesures. Si tu fonctionnes sur piles, tu peux estimer leur autonomie à l'avance avec le calculateur d'autonomie de batterie.
Étape 3 : version pan-tilt à deux servos
Un système pan-tilt comporte deux servos : celui du bas tourne à l'horizontale (pan), celui du haut à la verticale (tilt). Fixe dessus une caméra, un laser ou un capteur à ultrasons et tu obtiens un œil orientable à distance. Branche le servo pan sur GPIO 13 et le servo tilt sur GPIO 27, et alimente les deux avec la même source externe 5 V. Cette version apporte deux nouveautés : la page affiche deux curseurs, et au lieu de sauter d'un coup au nouvel angle, les servos avancent d'un degré toutes les 10 ms jusqu'à l'atteindre. Le mouvement devient plus fluide et les deux servos ne tirent pas un gros courant au même instant.
1#include <WiFi.h>
2#include <WebServer.h>
3#include <ESP32Servo.h>
4
5const char* WIFI_SSID = "AgAdi"; // Wi-Fi adın / your Wi-Fi name
6const char* WIFI_PASS = "Sifre123"; // Wi-Fi şifren / your Wi-Fi password
7const int PAN_PIN = 13; // yatay servo / pan servo
8const int TILT_PIN = 27; // dikey servo / tilt servo
9
10WebServer server(80);
11Servo pan, tilt;
12int panTarget = 90, tiltTarget = 90; // hedef açılar / target angles
13int panNow = 90, tiltNow = 90; // anlık açılar / current angles
14unsigned long lastStep = 0;
15
16const char PAGE[] PROGMEM = R"rawliteral(
17<!DOCTYPE html><html><head><meta charset="utf-8">
18<meta name="viewport" content="width=device-width,initial-scale=1">
19<title>ESP32 Pan-Tilt</title>
20<style>body{font-family:sans-serif;text-align:center}input{width:85%;height:40px}</style>
21</head><body>
22<h2>ESP32 Pan-Tilt</h2>
23<p>Pan: <b id="pv">%PAN%</b>°</p>
24<input type="range" id="pan" min="0" max="180" value="%PAN%">
25<p>Tilt: <b id="tv">%TILT%</b>°</p>
26<input type="range" id="tilt" min="20" max="160" value="%TILT%">
27<script>
28const pan = document.getElementById('pan');
29const tilt = document.getElementById('tilt');
30let last = 0, timer = null;
31function send() {
32 fetch('/set?pan=' + pan.value + '&tilt=' + tilt.value); // iki açı tek istekte / both angles in one request
33 last = Date.now();
34}
35function changed() {
36 document.getElementById('pv').textContent = pan.value;
37 document.getElementById('tv').textContent = tilt.value;
38 clearTimeout(timer);
39 if (Date.now() - last > 100) send();
40 else timer = setTimeout(send, 100);
41}
42pan.addEventListener('input', changed);
43tilt.addEventListener('input', changed);
44</script></body></html>
45)rawliteral";
46
47void handleRoot() {
48 String html = PAGE;
49 html.replace("%PAN%", String(panTarget));
50 html.replace("%TILT%", String(tiltTarget));
51 server.send(200, "text/html", html);
52}
53
54void handleSet() {
55 if (server.hasArg("pan")) panTarget = constrain(server.arg("pan").toInt(), 0, 180);
56 if (server.hasArg("tilt")) tiltTarget = constrain(server.arg("tilt").toInt(), 20, 160); // braket sınırı / bracket limit
57 server.send(200, "text/plain", "OK");
58}
59
60// Her 10 ms'de hedefe 1 derece yaklaş: yumuşak hareket, düşük akım
61// Step 1 degree toward the target every 10 ms: smooth motion, lower current peaks
62void moveSmoothly() {
63 if (millis() - lastStep < 10) return;
64 lastStep = millis();
65 if (panNow != panTarget) {
66 panNow += (panTarget > panNow) ? 1 : -1;
67 pan.write(panNow);
68 }
69 if (tiltNow != tiltTarget) {
70 tiltNow += (tiltTarget > tiltNow) ? 1 : -1;
71 tilt.write(tiltNow);
72 }
73}
74
75void setup() {
76 Serial.begin(115200);
77 pan.setPeriodHertz(50);
78 tilt.setPeriodHertz(50);
79 pan.attach(PAN_PIN, 500, 2400);
80 tilt.attach(TILT_PIN, 500, 2400);
81 pan.write(panNow);
82 tilt.write(tiltNow);
83
84 WiFi.mode(WIFI_STA);
85 WiFi.begin(WIFI_SSID, WIFI_PASS);
86 while (WiFi.status() != WL_CONNECTED) {
87 delay(500);
88 Serial.print(".");
89 }
90 Serial.println();
91 Serial.print("IP: ");
92 Serial.println(WiFi.localIP());
93
94 server.on("/", handleRoot);
95 server.on("/set", handleSet);
96 server.begin();
97}
98
99void loop() {
100 server.handleClient(); // istekleri işle / handle requests
101 moveSmoothly(); // servoları hedefe taşı / move the servos toward their targets
102}L'axe tilt est limité à 20–160 degrés, car sur la plupart des supports pan-tilt en plastique le servo du haut heurte la base aux extrémités. Sur ton propre montage, amène doucement le servo vers chaque extrémité, note l'angle juste avant le contact et règle en conséquence les valeurs min et max du curseur ainsi que les limites de constrain() dans le code. Si tu as besoin de plus de servos, passer des broches de l'ESP32 à une carte pilote de servos PCA9685 à 16 canaux simplifie beaucoup le câblage et l'alimentation.
Erreurs fréquentes et solutions
- Le servo ne bouge pas du tout : les masses ne sont pas reliées, le servo est sur le 3V3, ou le fil de signal est sur l'une des broches d'entrée seule GPIO 34–39.
- L'ESP32 redémarre quand le servo bouge : l'alimentation est insuffisante ; alimente le servo avec une source 5 V séparée et ajoute un condensateur.
- Erreur "This library only supports boards with an AVR..." : la bibliothèque Servo d'Arduino ne prend pas en charge l'ESP32 ; utilise #include <ESP32Servo.h>.
- La page ne s'ouvre pas : le téléphone et l'ESP32 ne sont pas sur le même réseau, le téléphone est passé en données mobiles ou le réseau est en 5 GHz ; l'ESP32 ne se connecte qu'aux réseaux 2,4 GHz. Pour les autres problèmes de connexion, vois L'ESP32 ne se connecte pas au Wi-Fi.
- Le servo suit le curseur avec du retard : trop de requêtes s'accumulent ; garde la limite de 100 ms du JavaScript ou monte-la à 150 ms.
- Le servo sursaute à chaque mise sous tension : le signal est sur une broche qui émet du PWM au démarrage (GPIO 2, 5, 12, 14, 15) ; déplace-le sur GPIO 13, 25–27 ou 32–33.
Piloter un servo depuis ton téléphone avec un curseur est la base de nombreux projets : bras robotisés, caméras orientables, serrures connectées et trappes qui s'ouvrent à distance. Si tu passes à un servo plus puissant, fais le calcul d'alimentation avec Servomoteur MG996R. Dans l'application BlueGrays, tu trouveras pas à pas, avec leur schéma de câblage et leur code, la commande d'un servo par potentiomètre avec l'ESP32, la serrure RFID à servo et les projets de serveur web ESP32.
Questions fréquentes
Comment piloter un servomoteur avec un ESP32 ?
Installe la bibliothèque ESP32Servo, branche le fil de signal du servo sur une broche sûre comme GPIO 13, initialise-le avec servo.attach(13, 500, 2400) puis utilise servo.write(angle). Alimente le servo avec une source externe 5 V plutôt qu'avec l'ESP32, et relie les masses.
Pourquoi Servo.h ne fonctionne-t-il pas sur l'ESP32 ?
La bibliothèque Servo standard d'Arduino est écrite pour des processeurs comme les AVR et les SAMD et ne connaît pas le matériel PWM de l'ESP32 (LEDC). La bibliothèque ESP32Servo propose les mêmes commandes et fonctionne sur les cores ESP32 2.x et 3.x.
Le signal 3,3 V de l'ESP32 suffit-il pour un servo ?
La plupart des servos courants, comme le SG90, le MG90S et le MG996R, reconnaissent sans problème un signal de 3,3 V. Le souci vient presque toujours de l'alimentation et non du signal : le fil rouge du servo doit aller vers une source de 5–6 V capable de fournir assez de courant.
Combien de servos peut-on brancher sur un ESP32 ?
L'unité LEDC de l'ESP32 classique dispose de 16 canaux PWM : en théorie, tu peux piloter jusqu'à 16 servos. En pratique, on manque d'abord de broches adaptées ou d'alimentation ; au-delà de quatre servos, une carte pilote PCA9685 en I2C est une solution plus propre.
Peut-on piloter un servo avec un ESP32 sans box internet ?
Oui. En mode point d'accès avec WiFi.softAP(), l'ESP32 crée son propre réseau Wi-Fi. Tu connectes ton téléphone à ce réseau, tu ouvres 192.168.4.1 dans le navigateur et tu utilises la même page avec le curseur.
Pourquoi mon servo tremble-t-il avec l'ESP32 ?
Les causes les plus fréquentes sont une alimentation insuffisante, l'absence de masse commune et un trop grand nombre de commandes par seconde. Alimente le servo avec une source 5 V séparée, ajoute un condensateur de 470 à 1000 µF et limite les requêtes de la page web à une toutes les 100 ms.
Projets à réaliser après cet article
Voir tous les projets
Servomoteur ESP32 (commande par potentiomètre)
Dans ce projet, nous contrôlons un servomoteur SG90 à l'aide d'un potentiomètre. Nous réglons l'angle du servomoteur en mappant la valeur analogique lue par le potentiomètre sur une plage de 0 à 180 degrés. La bibliothèque ESP32Servo génère des signaux de servomoteur sur les GPIO appropriés de l'ESP32 pouvant fonctionner en sortie ; ce projet utilise GPIO 18. Il s'agit d'une méthode de contrôle fondamentale pour les bras robotiques, les cardans de caméra et les mécanismes de portes automatiques.

Serrure de porte RFID ESP32 (RC522 + servomoteur + écran OLED + buzzer + LED)
On fabrique une serrure connectée avec un ESP32, un module RFID RC522, un servo SG90, un écran OLED SSD1306, un buzzer actif et 2 LED. L'UID de la carte lue est comparé aux cartes autorisées définies dans le code ; s'il correspond, le servo ouvre (LED verte + 2 bips courts) puis referme au bout de 5 secondes. Une carte inconnue allume la LED rouge, déclenche 3 bips rapides et affiche son UID sur l'OLED.

Serveur Web asynchrone ESP32 (avec affichage de l'adresse IP sur l'écran LCD)
On transforme l'ESP32 en serveur web asynchrone que tu pilotes depuis ton téléphone ou ton ordinateur sur le même réseau Wi-Fi. Grâce à la bibliothèque ESPAsyncWebServer, le serveur traite plusieurs requêtes à la fois (il ne bloque pas sur une seule requête comme le WebServer.h classique). Ouvre l'adresse IP de l'ESP32 dans le navigateur et allume ou éteins la LED sur GPIO 5 avec les boutons ON/OFF (adresses /on et /off).

Compteur ESP32 WebSocket (2 boutons + écran LCD + affichage Web en temps réel)
Dans ce projet, deux boutons reliés à l'ESP32 (GPIO 5 incrémente, GPIO 4 décrémente) modifient un compteur. La valeur se met à jour instantanément sur un écran LCD I2C 16x2 et, grâce au support WebSocket d'ESPAsyncWebServer, dans tous les navigateurs connectés sans recharger la page. Au lieu du polling HTTP, une seule connexion persistante est utilisée et l'ESP32 envoie la nouvelle valeur à tous avec ws.textAll().

Connexion Wi-Fi STA ESP32 (avec écran LCD)
Dans ce projet, nous connectons l'ESP32 au réseau Wi-Fi domestique en mode Station (STA) de manière sécurisée et tolérante aux pannes. Nous isolons SSID/mot de passe dans un fichier secrets.h pour empêcher leur fuite sur Git, mettons en place une reconnexion automatique, et affichons le niveau RSSI et l'adresse IP sur un écran LCD I2C. La LED intégrée sert d'indicateur d'état.

ESP32 mDNS : accès à l'appareil via bluegrays-esp.local (avec écran LCD)
Dans ce projet, en ajoutant un service mDNS (Multicast DNS) à l'ESP32, nous permettons d'accéder à l'appareil via un nom d'hôte lisible, tel que bluegrays-esp.local, plutôt qu'à l'aide d'une adresse IP. Même si l'adresse IP attribuée par le DHCP venait à changer, vous pourrez toujours accéder à l'appareil sous le même nom. En exécutant également un petit serveur web sur l'appareil, nous envoyons des commandes de contrôle des LED depuis un navigateur via l'adresse http://bluegrays-esp.local/.

Servocommande avec joystick
Pilote deux moteurs avec un joystick, comme si tu orientais une caméra de surveillance.
Autres articles
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

