Como Otimizar o Consumo de Energia do Meu Projeto ESP32/ESP8266 para Durar Meses a Pilhas? Guia Completo

Os microcontroladores ESP32 e ESP8266 revolucionaram o mundo do IoT (Internet of Things) e dos projetos DIY (Do It Yourself) devido ao seu baixo custo, conectividade Wi-Fi integrada e poder de processamento. No entanto, um dos maiores desafios ao criar dispositivos autónomos baseados nestas plataformas é a gestão da energia. Alimentar um ESP32 ou ESP8266 diretamente a pilhas e esperar que dure semanas, ou até meses, pode parecer uma tarefa hercúlea, dado o seu consumo relativamente elevado quando em pleno funcionamento.

Felizmente, com as estratégias certas de hardware e software, é perfeitamente possível alcançar uma autonomia impressionante. Este guia completo irá explorar em profundidade as técnicas e os truques necessários para otimizar drasticamente o consumo de energia do seu projeto ESP32 ou ESP8266, permitindo-lhe funcionar durante meses com um único conjunto de pilhas ou bateria.

1. Compreender o Consumo de Energia: Onde Vai a Energia?

Antes de otimizar, é crucial entender onde a energia é consumida num sistema ESP32/ESP8266:

CPU (Unidade Central de Processamento): O "cérebro" do microcontrolador. Quanto mais rápido funciona e quanto mais tempo está ativo, mais energia consome.
Rádio Wi-Fi e Bluetooth (ESP32): A conectividade sem fios é, de longe, um dos maiores consumidores de energia. Estabelecer uma ligação, transmitir dados e até mesmo apenas procurar redes consome picos significativos de corrente.
Periféricos Internos: Memória Flash, RAM, conversores Analógico-Digital (ADC), Digital-Analógico (DAC), interfaces de comunicação (SPI, I2C, UART), etc.
Periféricos Externos: Sensores, ecrãs (displays), LEDs, atuadores (motores, relés) ligados ao ESP.
Componentes da Placa de Desenvolvimento: Muitas placas de desenvolvimento (como as populares NodeMCU ou Wemos D1 Mini para ESP8266, ou as DevKitC para ESP32) incluem componentes adicionais que consomem energia mesmo quando o ESP está em modos de baixo consumo. Os principais culpados são:Regulador de Voltagem (LDO): Converte a tensão de entrada (ex: 5V do USB ou da pilha) para os 3.3V necessários pelo ESP. Muitos LDOs comuns têm uma corrente quiescente (consumo próprio) relativamente alta.
Chip USB-Serial (ex: CP2102, CH340): Permite a comunicação e programação via USB, mas consome energia constantemente quando alimentado.
LEDs de Power e Status: Embora consumam pouco individualmente, estão sempre ligados e contribuem para o consumo total em standby.

2. Modos de Baixo Consumo: A Chave para a Longevidade

Tanto o ESP8266 como o ESP32 foram desenhados com modos de baixo consumo em mente. Utilizar estes modos é a estratégia mais importante para prolongar a vida útil da bateria.

Modos Comuns (Conceitos Gerais):

Modo Ativo: O microcontrolador está totalmente operacional, CPU a funcionar, rádio ligado (se necessário). Consumo mais elevado (dezenas a centenas de mA).
Modem Sleep (ESP8266/ESP32): A CPU está ativa, mas o rádio Wi-Fi/Bluetooth está desligado ou num estado de baixo consumo. Útil quando se precisa de processamento contínuo sem comunicação constante. Consumo reduzido (alguns mA a dezenas de mA).
Light Sleep (ESP32): A CPU é pausada, a memória RAM retém o seu conteúdo, e os periféricos podem ser configurados para acordar o sistema. O relógio principal é desligado. Consumo significativamente mais baixo (centenas de µA a poucos mA). O rádio pode ser desligado.
Deep Sleep (ESP8266/ESP32): Este é o modo de eleição para máxima poupança de energia. Quase tudo é desligado, incluindo a CPU e a maior parte da RAM. Apenas o RTC (Real-Time Clock) e, no caso do ESP32, a memória RTC e o co-processador ULP (Ultra Low Power) podem permanecer ativos. O consumo pode cair para a ordem dos microamperes (µA).

