Alimentar Arduino con batería: pila de 9V, AA, 18650 y pin Vin

Alimentar Arduino con batería es el primer paso para liberar tu proyecto del cable USB del ordenador y convertirlo en un coche robot, un sensor en el jardín o un aparato que llevas en el bolsillo. La respuesta corta: la forma más segura de alimentar un Arduino Uno con pilas es conectar un pack de 7–12 V (6×AA o dos celdas 18650 en serie) al jack DC o al pin Vin, o enchufar un powerbank al puerto USB. El pin 5V solo debe usarse con una fuente de 5 V limpia que hayas medido y ajustado, porque este pin se salta por completo el regulador y las protecciones de la placa.

Una mala alimentación está detrás de muchos de los problemas misteriosos que sufren los principiantes: una placa que se reinicia cada vez que se mueve el servo, una pila de 9V que se agota en pocas horas, un powerbank que se apaga a los pocos segundos o un regulador que quema al tocarlo. En esta guía conocerás cada entrada por la que puedes alimentar un Arduino, qué batería va en cada una, por qué los motores necesitan su propia fuente y cómo calcular el consumo y la autonomía. Al final veremos también qué cambia al alimentar con baterías un ESP32 y una Raspberry Pi Pico.

5 formas de alimentar un Arduino

Dentro del Arduino Uno hay dos caminos de alimentación distintos. Los 5 V que llegan por USB pasan por un fusible rearmable de 500 mA (polyfuse) y un pequeño interruptor MOSFET, y van directos a la línea de 5 V de la placa. La tensión del jack DC pasa primero por un diodo de protección contra polaridad inversa, aparece en ese punto en el pin Vin y luego un regulador LDO de la familia 1117 la baja a 5 V. Los 3,3 V se obtienen de esa línea de 5 V con un segundo regulador más pequeño. Un comparador de la placa vigila Vin: cuando Vin supera unos 6,6 V, desconecta automáticamente la alimentación USB, así las fuentes no se pelean aunque tengas el adaptador y el USB conectados a la vez.

Alimentación por USB: el límite de 500 mA

El USB es la forma más sencilla y mejor protegida de alimentar un Arduino. Un puerto USB 2.0 del ordenador da como máximo 500 mA; el polyfuse del Uno se calienta y corta el circuito cuando la corriente total supera ese valor, y vuelve a conectar solo cuando se enfría. La placa consume unos 45–50 mA, así que quedan unos 400 mA para repartir entre sensores, LED y módulos. Un cargador de móvil o un powerbank funcionan en el mismo puerto USB; la única diferencia es que con cables finos y largos la tensión puede bajar hasta 4,6 V. Mientras la placa se alimenta por USB, cada miliamperio que sacas del pin 5V sale de ese presupuesto de 500 mA. Por eso, colgar un servo o una tira LED de la alimentación USB hace saltar el fusible, y el puerto del ordenador también puede cortar la conexión para protegerse.

Jack DC y pin Vin: ¿por qué 7–12 V?

El regulador de 5 V de la placa es un LDO lineal y necesita en su entrada alrededor de 1–1,2 V más que en la salida para funcionar bien. Si sumas la caída de 0,7–1 V del diodo de protección del jack, necesitas al menos 7 V en el jack para que los 5 V se mantengan firmes. Con una fuente de 6 V, la línea de 5 V baja a 4,2–4,5 V; la placa parece funcionar, pero las lecturas analógicas se desvían y los módulos hacen cosas raras. En el extremo superior el problema es el calor: un regulador lineal convierte la tensión sobrante en calor. La potencia que disipa es P = (Vin − 5 V) × I. Como regla, no hagas que el regulador disipe más de 1 W; a partir de ahí el pequeño encapsulado SOT-223 quema al tocarlo y acaba apagándose solo.

El pin Vin es a la vez entrada y salida. Cuando alimentas la placa por el jack, en Vin tienes la tensión del jack menos unos 0,7–1 V, y puedes alimentar desde ahí una pequeña carga de 9–12 V. Pero como en el camino de la corriente hay un diodo de protección de 1 A, las cargas grandes como los motores deben alimentarse directamente desde la fuente, no desde Vin. Si conectas un portapilas al pin Vin, ese diodo de protección queda fuera: el regulador sigue funcionando, pero si inviertes positivo y negativo nada protege la placa. En los nuevos Uno R4 Minima y R4 WiFi, el jack y Vin aceptan 6–24 V y usan un convertidor conmutado (buck) en lugar de un regulador lineal, así que no se calientan ni siquiera a 12 V. Tienes más detalles en Arduino Uno R4.

