Baterias na ESP32: autonomia, deep sleep e uma bateria que dura anos

Um projeto na mesa do laboratório vive no cabo USB. Mas os projetos mais interessantes saem da mesa: um relógio de pulso com uma ESP32 e uma tela redonda, um sensor de umidade enterrado no vaso, uma estação no telhado, um crachá que mostra o nome do aluno. Todos dependem de uma bateria, e é aí que muita gente descobre que a ESP32, do jeito que se programa na bancada, esvazia uma bateria em poucas horas.

A boa notícia é que a mesma ESP32 consegue funcionar por meses com uma bateria pequena — desde que o programa e a placa sejam pensados para isso. Este artigo mostra os números do consumo da ESP32 em cada modo, que tipo de bateria escolher, como carregar com segurança, como medir a carga com o ADC, como calcular a autonomia antes de montar e, no fim, como tratar a bateria de lítio para que ela dure anos em vez de meses.

Quanto a ESP32 consome

A folha de dados do ESP32, da Espressif, traz uma tabela de consumo por modo de operação. São números do chip, medidos em condições típicas a 3,3 V. A imagem mostra os principais, numa escala em que cada marca vale dez vezes a anterior.

Vale olhar a imagem com calma, porque ela resume tudo o que vem depois:

• o rádio é o vilão: transmitindo Wi-Fi, o chip chega a 240 mA; recebendo, fica entre 95 e 100 mA. Enquanto o Wi-Fi está conectado e ativo, a placa vive nessa faixa;
• a CPU sozinha (o modo que a Espressif chama de modem-sleep, com o rádio desligado) gasta 20 a 68 mA, dependendo da frequência: a 80 MHz, 20 a 31 mA; a 240 MHz, 30 a 68 mA;
• no light-sleep, a CPU para, mas a memória e o estado do programa ficam: 0,8 mA;
• no deep-sleep com o relógio e a memória RTC ligados, o consumo cai para 10 µA — dez milionésimos de ampère;
• na hibernação, só com o relógio RTC, 5 µA.

Do primeiro item ao último, a diferença passa de vinte mil vezes. Uma bateria que dura algumas horas com a placa acordada pode durar meses se a placa dormir quase o tempo todo.

O consumo da placa não é o do chip

Os números acima são do chip ESP32. Uma placa de desenvolvimento como a DevKit V1 tem mais coisas: o regulador que transforma os 5 V da USB em 3,3 V, o conversor USB-serial que conversa com o computador e o LED vermelho de alimentação, sempre aceso. Esses componentes gastam o tempo todo, mesmo com o chip em deep sleep.

Um exemplo de ordem de grandeza: muitas DevKit V1 usam um regulador da família AMS1117 — confira a inscrição no componente de três pernas perto do conector USB. Uma folha de dados de um fabricante desse regulador indica uma corrente própria (quiescente) típica de 3 mA e máxima de 10 mA. Isso é centenas de vezes os 10 µA do chip dormindo. Ou seja: com a DevKit V1, o deep sleep do chip quase não aparece na conta, porque a placa continua gastando miliampères.

A conclusão prática: para bateria, a placa importa tanto quanto o programa. Use a DevKit V1 para aprender e prototipar, e para o projeto final prefira placas pensadas para bateria — com regulador de baixo consumo, sem LED sempre aceso e, de preferência, com carregador embutido —, ou monte o seu circuito. E sempre meça: um multímetro em série com a bateria, na escala de miliampères com a placa acordada e na de microampères com ela dormindo, mostra o consumo real do seu conjunto.

Que bateria escolher

Lítio: Li-ion e LiPo

A escolha mais comum é a bateria de íons de lítio — a cilíndrica 18650, a "bateria de celular" retangular ou a LiPo fininha de relógios e drones. Segundo a Battery University, uma célula de lítio-cobalto típica tem tensão nominal de 3,6 V, chega a 4,20 V carregada e não deve descer abaixo de 2,50 V (o corte de descarga). Ela guarda muita energia num volume pequeno, mas tem duas exigências: precisa de um carregador próprio, que pare exatamente nos 4,2 V, e precisa de proteção contra descarga excessiva, sobrecarga e curto-circuito — muitas baterias e módulos já trazem um pequeno circuito de proteção, e é esse tipo que se deve comprar.

