ESP32 async webserver met WebSocket: bedieningspaneel in realtime
ESP32 async webserver met WebSocket: schakel een relais en bekijk live sensordata zonder te herladen. Installatie, PROGMEM vs LittleFS, esp32.local, wachtwoord en oplossingen.
Een ESP32 async webserver, gebouwd met de ESPAsyncWebServer-bibliotheek, maakt van je ESP32 een snelle webserver die tegelijk meerdere telefoons en computers kan bedienen. Met de WebSocket-ondersteuning die bij de bibliotheek hoort, houden de browser en het board een permanent open verbinding: druk op de knop op de pagina en het relais klikt meteen, en als de temperatuur verandert, wordt het getal op de pagina vanzelf bijgewerkt, zonder herladen. Elk ander apparaat waarop hetzelfde paneel openstaat, ziet jouw wijziging binnen dezelfde seconde. Kortom: dit duo is de handigste manier om binnen je thuisnetwerk een eigen smarthomepaneel te bouwen, zonder cloudservice.
In deze gids zie je eerst hoe een asynchrone server verschilt van de klassieke WebServer-bibliotheek en waarom WebSocket sneller is dan gewone HTTP-verzoeken. Daarna installeer je de juiste bibliotheken, draai je de simpelst mogelijke server en bouw je een realtime bedieningspaneel met een relais en een DHT22-sensor. Vervolgens leer je hoe je de HTML in PROGMEM of LittleFS bewaart, esp32.local gebruikt in plaats van een IP-adres, meerdere clients afhandelt, een eenvoudig wachtwoord aan het paneel toevoegt en de meest voorkomende compileer- en verbindingsfouten oplost. De code werkt met zowel de 2.x- als de 3.x-versie van de ESP32-core in de Arduino IDE.

