"Es werde Licht!"

Das lästige An- und Ausschalten von Leuchtkörpern, die im Haushalt normalerweise bei Dunkelheit
immer benötigt werden und manuell geschaltet werden müssen, übernimmt die Automatik in diesem Projekt.

Immer wenn es draußen dunkel wird (auch bei Gewitter oder natürlich nach Sonnenuntergang) schalten sich die
im System eingebundenen Lampen automatisch an. Zu einem programmierbaren Zeitpunkt abends schalten sich die Lampen
dann automatisch zur Nachtruhe aus. Dabei schwankt der Zeitpunkt zur Verunsicherung denkbarer diebischer
Beobachter automatisch immer um eine halbe Stunde im Zeitraum von 23.00h bis 23.30h. Eine Erweiterungsoption
ist vorgesehen, um bei Dunkelheit und eigentlich abgeschalteter Leuchte mittels Bewegungserkennung für einige Minuten
das Licht zu aktivieren.

Man hat also automatisch immer dann Licht, wenn man es braucht. Und es schaltet sich ab, wenn die Bewohner
normalerweise schlafen gehen. Praktischerweise steuert man mit dieser Technik z.B. die Stehlampe in der Diele
und die im Wohnzimmer. Vielleicht auch eine Leuchte vor dem Haus und überall dort, wo man automatisch
Licht haben möchte, wenn es draußen dunkel wird.

Die Funktionsweise:
Ein im Außenbereich des Hauses installierter Sender mit einem Helligkeitssensor steuert beliebig viele
Empfänger an und übermittelt im Minutenabstand den Wert der
in seiner Umgebung gemessenen Helligkeit sowie die quarzgenaue Uhrzeit. Sinnvollerweise wird
dieser Sender für den Betrieb also so positioniert, dass er die Umwelt-Helligkeit erfasst
(z.B. im Blumenfenster oder Wintergarten o.ä.).

Bei jeder zu steuernden Lampe wird ein Empfängermodul vorgeschaltet, das die Signale des Senders empfängt
und die Stromzufuhr für die Leuchte im geeigneten Moment schaltet. Ein Regler an jedem Empfänger dient dazu,
für diese eine Empfangsstelle den gewünschten Helligkeits-Schaltpunkt einzustellen. Programmierbar ist dabei
für jeden Empfänger individuell die gewünschte Uhrzeit für die automatische nächtliche Abschaltung.

Optional installierbare Bewegungssensoren bei jedem Empfänger aktivieren auch bei Inaktivität die jeweilige Leuchte,
wenn sich im Überwachungsbereich ein Objekt bewegt.

Die Funktechnik arbeitet im für derartige Steuerungen freigegeben Frequenzbereich von 433MHz. Um Beeinflussungen durch
fremde Sender zu verhindern, erfolgt die Datenübertragung vom Sender an die Empfänger kodiert.

Die technische Umsetzung erfolgte wieder mit programmierbaren Arduino-Mikrocontrollern.

Das ist der Sender-Sketch:
// ***************************** // // Lichtsteuerung Sender // // ****** lights_send_087 ****** // // manueller Time_Setup noch unzertifiziert 07.03.20 // o) Sendeformat: Zeit 'Zssmm' (Stunde ss=0..23, Minute (mm=0..59), Helligkeit 'Hxxxx' (xxxx=0-1024) und Temperatur 'Txx' in °C // o) Option: Synchronisierung der RTC-Uhr beim Compiliervorgang auf die interne Zeit des PC's // o) LDR an Analogport (LDR_PIN) ermittelt den aktuellen Wert für die Helligkeit // x) 2 Stelltaster ermöglichen, die interne Uhr abzugleichen (up/down) noch unzertifiziert #include <SPI.h> #include <VirtualWire.h> #include <VirtualWire_Config.h> #include <RTClib.h> #include <Wire.h> int LDR_PIN = A3; // Analog-Port zur LDR-Messung int LED = LED_BUILTIN; // Port der Arduino-internen LED int clock_up = 8; // Taster-Pin, um Uhrzeit jeweils um 1 Minute zu erhöhen int clock_down = 9; // ... um 1 Minute reduzieren const int transmit_pin = 12; // Daten-Port zum Sende-Modul // int MESSEN = 13; // für Tests boolean Cl_Up; boolean Cl_Dn; boolean Clock_Set; int Helligkeit; int Minute; int Stunde; int Tag; // Datumsanteile zur Re-Übertragung beim Stellen der internen Uhr int Monat; // .. int Jahr; // .. long Temperatur; String Text_Zeit; String Text_Hell; String Text_Temp; unsigned long Sendepause = 60000; // Pause in msec zwischen zwei kompletten Datenpaketen RTC_DS3231 rtc; // Uhren-Objekt RTC anlegen #define send ; // Schalter für den 'Seriellen Monitor' #define time_setup ; // ************************************************************************************* // void setup () { pinMode(LDR_PIN, INPUT); // Lichtmessung der Helligkeit mit LDR an Analog-Eingang pinMode(clock_up,INPUT_PULLUP); pinMode(clock_down,INPUT_PULLUP); // pinMode(MESSEN,OUTPUT); while (!Serial); // for Leonardo/Micro/Zero/Nano Serial.begin(9600); Serial.println("Setup SENDER V087"); if (! rtc.begin()) { Serial.println("Couldn't find RTC"); while (1); } #ifdef time_setup // if (rtc.lostPower()) { Serial.println("Set the time!"); // following line sets the RTC to the date & time when this sketch was compiled Serial.println(F(__TIME__)); Serial.println(F(__DATE__)); rtc.adjust(DateTime(F(__DATE__), F(__TIME__))); // This line sets the RTC with an explicit date & time, for example to set // October 27, 2019 at 7.45pm you would call: // rtc.adjust(DateTime(2019,10,27,19,45,0)); // } #endif vw_set_tx_pin(transmit_pin); // Initialise the IO and ISR vw_setup(1000); // Bits per sec sendString("SETUP",true); // Dummy-Data delay(100); } // ************************************************************************************* // void sendString(String message, bool wait) { byte messageLength = message.length() + 1; char charBuffer[messageLength]; // convert string to char array message.toCharArray(charBuffer, messageLength); vw_send((uint8_t *)charBuffer, messageLength); if (wait) vw_wait_tx(); } // ************************************************************************************* // void loop () { // digitalWrite(MESSEN,HIGH); // delay(100); // digitalWrite(MESSEN,LOW); // Ausgabestrings vorbereiten Text_Temp = "T"; // 'T'emperatur Text_Hell = "H"; // 'H'elligkeit Text_Zeit = "Z"; // 'Z'eit // Temperatur Temperatur = rtc.getTemperature(); Text_Temp = Text_Temp + Temperatur; // *** Helligkeit *** Helligkeit = analogRead(LDR_PIN); Text_Hell = Text_Hell + Helligkeit; // Uhrzeit ermitteln DateTime now = rtc.now(); // Werte aus RTC auslesen Stunde = now.hour(); Minute = now.minute(); if ((Stunde % 24) < 10){ Text_Zeit = Text_Zeit + '0'; } // *** Vornull Stunde *** Text_Zeit = Text_Zeit + Stunde; // Stundenwert einsetzen if ((Minute % 60) < 10){ Text_Zeit = Text_Zeit + '0'; } // *** Vornull Minute *** Text_Zeit = Text_Zeit + Minute; // Minutenwert einsetzen #ifdef send Serial.print("(118) "); Serial.print(Text_Hell); // Helligkeit Serial.print(","); Serial.print(Text_Zeit); // Uhrzeit Serial.print(","); Serial.println(Text_Temp); // Temperatur #endif // *** Datenpakete senden *** digitalWrite(LED,HIGH); // Sendeanzeige an sendString(Text_Hell,true); // Helligkeit delay(100); sendString(Text_Zeit,true); // Uhrzeit delay(200); sendString(Text_Temp,true); // Temperatur delay(100); digitalWrite(LED,LOW); // Sendeanzeige aus // *** ist ein Taster für 'Uhr stellen' gedrückt? *** (Datum... wird nicht geändert) Cl_Up = digitalRead(clock_up); Cl_Dn = digitalRead(clock_down); while ((Cl_Up == LOW) || (Cl_Dn == LOW)) { Clock_Set = true; // Uhr muss neu nach Beendigung der while-Schleife gesetzt werden if (Cl_Up == LOW) { Minute++; if (Minute > 59) { Stunde++; if (Stunde > 23) { Stunde = 0; } } } if (Cl_Dn == LOW) { Minute--; if (Minute < 0) { Minute = 59; Stunde--; if (Stunde < 0) { Stunde = 23; } } #ifdef send Serial.print("(165) Clock-Set "); Serial.print(Stunde); Serial.print(":"); Serial.print(Minute); Serial.print(" weil "); Serial.print(Cl_Up); Serial.print(" : "); Serial.println(Cl_Dn); #endif } delay(500); } // while // Nach einer manuellen Zeitjustierung jetzt die interne Uhr mit den geänderten Zeit-Werten neu setzen if (Clock_Set == true) { Jahr = now.year(); Monat = now.month(); Tag = now.day(); rtc.adjust(DateTime(Jahr,Monat,Tag,Stunde,Minute,0)); #ifdef send Serial.println("Uhr neu stellen"); Serial.println(Jahr); Serial.println(Monat); Serial.println(Tag); Serial.println(Stunde); Serial.println(Minute); #endif Clock_Set = false; } else { // *** Sendepause *** delay(Sendepause); } }

