Deep sleep su ESP32 sotto i 10 µA: misurare e ridurre i consumi

Deep sleep su ESP32 sotto i 10 µA: misurare e ridurre i consumi
Indice

In deep sleep un ESP32-C6 o un ESP32-S3 assorbe circa 7 µA: è il valore tipico dei datasheet, con il timer RTC attivo e la memoria RTC alimentata. Scendere sotto i 10 µA su un dispositivo reale, però, dipende più dalla scheda che dal chip: il regolatore di tensione, il LED di alimentazione, i pull-up e il partitore per leggere la batteria possono consumare cento volte di più. E anche con un deep sleep perfetto, la durata della batteria la decide spesso il tempo in cui il dispositivo resta sveglio.

In questo articolo vediamo cosa resta acceso in deep sleep, come misurare correttamente correnti di pochi microampere, come stimare la durata della batteria e come scrivere un firmware che si sveglia, misura, accumula i dati e torna a dormire. Il codice si riferisce a ESP-IDF v6.1 e funziona su ESP32-C6 ed ESP32-S3, come negli articoli precedenti della serie, a partire dal confronto tra i due chip.

Cosa resta acceso in deep sleep

In deep sleep le CPU, quasi tutta la RAM e le periferiche digitali vengono spente. Restano alimentati solo il controller RTC, il coprocessore ULP e la memoria RTC (su ESP32-S3 sia la fast sia la slow, su ESP32-C6 solo la fast, chiamata anche memoria LP). Wi-Fi e Bluetooth sono spenti e le connessioni si perdono: al risveglio il chip riparte dal bootloader, come dopo un reset, e solo le variabili salvate in memoria RTC conservano il loro valore.

I datasheet riportano questi valori tipici, misurati a 3,3 V e 25 °C:

Modalità ESP32-C6 ESP32-S3
Light sleep 180 µA (35 µA con le periferiche spente) 240 µA
Deep sleep, timer RTC e memoria RTC accesi 7 µA 7 µA (8 µA con le periferiche RTC accese)
Deep sleep con il coprocessore ULP o il touch attivi a intervalli — 18 µA
Chip spento (CHIP_PU a livello basso) 1 µA 1 µA

Per confronto, lo stesso ESP32-C6 in ricezione Wi-Fi assorbe circa 78 mA e in trasmissione arriva a picchi di 252–354 mA, secondo il protocollo e la potenza. Tra il deep sleep e la fase attiva ci sono quattro ordini di grandezza.

Il light sleep conserva lo stato del programma e si risveglia in pochi istanti, ma consuma decine di volte di più. Conviene quando il dispositivo deve reagire spesso o mantenere una connessione Wi-Fi o Bluetooth, grazie al light sleep automatico del power management. Il deep sleep conviene quando il dispositivo dorme per minuti o ore tra un’attività e l’altra: un sensore che misura e trasmette, un pulsante che invia un evento, un contatore che si sveglia una volta al giorno.

Le sorgenti di risveglio

Prima di chiamare esp_deep_sleep_start() si scelgono una o più sorgenti di risveglio; il chip si sveglia alla prima che scatta. Quelle utili in deep sleep sono:

  • Timer RTC, con esp_sleep_enable_timer_wakeup(): il tempo si indica in microsecondi. Non richiede di tenere accese le periferiche RTC.
  • ext1, con esp_sleep_enable_ext1_wakeup_io(): uno o più pin, ciascuno con il proprio livello di risveglio (alto o basso). Funziona anche con le periferiche RTC spente. Si possono usare solo i pin RTC: GPIO0–GPIO7 su ESP32-C6, GPIO0–GPIO21 su ESP32-S3.
  • ext0, solo su ESP32-S3, con esp_sleep_enable_ext0_wakeup(): un singolo pin, ma richiede le periferiche RTC accese e quindi qualche microampere in più.
  • Touch e coprocessore ULP: il chip resta in deep sleep mentre un sensore capacitivo o un piccolo programma sul coprocessore controlla un ingresso, e sveglia la CPU principale solo quando serve.

Un dettaglio che conviene conoscere prima di progettare la scheda: su ESP32-C6 il tasto BOOT delle schede di sviluppo è collegato a GPIO9, che non è un pin RTC. Per svegliare il chip con un pulsante serve un pin tra GPIO0 e GPIO7. Su ESP32-S3 il tasto BOOT è su GPIO0, che invece si può usare.

