O que significa mAh? Capacidade da bateria, Wh e autonomia explicados

O que significa mAh? Em resumo, mAh (miliampere-hora) é a unidade de capacidade que indica quanta carga elétrica uma bateria armazena. 1 mAh significa uma corrente de 1 miliampere circulando durante 1 hora; assim, uma bateria de 2000 mAh pode, em teoria, alimentar um circuito que consome 20 mA por 100 horas, ou um que consome 200 mA por 10 horas. Só esse número não basta, porém: a tensão da bateria, a corrente consumida, a temperatura e o regulador entre a bateria e o circuito mudam muito a autonomia real.

Quando você monta um projeto alimentado por bateria com Arduino, ESP32 ou Raspberry Pi Pico, a primeira pergunta é sempre a mesma: quantas horas ou dias essa bateria vai durar? Neste guia você vai aprender o que significam mAh e Wh, as capacidades reais das pilhas AA, das baterias 9V, 18650 e LiPo, como medir o consumo de corrente do seu projeto com um multímetro e um INA219, como calcular a autonomia com uma fórmula, como ligar baterias em série e em paralelo, o que é a taxa C e por que a bateria 9V é uma escolha ruim, tudo com números reais.

O que significa mAh? A capacidade da bateria explicada

A corrente é medida em amperes (A) e a capacidade em ampere-hora (Ah). Para baterias pequenas usamos o miliampere-hora, a milésima parte disso: 1 Ah = 1000 mAh. Em termos de física, trata-se de carga elétrica; 1 mAh equivale a 3,6 coulombs. Os fabricantes medem a capacidade com uma corrente de descarga específica até uma tensão de corte específica. Conforme a corrente aumenta, mais tensão se perde na resistência interna da bateria, a reação química não acompanha e a tensão de corte é atingida mais cedo; por isso a mesma bateria entrega menos mAh em corrente alta. O frio também reduz a capacidade; as pilhas alcalinas ficam visivelmente mais fracas abaixo de 0 °C. A tabela abaixo mostra como a corrente consumida altera a capacidade de uma pilha AA alcalina, com base nos dados da Energizer (até 0,8 V, a 21 °C).

A diferença é impressionante: quando você aumenta a corrente 20 vezes, a autonomia não cai 20 vezes, mas 40 vezes. Por isso, considere o mAh do rótulo como o melhor caso. Em projetos reais há mais uma perda: o circuito para antes de a bateria esvaziar por completo. O regulador do Arduino Uno não consegue mais manter 5 V quando a entrada cai abaixo de 7 V, e uma célula de lítio única deve ser desligada por volta de 3,0–3,3 V para não encurtar sua vida útil. A energia que sobra na bateria nesse ponto nunca é usada.

O que significa Wh? mAh vs. Wh

O mAh informa apenas a quantidade de carga; para saber a energia da bateria é preciso multiplicar pela tensão. A unidade de energia é o watt-hora (Wh), e a fórmula é: Wh = mAh × V / 1000. Por exemplo, uma célula 18650 de 3,7 V e 3000 mAh guarda 3,7 × 3 = 11,1 Wh. Uma pilha AA de 2500 mAh dá 1,5 × 2,5 = 3,75 Wh no papel, mas como a tensão média de uma pilha alcalina cai para 1,2–1,3 V durante a descarga, o valor real fica em torno de 3 Wh. Por isso, comparar baterias de tensões diferentes só pelo mAh engana: uma bateria 9V de 550 mAh parece bem menor que uma AA de 2500 mAh, mas com cerca de 4 Wh guarda um pouco mais de energia. Qual delas dura mais no seu projeto depende do tipo de regulador entre elas e o circuito; você vai ver isso na seção de autonomia. Para calcular rapidamente a relação entre potência e corrente (P = V × I), você pode usar a calculadora da lei de Ohm.

Tabela comparativa de pilhas AA e baterias 9V, 18650 e LiPo

