¿Qué significa mAh? Capacidad de batería, Wh y autonomía

¿Qué significa mAh? En pocas palabras, mAh (miliamperio-hora) es la unidad de capacidad que indica cuánta carga eléctrica almacena una pila o una batería. 1 mAh significa una corriente de 1 miliamperio circulando durante 1 hora; así, una batería de 2000 mAh puede, en teoría, alimentar un circuito que consume 20 mA durante 100 horas, o uno de 200 mA durante 10 horas. Pero ese dato por sí solo no basta: la tensión de la batería, la corriente que consumes, la temperatura y el regulador que hay entre la batería y el circuito cambian muchísimo la autonomía real.

Cuando montas un proyecto a batería con Arduino, ESP32 o Raspberry Pi Pico, la primera pregunta siempre es la misma: ¿cuántas horas o días va a durar esta batería? En esta guía aprenderás qué significan mAh y Wh, cuál es la capacidad real de las pilas AA, 9V, 18650 y LiPo, cómo medir el consumo de tu proyecto con un multímetro y un INA219, cómo calcular la autonomía con una fórmula, cómo conectar baterías en serie y en paralelo, qué es la tasa C y por qué la pila de 9V es una mala elección, todo con números reales.

¿Qué significa mAh? La capacidad de una batería explicada

La corriente se mide en amperios (A) y la capacidad en amperios-hora (Ah). Para baterías pequeñas se usa el miliamperio-hora, la milésima parte: 1 Ah = 1000 mAh. En física corresponde a una carga eléctrica; 1 mAh equivale a 3,6 culombios. Los fabricantes miden la capacidad con una corriente de descarga concreta hasta una tensión de corte concreta. Cuanto mayor es la corriente, más tensión se pierde en la resistencia interna, la reacción química no da abasto y la tensión de corte llega antes; por eso la misma pila entrega menos mAh con corrientes altas. El frío también reduce la capacidad: las pilas alcalinas se debilitan notablemente por debajo de 0 °C. La tabla muestra, según los datos de Energizer, cómo cambia la capacidad de una pila AA alcalina según la corriente (hasta 0,8 V, a 21 °C).

La diferencia es llamativa: si multiplicas la corriente por 20, la duración no se divide entre 20, sino entre 40. Por eso conviene ver los mAh de la etiqueta como el mejor caso posible. En los proyectos reales se suma otra pérdida: el circuito se detiene antes de que la batería se vacíe del todo. El regulador del Arduino Uno ya no puede mantener los 5 V cuando su entrada baja de 7 V, y una celda de litio debe cortarse hacia 3,0–3,3 V para no acortar su vida útil. La energía que queda dentro en ese momento nunca se aprovecha.

¿Qué significa Wh? Diferencia entre mAh y Wh

Los mAh solo indican la cantidad de carga; para conocer la energía de una batería hay que multiplicar por la tensión. La unidad de energía es el vatio-hora (Wh) y la fórmula es: Wh = mAh × V / 1000. Por ejemplo, una celda 18650 de 3,7 V y 3000 mAh almacena 3,7 × 3 = 11,1 Wh. Una pila AA de 2500 mAh da sobre el papel 1,5 × 2,5 = 3,75 Wh, pero como la tensión media de una alcalina baja a 1,2–1,3 V durante la descarga, el valor real ronda los 3 Wh. Por eso comparar baterías de distinta tensión solo por sus mAh lleva a error: una pila de 9V de 550 mAh parece mucho más pequeña que una AA de 2500 mAh, pero con unos 4 Wh guarda incluso algo más de energía. Cuál durará más en tu proyecto depende del tipo de regulador que haya en medio; lo verás en la sección del cálculo de autonomía. Para calcular rápido la relación entre potencia y corriente (P = V × I) puedes usar la calculadora de la ley de Ohm.

Tabla comparativa de pilas AA, 9V, 18650 y LiPo