Hier der Empfänger-Sketch:
// ************************************ // // Empfänger für Lichtsteuerung // // ********** lights_rec_065 ********** // // 12.3.2020 // // Zweck des Systems: // ================== // Tageslichtabhängige Beleuchtungssteuerung innerhalb bestimmter Kernzeiten mit Zusatzfunktionen // // Konfiguration: // ============== // 1 Sender (Arduino), beliebig viele Empfänger (Arduino) mit Netzstrom-Anschluss zum Ansteuerun von 230V-Lichtquellen // // Sender: // ======= // o) Sender misst an geeigneter Stelle das Tageslicht und // o) liest die Uhrzeit einer RTC (Real-Time-Clock) aus // o) zusätzlich misst der Sender auch die Lufttemperatur (wird zwar auch per Funk übermittelt, aber bisher nicht ausgewertet) // Diese Daten werden in Textform mittels eines 433MHz-Sendemoduls an beliebig viele Empfänger verbreitet // Sende-Signale: Zxxxx => aktuelle Uhrzeit (z.B. Z0945 = 9:45h) // Hxxxx => Helligkeit am Ort des Senders (D0..1023) // Txx => (nicht sehr präzise ermittelte) Luft-Temperatur beim Sender (z.B. T17) (die Info über die Temperatur wird derzeit nicht weiter ausgewertet) // // Empfänger: // ========== // Empfänger-Software zur Auswertung der Funkdaten der Lichtsteuerungs-Zentrale, um Lampen zu steuern // Pro Lampe wird ein Empfänger verwendet zur individuell programmierten Verarbeitung der empfangenen Signale // Jeder Empfänger kann mittels eines eigenen IR-Detektors oder per 'Switch_On'-Taster auch außerhalb der vordefinierten 'Licht-An'-Zeit die jeweilige Beleuchtung für mind. 15 min aktivieren // o) Anschluss an 230V-Netz und Steckdose für Versorgung einer 230V-Beleuchtung // O) eigenes Netzteil zur 5V-Versorgung // o) 433MHz-Superhet-Empfänger // o) Schaltschwelle pro Empfänger manuell über Regler einstellbar // o) Licht-AN/AUS Kernzeitpunkte variieren automatisch um 10 bzw. 15 min, um Automatik nicht einfach erkennbar zu machen // o) Fehleranzeige-LED, wenn länger als 10min kein Funksignal eintrifft. Bei Funkloch-Erkennung wird angeschlossene Beleuchtung aktiviert // o) Schaltrelais zur netzgetrennten Ansteuerung der 230V-Beleuchtung // o) (Option) Infrarot-Bewegungsmelder zur Aktivierung der Beleuchtung außerhalb der Kernzeiten bei Bewegungserkennung // o) (Option) Kurzzeit-Aktivierung mittels Taster 'Switch_On' für gleiche Dauer wie IR-Sensor /* Beispiel für Log-Protokoll: 09:24:49.140 -> Start Receiver 09:24:49.140 -> (134) Kernzeit-Beginn: 1209 09:24:49.186 -> (148) Kernzeit-Ende : 2301 09:24:53.157 -> (163) Schaltschwelle : 690 09:26:35.353 -> (306) Signalempfang : LIGHTS (Soll:0 Ist:0 Zeit:0925 Schwelle:690 IR:0 Hell:868 Temp:17) 09:26:35.588 -> (306) Signalempfang : T17 (Soll:0 Ist:0 Zeit:0925 Schwelle:690 IR:0 Hell:868 Temp:17) 09:26:35.822 -> (306) Signalempfang : H865 (Soll:0 Ist:0 Zeit:0925 Schwelle:690 IR:0 Hell:865 Temp:17) 09:26:36.057 -> (306) Signalempfang : Z0926 (Soll:0 Ist:0 Zeit:0926 Schwelle:690 IR:0 Hell:865 Temp:17) ... */ #include <VirtualWire.h> int i; const int receive_pin = 11; // 433MHz-Empfangs-Pin vom SuperHet-Empfänger int Relais = 7; // Steuer-Pin für das 230V-Schaltrelais int IRSensor = 6; // Abfrage-Pin für den IR-Detektor int Switch_On = 8; // Port für 15min ON-Taster int LED = LED_BUILTIN; // interne Arduino-Aktions-LED int Fehler_LED = 9; // Pin für Fehler-LED bei fehlendem Funksignal String Zeit = "1200"; // empfangene Uhrzeit (ssmm) // String Zeit_Von = "07"; // Kernzeit Beginn String Zeit_Von = "12"; // Kernzeit Beginn String Kernzeit_von; String Zeit_Bis = "23"; // Kernzeit Ende String Kernzeit_bis; int REGLER = A4; // Port für manuellen Schaltschwellen-Regler int Schaltschwelle = 800; // Schaltschwelle int Helligkeit = 0; // vom Sender empfangener LDR-Messwert (Dunkel=0...Hell=1024) int Temperatur; // vom Sender übermittelte Temperatur int IR_value; // Abfragewert am IR-Detektor int IR_ON; // Zähler für Abwicklung bei aktivem IR-Melder String info; // zuletzt empfangenes Datenpaket unsigned long last_rec; // Zeitpunkt des letzten Empfangs String Kennung; // die jeweilige Kennung, die vom Sender zur Übermittlung des letzten Datenpaketes verwendet wurde boolean LICHT_SOLL = false; // logischer Zustandswert für SOLL boolean LICHT_IST = false; // logischer Zustandswert für IST boolean KERN; // innerhalb Kernzeit (true/false) int WERT1; int WERT2; #define send ; // Schalter für den seriellen Debugging-Monitor // *** Programm-Vorbereitungen *************************************** // void setup() { #ifdef send Serial.begin(9600); // for debugging Serial.println("( 93) Start Receiver"); #endif randomSeed(analogRead(0)); // Zufall sicherstellen pinMode(IRSensor,INPUT); pinMode(Relais,OUTPUT); pinMode(Fehler_LED,OUTPUT); pinMode(Switch_On,INPUT_PULLUP); digitalWrite(Relais,LOW); // Licht anschalten beim Starten digitalWrite(LED,HIGH); // Onboard-LED mitlaufen lassen vw_set_rx_pin(receive_pin); // initialize the IO and ISR vw_setup(1000); // 1000 Bits per sec (= transmitter-baudrate !!!) vw_rx_start(); // start the receiver PLL running kernzeit_von(); // Kernzeit-Beginn definieren kernzeit_bis(); // Kernzeit-Ende definieren // *** Aktivierungs-Blinker als Bestätigung beim Start des Empfängers *** // for (i = 0; i < 2; i++) { digitalWrite(LED,HIGH); // Onboard-LED mitlaufen lassen digitalWrite(Relais,LOW); // Relais schalten (Negative Logik des Interfaces: LOW=ON; HIGH=OFF) delay(1000); digitalWrite(LED,LOW); digitalWrite(Relais,HIGH); delay(1000); } } // *** Kernzeit (leicht zufällig schwankend) definieren ********************************** // void kernzeit_von() { // Anfangszeiten leicht streuen Kernzeit_von = Zeit_Von; i = random(10); if (i<10) { Kernzeit_von = Zeit_Von + '0';} Kernzeit_von = Kernzeit_von + i; // Kernzeit_von = "1453"; #ifdef send Serial.print("(134) Kernzeit-Beginn: "); Serial.println(Kernzeit_von); #endif } void kernzeit_bis() { Kernzeit_bis = Zeit_Bis; i = random(15); if (i<10) { Kernzeit_bis = Zeit_Bis + '0';} Kernzeit_bis = Kernzeit_bis + i; // Kernzeit_bis = "1454"; #ifdef send Serial.print("(149) Kernzeit-Ende : "); Serial.println(Kernzeit_bis); #endif } // *** Haupt-Schleife ************************************************ // void loop() { // *** Manuell einstellbaren Regler für die Schaltschwelle berücksichtigen *** // WERT1 = Schaltschwelle; WERT2 = analogRead(REGLER); // Reglerstellung auslesen if (abs(WERT1 - WERT2) > 10) // bei relevanter Wertänderung neu setzen (Brumm-Verhinderung) { Schaltschwelle = WERT2; #ifdef send Serial.print("(164) Schaltschwelle : "); Serial.println(Schaltschwelle); #endif } // *** Empfangs-Modul abfragen *** // info = ""; uint8_t buf[VW_MAX_MESSAGE_LEN]; uint8_t buflen = VW_MAX_MESSAGE_LEN; if (vw_get_message(buf, &buflen)) // eine neue Message wurde mit korrekter Prüfsumme empfangen { for (i = 0; i < buflen; i++) { char c = (buf[i]); info = info + c; // aktuelles Datenpaket aufbauen } // *** Datenpaket nach gültigen Kennungen auswerten *** // Kennung = info.substring(0,1); // 1. Stelle enthält den Kennungsbuchstaben (Z/eit, H/elligkeit) if (Kennung == "Z") // Z)eit { Zeit = info.substring(1,5); } else if (Kennung == "H") // H)elligkeit { Kennung = info.substring(1,5); Helligkeit = Kennung.toInt(); } else if (Kennung == "T") // T)emperatur { Kennung = info.substring(1,3); Temperatur = Kennung.toInt(); } last_rec = millis(); // Zeitpunkt des letzten Empfangs speichern für TimeOut-Kontrolle bei Empfangs-Störungen } // *** TimeOut-Kontrolle bei Funkstörung *** // if ((millis() - last_rec) > 600000) // seit über 10 Minuten kein Funksignal!!! { digitalWrite(Fehler_LED,HIGH); // Fehler-LED aktivieren if (LICHT_SOLL == false) { #ifdef send Serial.println("(202) *** seit mehr als 10 Minuten kein Empfang ?!? ***"); #endif } LICHT_SOLL = true; // im Störfall generell das Licht anschalten } else // normaler Betrieb, also weitere Auswertungen { digitalWrite(Fehler_LED,LOW); // Fehler-LED löschen // *** sind wir innerhalb der Kenrzeit? *** // KERN = false; if ((Zeit >= Kernzeit_von) && (Zeit <= Kernzeit_bis)) { KERN = true; } // *** Auswertung *** // // 'Licht an' in der Zeit von..bis und wenn Wert für Helligkeit von Schaltschwelle ausreichend abweicht (simulierte Hystere) if (KERN == true) { if (abs(Helligkeit - Schaltschwelle) > 25) // relevante Abweichung vom Sollwert { if (Helligkeit < Schaltschwelle) // es ist dunkler als Sollwert fordert { if (LICHT_SOLL == false) { LICHT_SOLL = true; #ifdef send Serial.println("(228) Licht AN"); #endif } } else // es ist hell genug, also kein Licht // { if (LICHT_SOLL == true) { LICHT_SOLL = false; #ifdef send Serial.println("(238) Licht AUS"); #endif } } } } else // außerhalb Kernzeit, kein Licht // { /* #ifdef send Serial.println("(247) Keine Kernzeit"); #endif */ LICHT_SOLL = false; } } // *** jetzt das Schaltrelais je nach Auswertungs-Ergebnis steuern *** // if (LICHT_SOLL != LICHT_IST) // Licht-Soll/Ist unterschiedlich? { // *** Licht auf den Sollzustand bringen *** digitalWrite(Relais,!LICHT_SOLL); // Relais schalten (Negative Logik des Interfaces: LOW=ON; HIGH=OFF) digitalWrite(LED,LICHT_SOLL); // Onboard-LED mitlaufen lassen LICHT_IST = LICHT_SOLL; // aktuellen Schaltzustand merken // Kernzeit(en) neu setzen, damit sich Schwankungen ergeben, die mögliche Späher auf 'bewohnt' schließen lassen if (LICHT_IST == true) { kernzeit_bis(); } else { kernzeit_von(); } #ifdef send Serial.print("(268) Relais "); Serial.println(LICHT_IST); #endif } // *** Infrarot-Bewegungsmelder *** // // Signal des IR-Sensors auswerten; bei Dunkelheit triggert er 'Licht an' auch ausserhalb der Kernzeit // oder es kann Switch_On gedrückt worden sein für manuelle Kurzzeit-Beleuchtung IR_value = digitalRead(IRSensor); // Infrarot-Sensor auslesen // (IR-Melder) (Abweichung vom Sollwert) (Licht ist aus) (manuelle Kurzzeit-Aktivierung) if (((IR_value > 0) && (abs(Helligkeit - Schaltschwelle)>15) && !LICHT_IST) || (digitalRead(Switch_On) == LOW)) { do // Nachtriggerbarer Modus (also ohne schädliche Kurz-Stopps der Beleuchtung) { digitalWrite(LED,HIGH); // Onboard-LED mitlaufen lassen digitalWrite(Relais,LOW); // Relais anschalten (Negative Logik des Interfaces: LOW=ON; HIGH=OFF) if (digitalRead(Switch_On) == LOW) { #ifdef send Serial.println("(286) Kurzzeit-Switch On!"); #endif } else { #ifdef send Serial.println("(292) Bewegungsmelder On!"); #endif } IR_ON = 60; // Zähler für IR-Laufzeit starten: 60 mal 15 Sekunden = 15 Minuten Mindestdauer nach Bewegungserkennung do // Licht für mind. 15 Minuten aktivieren { delay(15000); // alle 15 Sekunden evtl. nachtriggern IR_ON-- ; IR_value = digitalRead(IRSensor); // Infrarot-Sensor zwischendurch erneut abfragen für evtl. Fortsetzung if (IR_value > 0) // wenn IR-Melder signalisiert, dann { IR_ON = 60; } // Laufzeit wieder komplett neu starten } while (IR_ON > 0); // solange IR_ON gesetzt ist, bleibt das Licht an } while ((abs(Helligkeit - Schaltschwelle) > 20) && (IR_value > 0)); // Es ist wieder hell geworden oder IR-Detektor nicht mehr aktiv digitalWrite(Relais,HIGH); // Licht abschalten digitalWrite(LED,LOW); last_rec = millis(); // Timeout-Empfangskontrolle zurücksetzen, weil in der Pause ohne Aktualisierung LICHT_SOLL = false; // Sollwert zurücksetzen #ifdef send Serial.println("(314) IR-Sensor oder Switch_On Ende"); #endif } // *** abschließend alle Daten zum Debuggen ausgeben *** // if (info > "") { #ifdef send info.concat(" "); info.remove(8); Serial.print("(324) Signalempfang : "); Serial.print(info); Serial.print(" (Soll:"); Serial.print(LICHT_SOLL); Serial.print(" Ist:"); Serial.print(LICHT_IST); Serial.print(" Zeit:"); Serial.print(Zeit); Serial.print(" Schwelle:"); Serial.print(Schaltschwelle); Serial.print(" IR:"); Serial.print(IR_value); Serial.print(" Hell:"); Serial.print(Helligkeit); Serial.print(" Temp:"); Serial.print(Temperatur); Serial.println(")"); #endif } } //