Simulation Sonnenuntergang

[violine21]

Hallo zusammen,

evtl. wurde das Thema schon einmal behandelt, habe aber unter den Schlagworten nichts gefunden.

Ich möchte den Sonnenuntergang simulieren, also ein Licht langsam abdimmen.
Ich habe mir dafür folgende Rule geschrieben:

Code: Alles auswählen

var Number Abdimmen = 100

rule "Beleuchtung Simulation Sonnenuntergang"
when
    Time cron "0/5 * * * * ?"// jede 5 Sekunden
then
    if((Abdimmen == 0) || (now.toString("HH") != "20"))
    return;
    Abdimmen = Abdimmen - 1
    SDimmer_D1_RelayBrightness.sendCommand(Abdimmen)
end

Das funktioniert auch, nur habe ich dabei Bauchschmerzen. Die Rule startet alle 5 Sekunden und führt das Dimmen im Zeitbereich 20:xx Uhr aus bis der Wert 0 ist.
Geht das nicht eleganter, so das die Rule nur 1x aufgerufen wird und so lange läuft, bis das Licht aus ist?

Besten Dank!

[Cyrelian]

Hi,

also ich habs genau umgekehrt für morgens zum aufstehen als Wecker .

Code: Alles auswählen

var Timer WakeupTimer = null
var DecimalType hue = new DecimalType(281)
var PercentType sat = new PercentType(87)
var PercentType bright = new PercentType(0)
var Integer dimmer = 0
var HSBType light

/* -------------  Wecker LightStrips Plus --------------------
*/
rule "Wecker LightStrips"
when
	Item SZ_Sonos_AlarmIsrunning changed
then
	if (SZ_Sonos_AlarmIsrunning.state == ON){
		WakeupTimer = createTimer(now.plusSeconds(3), [ |
					if(bright.intValue < 56) {
						dimmer = dimmer + 2	// erhöhen von 0 auf 56 innerhalb von 30 Min.	
						bright = new PercentType(dimmer)
						light = new HSBType(hue,sat,bright)
						SchlafzimmerLSColor.sendCommand(light.toString) 
						WakeupTimer.reschedule(now.plusSeconds(60))
					} else {
						WakeupTimer.cancel
						WakeupTimer = null
						bright = new PercentType(0)
						}
				])       
	} else {
		if (WakeupTimer !== null) {
			WakeupTimer.cancel
			WakeupTimer = null
			}
		bright = new PercentType(0)
		dimmer = 0
		SchlafzimmerLSColor.sendCommand(OFF)
	}
end

somit musst du die Rule nur einmal aufrufen .

CU
Cyrelian

[udo1toni]

Also, das Abdimmen startet ja um 20 Uhr, da es maximal 500 Sekunden dauert, könntest Du locker das Time Cron "etwas" eingrenzen:

Code: Alles auswählen

Time cron"0/5 0-9 20 * * ?"

Dir Rule wird nun von 20 Uhr bis 20:09:55 alle fünf Sekunden ausgeführt.
Eleganter ist es allerings, die Schleife in einem Timer abzuarbeiten und die Rule einmalig zum gewünschten Zeitraum zu starten:

Code: Alles auswählen

var Timer tSunset = null

rule "Beleuchtung Simulation Sonnenuntergang"
when
    Time cron "0 0 20 * * ?"// um 20:00:00 Uhr
then
    tSunset?.cancel
    tSunset = createTimer(now.plusMillis(10),[|
        if((SDimmer_D1_RelayBrightness.state as Number) > 0) {
            SDimmer_D1_RelayBrightness.sendCommand((SDimmer_D1_RelayBrightness.state as Number) - 1)
            tSunset.reschedule(now.plusSeconds(5))
        }
    ])
end

Der Timer wird um 20 Uhr von der Rule angelegt und fast unmittelbar das erste Mal ausgeführt. Falls der Dimmer heller als 0% ist, wird der Dimmwert um eins verringert. Danach wird der Timer nach 5 Sekunden erneut ausgeführt. Eine extra Variable (außer die für den Timer) braucht es in diesem Fall nicht. Falls die Lampe zunächst mit voller Helligkeit erstrahlen soll, müsste man vor dme Timeraufruf ein sendCommand(100) einbauen und auch schon den ersten Timeraufruf mit 5 Sekunden Verzögerung auslösen, aber da es explizit um ein Abdimmen geht, denke ich, ist obige Regel eher das, was Du suchst.

[violine21]

Danke euch beiden!
Ich hatte Zweifel, einen Rule-Thread über eine so lange Zeit "offen" zu lassen.
Wohl besser, als alle x Sekunden eine Instanz zu starten, die fast den ganzen Tag über nur sinnlos Traffic erzeugt?

Seit einiger Zeit haben wir 2 Mitbewohner (kleine Papageien). Damit ich auch am Abend meinen Spass mit ihnen habe,
will ich den Tag etwas verlängern .
Wenn es draussen dunkler wird, dimmt eine Lampe entsprechend der Lichtstärke draussen hoch.
Allerdings muss ich dann auch für einen künstlichen Sonnenuntergang sorgen

VG André

[udo1toni]

Der Timer Ansatz läuft nur wenige Millisekunden. Die Rule erzeugt den Timer und ist schon wieder fertig.
Der Timer liegt in der Liste des Schedulers. Erst wenn der Timer abläuft, belegt der Scheduler einen Thread für die Ausführung des Codes. Der Codeblock selbst läuft ebenfalls wenige Millisekunden und plant dann den nächsten Timer. Dieses Konstrukt läuft super stabil, solange man nicht die Datei neu lädt, in welcher die Rule gespeichert ist (weil beim neu Laden der Datei die Variable neu initialisiert wird und damit die Verbindung zum Timer verloren geht.)

Schlecht wäre, mittels while und Thread::sleep() dauerhaft einen Thread zu belegen.