Pin 5V: ¿cuándo es seguro saltarse el regulador?

El pin 5V está conectado directamente a la línea de alimentación del ATmega328P y del resto de chips de la placa. Si alimentas por este pin, te saltas el regulador, el diodo contra polaridad inversa y el fusible USB. Por eso la propia documentación de Arduino no recomienda alimentar por los pines 5V y 3.3V. Aun así, bien hecho tiene ventajas: sin la caída y la pérdida de calor del regulador, la batería dura más y puedes dar más corriente a los módulos. Solo hay una condición: la fuente debe estar regulada y medida. El ATmega328P está diseñado para funcionar como máximo a 5,5 V, y 6 V es su límite absoluto; un breve instante por encima puede dañar el chip para siempre.

• Mide primero: comprueba la salida de la fuente con el multímetro antes de conectarla al Arduino; debe estar entre 4,8 y 5,2 V.
• Nada de pilas a pelo: 4 pilas AA alcalinas nuevas llegan a 6,4 V y superan el límite. Conecta al pin 5V solo la salida de un regulador o de un módulo buck o boost.
• Cuidado con el USB a la vez: si conectas el USB mientras alimentas por el pin 5V, dos fuentes de 5 V quedan unidas a través de la placa; lo más seguro es desconectar la alimentación externa mientras subes el código.
• Añade un condensador: un condensador electrolítico de 100–470 µF en la línea externa de 5 V, cerca de la placa, suaviza las caídas durante los picos de consumo (¿qué es un condensador?).
• Soluciones listas: los módulos reguladores con 7805 (regulador de tensión 7805), un LM2596 ajustado a 5,0 V o, para protoboard, el módulo de alimentación MB102 dan 5 V limpios.

Pin 3.3V: ¿cuánta corriente puedes sacar?

El pin 3.3V del Uno no es una entrada de alimentación, sino la salida de un pequeño regulador, y su límite oficial es de 50 mA. Basta para módulos que no pasan de unas decenas de miliamperios, como un BME280, un MPU6050 o un lector RFID RC522. Pero los módulos con picos de corriente altos lo superan: el nRF24L01+PA+LNA con antena pasa de 100 mA al transmitir, el módulo Wi-Fi ESP-01 tiene picos de varios cientos de miliamperios y el SIM800L pide ráfagas de hasta 2 A. Para el nRF24L01+PA+LNA y el ESP-01 usa un módulo regulador AMS1117 de 3,3 V aparte, alimentado desde la línea de 5 V. El SIM800L, en cambio, no funciona a 3,3 V sino a 3,4–4,4 V y supera el límite de 1 A del AMS1117; aliméntalo con una sola celda Li-ion o con un módulo buck ajustado a 4,0 V que dé al menos 2 A. En el Arduino Nano y sus clones, el pin 3.3V suele salir del propio chip USB-serie y es todavía más débil que en el Uno; también ahí es más seguro un regulador aparte. Encontrarás más sobre la alimentación de módulos inalámbricos en la guía del nRF24L01.

Opciones de batería: pila de 9V, AA, 18650 y powerbank

La clásica pila de 9V es la opción más recomendada por su clip con clavija para el jack, pero también la menos eficiente. Lleva dentro seis celdas diminutas, así que su capacidad es de solo unos 400–600 mAh y su resistencia interna es alta; si a los 50 mA del Uno le sumas un servo o unos cuantos LED, la tensión cae pronto por debajo de 7 V y la placa empieza a reiniciarse. En una placa con regulador lineal, los mAh de la batería fijan directamente la autonomía, y los voltios de más solo se convierten en calor. Por eso un portapilas de 6×AA, que da los mismos 9 V, dura unas cuatro veces más que una pila de 9V. Explicamos las unidades de capacidad en detalle en ¿Qué significa mAh?.

