Gidsen · 22 min leestijd

ESP32 Brownout Detector Was Triggered en Guru Meditation oplossen

ESP32 brownout detector was triggered en eindeloze herstarts: verbeter voeding, kabel en condensator, lees rst-codes, Guru Meditation, Task WDT en backtraces.

De melding ESP32 brownout detector was triggered betekent dat de voedingsspanning van het board even onder een veilige grens zakte en dat de chip zichzelf opnieuw startte om veilig te blijven. Het probleem zit bijna nooit in je code, maar aan de voedingskant: een zwakke USB-poort, een dunne en lange kabel, een te zwakke regelaar, of servo's en ledstrips die op dezelfde lijn hangen als de ESP32. De tweede grote reden dat een ESP32 blijft herstarten is een softwarecrash; dan toont de Serial Monitor regels zoals Guru Meditation Error, task_wdt of Stack canary.

Het goede nieuws: de ESP32 vertelt je waarom hij herstartte, zolang je zijn meldingen kunt lezen. In deze gids leer je eerst de rst-codes in de bootregels en de foutmeldingen herkennen, en los je brownouts daarna blijvend op met de juiste voeding, kabel en condensator. Daarna behandelen we Guru Meditation-fouten zoals LoadProhibited en StoreProhibited, stack overflows, null pointers en watchdog-timeouts, en volg je een crash met de ESP Exception Decoder tot op de exacte regel code. Tot slot kijken we naar de strapping pins (GPIO0, 2, 12 en 15) die het bootproces kunnen verstoren.

ESP32 DevKit-ontwikkelboard
ESP32-ontwikkelboard: de 5 V van USB wordt door de ingebouwde regelaar teruggebracht naar 3,3 V. De meeste brownoutproblemen komen van korte dips op deze 3,3V-lijn.

Waarom blijft de ESP32 herstarten? Lees eerst de melding

Open voordat je begint met problemen oplossen de Serial Monitor op 115200 baud en druk op de EN-knop op het board. Bij elke start print de ROM-bootloader in de ESP32 eerst een datumregel zoals "ets Jun 8 2016 00:22:57", gevolgd door een regel als rst:0x1 (POWERON_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT). Het rst-deel vertelt waarom het board herstartte, het boot-deel toont in welke modus het startte. Zit het board vast in een lus, dan vind je de foutmelding, de laatste woorden van de vorige run, direct boven deze regels. De tabel hieronder vat de meldingen samen en laat zien waar je moet beginnen:

Wat je ziet in de Serial MonitorBetekenisWaar kijken
Brownout detector was triggeredDe voedingsspanning zakte onder de drempelVoeding, kabel, condensator
Guru Meditation Error: Core 1 panic'ed (LoadProhibited)De code probeerde van een ongeldig adres te lezenNull pointer, arraygrenzen
Guru Meditation Error: Core 1 panic'ed (StoreProhibited)De code probeerde naar een ongeldig adres te schrijvenNull pointer, bufferoverflow
Stack canary watchpoint triggered (loopTask)De stack van een taak liep volGrote lokale arrays, recursie
task_wdt: Task watchdog got triggeredEen taak gaf de CPU langer dan 5 seconden niet vrijLussen zonder pauzes, vastgelopen taken
Interrupt wdt timeout on CPU0 / CPU1Een interrupthandler of uitgeschakelde interrupts duurden langer dan 300 msLange ISR, Serial binnen een ISR
boot:0x3 (DOWNLOAD_BOOT...) waiting for downloadHet board startte in programmeermodusGPIO0 LOW bij het opstarten
invalid header of flash read errHet flashgeheugen kon niet worden gelezenGPIO12 HIGH bij het opstarten, onderbroken upload

Wat is "Brownout detector was triggered" en waarom gebeurt het?

Een brownout is een korte spanningsdaling zonder dat de voeding helemaal wegvalt. De ESP32 heeft een brownout detector die de voedingslijn voortdurend bewaakt; in de Arduino-core staat de drempel op het laagste niveau, ongeveer 2,43 V. Zodra de spanning onder deze waarde zakt, beschermt de chip de radio en het flashgeheugen, print hij "Brownout detector was triggered" in de Serial Monitor en herstart hij zichzelf. De reden is simpel: bij lage spanning kan de flash verkeerd worden gelezen, kunnen opgeslagen gegevens beschadigd raken en kan de CPU willekeurige instructies uitvoeren. De detector laat het board een nette reset doen in plaats van onvoorspelbaar gedrag te vertonen. De ESP32-WROOM-32-module is ontworpen voor een werkbereik van 3,0 tot 3,6 V, dus als de lijn 2,43 V bereikt, zit je al ruim buiten de veilige zone.

Na een brownoutmelding toont de bootregel rst:0xc (SW_CPU_RESET) of rst:0x3 (SW_RESET), afhankelijk van je Arduino-coreversie, omdat de interrupt van de detector de melding print en de chip daarna in software herstart. Laat je daardoor niet misleiden: dezelfde code noteert in het geheugen van de chip dat de oorzaak een brownout was, en esp_reset_reason() geeft ESP_RST_BROWNOUT terug. Slaat de eigen brownoutreset van de hardware toe, dan staat er in plaats daarvan rst:0xf (RTCWDT_BROWN_OUT_RESET). In de 3.x-cores, die op ESP-IDF 5 zijn gebaseerd, werd deze regel een log op infoniveau (I BOD: Brownout detector was triggered). Omdat de voorgecompileerde bibliotheken van Arduino alleen logs op foutniveau printen, verschijnt de melding meestal helemaal niet en herstart het board stilletjes; zie je bij het opstarten een onverklaarde rst:0x3 of rst:0xc, controleer dan de resetreden met de diagnostische sketch hieronder. Om te begrijpen waarom de spanning zakt, kijk je naar hoeveel stroom de ESP32 trekt:

BedrijfstoestandTypische stroom (ESP32-chip)
Deep sleep (RTC-timer aan)Ongeveer 10 µA
Light sleepOngeveer 0,8 mA
Wi-Fi uit, CPU op 240 MHz30–68 mA
Wi-Fi ontvangen (RX)95–100 mA
Wi-Fi zenden, 802.11b, 19,5 dBmOngeveer 240 mA
Radiokalibratie bij het opstarten en op het moment van verbindenKan in pieken van microseconden boven 400 mA komen

