Guías · 12 min de lectura

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.

Tira LED direccionable WS2812B
Tira WS2812B: cada LED lleva su propio controlador, así que cada escalón se puede encender por separado con una sola línea de datos.

¿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
ReposoLED apagados, se lee la LDRCon oscuridad, al activarse el PIR de abajo o de arriba pasa a encendiendo
EncendiendoLos escalones se encienden uno a uno en el sentido de la marchaAl encenderse el último escalón pasa a encendida
EncendidaTodos los escalones encendidos, cada movimiento alarga el tiempoSi pasa el tiempo (p. ej. 15 s) sin movimiento, pasa a apagando
ApagandoLos escalones se apagan uno a uno en la misma direcciónCon 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ísticaOpción A: WS2812BOpción B: MOSFET + tira de un color
Línea de controlUn solo pin de datos2 pines I2C con PCA9685 (hasta 16 escalones)
CableadoCadena de 3 hilos por todos los escalones (5V, GND, DIN)2 hilos propios desde cada escalón hasta el controlador
EfectosColores, arcoíris, animación LED por LEDEncendido suave por escalón, un solo color
Voltaje5 V (12 V con WS2815)12 V o 24 V
En tramos largosCaída de voltaje, hace falta inyectar alimentaciónMenos pérdidas gracias al mayor voltaje
Consumo en reposoUnos 0,5–1 mA por LED apagadoCasi 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.

EscalonesLED / escalónLED totalesBlanco total (60 mA)30 % de brillo (~18 mA)Fuente de 5 V recomendadaRAM (3 bytes/LED)
10101006,0 A1,8 A5 V 3 A300 bytes
121518010,8 A3,2 A5 V 5 A540 bytes
141521012,6 A3,8 A5 V 6 A630 bytes
162032019,2 A5,8 A5 V 10 A960 bytes
163048028,8 A8,6 A5 V 15 A o tira de 12 V1440 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ónArduino UnoESP32Nota
OUT del PIR de abajoD2GPIO 27VCC del PIR a 5 V, GND común
OUT del PIR de arribaD3GPIO 26Cable de 3 hilos si el extremo superior está lejos
Punto medio del divisor LDRA0GPIO 34LDR a 5 V (3,3 V en el ESP32), 10 kΩ a GND
DIN de la WS2812BD6 (con 330 Ω)GPIO 4 (con 74AHCT125)Opción A
SDA / SCL del PCA9685A4 / A5GPIO 21 / 22Opción B
+ y - de la tira5 V y GND de la fuente5 V y GND de la fuenteNo desde el pin 5V de la placa
Nunca alimentes la tira LED desde el pin 5V del Arduino: el camino USB o el regulador de la placa soporta como mucho de 500 mA a 1 A, y después de unas decenas de LED la placa se reinicia o se daña. Alimenta la tira directo desde la fuente, une el GND de la fuente con el GND del Arduino (tierra común) y pon un capacitor de 1000 µF / 10 V en la entrada de la tira. No hagas tú mismo las conexiones del lado de 110/220 V ni la instalación dentro de la pared; usa una fuente lista con enchufe o deja esa parte a un electricista.

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

  1. Cuenta los escalones y decide cuántos LED lleva cada uno; corta la tira WS2812B solo por las marcas de corte de cobre.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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.
  7. 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.

C++ (Arduino IDE)
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ónPara qué sirve
STEPS, LEDS_PER_STEPMedidas de la escalera; el total de LED es el producto de ambos
STEP_DELAY_MSRetardo entre escalones; 100–200 ms se siente como un paso natural
ON_TIME_MSTiempo que las luces siguen encendidas tras el último movimiento
DARK_LEVEL, LIGHT_LEVELDetecció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
Leer la LDR solo con las luces apagadas es un detalle pequeño pero importante: si la luz de la escalera le da a la LDR, el sistema puede creer que es de día y no encenderse en la siguiente activación. Para encontrar los umbrales, anota el valor al atardecer con Serial.println(analogRead(A0)) y pon DARK_LEVEL un poco por debajo y LIGHT_LEVEL un poco por encima.

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 MOSFETSe 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
Los populares módulos MOSFET IRF520 no conducen por completo con 5 V en la compuerta; se calientan con unos pocos amperes y la tira nunca llega a su brillo máximo. Usa MOSFET de nivel lógico como IRLZ44N, IRL540N o AOD4184; puedes comparar opciones en la tabla de transistores.
C++ (Arduino IDE)
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?.

C++ (Arduino IDE)
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}
La salida de datos del ESP32 es de 3,3 V, mientras que una WS2812B alimentada con 5 V espera al menos unos 3,5 V en la entrada de datos. Con cables cortos muchas veces funciona igual, pero si ves colores al azar o parpadeo, pon un elevador de nivel rápido como el 74AHCT125 en la línea de datos. Los convertidores de nivel bidireccionales para I2C pueden quedarse cortos para la señal de 800 kHz de la WS2812B; más detalles en la guía del convertidor de nivel lógico.

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í.

SensorVentajaDesventajaPara escaleras
PIR HC-SR501Barato, alcance de 5–7 m, ajustableFalsos disparos por fuentes de calor, 2–3 s de tiempo ciegoMuy bueno
Mini PIR AM312Pequeño, funciona con 3,3 V, cabe dentro del escalónSin ajustes, alcance de 3–5 mBueno
HC-SR04 o VL53L0XDetecta con seguridad un pie en el escalónNecesita código de medición continuaBueno (como barrera de luz)
Radar RCWL-0516Se puede esconder detrás de una tapaAtraviesa paredes, se activa desde el cuarto de al ladoNo 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 Ω.
A medianoche, el brillo máximo encandila a quien baja la escalera. Amplía el código para bajar el brillo al 10 % entre las 23:00 y las 6:00; para obtener la hora de internet en el ESP32 usa el método de la guía hora NTP con ESP32.

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.

Ver todos los proyectos
Iluminación inteligente de escaleras y pasillos
AR-82Intermedio
Premium

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.

5.0(36)
52
Luz nocturna con LDR
AR-12Principiante

Luz nocturna con LDR

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

4.7(105)
225
Uso de la tira LED WS2812B
AR-69Intermedio
Premium

Uso de la tira LED WS2812B

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

4.8(54)
70
Luz secuencial con WS2812B (efecto llenado)
AR-72Intermedio
Premium

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…

4.7(50)
65
Detector de movimiento con sensor de movimiento
AR-24Principiante
Premium

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…

4.6(47)
67
Iluminación automática con el sensor de movimiento PIR del ESP32
ES-19Intermedio
Premium

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.

4.4(24)
38
Iluminación Inteligente ESP32 (PIR + LDR + Relé + OLED)
ES-37Avanzado
Premium

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.

4.3(6)
11
Control de la tira NeoPixel WS2812B con ESP32
ES-24Intermedio
Premium

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.

4.9(19)
30