Tartalomjegyzék:

Az akkumulátor élettartamának megtakarítása mély alvással: 20 lépés
Az akkumulátor élettartamának megtakarítása mély alvással: 20 lépés

Videó: Az akkumulátor élettartamának megtakarítása mély alvással: 20 lépés

Videó: Az akkumulátor élettartamának megtakarítása mély alvással: 20 lépés
Videó: Hogyan válasszunk autó akkumulátort 🔋 | AUTODOC tippek 2024, December
Anonim
Image
Image
Az ESP32 ébresztésének módjai
Az ESP32 ébresztésének módjai

Szeretne akkumulátort használni az ESP32 készülékkel? Ha igen, ma megvitatok néhány fontos technikai információt ezzel a témával kapcsolatban. Tudjuk, hogy ez a mikrokontroller sok energiát költ, amikor információt továbbít. Közel 190 milliampert fogyaszt. Ebben a videóban megmutatom, hogyan takaríthat meg energiát az ESP32-től az úgynevezett "DEEP SLEEP" funkcióval. Beállítjuk a chipet ebbe az üzemmódba való belépéshez, megtanuljuk, hogyan lehet kilépni ebből a módból, és létrehozunk egy példát, amely bemutatja az ESP32 felébresztésének három különböző módját.

Fontos megjegyezni, hogy a rádió sok energiát költ, nem pedig a processzor. Az energiatakarékosság nagyon fontos. Ennek az az oka, hogy a végpontok (az információkat küldő áramkörök) gyakran elemmel működnek, és öt évig kell tartaniuk. Vannak olyan gyártók, amelyek akár tíz évet is ígérnek, és ez érvényes a kiváló minőségű akkumulátorokra, amelyek nem használják annyira a végpontokat. Minden más esetben azt tanácsolom, hogy használja a mély alvást, hogy energiát takarítson meg az áramkörből.

1. lépés: Bevezetés

Az ESP32 energiatakarékos üzemmóddal rendelkezik, amelyet „mély alvásnak” neveznek. Ebben a módban a CPU -k, a legtöbb RAM és az összes digitális órajelű periféria ki van kapcsolva. A chip egyetlen csatlakoztatható része még az RTC vezérlő, az RTC perifériák (beleértve az ULP társprocesszort) és az RTC memóriák.

Többféleképpen is felébreszthetjük az ESP32 -t alvás közben. Az ébresztési források bármikor beállíthatók, mielőtt mély alvás üzemmódba lépnének.

2. lépés: Az ESP32 ébresztésének módjai

Az ESP32 felébresztésének öt módja van:

• Időzítő

• Külső ébresztés (ext0)

• Külső ébresztés (ext1)

• ULP társprocesszoros ébresztés

• Érintőpad

3. lépés: Időzítő

Az RTC vezérlő beépített időzítővel rendelkezik, amellyel aktiválható a chip egy előre meghatározott idő elteltével. Az időt mikroszekundumos pontossággal adják meg.

esp_deep_sleep_enable_timer_wakeup (uint64_t time_in_us)

time_in_us> az idő mikroszekundumban

4. lépés: Külső ébresztés (ext0)

Az RTC IO modul olyan logikát tartalmaz, amely riasztást vált ki, amikor az RTC GPIO -k egy előre meghatározott logikai szintre lépnek. Az RTC IO része az RTC perifériák tápellátási tartományának, így az RTC perifériák életben maradnak a mély alvás alatt, ha ezt az aktiválási forrást kérik.

esp_deep_sleep_enable_ext0_wakeup (gpio_num_t gpio_num, int szint)

gpio_num> Aktiválási forrásként használt GPIO -szám. Csak RTC-funkciójú GPIO-k használhatók: 0, 2, 4, 12-15, 25-27, 32-39.

szint> bemeneti szint, amely kiváltja a riasztást (0 = LOW, 1 = HIGH)

5. lépés: Külső ébresztés (ext1)

Az RTC vezérlő logikát tartalmaz az ébresztőóra aktiválására több RTC GPIO használatával.

esp_deep_sleep_enable_ext1_wakeup (uint64_t maszk, esp_ext1_wakeup_mode_t mód)

maszk> GPIO -számok bitmaszkja, amelyek aktiválást okoznak. Ebben a bittérképben csak RTC-kompatibilis GPIO-k használhatók: 0, 2, 4, 12-15, 25-27, 32-39.

mód> válassza ki az aktiválási feltétel meghatározásához használt logikai függvényt:

• ESP_EXT1_WAKEUP_ALL_LOW: felébred, amikor az összes kiválasztott GPIO alacsony

• ESP_EXT1_WAKEUP_ANY_HIGH: felébred, ha a kiválasztott GPIO -k bármelyike magas

6. lépés: ULP Coprocessor Wakeup

Az ULP társprocesszor működhet, amíg a chip mély alvó üzemmódban van, és használható érzékelők keresésére, az ADC vagy kapacitív érintésérzékelő értékeinek figyelésére, valamint a chip aktiválására, ha egy adott eseményt észlel.