De kloof in deze tabel is de kern van het brownoutprobleem: zolang je code Wi-Fi niet inschakelt, ligt het board stil op ongeveer 50 mA, maar bij de regel WiFi.begin() springt de stroom binnen een paar microseconden vijf of zes keer omhoog. Kunnen voeding, kabel en regelaar die plotselinge vraag niet bijbenen, dan klapt de spanning in. Daarom raadt Espressif een voeding aan die minstens 500 mA kan leveren voor de ESP32. Het symptoom is heel herkenbaar: het board start, print een paar regels in de Serial Monitor, reset op het moment dat Wi-Fi of Bluetooth start, en dit loopt uit op een eindeloze lus. Hetzelfde kan gebeuren wanneer een servo beweegt, een relais schakelt of een ledstrip wit wordt.

De meest voorkomende oorzaken van brownout

  • Dunne of lange USB-kabel: de dunne voedingsdraden in goedkope kabels kunnen heen en terug samen 0,5 Ω bedragen. Volgens de wet van Ohm verliest een piek van 400 mA in zo'n kabel 0,2 V.
  • Zwakke USB-poort of hub: poorten op toetsenborden en monitoren, hubs zonder eigen voeding en de voorpoorten van sommige laptops laten de spanning bij piekstroom inzakken.
  • Dropout van de regelaar: de AMS1117 op de meeste boards heeft een verschil van 1,0–1,3 V tussen ingang en uitgang nodig. Zakt de spanning op de 5V-pin onder ongeveer 4,3 V, dan kan de uitgang geen 3,3 V meer houden.
  • Een batterij rechtstreeks aansluiten: een Li-ioncel van 3,7 V op de 5V-pin trekt de uitgang door de dropout van de regelaar onder 3 V; twee AA-batterijen zakken onder belasting snel onder het minimum van de ESP32.
  • De 3.3V-pin van de Arduino Uno: van deze pin wordt maar ongeveer 50 mA aanbevolen; dat is bij lange na niet genoeg voor een ESP32 met Wi-Fi aan.
  • Belastingen op dezelfde lijn: draaien servo's, relais, buzzers, gelijkstroommotoren of een WS2812B-strip op dezelfde 5 V als de ESP32, dan trekt elke beweging de spanning omlaag.
  • Breadboards en jumperdraden: losse contacten en dunne jumpers voegen bij elke verbinding wat weerstand toe; de voeding via een breadboard laten lopen maakt het erger.
  • ESP32-CAM: als camera, Wi-Fi en flashled tegelijk werken, wordt de stroom erg hoog; dit board wil 5 V en minstens 2 A. Zie de ESP32-CAM-gids voor details.
3,3 V zien op een multimeter betekent niet dat de voeding stevig is. Een multimeter neemt maar een paar metingen per seconde en toont iets wat dicht bij een gemiddelde ligt, terwijl de dips die brownouts veroorzaken microseconden tot enkele milliseconden duren en nooit op het display verschijnen. Alleen een oscilloscoop kan ze zichtbaar maken. Heb je er geen, pas dan de oplossingen hieronder in volgorde toe en controleer na elke stap of de fout weg is. De basis van meten vind je in Een multimeter gebruiken.

Oplossing 1: verbeter de voeding en de kabel

De eerste en meest effectieve stap is een sterkere voeding. Sluit het board met een korte, dikke datakabel waarvan je weet dat hij goed is, rechtstreeks aan op een USB-poort aan de achterkant van je computer of op een 5V-adapter van minstens 1 A. USB 2.0-poorten zijn ontworpen voor 500 mA en USB 3.0-poorten voor 900 mA; de 500 mA die Espressif aanbeveelt zit precies op de grens van een USB 2.0-poort, dus zodra de kabelverliezen erbij komen, beginnen de problemen. Lost alleen de kabel wisselen de fout op, dan was de weerstand van de kabel waarschijnlijk de boosdoener. Met V = I × R in de tool Wet van Ohm reken je uit hoeveel spanning een kabel verliest.

AMS1117 3,3V-spanningsregelaar
AMS1117-3.3: de regelaar op de meeste ESP32-boards. Hij heeft een verschil van 1,0–1,3 V tussen ingang en uitgang nodig; zakt de 5V-pin onder ongeveer 4,3 V, dan kan de uitgang geen 3,3 V houden.
VoedingsopstellingBrownoutrisicoOpmerking
Korte, dikke kabel en een USB-poort aan de achterkantLaagDe makkelijkste oplossing tijdens het ontwikkelen
Lange, dunne kabel, voorpoort of hubHoogDe kabelweerstand trekt de spanning omlaag bij piekstroom
5V-adapter van minstens 1 A, op de 5V- of VIN-pinLaagAanbevolen voor permanente projecten
Kant-en-klare 3,3V-voeding rechtstreeks op de 3V3-pinHangt van de voeding afMoet minstens 500 mA leveren en nooit meer dan 3,6 V
Li-ioncel van 3,7 V via de AMS1117HoogOnder ongeveer 4 V op de cel zakt de uitgang onder 3 V
Li-ioncel met een low-dropout (LDO) 3,3V-regelaar of een buck-boostconverterLaagLevert een stabiele 3,3 V, ook terwijl de cel ontlaadt
Twee AA-batterijen rechtstreeks op de 3V3-pinZeer hoogOnder belasting zakt de spanning snel onder het minimum van de ESP32

Projecten op batterijen vragen extra aandacht. Een Li-ioncel zoals een 18650 geeft 4,2 V als hij vol is en ongeveer 3,0 V als hij leeg is. Dat bereik past niet bij een directe aansluiting op de 3V3-pin (4,2 V overschrijdt de limiet van 3,6 V) en ook niet bij de 5V-pin met zijn AMS1117. De juiste oplossing is de cel via een 5V-boostmodule op de 5V-pin aan te sluiten, of de 3V3-lijn rechtstreeks te voeden via een low-dropout-regelaar van minstens 500 mA (bijvoorbeeld een ME6211 of HT7833) plus een condensator. Met de tool Batterijduur schat je hoe lang je project op een batterij werkt, en over de laadschakeling lees je meer in de gids TP4056-oplaadmodule.

Oplossing 2: voeg een condensator toe tussen 3V3 en GND

Een condensator werkt als een klein reservoir dat tijdens een stroompiek zelf energie levert totdat de regelaar en de kabel bijkomen. Voeg een elco van 100–470 µF toe tussen de pinnen 3V3 en GND van het board, zo dicht mogelijk bij het board, plus een keramische condensator van 100 nF ernaast. De elco vangt dips van milliseconden op, de keramische condensator de zeer korte, hoogfrequente rimpel. Het effect zie je ruwweg met ΔV = I × Δt / C: ook als een condensator van 470 µF alleen 200 µs lang 200 mA extra levert, zakt de spanning maar 0,085 V. De markering 104 op een keramische condensator betekent 100 nF; andere markeringen ontcijfer je met de tool Condensatorcode.

