Risparmiare la durata della batteria con Deep Sleep: 20 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:03

Ti interessa utilizzare una batteria con il tuo ESP32? Se è così, parlerò oggi di alcune importanti informazioni tecniche su questo argomento. Sappiamo che questo microcontrollore spende molta energia quando trasmette informazioni. Consuma quasi 190 milliampere. In questo video, mostrerò come risparmiare energia dall'ESP32 con la cosiddetta funzione "DEEP SLEEP". Imposteremo il chip per entrare in questa modalità, impareremo i modi per uscire da questa modalità e creeremo un esempio che mostra tre modi diversi per riattivare ESP32.

È importante ricordare che la radio spende molta energia, piuttosto che il processore. Il risparmio energetico è molto importante. Questo perché gli endpoint (i circuiti che inviano informazioni) sono spesso alimentati a batteria e dovrebbero durare fino a cinque anni. Ci sono alcuni produttori che promettono fino a dieci anni di durata, e questo vale per batterie di alta qualità che non utilizzano tanto gli Endpoint. In tutti gli altri casi, ti consiglio di utilizzare Deep Sleep per risparmiare energia dal tuo circuito.

Passaggio 1: Introduzione

L'ESP32 ha una modalità di risparmio energetico, chiamata "Deep Sleep". In questa modalità, le CPU, la maggior parte della RAM e tutte le periferiche con clock digitale sono disattivate. Le uniche parti del chip che possono ancora essere collegate sono il controller RTC, le periferiche RTC (incluso il coprocessore ULP) e le memorie RTC.

Abbiamo diversi modi per riattivare ESP32 quando dorme. Le sorgenti di risveglio possono essere impostate in qualsiasi momento prima di entrare nella modalità Deep Sleep.

Passaggio 2: modi per riattivare ESP32

Esistono cinque modi per riattivare ESP32:

• Timer

• Riattivazione esterna (ext0)

• Riattivazione esterna (est1)

• Riattivazione del coprocessore ULP

• Touchpad

Passaggio 3: timer

Il controller RTC ha un timer integrato che può essere utilizzato per attivare il chip dopo un periodo di tempo predefinito. Il tempo è specificato con precisione al microsecondo.

esp_deep_sleep_enable_timer_wakeup(uint64_t time_in_us)

time_in_us> è il tempo in microsecondi

Passaggio 4: riattivazione esterna (ext0)

Il modulo RTC IO contiene la logica per attivare l'allarme quando uno dei GPIO RTC entra in un livello logico predefinito. L'IO RTC fa parte del dominio di alimentazione delle periferiche RTC, quindi le periferiche RTC verranno mantenute attive durante il Deep Sleep se viene richiesta questa fonte di attivazione.

esp_deep_sleep_enable_ext0_wakeup(gpio_num_t gpio_num, livello int)

gpio_num> Numero GPIO utilizzato come fonte di attivazione. È possibile utilizzare solo GPIO con funzionalità RTC: 0, 2, 4, 12-15, 25-27, 32-39.

livello > livello di ingresso che attiverà l'allarme (0 = BASSO, 1 = ALTO)

Passaggio 5: riattivazione esterna (ext1)

Il controller RTC contiene la logica per attivare la sveglia utilizzando più GPIO RTC.

esp_deep_sleep_enable_ext1_wakeup (maschera uint64_t, modalità esp_ext1_wakeup_mode_t)

mask> maschera di bit dei numeri GPIO che causeranno l'attivazione. In questa bitmap possono essere utilizzati solo GPIO abilitati per RTC: 0, 2, 4, 12-15, 25-27, 32-39.

mode> selezionare la funzione logica utilizzata per determinare la condizione di attivazione:

• ESP_EXT1_WAKEUP_ALL_LOW: si attiva quando tutti i GPIO selezionati sono in LOW

• ESP_EXT1_WAKEUP_ANY_HIGH: si attiva quando uno dei GPIO selezionati è ALTO

Passaggio 6: riattivazione del coprocessore ULP

Il coprocessore ULP può funzionare mentre il chip è in Deep Sleep e può essere utilizzato per cercare sensori, monitorare i valori ADC o del sensore tattile capacitivo e attivare il chip quando viene rilevato un evento specifico.

Il coprocessore ULP fa parte del dominio di potenza delle periferiche RTC ed esegue il programma memorizzato nella memoria lenta RTC. Pertanto, le periferiche RTC e la memoria lenta RTC verranno attivate durante il Deep Sleep se viene richiesta questa modalità di attivazione.

Passaggio 7: touchpad

Il controller RTC contiene la logica per attivare l'allarme utilizzando i sensori tattili capacitivi. La definizione del touch pin, tuttavia, è diversa. Dobbiamo usare l'interruzione del tocco per ciascuno dei pin desiderati.

Dopo aver impostato gli interrupt, abbiamo abilitato la modalità di risveglio per utilizzare i sensori.

//Configura il Touchpad come sorgente di risveglio esp_sleep_enable_touchpad_wakeup();

Passaggio 8: accesso alla modalità di sospensione profonda

Dopo aver impostato una modalità di riattivazione, è sufficiente un singolo comando per mettere ESP32 in modalità Deep Sleep (spendendo 2,5 μA o meno). Sottolineo qui che questa spesa è dal chip ESP e non dalla piastra, in quanto quest'ultima spende di più.

esp_deep_sleep_start();

Da questo comando, ESP32 si addormenta e non esegue, ad esempio, le righe di codice successive.

Importante: tutte le impostazioni di riattivazione devono essere effettuate prima di eseguire il comando precedente.

Passaggio 9: ecco alcune informazioni più importanti

La chiamata seguente restituisce la causa del risveglio di ESP32.

1: EST0 2: EST1 3: TIMER 4: TOUCHPAD 5: ULP

esp_sleep_get_wakeup_cause();

Se impostiamo la riattivazione dal touchpad, possiamo recuperare quale GPIO si è verificato il tocco tramite il comando

esp_sleep_get_touchpad_wakeup_status();

Ogni volta che ESP32 si riattiva, eseguirà nuovamente l'installazione. Quindi tutte le variabili che non sono definite nella memoria RTC torneranno al loro stato iniziale.

Per mantenere le variabili in memoria anche dopo essersi addormentati, utilizzare la dichiarazione della variabile nell'esempio seguente:

//RTC_DATA_ATTR aloca a variável na memória RTCRTC_DATA_ATTR int bootCount = 0;

Passaggio 10: dimostrazione

Il video mostra il programma in funzione, secondo l'immagine.

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

Passaggio 12: assemblaggio

Passaggio 13: programma

Ora creeremo un programma in cui configureremo ESP32 per entrare in modalità Deep Sleep. Questo verrà attivato in tre modi diversi: uno per Riattivazione esterna (ext0), uno per Timer e uno per Touchpad. Non possono funzionare insieme, quindi useremo una variabile che sarà un contatore per il numero di volte in cui ESP32 ha dato Boot per configurare il modo di svegliarsi.

Passaggio 14: libreria richiesta

Per controllare il display OLED, abbiamo bisogno di una libreria esterna. Per questo, scaricheremo la libreria U8g2.

Nell'IDE di Arduino, vai al menu Schizzo >> Includi libreria >> Gestisci librerie ….

Passaggio 15: librerie e variabili

Abbiamo incluso la libreria per controllare il display OLED, oltre a un costruttore dell'istanza del controller del display. Inoltre, allochiamo la variabile nella memoria RTC. Impostiamo la sensibilità per l'accettazione del tocco, il fattore di conversione dei microsecondi per i secondi e il tempo in cui ESP32 passa alla modalità di sospensione (in secondi).

#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 display(SCL, SDA, U8X8_PIN_NONE); //RTC_DATA_ATTR aloca a variável na memoria 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

Passaggio 16: configurazione

In Setup, incrementiamo il numero di volte in cui si è verificato l'avvio. Chiamiamo la funzione per stampare il motivo Boot. Se il numero di avvio è PAR, impostiamo l'ESP32 per la riattivazione tramite il pulsante (EXT0). Se è un multiplo di 3, impostiamo ESP32 in modo che si riattivi dopo un tempo prestabilito. Altrimenti, impostiamo i pin tattili capacitivi per riattivare ESP32. Infine, impostiamo il Touchpad come sorgente di risveglio e forziamo ESP32 per entrare in modalità di sospensione.

void setup() { Serial.begin(115200); ritardo(1000); //incrementa il numero di volte che vuoi BOOT ocorreu ++bootCount; configureDisplay(); //chama a função para imprimir o motivo do BOOT print_wakeup_reason(); //se il numero di avvio per PAR configuramos o ESP32 per disperdere através do botão (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); } //caso contrario configuramos os pinos de touch capacitivo per despertar o ESP32 else { //Setup interrupt on Touch Pad 5 (GPIO12) touchAttachInterrupt(T5, callback, Threshold); //Configura il Touchpad come sorgente di risveglio esp_sleep_enable_touchpad_wakeup(); } Serial.println(“entra in modalità sleep ); esp_deep_sleep_start(); //força o ESP32 entra in modalità SLEEP }

Passaggio 17: loop, richiamata e configurazione del display

Nel Loop, non abbiamo niente da fare. Procediamo quindi a interrompere la richiamata se abbiamo qualcosa da fare quando si verifica l'interruzione. Per quanto riguarda configureDisplay, inizializziamo il display e configuriamo alcuni parametri. Stampiamo sullo schermo il numero di volte in cui è avvenuto il Boot.

//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. inizio(); 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, String(bootCount).c_str()); display.drawString(0, 4, "MOTIVO:"); }

Passaggio 18: Print_wakeup_reason (conoscere la causa del risveglio)

Qui abbiamo la funzione per stampare la causa del risveglio di ESP32. Controllare il pin e stampare sul display.

//função para imprimir a causa do ESP32 despertarvoid print_wakeup_reason(){ esp_sleep_wakeup_cause_t wakeup_reason; Motivo stringa = ""; wakeup_reason = esp_sleep_get_wakeup_cause(); //recupera a causa do despertar switch(wakeup_reason) { case 1:reason = "EXT0 RTC_IO BTN"; rottura; caso 2: motivo = "EXT1 RTC_CNTL"; rottura; caso 3: motivo = "TIMER"; rottura; caso 4: motivo = "TOUCHPAD"; rottura; caso 5:motivo = "PROGRAMMA ULP"; rottura; default:ragione = "NESSUNA CAUSA DS"; rottura; } Serial.println(motivo); display.clearLine(6); //apaga a linha 6 visualizza 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 } }

Passaggio 19: Print_wakeup_touchpad (conosci il GPIO Touch)

Ora, in questo passaggio, abbiamo la funzione per stampare il pin che è stato toccato. Abbiamo recuperato il GPIO che ha svegliato l'ESP32 e l'abbiamo stampato sul display.

//funzione 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 = ""; switch(touchPin) { case 0: GPIO = "4"; rottura; caso 1: GPIO = "0"; rottura; caso 2: GPIO = "2"; rottura; caso 3: GPIO = "15"; rottura; caso 4: GPIO = "13"; rottura; caso 5: GPIO = "12"; rottura; caso 6: GPIO = "14"; rottura; caso 7: GPIO = "27"; rottura; caso 8: GPIO = "33"; rottura; caso 9: GPIO = "32"; rottura; default: Serial.println("Risveglio non tramite touchpad"); rottura; } 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 }

Passaggio 20: Scarica i file

PDF

IO NO