Guide · 11 min di lettura

Illuminazione scale Arduino: LED segnapasso con sensore PIR

Illuminazione scale con Arduino: due sensori PIR capiscono se sali o scendi, i gradini si accendono uno dopo l'altro con WS2812B o MOSFET, LDR ed ESP32.

Per l'illuminazione delle scale con Arduino bastano un Arduino, due sensori di movimento e una striscia LED: quando metti piede sul primo gradino, i gradini si accendono uno dopo l'altro dal basso verso l'alto, e se arrivi dall'alto l'onda di luce scorre al contrario. Circa 15 secondi dopo l'ultimo movimento i gradini si spengono nello stesso ordine, proprio come un segnapasso intelligente. Gli occhi del sistema sono due sensori di movimento PIR in fondo e in cima alla scala e una fotoresistenza LDR che evita l'accensione di giorno; il cervello è una macchina a stati di poche righe.

In questa guida vedrai entrambe le strade: una striscia indirizzabile WS2812B, che comanda centinaia di LED singolarmente con un solo filo dati, e il metodo classico con una striscia monocolore a 12 V per ogni gradino, accesa e spenta dolcemente da un MOSFET. Trovi anche una tabella LED e alimentatore in base al numero di gradini, lo schema di collegamento, il codice per Arduino Uno, una versione per 16 gradini con PCA9685 e una versione ESP32 regolabile dallo smartphone.

Striscia LED indirizzabile WS2812B
Striscia WS2812B: ogni LED ha il suo driver integrato, quindi ogni gradino si può accendere singolarmente con una sola linea dati.

Come funziona l'illuminazione automatica delle scale?

La logica ha quattro stati: attesa, accensione, acceso e spegnimento. In attesa, Arduino controlla i due PIR e verifica con l'LDR se è buio. Se scatta il sensore in basso, la direzione viene salvata come "salita"; se scatta quello in alto, come "discesa", e i gradini si accendono uno alla volta a 100–200 ms di distanza. Quando anche l'ultimo gradino è acceso, il sistema resta nello stato acceso; ogni nuovo intervento di un sensore fa ripartire il tempo. Trascorso il tempo impostato senza movimento, le luci si spengono nella stessa direzione, come un'onda che segue la persona. Questa struttura si chiama macchina a stati e tutto gira senza blocchi grazie a millis(), così i sensori vengono letti anche durante l'animazione.

StatoCosa succede?Passaggio allo stato successivo
AttesaLED spenti, si legge l'LDRAl buio, quando scatta il PIR in basso o in alto, si passa all'accensione
AccensioneI gradini si accendono uno alla volta nel senso di marciaAcceso l'ultimo gradino, si passa allo stato acceso
AccesoTutti i gradini accesi, ogni movimento allunga il tempoSe il tempo (es. 15 s) passa senza movimento, inizia lo spegnimento
SpegnimentoI gradini si spengono uno alla volta nella stessa direzioneCon un nuovo movimento si torna all'accensione; tutto spento, si torna in attesa

Lista dei materiali e due varianti di circuito

  • Arduino Uno o Nano (ESP32 se vuoi regolare tutto dallo smartphone).
  • 2 sensori PIR HC-SR501: uno sul gradino più basso, uno su quello più alto.
  • LDR e resistenza da 10 kΩ: un partitore di tensione per riconoscere la notte.
  • Variante A: striscia WS2812B (30 o 60 LED/m), alimentatore da 5 V, condensatore da 1000 µF e resistenza da 330 Ω.
  • Variante B: un pezzo di striscia LED monocolore a 12 V per gradino, un MOSFET IRLZ44N e una resistenza da 10 kΩ per gradino, un modulo PWM PCA9685 a 16 canali e un alimentatore da 12 V.
  • Cavi e montaggio: cavo da 0,75–1,5 mm² per l'alimentazione, cavetto flessibile sottile per i segnali, profili in alluminio con diffusore per le strisce.