Um detalhe importante para a ESP32: a bateria cheia, com 4,2 V, passa do máximo de 3,6 V que o chip aceita na alimentação. Ela nunca vai direto nos pinos de 3,3 V: precisa de um regulador.

LiFePO4

A bateria de lítio-ferro-fosfato (LiFePO4 ou LFP) tem tensão nominal de 3,2 a 3,3 V, carga completa em 3,65 V e o mesmo corte de 2,50 V. A Battery University indica 2000 ciclos ou mais de vida — contra 500 a 1000 das de lítio-cobalto — e uma temperatura de fuga térmica bem mais alta: 270 °C contra 150 °C. É uma química mais segura e durável, com menos energia por volume.

Sua faixa de tensão é muito próxima da faixa da ESP32 (3,0 a 3,6 V no chip, pela folha de dados), o que tenta muita gente a ligá-la sem regulador. Cuidado: logo depois da carga ela está em 3,65 V, acima do máximo de 3,6 V. Com um regulador de baixa queda, ou com um carregador que pare um pouco antes, a combinação funciona muito bem. Ela também precisa de carregador próprio para LFP — o carregador de Li-ion, que vai até 4,2 V, a sobrecarrega.

Pilhas de botão (CR2032)

A pilha CR2032 é tentadora pelo tamanho, mas não serve para a ESP32 com rádio. Ela guarda cerca de 225 mAh a 3 V, e a ficha técnica da Energizer, citada num estudo de capacidade dessas pilhas, especifica uma descarga contínua de 0,19 mA e pulsos de 6,8 mA por 2 segundos. O Wi-Fi da ESP32 pede 240 mA ao transmitir: dezenas de vezes o pulso permitido. A tensão da pilha despenca e a placa reinicia. A CR2032 serve para segurar o relógio de um módulo RTC, não para alimentar um rádio.

Pilhas alcalinas comuns

Três pilhas AA ou AAA em série somam uma tensão nominal de 4,5 V, acima do que a ESP32 aceita, e por isso também precisam de regulador. Elas não recarregam e perdem tensão aos poucos durante o uso, mas são fáceis de achar e de trocar — uma opção razoável para protótipos e brinquedos.

Carregar com segurança: o TP4056

O módulo carregador mais comum em projetos com ESP32 é o TP4056. Pela folha de dados, ele:

• carrega até 4,2 V, com precisão de 1,5 %, e aceita de 4,0 a 8,0 V na entrada — os 5 V da USB servem;
• tem corrente de carga programável até 1000 mA por um resistor (o RPROG): 1,2 kΩ dá 1000 mA, 2 kΩ dá 580 mA, 5 kΩ dá 250 mA e 10 kΩ dá 130 mA;
• faz uma carga lenta, de cerca de 130 mA com o resistor de 1,2 kΩ, enquanto a bateria está abaixo de 2,9 V, antes de passar à carga normal;
• termina a carga quando a corrente cai a um décimo da corrente programada;
• tem dois pinos de estado para LEDs: um acende carregando e o outro quando a carga termina;
• reduz a corrente sozinho se esquentar demais.

A regra mais importante na hora de escolher o resistor é a corrente de carga. A Battery University recomenda carregar a 1C ou menos, onde 1C é a corrente numericamente igual à capacidade: para uma bateria de 1000 mAh, 1C é 1000 mA; para a LiPo de 200 mAh de um relógio, 1C é 200 mA. O módulo comum vem de fábrica com o resistor de 1,2 kΩ — 1000 mA —, que é cinco vezes o recomendado para essa LiPo pequena. Trocando o resistor por um de 10 kΩ (130 mA), a carga fica abaixo de 1C, mais lenta e muito mais gentil com a bateria.

Prefira os módulos que trazem também o circuito de proteção da bateria (eles têm um chip a mais e duas saídas: uma para a bateria e outra para a carga), ou baterias com proteção embutida.

Medindo a bateria com o ADC

Para o programa saber quanto resta, ele precisa medir a tensão da bateria. O problema é que a Li-ion cheia tem 4,2 V, e os pinos da ESP32 aguentam no máximo 3,6 V. A solução é o divisor de tensão, o mesmo da lição O ECHO tem 5 V: dois resistores iguais em série, e o pino no meio, que fica com metade da tensão — 2,1 V com a bateria cheia, dentro da faixa do ADC com a atenuação de 11 dB.

O valor dos resistores importa. Pela lei de Ohm, o divisor gasta corrente o tempo todo: com dois de 100 kΩ, são 4,2 V ÷ 200 kΩ = 21 µA, o dobro do chip em deep sleep. Resistores maiores gastam menos, mas deixam a medida mais sensível a ruído; é comum colocar um pequeno capacitor entre o pino e o terra para estabilizar a leitura. Outra saída é ligar o divisor por um transistor só na hora de medir.

No simulador, o potenciômetro do circuito da trilha analógica faz o papel do meio do divisor: girar o eixo é como a bateria carregar ou descarregar. O programa lê a tensão várias vezes e tira a média — a técnica da lição média móvel —, multiplica por 2 e estima a carga.

from machine import ADC, Pin
import time

adc = ADC(Pin(34), atten=ADC.ATTN_11DB)
DIVISOR = 2          # dois resistores iguais: o pino vê metade da bateria
CHEIA = 4.20         # Li-ion carregada (Battery University)
VAZIA = 3.40         # o "vazio" do nosso projeto: com folga acima do corte de 2,5 V

def tensao_bateria(amostras=16):
    soma = 0
    for _ in range(amostras):
        soma += adc.read_uv()
        time.sleep_ms(5)
    return soma / amostras / 1_000_000 * DIVISOR

def carga_aproximada(v):
    p = (v - VAZIA) / (CHEIA - VAZIA) * 100
    return max(0, min(100, round(p)))

for i in range(4):
    v = tensao_bateria()
    print('bateria: %.2f V  ~%d %%' % (v, carga_aproximada(v)))
    time.sleep(1)

Com o potenciômetro no meio, o pino recebe cerca de 1,65 V, a "bateria" fica em 3,3 V, e o programa mostra 0 %. Gire o eixo no simulador e rode de novo para ver a carga subir.

Duas ressalvas honestas sobre esse cálculo. Primeiro, a porcentagem é uma aproximação em linha reta: a tensão de uma bateria de lítio não cai em linha reta durante a descarga — ela fica um bom tempo num patamar e despenca no fim. Para uma estimativa melhor, meça a sua bateria descarregando com o seu projeto, anote a tensão a cada hora e monte uma tabela. Segundo, o ADC da ESP32 tem as imprecisões explicadas no artigo O ADC da ESP32; o read_uv(), que usa a calibração, é o mais indicado.

Estado da bateria com histerese

Quando a bateria está perto de um limite, a tensão oscila um pouco a cada leitura — e um aviso de "bateria fraca" que acende e apaga sem parar é irritante. A solução é a histerese: um limite para entrar no estado e outro, um pouco acima, para sair dele. O exemplo roda no simulador com uma lista de leituras e decide entre três estados, no estilo da lição máquina de estados.

leituras = [3.92, 3.71, 3.52, 3.49, 3.51, 3.48, 3.55, 3.62, 3.47, 3.39, 3.41, 3.44]

FRACA = 3.50       # abaixo disto: avisa
SAI_DE_FRACA = 3.60   # só volta ao normal acima disto (a histerese)
DESLIGA = 3.40     # abaixo disto: salva o que precisa e dorme de vez

