Conectar pilas en serie y paralelo: voltaje, capacidad y Arduino
Al conectar pilas en serie suma el voltaje; en paralelo, la capacidad. Ejemplos con AA, 9 V y 18650, portapilas y la combinación ideal para Arduino.
Conectar pilas en serie significa unir el positivo de una con el negativo de la siguiente para sumar los voltajes: si conectas cuatro pilas AA de 1,5 V en serie obtienes 6 V, pero la capacidad sigue siendo la de una sola pila. En paralelo se unen todos los positivos entre sí y todos los negativos entre sí; el voltaje no cambia, pero se suman la capacidad y la corriente que se puede entregar. Cuando quieras sacar tu proyecto con Arduino, ESP32 o Raspberry Pi Pico del enchufe y hacerlo portátil, saber cuántas pilas usar y cómo conectarlas decide si funcionará durante horas o solo unos minutos.
En este artículo verás con fórmulas cómo la conexión en serie y en paralelo cambia el voltaje y la capacidad. Te explicamos paso a paso ejemplos reales con pilas AA, de 9 V y 18650, por qué es peligroso mezclar pilas distintas, cómo elegir el portapilas correcto y cómo encontrar la combinación adecuada para tu placa. Al final tienes código listo para medir el nivel de batería con un divisor de tensión en Arduino, ESP32 y Pico.

¿Qué es conectar pilas en serie y cómo funciona?
En serie colocas las pilas una tras otra como una cadena: el positivo de la primera va al negativo de la segunda, el positivo de la segunda al negativo de la tercera, y el negativo libre del principio y el positivo libre del final son los terminales del pack. Como la corriente pasa por todas las pilas una tras otra, todas llevan la misma corriente y los voltajes se suman: V_total = V1 + V2 + … + Vn. La capacidad no se suma; cuatro pilas de 2500 mAh en serie siguen dando 2500 mAh, porque todas se descargan a la vez con la misma carga. Por ejemplo, cuatro AA alcalinas dan 4 × 1,5 = 6 V y dos celdas 18650 dan 2 × 3,7 = 7,4 V. En electrónica el número de celdas en serie se indica con la letra "S": 2S son dos celdas en serie y 3S, tres.
Conexión en paralelo: mismo voltaje, más capacidad
En paralelo todos los terminales positivos se unen en un punto y todos los negativos en otro. El voltaje es el de una sola pila, pero la capacidad se suma: C_total = C1 + C2 + … + Cn. Como la corriente de la carga se reparte entre las pilas, cada una trabaja menos, el pack dura más y puede entregar más corriente sin problemas. El número de celdas en paralelo se indica con "P"; un 2S2P es un pack de cuatro celdas en el que dos grupos en serie se conectan en paralelo, y con 18650 de 2500 mAh ofrece 7,4 V y 5000 mAh. Para saber cuánta energía lleva realmente un pack, mira los vatios-hora: E (Wh) = V × Ah. Cuatro pilas de 1,5 V y 2,5 Ah dan 15 Wh tanto en serie (6 V × 2,5 Ah) como en paralelo (1,5 V × 10 Ah); la forma de conectarlas no cambia la energía, sino con qué voltaje y corriente se entrega.
| Característica | Serie | Paralelo | Serie-paralelo (2S2P) |
|---|---|---|---|
| Conexión | Positivo con el negativo de la siguiente | Positivos juntos y negativos juntos | Dos grupos en serie conectados en paralelo |
| Voltaje | Se suma (n × V) | No cambia (V) | 2 × V |
| Capacidad (mAh) | No cambia (C) | Se suma (n × C) | 2 × C |
| Capacidad de corriente | La de una sola pila | n veces mayor | 2 veces mayor |
| Ejemplo con 4 × AA (1,5 V, 2500 mAh) | 6 V, 2500 mAh | 1,5 V, 10.000 mAh | 3 V, 5000 mAh |
| Energía total | 15 Wh | 15 Wh | 15 Wh |
Tipos de pilas: comparación de AA, 9 V y 18650
| Pila | Voltaje nominal | Voltaje lleno / vacío | Capacidad típica | ¿Recargable? |
|---|---|---|---|---|
| AA alcalina | 1,5 V | 1,6 V / 0,9–1,0 V | 2000–2800 mAh | No |
| AA NiMH | 1,2 V | 1,4 V / 1,0 V | 1900–2500 mAh | Sí |
| 9 V alcalina | 9 V | 9,5 V / unos 6 V | 400–550 mAh | No |
| 9 V NiMH | 8,4 V | unos 9,8 V / 7 V | 170–300 mAh | Sí |
| 18650 Li-ion | 3,6–3,7 V | 4,2 V / 2,5–3,0 V | 2000–3500 mAh | Sí (con circuito de carga específico) |

Ejemplos prácticos: ¿cuántos voltios da cada combinación?
| Combinación | Voltaje | Capacidad | Uso adecuado |
|---|---|---|---|
| 2 × AA en serie | 3 V (NiMH: 2,4 V) | unos 2500 mAh | Circuitos con LED, circuitos sencillos de 3 V |
| 3 × AA en serie | 4,5 V | unos 2500 mAh | VSYS de la Pico, pin 5V de Arduino (se debilita al agotarse) |
| 4 × AA NiMH en serie | 4,8 V | unos 2000 mAh | Pin 5V de Arduino, servomotores |
| 4 × AA alcalinas en serie | 6 V (6,4 V si son nuevas) | unos 2500 mAh | Servos y motores DC; no se conecta directamente al pin 5V de la Uno |
| 6 × AA en serie | 9 V | unos 2500 mAh | VIN o jack DC de Arduino, alimentación del motor L298N |
| 1 × 9 V | 9 V | unos 500 mAh | Pruebas breves con Arduino, circuitos de baja corriente |
| 1S 18650 | 3,7 V (lleno 4,2 V) | 2000–3500 mAh | ESP32 (con LDO), VSYS de la Pico |
| 2S 18650 en serie | 7,4 V (lleno 8,4 V) | 2000–3500 mAh | VIN de Arduino Uno / Nano, coche robot |
| 1S2P 18650 | 3,7 V | 4000–7000 mAh | Proyectos ESP32 y Pico de larga duración |
El riesgo de mezclar pilas distintas
En un pack en serie todas las pilas llevan la misma corriente, así que la más débil se agota primero. Las demás, aún cargadas, siguen empujando corriente a través de la pila agotada y esta se carga en sentido inverso (inversión de celda). El resultado es calentamiento, salida de gas y, en las alcalinas, una fuga blanca y corrosiva que destruye los muelles del portapilas y las pistas de cobre de la placa. En paralelo el peligro es distinto: la pila con más voltaje inyecta corriente directamente en la de menos voltaje. Como la resistencia interna de las pilas es muy baja (unos 20–50 mΩ en una 18650), incluso una diferencia de 0,3 V entre dos celdas supone varios amperios de corriente descontrolada que calientan las celdas. Por eso mezclar nuevas con viejas, alcalinas con NiMH o pilas de 2000 mAh con otras de 3000 mAh desperdicia capacidad y además es un riesgo de seguridad.
- Misma química: nunca pongas celdas alcalinas, NiMH y Li-ion en el mismo pack; sus voltajes y curvas de descarga son diferentes.
- Misma marca, modelo y capacidad: las resistencias internas deben ser parecidas; la celda de menor capacidad siempre se agota antes.
- Misma edad y nivel de carga: cambia todas las pilas del pack a la vez; sustituir una sola por una nueva desequilibra el conjunto.
- Iguala el voltaje antes de conectar celdas Li-ion en paralelo: la diferencia entre celdas debe ser inferior a 0,05 V; mídela con el multímetro y, si hace falta, carga las celdas por separado.
- Usa un BMS en packs Li-ion en serie: los packs 2S o 3S deben llevar una placa de protección con equilibrado (BMS) que proteja las celdas contra sobrecarga, sobredescarga y cortocircuito.
- Fusible contra cortocircuitos: en packs que pueden dar mucha corriente, un fusible pequeño o un polyfuse en la línea positiva reduce mucho el riesgo de incendio.
¿Cómo elegir el portapilas?

- El número de huecos determina el voltaje: los portapilas AA y AAA comerciales casi siempre van en serie internamente; elige el voltaje que necesitas según el número de huecos.
- Modelos con interruptor y tapa: un portapilas con interruptor te permite cortar el circuito sin sacar las pilas; con tapa, evita que las pilas salgan despedidas en robots en movimiento.
- Comprueba el cableado en portapilas de 18650: algunos portapilas dobles de 18650 están cableados en serie (7,4 V) y otros en paralelo (3,7 V). Antes de conectarlo al circuito, pon las pilas y mide los terminales de salida con el multímetro.
- Capacidad de corriente: los muelles y cables finos de los portapilas baratos provocan una caída de tensión notable a unos cientos de miliamperios. En robots con motores DC elige portapilas con cables gruesos y muelles firmes.
- Clip para pila de 9 V: la pila de 9 V se conecta a la entrada de alimentación de Arduino con un clip a presión y, opcionalmente, un adaptador de jack DC; si los extremos descubiertos del clip se tocan, se cortocircuita la pila.
- Longitud de las celdas protegidas: las 18650 con circuito de protección pueden llegar a 67–70 mm y no caber en portapilas cortos; comprueba la longitud que admite el portapilas antes de comprar.
La combinación adecuada para Arduino, ESP32 y Pico
| Placa | Entrada de alimentación | Rango aceptado | Pila recomendada |
|---|---|---|---|
| Arduino Uno / Nano | Pin VIN o jack DC (Uno) | Se recomiendan 7–12 V | 2S 18650 (7,4 V) o 6 × AA (9 V) |
| Arduino Uno / Nano | Pin 5V | 5 V regulados (máximo 5,5 V) | 4 × AA NiMH (4,8 V) o un pack con regulador |
| Placa de desarrollo ESP32 | Pin 5V / VIN | 5 V (van al regulador de 3,3 V de la placa) | 1S 18650 + elevador a 5 V o 4 × AA NiMH |
| Placa de desarrollo ESP32 | Pin 3V3 | 3,0–3,6 V | 1S 18650 + regulador de 3,3 V de baja caída (LDO) |
| Raspberry Pi Pico | Pin VSYS | 1,8–5,5 V | 1S 18650, 3 × AA alcalinas o 3 × AA NiMH |
Para calcular a grosso modo cuánto durará la pila usa esta fórmula: tiempo (horas) = capacidad (mAh) / corriente media (mA) × 0,8. El coeficiente 0,8 es el margen para las pérdidas del regulador, la temperatura y que la pila no se descarga por completo. Un Arduino Uno consume por sí solo unos 45–50 mA; con unos sensores y LED llega a 60 mA. Con un pack 2S 18650 de 2500 mAh funciona 2500 / 60 × 0,8 ≈ 33 horas. El mismo circuito con una pila de 9 V de 500 mAh dura solo 500 / 60 × 0,8 ≈ 6,5 horas, y como el voltaje de la pila de 9 V cae rápido bajo carga, el tiempo real es aún menor. Un ESP32 con Wi-Fi activo consume de media 80–120 mA, con picos de hasta 250 mA; por eso, en proyectos con ESP32, una 18650 o un pack 1S2P junto con el sueño profundo permite funcionar días e incluso semanas. Si no quieres hacer el cálculo a mano, puedes usar la calculadora de duración de batería.
Medir el voltaje de la pila: conexión del divisor de tensión
La forma más fácil de saber cuánta carga le queda a la pila es medir su voltaje. Pero los 8,4 V de un pack 2S superan los 5 V que soporta la entrada analógica de Arduino, y los 4,2 V de una celda 1S superan el límite de 3,3 V del ESP32 y la Pico. Por eso montas un divisor de tensión con dos resistencias: V_salida = V_pila × R2 / (R1 + R2). Dos resistencias iguales reducen el voltaje exactamente a la mitad; 8,4 V pasan a 4,2 V y 4,2 V a 2,1 V. Como el divisor consume corriente continuamente, usa resistencias de 100 kΩ en ESP32 y Pico para cuidar la duración de la pila; en la Uno bastan 10 kΩ para una lectura estable del ADC y a 8,4 V gastan solo 0,42 mA. Puedes ajustar los valores a tu pack con la calculadora de divisor de tensión.
| Conexión | Arduino Uno (2S 18650) | ESP32 (1S 18650) | Raspberry Pi Pico (1S 18650) |
|---|---|---|---|
| Positivo de la pila (+) | Extremo superior de R1 y VIN | Extremo superior de R1 y entrada del LDO | Extremo superior de R1 y VSYS |
| Punto medio R1 – R2 | A0 | GPIO 34 | GP26 (ADC0) |
| Extremo inferior de R2 | GND | GND | GND |
| Negativo de la pila (−) | GND | GND | GND |
| Valores de resistencia | R1 = R2 = 10 kΩ | R1 = R2 = 100 kΩ | R1 = R2 = 100 kΩ |
| Voltaje máximo en el pin | 4,2 V | 2,1 V | 2,1 V |
Indicador de nivel de batería con Arduino
- Pon dos celdas 18650 en el portapilas doble conectado en serie y comprueba con el multímetro que la salida está entre 7,4 y 8,4 V.
- Conecta el cable positivo del portapilas al pin VIN de la Uno (o al adaptador de jack DC) y el negativo a GND.
- Conecta dos resistencias de 10 kΩ en serie entre el positivo de la pila y GND; lleva el punto de unión de las dos resistencias a A0.
- Usarás el LED integrado de la placa (pin 13) como aviso de batería baja; no necesitas ningún componente extra.
- Sube el código, abre el Monitor Serie a 9600 baudios y compara el voltaje que aparece con el valor que muestra el multímetro.
1const int BAT_PIN = A0; // bölücü orta noktası / divider midpoint
2const int LED_PIN = 13; // düşük pil uyarısı / low battery warning
3const float R1 = 10000.0; // üst direnç / top resistor
4const float R2 = 10000.0; // alt direnç / bottom resistor
5const float VREF = 5.0; // ADC referansı / ADC reference
6const float V_EMPTY = 6.4; // 2S boş (2 x 3,2 V) / 2S empty
7const float V_FULL = 8.4; // 2S dolu (2 x 4,2 V) / 2S full
8const float V_LOW = 6.8; // uyarı eşiği / warning threshold
9
10void setup() {
11 Serial.begin(9600);
12 pinMode(LED_PIN, OUTPUT);
13}
14
15void loop() {
16 long sum = 0;
17 for (int i = 0; i < 16; i++) { // 16 ölçümün ortalaması / average of 16 samples
18 sum += analogRead(BAT_PIN);
19 delay(2);
20 }
21 float raw = sum / 16.0;
22 float vPin = raw * VREF / 1023.0; // pindeki gerilim / voltage at the pin
23 float vBat = vPin * (R1 + R2) / R2; // pil gerilimi / battery voltage
24 int pct = (int)((vBat - V_EMPTY) / (V_FULL - V_EMPTY) * 100.0);
25 pct = constrain(pct, 0, 100); // 0-100 aralığında tut / keep within 0-100
26
27 Serial.print(F("Pil / Battery: "));
28 Serial.print(vBat, 2);
29 Serial.print(F(" V %"));
30 Serial.println(pct);
31
32 digitalWrite(LED_PIN, vBat < V_LOW ? HIGH : LOW); // pil zayıfsa LED yanar / LED on when battery is low
33 delay(1000);
34}Para reducir el ruido, el código toma 16 lecturas de A0 y calcula su media. El valor bruto está entre 0 y 1023; se multiplica por la referencia de 5 V y se divide entre 1023 para obtener el voltaje en el pin, y luego se multiplica por la relación del divisor, (R1 + R2) / R2 = 2, para obtener el voltaje de la pila. El cálculo del porcentaje considera 6,4 V (3,2 V por celda) como vacío y 8,4 V como lleno. Como la curva de descarga de una Li-ion no es lineal, este porcentaje es solo una estimación aproximada: la celda pasa la mayor parte del tiempo entre 3,6 y 3,9 V y al final cae rápidamente. Cuando el voltaje baja de 6,8 V, el LED integrado se enciende y avisa de que es hora de cargar la pila. Como la medición toma como referencia la línea de 5 V de la placa, alimentando por USB una tensión baja de 4,8 V puede desplazar la lectura unos puntos porcentuales; para un resultado más preciso, cambia la constante VREF por el valor real que midas en el pin 5V.
Medir la pila con ESP32 y Raspberry Pi Pico
Una sola celda 18650 es la fuente de alimentación más práctica para ESP32 y Pico. En el ESP32, conecta el punto medio del divisor al GPIO 34; este pin pertenece al canal ADC1 y se puede leer también con el Wi-Fi activo (los pines ADC2 chocan con el Wi-Fi). La función analogReadMilliVolts(), disponible en las versiones 2.x y 3.x del núcleo de Arduino, devuelve directamente milivoltios usando la calibración de fábrica de la placa, así que no tienes que lidiar con la no linealidad del ADC del ESP32. En la Pico puedes conectar la celda directamente al pin VSYS, porque el convertidor buck-boost de la placa transforma una entrada de 1,8–5,5 V en 3,3 V. Conecta la salida del divisor a GP26; en MicroPython, read_u16() devuelve un valor entre 0 y 65535. En la Pico estándar, VSYS/3 ya está conectado internamente a GP29 y se puede leer con ADC(29) sin resistencias externas; en la Pico W ese pin se comparte con el chip inalámbrico, por lo que es más seguro un divisor externo.
1const int BAT_PIN = 34; // bölücü orta noktası (ADC1) / divider midpoint (ADC1)
2const float DIVIDER = 2.0; // (R1 + R2) / R2, 100k + 100k
3const float V_EMPTY = 3.2; // boş hücre / empty cell
4const float V_FULL = 4.2; // dolu hücre / full cell
5
6void setup() {
7 Serial.begin(115200);
8 analogReadResolution(12); // 12 bit çözünürlük / 12-bit resolution
9}
10
11void loop() {
12 uint32_t sum = 0;
13 for (int i = 0; i < 16; i++) {
14 sum += analogReadMilliVolts(BAT_PIN); // kalibre mV / calibrated mV
15 delay(2);
16 }
17 float vBat = (sum / 16.0) / 1000.0 * DIVIDER; // pil gerilimi / battery voltage
18 int pct = (int)((vBat - V_EMPTY) / (V_FULL - V_EMPTY) * 100.0);
19 pct = constrain(pct, 0, 100);
20 Serial.printf("Pil / Battery: %.2f V %%%d\n", vBat, pct);
21 delay(2000);
22}1from machine import ADC
2import time
3
4adc = ADC(26) # GP26 = ADC0, bölücü orta noktası / divider midpoint
5DIVIDER = 2.0 # 100k + 100k bölücü / 100k + 100k divider
6V_EMPTY = 3.2 # boş hücre / empty cell
7V_FULL = 4.2 # dolu hücre / full cell
8
9while True:
10 total = 0
11 for _ in range(16): # 16 ölçümün ortalaması / average of 16 samples
12 total += adc.read_u16()
13 time.sleep_ms(2)
14 v_bat = total / 16 * 3.3 / 65535 * DIVIDER # pil gerilimi / battery voltage
15 pct = (v_bat - V_EMPTY) / (V_FULL - V_EMPTY) * 100
16 pct = max(0, min(100, pct)) # 0-100 aralığında tut / keep within 0-100
17 print("Pil / Battery: {:.2f} V %{:.0f}".format(v_bat, pct))
18 time.sleep(2)Ideas de proyectos con pilas
- Coche robot: alimenta tanto el Arduino como el driver de motores con un pack 2S 18650; los detalles están en el artículo cómo construir un coche robot con Arduino.
- Comprobador de pilas: construye un medidor con divisor de tensión y LCD que muestre el nivel de carga de las pilas; el artículo voltímetro con Arduino es un buen punto de partida.
- Estación de sensores de larga duración: un ESP32 con una sola 18650 puede medir, entrar en sueño profundo y enviar datos durante semanas.
- Linterna recargable o lámpara nocturna: monta una lámpara portátil que se carga por USB con una 1S 18650, un módulo de carga TP4056 y unos LED.
- Consola de juegos portátil con Pico: la Pico alimentada por VSYS con 3 × AA se convierte en un juego de bolsillo con una pantalla pequeña y unos botones.
- Alarma de batería baja: un pequeño circuito que hace sonar un zumbador cuando el voltaje del pack baja de un umbral es la forma más barata de proteger tus pilas recargables de la sobredescarga.
Errores comunes y cómo solucionarlos
| Síntoma | Causa probable | Solución |
|---|---|---|
| Arduino se reinicia constantemente | La pila de 9 V no soporta la corriente del motor o servo | Conecta los motores a un pack aparte, usa 2S 18650 o 6 × AA y une los GND |
| El pack da la mitad del voltaje esperado | El portapilas está cableado en paralelo o una pila está al revés | Comprueba la orientación de cada pila y mide la salida con el multímetro |
| Una de las pilas se calienta o tiene fugas | Se han mezclado pilas viejas y nuevas o de tipos distintos | Cambia todas las pilas del pack por otras nuevas del mismo tipo |
| El regulador de la Uno se calienta mucho | Se aplica a VIN más de 12 V (p. ej., dos pilas de 9 V en serie = 18 V) | Mantente en 7–12 V o usa un convertidor buck externo |
| El ESP32 se apaga al conectarse al Wi-Fi | Pila débil o cable fino; el voltaje se hunde en el pico de 250 mA | Usa cable grueso y una celda cargada, y añade un condensador de 470 µF en la línea 3V3 |
| La medición de la pila fluctúa | Divisor de alta resistencia y ruido eléctrico | Haz una media y pon un condensador de 100 nF entre el pin del ADC y GND |
| La pila se calienta con la Pico conectada por USB | No hay protección entre la pila y VSYS; el voltaje USB inyecta corriente en la pila | Añade un diodo Schottky entre la pila y VSYS |
En resumen: si necesitas voltaje, conecta las pilas en serie; si necesitas autonomía y corriente, en paralelo; si necesitas ambas cosas, monta packs serie-paralelo como el 2S2P, y usa siempre pilas del mismo tipo y la misma edad. Para Arduino, un 2S 18650; para ESP32 y Pico, una sola 18650 o 3 × AA son la opción más equilibrada en la mayoría de proyectos. Para más detalles sobre cómo alimentar tu placa, echa un vistazo al artículo alimentación de Arduino. En la app BlueGrays encontrarás muchas aplicaciones, desde circuitos con LED hasta el coche robot y proyectos ESP32 de bajo consumo, con esquema y código paso a paso, y podrás probar enseguida tu nuevo pack de pilas en un proyecto.
Preguntas frecuentes
¿Qué pasa al conectar pilas en serie?
En serie se suman los voltajes de las pilas, mientras que la capacidad sigue siendo la de una sola pila. Por ejemplo, cuatro pilas AA de 1,5 V y 2500 mAh en serie dan un pack de 6 V y 2500 mAh. Como todas llevan la misma corriente, las pilas deben ser del mismo tipo y tener la misma carga.
¿Aumenta el voltaje si las pilas se conectan en paralelo?
No, en paralelo el voltaje es el de una sola pila. Lo que aumenta es la capacidad y la corriente que se puede entregar; dos 18650 de 3,7 V y 3000 mAh en paralelo dan 3,7 V y 6000 mAh. Antes de conectar celdas Li-ion en paralelo hay que igualar sus voltajes.
¿Cuánto dura un Arduino con una pila de 9 V?
Una pila alcalina de 9 V tiene unos 500 mAh y, con un Arduino Uno que consume por sí solo 45–50 mA, puede alimentarlo como máximo entre 6 y 8 horas. Al añadir sensores, LED o motores, ese tiempo baja a pocas horas. En proyectos largos, un pack 2S 18650 o 6 × AA da resultados mucho mejores.
¿Se pueden usar pilas viejas y nuevas juntas?
No se debe. En serie, la pila vieja y débil se agota primero y las demás la cargan en sentido inverso, lo que provoca calentamiento y fugas. Cambia siempre todas las pilas del pack a la vez, de la misma marca, el mismo tipo y nuevas.
¿Puedo alimentar Arduino con 4 pilas AA?
Cuatro pilas AA alcalinas dan 6,4 V cuando son nuevas; es demasiado para el pin 5V y poco para la entrada VIN, así que no es una opción correcta. Cuatro pilas NiMH recargables dan 4,8 V y se pueden conectar al pin 5V. Si vas a usar VIN o el jack DC, elige 6 × AA (9 V) o 2S 18650 (7,4 V).
¿Cómo se cargan pilas 18650 conectadas en serie?
Un pack 2S de dos 18650 en serie se carga con un cargador 2S de 8,4 V y una placa BMS que equilibre las celdas. Los módulos de una sola celda como el TP4056 cargan solo hasta 4,2 V, así que no sirven para un pack 2S. Como alternativa, puedes sacar las celdas del portapilas y cargarlas una por una.
Proyectos para hacer después de leer esto
Ver todos los proyectos
Parpadeo de LED
El primer hola de la electrónica: encender y apagar un solo LED. El Arduino enciende y apaga el LED a intervalos cortos, así que la luz parpadea rápido.