CaratteristicaVariante A: WS2812BVariante B: MOSFET + striscia monocolore
Linea di controlloUn solo pin dati2 pin I2C con PCA9685 (fino a 16 gradini)
CablaggioCatena a 3 fili su tutti i gradini (5V, GND, DIN)2 fili separati da ogni gradino al controller
EffettiColori, arcobaleno, animazioni LED per LEDAccensione graduale per gradino, un solo colore
Tensione5 V (12 V con WS2815)12 V o 24 V
Su tratte lungheCaduta di tensione, serve alimentare in più puntiMeno perdite grazie alla tensione più alta
Consumo a riposoCirca 0,5–1 mA per LED spentoQuasi zero con il MOSFET spento

Tabella LED e alimentatore in base al numero di gradini

Nella WS2812B ogni LED assorbe circa 60 mA in bianco pieno alla massima luminosità (20 mA per colore). Sulle scale però userai un bianco caldo intorno al 30 % di luminosità: non abbaglia e riduce la corrente a circa un terzo. La colonna "bianco pieno" della tabella è il caso peggiore: anche se il codice limita la luminosità, durante una prova tutti i LED possono accendersi in bianco pieno. Scegli quindi un alimentatore da almeno 1,5 volte la corrente pratica e dimensiona la sezione dei cavi per il bianco pieno. L'ultima colonna indica la RAM usata dal codice per memorizzare i colori; ricorda che l'Uno ha solo 2 KB di RAM.

GradiniLED / gradinoLED totaliBianco pieno (60 mA)Luminosità 30 % (~18 mA)Alimentatore 5 V consigliatoRAM (3 byte/LED)
10101006,0 A1,8 A5 V 3 A300 byte
121518010,8 A3,2 A5 V 5 A540 byte
141521012,6 A3,8 A5 V 6 A630 byte
162032019,2 A5,8 A5 V 10 A960 byte
163048028,8 A8,6 A5 V 15 A o striscia a 12 V1440 byte (troppi per l'Uno)

Nella variante B il calcolo è più semplice, perché per le strisce monocolore a 12 V il produttore indica la potenza al metro. Una striscia 2835 da 60 LED/m assorbe circa 4,8 W/m. Con 60 cm di striscia per gradino fanno 2,9 W a gradino e 46 W in totale su 16 gradini, cioè 3,8 A a 12 V. Con un margine del 20 % basta un alimentatore da 12 V 5 A (60 W). Per passare velocemente da corrente a tensione e potenza usa il calcolatore della legge di Ohm.

Schema di collegamento e tabella dei pin

CollegamentoArduino UnoESP32Nota
OUT del PIR in bassoD2GPIO 27VCC del PIR a 5 V, GND in comune
OUT del PIR in altoD3GPIO 26Cavo a 3 poli se la cima è lontana
Punto centrale del partitore LDRA0GPIO 34LDR a 5 V (3,3 V sull'ESP32), 10 kΩ a GND
DIN della WS2812BD6 (tramite 330 Ω)GPIO 4 (tramite 74AHCT125)Variante A
SDA / SCL del PCA9685A4 / A5GPIO 21 / 22Variante B
+ e - della striscia5 V e GND dell'alimentatore5 V e GND dell'alimentatoreNon dal pin 5V della scheda
Non alimentare mai la striscia LED dal pin 5V di Arduino: il percorso USB o il regolatore della scheda regge al massimo 500 mA–1 A, e dopo qualche decina di LED la scheda si riavvia o si danneggia. Alimenta la striscia direttamente dall'alimentatore, collega il GND dell'alimentatore al GND di Arduino (massa comune) e metti un condensatore da 1000 µF / 10 V all'ingresso della striscia. Non lavorare da solo sul lato a 230 V né sull'impianto sotto traccia: usa un alimentatore già pronto con spina oppure affida questa parte a un elettricista.

Con l'LDR tra 5 V e A0 e la resistenza da 10 kΩ tra A0 e GND, il valore letto sale all'aumentare della luce. La resistenza dell'LDR arriva ai megaohm al buio e scende a 1–10 kΩ alla luce del giorno; con il calcolatore del partitore di tensione vedi quale tensione dà il partitore con ogni livello di luce. L'uscita dell'HC-SR501 va a 3,3 V quando scatta: l'Uno la legge come HIGH e per l'ESP32 va bene direttamente. Gira il trimmer del tempo del sensore al minimo (circa 3 secondi) e metti il jumper su H (riattivabile): la durata dell'accensione la decide il codice, non il sensore. Altri dettagli nella guida al sensore di movimento PIR.

Montaggio passo dopo passo

  1. Conta i gradini e decidi quanti LED mettere su ciascuno; taglia la striscia WS2812B solo sui segni di taglio in rame.
  2. Collega in catena i pezzi di striscia partendo dal gradino più basso: l'uscita DOUT di ogni pezzo va all'ingresso DIN del pezzo sul gradino successivo. Così il gradino 0 nel codice è quello più in basso.
  3. Ogni 2–3 gradini (circa ogni 100 LED) porta 5 V e GND separatamente dall'alimentatore; questa alimentazione aggiuntiva evita che i colori ingialliscano sui gradini alti.
  4. Fissa i sensori PIR alla parete a circa 30–50 cm d'altezza, rivolti verso il primo e l'ultimo gradino; un tubetto davanti alla lente restringe il campo visivo.
  5. Metti l'LDR dove la luce delle scale non la colpisce direttamente, ma riceve luce da una finestra o dalla lampada del corridoio.
  6. Prova prima il circuito su una breadboard con una striscia corta da 2–3 gradini, poi adatta STEPS e LEDS_PER_STEP nel codice alla tua scala.
  7. Lascia ai PIR 30–60 secondi di riscaldamento dopo l'accensione; in questo tempo è normale che scattino a caso.

Variante A: codice Arduino con WS2812B

Il codice usa la libreria Adafruit NeoPixel, che installi dal Gestore librerie. Numero di gradini, LED per gradino, velocità dell'onda, tempo di accensione e soglie di buio si impostano con le costanti all'inizio del file. Le basi della WS2812B sono nella guida 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}
Costante o funzioneA cosa serve
STEPS, LEDS_PER_STEPDimensioni della scala; il totale dei LED è il loro prodotto
STEP_DELAY_MSRitardo tra i gradini; 100–200 ms sembrano un passo naturale
ON_TIME_MSQuanto restano accese le luci dopo l'ultimo movimento
DARK_LEVEL, LIGHT_LEVELRiconoscimento della notte a due soglie; evita accensioni a intermittenza al crepuscolo
stepAt(k)Restituisce il gradino fisico in posizione k secondo la direzione
updateDarkness()Legge l'LDR solo mentre le luci sono spente
Leggere l'LDR solo a luci spente è un dettaglio piccolo ma importante: se la luce delle scale colpisce l'LDR, il sistema può credere che sia giorno e non accendersi al passaggio successivo. Per trovare le soglie, annota il valore al crepuscolo con Serial.println(analogRead(A0)) e imposta DARK_LEVEL un po' più in basso e LIGHT_LEVEL un po' più in alto.

Variante B: accensione graduale con MOSFET e PCA9685

Ogni striscia monocolore ha bisogno del suo canale, ma l'Uno ha solo 6 pin PWM. Per accendere e spegnere dolcemente fino a 16 gradini usa il modulo PCA9685: si collega in I2C e genera un PWM a 12 bit (0–4095) su ognuno dei suoi 16 canali. Ogni canale pilota il gate di un MOSFET logic level IRLZ44N, che collega il negativo della striscia a GND. Una resistenza da 10 kΩ tra gate e source evita che le strisce si accendano a caso mentre Arduino si avvia. Le basi sono nella guida MOSFET con Arduino.

Pin del MOSFETCollegato a
Gate (G)Uscita del canale del PCA9685; 10 kΩ verso Source
Drain (D)Negativo (-) della striscia
Source (S)GND dell'alimentatore da 12 V (in comune con il GND di Arduino)
+ della striscia+ dell'alimentatore da 12 V
I diffusissimi moduli MOSFET IRF520 non conducono del tutto con 5 V sul gate: scaldano già con pochi ampere e la striscia non raggiunge mai la piena luminosità. Usa MOSFET logic level come IRLZ44N, IRL540N o AOD4184; puoi confrontare i componenti adatti nella tabella dei transistor.
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}

Il cuore del codice è la funzione updateWave(): la luminosità di ogni gradino si calcola dal tempo trascorso dall'inizio dell'onda e dalla posizione del gradino nella sequenza. La luminosità cresce in modo quadratico e non lineare, perché l'occhio percepisce molto di più le variazioni a bassa luminosità; così l'accensione sembra più naturale. Se arriva un nuovo movimento durante lo spegnimento, ogni gradino risale dalla luminosità in cui si trova, senza bruschi spegnimenti. Con una frequenza PWM di 1 kHz non vedrai sfarfallio nemmeno con la fotocamera del telefono.

Versione ESP32: luminosità e tempo dallo smartphone

Portando la stessa logica sull'ESP32 puoi regolare l'illuminazione delle scale via Wi-Fi. Il codice qui sotto si collega alla rete di casa e apre una piccola pagina di impostazioni all'indirizzo IP dell'ESP32: lì cambi luminosità e tempo di accensione e vedi l'ultimo valore dell'LDR. Se il Wi-Fi non si collega, dopo 10 secondi il sistema continua a funzionare offline, quindi la scala non resta mai al buio. Poiché l'ADC dell'ESP32 è a 12 bit, le soglie vanno da 0 a 4095 e il partitore dell'LDR è alimentato a 3,3 V. Per la configurazione vedi Cos'è l'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}
L'uscita dati dell'ESP32 è a 3,3 V, mentre una WS2812B alimentata a 5 V si aspetta almeno circa 3,5 V sull'ingresso dati. Con cavi corti spesso funziona lo stesso, ma se vedi colori casuali o sfarfallio, aggiungi sulla linea dati un traslatore di livello veloce come il 74AHCT125. I semplici convertitori bidirezionali per I2C possono essere troppo lenti per il segnale a 800 kHz della WS2812B; dettagli nella guida al convertitore di livello logico.

Posizione dei sensori e alternative

Un sensore PIR rileva variazioni di calore: reagisce quando il calore del corpo si muove nel suo campo visivo. Il problema più comune sulle scale è qualcuno che passa nel corridoio di sotto, o un termosifone, che fa scattare il sensore. Inclina il sensore verso il gradino, copri con del nastro una parte della lente di Fresnel e porta il trimmer della sensibilità a metà. Se vuoi un rilevamento più preciso, metti a ogni estremità un HC-SR04 o un VL53L0X e usalo come una barriera ottica: quando la distanza misurata si accorcia di colpo, qualcuno ha messo piede sul gradino. Il sensore radar RCWL-0516, invece, vede attraverso i muri e scatta dalla stanza accanto, quindi qui non è consigliato.

SensoreVantaggioSvantaggioAdatto alle scale
PIR HC-SR501Economico, portata 5–7 m, regolabileFalsi allarmi da fonti di calore, 2–3 s di tempo ciecoOttimo
Mini PIR AM312Piccolo, funziona a 3,3 V, si incassa nel gradinoNessuna regolazione, portata 3–5 mBuono
HC-SR04 o VL53L0XRileva con certezza un piede sul gradinoServe un codice di misura continuaBuono (come una barriera ottica)
Radar RCWL-0516Si può nascondere dietro una coperturaAttraversa i muri, scatta dalla stanza accantoSconsigliato

