ESP32 deep sleep: wekbronnen, stroomverbruik en batterijduur
ESP32 deep sleep uitgelegd: µA-stroomverbruik in elke slaapmodus, wakker worden met timer, knop, PIR en aanraking (ext0/ext1), RTC-geheugentellers en de batterijduur van een 18650.
ESP32 deep sleep is de energiemodus waarin de ESP32 zijn processors, zijn Wi-Fi- en Bluetooth-radio en zijn hoofdgeheugen uitschakelt en alleen het kleine RTC-domein actief houdt. In deze modus zakt het verbruik van de chip van 240 mA tijdens het zenden via Wi-Fi naar ongeveer 10 µA, een afname met een factor vierentwintigduizend. Het board wordt wakker wanneer de ingestelde tijd om is, wanneer een knop wordt ingedrukt, wanneer een PIR-sensor beweging ziet of wanneer een pin wordt aangeraakt; het doet zijn werk in een paar seconden en gaat weer slapen. Zo draaien weerstations, tuinsensoren, deuralarmen en loggers op afstand met batterijen maandenlang in plaats van dagen op één 18650-cel.
In deze gids leer je de slaapmodi van de ESP32 en hun werkelijke stroomwaarden, hoe je het board wekt met een timer, een knop, een PIR-sensor (ext0 en ext1) of een aanraking, hoe je tellers en metingen bewaart in RTC-geheugen dat de slaap overleeft, waarom ontwikkelboards ook tijdens het slapen nog milliampères trekken en hoe je stap voor stap berekent hoeveel maanden één 18650 het volhoudt. De Arduino-sketches zijn geschreven voor versie 3.1 of nieuwer van de ESP32 Arduino core, en aan het eind zie je hoe je hetzelfde doet in MicroPython.

