Éclairage escalier Arduino : LED automatiques avec détecteur PIR
Éclairage d'escalier automatique avec Arduino : deux détecteurs PIR repèrent le sens, les marches s'allument une à une (WS2812B ou MOSFET), LDR et ESP32.
Pour un éclairage d'escalier avec Arduino, il suffit d'un Arduino, de deux détecteurs de mouvement et d'un ruban LED : quand tu poses le pied sur la première marche, les marches s'allument l'une après l'autre de bas en haut, et quand tu arrives d'en haut, la vague de lumière part dans l'autre sens. Environ 15 secondes après le dernier mouvement, les marches s'éteignent dans le même ordre. Les yeux du système sont deux détecteurs de mouvement PIR placés en bas et en haut de l'escalier et une photorésistance LDR qui l'empêche de s'allumer en plein jour ; son cerveau est une machine à états de quelques lignes.
Dans ce guide, tu verras les deux approches : un ruban adressable WS2812B, qui pilote des centaines de LED individuellement avec un seul fil de données, et la méthode classique avec un ruban monochrome 12 V par marche, allumé et éteint en douceur par un MOSFET. Tu y trouveras aussi un tableau LED et alimentation selon le nombre de marches, le schéma de câblage, le code pour Arduino Uno, une version 16 marches avec PCA9685 et une version ESP32 réglable depuis ton téléphone.