Deep Sleep: O Herói da Poupança de Energia

No modo Deep Sleep, o ESP desliga quase completamente. Para voltar a funcionar (acordar), precisa de um gatilho externo ou interno:

Timer Wake-up: O RTC pode ser programado para acordar o ESP após um período de tempo definido (segundos, minutos, horas). Este é o método mais comum para tarefas periódicas (ex: ler um sensor a cada 10 minutos).
External Wake-up (GPIO): Um ou mais pinos GPIO podem ser configurados para acordar o ESP quando o seu estado lógico muda (ex: um botão premido, um sensor de movimento ativado).
Touch Wake-up (ESP32): Os pinos capacitivos do ESP32 podem ser usados para acordar o sistema.
ULP Co-processor Wake-up (ESP32): O co-processador ULP pode executar código simples enquanto o CPU principal dorme e acordá-lo quando certas condições são cumpridas.

Como Implementar Deep Sleep (Exemplos Arduino IDE):

ESP8266:

C++ 
// Definir o tempo de sono em microsegundos (ex: 10 minutos = 600 segundos)
#define SLEEP_DURATION_US 600 * 1000000 // 10 minutos * 1,000,000 us/s

void setup() {
Serial.begin(115200);
Serial.println("A acordar do Deep Sleep...");

// --- O seu código de leitura de sensor, ligação Wi-Fi, envio de dados ---
Serial.println("A realizar tarefas...");
delay(2000); // Simula trabalho
Serial.println("Tarefas concluídas. A entrar em Deep Sleep...");
// --- Fim do seu código ---

// Ligar o pino RST ao GPIO16 (D0 em muitas placas NodeMCU) para permitir o wake-up por timer
// O argumento 0 significa que o rádio Wi-Fi será desligado antes de dormir
ESP.deepSleep(SLEEP_DURATION_US, WAKE_RF_DISABLED);
// O código após deepSleep() normalmente não é executado, pois o ESP reinicia ao acordar.
}

void loop() {
// O loop fica vazio, pois o ESP reinicia a cada ciclo de sono/despertar.
}

Nota: Para o wake-up por timer no ESP8266, é essencial ligar fisicamente o pino RST ao pino GPIO16 (marcado como D0 em muitas placas NodeMCU/Wemos).

ESP32:

C++ 
#include "esp_sleep.h" // Necessário para funções de sono avançadas

// Definir o tempo de sono em microsegundos (ex: 5 minutos = 300 segundos)
#define SLEEP_DURATION_US 300 * 1000000ULL // Usar ULL para unsigned long long

// Definir um pino para acordar por toque (ex: T0 = GPIO4)
#define TOUCH_WAKEUP_PIN T0

// Definir um pino para acordar por sinal externo (ex: GPIO33)
#define EXT_WAKEUP_PIN GPIO_NUM_33

