ESP32 energiamegtakarítás elérése egyes alvó módjai alkalmazásával

Az ESP32 üzemmódtól függően viszonylag sok energiát vesz fel. Ha fali aljzatról tápláljuk, az energiafogyasztás nem jelent túl nagy problémát. Akkumulátorról történő üzemeltetés esetén azonban fontos az energiamegtakarítás, hogy lehető leghosszabban fenntartsuk az energiaforrásunk élettartamát.

Az ESP32 chip egy kétmagos, 32 bites mikroprocesszort tartalmaz, beépített WiFi és Bluetooth támogatással rendelkezik, ami még energiaigényesebb mikrovezérlővé teszi.

Ha az ESP32 projektnek nem kell folyamatosan aktívnak lennie, jó megoldás lehet az ESP32 valamelyik alvó módjának kihasználása az energiafogyasztás csökkentése és az akkumulátor élettartamának jelentős növelése érdekében.

Az ESP32 fejlett energiagazdálkodásának köszönhetően öt konfigurálható energiagazdálkodási módot kínál. Az alkalmazás energiaigényének megfelelően a chip öt különböző energiagazdálkodási módjai között választhatunk. Akár a program futása közben is válthatunk egyik módról a másikra.

ESP32 aktív mód

Az ESP32 aktív módja a normál működési mód, amelyben a CPU magok müködnek, a WiFi és Bluetooth modul engedélyezve van, és az összes periféria aktív.

Az ESP32 chip blokkvázlata aktív módban:

Mivel ebben az üzemmódban minden aktív, az ESP32 áramfelvétele 95~240mA a WiFi és Bluetooth használatától és a CPU órajelétől függően. Fontos megjegyezni, hogy ez az áramfogyasztási érték az ESP32 chipre vonatkozik, és nem a teljes ESP32 fejlesztőkártyára.

Aktív módban az energiamegtakarítás egyetlen módja a CPU futási órajelének szabályozása és/vagy az RF üzemmód megváltoztatása az alkalmazás igényeinek és a következő táblázatnak megfelelően.

Áramfogyasztás az RF módoktól függően
Transmit 802.11b, DSSS 1 Mbps, POUT = +19.5 dBm	240 mA
Transmit 802.11g, OFDM 54 Mbps, POUT = +16 dBm	190 mA
Transmit 802.11n, OFDM MCS7, POUT = +14 dBm	180 mA
Receive 802.11b/g/n	95 ~ 100 mA
Transmit BT/BLE, POUT = 0 dBm	130 mA
Receive BT/BLE	95 ~ 100 mA

A wifi rádiófrekvenciás teljesítményszint beállítása:

#include "esp_wifi.h"
...
// esp_wifi_set_max_tx_power(int level);
esp_wifi_set_max_tx_power(14);        // +14 dBm

A klasszikus bluetooth adó teljesítményszint beállítása:

#include "esp_bt.h"
....

// esp_err_t  esp_bredr_tx_power_set(esp_power_level_t  min_power_level, esp_power_level_t  max_power_level);
esp_bredr_tx_power_set(ESP_PWR_LVL_N6, ESP_PWR_LVL_N0);

Az alapértelmezett minimális teljesítményszint az ‘ESP_PWR_LVL_N0’, a maximális teljesítményszint pedig az ‘ESP_PWR_LVL_P3’.
Az alábbi táblázat tartalmazza a lehetséges teljesítményszint paramétereket:

Bluetooth teljesítményszintek:
ESP_PWR_LVL_N12	-12dbm
ESP_PWR_LVL_N9	-9dbm
ESP_PWR_LVL_N6	-6dbm
ESP_PWR_LVL_N3	-3dbm
ESP_PWR_LVL_N0	0dbm
ESP_PWR_LVL_P3	+3dbm
ESP_PWR_LVL_P6	+6dbm
ESP_PWR_LVL_P9	+9dbm
ESP_PWR_LVL_N14 = ESP_PWR_LVL_N12	Visszafelé kompatibilitás! Ha -14 dBm-re állítjuk, az valójában -12 dBm-et eredményez.
ESP_PWR_LVL_N11 = ESP_PWR_LVL_N9	Visszafelé kompatibilitás! Ha -11 dBm-re állítjuk, az valójában -9 dBm-et eredményez.
ESP_PWR_LVL_N8 = ESP_PWR_LVL_N6	Visszafelé kompatibilitás! Ha -8 dBm-re állítjuk, az valójában -6 dBm-et eredményez.
ESP_PWR_LVL_N5 = ESP_PWR_LVL_N3	Visszafelé kompatibilitás! Ha -5 dBm-re állítjuk, az valójában -3 dBm-et eredményez.
ESP_PWR_LVL_N2 = ESP_PWR_LVL_N0	Visszafelé kompatibilitás! Ha -2 dBm-re állítjuk, az valójában 0 dBm-et eredményez.
ESP_PWR_LVL_P1 = ESP_PWR_LVL_P3	Visszafelé kompatibilitás! Ha +1 dBm-re állítjuk, az valójában +3 dBm-et eredményez.
ESP_PWR_LVL_P4 = ESP_PWR_LVL_P6	Visszafelé kompatibilitás! Ha +4 dBm-re állítjuk, az valójában +6 dBm-et eredményez.
ESP_PWR_LVL_P7 = ESP_PWR_LVL_P9	Visszafelé kompatibilitás! Ha +7 dBm-re állítjuk, az valójában +9 dBm-et eredményez.

BLE adó teljesítmény beállítása:

#include "esp_bt.h"
....

// esp_err_t esp_ble_tx_power_set(esp_ble_power_type_t teljesítménytípus, esp_power_level_t teljesítményszint)
esp_ble_tx_power_set(ESP_BLE_PWR_TYPE_ADV, ESP_PWR_LVL_P6);

A következő táblázat bemutatja a BLE teljesítménytípus paramétereket:

BLE teljesítménytípusok
ESP_BLE_PWR_TYPE_CONN_HDL0	TX teljesítmény a 0. operátorhoz
ESP_BLE_PWR_TYPE_CONN_HDL1	TX teljesítmény a 1. operátorhoz
ESP_BLE_PWR_TYPE_CONN_HDL2	TX teljesítmény a 2. operátorhoz
ESP_BLE_PWR_TYPE_CONN_HDL3	TX teljesítmény a 3. operátorhoz
ESP_BLE_PWR_TYPE_CONN_HDL4	TX teljesítmény a 4. operátorhoz
ESP_BLE_PWR_TYPE_CONN_HDL5	TX teljesítmény a 5. operátorhoz
ESP_BLE_PWR_TYPE_CONN_HDL6	TX teljesítmény a 6. operátorhoz
ESP_BLE_PWR_TYPE_CONN_HDL7	TX teljesítmény a 7. operátorhoz
ESP_BLE_PWR_TYPE_CONN_HDL8	TX teljesítmény a 8. operátorhoz
ESP_BLE_PWR_TYPE_ADV	TX teljesítmény hirdetéshez.
ESP_BLE_PWR_TYPE_SCAN	TX teljesítmény szkenneléshez.
ESP_BLE_PWR_TYPE_DEFAULT	Alapértelmezett TX teljesítménytípus, amellyel beállítható a korábban nem beállított teljesítménytípusok TX teljesítménye.
ESP_BLE_PWR_TYPE_NUM	Típusok száma.

Kétségtelenül ez a mód fogyasztja a legtöbb áramot és a legkevésbé energiahatékony. Az energiatakarékosság érdekében váltsunk egy másik energiatakarékos módra.

Vissza a tartalomhoz

Modem alvó üzemmód

Modem alvó üzemmódban az ESP32 processzor magok és minden más periféria működik az óra konfigurálható, a rádió, a wifi és a bluetooth le van tiltva.

Az ESP32 blokkvázlata modem alvó üzemmódban:

Az ESP32 egy paranccsal aktiválhatja a könnyű alvás módot, vagy a mély alvás módot, de a modem alvás mód aktiválása nem feltétlenül ilyen egyszerű. Előfordulhat, hogy több művelet szükséges a megvalósításához.

Ha a modem alvó módja engedélyezve van, a wifi modul (csak állomás módban) a hozzáférési ponthoz való sikeres csatlakozás után rendszeresen váltogat aktív és alvó állapot között. A Bluetooth szintén az aktív és alvó üzemmódok között kapcsolgat.

Az ESP32 modem alvó módban fenn tudja tartani a kapcsolatot a hozzáférési ponttal, ehhez DTIM-et (Delivery Traffic Indication Message) használ. A DTIM alapötlete beacon technikán alapul. Periodikusan üzeneteket küld a hálózaton, ezzel értesíti az összes állomást, hogy ébredjenek fel az alvó állapotból, és szinkronizálják magukat a hálózaton, majd ismét aludjanak el. Ezzel energiát takaríthatunk meg.

A wifi modul két DTIM beacon közötti időtartam alatt le van tiltva, majd automatikusan engedélyezésre kerül közvetlenül a következő beacon megérkezésekor. Tehát a két DTIM beacon közt eltelt idő határozza meg az ESP32 modem alvási idejét.

Modem alvó üzemmód három lehetséges beállítása.

Minimális modem alvás.

Amikor a modem alvó (modem sleep) üzemmódja engedélyezve van, a fogadott wifi adatok a DTIM periódus után kerülnek átvitelre, ezért a sugárzott adatok nem vesznek el. A probléma az, hogy ha nagy a hálózatunkon a forgalom, akkor sok beacon üzenetet kaphatunk.

A használatához nem kell semmit tennünk, mivel ez a wifi modem alapértelmezett beállítási módja, akkor van rá szükség, ha előzőleg megváltoztattuk a modem üzemmódját. Visszaállításhoz használjuk ‘Wifi.h’ könyvtár ‘setSleep()’ függvényét.

#include <Wifi.h>
....

WiFi.setSleep(true);

A wifi modem energiatakarékossági beállításaihoz, használhatunk az ESP-IDF keretrendszer alacsony szintű utasítást is a kódunkbban. Ehez importálnunk kell az ‘esp_wifi.h’ könyvtárat, hogy használhassuk az ‘esp_wifi_set_ps()’ függvényt. Ezt az alábbi módon használjuk:

#include <esp_wifi.h>
....
esp_wifi_set_ps(WIFI_PS_MIN_MODEM);

Maximális modem alvás.

Amikor a modem max alvása engedélyezve van a kommunikációt rendszeres időközönként ellenőrzi és nem akkor amikor a beacon üzenetek érkeznek, nagy hálózati a forgalom esetén kicsit javulhat az energiafelhasználás viszont a sugárzott adatok elveszhetnek, mivel a wifi modul esetleg alvó üzemmódban lehet a DTIM idején.

Mivel a ‘Wifi.h’ könyvtár nem tartalmaz erre vonatkozó utasítást, ezért a maximális modem alvás mód engedélyezéséhez az ESP-IDF keretrendszer alacsony szintű függvényét kell használnunk, ezért importálnunk kell az ‘esp_wifi.h’ könyvtárat, hogy használhassuk az ‘esp_wifi_set_ps(WIFI_PS_MAX_MODEM)’ függvényt.

#include <esp_wifi.h>
....

esp_wifi_set_ps(WIFI_PS_MAX_MODEM);

Modem alvás letiltása.

Ez az üzemmód teljesen letiltja a modem alvó üzemmódját. Ez sokkal nagyobb energiafogyasztást eredményez, de minimális késleltetést biztosít a adatok valós idejű fogadásához a wifi hálózaton.

Itt is használhatjuk a ‘Wifi.h’ könyvtár ‘setSleep()’ függvényét.

#include <Wifi.h>
....

WiFi.setSleep(false);

Vagy importáljuk az ‘esp_wifi.h’ könyvtárat, az ‘esp_wifi_set_ps(WIFI_PS_NONE )’ függvény használatához.

#include <esp_wifi.h>
....

esp_wifi_set_ps(WIFI_PS_NONE);

A rádiócsoport elemeinek letiltása.

Elég zavaros, hogy mi tartozik a modem alvó mód megvalósításához. Egyesek szerint a teljes rádiócsoport letiltása, mások szerint a wifi modem minimális alvó módja (ez egyébként az alapértelmezett mód) elegendő.

Mindenesetre további energiamegtakarítás eléréséhez, ha nem használjuk, leállíthatjuk a Bluetooth-rádiót.

btStop();

Ha nincs szükségünk a wifi-re, akkor azt is letilthatjuk. Elöször leállítjuk a wifit a ‘WiFi.disconnect(true);’ függvénnyel, majd a ‘WiFi.mode(WIFI_OFF);’ függvény segítségével letiltjuk a wifi modem működését.

#include <Wifi.h>
...

WiFi.disconnect(true);
WiFi.mode(WIFI_OFF);

Ezzel az átlagos energiafogyasztás nem változik számottevően, de nem reagál a DTIM beacon üzenetekre, ezért a wifi adat fogadáskor megugró áramfogyasztás megszűnik. Ezzel is pár mA-t megtakaríthatunk.

A WiFi visszaállításához a következő funkciókat kell végrehajtani:

#include <Wifi.h>
...

WiFi.disconnect(false);
WiFi.mode(WIFI_STA);
WiFi.begin(STA_SSID, STA_PASS);
while (WiFi.status() != WL_CONNECTED)
{
  delay(500);
}

Csökkentsük a CPU órajel frekvenciáját.

Az áramfogyasztás jelentősen függ a CPU órajelétől. Ebben az üzemmódban is jobb eredményt érhetünk el a CPU órajel csökkentésével. Az órajel frekvencia csökkentése mérsékli az áramfogyasztást, az órajel emelése viszont megnöveli az energiafelhasználást.

Az alábbi táblázatban láthatjuk az energiafelhasználást a CPU órajel frekvencia függvényében.

CPU frekvencia	Energiafogyasztás
240 MHz	30 mA ~ 68 mA
160 MHz	27 mA ~ 44 mA
80 MHz	20 mA ~ 31 mA

Létezik egy függvény a CPU frekvencia beállítására, ez a ‘setCpuFrequencyMhz(80)’.

setCpuFrequencyMhz(80);

És van egy függvény a CPU frekvencia lekérésére, a ‘getCpuFrequencyMhz()’

Serial.println(getCpuFrequencyMhz());

void setup()
{
  Serial.begin(115200);

  delay(2000);
  Serial.print("basic frequency: ");
  Serial.println(getCpuFrequencyMhz());
  delay(1000);
  
  setCpuFrequencyMhz(80);

  delay(2000);
  Serial.print("1. modified frequency: ");
  Serial.println(getCpuFrequencyMhz());

  setCpuFrequencyMhz(40);

  delay(2000);
  Serial.print("2. modified frequency: ");
  Serial.println(getCpuFrequencyMhz());
}

void loop(){}

Vissza a tartalomhoz

Könnyű alvás mód

Az ESP32 könnyű alvás (light sleep) üzemmódban a wifi és bluetooth rádió nem működik, a CPU müködése felfüggesztésre kerül (órajel-vezérelten működik), valamint a RAM nagy része és a digitális perifériák leállnak.

Az ESP32 blokkvázlata könnyű alvás üzemmódban így néz ki:

A könnyű alvás módra váltás sikertelen lehet, ha van aktív wifi vagy bluetooth adatforgalom, érdemes lehet elötte megszakítani a kapcsolatot.

btStop();
WiFi.disconnect(true);
WiFi.mode(WIFI_OFF);

Az ESP32 könnyű alvás üzemmódját az alábbi függvénnyel aktiválhatjuk.

esp_light_sleep_start();

A könnyű alvás mód aktiválása előtt meg kell adnunk a rendszer felébresztési módját, majd indíthatjuk a könnyü alvás módot.

Ha ébresztési források konfigurálása nélkül lépünk alvó üzemmódba, a chip határozatlan ideig alvó üzemmódban lesz, amíg külső visszaállítást (reset) nem alkalmazunk.

A könnyű alvás módból való kilépéskor a CPU ott folytatja a működést ahol felfüggesztette a futást, a perifériák állapota, a változók ertéke megőrződik.

Az ESP32 chip könnyű alvás módból felébreszteni az ébresztőforrások fejezetben bemutatott módon lehetséges.

Vissza a tartalomhoz

Mély alvás mód

Az ESP32 mély alvás (deep sleep) üzemmódjában a CPU magok, a RAM jelentős része és az Advanced Peripheral Bus (APB_CLK) órájáról vezérelt összes digitális periféria kikapcsolásra kerül. Viszont továbbra is használható, a valós idejű óra (RTC) vezérlő, az Ultra Low Power(ULP) társprocesszor, az RTC perifériák, és az RTC memóriák.

Az ESP32 blokkvázlata mélyalvásban:

Az ESP32 mély alvás mód aktiválása előtt meg kell adnunk a rendszer felébresztési módját.

Ha ébresztési források megadása nélkül lépünk alvó üzemmódba, az esp32 mindaddig alvó módban lesz, amíg külső visszaállítást (reset) nem alkalmazunk.

A mély alvás üzemmódját a következő funkcióval aktiválhatjuk:

esp_deep_sleep_start();

Az ESP32 valahányszor felébred a mély alvásból, teljes újraindítást hajt végre ahelyett, hogy onnan folytatná, ahol felfüggesztette a program futását.

Ha bármilyen adatot kell tárolnunk, és a mély alvásból ébredés után előhívni, akkor azt az RTC memóriájába kell mentenünk. Az itt tárolt adatok mély alvás üzemmódban nem vesznek el, azonban a reset gomb megnyomásával törlődnek.

RTC_DATA_ATTR int myData = 0;

Viszatérni a mély alvás módból az ébresztőforrások fejezetben található módok valamelyikével lehetséges.

Vissza a tartalomhoz

Hibernációs mód

Az ESP32 hibernált állapota igazából egy kiterjesztett mély alvás üzemmód, amelynek célja az energiafogyasztás minimalizálása a lehető legalacsonyabb szintre. Ezt az állapotot gyakorlatilag az összes nem létfontosságú egység kikapcsolásával érhetjük el.

ESP32 hibernációs üzemmódban az összes oszcillátor, az RTC perifériatartomány és az RTC memóriák, valamint az Ultra Low Power(ULP) társprocesszor is letiltásra kerül.

Hibernációs üzemmódban csak egy RTC időzítő érhető el lassú órajelen, és csak bizonyos RTC GPIO pinek aktívak, amelyek a hibernált állapotból való felébresztéshez szükségesek. Ezzel messze a legalacsonyabb, akár 5 µA áramfogyasztást is elérhetünk.

Az ‘esp_sleep_pd_config()’ függvény segítséget nyújt az ESP32 chip energiatartományok kezeléséhez.

esp_sleep_pd_config(domain, option);

Energiatartomány domain
ESP_PD_DOMAIN_RTC_PERIPH	RTC perifériák
ESP_PD_DOMAIN_RTC_FAST_MEM	RTC gyors memória (ULP programok).
ESP_PD_DOMAIN_RTC_SLOW_MEM	RTC lassú memória (ULP adatok).
ESP_PD_DOMAIN_XTAL	kristályoszcillátor

Opciók a domainekhez
ESP_PD_OPTION_OFF	Kikapcsolja az adott domaint
ESP_PD_OPTION_ON	Bekapcsolja az adott domaint

esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_OFF);
esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_FAST_MEM, ESP_PD_OPTION_OFF);
esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_SLOW_MEM, ESP_PD_OPTION_OFF);
esp_sleep_pd_config(ESP_PD_DOMAIN_XTAL, ESP_PD_OPTION_OFF);