Ao ler a tabela, lembre-se: as células de lítio, como 18650 e LiPo, armazenam mais energia para o seu peso; uma única 18650 guarda quase a energia total de quatro pilhas AA alcalinas com cerca de metade do peso. As pilhas alcalinas são boas para dispositivos de baixa corrente que ficam muito tempo parados, porque perdem só alguns por cento da capacidade por ano; já com cargas de corrente alta, como motores ou servos, a tensão delas despenca rapidamente. As pilhas recarregáveis NiMH entregam corrente alta com facilidade, apesar da tensão baixa de 1,2 V, e o tipo de baixa autodescarga (LSD) fica carregado por meses. A bateria de botão CR2032 serve apenas para módulos de relógio e sensores em repouso que funcionam na faixa dos microamperes; ela nunca vai conseguir alimentar um ESP32 se conectando ao Wi-Fi.

Por que a bateria 9V é uma escolha ruim?

A bateria 9V retangular é comum em kits iniciantes porque o conector de pressão encaixa direto no conector DC do Arduino, mas é uma das piores opções para um projeto Arduino alimentado por bateria. Ela tem seis pequenas células em série, por isso sua capacidade é de apenas 400–600 mAh. Segundo os dados da Energizer, uma bateria 9V alcalina descarregada até 4,8 V entrega cerca de 600 mAh a 10 mA, 570 mAh a 25 mA e só 450 mAh a 50 mA. O regulador do Arduino Uno, por outro lado, precisa de pelo menos 7 V no conector DC; sob carga, a tensão da bateria cai abaixo disso em poucas horas e a energia restante não pode ser usada. É por isso que um Uno consumindo cerca de 50 mA normalmente funciona só algumas horas com uma bateria 9V, muitas vezes 4–8 horas.

• Capacidade baixa: apenas 400–600 mAh, contra 2000–2500 mAh de um pacote 6×AA, o que significa mais de quatro vezes menos autonomia com os mesmos 9 V.
• Resistência interna alta: quando um servo começa a girar ou um relé aciona, a tensão despenca na hora e o Arduino reinicia.
• Perda no regulador: o regulador linear do Uno transforma em calor a diferença de 4 V entre 9 V e 5 V; a 50 mA, cerca de 0,2 W dos 0,45 W tirados da bateria são desperdiçados.
• Energia cara: o custo por Wh é claramente maior que o das pilhas AA, e as baterias 9V recarregáveis NiMH caem para apenas 170–300 mAh.
• Onde ela funciona bem: a bateria 9V vai muito bem em detectores de fumaça, multímetros ou dispositivos que consomem poucos mA e ficam parados por muito tempo. Para o Arduino, prefira um pacote 6×AA, um pacote 2S de 18650 ou um power bank; os detalhes estão em Como alimentar o Arduino com bateria.

Medindo o consumo de corrente do seu projeto Arduino

Para calcular a autonomia da bateria, primeiro você precisa saber quanta corrente o seu projeto consome. Medir é melhor que estimar, porque o consumo da própria placa, os LEDs de alimentação e os reguladores muitas vezes puxam mais corrente que os sensores. O jeito mais fácil é ligar um multímetro em série entre a bateria e o circuito. Em projetos com ciclo de repouso e despertar, um sensor de corrente como o INA219 dá resultados melhores, porque capta os picos curtos de corrente e a média real. Para detalhes sobre as escalas e os bornes do multímetro, veja Como usar o multímetro.

