Guias · 12 min de leitura

Iluminação de escada com Arduino: degraus de LED com sensor PIR

Monte a iluminação de escada com Arduino: dois sensores PIR detectam o sentido, os degraus acendem um a um com WS2812B ou fitas com MOSFET, mais modo noturno com LDR e código para ESP32.

A iluminação de escada com Arduino pede só um Arduino, dois sensores de movimento e uma fita de LED: quando você pisa no primeiro degrau, os degraus acendem um depois do outro, de baixo para cima; quando você vem de cima, a onda de luz corre no sentido contrário. Cerca de 15 segundos depois do último movimento, os degraus se apagam na mesma ordem. Os olhos do sistema são dois sensores de movimento PIR, um no pé e outro no topo da escada, mais um LDR que mantém as luzes apagadas durante o dia; o cérebro é uma máquina de estados de poucas linhas.

Neste guia você vai ver os dois caminhos: uma fita endereçável WS2812B, que controla centenas de LEDs individualmente por um único fio de dados, e o método clássico, com uma fita de 12 V de uma cor só em cada degrau, acesa e apagada suavemente por um MOSFET. Você também encontra uma tabela de LEDs e de alimentação conforme o número de degraus, o esquema de ligação, o código para Arduino Uno, uma versão de 16 degraus com PCA9685 e uma versão para ESP32 que dá para ajustar pelo celular.

Fita de LED endereçável WS2812B
Fita WS2812B: cada LED tem o próprio chip de controle, então cada degrau pode ser aceso separadamente por uma única linha de dados.

Como funciona a iluminação automática de escada?

A lógica tem quatro estados: em espera, acendendo, aceso e apagando. Em espera, o Arduino vigia os dois sensores PIR e consulta o LDR para saber se está escuro. Se o sensor de baixo dispara, o sentido é guardado como “subindo”; se é o de cima, como “descendo”, e os degraus acendem um a um, com 100–200 ms de intervalo. Quando o último degrau acende, o sistema fica no estado aceso, e cada novo disparo reinicia o temporizador. Passado o tempo definido sem movimento, as luzes se apagam no mesmo sentido, como uma onda que acompanha a pessoa. Essa estrutura se chama máquina de estados, e tudo roda sem bloqueio graças ao millis(), de modo que os sensores continuam sendo lidos mesmo durante a animação das luzes.

EstadoO que acontece?Passagem para o próximo estado
Em esperaLEDs apagados, o LDR é lidoNo escuro, um disparo do PIR de baixo ou de cima inicia o acendimento
AcendendoOs degraus acendem um a um no sentido da caminhadaQuando o último degrau acende, o sistema passa para aceso
AcesoTodos os degraus acesos; cada movimento prolonga o tempoQuando o tempo (por exemplo, 15 s) passa sem movimento, começa o apagamento
ApagandoOs degraus se apagam um a um no mesmo sentidoUm novo movimento volta para acendendo; com tudo apagado, volta para em espera

Lista de materiais e duas opções de circuito

  • Arduino Uno ou Nano (ESP32, se você quiser ajustar as configurações pelo celular).
  • 2 × sensor PIR HC-SR501: um no primeiro degrau, outro no último.
  • LDR e resistor de 10 kΩ: um divisor de tensão para detectar a noite.
  • Opção A: fita WS2812B (30 ou 60 LEDs/m), fonte de 5 V, capacitor de 1000 µF e resistor de 330 Ω.
  • Opção B: um pedaço de fita de LED de 12 V de uma cor só por degrau, um MOSFET IRLZ44N e um resistor de 10 kΩ por degrau, um módulo PWM de 16 canais PCA9685 e uma fonte de 12 V.
  • Fiação e montagem: fio de 0,75–1,5 mm² (18–16 AWG) para a alimentação, cabinho flexível fino para os sinais e perfis de alumínio com difusor para as fitas.