Ezután aktiválhatjuk a hibernációs üzemmódot.

esp_deep_sleep_start();

Mivel az RTC memória is kikapcsolásra kerül, hibernációs módban semmilyen adatot nem tudunk megőrizni. Ebben az esetben az adatok mentésének egyetlen módja az EEPROM-ba való beírás.

#include <EEPROM.h>
int myData = 1;

void setup()
{
  EEPROM.begin(1);
}
void loop()
{
  myData = 5;
  EEPROM.write(0, myData);
  EEPROM.commit();
}

Vissza a tartalomhoz

Ébresztési források, példák

Időzítő ébresztés

Az RTC időzítő beállítható az esp_sleep_enable_timer_wakeup() függvény segítségével, hogy egy megadott időközönként felébressze az ESP32-t a könnyű/mély alvás módból. A következő példa 5 másodperc elteltével felébreszti az ESP32_t.

esp_sleep_enable_timer_wakeup(5 * 1000000);   // 5 sec
esp_light_sleep_start();

Lássunk egy példát a könnyű alvásból való visszatéréhez.

byte ledPin = 4;

void setup() 
{
  Serial.begin(115200);
  delay(50);
  Serial.println("starting...");

  pinMode(ledPin, OUTPUT);
  digitalWrite(ledPin, LOW);
  delay(2000);
  digitalWrite(ledPin, HIGH);
  delay(2000);

  Serial.println("go to light sleep...");
  delay(50);
  esp_sleep_enable_timer_wakeup(5 * 1000000);   // 5 sec
  esp_light_sleep_start();

  Serial.println("hi again here!");
}

void loop(){}

Mint láthatjuk, az esp32 a könnyű alvásból ébredés után ott folytatja a program futását, ahol abbahagyta, tehát a „hi again here!” üdvözlés megjelenik a soros monitoron és a csatlakoztatott led folyamatosan világít.

Nézzük meg, mi történik a programunkal, ha mélyalvásba küldjük az esp32-t.

byte ledPin = 4;

void setup() 
{
  Serial.begin(115200);
  delay(50);
  Serial.println("starting...");

  pinMode(ledPin, OUTPUT);
  digitalWrite(ledPin, LOW);
  delay(2000);
  digitalWrite(ledPin, HIGH);
  delay(2000);

  Serial.println("go to deep sleep...");
  delay(50);
  esp_sleep_enable_timer_wakeup(5 * 1000000);   // 5 sec
  esp_deep_sleep_start();

  Serial.println("you never see this: hi again here!");
}

void loop(){}

Ebben az esetben az ébredést követően az esp32 újraindul. A be- és kimenetek újra iniciálódnak, nem őrzik meg a korábbi állapotukat. A „esp_deep_sleep_start()” függvény után következő programsorok soha nem futnak le.

A külső esemény hatására bekövetkező ébresztés (pl.: gombnyomás) egy másik módja az ESP32 felébresztésének. A külső ébresztésnek két lehetősége van: ext0 és ext1.

Külső ébresztés (ext0)

Az ESP32 rendelkezik 16 RTC GPIO-val, amelyek az RTC Low-Power alrendszer részét képezik. Ezek az RTC GPIO-k külső forrásból képesek felébreszteni az ESP32-t, amikor az Ultra Low Power (ULP) társprocesszor fut.

Az ext0 ébresztés azt jelenti, hogy felébreszthetjük az ESP32-t az alvásból egy RTC GPIO-hoz csatlakoztatott gomb megnyomásával.

Az ESP32 ébresztési forrás használatához a következő függvényt tudjuk használni:

esp_sleep_enable_ext0_wakeup(GPIO_pin_num, level);

A függvény első argumentuma a használni kívánt láb GPIO-száma. A második paraméter a GPIO azon állapotát jelöli, amely kiváltja az ébresztést. Ez 1 vagy 0 lehet.

Az RTC GPIO dedikált csapjai a következő ábrán látható:

RTC_GPIO0	GPIO36
RTC_GPIO3	GPIO39
RTC_GPIO4	GPIO34
RTC_GPIO5	GPIO35
RTC_GPIO6	GPIO25
RTC_GPIO7	GPIO26
RTC_GPIO8	GPIO33
RTC_GPIO9	GPIO32
RTC_GPIO10	GPIO4
RTC_GPIO11	GPIO0
RTC_GPIO12	GPIO2
RTC_GPIO13	GPIO15
RTC_GPIO14	GPIO13
RTC_GPIO15	GPIO12
RTC_GPIO16	GPIO14
RTC_GPIO17	GPIO27

A következő képen láthatjuk, az ESP32 38 pines fejlesztőkártyán melyek az RTC_GPIO csapok:

Egy példa az esp32 mélyalvásból gombnyomással ébresztéséhez.

const gpio_num_t ledPin = GPIO_NUM_4;
const gpio_num_t wakePin = GPIO_NUM_0;
int wakeLevel = 0;

