ESP32 OTA-update: code draadloos uploaden met ArduinoOTA
Met ESP32 OTA upload je code via wifi zonder USB-kabel: ArduinoOTA-netwerkpoort, ElegantOTA-webpagina, wachtwoord, partitieschema en onderbroken uploads.
ESP32 OTA (Over-The-Air-update) betekent dat je nieuwe code via wifi naar je board uploadt in plaats van een USB-kabel aan te sluiten. Stel je een sensor voor die aan het plafond hangt, een beregeningscomputer in de tuin of een relaisboard in een meterkast: in plaats van een ladder te pakken, het board los te halen en bij elke kleine aanpassing op je computer aan te sluiten, stuur je de nieuwe versie in een paar seconden vanuit de Arduino IDE of een browser. Het board schrijft het nieuwe programma op de achtergrond in zijn geheugen, controleert het en start zichzelf opnieuw op.
In deze gids leer je stap voor stap hoe OTA in de ESP32 werkt, drie verschillende methoden (ArduinoOTA voor de Arduino IDE, ElegantOTA voor de browser en HTTPUpdate om van een server op te halen), hoe je het juiste partitieschema kiest, hoe je uploads met een wachtwoord beveiligt, wat er gebeurt als een upload wordt onderbroken en hoe je voorkomt dat je OTA in je volgende sketch kwijtraakt. Alle code is gecompileerd en getest met de ESP32 Arduino-core.