estado = 'normal'
for v in leituras:
    anterior = estado
    if estado == 'normal' and v < FRACA:
        estado = 'fraca'
    elif estado == 'fraca' and v >= SAI_DE_FRACA:
        estado = 'normal'
    if estado != 'desligar' and v < DESLIGA:
        estado = 'desligar'
    marca = '  <- mudou' if estado != anterior else ''
    print('%.2f V  %s%s' % (v, estado, marca))
    if estado == 'desligar':
        print('salvando os dados e entrando em deep sleep sem prazo')
        break

Repare como 3,51 V e 3,55 V não tiram o estado de "fraca": só 3,62 V, acima do limite de saída, faz isso. Os três números são escolhas do projeto, não constantes da física: dependem da bateria, do regulador e de quanto se quer guardar de folga.

O regulador também decide quando a bateria "acaba"

Um ponto que pega muita gente: com uma bateria de 4,2 V e um regulador de 3,3 V, a placa não funciona até a bateria chegar a 3,3 V. Todo regulador linear precisa de uma diferença mínima entre a entrada e a saída, a chamada queda (dropout). A folha de dados do AMS1117 citada acima indica cerca de 1,3 V de queda a 1 A — com ele, a saída começa a cair muito antes de a bateria esvaziar. Para bateria de lítio, procure reguladores de baixa queda (LDO) e baixa corrente quiescente, ou reguladores chaveados.

Calculando a autonomia antes de montar

A autonomia sai de uma conta simples, mostrada na imagem: primeiro a corrente média do ciclo de acordar e dormir, depois a capacidade usável da bateria dividida por essa média.

O exemplo roda no simulador e compara quatro cenários com a mesma bateria de 1000 mAh. Os números de cada cenário são hipóteses de exemplo: os 120 mA com o rádio ligado ficam entre os 95 a 100 mA de recepção e os 190 a 240 mA de transmissão da tabela; os 10 µA são o deep sleep do chip pela folha de dados; os 3 mA são a corrente típica do regulador AMS1117 citada acima. No seu projeto, troque pelos valores medidos.

def autonomia(capacidade_mah, i_acordada_ma, t_acordada_s, i_dormindo_ma, periodo_s, usavel=0.8):
    t_dormindo = periodo_s - t_acordada_s
    media = (i_acordada_ma * t_acordada_s + i_dormindo_ma * t_dormindo) / periodo_s
    horas = capacidade_mah * usavel / media
    return media, horas

BATERIA = 1000   # mAh

cenarios = [
    ('sempre acordada, Wi-Fi ligado',               120, 600, 0.010, 600),
    ('acorda 3 s a cada 10 min (Wi-Fi), chip ideal', 120,   3, 0.010, 600),
    ('o mesmo, numa placa com regulador de 3 mA',    120,   3, 3.0,   600),
    ('acorda 0,3 s a cada 10 min (ESP-NOW)',        120, 0.3, 0.010, 600),
]

for nome, i_ac, t_ac, i_dorm, periodo in cenarios:
    media, horas = autonomia(BATERIA, i_ac, t_ac, i_dorm, periodo)
    print('%s:' % nome)
    print('   média %.3f mA -> %.0f horas (%.1f dias)' % (media, horas, horas / 24))

O resultado mostra três lições. A placa sempre acordada dura menos de sete horas. Dormindo entre as leituras, a mesma bateria passa a durar perto de dois meses — mas só se a placa não gastar nada além do chip: com um regulador de 3 mA, cai para cerca de nove dias, porque o regulador vira o maior consumo. E acordar por menos tempo (o ESP-NOW, sem conectar a roteador, é um jeito) aumenta muito a conta — a ponto de outros efeitos, como a própria bateria se descarregar sozinha com o tempo e o consumo do circuito de proteção, passarem a ser os limites.

O usavel=0.8 usa só 80 % da capacidade. É uma escolha deliberada, que tem a ver com a próxima seção: não esvaziar a bateria até o fim faz ela durar muito mais ciclos.

Dormindo de verdade: deep sleep e light sleep