Soorten condensatoren
Bij elco's is het lange pootje positief (+) en gaat het naar 3V3; het pootje aan de gestreepte kant van de behuizing gaat naar GND. Een onderdeel van 6,3 V of 10 V is genoeg voor de 3,3V-lijn.
Monteer een elco nooit verkeerd om: hij wordt warm, zwelt op en kan barsten. Sluit je de condensator aan op de 5V-lijn, kies dan een type van minstens 10 V. Zeer grote condensatoren (1000 µF en meer) trekken bij het inschakelen een grote laadstroom, wat de USB-poort kortstondig kan belasten en het oplopen van de 3,3V-lijn kan vertragen; 470 µF op de 3V3-lijn is genoeg voor de meeste projecten. Hoe condensatoren werken lees je in Wat is een condensator?

Oplossing 3: voed servo's, motoren en ledstrips apart

Ook als de ESP32 zelf goed gevoed wordt, kunnen belastingen op dezelfde lijn de spanning omlaag trekken. Zelfs een kleine servo zoals de SG90 trekt een paar honderd mA als hij begint te bewegen; een WS2812B-led gebruikt op vol wit ongeveer 60 mA, dus een strip van 30 leds kan 1,8 A bereiken. Voed deze belastingen niet via de 5V- of 3V3-pin van de ESP32, maar via een aparte 5V-voeding; je kunt bijvoorbeeld een 12V-adapter met een LM2596-buckmodule terugbrengen naar 5 V. De belangrijkste regel is dat je de GND van beide voedingen met elkaar verbindt; zonder gemeenschappelijke massa heeft de signaallijn geen referentie en gedraagt de servo of strip zich willekeurig. Dit behandelen we uitgebreid in Arduino blijft resetten? en GND en gemeenschappelijke massa.

LM2596 step-down (buck)-module
LM2596-buckmodule: brengt 12 V efficiënt terug naar 5 V en is ideaal om belastingen zoals servo's, relais of ledstrips apart van de ESP32 te voeden. De uitgang wordt met een trimmer ingesteld; stel hem met een multimeter af op 5 V voordat je iets aansluit.
Je kunt stroompieken ook in software verzachten. Start Wi-Fi voordat je servo's beweegt of de ledstrip laat branden; beperk de helderheid van de strip met setBrightness(); schakel servo's en relais een paar honderd milliseconden na elkaar in in plaats van allemaal tegelijk. Het zendvermogen van Wi-Fi verlagen met WiFi.setTxPower() verlaagt ook de piekstroom; details in ESP32 maakt geen verbinding met wifi.

Is de brownout detector uitschakelen een oplossing?

De meest gegeven "oplossing" op internet is de detector met één regel uit te zetten. De code hieronder schakelt de detector uit door het brownoutregister van de ESP32 te wissen, en de foutmelding verdwijnt. Maar de spanningsdips blijven; niemand waarschuwt je alleen nog. Gebruik deze code alleen voor diagnose: als het board met de detector uit prima draait, heb je bevestigd dat het probleem zeker de voeding is. Verwijder dan de regel en repareer de voeding.

C++ (Arduino IDE)
1#include "soc/soc.h"
2#include "soc/rtc_cntl_reg.h"
3
4void setup() {
5  // YALNIZ TEŞHİS İÇİN: brownout dedektörünü kapat / DIAGNOSIS ONLY: disable the brownout detector
6  WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0);
7
8  Serial.begin(115200);
9  Serial.println("Brownout dedektoru kapali / brownout detector disabled");
10}
11
12void loop() {
13}
Laat de detector niet permanent uitgeschakeld. WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0) dempt niet alleen de waarschuwing; het schakelt ook de hardwarereset van de detector uit en zijn taak om flash en radio bij lage spanning uit te schakelen, waardoor de chip onbeschermd blijft draaien ver onder zijn minimum van 3,0 V. Zakt de spanning onder 2,4 V, dan kunnen gegevens die naar flash worden geschreven (Preferences, EEPROM, LittleFS), of zelfs het programma zelf tijdens een OTA-update, beschadigd raken, kan Wi-Fi zonder duidelijke reden wegvallen en kan het board nu crashen met Guru Meditation-fouten of helemaal vastlopen. De instelling is niet permanent: de chip schakelt de detector bij elke start weer in, dus de regel moet de eerste regel van setup() zijn, en zodra je hem verwijdert is de bescherming terug. Dit register bestaat op de klassieke ESP32, S2, S3 en C3; nieuwere modellen zoals de ESP32-C6 hebben het niet en de code compileert niet. De echte oplossing is altijd de voeding repareren.

rst-oorzaakcodes: de ESP32 vertelt waarom hij herstartte

De rst:-waarde die de ROM bij elke start print, laat zien hoe de vorige run eindigde. Bij een normale start is de bootwaarde 0x13 (SPI_FAST_FLASH_BOOT), wat betekent dat het board zijn programma vanuit flash start. De tabel hieronder toont de codes die je het vaakst ziet. ROM-codes zijn niet altijd genoeg: ESP.restart() en een herstart na een Guru Meditation verschijnen allebei als 0xc, terwijl een brownout als 0xc of 0x3 verschijnt, afhankelijk van de coreversie. Gebruik om ze te onderscheiden de sketch met esp_reset_reason() in de volgende sectie.

rst-codeNaamWat het betekent
0x1POWERON_RESETEr werd voor het eerst spanning gezet of er werd op de EN-knop gedrukt
0x3SW_RESETSoftware resette het hele digitale systeem; nieuwere coreversies tonen dit ook na een brownout
0x5DEEPSLEEP_RESETHet board werd wakker uit deep sleep (normaal)
0x7 / 0x8TG0WDT_SYS_RESET / TG1WDT_SYS_RESETEen timergroep-watchdog resette het systeem in hardware; interrupts bleven te lang uitgeschakeld of zelfs de panic handler kon niet draaien
0x9RTCWDT_SYS_RESETDe RTC-watchdog resette de digitale kern
0xcSW_CPU_RESETSoftwareherstart: ESP.restart(), na een Guru Meditation, of na een brownout in de Arduino-core
0xfRTCWDT_BROWN_OUT_RESETHardware-brownoutreset: onstabiele voedingsspanning
0x10RTCWDT_RTC_RESETDe RTC-watchdog resette de hele chip inclusief de RTC; vooral te zien op boards die tijdens het opstarten vastlopen

