RGB LED Treppenbeleuchtung mit Home Assistant

Kategorie:: hardware
Unterkategorie:: pcb
Pfad:: templates/hardware/rgb-led-treppe
Tags:
#pcb#esphome
ESPHome Build-Status

Letzter täglicher Build
Build OK
Build erfolgreich
Zuletzt gebaut: 01.09.2026, 15:17
Build-Details & Log anzeigen
Zur Übersicht
PCB-Fertigungsdateien (im Download enthalten)

KiCad-DesignKiCAD Tutorial →
Gerber1 BOM, 11 Dateien
BOM öffnen
Download2.4MB
Beschreibung & Dokumentation

RGB LED Treppenbeleuchtung mit Home Assistant Verwandle deine Treppe in eine smarte Lichtshow! Dieses DIY-Projekt setzt auf eine Adresse LED-Strip (z. B. WS2812B) und eine Steuerung mit ESP8266 + ESPHome, ausgelöst durch Bewegungsmelder an oben und unten. Alle Abläufe laufen lokal. Keine Cloud nötig...
Projekt-Assets

Grafiken (4)

rgb-treppe-leds.jpg
1205.9 KB
rgb-treppe-schaltplan.png
146.8 KB
rgb-treppe.jpg
720.7 KB
Code-Vorschau

Haupt-Konfiguration
Tipp: Markieren & ⌘/Ctrl + C zum Kopieren
configuration.yaml
substitutions:
  # ------------------
  #   Pin-Belegung
  # ------------------
  lightlevel_pin:            A0
  pir_down_pin:              D5
  pir_up_pin:                D7
  led_pin:                   D6
  
  statusled_pir_up_pin:      D1
  statusled_pir_down_pin:    D2
  statusled_light_pin:       D8


  # ------------------
  #    LED Timings
  # ------------------
  # Gibt die Zeit an, nach der die Treppe sich automatisch wieder ausschaltet, 
  # wenn bis dahin keine Bewegung am anderen Ende erkannt wurde.
  timeout_seconds:          60s
  
  # Gibt an, wie lange die Abschaltung verzögert werden soll, 
  # nach dem eine Bewegung am Ziel der Treppe erkannt wurde.
  switchoff_delay_seconds:   10s
  
  # Gibt an, wie lange die Treppe nach abschalten der LEDs deaktiviert sein soll,
  # Bevor sie durch Bewegung wieder ausgelöst werden kann.
  cooldown_seconds:          5s
  
  

  # ------------------------
  #   Effekt-Einstellungen
  # ------------------------
  
  # Folgende Effekte stehen zur Verfügung:
  #
  # Rainbow
  # Color Wipe Up
  # Color Wipe Down
  # Rocket
  # Firework
  # Stufenlicht rauf
  # Stufenlicht rauf animiert
  # Stufenlicht rauf colorized
  # Stufenlicht rauf aus
  # Stufenlicht runter
  # Stufenlicht runter animiert
  # Stufenlicht runter colorized
  # Stufenlicht runter aus
  
  # Effekt-Name für das einschalten der Treppe von unten nach oben.
  led_effect_up:             "Stufenlicht rauf colorized"

  # Effekt-Name für das einschalten der Treppe von oben nach unten.
  led_effect_down:           "Stufenlicht runter colorized"
  
  # Effekt-Name für das abschalten der Treppe von unten nach oben.
  # Wird kein Effektname angegeben, werden die LEDs nur ausgeschaltet.
  led_effect_up_off:         "Stufenlicht rauf aus"

  # Effekt-Name für das abschalten der Treppe von oben nach unten.
  # Wird kein Effektname angegeben, werden die LEDs nur ausgeschaltet.
  led_effect_down_off:       "Stufenlicht runter aus"
  led_effect_off_timeout:    10s
  
  # Gibt an, wie viele beleuchtete Stufen die Treppe besitzt 
  stufen_anzahl:             "16"
  
  # Gibt an, wie viele LEDs je Stufe existieren 
  # (Anzahl der Zahlenwerte muss mit "stufen_anzahl" übereinstimmen)
  leds_pro_stufe:            "{36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36}" #, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10}"

  # Gibt die Farbe je Stufe an (für "Colorized" Animation) 
  # (Anzahl der Zahlenwerte muss mit "stufen_anzahl" übereinstimmen)
  farbe_je_stufe:            "{Color(39,111,181), Color(39,111,181), Color(39,111,181), Color(39,111,181), Color(39,111,181), Color(39,111,181), Color(39,111,181), Color(39,111,181), Color(39,111,181), Color(39,111,181), Color(39,111,181), Color(39,111,181), Color(39,111,181), Color(39,111,181), Color(39,111,181), Color(39,111,181) }" 


  # ------------------
  #    System
  # ------------------
  # Anzahl der LEDs
  led_anzahl: "576"

  # Gibt an, ob die Treppe anhand des Lichtsensors ein/ausgeschaltet werden soll
  # Da der Fotowiderstand bei Dunkelheit weniger Strom durchlässt, 
  # ist die Treppe bei aktiviertem Lichtsensor nur aktiv, 
  # Wenn der Sensorwert unter dem "lightlevel_maxvalue" Wert liegt.
  light_sensor_active:       "false"
  lightlevel_maxvalue:       "0.7"

  # Gibt an, ob die Treppe anhand des Sonnenstandes automatisch ein/ausgeschaltet werden soll.
  # Wenn aktiv (true) ist schaltet sich die Treppe nur nach Sonnenuntergang ein.
  sun_active:       "false"
  
  # Höhen/Breitengrad für Sonnenstandsermittlung
  latitude: "51.138374°"
  longitude: "7.185790°"


  # WLAN Zugangsdaten
  wifi_ssid:                 !secret wifi_ssid 
  wifi_password:             !secret wifi_password

