- ✅ Dieses SPI TFT Display ist ein leuchtstarkes, entspiegeltes Display mit großer 1,8 Zoll Bilddiagonale und integriertem SD-Kartenleser.
- ✅ Das TFT Display verfügt über einen Kartenslot und das Lesen und Schreiben erfolgt über den Controller.
- ✅ Hohe Hardwarekompatibilität mit Raspberry Pi & Co. und andere Microcontrollern dank Standard SPI-Datenschnittstelle und frei verfügbarer Bibliotheken für den ST7735 Bildcontroller. Der Contoller wird mit 5V und die Hintergrundbeleuchtung mit 3.3V betrieben.
- ✅ Der Contoller wird mit 5V und die Hintergrundbeleuchtung mit 3.3V betrieben.
- ✅ Dieses Produkt enthält ein E-Book, das nützliche Informationen über den Beginn Ihres Projekts enthält, es hilft bei einer schnellen Einrichtung und spart Zeit beim Konfigurationsprozess. Wir bieten eine Reihe von Anwendungsbeispielen, vollständige Installationsanleitungen und Bibliotheken.
In dieser Anleitung stelle ich euch mein Treppen-Lauflicht mit Bewegungserkennung vor, welches ich während der Sanierung des Hauses nebenbei entwickelt habe. Es basiert auf einem Arduino mit Bewegungsmeldern und einfarbigen 12V LED-Stripes.
Dazu benötigen wir die folgenden Artikel:
Widerstände, Mosfets und Dioden werden je einer pro Treppenstufe benötigt.
Mit einem Schieberegister können bis zu 8 Stufen angesteuert werden. Bei 9-16 Stufen werden also zwei Register benötigt.
Bewegungsmelder benötigt Ihr immer zwei.
Beim Kabel hängt die benötigte Menge von den Abständen zu euren Treppenstufen ab.
Alle anderen Teile braucht Ihr jeweils nur einmal.
Für das optionale Fading benötigt Ihr noch weitere Kondensatoren und Widerstände. Nähere Infos zu dem Thema Fading findet Ihr HIER.
Alternativ Platine anfertigen lassen
Alternativ zur o.g. Bauteile-Liste könnt Ihr auch eine Platine anfertigen lassen. Dazu hat Jürgen mir netter Weise das von ihm entworfenes Layout einer Platine zur Verfügung gestellt, welches für einen Arduino Nano mit 2 Schieberegistern gedacht ist. Somit ist der Aufbau passend für bis zu 16 Stufen und inklusive Fadings. Und das auf gerade mal 10x10cm.
Bei PCBWay könnt Ihr die Platine kostengünstig fertigen lassen.
https://www.pcbway.com/project/shareproject/LED_stairlight__with_fade...
Alternativ könnt Ihr die Platinen mit Fading inzwischen auch direkt in Deutschland beziehen:
https://www.insaneware.de/c/smarthome/smarthomeyourself-de
Unter folgendem Link erhaltet Ihr noch eine Übersicht, welche Bauteile genau für die Platine gedacht sind und wo diese hingehören:
https://smarthomeyourself.de/Platine/Materials.html
Platine ohne Fading
Für alle, die die Treppenbeleuchtung ohne Fading haben möchten hat Jürgen nun noch eine zweite Variante bereit gestellt. Diese stelle ich euch natürlich ebenfalls zur Verfügung.
Auch diese Platine könnt Ihr natürlich bei PCBWay fertigen lassen:
https://www.pcbway.com/project/shareproject/LED_stairlight__without_fade...
Die Stückliste, welche Bauteile ihr benötigt gibt es natürlich ebenfalls für diese Variante:
https://smarthomeyourself.de/Platine/treppe_ohne_fade/ibom.html
Benötigte Bauteile für die Platine
Da viele bei der Bauteilsuche anhand der BOM-Liste Probleme haben hat Jürgen noch ein kurzes Video zu dem Thema erstellt.
Zusätzlich habe ich hier noch eine Liste der zu bestellenden Bauteile incl. Links erstellt:
https://smarthomeyourself.de/anleitung-zum-selber-bauen/unabhaengige-projekte/arduino-und-esp-projekte/treppen-lauflicht-mit-bewegungserkennung/bauteil-liste-fuer-platine-zur-treppenbeleuchtung-mit-fading/
Platine fertigen lassen
Eine Playlist der Tutorial-Serie zum Herstellen von Platinen, angefangen mit der Installation von KiCad übers Layouten bis hin zum fertigen lassen der PCB mit Hilfe der Gerber-Dateien findet Ihr auf meinem YouTube-Kanal:
Bewegungsmelder- Gehäuse
Die Gehäuse der Bewegungsmelder habe ich nun auch bei Shapeways zur Verfügung gestellt, so dass alle ohne 3D-Drucker diese bestellen können:
(Andere Farben kann ich gerne auf Wunsch hinzufügen)
https://www.shapeways.com/product/WCQRBJBEE/pir-case-for-hc-sr501
Vorbereiten der einzelnen Komponenten:
Kabel auf Länge schneiden
Kabel auf die passende Länge zugeschnitten
Die Reihenfolge der Vorbereitungen ist natürlich variabel. Ich hab zu erst einmal alle Kabel die später vom Arduino zu den LED-Stripes und den Bewegungsmeldern führen auf Länge geschnitten.
Benötigt wird jeweils ein zweiadriges Kabel zu jeder Treppenstufe und zusätzlich jeweils ein dreiadriges Kabel an jedes Treppen-Ende für die Bewegungsmelder. Vor dem zuschneiden sollte man sich also gut überlegen wo man die zentrale Stelle mit dem Arduino platziert. Ich habe mich für die Rückseite der mittleren Stufe entschieden.
Die Enden der Kabel müssen alle abisoliert und die Litzen mit Lötzinn versehen werden. Danach empfiehlt es sich, die Kabel mit Etiketten an beiden Seiten durch zu nummerieren, damit man später den Überblick behält. Sind alle Kabel auf Maß geschnitten und nummeriert, kann man sie mit Kabelbindern zu einem Kabelbaum zusammen schnüren.
LED-Stripe Zuleitungen vorbereiten
Die + Leitungen der Zuleitungen zu den LED-Stripes können auf der Arduino-Seite alle miteinander verbunden werden. Ebenfalls wird daran noch der 12V + Anschluss angelötet. Die Erdung der LED-Zuleitung wird über die Mosfets geschaltet.
An die LED-Seite der Zuleitungen werden die JST-Buchsen angelötet um später die LEDs anstecken zu können..
Widerstände und Dioden vorbereiten
Wer hier gerne ein Fading beim ein- und ausschalten der LEDs haben möchte, sollte sich hier erst einmal die Anleitung zur Erweiterung ansehen. Dazu werden die Diode und der Widerstand durch einen Kondensator und zwei Widerstände ersetzt. Wie das geht könnt Ihr im folgenden Beitrag nachlesen:
Falls Ihr ein Fading wollt macht Ihr einfach zuerst mit dieser Zusatzanleitung weiter. Ansonsten könnt Ihr diesen Schritt überspringen und beim Anschluss des Gate’s vom Mosfet am Arduino weiter machen.
Da die Dioden mit einem Widerstand parallel geschaltet verlötet werden müssen, bietet es sich an, diese direkt an den Beinchen zu verdrehen um sie nur einmal verlöten zu müssen. Damit man beim löten nicht mit der Richtung der Diode durcheinander kommt, kann empfehle ich, immer nur das Beinchen der Ausgangs-Seite zu kürzen, welches später am Mosfet angelötet wird. Den überschüssigen Teil der anderen Seite kann man später immer noch entfernen. Das vermeidet aber eine versehentlich falsch herum angelötete Diode.
Als Widerstand sollten hier mindestens 10k-Ohm Widerstände verwendet werden. Beim einschalten kann der Strom durch die Diode ungehindert ins Gate des Mosfet fließen. Beim ausschalten sperrt die Diode den Rückfluss und der Strom muss durch den Widerstand.
Transistoren (Mosfets)
Der folgende Abschnitt ist gefährliches Halbwissen, aber so in etwa hab ich es verstanden. 😉
Durch den hohen Widerstandswert wird der Abschalt-Vorgang des Transistors etwas verzögert. Diese Verzögerung ist bei 10k-Ohm zwar nicht stark sichtbar, aber bewirkt eine Minimierung des Magnetfeldes, welches vom Mosfet beim abschalten erzeugt wird. Dieses Feld könnte sonst die umliegenden Bauteile negativ beeinflussen und zu unerwarteten Verhalten führen. Ich hatte zudem das Problem, dass einige meiner Stripes im ausgeschalteten Zustand immer noch leicht am glimmen waren. Hier half ein Austausch des Widerstandes gegen einen 15k-Ohm.
Das ermitteln des passenden Widerstandswertes funktioniert nur in der komplett aufgebauten Schaltung, da die Störungen scheinbar dadurch entstehen, dass Rückströme von einem Mosfet die benachbarten mit einer zum schalten ausreichenden Spannung am Gate versorgen. Der Hochohmige Widerstand, der parallel zu den Dioden am Gate-Pin verdrahtet wird, dient also dazu, diese Ströme entsprechend gering zu halten.
Die fertig verdrillten Widerstand-/Dioden-Kombinationen können nun an die Gate-Anschlüsse der Mosfets gelötet werden. Dabei unbedingt darauf achten, dass die Diode richtig rum angelötet wird und den Schaltstrom zum Mosfet durch lässt. (Markierung muss auf der Seite des Mosfet sein)
Verbindungskabel zwischen Mosfet (Gate) und Arduino
Ich habe mich hier für Kabel mit steckverbindern an einem Ende entschieden, da ich mit kleinen Breadboards gearbeitet habe. Wer die Kabel lieber direkt fest verlötet kann das natürlich auch machen. Diese Kabel verbinden später die einzelnen Gates der Mosfets mit den Ausgängen der Schieberegister. Es sind also die “Schaltleitungen”.
Daher empfielt es sich, diese am Ende jeweils mit der entsprechenden Stufennummer wie am Kabelbaum zu markieren.
Auch hier wird wieder je Stufe ein Kabel benötigt. Mir reichte hier eine Länge von 10cm. Die Länge ist abängig davon, wo Ihr die Mosfets positionieren möchtet. Bei mir liegen sie direkt neben dem Arduino.
Die Kabel werden später mit dem einen Ende an die Dioden/Wiederstand-Kombination am Gate der Mosfets angelötet. (bei einseitigem Steckverbinder die Seite ohne Stecker)
Dabei sollte man am besten noch mal kontrollieren, ob die Diode auch richtig rum (Markierung auf der Mosfet-Seite) angelötet wurde.
GND-Leitungen zum Source des Mosfets
Nach dem die Schaltleitungen fürs Gate des Mosfets vorbereitet sind, fehlen nun noch die Anschlussleitungen für die Erdung am Source-Pin. Ich habe sie auf ca 10cm zugeschnitten. Die Länge hängt von der Position der Mosfets ab. Die Erdungszuleitungen verbinden alle Source-Anschlüsse der Mosfets miteinander und mit dem Ground des Arduinos so wie der 12V Erdung. (Kurz gesagt, alle Erdungen sind miteinander verbunden)
Ich habe daher alle Kabel auf einer Seite miteinander verdrillt und zusammen an den GND am 12V-Anschluss gelötet. Ans andere Kabelende lötet man die Source-Pins der einzelnen Mosfets.
Mosfets in den Kabelbaum integrieren
Mosfet Verkabelung
Nun fehlt nur noch der letzte Pin der Mosfets. Dabei handelt es sich um den sogenannten Drain. Das ist der geschaltete Ausgang der Transistoren.
An diese werden nun die GND-Leitungen der zweiadrigen Kabel, die zu den einzelnen LED-Stripes führen, angelötet.
LED Stripes vorbereiten
Vorbereitete LED-Stripes mit JST-Stecker
Für die LED-Stripes habe ich mir zwei 5050-Stripes mit jeweils 5 Meter Länge besorgt. Diese reichten ziemlich genau für die 16 Stufen. Da die Stripes alle 3cm durchtrennbar sind, wurde für jede Stufe ein 60cm Stück zurecht geschnitten. An ein Ende lötete ich jeweils einen JST-Stecker an, um bei späteren Problemen die Stripes bequem einzeln austauschen zu können. Man kann sie aber natürlich auch direkt am Kabelbaum anlöten. Die + Leitung der Stripes ist meist gut gekennzeichnet. Beim anlöten der Kabel bzw des Steckers immer auf die richtige Verpolung (+ = rot) achten.
Bewegungsmelder
Zur Bewegungserkennung des Treppen-Lauflichts werden nun die PIR-Sensoren vorbereitet.
Für die Bewegungsmelder benötigen wir je eine Leitung mit drei Adern. ich habe auf der einen Seite 3 Pins und auf der anderen Seite 3 Buchsen angelötet. Man kann anstelle der Buchsen natürlich auch direkt den PIR-Sensor anlöten.
Helligkeitssensor *optional
Der Helligkeitssensor benötigt ebenfalls ein dreiadriges Kabel. Der Data-Pin für den Sensor ist im Sketch frei wählbar.
Folgende Punkte sind im Sketch einstellbar:
– den Helligkeitssensor generell de-/aktivieren
– Data-Pin frei wählbar
– auswählen ob der Sensor ein analoges (0-1023) oder digitales (0/1) Signal liefert
– angeben ob das Signal invertiert ist (normal: 0=dunkel und >= 1 heller / invertiert: 0=hell und >=1 dunkler)
– Schwellenwert bei dem die Beleuchtung sich automatisch aktivieren soll (Wird bei digitalen Sensoren per Poti am Sensor geregelt)
Schieberegister am Arduino anschließen
Die Schieberegistern sind entsprechend der Abbildung im Schaltplan zu verdrahten. Die drei verwendeten Pins zur Ansteuerung können am Arduino frei gewählt und im Sketch später entsprechend angepasst werden.
Für mehr als 16 Stufen kann der Schaltplan nach unten beliebig um weitere Schieberegister erweitert werden. Bei bis zu 8 Stufen kann man das untere Register weg lassen. In einem dieser Fälle müsste das Sketch ggf noch angepasst werden.
Die weiß dargestellten Leitungen die in das große Steckbrett führen sind die Leitungen zu den Gate-Pins der Mosfets. Das sind die Pins, an denen die Diode mit Widerstand angelötet wurde. Im folgenden Bild sind das die farbigen Kabeln mit Steckverbinder.
Die Erdungen sind im Schaltplan schwarz dargestellt. Die Erdung die im Schaltplan nach links raus geht entspricht der Erdung, die mit der 12V-Erdung zusammengeführt und dann zu den Mosfets an den Source-Pin führt. Kurz gesagt, daran werden alle GND-Leitungen beider Stromkreise angeschlossen. (Der Steckkontakt rechts unten im Foto)
Nachdem der Kabelbaum fertig zusammen gelötet und mit Kabelbindern fixiert wurde, kann man die Mosfets nun mit den Ausgängen der Schieberegister am Arduino verbinden. Das ganze sieht bei mir dann in etwa wie auf dem folgenden Foto aus. (Mittig unter den ganzen Kabeln auf dem roten Steckbrett liegen die Schieberegister)
Im Gesamtbild sollte es nun in etwa so aussehen
Alle LEDs per Schalter dauerhaft einschalten *optional
Optional kann noch ein Schalter an Pin 5 wie folgt angeschlossen werden.
Ist dieser Schalter angeschlossen und die Option im Sketch aktiviert, können über den Schalter nun alle LEDs dauerhaft eingeschaltet werden, bis der Schalter wieder ausgeschaltet wird. Der PullDown Widerstand sollte in etwa 10k Ohm betragen.
(Jede laufende Aktion wird erst beendet, bevor der Schalter berücksichtigt wird.)
Wer mehrere Schalter verwenden möchte, muss beim Aufbau hier eine Wechselschaltung aufbauen. Ein in Reihe oder parallel schalten funktioniert hier nicht!
Netzteil für LEDs per Relais ein/ausschalten *optional
Wer sein Netzteil für die LEDs im Idle-Mode (wenn keine LEDs leuchten) abschalten möchte, kann hierzu ein Relais anschließen um die Phase des Netzteils bei Bedarf vom Strom zu trennen. Dazu müsst Ihr einfach die Phase der 230V Stromzufuhr trennen und die durch das Durchtrennen der Ader entstehenden Enden am Relais anschließen. Dann das relais mit 5V und GND verbinden und den Data-Pin an den im Sketch einstellbaren Pin anschließen. Wie das aussehen könnte, zeige ich hier auch noch einmal in einer kleinen Grafik:
Damit das Relais auch vom Sketch angesprochen wird, müsst Ihr nur noch den Parameter useRelaisForPowerSupply auf true setzen.
Vollständige Schaltpläne
Zwei User waren so nett, haben einen vollständigen Anschlussplan erstellt und mir diese zur Verfügung gestellt. Diese möchte ich euch nicht vorenthalten, da ich denke, dass diese noch einmal einen etwas besseren Gesamtüberblick verschaffen.
Vielen Dank noch mal an Thorsten und Norman
Nachdem der Aufbau der Hardware nun abgeschlossen ist, fehlt nur noch die Software um das ganze System in Betrieb nehmen zu können.
Sketch einrichten
Das notwendige Arduino-Sketch vom Treppen-Lauflicht mit Bewegungserkennung könnt ihr unter dem folgenden Link downloaden.
Treppenlauflicht mit LAN (zwei Register / 9-16 Stufen)
Oder als Alternative ohne benötigte Librarys:
Treppenlauflicht ohne LAN (zwei Register / 9-16 Stufen)
Die beiden Varianten unterscheiden sich nur durch die Verwendung des Ethernet-Shields. Wer also kein Netzwerk an der Treppe haben möchte um die Bewegungsdaten an die Haussteuerung zu übermitteln, sollte direkt das alternative Sketch verwenden, da die Ethernet-Librarys mit aktuelleren Arduino Versionen scheinbar eh etwas Probleme haben.
Die Variante ohne LAN gibt es auch noch mal für nur ein Schieberegister (also bis maximal 8 Stufen)
Treppenlauflicht ohne LAN (ein Register / bis 8 Stufen)
Jetzt gibt es die Variante ohne LAN auch für drei Schieberegister (17-24 Stufen)
Treppenlauflicht ohne LAN (drei Register / 17-24 Stufen)
Öffnet die Datei mit dem Arduino-Editor. Wie Ihr die Arduino-Software einrichtet, falls noch nicht geschehen, erfahrt Ihr hier:
https://smarthomeyourself.de/wiki/arduino/arduino-ide-installieren/
Am Anfang des Sketchs findet Ihr die folgenden Einstellungen. Passt diese frei nach euren Bedürfnissen an und ladet anschließend das Sketch auf euren Arduino.
(Hier der zu konfigurierbare AUSSCHNITT des Sketches)
//--------------------------------------
// Configuration Start
//--------------------------------------
// PIR-Data-Pins
#define PIR_TOP_PIN 3
#define PIR_BOTTOM_PIN 4
// All LEDs on Switch
#define ALL_ON_SWITCH_PIN 5
// Helligkeitssensor-Pin
int lightPin = 7;
// Schieberegister-Pins
int latchPin = 8;
int dataPin = 11;
int clockPin = 12;
// Allgemeine Einstellungen
//---------------------------------
// Gibt an, ob eine Animation erfolgen soll,
// solange die Treppe aktiv ist. (Während alle Stufen an sind)
boolean activeAnimation = true;
// Gibt ab, ob ein Lichtsensor angeschlossen ist und verwendet werden soll
boolean lightSensorActive = false;
// Gibt an, ob ein Dauer-An Schalter angeschlossen wurde
// Sollte hier ohne Schalter am Pin hier trotzdem true eingestellt sein,
// blinken die LEDs zufällig, da der INPUT-Pin ohne Pull-Down einen Zufallswert liefert!
boolean allOnSwitchActive = false;
// Gibt an, ob die Werte an den Server gesendet werden sollen
boolean sensorValueSendToServerActive = false;
// Bewegungsmelder Einstellungen
//---------------------------------
// Gibt an, ob der Lichtsensor bei Bewegung HIGH oder LOW zurück gibt
// Wenn HIGH eine erkannte Bewegung bedeutet, muss der Wert auf true stehen, sonst auf false.
boolean pirSensorSignalInverted = false;
//PIR Timings
// Dauer der Initialisierung
int calibrationTime = 10;
// Wie viele ms nach der letzten erkannten Bewegung
// soll der Bewegungsmelder wieder auf LOW schalten
long unsigned int pirPause = 2000;
// PIR-Sensor-IDs (nur notwendig wenn sensorValueSendToServerActive=true)
long pirTopSensorId = 22637;
long pirBottomSensorId = 22638;
// Hellligkeitssensor Settings *optional
// (nur notwendig wenn lightSensorActive=true)
//-----------------------------------------
// Gibt an, ob der Lichtsensor bei voller Helligkeit den maximal oder minimalwert angibt
// Wenn der maximalwert (HIGH bei digital, 1023 bei analog) volle Helligkeit bedeutet,
// muss der Wert auf false stehen. Gibt der Sensor bei voller Helligkeit 0 zurueck muuss hier true gesetzt werden.
boolean lightSensorSignalInverted = true;
// Gibt an ob der Sensor digital oder analog betrieben wird
boolean lightSensorDigital = true;
// Der maximale Helligkeitswert unter dem die Beleuchtung automatisch aktiviert wird.
// bei analog: 0-1023 / bei digitalen immer 1
int lightValueMax = 300;
// Gibt an, wie viele ms Pause zwischen den Helligkeitsmessungen liegen soll
int lightRefreshTime = 5000;
// Geschwindigkeits-Einstellungen
//---------------------------------
// gibt an, wie lang die Verzögerung zwischen den einzelnen Stufen beim einschalten in ms ist
int switchOnDelayTimeInit = 100;
// gibt an, wie lang die Verzögerung zwischen den einzelnen Stufen beim ausschalten in ms ist
int switchOffDelayTimeInit = 500;
// gibt an, wie lang die Verzögerung zwischen den einzelnen Stufen während der Animation in ms ist
int animationDelayTime = 70;
//Maximale Wartezeit bis zur automatischen
//Abschaltung der LEDs falls der andere
//Bewegungsmelder nicht aktiviert wird.
int maxTimeLightsOn = 30000;
// Dauer in ms, die nach der Bewegungserkennung
// bis zur Abschaltung gewartet werden soll
int waitBeforeSwitchOff = 3000;
// Wartezeit in ms, die nach dem Abschalten der Beleuchtung
// gewartet werden soll, bevor die Sensoren wieder aktiviert werden.
int sleepAfterLightsOff = 5000;
// Netzwerk-Einstellungen
// Diese sind nur notwendig wenn sensorValueSendToServerActive aktiviert ist.
//--------------------------------------
// IP-Adresse des SmartHome yourself Servers
byte _piAddress[] = {192, 168, 1, 98};
byte _mac[] = {0xDF, 0x8D, 0xCB, 0x37, 0xC4, 0xED };
byte _ip[] = { 192, 168, 1, 28 };
byte _dns[] = { 192, 168, 1, 1 };
byte _gate[] = { 192, 168, 1, 1 };
byte _mask[] = { 255, 255, 255, 0 };
//--------------------------------------
// Configuration End
//--------------------------------------
Ich denke der gesamte Sketch so wie auch die Einstellungen darin sind ausreichend Dokumentiert, so dass ich hier zusätzlich zu dem Auszug des Konfigurationsbereichs nicht mehr viel zu schreibe.
Sonstige Bemerkungen
Was evtl. noch erwähnenswert ist:
Wenn Ihr nicht das alternative Sketch ohne LAN verwendet, ist es so vorbereitet, dass die Sensoren ihre Werte an Euren SmartHome yourself-Server senden können. Dafür wird auch die SHYS_Sensor Library benötigt. Aus diesem Grund sind in den Einstellungen auch Sensor-IDs einstellbar.
Wer die Treppe als “Stand alone System” verwenden möchte, kann diese Einstellungen einfach ignorieren oder das Alternative Sketch verwenden. Standardmäßig ist diese Funktion deaktiviert. Wer sie allerdings nutzen möchte muss den Parameter sensorValueSendToServerActive = true setzen und die passenden Sensor-IDs eintragen.
Wie neue Sensoren in der Haussteuerung zu integrieren sind wird z.B. in dem folgenden Beitrag (incl. Video) anhand eines Klima-Sensors erklärt:
https://smarthomeyourself.de/anleitung-zum-selber-bauen/geraete-vorbereiten/sensoren/arduino-klimasensor-modul/
Nach hochladen des Sketchs auf den Arduino sollte bei korrekter Verkabelung und richtiger PIN-Auswahl in den Einstellungen die Treppenbeleuchtung nun funktionieren.
Solltet Ihr noch auf Probleme stoßen oder Fragen haben, stellt diese gerne per Email an: support@smarthomeyourself.de.
Ich werde mich bemühen euch schnellstmöglich weiter zu helfen.
Dann bleibt mir jetzt nur noch, Euch viel Spaß und Erfolg beim nachbauen zu wünschen.
Hier gibts noch das Video zur Treppenbeleuchtung: