Alimentare un ESP32 a batteria

Perché una scheda di sviluppo svuota la batteria

In deep sleep il chip ESP32 consuma circa 10 µA, l’ESP32-C3 circa 5 µA e l’ESP32-S3 circa 7 µA, secondo Espressif (il nostro confronto ESP32 li riporta tutti). Una scheda di sviluppo aggiunge attorno al chip componenti che non dormono mai:

• Il regolatore. Molte schede usano un AMS1117, con una corrente di riposo di circa 5 mA (fino a 11 mA): cinquecento volte quello che consuma un ESP32 in deep sleep.
• Il LED di alimentazione. Resta acceso finché la scheda è alimentata. La sua corrente dipende dalla resistenza in serie, che puoi calcolare con il nostro calcolatore della resistenza per LED.
• Il chip USB-seriale. Sulle schede che lo alimentano dai 3,3 V resta acceso, con o senza cavo USB. Per saperlo, guarda lo schema della scheda.
• Resistenze di pull-up, partitori e sensori collegati ai 3,3 V, che assorbono corrente giorno e notte.

Messi insieme, si fanno sentire. Il preset “ESP32 DevKit così com’è” del calcolatore di autonomia (un AMS1117, più 3 mA indicativi per LED e chip USB-seriale) svuoterebbe una cella 18650 da 3000 mAh in circa 13 giorni nel migliore dei casi, mentre la stessa cella fa funzionare il modulo nudo del nostro esempio per circa 13 mesi. Guarda il caso DevKit nel calcolatore. Ed è una stima ottimistica: un AMS1117 ha un dropout di circa 1 V, quindi con una cella Li-ion la linea a 3,3 V scende sotto i 3,0 V minimi del modulo molto prima che la cella sia scarica.

Per un progetto a batteria usa un modulo nudo su un circuito stampato tuo, oppure una scheda pensata per i bassi consumi, di cui il produttore dichiari il consumo complessivo. Seeed, per esempio, indica 44 µA in deep sleep per la XIAO ESP32C3 (vedi il nostro pinout della XIAO ESP32C3). Puoi anche togliere LED e regolatore da una scheda di sviluppo, ma poi i 3,3 V devi fornirli tu.

Scegliere la batteria

Un modulo ESP32 vuole 3,0–3,6 V, e 3,6 V è anche il suo massimo assoluto. Poche batterie restano in questa finestra da cariche a scariche, e da questo dipende se ti serve un regolatore, e quale.

• Una cella Li-ion o LiPo (1S). La scelta più comune: tanta energia, ricaricabile, economica. Va da 4,2 V carica a circa 3,0 V, quindi serve un regolatore: un LDO a basso dropout oppure un buck-boost (vedi la sezione successiva). Usa celle protette o aggiungi tu un circuito di protezione (vedi Sicurezza).
• Una cella LiFePO4. Passa gran parte della scarica attorno a 3,2–3,3 V, quindi può alimentare il modulo direttamente, senza regolatore e senza corrente di riposo. Una carica standard però finisce a 3,65 V, sopra il massimo di 3,6 V del modulo: fermane la carica sotto i 3,6 V e, quando la tensione scende sotto i 3,0 V circa, tieni il modulo in reset con un supervisore di tensione (un integrato di reset) su EN. Le checklist di Espressif lo raccomandano per le alimentazioni che salgono lentamente o sono instabili, come batterie e pannelli solari. Il supervisore ferma solo il modulo: la cella ha comunque bisogno di una protezione contro la scarica eccessiva (un BMS o una schedina di protezione). A parità di dimensioni immagazzina meno energia di una Li-ion.
• Tre stilo AA. Le alcaline nuove danno circa 4,5 V e nel datasheet le prove di scarica arrivano fino a 0,8 V per pila, 2,4 V in tutto; le NiMH vanno da circa 4,2 V appena caricate a 2,7 V. Nessuna delle due resta nella finestra: usa un buck-boost.
• Pile a bottone (CR2032). Non per la radio dell’ESP32: Renata dichiara 3 mA continui per la sua CR2032, mentre Espressif chiede un’alimentazione capace di erogare 500 mA. La nota di TI su pile a bottone e correnti di picco indica un condensatore in parallelo come il rimedio più efficace per i brevi picchi delle radio pensate per queste pile, che restano lontanissimi da quelli di un ESP32.
• Litio-cloruro di tionile (Li-SOCl₂). Ha un’autoscarica bassissima, quindi va bene per sensori che si svegliano di rado e devono durare anni. Ma una Saft LS14500 (formato AA) è specificata per 50 mA continui e impulsi da 250 mA, quindi per il Wi-Fi serve un condensatore che fornisca i picchi: la stessa Saft avverte che può essere necessario. Dopo un periodo di stoccaggio uno strato di passivazione ne alza la resistenza: in una prova di Qoitech una cella immagazzinata superava i 100 Ω e perdeva fino a 1,8 V sui primi impulsi. La sua tensione a vuoto, 3,67 V, è inoltre appena sopra il massimo del modulo.

