Ratgeber · 10 Min. Lesezeit

Treppenbeleuchtung Arduino: LED-Stufenlicht mit Bewegungsmelder

Treppenbeleuchtung mit Arduino selber bauen: zwei Bewegungsmelder erkennen die Richtung, Stufen leuchten nacheinander auf, WS2812B oder MOSFET, LDR, ESP32.

Für eine Treppenbeleuchtung mit Arduino brauchst du nur einen Arduino, zwei Bewegungsmelder und einen LED-Streifen: Betrittst du die unterste Stufe, leuchten die Stufen nacheinander von unten nach oben auf; kommst du von oben, läuft die Lichtwelle in die andere Richtung. Etwa 15 Sekunden nach der letzten Bewegung gehen die Stufen in derselben Reihenfolge wieder aus, wie bei einem Treppenlichtautomaten, nur mit Lauflicht. Die Augen des Systems sind zwei PIR-Bewegungsmelder am unteren und oberen Ende der Treppe und ein LDR, der verhindert, dass das Licht tagsüber unnötig angeht; das Gehirn ist ein Zustandsautomat aus wenigen Zeilen.

In dieser Anleitung lernst du beide Wege kennen: einen adressierbaren WS2812B-Streifen, der Hunderte LEDs einzeln über eine einzige Datenleitung steuert, und die klassische Lösung mit einem einfarbigen 12-V-Streifen pro Stufe, der über einen MOSFET sanft auf- und abgedimmt wird. Dazu gibt es eine LED- und Netzteiltabelle nach Stufenanzahl, den Schaltplan, Code für den Arduino Uno, Code für 16 Stufen mit PCA9685 und eine ESP32-Version, die du vom Handy aus einstellst.

Adressierbarer LED-Streifen WS2812B
WS2812B-Streifen: Jede LED hat ihren eigenen Treiber, deshalb lässt sich jede Stufe über eine einzige Datenleitung einzeln schalten.

Wie funktioniert eine automatische Treppenbeleuchtung?

Die Logik besteht aus vier Zuständen: Warten, Einschalten, An und Ausschalten. Im Wartezustand überwacht der Arduino beide PIR-Sensoren und prüft über den LDR, ob es dunkel ist. Löst der untere Sensor aus, wird die Richtung "aufwärts" gespeichert, beim oberen "abwärts", und die Stufen gehen im Abstand von 100–200 ms nacheinander an. Leuchtet auch die letzte Stufe, wartet das System im Zustand An; jede neue Auslösung eines Sensors startet die Zeit von vorn. Vergeht die eingestellte Zeit ohne Bewegung, gehen die Lichter in derselben Richtung aus, wie eine Welle, die der Person folgt. Diese Struktur heißt Zustandsautomat, und alles läuft mit millis() ohne Warten; so werden die Sensoren auch während des Lauflichts weiter abgefragt.

ZustandWas passiert?Übergang zum nächsten Zustand
WartenLEDs aus, LDR wird gelesenBei Dunkelheit und Auslösung des unteren oder oberen PIR folgt das Einschalten
EinschaltenDie Stufen gehen in Laufrichtung einzeln anLeuchtet die letzte Stufe, folgt der Zustand An
AnAlle Stufen leuchten, jede Bewegung verlängert die ZeitVergeht die Zeit (z. B. 15 s) ohne Bewegung, folgt das Ausschalten
AusschaltenDie Stufen gehen in derselben Richtung nacheinander ausNeue Bewegung: zurück zum Einschalten; alle aus: zurück zum Warten