In ESP-IDF v6.1 la vecchia esp_sleep_enable_ext1_wakeup() e esp_sleep_get_wakeup_cause() sono deprecate: al loro posto si usano esp_sleep_enable_ext1_wakeup_io() e esp_sleep_get_wakeup_causes(), che restituisce una maschera di bit con tutte le cause del risveglio.

Perché la scheda consuma più del chip

Se programmi un esempio di deep sleep su una scheda di sviluppo e misuri la corrente dall’alimentazione USB, è normale leggere qualche milliampere: non è il chip a consumarli. Su una scheda di sviluppo sono sempre accesi il regolatore da 5 V a 3,3 V, il LED che indica l’alimentazione e il convertitore USB-seriale. Sono componenti scelti per la comodità di sviluppo, non per il basso consumo.

Grafico a barre in scala logaritmica delle correnti in deep sleep: ESP32-C6 o ESP32-S3 7 µA; partitore da 2 × 100 kΩ sulla batteria a 4,2 V 21 µA; partitore da 2 × 1 MΩ 2,1 µA; pull-up da 10 kΩ su un pin a livello basso 330 µA; LED di alimentazione con resistenza da 1 kΩ 1,3 mA; una linea tratteggiata indica l’obiettivo di 10 µA totali
Bastano un LED o un pull-up nel posto sbagliato per superare di cento volte la corrente del chip.

Su una scheda progettata per la batteria, le voci da controllare una per una sono:

  • Il regolatore di tensione. La sua corrente di riposo (quiescent current, IQ) scorre sempre, anche quando il chip dorme. Alcuni regolatori molto diffusi sulle schede economiche assorbono milliampere; esistono LDO e convertitori progettati per il basso consumo con valori di 1 µA o meno. È il primo numero da leggere nel datasheet del regolatore.
  • I LED. Un LED di alimentazione con una resistenza da 1 kΩ a 3,3 V assorbe circa (3,3 − 2) / 1000 = 1,3 mA: da solo vale quasi duecento volte il chip in deep sleep. Sui prodotti a batteria si elimina o si pilota da un GPIO.
  • I pull-up e i pull-down. Un pull-up da 10 kΩ verso 3,3 V su un pin tenuto a livello basso assorbe 330 µA. Attenzione ai segnali che, durante il sonno, restano nello stato opposto a quello del resistore: un pulsante premuto, l’uscita di un sensore, una linea open-drain tenuta bassa.
  • Il partitore per misurare la batteria. Due resistori da 100 kΩ su una cella a 4,2 V assorbono 21 µA, giorno e notte. Con 2 × 1 MΩ e un condensatore sull’ingresso dell’ADC si scende a 2,1 µA; in alternativa si scollega il partitore con un MOSFET quando non serve.
  • Sensori e periferiche esterne. Molti sensori hanno una modalità di riposo da pochi microampere, ma va attivata via software prima di dormire. Se non ce l’hanno, si alimentano da un interruttore di carico comandato da un GPIO.
  • Il convertitore USB-seriale. Sulle schede di sviluppo è alimentato dall’USB. Se alimenti la scheda a batteria e lo lasci collegato alle linee TX e RX, può assorbire corrente attraverso i pin del chip.

La memoria flash non è un problema in deep sleep: esp_deep_sleep_start() la spegne sempre, qualunque sia la configurazione. Anche la PSRAM degli ESP32-S3 pesa solo nel light sleep, dove il datasheet indica di aggiungere da 40 a 200 µA secondo il tipo; per il deep sleep non riporta consumi aggiuntivi.

Per i pin collegati a circuiti esterni che potrebbero assorbire corrente attraverso i resistori interni, ESP-IDF offre rtc_gpio_isolate(): scollega il pin da ingresso, uscita e resistori interni per tutta la durata del sonno.

Misurare correnti di pochi microampere

Per sapere se il dispositivo è davvero sotto i 10 µA bisogna misurarlo, e la misura ha le sue trappole.

Misura solo ciò che ti interessa. Sulla ESP32-C6-DevKitC-1 il ponticello J5 separa l’alimentazione del modulo dal resto della scheda: togliendolo e collegando un amperometro ai due pin si misura solo il modulo ESP32-C6-WROOM-1. La ESP32-S3-DevKitC-1 non ha un ponticello equivalente: per misurare il modulo si alimenta direttamente il pin 3V3 con l’amperometro in serie, senza il cavo USB, così il regolatore e il convertitore USB-seriale restano fuori dalla misura.

