Vela LED parpadeante Arduino: llama realista y corona de Adviento
Haz una vela LED parpadeante con Arduino: llama realista con PWM y azar suavizado, corona de Adviento de 4 velas, tabla de ajustes, Nano con pilas y Pico.
En este proyecto de vela LED con Arduino haces que un LED normal parpadee como la llama de una vela de verdad usando PWM y aleatoriedad controlada. El resultado es una vela que arde con seguridad en la mesa, en la ventana o en el cuarto de los niños, sin fuego, sin hollín y sin riesgo de que se caiga. La mayoría de las velas LED comerciales repiten un único patrón de parpadeo; cuando escribes tu propio código, decides exactamente lo tranquila o viva que es la llama, el rango en el que brilla y se atenúa y cada cuánto se inclina con una "corriente de aire".
En esta guía encontrarás primero la lógica del efecto de parpadeo y un sketch corto para una vela, y después una tabla que muestra cómo cambia la llama cada parámetro. Luego montarás una corona de Adviento de cuatro velas: cada pulsación del botón enciende una vela más, la elección se guarda en la EEPROM y el circuito se pone a dormir pasadas 6 horas. Por último, verás cómo meterlo en una caja pequeña con un Arduino Nano, el cálculo de duración de las pilas y una versión en MicroPython para la Raspberry Pi Pico.

