Escalera con luces LED Arduino: sensor PIR y tira WS2812B
Escalera con luces LED con Arduino: dos sensores PIR detectan si subes o bajas, los escalones se encienden uno a uno con WS2812B o MOSFET, LDR y ESP32.
Para una escalera con luces LED con Arduino solo necesitas un Arduino, dos sensores de movimiento y una tira LED: cuando pisas el primer escalón, los escalones se encienden uno tras otro de abajo hacia arriba, y si vienes desde arriba la ola de luz corre en sentido contrario. Unos 15 segundos después del último movimiento, los escalones se apagan en el mismo orden. Los ojos del sistema son dos sensores de movimiento PIR en los extremos inferior y superior de la escalera y una fotorresistencia LDR que evita que se encienda de día; el cerebro es una máquina de estados de pocas líneas.
En esta guía verás los dos caminos: una tira direccionable WS2812B, que controla cientos de LED por separado con un solo cable de datos, y el método clásico con una tira de un solo color de 12 V en cada escalón, que se enciende y apaga suavemente con un MOSFET. Además tienes una tabla de LED y fuente según el número de escalones, el diagrama de conexión, el código para Arduino Uno, un código para 16 escalones con PCA9685 y una versión para ESP32 que ajustas desde el celular.

¿Cómo funciona la iluminación automática de una escalera?
La lógica tiene cuatro estados: reposo, encendiendo, encendida y apagando. En reposo, el Arduino vigila los dos PIR y revisa con la LDR si está oscuro. Si se activa el sensor de abajo, la dirección se guarda como "subir"; si se activa el de arriba, como "bajar", y los escalones se encienden uno a uno con 100–200 ms de separación. Cuando se enciende el último, el sistema se queda en estado encendida; cada nueva activación de un sensor reinicia el tiempo. Si pasa el tiempo fijado sin movimiento, las luces se apagan en la misma dirección, como una ola que sigue a la persona. Esta estructura se llama máquina de estados y todo funciona sin bloqueos gracias a millis(), así que los sensores se siguen leyendo mientras las luces se animan.
| Estado | ¿Qué pasa? | Paso al siguiente estado |
|---|---|---|
| Reposo | LED apagados, se lee la LDR | Con oscuridad, al activarse el PIR de abajo o de arriba pasa a encendiendo |
| Encendiendo | Los escalones se encienden uno a uno en el sentido de la marcha | Al encenderse el último escalón pasa a encendida |
| Encendida | Todos los escalones encendidos, cada movimiento alarga el tiempo | Si pasa el tiempo (p. ej. 15 s) sin movimiento, pasa a apagando |
| Apagando | Los escalones se apagan uno a uno en la misma dirección | Con nuevo movimiento vuelve a encendiendo; con todo apagado, a reposo |
Lista de materiales y dos opciones de circuito
- Arduino Uno o Nano (ESP32 si quieres cambiar los ajustes desde el celular).
- 2 sensores PIR HC-SR501: uno en el escalón de abajo y otro en el de arriba.
- LDR y resistencia de 10 kΩ: un divisor de voltaje para detectar la noche.
- Opción A: tira WS2812B (30 o 60 LED/m), fuente de 5 V, capacitor de 1000 µF y resistencia de 330 Ω.
- Opción B: un tramo de tira LED de un color de 12 V por escalón, un MOSFET IRLZ44N y una resistencia de 10 kΩ por escalón, un módulo PWM PCA9685 de 16 canales y una fuente de 12 V.
- Cables y montaje: cable de 0,75–1,5 mm² (18–16 AWG) para la alimentación, cable delgado multifilar para las señales y perfiles de aluminio con difusor para las tiras.
| Característica | Opción A: WS2812B | Opción B: MOSFET + tira de un color |
|---|---|---|
| Línea de control | Un solo pin de datos | 2 pines I2C con PCA9685 (hasta 16 escalones) |
| Cableado | Cadena de 3 hilos por todos los escalones (5V, GND, DIN) | 2 hilos propios desde cada escalón hasta el controlador |
| Efectos | Colores, arcoíris, animación LED por LED | Encendido suave por escalón, un solo color |
| Voltaje | 5 V (12 V con WS2815) | 12 V o 24 V |
| En tramos largos | Caída de voltaje, hace falta inyectar alimentación | Menos pérdidas gracias al mayor voltaje |
| Consumo en reposo | Unos 0,5–1 mA por LED apagado | Casi cero con el MOSFET apagado |
Tabla de LED y fuente según el número de escalones
En una WS2812B, cada LED consume unos 60 mA en blanco total y a brillo máximo (20 mA por color). En la escalera, sin embargo, usarás blanco cálido con alrededor de 30 % de brillo; así no deslumbra y la corriente baja a cerca de un tercio. La columna "blanco total" de la tabla es el peor caso: aunque el código limite el brillo, en una prueba todos los LED pueden encenderse en blanco total. Por eso elige una fuente de al menos 1,5 veces la corriente práctica y calcula el grosor del cable para blanco total. La última columna muestra la RAM que usa el código para guardar los colores; recuerda que el Uno solo tiene 2 KB.
| Escalones | LED / escalón | LED totales | Blanco total (60 mA) | 30 % de brillo (~18 mA) | Fuente de 5 V recomendada | RAM (3 bytes/LED) |
|---|---|---|---|---|---|---|
| 10 | 10 | 100 | 6,0 A | 1,8 A | 5 V 3 A | 300 bytes |
| 12 | 15 | 180 | 10,8 A | 3,2 A | 5 V 5 A | 540 bytes |
| 14 | 15 | 210 | 12,6 A | 3,8 A | 5 V 6 A | 630 bytes |
| 16 | 20 | 320 | 19,2 A | 5,8 A | 5 V 10 A | 960 bytes |
| 16 | 30 | 480 | 28,8 A | 8,6 A | 5 V 15 A o tira de 12 V | 1440 bytes (demasiado para el Uno) |
En la opción B el cálculo es más sencillo, porque en las tiras de un color de 12 V el fabricante indica la potencia por metro. Una tira 2835 de 60 LED/m consume unos 4,8 W/m. Con 60 cm de tira por escalón son 2,9 W por escalón y 46 W en 16 escalones, es decir, 3,8 A a 12 V. Con un 20 % de margen basta una fuente de 12 V 5 A (60 W). Puedes pasar de corriente a voltaje y potencia rápidamente con la calculadora de la ley de Ohm.
Diagrama de conexión y tabla de pines
| Conexión | Arduino Uno | ESP32 | Nota |
|---|---|---|---|
| OUT del PIR de abajo | D2 | GPIO 27 | VCC del PIR a 5 V, GND común |
| OUT del PIR de arriba | D3 | GPIO 26 | Cable de 3 hilos si el extremo superior está lejos |
| Punto medio del divisor LDR | A0 | GPIO 34 | LDR a 5 V (3,3 V en el ESP32), 10 kΩ a GND |
| DIN de la WS2812B | D6 (con 330 Ω) | GPIO 4 (con 74AHCT125) | Opción A |
| SDA / SCL del PCA9685 | A4 / A5 | GPIO 21 / 22 | Opción B |
| + y - de la tira | 5 V y GND de la fuente | 5 V y GND de la fuente | No desde el pin 5V de la placa |
Con la LDR entre 5 V y A0 y la resistencia de 10 kΩ entre A0 y GND, la lectura sube a medida que hay más luz. La resistencia de la LDR llega a megaohmios en la oscuridad y baja a 1–10 kΩ con luz de día; con la calculadora de divisor de voltaje ves qué voltaje da el divisor con cada nivel de luz. La salida del HC-SR501 da 3,3 V al activarse; el Uno lo lee como HIGH y para el ESP32 sirve directamente. Gira el potenciómetro de tiempo del sensor al mínimo (unos 3 segundos) y pon el jumper en H (redisparo); que el tiempo de encendido lo decida el código, no el sensor. Más detalles en la guía del sensor de movimiento PIR.
Montaje paso a paso
- Cuenta los escalones y decide cuántos LED lleva cada uno; corta la tira WS2812B solo por las marcas de corte de cobre.
- Encadena los tramos desde el escalón de abajo: la salida DOUT de cada tramo va a la entrada DIN del tramo del escalón siguiente. Así el escalón 0 del código es el de abajo.
- Cada 2–3 escalones (más o menos cada 100 LED), lleva 5 V y GND por separado desde la fuente; esta inyección de alimentación evita que los colores se vean amarillentos arriba.
- Coloca los sensores PIR en la pared a unos 30–50 cm de altura, apuntando al primer y al último escalón; un tubito delante de la lente reduce el campo de visión.
- Pon la LDR donde no le dé directamente la luz de la escalera pero sí reciba luz de una ventana o de la lámpara del pasillo.
- Prueba primero el circuito en la protoboard con una tira corta de 2–3 escalones y luego cambia STEPS y LEDS_PER_STEP en el código según tu escalera.
- Dale a los PIR de 30 a 60 segundos para estabilizarse después de encenderlos; es normal que se activen al azar en ese tiempo.
Opción A: código Arduino con WS2812B
El código usa la librería Adafruit NeoPixel, que instalas desde el Gestor de librerías. El número de escalones, los LED por escalón, la velocidad de la ola, el tiempo encendido y los umbrales de oscuridad se ajustan con las constantes al inicio del archivo. Lo básico de la WS2812B está en la guía LED WS2812B NeoPixel.
1// Arduino merdiven aydınlatması: 2 PIR + LDR + WS2812B / Arduino stair lighting: 2 PIR + LDR + WS2812B
2#include <Adafruit_NeoPixel.h>
3
4const uint8_t PIN_PIR_BOTTOM = 2; // alt basamak PIR / bottom step PIR
5const uint8_t PIN_PIR_TOP = 3; // üst basamak PIR / top step PIR
6const uint8_t PIN_LDR = A0; // LDR bölücü orta noktası / LDR divider midpoint
7const uint8_t PIN_STRIP = 6; // WS2812B DIN (330 ohm üzerinden / through 330 ohm)
8
9const uint8_t STEPS = 14; // basamak sayısı / number of steps
10const uint8_t LEDS_PER_STEP = 15; // basamak başına LED / LEDs per step
11const uint16_t STEP_DELAY_MS = 150; // basamaklar arası gecikme / delay between steps
12const unsigned long ON_TIME_MS = 15000; // son hareketten sonra açık kalma / on time after last motion
13const int DARK_LEVEL = 300; // bunun altı karanlık / below this is dark
14const int LIGHT_LEVEL = 400; // bunun üstü aydınlık / above this is bright
15
16Adafruit_NeoPixel strip(STEPS * LEDS_PER_STEP, PIN_STRIP, NEO_GRB + NEO_KHZ800);
17const uint32_t WARM_WHITE = Adafruit_NeoPixel::Color(255, 150, 50); // sıcak beyaz / warm white
18
19enum State { IDLE, TURNING_ON, LIT, TURNING_OFF };
20State state = IDLE;
21int8_t direction = 1; // 1: aşağıdan yukarı / bottom-up, -1: yukarıdan aşağı / top-down
22uint8_t stepCount = 0; // dalgada kaçıncı basamak / position in the wave
23unsigned long lastStepTime = 0;
24unsigned long lastMotion = 0;
25bool isDark = true;
26
27// Yöne göre k'inci sıradaki fiziksel basamak (0 = en alt) / physical step at position k (0 = bottom)
28uint8_t stepAt(uint8_t k) {
29 return (direction == 1) ? k : (STEPS - 1 - k);
30}
31
32void setStep(uint8_t step, uint32_t color) {
33 uint16_t first = step * LEDS_PER_STEP;
34 for (uint8_t i = 0; i < LEDS_PER_STEP; i++) strip.setPixelColor(first + i, color);
35 strip.show();
36}
37
38// LDR'yi yalnız ışıklar sönükken oku, iki eşikli / read the LDR only while lights are off, with hysteresis
39void updateDarkness() {
40 int level = analogRead(PIN_LDR);
41 if (isDark && level > LIGHT_LEVEL) isDark = false;
42 else if (!isDark && level < DARK_LEVEL) isDark = true;
43}
44
45void startWave(State next, int8_t dir) {
46 state = next;
47 direction = dir;
48 stepCount = 0;
49 lastStepTime = millis() - STEP_DELAY_MS; // ilk basamak hemen yansın / first step at once
50}
51
52void setup() {
53 pinMode(PIN_PIR_BOTTOM, INPUT);
54 pinMode(PIN_PIR_TOP, INPUT);
55 strip.begin();
56 strip.setBrightness(80); // yaklaşık %30 parlaklık / about 30% brightness
57 strip.show(); // hepsi kapalı / all off
58}
59
60void loop() {
61 unsigned long now = millis();
62 bool bottom = digitalRead(PIN_PIR_BOTTOM) == HIGH;
63 bool top = digitalRead(PIN_PIR_TOP) == HIGH;
64
65 if (state == IDLE) updateDarkness();
66
67 if (bottom || top) {
68 if ((state == IDLE && isDark) || state == TURNING_OFF) {
69 startWave(TURNING_ON, bottom ? 1 : -1); // yön: hangi sensör önce / direction: which sensor first
70 }
71 if (state != IDLE) lastMotion = now; // her hareket süreyi uzatır / every motion extends the time
72 }
73
74 switch (state) {
75 case TURNING_ON:
76 case TURNING_OFF:
77 if (now - lastStepTime >= STEP_DELAY_MS) {
78 lastStepTime = now;
79 setStep(stepAt(stepCount), state == TURNING_ON ? WARM_WHITE : 0);
80 stepCount++;
81 if (stepCount >= STEPS) state = (state == TURNING_ON) ? LIT : IDLE;
82 }
83 break;
84 case LIT:
85 if (now - lastMotion >= ON_TIME_MS) startWave(TURNING_OFF, direction); // aynı yönde sön / fade out the same way
86 break;
87 default:
88 break;
89 }
90}| Constante o función | Para qué sirve |
|---|---|
| STEPS, LEDS_PER_STEP | Medidas de la escalera; el total de LED es el producto de ambos |
| STEP_DELAY_MS | Retardo entre escalones; 100–200 ms se siente como un paso natural |
| ON_TIME_MS | Tiempo que las luces siguen encendidas tras el último movimiento |
| DARK_LEVEL, LIGHT_LEVEL | Detección de noche con dos umbrales; evita que se prenda y apague al atardecer |
| stepAt(k) | Devuelve el escalón físico en la posición k según la dirección |
| updateDarkness() | Lee la LDR solo mientras las luces están apagadas |
Opción B: encendido suave con MOSFET y PCA9685
Cada tira de un color necesita su propio canal, y el Uno solo tiene 6 pines PWM. Para encender y apagar suavemente hasta 16 escalones usa el módulo PCA9685: se conecta por I2C y genera PWM de 12 bits (0–4095) en cada uno de sus 16 canales. Cada canal maneja la compuerta (gate) de un MOSFET de nivel lógico IRLZ44N, que conecta el negativo de la tira a GND. Una resistencia de 10 kΩ entre gate y source evita que las tiras se enciendan al azar mientras arranca el Arduino. Lo básico está en la guía MOSFET con Arduino.
| Pin del MOSFET | Se conecta a |
|---|---|
| Gate (G) | Salida del canal del PCA9685; 10 kΩ a Source |
| Drain (D) | Negativo (-) de la tira |
| Source (S) | GND de la fuente de 12 V (común con el GND del Arduino) |
| + de la tira | + de la fuente de 12 V |
1// Arduino merdiven aydınlatması: PCA9685 + MOSFET ile yumuşak geçiş / stair lighting: smooth fades with PCA9685 + MOSFETs
2#include <Wire.h>
3#include <Adafruit_PWMServoDriver.h>
4
5Adafruit_PWMServoDriver pwm(0x40); // PCA9685 varsayılan adres / default address
6
7const uint8_t PIN_PIR_BOTTOM = 2;
8const uint8_t PIN_PIR_TOP = 3;
9const uint8_t PIN_LDR = A0;
10
11const uint8_t STEPS = 16; // kanal 0 = en alt basamak / channel 0 = bottom step
12const uint16_t STEP_DELAY_MS = 120; // dalga hızı / wave speed
13const uint16_t FADE_MS = 400; // bir basamağın açılma süresi / fade time of one step
14const uint16_t MAX_PWM = 3000; // 4095 = tam parlaklık / full brightness
15const unsigned long ON_TIME_MS = 15000;
16const int DARK_LEVEL = 300, LIGHT_LEVEL = 400;
17
18uint16_t level[STEPS]; // her basamağın parlaklığı / brightness of each step
19bool lightsOn = false; // hedef: açık mı / target: on?
20bool waveRunning = false;
21int8_t direction = 1;
22unsigned long waveStart = 0, lastMotion = 0;
23bool isDark = true;
24
25void updateDarkness() {
26 int v = analogRead(PIN_LDR);
27 if (isDark && v > LIGHT_LEVEL) isDark = false;
28 else if (!isDark && v < DARK_LEVEL) isDark = true;
29}
30
31void startWave(bool on) {
32 lightsOn = on;
33 waveStart = millis();
34 waveRunning = true;
35}
36
37// Her basamağın parlaklığı = dalga başlangıcından geçen süre - sıra x gecikme
38// Brightness of each step = time since wave start - position x delay
39void updateWave(unsigned long now) {
40 bool finished = true;
41 for (uint8_t k = 0; k < STEPS; k++) {
42 uint8_t step = (direction == 1) ? k : STEPS - 1 - k;
43 long t = (long)(now - waveStart) - (long)k * STEP_DELAY_MS;
44 uint32_t p = constrain(t, 0L, (long)FADE_MS); // 0..FADE_MS
45 if (p < FADE_MS) finished = false;
46 uint32_t q = lightsOn ? p : FADE_MS - p;
47 uint16_t target = q * q * MAX_PWM / ((uint32_t)FADE_MS * FADE_MS); // karesel: göze doğal / quadratic: natural to the eye
48 uint16_t next = lightsOn ? max(level[step], target) : min(level[step], target);
49 if (next != level[step]) {
50 level[step] = next;
51 pwm.setPin(step, next);
52 }
53 }
54 if (finished) waveRunning = false;
55}
56
57void setup() {
58 pinMode(PIN_PIR_BOTTOM, INPUT);
59 pinMode(PIN_PIR_TOP, INPUT);
60 pwm.begin();
61 pwm.setPWMFreq(1000); // 1 kHz, titremesiz / no visible flicker
62 for (uint8_t i = 0; i < STEPS; i++) {
63 level[i] = 0;
64 pwm.setPin(i, 0);
65 }
66}
67
68void loop() {
69 unsigned long now = millis();
70 bool bottom = digitalRead(PIN_PIR_BOTTOM) == HIGH;
71 bool top = digitalRead(PIN_PIR_TOP) == HIGH;
72
73 if (!lightsOn && !waveRunning) updateDarkness(); // yalnız hepsi sönükken / only while all are off
74
75 if (bottom || top) {
76 if (!lightsOn && (isDark || waveRunning)) { // karanlıkta ya da sönerken / when dark or while fading out
77 direction = bottom ? 1 : -1;
78 startWave(true);
79 }
80 if (lightsOn) lastMotion = now;
81 }
82 if (lightsOn && now - lastMotion >= ON_TIME_MS) startWave(false);
83 if (waveRunning) updateWave(now);
84}El corazón del código es la función updateWave(): el brillo de cada escalón se calcula con el tiempo transcurrido desde que empezó la ola y la posición del escalón en la secuencia. El brillo sube de forma cuadrática y no lineal, porque el ojo percibe mucho más los cambios a bajo brillo; así el encendido se ve más natural. Si llega un movimiento nuevo mientras se apagan, cada escalón vuelve a subir desde su brillo actual, sin apagones bruscos. Como la frecuencia PWM es de 1 kHz, no verás parpadeo ni con la cámara del celular.
Versión ESP32: brillo y tiempo desde el celular
Si pasas la misma lógica al ESP32, puedes ajustar la iluminación de la escalera por Wi-Fi. El siguiente código se conecta a tu red y abre una pequeña página de ajustes en la dirección IP del ESP32; ahí cambias el brillo y el tiempo encendido y ves la última lectura de la LDR. Si el Wi-Fi no conecta, el sistema sigue funcionando sin red después de 10 segundos, así que la escalera nunca se queda a oscuras. Como el ADC del ESP32 es de 12 bits, los umbrales van de 0 a 4095 y el divisor de la LDR se alimenta con 3,3 V. Para la instalación, revisa ¿Qué es el ESP32?.
1// ESP32 merdiven aydınlatması + Wi-Fi ayar sayfası / ESP32 stair lighting + Wi-Fi settings page
2#include <WiFi.h>
3#include <WebServer.h>
4#include <Adafruit_NeoPixel.h>
5
6const char* WIFI_SSID = "AgAdi"; // Wi-Fi adın / your Wi-Fi name
7const char* WIFI_PASS = "Sifre123"; // Wi-Fi şifren / your Wi-Fi password
8
9const uint8_t PIN_PIR_BOTTOM = 27;
10const uint8_t PIN_PIR_TOP = 26;
11const uint8_t PIN_LDR = 34; // ADC1, yalnız giriş / input only
12const uint8_t PIN_STRIP = 4; // 74AHCT125 üzerinden DIN / to DIN via 74AHCT125
13
14const uint8_t STEPS = 14;
15const uint8_t LEDS_PER_STEP = 15;
16const uint16_t STEP_DELAY_MS = 150;
17const int DARK_LEVEL = 1200, LIGHT_LEVEL = 1600; // 12 bit ADC: 0-4095
18
19uint8_t brightness = 80; // web sayfasından değişir / set from the web page
20unsigned long onTimeMs = 15000;
21
22Adafruit_NeoPixel strip(STEPS * LEDS_PER_STEP, PIN_STRIP, NEO_GRB + NEO_KHZ800);
23WebServer server(80);
24
25enum State { IDLE, TURNING_ON, LIT, TURNING_OFF };
26State state = IDLE;
27int8_t direction = 1;
28uint8_t stepCount = 0;
29unsigned long lastStepTime = 0, lastMotion = 0;
30bool isDark = true;
31int lastLdr = 0;
32
33uint32_t warmWhite() { // parlaklığı renge uygula / apply brightness to the color
34 return Adafruit_NeoPixel::Color(255 * brightness / 255, 150 * brightness / 255, 50 * brightness / 255);
35}
36
37void setStep(uint8_t step, uint32_t color) {
38 for (uint8_t i = 0; i < LEDS_PER_STEP; i++) strip.setPixelColor(step * LEDS_PER_STEP + i, color);
39 strip.show();
40}
41
42void startWave(State next, int8_t dir) {
43 state = next;
44 direction = dir;
45 stepCount = 0;
46 lastStepTime = millis() - STEP_DELAY_MS;
47}
48
49void handleRoot() {
50 if (server.hasArg("b")) brightness = constrain(server.arg("b").toInt(), 5, 255);
51 if (server.hasArg("t")) onTimeMs = constrain(server.arg("t").toInt(), 5, 300) * 1000UL;
52 String html = "<!DOCTYPE html><html><head><meta name='viewport' content='width=device-width'></head><body>";
53 html += "<h2>Merdiven / Stairs</h2><form>";
54 html += "Parlaklik / Brightness (5-255): <input name='b' type='number' value='" + String(brightness) + "'><br>";
55 html += "Sure / Time (s): <input name='t' type='number' value='" + String(onTimeMs / 1000) + "'><br>";
56 html += "<button>Kaydet / Save</button></form>";
57 html += "<p>LDR: " + String(lastLdr) + (isDark ? " (gece / night)" : " (gunduz / day)") + "</p></body></html>";
58 server.send(200, "text/html", html);
59}
60
61void setup() {
62 Serial.begin(115200);
63 pinMode(PIN_PIR_BOTTOM, INPUT);
64 pinMode(PIN_PIR_TOP, INPUT);
65 strip.begin();
66 strip.show();
67 WiFi.mode(WIFI_STA);
68 WiFi.begin(WIFI_SSID, WIFI_PASS);
69 unsigned long t0 = millis();
70 while (WiFi.status() != WL_CONNECTED && millis() - t0 < 10000) delay(250); // en çok 10 s / at most 10 s
71 if (WiFi.status() == WL_CONNECTED) Serial.println(WiFi.localIP());
72 else Serial.println("Wi-Fi yok, cevrimdisi calisiyor / no Wi-Fi, running offline");
73 server.on("/", handleRoot);
74 server.begin();
75}
76
77void loop() {
78 server.handleClient();
79 unsigned long now = millis();
80 bool bottom = digitalRead(PIN_PIR_BOTTOM) == HIGH;
81 bool top = digitalRead(PIN_PIR_TOP) == HIGH;
82
83 if (state == IDLE) { // LDR yalnız ışıklar sönükken / LDR only while lights are off
84 lastLdr = analogRead(PIN_LDR);
85 if (isDark && lastLdr > LIGHT_LEVEL) isDark = false;
86 else if (!isDark && lastLdr < DARK_LEVEL) isDark = true;
87 }
88
89 if (bottom || top) {
90 if ((state == IDLE && isDark) || state == TURNING_OFF) startWave(TURNING_ON, bottom ? 1 : -1);
91 if (state != IDLE) lastMotion = now;
92 }
93
94 if ((state == TURNING_ON || state == TURNING_OFF) && now - lastStepTime >= STEP_DELAY_MS) {
95 lastStepTime = now;
96 uint8_t step = (direction == 1) ? stepCount : STEPS - 1 - stepCount;
97 setStep(step, state == TURNING_ON ? warmWhite() : 0);
98 if (++stepCount >= STEPS) state = (state == TURNING_ON) ? LIT : IDLE;
99 } else if (state == LIT && now - lastMotion >= onTimeMs) {
100 startWave(TURNING_OFF, direction);
101 }
102}Ubicación de los sensores y alternativas
Un sensor PIR detecta cambios de calor: reacciona cuando el calor del cuerpo se mueve por su campo de visión. El problema más común en una escalera es que alguien que pasa por el pasillo de abajo, o un calefactor, active el sensor. Inclina el sensor hacia el escalón, tapa con cinta una parte de la lente de Fresnel y gira el potenciómetro de sensibilidad a la mitad. Si quieres una detección más precisa, pon en cada extremo un HC-SR04 o un VL53L0X y úsalo como barrera de luz: cuando la distancia medida baja de golpe, alguien pisó el escalón. En cambio, el sensor de radar RCWL-0516 ve a través de las paredes y se activa desde el cuarto de al lado, así que no se recomienda aquí.
| Sensor | Ventaja | Desventaja | Para escaleras |
|---|---|---|---|
| PIR HC-SR501 | Barato, alcance de 5–7 m, ajustable | Falsos disparos por fuentes de calor, 2–3 s de tiempo ciego | Muy bueno |
| Mini PIR AM312 | Pequeño, funciona con 3,3 V, cabe dentro del escalón | Sin ajustes, alcance de 3–5 m | Bueno |
| HC-SR04 o VL53L0X | Detecta con seguridad un pie en el escalón | Necesita código de medición continua | Bueno (como barrera de luz) |
| Radar RCWL-0516 | Se puede esconder detrás de una tapa | Atraviesa paredes, se activa desde el cuarto de al lado | No recomendado |
Errores comunes y soluciones
- Los colores se ven amarillentos en los escalones de arriba: hay caída de voltaje en la línea de 5 V; inyecta alimentación cada 2–3 escalones y usa cables gruesos.
- El primer LED está bien y los demás muestran colores al azar: falta la tierra común o la línea de datos es muy larga; une los GND, pon la resistencia de 330 Ω cerca de la tira y no uses más de unos pocos metros de cable de datos.
- Las luces corren en sentido contrario: la cadena de la tira empieza en el escalón de arriba; empieza la cadena abajo o invierte la lógica de dirección en el código.
- Se enciende de día o nunca de noche: los umbrales de la LDR están mal o la LDR ve la luz de la escalera; mide el valor en el Monitor Serie y cambia la LDR de lugar.
- Las luces nunca se apagan: el potenciómetro de tiempo del PIR está muy alto o el sensor apunta a una fuente de calor; ponlo al mínimo y reorienta el sensor.
- El Arduino se reinicia solo: la fuente se cae cuando encienden los LED o la tira está conectada al pin 5V de la placa; usa una fuente más grande y alimenta la tira aparte.
- El MOSFET se calienta: estás usando un MOSFET que no es de nivel lógico; cambia a uno como el IRLZ44N y deja la resistencia de gate entre 100 y 220 Ω.
Ideas para mejorar la iluminación de tu escalera
- Modo luz nocturna: sin movimiento, deja solo el primer y el último escalón al 5 % para marcar dónde está la escalera.
- Ola de colores: con WS2812B enciende cada escalón en un tono distinto del arcoíris y cambia los colores en Navidad.
- Extensión al pasillo: con la misma lógica ilumina un pasillo largo con un PIR en cada extremo.
- Domótica: conecta el ESP32 a Home Assistant con MQTT y controla la escalera junto con tus otras luces.
- Firmware listo: si quieres efectos sin programar, instala WLED y conéctale los sensores PIR.
La iluminación de escalera une lectura de sensores, temporización, cálculo de potencia y control de LED en un solo proyecto, así que le da un valor duradero a tu casa y te enseña muchísimo. Pruébala primero en la mesa con una tira corta de dos escalones y luego llévala a la escalera. En la app BlueGrays, el proyecto Iluminación Inteligente de Escalera y Pasillo te muestra el diagrama y el código paso a paso, y con los proyectos de WS2812B y PIR conoces cada pieza por separado.
Preguntas frecuentes
¿Cuántos LED necesito por escalón?
Depende del ancho del escalón y de la densidad de la tira. Con una tira de 30 LED/m, un escalón de 90 cm lleva 27 LED; en la mayoría de las escaleras, de 10 a 20 LED por escalón dan una luz pareja. Meter la tira en un perfil de aluminio con difusor oculta los puntos de cada LED.
¿Qué fuente de alimentación necesito para luces LED en la escalera?
Con WS2812B multiplica el total de LED por 18 mA (cerca de 30 % de brillo) y agrega un 50 % de margen; para 210 LED, por ejemplo, sirve una fuente de 5 V 6 A. Con tira de un color de 12 V multiplica los watts por metro por el largo total, divide entre 12 y suma un 20 % de margen.
¿WS2812B o tira LED de un solo color para la escalera?
Si quieres colores y animaciones, la WS2812B es más flexible y se instala con un solo cable de datos. Si solo buscas luz blanca cálida en tramos largos, una tira de un color de 12 V o 24 V con MOSFET es más eficiente, tiene menos caída de voltaje y casi no consume en reposo.
¿Por qué el sensor PIR enciende las luces de la escalera solo?
El PIR reacciona a cambios de calor, así que un calefactor, el sol que entra por la ventana, corrientes de aire caliente o las mascotas pueden activarlo. También es normal que se dispare en los primeros 30–60 segundos después de encenderlo. Apunta el sensor al escalón, tapa parte de la lente y baja la sensibilidad.
¿Cómo hago que las luces de la escalera no se prendan de día?
Agrega una LDR y acepta el disparo del PIR solo cuando la lectura de luz esté por debajo de un umbral. Usar dos umbrales en vez de uno (histéresis) evita que se prenda y apague al atardecer. Pon la LDR donde no le llegue la luz de la escalera y léela solo con las luces apagadas.
¿Cuántos LED WS2812B puede manejar un Arduino Uno?
Cada LED ocupa 3 bytes de RAM; con los 2 KB del Uno y el resto de variables, el límite práctico ronda los 400–500 LED. Para escaleras más largas usa un Arduino Mega o un ESP32, o pon menos LED por escalón. La corriente la entrega la fuente, así que el límite es la memoria y no la potencia.
Proyectos para hacer después de leer esto
Ver todos los proyectos
Iluminación inteligente de escaleras y pasillos
Pisas la escalera o entras en el pasillo y las luces se encienden escalón a escalón en la dirección en la que caminas.

Luz nocturna con LDR
Una pequeña lamparita que se enciende sola cuando oscurece y se apaga cuando llega la mañana.

Uso de la tira LED WS2812B
Conoces una tira LED inteligente en la que puedes dar color a cada luz por separado.

Luz secuencial con WS2812B (efecto llenado)
Una tira de luz que se llena y se vacía como un vaso de agua. El Arduino enciende diez LED de color uno a uno en naranja y los deja encendidos; cuando la tira está llena, los apaga uno a uno en el…

Detector de movimiento con sensor de movimiento
Un vigilante sencillo que te avisa cuando alguien entra en la habitación. El sensor de movimiento capta el calor que desprende el cuerpo humano, y el Arduino mantiene el LED encendido mientras hay…

Iluminación automática con el sensor de movimiento PIR del ESP32
Un sensor de movimiento PIR HC-SR501 detecta a quien entra en la habitación y enciende un LED automáticamente. millis() controla cuánto sigue encendido: cada lectura HIGH renueva la hora del último movimiento y el LED se apaga al menos 10 segundos después del último HIGH. El código además espera 50 ms con delay(50) en cada ciclo, así que el bucle no es del todo no bloqueante. Ideal para escaleras, pasillos, baños o armarios.

Iluminación Inteligente ESP32 (PIR + LDR + Relé + OLED)
Con un ESP32, un sensor de movimiento PIR, un sensor de luz LDR y un módulo de relé convertimos el pasillo, el baño o la despensa de tu casa en iluminación inteligente. Si ya hay luz, la lámpara no se enciende aunque haya movimiento, así no gasta energía de día. La luz se queda encendida 30 segundos y el tiempo se alarga solo mientras siga habiendo movimiento.

Control de la tira NeoPixel WS2812B con ESP32
Los LED direccionables WS2812B (NeoPixel) son LED RGB inteligentes que se encadenan y se controlan desde un solo pin de datos. Controlamos una tira WS2812B de 8 LED con la biblioteca Adafruit_NeoPixel y creamos un arcoíris fluido. La lógica de 3,3 V del ESP32 va bien con casi todos los WS2812B; si hay inestabilidad, mostramos la solución con una resistencia en serie de 470Ω y un condensador de 1000µF. La animación desplaza el tono en el espacio HSV.
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