Semáforo
Una copia en miniatura del semáforo que ves cada día en la calle. El rojo se queda dos segundos, el amarillo brilla un instante, el verde se queda dos segundos y luego vuelve al rojo pasando otra vez…

LED Parpadeante con ESP32
Enseña el uso básico de la salida GPIO con ESP32. Conseguimos un efecto de parpadeo encendiendo y apagando un LED desde el pin digital. Versión para ESP32 del clásico proyecto blink en Arduino UNO; los comandos básicos de blink en el entorno Arduino son los mismos, pero la distribución de pines y los niveles GPIO de 3,3 V del ESP32 difieren de los del Arduino UNO.

Parpadeo LED Integrado Raspberry Pi Pico (Pico y Pico W)
¡El proyecto de apertura de la serie Raspberry Pi Pico! Hacemos parpadear el LED verde integrado de la Pico para comprobar que la placa funciona: el clásico primer experimento tipo "Hello World". No hacen falta componentes externos, solo la Pico y un cable USB. El código está escrito en MicroPython, el lenguaje con soporte oficial de la Raspberry Pi Foundation.

Voltímetro digital con pantalla LCD
Descubre cuánto voltaje da una pila o un adaptador con un medidor hecho por ti. Un divisor de dos resistencias baja la tensión alta a un nivel que la placa puede leer, y el Arduino calcula el valor…

Coche controlado por Bluetooth con L298N
Convierte tu móvil en un mando y conduce tu propio coche robot. El Arduino recibe por un módulo Bluetooth las órdenes de una app de control remoto en el móvil y mueve las ruedas con un controlador de…

Robot para evitar obstáculos
¿Qué le parece construir un vehículo inteligente que encuentre su propio camino? El Robot Evitador de Obstáculos explora constantemente su entorno gracias al sensor ultrasónico que lleva delante.

Modo de suspensión profunda del ESP32 — Ahorro de batería (OLED + contador en RTC RAM)
El modo Deep Sleep del ESP32 apaga la CPU y la mayoría de los periféricos y reduce el consumo a unos 10µA, algo clave para dispositivos IoT con batería. Este proyecto usa tres fuentes de activación: un temporizador (15 s), un pin externo (EXT0, el botón en GPIO 33) y un pin táctil (T0/GPIO 4). Los contadores marcados con RTC_DATA_ATTR se conservan durante el deep sleep.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