Las pilas AA son baratas y se encuentran en todas partes, pero hay que acertar con el número. El error más común es usar 4×AA: 6 V no bastan para el jack, porque tras las caídas del diodo y del regulador solo llegan unos 4,2 V a la línea de 5 V, y conectar el mismo pack al pin 5V supone 6,4 V con pilas nuevas, por encima del límite. Las combinaciones correctas son un pack de 6×AA (9 V) en el jack DC y un pack de 3×AA (4,5 V) directo al pin 5V. Un Uno a 16 MHz con 3×AA empieza a volverse inestable cuando cada pila baja de 1,25 V, así que no puedes aprovechar toda la capacidad. Las pilas recargables NiMH dan 1,2 V por celda, por eso 4×NiMH (4,8 V) también es una opción popular para el pin 5V, aunque las recién cargadas pueden superar 5,5 V durante los primeros minutos.

Batería Li-ion 18650 y convertidor elevador

La 18650 es una celda recargable de iones de litio de 18 mm de diámetro y 65 mm de largo, la que llevan las baterías de portátil y los powerbanks. Su tensión nominal es 3,7 V; llena marca 4,2 V y vacía unos 3,0 V. Su capacidad real está entre 2000 y 3500 mAh; las que anuncian 6800 o 9900 mAh son casi siempre falsas. Una sola 18650 puede usarse con Arduino de dos maneras: subir los 3,7 V a 5 V con un convertidor elevador (boost, por ejemplo un módulo MT3608 o una placa de powerbank 18650) y alimentar el USB o el pin 5V, o conectar dos celdas en serie y enchufar el pack 2S (7,4 V) al jack DC. La segunda es la opción más equilibrada para el Uno: desde 8,4 V, la tensión se mantiene en la zona cómoda del regulador hasta bajar a 3,5 V por celda (7 V en total). Si usas un boost, recuerda que la corriente que sale de la batería es mayor que la de la salida: un circuito que pide 200 mA a 5 V saca unos 307 mA de una celda de 3,7 V con un 88 por ciento de eficiencia.

• La protección es obligatoria: descargar una celda Li-ion por debajo de 3,0 V acorta su vida y puede ser peligroso. Usa celdas protegidas o una placa de protección (BMS).
• El TP4056 es para una sola celda: el módulo TP4056 solo carga una celda (1S) hasta 4,2 V. Nunca cargues un pack 2S en serie con un TP4056; usa un circuito de carga con BMS 2S o un cargador balanceador. Tienes el conexionado en módulo de carga TP4056.
• Ojo con los cortocircuitos: una 18650 puede dar decenas de amperios en cortocircuito; no dejes cables pelados y pon un fusible y un interruptor en la línea de la batería.
• Ajuste del boost: no conectes módulos ajustables como el MT3608 al Arduino sin haber ajustado antes su salida a 5,0 V.
• No mezcles celdas: en un pack en serie usa celdas de la misma marca, capacidad y nivel de carga.

¿Por qué se apaga solo el powerbank?

Un powerbank es un paquete listo con celdas de litio, cargador, protección y boost de 5 V, así que es la forma más cómoda de hacer funcionar un Arduino con batería: basta con enchufar el cable USB. Sin embargo, la mayoría de powerbanks vigilan la corriente de salida para apagarse cuando el móvil está cargado, y cortan la salida en 10–60 segundos cuando la corriente baja de 50–100 mA. Un Nano que consume 20 mA o un Uno que consume 50 mA se quedan por debajo de ese umbral, así que la placa funciona un rato y se apaga sin avisar. Hay dos salidas: elegir un powerbank con modo de baja corriente (en algunos modelos se activa pulsando dos veces el botón) o hacer que el Arduino consuma una carga breve cada cierto tiempo. Para el segundo método, conecta una resistencia de 47 Ω y 1 W desde la línea de 5V al colector de un transistor NPN (BC337 o 2N2222), el emisor a GND y la base al pin D7 a través de una resistencia de 1 kΩ. Cuando el transistor conduce, la resistencia consume unos 5 V / 47 Ω ≈ 106 mA y el powerbank detecta una carga. Puedes comprobar los valores con la calculadora de la ley de Ohm.

1// Powerbank uyanık tutma / powerbank keep-alive
2// D7 -> 1 kΩ -> NPN beyzi, kolektör -> 47 Ω -> 5V / D7 -> 1 kΩ -> NPN base, collector -> 47 Ω -> 5V
3const int LOAD_PIN = 7;
4const unsigned long PERIOD_MS = 8000;  // her 8 saniyede bir / every 8 seconds
5const unsigned long PULSE_MS = 300;    // 300 ms yük / 300 ms of load
6
7unsigned long pulseStart = 0;
8bool loadOn = false;
9
10void setup() {
11  pinMode(LOAD_PIN, OUTPUT);
12  digitalWrite(LOAD_PIN, LOW);
13}
14
15void loop() {
16  unsigned long now = millis();
17  if (!loadOn && now - pulseStart >= PERIOD_MS) {
18    digitalWrite(LOAD_PIN, HIGH);   // ~106 mA çek / draw ~106 mA
19    loadOn = true;
20    pulseStart = now;
21  }
22  if (loadOn && now - pulseStart >= PULSE_MS) {
23    digitalWrite(LOAD_PIN, LOW);    // yükü kapat / switch the load off
24    loadOn = false;
25  }
26  // projenin kodu burada, delay() kullanmadan / your project code here, without delay()
27}

Como el código usa millis() en lugar de delay(), no bloquea el resto del proyecto; explicamos este enfoque en detalle en millis() en lugar de delay(). Consumir 106 mA durante 300 ms cada 8 segundos supone de media solo unos 4 mA extra. Si tu powerbank sigue apagándose, baja el periodo a 5 segundos o alarga el pulso a 500 ms; cada modelo usa un umbral y un tiempo de espera distintos.

Alimentación aparte para motores y servos, GND común

Los motores y los servos son las cargas que más problemas dan al alimentar un Arduino con baterías. Un servo pide un pico de corriente de varios cientos de miliamperios en el instante en que arranca, y los motores DC piden varias veces su corriente normal al arrancar o cuando se bloquean. Ese pico puede hundir un instante la línea de 5 V; si la tensión baja lo suficiente, salta la protección por baja tensión (brown-out) del ATmega328P y la placa se reinicia sola. Además, el ruido de las escobillas de los motores estropea las lecturas de los sensores. La regla es sencilla: alimenta como mucho un servo pequeño desde el pin 5V del Arduino y haz funcionar el resto de motores con otra fuente. Para entender cómo funcionan servos y motores DC, consulta servomotor y control de motores DC con L298N.

1. Elige una fuente aparte para los motores: 5–6 V para los servos (4×AA NiMH o un LM2596 ajustado a 5–6 V) y, para los motores DC, un pack adecuado a su tensión (por ejemplo 2S 18650).
2. Conecta el positivo de esa fuente solo al cable rojo de los servos o a la entrada de potencia del driver de motores; no lo conectes al pin 5V del Arduino.
3. Alimenta el Arduino por su propia entrada: puedes conectar el mismo pack 2S también al jack DC, siempre que la corriente de los motores no pase por el regulador del Arduino.
4. Conecta el negativo (GND) de la fuente al pin GND del Arduino. Sin GND común, la señal de control no funciona.
5. Conecta el cable de señal naranja o amarillo del servo a un pin digital del Arduino (por ejemplo D9); la librería Servo también funciona en pines sin la marca PWM.
6. Añade un condensador electrolítico de 470–1000 µF en la alimentación de los servos, cerca de ellos; respeta la polaridad.
7. Si usas un L298N, mete la alimentación de los motores por el borne de 12V; si supera los 12 V, quita el jumper 5V-EN y alimenta el Arduino con su propia fuente.

¿Cómo se calculan el consumo y la autonomía?

En un proyecto con baterías, la pregunta de verdad es "¿cuánto aguantará?". La fórmula básica es sencilla: Autonomía (horas) = Capacidad (mAh) × 0,85 / Corriente media (mA). El factor 0,85 tiene en cuenta que una batería nunca entrega toda su capacidad nominal: con corrientes altas y con frío la capacidad baja, el circuito se detiene antes de que la batería esté totalmente vacía y los convertidores añaden pérdidas. Con pilas cuya tensión cae pronto, como la de 9V, es más realista usar 0,7. Si tu proyecto pasa la mayor parte del tiempo dormido, calcula primero la corriente media: Corriente media = (Corriente activa × tiempo activo + Corriente en reposo × tiempo en reposo) / tiempo total. En lugar de hacerlo a mano, puedes usar la calculadora de duración de batería; introduces la capacidad, las corrientes despierto y en reposo y el intervalo de activación, y te da la autonomía en horas, días o meses.

