Alimentar um ESP32 com bateria

Por que uma placa de desenvolvimento descarrega a bateria

Em deep sleep (sono profundo), o chip ESP32 consome cerca de 10 µA, o ESP32-C3 cerca de 5 µA e o ESP32-S3 cerca de 7 µA, segundo a Espressif (nosso comparativo ESP32 traz todos os chips). Uma placa de desenvolvimento acrescenta em volta do chip componentes que nunca dormem:

• O regulador. Muitas placas usam um AMS1117, com corrente quiescente de cerca de 5 mA (até 11 mA): quinhentas vezes o que um ESP32 consome em deep sleep.
• O LED de alimentação. Fica aceso enquanto a placa estiver alimentada. A corrente dele depende do resistor em série; nossa calculadora de resistor para LED faz a conta.
• O chip USB-serial. Nas placas que o alimentam pelos 3,3 V, ele continua ligado, com ou sem cabo USB. O esquema da placa mostra se é o caso.
• Resistores de pull-up, divisores e sensores ligados aos 3,3 V, consumindo dia e noite.

Somados, fazem diferença rápido. A predefinição “ESP32 DevKit sem modificações” da calculadora de autonomia (um AMS1117, mais 3 mA indicativos para o LED e o chip USB-serial) esgotaria uma célula 18650 de 3.000 mAh em cerca de 13 dias, na melhor das hipóteses, enquanto a mesma célula alimenta o módulo avulso do nosso exemplo por cerca de 13 meses. Veja o caso do DevKit na calculadora. E é uma estimativa otimista: a queda do AMS1117 é de cerca de 1 V, então com uma célula Li-ion a linha de 3,3 V cai abaixo dos 3,0 V mínimos do módulo muito antes de a célula se esgotar.

Para um projeto com bateria, use um módulo avulso numa placa própria, ou uma placa feita para baixo consumo cujo fabricante informe o consumo da placa inteira. A Seeed, por exemplo, informa 44 µA em deep sleep para a XIAO ESP32C3 (veja nossa pinagem da XIAO ESP32C3). Tirar o LED e o regulador de uma placa também funciona, mas aí os 3,3 V ficam por sua conta.

Como escolher a bateria

Um módulo ESP32 precisa de 3,0–3,6 V, e 3,6 V é também o seu máximo absoluto. Poucas baterias ficam nessa faixa de cheias a vazias, e é isso que decide se você precisa de um regulador, e de qual tipo.

• Uma célula Li-ion ou LiPo (1S). A escolha mais comum: barata, recarregável e com muita energia. Vai de 4,2 V cheia até cerca de 3,0 V, então precisa de um regulador: um LDO (regulador linear de baixa queda) ou um buck-boost (próxima seção). Use células com circuito de proteção ou acrescente um (veja Segurança).
• Uma célula LiFePO4. Passa quase toda a descarga em torno de 3,2–3,3 V, então pode alimentar o módulo diretamente, sem regulador e sem corrente quiescente. Só que uma carga padrão termina em 3,65 V, acima do máximo de 3,6 V do módulo: limite a carga a menos de 3,6 V e, abaixo de cerca de 3,0 V, mantenha o módulo em reset com um supervisor de tensão (um CI de reset) no EN. Os checklists da Espressif recomendam isso para alimentações que sobem devagar ou são instáveis, como baterias e painéis solares. O supervisor só desliga o módulo: a célula continua precisando de proteção própria contra descarga excessiva (um BMS ou uma placa de proteção). No mesmo tamanho, guarda menos energia que uma Li-ion.
• Três pilhas AA. Alcalinas novas dão cerca de 4,5 V, e os testes do datasheet vão até 0,8 V por pilha, 2,4 V no total; as NiMH vão de cerca de 4,2 V recém-carregadas até 2,7 V. Nenhuma fica na faixa: use um buck-boost.
• Baterias tipo moeda (CR2032). Não servem para o rádio do ESP32: a Renata especifica a sua CR2032 para 3 mA contínuos, enquanto a Espressif pede uma alimentação capaz de fornecer 500 mA. A nota da TI sobre baterias tipo moeda e corrente de pico aponta um capacitor em paralelo como a forma mais eficaz de ajudá-las nos picos curtos dos rádios feitos para elas, e esses picos ainda ficam muito abaixo do que um ESP32 puxa.
• Lítio-cloreto de tionila (Li-SOCl₂). Autodescarga baixíssima, boa para sensores que acordam raramente durante anos. Mas uma Saft LS14500 (tamanho AA) é especificada para 50 mA contínuos e pulsos de 250 mA, então para o Wi-Fi é preciso um capacitor que forneça os picos; a própria Saft avisa que ele pode ser necessário. Depois de um período armazenada, uma camada de passivação aumenta a resistência: num teste da Qoitech, uma célula armazenada passava de 100 Ω e tinha quedas de tensão de até 1,8 V nos primeiros pulsos. Além disso, a tensão em aberto, 3,67 V, fica um pouco acima do máximo do módulo.