O deep sleep é a ferramenta principal. No MicroPython, machine.deepsleep(ms) desliga quase tudo por ms milissegundos; ao acordar, a placa começa do zero, como num reset, e roda o boot.py e o main.py de novo. Para saber se acordou de um sono profundo, o programa olha machine.reset_cause(); para lembrar algo de um ciclo para o outro, usa a memória RTC (até 2048 bytes na ESP32), que sobrevive ao deep sleep — o assunto do artigo guardar dados na ESP32.

import machine
import network

if machine.reset_cause() == machine.DEEPSLEEP_RESET:
    print('acordei de um deep sleep')

# ... mede o sensor, envia, guarda o que precisa ...

wlan = network.WLAN(network.STA_IF)
wlan.active(False)               # rádio desligado antes de dormir
machine.deepsleep(10 * 60_000)   # dorme 10 minutos

Além do tempo, a placa pode acordar por um pino: um botão, um sensor de movimento. Na ESP32 original, o módulo esp32 tem wake_on_ext0(pin, level) para um pino e wake_on_ext1(pins, level) para vários, com os níveis esp32.WAKEUP_ALL_LOW e esp32.WAKEUP_ANY_HIGH. Só alguns pinos podem fazer isso — os ligados ao domínio RTC do chip —, então confira na ficha da placa e no mapa de pinos qual usar. A documentação lembra também que os pinos que não são do domínio RTC são desligados no deep sleep.

import esp32
import machine
from machine import Pin

botao = Pin(33, Pin.IN, Pin.PULL_UP)
esp32.wake_on_ext0(pin=botao, level=esp32.WAKEUP_ALL_LOW)   # acorda quando apertar
machine.deepsleep()                                         # sem prazo: só o botão acorda

O light sleep (machine.lightsleep(ms)) é o meio-termo: com cerca de 0,8 mA no chip, ele mantém a RAM e o programa continua da linha seguinte ao acordar, sem recomeçar. Serve para pausas curtas, em que recomeçar do zero seria mais caro que dormir um pouco menos fundo.

No simulador, deepsleep e lightsleep ainda não são simulados; os trechos acima são para levar à placa.

Outras economias, sem dormir

Nem todo projeto pode dormir. Para os que ficam acordados, há economias menores que somam:

• baixar a frequência da CPU: machine.freq(80_000_000). Pela tabela da folha de dados, o consumo sem rádio cai de 30 a 68 mA (240 MHz) para 20 a 31 mA (80 MHz). O MicroPython da DevKit V1 já começa em 160 MHz;
• desligar o Wi-Fi quando não está em uso (wlan.active(False)) e juntar os envios: conectar uma vez por hora e mandar sessenta leituras gasta muito menos que conectar a cada minuto;
• apagar LEDs que não informam nada e reduzir o brilho de telas;
• trocar time.sleep() dentro de laços por lightsleep() quando nada precisa acontecer na pausa.

O caso do relógio: tela, toque e uma LiPo pequena

Um relógio com ESP32 junta todas as dificuldades: bateria pequena (uma LiPo de poucas centenas de mAh), uma tela colorida com luz de fundo e a expectativa de durar pelo menos um dia. A placa redonda ESP32-2424S012, com ESP32-C3 e tela de 1,28", é um bom exemplo: ela traz conector para bateria, chave liga/desliga e um chip carregador, e a luz de fundo da tela fica ligada ao GPIO3 por um transistor.

As estratégias que funcionam num relógio:

1. a tela é a maior conta: acenda a luz de fundo só quando o usuário olha (um toque, um botão, um movimento do pulso) e apague depois de alguns segundos. Como a luz de fundo está num pino, dá para controlar o brilho com PWM e usar o mínimo legível;
2. dormir entre as interações: com a tela apagada, o relógio pode ficar em light sleep e acordar a cada minuto para atualizar a hora, ou em deep sleep até o toque;
3. Wi-Fi raramente: acertar a hora pela internet uma vez por dia basta; o relógio interno segura o resto;
4. meça o consumo real com a tela acesa e apagada: é a única forma de saber quanto dura a sua combinação de placa, tela e programa.

