Modalità attiva Esp32 e consumo energetico in modalità deep sleep

ESP32 è uno dei moduli microcontrollori basati su Wi-Fi più diffusi ed è una scelta popolare in molte applicazioni IoT portatili. È un potente controller che supporta la programmazione Dual Core e ha anche il supporto Bluetooth Low Energy (BLE) integrato che lo rende una buona scelta per applicazioni portatili come dispositivi iBeacon, localizzatori GPS, ecc. Tuttavia, in applicazioni alimentate a batteria come queste, la preoccupazione principale è il backup della batteria. Questo backup della batteria può essere aumentato da un controllo più intelligente sull'unità microcontrollore come si può programmare ESP32 in modalità sleep durante la condizione ideale per aumentare il backup della batteria del dispositivo.

In questo progetto, controlleremo il consumo corrente della popolare unità microcontrollore ESP32 abilitata per Wi-Fi e Bluetooth in modalità di lavoro normale e modalità di sospensione profonda. Inoltre, testeremo la differenza e controlleremo come mettere l'ESP32 in modalità di sospensione profonda. Puoi anche consultare l'articolo su come ridurre al minimo il consumo di energia nei microcontrollori per altri suggerimenti che possono essere utilizzati per rendere il tuo progetto molto più efficiente dal punto di vista energetico. Inoltre, se sei interessato alla modalità sleep di altri microcontrollori, puoi anche provare la modalità Sleep di Arduino e la modalità Sleep ESP8266 NodeMCU.

Requisiti

Per fare ciò, utilizzeremo Devkit V4.0 basato su ESP32 di Espressif con bridge da USB a UART e altri pinout ESP32 per una facile connessione. La programmazione verrà eseguita con Arduino IDE. Se sei completamente nuovo, allora per Iniziare con ESP32 usando Arduino, leggi l'articolo collegato prima di procedere.

I requisiti di questo progetto sono i seguenti:

Entrerà in modalità di sospensione profonda premendo un pulsante.
Si risveglierà dalla modalità di sospensione profonda premendo un altro pulsante.
Per rilevare lo stato dell'ESP32, un LED lampeggerà con un tempo di accensione di 1000 millisecondi. Durante la modalità di sospensione, verrà disattivato.

Pertanto, componenti aggiuntivi richiesti-

LED - 1 pz
Pulsante (interruttore tattile) - 2 pz
Resistori 4.7k - 2 pz
Resistenza 680R - 1 pz
Breadboard
Collegare il filo
Adattatore 5V o alimentatore
Un cavo micro-USB
IDE Arduino con interfaccia di programmazione ESP32 in un PC o laptop.

Schema del circuito della modalità di sospensione ESP32

Di seguito è mostrato lo schema per mettere ESP32 in modalità sleep con il pulsante.

Lo schema è piuttosto semplice. Ha due pulsanti. Il pulsante di sospensione metterà l'ESP32 in modalità di sospensione profonda e un altro interruttore viene utilizzato per riattivare l'ESP32 dalla modalità di sospensione. Entrambi i pulsanti sono collegati nel PIN 16 e nel PIN 33. Entrambi i pulsanti sono configurati come attivi bassi quando vengono premuti, quindi viene fornito un ulteriore pull-up. Tuttavia, per rilevare se l'ESP 32 è in modalità di sospensione o in condizioni di funzionamento normale, il LED è collegato al pin 4 IO.

Panoramica delle modalità di sospensione in ESP32

Esistono molte diverse modalità di alimentazione per ESP32, ovvero modalità attiva, modalità di sospensione del modem, modalità di sospensione leggera, modalità di sospensione profonda e modalità di ibernazione.

Durante le normali condizioni di lavoro, l'ESP32 funziona in modalità attiva. Durante la modalità attiva di ESP32, la CPU, l'hardware WiFi / BT, la memoria RTC e le periferiche RTC, i co-processori ULP, sono tutti attivati e funzionano a seconda del carico di lavoro. Tuttavia, in diverse modalità di alimentazione, una o più periferiche sono spente. Per controllare le diverse modalità di alimentazione, seguire la tabella seguente

Hardware	Modalità attiva	Modalità di sospensione del modem	Modalità sospensione leggera	Modalità Deep-sleep	Ibernazione
processore	SOPRA	SOPRA	PAUSA	OFF	OFF
WiFi / BT	SOPRA	OFF	OFF	OFF	OFF
Periferiche RTC e RTC	SOPRA	SOPRA	SOPRA	SOPRA	OFF
Processore ULP-Co	SOPRA	SOPRA	SOPRA	ACCESO SPENTO	OFF

Come possiamo vedere nella tabella sopra, nella modalità di sospensione profonda ESP32, spesso chiamata pattern monitorato dal sensore ULP: CPU, WiFi / BT, memoria RTC e periferiche, co-processori ULP sono tutti disattivati. Vengono attivate solo la memoria RTC e le periferiche RTC.

Durante la situazione di riattivazione, l'ESP32 deve essere avvisato da una fonte di risveglio che riattiverà l'ESP32 dalla modalità di sospensione profonda. Tuttavia, poiché le periferiche RTC sono attivate, ESP32 può essere riattivato tramite GPIO abilitati per RTC. Ci sono anche altre opzioni. Può essere riattivato tramite un pin di interruzione del risveglio esterno o utilizzando un timer per riattivare ESP32. In questo progetto, stiamo usando ext0 wakeup sul pin 33.

Programmazione di ESP32 per la modalità Deep Sleep

Il programma completo si trova in fondo a questa pagina. È scritto per Arduino IDE e può quindi essere facilmente adattato alle tue esigenze. La spiegazione del codice è la seguente.

All'inizio del codice, // Crea una variabile PushButton PushBnt pushBtn = {GPIO_NUM_16, 0, false}; // definisce Led Pin uint8_t led_pin = GPIO_NUM_4; // definisci il pin di riattivazione uint8_t wakeUp_pin = GPIO_NUM_33;

Le tre linee precedenti definiscono il pin di attivazione, il pin LED e il pin della modalità sleep.