Diagnostische sketch: print de resetreden, het geheugen en de stack

Upload de code hieronder als aparte sketch, of voeg de regels toe aan setup() en loop() van je probleemproject. Elke keer dat het board start, print het de resetreden als leesbare tekst, hoe vaak het is opgestart en de geheugenstatus in de Serial Monitor. De teller met RTC_DATA_ATTR staat in het RTC-geheugen, dus hij overleeft softwareresets en deep sleep en wordt alleen gewist als de voeding helemaal wordt weggenomen. Loopt de teller om de paar seconden op, dan weet je meteen dat het board in een resetlus zit.

C++ (Arduino IDE)
1#include <esp_system.h>
2
3RTC_DATA_ATTR uint32_t bootCount = 0;   // yazılım resetinde korunur / survives software resets
4
5// Reset nedenini okunabilir yazıya çevir / turn the reset reason into readable text
6const char* reasonText(esp_reset_reason_t r) {
7  switch (r) {
8    case ESP_RST_POWERON:   return "POWERON: guc acilisi ya da EN / power-on or EN button";
9    case ESP_RST_SW:        return "SW: ESP.restart()";
10    case ESP_RST_PANIC:     return "PANIC: Guru Meditation";
11    case ESP_RST_INT_WDT:   return "INT_WDT: kesme watchdog'u / interrupt watchdog";
12    case ESP_RST_TASK_WDT:  return "TASK_WDT: gorev watchdog'u / task watchdog";
13    case ESP_RST_WDT:       return "WDT: diger watchdog / other watchdog";
14    case ESP_RST_DEEPSLEEP: return "DEEPSLEEP: derin uykudan uyanma / deep sleep wake-up";
15    case ESP_RST_BROWNOUT:  return "BROWNOUT: gerilim dusmesi / supply voltage dropped";
16    default:                return "UNKNOWN: bilinmiyor / unknown";
17  }
18}
19
20void setup() {
21  Serial.begin(115200);
22  delay(1000);                          // Seri Monitör'ün açılmasını bekle / wait for the Serial Monitor
23  bootCount++;
24  Serial.printf("Acilis sayisi / boot count: %u\n", (unsigned)bootCount);
25  Serial.printf("Reset nedeni / reset reason: %s\n", reasonText(esp_reset_reason()));
26}
27
28void loop() {
29  // Bellek durumu / memory status
30  Serial.printf("Bos heap / free heap: %u B, en dusuk / minimum: %u B, en buyuk blok / largest block: %u B\n",
31                (unsigned)ESP.getFreeHeap(), (unsigned)ESP.getMinFreeHeap(), (unsigned)ESP.getMaxAllocHeap());
32  // loopTask yığınında hiç kullanılmamış en küçük alan / smallest unused space on the loopTask stack
33  Serial.printf("loopTask bos yigin / free stack: %u B\n", (unsigned)uxTaskGetStackHighWaterMark(NULL));
34  delay(5000);
35}

De waarden die in de lus worden geprint, onthullen ook stille problemen. Daalt de vrije heap bij elke ronde een beetje, dan heeft je programma een geheugenlek en crasht het board vroeg of laat. Is het grootste blok veel kleiner dan de vrije heap, dan is het geheugen gefragmenteerd; dit komt meestal van String-objecten die binnen de lus steeds groeien en krimpen. Zakt de vrije stack van loopTask onder een paar honderd bytes, dan is een stack overflow nabij. Is de resetreden BROWNOUT, richt je dan op de voedingssecties; is het PANIC, TASK_WDT of INT_WDT, richt je dan op de softwaresecties hieronder.

Wat is een Guru Meditation Error? Lees de crashuitvoer regel voor regel

Een Guru Meditation Error is het crashrapport dat de panic handler print wanneer de CPU van de ESP32 een fout tegenkomt waarvan hij niet kan herstellen; de naam komt van het foutscherm van oude Amiga-computers. Het rapport ziet er eerst eng uit, maar slechts een paar regels doen ertoe. Core 1 vertelt op welke core de fout optrad: in Arduino draaien setup() en loop() op core 1, terwijl de Wi-Fi-stack op core 0 draait. De naam tussen haakjes is het type exception. Als het rapport eindigt, print het board "Rebooting..." en herstart; op de bootregel zie je dan rst:0xc.

RegelBetekenis
Guru Meditation Error: Core 1 panic'ed (LoadProhibited). Exception was unhandled.Code op core 1 probeerde van een ongeldig adres te lezen en de fout werd niet afgehandeld
PC : 0x400d1a2cAdres van de instructie die crashte; begint het met 0x400d, dan draaide je code of een bibliotheek vanuit flash
EXCCAUSE: 0x0000001cExceptioncode; 0x1c, dus 28, betekent LoadProhibited
EXCVADDR: 0x00000000Het adres waartoe toegang werd gezocht; 0 of een heel klein getal wijst op een null pointer
Backtrace: 0x400d1a29:0x3ffb2270 0x400d0f6e:0x3ffb2290 ...Aanroepketen; elk paar is PC:SP en kan met de decoder in een regel code worden omgezet
ELF file SHA256: ...Vingerafdruk van het gecrashte programma; de decoder heeft precies dezelfde build nodig
Rebooting...De panic handler herstart de chip in software

LoadProhibited, StoreProhibited en andere exceptiontypes

ExceptionEXCCAUSEWat gebeurde er?Veelvoorkomende oorzaak
LoadProhibited28 (0x1c)Lezen van een ongeldig adresNull of niet-geïnitialiseerde pointer, verwijderd object
StoreProhibited29 (0x1d)Schrijven naar een ongeldig adresSchrijven via een null pointer, buffer die een array overschrijdt
InstrFetchProhibited20 (0x14)Een instructie ophalen van een ongeldig adresNiet-toegewezen functiepointer of callback
IllegalInstruction0 (0x0)Ongeldige instructieBeschadigde stack, ontbrekende return in een functie die een waarde moet teruggeven
LoadStoreAlignment9 (0x9)Niet-uitgelijnde geheugentoegangEen bytearray casten naar een type als uint32_t*
IntegerDivideByZero6 (0x6)Gehele deling door nulDelen door een teller die nul kan zijn
Unhandled debug exception-Debug-exceptionWatchpoint van de stack canary geactiveerd: stack overflow
Interrupt wdt timeout on CPU0/CPU1-Interrupt-watchdog verlopenLange ISR, Serial of delay binnen een ISR
Cache disabled but cached memory region accessed-Code in flash benaderd terwijl de flash bezig wasInterrupthandler zonder IRAM_ATTR