Materialliste und zwei Schaltungsvarianten

  • Arduino Uno oder Nano (ESP32, wenn du die Einstellungen per Handy ändern willst).
  • 2 × HC-SR501 PIR-Bewegungsmelder: einer an der untersten, einer an der obersten Stufe.
  • LDR und 10-kΩ-Widerstand: ein Spannungsteiler als Dämmerungssensor.
  • Variante A: WS2812B-Streifen (30 oder 60 LEDs/m), 5-V-Netzteil, 1000-µF-Elko und 330-Ω-Widerstand.
  • Variante B: pro Stufe ein Stück einfarbiger 12-V-LED-Streifen, pro Stufe ein IRLZ44N-MOSFET und ein 10-kΩ-Widerstand, ein PCA9685-PWM-Modul mit 16 Kanälen und ein 12-V-Netzteil.
  • Kabel und Montage: 0,75–1,5 mm² für die Versorgung, dünne Litze für die Signale, Aluprofile mit Diffusor für die Streifen.
MerkmalVariante A: WS2812BVariante B: MOSFET + einfarbiger Streifen
SteuerleitungEin Datenpin2 I2C-Pins mit PCA9685 (bis 16 Stufen)
Verkabelung3-adrige Kette über alle Stufen (5V, GND, DIN)Von jeder Stufe 2 eigene Adern zum Controller
EffekteFarben, Regenbogen, Animation LED für LEDSanftes Dimmen pro Stufe, eine Farbe
Spannung5 V (12 V mit WS2815)12 V oder 24 V
Bei langen LeitungenSpannungsabfall, Zwischeneinspeisung nötigWeniger Verluste dank höherer Spannung
Standby-VerbrauchEtwa 0,5–1 mA pro ausgeschalteter LEDBei gesperrtem MOSFET fast null

LED- und Netzteiltabelle nach Stufenanzahl

Beim WS2812B zieht jede LED in vollem Weiß und bei voller Helligkeit etwa 60 mA (20 mA pro Farbe). Auf der Treppe nutzt du die LEDs aber in Warmweiß und mit rund 30 % Helligkeit; das blendet nicht und senkt den Strom auf etwa ein Drittel. Die Spalte "volles Weiß" in der Tabelle ist der ungünstigste Fall: Selbst wenn der Code die Helligkeit begrenzt, können beim Testen alle LEDs voll weiß leuchten. Wähle das Netzteil deshalb mindestens 1,5-mal so groß wie den praktischen Strom und lege den Kabelquerschnitt für volles Weiß aus. Die letzte Spalte zeigt den RAM, den der Code für die LED-Farben braucht; denk daran, dass der Uno nur 2 KB RAM hat.