Az ULP társprocesszor része az RTC perifériák tápellátási tartományának, és futtatja a lassú memóriájú RTC -ben tárolt programot. Ezért az RTC perifériák és az RTC lassú memória aktiválódnak a mély alvás során, ha ezt az aktiválási módot kérik.

7. lépés: Érintőpad

Az RTC vezérlő logikát tartalmaz a riasztás aktiválásához a kapacitív érintésérzékelők segítségével. Az érintőcsap definíciója azonban eltérő. Az érintésmegszakítást minden kívánt csapnál használnunk kell.

A megszakítások beállítása után engedélyeztük az ébresztési módot az érzékelők használatához.

// Érintőpad beállítása ébresztési forrásként esp_sleep_enable_touchpad_wakeup ();

8. lépés: Belépés a mély alvó üzemmódba

Az ébresztési mód beállítása után elegendő egyetlen parancs az ESP32 mély alvó üzemmódba állításához (2,5 μA vagy kevesebb). Itt hangsúlyozom, hogy ez a költség az ESP chipből származik, és nem a lemezből, mivel az utóbbi többet költ.

esp_deep_sleep_start ();

Ebből a parancsból az ESP32 elalszik, és nem hajtja végre például a következő kódsorokat.

Fontos: A fenti parancs végrehajtása előtt minden ébresztési beállítást meg kell adni.

9. lépés: Íme néhány fontosabb információ

Íme néhány fontosabb információ
Íme néhány fontosabb információ

Az alábbi hívás az ESP32 felébresztésének okát adja vissza.

1: EXT0 2: EXT1 3: TIMER 4: TOUCHPAD 5: ULP

esp_sleep_get_wakeup_cause ();

Ha az ébresztőt az érintőpad segítségével állítjuk be, akkor a paranccsal vissza tudjuk állítani, hogy melyik GPIO az érintés

esp_sleep_get_touchpad_wakeup_status ();

Minden alkalommal, amikor az ESP32 felébred, újra átfut a beállításon. Így minden olyan változó, amely nincs meghatározva az RTC memóriában, visszatér a saját állapotába.

Annak érdekében, hogy elalvás után is megőrizze a változókat a memóriában, használja az alábbi példában szereplő változó deklarációt:

// RTC_DATA_ATTR a változó memória RTCRTC_DATA_ATTR int bootCount = 0;

10. lépés: demonstráció

Demonstráció
Demonstráció

A videón látható, hogy a program a képnek megfelelően működik.

11. lépés: WiFi NodeMCU-32S ESP-WROOM-32

WiFi csomópontMCU-32S ESP-WROOM-32
WiFi csomópontMCU-32S ESP-WROOM-32

12. lépés: Összeszerelés

Összeszerelés
Összeszerelés

13. lépés: Programozás

Most készítünk egy programot, ahol az ESP32 -t úgy konfiguráljuk, hogy mély alvó üzemmódba lépjen. Ez háromféleképpen ébreszthető fel: az egyik a külső ébresztéshez (ext0), a másik az időzítőhöz és egy az érintőpadhoz. Nem tudnak együtt dolgozni, ezért az ébredés módjának konfigurálásához olyan változót fogunk használni, amely az ESP32 által a Boot által megadott számok számát fogja használni.

14. lépés: Könyvtár szükséges

Könyvtár szükséges
Könyvtár szükséges

Az OLED kijelző vezérléséhez külső könyvtárra van szükségünk. Ehhez letöltjük az U8g2 könyvtárat.

Az Arduino IDE -ben lépjen a Vázlat menübe >> Könyvtár beillesztése >> Könyvtárak kezelése….

15. lépés: Könyvtárak és változók

Tartalmaztuk az OLED kijelző vezérlésére szolgáló könyvtárat, valamint a kijelzővezérlő példányának konstruktorát. Ezenkívül kiosztjuk a változót az RTC memóriában. Beállítottuk az érzékenységet az érintés elfogadására, a mikroszekundumos konverziós tényezőt másodpercekre, és azt az időt, amikor az ESP32 alvó üzemmódba lép (másodpercben).

#include // biblioteca para controle do display oled

// construtor da instancia do controlador do display // SDA = 21 e SCL = 22 U8X8_SSD1306_128X64_NONAME_SW_I2C kijelző (SCL, SDA, U8X8_PIN_NONE); // RTC_DATA_ATTR a memória változó szintjén RTC RTC_DATA_ATTR int bootCount = 0; // sensibilidade para aceitação do toque #define Threshold 40 // fator de conversão de microsegundos para segundos #define uS_TO_S_FACTOR 1000000 // tempo que o ESP32 ficará em modo sleep (em segundos) #define TIME_TO_SLEEP 3

16. lépés: Beállítás

A telepítés során növeljük a rendszerindítás alkalmának számát. Funkciónak hívjuk a Boot motívum kinyomtatását. Ha a rendszerindítási szám PAR, az ESP32 -et az (EXT0) gombbal ébresztjük. Ha a 3 többszöröse, akkor beállítjuk, hogy az ESP32 felébredjen egy meghatározott idő után. Ellenkező esetben beállítottuk a kapacitív érintkezőcsapokat az ESP32 felébresztésére. Végül beállítottuk az érintőpadot ébresztési forrásként, és kényszerítettük az ESP32 -t alvó üzemmódba.

void setup () {Serial.begin (115200); késleltetés (1000); // növekmény o szám de vezes que o BOOT ocorreu ++ bootCount; configureDisplay (); // chama a função para imprimir o motivo do BOOT print_wakeup_reason (); // se o numero de boot for PAR Configuramos o ESP32 para despertar através do botão (EXT0) if (bootCount % 2 == 0) {esp_sleep_enable_ext0_wakeup (GPIO_NUM_39, 1); // 1 = Magas, 0 = Alacsony} // se a multiplo de 3 konfigurációkhoz vagy az ESP32 paramétereihez, de temp tempo definido else if (bootCount % 3 == 0) {esp_sleep_enable_timer_wakeup (TIME_TO_SLEEP * uS_TO_S_FACTOR); } // caso contrario configuramos os pinos de touch kapacitivo para despertar o ESP32 else {// Setup interrupt on Touch Pad 5 (GPIO12) touchAttachInterrupt (T5, callback, Threshold); // Érintőpad beállítása ébresztési forrásként esp_sleep_enable_touchpad_wakeup (); } Serial.println (“entrando em modo sleep”); esp_deep_sleep_start (); // força o ESP32 entrar em modo SLEEP}

17. lépés: Loop, visszahívás és ConfigureDisplay

A Loopban nincs dolgunk. Ezután folytatjuk a visszahívás megszakítását, ha van valami teendőnk, amikor a megszakítás bekövetkezik. Ami a configureDisplay -t illeti, inicializáljuk a kijelzőt, és konfigurálunk néhány paramétert. A képernyőn kinyomtatjuk, hányszor történt a rendszerindítás.

// nada a se fazer no loopvoid loop () {} // callback das interrupções void callback () {// caso queira fazer algo ao ocorrer a interrupção} void configureDisplay () {// inicializa o display e configura alguns parametros display. kezdődik(); display.setPowerSave (0); // modo powerSave (0-Off? 1-On) display.setFont (u8x8_font_torussansbold8_u); // fonte utilizada // imprime no display os numero de vezes que aconteceu o BOOT display.drawString (0, 0, "BOOT NUM:"); display.drawString (0, 2, Karakterlánc (bootCount).c_str ()); display.drawString (0, 4, "MOTIVO:"); }

18. lépés: Print_wakeup_reason (az ébredés okának ismerete)

Itt az a funkciónk, hogy kinyomtassuk az ESP32 felébredésének okát. Ellenőrizze a tűt és nyomtasson a kijelzőn.

// função para imprimir a causa do ESP32 despertarvoid print_wakeup_reason () {esp_sleep_wakeup_cause_t wakeup_reason; Karakterlánc oka = ""; wakeup_reason = esp_sleep_get_wakeup_cause (); // recupera a causa do despertar switch (wakeup_reason) {case 1: reason = "EXT0 RTC_IO BTN"; szünet; 2. eset: ok = "EXT1 RTC_CNTL"; szünet; 3. eset: ok = "IDŐZÍTŐ"; szünet; 4. eset: ok = "TOUCHPAD"; szünet; 5. eset: ok = "ULP PROGRAM"; szünet; alapértelmezett: reason = "NO DS CAUSE"; szünet; } Serial.println (ok); display.clearLine (6); // apaga a linha 6 do display.drawString (0, 6, reason.c_str ()); // imprime a causa do despertar no display // se despertou por TOUCHPAD, então vamos verificar em quality dos pinos ocorreu if (wakeup_reason == 4) {print_wakeup_touchpad (); // verifica o pino e imprime no display}}

19. lépés: Print_wakeup_touchpad (ismerje meg a GPIO Touch -ot)

Most ebben a lépésben van az a funkciónk, hogy kinyomtassuk a megérintett csapot. Visszaállítottuk a GPIO -t, amely felébresztette az ESP32 -et, és kinyomtattuk a kijelzőn.

// função para imprimir o pino que foi tocadovoid print_wakeup_touchpad () {touch_pad_t touchPin; touchPin = esp_sleep_get_touchpad_wakeup_status (); // recupera o GPIO que despertou o ESP32 String GPIO = ""; switch (touchPin) {case 0: GPIO = "4"; szünet; 1. eset: GPIO = "0"; szünet; 2. eset: GPIO = "2"; szünet; 3. eset: GPIO = "15"; szünet; 4. eset: GPIO = "13"; szünet; 5. eset: GPIO = "12"; szünet; 6. eset: GPIO = "14"; szünet; 7. eset: GPIO = "27"; szünet; 8. eset: GPIO = "33"; szünet; 9. eset: GPIO = "32"; szünet; alapértelmezett: Serial.println ("Wakeup not by touchpad"); szünet; } Serial.println ("GPIO:"+GPIO); display.clearLine (7); // az a 7 és a display display.drawString (0, 7, "GPIO:"); display.drawString (6, 7, GPIO.c_str ()); // imprime o GPIO}

20. lépés: Töltse le a fájlokat

PDF

ÉN NEM

Ajánlott: