Gidsen · 16 min leestijd

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.

ESP32-developmentboard voor een webserverproject
ESP32 DevKit: dankzij de wifichip draait er zelfstandig een webserver op; het paneel dat je op je telefoon opent, komt rechtstreeks uit het flashgeheugen van dit board.

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.

EigenschapWebServer.h (synchroon)ESPAsyncWebServer (asynchroon)
InstallatieZit bij de ESP32-core2 bibliotheken uit de Library Manager
Verzoeken afhandelenEén voor één via handleClient() in loop()In de achtergrondtaak async_tcp, meerdere tegelijk
delay() in loop()Vertraagt het antwoord van de paginaHeeft geen invloed op de server
WebSocketGeen; je hebt een aparte bibliotheek nodig (bijv. de WebSockets-bibliotheek van Markus Sattler)Ingebouwd (AsyncWebSocket)
Server-Sent EventsGeenIngebouwd (AsyncEventSource)
Statische bestanden serverenMet serveStaticserveStatic, automatische .gz-ondersteuning en cachebeheer
Let opHet makkelijkst te lerenGeen 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:

MethodeWerkingLatentie en overheadWanneer gebruiken
Pagina vernieuwen (meta refresh)De browser downloadt om de paar seconden de hele pagina opnieuwHoog; de pagina flikkert elke keerVermijd het
Polling met fetchJavaScript vraagt elke 1–2 seconden een kleine JSON opGemiddeld; elk verzoek draagt nieuwe headersEén waarde die zelden verandert
Server-Sent Events (SSE)De server pusht eenrichtingsgebeurtenissen over een open verbindingLaag; alleen van server naar browserDashboards die alleen monitoren
WebSocketTweerichtingsberichten over een open verbindingLaagste; frames van een paar bytesKnoppen, schuifregelaars en live data samen

Benodigde bibliotheken: ESPAsyncWebServer en AsyncTCP installeren

  1. Zorg dat het ESP32-boardpakket (Espressif Systems) in de Arduino IDE is geïnstalleerd; de installatiestappen staan in Wat is de ESP32?
  2. Open de Library Manager (Ctrl+Shift+I) en zoek naar ESPAsyncWebServer. Installeer de bibliotheek ESP Async WebServer met als auteur ESP32Async.
  3. 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.
  4. 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.
  5. 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.
De meeste oudere tutorials op internet verwijzen naar de originele ESPAsyncWebServer-bibliotheek op het account me-no-dev. Die bibliotheek wordt niet meer onderhouden en compileert niet met versie 3.x van de ESP32-core; de build stopt met de fout 'mbedtls_md5_starts_ret' was not declared in this scope. De oplossing is de oude kopie te verwijderen en de ESP32Async-versies te installeren. In de nieuwe versie is ook send_P() verouderd: op de ESP32 kun je een PROGMEM-array rechtstreeks versturen met request->send(200, "text/html", index_html).

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.

C++ (Arduino IDE)
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}
OpdrachtWat 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
Een lege loop() is geen fout; de server draait in een eigen taak. Gebruik juist geen delay(), lange while-lussen of verzoeken die gegevens van internet ophalen in callbacks. De async_tcp-taak loopt dan vast en een paar seconden later herstart de ESP32 met de melding Task watchdog got triggered. Geef lange taken met een vlagvariabele door aan loop() en doe je timing met millis().

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.

ModulepinESP32 DevKitESP8266 NodeMCUOpmerking
Relais VCCVIN (5 V)VIN of VU (5 V)De relaisspoel heeft 5 V nodig; wordt gevoed via USB
Relais GNDGNDGNDGemeenschappelijke massa
Relais INGPIO 26D1 (GPIO 5)De meeste modules schakelen in met een LOW-signaal
DHT22 VCC (+)3V33V3Gevoed met 3,3 V, dus de datalijn is ook 3,3 V
DHT22 DATA (OUT)GPIO 4D2 (GPIO 4)Losse sensor: weerstand van 10 kΩ tussen DATA en VCC
DHT22 GND (−)GNDGNDGemeenschappelijke massa
De pins van de ESP32 leveren 3,3 V. Sommige 5V-relaismodules herkennen dit niveau niet als HIGH, waardoor het relais nooit loslaat; gebruik bij zo'n module een 3,3V-compatibel relais, een module met een JD-VCC-jumper of een transistor ertussen. Als je met het relais netspanning (230 V) wilt schakelen, bedraad het dan met de stroom uit, laat geen schroefklemmen onbedekt en test bij twijfel eerst met een laagspanningsbelasting (een ledstrip of een 12V-ventilator). Details staan in Wat is een relaismodule?

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.

C++ (Arduino IDE)
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> &deg;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.

CriteriumPROGMEM (in de code)LittleFS (bestandssysteem)
InstallatieGeen extra stap, één bestandHeeft een data-map en een uploadplugin nodig
BewerkenHTML in een C++-arrayAparte bestanden index.html, style.css en app.js
BijwerkenJe uploadt de sketch na elke wijziging opnieuwJe uploadt alleen het bestandssysteem opnieuw
GrootteIdeaal voor pagina's van een paar KBOngeveer 1,5 MB ruimte met de standaardpartitionering
Afbeeldingen en lettertypenNiet praktischPictogrammen, afbeeldingen en .gz-bestanden kunnen worden geserveerd
Wanneer?Eerste tests en kleine panelenMeerpagina's- of groeiende interfaces

