Dazu benötigen wir:

  • ein Arduino-Board
  • ein Ethernet-Shield *optional wenn die Sensoren auch ihre Daten an die Zentrale senden sollen.
  • einen Mosfet je Stufe
  • einen Wiederstand je Stufe (mindestens 10k Ohm)
  • eine Diode je Stufe 
  • einen LED-Stripe je Stufe
  • einen JST-Stecker & Buchse je Stufe
  • 8-Bit Schieberegister (Je nach Stufenanzahl 1 Register für max 8 Stufen)
  • eine 12V Hohlstecker-Buchse 
  • einen Lichtsensor * optional 
  • zwei Bewegungsmelder
    (Hier gibts das Gehäuse: https://www.shapeways.com/product/WCQRBJBEE)
  • 12V Netzteil für die LED-Stripes
  • USB-Netzteil oder eine alternative Stromquelle für den Arduino
  • Kabel, Schrumpfschlauch, Kabelbinder
  • Lötkolben / Lötzinn oder alternativ ein kleines Steckbrett

 

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

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.

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) (215 Downloads)

Oder als Alternative ohne benötigte Librarys:
Treppenlauflicht ohne LAN (zwei Register) (316 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 (160 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 über das Kontaktformular oder erstellt ein Ticket in meinem ServiceDesk unter http://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: