Estalvi de vida de la bateria amb son profund: 20 passos

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:15

T’interessa fer servir una bateria amb el teu ESP32? Si és així, parlaré avui d’alguna informació tècnica important sobre aquest tema. Sabem que aquest microcontrolador gasta molta energia quan transmet informació. Consumeix prop de 190 miliamperis. En aquest vídeo, mostraré com conservar l’energia de l’ESP32 amb l’anomenada funció DEEP SLEEP. Establirem el xip per entrar en aquest mode, aprendrem les maneres de sortir d’aquest mode i crearem un exemple que mostri tres maneres diferents de despertar l’ESP32.

És important recordar que la ràdio gasta molta energia en lloc del processador. L’estalvi energètic és molt important. Això es deu al fet que els punts finals (els circuits que envien informació) sovint funcionen amb bateria i han de durar fins a cinc anys. Hi ha alguns fabricants que prometen una durada de fins a deu anys, i això és vàlid per a bateries d’alta qualitat que no fan servir tant els punts finals. En la resta de casos, us aconsello que utilitzeu Deep Sleep per estalviar energia del circuit.

Pas 1: Introducció

L'ESP32 té un mode d'estalvi d'energia, anomenat "Deep Sleep". En aquest mode, les CPU, la majoria de RAM i tots els perifèrics de rellotge digital estan apagats. Les úniques parts del xip que encara es poden connectar són el controlador RTC, els perifèrics RTC (inclòs el coprocessador ULP) i les memòries RTC.

Tenim diverses maneres de despertar l’ESP32 quan dormim. Les fonts de despertar es poden configurar en qualsevol moment abans d’entrar al mode de son profund.

Pas 2: maneres de despertar l'ESP32

Hi ha cinc maneres de despertar ESP32:

• Temporitzador

• Activació externa (ext0)

• Activació externa (ext1)

• Activació del coprocessador ULP

• Touchpad

Pas 3: temporitzador

El controlador RTC té un temporitzador integrat que es pot utilitzar per activar el xip després d’un període de temps predefinit. L’hora s’especifica amb precisió de microsegons.

esp_deep_sleep_enable_timer_wakeup (uint64_t time_in_us)

time_in_us> és el temps en microsegons

Pas 4: despertar extern (ext0)

El mòdul RTC IO conté lògica per activar l'alarma quan un dels GPIO RTC entra en un nivell lògic predefinit. L'OI RTC forma part del domini de potència dels perifèrics RTC, de manera que els perifèrics RTC es mantindran vius durant Deep Sleep si es demana aquesta font d'activació.

esp_deep_sleep_enable_ext0_wakeup (gpio_num_t gpio_num, nivell int)

gpio_num> Número GPIO utilitzat com a font d'activació. Només es poden utilitzar GPIO funcionals RTC: 0, 2, 4, 12-15, 25-27, 32-39.

nivell> nivell d'entrada que activarà l'alarma (0 = BAIX, 1 = ALT)

Pas 5: despertar extern (ext1)

El controlador RTC conté lògica per activar el despertador mitjançant diversos GPIO RTC.

esp_deep_sleep_enable_ext1_wakeup (màscara uint64_t, mode esp_ext1_wakeup_mode_t)

màscara> màscara de bits dels números GPIO que provocaran l'activació. Només es poden utilitzar GPIO habilitats per a RTC en aquest mapa de bits: 0, 2, 4, 12-15, 25-27, 32-39.

mode> seleccioneu la funció lògica que s’utilitza per determinar la condició d’activació:

• ESP_EXT1_WAKEUP_ALL_LOW: es desperta quan tots els GPIO seleccionats estan en BAIX

• ESP_EXT1_WAKEUP_ANY_HIGH: es desperta quan algun dels GPIO seleccionats és ALT

Pas 6: despertar del coprocessador ULP

El coprocessador ULP pot funcionar mentre el xip es troba en son profund i es pot utilitzar per buscar sensors, controlar els valors del sensor tàctil ADC o capacitiu i activar el xip quan es detecta un esdeveniment específic.