StufenLEDs / StufeLEDs gesamtVolles Weiß (60 mA)30 % Helligkeit (~18 mA)Empfohlenes 5-V-NetzteilRAM (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 oder 12-V-Streifen1440 Byte (zu viel für den Uno)

Bei Variante B ist die Rechnung einfacher, denn bei einfarbigen 12-V-Streifen gibt der Hersteller die Leistung pro Meter an. Ein 2835-Streifen mit 60 LEDs/m braucht etwa 4,8 W/m. Mit 60 cm Streifen pro Stufe sind das 2,9 W pro Stufe und bei 16 Stufen insgesamt 46 W, also 3,8 A bei 12 V. Mit 20 % Reserve reicht ein Netzteil mit 12 V 5 A (60 W). Umrechnungen zwischen Strom, Spannung und Leistung erledigst du schnell mit dem Rechner für das ohmsche Gesetz.

Schaltplan und Pinbelegung

VerbindungArduino UnoESP32Hinweis
Unterer PIR OUTD2GPIO 27PIR VCC an 5 V, GND gemeinsam
Oberer PIR OUTD3GPIO 26Bei langer Strecke 3-adriges Kabel
Mittelpunkt LDR-TeilerA0GPIO 34LDR an 5 V (beim ESP32 an 3,3 V), 10 kΩ an GND
WS2812B DIND6 (über 330 Ω)GPIO 4 (über 74AHCT125)Variante A
PCA9685 SDA / SCLA4 / A5GPIO 21 / 22Variante B
Streifen + und -5 V und GND des Netzteils5 V und GND des NetzteilsNicht vom 5V-Pin des Boards
Versorge den LED-Streifen niemals über den 5V-Pin des Arduino: Der USB- oder Reglerpfad des Boards verkraftet höchstens 500 mA bis 1 A, und nach ein paar Dutzend LEDs startet das Board neu oder nimmt Schaden. Speise den Streifen direkt aus dem Netzteil, verbinde GND des Netzteils mit GND des Arduino (gemeinsame Masse) und setze einen 1000-µF/10-V-Elko an den Einspeisepunkt des Streifens. Arbeiten auf der 230-V-Seite und an der Hausinstallation gehören in die Hände einer Elektrofachkraft; nimm am besten ein fertiges Steckernetzteil.

Schließt du den LDR zwischen 5 V und A0 und den 10-kΩ-Widerstand zwischen A0 und GND an, steigt der gelesene Wert mit zunehmender Helligkeit. Der Widerstand des LDR liegt im Dunkeln im Megaohm-Bereich und sinkt bei Tageslicht auf 1–10 kΩ; welche Spannung der Teiler bei welcher Helligkeit liefert, siehst du mit dem Spannungsteiler-Rechner. Der Ausgang des HC-SR501 liefert beim Auslösen 3,3 V; der Uno erkennt das als HIGH, und für den ESP32 passt es direkt. Dreh das Zeit-Poti am Sensor ganz auf Minimum (etwa 3 Sekunden) und setze den Jumper auf H (retriggerbar); die Leuchtdauer soll der Code bestimmen, nicht der Sensor. Mehr zum Sensor findest du im Artikel PIR-Bewegungsmelder.

Aufbau Schritt für Schritt

  1. Zähle die Stufen und lege fest, wie viele LEDs auf jede Stufe kommen; schneide den WS2812B-Streifen nur an den Kupfer-Schnittmarken.
  2. Verkette die Streifenstücke ab der untersten Stufe: Der DOUT-Ausgang jedes Stücks geht zum DIN-Eingang des Stücks auf der nächsthöheren Stufe. So ist Stufe 0 im Code die unterste.
  3. Speise alle 2–3 Stufen (etwa alle 100 LEDs) 5 V und GND zusätzlich direkt vom Netzteil ein; diese Zwischeneinspeisung verhindert, dass die Farben oben gelblich werden.
  4. Montiere die PIR-Sensoren in etwa 30–50 cm Höhe an der Wand, ausgerichtet auf die erste und die letzte Stufe; ein kurzes Röhrchen vor der Linse engt das Sichtfeld ein.
  5. Platziere den LDR dort, wo das Treppenlicht ihn nicht direkt trifft, er aber Licht vom Fenster oder vom Flurlicht bekommt.
  6. Teste die Schaltung zuerst auf dem Tisch oder Steckbrett mit einem kurzen Streifen für 2–3 Stufen und passe dann STEPS und LEDS_PER_STEP im Code an deine Treppe an.
  7. Gib den PIR-Sensoren nach dem Einschalten 30–60 Sekunden Aufwärmzeit; zufällige Auslösungen in dieser Phase sind normal.

Variante A: Arduino-Code mit WS2812B

Der Code nutzt die Bibliothek Adafruit NeoPixel, die du über den Bibliotheksverwalter installierst. Stufenanzahl, LEDs pro Stufe, Lauflicht-Tempo, Leuchtdauer und Dunkelschwellen stellst du über die Konstanten am Anfang der Datei ein. Die Grundlagen zum WS2812B findest du im Artikel WS2812B NeoPixel LED.

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}
Konstante oder FunktionAufgabe
STEPS, LEDS_PER_STEPMaße der Treppe; die LED-Gesamtzahl ist das Produkt beider Werte
STEP_DELAY_MSVerzögerung zwischen den Stufen; 100–200 ms wirken wie natürliches Gehtempo
ON_TIME_MSLeuchtdauer nach der letzten Bewegung
DARK_LEVEL, LIGHT_LEVELDämmerungserkennung mit zwei Schwellen; verhindert ständiges Umschalten in der Dämmerung
stepAt(k)Liefert je nach Richtung die echte Stufe an Position k
updateDarkness()Liest den LDR nur, solange das Licht aus ist
Den LDR nur bei ausgeschaltetem Licht zu lesen, ist ein kleines, aber wichtiges Detail: Trifft das Treppenlicht den LDR, hält das System es womöglich für Tag und schaltet beim nächsten Mal gar nicht ein. Um die Schwellen zu finden, notiere mit Serial.println(analogRead(A0)) den Wert in der Dämmerung und setze DARK_LEVEL etwas darunter, LIGHT_LEVEL etwas darüber.