void setup() {
Serial.begin(115200);
Serial.println("A acordar...");

// Verificar a causa do despertar
esp_sleep_wakeup_cause_t wakeup_reason = esp_sleep_get_wakeup_cause();

switch(wakeup_reason) {
case ESP_SLEEP_WAKEUP_TIMER:
Serial.println("Acordou pelo Timer");
break;
case ESP_SLEEP_WAKEUP_EXT0: // Se configurado para EXT0
Serial.println("Acordou pelo pino EXT0");
break;
case ESP_SLEEP_WAKEUP_EXT1: // Se configurado para EXT1
Serial.println("Acordou por um dos pinos EXT1");
// Pode verificar qual pino causou o despertar com esp_sleep_get_ext1_wakeup_status()
break;
case ESP_SLEEP_WAKEUP_TOUCHPAD:
Serial.println("Acordou por Touch Pad");
break;
case ESP_SLEEP_WAKEUP_ULP:
Serial.println("Acordou pelo ULP Co-processor");
break;
default:
Serial.printf("Acordou por outra razão: %d\n", wakeup_reason);
break;
}

// --- O seu código de leitura de sensor, ligação Wi-Fi, envio de dados ---
Serial.println("A realizar tarefas...");
// Exemplo: Ligar Wi-Fi, enviar dados, desligar Wi-Fi
delay(2000); // Simula trabalho
Serial.println("Tarefas concluídas. A configurar fontes de despertar e entrar em Deep Sleep...");
// --- Fim do seu código ---

// Configurar o Timer como fonte de despertar
esp_sleep_enable_timer_wakeup(SLEEP_DURATION_US);
Serial.printf("A dormir por %llu microsegundos...\n", SLEEP_DURATION_US);

// Configurar wake-up por pino externo (EXT0 - um único pino)
// ESP_SLEEP_WAKEUP_EXT0_HIGH -> acorda se o pino estiver ALTO
// ESP_SLEEP_WAKEUP_EXT0_LOW -> acorda se o pino estiver BAIXO
// esp_sleep_enable_ext0_wakeup(EXT_WAKEUP_PIN, ESP_SLEEP_WAKEUP_EXT0_LOW); // Exemplo: acorda se pino for LOW

// Configurar wake-up por pinos externos (EXT1 - múltiplos pinos)
// uint64_t ext1_pin_mask = (1ULL << GPIO_NUM_32) | (1ULL << GPIO_NUM_33); // Exemplo: Pinos 32 e 33
// esp_sleep_enable_ext1_wakeup(ext1_pin_mask, ESP_EXT1_WAKEUP_ANY_HIGH); // Acorda se qualquer um dos pinos selecionados ficar ALTO

// Configurar wake-up por Touch Pad
// touchAttachInterrupt(TOUCH_WAKEUP_PIN, [](){ /* callback vazio */ }, 40); // Ajustar threshold (40)
// esp_sleep_enable_touchpad_wakeup();

// Entrar em Deep Sleep
esp_deep_sleep_start();
}

void loop() {
// O loop fica vazio ou pode conter código que só executa se não entrar em deep sleep no setup
}

Importante: Quando o ESP acorda do Deep Sleep, ele reinicia. O seu código no setup() será executado novamente. Variáveis globais não retêm o seu valor, a menos que sejam armazenadas na memória RTC (uma pequena quantidade de RAM que sobrevive ao Deep Sleep).

C++ 
// Exemplo de variável na memória RTC (persistente durante Deep Sleep)
RTC_DATA_ATTR int bootCount = 0;

void setup() {
bootCount++;
Serial.begin(115200);
Serial.printf("Número de arranques: %d\n", bootCount);
// ... resto do código ...
esp_deep_sleep_start();
}

void loop() { }

3. Otimização de Hardware: Escolhas Inteligentes

O software é crucial, mas o hardware também desempenha um papel fundamental.

Escolha da Placa:

Evite Placas de Desenvolvimento Padrão: Se a longevidade da bateria é crítica, evite usar placas como NodeMCU ou ESP32 DevKitC diretamente no projeto final. Os seus reguladores de voltagem e chips USB-Serial consomem energia preciosa em standby (muitas vezes na ordem dos mA, o que esgota rapidamente uma pilha).
Placas Otimizadas: Procure placas especificamente desenhadas para baixo consumo (ex: algumas da Lolin/Wemos, FireBeetle ESP32, placas da Unexpected Maker, etc.) que usam reguladores mais eficientes e permitem desligar ou remover facilmente componentes desnecessários.
Módulo ESP "Puro": Para o controlo máximo, use o módulo ESP32 ou ESP8266 diretamente (ex: ESP-WROOM-32, ESP-12F) e construa o seu próprio circuito de suporte mínimo.

Regulador de Voltagem (LDO vs. Buck/Boost Converter):