Comment fonctionne un éclairage d'escalier automatique ?
La logique comporte quatre états : veille, allumage, allumé et extinction. En veille, l'Arduino surveille les deux PIR et vérifie avec la LDR s'il fait nuit. Si le capteur du bas se déclenche, le sens est enregistré comme "montée" ; si c'est celui du haut, comme "descente", et les marches s'allument une à une à 100–200 ms d'intervalle. Une fois la dernière marche allumée, le système reste dans l'état allumé ; chaque nouveau déclenchement relance la temporisation. Quand le délai s'écoule sans mouvement, les lumières s'éteignent dans le même sens, comme une vague qui suit la personne. Cette structure s'appelle une machine à états, et tout tourne sans blocage grâce à millis() : les capteurs restent lus même pendant l'animation.
| État | Que se passe-t-il ? | Passage à l'état suivant |
|---|---|---|
| Veille | LED éteintes, la LDR est lue | Dans le noir, un déclenchement du PIR du bas ou du haut lance l'allumage |
| Allumage | Les marches s'allument une à une dans le sens de la marche | Quand la dernière marche est allumée, passage à l'état allumé |
| Allumé | Toutes les marches allumées, chaque mouvement prolonge la durée | Si la durée (ex. 15 s) passe sans mouvement, l'extinction commence |
| Extinction | Les marches s'éteignent une à une dans le même sens | Nouveau mouvement : retour à l'allumage ; tout éteint : retour en veille |
Liste du matériel et deux options de montage
- Arduino Uno ou Nano (ESP32 si tu veux régler le système depuis ton téléphone).
- 2 détecteurs PIR HC-SR501 : un sur la marche du bas, un sur celle du haut.
- LDR et résistance de 10 kΩ : un pont diviseur pour détecter la nuit.
- Option A : ruban WS2812B (30 ou 60 LED/m), alimentation 5 V, condensateur de 1000 µF et résistance de 330 Ω.
- Option B : un morceau de ruban LED monochrome 12 V par marche, un MOSFET IRLZ44N et une résistance de 10 kΩ par marche, un module PWM PCA9685 à 16 canaux et une alimentation 12 V.
- Câbles et pose : câble de 0,75–1,5 mm² pour l'alimentation, fil souple fin pour les signaux, profilés aluminium avec diffuseur pour les rubans.
| Caractéristique | Option A : WS2812B | Option B : MOSFET + ruban monochrome |
|---|---|---|
| Ligne de commande | Une seule broche de données | 2 broches I2C avec le PCA9685 (jusqu'à 16 marches) |
| Câblage | Chaîne à 3 fils sur toutes les marches (5V, GND, DIN) | 2 fils séparés de chaque marche jusqu'au contrôleur |
| Effets | Couleurs, arc-en-ciel, animation LED par LED | Allumage progressif par marche, une seule couleur |
| Tension | 5 V (12 V avec le WS2815) | 12 V ou 24 V |
| Sur de grandes longueurs | Chute de tension, réinjection nécessaire | Moins de pertes grâce à la tension plus élevée |
| Consommation en veille | Environ 0,5–1 mA par LED éteinte | Presque nulle quand le MOSFET est bloqué |
Tableau LED et alimentation selon le nombre de marches
Sur un WS2812B, chaque LED consomme environ 60 mA en blanc pur à pleine luminosité (20 mA par couleur). Dans un escalier, tu utiliseras plutôt un blanc chaud à environ 30 % de luminosité : cela n'éblouit pas et divise le courant par trois environ. La colonne "blanc pur" du tableau correspond au pire cas : même si le code limite la luminosité, toutes les LED peuvent s'allumer en blanc pur pendant un test. Choisis donc une alimentation d'au moins 1,5 fois le courant pratique et dimensionne la section des câbles pour le blanc pur. La dernière colonne indique la RAM utilisée par le code pour mémoriser les couleurs ; n'oublie pas que l'Uno n'a que 2 Ko de RAM.
| Marches | LED / marche | LED au total | Blanc pur (60 mA) | 30 % de luminosité (~18 mA) | Alimentation 5 V conseillée | RAM (3 octets/LED) |
|---|---|---|---|---|---|---|
| 10 | 10 | 100 | 6,0 A | 1,8 A | 5 V 3 A | 300 octets |
| 12 | 15 | 180 | 10,8 A | 3,2 A | 5 V 5 A | 540 octets |
| 14 | 15 | 210 | 12,6 A | 3,8 A | 5 V 6 A | 630 octets |
| 16 | 20 | 320 | 19,2 A | 5,8 A | 5 V 10 A | 960 octets |
| 16 | 30 | 480 | 28,8 A | 8,6 A | 5 V 15 A ou ruban 12 V | 1440 octets (trop pour l'Uno) |
Pour l'option B, le calcul est plus simple, car le fabricant indique la puissance par mètre des rubans monochromes 12 V. Un ruban 2835 à 60 LED/m consomme environ 4,8 W/m. Avec 60 cm de ruban par marche, cela fait 2,9 W par marche et 46 W pour 16 marches, soit 3,8 A sous 12 V. Avec 20 % de marge, une alimentation 12 V 5 A (60 W) suffit. Pour passer rapidement du courant à la tension et à la puissance, utilise le calculateur de loi d'Ohm.
Schéma de câblage et tableau des broches
| Connexion | Arduino Uno | ESP32 | Remarque |
|---|---|---|---|
| OUT du PIR du bas | D2 | GPIO 27 | VCC du PIR sur 5 V, GND commun |
| OUT du PIR du haut | D3 | GPIO 26 | Câble 3 conducteurs si le haut est loin |
| Point milieu du pont LDR | A0 | GPIO 34 | LDR vers 5 V (3,3 V sur l'ESP32), 10 kΩ vers GND |
| DIN du WS2812B | D6 (via 330 Ω) | GPIO 4 (via 74AHCT125) | Option A |
| SDA / SCL du PCA9685 | A4 / A5 | GPIO 21 / 22 | Option B |
| + et - du ruban | 5 V et GND de l'alimentation | 5 V et GND de l'alimentation | Pas depuis la broche 5V de la carte |
Avec la LDR entre 5 V et A0 et la résistance de 10 kΩ entre A0 et GND, la valeur lue augmente avec la lumière. La résistance de la LDR monte à plusieurs mégaohms dans le noir et descend à 1–10 kΩ en plein jour ; le calculateur de pont diviseur te montre quelle tension le pont donne selon la lumière. La sortie du HC-SR501 passe à 3,3 V lors d'un déclenchement : l'Uno la lit comme HIGH, et elle convient directement à l'ESP32. Tourne le potentiomètre de durée du capteur au minimum (environ 3 secondes) et place le cavalier sur H (redéclenchable) : c'est le code qui doit décider de la durée d'allumage, pas le capteur. Plus de détails dans le guide du détecteur de mouvement PIR.
Montage étape par étape
- Compte les marches et décide du nombre de LED par marche ; coupe le ruban WS2812B uniquement sur les repères de coupe en cuivre.
- Chaîne les morceaux de ruban en partant de la marche du bas : la sortie DOUT de chaque morceau va à l'entrée DIN du morceau de la marche suivante. Ainsi, la marche 0 du code est celle du bas.
- Toutes les 2–3 marches (environ toutes les 100 LED), ramène le 5 V et le GND séparément depuis l'alimentation ; cette réinjection évite que les couleurs jaunissent en haut.
- Fixe les détecteurs PIR au mur à environ 30–50 cm de hauteur, orientés vers la première et la dernière marche ; un petit tube devant la lentille réduit le champ de vision.
- Place la LDR là où l'éclairage de l'escalier ne l'atteint pas directement, mais où elle reçoit la lumière d'une fenêtre ou du couloir.
- Teste d'abord le montage sur une plaque d'essai avec un ruban court de 2–3 marches, puis adapte STEPS et LEDS_PER_STEP à ton escalier.
- Laisse aux PIR 30 à 60 secondes de préchauffage après la mise sous tension ; des déclenchements aléatoires pendant ce temps sont normaux.
Option A : code Arduino avec WS2812B
Le code utilise la bibliothèque Adafruit NeoPixel, à installer depuis le gestionnaire de bibliothèques. Le nombre de marches, les LED par marche, la vitesse de la vague, la durée d'allumage et les seuils d'obscurité se règlent avec les constantes en haut du fichier. Les bases du WS2812B sont dans le guide LED WS2812B NeoPixel.
1// Arduino merdiven aydınlatması: 2 PIR + LDR + WS2812B / Arduino stair lighting: 2 PIR + LDR + WS2812B
2#include <Adafruit_NeoPixel.h>
3
4const uint8_t PIN_PIR_BOTTOM = 2; // alt basamak PIR / bottom step PIR
5const uint8_t PIN_PIR_TOP = 3; // üst basamak PIR / top step PIR
6const uint8_t PIN_LDR = A0; // LDR bölücü orta noktası / LDR divider midpoint
7const uint8_t PIN_STRIP = 6; // WS2812B DIN (330 ohm üzerinden / through 330 ohm)
8
9const uint8_t STEPS = 14; // basamak sayısı / number of steps
10const uint8_t LEDS_PER_STEP = 15; // basamak başına LED / LEDs per step
11const uint16_t STEP_DELAY_MS = 150; // basamaklar arası gecikme / delay between steps
12const unsigned long ON_TIME_MS = 15000; // son hareketten sonra açık kalma / on time after last motion
13const int DARK_LEVEL = 300; // bunun altı karanlık / below this is dark
14const int LIGHT_LEVEL = 400; // bunun üstü aydınlık / above this is bright
15
16Adafruit_NeoPixel strip(STEPS * LEDS_PER_STEP, PIN_STRIP, NEO_GRB + NEO_KHZ800);
17const uint32_t WARM_WHITE = Adafruit_NeoPixel::Color(255, 150, 50); // sıcak beyaz / warm white
18
19enum State { IDLE, TURNING_ON, LIT, TURNING_OFF };
20State state = IDLE;
21int8_t direction = 1; // 1: aşağıdan yukarı / bottom-up, -1: yukarıdan aşağı / top-down
22uint8_t stepCount = 0; // dalgada kaçıncı basamak / position in the wave
23unsigned long lastStepTime = 0;
24unsigned long lastMotion = 0;
25bool isDark = true;
26
27// Yöne göre k'inci sıradaki fiziksel basamak (0 = en alt) / physical step at position k (0 = bottom)
28uint8_t stepAt(uint8_t k) {
29 return (direction == 1) ? k : (STEPS - 1 - k);
30}
31
32void setStep(uint8_t step, uint32_t color) {
33 uint16_t first = step * LEDS_PER_STEP;
34 for (uint8_t i = 0; i < LEDS_PER_STEP; i++) strip.setPixelColor(first + i, color);
35 strip.show();
36}
37
38// LDR'yi yalnız ışıklar sönükken oku, iki eşikli / read the LDR only while lights are off, with hysteresis
39void updateDarkness() {
40 int level = analogRead(PIN_LDR);
41 if (isDark && level > LIGHT_LEVEL) isDark = false;
42 else if (!isDark && level < DARK_LEVEL) isDark = true;
43}
44
45void startWave(State next, int8_t dir) {
46 state = next;
47 direction = dir;
48 stepCount = 0;
49 lastStepTime = millis() - STEP_DELAY_MS; // ilk basamak hemen yansın / first step at once
50}
51
52void setup() {
53 pinMode(PIN_PIR_BOTTOM, INPUT);
54 pinMode(PIN_PIR_TOP, INPUT);
55 strip.begin();
56 strip.setBrightness(80); // yaklaşık %30 parlaklık / about 30% brightness
57 strip.show(); // hepsi kapalı / all off
58}
59
60void loop() {
61 unsigned long now = millis();
62 bool bottom = digitalRead(PIN_PIR_BOTTOM) == HIGH;
63 bool top = digitalRead(PIN_PIR_TOP) == HIGH;
64
65 if (state == IDLE) updateDarkness();
66
67 if (bottom || top) {
68 if ((state == IDLE && isDark) || state == TURNING_OFF) {
69 startWave(TURNING_ON, bottom ? 1 : -1); // yön: hangi sensör önce / direction: which sensor first
70 }
71 if (state != IDLE) lastMotion = now; // her hareket süreyi uzatır / every motion extends the time
72 }
73
74 switch (state) {
75 case TURNING_ON:
76 case TURNING_OFF:
77 if (now - lastStepTime >= STEP_DELAY_MS) {
78 lastStepTime = now;
79 setStep(stepAt(stepCount), state == TURNING_ON ? WARM_WHITE : 0);
80 stepCount++;
81 if (stepCount >= STEPS) state = (state == TURNING_ON) ? LIT : IDLE;
82 }
83 break;
84 case LIT:
85 if (now - lastMotion >= ON_TIME_MS) startWave(TURNING_OFF, direction); // aynı yönde sön / fade out the same way
86 break;
87 default:
88 break;
89 }
90}| Constante ou fonction | Rôle |
|---|---|
| STEPS, LEDS_PER_STEP | Dimensions de l'escalier ; le nombre total de LED est leur produit |
| STEP_DELAY_MS | Délai entre les marches ; 100–200 ms donnent l'impression d'un pas naturel |
| ON_TIME_MS | Durée d'allumage après le dernier mouvement |
| DARK_LEVEL, LIGHT_LEVEL | Détection de nuit à deux seuils ; évite les allumages répétés au crépuscule |
| stepAt(k) | Renvoie la marche physique à la position k selon le sens |
| updateDarkness() | Lit la LDR uniquement lorsque les lumières sont éteintes |
Option B : allumage progressif avec MOSFET et PCA9685
Chaque ruban monochrome demande son propre canal, alors que l'Uno n'a que 6 broches PWM. Pour un allumage et une extinction progressifs jusqu'à 16 marches, utilise le module PCA9685 : il se branche en I2C et produit un PWM 12 bits (0–4095) sur chacun de ses 16 canaux. Chaque canal commande la grille (gate) d'un MOSFET à niveau logique IRLZ44N, qui relie le moins du ruban au GND. Une résistance de 10 kΩ entre grille et source évite que les rubans s'allument au hasard au démarrage de l'Arduino. Les bases sont dans le guide MOSFET avec Arduino.
| Broche du MOSFET | Se relie à |
|---|---|
| Gate (G) | Sortie du canal du PCA9685 ; 10 kΩ vers Source |
| Drain (D) | Moins (-) du ruban |
| Source (S) | GND de l'alimentation 12 V (commun avec le GND de l'Arduino) |
| + du ruban | + de l'alimentation 12 V |
1// Arduino merdiven aydınlatması: PCA9685 + MOSFET ile yumuşak geçiş / stair lighting: smooth fades with PCA9685 + MOSFETs
2#include <Wire.h>
3#include <Adafruit_PWMServoDriver.h>
4
5Adafruit_PWMServoDriver pwm(0x40); // PCA9685 varsayılan adres / default address
6
7const uint8_t PIN_PIR_BOTTOM = 2;
8const uint8_t PIN_PIR_TOP = 3;
9const uint8_t PIN_LDR = A0;
10
11const uint8_t STEPS = 16; // kanal 0 = en alt basamak / channel 0 = bottom step
12const uint16_t STEP_DELAY_MS = 120; // dalga hızı / wave speed
13const uint16_t FADE_MS = 400; // bir basamağın açılma süresi / fade time of one step
14const uint16_t MAX_PWM = 3000; // 4095 = tam parlaklık / full brightness
15const unsigned long ON_TIME_MS = 15000;
16const int DARK_LEVEL = 300, LIGHT_LEVEL = 400;
17
18uint16_t level[STEPS]; // her basamağın parlaklığı / brightness of each step
19bool lightsOn = false; // hedef: açık mı / target: on?
20bool waveRunning = false;
21int8_t direction = 1;
22unsigned long waveStart = 0, lastMotion = 0;
23bool isDark = true;
24
25void updateDarkness() {
26 int v = analogRead(PIN_LDR);
27 if (isDark && v > LIGHT_LEVEL) isDark = false;
28 else if (!isDark && v < DARK_LEVEL) isDark = true;
29}
30
31void startWave(bool on) {
32 lightsOn = on;
33 waveStart = millis();
34 waveRunning = true;
35}
36
37// Her basamağın parlaklığı = dalga başlangıcından geçen süre - sıra x gecikme
38// Brightness of each step = time since wave start - position x delay
39void updateWave(unsigned long now) {
40 bool finished = true;
41 for (uint8_t k = 0; k < STEPS; k++) {
42 uint8_t step = (direction == 1) ? k : STEPS - 1 - k;
43 long t = (long)(now - waveStart) - (long)k * STEP_DELAY_MS;
44 uint32_t p = constrain(t, 0L, (long)FADE_MS); // 0..FADE_MS
45 if (p < FADE_MS) finished = false;
46 uint32_t q = lightsOn ? p : FADE_MS - p;
47 uint16_t target = q * q * MAX_PWM / ((uint32_t)FADE_MS * FADE_MS); // karesel: göze doğal / quadratic: natural to the eye
48 uint16_t next = lightsOn ? max(level[step], target) : min(level[step], target);
49 if (next != level[step]) {
50 level[step] = next;
51 pwm.setPin(step, next);
52 }
53 }
54 if (finished) waveRunning = false;
55}
56
57void setup() {
58 pinMode(PIN_PIR_BOTTOM, INPUT);
59 pinMode(PIN_PIR_TOP, INPUT);
60 pwm.begin();
61 pwm.setPWMFreq(1000); // 1 kHz, titremesiz / no visible flicker
62 for (uint8_t i = 0; i < STEPS; i++) {
63 level[i] = 0;
64 pwm.setPin(i, 0);
65 }
66}
67
68void loop() {
69 unsigned long now = millis();
70 bool bottom = digitalRead(PIN_PIR_BOTTOM) == HIGH;
71 bool top = digitalRead(PIN_PIR_TOP) == HIGH;
72
73 if (!lightsOn && !waveRunning) updateDarkness(); // yalnız hepsi sönükken / only while all are off
74
75 if (bottom || top) {
76 if (!lightsOn && (isDark || waveRunning)) { // karanlıkta ya da sönerken / when dark or while fading out
77 direction = bottom ? 1 : -1;
78 startWave(true);
79 }
80 if (lightsOn) lastMotion = now;
81 }
82 if (lightsOn && now - lastMotion >= ON_TIME_MS) startWave(false);
83 if (waveRunning) updateWave(now);
84}Le cœur du code est la fonction updateWave() : la luminosité de chaque marche est calculée à partir du temps écoulé depuis le début de la vague et de la position de la marche dans la séquence. La luminosité augmente de façon quadratique et non linéaire, car l'œil perçoit bien plus les variations à faible luminosité ; l'allumage paraît ainsi plus naturel. Si un nouveau mouvement arrive pendant l'extinction, chaque marche remonte depuis sa luminosité actuelle, sans coupure brutale. Avec une fréquence PWM de 1 kHz, aucun scintillement n'apparaît, même à travers la caméra d'un téléphone.
Version ESP32 : luminosité et durée réglables depuis le téléphone
En portant la même logique sur un ESP32, tu peux régler l'éclairage de l'escalier en Wi-Fi. Le code ci-dessous se connecte à ton réseau et ouvre une petite page de réglages à l'adresse IP de l'ESP32 : tu y modifies la luminosité et la durée d'allumage et tu vois la dernière valeur de la LDR. Si le Wi-Fi ne se connecte pas, le système continue hors ligne au bout de 10 secondes : l'escalier ne reste jamais dans le noir. Comme l'ADC de l'ESP32 est sur 12 bits, les seuils vont de 0 à 4095 et le pont de la LDR est alimenté en 3,3 V. Pour l'installation, consulte Qu'est-ce que l'ESP32 ?.
1// ESP32 merdiven aydınlatması + Wi-Fi ayar sayfası / ESP32 stair lighting + Wi-Fi settings page
2#include <WiFi.h>
3#include <WebServer.h>
4#include <Adafruit_NeoPixel.h>
5
6const char* WIFI_SSID = "AgAdi"; // Wi-Fi adın / your Wi-Fi name
7const char* WIFI_PASS = "Sifre123"; // Wi-Fi şifren / your Wi-Fi password
8
9const uint8_t PIN_PIR_BOTTOM = 27;
10const uint8_t PIN_PIR_TOP = 26;
11const uint8_t PIN_LDR = 34; // ADC1, yalnız giriş / input only
12const uint8_t PIN_STRIP = 4; // 74AHCT125 üzerinden DIN / to DIN via 74AHCT125
13
14const uint8_t STEPS = 14;
15const uint8_t LEDS_PER_STEP = 15;
16const uint16_t STEP_DELAY_MS = 150;
17const int DARK_LEVEL = 1200, LIGHT_LEVEL = 1600; // 12 bit ADC: 0-4095
18
19uint8_t brightness = 80; // web sayfasından değişir / set from the web page
20unsigned long onTimeMs = 15000;
21
22Adafruit_NeoPixel strip(STEPS * LEDS_PER_STEP, PIN_STRIP, NEO_GRB + NEO_KHZ800);
23WebServer server(80);
24
25enum State { IDLE, TURNING_ON, LIT, TURNING_OFF };
26State state = IDLE;
27int8_t direction = 1;
28uint8_t stepCount = 0;
29unsigned long lastStepTime = 0, lastMotion = 0;
30bool isDark = true;
31int lastLdr = 0;
32
33uint32_t warmWhite() { // parlaklığı renge uygula / apply brightness to the color
34 return Adafruit_NeoPixel::Color(255 * brightness / 255, 150 * brightness / 255, 50 * brightness / 255);
35}
36
37void setStep(uint8_t step, uint32_t color) {
38 for (uint8_t i = 0; i < LEDS_PER_STEP; i++) strip.setPixelColor(step * LEDS_PER_STEP + i, color);
39 strip.show();
40}
41
42void startWave(State next, int8_t dir) {
43 state = next;
44 direction = dir;
45 stepCount = 0;
46 lastStepTime = millis() - STEP_DELAY_MS;
47}
48
49void handleRoot() {
50 if (server.hasArg("b")) brightness = constrain(server.arg("b").toInt(), 5, 255);
51 if (server.hasArg("t")) onTimeMs = constrain(server.arg("t").toInt(), 5, 300) * 1000UL;
52 String html = "<!DOCTYPE html><html><head><meta name='viewport' content='width=device-width'></head><body>";
53 html += "<h2>Merdiven / Stairs</h2><form>";
54 html += "Parlaklik / Brightness (5-255): <input name='b' type='number' value='" + String(brightness) + "'><br>";
55 html += "Sure / Time (s): <input name='t' type='number' value='" + String(onTimeMs / 1000) + "'><br>";
56 html += "<button>Kaydet / Save</button></form>";
57 html += "<p>LDR: " + String(lastLdr) + (isDark ? " (gece / night)" : " (gunduz / day)") + "</p></body></html>";
58 server.send(200, "text/html", html);
59}
60
61void setup() {
62 Serial.begin(115200);
63 pinMode(PIN_PIR_BOTTOM, INPUT);
64 pinMode(PIN_PIR_TOP, INPUT);
65 strip.begin();
66 strip.show();
67 WiFi.mode(WIFI_STA);
68 WiFi.begin(WIFI_SSID, WIFI_PASS);
69 unsigned long t0 = millis();
70 while (WiFi.status() != WL_CONNECTED && millis() - t0 < 10000) delay(250); // en çok 10 s / at most 10 s
71 if (WiFi.status() == WL_CONNECTED) Serial.println(WiFi.localIP());
72 else Serial.println("Wi-Fi yok, cevrimdisi calisiyor / no Wi-Fi, running offline");
73 server.on("/", handleRoot);
74 server.begin();
75}
76
77void loop() {
78 server.handleClient();
79 unsigned long now = millis();
80 bool bottom = digitalRead(PIN_PIR_BOTTOM) == HIGH;
81 bool top = digitalRead(PIN_PIR_TOP) == HIGH;
82
83 if (state == IDLE) { // LDR yalnız ışıklar sönükken / LDR only while lights are off
84 lastLdr = analogRead(PIN_LDR);
85 if (isDark && lastLdr > LIGHT_LEVEL) isDark = false;
86 else if (!isDark && lastLdr < DARK_LEVEL) isDark = true;
87 }
88
89 if (bottom || top) {
90 if ((state == IDLE && isDark) || state == TURNING_OFF) startWave(TURNING_ON, bottom ? 1 : -1);
91 if (state != IDLE) lastMotion = now;
92 }
93
94 if ((state == TURNING_ON || state == TURNING_OFF) && now - lastStepTime >= STEP_DELAY_MS) {
95 lastStepTime = now;
96 uint8_t step = (direction == 1) ? stepCount : STEPS - 1 - stepCount;
97 setStep(step, state == TURNING_ON ? warmWhite() : 0);
98 if (++stepCount >= STEPS) state = (state == TURNING_ON) ? LIT : IDLE;
99 } else if (state == LIT && now - lastMotion >= onTimeMs) {
100 startWave(TURNING_OFF, direction);
101 }
102}Placement des capteurs et alternatives
Un capteur PIR détecte les variations de chaleur : il réagit quand la chaleur du corps se déplace dans son champ de vision. Le problème le plus fréquent dans un escalier, c'est quelqu'un qui passe dans le couloir du bas, ou un radiateur, qui déclenche le capteur. Oriente le capteur en biais vers la marche, masque une partie de la lentille de Fresnel avec du ruban adhésif et règle le potentiomètre de sensibilité à mi-course. Pour une détection plus précise, place à chaque extrémité un HC-SR04 ou un VL53L0X et utilise-le comme une barrière lumineuse : si la distance mesurée diminue brusquement, quelqu'un a posé le pied sur la marche. Le capteur radar RCWL-0516, lui, voit à travers les murs et se déclenche depuis la pièce voisine ; il n'est pas recommandé ici.
| Capteur | Avantage | Inconvénient | Pour l'escalier |
|---|---|---|---|
| PIR HC-SR501 | Bon marché, portée de 5–7 m, réglable | Faux déclenchements par sources de chaleur, 2–3 s de temps mort | Très bien |
| Mini PIR AM312 | Petit, fonctionne en 3,3 V, s'encastre dans la marche | Aucun réglage, portée de 3–5 m | Bien |
| HC-SR04 ou VL53L0X | Détecte avec certitude un pied sur la marche | Demande un code de mesure continue | Bien (comme une barrière lumineuse) |
| Radar RCWL-0516 | Peut se cacher derrière un cache | Traverse les murs, se déclenche depuis la pièce voisine | Déconseillé |
Erreurs fréquentes et solutions
- Les couleurs jaunissent sur les marches du haut : chute de tension sur la ligne 5 V ; réinjecte l'alimentation toutes les 2–3 marches et utilise des câbles d'alimentation épais.
- La première LED est correcte, les autres ont des couleurs aléatoires : pas de masse commune ou ligne de données trop longue ; relie les GND, place la résistance de 330 Ω près du ruban et garde le fil de données sous quelques mètres.
- Les lumières partent dans le mauvais sens : la chaîne du ruban commence à la marche du haut ; commence la chaîne en bas ou inverse la logique de sens dans le code.
- Le système s'allume de jour ou jamais la nuit : les seuils de la LDR sont faux ou la LDR voit l'éclairage de l'escalier ; mesure la valeur dans le moniteur série et déplace la LDR.
- Les lumières ne s'éteignent jamais : le potentiomètre de durée du PIR est réglé trop haut ou le capteur vise une source de chaleur ; mets-le au minimum et réoriente le capteur.
- L'Arduino redémarre au hasard : l'alimentation s'effondre à l'allumage des LED ou le ruban est branché sur la broche 5V de la carte ; prends une alimentation plus puissante et alimente le ruban séparément.
- Le MOSFET chauffe : tu utilises un MOSFET qui n'est pas à niveau logique ; passe à un modèle comme l'IRLZ44N et garde la résistance de grille entre 100 et 220 Ω.
Idées pour améliorer ton éclairage d'escalier
- Mode veilleuse : sans mouvement, seules la première et la dernière marche restent allumées à 5 % pour signaler l'escalier.
- Vague de couleurs : avec le WS2812B, allume chaque marche dans une teinte différente de l'arc-en-ciel et change les couleurs à Noël.
- Extension au couloir : avec la même logique, éclaire un long couloir avec un PIR à chaque extrémité.
- Domotique : relie l'ESP32 à Home Assistant via MQTT et pilote l'escalier avec tes autres lampes.
- Firmware prêt à l'emploi : si tu veux des effets sans coder, installe WLED et branche-y les capteurs PIR.
L'éclairage d'escalier réunit lecture de capteurs, temporisation, calcul de puissance et pilotage de LED dans un seul projet : il apporte une vraie valeur à ta maison et t'apprend beaucoup au passage. Essaie-le d'abord sur la table avec un ruban court de deux marches, puis installe-le dans ton escalier. Dans l'application BlueGrays, le projet Éclairage intelligent d'escalier et de couloir te guide pas à pas avec le schéma et le code, et les projets WS2812B et PIR te font découvrir chaque composant séparément.
Questions fréquentes
Combien de LED faut-il par marche d'escalier ?
Cela dépend de la largeur de la marche et de la densité du ruban. Avec un ruban à 30 LED/m, une marche de 90 cm reçoit 27 LED ; dans la plupart des escaliers, 10 à 20 LED par marche donnent une lumière homogène. Un profilé aluminium avec diffuseur masque les points lumineux de chaque LED.
Quelle alimentation choisir pour un éclairage d'escalier LED ?
Avec le WS2812B, multiplie le nombre total de LED par 18 mA (environ 30 % de luminosité) et ajoute 50 % de marge ; pour 210 LED, par exemple, une alimentation 5 V 6 A convient. Avec un ruban monochrome 12 V, multiplie les watts par mètre par la longueur totale, divise par 12 et ajoute 20 % de marge.
WS2812B ou ruban LED monochrome pour un escalier ?
Si tu veux des couleurs et des animations, le WS2812B est plus souple et s'installe avec un seul fil de données. Si tu cherches seulement un blanc chaud sur de grandes longueurs, un ruban monochrome 12 V ou 24 V avec MOSFET est plus efficace, subit moins de chute de tension et ne consomme presque rien en veille.
Pourquoi mon détecteur PIR allume-t-il l'escalier tout seul ?
Le PIR réagit aux variations de chaleur : un radiateur, le soleil à travers une fenêtre, un courant d'air chaud ou un animal peuvent le déclencher. Les déclenchements dans les 30 à 60 premières secondes après la mise sous tension sont aussi normaux. Oriente le capteur vers la marche, masque une partie de la lentille et baisse la sensibilité.
Comment empêcher l'éclairage de l'escalier de s'allumer en journée ?
Ajoute une LDR et n'accepte le déclenchement du PIR que si la valeur de lumière est sous un seuil. Deux seuils au lieu d'un (hystérésis) évitent les allumages et extinctions répétés au crépuscule. Place la LDR hors de portée de l'éclairage de l'escalier et lis-la uniquement lumières éteintes.
Combien de LED WS2812B un Arduino Uno peut-il piloter ?
Chaque LED occupe 3 octets de RAM ; avec les 2 Ko de l'Uno et tes autres variables, la limite pratique se situe vers 400 à 500 LED. Pour un escalier plus long, prends un Arduino Mega ou un ESP32, ou mets moins de LED par marche. C'est l'alimentation qui fournit le courant, donc la limite est la mémoire et non la puissance.
Projets à réaliser après cet article
Voir tous les projets
Éclairage intelligent des escaliers et des couloirs
Pose le pied dans l'escalier ou le couloir et les lumières s'allument marche après marche dans ton sens de passage.

Veilleuse avec LDR
Une petite veilleuse qui s'allume toute seule quand il fait nuit et s'éteint au matin.

Utilisation du ruban LED WS2812B
Tu découvres un ruban LED intelligent dont chaque lumière peut prendre sa propre couleur.

Chenillard WS2812B (remplissage)
Un ruban lumineux qui se remplit et se vide comme un verre d'eau. L'Arduino allume une à une dix LED de couleur en orange et les laisse allumées ; une fois le ruban plein, il les éteint une à une…

Détecteur de mouvement avec capteur de mouvement
Un gardien tout simple qui te prévient quand quelqu'un entre dans la pièce. Le détecteur de mouvement repère la chaleur dégagée par le corps humain ; l'Arduino garde la LED allumée tant qu'il y a du…

Éclairage automatique avec le capteur de mouvement PIR ESP32
Un capteur de mouvement PIR HC-SR501 détecte la personne qui entre dans la pièce et allume une LED automatiquement. millis() suit la durée d'allumage : chaque lecture HIGH remet à jour l'heure du dernier mouvement, et la LED s'éteint au moins 10 secondes après le dernier HIGH. Le code attend aussi 50 ms avec delay(50) à chaque boucle, qui n'est donc pas totalement non bloquante. Idéal pour un escalier, un couloir ou un placard.

Éclairage Intelligent ESP32 (PIR + LDR + Relais + OLED)
Avec un ESP32, un capteur de mouvement PIR, un capteur de lumière LDR et un module relais, on transforme ton couloir, tes toilettes ou ton cellier en éclairage intelligent. Si la pièce est déjà claire, la lumière reste éteinte malgré le mouvement : pas de gaspillage d'énergie en journée. La lumière reste allumée 30 secondes et la durée se prolonge automatiquement tant que le mouvement continue.

Contrôle d'une bande NeoPixel WS2812B avec l'ESP32
Les LED adressables WS2812B (NeoPixel) sont des LED RGB intelligentes chaînées et pilotées par une seule broche de données. On pilote un ruban WS2812B de 8 LED avec la bibliothèque Adafruit_NeoPixel pour créer un arc-en-ciel fluide. La logique 3,3 V de l'ESP32 convient à la plupart des WS2812B ; en cas d'instabilité, on montre la solution : résistance série de 470Ω et condensateur de 1000µF. L'animation fait glisser la teinte dans l'espace HSV.
Autres articles
- Ruban LED WS2812B NeoPixel avec Arduino : guide des LED RGB adressables
- Capteur de mouvement PIR (HC-SR501) : détection de mouvement avec Arduino, ESP32 et Pico
- Qu'est-ce qu'un capteur de lumière LDR ? Mesurer la lumière avec Arduino et veilleuse automatique
- MOSFET Arduino : piloter ruban LED, moteur et pompe en 12 V
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