Wat is de ESP32 async webserver en hoe werkt hij?
De WebServer.h-bibliotheek die bij de ESP32-core zit, is synchroon: binnenkomende verzoeken worden pas, één voor één, afgehandeld wanneer server.handleClient() in loop() wordt aangeroepen. Als loop() een delay() van 2 seconden bevat, wacht de pagina ook 2 seconden; als twee mensen tegelijk verbinden, wacht de één op de ander. ESPAsyncWebServer draait daarentegen in een aparte FreeRTOS-taak (async_tcp) die door de AsyncTCP-bibliotheek wordt aangemaakt. Zodra een verzoek binnenkomt, worden de headers op de achtergrond verwerkt, wordt de functie die jij schreef (de callback) aangeroepen als het verzoek klaar is en wordt het antwoord ook op de achtergrond verstuurd. Ondertussen gaat loop() gewoon door met zijn eigen werk. Zo kunnen meerdere verbindingen tegelijk openstaan en zijn permanent open verbindingen zoals WebSocket en Server-Sent Events (SSE) mogelijk. Als je meer wilt weten over de twee cores en taken van de ESP32, lees dan het artikel ESP32 FreeRTOS.
| Eigenschap | WebServer.h (synchroon) | ESPAsyncWebServer (asynchroon) |
|---|---|---|
| Installatie | Zit bij de ESP32-core | 2 bibliotheken uit de Library Manager |
| Verzoeken afhandelen | Eén voor één via handleClient() in loop() | In de achtergrondtaak async_tcp, meerdere tegelijk |
| delay() in loop() | Vertraagt het antwoord van de pagina | Heeft geen invloed op de server |
| WebSocket | Geen; je hebt een aparte bibliotheek nodig (bijv. de WebSockets-bibliotheek van Markus Sattler) | Ingebouwd (AsyncWebSocket) |
| Server-Sent Events | Geen | Ingebouwd (AsyncEventSource) |
| Statische bestanden serveren | Met serveStatic | serveStatic, automatische .gz-ondersteuning en cachebeheer |
| Let op | Het makkelijkst te leren | Geen delay() of zwaar werk in callbacks |
Wat is WebSocket en hoe verschilt het van een HTTP-verzoek?
Bij een gewoon HTTP-verzoek opent de browser een verbinding, zegt "geef me deze pagina", ontvangt het antwoord en daarmee eindigt het gesprek. De server kan de browser uit zichzelf niets vertellen; om een nieuwe waarde te zien, moet de browser opnieuw vragen. WebSocket (RFC 6455) is een handshake die als HTTP begint: de browser voegt een Upgrade: websocket-header aan zijn verzoek toe, de ESP32 accepteert met een 101 Switching Protocols-antwoord en dezelfde TCP-verbinding blijft open. Vanaf dat moment kunnen beide kanten een bericht sturen wanneer ze willen (full-duplex). Elk bericht heeft maar 2 tot 14 bytes overhead, terwijl elk HTTP-verzoek honderden bytes aan headers meedraagt. Daarom komen WebSocket-berichten binnen enkele milliseconden aan en is het de efficiëntste methode voor panelen die meerdere updates per seconde versturen. Zo verhouden de vier manieren om een pagina met sensorwaarden actueel te houden zich tot elkaar:
| Methode | Werking | Latentie en overhead | Wanneer gebruiken |
|---|---|---|---|
| Pagina vernieuwen (meta refresh) | De browser downloadt om de paar seconden de hele pagina opnieuw | Hoog; de pagina flikkert elke keer | Vermijd het |
| Polling met fetch | JavaScript vraagt elke 1–2 seconden een kleine JSON op | Gemiddeld; elk verzoek draagt nieuwe headers | Eén waarde die zelden verandert |
| Server-Sent Events (SSE) | De server pusht eenrichtingsgebeurtenissen over een open verbinding | Laag; alleen van server naar browser | Dashboards die alleen monitoren |
| WebSocket | Tweerichtingsberichten over een open verbinding | Laagste; frames van een paar bytes | Knoppen, schuifregelaars en live data samen |
Benodigde bibliotheken: ESPAsyncWebServer en AsyncTCP installeren
- Zorg dat het ESP32-boardpakket (Espressif Systems) in de Arduino IDE is geïnstalleerd; de installatiestappen staan in Wat is de ESP32?
- Open de Library Manager (Ctrl+Shift+I) en zoek naar ESPAsyncWebServer. Installeer de bibliotheek ESP Async WebServer met als auteur ESP32Async.
- Deze bibliotheek meldt haar afhankelijkheid niet aan de Library Manager, dus de IDE stelt geen extra bibliotheken voor: installeer de Async TCP-bibliotheek, ook uitgegeven door ESP32Async, apart. Voor een ESP8266 heb je in plaats daarvan de bibliotheek ESP Async TCP (ESPAsyncTCP.h) van ESP32Async nodig.
- Installeer voor het paneelvoorbeeld de DHT sensor library van Adafruit en de bijbehorende afhankelijkheid Adafruit Unified Sensor. Als je voor het eerst een bibliotheek installeert, lees dan de gids over bibliotheken toevoegen aan Arduino.
- Als je map Documents/Arduino/libraries de mappen ESPAsyncWebServer-master, AsyncTCP-master of ESPAsyncWebSrv bevat die ooit vanuit een ZIP zijn toegevoegd, verwijder ze dan. Twee kopieën van dezelfde bibliotheek zorgen ervoor dat de compiler de verkeerde kiest.
Eerste stap: de simpelste server met AsyncWebServer
Voordat we naar het paneel gaan, kijken we met een klein voorbeeld hoe de bibliotheek werkt. De onderstaande code verbindt de ESP32 met je thuisnetwerk, toont een begroeting op de startpagina en schakelt de ingebouwde led aan en uit via de adressen /led?durum=1 en /led?durum=0. Upload de code, open de Serial Monitor op 115200 baud en typ het adres dat daar verschijnt in de browser van een telefoon op hetzelfde wifinetwerk. Als het board geen verbinding met het netwerk maakt, gebruik dan de diagnosecode in de gids ESP32 maakt geen wifiverbinding.
1#include <WiFi.h>
2#include <AsyncTCP.h>
3#include <ESPAsyncWebServer.h>
4
5const char* ssid = "AgAdi"; // Wi-Fi adın / your Wi-Fi name
6const char* password = "Sifre123"; // Wi-Fi şifren / your Wi-Fi password
7const int LED_PIN = 2; // çoğu DevKit'te dahili LED / onboard LED on most DevKits
8
9AsyncWebServer server(80); // 80 = standart HTTP portu / standard HTTP port
10bool ledAcik = false;
11
12void setup() {
13 Serial.begin(115200);
14 pinMode(LED_PIN, OUTPUT);
15
16 WiFi.mode(WIFI_STA);
17 WiFi.begin(ssid, password);
18 while (WiFi.status() != WL_CONNECTED) {
19 delay(500);
20 Serial.print(".");
21 }
22 Serial.println();
23 Serial.print("Adres / address: http://");
24 Serial.println(WiFi.localIP());
25
26 // Ana sayfa / home page
27 server.on("/", HTTP_GET, [](AsyncWebServerRequest *request) {
28 request->send(200, "text/plain", "Merhaba, ben ESP32 / Hello from ESP32");
29 });
30
31 // /led?durum=1 yakar, /led?durum=0 söndürür / turns the LED on or off
32 server.on("/led", HTTP_GET, [](AsyncWebServerRequest *request) {
33 if (request->hasParam("durum")) {
34 ledAcik = request->getParam("durum")->value() == "1";
35 digitalWrite(LED_PIN, ledAcik ? HIGH : LOW);
36 }
37 request->send(200, "text/plain", ledAcik ? "LED: ON" : "LED: OFF");
38 });
39
40 // Tanımsız adresler / unknown addresses
41 server.onNotFound([](AsyncWebServerRequest *request) {
42 request->send(404, "text/plain", "Sayfa yok / Not found");
43 });
44
45 server.begin();
46}
47
48void loop() {
49 // Sunucu arka planda çalışır, loop() boş kalabilir / the server runs in the background
50}| Opdracht | Wat het doet |
|---|---|
| AsyncWebServer server(80) | Maakt de server aan die op HTTP-poort 80 luistert |
| server.on("/led", HTTP_GET, ...) | Registreert de functie (callback) die wordt uitgevoerd voor een adres en verzoektype |
| request->hasParam("durum") | Controleert of het adres een ?durum=...-parameter bevat |
| request->getParam("durum")->value() | Geeft de waarde van de parameter als String terug |
| request->send(code, type, content) | Verstuurt het antwoord: 200 OK, 404 niet gevonden; type text/plain, text/html of application/json |
| server.onNotFound(...) | Wordt uitgevoerd voor elk adres dat niet is gedefinieerd |
| server.begin() | Start de server; roep het aan na alle server.on()-regels |
Onderdelen en bedrading voor het bedieningspaneel
In het paneelvoorbeeld schakel je een lamp of ventilator met een relaismodule en meet je temperatuur en luchtvochtigheid met een DHT22. Je hebt een ESP32 DevKit nodig, een eenkanaals 5V-relaismodule, een DHT22-sensormodule (of DHT11), een breadboard en jumperdraden. Kies bij het relais bij voorkeur een module met optocoupler. De DHT22 meet van −40 tot 80 °C met een nauwkeurigheid van ±0,5 °C en kan hooguit eens per 2 seconden worden uitgelezen; de DHT11 is goedkoper, maar heeft een nauwkeurigheid van ±2 °C over 0–50 °C. Voor details over de sensor zie het artikel DHT11-temperatuur- en vochtsensor, en voor de pinindeling van je board de tool Pinout.
| Modulepin | ESP32 DevKit | ESP8266 NodeMCU | Opmerking |
|---|---|---|---|
| Relais VCC | VIN (5 V) | VIN of VU (5 V) | De relaisspoel heeft 5 V nodig; wordt gevoed via USB |
| Relais GND | GND | GND | Gemeenschappelijke massa |
| Relais IN | GPIO 26 | D1 (GPIO 5) | De meeste modules schakelen in met een LOW-signaal |
| DHT22 VCC (+) | 3V3 | 3V3 | Gevoed met 3,3 V, dus de datalijn is ook 3,3 V |
| DHT22 DATA (OUT) | GPIO 4 | D2 (GPIO 4) | Losse sensor: weerstand van 10 kΩ tussen DATA en VCC |
| DHT22 GND (−) | GND | GND | Gemeenschappelijke massa |
Realtime bedieningspaneel: relais, DHT22 en WebSocket
Nu het hoofdproject. De onderstaande code is één bestand: de HTML, CSS en JavaScript zitten er als PROGMEM-array in. Als de pagina opent, maakt de browser een WebSocket-verbinding met /ws. Elke 2 seconden leest de ESP32 de DHT22 uit en stuurt temperatuur, luchtvochtigheid, relaisstatus en aantal verbonden apparaten in één JSON-bericht naar elke browser. Als je op de knop drukt, stuurt de browser het bericht toggle, schakelt de ESP32 het relais om en meldt de nieuwe status opnieuw aan iedereen. Pas de netwerknaam en het wachtwoord aan, upload en open dan http://esp32.local of het IP-adres uit de Serial Monitor in je browser.
1#include <WiFi.h>
2#include <AsyncTCP.h>
3#include <ESPAsyncWebServer.h>
4#include <ESPmDNS.h>
5#include <DHT.h>
6
7const char* ssid = "AgAdi"; // Wi-Fi adın / your Wi-Fi name
8const char* password = "Sifre123"; // Wi-Fi şifren / your Wi-Fi password
9
10const int ROLE_PIN = 26; // röle modülü IN / relay module IN
11const bool ROLE_AKTIF_LOW = true; // çoğu modül LOW ile çeker / most modules switch on LOW
12const int DHT_PIN = 4; // DHT22 veri pini / DHT22 data pin
13
14DHT dht(DHT_PIN, DHT22); // DHT11 için DHT11 yaz / write DHT11 for a DHT11
15AsyncWebServer server(80);
16AsyncWebSocket ws("/ws"); // WebSocket adresi / WebSocket path
17
18bool roleAcik = false;
19float sicaklik = NAN;
20float nem = NAN;
21volatile bool gonder = false; // loop() yayın yapsın mı? / should loop() broadcast?
22unsigned long sonOlcum = 0;
23unsigned long sonTemizlik = 0;
24
25// Tarayıcıya giden sayfa / the page sent to the browser
26const char index_html[] PROGMEM = R"rawliteral(
27<!DOCTYPE html>
28<html lang="tr">
29<head>
30<meta charset="utf-8">
31<meta name="viewport" content="width=device-width, initial-scale=1">
32<title>ESP32 Panel</title>
33<style>
34body{font-family:sans-serif;background:#0f172a;color:#e2e8f0;text-align:center;margin:0;padding:16px}
35.kart{background:#1e293b;border-radius:12px;padding:16px;margin:12px auto;max-width:320px}
36.deger{font-size:2.4em;font-weight:bold}
37button{font-size:1.2em;padding:14px 32px;border:0;border-radius:8px;color:#fff;width:100%}
38.acik{background:#16a34a}.kapali{background:#475569}
39</style>
40</head>
41<body>
42<h2>ESP32 Panel</h2>
43<p id="baglanti">Bağlanıyor / Connecting...</p>
44<div class="kart">Sıcaklık / Temperature<div class="deger"><span id="sicaklik">--</span> °C</div></div>
45<div class="kart">Nem / Humidity<div class="deger"><span id="nem">--</span> %</div></div>
46<div class="kart">Röle / Relay<p><button id="dugme" class="kapali" onclick="degistir()">KAPALI / OFF</button></p></div>
47<p>Bağlı cihaz / Clients: <span id="istemci">0</span></p>
48<script>
49let ws;
50const $ = (id) => document.getElementById(id);
51function baglan() {
52 ws = new WebSocket('ws://' + location.host + '/ws');
53 ws.onopen = () => { $('baglanti').textContent = 'Bağlı / Connected'; };
54 ws.onclose = () => {
55 $('baglanti').textContent = 'Koptu, yeniden deneniyor / Reconnecting...';
56 setTimeout(baglan, 2000);
57 };
58 ws.onmessage = (e) => {
59 const d = JSON.parse(e.data);
60 $('sicaklik').textContent = d.sicaklik === null ? '--' : d.sicaklik.toFixed(1);
61 $('nem').textContent = d.nem === null ? '--' : d.nem.toFixed(0);
62 $('istemci').textContent = d.istemci;
63 $('dugme').textContent = d.role ? 'AÇIK / ON' : 'KAPALI / OFF';
64 $('dugme').className = d.role ? 'acik' : 'kapali';
65 };
66}
67function degistir() {
68 if (ws.readyState === WebSocket.OPEN) ws.send('toggle');
69}
70baglan();
71</script>
72</body>
73</html>
74)rawliteral";
75
76void roleAyarla(bool acik) {
77 roleAcik = acik;
78 digitalWrite(ROLE_PIN, ROLE_AKTIF_LOW ? !acik : acik);
79}
80
81// Durumu JSON metnine çevir / build the state as JSON text
82String durumJson() {
83 String s = "{\"role\":";
84 s += roleAcik ? "true" : "false";
85 s += ",\"sicaklik\":";
86 s += isnan(sicaklik) ? String("null") : String(sicaklik, 1);
87 s += ",\"nem\":";
88 s += isnan(nem) ? String("null") : String(nem, 0);
89 s += ",\"istemci\":";
90 s += (unsigned long)ws.count();
91 s += "}";
92 return s;
93}
94
95// WebSocket olayları (async_tcp görevinde çalışır) / WebSocket events (run in the async_tcp task)
96void wsOlay(AsyncWebSocket *sunucu, AsyncWebSocketClient *client, AwsEventType type,
97 void *arg, uint8_t *data, size_t len) {
98 switch (type) {
99 case WS_EVT_CONNECT:
100 Serial.printf("Istemci #%u baglandi / connected: %s\n",
101 (unsigned)client->id(), client->remoteIP().toString().c_str());
102 gonder = true; // yeni gelen güncel durumu alsın / newcomer gets the state
103 break;
104 case WS_EVT_DISCONNECT:
105 Serial.printf("Istemci #%u ayrildi / disconnected\n", (unsigned)client->id());
106 gonder = true;
107 break;
108 case WS_EVT_DATA: {
109 AwsFrameInfo *info = (AwsFrameInfo *)arg;
110 // Tek parça, tam bir metin mesajı mı? / a complete single-frame text message?
111 if (info->final && info->index == 0 && info->len == len && info->opcode == WS_TEXT) {
112 if (len == 6 && memcmp(data, "toggle", 6) == 0) {
113 roleAyarla(!roleAcik);
114 gonder = true; // tüm ekranlar eşitlensin / sync every screen
115 }
116 }
117 break;
118 }
119 default: // PONG, ERROR vb. / PONG, ERROR etc.
120 break;
121 }
122}
123
124void setup() {
125 Serial.begin(115200);
126 pinMode(ROLE_PIN, OUTPUT);
127 roleAyarla(false); // açılışta röle kapalı / relay off at start
128 dht.begin();
129
130 WiFi.mode(WIFI_STA);
131 WiFi.begin(ssid, password);
132 Serial.print("Baglaniyor / connecting");
133 while (WiFi.status() != WL_CONNECTED) {
134 delay(500);
135 Serial.print(".");
136 }
137 WiFi.setSleep(false); // daha hızlı tepki / lower latency
138 Serial.println();
139 Serial.print("http://");
140 Serial.println(WiFi.localIP());
141
142 if (MDNS.begin("esp32")) { // http://esp32.local
143 MDNS.addService("http", "tcp", 80);
144 Serial.println("http://esp32.local");
145 }
146
147 ws.onEvent(wsOlay);
148 server.addHandler(&ws);
149
150 server.on("/", HTTP_GET, [](AsyncWebServerRequest *request) {
151 request->send(200, "text/html", index_html);
152 });
153 server.onNotFound([](AsyncWebServerRequest *request) {
154 request->send(404, "text/plain", "Sayfa yok / Not found");
155 });
156 server.begin();
157}
158
159void loop() {
160 if (millis() - sonOlcum >= 2000) { // DHT22 en fazla 2 sn'de bir / DHT22: once per 2 s
161 sonOlcum = millis();
162 float t = dht.readTemperature();
163 float h = dht.readHumidity();
164 if (!isnan(t) && !isnan(h)) { // hatalı okumayı atla / skip failed reads
165 sicaklik = t;
166 nem = h;
167 }
168 gonder = true;
169 }
170
171 if (gonder) {
172 gonder = false;
173 ws.textAll(durumJson()); // tüm tarayıcılara yolla / send to every browser
174 }
175
176 if (millis() - sonTemizlik >= 1000) {
177 sonTemizlik = millis();
178 ws.cleanupClients(); // kopuk istemcileri temizle / drop stale clients
179 }
180}Hoe werkt de code?
- AsyncWebSocket ws("/ws") maakt het WebSocket-eindpunt aan en server.addHandler(&ws) koppelt het aan de server. Het adres in de JavaScript moet exact met dit pad overeenkomen.
- De functie wsOlay() wordt aangeroepen bij elke verbinding, verbreking en binnenkomend bericht. WS_EVT_CONNECT betekent een nieuwe client, WS_EVT_DISCONNECT een vertrekkende client en WS_EVT_DATA een binnenkomend bericht.
- AwsFrameInfo bevat informatie over het binnenkomende frame. Door final, index == 0 en len te controleren, weet je dat het bericht compleet in één frame is aangekomen, en met WS_TEXT dat het tekst is. Korte opdrachten passen altijd in één frame.
- De binnenkomende data wordt samen met de lengte vergeleken met memcmp(), zodat je niet afhankelijk bent van een nulteken aan het einde van de data.
- Omdat de callbacks in de async_tcp-taak draaien, schakelen ze alleen het relais om en zetten ze de vlag gonder aan. Het eigenlijke versturen gebeurt in loop() met ws.textAll(), zodat elk bericht op één plek en in volgorde vertrekt.
- ws.cleanupClients() wordt één keer per seconde aangeroepen: het maakt het geheugen van weggevallen verbindingen vrij en sluit de oudste verbinding wanneer het aantal clients de limiet overschrijdt.
- Aan de JavaScript-kant maakt de onclose-gebeurtenis na 2 seconden opnieuw verbinding. Zelfs als de ESP32 herstart of de wifi even wegvalt, herstelt de pagina zichzelf. Omdat het adres uit location.host wordt opgebouwd, werkt de pagina zowel met het IP als met esp32.local.
- WiFi.setSleep(false) schakelt het wifi-energiebesparingsmodus uit. De standaard modem sleep kan vertragingen van enkele honderden milliseconden aan antwoorden toevoegen; uitschakelen op een paneel met netvoeding laat de knoppen direct aanvoelen.
JSON als berichtformaat kiezen maakt het leven makkelijk: de browser zet de binnenkomende tekst met JSON.parse() in één regel om in een object. Een voorbeeldbericht ziet er zo uit: {"role":true,"sicaklik":23.4,"nem":48,"istemci":2}. Als de sensor niet uitgelezen kan worden, wordt de waarde als null verstuurd en toont de pagina "--"; als een mislukte meting als NaN werd verstuurd, zou de ongeldige JSON ervoor zorgen dat de pagina helemaal niet meer wordt bijgewerkt. Omdat elk bericht maar ongeveer 60 bytes is, belasten zelfs meerdere updates per seconde het netwerk niet. Voor complexere berichten kun je overstappen op de ArduinoJson-bibliotheek, maar voor een paneel van dit formaat is het aan elkaar plakken van Strings ruim voldoende. Je kunt dezelfde code ook ongewijzigd proberen met een led of een buzzer in plaats van het relais.
Waar moet de HTML staan: PROGMEM of LittleFS?
In de paneelcode staat de pagina in een raw string literal geschreven als R"rawliteral( ... )rawliteral". Met deze syntaxis kun je aanhalingstekens en regeleinden gebruiken zonder escapetekens. Op AVR-gebaseerde Arduino's is PROGMEM nodig om tekst in flash in plaats van in RAM te bewaren; op de ESP32 worden constante arrays toch al uit flash gelezen, dus PROGMEM schrijf je alleen voor compatibiliteit en het kan geen kwaad. Naarmate de pagina groeit, wordt HTML bewerken in de code onhandig; dan is het netter de bestanden te verplaatsen naar het LittleFS-bestandssysteem in flash.
| Criterium | PROGMEM (in de code) | LittleFS (bestandssysteem) |
|---|---|---|
| Installatie | Geen extra stap, één bestand | Heeft een data-map en een uploadplugin nodig |
| Bewerken | HTML in een C++-array | Aparte bestanden index.html, style.css en app.js |
| Bijwerken | Je uploadt de sketch na elke wijziging opnieuw | Je uploadt alleen het bestandssysteem opnieuw |
| Grootte | Ideaal voor pagina's van een paar KB | Ongeveer 1,5 MB ruimte met de standaardpartitionering |
| Afbeeldingen en lettertypen | Niet praktisch | Pictogrammen, afbeeldingen en .gz-bestanden kunnen worden geserveerd |
| Wanneer? | Eerste tests en kleine panelen | Meerpagina's- of groeiende interfaces |
HTML-, CSS- en JavaScript-bestanden serveren met LittleFS
- Maak in de sketchmap (de map met het .ino-bestand) een map met de naam data en sla de HTML tussen R"rawliteral( en )rawliteral" uit de paneelcode op als data/index.html. Als je wilt, kun je de CSS en JavaScript in aparte bestanden splitsen.
- Arduino IDE 2 ondersteunt het oude menu ESP32 Sketch Data Upload niet. Download in plaats daarvan het .vsix-bestand van de plugin arduino-littlefs-upload en zet het in C:\Users\(jouw gebruikersnaam)\.arduinoIDE\plugins op Windows of ~/.arduinoIDE/plugins op macOS en Linux (maak de map aan als die niet bestaat), en start de IDE opnieuw. De plugin vereist IDE 2.2.1 of nieuwer.
- Sluit de Serial Monitor als die openstaat, open het commandopalet met Ctrl+Shift+P (Cmd+Shift+P op macOS) en kies Upload LittleFS to Pico/ESP8266/ESP32. De bestanden worden naar de bestandssysteempartitie in flash geschreven.
- Zorg dat onder Tools > Partition Scheme een partitieschema met een bestandssysteempartitie is gekozen (bijvoorbeeld Default 4MB with spiffs). LittleFS gebruikt deze partitie, die spiffs heet.
- Upload de onderstaande code zoals gewoonlijk. Zolang de optie Erase All Flash in het menu Tools is uitgeschakeld, wist het uploaden van een sketch het bestandssysteem niet; als je de bestanden wijzigt, hoef je alleen stap 3 te herhalen.
1#include <WiFi.h>
2#include <AsyncTCP.h>
3#include <ESPAsyncWebServer.h>
4#include <LittleFS.h>
5
6const char* ssid = "AgAdi"; // Wi-Fi adın / your Wi-Fi name
7const char* password = "Sifre123"; // Wi-Fi şifren / your Wi-Fi password
8
9AsyncWebServer server(80);
10
11void setup() {
12 Serial.begin(115200);
13
14 if (!LittleFS.begin(true)) { // true: bağlanamazsa biçimlendir / format if mount fails
15 Serial.println("LittleFS hatasi / LittleFS error");
16 return;
17 }
18
19 WiFi.mode(WIFI_STA);
20 WiFi.begin(ssid, password);
21 while (WiFi.status() != WL_CONNECTED) {
22 delay(500);
23 }
24 Serial.println(WiFi.localIP());
25
26 // data/ klasörünün içeriğini sun / serve the contents of the data/ folder
27 server.serveStatic("/", LittleFS, "/")
28 .setDefaultFile("index.html") // varsayılan index.htm'dir / default is index.htm
29 .setCacheControl("max-age=600"); // tarayıcı 10 dk önbelleğe alsın / cache for 10 min
30
31 server.onNotFound([](AsyncWebServerRequest *request) {
32 request->send(404, "text/plain", "Sayfa yok / Not found");
33 });
34 server.begin();
35}
36
37void loop() {
38}mDNS: esp32.local in plaats van een IP-adres
Je router kan de ESP32 elke keer bij het opstarten een ander IP-adres geven en getallen als 192.168.1.47 zijn lastig te onthouden. Met mDNS (multicast DNS) kan een apparaat zijn eigen naam op het lokale netwerk bekendmaken. Dankzij de regel MDNS.begin("esp32") in de paneelcode kunnen apparaten op hetzelfde netwerk de pagina openen op http://esp32.local, en MDNS.addService("http", "tcp", 80) vertelt netwerkbrowser-apps dat hier een webserver is. Voeg geen ".local" aan de naam toe en gebruik alleen kleine letters, cijfers en koppeltekens. Als je meerdere ESP32's gebruikt, geef ze dan elk een andere naam (keuken, woonkamer enzovoort), want twee apparaten met dezelfde naam storen elkaar. mDNS wordt niet op elk systeem even goed ondersteund:
| Systeem | .local-ondersteuning | Als het niet werkt |
|---|---|---|
| iPhone, iPad, macOS | Ingebouwd (Bonjour) | Controleer of je op hetzelfde wifinetwerk zit |
| Windows 10 en 11 | Werkt meestal op up-to-date versies | Installeer de Bonjour-service of gebruik het IP |
| Linux | Werkt als avahi-daemon is geïnstalleerd | Installeer de pakketten avahi-daemon en nss-mdns |
| Android | Hangt af van de versie en de browser | Gebruik het IP-adres of stel een DHCP-reservering in op de router |
Meerdere clients: telefoon, tablet en computer tegelijk
Het fijnste aan WebSocket is dat iedereen die het paneel opent dezelfde status ziet. Als je het relais vanaf je telefoon inschakelt, stuurt de ESP32 de nieuwe status met textAll() naar elke verbinding, en het tabblad op je computer wordt op hetzelfde moment groen. Elk tabblad is een aparte client: open drie tabbladen in dezelfde browser en de teller toont 3. Standaard staat de bibliotheek 8 gelijktijdige WebSocket-clients toe op de ESP32 en 4 op de ESP8266 (DEFAULT_MAX_WS_CLIENTS). Deze limiet wordt niet automatisch afgedwongen; wanneer cleanupClients() wordt aangeroepen, wordt de oudste verbinding boven de limiet gesloten. Hier is waar je verder op moet letten:
- Als een telefoon in slaap valt: een telefoon waarvan het scherm uitgaat, sluit de verbinding mogelijk niet netjes. Zulke half geopende verbindingen worden na verloop van tijd opgeruimd dankzij cleanupClients() en regelmatig versturen van data.
- Verzendsnelheid: per client kunnen maximaal 32 berichten in de wachtrij staan (8 op de ESP8266). Als je textAll() bij elke ronde van loop() aanroept, loopt de wachtrij vol en worden nieuwe berichten stilletjes weggegooid; stel Tools > Core Debug Level in op Warn of een gedetailleerder niveau en je ziet de waarschuwing Too many messages queued in de Serial Monitor. Verstuur een waarde alleen als hij verandert, of een paar keer per seconde.
- Een nieuw verbonden client: stuur de huidige status meteen naar elke pagina die verbindt; anders staart de gebruiker naar een leeg paneel tot de eerste meting. In de paneelcode doet de vlag die in WS_EVT_CONNECT wordt gezet dit.
- Antwoorden aan één client: om alleen de browser te antwoorden die vroeg in plaats van iedereen, gebruik je client->text("..."); client->id() geeft je het nummer van de client.
- Geheugen: elke open verbinding houdt een TCP-socket en buffergeheugen vast. De 520 KB RAM van de ESP32 is ruim voldoende voor een paar clients, maar af en toe het vrije geheugen printen met ESP.getFreeHeap() helpt je geheugenlekken vroeg te ontdekken.
Eenvoudige wachtwoordbeveiliging
Iedereen op je thuisnetwerk die het adres van het paneel kent, kan het relais schakelen. Met de functies request->authenticate() en request->requestAuthentication() van de bibliotheek kun je een gebruikersnaam en wachtwoord op de pagina zetten; de browser opent zijn eigen inlogvenster en onthoudt de gegevens voor de sessie. De standaardmethode is Digest-authenticatie, wat betekent dat het wachtwoord niet als leesbare tekst over het netwerk gaat. Alleen de pagina beveiligen is echter niet genoeg: het WebSocket-adres is een aparte deur en iemand kan rechtstreeks verbinden met ws://ip/ws. Het onderstaande voorbeeld sluit ook die deur: bij elke start genereert de ESP32 een willekeurige sleutel, geeft die alleen aan een ingelogde browser op /anahtar en gebruikt setFilter() om WebSocket-verbindingen te weigeren die niet de juiste sleutel meebrengen.
1#include <WiFi.h>
2#include <AsyncTCP.h>
3#include <ESPAsyncWebServer.h>
4
5const char* ssid = "AgAdi"; // Wi-Fi adın / your Wi-Fi name
6const char* password = "Sifre123"; // Wi-Fi şifren / your Wi-Fi password
7const char* KULLANICI = "admin"; // panel kullanıcı adı / panel username
8const char* PAROLA = "Gizli-2026"; // panel parolası / panel password
9const int LED_PIN = 2;
10
11AsyncWebServer server(80);
12AsyncWebSocket ws("/ws");
13String wsAnahtar; // her açılışta yeni anahtar / a new key on every boot
14bool ledAcik = false;
15
16const char index_html[] PROGMEM = R"rawliteral(
17<!DOCTYPE html>
18<html><head><meta charset="utf-8">
19<meta name="viewport" content="width=device-width, initial-scale=1"></head>
20<body style="font-family:sans-serif;text-align:center">
21<h2>Korumali panel / Protected panel</h2>
22<button style="font-size:1.4em;padding:12px 32px" onclick="ws && ws.send('toggle')">LED</button>
23<p id="durum">...</p>
24<script>
25let ws;
26fetch('/anahtar').then(r => r.text()).then(k => {
27 ws = new WebSocket('ws://' + location.host + '/ws?k=' + k);
28 ws.onmessage = (e) => { document.getElementById('durum').textContent = e.data; };
29});
30</script>
31</body></html>
32)rawliteral";
33
34bool girisVar(AsyncWebServerRequest *request) {
35 return request->authenticate(KULLANICI, PAROLA);
36}
37
38void setup() {
39 Serial.begin(115200);
40 pinMode(LED_PIN, OUTPUT);
41
42 WiFi.mode(WIFI_STA);
43 WiFi.begin(ssid, password);
44 while (WiFi.status() != WL_CONNECTED) {
45 delay(500);
46 }
47 Serial.println(WiFi.localIP());
48
49 // Wi-Fi açıkken random() donanım üretecini kullanır / random() uses the hardware RNG
50 wsAnahtar = String(random(0x7FFFFFFF), HEX) + String(random(0x7FFFFFFF), HEX);
51
52 // Sayfa: tarayıcı kullanıcı adı ve parola sorar / page: the browser asks for login
53 server.on("/", HTTP_GET, [](AsyncWebServerRequest *request) {
54 if (!girisVar(request)) return request->requestAuthentication();
55 request->send(200, "text/html", index_html);
56 });
57
58 // Anahtar yalnız giriş yapana verilir / the key is given only after login
59 server.on("/anahtar", HTTP_GET, [](AsyncWebServerRequest *request) {
60 if (!girisVar(request)) return request->requestAuthentication();
61 request->send(200, "text/plain", wsAnahtar);
62 });
63
64 // Doğru anahtarı getirmeyen bağlantıyı reddet / reject sockets without the right key
65 ws.setFilter([](AsyncWebServerRequest *request) {
66 return request->hasParam("k") && request->getParam("k")->value() == wsAnahtar;
67 });
68
69 ws.onEvent([](AsyncWebSocket *sunucu, AsyncWebSocketClient *client, AwsEventType type,
70 void *arg, uint8_t *data, size_t len) {
71 if (type == WS_EVT_DATA && len == 6 && memcmp(data, "toggle", 6) == 0) {
72 ledAcik = !ledAcik;
73 digitalWrite(LED_PIN, ledAcik ? HIGH : LOW);
74 sunucu->textAll(ledAcik ? "LED: ON" : "LED: OFF");
75 }
76 });
77
78 server.addHandler(&ws);
79 server.begin();
80}
81
82void loop() {
83 ws.cleanupClients(); // saniyede bir yeterli / once per second is enough
84 delay(1000);
85}Opmerkingen voor de ESP8266 en Raspberry Pi Pico W
Dezelfde bibliotheek draait ook op de ESP8266 (NodeMCU, Wemos D1 mini). Dit moet je aanpassen: installeer de bibliotheek ESP Async TCP van ESP32Async in plaats van Async TCP; include ESP8266WiFi.h in plaats van WiFi.h, ESPAsyncTCP.h in plaats van AsyncTCP.h en ESP8266mDNS.h in plaats van ESPmDNS.h, en voeg de regel MDNS.update() toe in loop(). Vervang WiFi.setSleep(false) door WiFi.setSleepMode(WIFI_NONE_SLEEP) en stel de pins in volgens de NodeMCU-kolom van de bedradingstabel. De ESP8266 heeft maar ongeveer 80 KB bruikbaar RAM, dus houd de pagina klein en bedenk dat de clientlimiet 4 is. Als je een Raspberry Pi Pico W gebruikt, lees je in de gids Raspberry Pi Pico W wifi hoe je een webserver met MicroPython bouwt; nieuwere versies van ESPAsyncWebServer ondersteunen aan de Arduino-kant ook de chips RP2040 en RP2350.
Projectideeën voor een ESP32-webserver
- Slim stopcontact met meerdere kanalen: gebruik een relaisboard met 4 kanalen om aparte knoppen te maken voor een lamp, een ventilator en een stopcontact; onderscheid de opdrachten met korte teksten zoals "r1" en "r2". Voor het kiezen van een relais zie het artikel over de relaismodule.
- Plantenbewateringspaneel: toon de waarde van de bodemvochtsensor live, stel de bewateringsdrempel in met een schuifregelaar op de pagina en laat de pomp met de hand draaien wanneer je wilt.
- Weerstation: gebruik een BME280 in plaats van de DHT22 om luchtdruk toe te voegen, en toon de laatste 60 metingen in een kleine lijngrafiek op de pagina.
- Lamp met kleurkiezer: stuur de waarde van een kleurkiezer op de pagina via WebSocket en kleur een WS2812B NeoPixel-strip direct.
- Servo op een schuifregelaar: stuur bij elke beweging de waarde van de schuifregelaar en draai een servomotor; ideaal om een camera of een deurgrendel te richten.
- Logging met tijdstempel: voeg de tijd via NTP toe aan elke meting en werk je code draadloos bij via OTA in plaats van elke keer via USB.
Veelvoorkomende fouten en oplossingen
| Symptoom | Oorzaak | Oplossing |
|---|---|---|
| 'mbedtls_md5_starts_ret' was not declared in this scope | Oude me-no-dev-bibliotheek met ESP32-core 3.x | Installeer ESP Async WebServer en Async TCP van ESP32Async, verwijder de oude mappen |
| Multiple libraries were found for "AsyncTCP.h" | Twee kopieën van dezelfde bibliotheek | Verwijder de oude -master-kopieën in de libraries-map |
| Deprecated-waarschuwing voor send_P | send_P wordt in de nieuwe versie verwijderd | Gebruik request->send(200, "text/html", index_html) |
| De pagina opent helemaal niet | Telefoon op een gastnetwerk of mobiele data, of het IP-adres is veranderd | Verbind met hetzelfde wifinetwerk en gebruik het actuele IP uit de Serial Monitor |
| De pagina opent, maar de waarden blijven op -- | WebSocket kon niet verbinden: ander pad of addHandler vergeten | Open de F12-console en vergelijk ws("/ws") met het adres in de JavaScript |
| Task watchdog got triggered met async_tcp | delay(), een lange lus of een HTTP-verzoek in een callback | Houd de callback kort en verplaats het werk met een vlag naar loop() |
| Too many messages queued | textAll() wordt te vaak aangeroepen | Verstuur alleen bij verandering, of een paar keer per seconde |
| De LittleFS-pagina geeft 404 | data-map niet geüpload of setDefaultFile ontbreekt | Upload de bestanden met de plugin en voeg setDefaultFile("index.html") toe |
| does not exist, no permits for creation in de Serial Monitor | Het gevraagde bestand staat niet in LittleFS | Controleer de bestandsnaam en de hoofd- en kleine letters; regels die .gz noemen zijn onschadelijk |
| Het relais schakelt nooit uit | De 5V-module herkent een 3,3V-HIGH niet | Gebruik een 3,3V-compatibele module, JD-VCC of een transistor |
| De ESP32 reset als het relais klikt | De spoelstroom trekt de voeding omlaag (brownout) | Gebruik een stevige 5V-adapter en een condensator van 470 µF |
| esp32.local opent niet | Het apparaat ondersteunt geen mDNS of de naam is met .local geschreven | Schrijf MDNS.begin("esp32") en gebruik zo nodig het IP-adres |
| De knop reageert laat | De modem sleep van de wifi staat aan | Roep WiFi.setSleep(false) aan na het verbinden |
De combinatie van een ESP32 async webserver en WebSocket is de kortste weg naar een snel bedieningspaneel dat werkt zonder cloudservice of telefoon-app en dat meerdere apparaten kunnen delen. Begin met het PROGMEM-paneel in één bestand, stap over op LittleFS naarmate de interface groeit en geef elk nieuw apparaat op je netwerk een eigen mDNS-naam. Ben je nieuw met de ESP32, dan vind je de basis in Wat is de ESP32? In de BlueGrays-app kun je ook ESP32-projecten zoals een async webserver, een WebSocket-teller, mDNS-toegang, een NTP-klok en OTA-updates stap voor stap verkennen, met schakelschema's en kant-en-klare code.
Veelgestelde vragen
Wat is het verschil tussen ESPAsyncWebServer en WebServer op de ESP32?
De WebServer-bibliotheek handelt verzoeken één voor één af via de aanroep handleClient() in loop(); als loop() trager wordt, wordt de pagina dat ook. ESPAsyncWebServer handelt verzoeken af in een aparte achtergrondtaak, kan meerdere verbindingen tegelijk aan en heeft ingebouwde ondersteuning voor WebSocket en SSE. Voor realtimepanelen past de asynchrone versie beter.
Hoeveel clients kunnen tegelijk verbinden met een ESP32-webserver?
Standaard staat ESPAsyncWebServer 8 WebSocket-clients toe op de ESP32 en sluit het de extra clients wanneer cleanupClients() wordt aangeroepen; op de ESP8266 is de limiet 4. Omdat gewone paginaverzoeken kort zijn, kunnen meer apparaten de pagina na elkaar openen. In de praktijk draaien 3–5 gelijktijdige apparaten soepel op een thuispaneel.
Kan ik mijn ESP32-webserver vanaf internet bereiken?
Technisch kan het met portforwarding op je router, maar het wordt afgeraden: de bibliotheek biedt op de ESP32 geen HTTPS en het apparaat blijft blootgesteld aan aanvallen vanaf internet. Voor bediening op afstand is een Telegram-bot, een MQTT-systeem of de vpn-functie van je router veel veiliger.
Waarom werkt esp32.local niet?
De meest voorkomende reden is dat de telefoon of computer mDNS-namen niet kan omzetten; dat gebeurt vooral op sommige Android-telefoons en oudere Windows-versies. MDNS.begin("esp32.local") in de code schrijven is ook een fout, want je moet de naam zonder .local opgeven. Als de naam nog steeds niet wordt omgezet, gebruik dan het IP-adres uit de Serial Monitor of reserveer een vast IP voor de ESP32 op je router.
Kan een ESP32-webserver zonder router werken?
Ja. Met WiFi.softAP("ESP32-Panel", "12345678") maakt de ESP32 een eigen wifinetwerk; verbind je telefoon ermee en open 192.168.4.1 in de browser. In deze accesspointmodus is er geen internet, maar het paneel en WebSocket werken precies hetzelfde. Het netwerkwachtwoord moet minstens 8 tekens lang zijn.
Welke ESPAsyncWebServer-bibliotheek moet ik installeren?
Installeer in de Arduino Library Manager de bibliotheken ESP Async WebServer en Async TCP met als auteur ESP32Async. De oorspronkelijke versie op het account me-no-dev wordt niet meer onderhouden en compileert niet met ESP32-core 3.x. Verwijder ook oude kopieën die vanuit een ZIP zijn toegevoegd uit je libraries-map.
Projecten om hierna te bouwen
Alle projecten bekijken
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 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/.

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 DHT22 temperatuur en luchtvochtigheid (met LCD)
Dit project meet de omgevingstemperatuur en luchtvochtigheid met een DHT22-sensor en toont de gegevens in realtime op een 16x2 I2C-LCD. De data wordt met het one-wire-protocol via de Adafruit DHT-bibliotheek uit de sensor gelezen. Dit project is de basis voor IoT-weerstations, slimme domotica of omgevingsbewaking in kassen. De communicatie met de DHT22 loopt via pin GPIO 4 van de ESP32.

ESP32 slimme verlichting (PIR + LDR + relais + OLED)
Met een ESP32, een PIR-bewegingssensor, een LDR-lichtsensor en een relaismodule maak je van je gang, toilet of bijkeuken slimme verlichting. Is het al licht in de ruimte, dan blijft het licht uit, ook bij beweging, zodat overdag geen energie wordt verspild. Het licht blijft 30 seconden aan en de tijd verlengt automatisch zolang er beweging is.

ESP32 OTA-update: firmware draadloos installeren (met lcd-scherm)
In dit project leer je nieuwe firmware naar de ESP32 te uploaden via wifi, zonder USB-kabel. Met de ArduinoOTA-bibliotheek wordt de ESP32 zichtbaar op het netwerk en verschijnt hij automatisch als bluegrays-ota onder "Network port" in de Arduino IDE. De eerste upload gaat via USB; daarna zijn alle updates draadloos, een belangrijke functie voor apparaten die op afstand hangen.

Echte tijd van internet met ESP32 en NTP
De ESP32 verbindt met Wi-Fi en haalt met milliseconde-precisie de echte tijd op bij NTP-servers (Network Time Protocol). configTzTime() past de Turkse tijdzone (TRT, UTC+3) automatisch toe, en in landen met zomertijd wordt de overgang naar zomertijd (DST) geregeld met een POSIX TZ-string. De tijd wordt zowel naar de Serial Monitor als naar een optioneel I2C-lcd gestuurd.
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