Errori comuni e soluzioni

  • I colori ingialliscono sui gradini alti: c'è caduta di tensione sulla linea a 5 V; alimenta la striscia ogni 2–3 gradini e usa cavi di alimentazione spessi.
  • Il primo LED è giusto, gli altri hanno colori casuali: manca la massa comune o la linea dati è troppo lunga; collega i GND, metti la resistenza da 330 Ω vicino alla striscia e tieni il cavo dati sotto qualche metro.
  • Le luci scorrono nel verso sbagliato: la catena della striscia parte dal gradino più alto; fai partire la catena dal basso o inverti la logica della direzione nel codice.
  • Si accende di giorno o non si accende mai di notte: le soglie dell'LDR sono sbagliate o l'LDR vede la luce delle scale; misura il valore nel Monitor seriale e sposta l'LDR.
  • Le luci non si spengono mai: il trimmer del tempo del PIR è troppo alto o il sensore guarda una fonte di calore; portalo al minimo e riorienta il sensore.
  • Arduino si riavvia a caso: l'alimentatore cede quando si accendono i LED o la striscia è alimentata dal pin 5V della scheda; usa un alimentatore più potente e alimenta la striscia a parte.
  • Il MOSFET scalda: stai usando un MOSFET non logic level; passa a un modello come l'IRLZ44N e tieni la resistenza di gate tra 100 e 220 Ω.
Nel cuore della notte la luminosità piena abbaglia chi scende le scale. Estendi il codice per abbassarla al 10 % tra le 23:00 e le 6:00; per prendere l'ora da Internet con l'ESP32 usa il metodo della guida ora NTP con ESP32.

Idee per migliorare l'illuminazione delle tue scale

  • Modalità luce notturna: senza movimento restano accesi solo il primo e l'ultimo gradino al 5 %, come segnapasso.
  • Onda colorata: con la WS2812B accendi ogni gradino in una tonalità diversa dell'arcobaleno e cambia i colori a Natale.
  • Estensione al corridoio: con la stessa logica illumina un corridoio lungo con un PIR a ogni estremità.
  • Domotica: collega l'ESP32 a Home Assistant tramite MQTT e gestisci le scale insieme alle altre luci.
  • Firmware pronto: se vuoi effetti senza scrivere codice, installa WLED e collegaci i sensori PIR.

L'illuminazione delle scale unisce lettura dei sensori, temporizzazione, calcolo della potenza e pilotaggio dei LED in un solo progetto: dà un valore duraturo alla tua casa e ti insegna tantissimo. Provala prima sul tavolo con una striscia corta da due gradini e poi portala sulla scala. Nell'app BlueGrays, il progetto Illuminazione intelligente per scale e corridoi ti guida passo passo con schema e codice, e con i progetti WS2812B e PIR conosci ogni componente da solo.

Domande frequenti

Quanti LED servono per ogni gradino?

Dipende dalla larghezza del gradino e dalla densità della striscia. Con una striscia da 30 LED/m, un gradino di 90 cm ha 27 LED; nella maggior parte delle scale 10–20 LED per gradino danno una luce uniforme. Un profilo in alluminio con diffusore nasconde i singoli punti luce.

Quale alimentatore serve per le luci LED delle scale?

Con la WS2812B moltiplica il numero totale di LED per 18 mA (circa il 30 % di luminosità) e aggiungi il 50 % di margine; per 210 LED, ad esempio, va bene un alimentatore da 5 V 6 A. Con una striscia monocolore a 12 V moltiplica i watt al metro per la lunghezza totale, dividi per 12 e aggiungi il 20 %.

Meglio WS2812B o striscia LED monocolore per le scale?

Se vuoi colori e animazioni, la WS2812B è più flessibile e richiede un solo filo dati. Se ti basta un bianco caldo su tratte lunghe, una striscia monocolore a 12 V o 24 V con MOSFET è più efficiente, ha meno caduta di tensione e quasi nessun consumo a riposo.

Perché il sensore PIR accende le luci delle scale da solo?

Il PIR reagisce alle variazioni di calore, quindi termosifoni, sole che entra dalla finestra, correnti d'aria calda o animali domestici possono farlo scattare. Sono normali anche gli interventi nei primi 30–60 secondi dopo l'accensione. Orienta il sensore verso il gradino, copri parte della lente e riduci la sensibilità.

Come evito che le luci delle scale si accendano di giorno?

Aggiungi un'LDR e accetta lo scatto del PIR solo quando il valore di luce è sotto una soglia. Usare due soglie invece di una (isteresi) evita accensioni e spegnimenti continui al crepuscolo. Metti l'LDR dove la luce delle scale non arriva e leggila solo a luci spente.

Quanti LED WS2812B può gestire un Arduino Uno?

Ogni LED occupa 3 byte di RAM; con i 2 KB dell'Uno e le altre variabili il limite pratico è di circa 400–500 LED. Per scale più lunghe usa un Arduino Mega o un ESP32, oppure metti meno LED per gradino. La corrente la fornisce l'alimentatore, quindi il limite è la memoria, non la potenza.

Vedi tutti i progetti
Illuminazione intelligente di scale e corridoi
AR-82Intermedio
Premium

Illuminazione intelligente di scale e corridoi

Metti piede sulle scale o nel corridoio e le luci si accendono gradino dopo gradino nella direzione in cui cammini.

5.0(36)
52
Luce notturna con LDR
AR-12Principiante

Luce notturna con LDR

Una piccola luce notturna che si accende da sola quando fa buio e si spegne quando arriva il mattino.

4.7(105)
225
Utilizzo della striscia LED WS2812B
AR-69Intermedio
Premium

Utilizzo della striscia LED WS2812B

Conosci una striscia LED intelligente in cui puoi colorare ogni singola luce per conto suo.

4.8(54)
70
LED in sequenza con WS2812B (riempimento)
AR-72Intermedio
Premium

LED in sequenza con WS2812B (riempimento)

Una striscia di luce che si riempie e si svuota come un bicchiere d'acqua. L'Arduino accende uno alla volta dieci LED colorati in arancione e li lascia accesi; quando la striscia è piena, li spegne…

4.7(50)
65
Rilevatore di movimento con sensore di movimento
AR-24Principiante
Premium

Rilevatore di movimento con sensore di movimento

Un semplice guardiano che ti avvisa quando qualcuno entra nella stanza. Il sensore di movimento percepisce il calore emesso dal corpo umano, e l'Arduino tiene acceso il LED finché c'è movimento e lo…

4.6(47)
67
Illuminazione automatica con sensore di movimento PIR ESP32
ES-19Intermedio
Premium

Illuminazione automatica con sensore di movimento PIR ESP32

Un sensore di movimento PIR HC-SR501 rileva chi entra nella stanza e accende un LED in automatico. millis() misura quanto resta acceso: ogni lettura HIGH aggiorna l'ora dell'ultimo movimento e il LED si spegne almeno 10 secondi dopo l'ultimo HIGH. Il codice attende anche 50 ms con delay(50) a ogni ciclo, quindi il loop non è del tutto non bloccante. Ideale per scale, corridoi, bagni o l'interno degli armadi.

4.4(24)
38
Illuminazione Intelligente ESP32 (PIR + LDR + Relè + OLED)
ES-37Avanzato
Premium

Illuminazione Intelligente ESP32 (PIR + LDR + Relè + OLED)

Con un ESP32, un sensore di movimento PIR, un sensore di luce LDR e un modulo relè trasformiamo il corridoio, il bagno o la dispensa di casa in un'illuminazione smart. Se l'ambiente è già luminoso, la luce non si accende nemmeno con il movimento, così di giorno non spreca energia. La luce resta accesa 30 secondi e il tempo si allunga in automatico finché il movimento continua.

4.3(6)
11
Controllo della striscia LED NeoPixel WS2812B con ESP32
ES-24Intermedio
Premium

Controllo della striscia LED NeoPixel WS2812B con ESP32

I LED indirizzabili WS2812B (NeoPixel) sono LED RGB intelligenti collegabili in catena e controllati da un solo pin dati. Pilotiamo una striscia WS2812B da 8 LED con la libreria Adafruit_NeoPixel e creiamo un arcobaleno fluido. La logica a 3,3 V dell'ESP32 va bene con quasi tutti i WS2812B; in caso di instabilità mostriamo la soluzione con una resistenza in serie da 470Ω e un condensatore da 1000µF. L'animazione sposta la tonalità nello spazio HSV.

4.9(19)
30