¿Cómo funciona el efecto de vela LED?
Los pines del Arduino solo pueden dar 0 V o 5 V; para encender un LED a media intensidad, el pin se enciende y apaga cientos de veces por segundo. Esto se llama PWM (modulación por ancho de pulso). El valor de 0 a 255 de analogWrite(pin, valor) fija cuánto tiempo de cada periodo el pin está encendido: 64 equivale a un 25 por ciento de brillo y 191 a un 75 por ciento. En el Uno y el Nano la frecuencia PWM es de unos 980 Hz en los pines 5 y 6 y de unos 490 Hz en los pines 3, 9, 10 y 11; el ojo no ve esa velocidad y percibe el LED fijo pero atenuado. Los detalles están en la guía qué es PWM.
El secreto de una llama realista es suavizar el azar. Si escribes analogWrite(pin, random(0, 256)) cada 20 milisegundos, el LED tiembla como un fluorescente estropeado, porque una llama real nunca salta de cero a pleno brillo de golpe. Es mejor elegir un brillo objetivo al azar y acercar el brillo actual un poco hacia él en cada paso: nivel = nivel + (objetivo − nivel) / 4. El objetivo cambia de vez en cuando y el nivel lo sigue con suavidad. Si añades caídas profundas ocasionales, es decir, la llama inclinándose con una corriente de aire, el ojo lo acepta como una vela real.
Materiales y elección de los LED
| Color del LED | Tensión directa (aprox.) | Resistencia (Uno, 5 V) | Resistencia (Pico, 3,3 V) | Aspecto de vela |
|---|---|---|---|---|
| Amarillo | 2,0–2,1 V | 220 Ω (~13 mA) | 220 Ω (~6 mA) | Muy bueno, el color clásico de vela |
| Naranja / ámbar | 2,0–2,1 V | 220 Ω (~13 mA) | 220 Ω (~6 mA) | El tono más cálido y realista |
| Blanco cálido | 3,0–3,2 V | 150 Ω (~12 mA) | No recomendado (muy tenue) | Brillante, como una vela LED moderna |
| Rojo | 1,8–2,0 V | 220 Ω (~14 mA) | 220 Ω (~6 mA) | Demasiado oscuro solo; bien junto al amarillo |
- Arduino Uno o Nano: El Uno para probar en la mesa y el Nano para meterlo en una caja. Ambas placas comparten pines y código.
- 4 LED amarillos o naranjas y la resistencia de la tabla para cada uno. Puedes calcular las resistencias para otros LED con la calculadora de resistencia para LED.
- 1 pulsador: Para cambiar el número de velas y apagar. Se usa la resistencia pull-up interna, así que no hace falta otra.
- Protoboard y cables jumper, y placa perforada y estaño para una corona permanente.
- Alimentación: Un cargador USB, una batería externa o un portapilas. Elegiremos las pilas con el cálculo de más abajo.
- Cuerpo de la vela: Un trozo de tubo de PVC blanco, una vela vieja vaciada o un vaso de cristal esmerilado; vale cualquier cosa que difumine la luz del LED.
Una vela: el primer sketch de parpadeo
1const byte LED_PIN = 9; // PWM pini, 220 ohm ile LED / PWM pin, LED through 220 ohm
2
3int level = 180; // şu anki parlaklık / current brightness
4int target = 180; // hedef parlaklık / target brightness
5
6void setup() {
7 pinMode(LED_PIN, OUTPUT);
8 randomSeed(analogRead(A0)); // her açılışta farklı titreme / different flicker on every start
9}
10
11void loop() {
12 if (random(100) < 8) { // %8 ihtimalle yeni hedef / 8% chance of a new target
13 target = random(90, 256);
14 if (random(100) < 5) target = 40; // nadir esinti: alev eğilir / rare gust: the flame dips
15 }
16 level += (target - level) / 4; // hedefe yumuşak yaklaş / ease toward the target
17 analogWrite(LED_PIN, level);
18 delay(random(15, 40)); // düzensiz adım / irregular step
19}Conecta el LED con una resistencia de 220 Ω al pin 9, su pata corta a GND, y carga el sketch. En cada vuelta hay un 8 por ciento de probabilidad de elegir un objetivo nuevo entre 90 y 255; con un 5 por ciento de probabilidad el objetivo baja a 40 para una caída profunda. La línea level += (target − level) / 4 suma un cuarto de la diferencia para lograr una transición suave, y la pausa aleatoria de 15–40 ms hace el patrón aún más irregular. La línea randomSeed(analogRead(A0)) usa el ruido del pin A0 al aire para empezar una secuencia aleatoria distinta en cada encendido; sin ella, la vela parpadea igual cada vez.
Tabla de parámetros de parpadeo
| Parámetro | Por defecto | Si lo bajas | Si lo subes |
|---|---|---|---|
| FLAME_MIN | 90 | La llama parpadea más hondo y parece que se va a apagar | La llama se calma y arde casi fija |
| FLAME_MAX | 255 | La vela queda más tenue, como una luz quitamiedos | 255 es el máximo; para más brillo hace falta más corriente en el LED |
| CHANGE_CHANCE | 8 (%) | Una llama tranquila en una habitación sin corrientes | Parpadeo rápido y nervioso que cansa al rato |
| GUST_CHANCE | 3 (%) | Casi nunca hay corriente de aire | Una llama que se inclina a menudo, como con la ventana abierta |
| SMOOTH | 4 | 1–2: saltos bruscos, como una bombilla averiada | 8 o más: oscilaciones de brillo lentas, como olas |
| STEP_MS | 25 ms | Una llama más rápida y viva | A partir de 50 ms parece cámara lenta |
Corona de Adviento de cuatro velas: conexiones
La corona de Adviento es una tradición, muy querida sobre todo en Alemania, Austria y Suiza, en la que se enciende una vela más cada uno de los cuatro domingos antes de Navidad. En 2026 los domingos de Adviento son el 29 de noviembre, el 6 de diciembre, el 13 de diciembre y el 20 de diciembre. En nuestra corona, cuatro LED representan las cuatro velas; una pulsación corta suma una vela encendida (0, 1, 2, 3, 4 y de nuevo 0) y una larga apaga el circuito. Cada vela tiene su propio estado de parpadeo, así que las cuatro llamas parecen independientes y naturales.
| Conexión | Arduino Uno / Nano | Raspberry Pi Pico |
|---|---|---|
| Vela 1 (resistencia hacia la pata larga del LED) | D3 | GP14 |
| Vela 2 | D5 | GP15 |
| Vela 3 | D6 | GP16 |
| Vela 4 | D9 | GP17 |
| Patas cortas de los LED | GND | GND |
| Pulsador (la otra pata a GND) | D2 | GP2 |

