Guías · 10 min de lectura

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.

LED de 5 mm
LED de 5 mm: para el efecto vela elige amarillo, naranja o blanco cálido; los LED azules o blanco frío no parecen una llama.

¿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 LEDTensión directa (aprox.)Resistencia (Uno, 5 V)Resistencia (Pico, 3,3 V)Aspecto de vela
Amarillo2,0–2,1 V220 Ω (~13 mA)220 Ω (~6 mA)Muy bueno, el color clásico de vela
Naranja / ámbar2,0–2,1 V220 Ω (~13 mA)220 Ω (~6 mA)El tono más cálido y realista
Blanco cálido3,0–3,2 V150 Ω (~12 mA)No recomendado (muy tenue)Brillante, como una vela LED moderna
Rojo1,8–2,0 V220 Ω (~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

C++ (Arduino IDE)
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ámetroPor defectoSi lo bajasSi lo subes
FLAME_MIN90La llama parpadea más hondo y parece que se va a apagarLa llama se calma y arde casi fija
FLAME_MAX255La vela queda más tenue, como una luz quitamiedos255 es el máximo; para más brillo hace falta más corriente en el LED
CHANGE_CHANCE8 (%)Una llama tranquila en una habitación sin corrientesParpadeo rápido y nervioso que cansa al rato
GUST_CHANCE3 (%)Casi nunca hay corriente de aireUna llama que se inclina a menudo, como con la ventana abierta
SMOOTH41–2: saltos bruscos, como una bombilla averiada8 o más: oscilaciones de brillo lentas, como olas
STEP_MS25 msUna llama más rápida y vivaA partir de 50 ms parece cámara lenta
Al ajustar, cambia un parámetro cada vez y mira el LED a través de un papel o un cristal esmerilado, no directamente; en un LED desnudo el parpadeo siempre parece más brusco de lo que es. Para la mayoría, el resultado más natural sale con FLAME_MIN en 80–110, SMOOTH en 3–5 y CHANGE_CHANCE en 6–10.

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ónArduino Uno / NanoRaspberry Pi Pico
Vela 1 (resistencia hacia la pata larga del LED)D3GP14
Vela 2D5GP15
Vela 3D6GP16
Vela 4D9GP17
Patas cortas de los LEDGNDGND
Pulsador (la otra pata a GND)D2GP2
Conecta las velas solo a pines con PWM: en el Uno y el Nano son el 3, 5, 6, 9, 10 y 11 (marcados con ~ en la placa). Un LED en otro pin no parpadea con analogWrite(); queda apagado con valores por debajo de 128 y encendido del todo por encima. Conecta el pulsador al pin 2, porque el sketch se despierta del modo de reposo con la interrupción de ese pin (INT0). Para el mapa de pines del Nano, consulta la guía pines del Arduino Nano.
Arduino Nano
Arduino Nano: el mismo procesador ATmega328P y los mismos pines PWM que el Uno, pero tan pequeño que cabe en la base de una corona.

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.

C++ (Arduino IDE)
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ódigoFunción
level[i], target[i]Brillo y objetivo propios de cada vela; las cuatro llamas parpadean de forma independiente
i >= litCountApaga 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 1Una EEPROM nunca escrita lee 255; en el primer arranque empieza con una vela
ON_TIMEA 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ónCapacidad útilTardes 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 tardesHay que recargarlas 4–5 veces durante el Adviento
18650 + TP4056 + elevador a 5 V~1.600 mAh (a 5 V)~4 tardesSe carga por USB y cabe en una caja
Batería externa USB de 10.000 mAh~6.300 mAh (a 5 V)~16 tardesPuede apagarse sola en reposo por la baja corriente
Cargador USB de 5 V 1 AIlimitadaIlimitadasLa solución más cómoda para una corona en la mesa
No conectes cuatro pilas AA alcalinas directamente al pin 5V: las alcalinas nuevas llegan a sumar hasta 6,4 V y, en el pin 5V, que se salta el regulador, eso supera el límite de 5,5 V del procesador. Una pila de 9 V tampoco es buena idea; tiene unos 500 mAh y el regulador de VIN convierte el exceso de tensión en calor. Si quieres una vela que dure mucho con pilas, un Arduino Pro Mini sin el LED de encendido baja la corriente en reposo a microamperios.

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.

MicroPython
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íntomaCausa probableSolución
El LED no parpadea, o está encendido o apagadoEl LED está en un pin sin PWMPasa el LED al pin 3, 5, 6, 9, 10 u 11
La llama tiembla como un fluorescente estropeadoSMOOTH es demasiado pequeño o el objetivo cambia en cada pasoPon SMOOTH en 4–6 y baja CHANGE_CHANCE por debajo de 10
Todas las velas parpadean igual a la vezSe escribe una sola variable level en todos los pinesUsa arrays level y target separados para cada vela
La placa no se despierta del reposoEl pulsador no está en D2 o la interrupción no es por nivel LOWConecta el pulsador a D2 y usa attachInterrupt(..., LOW)
El mismo patrón de parpadeo en cada arranqueNo se llamó a randomSeed o A0 está conectado a algoLlama a randomSeed(analogRead(A0)) con un pin analógico al aire
Las pilas se agotan en pocos díasEl LED de encendido y el chip USB del Nano consumen incluso en reposoUsa un cargador o pasa a un Pro Mini sin LED de encendido
Observa una vela real unos minutos en una habitación a oscuras y cuenta cada cuánto cambia el brillo; después ajusta STEP_MS y CHANGE_CHANCE según lo que hayas visto. La mayoría de las llamas oscilan visiblemente dos o tres veces por segundo y solo se inclinan de verdad cada pocos minutos.

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.

Ver todos los proyectos
Parpadeo de LED
AR-1Principiante

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.

4.6(200)
1246
Dos LED parpadeando alternadamente
AR-2Principiante

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.

4.6(110)
362
Encender y apagar un LED con un botón
AR-10Principiante

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.

4.7(103)
177
Uso de Led RGB
AR-39Principiante
Premium

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…

4.9(73)
100
Transición de color suave con Led RGB
AR-40Principiante
Premium

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.

4.8(58)
78
ESP32 LED Fade con PWM
ES-8Principiante

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.

4.8(36)
55
Brillo de LED con Potenciómetro en ESP32 (Analógico → PWM)
ES-13Intermedio
Premium

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.

4.5(19)
32
Raspberry Pi Pico PWM LED Fade (Efecto Respiración)
PI-14Principiante

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.

4