Dazu benötigen wir:

Fürs optionale Fading benötigt Ihr noch weitere Kondensatoren und Widerstände. Nähere Infos zu dem Thema findet Ihr HIER.

 

Hier gibts die Material-Liste noch mal als Liste mit den entsprechenden Amazon-Links: (Ohne Werkzeug, Schrumpfschlauch, Lötzinn und Kabelbinder)

https://docs.google.com/document/d/1TK7kOz5kIfbrogl7YZcqrSrxO2yBnaHVyg9oSHAnjK8/edit?usp=sharing

 

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)

 

Vorbereiten der einzelnen Komponenten:

 

Kabel auf Länge schneiden

IMG_20160306_142349
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 kein Fading wollt macht Ihr einfach hier 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.

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)

IMG_20160306_153759
So sollte der Mosfet mit Widerstand und Diode in etwa aussehen

 

 

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

IMG_20160306_160911
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

IMG_20160215_231142
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

Bewegungssensoren

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


Schieberegister Anschlussplan

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)

IMG_20160427_172913
Alle Anschlüsse kurz erklärt

 

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)

IMG_20160427_210247
Alles am Arduino Angeschlossen

 

Im Gesamtbild sollte es nun in etwa so aussehen

IMG_20160427_214951
Alle 16 Stripes vollständig verdrahtet am Arduino

 

 

Alle LEDs per Schalter dauerhaft einschalten  *optional

Optional kann noch ein Schalter an Pin 5 wie folgt angeschlossen werden.

all_leds_on_switch

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

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

                   treppe_schaltplan

 

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 Sketch für den Arduino könnt ihr unter dem folgenden Link downloaden.
Treppenlauflicht mit LAN (zwei Register) (371 Downloads)

Oder als Alternative ohne benötigte Librarys:
Treppenlauflicht ohne LAN (zwei Register) (547 Downloads)

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 mit nur einem Register (282 Downloads)

 

Öffnet die Datei mit dem Arduino-Editor. Wie Ihr die Arduino-Software einrichtet, falls noch nicht geschehen, erfahrt Ihr hier:
https://smarthomeyourself.de/anleitung-zum-selber-bauen/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.

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:

Vorstellung: LED-Lauflicht als Treppenbeleuchtung mit Bewegungserkennung am Arduino

Durch starten des Videos stellen Sie eine Verbindung zu YouTube her. Die Datenschutzerklärung von YouTube finden Sie hier: https://www.youtube.com/static?gl=DE&template=terms&hl=de. Weitere Informationen zum Thema Datenschutz bei Google/YouTube finden Sie hier: https://policies.google.com/privacy?hl=de&gl=de

Bei Links auf Amazon-Artikel handelt es sich um Affiliate-Links. In diesen Links wird meine Amazon-Partner-Id mit übergeben, wodurch ich eine kleine Provision für eure Käufe erhalte. Ihr zahlt natürlich das gleiche wie sonst auch.
Ich würde mich freuen, wenn Ihr bei eurer Bestellung die Links verwendet und mich so einfach und für euch kostenlos unterstützt, um weiterhin neue Projekte mit euch teilen zu können.

Vielen Dank für euer Verständnis und eure Unterstützung!


Daniel Scheidler

Da mein Vater bereits in der IT tätig war, wurde auch mein Interesse für diesen Bereich sehr früh geweckt. Mit 13 bekam ich meinen ersten Laptop mit dem ich den Einstieg in die Programmierung begann. (Das Codes abtippen am C64 lasse ich mal aussen vor) Und so nahm alles seinen lauf.

Im Jahr 2004 schloss ich meine Ausbildung als Fachinformatiker Fachrichtung Anwendungsentwicklung ab und bin seit dem als Java Fullstack Entwickler tätig. Damals noch im ERP Umfeld, heute im Medizinischen Bereich.

Auch meine Freizeit „opfere“ ich gerne der Technik. Hier widme ich mich sämtlichen Themen rund um Arduino, Raspberry, 3D Druck/Design, RC-Modellbau (Multicopter, Heli, Flugzeug, Autos) und anderen Handwerklichen Projekten.

Mit der Kernsanierung des Altbaus entstand die Idee, das Haus auf ein SmartHome umzurüsten. Nach dem Kostenvoranschlag des Elektrikers wurde schnell klar, dass ich hier selber ran muss, wenns bezahlbar bleiben soll.

In der Hoffnung weitere kreative Leute zu finden, die sich an dem Vorhaben beteiligen oder es einfach nur nachbauen möchten dokumentierte ich alles und stellte alle Quelltexte incl. Anleitungen online.

Und so entstand SmartHomeYourself.de.

Diese Webseite verwendet Cookies, um die Nutzung der Seite zu verbessern, den Erfolg von Werbemaßnahmen zu messen und interessengerechte Werbung anzuzeigen.
Durch die weitere Nutzung der Seite stimmst du der Verwendung von Cookies zu. Weitere Informationen

Die Cookie-Einstellungen auf dieser Website sind auf "Cookies zulassen" eingestellt, um das beste Surferlebnis zu ermöglichen.

Wenn Sie diese Website ohne Änderung der Cookie-Einstellungen verwenden oder auf "Akzeptieren" klicken, erklären Sie sich damit einverstanden.

Weitere Informationen zu den verwendeten Cookies und unseren Datenschutzbestimmungen finden Sie in unseren Datenschutzbestimmungen.

Schließen