# -------------------------------------------------------------
# -------------------------------------------------------------
#  AB HIER MUSS NICHTS MEHR GEÄNDERT WERDEN
# -------------------------------------------------------------
# -------------------------------------------------------------


wifi:
  ssid: ${wifi_ssid}
  password: ${wifi_password}

  ap:
    ssid: "RGB-Treppe"
    password: "fnlIp2hjHmrL"
    ap_timeout: 30s

web_server:
captive_portal:

api:
  encryption:
    key: !secret ESPHOME_ENCRYPTION_KEY

ota:
  platform: esphome
  password: !secret ota_password


esphome:
  name: shys-rgb-treppe
  friendly_name: SHYS RGB Treppe
  on_boot:
    priority: 500
    then:
      - switch.turn_on: treppe_aktiv

esp8266:
  board: nodemcuv2

logger:


globals:
  - id: treppe_rauf_laeuft
    type: bool
    restore_value: no
    initial_value: 'false'
    
  - id: treppe_runter_laeuft
    type: bool
    restore_value: no
    initial_value: 'false'
    
  - id: led_anzahl
    type: int
    restore_value: yes
    initial_value: '120'
    
  - id: stufen_anzahl
    type: int
    restore_value: yes
    initial_value: '12'


number:
  - platform: template
    id: led_count_test
    name: "led_count_test"
    optimistic: true
    min_value: 0
    max_value: 1000
    step: 1
    initial_value: 120
    restore_value: true


sun:
  latitude: ${latitude}
  longitude: ${longitude}

time:
  - platform: homeassistant
    id: local_time
  - platform: sntp
    id: sntp_time