Nosso comparativo de baterias tem os detalhes de cada química, e a tabela de tensão de baterias converte uma tensão medida na carga que resta.

O regulador: pouca corrente quiescente, corrente suficiente para o Wi-Fi

Em deep sleep, a corrente quiescente do próprio regulador muitas vezes pesa mais que o chip. Durante uma transmissão Wi-Fi é o contrário: os guias de projeto de hardware da Espressif pedem uma alimentação de 3,3 V que forneça no mínimo 500 mA. Um regulador para um nó com bateria precisa das duas coisas.

Corrente quiescente típica e corrente de saída nominal dos datasheets, os mesmos valores da nossa calculadora de reguladores.

O MCP1700 e o HT7333 são populares pela corrente quiescente minúscula, mas com 250 mA são especificados para metade do que a Espressif pede. O TLV755P e o AP2112K atendem a essa exigência consumindo algumas dezenas de microampères. Só que o TLV755P não tem folga: é especificado para exatamente 500 mA e, nessa corrente, a queda dele pode chegar a 238 mV, então nos picos do Wi-Fi ele para de regular assim que a célula fica abaixo de cerca de 3,54 V. Para ter mais folga, escolha o AP2112K, especificado para 600 mA, e com qualquer um dos dois coloque o capacitor de reserva que a Espressif recomenda (veja abaixo).

Com uma célula Li-ion, um LDO para de regular quando a célula cai para 3,3 V mais a queda (dropout) do regulador e, a partir daí, entrega a tensão da célula menos a queda. O módulo funciona até 3,0 V e, pela nossa tabela de tensão de baterias, uma célula Li-ion em repouso a 3,6 V tem só cerca de 7% de carga (0–40% conforme as tabelas dos fabricantes), então um bom LDO aproveita quase toda a bateria. Nos picos do Wi-Fi a tensão da célula diminui e a queda do regulador aumenta, por isso a autonomia acaba um pouco antes do que a tensão em repouso indica; nesse ponto, um supervisor no EN ajustado para cerca de 3,0 V, como a Espressif recomenda, mantém o módulo em reset enquanto a tensão estiver baixa demais. Um buck-boost como o TPS63802 mantém 3,3 V com a bateria tanto acima quanto abaixo desse valor, e é a escolha certa para três pilhas AA, que começam acima de 3,6 V e terminam abaixo de 3,0 V.

Confira um regulador com a sua bateria (queda, aquecimento e corrente quiescente); neste exemplo, um TLV755P com uma célula Li-ion.Abrir a calculadora de reguladores

Capacitores: os guias de projeto da Espressif recomendam pelo menos 10 µF na entrada de alimentação e 0,1 µF perto dos pinos de alimentação do chip. Com uma bateria que não consegue fornecer os picos sozinha, como uma Li-SOCl₂, quem fornece é um capacitor.

Deep sleep na prática