De meest voorkomende van deze fouten is het gebruik van een null pointer. NULL is adres 0, en op de ESP32 is er rond adres 0 geen leesbaar geheugen, dus lezen waar een lege pointer naar wijst geeft LoadProhibited en daar schrijven geeft StoreProhibited. Hier is EXCVADDR een perfecte aanwijzing: 0x00000000 wijst naar de pointer zelf, terwijl kleine waarden zoals 0x00000004 of 0x00000010 wijzen naar een veld binnen een lege pointer (NULL plus de offset van het veld). In Arduino-projecten is de meest voorkomende oorzaak een functie die NULL teruggeeft voor "niet gevonden" waarna die waarde zonder controle wordt gebruikt. In het voorbeeld hieronder geeft strstr() NULL terug als de tekst niet wordt gevonden; zonder controle crasht het board met EXCVADDR 0x00000005.

C++ (Arduino IDE)
1const char* response = "temp=23.5;hum=40";   // sunucudan gelen yanıt / reply from a server
2
3void setup() {
4  Serial.begin(115200);
5  delay(500);
6
7  // YANLIŞ: "pres=" yoksa strstr NULL döner ve kart çöker (EXCVADDR 0x00000005)
8  // WRONG: if "pres=" is missing strstr returns NULL and the board crashes (EXCVADDR 0x00000005)
9  // float pressure = atof(strstr(response, "pres=") + 5);
10
11  // DOĞRU: işaretçiyi kullanmadan önce NULL kontrolü yap / RIGHT: check for NULL before using the pointer
12  const char* found = strstr(response, "pres=");
13  if (found != nullptr) {
14    float pressure = atof(found + 5);
15    Serial.println(pressure);
16  } else {
17    Serial.println("pres alani bulunamadi / pres field not found");
18  }
19}
20
21void loop() {
22}
Bouw een paar gewoontes op tegen null pointers: initialiseer pointers met nullptr wanneer je ze declareert, controleer de returnwaarde van de begin()-functies van bibliotheken, zet een pointer op nullptr nadat je een object hebt verwijderd, en zorg dat de index kleiner is dan de arraygrootte wanneer je naar arrays schrijft. Zet je compilerwaarschuwingen op All onder File > Preferences in de Arduino IDE, dan zie je een ontbrekende return en soortgelijke bugs al bij het compileren.

Stack overflow: de fout "Stack canary watchpoint triggered"

Op de ESP32 heeft elke taak een stack van vaste grootte, waarin lokale variabelen, functieaanroepen en terugkeeradressen worden opgeslagen. In Arduino heeft de loopTask die setup() en loop() draait een stack van 8192 bytes. Een lokale array van 10.000 bytes binnen loop() declareren, een functie die zichzelf aanroept (recursie) of een bibliotheekfunctie met veel lokale variabelen overschrijdt deze limiet. Aan het einde van de stack zit een bewakingsgebied (canary); als de stack dat bereikt, print het board Guru Meditation Error: Core 1 panic'ed (Unhandled debug exception) en direct eronder Debug exception reason: Stack canary watchpoint triggered (loopTask). De naam tussen haakjes is de taak waarvan de stack overliep. Hetzelfde probleem verschijnt soms als ***ERROR*** A stack overflow in task loopTask has been detected. Zo los je het op:

  • Verplaats grote arrays van de stack: declareer de array globaal of zet er static voor; dan staat hij in permanent RAM in plaats van op de stack.
  • Vergroot de stack van loopTask: zet SET_LOOP_TASK_STACK_SIZE(16 * 1024); bovenaan je sketch om de stack van loop() te verhogen naar 16 KB.
  • Geef je eigen taken genoeg ruimte: op de ESP32 is de stackgrootte die je aan xTaskCreate en xTaskCreatePinnedToCore meegeeft in bytes, niet in woorden zoals bij FreeRTOS op andere platforms. 1024 bytes is te weinig, zelfs voor een taak die Serial.printf gebruikt; begin met 4096.
  • Meten: uxTaskGetStackHighWaterMark(NULL) geeft in bytes de kleinste hoeveelheid stack terug die de taak tot nu toe nooit heeft gebruikt; zakt die onder een paar honderd bytes, vergroot dan de stack.
  • Vermijd recursie: zet functies die zichzelf aanroepen om in lussen of beperk hun diepte.

Task watchdog: de fout "task_wdt: Task watchdog got triggered"

Een watchdog is een timer die een vastgelopen programma opmerkt en het board redt. De Task Watchdog (Task WDT) van de ESP32 verwacht dat de taken die erbij zijn geregistreerd met regelmatige tussenpozen "ik leef nog" signaleren. In de Arduino-core bewaakt hij standaard de idle-taak (IDLE) van core 0, met een timeout van 5 seconden. Geeft een taak die op core 0 draait de CPU 5 seconden niet vrij, dan kan de IDLE-taak niet draaien en toont de Serial Monitor een melding die begint met E (10257) task_wdt: Task watchdog got triggered. Daarna volgt de lijst met taken die de watchdog niet op tijd resetten (meestal - IDLE (CPU 0)) en, onder Tasks currently running:, de taken die op dat moment draaiden. In de Arduino-core leidt dit tot een panic met de regel task_wdt: Aborting. en herstart het board.

De meest voorkomende oorzaken zijn: een lus die met xTaskCreatePinnedToCore aan core 0 is vastgepind en nooit vTaskDelay() aanroept, een while-lus die op een sensorantwoord wacht zonder timeout, of delay() en lange bewerkingen binnen de callbacks van bibliotheken zoals AsyncWebServer. In het laatste geval zie je de taak async_tcp in de lijst in plaats van IDLE. De oplossing is lange klussen in kleine stukjes te splitsen en korte pauzes zoals vTaskDelay(1) aan je lussen toe te voegen. De functie loop() zelf wordt standaard niet bewaakt; wil je dat, roep dan enableLoopWDT() aan in setup() zodat het board ook herstart wanneer loop() langer dan 5 seconden vastloopt. De watchdog uitschakelen met disableCore0WDT() verbergt de fout maar repareert de vastgelopen code niet. Meer over taken en cores lees je in ESP32 FreeRTOS en dual core. De code hieronder toont zowel een goede taakstructuur als de voorzorgen tegen stack overflow:

C++ (Arduino IDE)
1SET_LOOP_TASK_STACK_SIZE(16 * 1024);   // loop() yığını 8 KB yerine 16 KB / loop() stack 16 KB instead of 8 KB
2
3volatile uint32_t sampleCount = 0;
4
5// 0. çekirdekte çalışan görev / task running on core 0
6void sensorTask(void* parameter) {
7  for (;;) {
8    sampleCount = sampleCount + 1;       // sensörünü burada oku / read your sensor here
9    vTaskDelay(pdMS_TO_TICKS(10));       // IDLE görevine sıra ver, task_wdt tetiklenmez / let IDLE run, no task_wdt
10  }
11}
12
13void setup() {
14  Serial.begin(115200);
15  // Yığın boyutu bayt cinsindendir: 4096 bayt / stack size is in bytes: 4096 bytes
16  xTaskCreatePinnedToCore(sensorTask, "sensorTask", 4096, NULL, 1, NULL, 0);
17}
18
19void loop() {
20  static uint8_t buffer[10000];          // static: yığında değil kalıcı RAM'de / static: in RAM, not on the stack
21  memset(buffer, 0, sizeof(buffer));
22
23  Serial.printf("Ornek / samples: %u, loopTask bos yigin / free stack: %u B\n",
24                (unsigned)sampleCount, (unsigned)uxTaskGetStackHighWaterMark(NULL));
25  delay(1000);
26}

Interrupt wdt timeout en IRAM_ATTR: crashes in interrupts

De Interrupt Watchdog (Interrupt WDT) is een stuk minder geduldig: duurt een interrupthandler (ISR) of een stuk code met uitgeschakelde interrupts langer dan 300 ms, dan crasht het board met Guru Meditation Error: Core 1 panic'ed (Interrupt wdt timeout on CPU1). Serial.print, delay(), I2C of Wi-Fi gebruiken binnen een ISR is de meest voorkomende oorzaak. Flashgeheugen is nog een valkuil: terwijl Preferences, EEPROM of LittleFS naar flash schrijven, is de flashcache even uitgeschakeld. Komt er in die tijd een interrupt binnen waarvan de handler in flash staat, dan meldt het board Cache disabled but cached memory region accessed. De oplossing is ISR's te markeren met IRAM_ATTR zodat ze in RAM staan en er alleen een vlag in te zetten; loop() doet het echte werk. Variabelen die tussen een ISR en loop() worden gedeeld, moeten volatile zijn.

C++ (Arduino IDE)
1const int BUTTON_PIN = 27;              // buton GPIO 27 ile GND arasında / button between GPIO 27 and GND
2volatile bool buttonPressed = false;    // ISR ile loop arasında paylaşılan bayrak / flag shared by the ISR and loop
3uint32_t pressCount = 0;
4
5void IRAM_ATTR onButton() {             // IRAM_ATTR: fonksiyon flaşta değil RAM'de durur / the function lives in RAM, not flash
6  buttonPressed = true;                 // yalnızca bayrak kaldır, Serial yok / only set a flag, no Serial
7}
8
9void setup() {
10  Serial.begin(115200);
11  pinMode(BUTTON_PIN, INPUT_PULLUP);
12  attachInterrupt(digitalPinToInterrupt(BUTTON_PIN), onButton, FALLING);
13}
14
15void loop() {
16  if (buttonPressed) {
17    buttonPressed = false;
18    pressCount++;
19    Serial.printf("Butona basildi / button pressed: %u\n", (unsigned)pressCount);   // yavaş iş burada / slow work here
20  }
21}

De backtrace omzetten in een regel code met de ESP Exception Decoder

De adressen in de Backtrace-regel zeggen op zichzelf niets; de tool die ze omzet in het bestand, de functie en het regelnummer in je broncode heet de ESP Exception Decoder. In de oude Arduino IDE 1.8 was dat een plugin die aan het menu Tools werd toegevoegd. In Arduino IDE 2 gebruik je een door de community gemaakte extensie met dezelfde naam:

  1. Download het .vsix-bestand uit het gedeelte Releases van het project dankeboy36/esp-exception-decoder op GitHub. Kies voor Arduino IDE 2 een 1.x-release; de nieuwere 2.x-releases zijn gemaakt voor VS Code.
  2. Sluit de Arduino IDE en kopieer het bestand naar %UserProfile%\.arduinoIDE\plugins op Windows of ~/.arduinoIDE/plugins op macOS en Linux; maak de map aan als die niet bestaat.
  3. Open de IDE, open de crashende sketch, compileer hem met Verify en upload hem naar het board.
  4. Open de Serial Monitor en wacht tot de crash opnieuw gebeurt.
  5. Open het commandovenster met Ctrl+Shift+P (Cmd+Shift+P op macOS) en voer ESP Exception Decoder: Show Decoder Terminal uit.
  6. Kopieer het Guru Meditation-blok uit de Serial Monitor, inclusief de Backtrace-regel, en plak het in de terminal die opent; de tool toont elk adres met bestandsnaam, functie en regelnummer.

Kun je de extensie niet installeren, dan kun je hetzelfde werk met de hand doen. Het menu Sketch > Export Compiled Binary laat een bestand met de extensie .elf achter in de buildmap in je sketchmap. Het commando xtensa-esp32-elf-addr2line -pfiaC -e sketch.ino.elf 0x400d1a29 0x400d0f6e uit de ESP32-toolchain zet deze adressen om in functienamen en regelnummers. Gebruik je PlatformIO, voeg dan gewoon de regel monitor_filters = esp32_exception_decoder toe aan platformio.ini; crashuitvoer wordt dan automatisch gedecodeerd in de seriële monitor.

De decoder geeft alleen juiste resultaten met het .elf-bestand van precies dezelfde build die crashte. Wijzig je één regel en compileer je opnieuw, dan verschuiven de adressen en wijst de uitvoer naar de verkeerde regels. Eindigt de Backtrace-regel op CORRUPTED, dan is de stack beschadigd; dat wijst meestal op een stack overflow of een buffer die zijn grenzen overschrijdt.

Strapping pins: hoe GPIO0, GPIO2, GPIO12 en GPIO15 het opstarten kunnen verstoren

Wanneer de ESP32 start, kijkt hij naar het niveau van bepaalde pins om te bepalen hoe hij opstart. Dit zijn de strapping pins, en alleen hun niveau op het moment van reset telt; zodra het opstarten klaar is, kunnen ze als gewone GPIO's worden gebruikt. Het probleem ontstaat wanneer een sensor, knop of module die je erop aansluit de pin bij het opstarten naar het verkeerde niveau trekt. Dan start het board zijn programma helemaal niet, belandt het in programmeermodus of kan het de flash niet lezen; van buitenaf lijkt ook dat op "de ESP32 start niet op" of "hij blijft resetten". De volledige pinindeling van je board zie je in de tool Pinout.