Attenzione alla caduta sull’amperometro. Un multimetro sulla portata dei microampere misura la tensione su una resistenza interna (lo shunt), che sulle portate più basse è relativamente grande. Finché il chip dorme non succede niente; quando si sveglia e chiede centinaia di milliampere, la caduta sullo shunt può abbassare la tensione al chip fino a farlo resettare per sottotensione (brownout). Il sintomo tipico è un dispositivo che sembra riavviarsi in continuazione solo quando c’è il multimetro. La soluzione pratica è cortocircuitare lo strumento durante l’avvio e aprire il cortocircuito solo quando il chip è in deep sleep.

Un multimetro mostra un numero, non un ciclo. Per misurare l’energia di un ciclo completo, fase attiva compresa, servono strumenti che campionano la corrente su un intervallo molto ampio, dai nanoampere all’ampere, e calcolano la media: per esempio Joulescope, Nordic Power Profiler Kit II o Otii Arc. La guida di Espressif sulla misura dei consumi usa un Joulescope su un modulo ESP32-S3-WROOM-1 con l’esempio deep_sleep di ESP-IDF e riporta 8,14 µA in deep sleep e circa 24 mA durante la fase attiva: un valore vicino a quello del datasheet, ma misurato sul modulo intero, flash compresa.

Quanto dura la batteria

La corrente media di un dispositivo che si sveglia periodicamente è la carica consumata in un ciclo divisa per la durata del ciclo. In una formula:

Testo
I_media = (I_att × t_att + I_sleep × t_sleep) / (t_att + t_sleep)
durata  = capacità / I_media

Prendiamo un sensore che ogni 10 minuti si sveglia, si connette al Wi-Fi e invia una misura. Come ipotesi di lavoro, la fase attiva dura 1,5 s con una corrente media di 80 mA: è un ordine di grandezza plausibile per una connessione Wi-Fi con l’invio di pochi byte, ma il valore reale va misurato sul tuo dispositivo, perché dipende dalla rete, dal server e dal firmware.

Profilo di corrente di un ciclo in scala logaritmica: deep sleep a 7 µA per circa 10 minuti, poi una fase attiva di 1,5 secondi con l’avvio a qualche decina di mA, la connessione Wi-Fi a 80 mA medi e picchi di trasmissione di centinaia di mA, poi di nuovo deep sleep; la fase attiva consuma 120 mAs, il deep sleep a 10 µA circa 6 mAs
Con un risveglio ogni 10 minuti, la fase attiva consuma venti volte più del deep sleep.

Con una batteria da 2000 mAh e le stesse ipotesi, la corrente in deep sleep cambia la durata così:

Corrente in deep sleep Risveglio ogni 10 minuti Risveglio ogni ora
10 µA 210 µA medi, circa 13 mesi 43 µA medi, circa 5 anni
100 µA 300 µA medi, circa 9 mesi 133 µA medi, circa 1 anno e 8 mesi
1 mA 1,2 mA medi, circa 70 giorni 1 mA medi, circa 80 giorni

Sono durate teoriche: non tengono conto dell’autoscarica della batteria, del rendimento del regolatore e della capacità che si riduce al freddo o con correnti di picco elevate. Servono però a capire dove intervenire:

  • Con risvegli frequenti conta la fase attiva. Ogni 10 minuti, passare da 100 µA a 10 µA in deep sleep allunga la durata del 40%; ridurre la fase attiva da 1,5 s a 0,5 s, a parità di deep sleep, la porta da 13 mesi a circa tre anni.
  • Con risvegli rari conta il deep sleep. Ogni ora, la differenza tra 10 e 100 µA vale un fattore tre sulla durata.
  • Sopra il milliampere non c’è firmware che tenga. Un LED o un regolatore sbagliato annullano qualunque ottimizzazione del codice.

Ridurre il tempo da sveglio

Al risveglio dal deep sleep il chip esegue il bootloader, carica l’applicazione dalla flash e la avvia: tutto questo è tempo a decine di milliampere. Alcuni accorgimenti per accorciarlo:

  • Accumula e trasmetti a gruppi. Leggere un sensore costa pochi millisecondi; connettersi al Wi-Fi, qualche secondo. Salva le misure in memoria RTC con RTC_DATA_ATTR e trasmettile ogni N risvegli: è quello che fa l’esempio più sotto.
  • Riconnettiti al Wi-Fi più in fretta. Salva in memoria RTC il canale e il BSSID dell’access point e impostali nei campi channel, bssid_set e bssid di wifi_config_t: il driver salta la scansione dei canali. Un indirizzo IP statico evita lo scambio DHCP.
  • Riduci i log. Ogni riga inviata alla seriale tiene sveglio il chip. In produzione imposta CONFIG_BOOTLOADER_LOG_LEVEL_WARN e CONFIG_LOG_DEFAULT_LEVEL_WARN; esp_deep_sleep_disable_rom_logging() disattiva anche i messaggi della ROM al risveglio.
  • Controlla gli aggiornamenti di rado. Se il dispositivo usa gli aggiornamenti OTA, il controllo può avvenire una volta al giorno, non a ogni risveglio.
  • Valuta il light sleep per attese brevi. Se il dispositivo deve aspettare pochi secondi, per esempio la conversione di un sensore, il light sleep conserva lo stato ed evita il riavvio completo.