void setup() 
{
  Serial.begin(115200);
  delay(50);
  Serial.println("starting...");

  pinMode(ledPin, OUTPUT);
  digitalWrite(ledPin, LOW);
  delay(2000);
  digitalWrite(ledPin, HIGH);
  delay(2000);

  Serial.println("go to deep sleep...");
  delay(50);
  esp_sleep_enable_ext0_wakeup(wakePin, wakeLevel);
  esp_deep_sleep_start();

  Serial.println("you never see this");
}
void loop(){}

Ez az ébresztési mód működik könnyű alvás esetén is:

const gpio_num_t ledPin = GPIO_NUM_4;
const gpio_num_t wakePin = GPIO_NUM_0;
int wakeLevel = 0;

void setup() 
{
  Serial.begin(115200);
  delay(50);
  Serial.println("starting...");

  pinMode(ledPin, OUTPUT);
  digitalWrite(ledPin, LOW);
  delay(2000);
  digitalWrite(ledPin, HIGH);
  delay(2000);

  Serial.println("go to light sleep...");
  delay(50);
  esp_sleep_enable_ext0_wakeup(wakePin, wakeLevel);
  esp_light_sleep_start();

  Serial.println("hi again here!");
}
void loop(){}

Külső ébresztés (ext1)

Az ext1 ébresztési forrás lehetővé teszi több RTC GPIO egyidejű használatát. Az ext1 ébresztési forrás használatához a következő függvényt kell használnunk:

esp_sleep_enable_ext1_wakeup_io(bitmask, mode);

Ez a függvény két argumentumot fogad el:

Az első argumentum, a GPIO-számok bitmaszkja, amelyek részt vesznek az ébresztésben.

A második, a ‘mode’ paraméter határozza meg az ébresztést kiváltó logikát.

Az ébresztést kiváltó logika
ESP_EXT1_WAKEUP_ALL_LOW	Felébred, amikor az összes engedélyezett GPIO alacsony szintre süllyed.
ESP_EXT1_WAKEUP_ANY_HIGH	Felébred, ha bármelyik engedélyezett GPIO magasra állapotba kerül.

Egy példa könnyű alvásból ext1 ébresztésel.

#include "driver/rtc_io.h"

const gpio_num_t ledPin = GPIO_NUM_4;
const gpio_num_t wakePin1 = GPIO_NUM_12;
const gpio_num_t wakePin2 = GPIO_NUM_14;
const gpio_num_t wakePin3 = GPIO_NUM_27;

// Makró a GPIO bitmaszkhoz
#define WAKE_PIN_BITMASK(GPIO) (1ULL << GPIO)

//Bitmaszk létrehozása
uint64_t bitmask = WAKE_PIN_BITMASK(wakePin1) | WAKE_PIN_BITMASK(wakePin2) | WAKE_PIN_BITMASK(wakePin3);

// függvény a felébresztést kiváltó GPIO kinyomtatására
void print_GPIO_wake_up()
{
  uint64_t GPIO_reason = esp_sleep_get_ext1_wakeup_status();
  Serial.print("Az ébresztést kiváltó pin: ");
  Serial.println((log(GPIO_reason))/log(2), 0);
}
void setup()
{
  Serial.begin(115200);
  delay(50);
  Serial.println("starting...");

  pinMode(ledPin, OUTPUT);
  digitalWrite(ledPin, LOW);
  delay(2000);
  digitalWrite(ledPin, HIGH);
  delay(2000);

  // lehúzó ellenállás aktiválása
  pinMode(wakePin1, INPUT_PULLDOWN);
  pinMode(wakePin2, INPUT_PULLDOWN);
  pinMode(wakePin3, INPUT_PULLDOWN);

  // az ébresztőpin(ek) konfigurálása RTC IO-ként EXT1 ébresztéshez
  rtc_gpio_deinit(wakePin1);
  rtc_gpio_deinit(wakePin2);
  rtc_gpio_deinit(wakePin3);

  // EXT1 ébresztési forrás engedélyezése
  esp_sleep_enable_ext1_wakeup(bitmask, ESP_EXT1_WAKEUP_ANY_HIGH);
}

void loop()
{
  Serial.println("Könnyű alvás üzemmódba lépés...");
  delay(100);
  // Könnyű alvásba lépünk
  esp_light_sleep_start();

  // Ébresztés után tiltsuk le a tartás funkciót az RTC GPIO-kon.
  rtc_gpio_hold_dis(wakePin1);
  rtc_gpio_hold_dis(wakePin2);
  rtc_gpio_hold_dis(wakePin3);

  Serial.println("Visszatérés a könnyű alvásból.");
  // Kiiratjuk az ébresztést okozó GPIO számát
  print_GPIO_wake_up();

  delay(2000);
}

Es egy másik ext1 ébresztés mélyalvásból.

#include "driver/rtc_io.h"

const gpio_num_t ledPin = GPIO_NUM_4;
const gpio_num_t wakePin1 = GPIO_NUM_12;
const gpio_num_t wakePin2 = GPIO_NUM_14;
const gpio_num_t wakePin3 = GPIO_NUM_27;

// Makró a GPIO bitmaszkhoz
#define WAKE_PIN_BITMASK(GPIO) (1ULL << GPIO)

//Bitmaszk létrehozása
uint64_t bitmask = WAKE_PIN_BITMASK(wakePin1) | WAKE_PIN_BITMASK(wakePin2) | WAKE_PIN_BITMASK(wakePin3);

// függvény a felébresztést kiváltó GPIO kinyomtatására
void print_GPIO_wake_up()
{
  uint64_t GPIO_reason = esp_sleep_get_ext1_wakeup_status();
  if(GPIO_reason != 0)
  {
    Serial.print("Az ébresztést kiváltó pin: ");
    Serial.println((log(GPIO_reason))/log(2), 0);
  }
}
void setup()
{
  Serial.begin(115200);
  delay(50);
  Serial.println("starting...");

  pinMode(ledPin, OUTPUT);
  digitalWrite(ledPin, LOW);
  delay(2000);
  digitalWrite(ledPin, HIGH);
  delay(2000);

  // lehúzó ellenállás aktiválása
  pinMode(wakePin1, INPUT_PULLDOWN);
  pinMode(wakePin2, INPUT_PULLDOWN);
  pinMode(wakePin3, INPUT_PULLDOWN);

  // az ébresztőpin(ek) konfigurálása RTC IO-ként EXT1 ébresztéshez
  rtc_gpio_deinit(wakePin1);
  rtc_gpio_deinit(wakePin2);
  rtc_gpio_deinit(wakePin3);

  // EXT1 ébresztési forrás engedélyezése
  esp_sleep_enable_ext1_wakeup(bitmask, ESP_EXT1_WAKEUP_ANY_HIGH);
}

void loop()
{
  rtc_gpio_hold_dis(wakePin1);
  rtc_gpio_hold_dis(wakePin2);
  rtc_gpio_hold_dis(wakePin3);

  print_GPIO_wake_up();

  Serial.println("Mélyalvás üzemmódba lépés...");
  delay(100);
  esp_deep_sleep_start();
}

Érintőpad ébresztés

Az ESP32 panel 10 kapacitív érintőképernyős GPIO-val rendelkezik (amelyek az ESP32 chiptől függően változhatnak). Ezek a GPIO-k képesek érzékelni az elektromos töltést tartalmazó dolgok, például az emberi bőr változásait. Így képesek érzékelni a GPIO-k ujjal történő megérintésekor keletkező változásokat. Ezek az ESP32 érintőtüskék használhatók az ESP32 felébresztésére a mély alvásból.

Az RTC IO modul tartalmazza a logikát érintésérzékelő által kiváltott ébresztés kezeléséhez. Az érintésérzékelő által történő felébresztéshez konfigurálnunk kell az érintőpad megszakítását, mielőtt az ESP32 mély vagy könnyű alvás módba lépne.

Az ‘esp_sleep_enable_touchpad_wakeup()’ függvény segítségével engedélyezhető az érintésérzékelő általi ébresztési forrás.

touchSleepWakeUpEnable(TOUCH_PIN, THRESHOLD);

Az ‘esp_sleep_get_touchpad_wakeup_status()’ függvény visszaadja, hogy melyik érintésérzékelő pin váltotta ki az ébresztést.

touch_pad_t touchPin = esp_sleep_get_touchpad_wakeup_status();

Az ESP32 érintésérzékelők ezekhez a dedikált GPIO-csapokhoz csatlakoznak.

Touch0	GPIO4
Touch1	GPIO0
Touch2	GPIO2
Touch3	GPIO15
Touch4	GPIO13
Touch5	GPIO12
Touch6	GPIO14
Touch7	GPIO27
Touch8	GPIO33
Touch9	GPIO32

Az Arduino IDE tartalmaz erre egy jól érthető példakódot a Fájl/Példák/ESP32 Deep Sleep/ menüpont alatt a TouchWakeUp vázlatot.

ULP társprocesszor ébresztése

Az ULP társprocesszor az ESP32 alvó üzemmódjában is futhat és az RTC SLOW memóriában tárolt programot futtatja. Használhatjuk szenzorok, ADC értékek lekérdezésére, érintésérzékelő figyelésére, de többek között a chip ébresztésére egy esemény észlelésekor.

Az RTC SLOW memóriához mind a CPU, mind az ULP társprocesszor hozzáférhet, így használhatjuk adatok megosztására a CPU és az ULP társprocesszor között.

Az ULP koprocesszor programozásáról az alábbi linken olvashatunk bővebben:

https://docs.espressif.com/projects/esp-idf/en/v5.4.2/esp32/api-reference/system/ulp.html#

Ébresztés okai

Sokszor tudnunk kell, hogy mi miatt ébredt fel az ESP32 az alvásból, hogy melyik feltétel szerint folytatódjon a programunk futása. Az ‘esp_sleep_get_wakeup_cause()’ függvény visszaadja, hogy mi váltotta ki az ébresztést.