LDOs (Low-Dropout Regulators): Simples e baratos, mas muitas vezes ineficientes, especialmente com grandes diferenças entre a tensão de entrada e saída (3.3V). A corrente quiescente (Iq) é crucial – procure LDOs com Iq na ordem dos microamperes (µA) ou até nanoamperes (nA) (ex: MCP1700, HT7333 - verificar sempre a datasheet!).
Buck Converters (Step-Down): Mais eficientes que LDOs, especialmente com tensões de entrada mais altas (ex: pilhas Li-Ion de 3.7V/4.2V). Convertem a tensão "cortando-a" rapidamente. A eficiência pode chegar a >90%.
Boost Converters (Step-Up): Necessários se a tensão da pilha for inferior a 3.3V (ex: duas pilhas AA de 1.5V = 3V). Também podem ser bastante eficientes.
Buck-Boost Converters: Podem aumentar ou diminuir a tensão, úteis para pilhas cuja tensão varia significativamente durante a descarga (como Li-Ion).
Consideração: Conversores Buck/Boost são mais complexos e podem introduzir ruído elétrico, mas para baixo consumo, a sua eficiência geralmente compensa. Procure modelos com bons modos de baixo consumo (PFM/PWM automático). Exemplos: TPS63031 (buck-boost), TPS6274x (buck).

Remover/Desativar Componentes Desnecessários:

LED de Power: Dessolde-o ou corte a sua ligação.

LED de Status (GPIO): Use-o apenas para depuração, remova-o no design final ou desligue-o por software (pinMode(LED_BUILTIN, INPUT); pode ajudar a reduzir fugas).
Chip USB-Serial: Se a sua placa o permitir, dessolde-o ou encontre uma forma de cortar a sua alimentação (algumas placas têm jumpers para isso). Essencial para atingir consumos em µA.
Seleção de Sensores e Periféricos:

Escolha sensores com baixo consumo em standby ou que possam ser desligados completamente.

Sensores I2C ou SPI são geralmente preferíveis a sensores analógicos que podem requerer divisores de tensão (que consomem corrente constantemente).
Se precisar de um ecrã, considere e-Paper (e-Ink), que só consomem energia ao atualizar a imagem. Ecrãs OLED/LCD consomem muito mais.

Gestão da Alimentação de Periféricos:

Use um pino GPIO do ESP para controlar a alimentação de sensores/módulos externos através de um MOSFET (P-channel para high-side switching, N-channel para low-side switching) ou um LDO com pino de Enable. Ligue a alimentação do periférico apenas quando precisar de o ler, e desligue-a antes de entrar em Deep Sleep.

Seleção da Bateria/Pilhas:

Li-Ion / LiPo (Lítio-Ion / Polímero de Lítio): Alta densidade energética, recarregáveis. Tensão nominal ~3.7V (varia de ~4.2V carregada a ~3.0V descarregada). Requerem circuitos de proteção. Boa opção, mas a tensão pode ser um pouco alta para alimentar diretamente alguns ESPs (embora muitos funcionem) e pode requerer um LDO ou Buck eficiente.
LiFePO4 (Fosfato de Ferro-Lítio): Tensão nominal mais baixa (~3.2V, varia de ~3.6V a ~2.8V), muito seguras, longa vida útil (ciclos). Excelente opção para alimentar diretamente ESPs (dentro da faixa de tensão recomendada) ou com LDOs de baixo dropout.
Pilhas Alcalinas (AA/AAA): Baratas, disponíveis em todo o lado. Tensão nominal 1.5V. Precisará de 3 em série (4.5V) com um bom LDO/Buck, ou talvez 2 (3V) com um Boost converter (a tensão cai rapidamente sob carga). Auto-descarga moderada.
Pilhas de Lítio Primárias (Não recarregáveis - ex: AA Lítio, CR123A, CR2032): Excelente densidade energética, longa vida útil (shelf life de anos), bom desempenho a baixas temperaturas. Tensão inicial pode ser alta (ex: AA Lítio ~1.8V, CR123A ~3V). Ótimas para implementações de longa duração onde a recarga não é opção. CR2032 (3V) tem capacidade limitada, adequada apenas para consumos extremamente baixos (Deep Sleep na ordem de poucos µA).
Capacidade (mAh/Ah): Escolha uma capacidade adequada ao consumo esperado e à duração desejada. Lembre-se: Duração (horas) ≈ Capacidade da Bateria (mAh) / Consumo Médio (mA).

