Guides · 12 min de lecture

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

Ruban LED adressable WS2812B
Ruban WS2812B : chaque LED possède son propre circuit de commande, ce qui permet d'allumer chaque marche séparément avec une seule ligne de données.

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.

ÉtatQue se passe-t-il ?Passage à l'état suivant
VeilleLED éteintes, la LDR est lueDans le noir, un déclenchement du PIR du bas ou du haut lance l'allumage
AllumageLes marches s'allument une à une dans le sens de la marcheQuand la dernière marche est allumée, passage à l'état allumé
AlluméToutes les marches allumées, chaque mouvement prolonge la duréeSi la durée (ex. 15 s) passe sans mouvement, l'extinction commence
ExtinctionLes marches s'éteignent une à une dans le même sensNouveau 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éristiqueOption A : WS2812BOption B : MOSFET + ruban monochrome
Ligne de commandeUne seule broche de données2 broches I2C avec le PCA9685 (jusqu'à 16 marches)
CâblageChaîne à 3 fils sur toutes les marches (5V, GND, DIN)2 fils séparés de chaque marche jusqu'au contrôleur
EffetsCouleurs, arc-en-ciel, animation LED par LEDAllumage progressif par marche, une seule couleur
Tension5 V (12 V avec le WS2815)12 V ou 24 V
Sur de grandes longueursChute de tension, réinjection nécessaireMoins de pertes grâce à la tension plus élevée
Consommation en veilleEnviron 0,5–1 mA par LED éteintePresque 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.

MarchesLED / marcheLED au totalBlanc pur (60 mA)30 % de luminosité (~18 mA)Alimentation 5 V conseilléeRAM (3 octets/LED)
10101006,0 A1,8 A5 V 3 A300 octets
121518010,8 A3,2 A5 V 5 A540 octets
141521012,6 A3,8 A5 V 6 A630 octets
162032019,2 A5,8 A5 V 10 A960 octets
163048028,8 A8,6 A5 V 15 A ou ruban 12 V1440 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

ConnexionArduino UnoESP32Remarque
OUT du PIR du basD2GPIO 27VCC du PIR sur 5 V, GND commun
OUT du PIR du hautD3GPIO 26Câble 3 conducteurs si le haut est loin
Point milieu du pont LDRA0GPIO 34LDR vers 5 V (3,3 V sur l'ESP32), 10 kΩ vers GND
DIN du WS2812BD6 (via 330 Ω)GPIO 4 (via 74AHCT125)Option A
SDA / SCL du PCA9685A4 / A5GPIO 21 / 22Option B
+ et - du ruban5 V et GND de l'alimentation5 V et GND de l'alimentationPas depuis la broche 5V de la carte
N'alimente jamais le ruban LED par la broche 5V de l'Arduino : le chemin USB ou le régulateur de la carte supporte au plus 500 mA à 1 A, et au-delà de quelques dizaines de LED la carte redémarre ou s'abîme. Alimente le ruban directement depuis l'alimentation, relie le GND de l'alimentation à celui de l'Arduino (masse commune) et place un condensateur de 1000 µF / 10 V à l'entrée du ruban. Ne touche pas toi-même au côté 230 V ni à l'installation encastrée : prends une alimentation prête à brancher ou confie cette partie à un électricien.

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

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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.
  7. 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.

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 fonctionRôle
STEPS, LEDS_PER_STEPDimensions de l'escalier ; le nombre total de LED est leur produit
STEP_DELAY_MSDélai entre les marches ; 100–200 ms donnent l'impression d'un pas naturel
ON_TIME_MSDurée d'allumage après le dernier mouvement
DARK_LEVEL, LIGHT_LEVELDé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
Lire la LDR uniquement quand les lumières sont éteintes est un détail petit mais important : si l'éclairage de l'escalier éclaire la LDR, le système peut croire qu'il fait jour et ne plus s'allumer au déclenchement suivant. Pour trouver les seuils, note la valeur au crépuscule avec Serial.println(analogRead(A0)), puis règle DARK_LEVEL un peu en dessous et LIGHT_LEVEL un peu au-dessus.

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 MOSFETSe 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
Les modules MOSFET IRF520 très répandus ne conduisent pas complètement avec 5 V sur la grille : ils chauffent dès quelques ampères et le ruban n'atteint jamais sa pleine luminosité. Utilise des MOSFET à niveau logique comme l'IRLZ44N, l'IRL540N ou l'AOD4184 ; tu peux comparer les références dans le tableau des transistors.
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}

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

C++ (Arduino IDE)
1// ESP32 merdiven aydınlatması + Wi-Fi ayar sayfası / ESP32 stair lighting + Wi-Fi settings page
2#include <WiFi.h>
3#include <WebServer.h>
4#include <Adafruit_NeoPixel.h>
5
6const char* WIFI_SSID = "AgAdi";        // Wi-Fi adın / your Wi-Fi name
7const char* WIFI_PASS = "Sifre123";     // Wi-Fi şifren / your Wi-Fi password
8
9const uint8_t PIN_PIR_BOTTOM = 27;
10const uint8_t PIN_PIR_TOP    = 26;
11const uint8_t PIN_LDR        = 34;      // ADC1, yalnız giriş / input only
12const uint8_t PIN_STRIP      = 4;       // 74AHCT125 üzerinden DIN / to DIN via 74AHCT125
13
14const uint8_t  STEPS         = 14;
15const uint8_t  LEDS_PER_STEP = 15;
16const uint16_t STEP_DELAY_MS = 150;
17const int DARK_LEVEL = 1200, LIGHT_LEVEL = 1600;   // 12 bit ADC: 0-4095
18
19uint8_t brightness = 80;               // web sayfasından değişir / set from the web page
20unsigned long onTimeMs = 15000;
21
22Adafruit_NeoPixel strip(STEPS * LEDS_PER_STEP, PIN_STRIP, NEO_GRB + NEO_KHZ800);
23WebServer server(80);
24
25enum State { IDLE, TURNING_ON, LIT, TURNING_OFF };
26State state = IDLE;
27int8_t direction = 1;
28uint8_t stepCount = 0;
29unsigned long lastStepTime = 0, lastMotion = 0;
30bool isDark = true;
31int lastLdr = 0;
32
33uint32_t warmWhite() {                 // parlaklığı renge uygula / apply brightness to the color
34  return Adafruit_NeoPixel::Color(255 * brightness / 255, 150 * brightness / 255, 50 * brightness / 255);
35}
36
37void setStep(uint8_t step, uint32_t color) {
38  for (uint8_t i = 0; i < LEDS_PER_STEP; i++) strip.setPixelColor(step * LEDS_PER_STEP + i, color);
39  strip.show();
40}
41
42void startWave(State next, int8_t dir) {
43  state = next;
44  direction = dir;
45  stepCount = 0;
46  lastStepTime = millis() - STEP_DELAY_MS;
47}
48
49void handleRoot() {
50  if (server.hasArg("b")) brightness = constrain(server.arg("b").toInt(), 5, 255);
51  if (server.hasArg("t")) onTimeMs = constrain(server.arg("t").toInt(), 5, 300) * 1000UL;
52  String html = "<!DOCTYPE html><html><head><meta name='viewport' content='width=device-width'></head><body>";
53  html += "<h2>Merdiven / Stairs</h2><form>";
54  html += "Parlaklik / Brightness (5-255): <input name='b' type='number' value='" + String(brightness) + "'><br>";
55  html += "Sure / Time (s): <input name='t' type='number' value='" + String(onTimeMs / 1000) + "'><br>";
56  html += "<button>Kaydet / Save</button></form>";
57  html += "<p>LDR: " + String(lastLdr) + (isDark ? " (gece / night)" : " (gunduz / day)") + "</p></body></html>";
58  server.send(200, "text/html", html);
59}
60
61void setup() {
62  Serial.begin(115200);
63  pinMode(PIN_PIR_BOTTOM, INPUT);
64  pinMode(PIN_PIR_TOP, INPUT);
65  strip.begin();
66  strip.show();
67  WiFi.mode(WIFI_STA);
68  WiFi.begin(WIFI_SSID, WIFI_PASS);
69  unsigned long t0 = millis();
70  while (WiFi.status() != WL_CONNECTED && millis() - t0 < 10000) delay(250);   // en çok 10 s / at most 10 s
71  if (WiFi.status() == WL_CONNECTED) Serial.println(WiFi.localIP());
72  else Serial.println("Wi-Fi yok, cevrimdisi calisiyor / no Wi-Fi, running offline");
73  server.on("/", handleRoot);
74  server.begin();
75}
76
77void loop() {
78  server.handleClient();
79  unsigned long now = millis();
80  bool bottom = digitalRead(PIN_PIR_BOTTOM) == HIGH;
81  bool top = digitalRead(PIN_PIR_TOP) == HIGH;
82
83  if (state == IDLE) {                 // LDR yalnız ışıklar sönükken / LDR only while lights are off
84    lastLdr = analogRead(PIN_LDR);
85    if (isDark && lastLdr > LIGHT_LEVEL) isDark = false;
86    else if (!isDark && lastLdr < DARK_LEVEL) isDark = true;
87  }
88
89  if (bottom || top) {
90    if ((state == IDLE && isDark) || state == TURNING_OFF) startWave(TURNING_ON, bottom ? 1 : -1);
91    if (state != IDLE) lastMotion = now;
92  }
93
94  if ((state == TURNING_ON || state == TURNING_OFF) && now - lastStepTime >= STEP_DELAY_MS) {
95    lastStepTime = now;
96    uint8_t step = (direction == 1) ? stepCount : STEPS - 1 - stepCount;
97    setStep(step, state == TURNING_ON ? warmWhite() : 0);
98    if (++stepCount >= STEPS) state = (state == TURNING_ON) ? LIT : IDLE;
99  } else if (state == LIT && now - lastMotion >= onTimeMs) {
100    startWave(TURNING_OFF, direction);
101  }
102}
La sortie de données de l'ESP32 est en 3,3 V, alors qu'un WS2812B alimenté en 5 V attend au moins 3,5 V environ sur son entrée. Avec des fils courts, cela marche souvent quand même, mais si tu vois des couleurs aléatoires ou un scintillement, ajoute un adaptateur de niveau rapide comme le 74AHCT125 sur la ligne de données. Les convertisseurs bidirectionnels pour I2C peuvent être trop lents pour le signal à 800 kHz du WS2812B ; détails dans le guide du convertisseur de niveau logique.

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.

CapteurAvantageInconvénientPour l'escalier
PIR HC-SR501Bon marché, portée de 5–7 m, réglableFaux déclenchements par sources de chaleur, 2–3 s de temps mortTrès bien
Mini PIR AM312Petit, fonctionne en 3,3 V, s'encastre dans la marcheAucun réglage, portée de 3–5 mBien
HC-SR04 ou VL53L0XDétecte avec certitude un pied sur la marcheDemande un code de mesure continueBien (comme une barrière lumineuse)
Radar RCWL-0516Peut se cacher derrière un cacheTraverse les murs, se déclenche depuis la pièce voisineDé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 Ω.
En pleine nuit, la pleine luminosité éblouit la personne qui descend l'escalier. Complète le code pour réduire la luminosité à 10 % entre 23 h et 6 h ; pour récupérer l'heure sur Internet avec l'ESP32, utilise la méthode du guide heure NTP avec l'ESP32.

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.

Voir tous les projets
Éclairage intelligent des escaliers et des couloirs
AR-82Intermédiaire
Premium

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

5.0(36)
52
Veilleuse avec LDR
AR-12Débutant

Veilleuse avec LDR

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

4.7(105)
225
Utilisation du ruban LED WS2812B
AR-69Intermédiaire
Premium

Utilisation du ruban LED WS2812B

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

4.8(54)
70
Chenillard WS2812B (remplissage)
AR-72Intermédiaire
Premium

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…

4.7(50)
65
Détecteur de mouvement avec capteur de mouvement
AR-24Débutant
Premium

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…

4.6(47)
67
Éclairage automatique avec le capteur de mouvement PIR ESP32
ES-19Intermédiaire
Premium

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

4.4(24)
38
Éclairage Intelligent ESP32 (PIR + LDR + Relais + OLED)
ES-37Avancé
Premium

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

4.3(6)
11
Contrôle d'une bande NeoPixel WS2812B avec l'ESP32
ES-24Intermédiaire
Premium

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.

4.9(19)
30