CaracterísticaOpção A: WS2812BOpção B: MOSFET + fita de uma cor
Linha de controleUm pino de dados2 pinos I2C com o PCA9685 (até 16 degraus)
FiaçãoCadeia de 3 fios passando por todos os degraus (5V, GND, DIN)2 fios separados de cada degrau até o controlador
EfeitosCores, arco-íris, animação LED a LEDTransição suave por degrau, uma cor só
Tensão5 V (12 V com o WS2815)12 V ou 24 V
Trechos longosQueda de tensão; exige injeção de alimentaçãoMenos perdas graças à tensão mais alta
Consumo em esperaCerca de 0,5–1 mA por LED apagadoQuase zero com o MOSFET desligado

Tabela de LEDs e de alimentação por número de degraus

Em uma WS2812B, cada LED consome cerca de 60 mA no branco total com brilho máximo (20 mA por cor). Em uma escada, porém, você usa os LEDs em branco quente, com uns 30% de brilho, o que evita o ofuscamento e reduz a corrente a mais ou menos um terço. A coluna “branco total” da tabela é o pior caso: mesmo que o código limite o brilho, todos os LEDs podem acender em branco total durante um teste. Por isso, escolha uma fonte com capacidade de pelo menos 1,5 vez a corrente prática e dimensione os fios para o branco total. A última coluna mostra a RAM de que o código precisa para guardar as cores dos LEDs; lembre que o Uno tem só 2 KB de RAM.

DegrausLEDs / degrauTotal de LEDsBranco total (60 mA)30% de brilho (~18 mA)Fonte 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 ou uma fita de 12 V1440 bytes (demais para o Uno)

A opção B é mais fácil de calcular, porque as fitas de 12 V de uma cor só são especificadas em watts por metro. Uma fita 2835 com 60 LEDs/m consome cerca de 4,8 W/m. Com 60 cm de fita em cada degrau, são 2,9 W por degrau e 46 W para 16 degraus, o que dá 3,8 A em 12 V. Com 20% de margem, uma fonte de 12 V 5 A (60 W) é suficiente. Para converter rapidamente entre corrente, tensão e potência, use a calculadora da lei de Ohm.

Esquema de ligação e tabela de pinos

LigaçãoArduino UnoESP32Observação
OUT do PIR de baixoD2GPIO 27VCC do PIR em 5 V, GND comum
OUT do PIR de cimaD3GPIO 26Cabo de 3 vias se a ponta de cima ficar longe
Ponto central do divisor do LDRA0GPIO 34LDR em 5 V (3,3 V no ESP32), 10 kΩ para o GND
DIN da WS2812BD6 (por um resistor de 330 Ω)GPIO 4 (por um 74AHCT125)Opção A
SDA / SCL do PCA9685A4 / A5GPIO 21 / 22Opção B
+ e - da fita5 V e GND da fonte5 V e GND da fonteNão pelo pino 5V da placa
Nunca alimente a fita de LED pelo pino 5V do Arduino: o caminho do USB ou do regulador da placa aguenta no máximo de 500 mA a 1 A, e depois de algumas dezenas de LEDs a placa reinicia ou é danificada. Alimente a fita direto da fonte, ligue o GND da fonte ao GND do Arduino (terra comum) e coloque um capacitor de 1000 µF / 10 V na entrada da fita. Deixe a fiação do lado da rede elétrica e a instalação embutida na parede para um eletricista habilitado; uma fonte pronta, de ligar na tomada, é a escolha segura.

Com o LDR entre 5 V e A0 e o resistor de 10 kΩ entre A0 e GND, a leitura sobe à medida que o ambiente clareia. A resistência do LDR chega à faixa dos megaohms no escuro e cai para 1–10 kΩ à luz do dia; a calculadora de divisor de tensão mostra que tensão o divisor entrega em cada nível de luz. A saída do HC-SR501 vai a 3,3 V quando dispara; o Uno lê isso como HIGH, e ela serve direto para o ESP32. Gire o potenciômetro de tempo do sensor para o mínimo (cerca de 3 segundos) e coloque o jumper em H (disparo repetido); quem decide por quanto tempo as luzes ficam acesas é o código, não o sensor. Mais sobre o sensor no guia do sensor de movimento PIR.