Il nostro confronto batterie riporta i dettagli di ogni chimica, e la tabella tensione batterie trasforma una tensione misurata nella carica residua.

Il regolatore: poca corrente a riposo, abbastanza corrente per il Wi-Fi

In deep sleep la corrente di riposo del regolatore conta spesso più del consumo del chip. Durante una trasmissione Wi-Fi è il contrario: le linee guida hardware di Espressif chiedono un’alimentazione a 3,3 V che eroghi almeno 500 mA. Un regolatore per un nodo a batteria deve soddisfare entrambe le esigenze.

Corrente di riposo tipica e corrente di uscita nominale dai datasheet, gli stessi valori del nostro calcolatore per regolatori.

MCP1700 e HT7333 sono molto usati per la corrente di riposo minuscola, ma con 250 mA sono specificati per la metà di quanto chiede Espressif. TLV755P e AP2112K ci arrivano consumando a riposo poche decine di microampere. Il TLV755P però non ha margine: è specificato proprio per 500 mA, e a quella corrente il suo dropout può arrivare a 238 mV, quindi nei picchi del Wi-Fi smette di regolare appena la cella scende sotto i 3,54 V circa. Per avere più margine scegli l’AP2112K, specificato per 600 mA, e con tutti e due metti il condensatore di riserva raccomandato da Espressif (vedi sotto).

Con una cella Li-ion, un LDO smette di regolare quando la cella scende a 3,3 V più il suo dropout, e da lì in poi lascia passare la tensione della cella meno il dropout. Il modulo funziona fino a 3,0 V, e secondo la nostra tabella tensione batterie una cella Li-ion che a riposo segna 3,6 V conserva solo il 7 % circa della carica (0–40 % a seconda delle tabelle dei produttori), quindi un buon LDO sfrutta quasi tutta la batteria. Nei picchi del Wi-Fi, però, la tensione della cella cala e il dropout cresce, per cui l’autonomia finisce un po’ prima di quanto faccia pensare la tensione a riposo; a quel punto un supervisore su EN tarato a circa 3,0 V, come raccomanda Espressif, tiene il modulo in reset finché la tensione resta troppo bassa. Un buck-boost come il TPS63802 tiene i 3,3 V sia quando la batteria è sopra questa tensione sia quando è sotto, ed è la scelta giusta per tre stilo AA, che partono sopra i 3,6 V e finiscono sotto i 3,0 V.

Verifica un regolatore con la tua batteria (dropout, calore e corrente di riposo): il link apre un TLV755P su una cella Li-ion.Apri il calcolatore per regolatori

Condensatori: le linee guida di Espressif raccomandano almeno 10 µF all’ingresso dell’alimentazione e 0,1 µF vicino ai pin di alimentazione del chip. Con una batteria che non riesce a fornire i picchi da sola, come una Li-SOCl₂, li deve fornire un condensatore.

Il deep sleep in pratica

In deep sleep le CPU, gran parte della RAM e le periferiche digitali sono spente, come anche Wi-Fi e Bluetooth; restano alimentati il controller RTC e la memoria RTC. Al risveglio il programma riparte dall’inizio, quindi con Arduino tutto avviene in setup().