1. Desligue o circuito; encaixe a ponta de prova vermelha no borne mA do multímetro e a preta no COM. Se você acha que a corrente pode passar de 200 mA, comece pelo borne 10A.
2. Gire a chave seletora para corrente contínua (A⎓) e, se o multímetro não tiver escala automática, para a escala de 200 mA.
3. Desconecte o fio positivo da bateria do circuito; encoste a ponta vermelha no positivo da bateria e a preta na entrada positiva do circuito. Assim toda a corrente passa pelo multímetro.
4. Ligue o circuito e leia o valor. Meça separadamente enquanto um servo gira, enquanto o Wi-Fi se conecta ou enquanto um relé está acionado, e anote a corrente de cada estado.
5. Se a corrente em repouso estiver na faixa dos microamperes, passe para a escala µA. Nessa escala a placa pode não receber corrente suficiente para iniciar; faça uma ponte entre as pontas de prova com um jumper durante a inicialização e retire-o quando a placa entrar em repouso.
6. Coloque as correntes medidas, junto com o tempo gasto em cada estado, na fórmula de corrente média abaixo.

Medindo corrente e mAh consumidos com o INA219

O INA219 é um pequeno módulo sensor de corrente e tensão I2C. Ele mede a tensão sobre o resistor shunt de 0,1 Ω da placa com resolução de 12 bits e lê correntes de até cerca de ±3,2 A em circuitos de até 26 V, com resolução de aproximadamente 0,1 mA. Seu endereço I2C padrão é 0x40. Você liga o módulo em série na linha positiva do circuito a ser medido: o positivo da bateria vai em Vin+, e Vin− vai na entrada positiva do circuito. O Arduino que faz a medição é alimentado pelo USB, e o GND dele é ligado ao GND do circuito em teste. Basta instalar a biblioteca Adafruit INA219 pelo Gerenciador de Bibliotecas do Arduino IDE. O INA219 não consegue resolver correntes de repouso na faixa dos microamperes; meça essas com a escala µA de um multímetro.

1// INA219 ile akım, harcanan mAh ve pil ömrü / current, used mAh and battery life with INA219
2#include <Wire.h>
3#include <Adafruit_INA219.h>
4
5Adafruit_INA219 ina219;                    // varsayılan adres 0x40 / default address 0x40
6
7const float CAPACITY_MAH = 2500.0;         // pilin etiket kapasitesi / rated battery capacity
8const float USABLE = 0.85;                 // kullanılabilir oran / usable share
9
10float usedMah = 0;                         // toplam harcanan yük / total charge used
11float secMaMs = 0;                         // son saniyenin mA x ms toplamı / mA x ms of the last second
12unsigned long startMs, lastSample, lastPrint;
13
14void setup() {
15  Serial.begin(9600);
16  if (!ina219.begin()) {
17    Serial.println(F("INA219 bulunamadi / INA219 not found"));
18    while (true) {}
19  }
20  ina219.setCalibration_32V_1A();          // 1 A'e kadar ince ölçüm / finer steps up to 1 A
21  startMs = lastSample = lastPrint = millis();
22}
23
24void loop() {
25  unsigned long now = millis();
26
27  if (now - lastSample >= 10) {            // 10 ms'de bir örnek / one sample every 10 ms
28    float mA = ina219.getCurrent_mA();
29    secMaMs += mA * (now - lastSample);    // akım x süre / current x time
30    lastSample = now;
31  }
32
33  if (now - lastPrint >= 1000) {           // saniyede bir rapor / report once a second
34    lastPrint = now;
35    usedMah += secMaMs / 3600000.0;        // mA x ms -> mAh
36    secMaMs = 0;
37    float avgMa = usedMah / ((now - startMs) / 3600000.0);   // ortalama akım / average current
38    float volts = ina219.getBusVoltage_V() + ina219.getShuntVoltage_mV() / 1000.0;   // pil gerilimi / battery voltage
39
40    Serial.print(F("Pil / Battery: "));
41    Serial.print(volts, 2);
42    Serial.print(F(" V | Ort / Avg: "));
43    Serial.print(avgMa, 1);
44    Serial.print(F(" mA | Harcanan / Used: "));
45    Serial.print(usedMah, 2);
46    Serial.print(F(" mAh"));
47    if (avgMa > 0.5) {
48      Serial.print(F(" | Sure / Runtime: "));
49      Serial.print(CAPACITY_MAH * USABLE / avgMa, 1);   // saat / hours
50      Serial.print(F(" h"));
51    }
52    Serial.println();
53  }
54}