Montagem passo a passo

  1. Conte os degraus e decida quantos LEDs vão em cada um; corte a fita WS2812B somente nas marcas de corte de cobre.
  2. Encadeie os pedaços de fita a partir do degrau de baixo: a ponta DOUT de cada pedaço vai para a ponta DIN do pedaço do degrau de cima. Assim, o degrau 0 do código é o de baixo.
  3. A cada 2–3 degraus (mais ou menos a cada 100 LEDs), traga 5 V e GND separadamente da fonte; essa injeção de alimentação evita que as cores fiquem amareladas nos degraus de cima.
  4. Fixe os sensores PIR na parede a uns 30–50 cm (12–20 pol) de altura, voltados para o primeiro e para o último degrau; um tubinho curto na frente da lente estreita o campo de visão.
  5. Coloque o LDR onde a luz da escada não bata direto nele, mas onde ele ainda receba a luz de uma janela ou da lâmpada do corredor.
  6. Primeiro teste o circuito na bancada com uma fita curta, para 2–3 degraus, e depois mude STEPS e LEDS_PER_STEP no código de acordo com a sua escada.
  7. Dê aos sensores PIR de 30 a 60 segundos de aquecimento depois de ligar; disparos aleatórios nesse intervalo são normais.

Opção A: código para Arduino com WS2812B

O código usa a biblioteca Adafruit NeoPixel, que você instala pelo Gerenciador de Bibliotecas. O número de degraus, os LEDs por degrau, a velocidade da onda, o tempo aceso e os limiares de escuridão são definidos nas constantes do início do arquivo. O básico da WS2812B está no guia 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 ou funçãoPara que serve
STEPS, LEDS_PER_STEPTamanho da escada; o total de LEDs é o produto dos dois
STEP_DELAY_MSIntervalo entre os degraus; 100–200 ms lembra o ritmo natural de uma caminhada
ON_TIME_MSPor quanto tempo as luzes ficam acesas depois do último movimento
DARK_LEVEL, LIGHT_LEVELDetecção de noite com dois limiares; evita o liga-desliga ao anoitecer
stepAt(k)Devolve o degrau físico da posição k para o sentido atual
updateDarkness()Lê o LDR somente com as luzes apagadas
Ler o LDR somente com as luzes apagadas é um detalhe pequeno, mas importante: se a luz da escada bater no LDR, o sistema pode achar que é dia e não acender no próximo disparo. Para encontrar os limiares, anote o valor ao anoitecer com Serial.println(analogRead(A0)) e então defina DARK_LEVEL um pouco abaixo dele e LIGHT_LEVEL um pouco acima.

Opção B: transição suave com MOSFETs e um PCA9685

Cada fita de uma cor só precisa do próprio canal, mas o Uno tem apenas 6 pinos PWM. Para transições suaves em até 16 degraus, use o módulo PCA9685: ele se conecta por I2C e gera PWM de 12 bits (0–4095) em cada um dos seus 16 canais. Cada canal aciona o gate de um MOSFET de nível lógico IRLZ44N, que chaveia o fio negativo da fita para o GND. Um resistor de 10 kΩ entre gate e source impede que as fitas pisquem ao acaso enquanto o Arduino inicializa. O básico está no guia de MOSFET com Arduino.

Pino do MOSFETVai ligado em
Gate (G)Saída do canal do PCA9685; 10 kΩ para o Source
Drain (D)Fio - da fita
Source (S)GND da fonte de 12 V (comum com o GND do Arduino)
+ da fita+ da fonte de 12 V
Os populares módulos com MOSFET IRF520 não conduzem totalmente com 5 V no gate; esquentam com poucos ampères e a fita nunca chega ao brilho máximo. Use MOSFETs de nível lógico, como o IRLZ44N, o IRL540N ou o AOD4184; você pode comparar as peças adequadas na tabela 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}