Sorgenti di risveglio

• Timer, su tutti i chip: il timer RTC sveglia il chip dopo un tempo prestabilito.
• Pin. ESP32 ed ESP32-S3 si svegliano con il livello di un pin RTC (ext0) o di più pin (ext1). L’ESP32-C3 si sveglia solo sui pin del suo dominio di alimentazione RTC, GPIO0–5, attivati con esp_deep_sleep_enable_gpio_wakeup() (vedi il nostro pinout dell’ESP32-C3 SuperMini).
• Pad touch, su ESP32 ed ESP32-S3.
• Il coprocessore ULP, su ESP32 ed ESP32-S3: un piccolo core che può leggere un sensore mentre le CPU principali dormono e svegliarle quando succede qualcosa.

Conservare i dati tra un risveglio e l’altro

Le variabili normali si perdono a ogni risveglio. Dichiara quelle che ti servono con RTC_DATA_ATTR: stanno nella memoria RTC, che di default resta alimentata in deep sleep.

Arduino-ESP32

#define SLEEP_MINUTES 15

RTC_DATA_ATTR int bootCount = 0;   // conservato nella memoria RTC

void setup() {
  bootCount++;
  // leggi il sensore, collegati, invia i dati...
  esp_sleep_enable_timer_wakeup(SLEEP_MINUTES * 60ULL * 1000000ULL);  // microsecondi
  esp_deep_sleep_start();          // non ritorna
}

void loop() {}                     // mai raggiunto

Il codice è scritto per Arduino-ESP32 3.x, la cui serie stabile 3.3 si basa su ESP-IDF 5.5. Il timer si imposta in microsecondi, da qui la conversione. Per svegliarsi su un pin, ESP32 ed ESP32-S3 usano esp_sleep_enable_ext0_wakeup(pin, level); dopo il riavvio esp_sleep_get_wakeup_cause() ti dice perché il chip si è svegliato. In ESP-IDF 6, la base di Arduino-ESP32 4.x, questa funzione è deprecata a favore di esp_sleep_get_wakeup_causes(), che restituisce tutte le sorgenti di risveglio in una bitmap, e la esp_deep_sleep_enable_gpio_wakeup() dell’ESP32-C3 è sostituita da esp_sleep_enable_gpio_wakeup_on_hp_periph_powerdown().

ESPHome

deep_sleep:
  run_duration: 10s
  sleep_duration: 15min

run_duration è quanto resta sveglio il nodo, sleep_duration quanto dorme; sull’ESP32 wakeup_pin aggiunge un pin di risveglio. Il nostro generatore di configurazioni ESPHome può aggiungere per te questo blocco e un IP statico.

I pin durante il deep sleep

Un pin che deve mantenere il suo livello mentre il chip dorme, come il gate di un MOSFET che tiene spento un sensore, va bloccato: gpio_hold_en() prima di dormire e gpio_hold_dis() dopo il risveglio. Su ESP32, ESP32-C3 ed ESP32-S3 questo basta solo per i pin RTC: quelli fuori dal dominio RTC (GPIO1, 3, 5, 16–19 e 21–23 sull’ESP32, dal GPIO6 in su sull’ESP32-C3, dal GPIO22 in su sull’ESP32-S3) richiedono anche gpio_deep_sleep_hold_en(). Fai attenzione anche alla corrente che passa da pull-up e partitori. L’esempio di Espressif è il GPIO12 dell’ESP32-WROVER, con un pull-up esterno e un pull-down interno: perde corrente finché non lo isoli con rtc_gpio_isolate() prima di dormire.

Accorciare il tempo da sveglio

Nell’esempio il Wi-Fi rappresenta la maggior parte della corrente media, quindi ogni secondo risparmiato da sveglio conta:

• Un IP statico. Evita il DHCP; la documentazione di ESPHome dice che “can dramatically improve connection times”, cioè che può ridurre di molto i tempi di connessione. Con Arduino chiama WiFi.config(ip, gateway, subnet, dns) prima di WiFi.begin().
• Ricordare l’access point. WiFi.begin(ssid, password, channel, bssid) accetta il canale e il BSSID che hai salvato nella memoria RTC dopo la prima connessione. L’opzione fast_connect di ESPHome salta la scansione iniziale e memorizza anch’essa BSSID e canale.
• ESP-NOW invece di Wi-Fi e MQTT. ESP-NOW è il protocollo senza connessione di Espressif: niente access point, niente indirizzo IP, niente broker. I pacchetti portano fino a 250 byte (1470 con ESP-NOW v2), e trasmettitore e ricevitore devono stare sullo stesso canale. Un ESP32 alimentato dalla rete elettrica può ricevere i dati e inoltrarli via MQTT.
• Alimentare i sensori solo quando servono. Alimenta un sensore da un GPIO se consuma poco, oppure accendilo e spegnilo con un MOSFET; il nostro calcolatore transistor come interruttore verifica il componente. Nella fase da sveglio considera anche il tempo di avvio del sensore.

Non citiamo tempi di connessione: dipendono dall’access point e dalla rete. Misura i tuoi, come spiegato qui sotto.

Misurare bene la corrente

Un multimetro in serie va bene per la corrente di deep sleep, con due avvertenze. Il suo shunt provoca una caduta di tensione, la cosiddetta burden voltage, che sulle portate in microampere può bastare a lasciare la scheda senza tensione al risveglio; inoltre la lettura si aggiorna lentamente, quindi non segue le raffiche Wi-Fi che durano una frazione di secondo.

Strumenti fatti apposta:

• Nordic Power Profiler Kit II (PPK2): misura da 200 nA a 1 A a 100.000 campioni al secondo, e può anche alimentare la scheda, tra 0,8 e 5 V.
• Joulescope JS220: campiona insieme corrente e tensione a 2 milioni di campioni al secondo, con una risoluzione fino a 0,5 nA.
• EEVblog µCurrent GOLD: un adattatore che trasforma un multimetro in un amperometro a bassa caduta, 1 mV per nA, µA o mA.

Qualunque strumento usi, misura la media su almeno un ciclo completo, deep sleep e risveglio compresi, alimenta la scheda alla tensione della batteria che userai davvero e scollega l’USB, che altrimenti alimenta la scheda da un’altra fonte.

Tenere d’occhio la tensione della batteria

Una cella Li-ion (4,2 V da carica) supera quello che l’ADC sa leggere, quindi va letta attraverso un partitore. Con 1 MΩ + 1 MΩ il partitore dimezza la tensione e assorbe 2,1 µA da una cella carica. Aggiungi un condensatore da 100 nF tra il pin dell’ADC e massa, così l’ADC vede una sorgente a bassa impedenza mentre campiona. Se vuoi che in deep sleep il partitore non consumi nulla, accendilo solo durante la lettura con un MOSFET sul lato alto: un P-MOSFET tra la cella e il partitore, comandato da un GPIO attraverso un piccolo N-MOSFET. Un N-MOSFET verso massa da solo non va bene: quando è spento, la resistenza superiore porta il pin dell’ADC alla tensione della cella, 4,2 V da carica, sopra il limite di 3,6 V del chip; e un P-MOSFET comandato direttamente da un GPIO a 3,3 V non si spegne del tutto con 4,2 V sul source. Il nostro calcolatore transistor come interruttore verifica entrambi i componenti.

Provalo nel nostro calcolatore: un partitore da 1 MΩ + 1 MΩ su una cella Li-ion carica, letto da un ESP32-C3.Apri il calcolatore del partitore

Tieni l’uscita del partitore entro l’intervallo in cui l’ADC è specificato: fino a circa 2,45 V sull’ESP32 e 2,5 V sull’ESP32-C3 con l’attenuazione massima, secondo i datasheet di Espressif. Con Arduino, analogReadMilliVolts() restituisce una lettura calibrata in millivolt. Sull’ESP32 usa un pin dell’ADC1: l’ADC2 non si legge in modo affidabile con il Wi-Fi acceso. Poi trasforma la tensione in livello di carica con la nostra tabella tensione batterie; con una LiFePO4, a metà scarica la tensione dice poco.

Un esempio completo