Al leer la tabla, recuerda: las celdas de litio como las 18650 y las LiPo son las que más energía guardan en relación con su peso; una sola 18650 almacena casi tanta energía como cuatro pilas AA alcalinas juntas, con la mitad de peso aproximadamente. Las pilas alcalinas van bien para aparatos de bajo consumo que pasan mucho tiempo guardados, porque pierden solo un pequeño porcentaje de capacidad al año; con cargas exigentes como motores o servos, en cambio, su tensión se desploma rápido. Las pilas recargables de NiMH entregan corrientes altas sin problema a pesar de sus 1,2 V, y las de baja autodescarga (LSD) se mantienen cargadas durante meses. La pila de botón CR2032 solo sirve para módulos de reloj y sensores dormidos que funcionan en el rango de los microamperios; nunca podrá alimentar un ESP32 que se conecta a la wifi.

¿Por qué la pila de 9V es una mala elección?

La pila rectangular de 9V aparece a menudo en los kits de iniciación porque su conector de broche encaja directamente en el jack DC del Arduino, pero es una de las peores opciones para un proyecto Arduino a batería. Dentro lleva seis celdas pequeñas en serie, así que su capacidad es de solo 400–600 mAh. Según los datos de Energizer, una pila alcalina de 9V descargada hasta 4,8 V entrega unos 600 mAh a 10 mA, 570 mAh a 25 mA y solo 450 mAh a 50 mA. El regulador del Arduino Uno, en cambio, necesita al menos 7 V en el jack DC; con carga, la tensión de la pila cae por debajo de ese límite en pocas horas y el resto de la energía queda sin usar. Por eso un Uno que consume unos 50 mA suele funcionar solo unas horas con una pila de 9V, a menudo entre 4 y 8 horas.

• Poca capacidad: solo 400–600 mAh frente a los 2000–2500 mAh de un pack de 6×AA, es decir, más de cuatro veces menos autonomía con los mismos 9 V.
• Resistencia interna alta: cuando un servo empieza a moverse o un relé se activa, la tensión cae de golpe y el Arduino se reinicia.
• Pérdidas en el regulador: el regulador lineal del Uno convierte en calor los 4 V de diferencia entre 9 V y 5 V; a 50 mA se desperdician unos 0,2 W de los 0,45 W que salen de la pila.
• Energía cara: su coste por Wh es claramente mayor que el de las pilas AA, y las pilas recargables de 9V de NiMH bajan a solo 170–300 mAh.
• Dónde sí funciona: en detectores de humo, multímetros o aparatos que consumen pocos mA y pasan mucho tiempo en reposo, la pila de 9V va perfecta. Para un Arduino es mejor un pack de 6×AA, un pack 2S de 18650 o una power bank; tienes los detalles en Cómo alimentar Arduino con batería.

Cómo medir el consumo de corriente de tu proyecto Arduino

Para calcular la duración de la batería, primero necesitas saber cuánta corriente consume tu proyecto. Medir es mejor que suponer, porque el propio consumo de la placa, los LED de alimentación y los reguladores suelen gastar más que los sensores. Lo más sencillo es conectar un multímetro en serie entre la batería y el circuito. En los proyectos con ciclos de sueño y vigilia, un sensor de corriente como el INA219 da mejores resultados, porque capta los picos breves de corriente y la media real. Para saber más sobre las escalas y bornes del multímetro, consulta Cómo usar un multímetro.

1. Desconecta la alimentación del circuito; conecta la punta roja al borne mA del multímetro y la negra al borne COM. Si crees que la corriente puede superar los 200 mA, empieza con el borne 10A.
2. Gira el selector a corriente continua (A⎓) y, si no es de rango automático, a la escala de 200 mA.
3. Desconecta el cable positivo de la batería del circuito; apoya la punta roja en el positivo de la batería y la negra en la entrada positiva del circuito. Así toda la corriente pasa por el multímetro.
4. Enciende el circuito y lee el valor. Mide también por separado mientras un servo se mueve, mientras la wifi se conecta o mientras un relé está activado, y anota la corriente de cada estado.
5. Si la corriente en reposo está en el rango de los microamperios, cambia a la escala de µA. En esa escala la placa puede no recibir corriente suficiente para arrancar; puentea las puntas con un cable jumper durante el arranque y quítalo cuando la placa entre en reposo.
6. Introduce las corrientes medidas, junto con el tiempo que dura cada estado, en la fórmula de la corriente media que verás más abajo.