O coração do código é a função updateWave(): o brilho de cada degrau é calculado a partir do tempo decorrido desde o início da onda e da posição do degrau na sequência. O brilho sobe de forma quadrática, e não linear, porque o olho percebe com muito mais força as mudanças em brilho baixo; assim a transição fica mais natural. Se chegar um novo movimento enquanto as luzes estão se apagando, cada degrau volta a subir a partir do brilho em que está, sem um salto brusco de apaga e acende. Com a frequência do PWM em 1 kHz, você não vê cintilação nem pela câmera do celular.

Versão para ESP32: ajuste o brilho e o tempo aceso pelo celular

Leve a mesma lógica para um ESP32 e você passa a ajustar a iluminação da escada pelo Wi-Fi. O código abaixo entra na rede da sua casa e serve uma pequena página de configurações no endereço IP do ESP32, onde você muda o brilho e o tempo aceso e vê a última leitura do LDR. Se o Wi-Fi não conectar, o sistema segue offline depois de 10 segundos, então a escada nunca fica no escuro. Como o ADC do ESP32 é de 12 bits, os limiares vão de 0 a 4095, e o divisor do LDR trabalha em 3,3 V. Para a instalação, veja O que é o 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}
A saída de dados do ESP32 é de 3,3 V, enquanto uma WS2812B alimentada em 5 V espera pelo menos uns 3,5 V na entrada de dados. Com fios curtos, muitas vezes funciona assim mesmo, mas, se você notar cores aleatórias ou cintilação, coloque na linha de dados um conversor de nível rápido, como o 74AHCT125. Os conversores de nível I2C bidirecionais simples podem ser lentos demais para o sinal de 800 kHz da WS2812B; os detalhes estão no guia do conversor de nível lógico.

Posição dos sensores e sensores alternativos

Um sensor PIR detecta variações de calor: ele reage quando o calor de um corpo atravessa o seu campo de visão. O problema mais comum em escadas é alguém passando pelo corredor lá embaixo, ou um aquecedor, disparar o sensor. Incline o sensor na direção do degrau, cubra parte da lente de Fresnel com fita e deixe o potenciômetro de sensibilidade no meio. Para uma detecção mais precisa, coloque um HC-SR04 ou um VL53L0X em cada ponta e use-o como uma barreira de luz: quando a distância medida cai de repente, alguém pisou no degrau. Já o sensor de radar RCWL-0516 enxerga através das paredes e dispara com movimento no cômodo ao lado, por isso não é recomendado aqui.

SensorVantagensDesvantagensServe para escada?
HC-SR501 PIRBarato, alcance de 5–7 m, ajustávelDisparos falsos com fontes de calor, 2–3 s de tempo cegoMuito bom
Mini PIR AM312Pequeno, funciona em 3,3 V, cabe dentro de um degrauSem ajuste, alcance de 3–5 mBom
HC-SR04 ou VL53L0XDetecta com segurança um pé no degrauExige código de medição contínuaBom (como barreira de luz)
Radar RCWL-0516Pode ficar escondido atrás de uma tampaAtravessa paredes, dispara com movimento no cômodo ao ladoNão recomendado

Erros comuns e como resolver

  • As cores ficam amareladas nos degraus de cima: queda de tensão na linha de 5 V; injete alimentação a cada 2–3 degraus e use fios de alimentação grossos.
  • O primeiro LED está certo e os outros mostram cores aleatórias: falta o terra comum ou a linha de dados está longa demais; una os GNDs, coloque o resistor de 330 Ω perto da fita e mantenha o fio de dados com menos de alguns metros.
  • As luzes correm no sentido errado: a cadeia de fitas começa no degrau de cima; comece a cadeia por baixo ou inverta a lógica de sentido no código.
  • Acende de dia ou nunca acende à noite: os limiares do LDR estão errados ou o LDR enxerga a luz da escada; meça o valor no Monitor Serial e mude o LDR de lugar.
  • As luzes nunca se apagam: o potenciômetro de tempo do PIR está em um valor alto demais ou o sensor está voltado para uma fonte de calor; gire o potenciômetro para o mínimo e reposicione o sensor.
  • O Arduino reinicia do nada: a tensão da fonte cai quando os LEDs acendem, ou a fita está sendo alimentada pelo pino 5V da placa; use uma fonte maior e alimente a fita separadamente.
  • O MOSFET esquenta: você está usando um MOSFET que não é de nível lógico; troque por uma peça como o IRLZ44N e mantenha o resistor de gate entre 100 e 220 Ω.