Variante B: sanftes Dimmen mit MOSFET und PCA9685

Jeder einfarbige Streifen braucht einen eigenen Kanal, der Uno hat aber nur 6 PWM-Pins. Für sanftes Auf- und Abdimmen von bis zu 16 Stufen nimmst du das Modul PCA9685: Es hängt am I2C-Bus und erzeugt auf jedem seiner 16 Kanäle eine 12-Bit-PWM (0–4095). Jeder Kanal steuert das Gate eines IRLZ44N, eines Logic-Level-MOSFETs, der den Minuspol des Streifens nach GND schaltet. Ein 10-kΩ-Widerstand zwischen Gate und Source verhindert, dass die Streifen beim Einschalten des Arduino zufällig aufleuchten. Die Grundlagen stehen im Artikel MOSFET am Arduino.

MOSFET-PinAnschluss
Gate (G)Kanalausgang des PCA9685; über 10 kΩ an Source
Drain (D)Minuspol (-) des Streifens
Source (S)GND des 12-V-Netzteils (gemeinsam mit GND des Arduino)
Streifen +Pluspol des 12-V-Netzteils
Die verbreiteten IRF520-MOSFET-Module schalten bei 5 V Gatespannung nicht voll durch; sie werden bei einigen Ampere heiß, und der Streifen erreicht nicht die volle Helligkeit. Verwende Logic-Level-MOSFETs wie IRLZ44N, IRL540N oder AOD4184; passende Typen vergleichst du in der Transistortabelle.
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}

Das Herz des Codes ist die Funktion updateWave(): Die Helligkeit jeder Stufe ergibt sich aus der Zeit seit dem Start der Welle und der Position der Stufe in der Reihenfolge. Die Helligkeit steigt quadratisch statt linear, weil das Auge Änderungen bei geringer Helligkeit viel stärker wahrnimmt; so wirkt das Aufdimmen natürlicher. Kommt während des Ausschaltens eine neue Bewegung, dimmt jede Stufe von ihrer aktuellen Helligkeit wieder hoch, ohne hartes Aus und An. Da die PWM-Frequenz 1 kHz beträgt, sieht man selbst mit der Handykamera kein Flimmern.

ESP32-Version: Helligkeit und Leuchtdauer per Handy einstellen

Überträgst du dieselbe Logik auf den ESP32, kannst du die Treppenbeleuchtung über WLAN einstellen. Der folgende Code verbindet sich mit deinem Heimnetz und öffnet unter der IP-Adresse des ESP32 eine kleine Einstellungsseite; dort änderst du Helligkeit und Leuchtdauer und siehst den letzten LDR-Wert. Klappt die WLAN-Verbindung nicht, läuft das System nach 10 Sekunden offline weiter, die Treppe bleibt also nie dunkel. Da der ADC des ESP32 12 Bit hat, liegen die Schwellen zwischen 0 und 4095, und der LDR-Teiler hängt an 3,3 V. Zur Einrichtung siehe Was ist der 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}
Der Datenausgang des ESP32 liefert 3,3 V, ein mit 5 V versorgter WS2812B erwartet aber mindestens etwa 3,5 V. Mit kurzen Kabeln klappt es oft trotzdem; siehst du jedoch zufällige Farben oder Flackern, setze einen schnellen Pegelwandler wie den 74AHCT125 in die Datenleitung. Einfache bidirektionale I2C-Pegelwandler sind für das 800-kHz-Signal des WS2812B oft zu langsam; Details im Artikel Pegelwandler.