El coprocessador ULP forma part del domini de potència dels perifèrics RTC i executa el programa emmagatzemat en RTC de memòria lenta. Per tant, els perifèrics RTC i la memòria lenta RTC s’activaran durant Deep Sleep si es demana aquest mode d’activació.

Pas 7: Touchpad

El controlador RTC conté lògica per activar l'alarma mitjançant els sensors tàctils capacitius. La definició del pin tàctil, però, és diferent. Hem d’utilitzar la interrupció tàctil per a cadascun dels pins desitjats.

Després de configurar les interrupcions, vam activar el mode de despertador per utilitzar els sensors.

// Configureu el touchpad com a font de despertador esp_sleep_enable_touchpad_wakeup ();

Pas 8: accedir al mode de son profund

Després d’establir un mode de despertador, n’hi ha prou amb una sola ordre per posar l’ESP32 en mode Deep Sleep (gastar 2,5 μA o menys). Destaco aquí que aquesta despesa prové del xip ESP i no de la placa, ja que aquest últim gasta més.

esp_deep_sleep_start ();

A partir d’aquesta ordre, l’ESP32 s’adorm i, per exemple, no executa les següents línies de codi.

Important: tots els paràmetres de despertador s'han de fer abans d'executar l'ordre anterior.

Pas 9: aquí hi ha informació més important

La trucada següent retorna la causa del despertador ESP32.

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

esp_sleep_get_wakeup_cause ();

Si configurem el despertador mitjançant el touchpad, podem recuperar quin GPIO es va produir mitjançant el comandament

esp_sleep_get_touchpad_wakeup_status ();

Cada vegada que l’ESP32 es desperta, tornarà a circular per la configuració. Així, totes les variables que no estan definides a la memòria RTC tornaran al seu estat inicial.

Per conservar les variables a la memòria fins i tot després d’haver-se adormit, utilitzeu la declaració de variables de l’exemple següent:

// RTC_DATA_ATTR pot variar a la memòria RTCRTC_DATA_ATTR int bootCount = 0;

Pas 10: demostració

El vídeo mostra el programa funcionant, d'acord amb la imatge.

Pas 11: WiFi NodeMCU-32S ESP-WROOM-32

Pas 12: Muntatge

Pas 13: programa

Ara farem un programa on configurarem l’ESP32 per entrar al mode Deep Sleep. Es despertarà de tres maneres diferents: una per al despertar extern (ext0), una per al temporitzador i una per al touchpad. No poden treballar junts, de manera que farem servir una variable que serà un comptador per al nombre de vegades que l’ESP32 ha donat a Boot per configurar la manera de despertar-se.

Pas 14: biblioteca obligatòria

Per controlar la pantalla OLED, necessitem una biblioteca externa. Per a això, descarregarem la biblioteca U8g2.

A l'IDE Arduino, aneu al menú Sketch >> Inclou biblioteca >> Gestiona biblioteques …

Pas 15: biblioteques i variables

Hem inclòs la biblioteca per controlar la pantalla OLED, així com un constructor de la instància del controlador de pantalla. A més, assignem la variable a la memòria RTC. Establim la sensibilitat per a l’acceptació tàctil, el factor de conversió de microsegons durant segons i el temps que l’ESP32 passa al mode de repòs (en segons).

#include // biblioteca para control do display oled

// construtor da instancia do controlador do display // SDA = 21 e SCL = 22 U8X8_SSD1306_128X64_NONAME_SW_I2C display (SCL, SDA, U8X8_PIN_NONE); // RTC_DATA_ATTR pot variar a la memòria 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

Pas 16: Configuració

A Configuració, incrementem el nombre de vegades que s’ha produït l’arrencada. Anomenem la funció per imprimir el motiu d'arrencada. Si el número d’arrencada és PAR, configurem l’ESP32 perquè es desperti mitjançant el botó (EXT0). Si és múltiple de 3, configurem l'ESP32 perquè es desperti després d'un temps establert. En cas contrari, configurem els pins tàctils capacitius per activar l’ESP32. Finalment, configurem el touchpad com a font d’activació i forcem l’ESP32 a entrar en mode de repòs.

configuració nul·la () {Serial.begin (115200); retard (1000); // incrementa o número de vegades que o BOOT ocorreu ++ bootCount; configureDisplay (); // chama a função per imprimir o motivo do BOOT print_wakeup_reason (); // veure el número d'arrencada per PAR configurem o ESP32 per despertar através de botó (EXT0) if (bootCount% 2 == 0) {esp_sleep_enable_ext0_wakeup (GPIO_NUM_39, 1); // 1 = High, 0 = Low} // se for multiplo de 3 configuramos o ESP32 para despertar depois de um tempo definido else if (bootCount% 3 == 0) {esp_sleep_enable_timer_wakeup (TIME_TO_SLEEP * uS_TO_S_FACTOR); } // cas contrari configurem els pinos de tacte capacitius per despertar o ESP32 else {// Configuració de la interrupció al Touch Pad 5 (GPIO12) touchAttachInterrupt (T5, devolució de trucada, llindar); // Configureu el touchpad com a font de despertador esp_sleep_enable_touchpad_wakeup (); } Serial.println (“entrant em modo sleep”); esp_deep_sleep_start (); // força o ESP32 entrar em modo SLEEP}

Pas 17: bucle, devolució de trucada i configuració de visualització

Al bucle no tenim res a fer. A continuació, procedim a interrompre la devolució de trucada si tenim alguna cosa a fer quan es produeix la interrupció. Quant a configureDisplay, inicialitzem la pantalla i configurem alguns paràmetres. Imprimim a la pantalla el nombre de vegades que s’ha produït l’arrencada.

// 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. begin (); display.setPowerSave (0); // modo powerSave (0-Off? 1-On) display.setFont (u8x8_font_torussansbold8_u); // fonte utilizada // imprime no display os number of vezes that aconteceu o BOOT display.drawString (0, 0, "BOOT NUM:"); display.drawString (0, 2, String (bootCount).c_str ()); display.drawString (0, 4, "MOTIVO:"); }

Pas 18: Print_wakeup_reason (coneixement de la causa del despertar)

Aquí tenim la funció d’imprimir la causa del despertar de l’ESP32. Comproveu el pin i imprimiu a la pantalla.

// função para imprimir a causa do ESP32 despertarvoid print_wakeup_reason () {esp_sleep_wakeup_cause_t wakeup_reason; String reason = ""; wakeup_reason = esp_sleep_get_wakeup_cause (); // recupera a causa do despertar switch (wakeup_reason) {case 1: reason = "EXT0 RTC_IO BTN"; trencar; cas 2: reason = "EXT1 RTC_CNTL"; trencar; cas 3: reason = "TIMER"; trencar; cas 4: reason = "TOUCHPAD"; trencar; cas 5: reason = "PROGRAMA ULP"; trencar; per defecte: reason = "SENSE CAUSA DS"; trencar; } Serial.println (motiu); display.clearLine (6); // apaga a linha 6 do display display.drawString (0, 6, reason.c_str ()); // imprime a causa do despertar no display // se despertou por TOUCHPAD, então vamos verificar em qual dos pinos ocorreu if (wakeup_reason == 4) {print_wakeup_touchpad (); // verifica o pino e imprime no display}}

Pas 19: Print_wakeup_touchpad (coneixeu el GPIO Touch)

Ara, en aquest pas, tenim la funció d'imprimir el pin que s'ha tocat. Hem recuperat el GPIO que va despertar l’ESP32 i el vam imprimir a la pantalla.

// função per 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 = ""; commutador (TouchPin) {cas 0: GPIO = "4"; trencar; cas 1: GPIO = "0"; trencar; cas 2: GPIO = "2"; trencar; cas 3: GPIO = "15"; trencar; cas 4: GPIO = "13"; trencar; cas 5: GPIO = "12"; trencar; cas 6: GPIO = "14"; trencar; cas 7: GPIO = "27"; trencar; cas 8: GPIO = "33"; trencar; cas 9: GPIO = "32"; trencar; per defecte: Serial.println ("Wakeup not by touchpad"); trencar; } Serial.println ("GPIO:" + GPIO); display.clearLine (7); // apaga a linha 7 do display display.drawString (0, 7, "GPIO:"); display.drawString (6, 7, GPIO.c_str ()); // imprime o GPIO}

Pas 20: baixeu els fitxers

PDF

INO