Esiste anche l’opzione CONFIG_BOOTLOADER_SKIP_VALIDATE_IN_DEEP_SLEEP, che salta la verifica dell’immagine al risveglio e accorcia l’avvio. La descrizione dell’opzione sconsiglia di usarla con Secure Boot e con gli aggiornamenti OTA, perché la nuova immagine potrebbe essere avviata senza essere verificata: su un dispositivo che riceve firmware firmati, come quello dell’articolo precedente, è meglio lasciarla disattivata.

Un esempio completo

L’esempio legge il sensore di temperatura interno ogni 10 minuti, accumula sei misure in memoria RTC e le “invia” una volta all’ora. Un pulsante tra GPIO2 e massa sveglia il chip e forza l’invio immediato. Al posto della funzione send_batch(), che qui stampa le misure sul log, andranno la connessione Wi-Fi e la trasmissione, come nell’esempio dell’articolo sugli aggiornamenti OTA.

GPIO2 è un pin RTC sia su ESP32-C6 sia su ESP32-S3 e su nessuno dei due è un pin di strapping o della JTAG: su ESP32-C6, per esempio, GPIO4 e GPIO5 lo sono, e un pulsante premuto all’accensione potrebbe cambiare la modalità di avvio. Il sensore di temperatura è lo stesso usato nell’articolo su FreeRTOS: non serve altro hardware.

Il main/CMakeLists.txt dichiara i componenti usati:

CMake
idf_component_register(SRCS "main.c"
                       INCLUDE_DIRS "."
                       REQUIRES esp_driver_gpio esp_driver_tsens esp_hw_support log)

Questo è main/main.c:

C
#include <inttypes.h>
#include "driver/rtc_io.h"
#include "driver/temperature_sensor.h"
#include "esp_log.h"
#include "esp_sleep.h"

#define WAKE_GPIO     GPIO_NUM_2                     // Pin RTC: GPIO0-7 su C6, GPIO0-21 su S3
#define SLEEP_TIME_US (10ULL * 60 * 1000 * 1000)     // 10 minuti
#define BATCH_SIZE    6                              // Un invio ogni ora

static const char *TAG = "sleep";

// In memoria RTC: sopravvivono al deep sleep, non a un reset o a un blackout.
static RTC_DATA_ATTR uint32_t wake_count;
static RTC_DATA_ATTR float samples[BATCH_SIZE];
static RTC_DATA_ATTR uint8_t sample_count;

static float read_temperature(void)
{
    temperature_sensor_handle_t tsens = NULL;
    temperature_sensor_config_t config = TEMPERATURE_SENSOR_CONFIG_DEFAULT(-10, 80);
    float celsius = 0;

    ESP_ERROR_CHECK(temperature_sensor_install(&config, &tsens));
    ESP_ERROR_CHECK(temperature_sensor_enable(tsens));
    ESP_ERROR_CHECK(temperature_sensor_get_celsius(tsens, &celsius));
    ESP_ERROR_CHECK(temperature_sensor_disable(tsens));
    ESP_ERROR_CHECK(temperature_sensor_uninstall(tsens));
    return celsius;
}

static void send_batch(void)
{
    // Qui vanno la connessione Wi-Fi e la trasmissione delle misure.
    for (int i = 0; i < sample_count; i++) {
        ESP_LOGI(TAG, "Misura %d: %.1f °C", i + 1, samples[i]);
    }
    sample_count = 0;
}

static void configure_wakeup(void)
{
    ESP_ERROR_CHECK(esp_sleep_enable_timer_wakeup(SLEEP_TIME_US));

    // Pulsante verso massa: il chip si sveglia quando il pin va a livello basso.
    ESP_ERROR_CHECK(esp_sleep_enable_ext1_wakeup_io(BIT64(WAKE_GPIO), ESP_EXT1_WAKEUP_ANY_LOW));

    // Pull-up interno mantenuto durante il sonno. Con il pulsante rilasciato
    // il pin è a livello alto e il pull-up non assorbe corrente.
    ESP_ERROR_CHECK(rtc_gpio_init(WAKE_GPIO));
    ESP_ERROR_CHECK(rtc_gpio_pulldown_dis(WAKE_GPIO));
    ESP_ERROR_CHECK(rtc_gpio_pullup_en(WAKE_GPIO));
}