O brilho máximo ofusca quem desce a escada no meio da noite. Amplie o código para baixar o brilho a 10% entre as 23h e as 6h; para pegar a hora da internet no ESP32, use o método do guia relógio NTP com ESP32.

Ideias para turbinar a sua iluminação de escada

  • Modo luz noturna: sem movimento, deixe só o primeiro e o último degrau em 5% para mostrar onde fica a escada.
  • Onda de cores: com a WS2812B, acenda cada degrau em um tom diferente do arco-íris e troque as cores nas datas comemorativas.
  • Extensão para o corredor: use a mesma lógica para iluminar um corredor comprido, com um PIR em cada ponta.
  • Automação residencial: conecte o ESP32 ao Home Assistant via MQTT e controle a escada junto com as outras luzes da casa.
  • Firmware pronto: se você quer efeitos sem escrever código, instale o WLED e ligue os sensores PIR a ele.

A iluminação de escada junta leitura de sensores, temporização, cálculo de alimentação e acionamento de LEDs em um projeto só; por isso, deixa algo duradouro na sua casa e ensina muito pelo caminho. Experimente primeiro na bancada, com uma fita curta para dois degraus, e só depois leve para a escada. No app BlueGrays, o projeto de iluminação inteligente de escada e corredor conduz você passo a passo pelo esquema do circuito e pelo código, e os projetos com WS2812B e PIR ajudam a conhecer cada peça separadamente.

Perguntas frequentes

Quantos LEDs preciso por degrau da escada?

Depende da largura do degrau e da densidade da fita. Uma fita de 30 LEDs/m dá 27 LEDs em um degrau de 90 cm (36 pol); na maioria das escadas, 10–20 LEDs por degrau garantem uma luz uniforme. Colocar a fita em um perfil de alumínio com difusor esconde os pontinhos de cada LED.

Que fonte de alimentação preciso para a iluminação de escada com LED?

Para a WS2812B, multiplique o total de LEDs por 18 mA (cerca de 30% de brilho) e some 50% de folga; para 210 LEDs, por exemplo, uma fonte de 5 V 6 A cai bem. Para uma fita de 12 V de uma cor só, multiplique os watts por metro pelo comprimento total, divida por 12 e some 20% de margem.

WS2812B ou fita de LED de uma cor só para a escada?

Se você quer cores e animações, a WS2812B é mais flexível e só precisa de um fio de dados. Se quer apenas luz branca quente em trechos longos, uma fita de 12 V ou 24 V de uma cor só com MOSFETs é mais eficiente, tem menos queda de tensão e quase nenhum consumo em espera.

Por que meu sensor PIR acende as luzes da escada sozinho?

Um sensor PIR reage a variações de calor, então aquecedores, o sol entrando pela janela, correntes de ar quente ou animais de estimação podem dispará-lo. Disparos nos primeiros 30–60 segundos depois de ligar também são normais. Aponte o sensor para o degrau, cubra parte da lente e diminua a sensibilidade.

Como evitar que as luzes da escada acendam durante o dia?

Acrescente um LDR e só aceite os disparos do PIR quando a leitura de luz estiver abaixo de um limiar. Usar dois limiares em vez de um (histerese) evita o liga-desliga ao anoitecer. Coloque o LDR onde as luzes da escada não batam nele e leia-o somente com as luzes apagadas.

Quantos LEDs WS2812B um Arduino Uno consegue controlar?

Cada LED usa 3 bytes de RAM; com os 2 KB do Uno e as suas outras variáveis, o limite prático fica em uns 400–500 LEDs. Para escadas mais compridas, use um Arduino Mega ou um ESP32, ou então menos LEDs por degrau. Quem fornece a corrente é a fonte, portanto o limite é a memória, não a potência.

Ver todos os projetos
Iluminação inteligente de escadas e corredores
AR-82Intermediário
Premium

Iluminação inteligente de escadas e corredores

Ao entrar na escada ou no corredor, as luzes acendem uma a uma no sentido em que você caminha.

5.0(36)
52
Luz noturna com LDR
AR-12Iniciante

Luz noturna com LDR

Uma pequena luz noturna que acende sozinha quando escurece e apaga ao amanhecer.

4.7(105)
225
Uso da fita LED WS2812B
AR-69Intermediário
Premium

Uso da fita LED WS2812B

Conheça uma fita LED inteligente em que você pode definir a cor de cada luz individualmente.

4.8(54)
70
LED sequencial com WS2812B (efeito de preenchimento)
AR-72Intermediário
Premium

LED sequencial com WS2812B (efeito de preenchimento)

Uma fita de luz que enche e esvazia como um copo de água. O Arduino acende dez LEDs coloridos em laranja, um por vez, e os mantém acesos; quando a fita está cheia, apaga um por vez na mesma ordem, e…

4.7(50)
65
Detector de movimento com sensor de movimento
AR-24Iniciante
Premium

Detector de movimento com sensor de movimento

Um vigia simples que avisa quando alguém entra no cômodo. O sensor de movimento detecta o calor emitido pelo corpo humano, e o Arduino mantém o LED aceso enquanto há movimento e o apaga quando ele…

4.6(47)
67
Iluminação automática com ESP32 e sensor de movimento PIR
ES-19Intermediário
Premium

Iluminação automática com ESP32 e sensor de movimento PIR

Neste projeto, usaremos o sensor de movimento PIR HC-SR501 para detectar quando alguém entra no cômodo e acender o LED automaticamente. Acompanharemos o tempo em que o LED fica aceso com millis(). Cada leitura HIGH do sensor atualizará o instante do último movimento, e o LED apagará pelo menos 10 segundos após a última leitura HIGH. O código atual também espera 50 ms em cada ciclo com delay(50), portanto o laço da aplicação não é totalmente livre de bloqueios.

4.4(24)
38
Iluminação inteligente com ESP32 (PIR + LDR + relé + OLED)
ES-37Avançado
Premium

Iluminação inteligente com ESP32 (PIR + LDR + relé + OLED)

Transforme a iluminação do corredor, banheiro ou despensa em iluminação inteligente com ESP32! Com um sensor de movimento PIR, um sensor de luz LDR e um módulo relé, montamos o cenário clássico de "acender a luz ao detectar movimento no escuro" — se o ambiente já estiver claro, o movimento NÃO aciona a luz, economizando energia durante o dia. A luz fica acesa por 30 segundos; se o movimento continuar, o temporizador reinicia e a luz permanece acesa por mais tempo.

4.3(6)
11
Controle de fita WS2812B NeoPixel com ESP32
ES-24Intermediário
Premium

Controle de fita WS2812B NeoPixel com ESP32

Os LEDs endereçáveis WS2812B (NeoPixel) são LEDs RGB inteligentes que podem ser controlados em cadeia por um único pino de dados. Neste projeto, vamos controlar uma fita WS2812B de 8 LEDs com a biblioteca Adafruit_NeoPixel para criar uma animação suave de arco-íris. Embora o nível lógico de 3,3V do ESP32 funcione sem problemas na maioria dos lotes de WS2812B, vamos mostrar uma solução com um resistor de 470Ω em série e um capacitor de 1.000µF para casos de instabilidade.

4.9(19)
30