Em deep sleep, as CPUs, a maior parte da RAM e os periféricos digitais ficam desligados, assim como o Wi-Fi e o Bluetooth; o controlador RTC e a memória RTC continuam ligados. Ao acordar, o programa recomeça do início, então no Arduino tudo acontece no setup().

Fontes de despertar

• Timer, em todos os chips: o timer RTC acorda o chip depois de um tempo definido.
• Pinos. O ESP32 e o ESP32-S3 acordam por um pino RTC num nível definido (ext0) ou por vários (ext1). O ESP32-C3 só acorda pelos pinos do seu domínio de alimentação RTC, GPIO0–5, ativados com esp_deep_sleep_enable_gpio_wakeup() (veja nossa pinagem da ESP32-C3 SuperMini).
• Pads de toque, no ESP32 e no ESP32-S3.
• O coprocessador ULP, no ESP32 e no ESP32-S3: um núcleo pequeno que pode ler um sensor enquanto as CPUs principais dormem e acordá-las quando algo acontece.

Guardar dados durante o sono

As variáveis comuns se perdem a cada despertar. Declare as de que você precisa com RTC_DATA_ATTR: elas ficam na memória RTC, que por padrão continua alimentada em deep sleep.

Arduino-ESP32

#define SLEEP_MINUTES 15

RTC_DATA_ATTR int bootCount = 0;   // guardado na memória RTC

void setup() {
  bootCount++;
  // ler o sensor, conectar, enviar os dados...
  esp_sleep_enable_timer_wakeup(SLEEP_MINUTES * 60ULL * 1000000ULL);  // microssegundos
  esp_deep_sleep_start();          // não retorna
}

void loop() {}                     // nunca é executado

O código foi escrito para o Arduino-ESP32 3.x, cuja série estável 3.3 é baseada no ESP-IDF 5.5. O timer recebe microssegundos, daí a conversão. Para acordar por um pino, o ESP32 e o ESP32-S3 usam esp_sleep_enable_ext0_wakeup(pin, level); depois do reinício, esp_sleep_get_wakeup_cause() informa por que o chip acordou. No ESP-IDF 6, base do Arduino-ESP32 4.x, essa função foi marcada como obsoleta em favor de esp_sleep_get_wakeup_causes(), que devolve todas as fontes de despertar num mapa de bits, e a esp_deep_sleep_enable_gpio_wakeup() do ESP32-C3 foi substituída por esp_sleep_enable_gpio_wakeup_on_hp_periph_powerdown().

ESPHome

deep_sleep:
  run_duration: 10s
  sleep_duration: 15min

run_duration é quanto tempo o nó fica acordado, e sleep_duration quanto tempo dorme; no ESP32, wakeup_pin acrescenta um pino de despertar. Nosso gerador de configuração ESPHome pode acrescentar esse bloco, e um IP fixo, para você.

Os pinos durante o sono

Um pino que tem de manter o nível enquanto o chip dorme, como o gate de um MOSFET que deixa um sensor desligado, precisa de um hold: gpio_hold_en() antes de dormir e gpio_hold_dis() depois de acordar. No ESP32, no ESP32-C3 e no ESP32-S3, isso basta apenas para os pinos RTC: os que ficam fora do domínio RTC (GPIO1, 3, 5, 16–19 e 21–23 no ESP32, do GPIO6 em diante no ESP32-C3 e do GPIO22 em diante no ESP32-S3) precisam também de gpio_deep_sleep_hold_en(). Fique de olho também na corrente que passa por pull-ups e divisores. O exemplo da própria Espressif é o GPIO12 do ESP32-WROVER, com pull-up externo e pull-down interno: ele vaza corrente até você isolá-lo com rtc_gpio_isolate() antes de dormir.

Encurtar o tempo acordado

No exemplo, o Wi-Fi responde pela maior parte da corrente média, então cada segundo economizado com o chip acordado conta:

• Um IP fixo. Pula o DHCP; a documentação do ESPHome diz que ele “can dramatically improve connection times” (pode encurtar bastante o tempo de conexão). No Arduino, chame WiFi.config(ip, gateway, subnet, dns) antes de WiFi.begin().
• Lembrar do ponto de acesso. WiFi.begin(ssid, password, channel, bssid) aceita o canal e o BSSID que você guardou na memória RTC depois da primeira conexão. O fast_connect do ESPHome pula a varredura inicial e também guarda o BSSID e o canal.
• ESP-NOW em vez de Wi-Fi e MQTT. O ESP-NOW é o protocolo sem conexão da Espressif: sem ponto de acesso, sem endereço IP, sem broker. Os pacotes levam até 250 bytes (1.470 com o ESP-NOW v2), e transmissor e receptor precisam estar no mesmo canal. Um ESP32 ligado na tomada pode receber os dados e repassá-los ao MQTT.
• Alimentar os sensores só quando necessário. Alimente um sensor por um GPIO se ele consumir pouco, ou chaveie a alimentação dele com um MOSFET; nossa calculadora de transistor como chave confere o componente. Conte também o tempo de inicialização do sensor na fase acordada.

Não citamos tempos de conexão: eles dependem do ponto de acesso e da rede. Meça os seus, como explicado a seguir.

Medir a corrente do jeito certo

Um multímetro em série serve para a corrente de deep sleep, com duas ressalvas. O shunt dele provoca uma queda de tensão (burden voltage) que, nas escalas de microampère, pode bastar para deixar a placa sem tensão suficiente quando ela acorda; e ele mostra uma leitura lenta, que não acompanha rajadas de Wi-Fi de uma fração de segundo.

Instrumentos feitos para isso:

• Nordic Power Profiler Kit II (PPK2): mede de 200 nA a 1 A a 100.000 amostras por segundo, e pode ele mesmo alimentar a placa com 0,8–5 V.
• Joulescope JS220: amostra corrente e tensão juntas a 2 milhões de amostras por segundo, com resolução de até 0,5 nA.
• EEVblog µCurrent GOLD: um adaptador que transforma um multímetro num amperímetro de baixa queda, 1 mV por nA, µA ou mA.

Seja qual for o instrumento, meça a média em pelo menos um ciclo completo, com sono e despertar incluídos, alimente a placa com a tensão da bateria que você vai usar de verdade e desconecte o USB, que alimenta a placa por outro caminho.

Monitorar a tensão da bateria

Uma célula Li-ion (4,2 V cheia) passa do que o ADC consegue ler, então use um divisor. Com 1 MΩ + 1 MΩ, o divisor corta a tensão pela metade e puxa 2,1 µA de uma célula cheia. Acrescente um capacitor de 100 nF entre o pino do ADC e o terra, para o ADC enxergar uma fonte de baixa impedância enquanto amostra. Para o divisor não consumir nada durante o sono, faça o chaveamento pelo lado alto: um MOSFET canal P entre a célula e o divisor, acionado por um GPIO através de um MOSFET canal N pequeno. Um MOSFET canal N no lado do terra sozinho não serve: desligado, ele deixa o resistor de cima puxar o pino do ADC para a tensão da célula, 4,2 V com ela cheia, acima do limite de 3,6 V do chip; e um MOSFET canal P acionado direto por um GPIO de 3,3 V não desliga por completo com 4,2 V no source. Nossa calculadora de transistor como chave confere os dois componentes.

Veja na nossa calculadora: 1 MΩ + 1 MΩ de uma célula Li-ion cheia para um ESP32-C3.Abrir o divisor de tensão

Mantenha a saída do divisor dentro da faixa em que o ADC é especificado: até cerca de 2,45 V no ESP32 e 2,5 V no ESP32-C3 com a atenuação máxima, segundo os datasheets da Espressif. No Arduino, analogReadMilliVolts() devolve uma leitura calibrada em milivolts. No ESP32 use um pino do ADC1: o ADC2 não pode ser lido de forma confiável com o Wi-Fi ligado. Depois, converta a tensão em nível de carga com a nossa tabela de tensão de baterias; com uma LiFePO4, no meio da descarga a tensão diz pouco.