PinInterne weerstandRol bij het opstartenWat gebeurt er bij het verkeerde niveau?
GPIO0Pull-upLOW kiest programmeermodus (download), HIGH normaal opstartenboot:0x3 (DOWNLOAD_BOOT) en wachten op download; het programma draait niet
GPIO2Pull-downMoet LOW zijn of zweven om in programmeermodus te komen; maakt voor normaal opstarten niet uitEen schakeling die hem HIGH trekt blokkeert uploads
GPIO12 (MTDI)Pull-downKiest de voedingsspanning van de flash: LOW 3,3 V, HIGH 1,8 VBij HIGH wordt een flash van 3,3 V niet goed gevoed; het board start niet of belandt in een resetlus
GPIO15 (MTDO)Pull-upLOW dempt de boot-meldingen van de ROMBootregels verschijnen niet in de Serial Monitor, wat diagnose lastiger maakt
GPIO5Pull-upStelt de SDIO-timing inVeroorzaakt zelden problemen op ontwikkelboards
Een pull-upweerstand, relais of sensormodule op GPIO12 die de pin bij het opstarten HIGH trekt, is de meest verborgen reden dat een ESP32 helemaal niet start. Moet je deze pin toch gebruiken, zorg dan dat de module hem op het moment van opstarten LOW laat. Als alternatief schrijft het commando espefuse.py set_flash_voltage 3.3V uit esptool de flashspanning permanent in een eFuse en haalt het het effect van GPIO12 bij het opstarten weg; dit kan echter niet ongedaan worden gemaakt en mag alleen bij modules met 3,3V-flash (zoals de ESP32-WROOM-32).

Nieuwere boards hebben andere strapping pins: op de ESP32-S3 zijn dat GPIO0, GPIO3, GPIO45 en GPIO46, en op de ESP32-C3 beïnvloeden GPIO2, GPIO8 en GPIO9 het opstarten. De ESP32-S3 gebruikt dezelfde Xtensa-exceptionnamen als de klassieke ESP32. Op de op RISC-V gebaseerde ESP32-C3 zie je echter Load access fault in plaats van LoadProhibited en Store access fault in plaats van StoreProhibited, en het register MTVAL neemt de rol van EXCVADDR over. De brownoutmelding is op elk model hetzelfde.

ESP32 en Raspberry Pi Pico in MicroPython

Programmeer je de ESP32 in MicroPython, dan gebeuren brownouts precies op dezelfde manier, omdat het probleem in de hardware zit en niet in de software. Fouten in Python-code verschijnen daarentegen als een leesbare Traceback in plaats van een Guru Meditation, en het board crasht zelden. Je kunt de resetreden lezen met machine.reset_cause(), maar let op: de ESP32-port van MicroPython geeft een brownout niet als aparte waarde terug, maar meldt hem samen met het inschakelen als PWRON_RESET. Blijft het board met PWRON_RESET starten terwijl je er niets aan hebt gedaan, verdenk dan opnieuw de voeding. De code hieronder is voor de ESP32; op de Raspberry Pi Pico kent de module machine minder resettypen. Op de Pico werkt de buck-boostregelaar op de VSYS-ingang met alles van 1,8 tot 5,5 V, dus brownoutproblemen zijn veel zeldzamer; om het board te leren kennen, zie Wat is de Raspberry Pi Pico?

MicroPython
1import machine, gc, time
2
3# Reset nedenleri (ESP32 için) / reset causes (for ESP32)
4causes = {
5    machine.PWRON_RESET: "PWRON: guc acilisi ya da brownout / power-on or brownout",
6    machine.HARD_RESET: "HARD: cokme ya da machine.reset() / crash or machine.reset()",
7    machine.WDT_RESET: "WDT: watchdog",
8    machine.DEEPSLEEP_RESET: "DEEPSLEEP: derin uykudan uyanma / deep sleep wake-up",
9    machine.SOFT_RESET: "SOFT: Ctrl+D ile yazilim reseti / soft reset with Ctrl+D",
10}
11print("Reset nedeni / reset cause:", causes.get(machine.reset_cause(), "bilinmiyor / unknown"))
12
13while True:
14    gc.collect()                                     # çöp toplayıcıyı çalıştır / run the garbage collector
15    print("Bos RAM / free RAM:", gc.mem_free(), "bayt / bytes")
16    time.sleep(5)

Veelgemaakte fouten en oplossingen

SymptoomWaarschijnlijke oorzaakOplossing
Brownout detector was triggered wanneer Wi-Fi startKabel, poort of regelaar kan de piekstroom niet bijbenenKorte dikke kabel, adapter van 1 A, 470 µF + 100 nF tussen 3V3 en GND
Reset wanneer een servo draait of een relais schakeltDe belasting deelt de voedingslijn van de ESP32Voed de belasting met een aparte 5V-voeding en verbind de GND's
Resets beginnen zodra de batterij een beetje leeg isDropout van de AMS1117Gebruik een LDO of een buck-boostconverter
Guru Meditation, EXCVADDR 0x00000000Null pointerControleer de pointer voordat je hem gebruikt
Stack canary watchpoint triggered (loopTask)De stack van loop() zit volMaak grote arrays static of gebruik SET_LOOP_TASK_STACK_SIZE
task_wdt: - IDLE (CPU 0)Lus zonder pauzes op core 0Voeg vTaskDelay toe aan de lus
Interrupt wdt timeout on CPU1ISR duurt te langZet in de ISR alleen een vlag, gebruik IRAM_ATTR
Board stil, boot:0x3 en wachten op downloadGPIO0 LOW bij het opstartenHaal de schakeling van GPIO0 af, druk op EN
Board start helemaal niet, flashleesfoutGPIO12 HIGH bij het opstartenVerplaats de pull-up of de module op GPIO12 naar een andere pin
Failed to connect to ESP32 tijdens het uploadenGPIO2 HIGH of het board kan niet in programmeermodus komenMaak GPIO2 vrij, houd BOOT ingedrukt zodra de upload start
Houd bij het problemen oplossen de volgorde aan: wissel eerst de kabel en de voeding, voeg dan de condensator toe en voed daarna de servo's en leds apart. Gaan de resets door nadat de brownoutmelding weg is, controleer dan de resetreden in de diagnostische sketch en ga verder met de softwaresecties. Zet je Tools > Core Debug Level op Verbose, dan print de ESP32-core veel gedetailleerdere meldingen over Wi-Fi en systeemgebeurtenissen. Kijk bij uploadproblemen ook eens naar Arduino-code wordt niet geüpload.