Medir la corriente y los mAh consumidos con un INA219

El INA219 es un pequeño módulo I2C que mide corriente y tensión. Mide con 12 bits de resolución la caída de tensión en la resistencia shunt de 0,1 Ω de la placa y lee corrientes de hasta unos ±3,2 A en circuitos de hasta 26 V con una resolución de aproximadamente 0,1 mA. Su dirección I2C por defecto es 0x40. El módulo se conecta en serie en la línea positiva del circuito que quieres medir: el positivo de la batería va a Vin+ y Vin− va a la entrada positiva del circuito. El Arduino que mide se alimenta por USB y su GND se une a la GND del circuito medido. Solo necesitas instalar la librería Adafruit INA219 desde el Gestor de librerías del Arduino IDE. El INA219 no puede resolver corrientes de reposo del orden de los microamperios; esas mídelas con la escala de µA de un 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}

El código lee la corriente cada 10 milisegundos y suma los productos de corriente × tiempo para obtener los mAh consumidos; así, los pulsos breves de corriente, como una transmisión wifi o el movimiento de un servo, también entran en la media. Una vez por segundo muestra en el Monitor Serie la tensión de la batería, la corriente media hasta ese momento, la capacidad consumida y la autonomía estimada con el 85 % de la capacidad nominal. Deja la medición en marcha durante al menos un ciclo completo de funcionamiento, por ejemplo el tiempo suficiente para cubrir un ciclo entero de reposo y vigilia. Con cargas de más de 1 A, usa setCalibration_32V_2A(). El mismo código funciona sin cambios en el ESP32 con los GPIO 21 y 22; si necesitas ayuda con el Monitor Serie, consulta Monitor Serie de Arduino.

Cálculo de la autonomía: capacidad / corriente × eficiencia

Cuando conoces la corriente media, la fórmula básica es sencilla: Autonomía (horas) = Capacidad (mAh) / Corriente media (mA) × Eficiencia. Un factor de 0,85 es un buen punto de partida; tiene en cuenta la capacidad que se pierde con corrientes altas y con frío, que el circuito se detenga antes de vaciar la batería y el envejecimiento de esta. Esta fórmula vale cuando no hay regulador entre la batería y el circuito o cuando hay uno lineal (el regulador de 5 V del Uno, el AMS1117, el 7805), porque en un regulador lineal la corriente de entrada es igual a la de salida y la diferencia de tensión se convierte en calor. Si usas un convertidor conmutado, como un elevador (boost) o un reductor (buck), calcula con la energía: Autonomía (horas) = Energía de la batería (Wh) × Eficiencia / Potencia de la carga (W). Aquí la eficiencia es el producto del 85–90 % del convertidor por la parte aprovechable de la batería; tomar 0,75–0,8 es realista.

En los proyectos que duermen y se despiertan, primero necesitas la corriente media: Corriente media = (Corriente despierto × Tiempo despierto + Corriente en reposo × Tiempo en reposo) / Tiempo total. Por ejemplo, un módulo ESP32 solo que se despierta cada 10 minutos durante 5 segundos consumiendo 120 mA y duerme los 595 segundos restantes con 10 µA (0,01 mA) tiene una media de (120 × 5 + 0,01 × 595) / 600 ≈ 1,01 mA. Con una 18650 de 3000 mAh eso da 3000 / 1,01 × 0,85 ≈ 2520 horas, unos 3,5 meses. Si el mismo código corre en una placa de desarrollo que consume 5 mA en reposo, la media sube a 5,96 mA y la autonomía baja a unos 18 días. En lugar de hacerlo a mano, puedes usar la calculadora de duración de batería: solo tienes que introducir la capacidad, las corrientes despierto y en reposo y el intervalo de despertar. Cuando la corriente media baja de 0,1 mA, la autodescarga de la batería también pasa a ser decisiva: una celda de iones de litio pierde aproximadamente un 2–3 % de su capacidad al mes.