Medir siempre es mejor que suponer. Pon el multímetro en la escala de corriente (mA) y conéctalo en serie entre la batería y el circuito para ver el consumo real; te explicamos cómo en cómo usar el multímetro. Si la lectura es mayor de lo esperado, mira primero el consumo propio de la placa: en el Uno, el chip USB-serie (ATmega16U2), el LED de encendido y el regulador consumen más de 30 mA incluso con el ATmega328P dormido. Por eso, en los proyectos que necesitan mucha autonomía se prefieren placas sin chip USB como el Arduino Pro Mini; un Pro Mini sin el LED de encendido ni el regulador baja a microamperios en modo reposo.

Paso a paso: haz que tu proyecto funcione con baterías

1. Con el proyecto funcionando por USB, mide con el multímetro la corriente media y la de pico, también mientras se mueve el servo o el motor.
2. Separa las cargas de alta corriente, como motores, servos y tiras LED, y planifica una fuente aparte para ellas.
3. Elige la entrada de la placa: en el Uno, un pack de 7–12 V al jack DC o 5 V regulados al USB o al pin 5V; en la Pico, 1,8–5,5 V a VSYS.
4. Calcula la capacidad necesaria para la autonomía que quieres o usa la calculadora de duración de batería.
5. Pon un interruptor de encendido en la línea positiva de la batería; asegúrate de que los packs Li-ion llevan placa de protección (BMS).
6. Sube el código por USB, luego desconecta el USB y prueba con baterías; comprueba con el multímetro la tensión en el pin 5V mientras se mueve el servo.
7. Vigila la tensión de la batería en el código y avisa cuando baje de cierto valor (código a continuación).

Medir la tensión de la batería con Arduino

En lugar de adivinar cuándo se agotará la batería, puedes medir su tensión. Las entradas analógicas del Arduino leen como máximo 5 V, así que no puedes conectar a A0 un pack 2S que llega a 8,4 V; necesitas un divisor de tensión. Dos resistencias de 100 kΩ y 10 kΩ dividen la tensión entre 11: 8,4 V se quedan en unos 0,76 V en A0. Como la línea de 5 V de la placa puede variar al debilitarse la batería, es más exacto medir con la referencia interna de 1,1 V, que no depende de la tensión de alimentación. Puedes elegir las resistencias para tu pack con la calculadora de divisor de tensión y leer más en divisor de tensión.

1// 2S Li-ion paket gerilimini ölçme / measuring a 2S Li-ion pack voltage
2// Pil+ -> 100k -> A0 -> 10k -> GND / pack+ -> 100k -> A0 -> 10k -> GND
3const int BAT_PIN = A0;
4const int LED_PIN = 13;      // pil zayıf uyarısı / low-battery warning
5const float R1 = 100000.0;   // üst direnç / top resistor
6const float R2 = 10000.0;    // alt direnç / bottom resistor
7const float VREF = 1.1;      // dahili referans, multimetreyle düzelt / internal reference, calibrate with a multimeter
8const float LOW_V = 6.6;     // 2S için alt sınır (3,3 V/hücre) / low limit for 2S (3.3 V per cell)
9
10void setup() {
11  Serial.begin(9600);
12  pinMode(LED_PIN, OUTPUT);
13  analogReference(INTERNAL);   // 1,1 V referans (Uno/Nano) / 1.1 V reference (Uno/Nano)
14  analogRead(BAT_PIN);         // ilk ölçümü at / discard the first reading
15  delay(10);
16}
17
18void loop() {
19  long sum = 0;
20  for (int i = 0; i < 16; i++) {   // 16 ölçümün ortalaması / average of 16 readings
21    sum += analogRead(BAT_PIN);
22    delay(2);
23  }
24  float pinV = (sum / 16.0) * VREF / 1024.0;
25  float batV = pinV * (R1 + R2) / R2;
26
27  Serial.print("Pil / Battery: ");
28  Serial.print(batV, 2);
29  Serial.println(" V");
30
31  digitalWrite(LED_PIN, batV < LOW_V ? HIGH : LOW);   // zayıfsa LED yanar / LED on when low
32  delay(2000);
33}

Conecta el extremo superior del divisor al positivo de la batería después del interruptor, para que el divisor no la descargue con el aparato apagado. La referencia interna de 1,1 V puede variar alrededor de ±10 % de un chip a otro: compara la tensión que mides con el multímetro con la del monitor serie y corrige VREF (por ejemplo a 1,08). El divisor consume siempre unos 76 µA, algo que prácticamente no afecta a la autonomía. El código es para Uno y Nano; en el Mega la referencia se llama INTERNAL1V1. El umbral de 6,6 V equivale a 3,3 V por celda; en ese punto las celdas están casi vacías, y bajar de 3,0 V por celda las daña. Si el pack va al jack DC, la línea de 5 V empieza a caer hacia los 7 V, así que también tiene sentido poner LOW_V a 7,0.