Je board draait stabiel: wat nu?

  • Batterijvriendelijk apparaat: zet het board met ESP32 deep sleep tussen metingen in slaap en trek stroom in het microamperebereik.
  • Draadloze updates: upload code zonder USB-kabel met ESP32 OTA.
  • Realtime dashboard: bekijk sensorgegevens live in de browser met ESP32 WebSocket.
  • Meldingen versturen: krijg met een ESP32 Telegram-bot elke keer dat het board herstart de resetreden op je telefoon.
  • Lichtshow: stuur een WS2812B NeoPixel-strip veilig aan met een aparte voeding.

De meeste herstartproblemen van de ESP32 zijn óf een voedingsprobleem óf een paar regels foutieve code; zodra je de melding goed leest, zijn beide snel opgelost. Wil je de basis van het board opfrissen, kijk dan eens naar Wat is de ESP32? In de BlueGrays-app vind je ESP32-projecten met leds, servo's, NeoPixel-strips, wifiverbindingen, een webserver, OTA-updates en deep sleep, elk met een stap-voor-stap-schakelschema en code, zodat je de voedings- en diagnosetechnieken die je hier hebt geleerd in echte projecten kunt uitproberen.

Veelgestelde vragen

Hoe los ik ESP32 brownout detector was triggered op?

Deze fout betekent dat de voedingsspanning van de ESP32 kort onder ongeveer 2,43 V zakte. Gebruik eerst een korte, dikke USB-kabel met een 5V-voeding van minstens 1 A en voeg dan een elco van 100–470 µF en een keramische condensator van 100 nF toe tussen 3V3 en GND. Voed belastingen zoals servo's, relais en ledstrips met een aparte voeding en verbind de GND's met elkaar.

Waarom blijft mijn ESP32 herstarten?

De meest voorkomende oorzaken zijn een onvoldoende voeding (brownout), softwarecrashes (Guru Meditation), watchdog-timeouts en strapping pins die bij het opstarten op het verkeerde niveau staan. Open de Serial Monitor op 115200 baud en druk op EN; de laatste melding vóór de reset en de rst-code bij het opstarten laten de oorzaak zien. Met de functie esp_reset_reason() kun je hem ook vanuit je code uitlezen.

Wat betekent Guru Meditation Error LoadProhibited?

Het betekent dat code op de ESP32 probeerde van een ongeldig geheugenadres te lezen. Is EXCVADDR 0 of een heel klein getal, dan is vrijwel zeker een null pointer gebruikt. Plak de Backtrace-regel in de ESP Exception Decoder om het bestand en de regel te vinden waar de fout optrad.

Kan ik de brownout detector van de ESP32 uitschakelen?

Ja, de regel WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0) schakelt hem uit, maar dat dempt alleen de waarschuwing. Omdat de spanningsdips doorgaan, kunnen gegevens in flash beschadigd raken en kan het board met andere fouten crashen. Gebruik dit alleen kort om te bevestigen dat het probleem uit de voeding komt.

Hoe los ik ESP32 Task watchdog got triggered op?

Deze melding betekent dat een bewaakte taak de CPU 5 seconden niet vrijgaf; in Arduino toont de lijst meestal de IDLE-taak van core 0. Voeg vTaskDelay() toe aan de lussen in je eigen taken, gebruik timeouts wanneer je op sensoren wacht en vermijd delay() of lange bewerkingen in webservercallbacks. De watchdog uitschakelen verbergt de fout maar lost de oorzaak niet op.

Welke voeding heeft een ESP32 nodig?

Espressif raadt een voeding aan die minstens 500 mA kan leveren voor de ESP32; in de praktijk laat een 5V-adapter van 1 A een veilige marge. Gebruik je een ESP32-CAM of voeg je belastingen zoals servo's of ledstrips toe, kies dan een voeding van 2 A of meer en voed die belastingen zo mogelijk via een aparte lijn.

Alle projecten bekijken
Led laten knipperen met ESP32
ES-1Beginner

Led laten knipperen met ESP32

Leert je het basisgebruik van een GPIO-uitgang met de ESP32. Door een led via een digitale pin aan en uit te zetten krijgen we een knippereffect. Dit is de ESP32-versie van het klassieke blinkproject op de Arduino UNO; de basiscommando's in de Arduino-omgeving zijn hetzelfde, maar de pinindeling en de 3,3 V-GPIO-niveaus van de ESP32 verschillen van die van de Arduino UNO.

4.7(37)
108
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-servomotor (bediening met potentiometer)
ES-16Gemiddeld
Premium

ESP32-servomotor (bediening met potentiometer)

In dit project bedien je een SG90-servomotor met een potentiometer. De analoge waarde van de potentiometer zet je om naar het bereik van 0–180 graden en zo stel je de servohoek in. De ESP32Servo-bibliotheek maakt het servosignaal op geschikte GPIO-pinnen van de ESP32 die als uitgang kunnen dienen; dit project gebruikt GPIO 18. Dit is een basismethode voor robotarmen, cameragimbals en automatische deurmechanismen.

4.3(29)
42
ESP32 WS2812B NeoPixel-strip aansturen
ES-24Gemiddeld
Premium

ESP32 WS2812B NeoPixel-strip aansturen

WS2812B-leds (NeoPixel) zijn adresseerbare slimme RGB-leds die je kunt doorlussen en via één datapin kunt aansturen. In dit project sturen we een WS2812B-strip met 8 leds aan met de Adafruit_NeoPixel-bibliotheek en maken we een vloeiende regenbooganimatie. De 3,3V-logica van de ESP32 werkt met de meeste WS2812B-batches; wordt het instabiel, dan laten we de oplossing zien met een serieweerstand van 470Ω en een condensator van 1000µF. De animatie schuift de tint op in de HSV-kleurruimte.

4.9(19)
30
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 Deep Sleep: batterij sparen (OLED + RTC RAM-teller)
ES-33Gevorderd
Premium

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.

4.3(10)
16
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
ESP32-bewegingsalarm (PIR + buzzer + LED + Telegram)
ES-41Gevorderd
Premium

ESP32-bewegingsalarm (PIR + buzzer + LED + Telegram)

Een slim beveiligingsalarm: als de PIR-sensor beweging detecteert, gaat de buzzer af, licht de LED op en krijgt de eigenaar direct een Telegram-melding. Een afkoeltijd van 30 seconden beperkt hoe vaak het alarm zich herhaalt; valse detecties van de PIR-sensor filtert dit niet weg. Gebruik het thuis, in een garage, een berging of een studeerkamer.

9