O código lê a corrente a cada 10 milissegundos e soma os produtos corrente × tempo para obter os mAh consumidos; assim, pulsos curtos de corrente, como uma transmissão Wi-Fi ou o movimento de um servo, entram na média. Uma vez por segundo, ele mostra no Monitor Serial a tensão da bateria, a corrente média até o momento, a capacidade consumida e a autonomia estimada com base em 85% da capacidade nominal. Deixe rodando por pelo menos um ciclo completo de funcionamento, por exemplo tempo suficiente para cobrir um ciclo inteiro de repouso e despertar. Para cargas acima de 1 A, use setCalibration_32V_2A(). O mesmo código roda sem alterações no ESP32 com os GPIO 21 e 22; para ajuda com o Monitor Serial, veja Monitor Serial do Arduino.

Calculando a autonomia: capacidade / corrente × eficiência

Quando você conhece a corrente média, a fórmula básica é simples: Autonomia (horas) = Capacidade (mAh) / Corrente média (mA) × Eficiência. Um fator de eficiência de 0,85 é um bom ponto de partida; ele considera a capacidade perdida em corrente alta e no frio, o circuito parando antes de a bateria esvaziar por completo e o envelhecimento da bateria. Essa fórmula vale quando não há regulador entre a bateria e o circuito, ou quando o regulador é linear (o regulador de 5 V do Uno, AMS1117, 7805), porque num regulador linear a corrente de entrada é igual à de saída e a diferença de tensão vira calor. Se você usa um conversor chaveado, como um módulo boost ou buck, calcule pela energia: Autonomia (horas) = Energia da bateria (Wh) × Eficiência / Potência da carga (W). Aqui a eficiência é a eficiência de 85–90% do conversor multiplicada pela parcela utilizável da bateria; 0,75–0,8 é um valor realista.

Em projetos que entram em repouso e despertam, primeiro você precisa da corrente média: Corrente média = (Corrente acordado × Tempo acordado + Corrente em repouso × Tempo em repouso) / Tempo total. Por exemplo, um módulo ESP32 puro que acorda por 5 segundos a cada 10 minutos consumindo 120 mA e fica em repouso a 10 µA (0,01 mA) nos 595 segundos restantes tem média de (120 × 5 + 0,01 × 595) / 600 ≈ 1,01 mA. Com uma 18650 de 3000 mAh, isso dá 3000 / 1,01 × 0,85 ≈ 2520 horas, ou cerca de 3,5 meses. Se o mesmo código rodar numa placa de desenvolvimento que consome 5 mA em repouso, a média sobe para 5,96 mA e a autonomia cai para cerca de 18 dias. Em vez de fazer isso à mão, você pode usar a calculadora de autonomia da bateria; basta informar a capacidade, as correntes acordado e em repouso e o intervalo de despertar. Quando a corrente média fica abaixo de 0,1 mA, a autodescarga da bateria também passa a ser decisiva: uma célula de Li-ion perde cerca de 2–3% da capacidade por mês.

ESP32: medindo o tempo acordado para estimar a autonomia

O consumo do ESP32 varia milhares de vezes conforme o modo de operação. Segundo o datasheet da Espressif, o chip consome até 240 mA ao transmitir por Wi-Fi, cerca de 100 mA ao receber, 20–68 mA com o Wi-Fi desligado (modem sleep), cerca de 0,8 mA em light sleep e apenas 10 µA em deep sleep. Por isso, o que realmente define a autonomia é o tempo que a placa passa acordada: conectar ao Wi-Fi costuma levar 1–3 segundos, e a energia gasta nesses poucos segundos é maior que a de horas de repouso. O código abaixo guarda na memória RTC quanto tempo a placa ficou acordada a cada despertar e, usando as correntes que você mediu, calcula a corrente média e a autonomia estimada.

1// ESP32 derin uyku ve pil ömrü tahmini / ESP32 deep sleep and battery life estimate
2RTC_DATA_ATTR int bootCount = 0;               // derin uykuda silinmez / survives deep sleep
3RTC_DATA_ATTR unsigned long lastAwakeMs = 0;   // önceki uyanık süre / previous awake time
4
5const float ACTIVE_MA = 120.0;      // ölçtüğün uyanık akım / measured awake current
6const float SLEEP_MA = 0.01;        // ölçtüğün uyku akımı (10 µA) / measured sleep current (10 µA)
7const int SLEEP_S = 600;            // 10 dakika uyku / 10 minutes of sleep
8const float CAPACITY_MAH = 3000.0;  // 18650 kapasitesi / 18650 capacity
9const float USABLE = 0.85;          // kullanılabilir oran / usable share
10
11void setup() {
12  Serial.begin(115200);
13  bootCount++;
14
15  // Burada sensörü oku ve veriyi gönder / read the sensor and send the data here
16  delay(500);                       // örnek iş yükü / sample workload
17
18  if (lastAwakeMs > 0) {
19    float awakeS = lastAwakeMs / 1000.0;
20    float avgMa = (ACTIVE_MA * awakeS + SLEEP_MA * SLEEP_S) / (awakeS + SLEEP_S);
21    float days = CAPACITY_MAH * USABLE / avgMa / 24.0;
22    Serial.printf("Uyanis / Wake #%d, uyanik / awake: %.2f s\n", bootCount, awakeS);
23    Serial.printf("Ortalama / Average: %.3f mA, pil omru / battery life: %.0f gun / days\n", avgMa, days);
24  }
25
26  lastAwakeMs = millis();           // bu uyanışın süresi / duration of this wake
27  Serial.flush();
28  esp_sleep_enable_timer_wakeup((uint64_t)SLEEP_S * 1000000ULL);   // mikrosaniye / microseconds
29  esp_deep_sleep_start();           // loop() hiç çalışmaz / loop() never runs
30}
31
32void loop() {
33}

No primeiro despertar ele só guarda o tempo; em cada despertar seguinte, calcula e mostra a corrente média e a autonomia em dias usando o tempo acordado anterior. Meça ACTIVE_MA e SLEEP_MA na sua própria placa com um multímetro e coloque os valores no código. O millis() não conta o tempo do bootloader na inicialização, então somar uma margem de 0,1–0,3 segundo ao tempo acordado dá um resultado mais realista. Para detalhes sobre os modos de repouso e as fontes de despertar, veja ESP32 deep sleep, e para problemas de reinicialização que podem aparecer com alimentação por bateria, veja Erro de brownout no ESP32.

Ligando baterias em série e em paralelo

Quando você liga baterias em série (o positivo de uma no negativo da seguinte), as tensões se somam e a capacidade (mAh) continua a mesma: quatro pilhas AA de 1,5 V e 2500 mAh em série dão 6 V e 2500 mAh. Quando você as liga em paralelo (positivos juntos, negativos juntos), a tensão continua a mesma e as capacidades se somam: duas 18650 de 3000 mAh em paralelo dão 3,7 V e 6000 mAh. Nos dois casos, a energia total (Wh) cresce com o número de células. Em pacotes de lítio, essa configuração é escrita com as letras S (série) e P (paralelo); por exemplo, 2S2P é um pacote de quatro células formado por dois pares em paralelo ligados em série.

