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.

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 Monitor | Betekenis | Waar kijken |
|---|---|---|
| Brownout detector was triggered | De voedingsspanning zakte onder de drempel | Voeding, kabel, condensator |
| Guru Meditation Error: Core 1 panic'ed (LoadProhibited) | De code probeerde van een ongeldig adres te lezen | Null pointer, arraygrenzen |
| Guru Meditation Error: Core 1 panic'ed (StoreProhibited) | De code probeerde naar een ongeldig adres te schrijven | Null pointer, bufferoverflow |
| Stack canary watchpoint triggered (loopTask) | De stack van een taak liep vol | Grote lokale arrays, recursie |
| task_wdt: Task watchdog got triggered | Een taak gaf de CPU langer dan 5 seconden niet vrij | Lussen zonder pauzes, vastgelopen taken |
| Interrupt wdt timeout on CPU0 / CPU1 | Een interrupthandler of uitgeschakelde interrupts duurden langer dan 300 ms | Lange ISR, Serial binnen een ISR |
| boot:0x3 (DOWNLOAD_BOOT...) waiting for download | Het board startte in programmeermodus | GPIO0 LOW bij het opstarten |
| invalid header of flash read err | Het flashgeheugen kon niet worden gelezen | GPIO12 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:
| Bedrijfstoestand | Typische stroom (ESP32-chip) |
|---|---|
| Deep sleep (RTC-timer aan) | Ongeveer 10 µA |
| Light sleep | Ongeveer 0,8 mA |
| Wi-Fi uit, CPU op 240 MHz | 30–68 mA |
| Wi-Fi ontvangen (RX) | 95–100 mA |
| Wi-Fi zenden, 802.11b, 19,5 dBm | Ongeveer 240 mA |
| Radiokalibratie bij het opstarten en op het moment van verbinden | Kan 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.
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.