Wat is ESP32 OTA en hoe werkt het?
Het flashgeheugen van de ESP32 is geen enkel blok; het is met een kaart, de partitietabel, in stukken verdeeld. Een partitietabel die OTA ondersteunt, heeft twee identieke gebieden voor het programma: app0 (ota_0) en app1 (ota_1). Terwijl het board vanuit het ene gebied draait, wordt het nieuwe programma in het andere geschreven. Een kleine otadata-partitie slaat op welk gebied bij de volgende start wordt uitgevoerd. Zo wordt het draaiende programma tijdens de upload nooit aangeraakt, en geeft het board het oude programma pas op als de nieuwe code volledig is geschreven en gecontroleerd.
- Het nieuwe programma (het gecompileerde .bin-bestand) komt stukje voor stukje via wifi bij het board aan.
- De ESP32 schrijft elk stukje naar de programmapartitie die op dat moment niet in gebruik is; de draaiende code blijft intussen gewoon zijn werk doen.
- Zodra het hele bestand binnen is, worden de image-header en de checksum gecontroleerd; een beschadigd of onvolledig bestand wordt geweigerd.
- Als de controle slaagt, wordt otadata bijgewerkt: de nieuwe partitie wordt bij de volgende start uitgevoerd.
- Het board start opnieuw op met het nieuwe programma. De volgende update gaat naar de andere partitie; de twee gebieden worden om beurten gebruikt.
| Methode | Vanaf waar stuur je de code? | Meest geschikt voor | Extra bibliotheek |
|---|---|---|---|
| ArduinoOTA | Vanaf de netwerkpoort in de Arduino IDE | Ontwikkelen aan je bureau, op hetzelfde netwerk | Geen (zit in de core) |
| ElegantOTA | Door in de browser op de pagina /update een .bin te kiezen | Iemand zonder IDE laten updaten, uploaden vanaf een telefoon | ElegantOTA |
| HTTPUpdate | Het board downloadt zelf een .bin-bestand van een server | Veel apparaten, apparaten op afstand, automatische updates | Geen (zit in de core) |
Partitieschema en flashgrootte
Dit is de meest over het hoofd geziene eis van OTA: er moet een tweede vrij gebied zijn om het nieuwe programma in te schrijven. Daarom is het grootste programma dat je via OTA kunt uploaden kleiner dan de helft van de flash. Je kiest de partitietabel in de Arduino IDE onder Tools › Partition Scheme. Op de gangbare ESP32 DevKit-boards met 4 MB flash (ESP32 Dev Module) zijn de opties:
| Partition Scheme | Programmagebied | OTA | Bestandssysteem (SPIFFS/LittleFS) |
|---|---|---|---|
| Default 4MB with spiffs | 2 × 1,25 MB (1.310.720 bytes) | Ja | 1,375 MB |
| Minimal SPIFFS (1.9MB APP with OTA) | 2 × 1,875 MB (1.966.080 bytes) | Ja | 128 KB |
| No OTA (2MB APP/2MB SPIFFS) | 1 × 2 MB | Nee | 1,875 MB |
| Huge APP (3MB No OTA/1MB SPIFFS) | 1 × 3 MB | Nee | 896 KB |
| Minimal (1.3MB APP/700KB SPIFFS) | 1 × 1,25 MB (voor boards met 2 MB flash) | Nee | 640 KB |
Hoeveel ruimte je programma inneemt, zie je in de compileruitvoer: ons eerste voorbeeld met wifi en ArduinoOTA geeft "Sketch uses 758685 bytes (57%) ... Maximum is 1310720 bytes". Het maximum is hier de grootte van één programmagebied in het gekozen schema. Komt het gebruik boven 90%, dan moet je binnenkort naar Minimal SPIFFS. Nog een belangrijke regel: de partitietabel kan niet via OTA worden gewijzigd. Heb je het schema veranderd, dan moet die upload via USB; latere OTA-updates werken met de nieuwe tabel. Op boards met 8 MB of 16 MB flash (zoals veel ESP32-S3-modellen) krijg je veel grotere OTA-gebieden door in het menu Flash Size de juiste grootte te kiezen.
Wil je zien vanuit welke partitie je board werkelijk draait en hoeveel ruimte er voor OTA over is, upload dan de kleine sketch hieronder. Hij heeft geen bibliotheek nodig en gebruikt direct de OTA-functies van ESP-IDF:
1#include <esp_ota_ops.h>
2
3void setup() {
4 Serial.begin(115200);
5 delay(1000);
6 const esp_partition_t* running = esp_ota_get_running_partition();
7 const esp_partition_t* next = esp_ota_get_next_update_partition(NULL);
8
9 Serial.printf("Flash boyutu / Flash size: %u KB\n", ESP.getFlashChipSize() / 1024);
10 Serial.printf("Program boyutu / Sketch size: %u KB\n", ESP.getSketchSize() / 1024);
11 Serial.printf("OTA icin bos alan / Free space for OTA: %u KB\n", ESP.getFreeSketchSpace() / 1024);
12 Serial.printf("Calisan bolum / Running partition: %s (0x%06x)\n", running->label, running->address);
13 if (next != NULL) {
14 Serial.printf("Siradaki OTA bolumu / Next OTA partition: %s (0x%06x)\n", next->label, next->address);
15 } else {
16 Serial.println("OTA bolumu yok: bolum tablosunu degistir / No OTA partition: change the partition scheme");
17 }
18}
19
20void loop() {
21}Met het standaardschema staat er na de eerste USB-upload "Running partition: app0 (0x010000)" en "Next OTA partition: app1 (0x150000)". Voer de code na een OTA-update opnieuw uit en je ziet dat hij nu vanuit app1 draait. De waarde van ESP.getFreeSketchSpace() is de grootte van het grootste programma dat je via OTA kunt uploaden; is je nieuwe .bin-bestand groter, dan start de update niet.
Methode 1: draadloos uploaden vanuit de Arduino IDE met ArduinoOTA
De ArduinoOTA-bibliotheek zit in de ESP32-core, dus er is niets te installeren. Zodra het board op het netwerk komt, meldt het zich via mDNS aan; de Arduino IDE ziet dat en voegt een netwerkpoort toe aan het menu Port. Als je op Upload drukt, stuurt de IDE het programma via die netwerkpoort in plaats van via USB. Op de ESP32 luistert de OTA-service standaard op poort 3232. De sketch hieronder maakt verbinding met wifi, start OTA met een wachtwoord en laat als bewijs de ingebouwde led knipperen:
1#include <WiFi.h>
2#include <ArduinoOTA.h>
3
4const char* WIFI_SSID = "AgAdi"; // Wi-Fi adın / your Wi-Fi name
5const char* WIFI_PASS = "AgSifresi"; // Wi-Fi şifren / your Wi-Fi password
6const int LED_PIN = 2; // çoğu DevKit'te dahili LED / onboard LED on most DevKits
7
8unsigned long lastBlink = 0;
9
10void setup() {
11 Serial.begin(115200);
12 pinMode(LED_PIN, OUTPUT);
13
14 WiFi.mode(WIFI_STA);
15 WiFi.begin(WIFI_SSID, WIFI_PASS);
16 while (WiFi.status() != WL_CONNECTED) { // bağlanana kadar bekle / wait until connected
17 delay(500);
18 Serial.print(".");
19 }
20 Serial.println();
21 Serial.print("IP: ");
22 Serial.println(WiFi.localIP());
23
24 ArduinoOTA.setHostname("bluegrays-esp32"); // IDE'de görünen ad / name shown in the IDE
25 ArduinoOTA.setPassword("ota1234"); // yükleme parolası / upload password
26
27 ArduinoOTA.onStart([]() {
28 // Güncelleme başlıyor: motorları, röleleri güvenli konuma al / update starting: put motors and relays in a safe state
29 String type = (ArduinoOTA.getCommand() == U_FLASH) ? "program" : "dosya sistemi / filesystem";
30 Serial.println("OTA basladi / started: " + type);
31 });
32 ArduinoOTA.onEnd([]() {
33 Serial.println("\nOTA bitti, yeniden baslatiliyor / done, rebooting");
34 });
35 ArduinoOTA.onProgress([](unsigned int progress, unsigned int total) {
36 Serial.printf("Ilerleme / Progress: %u%%\r", progress * 100 / total);
37 });
38 ArduinoOTA.onError([](ota_error_t error) {
39 Serial.printf("Hata / Error[%u]: ", error);
40 if (error == OTA_AUTH_ERROR) Serial.println("parola / auth failed");
41 else if (error == OTA_BEGIN_ERROR) Serial.println("baslatilamadi, yer yok / begin failed, no space");
42 else if (error == OTA_CONNECT_ERROR) Serial.println("baglanti / connect failed");
43 else if (error == OTA_RECEIVE_ERROR) Serial.println("veri alinamadi / receive failed");
44 else if (error == OTA_END_ERROR) Serial.println("bitirilemedi / end failed");
45 });
46
47 ArduinoOTA.begin(); // OTA hizmetini başlat / start the OTA service
48}
49
50void loop() {
51 ArduinoOTA.handle(); // her turda çağır, unutma / call on every pass, never forget
52
53 // delay() yerine millis(): OTA isteklerini kaçırmamak için / millis() instead of delay() so OTA requests aren't missed
54 if (millis() - lastBlink >= 500) {
55 lastBlink = millis();
56 digitalWrite(LED_PIN, !digitalRead(LED_PIN));
57 }
58}| Regel | Wat doet het? |
|---|---|
| ArduinoOTA.setHostname("bluegrays-esp32") | De naam die in de Port-lijst van de IDE en op het netwerk verschijnt. Heb je meerdere boards, geef ze dan elk een andere naam. |
| ArduinoOTA.setPassword("ota1234") | Zonder wachtwoord kan iedereen op je netwerk code naar je board uploaden. De IDE vraagt dit wachtwoord voordat hij uploadt. |
| onStart / onEnd | Worden uitgevoerd als de update begint en eindigt. De ideale plek om motoren te stoppen, relais uit te schakelen of "Updating" op een display te tonen. |
| onProgress | Geeft je het percentage; je kunt er een voortgangsbalk mee tekenen op een LCD of OLED. |
| onError | Vertelt je het type fout: wachtwoord-, ruimte-, verbindings-, ontvangst- of eindfout. |
| ArduinoOTA.handle() | Controleert op binnenkomende OTA-verzoeken. Wordt hij binnen loop() niet vaak genoeg aangeroepen, dan kan het board de IDE niet antwoorden. |
Stap voor stap: je eerste OTA-upload
- Pas de waarden WIFI_SSID en WIFI_PASS in de code aan voor jouw netwerk. De ESP32 maakt alleen verbinding met 2,4 GHz-netwerken.
- Kies in het menu Tools je board (bijvoorbeeld ESP32 Dev Module) en een Partition Scheme met OTA (Default of Minimal SPIFFS).
- Doe de eerste upload met een USB-kabel. Deze stap is verplicht, omdat het board nog geen OTA-code heeft.
- Open de Serial Monitor op 115200 baud en noteer het IP-adres dat het board afdrukt.
- Haal de USB-kabel los en voed het board desgewenst met een andere voeding. Binnen 10–20 seconden verschijnt onder netwerkpoorten in Tools › Port een regel als "bluegrays-esp32 at 192.168.1.x"; selecteer die.
- Verander in de code de led-vertraging van 500 naar 100 en druk op Upload. Typ "ota1234" als de IDE om het wachtwoord vraagt.
- In het uitvoervenster zie je het voortgangspercentage en uiteindelijk een regel als "Done" of "Result: OK". Het board start opnieuw op en de led knippert nu snel.
Er is één beperking die je moet kennen: de netwerkpoort is alleen om te uploaden, en de Serial Monitor werkt niet draadloos. Om de berichten van het board te zien, sluit je USB weer aan of toon je de status op een webpagina, een display of via MQTT-berichten. Tijdens het ontwikkelen aan je bureau kun je het board ook op USB laten zitten en toch via het netwerk uploaden; zo heb je snelle uploads en de Serial Monitor tegelijk.
Wachtwoordbeveiliging en veiligheid
Een board met een open OTA-service is een deur waardoor iedereen op je netwerk code kan uploaden. In ArduinoOTA bewaart setPassword() het wachtwoord als leesbare tekst in de code; als je de code gaat delen, kun je met setPasswordHash() de MD5-hash van het wachtwoord meegeven, zodat het wachtwoord zelf niet in de broncode staat. ElegantOTA beveiligt de pagina /update met een gebruikersnaam en wachtwoord (HTTP Basic Auth).
- Geef elk apparaat een ander, moeilijk te raden wachtwoord: waarden als "1234" of "admin" probeert iedereen als eerste.
- Zet het board niet open op internet: OTA of de pagina /update naar buiten openstellen met port forwarding op je router is een serieus risico; deze methoden werken via onversleuteld HTTP.
- Gebruik HTTPUpdate voor apparaten op afstand: omdat het board de update zelf opvraagt, is een uitgaande verbinding genoeg; haal je het via internet op, kies dan liever HTTPS met WiFiClientSecure.
- Ga tijdens de update naar een veilige toestand: stop motoren en schakel verwarmings- en pomprelais uit in onStart. Het herstarten duurt een paar seconden en de pins kunnen in die tijd ongedefinieerd zijn.
Methode 2: een .bin uploaden vanuit de browser met ElegantOTA
ElegantOTA voegt een nette pagina /update toe aan de webserver die op de ESP32 draait. Je opent die pagina op je telefoon of op elke computer zonder Arduino IDE, kiest het gecompileerde .bin-bestand en uploadt het; de voortgangsbalk verschijnt in de browser. Het is de handigste methode als je het apparaat aan iemand anders geeft of ter plaatse bijwerkt.
- Open in de Arduino IDE de Library Manager, zoek naar ElegantOTA (Ayush Sharma) en installeer die.
- Pas de onderstaande code aan en upload hem de eerste keer via USB.
- Open het adres dat de Serial Monitor afdrukt (bijvoorbeeld http://192.168.1.42/update) in je browser en log in met de gebruikersnaam "admin" en het wachtwoord "ota1234".
- Laat Firmware als modus geselecteerd en sleep het .bin-bestand erheen; als de upload klaar is, start het board zichzelf opnieuw op.
1#include <WiFi.h>
2#include <WebServer.h>
3#include <ElegantOTA.h>
4
5const char* WIFI_SSID = "AgAdi"; // Wi-Fi adın / your Wi-Fi name
6const char* WIFI_PASS = "AgSifresi"; // Wi-Fi şifren / your Wi-Fi password
7
8WebServer server(80);
9unsigned long otaProgressMillis = 0;
10
11void onOTAStart() {
12 Serial.println("OTA basladi / OTA started"); // röleleri kapat / switch relays off
13}
14
15void onOTAProgress(size_t current, size_t final) {
16 if (millis() - otaProgressMillis > 1000) { // saniyede bir yaz / print once per second
17 otaProgressMillis = millis();
18 Serial.printf("%u / %u bayt / bytes\n", current, final);
19 }
20}
21
22void onOTAEnd(bool success) {
23 Serial.println(success ? "OTA basarili / OTA successful" : "OTA hatasi / OTA failed");
24}
25
26void setup() {
27 Serial.begin(115200);
28 WiFi.mode(WIFI_STA);
29 WiFi.begin(WIFI_SSID, WIFI_PASS);
30 while (WiFi.status() != WL_CONNECTED) {
31 delay(500);
32 Serial.print(".");
33 }
34 Serial.println();
35 Serial.print("Adres / Address: http://");
36 Serial.print(WiFi.localIP());
37 Serial.println("/update");
38
39 server.on("/", []() {
40 server.send(200, "text/plain", "BlueGrays ESP32 - surum / version 1.0");
41 });
42
43 ElegantOTA.begin(&server, "admin", "ota1234"); // /update sayfası + kullanıcı/parola / /update page + user/password
44 ElegantOTA.onStart(onOTAStart);
45 ElegantOTA.onProgress(onOTAProgress);
46 ElegantOTA.onEnd(onOTAEnd);
47
48 server.begin();
49}
50
51void loop() {
52 server.handleClient(); // web isteklerini işle / handle web requests
53 ElegantOTA.loop(); // başarılı yüklemeden sonra yeniden başlatır / reboots after a successful upload
54}Standaard werkt ElegantOTA met de synchrone klasse WebServer uit de core, dus de aanroepen server.handleClient() en ElegantOTA.loop() in loop() zijn verplicht. Gebruikt je project al ESPAsyncWebServer, dan kun je de optie ELEGANTOTA_USE_ASYNC_WEBSERVER van de bibliotheek op 1 zetten en hem met de asynchrone server gebruiken; hoe je de asynchrone server opzet, behandelden we in het bericht ESP32 Async Web Server en WebSocket. De modus Filesystem op de pagina werkt het LittleFS- of SPIFFS-image (webpaginabestanden, instellingenbestanden) bij in plaats van het programma.
Het .bin-bestand verkrijgen: de gecompileerde binary exporteren
Voor ElegantOTA en HTTPUpdate heb je het gecompileerde programmabestand nodig. Voer in de Arduino IDE Sketch › Export Compiled Binary uit. De IDE compileert het programma en zet meerdere bestanden in een map build in je sketchmap. Slechts één ervan is geschikt voor OTA:
| Bestand | Inhoud | Gebruikt voor OTA? |
|---|---|---|
| myproject.ino.bin | Alleen de applicatie (jouw programma) | Ja, dit is het bestand om te uploaden |
| myproject.ino.bootloader.bin | Bootloader | Nee |
| myproject.ino.partitions.bin | Partitietabel | Nee |
| myproject.ino.merged.bin (core 3.x) | Bootloader, tabel en programma gecombineerd | Nee, wordt alleen via USB op adres 0x0 geschreven |
Methode 3: automatische updates vanaf een server met HTTPUpdate
Stel je voor dat je vijf sensorboards in huis hebt. In plaats van elk daarvan vanuit de IDE te uploaden, zet je het nieuwe .bin-bestand op een server en downloaden de boards het zelf. De HTTPUpdate-bibliotheek uit de ESP32-core doet dit in één regel. In het voorbeeld hieronder start de update als je op de BOOT-knop (GPIO 0) van het board drukt:
1#include <WiFi.h>
2#include <HTTPUpdate.h>
3
4const char* WIFI_SSID = "AgAdi";
5const char* WIFI_PASS = "AgSifresi";
6// Bilgisayarındaki ya da sunucundaki .bin dosyası / the .bin file on your computer or server
7const char* FIRMWARE_URL = "http://192.168.1.50:8000/firmware.bin";
8const int BUTTON_PIN = 0; // karttaki BOOT butonu / the BOOT button on the board
9
10void setup() {
11 Serial.begin(115200);
12 pinMode(BUTTON_PIN, INPUT_PULLUP);
13 WiFi.begin(WIFI_SSID, WIFI_PASS);
14 while (WiFi.status() != WL_CONNECTED) delay(500);
15 Serial.println("Hazir: guncellemek icin BOOT'a bas / Ready: press BOOT to update");
16}
17
18void loop() {
19 if (digitalRead(BUTTON_PIN) == LOW) { // butona basıldı / button pressed
20 WiFiClient client;
21 httpUpdate.rebootOnUpdate(true); // başarılıysa yeniden başlat / reboot on success
22 t_httpUpdate_return ret = httpUpdate.update(client, FIRMWARE_URL);
23
24 switch (ret) {
25 case HTTP_UPDATE_FAILED:
26 Serial.printf("Hata / Error (%d): %s\n", httpUpdate.getLastError(),
27 httpUpdate.getLastErrorString().c_str());
28 break;
29 case HTTP_UPDATE_NO_UPDATES:
30 Serial.println("Guncelleme yok / No update");
31 break;
32 case HTTP_UPDATE_OK:
33 Serial.println("Tamam / OK"); // buraya genelde gelinmez, kart yeniden başlar / usually not reached, the board reboots
34 break;
35 }
36 delay(1000);
37 }
38}Om het uit te proberen zet je het .bin-bestand als firmware.bin in een map op je computer en voer je in die map python3 -m http.server 8000 uit; vervang het IP-adres in de code door het lokale IP van je computer. In het echte gebruik vervang je de knop door een timer: bijvoorbeeld één keer per uur leest het board een klein bestand "version.txt", en als het versienummer op de server hoger is dan zijn eigen, start het de update. Zo blijft het ook niet steeds hetzelfde bestand downloaden en opnieuw opstarten.
Wat gebeurt er als de verbinding tijdens OTA wegvalt?
Kort antwoord: je board raakt niet bricked. Omdat het nieuwe programma naar de ongebruikte partitie wordt geschreven en de bootpartitie pas wordt omgezet nadat het hele bestand is gecontroleerd, blijft het board na een onderbroken upload gewoon zijn oude programma draaien. Je ziet "Error Uploading" in de IDE, OTA_RECEIVE_ERROR in ArduinoOTA of een mislukt resultaat in ElegantOTA; los het probleem op en herhaal de upload. Valt de stroom midden in de upload uit, dan is het hetzelfde verhaal: het board start het oude programma. Het enige echte risico is dat het nieuwe programma zelf defect is: upload je een programma dat geen verbinding met wifi maakt of de OTA-code niet bevat, dan heb je voor de volgende update weer de kabel nodig.
- Zwak wifisignaal: blijft de upload hangen rond 30–60%, zet het board dan dichter bij de router of gebruik een module met externe antenne. Is WiFi.RSSI() in de Serial Monitor slechter dan -75 dBm, reken dan op haperingen; zie ESP32 maakt geen verbinding met wifi voor details.
- Te weinig stroom: schrijven naar flash en zenden via wifi vragen tegelijk stroom. Een zwakke USB-poort of een dunne kabel kan het board tijdens de upload resetten; dat zie je als een brownout-fout. Gebruik een stevige 5 V-voeding die minstens 500 mA kan leveren.
- Lange wachttijden in loop(): wachttijden als delay(5000) vertragen de aanroep van handle() en de IDE meldt "No response from the ESP". Doe je timing met millis().
- Firewall: bij ArduinoOTA maakt de ESP32 aan het begin van de upload verbinding terug naar je computer. Blokkeert Windows Firewall of een antivirusprogramma deze inkomende verbinding, dan mislukt de upload meteen; sta privénetwerken toe in het toestemmingsvenster dat bij de eerste poging verschijnt.
OTA in elke nieuwe sketch houden
De meest voorkomende OTA-teleurstelling gaat zo: je uploadt via OTA een heel ander project, dat project bevat geen ArduinoOTA-code, en het board verschijnt niet meer als netwerkpoort. Het nieuw geüploade programma vervangt het oude volledig; OTA is niet iets dat "op het board blijft staan", elk programma moet het zelf meedragen. Om niet opnieuw de ladder naar het plafondapparaat te hoeven op, maak je van deze regels een gewoonte:
- Gebruik een sjabloon: zet de wifiverbinding en de ArduinoOTA-instellingen in een aparte functie (bijvoorbeeld setupOTA()) en begin elk nieuw project vanuit dat bestand.
- Zet de aanroep van handle() helemaal bovenaan loop() en laat nooit een lang blokkerende lus in loop() staan.
- Maak opnieuw verbinding als wifi wegvalt: gebruik WiFi.setAutoReconnect(true) of controleer de verbinding regelmatig; een board zonder verbinding kan geen updates ontvangen.
- Voeg een onderhoudsvenster toe aan deep-sleepprojecten: een slapend board hoort het OTA-verzoek niet. Schrijf een modus die 60 seconden op OTA wacht voordat hij gaat slapen als er bij het opstarten een knop wordt ingedrukt of een MQTT-vlag is binnengekomen. Voor slaapmodi zie het bericht ESP32 Deep Sleep.
- Test eerst op een tweede board aan je bureau: voordat je naar het apparaat in het veld stuurt, draai je dezelfde code op een board naast je; maakt het verbinding met wifi en verschijnt het als netwerkpoort, dan kun je veilig versturen.
- Druk een versienummer af: houd bovenaan de code een constante FW_VERSION bij en toon die op de webpagina of het display; zo weet je altijd welke versie op welk board draait.
OTA op de ESP8266 en Raspberry Pi Pico W
De ArduinoOTA- en ElegantOTA-code uit deze gids draait met kleine wijzigingen ook op ESP8266-boards (NodeMCU, Wemos D1 Mini): er wordt ESP8266WiFi.h gebruikt in plaats van WiFi.h, ESP8266WebServer in plaats van WebServer, en de OTA-poort is 8266. Kies op ESP8266-boards met 4 MB flash een Flash Size-optie die genoeg programmaruimte voor OTA overlaat. Op de Raspberry Pi Pico W biedt de arduino-pico-core ondersteuning voor ArduinoOTA; hier wordt het nieuwe programma eerst in het LittleFS-bestandssysteem gedownload en bij het opstarten op zijn plek gekopieerd. Daarom moet je op de Pico W in het menu Flash Size een bestandssysteemgebied reserveren dat groter is dan je programma. MicroPython heeft geen kant-en-klare OTA-tool; je kunt kleine scripts schrijven die .py-bestanden via het netwerk downloaden en vervangen, maar dat is geen gecontroleerde update met twee partities zoals op de ESP32.
Ideeën voor OTA-projecten
- Plafond- of wandsensor: pas de drempels aan van een board dat temperatuur, luchtvochtigheid en beweging meet, zonder een kabel aan te raken.
- Slimme-woningrelais: werk de tijdsregels van het relaisboard in de meterkast via OTA bij; zet de relais in onStart in een veilige toestand.
- Home Assistant-apparaten: voeg via het netwerk nieuwe functies toe aan sensoren die via MQTT met Home Assistant zijn verbonden.
- Beregeningscomputer voor de tuin: wijzig de beregeningstijden en de drempel voor bodemvocht zonder de waterdichte doos te openen.
- Voortgangsbalk op een LCD: toon de waarde van onProgress als percentage en balk op een 16x2-LCD; het project ESP32 OTA in BlueGrays doet precies dat.
- Updaten van een vloot: laat meerdere boards elke nacht met HTTPUpdate op dezelfde server controleren op een nieuwe versie.
Veelgemaakte fouten en hoe je ze oplost
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| Geen netwerkpoort in het menu Port | Board op een ander netwerk, mDNS geblokkeerd, de code roept ArduinoOTA.begin() niet aan | Gebruik hetzelfde 2,4 GHz-netwerk, start de IDE opnieuw, controleer of het IP in de Serial Monitor wordt afgedrukt |
| "No response from the ESP" | Lange delay() in loop(), board bezet of firewall | Gebruik millis() in plaats van delay(), sta de IDE toe in de firewall |
| "Authentication Failed" | Verkeerd OTA-wachtwoord | Voer de waarde van setPassword uit de code in; ben je het vergeten, upload dan één keer via USB |
| "Not Enough Space" / Begin Failed | Huge APP of No OTA-schema, programma past niet in het tweede gebied | Kies Minimal SPIFFS en upload één keer via USB; maak het programma kleiner |
| Upload stopt halverwege | Zwak signaal, spanningsdip, wegvallende verbinding | Zet het board dichter bij de router, gebruik een stevige 5 V-voeding, probeer opnieuw; het oude programma blijft draaien |
| Board komt na de upload niet op het netwerk | Nieuwe code bevat geen wifi of OTA, verkeerde SSID | Herstel het via USB; begin vanaf nu elk project vanuit het OTA-sjabloon |
| "Wrong Magic Byte" of activeringsfout in ElegantOTA | merged.bin, bootloader.bin of een bestand voor een andere chip was geselecteerd | Upload alleen het bestand myproject.ino.bin |
OTA is de sleutel om ESP32-projecten van je bureau te halen en ergens echt op te hangen: als het eenmaal goed is ingesteld, komen aanpassingen, nieuwe functies en drempelwijzigingen in seconden draadloos binnen. In de BlueGrays-app vind je het project ESP32 OTA-update (met IP en voortgang op een LCD) samen met de projecten wifiverbinding, Async Web Server, mDNS en NTP, elk met schakelschema en code, stap voor stap.
Veelgestelde vragen
Wat is ESP32 OTA?
OTA (Over-The-Air) betekent dat je een nieuw programma via wifi naar de ESP32 uploadt in plaats van via een USB-kabel. Het board schrijft de nieuwe code naar een ongebruikte programmapartitie, controleert die en start opnieuw op met de nieuwe versie. De eerste sketch met OTA moet je één keer via USB uploaden.
Waarom verschijnt de ESP32-netwerkpoort niet in de Arduino IDE?
De meest voorkomende oorzaken zijn dat computer en board op verschillende netwerken zitten, dat een gastnetwerk apparaten isoleert en dat de aanroep ArduinoOTA.begin() in de code nooit wordt uitgevoerd. Controleer in de Serial Monitor of het board een IP heeft gekregen, start de IDE opnieuw en wacht een paar seconden.
Welk partitieschema moet ik kiezen voor ESP32 OTA?
Kies op boards met 4 MB flash Default (2 × 1,25 MB programmagebied) of, als je programma groot is, Minimal SPIFFS (2 × 1,875 MB). Huge APP en No OTA hebben geen tweede programmagebied, dus OTA werkt daarmee niet. De eerste upload na het wijzigen van het schema moet via USB.
Kan een onderbroken OTA-upload de ESP32 bricken?
Nee. Het nieuwe programma wordt naar een lege partitie geschreven en de bootpartitie wordt pas omgezet nadat het hele bestand is gecontroleerd. Valt de verbinding of de stroom weg, dan start het board het oude programma en kun je de upload gewoon opnieuw proberen.
Kan ik de Serial Monitor gebruiken bij uploaden via OTA?
De netwerkpoort is alleen voor het uploaden van code; de Serial Monitor werkt niet draadloos. Om berichten te zien, kun je het board aan USB laten zitten of de informatie tonen op een webpagina, een display of via MQTT.
Hoe stel ik een ESP32 OTA-wachtwoord in?
In ArduinoOTA roep je vóór begin() ArduinoOTA.setPassword("password") aan; de IDE vraagt dit wachtwoord voordat hij uploadt. Wil je het wachtwoord niet in de code zichtbaar hebben, geef dan de MD5-hash mee met setPasswordHash(). In ElegantOTA beveilig je de pagina met begin(&server, "user", "password").
Projecten om hierna te bouwen
Alle projecten bekijken
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.

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

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.

ESP32 HTTPClient + weer-API (met lcd-scherm)
In dit project doet de ESP32 via internet een REST API-aanroep naar een weer-API (wttr.in) met HTTPClient.h. Het JSON-antwoord wordt verwerkt met ArduinoJson v7 en stad, temperatuur, luchtvochtigheid, weer en wind verschijnen op een I2C-LCD. wttr.in vraagt geen API-sleutel; typ gewoon de naam van een willekeurige stad.

ESP32 Deep Sleep: batterij sparen (OLED + RTC RAM-teller)
De Deep Sleep-modus van de ESP32 schakelt de CPU en de meeste randapparatuur uit, waardoor het stroomverbruik daalt tot ongeveer 10µA; dat is cruciaal voor IoT-apparaten op batterijen. Dit project gebruikt drie wekbronnen: een timer (15 s), een externe pin (EXT0, de knop op GPIO 33) en een touchpin (T0/GPIO 4). Tellers met RTC_DATA_ATTR blijven behouden tijdens deep sleep.
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