Um exemplo completo

Um nó sensor com um módulo ESP32-C3 avulso, um buck-boost TPS63802 e uma célula Li-ion 18650 de 3.000 mAh, que acorda a cada 15 minutos para enviar uma leitura por Wi-Fi:

Os valores da fase acordada são os indicativos da calculadora: troque-os pelos que você medir.

A corrente média fica em cerca de 270 µA, o que dá cerca de 13 meses. A maior fatia é do Wi-Fi, e depois da autodescarga da própria célula; o deep sleep é quase desprezível.

Acordando uma vez por hora, a média cai para cerca de 142 µA, a bateria dura cerca de 2 anos (veja na calculadora) e a maior fatia passa a ser a autodescarga. A mesma célula num DevKit sem modificações dura, na melhor das hipóteses, cerca de 13 dias.

Uma ressalva: a calculadora modela um regulador linear, em que a bateria fornece a corrente do circuito mais a corrente quiescente do regulador. Um buck-boost como o TPS63802 transfere potência: a corrente da bateria é a corrente do circuito × 3,3 V ÷ (tensão da bateria × eficiência). Com cerca de 90% de eficiência (o valor que a nossa calculadora de reguladores adota para o TPS63802), a 3,7 V, a tensão nominal de uma célula Li-ion, a bateria fornece mais ou menos a mesma corrente do circuito; um pouco menos com a célula cheia e cerca de um quinto a mais perto de 3,0 V, então para este exemplo a estimativa se sustenta. Com três pilhas AA perto do fim da descarga, por volta de 2,7 V, a bateria fornece cerca de um terço a mais do que o circuito consome.

Abra o exemplo na calculadora de autonomia e depois troque os valores indicativos pelas correntes que você mediu.Abrir a calculadora de autonomia

Recarga e energia solar

O onipresente TP4056 carrega uma célula Li-ion com até 1 A e até 4,2 V, e encerra a carga quando a corrente cai para um décimo do valor ajustado. Ele não tem power path: durante a carga o ESP32 fica ligado à célula e, se consumir mais que esse décimo, a carga pode nunca terminar. É só um carregador, então a proteção contra descarga excessiva e curto-circuito tem que vir da célula ou de um circuito separado. Ele tem uma entrada TEMP para o termistor da bateria, mas ligá-la ao terra desativa a verificação, e os módulos mais comuns já vêm com ela ligada ao terra.

Carregadores com gerenciamento de power path alimentam o circuito e carregam a célula ao mesmo tempo. O BQ24074 da TI faz isso (até 1,5 A, com gerenciamento da potência de entrada que recua quando a fonte cede) e tem uma entrada de temperatura da bateria que suspende a carga fora da sua faixa; o exemplo da TI define 0–50 °C. Para energia solar, o CN3791 da Consonance é um carregador chaveado para uma célula Li-ion, de até 4 A. O que ele chama de MPPT é um ponto de trabalho fixo: o chip mantém o pino MPPT em 1,205 V, então é o divisor a partir do painel que define a tensão em que o painel trabalha, escolhida uma vez só com base no datasheet do painel. O CN3791 também não tem entrada de temperatura da bateria.

Para dimensionar o painel e a bateria de um nó que precisa atravessar o inverno, use nossa calculadora solar off-grid.

Segurança

• Proteção. Uma célula Li-ion ou LiPo precisa de proteção contra sobrecarga, descarga excessiva e curto-circuito, na célula, na placa ou num módulo separado.
• Polaridade. Os conectores JST PH de 2 pinos das células LiPo não têm polaridade padrão: confira + e − com um multímetro antes de ligar uma bateria a uma placa (veja nossa página do JST PH).
• Packs maiores. Várias células juntas podem fornecer correntes muito altas: coloque um BMS e um fusível no cabo principal. Nossa calculadora de pack de baterias dá a corrente do BMS.
• LiFePO4 direto no módulo. Só com um carregador que pare abaixo de 3,6 V.