Sensorplatzierung und alternative Sensoren

Ein PIR-Sensor erkennt Wärmeänderungen: Er reagiert, wenn sich Körperwärme durch sein Sichtfeld bewegt. Das häufigste Problem an der Treppe: Jemand läuft unten durch den Flur, oder ein Heizkörper löst den Sensor aus. Richte den Sensor schräg auf die Stufe, klebe einen Teil der Fresnel-Linse ab und dreh das Empfindlichkeits-Poti auf die Mitte. Willst du eine exaktere Erkennung, setze an jedes Ende einen HC-SR04 oder VL53L0X und nutze ihn wie eine Lichtschranke: Wird die gemessene Entfernung plötzlich kürzer, hat jemand die Stufe betreten. Der Radarsensor RCWL-0516 sieht dagegen durch Wände und löst aus dem Nebenzimmer aus; für die Treppe ist er nicht zu empfehlen.

SensorVorteilNachteilFür die Treppe
HC-SR501 PIRGünstig, 5–7 m Reichweite, einstellbarFehlauslösung durch Wärmequellen, 2–3 s SperrzeitSehr gut
AM312 Mini-PIRKlein, läuft mit 3,3 V, lässt sich in die Stufe einbauenNicht einstellbar, 3–5 m ReichweiteGut
HC-SR04 oder VL53L0XErkennt sicher, dass jemand die Stufe betrittBraucht Code für ständiges MessenGut (wie eine Lichtschranke)
RCWL-0516 RadarLässt sich hinter einer Abdeckung versteckenSieht durch Wände, löst im Nebenraum ausNicht empfohlen

Häufige Fehler und Lösungen

  • Oben werden die Farben gelblich: Spannungsabfall auf der 5-V-Leitung; speise alle 2–3 Stufen zusätzlich ein und verwende dicke Versorgungskabel.
  • Erste LED stimmt, die anderen zeigen zufällige Farben: Keine gemeinsame Masse oder zu lange Datenleitung; verbinde die GNDs, setze den 330-Ω-Widerstand nah an den Streifen und halte die Datenleitung kürzer als ein paar Meter.
  • Das Licht läuft in die falsche Richtung: Die Streifenkette beginnt an der obersten Stufe; beginne die Kette unten oder kehre die Richtungslogik im Code um.
  • Das Licht geht tagsüber an oder nachts gar nicht: Die LDR-Schwellen stimmen nicht oder der LDR sieht das Treppenlicht; miss den Wert im Seriellen Monitor und versetze den LDR.
  • Das Licht geht nie aus: Das Zeit-Poti am PIR steht zu hoch oder der Sensor blickt auf eine Wärmequelle; dreh das Poti auf Minimum und richte den Sensor neu aus.
  • Der Arduino startet zufällig neu: Das Netzteil bricht beim Einschalten der LEDs ein oder der Streifen hängt am 5V-Pin des Boards; nimm ein stärkeres Netzteil und versorge den Streifen separat.
  • Der MOSFET wird heiß: Du verwendest einen MOSFET ohne Logic-Level; wechsle zu einem Typ wie IRLZ44N und halte den Gatewiderstand zwischen 100 und 220 Ω.
Mitten in der Nacht blendet volle Helligkeit auf der Treppe. Erweitere den Code so, dass die Helligkeit zwischen 23:00 und 6:00 Uhr auf 10 % sinkt; die Uhrzeit holt sich der ESP32 mit der Methode aus dem Artikel ESP32 NTP-Uhrzeit aus dem Internet.