| Voedingsopstelling | Brownoutrisico | Opmerking |
|---|---|---|
| Korte, dikke kabel en een USB-poort aan de achterkant | Laag | De makkelijkste oplossing tijdens het ontwikkelen |
| Lange, dunne kabel, voorpoort of hub | Hoog | De kabelweerstand trekt de spanning omlaag bij piekstroom |
| 5V-adapter van minstens 1 A, op de 5V- of VIN-pin | Laag | Aanbevolen voor permanente projecten |
| Kant-en-klare 3,3V-voeding rechtstreeks op de 3V3-pin | Hangt van de voeding af | Moet minstens 500 mA leveren en nooit meer dan 3,6 V |
| Li-ioncel van 3,7 V via de AMS1117 | Hoog | Onder 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-boostconverter | Laag | Levert een stabiele 3,3 V, ook terwijl de cel ontlaadt |
| Twee AA-batterijen rechtstreeks op de 3V3-pin | Zeer hoog | Onder 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.

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.

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.
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}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-code | Naam | Wat het betekent |
|---|---|---|
| 0x1 | POWERON_RESET | Er werd voor het eerst spanning gezet of er werd op de EN-knop gedrukt |
| 0x3 | SW_RESET | Software resette het hele digitale systeem; nieuwere coreversies tonen dit ook na een brownout |
| 0x5 | DEEPSLEEP_RESET | Het board werd wakker uit deep sleep (normaal) |
| 0x7 / 0x8 | TG0WDT_SYS_RESET / TG1WDT_SYS_RESET | Een timergroep-watchdog resette het systeem in hardware; interrupts bleven te lang uitgeschakeld of zelfs de panic handler kon niet draaien |
| 0x9 | RTCWDT_SYS_RESET | De RTC-watchdog resette de digitale kern |
| 0xc | SW_CPU_RESET | Softwareherstart: ESP.restart(), na een Guru Meditation, of na een brownout in de Arduino-core |
| 0xf | RTCWDT_BROWN_OUT_RESET | Hardware-brownoutreset: onstabiele voedingsspanning |
| 0x10 | RTCWDT_RTC_RESET | De 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.
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.
| Regel | Betekenis |
|---|---|
| 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 : 0x400d1a2c | Adres van de instructie die crashte; begint het met 0x400d, dan draaide je code of een bibliotheek vanuit flash |
| EXCCAUSE: 0x0000001c | Exceptioncode; 0x1c, dus 28, betekent LoadProhibited |
| EXCVADDR: 0x00000000 | Het 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
| Exception | EXCCAUSE | Wat gebeurde er? | Veelvoorkomende oorzaak |
|---|---|---|---|
| LoadProhibited | 28 (0x1c) | Lezen van een ongeldig adres | Null of niet-geïnitialiseerde pointer, verwijderd object |
| StoreProhibited | 29 (0x1d) | Schrijven naar een ongeldig adres | Schrijven via een null pointer, buffer die een array overschrijdt |
| InstrFetchProhibited | 20 (0x14) | Een instructie ophalen van een ongeldig adres | Niet-toegewezen functiepointer of callback |
| IllegalInstruction | 0 (0x0) | Ongeldige instructie | Beschadigde stack, ontbrekende return in een functie die een waarde moet teruggeven |
| LoadStoreAlignment | 9 (0x9) | Niet-uitgelijnde geheugentoegang | Een bytearray casten naar een type als uint32_t* |
| IntegerDivideByZero | 6 (0x6) | Gehele deling door nul | Delen door een teller die nul kan zijn |
| Unhandled debug exception | - | Debug-exception | Watchpoint van de stack canary geactiveerd: stack overflow |
| Interrupt wdt timeout on CPU0/CPU1 | - | Interrupt-watchdog verlopen | Lange ISR, Serial of delay binnen een ISR |
| Cache disabled but cached memory region accessed | - | Code in flash benaderd terwijl de flash bezig was | Interrupthandler 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.
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}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:
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.
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:
- 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.
- 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.
- Open de IDE, open de crashende sketch, compileer hem met Verify en upload hem naar het board.
- Open de Serial Monitor en wacht tot de crash opnieuw gebeurt.
- Open het commandovenster met Ctrl+Shift+P (Cmd+Shift+P op macOS) en voer ESP Exception Decoder: Show Decoder Terminal uit.
- 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.
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.
| Pin | Interne weerstand | Rol bij het opstarten | Wat gebeurt er bij het verkeerde niveau? |
|---|---|---|---|
| GPIO0 | Pull-up | LOW kiest programmeermodus (download), HIGH normaal opstarten | boot:0x3 (DOWNLOAD_BOOT) en wachten op download; het programma draait niet |
| GPIO2 | Pull-down | Moet LOW zijn of zweven om in programmeermodus te komen; maakt voor normaal opstarten niet uit | Een schakeling die hem HIGH trekt blokkeert uploads |
| GPIO12 (MTDI) | Pull-down | Kiest de voedingsspanning van de flash: LOW 3,3 V, HIGH 1,8 V | Bij HIGH wordt een flash van 3,3 V niet goed gevoed; het board start niet of belandt in een resetlus |
| GPIO15 (MTDO) | Pull-up | LOW dempt de boot-meldingen van de ROM | Bootregels verschijnen niet in de Serial Monitor, wat diagnose lastiger maakt |
| GPIO5 | Pull-up | Stelt de SDIO-timing in | Veroorzaakt zelden problemen op ontwikkelboards |
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?
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
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| Brownout detector was triggered wanneer Wi-Fi start | Kabel, poort of regelaar kan de piekstroom niet bijbenen | Korte dikke kabel, adapter van 1 A, 470 µF + 100 nF tussen 3V3 en GND |
| Reset wanneer een servo draait of een relais schakelt | De belasting deelt de voedingslijn van de ESP32 | Voed de belasting met een aparte 5V-voeding en verbind de GND's |
| Resets beginnen zodra de batterij een beetje leeg is | Dropout van de AMS1117 | Gebruik een LDO of een buck-boostconverter |
| Guru Meditation, EXCVADDR 0x00000000 | Null pointer | Controleer de pointer voordat je hem gebruikt |
| Stack canary watchpoint triggered (loopTask) | De stack van loop() zit vol | Maak grote arrays static of gebruik SET_LOOP_TASK_STACK_SIZE |
| task_wdt: - IDLE (CPU 0) | Lus zonder pauzes op core 0 | Voeg vTaskDelay toe aan de lus |
| Interrupt wdt timeout on CPU1 | ISR duurt te lang | Zet in de ISR alleen een vlag, gebruik IRAM_ATTR |
| Board stil, boot:0x3 en wachten op download | GPIO0 LOW bij het opstarten | Haal de schakeling van GPIO0 af, druk op EN |
| Board start helemaal niet, flashleesfout | GPIO12 HIGH bij het opstarten | Verplaats de pull-up of de module op GPIO12 naar een andere pin |
| Failed to connect to ESP32 tijdens het uploaden | GPIO2 HIGH of het board kan niet in programmeermodus komen | Maak GPIO2 vrij, houd BOOT ingedrukt zodra de upload start |
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.
Projecten om hierna te bouwen
Alle projecten bekijken
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.

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

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

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

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