Fazendo a bateria de lítio durar anos

A capacidade de uma bateria de lítio cai com o uso e com o tempo, e alguns hábitos aceleram ou freiam essa perda. As tabelas a seguir são da Battery University (artigo BU-808).

1. Não esvazie até o fim. A profundidade de descarga muda muito a quantidade de ciclos até a bateria cair para 70 % da capacidade:

Na prática: deixe o programa desligar com folga, antes do corte de 2,5 V, e recarregue com frequência. Cargas parciais não fazem mal — a Battery University é clara em que as baterias de lítio não têm memória e não precisam ser esvaziadas de vez em quando.

2. Carregar até um pouco menos que 4,2 V aumenta a vida. Pela mesma fonte, cada 70 mV a menos na tensão de carga reduz a capacidade em cerca de 10 %, mas aumenta muito os ciclos: a 4,20 V, 300 a 500 ciclos; a 4,06 V, 600 a 1000; a 3,92 V, 1200 a 2000. O TP4056 tem a tensão fixa em 4,2 V, então essa técnica pede outro carregador; o que está ao alcance do programa é não deixar a bateria parada em 4,2 V por longos períodos, que a Battery University aponta como um dos piores cenários.

3. Calor é inimigo. A capacidade que sobra depois de um ano guardada mostra o efeito da temperatura e da carga:

Um relógio esquecido no carro ao sol, ou um sensor dentro de uma caixa preta no telhado, envelhece muito mais rápido.

4. Para guardar, meia carga. A tabela acima mostra que uma bateria guardada com 40 % perde muito menos do que uma guardada cheia. Antes de guardar um projeto por meses, descarregue até perto da metade e desconecte da placa.

5. Carga a 1C ou menos — o assunto do resistor do TP4056 — e nada de carregadores rápidos em baterias pequenas.

Segurança

Bateria de lítio guarda muita energia. Algumas regras não são negociáveis: nunca curto-circuite os fios da bateria; não fure, não amasse e não aqueça; aposente qualquer bateria estufada; carregue sobre uma superfície que não pega fogo e longe de papel e tecido; e use sempre bateria ou módulo com proteção. Num projeto de sala de aula, a bateria fica dentro de uma caixa, presa, com os fios isolados.

Para continuar

A trilha Analógico é a base para medir a bateria: a lição ADC, a de atenuação e a de média móvel. A lição divisor de tensão, da trilha de sensores, mostra o circuito que reduz a tensão para o pino, e a trilha Tempo sem travar ajuda a organizar o programa em estados, como o da histerese.

Os artigos ESP-NOW, que mostra um rádio que acorda e envia rápido, e guardar dados na ESP32, com a memória RTC que atravessa o deep sleep, completam este. Para as placas, veja a ficha da ESP32 DevKit V1, a ficha da ESP32-C3 Super Mini e a ficha do potenciômetro.

Fontes

• Folha de dados do ESP32 (Espressif): consumo por modo (tabela 4-2), consumo do rádio (tabela 5-4) e alimentação de 3,0 a 3,6 V, com fonte de 500 mA ou mais.
• Battery University, BU-808: como prolongar baterias de lítio: profundidade de descarga, tensão de carga, temperatura e armazenamento.
• Battery University, BU-205: tipos de baterias de lítio: tensões, ciclos e fuga térmica do lítio-cobalto e do LiFePO4.
• Folha de dados do TP4056: 4,2 V ±1,5 %, corrente programável, carga lenta abaixo de 2,9 V e término a C/10.
• Capacidade real da CR2032 (Embedded Computing Design): correntes da ficha da Energizer.
• Folha de dados de um AMS1117-3.3: corrente quiescente e queda.
• Documentação do MicroPython: referência rápida da ESP32, módulo esp32 e machine.RTC: deep sleep, despertar por pino e memória RTC.