Ideen zum Erweitern deiner Treppenbeleuchtung

  • Nachtlicht-Modus: Ohne Bewegung leuchten nur die erste und die letzte Stufe mit 5 % und zeigen, wo die Treppe ist.
  • Farbige Welle: Mit WS2812B leuchtet jede Stufe in einem anderen Regenbogenton, an Weihnachten wechselst du die Farben.
  • Flur-Erweiterung: Mit derselben Logik beleuchtest du einen langen Flur mit je einem PIR an beiden Enden.
  • Hausautomation: Binde den ESP32 per MQTT in Home Assistant ein und steuere die Treppe zusammen mit deinen anderen Lampen.
  • Fertige Firmware: Wenn du Effekte ohne eigenen Code willst, installiere WLED und schließe die PIR-Sensoren dort an.

Eine Treppenbeleuchtung verbindet Sensorabfrage, Zeitsteuerung, Leistungsberechnung und LED-Ansteuerung in einem Projekt; sie wertet dein Zuhause dauerhaft auf und bringt dir dabei eine Menge bei. Probiere sie zuerst auf dem Tisch mit einem kurzen Streifen für zwei Stufen aus und bring sie dann an die Treppe. In der BlueGrays-App findest du im Projekt Intelligente Treppen- und Flurbeleuchtung den Schaltplan und den Code Schritt für Schritt, und mit den WS2812B- und PIR-Projekten lernst du die Bauteile einzeln kennen.

Häufige Fragen

Wie viele LEDs brauche ich pro Treppenstufe?

Das hängt von der Stufenbreite und der LED-Dichte ab. Mit einem Streifen mit 30 LEDs/m kommen auf eine 90 cm breite Stufe 27 LEDs; bei den meisten Treppen ergeben 10–20 LEDs pro Stufe ein gleichmäßiges Licht. Ein Aluprofil mit Diffusor lässt die einzelnen LED-Punkte verschwinden.

Welches Netzteil brauche ich für eine LED-Treppenbeleuchtung?

Beim WS2812B multiplizierst du die LED-Anzahl mit 18 mA (etwa 30 % Helligkeit) und rechnest 50 % Reserve dazu; für 210 LEDs passt zum Beispiel ein Netzteil mit 5 V 6 A. Beim einfarbigen 12-V-Streifen multiplizierst du die Watt pro Meter mit der Gesamtlänge, teilst durch 12 und gibst 20 % Reserve dazu.

WS2812B oder einfarbiger LED-Streifen für die Treppe?

Willst du Farben und Animationen, ist der WS2812B flexibler und kommt mit einer einzigen Datenleitung aus. Geht es nur um warmweißes Licht und lange Leitungen, ist ein einfarbiger 12-V- oder 24-V-Streifen mit MOSFET effizienter, hat weniger Spannungsabfall und fast keinen Standby-Verbrauch.

Warum schaltet der Bewegungsmelder das Treppenlicht ohne Grund ein?

Ein PIR-Sensor reagiert auf Wärmeänderungen, daher können Heizkörper, Sonne durchs Fenster, warme Luftströmungen oder Haustiere ihn auslösen. Auch Auslösungen in den ersten 30–60 Sekunden nach dem Einschalten sind normal. Richte den Sensor auf die Stufe aus, decke einen Teil der Linse ab und senke die Empfindlichkeit.

Wie verhindere ich, dass die Treppenbeleuchtung tagsüber angeht?

Du ergänzt einen LDR als Dämmerungssensor und akzeptierst die PIR-Auslösung nur, wenn der Lichtwert unter einer Schwelle liegt. Zwei Schwellen statt einer (Hysterese) verhindern ständiges Umschalten in der Dämmerung. Setze den LDR so, dass ihn das Treppenlicht nicht trifft, und lies ihn nur bei ausgeschaltetem Licht.

Wie viele WS2812B-LEDs schafft ein Arduino Uno?

Jede LED belegt 3 Byte RAM; mit den 2 KB des Uno und den übrigen Variablen liegt die praktische Grenze bei etwa 400–500 LEDs. Für längere Treppen nimmst du einen Arduino Mega oder ESP32 oder weniger LEDs pro Stufe. Den Strom liefert das Netzteil, die Grenze ist also der Speicher, nicht die Leistung.