ESP32: medir el tiempo despierto para estimar la duración de la batería

El consumo del ESP32 varía miles de veces según el modo de funcionamiento. Según la hoja de datos de Espressif, el chip consume hasta 240 mA al transmitir por wifi, unos 100 mA al recibir, 20–68 mA con la wifi apagada (modem sleep), unos 0,8 mA en light sleep y solo 10 µA en deep sleep. Por eso lo que realmente marca la duración de la batería es el tiempo que permanece despierto: conectarse a la wifi suele llevar 1–3 segundos, y la energía de esos pocos segundos supera a la de horas de reposo. El siguiente código guarda en la memoria RTC cuánto tiempo estuvo despierto en cada ciclo y, con las corrientes que hayas medido, calcula la corriente media y la duración estimada de la batería.

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}

En el primer despertar solo guarda el tiempo; en cada despertar siguiente calcula y muestra la corriente media y la duración de la batería en días usando el tiempo despierto anterior. Mide ACTIVE_MA y SLEEP_MA en tu propia placa con un multímetro y escríbelos en el código. millis() no cuenta el tiempo del bootloader en el arranque, así que sumar un margen de 0,1–0,3 segundos al tiempo despierto da un resultado más realista. Tienes los detalles de los modos de reposo y las fuentes de despertar en ESP32 deep sleep, y los problemas de reinicio que pueden aparecer al alimentarlo con batería en Error brownout del ESP32.

Conectar pilas y baterías en serie y en paralelo

Cuando conectas baterías en serie (el positivo de una con el negativo de la siguiente), las tensiones se suman y la capacidad (mAh) se mantiene: cuatro pilas AA de 1,5 V y 2500 mAh en serie dan 6 V y 2500 mAh. Cuando las conectas en paralelo (positivos con positivos y negativos con negativos), la tensión se mantiene y las capacidades se suman: dos 18650 de 3000 mAh en paralelo dan 3,7 V y 6000 mAh. En ambos casos la energía total (Wh) crece con el número de celdas. En los packs de litio esta disposición se escribe con las letras S (serie) y P (paralelo); por ejemplo, 2S2P es un pack de cuatro celdas formado por dos parejas en paralelo conectadas en serie.

• Usa celdas idénticas: en un pack en serie o en paralelo usa baterías de la misma marca, capacidad, antigüedad y nivel de carga; la celda más débil se agota antes que las demás y sufre.
• Iguala las tensiones antes de conectar en paralelo: antes de unir celdas de iones de litio en paralelo, la diferencia de tensión entre ellas no debe superar 0,1 V; si no, la celda llena empuja una corriente grande y descontrolada hacia la vacía.
• Los packs de litio en serie necesitan protección: a partir de 2S usa una placa BMS con balanceo que vigile cada celda por separado. Un pack en serie no se puede cargar con un módulo TP4056, que solo carga una celda.
• No mezcles recargables y desechables: no pongas pilas alcalinas y de NiMH en el mismo pack; sus tensiones y resistencias internas son distintas.
• El paralelo reparte la carga: en un pack 1S2P cada celda lleva la mitad de la corriente, así que dura más y se calienta menos con corrientes altas.

¿Qué es la tasa C de una batería?

La tasa C indica lo rápido que se descarga o se carga una batería en relación con su capacidad. 1C es la corriente que vacía la batería en 1 hora y coincide numéricamente con su capacidad: para una batería de 2000 mAh, 1C = 2 A, 0,5C = 1 A y 20C = 40 A. Calcular el tiempo también es fácil: a 2C la batería se agota en unos 30 minutos y a 0,2C en 5 horas. Los valores como 25C o 50C impresos en las LiPo de drones y modelos RC indican la corriente máxima de descarga continua; una LiPo de 1000 mAh y 25C puede entregar 25 A. En las 18650 este dato suele darse directamente en amperios: las celdas de alta capacidad de 3500 mAh dan 8–10 A, y las de alta descarga de 2500–3000 mAh, 15–30 A de forma continua. En la carga la regla es más estricta: la corriente de carga estándar para celdas de litio ronda 0,5C y como máximo 1C. Un módulo TP4056 que carga a 1 A va bien para una 18650 de 2000 mAh, pero fuerza una LiPo pequeña de 300 mAh a unos 3C; en ese caso debes cambiar la resistencia Rprog del módulo para bajar la corriente de carga.

