RGB Treppenbeleuchtung mit ESPHome

Kategorie:: hardware
Unterkategorie:: pcb
Pfad:: templates/hardware/rgb-treppenbeleuchtung
Tags:
#pcb#esphome
Zur Übersicht
PCB-Fertigungsdateien (im Download enthalten)

KiCad-DesignKiCAD Tutorial →
Gerber2 BOM, 11 Dateien
BOM öffnen
Download886.9kB
Beschreibung & Dokumentation

Kurzbeschreibung

Eine ausführliche Anleitung des Pro...
Vollständige Dokumentation

RGB Treppenbeleuchtung mit ESPHome

(Auch ohne Home Assistant nutzbar!)

Livestream über den Umbau zur Standalone Variante mit Offline-Automatisierungen

[ RGB-Treppenbeleuchtung Standalone ](https://www.youtube.com/watch?v=RzkHVJpzZmQ "RGB Tre...
Projekt-Assets (3)

Grafiken (3)

RGB_Treppe.png
136.8 KB
rgb-treppe-pcb.webp
310.7 KB
rgb-treppe-schematic.png
146.8 KB
Code-Vorschau

Haupt-Konfiguration
Tipp: Markieren & ⌘/Ctrl + C zum Kopieren
configuration.yaml
esphome:
  name: shys-rgb-treppe
  on_boot:
    priority: 500
    then:
      - switch.turn_on: treppe_aktiv

esp8266:
  board: nodemcuv2

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:          20s
  
  # Gibt an, wie lange die Abschaltung verzögert werden soll, 
  # nach dem eine Bewegung am Ziel der Treppe erkannt wurde.
  switchoff_delay_seconds:   5s
  
  # 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:             "Color Wipe Down"

  # Effekt-Name für das einschalten der Treppe von oben nach unten.
  led_effect_down:           "Color Wipe Up"
  
  # 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:         ""

  # 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:       ""
  led_effect_off_timeout:    10s
  
  # Gibt an, wie viele beleuchtete Stufen die Treppe besitzt 
  stufen_anzahl:             "12"
  
  # Gibt an, wie viele LEDs je Stufe existieren 
  # (Anzahl der Zahlenwerte muss mit "stufen_anzahl" übereinstimmen)
  leds_pro_stufe:            "{10, 10, 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(255,0,0), Color(0,255,0), Color(255,0,0), Color(0,255,0), Color(255,0,0), Color(0,0,255), Color(255,0,0), Color(0,0,255), Color(255,0,0), Color(255,255,0), Color(255,0,0), Color(255,255,0)}"


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

  # 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: "50.35347°"
  longitude: "7.64325°"


  # 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}
  reboot_timeout: 0s
  power_save_mode: none
  
  ap:
    ssid: "RGB-Treppe"
    password: "fnlIp2hjHmrL"
    ap_timeout: 30s

web_server:
captive_portal:

api:
ota:
  - platform: esphome

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'


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:
            - 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:
            - 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;
    



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: "RGB-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: "RGB-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

  - platform: gpio
    pin: ${statusled_pir_down_pin}
    name: "RGB-Treppe PIR unten Status LED"
    id: rgbtreppe_pir_status_u

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

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


light:
  - platform: neopixelbus
    variant: WS2812
    pin: ${led_pin}
    num_leds: ${led_anzahl}
    default_transition_length: 3s
    type: GRB
    name: "RGB-LED Treppe oben"
    id: rgbtreppe_led
    restore_mode: ALWAYS_OFF

    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]) = ESPColor::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]) = ESPColor::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(300);
            } 
            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]) = ESPColor(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]) = ESPColor::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]) = ESPColor::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(300);
            }
            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]) = ESPColor(0,0,0);
              } else {
                von += ledStufe[stufe];
              }
            }
            if(progress < anzahl){
              delay(500);
            } 

            progress--;