Alle Projekte ansehen
Intelligente Treppen- und Korridorbeleuchtung
AR-82Mittel
Premium

Intelligente Treppen- und Korridorbeleuchtung

Betrittst du die Treppe oder den Flur, gehen die Lichter Stufe für Stufe in deiner Laufrichtung an.

5.0(36)
52
Nachtlicht mit LDR
AR-12Anfänger

Nachtlicht mit LDR

Ein kleines Nachtlicht, das von selbst angeht, wenn es dunkel wird, und am Morgen wieder ausgeht.

4.7(105)
225
WS2812B-LED-Streifen verwenden
AR-69Mittel
Premium

WS2812B-LED-Streifen verwenden

Du lernst einen smarten LED-Streifen kennen, bei dem du jedes einzelne Licht für sich einfärben kannst.

4.8(54)
70
WS2812B-Lauflicht (auffüllend)
AR-72Mittel
Premium

WS2812B-Lauflicht (auffüllend)

Ein Lichtstreifen, der sich füllt und leert wie ein Glas Wasser. Der Arduino schaltet zehn Farb-LEDs nacheinander in Orange ein und lässt sie an; ist der Streifen voll, schaltet er sie in derselben…

4.7(50)
65
Bewegungsmelder mit Bewegungssensor
AR-24Anfänger
Premium

Bewegungsmelder mit Bewegungssensor

Ein einfacher Wächter, der Bescheid gibt, wenn jemand den Raum betritt. Der Bewegungsmelder spürt die Wärme, die der menschliche Körper abgibt; der Arduino lässt die LED leuchten, solange sich etwas…

4.6(47)
67
Automatische Beleuchtung mit dem ESP32-PIR-Bewegungssensor
ES-19Mittel
Premium

Automatische Beleuchtung mit dem ESP32-PIR-Bewegungssensor

Ein PIR-Bewegungssensor HC-SR501 erkennt, wenn jemand den Raum betritt, und schaltet automatisch eine LED ein. millis() misst, wie lange sie leuchtet: Jedes HIGH erneuert die Zeit der letzten Bewegung, frühestens 10 Sekunden nach dem letzten HIGH geht die LED aus. Der Code wartet zudem in jeder Schleife 50 ms mit delay(50), ist also nicht ganz blockierungsfrei. Ideal für Treppen, Flure, Bäder oder Schrankbeleuchtung.

4.4(24)
38
ESP32 Intelligente Beleuchtung (PIR + LDR + Relais + OLED)
ES-37Fortgeschritten
Premium

ESP32 Intelligente Beleuchtung (PIR + LDR + Relais + OLED)

Mit ESP32, PIR-Bewegungssensor, LDR-Lichtsensor und Relaismodul machen wir aus Flur, Bad oder Vorratskammer eine smarte Beleuchtung. Ist es hell, bleibt das Licht trotz Bewegung aus, so brennt es tagsüber nicht umsonst und spart Energie. Das Licht bleibt 30 Sekunden an; solange Bewegung erkannt wird, verlängert sich die Zeit automatisch.

4.3(6)
11
Steuerung des ESP32 WS2812B NeoPixel-Streifens
ES-24Mittel
Premium

Steuerung des ESP32 WS2812B NeoPixel-Streifens

WS2812B-LEDs (NeoPixel) sind adressierbare RGB-LEDs, die sich in Reihe über einen einzigen Datenpin steuern lassen. Wir steuern einen WS2812B-Streifen mit 8 LEDs über die Bibliothek Adafruit_NeoPixel und erzeugen eine flüssige Regenbogenanimation. Die 3,3-V-Logik des ESP32 klappt bei den meisten WS2812B; bei Instabilität hilft ein 470Ω-Serienwiderstand plus 1000µF-Kondensator. Die Animation verschiebt den Farbton im HSV-Farbraum.

4.9(19)
30