Medir la capacidad de una batería con Raspberry Pi Pico (MicroPython)

Las 18650 que dicen tener 9900 mAh son casi siempre falsas; las 18650 auténticas de mayor capacidad del mercado rondan los 3500–3600 mAh. La única forma de conocer la capacidad real de una batería es descargarla a través de una carga conocida y sumar la corriente a lo largo del tiempo. Con una Raspberry Pi Pico, una resistencia de carga y un MOSFET puedes montar un sencillo medidor de capacidad: la Pico conecta la carga mediante el MOSFET, mide la tensión de la batería a través de un divisor de tensión, calcula la corriente con I = V / R y desconecta la carga cuando la tensión llega al valor de corte. Puedes comprobar los valores del divisor con la calculadora de divisor de tensión, y tienes los detalles del conexionado del MOSFET en Cómo usar un 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

Cada 30 segundos el código mide la tensión de la batería con carga, calcula la corriente y suma los mAh y Wh consumidos; muestra los resultados en la consola de Thonny y además los guarda en el archivo desarj.csv de la memoria flash de la Pico. Después puedes abrir ese archivo en Excel y dibujar la curva de descarga (Pasar datos de Arduino a Excel). Con la carga de 10 Ω, la prueba de una 18650 de 3000 mAh dura unas 8–9 horas. Para obtener un resultado preciso, mide la resistencia de carga con un multímetro y escribe su valor en R_LOAD; luego compara la tensión de la batería con la del multímetro y corrige el factor DIV. Si vas a probar una AA de NiMH, baja CUTOFF a 1,0 V y la resistencia de carga a 4,7 Ω. A 4,2 V la resistencia de carga disipa unos 1,8 W; elige una de al menos 5 W, mantenla lejos de superficies inflamables y no dejes la prueba sin vigilancia. Si todavía no sabes instalar MicroPython en la Pico, empieza por ¿Qué es la Raspberry Pi Pico?.

Ideas de proyectos con cálculo de baterías

• Sensor de jardín que dura meses: mantén un ESP32 en deep sleep, mide la humedad del suelo una vez por hora y baja la corriente media de 1 mA.
• Voltímetro con indicador de batería: mide la tensión de la batería y muéstrala como porcentaje en un LCD (Cómo hacer un voltímetro con Arduino).
• El pack adecuado para un coche robot: mide la corriente de los motores y calcula cuántos minutos durará un pack 2S de 18650 (Cómo hacer un coche robot con Arduino).
• Registrador de consumo: guarda las lecturas del INA219 en una tarjeta SD para obtener el perfil energético diario de un aparato (Módulo de tarjeta SD).
• Estación de prueba de capacidad para 18650: añade una pantalla OLED al medidor con Pico y muestra los mAh en directo.
• Estación meteorológica a batería: haz funcionar durante meses con una sola 18650 un ESP32 que envía datos del DHT11 cada 10 minutos.

Errores frecuentes y cómo solucionarlos

Ya conoces la diferencia entre mAh y Wh, sabes cómo medir la corriente de tu proyecto y cómo calcular cuántas horas o días durará una batería. Como siguiente paso, echa un vistazo a Cómo alimentar Arduino con batería y Cargar una 18650 con el TP4056. En la app BlueGrays encontrarás proyectos a batería como el ahorro de energía con deep sleep del ESP32, un voltímetro digital con LCD, un coche robot controlado por Bluetooth y un robot que esquiva obstáculos, cada uno con esquemas de circuito y código paso a paso.