Esp32 aktív mód és mély alvó üzemmód energiafogyasztása

Az ESP32 az egyik legnépszerűbb Wi-Fi alapú mikrokontroller modul, és számos hordozható IoT alkalmazásban népszerű választás. Ez egy nagy teljesítményű vezérlő, amely támogatja a kétmagos programozást, és beépített Bluetooth Low Energy (BLE) támogatással is rendelkezik, így jó választás olyan hordozható alkalmazásokhoz, mint például az iBeacon eszközök, a GPS nyomkövetők stb., a legfőbb gond az akkumulátor biztonsági mentése. Ez az akkumulátor-tartalék növelhető a mikrovezérlő egység intelligensebb vezérlésével, mint például az ESP32 alvó üzemmódba programozása ideális állapotban a készülék akkumulátorának biztonsági mentésének növelése érdekében.

Ebben a projektben ellenőrizni fogjuk a széles körben elterjedt Wi-Fi és Bluetooth-kompatibilis ESP32 mikrovezérlő egység jelenlegi fogyasztását normál üzemmódban és mély alvó üzemmódban. Ezenkívül teszteljük a különbséget és ellenőrizzük, hogyan lehet az ESP32-et mély alvó üzemmódba állítani. Megtekintheti a mikrovezérlők energiafogyasztásának minimalizálásáról szóló cikket, és más tippeket is felhasználhat, amelyek segítségével a terv sokkal energiahatékonyabbá tehető. Továbbá, ha érdekel más mikrovezérlők alvási üzemmódja, kiválaszthatja az Arduino alvó üzemmódot és az ESP8266 NodeMCU alvó üzemmódot is.

Követelmények

Ehhez az ESP32 alapú Devkit V4.0-t használjuk az Espressif-től, amely rendelkezik USB-től UART-híddal, valamint más ESP32-csatlakozókat a könnyű csatlakozáshoz. A programozás az Arduino IDE-vel történik. Ha teljesen új vagy, akkor az ESP32 használatának megkezdése az Arduino használatával kapcsolatban olvassa el a kapcsolódó cikket, mielőtt folytatná.

A projekt követelményei a következők:

1. Egy gombnyomással mély alvás üzemmódba kapcsol.
2. A mély alvás üzemmódból egy másik gomb megnyomásával ébred fel.
3. Az ESP32 állapotának észleléséhez a LED villogni kezd, bekapcsolási ideje 1000 milliszekundum. Alvó üzemmódban kikapcsol.

Ezért további alkatrészek szükségesek-

1. LED - 1 db
2. Nyomógomb (tapintható kapcsoló) - 2 db
3. 4,7 ezer ellenállás - 2 db
4. 680R ellenállás - 1 db
5. Kenyérlemez
6. Csatlakoztassa a vezetéket
7. 5 V-os adapter vagy tápegység
8. Mikro-USB kábel
9. Arduino IDE ESP32 programozási felülettel egy PC-ben vagy laptopban.

ESP32 alvó üzemmód áramkör diagram

Az ESP32 nyomógombbal történő alvásának vázlata az alábbiakban látható.

A vázlat meglehetősen egyszerű. Két gombja van. Az alvó gomb az ESP32-et mély alvó üzemmódba kapcsolja, és egy másik kapcsolót használ az ESP32 alvó üzemmódból való ébresztésére. Mindkét gomb a 16-os és a 33-as PIN-kódban van összekapcsolva. Mindkét gomb aktív alacsonyan van konfigurálva, amikor megnyomják, ezért további felhúzás adódik. Annak megállapításához, hogy az ESP 32 alvó vagy normál üzemmódban van-e, a LED csatlakozik az IO 4-es csatlakozóhoz.

Az alvási módok áttekintése az ESP32-ben

Az ESP32 számára számos különféle energiamód van, nevezetesen aktív mód, modem alvó üzemmód, könnyű alvó üzemmód, mély alvás üzemmód és hibernált mód.

Normál üzemi körülmények között az ESP32 aktív üzemmódban működik. Az ESP32 aktív módban a CPU, a WiFi / BT hardver, az RTC memória és az RTC perifériák, az ULP társprocesszorok mind aktiválódnak és működnek a munkaterheléstől függően. Különböző energiamódok esetén azonban egy vagy több perifériát kikapcsolnak. A különböző üzemmód-műveletek ellenőrzéséhez kövesse az alábbi táblázatot -

Hardver	Aktív mód	Modem-alvó mód	Könnyű alvó üzemmód	Mély alvás üzemmód	Hibernálás
CPU	TOVÁBB	TOVÁBB	SZÜNET	KI	KI
WiFi / BT	TOVÁBB	KI	KI	KI	KI
RTC és RTC perifériák	TOVÁBB	TOVÁBB	TOVÁBB	TOVÁBB	KI
ULP-Co processzor	TOVÁBB	TOVÁBB	TOVÁBB	BE KI	KI

Amint a fenti táblázatból kiderül, hogy az ESP32 mély alvás üzemmódban, amelyet gyakran ULP érzékelő által megfigyelt mintának hívnak - a CPU, a WiFi / BT, az RTC memória és a perifériák, az ULP társprocesszorok mind ki vannak kapcsolva. Csak az RTC memória és az RTC perifériák vannak bekapcsolva.

Az ébresztési helyzet során az ESP32-t egy olyan ébresztőforrásnak kell értesítenie, amely felébreszti az ESP32-et a mély alvó üzemmódból. Mivel azonban az RTC perifériák be vannak kapcsolva, az ESP32 az RTC-kompatibilis GPIO-k segítségével ébreszthető fel. Vannak más lehetőségek is. Fel lehet ébreszteni egy külső ébresztés megszakító csapok segítségével, vagy egy időzítővel az ESP32 felébresztésére. Ebben a projektben ext0 ébresztést használunk a 33. tűn.

ESP32 programozása mély alvó üzemmódba

A teljes program az oldal alján található. Arduino IDE-hez készült, és így könnyen adaptálható az Ön igényeinek. A kód magyarázata a következő.

A kód elején, // PushButton változó létrehozása PushBnt pushBtn = {GPIO_NUM_16, 0, false}; // definiálja a Led Pin-t uint8_t led_pin = GPIO_NUM_4; // definiálja az ébresztőcsapot uint8_t wakeUp_pin = GPIO_NUM_33;

A fenti három vonal határozza meg az ébresztő tüskét, a LED csapot és az alvó üzemmód tüskéjét.

void setup () { // tegye ide a beállító kódot, hogy egyszer fusson: // állítsa a soros portot 115200-ra Serial.begin (115200); késés (1000); // állítsa be a pushButton csapot bemenetként a belső PullUp pinMode-mel (pushBtn.pin, INPUT_PULLUP); // állítsa be a megszakítás kezelőt a pushButton csapszeggel a Falling üzemmódba attachInterrupt (pushBtn.pin, isr_handle, FALLING); // állítsa be a Led csapot ouput pinMode-ként (led_pin, OUTPUT); // hozzon létre egy feladatot, amelyet a blinkLed () függvényben hajtanak végre, elsőbbséggel és a core 0 xTaskCreate ( blinkLed, / * Task függvény. * / "blinkLed", / * feladat neve. * / 1024 * 2, / * A feladat veremmérete * / NULL, / * a feladat paramétere * / 5, / * a feladat prioritása * / & taskBlinkled); / * Feladatkezelő a létrehozott feladat nyomon követéséhez * / delay (500); // Konfigurálja a 33. tűt ext0 ébresztési forrásként LOW logikai szinttel esp_sleep_enable_ext0_wakeup ((gpio_num_t) wakeUp_pin, 0); }

A fentiekben a megszakítást a kódrészlet eső üzemmódra állítja

attachInterrupt (pushBtn.pin, isr_handle, FALLING);

Ezért amikor a kapcsolót megnyomják, a logikai szint az 1. logikáról (3.3V) 0 logikára (0V) változik. A gombostű feszültsége csökken, és az ESP32 felismeri, hogy a kapcsolót megnyomták. A LED villogására is van egy feladat.

xTaskCreate ( blinkLed, / * Feladat függvény. * / "blinkLed", / * feladat neve. * / 1024 * 2, / * Feladat halmozási mérete * / NULL, / * a feladat paramétere * / 5, / * prioritás a feladat * / & taskBlinkled); / * Feladatkezelő a létrehozott feladat nyomon követéséhez * / delay (500);

A 33 tűt az alábbi kódrészlet használatával konfigurálják külső ébresztési forrásként, amelyet ext0-ként azonosítanak.

esp_sleep_enable_ext0_wakeup ((gpio_num_t) wakeUp_pin, 0);

Ezután a while ciklusban

void loop () { // tegye ide a fő kódot, hogy többször is fusson: if (pushBtn.pressed) { Serial.printf ("PushButton (% d) megnyomva \ n", pushBtn.pin); Serial.printf ("Felfüggeszti a 'blinkLed' Feladatot \ n"; // A blinkLed Task vTaskSuspend (taskBlinkled) felfüggesztése ; digitalWrite (led_pin, LOW); Serial.printf ("Aludni megyek….. \ n", pushBtn.pin); pushBtn.pressed = false; // Menj aludni most esp_deep_sleep_start (); } esp_sleep_wakeup_cause_t wakeupReason; wakeupReason = esp_sleep_get_wakeup_cause (); kapcsoló (wakeupReason) { eset ESP_SLEEP_WAKEUP_EXT0: Serial.println ("az ext0 külső jel használata a WakeUp From alváshoz"); szünet; ESP_SLEEP_WAKEUP_EXT1 eset: Serial.println ("az ext1 külső jel használata WakeUp From alváshoz"); szünet; ESP_SLEEP_WAKEUP_TIMER eset: Serial.println ("Idõzítõ jel használata a WakeUp From sleep" -hez); szünet; eset ESP_SLEEP_WAKEUP_TOUCHPAD: Serial.println ("az érintőtábla jelének használata a WakeUp From sleep" funkcióhoz); szünet; ESP_SLEEP_WAKEUP_ULP eset: Serial.println ("ULP jel használata a WakeUp From sleep" -hez); szünet; alapértelmezett: break; Serial.printf ("Folytassa a 'blinkLed' Feladatot \ n"); // indítsa újra a blinkLed Task vTaskResume (taskBlinkled) parancsot; } }

A while hurok folyamatosan ellenőrzi, hogy megnyomták-e az alvó gombot. Ha megnyomja a gombot, akkor leállítja vagy felfüggeszti a LED villogását és futtatja az esp mély alvás indítás funkciót.

esp_deep_sleep_start ();

Ebben a helyzetben, ha megnyomja az ext0 külső megszakító gombot, az azonnal felébred a mély alvás üzemmódból, és folytatja a led villogást.

Végül a LED villogása az alábbi részletekben látható, 1000 ms másodpercig villog a LED.

void blinkLed (void * param) { while (1) { static uint32_t pin_val = 0; // kapcsolja a pin értéket pin_val ^ = 1; digitalWrite (led_pin, pin_val); Serial.printf ("Led -----------------% s \ n", pin_val? "Be": "Ki"); / * Egyszerűen kapcsolja a LED- et 1000 ms-onként vagy 1 másodpercenként * / vTaskDelay (1000 / portTICK_PERIOD_MS); } taskBlinkled = NULL; vTaskDelete (NULL); }

ESP32 tesztelése mély alvó üzemmódban

Az áramkört kenyérlemezbe építik, és az áram mérésére Metravi XB kiadású multimétert használnak. Az áramkör által aktív üzemmódban felvett áram majdnem 58 mA, de mélyen alvó üzemmódban az áram majdnem 4,10 mA. Az alábbi képen látható az ESP32 aktív üzemmód áramfogyasztása -

Mély alvó üzemmódban az áramfogyasztás 3,95 mA körüli értékre csökken, az alábbi képen az ESP32 mély alvó üzemmód áramfogyasztása látható.

A

Mély alvó üzemmódban azonban az ESP32 jelenlegi fogyasztása csaknem 150 uA. De ennek az ESP32 Devkit kártyának a felvett áramfogyasztása csaknem 4,10 mA. Ennek oka a CP2102 és a lineáris szabályozó. Ez a kettő az 5 V-os tápvezetékhez csatlakozik. A tápvezetékben van egy bekapcsolt LED is, amely majdnem 2mA áramot fogyaszt.

Ezért könnyen azonosítható, hogy az ESP32 nagyon alacsony energiafogyasztást igényel mély alvó üzemmódban, ami nagyon hasznos akkumulátoros működéshez. További információ a működéséről az alábbi linkre kattintva olvasható el. Ha bármilyen kérdése van, hagyja őket az alábbi megjegyzés részben, vagy más technikai kérdésekhez használja a fórumunkat.