ESP32-servo-webserver: bestuur een servo met een schuifregelaar op je telefoon
Bouw een ESP32-servo-webserver: ESP32Servo-bibliotheek, een webschuifregelaar die de hoek met fetch verstuurt, pinkeuze, voeding en gemeenschappelijke massa, trillingen verhelpen, pan-tilt.
De leukste manier om een ESP32-servo-webserver te bouwen is de servo in realtime te laten draaien met een schuifregelaar op je telefoon: schuif met je vinger en de servo volgt, zonder dat je een app op de telefoon hoeft te installeren. In deze gids maken we van de ESP32 een webserver, sturen we de waarde van de schuifregelaar vanaf de pagina in de browser met het JavaScript-commando fetch naar de ESP32 en bewegen we de servo naar die hoek met de bibliotheek ESP32Servo.
Naast de code behandelen we de hardware uitgebreid, want de meeste wifi-servoprojecten mislukken door de voeding, niet door de software: de servo trilt, de ESP32 reset of de verbinding valt weg. Stap voor stap zie je welke pin je kiest, waarmee je de servo voedt, waarom een gemeenschappelijke massa essentieel is, hoe je trillingen voorkomt en tot slot hoe je een pan-tilt-houder met twee servo's bouwt.

Zo werkt het: van de schuifregelaar naar de servo
- De browser op je telefoon opent het IP-adres van de ESP32 en de ESP32 stuurt een kleine HTML-pagina met een schuifregelaar terug.
- Terwijl je de schuifregelaar beweegt, stuurt JavaScript op de pagina de hoek met fetch naar een adres zoals /set?angle=120; de pagina wordt niet opnieuw geladen.
- De webserver op de ESP32 ontvangt het verzoek, leest de hoek en beperkt die tot het bereik 0–180.
- De bibliotheek ESP32Servo zet de hoek om in een pulsbreedte: ongeveer 500 µs voor 0 graden en 2400 µs voor 180 graden, 50 keer per seconde verstuurd.
- De besturingsprint in de servo leest de puls, stuurt de motor naar die hoek en houdt hem daar vast.
In Wat is een servomotor? hebben we uitgelegd hoe een servo werkt en hoe pulsbreedte en hoek samenhangen. Hier is dit het belangrijkste: de standaard Arduino-bibliotheek Servo werkt niet op de ESP32, omdat de ESP32 PWM met andere hardware (LEDC) opwekt. Daarom gebruiken we de bibliotheek ESP32Servo; die biedt dezelfde commando's attach() en write() en werkt met zowel de 2.x- als de 3.x-ESP32-core.
Wat je nodig hebt
- Een ESP32-ontwikkelboard (DevKit, NodeMCU-32S of vergelijkbaar)
- Een SG90- of MG90S-servo (twee stuks en een pan-tilt-beugel voor de pan-tilt-versie)
- Een externe 5 V-voeding: een adapter van minimaal 2 A of een batterijhouder voor 4 × AA
- Een elco van 470–1000 µF (minimaal 10 V)
- Een breadboard en jumperdraden
- Het ESP32-boardpakket geïnstalleerd in de Arduino IDE en de bibliotheek ESP32Servo geïnstalleerd via de Library Manager
Een pin kiezen: welke GPIO gebruik je voor de servo?
Bijna elke uitgangspin van de ESP32 kan PWM opwekken, maar ze zijn niet allemaal even geschikt voor een servo. Sommige pins geven tijdens het opstarten korte signalen af, waardoor de servo elke keer schokt als het board wordt gevoed; andere zijn alleen ingang. Je ziet de complete pinindeling van je board in de tool Pinout:
| Pins | Voor een servo | Waarom |
|---|---|---|
| GPIO 13, 25, 26, 27, 32, 33 | Aanbevolen | Stil tijdens het opstarten en elk kan PWM (LEDC) leveren |
| GPIO 4, 16, 17, 18, 19, 21, 22, 23 | Prima | Veilige algemene pins; laat ze ongebruikt als je I2C (21, 22) of SPI (18, 19, 23) gebruikt |
| GPIO 2, 5, 12, 14, 15 | Vermijden | Strapping-pins of pins die tijdens het opstarten PWM afgeven; de servo kan schokken of het board start mogelijk niet op |
| GPIO 34–39 | Niet bruikbaar | Alleen ingang, ze kunnen geen PWM afgeven |
| GPIO 6–11 | Niet bruikbaar | Verbonden met het interne flashgeheugen |
| GPIO 1 en 3 | Niet bruikbaar | De USB-seriële lijn (TX, RX) |
De servo voeden en de gemeenschappelijke massa
Een SG90 in rust trekt ongeveer 10 mA, maar zodra hij beweegt of een last vasthoudt, springt de stroom naar 500–700 mA. De ESP32 zelf trekt pieken van ongeveer 250 mA tijdens het zenden via wifi. Voed je beide via dezelfde zwakke USB-lijn, dan zakt de spanning in en reset de ESP32 met "Brownout detector was triggered". De oplossing is de servo te voeden met een aparte 5 V-voeding en de massa's van beide schakelingen te verbinden:
| Servodraad | Aansluiten op | Opmerking |
|---|---|---|
| Bruin of zwart (GND) | Min van de externe voeding en de GND-pin van de ESP32 | Een gemeenschappelijke massa is verplicht: het is de referentie van het signaal |
| Rood (V+) | Externe 5 V-voeding (4,8–6 V) | Sluit hem nooit aan op de 3V3-pin van de ESP32 |
| Oranje of geel (signaal) | GPIO 13 | Een signaal van 3,3 V is genoeg voor de SG90 en MG90S |
| Opstelling | Aanbevolen voeding | Opmerking |
|---|---|---|
| 1 SG90, test zonder belasting | De 5V-pin (VIN) van het ESP32-board, via USB | Alleen korte tests; samen met wifi zijn brownouts mogelijk |
| 2 SG90 (pan-tilt) | 5 V-adapter, minimaal 2 A | Plaats een condensator van 470–1000 µF over de voeding |
| 1–2 MG996R | 5–6 V, minimaal 3 A | De blokkeerstroom kan oplopen tot 2,5 A per servo |
| Draagbaar project | 4 AA-batterijen (alkaline, 6 V) | Oplaadbare NiMH-cellen geven 4,8 V, dat is ook prima |
Stap 1: een eerste test met ESP32Servo
Controleer voordat je wifi toevoegt of de servo en de voeding goed werken. Zoek ESP32Servo in de Library Manager, installeer de bibliotheek van Kevin Harrington en John K. Bennett en upload dan de onderstaande sketch. De servo moet langzaam heen en weer bewegen tussen 0 en 180 graden; doet hij dat niet, dan zit het probleem in de bedrading of de voeding, niet in de software.
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}Stap 2: de servo bedienen met een schuifregelaar op een webpagina
Nu het hoofdproject. De onderstaande sketch verbindt de ESP32 met je thuisnetwerk, serveert een pagina met een schuifregelaar en schrijft de hoek die bij /set binnenkomt naar de servo. De HTML-pagina staat als raw string in de code, dus er is geen apart bestand om te uploaden. Vul je wifinaam en wachtwoord in, upload de sketch en open dan het IP-adres dat de Serial Monitor toont in de browser van je telefoon.
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}Er zijn twee kernpunten in deze code. Ten eerste stuurt de JavaScript niet bij elke beweging van de schuifregelaar een verzoek: er zit minstens 100 ms tussen de verzoeken en bij het loslaten van je vinger wordt altijd de laatste waarde verstuurd. Een schuifregelaar kan 60 events per seconde afgeven; als je ze allemaal verstuurt, loopt de webserver van de ESP32 vast en beweegt de servo schokkerig. Ten tweede beperkt constrain() aan de serverkant de hoek tot 0–180, zodat de servo niet wordt geforceerd, ook als iemand een foute waarde in de adresbalk typt.
Elke keer dat de pagina opent, wordt de placeholder %ANGLE% vervangen door de huidige hoek van de servo, zodat de schuifregelaar ook na het sluiten en heropenen van de browser op de juiste positie begint. Meerdere telefoons kunnen tegelijk verbinden en de laatst verstuurde hoek wint. Wil je een live interface die op elke telefoon direct meebeweegt, ga dan over op de aanpak uit ESP32 Async Web Server en WebSocket.
Geen router? Laat de ESP32 een eigen wifinetwerk maken
Gebruik je het project op een wetenschapsbeurs, in de tuin of ergens zonder thuisnetwerk, laat de ESP32 dan werken in access point-modus (AP). Vervang in setup() de regels WiFi.mode en WiFi.begin en de lus die op de verbinding wacht door de onderstaande regels; maak daarna met je telefoon verbinding met het netwerk ESP32-Servo en open 192.168.4.1 in de browser:
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.1Zo voorkom je trillingen van de servo
- Aparte voeding en een gemeenschappelijke massa: een zwakke voeding is de belangrijkste oorzaak van trillingen; voed de servo met een 5 V-voeding van minimaal 2 A en verbind de massa's.
- Condensator: plaats een elco van 470–1000 µF over de voedingsdraden van de servo, dicht bij de servo; hij dempt de spanningsdip wanneer de servo start. Met de tool condensatorcode kun je de markeringen op condensatoren ontcijferen.
- Beperk de verzoeken: verstuur niet elk event van de schuifregelaar; de limiet van 100 ms in de code ontlast zowel het netwerk als de servo.
- Schrijf niet steeds dezelfde hoek: de controle if (angle != currentAngle) in de code slaat onnodige schrijfacties over.
- Het juiste pulsbereik: zoemt de servo aan de uiteinden, dan duwt hij tegen zijn mechanische aanslag; verklein het bereik van attach() of de hoeklimieten.
- Houd de signaaldraad kort: leg bij draden langer dan 30 cm signaal en GND naast elkaar, bij voorkeur in elkaar gedraaid.
- Laatste redmiddel, detach(): als je detach() aanroept zodra de servo zijn positie bereikt, wordt het signaal onderbroken en stoppen de trillingen, maar de servo houdt de last niet meer vast.
Houdt het probleem aan, lees dan Servotrillingen: oorzaken en oplossingen, waar we alle oorzaken van trillingen met metingen doorlopen. Werk je op batterijen, dan kun je vooraf met de batterijduurcalculator inschatten hoe lang ze meegaan.
Stap 3: een pan-tilt-versie met twee servo's
Een pan-tilt-houder heeft twee servo's: de onderste draait horizontaal (pan) en de bovenste verticaal (tilt). Voeg een camera, een laser of een ultrasone sensor toe en je hebt een oog dat je op afstand kunt richten. Sluit de pan-servo aan op GPIO 13 en de tilt-servo op GPIO 27 en voed beide met dezelfde externe 5 V-voeding. Deze versie heeft twee veranderingen: de pagina heeft twee schuifregelaars en de servo's springen niet meteen naar de nieuwe hoek, maar bewegen elke 10 ms één graad tot ze er zijn. Dat maakt de beweging soepeler en voorkomt dat beide servo's op hetzelfde moment een grote stroom trekken.
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}De tilt-as is beperkt tot 20–160 graden, omdat bij de meeste plastic pan-tilt-beugels de bovenste servo in de uiterste standen tegen de basis botst. Beweeg op je eigen houder de servo langzaam naar elk uiteinde, noteer de hoek vlak voordat hij botst en stel zowel de min- en maxwaarde van de schuifregelaar als de constrain()-limieten in de code daarop af. Heb je meer servo's nodig, dan maakt een overstap van de pins van de ESP32 naar een PCA9685-servodriver met 16 kanalen de bedrading en voeding een stuk eenvoudiger.
Veelgemaakte fouten en hoe je ze oplost
- De servo beweegt helemaal niet: de massa's zijn niet verbonden, de servo hangt aan 3V3 of de signaaldraad zit op een van de pins die alleen ingang zijn, GPIO 34–39.
- De ESP32 reset als de servo beweegt: de voeding is niet krachtig genoeg; voed de servo met een aparte 5 V-voeding en voeg een condensator toe.
- Foutmelding "This library only supports boards with an AVR...": de Arduino-bibliotheek Servo ondersteunt de ESP32 niet; gebruik #include <ESP32Servo.h>.
- De pagina opent niet: de telefoon en de ESP32 zitten niet op hetzelfde netwerk, de telefoon is overgeschakeld naar mobiele data of het netwerk is 5 GHz; de ESP32 maakt alleen verbinding met 2,4 GHz-netwerken. Zie voor andere verbindingsproblemen ESP32 maakt geen verbinding met wifi.
- De servo loopt achter op de schuifregelaar: er staan te veel verzoeken in de wachtrij; houd de limiet van 100 ms in de JavaScript aan of verhoog hem naar 150 ms.
- De servo schokt elke keer als het board wordt gevoed: het signaal zit op een pin die tijdens het opstarten PWM afgeeft (GPIO 2, 5, 12, 14, 15); verplaats het naar GPIO 13, 25–27 of 32–33.
Een servo met een schuifregelaar vanaf je telefoon bedienen is de basis van veel projecten: robotarmen, camerahouders, slimme deursloten en deksels die op afstand openen. Stap je over op een sterkere servo, bereken dan het vermogensbudget met MG996R-servomotor. In de BlueGrays-app vind je de projecten ESP32-servobesturing met potmeter, het RFID-deurslot met servo en de ESP32-webserver stap voor stap, elk met schakelschema en code.
Veelgestelde vragen
Hoe bestuur je een servomotor met een ESP32?
Installeer de bibliotheek ESP32Servo, sluit de signaaldraad van de servo aan op een veilige pin zoals GPIO 13, start hem met servo.attach(13, 500, 2400) en gebruik daarna servo.write(angle). Voed de servo met een externe 5 V-voeding in plaats van via de ESP32 en verbind de massa's.
Waarom werkt Servo.h niet op de ESP32?
De standaard Arduino-bibliotheek Servo is geschreven voor processors zoals AVR en SAMD en kent de PWM-hardware (LEDC) van de ESP32 niet. De bibliotheek ESP32Servo biedt dezelfde commando's en werkt op zowel de 2.x- als de 3.x-ESP32-core.
Is het 3,3 V-signaal van de ESP32 genoeg voor een servo?
De meeste gangbare servo's, waaronder de SG90, MG90S en MG996R, lezen een signaal van 3,3 V zonder problemen. Het probleem is bijna altijd de voeding, niet het signaal: de rode draad van de servo moet naar een voeding van 5–6 V die genoeg stroom kan leveren.
Hoeveel servo's kan een ESP32 aansturen?
De LEDC-eenheid van de klassieke ESP32 heeft 16 PWM-kanalen, dus in theorie kun je tot 16 servo's aansturen. In de praktijk heb je eerder te weinig geschikte pins of te weinig voeding; voor meer dan vier servo's is een PCA9685-driverboard via I2C een nettere oplossing.
Kan ik een servo met een ESP32 bedienen zonder router?
Ja. Zet de ESP32 in access point-modus met WiFi.softAP() en hij maakt een eigen wifinetwerk. Maak met je telefoon verbinding met dat netwerk, open 192.168.4.1 in de browser en gebruik dezelfde pagina met schuifregelaar.
Waarom trilt mijn servo als hij op een ESP32 is aangesloten?
De meest voorkomende oorzaken zijn een ontoereikende voeding, een ontbrekende gemeenschappelijke massa en te veel commando's per seconde. Voed de servo met een aparte 5 V-voeding, voeg een condensator van 470–1000 µF toe en beperk de verzoeken van de webpagina tot één per 100 ms.
Projecten om hierna te bouwen
Alle projecten bekijken
ESP32-servomotor (bediening met potentiometer)
In dit project bedien je een SG90-servomotor met een potentiometer. De analoge waarde van de potentiometer zet je om naar het bereik van 0–180 graden en zo stel je de servohoek in. De ESP32Servo-bibliotheek maakt het servosignaal op geschikte GPIO-pinnen van de ESP32 die als uitgang kunnen dienen; dit project gebruikt GPIO 18. Dit is een basismethode voor robotarmen, cameragimbals en automatische deurmechanismen.

