Treppenhausautomat mit Bewegungsmelder und AUS-Ankündigung
(mit PIR-Bewegungsmelder und Arduino)
Die Funktionalität einer Flur- bzw. Treppenhausbeleuchtung mit einem konventionellen Treppenhausautomat ist allgemein
bekannt. Mit einem Taster wird die Beleuchtung eingeschaltet und gleichzeitig ein Timer gestartet. Nach Ablauf der eingestellten Zeit, sofern
der Taster (oder ein anderer) nicht erneut betätigt wird, geht das Licht wieder aus. Die folgende Schaltung erfüllt vollständig die Hauptaufgabe
eines Treppenhausautomaten jedoch mit zwei Erweiterungen. Statt eines Tasters, der dazu dient, die Beleuchtung einzuschalten, kommt ein
Bewegungsmelder zum Einsatz. Es können, genauso wie es in der Praxis vorkommt, mehrere Bewegungsmelder eingesetzt werden. Auch eine Kombination
aus Tastern und Bewegungsmeldern ist in diesem Fall möglich. Die weitere Erweiterung bezieht sich auf das Ausschalten des Lichtes. Anstatt
eines einfachen „AUS“ wird die kurz bevorstehende Ausschaltung angekündigt. In diesem Fall ändern die eingesetzten RGB-Leuchtdioden ihre Farbe
(und Blinken anschließend abwechselnd) bevor das Licht endgültig ausgeht. Dadurch wird man vor der darauf folgenden Dunkelheit gewarnt. Bei
einer praktischen Anwendung muss natürlich darauf geachtet werden, welche Leuchtmittel zum Einsatz kommen, damit solche Funktionalität
realisierbar ist.
Bewegungsmelder
Die Bewegung wird von einem Mini-PIR-Bewegungsmelder (VMA314 von Velleman) erfasst und an Arduino weiter gemeldet. Die
Abmessungen des kleinen Moduls betragen ca. 2,5 x 3,3 cm. Die Verarbeitung der Signale des PIR-Sensors innerhalb des Moduls übernimmt der Controller BISS0001.
Das Modul verfügt über zwei Potenziometer, mit welchen die Empfindlichkeit und Nachlaufzeit eingestellt werden können. Auf der kleinen
Platine des Bewegungsmelders sitz darüber hinaus ein 3,3 V fester Spannungsregler, der die Betriebsspannung des Moduls bestimmt. Damit
bekommen wir am Ausgang im Bewegungsfall ein Signal von 3,3V.
Das Signal von 3,3 V, das von dem Bewegungsmelder geliefert wird, wird von Arduino durchaus erkannt. Doch Arduino arbeitet
grundsätzlich mit 5 VDC und erwartet an Eingängen dementsprechend auch 5V-Signale. Damit das gewährleistet ist, muss das 3,3V Signal auf
5V hochtransferiert werden. Diese Aufgabe übernimmt ein Level Converter (Logikpegelkonverter). Dabei handelt es sich um ein Modul, das in
der Welt des Arduino und Raspberry Pi bekannt und überall erhältlich ist. Mit dem Modul können Signale in beiden Richtungen, z.B. von 3,3 auf
5V oder 5V auf 3,3V, gewandelt werden. In diesem Fall kann das Modul vier Signale gleichzeitig verarbeiten.
Pegelkonverter
Beleuchtung
Die Beleuchtung (Flur, Treppenhaus, Treppenstufen etc.) wird von acht RGB-Leuchtdiode symbolisiert. Jede RGB-Diode besteht aus drei
einzelnen Leuchtdioden, die in einem Gehäuse untergebracht sind. Jede RGB-Leuchtdiode verfügt über vier Anschlüsse (hier gemeinsame Kathode). Drei
Anschlüsse werden für die einzelnen Leuchtdioden benötigt, vierter Anschluss ist GND. Damit muss die Steuerung insgesamt 24 Leuchtdioden
ansteuern, um den gewünschten Effekt zu erhalten. Jede einzelne Leuchtdiode wird mit einem Vorwiderstand abgesichert. Bei einer Spannung
von 5VDC und Widerstandswert von 1kOhm ergibt sich für jede Leuchtdiode ein Strom im
Wert von I = U / R = 5V / 1000 Ohm = 5 mA.
RGB-Dioden
Spannungsversorgung
Die Schaltung arbeitet mit zwei Spannungen. Externe Spannung, die von einem Netzteil stammt, beträgt 9 VDC. Mit dieser
Spannung werden direkt Arduino und der Bewegungsmelder eingespeist. Die minimale Spannung für Arduino, Anschluss Vin, beträgt ca. 7 VDC.
Eine andere Alternative, Arduino mit Spannung zu versorgen, ist der USB-Anschluss. Die minimale Spannung für den Bewegungssensor beträgt
dagegen 5VDC. Alternativ könnte man den Bewegungssensor an den 5 V Pin des Arduino anschließen. Alle anderen Komponenten arbeiten mit 5 VDC.
Diese Spannung wird hinter dem Schaltregler LM2596S abgegriffen, der hier als Modul mit der externen Beschaltung zum Einsatz
kommt.
Spannungsregler mit LM2596S
Schieberegister
Um die 24 Leuchtionen anzusteuern, verwenden wir drei 8-Bit Schieberegister. Damit werden Ausgänge des Arduino gespart und können
für andere Zwecke eingesetzt werden. Für Ansteuerung der drei Schieberegister werden drei Ausgänge des Arduino in Anspruch genommen. Die drei
Bausteine werden in Kaskadenschaltung hintereinander verschaltet. Jedes Schieberegister ist für eine Farbe der RGB-Dioden zuständig. Das erste
Schieberegister steht für Blau, das zweite für Gelb und schließlich das dritte für Rot. Jeder IC stellt acht Ausgänge zur Verfügung. Damit
ist es möglich, alle 24 Leuchtdioden einzeln anzusteuern.
Die Koordination aller Komponenten der Schaltung übernimmt Arduino Nano. Damit das möglich wird, wird der kleine
Mikrocontroller mit einem Programm (Sketch) geladen. Für die gestellte Aufgabe werden fünf seiner Pins, die nach Bedarf als Ein- bzw.
Ausgänge definiert werden, in Anspruch genommen. Damit stehen die meisten seiner Anschlüsse für andere Aufgaben frei zur Verfügung.
Arduino Nano
Schaltplan
Testschaltung
Testschaltung
Das Programm (Sketch)
Die Aufgabe der Schaltung ist äußerst simpel. Sobald der Bewegungsmelder eine Bewegung registriert, wird die Beleuchtung
eingeschaltet. Nach Ablauf der Nachlaufzeit geht das Licht wieder aus. Die Innovation gegenüber einer konventionellen Schaltung
besteht darin, dass das Ausschalten des Lichtes angekündigt wird. Hierzu wird die Farbe des Lichtes verändert und wir lasen ganz zum Schluss
die „Lampen“ kurz abwechselnd blinken. So kann sich jeder auf das „AUS“ vorbereiten oder durch weitere Bewegung die Nachlaufzeit verlängern.
Damit an die Schaltung auch weitere Bewegungsmelder oder auch Taster angeschlossen werden können, übernimmt Arduino die Steuerung der
Nachlaufzeit. Die Nachlaufzeit beginnt, sobald das Signal vom Bewegungsmelder abfällt.
Das Signal von dem Bewegungsmelder wird am Pin D5 des Arduino registriert. Damit man sehen kann, wie lange das Signal ansteht, wird das
Signal unverändert an die Leuchtdiode LD1 weitergereicht. Die Leuchtdiode leuchtet also, solange das Signal vom Bewegungsmelder auf High steht.
Mit dem Signal wird das Licht mit voller Helligkeit eingeschaltet (Alle farbigen Leuchtdioden der RGB-Leuchtdioden gehen an). Nach Änderung
des Signals auf Low, wird die Nachlaufzeit gestartet. Wird während der Zeit erneut Bewegung registriert, wird die Nachlaufzeit verlängert.
Ist sie schließlich abgelaufen verändern die RGB-Dioden ihre Farbe, um zu signalisieren, dass das Licht bald ausgeht. Kurz von der Abschaltung
blinken sie noch abwechselnd.
Die Leuchtdioden bekommen ihre Signale direkt von den Schieberegistern, die wiederum vom Arduino gesteuert werden. Um alle Leuchtdioden
anzusteuern, muss Arduino 24 Bits in die Register übertragen. Da die Schieberegister in Reihe geschaltet sind, bezieht sich das erste
übertragene Bit auf die letzte Leuchtdiode, das letzte Bit ist dann entsprechend für die erste Leuchtdiode zuständig. Die Bits werden auf
die Leitung DS (Arduino Pin D4) gelegt. Dabei steht SHCP (Pin D2) auf Low. Die Übernahme des Wertes erfolgt, wenn SHCP seinen Zustand von
Low auf High ändert. Um erneut einen Wert zu übertragen, muss SHCP wieder auf Low gehen. Mit einem High Signal auf dem Anschluss STCP
(Arduino Pin D3) werden die Ausgänge entsprechend der davor übernommenen Werten gesetzt.
// --------------------------------------------------------
// Treppenhausautomat mit "AUS"-Ankündigung
// Mit PIR-Bewegungsmelder und Schieberegistern
// Arduino Nano, IDE 1.8.12
// --------------------------------------------------------
int SH_CP_Pin = 2;
int ST_CP_Pin = 3;
int DS_Pin = 4;
int Bewegungsmelder = 5;
int Led = 6;
bool Led_On_Off [24];
int Show_Zaehler = 0;
unsigned long MillisAktuell = 0;
unsigned long MillisSoll_An = 10000;
void setup() {
pinMode(ST_CP_Pin, OUTPUT);
pinMode(SH_CP_Pin, OUTPUT);
pinMode(DS_Pin, OUTPUT);
pinMode(Bewegungsmelder, INPUT_PULLUP);
pinMode(Led, OUTPUT);
}
void Ausgabe () {
digitalWrite(ST_CP_Pin, LOW);
for (int i=0; i<24; i++) {
digitalWrite(SH_CP_Pin, LOW);
digitalWrite(DS_Pin, Led_On_Off [i]);
digitalWrite(SH_CP_Pin, HIGH); }
digitalWrite(ST_CP_Pin, HIGH);
}
void Nullen () {
for (int i=0; i<24; i++) { Led_On_Off [i] = 0; };
}
void loop () {
// Bewegung wurde erkannt ...................................
// Kontrollleuchte an
// Licht an .................................................
if (digitalRead(Bewegungsmelder) == HIGH) {
digitalWrite (Led, HIGH);
for (int i=0; i<24; i++) { Led_On_Off [i] = 1; };
Ausgabe ();
Show_Zaehler = 0; }
// Bewegung zu Ende = Nachlaufzeit Start ....................
if ((digitalRead(Bewegungsmelder) == LOW) && (Show_Zaehler == 0)) {
digitalWrite (Led, LOW);
MillisAktuell = millis();
Show_Zaehler = 1; }
// Zeit abgelaufen - Vorwarnung Start .......................
if ((Show_Zaehler == 1) && ((millis() - MillisAktuell) > MillisSoll_An)) {
Show_Zaehler = 2; }
// alles Aus ................................................
if (Show_Zaehler == 6) {
Nullen ();
Ausgabe ();
Show_Zaehler = 0; }
// alles Blinken ............................................
if (Show_Zaehler == 5) {
for (int i=1; i<20; i++) {
for (int j=0; j<24; j++) { Led_On_Off [j] = random (2); };
Ausgabe ();
delay (100); }
Show_Zaehler = 6; }
// alles Rot ................................................
if (Show_Zaehler == 4) {
Nullen ();
for (int i=16; i<24; i++) { Led_On_Off [i] = 1; };
Ausgabe ();
delay (1000);
Show_Zaehler = 5; }
// alles Gelb ...............................................
if (Show_Zaehler == 3) {
Nullen ();
for (int i=8; i<16; i++) { Led_On_Off [i] = 1; };
Ausgabe ();
delay (1000);
Show_Zaehler = 4; }
// alles Blau ...............................................
if (Show_Zaehler == 2) {
Nullen ();
for (int i=0; i<8; i++) { Led_On_Off [i] = 1; };
Ausgabe ();
delay (1000);
Show_Zaehler = 3; }
}
// ----------------------------------------------------------