void setup () { // inserisci qui il tuo codice di configurazione, da eseguire una volta: // imposta la porta seriale su 115200 Serial.begin (115200); ritardo (1000); // imposta il pin pushButton come input con pullUp interno pinMode (pushBtn.pin, INPUT_PULLUP); // imposta il gestore degli interrupt con il pin pushButton in modalità Falling attachInterrupt (pushBtn.pin, isr_handle, FALLING); // imposta il pin Led come output pinMode (led_pin, OUTPUT); // crea un'attività che verrà eseguita nella funzione blinkLed (), con priorità 1 ed eseguita sul core 0 xTaskCreate ( blinkLed, / * Task function. * / "blinkLed", / * nome dell'attività. * / 1024 * 2, / * Dimensione dello stack dell'attività * / NULL, / * parametro dell'attività * / 5, / * priorità dell'attività * / & taskBlinkled); / * Maniglia dell'attività per tenere traccia dell'attività creata * / delay (500); // Configura il Pin 33 come sorgente di attivazione ext0 con livello logico BASSO esp_sleep_enable_ext0_wakeup ((gpio_num_t) wakeUp_pin, 0); }

In precedenza, l'interrupt è impostato su una modalità decrescente dal frammento di codice

attachInterrupt (pushBtn.pin, isr_handle, FALLING);

Pertanto, ogni volta che si preme l'interruttore, il livello logico verrà modificato da 1 logico (3,3 V) a 0 logico (0 V). La tensione del pin del pulsante diminuirà e l'ESP32 identificherà che l'interruttore è premuto. C'è anche un'attività creata per far lampeggiare il LED.

xTaskCreate ( blinkLed, / * Funzione attività. * / "blinkLed", / * nome dell'attività. * / 1024 * 2, / * Dimensione dello stack dell'attività * / NULL, / * parametro dell'attività * / 5, / * priorità dell'attività * / & taskBlinkled); / * Maniglia dell'attività per tenere traccia dell'attività creata * / delay (500);

Il pin 33 è anche configurato utilizzando lo snippet di codice riportato di seguito come sorgente di attivazione esterna identificata come ext0.

esp_sleep_enable_ext0_wakeup ((gpio_num_t) wakeUp_pin, 0);

Successivamente, nel ciclo while-

void loop () { // metti qui il tuo codice principale, da eseguire ripetutamente: if (pushBtn.pressed) { Serial.printf ("PushButton (% d) Pressed \ n", pushBtn.pin); Serial.printf ("Sospendi l'attività 'blinkLed' \ n"); // Sospende l'attività blinkLed vTaskSuspend (taskBlinkled); digitalWrite (led_pin, LOW); Serial.printf ("Sto andando a dormire….. \ n", pushBtn.pin); pushBtn.pressed = false; // Vai a dormire adesso esp_deep_sleep_start (); } esp_sleep_wakeup_cause_t wakeupReason; wakeupReason = esp_sleep_get_wakeup_cause (); switch (wakeupReason) { case ESP_SLEEP_WAKEUP_EXT0: Serial.println ("utilizzando il segnale esterno ext0 per WakeUp From sleep"); rompere; case ESP_SLEEP_WAKEUP_EXT1: Serial.println ("utilizza il segnale esterno ext1 per WakeUp From sleep"); rompere; case ESP_SLEEP_WAKEUP_TIMER: Serial.println ("using Timer signal for WakeUp From sleep"); rompere; case ESP_SLEEP_WAKEUP_TOUCHPAD: Serial.println ("utilizzo del segnale del TouchPad per WakeUp From sleep"); rompere; case ESP_SLEEP_WAKEUP_ULP: Serial.println ("utilizza il segnale ULP per WakeUp From sleep"); rompere; default: pausa; Serial.printf ("Riprendi l'attività 'blinkLed' \ n"); // riavvia l'attività blinkLed vTaskResume (taskBlinkled); } }

Il ciclo while controlla costantemente se il pulsante di sospensione è premuto o meno. Se il pulsante viene premuto, interromperà o sospenderà l'attività di lampeggiamento LED ed eseguirà la funzione di avvio del sonno profondo esp

esp_deep_sleep_start ();

In questa situazione, se viene premuto il pulsante di interruzione esterno ext0, si risveglierà immediatamente dalla modalità di sospensione profonda e riprenderà l'attività di lampeggiamento del LED.

Infine, la funzione di lampeggiamento del LED può essere vista nei frammenti di seguito, lampeggerà il LED per 1000 ms secondi.

void blinkLed (void * param) { while (1) { static uint32_t pin_val = 0; // cambia il valore pin pin_val ^ = 1; digitalWrite (led_pin, pin_val); Serial.printf ("Led -----------------% s \ n", pin_val? "On": "Off"); / * Basta attivare il LED ogni 1000 ms o 1 secondo * / vTaskDelay (1000 / portTICK_PERIOD_MS); } taskBlinkled = NULL; vTaskDelete (NULL); }

Test di ESP32 in modalità Deep Sleep

Il circuito è costruito in una breadboard e per misurare la corrente viene utilizzato un multimetro Metravi XB edition. La corrente assorbita dal circuito in modalità attiva è di quasi 58 mA ma in modalità deep sleep, la corrente è quasi 4,10 mA. L'immagine sotto mostra il consumo di corrente in modalità attiva ESP32 -

In modalità deep sleep, il consumo di corrente registrato è sceso a circa 3,95 mA, l'immagine sotto mostra il consumo di corrente in modalità Deep Sleep ESP32-

Tuttavia, in modalità di sospensione profonda, il consumo attuale di ESP32 è di quasi 150 uA. Ma il consumo di corrente registrato per questa scheda ESP32 Devkit è di quasi 4,10 mA. Ciò è dovuto al CP2102 e al regolatore lineare. Questi due sono collegati alla linea di alimentazione 5V. C'è anche un LED di alimentazione collegato alla linea di alimentazione che consuma quasi 2 mA di corrente.

Pertanto, si può facilmente identificare che l'ESP32 consuma una quantità molto bassa di energia in condizioni di modalità di sospensione profonda che è molto utile per le operazioni alimentate a batteria. Per ulteriori informazioni su come ha funzionato, guarda il video collegato di seguito. Se hai domande, lasciale nella sezione commenti qui sotto o usa i nostri forum per altre domande tecniche.