Alimentar un ESP32 con baterías

Las placas de desarrollo ESP32 funcionan a 3,3 V y se pueden alimentar de tres maneras: por el puerto USB, por el pin 5V (VIN en algunas placas) o directamente por el pin 3V3. Espressif pide de forma explícita que no se usen a la vez, sino solo una de ellas. La tensión del pin 5V pasa por el regulador LDO de 3,3 V de la placa (un AMS1117 en la mayoría de clones), mientras que el pin 3V3 solo admite 3,0–3,6 V regulados. Al transmitir por Wi-Fi, el ESP32 pide picos de hasta 240 mA, así que necesita una fuente capaz de dar al menos 500 mA; si no, se reinicia con el error "Brownout detector was triggered" (detalles en error de brownout). No conectes una 18650 directamente al pin 3V3: con 4,2 V a plena carga supera el límite. El pin 5V tampoco es buena idea, porque el AMS1117 necesita una caída de unos 1,1 V y, al bajar la tensión de la celda, la salida cae por debajo de 3,3 V. Las opciones correctas son una 18650 con boost a 5 V al pin 5V, un regulador de 3,3 V de baja caída (LDO) que dé al menos 500 mA o una placa ESP32 con cargador Li-ion integrado. Lo que de verdad decide la autonomía, eso sí, es que el ESP32 pase la mayor parte del tiempo en sueño profundo (deep sleep); el chip consume unos 10 µA en ese modo, pero el chip USB-serie, el LED y el regulador de las placas de desarrollo pueden llevarlo a miliamperios. De ahí sale la diferencia entre 3 meses y 18 días de la tabla anterior; tienes más detalles en ESP32 deep sleep.

1// ESP32: 18650 gerilimini ölç, sonra derin uykuya geç / measure the 18650, then deep sleep
2// Pil+ -> 100k -> GPIO34 -> 100k -> GND / cell+ -> 100k -> GPIO34 -> 100k -> GND
3const int BAT_PIN = 34;                         // yalnız giriş, ADC1 / input-only, ADC1
4const uint64_t SLEEP_US = 60ULL * 1000000ULL;   // 60 saniye / 60 seconds
5
6void setup() {
7  Serial.begin(115200);
8  uint32_t mv = 0;
9  for (int i = 0; i < 16; i++) {
10    mv += analogReadMilliVolts(BAT_PIN);        // kalibre milivolt / calibrated millivolts
11  }
12  float batV = (mv / 16.0) * 2.0 / 1000.0;      // bölücü yarıya indirir / the divider halves it
13  Serial.printf("Pil / Battery: %.2f V\n", batV);
14
15  if (batV < 3.3) {
16    Serial.println("Pil zayif / Battery low");  // işi atla, pili koru / skip the work, protect the cell
17  } else {
18    // sensörü oku, Wi-Fi ile gönder / read the sensor, send over Wi-Fi
19  }
20
21  esp_sleep_enable_timer_wakeup(SLEEP_US);      // 60 sn sonra uyan / wake up after 60 s
22  Serial.flush();
23  esp_deep_sleep_start();                       // loop() hiç çalışmaz / loop() never runs
24}
25
26void loop() {
27}

En cada despertar, el código mide la tensión de la batería, hace su trabajo y vuelve a dormir con un temporizador de 60 segundos; como el ESP32 reinicia el programa desde el principio al salir del sueño profundo, loop() nunca se ejecuta. GPIO 34 es un pin de solo entrada del ADC1 y funciona con el Wi-Fi activo, mientras que los pines del ADC2 no se pueden usar junto con el Wi-Fi. analogReadMilliVolts() usa la calibración de fábrica del chip para devolver directamente milivoltios. El divisor de 100 kΩ + 100 kΩ convierte 4,2 V en 2,1 V y consume solo 21 µA; si la lectura tiene ruido, añade un condensador de 100 nF entre GPIO 34 y GND. Para tus primeros pasos con el ESP32, ¿Qué es el ESP32? es un buen punto de partida.

Alimentar una Raspberry Pi Pico con baterías