esp_sleep_wakeup_cause_t wakeup_reason = esp_sleep_get_wakeup_cause();

switch(wakeup_reason)
{
case ESP_SLEEP_WAKEUP_EXT0 :
  Serial.println("Külső forrás által kiváltott ébresztés (ext0)"); 
  break;
case ESP_SLEEP_WAKEUP_EXT1 :
  Serial.println("Külső forrás által kiváltott ébresztés (ext1)"); 
  break;
case ESP_SLEEP_WAKEUP_TIMER :
  Serial.println("Időzítő által kiváltott ébresztés"); 
  break;
case ESP_SLEEP_WAKEUP_TOUCHPAD :
  Serial.println("Érintőpad által kiváltott ébresztés"); 
  break;
case ESP_SLEEP_WAKEUP_ULP :
  Serial.println("ULP program által kiváltott ébresztés");
  break;
default : 
  Serial.printf("Nem meghatározott forrás: %d\n",wakeup_reason); 
  break;
}

#include "driver/rtc_io.h"

const gpio_num_t ledPin = GPIO_NUM_4;
const gpio_num_t wakePin1 = GPIO_NUM_12;
const gpio_num_t wakePin2 = GPIO_NUM_14;
const gpio_num_t wakePin3 = GPIO_NUM_27;
const gpio_num_t wakePin = GPIO_NUM_0;
int wakeLevel = 0;

// Makró a GPIO bitmaszkhoz
#define WAKE_PIN_BITMASK(GPIO) (1ULL << GPIO)

//Bitmaszk létrehozása
uint64_t bitmask = WAKE_PIN_BITMASK(wakePin1) | WAKE_PIN_BITMASK(wakePin2) | WAKE_PIN_BITMASK(wakePin3);

// függvény a felébresztést kiváltó GPIO kinyomtatására
void print_GPIO_wake_up()
{
  uint64_t GPIO_reason = esp_sleep_get_ext1_wakeup_status();
  if(GPIO_reason != 0)
  {
    Serial.print("Az ébresztést kiváltó pin: ");
    Serial.println((log(GPIO_reason))/log(2), 0);
  }
}

// függvény a felébresztést kiváltó ok kinyomtatására
void print_wakeup_reason()
{
  esp_sleep_wakeup_cause_t wakeup_reason;

  wakeup_reason = esp_sleep_get_wakeup_cause();

  switch(wakeup_reason)
  {
  case ESP_SLEEP_WAKEUP_EXT0 :
    Serial.println("Külső forrás által kiváltott ébresztés (ext0)"); 
    break;
  case ESP_SLEEP_WAKEUP_EXT1 :
    Serial.println("Külső forrás által kiváltott ébresztés (ext1)"); 
    break;
  case ESP_SLEEP_WAKEUP_TIMER :
    Serial.println("Időzítő által kiváltott ébresztés"); 
    break;
  case ESP_SLEEP_WAKEUP_TOUCHPAD :
    Serial.println("Érintőpad által kiváltott ébresztés"); 
    break;
  case ESP_SLEEP_WAKEUP_ULP :
    Serial.println("ULP program által kiváltott ébresztés");
    break;
  default : 
    Serial.printf("Nem meghatározott forrás: %d\n", wakeup_reason); 
    break;
  }
}

void setup()
{
  Serial.begin(115200);
  delay(50);
  Serial.println("starting...");

  pinMode(ledPin, OUTPUT);
  digitalWrite(ledPin, LOW);
  delay(2000);
  digitalWrite(ledPin, HIGH);
  delay(2000);

  // lehúzó ellenállás aktiválása
  pinMode(wakePin1, INPUT_PULLDOWN);
  pinMode(wakePin2, INPUT_PULLDOWN);
  pinMode(wakePin3, INPUT_PULLDOWN);

  // az ébresztőpin(ek) konfigurálása RTC IO-ként EXT1 ébresztéshez
  rtc_gpio_deinit(wakePin1);
  rtc_gpio_deinit(wakePin2);
  rtc_gpio_deinit(wakePin3);


  // EXT0 ébresztési forrás engedélyezése
  esp_sleep_enable_ext0_wakeup(wakePin, wakeLevel);

  // EXT1 ébresztési forrás engedélyezése
  esp_sleep_enable_ext1_wakeup(bitmask, ESP_EXT1_WAKEUP_ANY_HIGH);

  // RTC időzítő ébresztési forrás engedélyezése
  esp_sleep_enable_timer_wakeup(15 * 1000000);
}

void loop()
{
  rtc_gpio_hold_dis(wakePin1);
  rtc_gpio_hold_dis(wakePin2);
  rtc_gpio_hold_dis(wakePin3);

  print_wakeup_reason();
  print_GPIO_wake_up();

  Serial.println("Könnyű alvás üzemmódba lépés...");
  delay(1000);
  esp_light_sleep_start();
}

Vissza a tartalomhoz