HTML-, CSS- en JavaScript-bestanden serveren met LittleFS

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
C++ (Arduino IDE)
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}
Als een bestand wordt opgevraagd, zoekt serveStatic() eerst naar een gecomprimeerde versie met dezelfde naam en de extensie .gz. Als je index.html met gzip comprimeert en uploadt als index.html.gz, krimpt de pagina meestal tot een derde à een kwart van de grootte en laadt hij sneller. Bij een verzoek om een mapadres is de standaardbestandsnaam index.htm, dus vergeet de regel setDefaultFile("index.html") niet. Als je de sjabloonfunctie van de bibliotheek gebruikt, worden plaatshouders zoals %DEGER% in de pagina vervangen; dan moet je procenttekens in je CSS, zoals width:100%, als %% schrijven.

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-ondersteuningAls het niet werkt
iPhone, iPad, macOSIngebouwd (Bonjour)Controleer of je op hetzelfde wifinetwerk zit
Windows 10 en 11Werkt meestal op up-to-date versiesInstalleer de Bonjour-service of gebruik het IP
LinuxWerkt als avahi-daemon is geïnstalleerdInstalleer de pakketten avahi-daemon en nss-mdns
AndroidHangt af van de versie en de browserGebruik 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.

C++ (Arduino IDE)
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}
Deze beveiliging is een goed genoeg slot voor een thuisnetwerk, maar het is geen versleuteling: ESPAsyncWebServer biedt op de ESP32 geen HTTPS en WebSocket-berichten reizen als leesbare tekst. Omdat het wachtwoord in de code staat, moet je eraan denken het te verwijderen voordat je je code deelt. Open het paneel niet naar internet met portforwarding op je router; voor bediening op afstand zijn een ESP32 Telegram-bot, MQTT en Home Assistant of de vpn-functie van je router veel veiliger. In nieuwere versies van de bibliotheek kun je hetzelfde doen met de klasse AsyncAuthenticationMiddleware.

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

SymptoomOorzaakOplossing
'mbedtls_md5_starts_ret' was not declared in this scopeOude me-no-dev-bibliotheek met ESP32-core 3.xInstalleer ESP Async WebServer en Async TCP van ESP32Async, verwijder de oude mappen
Multiple libraries were found for "AsyncTCP.h"Twee kopieën van dezelfde bibliotheekVerwijder de oude -master-kopieën in de libraries-map
Deprecated-waarschuwing voor send_Psend_P wordt in de nieuwe versie verwijderdGebruik request->send(200, "text/html", index_html)
De pagina opent helemaal nietTelefoon op een gastnetwerk of mobiele data, of het IP-adres is veranderdVerbind 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 vergetenOpen de F12-console en vergelijk ws("/ws") met het adres in de JavaScript
Task watchdog got triggered met async_tcpdelay(), een lange lus of een HTTP-verzoek in een callbackHoud de callback kort en verplaats het werk met een vlag naar loop()
Too many messages queuedtextAll() wordt te vaak aangeroepenVerstuur alleen bij verandering, of een paar keer per seconde
De LittleFS-pagina geeft 404data-map niet geüpload of setDefaultFile ontbreektUpload de bestanden met de plugin en voeg setDefaultFile("index.html") toe
does not exist, no permits for creation in de Serial MonitorHet gevraagde bestand staat niet in LittleFSControleer de bestandsnaam en de hoofd- en kleine letters; regels die .gz noemen zijn onschadelijk
Het relais schakelt nooit uitDe 5V-module herkent een 3,3V-HIGH nietGebruik een 3,3V-compatibele module, JD-VCC of een transistor
De ESP32 reset als het relais kliktDe spoelstroom trekt de voeding omlaag (brownout)Gebruik een stevige 5V-adapter en een condensator van 470 µF
esp32.local opent nietHet apparaat ondersteunt geen mDNS of de naam is met .local geschrevenSchrijf MDNS.begin("esp32") en gebruik zo nodig het IP-adres
De knop reageert laatDe modem sleep van de wifi staat aanRoep WiFi.setSleep(false) aan na het verbinden
Als iets niet werkt, open dan de ontwikkelaarstools van je browser met F12. Het tabblad Console toont fouten zoals WebSocket connection to 'ws://192.168.1.50/ws' failed; klik in het tabblad Network op de WebSocket-verbinding en het gedeelte Messages toont elk bericht dat binnenkomt en vertrekt. Aan de ESP32-kant zie je binnen enkele seconden of het probleem in de browser of op het board zit als je clients naar de Serial Monitor print wanneer ze verbinden en vertrekken. Als het board herstart op het moment dat het relais klikt, lees dan de gids ESP32 brownout.

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.

Alle projecten bekijken
ESP32 asynchrone webserver (met IP-weergave op lcd)
ES-27Gevorderd

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.

4.8(16)
26
ESP32 WebSocket-teller (2 knoppen + lcd + realtime web)
ES-28Gevorderd
Premium

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.

4.5(14)
23
ESP32 mDNS: het apparaat bereiken via bluegrays-esp.local (met lcd-scherm)
ES-29Gevorderd
Premium

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

4.8(14)
23
ESP32 Wi-Fi-verbinding in STA-modus (met lcd-scherm)
ES-25Gevorderd

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.

4.4(21)
38
ESP32 DHT22 temperatuur en luchtvochtigheid (met LCD)
ES-15Gemiddeld

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.

4.8(38)
57
ESP32 slimme verlichting (PIR + LDR + relais + OLED)
ES-37Gevorderd
Premium

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.

4.3(6)
11
ESP32 OTA-update: firmware draadloos installeren (met lcd-scherm)
ES-30Gevorderd
Premium

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.

4.6(14)
22
Echte tijd van internet met ESP32 en NTP
ES-26Gevorderd
Premium

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.

4.5(13)
22