La Raspberry Pi Pico es una de las placas más cómodas para usar con baterías, porque en lugar de un regulador lineal lleva un regulador conmutado buck-boost. Dale al pin VSYS cualquier tensión entre 1,8 y 5,5 V y la placa la convierte de forma eficiente en 3,3 V; sigue funcionando incluso cuando la entrada baja de 3,3 V. Así puedes conectar 2 o 3 pilas AA, una sola 18650 o una LiPo de una celda directamente entre VSYS y GND, sin módulos adicionales. Lo único que debes vigilar es usarla junto con el USB: los 5 V del USB (VBUS) llegan a VSYS a través de un diodo Schottky; si la batería está conectada directamente a VSYS y enchufas el USB, el USB intenta meter corriente en la batería. La solución que recomienda Raspberry Pi es conectar la batería a VSYS a través de su propio diodo Schottky (por ejemplo un 1N5817). El pin 3V3 da como máximo unos 300 mA a circuitos externos, y llevar el pin 3V3_EN a GND apaga el regulador y, con él, toda la placa. Para una visión general de la placa, consulta ¿Qué es la Raspberry Pi Pico?.

1from machine import ADC, Pin
2import time
3
4vsys = ADC(29)            # VSYS/3 ölçer (Pico) / measures VSYS/3 (Pico)
5usb = Pin(24, Pin.IN)     # USB takılıysa 1 / 1 when USB is connected
6CONV = 3.3 / 65535        # ham değeri volta çevir / raw value to volts
7
8while True:
9    total = 0
10    for _ in range(16):   # 16 ölçümün ortalaması / average of 16 readings
11        total += vsys.read_u16()
12    volts = total / 16 * CONV * 3   # kart içindeki bölücü 3'e böler / on-board divider divides by 3
13    source = "USB" if usb.value() else "Pil / Battery"
14    print("{}: VSYS = {:.2f} V".format(source, volts))
15    if not usb.value() and volts < 3.3:   # 3xAA ya da 18650 için alt sınır / low limit for 3xAA or a 18650
16        print("Pil zayif! / Battery low!")
17    time.sleep(5)

En la Pico, GP29 mide un tercio de VSYS mediante un divisor de la propia placa, y GP24 lee 1 cuando el USB está conectado. Así, sin piezas extra, sabes tanto la tensión de la batería como si la placa se alimenta por USB o por batería. Si conectaste la batería con un diodo Schottky, como se recomienda, VSYS se lee unos 0,2–0,3 V por debajo de la tensión de la batería. La medida supone que la referencia del ADC es de 3,3 V; gracias al regulador buck-boost, esa referencia se mantiene estable aunque la batería se debilite. En la Pico W, GP29 y GP24 se comparten con el chip inalámbrico, así que este código no funciona tal cual; allí el estado del USB se lee con Pin("WL_GPIO2"). Para alargar la autonomía, usa machine.lightsleep() en lugar de time.sleep() entre medidas.

Ideas de proyectos con baterías

• Coche robot controlado por Bluetooth: alimenta motores y Arduino con un pack 2S de 18650; los detalles están en cómo hacer un coche con Arduino.
• Robot que esquiva obstáculos: evita los reinicios alimentando los motores por el L298N con una línea aparte y el Arduino por el jack DC (robot esquiva obstáculos).
• Voltímetro con indicador de batería: muestra en un LCD el valor medido con un divisor de tensión (cómo hacer un voltímetro con Arduino).
• Estación de humedad para el jardín: mantén un ESP32 en sueño profundo, mide la humedad del suelo una vez por hora y haz que funcione meses con una sola 18650.
• Registrador GPS portátil: guarda la ruta de tus excursiones con un GPS NEO-6M y un powerbank.
• Luz nocturna con Pico a pilas: una Pico alimentada con 3×AA por VSYS enciende los LED cuando oscurece.

Errores comunes y cómo solucionarlos

Una buena alimentación es la mitad de un proyecto estable: elige bien la entrada, alimenta los motores aparte, une las masas y calcula la autonomía desde el principio. Cuando estés listo para montar un proyecto con baterías, echa un vistazo en la aplicación BlueGrays al coche Bluetooth con L298N, al robot que esquiva obstáculos, a la estación de riego inteligente, al voltímetro digital con LCD y al proyecto de ahorro de batería con deep sleep del ESP32; cada uno explica paso a paso el esquema, las conexiones y el código.