ESP32 RFID-deurslot (RC522 + servo + OLED + buzzer + LED)
We bouwen een slim deurslot met een ESP32, een RC522 RFID-module, een SG90-servo, een SSD1306 OLED-display, een actieve buzzer en 2 leds. Bij het scannen van een kaart wordt de UID vergeleken met de geautoriseerde kaarten in de code; bij een match ontgrendelt de servo (groene led + 2 korte piepjes) en vergrendelt na 5 seconden weer. Een onbekende kaart laat de rode led branden, geeft 3 snelle piepjes en toont de UID op de OLED.

ESP32 asynchrone webserver (met IP-weergave op lcd)
In dit project maken we van de ESP32 een asynchrone webserver die je met je telefoon of computer op hetzelfde wifinetwerk kunt bedienen. Dankzij de ESPAsyncWebServer-bibliotheek kan de server meerdere verzoeken tegelijk verwerken (anders dan de klassieke WebServer.h, die bij één verzoek blokkeert). Je opent het IP-adres van de ESP32 in een browser en klikt op de knoppen ON/OFF (de routes /on en /off) om de led op GPIO 5 aan en uit te zetten.

ESP32 WebSocket-teller (2 knoppen + lcd + realtime web)
In dit project verandert een teller met twee knoppen op de ESP32 (GPIO 5 telt op, GPIO 4 telt af). De waarde wordt direct bijgewerkt op een 16x2 I2C-lcd en, via de WebSocket-ondersteuning van ESPAsyncWebServer, in elke verbonden browser zonder de pagina te herladen. In plaats van HTTP-polling wordt één blijvende verbinding gebruikt en de ESP32 stuurt de nieuwe waarde met ws.textAll() naar iedereen.

ESP32 Wi-Fi-verbinding in STA-modus (met lcd-scherm)
In dit project verbinden we de ESP32 in Station-modus (STA) veilig en foutbestendig met het wifinetwerk thuis. We zetten de SSID en het wachtwoord in een apart bestand secrets.h zodat ze niet in Git lekken, bouwen een automatisch herverbindingsmechanisme en tonen het RSSI-signaalniveau en het IP-adres op een I2C-lcd-scherm. De ingebouwde led werkt als statusindicator. Het is een verbindingsmanager van productieniveau.

ESP32 mDNS: het apparaat bereiken via bluegrays-esp.local (met lcd-scherm)
In dit project voegen we een mDNS-service (Multicast DNS) toe aan de ESP32, zodat je het apparaat bereikt met een leesbare hostnaam zoals bluegrays-esp.local in plaats van een IP-adres. Ook als het IP-adres dat DHCP uitdeelt verandert, reageert het apparaat altijd op dezelfde naam. Met een kleine webserver op het board bedien je de LED vanuit je browser op http://bluegrays-esp.local/.

Servo's bedienen met joystick
Stuur twee motoren aan met een joystick, net als bij het draaien van een bewakingscamera.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

