Gidsen · 16 min leestijd

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.

ESP32-ontwikkelboard (DevKit)
ESP32-ontwikkelboard: de afgeschermde module trekt in deep sleep ongeveer 10 µA, terwijl de regelaar, de voedingsled en de USB-naar-serieel-chip op het board dat verbruik opdrijven tot in het milliampèrebereik.

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)

ModusWat blijft er draaien?Stroom (ESP32-chip)
Actief: Wi-Fi zenden (802.11b, 19,5 dBm)CPU en radio240 mA
Actief: Wi-Fi ontvangen en luisterenCPU en radio95–100 mA
Modem sleep, 240 MHzCPU draait, radio uit30–68 mA
Modem sleep, 80 MHzCPU draait langzamer, radio uit20–31 mA
Light sleepCPU gepauzeerd, RAM behouden0,8 mA
Deep sleep met ULP aanRTC-domein en ULP-coprocessor150 µA
Deep sleepRTC-timer en RTC-geheugen10 µA
HibernationAlleen RTC-timer en enkele RTC-pins5 µA
Uit (EN-pin LOW)Niets1 µ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.

StroombronStroom tijdens slaapOplossing
ESP32-module (deep sleep)≈10 µAAl laag, niets aan te doen
AMS1117-regelaarTypisch 5 mA (ruststroom)Gebruik een MCP1700 (1,6 µA ruststroom) of een HT7333 (ongeveer 4 µA)
Voedingsled1–3 mAVerwijder de led of zijn weerstand
USB-naar-serieel-chip (CP2102, CH340)Hangt af van het board, kan in het mA-bereik komenGebruik 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 hebbenVan µA tot mA, afhankelijk van de sensorVoed de sensor alleen tijdens het meten via een GPIO of een MOSFET
Sluit een Li-ioncel zoals een 18650 nooit rechtstreeks aan op de 3V3-pin: een volle Li-ioncel staat op 4,2 V, terwijl de ESP32 hooguit 3,6 V verdraagt. De batterij op de VIN-pin zetten is ook geen goed antwoord, want de AMS1117 laat ongeveer 1 V vallen en zijn uitgang zakt onder 3 V zodra de cel half leeg is. De juiste manier is de 3V3-pin te voeden via een 3,3 V-LDO met lage ruststroom en lage drop-out. Kleine LDO's zoals de MCP1700 en HT7333 leveren maar 250 mA, dus plaats minstens 470 µF op hun uitgang om de Wi-Fi-stroompieken op te vangen. LiFePO4-cellen, die zelfs vol nooit boven 3,6 V komen, kun je zonder regelaar rechtstreeks op 3V3 aansluiten.

Je eerste deep-sleepsketch: wakker worden met een timer

  1. 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.
  2. Upload de sketch hieronder en open de Serial Monitor op 115200 baud.
  3. Het board wordt elke 10 seconden wakker; zie de bootteller oplopen en de wekreden als Timer verschijnen.
  4. Druk op de EN-knop: de teller gaat terug naar 1, omdat dit een gewone reset is en geen wake-up uit deep sleep.
  5. Zet in je echte project TIME_TO_SLEEP op 600 (10 minuten) of 3600 (1 uur).
C++ (Arduino IDE)
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.

GebeurtenisGewone variabeleRTC_DATA_ATTRPreferences (flash)
Wake-up uit deep sleepResetBehoudenBehouden
EN-knop of ESP.restart()ResetTerug naar beginwaardeBehouden
Batterij verwijderd, stroom uitgevallenResetVerlorenBehouden
Nieuwe code geüploadResetVerlorenBehouden (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.

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

WekbronFunctiePinsOpmerking
Timeresp_sleep_enable_timer_wakeup()Geen pin nodigTijd in microseconden, 64-bit
ext0esp_sleep_enable_ext0_wakeup()Eén RTC-GPIOWekt bij HIGH of LOW; niet te combineren met touch of ULP
ext1esp_sleep_enable_ext1_wakeup_io()Meerdere RTC-GPIO'sANY_HIGH of ALL_LOW; externe weerstanden aanbevolen
TouchtouchSleepWakeUpEnable()T0–T9 (10 pins)Wekt wanneer de waarde onder de drempel zakt; niet te combineren met ext0
ULP-coprocessoresp_sleep_enable_ulp_wakeup()Hangt af van het programmaKan sensoren uitlezen tijdens de slaap; gevorderd

Bedrading voor de voorbeeldschakeling

OnderdeelPin van het onderdeelESP32-pinOpmerking
PIR-sensor (HC-SR501 of AM312)OUTGPIO 33Wekt het board via ext0
PIR-sensorVCC / GND5V (HC-SR501) of 3V3 (AM312) / GNDDe HC-SR501 heeft minstens 4,5 V nodig
Knop AHet ene pootje / het andere pootje3V3 / GPIO 2510 kΩ pull-down tussen GPIO 25 en GND
Knop BHet ene pootje / het andere pootje3V3 / GPIO 2610 kΩ pull-down tussen GPIO 26 en GND
Touchpad of draad–GPIO 27 (T7)Werkt betrouwbaarder als hij kort blijft
LED + 220 ΩAnodeGPIO 2Op de meeste DevKits zit de blauwe led op het board ook op deze pin
Batterijdeler (1 MΩ + 1 MΩ)MiddelpuntGPIO 35100 nF tussen het middelpunt en GND
18650 + TP4056 + 3,3 V-LDOLDO-uitgang / GND3V3 / GNDCondensator van 470 µF op de LDO-uitgang
Vermijd GPIO 0, 2, 12 en 15 als wake-upingangen. Dit zijn strappingpins; als een knop of sensor ze tijdens de reset op het verkeerde niveau houdt, gaat het board in downloadmodus of start het helemaal niet. Is GPIO 12 bijvoorbeeld HIGH bij het opstarten, dan wordt de flashspanning op 1,8 V gezet en kan het board niet booten. GPIO 34–39 zijn alleen ingangen en hebben geen interne pull-up- of pull-downweerstanden, dus voeg de weerstand extern toe als je het board met deze pins wekt. Je kunt de volledige pinindeling van je board controleren met de tool Pinout.

Wake-upsketch met PIR-sensor (ext0)

C++ (Arduino IDE)
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)

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

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

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 s

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

ScenarioSlaapstroomWakkere tijdGemiddelde stroomGeschatte duur
DevKit-board8 mA3 s, 120 mA8,56 mA≈12 dagen
DevKit-board, snelle verbinding8 mA1 s, 120 mA8,19 mA≈13 dagen
Kale module + MCP1700 + 1 MΩ-deler15 µA3 s, 120 mA0,61 mA≈173 dagen (5,7 maanden)
Kale module, snelle verbinding15 µA1 s, 120 mA0,215 mA≈494 dagen (16 maanden)
Kale module, uurlijkse batchupload15 µA1 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

VerschijnselOorzaakOplossing
Het board wordt direct na het slapen gaan weer wakkerDe wekpin is nog actief (PIR HIGH, knop ingedrukt) of zweeftWacht 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 wakker32-bit overflow in de tijdberekening (3600 * 1000000)Voeg ULL toe aan de constanten: 3600ULL * 1000000ULL
De teller begint altijd bij 1De variabele is geen RTC_DATA_ATTR of het board is geresetVoeg RTC_DATA_ATTR toe; gebruik Preferences voor blijvende gegevens
5–15 mA gemeten tijdens de slaapRegelaar, voedingsled, USB-chip, deler of sensorenBoard met laag verbruik of kale module, LDO met lage ruststroom
De laatste regels in de Serial Monitor worden afgekaptHet board ging slapen voordat de buffer leeg wasRoep Serial.flush() aan vóór esp_deep_sleep_start()
digitalRead() geeft verkeerde waarden na het wakker wordenDe wekpin staat nog in RTC-modusRoep rtc_gpio_deinit() aan voordat je de pin gebruikt
Een knop op GPIO 34–39 wekt het board nietDeze pins hebben geen interne pullweerstanden, dus de pin zweeftVoeg een externe weerstand van 10 kΩ toe
Code uploaden lukt niet terwijl het board slaaptHet board heeft geen auto-resetschakeling; op de S3 en C3 verdwijnt de native USB-poort tijdens de slaapHoud 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 slapenDigitale pins zweven (hoogohmig) in deep sleepGebruik een pullweerstand of houd het pinniveau vast met rtc_gpio_hold_en()
Voeg tijdens de ontwikkeling tijdelijk een wachttijd van 5 seconden toe aan het begin van setup(), of een voorwaarde die het slapen overslaat zolang een knop wordt ingedrukt. Zo heb je tijd om de Serial Monitor te openen en nieuwe code te uploaden, ook als het board de hele tijd slaapt; vergeet het alleen niet te verwijderen als het project klaar is. Als het board op batterijvoeding af en toe vanzelf reset, zijn de Wi-Fi-stroompieken de meest waarschijnlijke oorzaak; de oplossingen staan in de gids ESP32-brownoutfout.

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.

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-ledbesturing met drukknop (Push)
ES-2Beginner

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.

4.6(36)
57
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-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
Automatische verlichting met de ESP32 en een PIR-bewegingssensor
ES-19Gemiddeld
Premium

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.

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

ESP32 DHT22 temperatuur en luchtvochtigheid (met LCD)

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

4.8(38)
57
ESP32-temperatuurlogger (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Gevorderd
Premium

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.

4.7(7)
12