Un nodo sensore con un modulo ESP32-C3 nudo, un buck-boost TPS63802 e una cella Li-ion 18650 da 3000 mAh, che si sveglia ogni 15 minuti per inviare una lettura via Wi-Fi:

I valori da sveglio sono quelli indicativi del calcolatore: sostituiscili con quelli che misuri.

La corrente media è di circa 270 µA, per un’autonomia di circa 13 mesi. La fetta più grande è del Wi-Fi, poi dell’autoscarica della cella; il deep sleep è quasi trascurabile.

Se il nodo si sveglia una volta all’ora, la corrente media scende a circa 142 µA e l’autonomia sale a circa 2 anni (guardalo nel calcolatore); la fetta più grande diventa allora l’autoscarica. La stessa cella in un DevKit non modificato dura circa 13 giorni, nel migliore dei casi.

Un’avvertenza: il calcolatore modella un regolatore lineare, in cui la batteria fornisce la corrente del circuito più la corrente di riposo del regolatore. Un buck-boost come il TPS63802 trasferisce invece potenza: la corrente presa dalla batteria è la corrente del circuito × 3,3 V ÷ (tensione della batteria × rendimento). Con un rendimento del 90 % circa (il valore che il nostro calcolatore per regolatori assume per il TPS63802), a 3,7 V, la tensione nominale di una cella Li-ion, la batteria fornisce più o meno la corrente del circuito; un po’ meno con la cella carica e circa un quinto in più verso i 3,0 V, quindi per questo esempio la stima regge. Con tre stilo AA verso la fine della scarica, intorno ai 2,7 V, la batteria fornisce circa un terzo in più di quanto assorbe il circuito.

Apri l’esempio nel calcolatore di autonomia, poi sostituisci i valori indicativi con le correnti che hai misurato.Apri il calcolatore di autonomia

Ricarica e pannello solare

L’onnipresente TP4056 carica una cella Li-ion a 4,2 V con al massimo 1 A, e termina la carica quando la corrente scende a un decimo del valore impostato. Non ha power path: durante la carica l’ESP32 resta collegato alla cella, e se assorbe più di quel decimo la carica può non finire mai. È solo un caricabatterie, quindi la protezione da scarica eccessiva e cortocircuiti deve venire dalla cella o da un circuito separato. Ha un ingresso TEMP per il termistore della batteria, ma collegarlo a massa disattiva il controllo, e i moduli più diffusi lo hanno già collegato a massa.

I caricabatterie con gestione del power path alimentano il carico e caricano la cella nello stesso momento. Il BQ24074 di TI lo fa (fino a 1,5 A, con una gestione della potenza in ingresso che riduce l’assorbimento quando la sorgente cede) e ha un ingresso per la temperatura della batteria che sospende la carica fuori dall’intervallo impostato; l’esempio di TI imposta 0–50 °C. Per il solare, il CN3791 di Consonance è un caricabatterie a commutazione per una cella Li-ion, fino a 4 A. Quello che il datasheet chiama MPPT è un punto di lavoro fisso: il chip tiene il pin MPPT a 1,205 V, quindi è il partitore dal pannello a fissare la tensione a cui il pannello lavora, e la scegli una volta per tutte dal datasheet del pannello. Non ha un ingresso per la temperatura della batteria.

Per dimensionare pannello e batteria di un nodo che deve superare l’inverno usa il nostro calcolatore fotovoltaico off-grid.

Sicurezza

• Protezione. Una cella Li-ion o LiPo va protetta da sovraccarica, scarica eccessiva e cortocircuiti, con un circuito integrato nella cella, sulla scheda o in un modulo a parte.
• Polarità. I connettori JST PH a 2 pin delle celle LiPo non hanno una polarità standard: controlla + e − con un multimetro prima di collegare una batteria a una scheda (vedi la nostra pagina sul JST PH).
• Pacchi più grandi. Più celle insieme possono erogare correnti molto alte: metti un BMS e un fusibile sul cavo principale. Il nostro calcolatore pacco batterie ti aiuta a dimensionare il BMS.
• LiFePO4 direttamente sul modulo. Solo con un caricabatterie che si ferma sotto i 3,6 V.