Wat is ESP32 deep sleep en hoe werkt het?
In de ESP32 zitten twee gescheiden werelden. De eerste is het hoofddomein met de processors, 520 KB RAM en de Wi-Fi- en Bluetooth-radio. De tweede is het RTC-domein, met een eigen kleine timer, 8 KB RTC FAST- en 8 KB RTC SLOW-geheugen, de RTC-GPIO-pins en een coprocessor met ultralaag verbruik, de ULP. In deep sleep is het hoofddomein volledig uitgeschakeld en blijft alleen het RTC-domein draaien. Als het tijd is om wakker te worden, herstart de chip eigenlijk: de bootloader draait, het programma wordt opnieuw uit flash geladen en setup() begint weer bovenaan. Daarom doet een deep-sleepprogramma al zijn werk in setup() en draait loop() nooit. Gewone variabelen worden bij elke wake-up gereset; alleen variabelen die je in RTC-geheugen plaatst blijven behouden.
Slaapmodi van de ESP32 en stroomverbruik (µA)
| Modus | Wat blijft er draaien? | Stroom (ESP32-chip) |
|---|---|---|
| Actief: Wi-Fi zenden (802.11b, 19,5 dBm) | CPU en radio | 240 mA |
| Actief: Wi-Fi ontvangen en luisteren | CPU en radio | 95–100 mA |
| Modem sleep, 240 MHz | CPU draait, radio uit | 30–68 mA |
| Modem sleep, 80 MHz | CPU draait langzamer, radio uit | 20–31 mA |
| Light sleep | CPU gepauzeerd, RAM behouden | 0,8 mA |
| Deep sleep met ULP aan | RTC-domein en ULP-coprocessor | 150 µA |
| Deep sleep | RTC-timer en RTC-geheugen | 10 µA |
| Hibernation | Alleen RTC-timer en enkele RTC-pins | 5 µA |
| Uit (EN-pin LOW) | Niets | 1 µA |
Deze waarden komen uit de ESP32-datasheet van Espressif en gelden voor de chip alleen. Twee punten in de tabel verdienen aandacht. Ten eerste gaat het programma in light sleep verder op de regel waar het stopte en blijft alles in het RAM behouden, maar het verbruik is tachtig keer hoger dan in deep sleep, dus het past bij pauzes van een paar seconden. In deep sleep begint het programma opnieuw, maar zakt het verbruik naar microampères, wat de juiste keuze is voor wachttijden van minuten of uren. Ten tweede houdt geen van beide slaapmodi de Wi-Fi- of Bluetooth-verbinding in stand; je moet bij elke wake-up opnieuw verbinden. Nieuwere chips verschillen iets: de ESP32-C3 trekt in deep sleep ongeveer 5 µA en de ESP32-S3 ongeveer 7–8 µA.
Wil je een nog lager verbruik, dan kun je ook de RTC-randapparatuur en het RTC-geheugen uitschakelen. Schrijf esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_OFF) en dezelfde regel voor ESP_PD_DOMAIN_RTC_SLOW_MEM en ESP_PD_DOMAIN_RTC_FAST_MEM, en de chip komt in de buurt van de hibernationmodus met ongeveer 5 µA. In dat geval gaan variabelen in het RTC-geheugen verloren en kunnen alleen de timer of ext1 het board wekken. In de meeste projecten is het verschil tussen 10 µA en 5 µA te verwaarlozen naast de rest van het board, dus los eerst de problemen in het volgende hoofdstuk op.
Waarom trekken ontwikkelboards milliampères in deep sleep?
Als je je sketch uploadt en een multimeter aansluit, zie je vaak 5–15 mA in plaats van 10 µA. Het probleem is niet de chip maar de extra onderdelen op het board. De meeste goedkope DevKit- en NodeMCU-32S-boards gebruiken een AMS1117-regelaar om 5 V naar 3,3 V te verlagen, en alleen die regelaar verspilt al typisch 5 mA, ook zonder belasting. Dan komen daar een permanent brandende voedingsled en de USB-naar-serieel-chip bij die met je computer praat (CP2102 of CH340). Samen komen ze meestal op ongeveer 8 mA en leegt dat zo'n 190 mAh per dag uit de batterij, ook terwijl de ESP32 slaapt, dus een 18650 van 3000 mAh houdt het met zo'n board nauwelijks twee weken vol. Om de stroom te meten zet je de multimeter in serie tussen de batterij en de schakeling en schakel je tijdens de slaap naar het µA-bereik; de details staan in de gids een multimeter gebruiken.
| Stroombron | Stroom tijdens slaap | Oplossing |
|---|---|---|
| ESP32-module (deep sleep) | ≈10 µA | Al laag, niets aan te doen |
| AMS1117-regelaar | Typisch 5 mA (ruststroom) | Gebruik een MCP1700 (1,6 µA ruststroom) of een HT7333 (ongeveer 4 µA) |
| Voedingsled | 1–3 mA | Verwijder de led of zijn weerstand |
| USB-naar-serieel-chip (CP2102, CH340) | Hangt af van het board, kan in het mA-bereik komen | Gebruik een board zonder USB-chip of een kale module |
| Batterijdeler 100 kΩ + 100 kΩ | 21 µA (bij 4,2 V) | Gebruik 1 MΩ + 1 MΩ of schakel de deler alleen tijdens het meten in met een MOSFET |
| Sensoren die permanent voeding hebben | Van µA tot mA, afhankelijk van de sensor | Voed de sensor alleen tijdens het meten via een GPIO of een MOSFET |
Je eerste deep-sleepsketch: wakker worden met een timer
- Installeer in de Boards Manager van Arduino IDE het pakket esp32 by Espressif Systems (versie 3.1 of nieuwer) en kies ESP32 Dev Module als board.
- Upload de sketch hieronder en open de Serial Monitor op 115200 baud.
- Het board wordt elke 10 seconden wakker; zie de bootteller oplopen en de wekreden als Timer verschijnen.
- Druk op de EN-knop: de teller gaat terug naar 1, omdat dit een gewone reset is en geen wake-up uit deep sleep.
- Zet in je echte project TIME_TO_SLEEP op 600 (10 minuten) of 3600 (1 uur).
1// ESP32 deep sleep: zamanlayıcıyla uyanma ve RTC sayaç / timer wake-up and RTC counter
2#define uS_TO_S_FACTOR 1000000ULL // 1 saniye = 1.000.000 µs / 1 second = 1,000,000 µs
3#define TIME_TO_SLEEP 10 // uyku süresi, saniye / sleep time in seconds
4
5RTC_DATA_ATTR int bootCount = 0; // RTC belleğinde, derin uykuda silinmez / in RTC memory, kept in deep sleep
6
7void printWakeupReason() {
8 esp_sleep_wakeup_cause_t cause = esp_sleep_get_wakeup_cause();
9 switch (cause) {
10 case ESP_SLEEP_WAKEUP_TIMER: Serial.println("Zamanlayici / Timer"); break;
11 case ESP_SLEEP_WAKEUP_EXT0: Serial.println("ext0 (tek pin / single pin)"); break;
12 case ESP_SLEEP_WAKEUP_EXT1: Serial.println("ext1 (coklu pin / multiple pins)"); break;
13 case ESP_SLEEP_WAKEUP_TOUCHPAD: Serial.println("Dokunmatik / Touch"); break;
14 default: Serial.printf("Ilk acilis ya da reset / Power-on or reset (%d)\n", (int)cause); break;
15 }
16}
17
18void setup() {
19 Serial.begin(115200);
20 delay(500); // Seri Monitör'e zaman tanı / give the Serial Monitor time
21 bootCount++;
22 Serial.printf("Uyanis sayisi / Boot count: %d\n", bootCount);
23 printWakeupReason();
24
25 // Burada sensörü oku, veriyi gönder / read the sensor and send the data here
26
27 esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR); // 10 s sonra uyan / wake after 10 s
28 Serial.println("Derin uyku basliyor / Entering deep sleep");
29 Serial.flush(); // yazı bitmeden uyuma / finish printing before sleeping
30 esp_deep_sleep_start(); // buradan sonrası çalışmaz / nothing below runs
31}
32
33void loop() {
34 // Derin uykuda loop() hiç çalışmaz / loop() never runs with deep sleep
35}Het hart van de sketch bestaat uit twee regels: esp_sleep_enable_timer_wakeup() stelt de wektijd in microseconden in en esp_deep_sleep_start() stuurt de chip meteen slapen; niets wat je na die regel schrijft wordt ooit uitgevoerd. Vergeet het achtervoegsel ULL (64-bit) niet bij het berekenen van de tijd: 3600 * 1000000 loopt over in een 32-bit int, de compiler geeft slechts een waarschuwing, en het board wordt op het verkeerde moment wakker of helemaal niet. Serial.flush() wacht tot de zendbuffer leeg is; zonder die regel worden de laatste regels afgekapt. esp_sleep_get_wakeup_cause() vertelt waarom het board wakker werd en geeft na de eerste inschakeling of een reset geen wekbron terug. De RTC-timer die de slaaptijd telt, draait standaard op een interne RC-oscillator van ongeveer 150 kHz. Die is niet zo stabiel als een kristal en kan met de temperatuur enkele procenten afwijken, dus in projecten waar de klok ertoe doet is het verstandig om de tijd te synchroniseren met NTP als het board wakker wordt.
Tellers en metingen bewaren in het RTC-geheugen
Als je iets tussen twee wake-ups wilt onthouden, zet dan RTC_DATA_ATTR voor de variabele: de compiler plaatst hem dan in het 8 KB RTC SLOW-geheugen, dat in deep sleep onder spanning blijft, in plaats van in het hoofd-RAM. Het is ideaal voor kleine gegevens zoals tellers, recente metingen, informatie over het Wi-Fi-kanaal of de laatste temperatuur die je hebt verstuurd. Dit geheugen is echter niet permanent: volgens de documentatie van Espressif worden gegevens in het RTC-geheugen bij elke herstart opnieuw geïnitialiseerd, behalve bij een wake-up uit deep sleep. De batterij wisselen, op EN drukken, nieuwe code uploaden of ESP.restart() aanroepen reset de teller. Sla instellingen die een stroomuitval moeten overleven op in flash met de bibliotheek Preferences, maar doe dat niet bij elke wake-up, want flash heeft een beperkt aantal schrijfcycli.
| Gebeurtenis | Gewone variabele | RTC_DATA_ATTR | Preferences (flash) |
|---|---|---|---|
| Wake-up uit deep sleep | Reset | Behouden | Behouden |
| EN-knop of ESP.restart() | Reset | Terug naar beginwaarde | Behouden |
| Batterij verwijderd, stroom uitgevallen | Reset | Verloren | Behouden |
| Nieuwe code geüpload | Reset | Verloren | Behouden (tenzij flash wordt gewist) |
Verstandig gebruikt kan dit geheugen je batterijduur vermenigvuldigen. Verbinden met Wi-Fi is het duurste deel van elke wake-up. Daarom meet de sketch hieronder elke 10 minuten de batterijspanning, maar zet hij Wi-Fi slechts één keer per uur aan: zes metingen stapelen zich op in een array in het RTC-geheugen en bij de zesde wake-up worden ze allemaal tegelijk verstuurd. De sketch slaat ook het kanaal en het MAC-adres (BSSID) van het accesspoint op in het RTC-geheugen, zodat de ESP32 bij de volgende verbinding rechtstreeks naar dat accesspoint gaat zonder alle kanalen af te zoeken, wat de verbindingstijd merkbaar verkort.
1// RTC belleğinde ölçüm biriktirip saatte bir gönderme / buffer readings in RTC memory, send hourly
2#include <WiFi.h>
3
4const char* SSID = "AgAdi"; // Wi-Fi adı / Wi-Fi name
5const char* PASS = "Sifre123"; // Wi-Fi şifresi / Wi-Fi password
6const int BAT_PIN = 35; // 1M + 1M bölücünün orta noktası / divider midpoint
7const uint64_t SLEEP_US = 600ULL * 1000000ULL; // 10 dakika / 10 minutes
8const int BATCH = 6; // 6 ölçümde bir gönder / send every 6 readings
9
10RTC_DATA_ATTR float readings[BATCH]; // uykuda korunan ölçümler / readings kept in sleep
11RTC_DATA_ATTR int count = 0; // biriken ölçüm sayısı / number of stored readings
12RTC_DATA_ATTR int32_t savedChannel = 0; // son Wi-Fi kanalı / last Wi-Fi channel
13RTC_DATA_ATTR uint8_t savedBssid[6]; // modemin MAC adresi / access point MAC address
14
15bool connectFast() {
16 WiFi.mode(WIFI_STA);
17 if (savedChannel > 0) {
18 WiFi.begin(SSID, PASS, savedChannel, savedBssid); // taramadan bağlan / connect without scanning
19 } else {
20 WiFi.begin(SSID, PASS); // ilk sefer: normal bağlantı / first time: normal connect
21 }
22 unsigned long start = millis();
23 while (WiFi.status() != WL_CONNECTED) {
24 if (millis() - start > 10000) { // 10 s içinde bağlanamazsa vazgeç / give up after 10 s
25 savedChannel = 0; // bir dahaki sefere tara / scan next time
26 return false;
27 }
28 delay(50);
29 }
30 savedChannel = WiFi.channel();
31 memcpy(savedBssid, WiFi.BSSID(), 6);
32 return true;
33}
34
35void setup() {
36 Serial.begin(115200);
37 // Pili Wi-Fi açılmadan önce ölç / measure the battery before Wi-Fi starts
38 float v = analogReadMilliVolts(BAT_PIN) * 2 / 1000.0; // bölücü gerilimi yarıya indirir / divider halves it
39 readings[count++] = v;
40 Serial.printf("Olcum / Reading %d: %.2f V\n", count, v);
41
42 if (count >= BATCH) {
43 if (connectFast()) {
44 for (int i = 0; i < BATCH; i++) {
45 Serial.printf("Gonder / Send: %.2f V\n", readings[i]); // burada HTTP ya da MQTT / HTTP or MQTT here
46 }
47 count = 0;
48 } else {
49 for (int i = 1; i < BATCH; i++) readings[i - 1] = readings[i]; // en eskiyi at / drop the oldest
50 count = BATCH - 1;
51 }
52 WiFi.disconnect(true);
53 WiFi.mode(WIFI_OFF); // radyoyu kapat / turn the radio off
54 }
55
56 Serial.flush();
57 esp_sleep_enable_timer_wakeup(SLEEP_US);
58 esp_deep_sleep_start();
59}
60
61void loop() {
62}De batterijspanning wordt gehalveerd door een spanningsdeler van 1 MΩ + 1 MΩ en gelezen op GPIO 35, een ADC1-kanaal. Een condensator van 100 nF tussen het middelpunt van de deler en GND houdt de meting stabiel, ook met zo'n hoogohmige deler. Meten voordat Wi-Fi start is ook belangrijk, want de stroom die de radio trekt laat de batterijspanning even inzakken. Als Wi-Fi niet kan verbinden, wordt de oudste meting weggegooid en blijven de rest bewaard voor de volgende poging. De radio netjes uitschakelen met WiFi.disconnect(true) en WiFi.mode(WIFI_OFF) voordat je gaat slapen is ook wat Espressif aanbeveelt. Om de verbinding nog sneller te maken geef je het board met WiFi.config() een vast IP-adres en sla je het wachten op DHCP over. De berekening van de deler vind je in de gids spanningsdeler en de laadschakeling in de gids TP4056-oplaadmodule.
Wakker worden met een knop of een PIR-sensor: ext0 en ext1
Naast de timer kan ook een signaal uit de buitenwereld de ESP32 wekken. Daarvoor zijn twee manieren, en beide werken alleen op RTC-GPIO-pins: 0, 2, 4, 12–15, 25–27 en 32–39. ext0 bewaakt één pin en wekt het board wanneer die pin het gekozen niveau bereikt (HIGH of LOW); omdat het de RTC-randapparatuur onder spanning houdt, blijven de interne pull-up- en pull-downweerstanden tijdens de slaap werken. ext1 bewaakt via een bitmasker meerdere pins tegelijk. Op de klassieke ESP32 heeft ext1 twee modi: ESP_EXT1_WAKEUP_ANY_HIGH wekt het board als een van de gekozen pins HIGH wordt, en ESP_EXT1_WAKEUP_ALL_LOW wekt het als ze allemaal tegelijk LOW zijn. De modus ANY_LOW, die wekt zodra een pin LOW wordt, bestaat alleen op de ESP32-S2, S3, C6 en H2. Wil je dus dat meerdere knoppen een klassieke ESP32 wekken, sluit de knoppen dan aan op 3V3 en geef elke pin een pull-downweerstand van 10 kΩ. Je kunt ook meerdere bronnen tegelijk inschakelen; met zowel de PIR als een uurtimer actief wordt het board bijvoorbeeld wakker door wat het eerst gebeurt.
| Wekbron | Functie | Pins | Opmerking |
|---|---|---|---|
| Timer | esp_sleep_enable_timer_wakeup() | Geen pin nodig | Tijd in microseconden, 64-bit |
| ext0 | esp_sleep_enable_ext0_wakeup() | Eén RTC-GPIO | Wekt bij HIGH of LOW; niet te combineren met touch of ULP |
| ext1 | esp_sleep_enable_ext1_wakeup_io() | Meerdere RTC-GPIO's | ANY_HIGH of ALL_LOW; externe weerstanden aanbevolen |
| Touch | touchSleepWakeUpEnable() | T0–T9 (10 pins) | Wekt wanneer de waarde onder de drempel zakt; niet te combineren met ext0 |
| ULP-coprocessor | esp_sleep_enable_ulp_wakeup() | Hangt af van het programma | Kan sensoren uitlezen tijdens de slaap; gevorderd |
Bedrading voor de voorbeeldschakeling
| Onderdeel | Pin van het onderdeel | ESP32-pin | Opmerking |
|---|---|---|---|
| PIR-sensor (HC-SR501 of AM312) | OUT | GPIO 33 | Wekt het board via ext0 |
| PIR-sensor | VCC / GND | 5V (HC-SR501) of 3V3 (AM312) / GND | De HC-SR501 heeft minstens 4,5 V nodig |
| Knop A | Het ene pootje / het andere pootje | 3V3 / GPIO 25 | 10 kΩ pull-down tussen GPIO 25 en GND |
| Knop B | Het ene pootje / het andere pootje | 3V3 / GPIO 26 | 10 kΩ pull-down tussen GPIO 26 en GND |
| Touchpad of draad | – | GPIO 27 (T7) | Werkt betrouwbaarder als hij kort blijft |
| LED + 220 Ω | Anode | GPIO 2 | Op de meeste DevKits zit de blauwe led op het board ook op deze pin |
| Batterijdeler (1 MΩ + 1 MΩ) | Middelpunt | GPIO 35 | 100 nF tussen het middelpunt en GND |
| 18650 + TP4056 + 3,3 V-LDO | LDO-uitgang / GND | 3V3 / GND | Condensator van 470 µF op de LDO-uitgang |
Wake-upsketch met PIR-sensor (ext0)
1// PIR ile uyanma (ext0) / wake on PIR motion (ext0)
2#include "driver/rtc_io.h"
3
4const gpio_num_t PIR_PIN = GPIO_NUM_33; // RTC GPIO olmalı / must be an RTC GPIO
5const int LED_PIN = 2; // uyarı LED'i / alert LED
6
7RTC_DATA_ATTR int motionCount = 0; // toplam hareket sayısı / total motion count
8
9void setup() {
10 Serial.begin(115200);
11 rtc_gpio_deinit(PIR_PIN); // pini yeniden normal GPIO yap / turn the pad back into a normal GPIO
12 pinMode(PIR_PIN, INPUT);
13 pinMode(LED_PIN, OUTPUT);
14
15 if (esp_sleep_get_wakeup_cause() == ESP_SLEEP_WAKEUP_EXT0) {
16 motionCount++;
17 Serial.printf("Hareket! / Motion! Toplam / Total: %d\n", motionCount);
18 digitalWrite(LED_PIN, HIGH); // burada bildirim gönderebilirsin / send a notification here
19 delay(1000);
20 digitalWrite(LED_PIN, LOW);
21 }
22
23 // PIR çıkışı LOW olana kadar bekle, yoksa hemen yeniden uyanır / wait for LOW or it wakes again at once
24 while (digitalRead(PIR_PIN) == HIGH) {
25 delay(100);
26 }
27
28 esp_sleep_enable_ext0_wakeup(PIR_PIN, 1); // pin HIGH olunca uyan / wake when the pin goes HIGH
29 rtc_gpio_pullup_dis(PIR_PIN);
30 rtc_gpio_pulldown_en(PIR_PIN); // boştayken LOW tut / keep it LOW while idle
31 Serial.println("Uyku / Sleep");
32 Serial.flush();
33 esp_deep_sleep_start();
34}
35
36void loop() {
37}Na het wakker worden zet de sketch de pin eerst met rtc_gpio_deinit() terug naar een gewone GPIO. Na een ext0-wake-up blijft de pin in RTC-modus, en zonder deze regel werkt digitalRead() mogelijk niet goed. De sketch telt de beweging, laat de led knipperen en wacht dan tot de PIR-uitgang weer LOW wordt. Deze wachttijd is essentieel: ga je slapen terwijl de uitgang nog HIGH is, dan wordt het board meteen weer wakker en beland je in een lus die meerdere keren per seconde aan- en uitschakelt. De HC-SR501 houdt zijn uitgang HIGH voor de tijd die op zijn potmeter is ingesteld, dus draai de tijdpotmeter naar het minimum om het wachten te verkorten. Omdat de HC-SR501 minstens 4,5 V nodig heeft, kies je voor projecten op één 18650 de kleine AM312-PIR-module, die ook op 3,3 V draait. Voor de sensorinstellingen, zie de gids PIR-bewegingssensor.
Wake-upsketch met twee knoppen (ext1)
1// İki butonla uyanma (ext1) / wake with two buttons (ext1)
2#include "driver/rtc_io.h"
3
4const gpio_num_t BTN_A = GPIO_NUM_25; // buton A: 3V3'e, 10k pull-down / button A: to 3V3, 10k pull-down
5const gpio_num_t BTN_B = GPIO_NUM_26; // buton B: 3V3'e, 10k pull-down / button B: to 3V3, 10k pull-down
6const uint64_t WAKE_MASK = (1ULL << BTN_A) | (1ULL << BTN_B);
7
8void setup() {
9 Serial.begin(115200);
10 rtc_gpio_deinit(BTN_A); // pinleri normal GPIO'ya döndür / back to normal GPIO
11 rtc_gpio_deinit(BTN_B);
12 pinMode(BTN_A, INPUT);
13 pinMode(BTN_B, INPUT);
14
15 if (esp_sleep_get_wakeup_cause() == ESP_SLEEP_WAKEUP_EXT1) {
16 uint64_t pins = esp_sleep_get_ext1_wakeup_status(); // hangi pin uyandırdı? / which pin woke us?
17 if (pins & (1ULL << BTN_A)) Serial.println("Buton A: isigi ac / Button A: lights on");
18 if (pins & (1ULL << BTN_B)) Serial.println("Buton B: isigi kapat / Button B: lights off");
19 } else {
20 Serial.println("Ilk acilis / First boot");
21 }
22
23 while (digitalRead(BTN_A) == HIGH || digitalRead(BTN_B) == HIGH) {
24 delay(10); // butonlar bırakılana kadar bekle / wait until released
25 }
26
27 esp_sleep_enable_ext1_wakeup_io(WAKE_MASK, ESP_EXT1_WAKEUP_ANY_HIGH); // biri HIGH olunca / any goes HIGH
28 Serial.flush();
29 esp_deep_sleep_start();
30}
31
32void loop() {
33}Na een ext1-wake-up geeft esp_sleep_get_ext1_wakeup_status() een bitmasker terug dat laat zien welke pin het board wekte. Zo kun je de twee knoppen verschillende taken geven: de ene zet het licht aan en de andere uit, of de ene verstuurt een meting en de andere opent een menu. Omdat de knoppen op 3V3 zijn aangesloten en de pins met 10 kΩ naar GND zijn getrokken, lezen ze LOW als ze losgelaten zijn en HIGH als ze ingedrukt zijn, precies wat de modus ANY_HIGH verwacht. De sketch wacht tot de knoppen zijn losgelaten voordat hij gaat slapen, anders zou een nog ingedrukte knop het board direct weer wekken. Gebruik je de ESP32 Arduino core 2.x of 3.0.x, waar de functie met _io ontbreekt, schrijf dan esp_sleep_enable_ext1_wakeup met dezelfde parameters in plaats van esp_sleep_enable_ext1_wakeup_io. Waarom de pull-downweerstand nodig is, lees je in de gids een knop aansluiten op Arduino.
Wakker worden met een aanraking (touch wake-up)
Tien pins van de ESP32 (T0–T9) werken als capacitieve aanraaksensoren en kunnen je vinger zelfs in deep sleep detecteren. Een draad, een strook koperen tape of een printpad dat op de pin is aangesloten gedraagt zich als een knop en kan zelfs achter een dun plastic of houten paneel zitten. Op de klassieke ESP32 daalt de waarde van touchRead() bij aanraking: met een korte draad leest hij meestal 60–80 zonder aanraking en 10–20 bij aanraking. Zet de wekdrempel tussen deze twee waarden; de 40 in het voorbeeld is een goed beginpunt. Op de klassieke ESP32 kun je meerdere touchpins tegelijk als wekbron gebruiken. Op de ESP32-S2 en S3 kan echter maar één pin de chip wekken, stijgt de waarde bij aanraking en gebruikt de drempel een totaal andere schaal (5000 in het voorbeeld van Espressif). Touch wake-up kan niet met ext0 worden gecombineerd; heb je ook een knop nodig, gebruik dan ext1. Voor de pinlijst en de kalibratie lees je de gids touchpins van de ESP32.
1// Dokunarak uyandırma: T7 = GPIO 27 / touch wake-up: T7 = GPIO 27
2#define THRESHOLD 40 // değer bunun altına inince uyanır / wakes when the value drops below this
3
4RTC_DATA_ATTR int touchWakes = 0;
5
6void setup() {
7 Serial.begin(115200);
8 delay(500);
9 if (esp_sleep_get_wakeup_cause() == ESP_SLEEP_WAKEUP_TOUCHPAD) {
10 touchWakes++;
11 Serial.printf("Dokunusla uyanma / Touch wake #%d\n", touchWakes);
12 }
13 // Eşiği ayarlamak için dokunmadan ve dokunarak değeri izle / watch the value untouched and touched
14 Serial.printf("T7 degeri / value: %d\n", (int)touchRead(T7));
15
16 touchSleepWakeUpEnable(T7, THRESHOLD); // dokunmatikle uyanmayı aç / enable touch wake-up
17 Serial.flush();
18 esp_deep_sleep_start();
19}
20
21void loop() {
22}ESP32 deep sleep met MicroPython
Programmeer je de ESP32 in MicroPython, dan doe je hetzelfde met kortere code. machine.deepsleep(ms) zet het board het opgegeven aantal milliseconden te slapen, esp32.wake_on_ext0() maakt van een pin een wekbron en machine.RTC().memory() geeft je een bytebuffer die de slaap overleeft; op de ESP32 is die standaard 2048 bytes groot. Bij het wakker worden draait main.py weer vanaf de top; machine.reset_cause() vertelt of het board uit deep sleep kwam en machine.wake_reason() vertelt wat het wekte. RTC-pins die met een pull-up of pull-down zijn ingesteld, behouden die instelling tijdens de slaap. Ben je nieuw met MicroPython, begin dan met de gids basis van MicroPython.
1import machine, esp32, time
2from machine import Pin
3
4rtc = machine.RTC()
5led = Pin(2, Pin.OUT)
6
7mem = rtc.memory() # RTC belleğini oku / read RTC memory
8count = int.from_bytes(mem, "little") if mem else 0
9
10if machine.reset_cause() == machine.DEEPSLEEP_RESET:
11 count += 1
12 if machine.wake_reason() == machine.EXT0_WAKE:
13 print("Butonla uyandi / Woken by button")
14 else:
15 print("Zamanlayiciyla uyandi / Woken by timer")
16else:
17 count = 0
18 print("Ilk acilis / First boot")
19
20rtc.memory(count.to_bytes(4, "little")) # sayacı sakla / store the counter
21print("Uyanis / Wake:", count)
22
23led.on() # kısa iş: ölç ve gönder / short task: measure and send
24time.sleep_ms(200)
25led.off()
26
27button = Pin(33, Pin.IN, Pin.PULL_DOWN) # buton GPIO 33 ile 3V3 arasında / button between GPIO 33 and 3V3
28esp32.wake_on_ext0(button, esp32.WAKEUP_ANY_HIGH) # basınca uyan / wake on press
29machine.deepsleep(60000) # 60 s uyu / sleep for 60 sDe Raspberry Pi Pico heeft daarentegen geen deep sleep op microampèreniveau zoals de ESP32. In MicroPython stopt machine.lightsleep(ms) het grootste deel van de klokken, pauzeert de CPU en behoudt het RAM, terwijl machine.deepsleep(ms) het board na hetzelfde soort slaap reset. Ook in deze modi blijft het verbruik van het board in het milliampèrebereik. Wil je dus een Pico-apparaat bouwen dat maandenlang op batterijen draait, dan geeft het volledig afsnijden van de voeding van het board tussen de metingen met een stroomtimer zoals de TPL5110 betere resultaten. Voor de basis van de Pico, zie de gids wat is de Raspberry Pi Pico.
Een sensor die maandenlang op een 18650 draait: batterijduur berekenen
Om de batterijduur van een apparaat dat slaapt en wakker wordt te bepalen, bereken je eerst de gemiddelde stroom: Gemiddelde stroom = (wakkere stroom × wakkere tijd + slaapstroom × slaaptijd) / totale tijd. Daarna deel je de bruikbare batterijcapaciteit door dat gemiddelde. Je kunt niet alles van een 18650 van 3000 mAh gebruiken; rekenen met ongeveer 85%, oftewel 2550 mAh, voor de uitschakelspanning, regelaarverliezen en veroudering is realistisch. De tabel hieronder is berekend voor een sensor die elke 10 minuten wakker wordt, gegevens via Wi-Fi verstuurt en tijdens het verbinden gemiddeld 120 mA trekt.
| Scenario | Slaapstroom | Wakkere tijd | Gemiddelde stroom | Geschatte duur |
|---|---|---|---|---|
| DevKit-board | 8 mA | 3 s, 120 mA | 8,56 mA | ≈12 dagen |
| DevKit-board, snelle verbinding | 8 mA | 1 s, 120 mA | 8,19 mA | ≈13 dagen |
| Kale module + MCP1700 + 1 MΩ-deler | 15 µA | 3 s, 120 mA | 0,61 mA | ≈173 dagen (5,7 maanden) |
| Kale module, snelle verbinding | 15 µA | 1 s, 120 mA | 0,215 mA | ≈494 dagen (16 maanden) |
| Kale module, uurlijkse batchupload | 15 µA | 1 s Wi-Fi per uur (120 mA) + 5 × 0,3 s metingen (40 mA) | 0,065 mA | ≈4,5 jaar in theorie |
De conclusie is duidelijk: op een ontwikkelboard verandert het verkorten van de wakkere tijd bijna niets, omdat de 8 mA tijdens de slaap de batterij echt leegtrekt. Zodra de slaapstroom naar microampères zakt, draait de balans om en telt elke wakkere seconde: de Wi-Fi-verbinding van 3 seconden naar 1 terugbrengen verdrievoudigt de batterijduur bijna. Wanneer de gemiddelde stroom onder 0,1 mA komt, gaat de zelfontlading van de batterij meespelen. Een Li-ioncel verliest ongeveer 2–3% van zijn capaciteit per maand, dus de theoretische 4,5 jaar krimpt in de praktijk tot ongeveer 2 jaar. Wil je de berekening met je eigen waarden doen, gebruik dan de batterijduurcalculator en lees over mAh en Wh in de gids wat betekent mAh.
- Kies het juiste board: boards zonder USB-chip en voedingsled, of een kale ESP32-module, trekken in slaap microampères.
- Vervang de regelaar: gebruik een LDO met een ruststroom van enkele microampères in plaats van de AMS1117.
- Voed de sensor alleen tijdens het meten: voed sensoren die een paar mA trekken rechtstreeks vanaf een GPIO en grotere belastingen via een P-kanaal-MOSFET; zet een pull-upweerstand op de gate van de MOSFET zodat hij tijdens de slaap uit blijft. De details staan in de Arduino-MOSFET-gids.
- Zet Wi-Fi zelden aan: verzamel metingen in het RTC-geheugen en verstuur ze in batches; stuur je gegevens naar een andere ESP32 in de buurt, dan zendt ESP-NOW in veel minder tijd, omdat het geen verbinding met een accesspoint nodig heeft.
- Versnel de verbinding: met een vast IP-adres en een opgeslagen kanaal en BSSID duurt de Wi-Fi-verbinding vaak minder dan een seconde.
- Haal onnodig wachten weg: verwijder Serial Monitor-uitvoer en lange delay()-regels uit het afgewerkte project; elke wakkere milliseconde gaat van de batterij af.
- Vergeet de deler en de leds niet: een permanent aangesloten deler van 100 kΩ + 100 kΩ trekt twee keer zoveel stroom als de slapende ESP32.
Projectideeën voor ESP32 deep sleep
- Weerstation op batterij: meet elke 10 minuten temperatuur, luchtvochtigheid en luchtdruk met een BME280 en stuur ze één keer per uur via MQTT naar Home Assistant.
- Vochtsensor voor de tuin: word één keer per uur wakker, meet het bodemvocht en stuur een bericht naar je telefoon als de grond droog wordt.
- Deur- en raamalarm: als de deur opengaat, wekt een reedschakelaar de ESP32 via ext0 en stuurt een Telegram-bot je een bericht.
- Beveiligingssensor op batterij: bouw een apparaat dat wakker wordt en een melding stuurt als de PIR beweging ziet en de rest van de tijd maandenlang slaapt.
- Aanraakdeurbel: plak koperen tape achter een houten paneel; een aanraking wekt de ESP32, die via ESP-NOW de gong binnen laat luiden.
- Temperatuurlogger op batterij: meet de temperatuur van een koelkast of een aquarium met een waterdichte DS18B20, verzamel de waarden in het RTC-geheugen en verstuur ze een paar keer per dag.
Veelgemaakte fouten en hoe je ze oplost
| Verschijnsel | Oorzaak | Oplossing |
|---|---|---|
| Het board wordt direct na het slapen gaan weer wakker | De wekpin is nog actief (PIR HIGH, knop ingedrukt) of zweeft | Wacht tot de pin terug is op zijn rustniveau voordat je gaat slapen en voeg een pull-down- of pull-upweerstand toe |
| Het board wordt niet op het verwachte moment wakker | 32-bit overflow in de tijdberekening (3600 * 1000000) | Voeg ULL toe aan de constanten: 3600ULL * 1000000ULL |
| De teller begint altijd bij 1 | De variabele is geen RTC_DATA_ATTR of het board is gereset | Voeg RTC_DATA_ATTR toe; gebruik Preferences voor blijvende gegevens |
| 5–15 mA gemeten tijdens de slaap | Regelaar, voedingsled, USB-chip, deler of sensoren | Board met laag verbruik of kale module, LDO met lage ruststroom |
| De laatste regels in de Serial Monitor worden afgekapt | Het board ging slapen voordat de buffer leeg was | Roep Serial.flush() aan vóór esp_deep_sleep_start() |
| digitalRead() geeft verkeerde waarden na het wakker worden | De wekpin staat nog in RTC-modus | Roep rtc_gpio_deinit() aan voordat je de pin gebruikt |
| Een knop op GPIO 34–39 wekt het board niet | Deze pins hebben geen interne pullweerstanden, dus de pin zweeft | Voeg een externe weerstand van 10 kΩ toe |
| Code uploaden lukt niet terwijl het board slaapt | Het board heeft geen auto-resetschakeling; op de S3 en C3 verdwijnt de native USB-poort tijdens de slaap | Houd BOOT ingedrukt, druk op EN (RESET) en laat los, en start dan de upload |
| Een relais of led verandert van toestand als het board gaat slapen | Digitale pins zweven (hoogohmig) in deep sleep | Gebruik een pullweerstand of houd het pinniveau vast met rtc_gpio_hold_en() |
ESP32 deep sleep is de sleutel om dezelfde code maandenlang in plaats van dagen op een batterij te laten draaien: houd het werk kort, kies de juiste wekbron, bewaar de kleine gegevens die je tussen twee wake-ups nodig hebt in het RTC-geheugen en vergeet nooit het eigen verbruik van het board. Wil je terug naar de basis van de ESP32, dan is de gids wat is de ESP32 een goed begin. In de BlueGrays-app laat het project ESP32 Deep Sleep — Batterij sparen (OLED + RTC-RAM-teller) je de timer- en RTC-tellerlogica uit dit artikel uitproberen op een schakeling met een OLED-display, met een stap-voor-stapschakelschema en kant-en-klare code.
Veelgestelde vragen
Hoeveel stroom trekt de ESP32 in deep sleep?
Volgens de datasheet van Espressif trekt de ESP32-chip in deep sleep ongeveer 10 µA met de RTC-timer en het RTC-geheugen aan, en 5 µA in hibernationmodus. Op ontwikkelboards zoals de DevKit brengen de regelaar, de voedingsled en de USB-naar-serieel-chip de slaapstroom echter meestal op 5–15 mA.
Hoe wek je een ESP32 uit deep sleep?
Er zijn vijf manieren: de RTC-timer, één RTC-pin (ext0), meerdere RTC-pins (ext1), de touchpins en de ULP-coprocessor. Je stelt de wekbron in voordat je esp_deep_sleep_start() aanroept en kunt er meerdere tegelijk inschakelen; alleen ext0 en touch wake-up kunnen niet samen worden gebruikt.
Gaan variabelen verloren in ESP32 deep sleep?
Ja, gewone variabelen gaan verloren, omdat wakker worden uit deep sleep een herstart is en setup() vanaf het begin draait. Variabelen met RTC_DATA_ATTR worden opgeslagen in het RTC-geheugen en blijven tussen wake-ups behouden, maar ze keren terug naar hun beginwaarde na een stroomuitval, een druk op de EN-knop of een nieuwe upload.
Hoe lang kan een ESP32 op een 18650-batterij draaien?
Van een dag tot meer dan een jaar, afhankelijk van het board en hoe je het gebruikt. Een DevKit die verbonden blijft met Wi-Fi houdt het op een 18650 van 3000 mAh maar 1–2 dagen vol, en een DevKit die elke 10 minuten wakker wordt ongeveer 12 dagen. Een schakeling met laag verbruik die hetzelfde werk doet met een slaapstroom van 15 µA draait 5 tot 16 maanden, afhankelijk van hoe lang elke verbinding duurt.
Wat is het verschil tussen ESP32 light sleep en deep sleep?
In light sleep is de CPU gepauzeerd maar blijft het RAM behouden; als het board wakker wordt, gaat het programma verder op de regel waar het stopte en trekt de chip ongeveer 0,8 mA. In deep sleep is ook het RAM uitgeschakeld en zakt het verbruik naar 10 µA, maar het programma begint bij elke wake-up opnieuw. Light sleep past bij pauzes van een paar seconden, deep sleep bij wachttijden van minuten of uren.
Hoe upload je code naar een ESP32 in deep sleep?
Op boards met een auto-resetschakeling start de upload meestal zonder problemen, omdat de uploader de chip via de EN-pin reset. Lukt dat niet, houd dan de BOOT-knop ingedrukt, druk op EN (RESET) en laat los, en start dan de upload. Op boards met native USB zoals de ESP32-S3 en C3 verdwijnt de poort tijdens de slaap, dus deze methode is daar vaak nodig.
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-ledbesturing met drukknop (Push)
De led brandt zolang je de knop indrukt en gaat uit als je loslaat. Laat zien hoe je de digitale ingangspin en de interne pull-upweerstand van de ESP32 gebruikt. Met de modus INPUT_PULLUP heb je geen externe weerstand nodig.

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

Automatische verlichting met de ESP32 en een PIR-bewegingssensor
In dit project detecteert een HC-SR501 PIR-bewegingssensor iemand die de kamer binnenkomt en zet een led automatisch aan. Met millis() houd je bij hoe lang de led aan blijft: elke HIGH-meting vernieuwt het tijdstip van de laatste beweging en de led gaat minstens 10 seconden na de laatste HIGH uit. De code wacht bovendien in elke lus 50 ms met delay(50), dus de lus is niet volledig non-blocking. Handig voor trappen, gangen, badkamers of kastverlichting.

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

ESP32-temperatuurlogger (DHT22 + DS1307 RTC + microSD + OLED)
Bouw met de ESP32 een temperatuur- en vochtigheidslogger met tijdstempel! Een DHT22-sensor meet elke minuut temperatuur en luchtvochtigheid en elke meting wordt als CSV op een microSD-kaart opgeslagen, met de actuele tijd van de DS1307 RTC-module. Het OLED-display toont in grote letters live de laatste temperatuur, vochtigheid, tijdstempel en het totale aantal records.
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