• Use células idênticas: num pacote em série ou em paralelo, use baterias da mesma marca, capacidade, idade e nível de carga; uma célula mais fraca esvazia antes das outras e sofre esforço.
• Iguale as tensões antes de ligar em paralelo: antes de ligar células de Li-ion em paralelo, a diferença de tensão entre elas não deve passar de 0,1 V; caso contrário, a célula cheia empurra uma corrente grande e descontrolada para a vazia.
• Pacotes de lítio em série precisam de proteção: em pacotes 2S ou maiores, use uma placa BMS com balanceamento que monitore cada célula. Um pacote em série não pode ser carregado com um módulo TP4056, que é de uma célula só.
• Não misture pilhas recarregáveis e descartáveis: não coloque pilhas alcalinas e NiMH no mesmo pacote; as tensões e as resistências internas são diferentes.
• A ligação em paralelo divide a carga: num pacote 1S2P cada célula conduz metade da corrente, então um pacote em paralelo dura mais e esquenta menos em corrente alta.

O que é a taxa C?

A taxa C indica a rapidez com que uma bateria é descarregada ou carregada em relação à sua capacidade. 1C é a corrente que esvazia a bateria em 1 hora e é numericamente igual à capacidade: para uma bateria de 2000 mAh, 1C = 2 A, 0,5C = 1 A e 20C = 40 A. Calcular o tempo também é fácil: a 2C a bateria esvazia em cerca de 30 minutos, a 0,2C em 5 horas. Valores como 25C ou 50C impressos em LiPos de drones e modelos RC indicam a corrente máxima de descarga contínua; uma LiPo de 1000 mAh 25C pode entregar 25 A. Nas células 18650 isso geralmente vem direto em amperes: as células de alta capacidade de 3500 mAh entregam 8–10 A, enquanto as de alta descarga de 2500–3000 mAh entregam 15–30 A contínuos. Na carga a regra é mais rígida: a corrente de carga padrão para células de lítio fica em torno de 0,5C, e no máximo 1C. Um módulo TP4056 que carrega a 1 A serve bem para uma 18650 de 2000 mAh, mas força uma pequena LiPo de 300 mAh a cerca de 3C; nesse caso você precisa trocar o resistor Rprog do módulo para reduzir a corrente de carga.

Medindo a capacidade da bateria com o Raspberry Pi Pico (MicroPython)

Células 18650 com rótulo de 9900 mAh são quase sempre falsas; as 18650 genuínas de maior capacidade no mercado ficam em torno de 3500–3600 mAh. A única forma de descobrir a capacidade real de uma bateria é descarregá-la por uma carga conhecida e somar a corrente ao longo do tempo. Com um Raspberry Pi Pico, um resistor de carga e um MOSFET, você pode montar um testador de capacidade simples que faz exatamente isso: o Pico liga a carga pelo MOSFET, mede a tensão da bateria por um divisor de tensão, calcula a corrente com I = V / R e desconecta a carga quando a tensão chega ao valor de corte. Você pode conferir os valores do divisor com a calculadora de divisor de tensão e, para detalhes da ligação do MOSFET, veja Como usar MOSFET.