Código de la corona de Adviento: una vela más cada domingo
El sketch funciona con millis() en lugar de delay(), así el parpadeo nunca se detiene mientras escucha el pulsador y cuenta el temporizador. Este enfoque se explica en la guía millis frente a delay. Cada 25 ms se actualiza el estado de las cuatro velas, y las que no están encendidas se mantienen con PWM a cero. El número de velas elegido se guarda en la dirección 0 de la EEPROM; aunque desenchufes y vuelvas a enchufar, la corona arranca con el mismo número de velas.
1#include <EEPROM.h>
2#include <avr/sleep.h>
3
4const byte CANDLES = 4;
5const byte CANDLE_PINS[CANDLES] = {3, 5, 6, 9}; // PWM pinleri / PWM pins
6const byte BUTTON_PIN = 2; // buton -> GND, INT0 / button -> GND, INT0
7
8// Titreme ayarları / flicker settings
9const int FLAME_MIN = 90; // en kısık alev / dimmest flame
10const int FLAME_MAX = 255; // en parlak alev / brightest flame
11const byte CHANGE_CHANCE = 8; // her adımda yeni hedef olasılığı (%) / chance of a new target per step (%)
12const byte GUST_CHANCE = 3; // esinti olasılığı (%) / chance of a gust (%)
13const byte SMOOTH = 4; // büyüdükçe alev yavaşlar / higher = calmer flame
14const unsigned long STEP_MS = 25; // adım süresi / step time
15const unsigned long ON_TIME = 6UL * 60 * 60 * 1000; // 6 saat sonra uyku / sleep after 6 hours
16
17int level[CANDLES];
18int target[CANDLES];
19byte litCount = 1; // yanan mum sayısı (0-4) / number of lit candles (0-4)
20unsigned long onSince = 0;
21unsigned long lastStep = 0;
22
23void wakeUp() {} // yalnız uyandırmak için / only used to wake the chip
24
25void goToSleep() {
26 for (byte i = 0; i < CANDLES; i++) analogWrite(CANDLE_PINS[i], 0);
27 while (digitalRead(BUTTON_PIN) == LOW) {} // butonun bırakılmasını bekle / wait for release
28 delay(50);
29 set_sleep_mode(SLEEP_MODE_PWR_DOWN);
30 sleep_enable();
31 noInterrupts();
32 attachInterrupt(digitalPinToInterrupt(BUTTON_PIN), wakeUp, LOW);
33 interrupts();
34 sleep_cpu(); // burada uyur / sleeps here
35 sleep_disable(); // butona basınca buradan devam / resumes here on press
36 detachInterrupt(digitalPinToInterrupt(BUTTON_PIN));
37 while (digitalRead(BUTTON_PIN) == LOW) {} // uyandıran basış sayılmasın / ignore the wake-up press
38 delay(50);
39 onSince = millis();
40}
41
42void flicker() {
43 for (byte i = 0; i < CANDLES; i++) {
44 if (i >= litCount) { // bu mum henüz yakılmadı / not lit yet
45 analogWrite(CANDLE_PINS[i], 0);
46 continue;
47 }
48 if (random(100) < CHANGE_CHANCE) {
49 target[i] = random(FLAME_MIN, FLAME_MAX + 1);
50 if (random(100) < GUST_CHANCE) target[i] = FLAME_MIN / 2; // alev eğilir / the flame bends
51 }
52 level[i] += (target[i] - level[i]) / SMOOTH;
53 analogWrite(CANDLE_PINS[i], level[i]);
54 }
55}
56
57void setup() {
58 pinMode(BUTTON_PIN, INPUT_PULLUP);
59 for (byte i = 0; i < CANDLES; i++) {
60 pinMode(CANDLE_PINS[i], OUTPUT);
61 level[i] = target[i] = 200;
62 }
63 randomSeed(analogRead(A0));
64 litCount = EEPROM.read(0); // son seçimi hatırla / remember the last choice
65 if (litCount > CANDLES) litCount = 1; // boş EEPROM 255 okur / empty EEPROM reads 255
66 onSince = millis();
67}
68
69void loop() {
70 if (digitalRead(BUTTON_PIN) == LOW) {
71 unsigned long pressStart = millis();
72 while (digitalRead(BUTTON_PIN) == LOW) {
73 if (millis() - pressStart > 1500) { // uzun basış: kapat / long press: switch off
74 goToSleep();
75 return;
76 }
77 }
78 if (millis() - pressStart > 50) { // kısa basış: bir mum daha / short press: one more candle
79 litCount = (litCount + 1) % (CANDLES + 1);
80 EEPROM.update(0, litCount);
81 onSince = millis();
82 }
83 }
84
85 if (millis() - onSince > ON_TIME) goToSleep(); // zamanlayıcı / auto-off timer
86
87 if (millis() - lastStep >= STEP_MS) {
88 lastStep = millis();
89 flicker();
90 }
91}| Parte del código | Función |
|---|---|
| level[i], target[i] | Brillo y objetivo propios de cada vela; las cuatro llamas parpadean de forma independiente |
| i >= litCount | Apaga las velas a las que aún no les toca; para el 2.º domingo litCount = 2 |
| EEPROM.update(0, litCount) | No escribe si el valor no ha cambiado, lo que protege la vida de la celda EEPROM |
| si litCount > CANDLES, entonces 1 | Una EEPROM nunca escrita lee 255; en el primer arranque empieza con una vela |
| ON_TIME | A las 6 horas apaga las velas y se duerme; una corona olvidada toda la noche no agota las pilas |
| goToSleep() | Detiene el procesador con SLEEP_MODE_PWR_DOWN; al pulsar el botón, la interrupción INT0 despierta la placa |
En el modo de reposo, el reloj del ATmega328P se para y el procesador baja a microamperios. Para despertarlo se asocia al pin 2 una interrupción por nivel LOW; en el modo power-down solo una interrupción por nivel puede despertar al procesador, así que CHANGE o FALLING no sirven aquí. Al despertar, el código espera a que se suelte el botón para que esa pulsación no cuente también como una vela más. millis() también se detiene durante el reposo, por eso el temporizador se reinicia al despertar.
Tamaño reducido con un Nano y cálculo de duración de pilas
Lo que dura una pila se calcula con duración (horas) = capacidad útil (mAh) / corriente media (mA). Calculemos la corriente de la corona: un LED parpadeante consume de media un 70 por ciento de su corriente máxima, es decir, unos 8–9 mA para un LED de 12 mA. Cuatro velas suman unos 35 mA; si añades los 15–20 mA que consume un Nano clónico, el total es de unos 50 mA. Una tarde de 6 horas gasta 300 mAh. En reposo el procesador casi no consume, pero por el LED de encendido, el chip USB y el regulador de la placa, la mayoría de los Nano clónicos siguen gastando unos pocos mA (normalmente unos 5 mA); 18 horas de reposo suman unos 90 mAh. Puedes probar otros casos con la calculadora de autonomía de baterías.
| Fuente de alimentación | Capacidad útil | Tardes de 6 horas (≈50 mA) | Nota |
|---|---|---|---|
| 3 × AA alcalinas (≈4,5 V, al pin 5V) | ~2.000 mAh | ~5 tardes (con pérdidas en reposo) | Al gastarse las pilas, los LED también se atenúan |
| 4 × AA NiMH recargables (≈4,8 V, al pin 5V) | ~1.900 mAh | ~5 tardes | Hay que recargarlas 4–5 veces durante el Adviento |
| 18650 + TP4056 + elevador a 5 V | ~1.600 mAh (a 5 V) | ~4 tardes | Se carga por USB y cabe en una caja |
| Batería externa USB de 10.000 mAh | ~6.300 mAh (a 5 V) | ~16 tardes | Puede apagarse sola en reposo por la baja corriente |
| Cargador USB de 5 V 1 A | Ilimitada | Ilimitadas | La solución más cómoda para una corona en la mesa |
Versión para Raspberry Pi Pico en MicroPython
En la Pico todos los pines GPIO pueden dar PWM, así que las velas van a GP14–GP17 y el pulsador a GP2. En MicroPython el brillo se fija con duty_u16() de 0 a 65535; el código mantiene los valores de 0 a 255 de la versión de Arduino y los multiplica por 257 para llegar a la misma escala (255 × 257 = 65535). En lugar de la EEPROM, el número de velas se guarda en el archivo mum.txt del sistema de archivos de la Pico. Si guardas el código como main.py, la corona se enciende en cuanto la Pico recibe alimentación.
1from machine import Pin, PWM
2import time, random
3
4PINS = (14, 15, 16, 17) # 4 mum: GP14-GP17, 220 ohm / 4 candles, 220 ohm each
5button = Pin(2, Pin.IN, Pin.PULL_UP) # buton -> GND / button -> GND
6
7FLAME_MIN = 90 # 0-255 ölçeğinde / on a 0-255 scale
8FLAME_MAX = 255
9CHANGE_CHANCE = 8 # yeni hedef olasılığı (%) / chance of a new target (%)
10GUST_CHANCE = 3 # esinti olasılığı (%) / chance of a gust (%)
11SMOOTH = 4
12STEP_MS = 25
13
14leds = []
15for p in PINS:
16 pwm = PWM(Pin(p))
17 pwm.freq(1000) # 1 kHz, göz titreşimi görmez / 1 kHz, no visible strobing
18 leds.append(pwm)
19
20level = [200] * len(PINS)
21target = [200] * len(PINS)
22
23try:
24 with open("mum.txt") as f: # son seçimi oku / read the last choice
25 lit = int(f.read())
26except (OSError, ValueError):
27 lit = 1
28
29
30def save(n):
31 with open("mum.txt", "w") as f:
32 f.write(str(n))
33
34
35last_button = 1
36while True:
37 b = button.value()
38 if b == 0 and last_button == 1: # basıldığı an / the moment it is pressed
39 lit = (lit + 1) % (len(PINS) + 1)
40 save(lit)
41 time.sleep_ms(30) # basit debounce / simple debounce
42 last_button = b
43
44 for i, led in enumerate(leds):
45 if i >= lit:
46 led.duty_u16(0)
47 continue
48 if random.randint(0, 99) < CHANGE_CHANCE:
49 target[i] = random.randint(FLAME_MIN, FLAME_MAX)
50 if random.randint(0, 99) < GUST_CHANCE:
51 target[i] = FLAME_MIN // 2
52 level[i] += (target[i] - level[i]) // SMOOTH
53 led.duty_u16(level[i] * 257) # 0-255 -> 0-65535
54 time.sleep_ms(STEP_MS)Como la Pico funciona a 3,3 V, los LED blanco cálido (unos 3 V de tensión directa) apenas se encienden; usa LED amarillos o naranjas con resistencias de 220 Ω. Esta versión no tiene temporizador ni modo de reposo; si quieres, cuenta 6 horas con time.ticks_ms() y pon todos los valores de duty a cero. Pusimos la frecuencia PWM de la Pico en 1 kHz; con frecuencias más bajas pueden aparecer franjas en los vídeos grabados con el móvil.
Cómo darle un aspecto realista
- Difumina la luz: Lija un poco la punta del LED con lija fina o mete algo de algodón dentro del cuerpo de la vela; brillará todo el cuerpo en vez de un solo punto.
- Llama de dos LED: Pon un LED amarillo y otro naranja en una misma vela, en pines PWM distintos, y hazlos parpadear a velocidades diferentes; así también se mueve el color de la llama. Los seis pines PWM del Uno dan para tres velas así.
- Cuerpo de la vela: Usa tubo de PVC blanco de 2–3 cm de diámetro, una vela real vaciada o un vaso esmerilado. El cuerpo de una vela real es el que mejor difumina la luz.
- Base de la corona: Decora las cuatro velas con ramas de abeto artificial y piñas, esconde el Nano y las pilas bajo la base y pon el pulsador en una esquina fácil de alcanzar.
- Temperatura de color: Si usas LED blanco cálido, una lámina transparente naranja delante acerca la luz al color de una llama real.
Errores frecuentes y soluciones
| Síntoma | Causa probable | Solución |
|---|---|---|
| El LED no parpadea, o está encendido o apagado | El LED está en un pin sin PWM | Pasa el LED al pin 3, 5, 6, 9, 10 u 11 |
| La llama tiembla como un fluorescente estropeado | SMOOTH es demasiado pequeño o el objetivo cambia en cada paso | Pon SMOOTH en 4–6 y baja CHANGE_CHANCE por debajo de 10 |
| Todas las velas parpadean igual a la vez | Se escribe una sola variable level en todos los pines | Usa arrays level y target separados para cada vela |
| La placa no se despierta del reposo | El pulsador no está en D2 o la interrupción no es por nivel LOW | Conecta el pulsador a D2 y usa attachInterrupt(..., LOW) |
| El mismo patrón de parpadeo en cada arranque | No se llamó a randomSeed o A0 está conectado a algo | Llama a randomSeed(analogRead(A0)) con un pin analógico al aire |
| Las pilas se agotan en pocos días | El LED de encendido y el chip USB del Nano consumen incluso en reposo | Usa un cargador o pasa a un Pro Mini sin LED de encendido |
Esta vela LED, hecha con unos pocos LED, resistencias y un pulsador, reúne PWM, temporización con millis(), EEPROM, modo de reposo y cálculo de pilas en un proyecto acogedor. Puedes llevar el efecto vela a tus propios proyectos consultando en la app BlueGrays los esquemas paso a paso y el código de proyectos de luz básicos, como encender un LED, encender y apagar un LED con un pulsador, un cambio de color suave con un LED RGB y la atenuación PWM con ESP32 o Pico.
Preguntas frecuentes
¿Cómo se hace una vela LED parpadeante con Arduino?
Conecta el LED con una resistencia de 220 Ω a uno de los pines PWM del Arduino y cambia su brillo de forma aleatoria pero suave con analogWrite(). El mejor resultado se consigue eligiendo un brillo objetivo al azar y acercando el brillo actual hacia él poco a poco en cada paso. Las caídas profundas ocasionales imitan la llama inclinándose con una corriente de aire.
¿Qué color de LED conviene para una vela LED?
Los LED amarillos o naranjas (ámbar) son los que más se acercan al color de una llama real. Los blanco cálido son más brillantes y recuerdan a las velas LED modernas, pero se quedan tenues en placas de 3,3 V. Los LED azules y blanco frío no parecen una llama.
¿Qué resistencia uso para conectar un LED al Arduino?
A 5 V, una resistencia de 220 Ω para un LED amarillo o rojo y de 150 Ω para uno blanco cálido dan unos 12–14 mA, que es seguro. El valor se calcula con (tensión de alimentación − tensión del LED) / corriente deseada. No poner resistencia puede dañar el LED y el pin del Arduino.
¿Qué pines del Arduino tienen PWM?
En el Arduino Uno y el Nano los pines con PWM son el 3, 5, 6, 9, 10 y 11, marcados con ~ en la placa. Los pines 5 y 6 funcionan a unos 980 Hz y los demás a unos 490 Hz. En la Raspberry Pi Pico todos los pines GPIO pueden dar PWM.
¿Cuánto dura una vela LED con Arduino a pilas?
Una corona de cuatro velas con un Nano consume unos 50 mA; con tres pilas AA de 2.000 mAh, contando las pérdidas en reposo, son unas cinco tardes de 6 horas. Una batería externa de 10.000 mAh dura unas 16 tardes. Para una autonomía larga se usa un Pro Mini sin LED de encendido y el modo de reposo.
¿Qué días se encienden las velas de la corona de Adviento?
En la corona de Adviento se enciende una vela más cada uno de los cuatro domingos antes de Navidad. En 2026 son el 29 de noviembre, el 6 de diciembre, el 13 de diciembre y el 20 de diciembre. Pulsa el botón de este proyecto una vez cada domingo para aumentar el número de velas encendidas.
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.

Dos LED parpadeando alternadamente
Dos LED parpadean rápido por turnos: cuando uno se enciende, el otro se apaga, como si se pasaran una pelota. El Arduino deja cada luz encendida una quinta parte de segundo y luego le toca a la otra.

Encender y apagar un LED con un botón
Pulsas el botón una vez y la luz se enciende, lo pulsas otra vez y se apaga, igual que el interruptor de tu habitación.

Uso de Led RGB
Dentro de un solo LED se esconden tres colores: el LED RGB se enciende en rojo, luego en verde y luego en azul, cada color medio segundo encendido y medio segundo apagado, y la secuencia vuelve a…

Transición de color suave con Led RGB
Un solo LED RGB pasa lentamente del rojo al verde, del verde al azul y vuelve al rojo, en un bucle de arcoíris que nunca se detiene.

ESP32 LED Fade con PWM
Cambiar el brillo del LED suavemente de 0 a max, de max a 0. Controlamos PWM con analogWrite() como en Arduino - la misma sintaxis con ESP32 Arduino Core 3.0+ funciona sin problemas. Pin definición + pinMode + analogWrite es suficiente.

Brillo de LED con Potenciómetro en ESP32 (Analógico → PWM)
En este proyecto controlamos el brillo de un LED de forma analógica mediante un potenciómetro. El pin ADC del ESP32 lee la tensión de 0-3,3 V procedente del potenciómetro y este valor se convierte en una señal PWM (modulación por ancho de pulso) que se envía al LED. Al girar el potenciómetro, el LED se enciende y se apaga gradualmente. Con Arduino Core 3.0+ se usa directamente analogWrite(); en el ESP32-S2/S3, la resolución del ADC es de 12 bits.

Raspberry Pi Pico PWM LED Fade (Efecto Respiración)
¡El LED ya no solo parpadea — respira! Con el PWM (modulación por ancho de pulso) del Raspberry Pi Pico, el brillo sube y baja lentamente. Aprende la clase machine.PWM, duty_u16() (brillo de 16 bits 0–65535), la frecuencia PWM, bucles range() y salida tipo analógica. Base para mezcla de color RGB, control de motores, servos y buzzer.
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