4. Otimização de Software: Código Eficiente

Além do Deep Sleep, outras otimizações de software são importantes:

Gestão do Wi-Fi/Bluetooth:

Ligar Apenas Quando Necessário: O ciclo ideal é: Acordar -> Ler Sensores -> Ligar Wi-Fi -> Conectar -> Enviar Dados -> Desconectar Wi-Fi -> Entrar em Deep Sleep.
Minimizar Tempo de Ligação: Otimize o processo de conexão e transmissão. Use IPs estáticos se possível para acelerar a conexão à rede.
Desligar Explicitamente: Após a transmissão, desligue o rádio:C++ 
#include <WiFi.h> // Para ESP32 ou ESP8266
#ifdef ESP32
#include <esp_bt.h>
#include <esp_bt_main.h>
#endif

// ... código de conexão e envio ...

WiFi.disconnect(true); // true = desliga também o Wi-Fi station mode
WiFi.mode(WIFI_OFF); // Desliga completamente o hardware Wi-Fi
Serial.println("Wi-Fi desligado.");

#ifdef ESP32
// Desligar Bluetooth no ESP32 se não for necessário
btStop(); // Parar o controller Bluetooth
esp_bt_controller_disable(); // Desabilitar o controller
esp_bluedroid_disable(); // Desabilitar Bluedroid stack
esp_bluedroid_deinit(); // Desinicializar Bluedroid stack
esp_bt_controller_deinit(); // Desinicializar o controller
Serial.println("Bluetooth desligado.");
#endif

// ... entrar em Deep Sleep ...

Protocolos Eficientes: MQTT (com QOS 0) é geralmente mais leve que HTTP POST/GET para envio de pequenos pacotes de dados. Considere CoAP.
Redução da Frequência da CPU (Principalmente ESP32):

O ESP32 pode ajustar a sua frequência de CPU dinamicamente. Se não precisar da performance máxima (240MHz ou 160MHz), reduza-a para poupar energia durante o tempo em que está ativo.
Use setCpuFrequencyMhz(80); ou setCpuFrequencyMhz(40); ou até setCpuFrequencyMhz(10); (verificar compatibilidade com periféricos como Wi-Fi) no início do seu setup(). Lembre-se que isto afeta a velocidade de execução e a temporização (ex: delay()).
C++ 
#include "soc/soc.h" // Para constantes de frequência
#include "soc/rtc_cntl_reg.h" // Para registos RTC

void setup() {
// Tentar definir para 80MHz (padrão é geralmente 240 ou 160)
// Outras opções comuns: 240, 160, 80. Menos comuns: 40, 20, 10.
if (setCpuFrequencyMhz(80)) {
Serial.println("Frequência da CPU definida para 80MHz");
} else {
Serial.println("Falha ao definir frequência da CPU.");
}

// Desativar Brownout Detector (BOD) pode poupar um pouco, mas CUIDADO:
// O BOD evita que o ESP se comporte erraticamente com baixa voltagem.
// Desative apenas se tiver uma fonte de alimentação muito estável e souber os riscos.
// WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0); // DESATIVAR BOD -> Usar com extrema cautela!

Serial.begin(115200);
// ... resto do setup ...
}

Código Eficiente:

Evite delay() longos quando o microcontrolador precisa de estar ativo. Use millis() para tarefas não bloqueantes se precisar de atividade contínua (embora para ultra-baixo consumo, o objetivo seja dormir o máximo possível).
Otimize algoritmos e loops.
Use interrupções em vez de polling (verificação constante) sempre que possível para detetar eventos enquanto o CPU faz outras coisas ou está em Light Sleep.
Gestão de Periféricos por Software:

Desligue ou coloque em modo de baixo consumo os periféricos internos que não está a usar (ex: ADC, DAC, Bluetooth no ESP32) usando as funções apropriadas do ESP-IDF (através do Arduino core ou diretamente).

5. Técnicas Avançadas: Otimização Extrema

Para ir ainda mais longe:

Co-processador ULP (Ultra Low Power) no ESP32:

Este é um pequeno processador que pode executar código escrito em Assembly enquanto o CPU principal está em Deep Sleep.
Ideal para monitorizar um sensor simples (ex: ler um GPIO, medir um ADC de baixo débito, verificar um sensor I2C básico) e acordar o CPU principal apenas quando um evento de interesse ocorre (ex: a temperatura excede um limite).
Permite manter o sistema em Deep Sleep por mais tempo, reagindo apenas a condições específicas.
A programação do ULP é mais complexa e requer ferramentas do ESP-IDF.
RTC Externo:

Embora o ESP tenha um RTC interno, um RTC externo de ultra-baixo consumo (ex: DS3231 com modificações, PCF8523, RV-3028-C7) pode oferecer menor consumo em modo de timekeeping e funcionalidades adicionais, como alarmes mais precisos ou memória não volátil. Pode ser usado para acordar o ESP através de um pino externo.
Power Gating com MOSFETs:

Para periféricos externos que não têm um modo de baixo consumo ou pino de enable, use um P-channel MOSFET no lado da alimentação (high-side) ou um N-channel MOSFET no lado do ground (low-side), controlado por um GPIO do ESP. Ligue a alimentação do periférico (digitalWrite(MOSFET_GATE_PIN, LOW) para P-channel, HIGH para N-channel, dependendo da configuração) apenas quando necessário. Certifique-se que o GPIO está no estado correto (sem consumo) durante o Deep Sleep (geralmente INPUT ou output LOW/HIGH conforme necessário para manter o MOSFET desligado).

6. Medir é Essencial: Não Confie Apenas na Teoria

Não pode otimizar o que não mede. As datasheets fornecem valores típicos, mas o consumo real depende da sua placa específica, código, qualidade da fonte de alimentação e periféricos.

Ferramentas Necessárias:

Multímetro de Qualidade: Essencial um que consiga medir corrente contínua (DC) nas gamas de mA e, crucialmente, µA com boa precisão.
Método de Medição: A forma mais simples é interromper o circuito de alimentação (positivo ou negativo) entre a bateria/fonte e a entrada de alimentação do ESP (NÃO o pino 5V/Vin se estiver a usar o regulador da placa, mas sim diretamente a entrada de 3.3V ou a entrada do regulador de baixo consumo que adicionou) e inserir o multímetro em série, configurado para medir corrente (A/mA/µA).
Ferramentas Dedicadas (Melhor Opção): Para medir picos de corrente (Wi-Fi) e o consumo ultra-baixo em Deep Sleep de forma precisa e dinâmica, ferramentas especializadas são ideais:Nordic Semiconductor Power Profiler Kit II (PPK2): Relativamente acessível e muito popular.
Joulescope JS110/JS220: Mais caras, mas extremamente precisas e com vasta gama dinâmica.
Current Ranger (LowPowerLab): Outra opção popular na comunidade maker.

O que Medir:

Corrente em Deep Sleep (o mais baixo possível, idealmente < 20µA para meses de duração).
Corrente durante a fase ativa (leitura de sensores, processamento).
Picos de corrente durante a ligação e transmissão Wi-Fi.
Duração da fase ativa.

Calcular a Autonomia:

Consumo Médio (mA) = [ (I_sleep * T_sleep) + (I_active * T_active) ] / (T_sleep + T_active)Onde I_sleep é a corrente em Deep Sleep (mA), T_sleep é o tempo em Deep Sleep (horas).
I_active é a corrente média durante a fase ativa (mA), T_active é o tempo em fase ativa (horas).
Autonomia (horas) ≈ Capacidade da Bateria (mAh) / Consumo Médio (mA)
Não se esqueça de considerar a auto-descarga da bateria e a eficiência do regulador de voltagem!

7. Exemplo Prático: Sensor de Temperatura a Pilhas

Vamos esboçar um projeto otimizado:

Objetivo: Ler a temperatura a cada 15 minutos e enviar via MQTT para um servidor. Duração desejada: 6+ meses com 2 pilhas AA LiFePO4.
Hardware:Módulo ESP32-WROOM-32 (sem placa de desenvolvimento).
Regulador Buck-Boost de ultra-baixo consumo (ex: TPS63031) para fornecer 3.3V estáveis a partir das pilhas LiFePO4 (cuja tensão varia de ~3.6V a ~2.8V).
Sensor de temperatura I2C de baixo consumo (ex: BME280, SHT31).
2x Pilhas LiFePO4 AA (~1500-2000mAh cada, ligadas em série daria ~6.4V, o que não é ideal. Melhor usar uma pilha LiFePO4 de 3.2V e um Buck-Boost, ou 3x Alcalinas/NiMH com LDO/Buck). Alternativa: Uma única bateria Li-Ion 18650 (3.7V, ~3000mAh) com um LDO de baixo Iq (MCP1700) ou Buck eficiente.
Nenhum LED, nenhum USB-Serial.
Software:setup(): Configura I2C, lê o sensor BME280.
Conecta ao Wi-Fi (usando credenciais guardadas ou smart config na primeira vez).
Conecta ao broker MQTT.
Publica a leitura da temperatura.
Desconecta do MQTT e do Wi-Fi (WiFi.disconnect(true), WiFi.mode(WIFI_OFF)).
Configura wake-up por timer para 15 minutos (esp_sleep_enable_timer_wakeup(15 * 60 * 1000000ULL)).
Entra em Deep Sleep (esp_deep_sleep_start()).
loop(): Vazio.
Usa RTC_DATA_ATTR se precisar de guardar algum estado entre arranques.
Considerar reduzir a frequência da CPU para 80MHz se o tempo de atividade for significativo.
Medição e Otimização:Medir a corrente em Deep Sleep (objetivo < 15µA).
Medir o tempo e a corrente média durante a fase ativa (Wi-Fi é o maior fator). Tentar manter o tempo ativo abaixo de 5-10 segundos.
Calcular o consumo médio e estimar a autonomia. Ajustar o intervalo de sono se necessário.

Conclusão

Otimizar o consumo de energia de projetos ESP32 e ESP8266 para que durem meses a pilhas não é magia negra, mas sim uma combinação metódica de escolhas inteligentes de hardware e programação cuidadosa focada nos modos de baixo consumo. O Deep Sleep é a ferramenta mais poderosa no seu arsenal, permitindo reduzir o consumo a meros microamperes durante a maior parte do tempo.

Lembre-se dos passos chave:

Use Deep Sleep extensivamente.
Minimize o tempo de atividade, especialmente com o Wi-Fi ligado.
Escolha hardware de baixo consumo: placas mínimas, reguladores eficientes (baixo Iq), sensores adequados.
Remova ou desative componentes desnecessários (LEDs, USB-Serial).
Controle a alimentação dos periféricos externos.
Otimize o seu código (desligue rádios, considere frequência da CPU).
Meça o consumo real para validar as suas otimizações e estimar a autonomia.
Com paciência e experimentação, é absolutamente viável criar dispositivos IoT baseados em ESP32 e ESP8266 que funcionem de forma autónoma durante longos períodos, abrindo um vasto leque de possibilidades para os seus projetos, desde sensores ambientais remotos a sistemas de monitorização de baixo custo e longa duração. Boa otimização!