1from machine import ADC, Pin
2import time
3
4adc = ADC(26)                      # GP26: bölücünün orta noktası / divider midpoint
5load = Pin(15, Pin.OUT, value=0)   # GP15: MOSFET kapısı / MOSFET gate
6R_LOAD = 10.0                      # yük direnci, ohm (ölçüp yaz) / load resistor in ohms (measure it)
7DIV = 2.0                          # 100k + 100k bölücü / 100k + 100k divider
8CUTOFF = 3.0                       # Li-ion bitiş gerilimi / Li-ion end voltage
9CONV = 3.3 / 65535                 # ham değeri volta çevir / raw value to volts
10
11def battery_v():
12    total = 0
13    for _ in range(32):            # 32 ölçümün ortalaması / average of 32 readings
14        total += adc.read_u16()
15    return total / 32 * CONV * DIV
16
17mah = 0.0
18mwh = 0.0
19log = open("desarj.csv", "w")      # Pico'nun belleğine kaydedilir / saved to the Pico's flash
20log.write("dakika,volt,mA,mAh\n")
21load.value(1)                      # deşarjı başlat / start the discharge
22start = last = time.ticks_ms()
23
24while True:
25    time.sleep(30)
26    now = time.ticks_ms()
27    hours = time.ticks_diff(now, last) / 3600000
28    last = now
29    v = battery_v()                # yük altındaki gerilim / voltage under load
30    ma = v / R_LOAD * 1000         # I = V / R
31    mah += ma * hours
32    mwh += v * ma * hours
33    minutes = time.ticks_diff(now, start) / 60000
34    print("{:.0f} dk/min  {:.3f} V  {:.0f} mA  {:.0f} mAh  {:.2f} Wh".format(minutes, v, ma, mah, mwh / 1000))
35    log.write("{:.1f},{:.3f},{:.0f},{:.1f}\n".format(minutes, v, ma, mah))
36    log.flush()
37    if v <= CUTOFF:
38        load.value(0)              # yükü ayır, pili koru / disconnect the load, protect the cell
39        log.close()
40        print("Kapasite / Capacity: {:.0f} mAh, {:.2f} Wh".format(mah, mwh / 1000))
41        break

A cada 30 segundos o código mede a tensão da bateria sob carga, calcula a corrente e soma os mAh e Wh consumidos; ele mostra os resultados no console do Thonny e também os salva no arquivo desarj.csv na memória flash do Pico. Depois você pode abrir esse arquivo no Excel e traçar a curva de descarga (Como enviar dados do Arduino para o Excel). Com a carga de 10 Ω, testar uma 18650 de 3000 mAh leva cerca de 8–9 horas. Para resultados precisos, meça o resistor de carga com um multímetro e coloque o valor em R_LOAD, depois compare a tensão da bateria com a leitura de um multímetro e ajuste o fator DIV. Para testar uma AA NiMH, reduza CUTOFF para 1,0 V e o resistor de carga para 4,7 Ω. A 4,2 V o resistor de carga dissipa cerca de 1,8 W; escolha um resistor de pelo menos 5 W, mantenha-o longe de superfícies inflamáveis e não deixe o teste sem supervisão. Se você ainda não sabe instalar o MicroPython no Pico, comece por O que é o Raspberry Pi Pico?.

Ideias de projetos usando cálculo de bateria

• Sensor de jardim que funciona por meses: mantenha um ESP32 em deep sleep, meça a umidade do solo uma vez por hora e leve a corrente média para menos de 1 mA.
• Voltímetro com indicador de bateria: meça a tensão da bateria e mostre em porcentagem num LCD (Como fazer um voltímetro com Arduino).
• O pacote certo para um carrinho robô: meça a corrente dos motores e calcule quantos minutos um pacote 2S de 18650 vai durar (Como fazer um carrinho robô com Arduino).
• Registrador de consumo de energia: grave as leituras do INA219 num cartão SD para montar o perfil diário de energia de um dispositivo (Módulo de cartão SD).
• Estação de teste de capacidade de 18650: acrescente um display OLED de 0,96 polegada ao testador com Pico e mostre os mAh ao vivo.
• Estação meteorológica a bateria: faça um ESP32 que envia dados do DHT11 a cada 10 minutos funcionar por meses com uma única 18650.

Erros comuns e como corrigi-los

Agora você sabe a diferença entre mAh e Wh, como medir a corrente do seu projeto e como calcular quantas horas ou dias uma bateria vai durar. Como próximo passo, dê uma olhada em Como alimentar o Arduino com bateria e Como carregar uma 18650 com TP4056. No app BlueGrays você encontra projetos alimentados por bateria, como economia de energia com deep sleep no ESP32, voltímetro digital com LCD, carrinho robô controlado por Bluetooth e robô que desvia de obstáculos, cada um com esquema do circuito e código passo a passo.