Ang aktibong mode ng Esp32 at pagkonsumo ng kuryente ng mode ng matulog na mode

Ang ESP32 ay isa sa pinakatanyag na mga module ng microcontroller na batay sa Wi-Fi at ito ay isang tanyag na pagpipilian sa maraming mga Portable IoT Applications. Ito ay isang malakas na tagasuporta na sumusuporta sa Dual Core Programming at mayroon ding in-built na suporta ng Bluetooth Low Energy (BLE) na ginagawang isang mahusay na pagpipilian para sa mga portable application tulad ng sa iBeacon device, GPS Trackers, atbp Gayunpaman, sa mga application na pinapatakbo ng baterya tulad nito, ang pangunahing alalahanin ay ang pag-backup ng baterya. Ang backup ng baterya na ito ay maaaring madagdagan ng mas matalinong kontrol sa yunit ng microcontroller tulad ng isang maaaring programa ng ESP32 sa mode na pagtulog sa panahon ng perpektong kondisyon upang madagdagan ang pag-backup ng baterya ng aparato.

Sa proyektong ito, susuriin namin ang kasalukuyang pagkonsumo ng malawak na tanyag na unit ng Wi-Fi at Bluetooth na pinagana ng microcontroller unit na ESP32 sa normal na mode ng pagtatrabaho at malalim na mode sa pagtulog. Gayundin, susubukan namin ang pagkakaiba at suriin kung paano ilalagay ang ESP32 sa malalim na mode sa pagtulog. Maaari mo ring suriin ang artikulo kung paano i-minimize ang pagkonsumo ng kuryente sa mga microcontroller para sa iba pang mga tip na maaaring magamit upang gawing mas mahusay ang iyong disenyo. Bukod dito, kung interesado ka sa mode ng pagtulog ng iba pang mga microcontroller maaari kang mag-chek out ng Arduino Sleep mode at ESP8266 NodeMCU Sleep mode din.

Mga Kinakailangan

Upang magawa ito, gagamitin namin ang nakabase sa ESP32 na Devkit V4.0 mula sa Espressif na mayroong USB hanggang UART bridge pati na rin ang iba pang mga pinout ng ESP32 para sa madaling koneksyon. Ang programa ay gagawin sa Arduino IDE. Kung ganap kang bago, pagkatapos para sa Pagsisimula sa ESP32 gamit ang Arduino, basahin ang na-link na artikulo bago ka magpatuloy.

Ang mga kinakailangan ng proyektong ito ay ang mga sumusunod-

Pupunta ito sa deep mode ng pagtulog sa pamamagitan ng isang pagpindot sa isang pindutan.
Gisingin ito mula sa malalim na mode ng pagtulog sa pamamagitan ng pagpindot sa isa pang pindutan.
Upang makita ang estado ng ESP32, isang LED ay magpapikit sa isang oras ng pag-turn ng 1000 milliseconds. Sa panahon ng mode ng pagtulog, papatayin ito.

Samakatuwid, kinakailangang mga karagdagang sangkap-

LED - 1 pc
Push-button (Tactile switch) - 2 mga PC
4.7k resistors - 2 mga PC
680R risistor - 1 pc
Breadboard
I-hook up ang kawad
5V adapter o power supply unit
Isang micro-USB cable
Arduino IDE na may interface ng programa ng ESP32 sa isang PC o Laptop.

ESP32 Sleep Mode Circuit Diagram

Ang eskematiko upang ilagay sa pagtulog ang ESP32 na may pindutan ng push ay ipinapakita sa ibaba.

Ang eskematiko ay medyo simple. Mayroon itong dalawang mga pindutan. Ilalagay ng pindutan ng pagtulog ang ESP32 sa malalim na mode ng pagtulog at isa pang switch ang ginagamit para sa paggising ng ESP32 mula sa mode na pagtulog. Ang parehong mga pindutan ay konektado sa PIN 16 at PIN 33. Parehong mga pindutan ay naka-configure bilang mababang aktibo kapag pinindot, samakatuwid ang isang karagdagang pull-up ay ibinigay. Gayunpaman, upang makita kung ang ESP 32 ay nasa mode ng pagtulog o normal na mode ng kondisyon sa pagtatrabaho, ang LED ay konektado sa IO Pin 4.

Pangkalahatang-ideya ng Mga Mode sa Pagtulog sa ESP32

Mayroong maraming magkakaibang mga mode ng kuryente para sa ESP32, katulad ng aktibong mode, modem mode ng pagtulog, light mode na pagtulog, malalim na mode sa pagtulog, at mode ng pagtulog sa panahon ng taglamig.

Sa panahon ng normal na kalagayan sa pagtatrabaho, tumatakbo ang ESP32 sa aktibong mode. Sa panahon ng aktibong mode ng ESP32, ang CPU, hardware ng WiFi / BT, memorya ng RTC, at mga peripheral ng RTC, mga co-processor ng ULP, lahat ay naisasaaktibo at gumagana depende sa dami ng trabaho. Gayunpaman, sa iba't ibang mga mode ng kuryente, isa o higit pang mga peripheral ay naka-patay. Upang suriin ang iba't ibang mga pagpapatakbo ng mode ng kuryente, sundin ang talahanayan sa ibaba-

Hardware	Aktibong Mode	Modem-sleep Mode	Magaan na Mode ng Pagtulog	Deep-sleep Mode	Hibernation
CPU	ON na	ON na	PAUSE	NAKA-OFF	NAKA-OFF
WiFi / BT	ON na	NAKA-OFF	NAKA-OFF	NAKA-OFF	NAKA-OFF
RTC at RTC Peripherals	ON na	ON na	ON na	ON na	NAKA-OFF
Proseso ng ULP-Co	ON na	ON na	ON na	BUKAS SARADO	NAKA-OFF

Tulad ng nakikita natin sa talahanayan sa itaas na sa ESP32 malalim na mode ng pagtulog na madalas na tinatawag na pattern na sinusubaybayan ng sensor ng ULP - ang CPU, WiFi / BT, memorya ng RTC at mga peripheral, ang mga co-processor ng ULP ay naka-patay lahat. Ang memorya lamang ng RTC at mga peripheral ng RTC ang nakabukas.

Sa panahon ng sitwasyon ng paggising, kailangang maabisuhan ang ESP32 ng isang mapagkukunang paggising na magising ang ESP32 mula sa malalim na mode ng pagtulog. Gayunpaman, dahil naka-on ang mga peripheral ng RTC, maaaring magising ang ESP32 sa pamamagitan ng mga pinapagana ng RTC na GPIO. Mayroon ding iba pang mga pagpipilian. Maaari itong magising sa pamamagitan ng isang panlabas na gisingin na makagambala na mga pin o gumagamit ng isang timer upang gisingin ang ESP32. Sa proyektong ito, gumagamit kami ng ext0 wakup sa pin 33.

Programming ESP32 para sa Deep Sleep Mode

Ang kumpletong programa ay matatagpuan sa ilalim ng pahinang ito. Ito ay nakasulat para sa Arduino IDE at sa gayon ay madaling maiakma sa iyong mga kinakailangan. Ang paliwanag ng code ay ang mga sumusunod.

Sa simula ng code, // Lumikha ng variable na Push Button na PushBnt pushBtn = {GPIO_NUM_16, 0, false}; // tukuyin ang Pin Pin uint8_t led_pin = GPIO_NUM_4; // tukuyin ang paggising pin uint8_t wakUp_pin = GPIO_NUM_33;

Ang tatlong mga linya sa itaas ay tumutukoy sa paggising na pin, LED pin, at pin na mode ng pagtulog.

void setup () { // ilagay ang iyong code sa pag-setup dito, upang magpatakbo nang isang beses: // itakda ang serial port sa 115200 Serial.begin (115200); pagkaantala (1000); // itakda ang pushbutton pin bilang input na may panloob na PullUp pinMode (pushBtn.pin, INPUT_PULLUP); // set the Interrupt handler with the push Button pin in Falling mode attachInterrupt (pushBtn.pin, isr_handle, FALLING); // itakda ang Led pin bilang ouput pinMode (led_pin, OUTPUT); // lumikha ng isang gawain na naisasagawa sa blinkLed () na function, na may priyoridad 1 at naisakatuparan sa core 0 xTaskCreate ( blinkLed, / * Gawain ng gawain. * / "blinkLed", / * pangalan ng gawain. * / 1024 * 2, / * Laki ng stack ng gawain * / NULL, / * parameter ng gawain * / 5, / * prayoridad ng gawain * / & taskBlinkled); / * Gawain ang gawain upang subaybayan ang nilikha na gawain * / pagkaantala (500); // I-configure ang Pin 33 bilang ext0 paggising ng mapagkukunan na may LOW antas ng lohika esp_sidur_enable_ext0_wakeup ((gpio_num_t) wakUp_pin, 0); }

Sa itaas, ang nakakagambala ay nakatakda sa isang bumabagsak na mode ng code na snippet

attachInterrupt (pushBtn.pin, isr_handle, FALLING);

Samakatuwid, tuwing pinindot ang switch, ang antas ng lohika ay mababago mula sa lohika 1 (3.3V) hanggang sa lohika 0 (0V). Ang boltahe ng pindutan ng pindutan ay mahuhulog at makikilala ng ESP32 na ang switch ay pinindot. Mayroon ding isang gawain na nilikha upang pumikit ang LED.

xTaskCreate ( blinkLed, / * Pag-andar ng gawain. * / "blinkLed", / * pangalan ng gawain. * / 1024 * 2, / * Laki ng stack ng gawain * / NULL, / * parameter ng gawain * / 5, / * priyoridad ng gawain * / & taskBlinkled); / * Gawain ang gawain upang subaybayan ang nilikha na gawain * / pagkaantala (500);

Ang pin 33 ay naka-configure din gamit ang ibaba ng code snippet bilang isang panlabas na mapagkukunan ng paggising na kinilala bilang ext0.

esp_sleep_enable_ext0_wakeup ((gpio_num_t) wakUp_pin, 0);

Susunod, habang habang loop-

void loop () { // ilagay ang iyong pangunahing code dito, upang tumakbo nang paulit-ulit: kung (pushBtn.pressed) { Serial.printf ("Push Button (% d) Pressed \ n", pushBtn.pin); Serial.printf ("Suspindihin ang 'blinkLed' Gawain \ n"); // Suspindihin ang blinkLed Task vTaskSuspend (taskBlinkled); digitalWrite (led_pin, LOW); Serial.printf ("Matulog na….. \ n", pushBtn.pin); pushBtn.pressed = false; // Matulog ka na ngayon esp_deep_sleep_start (); } esp_sleep_wakeup_cause_t wakupReason; wakupReason = esp_sleep_get_wakeup_cause (); switch (wakupReason) { case ESP_SLEEP_WAKEUP_EXT0: Serial.println ("gamit ang panlabas na signal ext0 para sa WakeUp Mula sa pagtulog"); pahinga; kaso ESP_SLEEP_WAKEUP_EXT1: Serial.println ("gumagamit ng panlabas na signal ext1 para sa WakeUp Mula sa pagtulog"); pahinga; kaso ESP_SLEEP_WAKEUP_TIMER: Serial.println ("gamit ang Timer signal para sa WakeUp Mula sa pagtulog"); pahinga; kaso ESP_SLEEP_WAKEUP_TOUCHPAD: Serial.println ("gamit ang TouchPad signal para sa WakeUp Mula sa pagtulog"); pahinga; kaso ESP_SLEEP_WAKEUP_ULP: Serial.println ("gumagamit ng ULP signal para sa WakeUp Mula sa pagtulog"); pahinga; default: masira; Serial.printf ("Ipagpatuloy ang 'blinkLed' Gawain \ n"); // restart the blinkLed Task vTaskResume (taskBlinkled); } }

Ang habang loop ay patuloy na suriin kung ang pindutan ng pagtulog ay pinindot o hindi. Kung ang pindutan ay pinindot, ititigil o suspindihin nito ang gawain ng LED blink at patakbuhin ang pagpapaandar ng deep deep sleep-

esp_deep_sleep_start ();

Sa sitwasyong ito, kung ang ext0 panlabas na makagambala na pindutan ay pinindot, agad itong magigising mula sa malalim na mode ng pagtulog, at ipagpatuloy ang pinangungunahang gawain na blink.

Panghuli, ang pag-andar ng LED blink ay maaaring makita sa mga snippet sa ibaba, magpapikit ito sa LED 1000 ms segundo.

void blinkLed (void * param) { habang (1) { static uint32_t pin_val = 0; // toggle ang halaga ng pin na pin_val ^ = 1; digitalWrite (led_pin, pin_val); Serial.printf ("Led -----------------% s \ n", pin_val? "On": "Off"); / * I-toggle lang ang LED bawat 1000ms o 1sec * / vTaskDelay (1000 / portTICK_PERIOD_MS); } taskBlinkled = NULL; vTaskDelete (NULL); }

Pagsubok sa ESP32 sa Deep Sleep Mode

Ang circuit ay itinayo sa isang breadboard at ginagamit ang isang Metravi XB edition multimeter upang masukat ang kasalukuyang. Ang kasalukuyang iginuhit ng circuit sa aktibong mode ay halos 58 mA ngunit sa malalim na mode ng pagtulog, ang kasalukuyang ay halos 4.10 mA. Ang larawan sa ibaba ay ipinapakita ang kasalukuyang konsumo ng aktibong mode ng ESP32 -

Sa deep mode ng pagtulog, ang kasalukuyang pagkonsumo ay naitala na bumaba sa paligid ng 3.95mA, ipinapakita sa imahe sa ibaba ang ESP32 Deep Sleep Mode Kasalukuyang Pagkonsumo-

Nyawang

Gayunpaman, sa malalim na mode ng pagtulog, ang kasalukuyang pagkonsumo ng ESP32 ay halos 150 uA. Ngunit ang naitala na kasalukuyang pagkonsumo para sa board na ito ng ESP32 Devkit ay halos 4.10 mA. Ito ay dahil sa CP2102 at sa Linear Regulator. Ang dalawang ito ay konektado sa linya ng kuryente na 5V. Mayroon ding isang power LED na konektado sa linya ng kuryente na kumakain ng halos 2mA ng kasalukuyang.

Samakatuwid, madali itong makikilala na ang ESP32 ay gumagamit ng napakababang halaga ng enerhiya sa kundisyon ng deep mode ng pagtulog na lubhang kapaki-pakinabang para sa pagpapatakbo ng baterya. Para sa karagdagang impormasyon sa kung paano ito gumana, tingnan ang naka-link na video sa ibaba. Kung mayroon kang anumang mga katanungan, iwanan ang mga ito sa seksyon ng komento sa ibaba o gamitin ang aming Mga Forum para sa iba pang mga teknikal na katanungan.