script:
  - id: treppe_rauf_aktivieren
    mode: restart
    then:
      - if:
          condition:
            - switch.is_on: treppe_aktiv
            - or:
                - lambda: return id(rgbtreppe_helligkeitssensor).state < ${lightlevel_maxvalue};
                - lambda: return ${light_sensor_active} == false;
            - or:
                - not: 
                    - wifi.connected:
                - sun.is_below_horizon:
                - lambda: return ${sun_active} == false;
            - lambda: return id(treppe_rauf_laeuft) == false && id(treppe_runter_laeuft) == false;

          then:
            - text_sensor.template.publish:
                id: treppen_status
                state: "Treppe rauf"
            - lambda: id(treppe_rauf_laeuft) = true;
            - light.turn_on:
                id: rgbtreppe_led
                effect: ${led_effect_up}
                
      # Trennung + zusätzliches if für "restart"-Mode
      - if:
          condition:
            - lambda: return id(treppe_rauf_laeuft) == true;
          then:
            - wait_until:
                timeout: ${timeout_seconds}
                condition: 
                  binary_sensor.is_on: rgbtreppe_pir_o
            - script.execute: treppe_rauf_deaktivieren

  - id: treppe_runter_aktivieren
    mode: restart
    then:
      - if:
          condition:
            - switch.is_on: treppe_aktiv
            - or:
                - lambda: return id(rgbtreppe_helligkeitssensor).state < ${lightlevel_maxvalue};
                - lambda: return ${light_sensor_active} == false;
            - or:
                - not: 
                    - wifi.connected:
                - sun.is_below_horizon:
                - lambda: return ${sun_active} == false;
            - lambda: return id(treppe_rauf_laeuft) == false && id(treppe_runter_laeuft) == false;

          then:
            - text_sensor.template.publish:
                id: treppen_status
                state: "Treppe runter"
            - lambda: id(treppe_runter_laeuft) = true;
            - light.turn_on:
                id: rgbtreppe_led
                effect: ${led_effect_down}
      # Trennung + zusätzliches if für "restart"-Mode
      - if:
          condition:
            - lambda: return id(treppe_runter_laeuft) == true;
          then:
            - wait_until:
                timeout: ${timeout_seconds}
                condition: 
                  binary_sensor.is_on: rgbtreppe_pir_u
            - script.execute: treppe_runter_deaktivieren

  - id: treppe_rauf_deaktivieren
    mode: restart
    then:
      - delay: ${switchoff_delay_seconds}
            
      - if:
          condition:
            - not: 
              - lambda: 'return strcmp("${led_effect_up_off}", "") == 0;'
          then:
            - light.turn_on:
                id: rgbtreppe_led
                effect: ${led_effect_up_off}
            - delay: ${led_effect_off_timeout}
            
      - light.turn_off:
          id: rgbtreppe_led
      - delay: ${cooldown_seconds}
      - lambda: id(treppe_rauf_laeuft) = false;

    
  - id: treppe_runter_deaktivieren
    mode: restart
    then:
      - delay: ${switchoff_delay_seconds}
      
      - if:
          condition:
            - not: 
              - lambda: 'return strcmp("${led_effect_down_off}", "") == 0;'
          then:
            - light.turn_on:
                id: rgbtreppe_led
                effect: ${led_effect_down_off}
            - delay: ${led_effect_off_timeout}
            
      - light.turn_off:
          id: rgbtreppe_led
      - delay: ${cooldown_seconds}
      - lambda: id(treppe_runter_laeuft) = false;


text_sensor:
  - platform: template
    name: "Treppen-Status"
    id: treppen_status
    lambda: return {"idle"};


sensor:
  - platform: adc
    pin: ${lightlevel_pin}
    name: "RGB-Treppe Helligkeitssensor"
    update_interval: 30s
    id: rgbtreppe_helligkeitssensor


binary_sensor:
  - platform: gpio
    pin: ${pir_down_pin}
    name: "Treppe Bewegungsmelder unten"
    device_class: motion
    id: rgbtreppe_pir_u
    on_press:
      then:
        - script.execute: treppe_rauf_aktivieren

  - platform: gpio
    pin: ${pir_up_pin}
    name: "Treppe Bewegungsmelder oben"
    device_class: motion
    id: rgbtreppe_pir_o
    on_press:
      then:
        - script.execute: treppe_runter_aktivieren

switch:
  - platform: gpio
    pin: ${statusled_pir_up_pin}
    name: "RGB-Treppe PIR oben Status LED"
    id: rgbtreppe_pir_status_o
    internal: true
    
  - platform: gpio
    pin: ${statusled_pir_down_pin}
    name: "RGB-Treppe PIR unten Status LED"
    id: rgbtreppe_pir_status_u
    internal: true

  - platform: gpio
    pin: ${statusled_light_pin}
    name: "RGB-Treppe Helligkeit Status LED"
    id: rgbtreppe_hell_status
    internal: true

  - platform: template
    name: "Treppe Aktiviert"
    id: treppe_aktiv
    optimistic: true
    


light:
  - platform: neopixelbus
    type: GRB
    variant: WS2812
    pin: ${led_pin}
    num_leds: ${led_anzahl}
    default_transition_length: 3s
    name: "Treppe Oben LED"
    id: rgbtreppe_led
    restore_mode: ALWAYS_OFF
    
    on_turn_off:
      - text_sensor.template.publish:
          id: treppen_status
          state: "idle"    
    
    effects:
      - addressable_rainbow:
          name: Rainbow
          speed: 10
          width: 90

      - addressable_color_wipe:
          name: Color Wipe Down
          colors:
            - red: 0%
              green: 0%
              blue: 100%
              num_leds: 30
            - red: 30%
              green: 100%
              blue: 60%
              num_leds: 30
          add_led_interval: 50ms
          reverse: false

      - addressable_color_wipe:
          name: Color Wipe Up
          colors:
            - red: 0%
              green: 0%
              blue: 100%
              num_leds: 30
            - red: 30%
              green: 100%
              blue: 60%
              num_leds: 30
          add_led_interval: 50ms
          reverse: true

      - addressable_color_wipe:
          name: Rocket
          colors:
            - red: 100%
              green: 0%
              blue: 0%
              num_leds: 3
            - red: 100%
              green: 100%
              blue: 100%
              num_leds: 2
            - red: 100%
              green: 0%
              blue: 0%
              num_leds: 3
            - red: 100%
              green: 100%
              blue: 100%
              num_leds: 2

            - red: 10%
              green: 5%
              blue: 2%
              num_leds: 1
            - red: 30%
              green: 15%
              blue: 6%
              num_leds: 1
            - red: 70%
              green: 30%
              blue: 10%
              num_leds: 1
            - red: 100%
              green: 80%
              blue: 20%
              num_leds: 1
            - red: 100%
              green: 40%
              blue: 10%
              num_leds: 1
            - red: 10%
              green: 5%
              blue: 1%
              num_leds: 1
            - red: 0%
              green: 0%
              blue: 0%
              num_leds: 1
            - red: 10%
              green: 5%
              blue: 1%
              num_leds: 1

            - red: 0%
              green: 0%
              blue: 0%
              num_leds: 155
          add_led_interval: 20ms
          reverse: true

      - addressable_fireworks:
          name: Firework
          update_interval: 32ms
          spark_probability: 40%
          use_random_color: true
          fade_out_rate: 120
 

      # Bei diesem Effekt wird jede Stufe einzeln in einer Zufalls-Farbe eingeschaltet. (Laufrichtung von Stripe-Start nach Stripe-Ende)
      # In diesem Effekt behalten die Stufen bis zum abschalten ihre Farbe. 
      # 
      # - anzahl             -  muss auf die Anzahl der Stufen angepasst werden
      # - ledStufe[anzahl]   -  ist ein Array, welches für jede Stufe die jeweilige Anzahl der LEDs beinhaltet.
      #                         Die Anzahl der in ledStufe enthaltenen Einträge muss der Anzahl der Stufen entsprechen!
      - addressable_lambda:
          name: "Stufenlicht rauf"
          update_interval: 16ms
          lambda: |-
            static const int16_t anzahl = ${stufen_anzahl};
            int ledStufe[anzahl] = ${leds_pro_stufe};
            int von = 0;
            
            static uint16_t progress = 0;
            if (initial_run) {
              progress = -1;
            }
            
            for(int stufe=0; stufe < anzahl; stufe++){
              if(stufe == progress){
                it.range(von, von + ledStufe[stufe]) = esphome::Color::random_color();
              } else {
                von += ledStufe[stufe];
              }
            }
            
            if(progress >= 0){
              delay(300);
            } 
            progress++;


      # Beim animierten Effekt wird jede Stufe einzeln in einer Zufalls-Farbe eingeschaltet.  (Laufrichtung von Stripe-Start nach Stripe-Ende)
      # Sobald alle Stufen aktiv sind, wird bei der ersten Stufe wieder mit einer neuen Zufalls-Farbe angefangen.
      # 
      # - anzahl             -  muss auf die Anzahl der Stufen angepasst werden
      # - ledStufe[anzahl]   -  ist ein Array, welches für jede Stufe die jeweilige Anzahl der LEDs beinhaltet.
      #                         Die Anzahl der in ledStufe enthaltenen Einträge muss der Anzahl der Stufen entsprechen!
      - addressable_lambda:
          name: "Stufenlicht rauf animiert"
          update_interval: 16ms
          lambda: |-
            static const int16_t anzahl = ${stufen_anzahl};
            int ledStufe[anzahl] = ${leds_pro_stufe};

            int von = 0;
            static uint16_t progress = 0;
            if (initial_run) {
              progress = -1;
            }
            
            for(int stufe=0; stufe < anzahl; stufe++){
              if(stufe == progress){
                it.range(von, von + ledStufe[stufe]) = esphome::Color::random_color();
              } else {
                von += ledStufe[stufe];
              }
            }
            
            if(progress >= 0){
              delay(300);
            }
            
            if(progress > anzahl){
              progress = 0;
            } else {
              progress++;
            }


      # Beim colorized Effekt wird jede Stufe einzeln in einer Festgelegten-Farbe eingeschaltet.  (Laufrichtung von Stripe-Start nach Stripe-Ende)
      # Die Farbauswahl kann für jede Stufe individuell erfolgen
      # 
      # - anzahl                  -  muss auf die Anzahl der Stufen angepasst werden
      # - ledStufe[anzahl]        -  ist ein Array, welches für jede Stufe die jeweilige Anzahl der LEDs beinhaltet.
      #                              Die Anzahl der in ledStufe enthaltenen Einträge muss der Anzahl der Stufen entsprechen!
      # - ledStufenFarbe[anzahl]  -  ist ein Array, welches für jede Stufe die jeweilige Farbe beinhaltet.
      #                              Die Anzahl der in ledStufenFarbe enthaltenen Einträge muss der Anzahl der Stufen entsprechen!
      #                              Die Farben sind in der Form "Color(rot, grün, blau)" anzugeben, 
      #                              wobei hier für rot, grün und blau jeweils eine Zahl zwischen 0 und 255 angegeben werden muss.
      - addressable_lambda:
          name: "Stufenlicht rauf colorized"
          update_interval: 16ms
          lambda: |-
            static const int16_t anzahl = ${stufen_anzahl};
            int ledStufe[anzahl] = ${leds_pro_stufe};
            Color ledStufenFarbe[anzahl] = ${farbe_je_stufe};

            int von = 0;
            static uint16_t progress = 0;
            if (initial_run) {
              progress = -1;
            }
            
            for(int stufe=0; stufe < anzahl; stufe++){
              if(stufe == progress){
                it.range(von, von + ledStufe[stufe]) = ledStufenFarbe[stufe];
              } else {
                von += ledStufe[stufe];
              }
            }
            
            if(progress >= 0){
              delay(200);
            } 
            progress++;


      # Bei diesem Effekt wird jede Stufe einzeln ausgeschaltet. (Laufrichtung von Stripe-Start nach Stripe-Ende)
      # 
      # - anzahl             -  muss auf die Anzahl der Stufen angepasst werden
      # - ledStufe[anzahl]   -  ist ein Array, welches für jede Stufe die jeweilige Anzahl der LEDs beinhaltet.
      #                         Die Anzahl der in ledStufe enthaltenen Einträge muss der Anzahl der Stufen entsprechen!
      - addressable_lambda:
          name: "Stufenlicht rauf aus"
          update_interval: 16ms
          lambda: |-
            static const int16_t anzahl = ${stufen_anzahl};
            int ledStufe[anzahl] = ${leds_pro_stufe};
            int von = 0;
            
            static uint16_t progress = 0;
            if (initial_run) {
              progress = -1;
            }
            
            for(int stufe=0; stufe < anzahl; stufe++){
              if(stufe == progress){
                it.range(von, von + ledStufe[stufe]) = esphome::Color(0,0,0);
              } else {
                von += ledStufe[stufe];
              }
            }
            
            if(progress >= 0){
              delay(500);
            }
            
            progress++;


      # Bei diesem Effekt wird jede Stufe einzeln in einer Zufalls-Farbe eingeschaltet. (Laufrichtung von Stripe-Ende nach Stripe-Start)
      # In diesem Effekt behalten die Stufen bis zum abschalten ihre Farbe. 
      # 
      # - anzahl             -  muss auf die Anzahl der Stufen angepasst werden
      # - ledStufe[anzahl]   -  ist ein Array, welches für jede Stufe die jeweilige Anzahl der LEDs beinhaltet.
      #                         Die Anzahl der in ledStufe enthaltenen Einträge muss der Anzahl der Stufen entsprechen!
      - addressable_lambda:
          name: "Stufenlicht runter"
          update_interval: 16ms
          lambda: |-
            static const int16_t anzahl = ${stufen_anzahl};
            int ledStufe[anzahl] = ${leds_pro_stufe};
            int von = 0;
            
            static uint16_t progress = 0;
            if (initial_run) {
              progress = anzahl;
            }
            
            for(int stufe=0; stufe < anzahl; stufe++){
              if(stufe == progress){
                it.range(von, von + ledStufe[stufe]) = esphome::Color::random_color();
              } else {
                von += ledStufe[stufe];
              }
            }
            
            if(progress < anzahl){
              delay(300);
            }
            progress--;


      # Beim animierten Effekt wird jede Stufe einzeln in einer Zufalls-Farbe eingeschaltet.  (Laufrichtung von Stripe-Ende nach Stripe-Start)
      # Sobald alle Stufen aktiv sind, wird bei der ersten Stufe wieder mit einer neuen Zufalls-Farbe angefangen.
      # 
      # - anzahl             -  muss auf die Anzahl der Stufen angepasst werden
      # - ledStufe[anzahl]   -  ist ein Array, welches für jede Stufe die jeweilige Anzahl der LEDs beinhaltet.
      #                         Die Anzahl der in ledStufe enthaltenen Einträge muss der Anzahl der Stufen entsprechen!
      - addressable_lambda:
          name: "Stufenlicht runter animiert"
          update_interval: 16ms
          lambda: |-
            static const uint16_t anzahl = ${stufen_anzahl};
            int ledStufe[anzahl] = ${leds_pro_stufe};
            int von = 0;
            
            static uint16_t progress = 0;
            if (initial_run) {
              progress = anzahl;
            }
            
            for(int stufe=0; stufe < anzahl; stufe++){
              if(stufe == progress){
                it.range(von, von + ledStufe[stufe]) = esphome::Color::random_color();
              } else {
                von += ledStufe[stufe];
              }
            }
            
            if(progress < anzahl){
              delay(300);
            }

            if(progress <= 0){
              progress = anzahl-1;
            } else {
              progress--;
            }


      # Beim colorized Effekt wird jede Stufe einzeln in einer Festgelegten-Farbe eingeschaltet.  (Laufrichtung von Stripe-Ende nach Stripe-Start)
      # Die Farbauswahl kann für jede Stufe individuell erfolgen
      # 
      # - anzahl                  -  muss auf die Anzahl der Stufen angepasst werden
      # - ledStufe[anzahl]        -  ist ein Array, welches für jede Stufe die jeweilige Anzahl der LEDs beinhaltet.
      #                              Die Anzahl der in ledStufe enthaltenen Einträge muss der Anzahl der Stufen entsprechen!
      # - ledStufenFarbe[anzahl]  -  ist ein Array, welches für jede Stufe die jeweilige Farbe beinhaltet.
      #                              Die Anzahl der in ledStufenFarbe enthaltenen Einträge muss der Anzahl der Stufen entsprechen!
      #                              Die Farben sind in der Form "Color(rot, grün, blau)" anzugeben, 
      #                              wobei hier für rot, grün und blau jeweils eine Zahl zwischen 0 und 255 angegeben werden muss.
      - addressable_lambda:
          name: "Stufenlicht runter colorized"
          update_interval: 16ms
          lambda: |-
            static const int16_t anzahl = ${stufen_anzahl};
            int ledStufe[anzahl] = ${leds_pro_stufe};
            Color ledStufenFarbe[anzahl] = ${farbe_je_stufe};

            int von = 0;
            static uint16_t progress = 0;
            if (initial_run) {
              progress = anzahl;
            }
            
            for(int stufe=0; stufe < anzahl; stufe++){
              if(stufe == progress){
                it.range(von, von + ledStufe[stufe]) = ledStufenFarbe[stufe];
              } else {
                von += ledStufe[stufe];
              }
            }
            
            if(progress < anzahl){
              delay(200);
            }
            progress--;


      # Bei diesem Effekt wird jede Stufe einzeln ausgeschaltet. (Laufrichtung von Stripe-Ende nach Stripe-Start)
      # 
      # - anzahl             -  muss auf die Anzahl der Stufen angepasst werden
      # - ledStufe[anzahl]   -  ist ein Array, welches für jede Stufe die jeweilige Anzahl der LEDs beinhaltet.
      #                         Die Anzahl der in ledStufe enthaltenen Einträge muss der Anzahl der Stufen entsprechen!
      - addressable_lambda:
          name: "Stufenlicht runter aus"
          update_interval: 16ms
          lambda: |-
            static const uint16_t anzahl = ${stufen_anzahl};
            int ledStufe[anzahl] = ${leds_pro_stufe};
            int von = 0;
            
            static uint16_t progress = 0;
            if (initial_run) {
              progress = anzahl;
            }
            
            for(int stufe=0; stufe < anzahl; stufe++){
              if(stufe == progress){
                it.range(von, von + ledStufe[stufe]) = esphome::Color(0,0,0);
              } else {
                von += ledStufe[stufe];
              }
            }
            if(progress < anzahl){
              delay(500);
            } 

            progress--;
GitHub anzeigen