void app_main(void)
{
    uint32_t causes = esp_sleep_get_wakeup_causes();
    bool button = causes & BIT(ESP_SLEEP_WAKEUP_EXT1);

    if (causes & (BIT(ESP_SLEEP_WAKEUP_TIMER) | BIT(ESP_SLEEP_WAKEUP_EXT1))) {
        wake_count++;
    } else {
        // Accensione o reset: la memoria RTC non contiene dati validi.
        wake_count = 0;
        sample_count = 0;
    }
    ESP_LOGI(TAG, "Risveglio %" PRIu32 "%s", wake_count, button ? " dal pulsante" : "");

    if (sample_count < BATCH_SIZE) {
        samples[sample_count++] = read_temperature();
    }
    if (button || sample_count == BATCH_SIZE) {
        send_batch();
    }

    configure_wakeup();
    ESP_LOGI(TAG, "Deep sleep per %llu s", SLEEP_TIME_US / 1000000);
    esp_deep_sleep_start();  // Non ritorna: al risveglio si riparte da app_main()
}

Le scelte del codice

  • Tutto in app_main(). Dopo il deep sleep il programma riparte dall’inizio: non servono task o cicli infiniti. Il flusso è lineare: capire perché ci si è svegliati, fare il lavoro, configurare il risveglio, dormire.
  • La memoria RTC va considerata non valida dopo un reset. Le variabili con RTC_DATA_ATTR mantengono il valore solo tra un deep sleep e l’altro. Dopo un’accensione, un reset o un crash il codice le azzera esplicitamente in base alla causa del risveglio.
  • Le periferiche si spengono prima di dormire. Il sensore di temperatura viene disinstallato subito dopo la lettura. In deep sleep si spegnerebbe comunque, ma è un’abitudine utile: con un sensore esterno, mandarlo in riposo prima di dormire è ciò che fa la differenza.
  • Il pull-up del pulsante non costa nulla a riposo. La corrente scorre solo mentre il pulsante è premuto. Per lo stesso motivo un sensore che tiene basso un pin collegato a un pull-up, durante il sonno, va evitato.
  • Un pulsante tenuto premuto sveglia il chip di continuo. Se il pulsante resta premuto, il chip si risveglia appena torna in deep sleep. In un prodotto conviene attendere il rilascio prima di dormire, oppure disattivare la sorgente ext1 per quel ciclo con esp_sleep_disable_ext1_wakeup_io().

Per le prove, riduci SLEEP_TIME_US a qualche secondo. Il monitor seriale mostrerà a ogni risveglio il numero progressivo e, ogni sei risvegli o alla pressione del pulsante, l’elenco delle misure. Su ESP32-C6 e ESP32-S3 con la console sull’USB integrato (USB Serial/JTAG), la porta seriale sparisce durante il deep sleep e ricompare al risveglio: è normale, il monitor si ricollega da solo.

Checklist per scendere sotto i 10 µA

  • Misura il modulo da solo, non la scheda di sviluppo: ponticello J5 sulla ESP32-C6-DevKitC-1, alimentazione dal pin 3V3 sulla ESP32-S3-DevKitC-1.
  • Scegli un regolatore con corrente di riposo di pochi microampere, o meno.
  • Elimina il LED di alimentazione o pilotalo da un GPIO.
  • Controlla ogni pull-up e pull-down: nessuno deve avere il pin nello stato opposto durante il sonno.
  • Partitore della batteria da qualche megaohm, o scollegabile con un MOSFET.
  • Sensori in modalità di riposo prima di dormire, o alimentati da un interruttore di carico.
  • rtc_gpio_isolate() sui pin collegati a circuiti esterni che non servono durante il sonno.
  • Sorgenti di risveglio che non richiedono le periferiche RTC accese: timer ed ext1.
  • Misure accumulate in memoria RTC e trasmesse a gruppi; log ridotti in produzione.
  • Una misura del ciclo completo con uno strumento adatto, prima di stimare la durata della batteria.

Con questo articolo si chiude la serie sul firmware moderno con ESP32: dalla scelta del chip al passaggio a ESP-IDF, da FreeRTOS agli aggiornamenti OTA, fino ai consumi.

Fonti