Rollladenautomatik (Sonnenstand und Temperatur)

[int5749]

Hallo zusammen,

der Sommer naht und auch wenn unsere Sonnenautomatik im großen und ganzen funktioniert, lese ich gerade mit Begeisterung die einzelnen Threads dazu und evtl. schaffen wir ja durch eine geschickte Verquickung der Lösungen eine Forums-Variante zu erstellen.

Ich verzichte mal auf die Items der Rollladen, da diese über UP/DOWN oder auch direkt über einen Position angefahren werden können.

Die später verwendete "SonneS_aus.state == 0" setze beim auffahren der Rollladen, sofern eine gewisse Temperatur erwartet wird

Code: Alles auswählen

rule "Sonnenschutzautomatik"
when
  Item SunProtection changed
then
	val mailActions = getActions("mail","mail:smtp:xyc")
	if (SunProtection.state == ON) {
		ManSunProtection.postUpdate(OFF)
		mySunProtectionVis.postUpdate(ON)
		mailActions.sendMail("abc@api.prowlapp.com", ""+ tempmax + " Grad erwartet.", "Sonnenschutzautomatik EIN: " + OffsetDateTime.now().toString)
		SonneS_aus.postUpdate(0)
	} else if (SunProtection.state == OFF) {
		mySunProtectionVis.postUpdate(OFF)
		mailActions.sendMail("abc@api.prowlapp.com", "Info", "Sonnenschutzautomatik AUS: " + OffsetDateTime.now().toString)
		SonneS_aus.postUpdate(1)
	}
end

Rule "SunProtection"

Code: Alles auswählen

/* benötgte Variablen */
var int hoehe1			= 0		//wird für die Höhe der Rollos benötigt
var int hoehe2			= 0		//wird für die Höhe der Rollos benötigt
var int hoehe3			= 0		//wird für die Höhe der Rollos benötigt		
var int hoehe4			= 0		//wird für die Höhe der Rollos benötigt	
var int hoehe5			= 0		//wird für die Höhe der Rollos benötigt

var int tempmax = 0

rule "SunProtection"
when
	Item azimuth received update
then
/*	Fuellen der Variablen */
	val mailActions = getActions("mail","mail:smtp:xyz")
	var int azimuth		= (azimuth.state as DecimalType).intValue
	var int elevation	= (elevation.state as DecimalType).intValue
	var int	min		= now.toLocalTime.getHour   		// es werden die Minuten das Tages gezählt z.b 9:00 Uhr > 540 Min

	tempmax = (Weather_Temp_Max_0.state as DecimalType).intValue
	switch (tempmax) {
		case (tempmax >= 20 && tempmax <=26): {hoehe1 = 85 hoehe2 = 75 hoehe3 = 55 hoehe4 =  45 hoehe5 =  0}  // Höhe des Rollos je nach Temperatur
		case (tempmax >= 27 && tempmax <=31): {hoehe1 = 90 hoehe2 = 80 hoehe3 = 55 hoehe4 = 50 hoehe5 = 0}
		case (tempmax >= 32 && tempmax <=45): {hoehe1 = 100 hoehe2 = 90 hoehe3 = 80 hoehe4 = 70 hoehe5 = 0} 
		default: 							  {hoehe1 =  0 hoehe2 =  0 hoehe3 =  0 hoehe4 =  0 hoehe5 =  0}					
	}	

	logInfo("Sun_Protection","azimuth: {}",azimuth)
	logInfo("Sun_Protection","elevation: {}",elevation)
	logInfo("Sun_Protection","Minuten heute: {}",min)
	logInfo("Sun_Protection","tempmax: {}",tempmax)
	logInfo("Sun_Protection","Sonne Ost: {}",sonneost.state)
	logInfo("Sun_Protection","Sonne Sued: {}",sonnesued.state)
	logInfo("Sun_Protection","Sonne West: {}",sonnewest.state)
	logInfo("Sun_Protection","SonneS aus: {}",SonneS_aus.state)
	logInfo("Sun_Protection","Hoehe 1: {}",hoehe1)
	logInfo("Sun_Protection","Hoehe 2: {}",hoehe2)
	logInfo("Sun_Protection","Hoehe 3: {}",hoehe3)
	logInfo("Sun_Protection","Hoehe 4: {}",hoehe4)	
	logInfo("Sun_Protection","Hoehe 5: {}",hoehe5)
	logInfo("Weather","Condition: {}",Condition.state)

/* ################################################################# */
/*		Sonnenschutz OST	 */
		if	(SonneS_aus.state == 0 && sonneost.state == 0 && tempmax >= 20 && azimuth >= 50 && azimuth <= 135 && elevation >=5) {
			mailActions.sendMail("abc@api.prowlapp.com", "Information", "Sonnenschutz Ost - Stufe 1")

	/*		Rollladen Nord	 */
			Kueche_rechts_Rollo.sendCommand(hoehe3)
			Flur_Rollo.sendCommand(hoehe3)

	/*		Rollladen Ost	 */
			Bad_Rollo.sendCommand(hoehe2)
			Kind1_Strasse_Rollo.sendCommand(hoehe2)
			GaesteWC_Rollo.sendCommand(hoehe2)

	/*		Rollladen Sued	 */
			Kind1_Widerkehr_Rollo.sendCommand(hoehe5)
			Schlaf_Widerkehr_Rollo.sendCommand(hoehe5)
			Terrasse_links_Fenster_Rollo.sendCommand(hoehe5)
			Terrasse_links_Tuere_Rollo.sendCommand(hoehe5)
			Terrasse_rechts_Tuere_Rollo.sendCommand(hoehe5)
			Terrasse_rechts_Fenster_Rollo.sendCommand(hoehe5)

	/*		Rollladen West	 */
			Schlaf_Garten_Rollo.sendCommand(hoehe5)
			Lea_Rollo.sendCommand(hoehe5)
			Esszimmer_links_Rollo.sendCommand(hoehe5)
			Esszimmer_rechts_Rollo.sendCommand(hoehe5)
			Kueche_links_Rollo.sendCommand(hoehe5)

			sonneost.postUpdate(1)
			println("Sonne Ost- ")
	logInfo("Sun_Protection","Sonnenschutz Ost - Stufe 1")

		} else if (SonneS_aus.state == 0 && sonneost.state == 1 && azimuth >= 128 && elevation >= 10) { // Sonne scheint jetzt von Süd-Ost.
			mailActions.sendMail("abc@api.prowlapp.com", "Information", "Sonnenschutz Ost - Stufe 2")

	/*		Rollladen Nord	 */
			Kueche_rechts_Rollo.sendCommand(hoehe5)
			Flur_Rollo.sendCommand(hoehe5)

	/*		Rollladen Ost	 */
			Bad_Rollo.sendCommand(hoehe2)
			Kind1_Strasse_Rollo.sendCommand(hoehe2)
			GaesteWC_Rollo.sendCommand(hoehe2)

			sonneost.postUpdate(2)
			println("Sonne -Ost-, Rollo auf wenn Sonne im Süden  ")
logInfo("Sun_Protection","Sonnenschutz Ost - Stufe 2")

		} else if (SonneS_aus.state == 0 && sonneost.state == 2 && azimuth >= 220 && elevation <= 60) {										// Rollos auf, ohne wenn und aber
			mailActions.sendMail("abc@api.prowlapp.com", "Information", "Sonnenschutz Ost - Stufe 3")

	/*		Rollladen Ost	 */
			Bad_Rollo.sendCommand(hoehe5)
			Kind1_Strasse_Rollo.sendCommand(hoehe5)
			GaesteWC_Rollo.sendCommand(hoehe5)

			sonneost.postUpdate(0)
			println("Sonne ist fast untergegangen alles auf -Ost-")
logInfo("Sun_Protection","Sonnenschutz Ost - Stufe 3")
		
		}
		
/* ################################################################# */
/*		Sonnenschutz SÜD	 */
		if (SonneS_aus.state == 0 && sonnesued.state == 0 && tempmax >= 20 && azimuth >= 120 && azimuth <= 250 && elevation >= 40) {	//
			mailActions.sendMail("abc@api.prowlapp.com", "Information", "Sonnenschutz Süd - Stufe 1")

	/*		Rollladen Sued	 */
			Kind1_Widerkehr_Rollo.sendCommand(hoehe2)
			Schlaf_Widerkehr_Rollo.sendCommand(hoehe2)
			Terrasse_links_Fenster_Rollo.sendCommand(hoehe2)
			Terrasse_links_Tuere_Rollo.sendCommand(hoehe2)
			Terrasse_rechts_Tuere_Rollo.sendCommand(hoehe2)
			Terrasse_rechts_Fenster_Rollo.sendCommand(hoehe2)

       		sonnesued.postUpdate(1)
			println("**Sonnenschutz Zu-Fahren Süden- ")			
logInfo("Sun_Protection","Sonnenschutz Süden - Stufe 1")

		} else if (SonneS_aus.state == 0 && sonnesued.state == 1 && azimuth >= 137) {
			mailActions.sendMail("abc@api.prowlapp.com", "Information", "Sonnenschutz Süd - Stufe 2")

	/*		Rollladen Sued	 */
			Kind1_Widerkehr_Rollo.sendCommand(hoehe2)
			Schlaf_Widerkehr_Rollo.sendCommand(hoehe2)
			Terrasse_links_Fenster_Rollo.sendCommand(hoehe2)
			Terrasse_links_Tuere_Rollo.sendCommand(hoehe2)
			Terrasse_rechts_Tuere_Rollo.sendCommand(hoehe2)
			Terrasse_rechts_Fenster_Rollo.sendCommand(hoehe2)

       		sonnesued.postUpdate(2)
       		println("**Sonnenschutz Fahren. Sonne ist fast weg Süd- ")
logInfo("Sun_Protection","Sonnenschutz Süden - Stufe 2")


		} else if (SonneS_aus.state == 0 && sonnesued.state == 2 && azimuth >= 270) {
			mailActions.sendMail("abc@api.prowlapp.com", "Information", "Sonnenschutz Süd - Stufe 3")

	/*		Rollladen Sued	 */
			Terrasse_links_Fenster_Rollo.sendCommand(hoehe4)
			Terrasse_links_Tuere_Rollo.sendCommand(hoehe4)
			Terrasse_rechts_Tuere_Rollo.sendCommand(hoehe4)
			Terrasse_rechts_Fenster_Rollo.sendCommand(hoehe4)

       		sonnesued.postUpdate(3)
       		println("**Sonnenschutz Auf-Fahren. Sonne ist fast weg Süd- ")
logInfo("Sun_Protection","Sonnenschutz Süden - Stufe 3")


  		} else if (SonneS_aus.state == 0 && sonnesued.state == 3 && azimuth >= 280 && elevation <= 13) {
			mailActions.sendMail("abc@api.prowlapp.com", "Information", "Sonnenschutz Süd - Stufe 4")

	/*		Rollladen Sued	 */
			Terrasse_links_Fenster_Rollo.sendCommand(hoehe5)
			Terrasse_links_Tuere_Rollo.sendCommand(hoehe5)
			Terrasse_rechts_Tuere_Rollo.sendCommand(hoehe5)
			Terrasse_rechts_Fenster_Rollo.sendCommand(hoehe5)

       		sonnesued.postUpdate(4)
       		println("**Sonnenschutz Auf-Fahren. Sonne ist weg Süd- ")
logInfo("Sun_Protection","Sonnenschutz Süden - Stufe 4")

  		} else if (SonneS_aus.state == 0 && sonnesued.state == 4 && elevation <= 10) {
			mailActions.sendMail("abc@api.prowlapp.com", "Information", "Sonnenschutz Süd - Stufe 5")

	/*		Rollladen Sued	 */
			Kind1_Widerkehr_Rollo.sendCommand(hoehe5)
			Schlaf_Widerkehr_Rollo.sendCommand(hoehe5)
			Terrasse_links_Fenster_Rollo.sendCommand(hoehe5)
			Terrasse_links_Tuere_Rollo.sendCommand(hoehe5)
			Terrasse_rechts_Tuere_Rollo.sendCommand(hoehe5)
			Terrasse_rechts_Fenster_Rollo.sendCommand(hoehe5)

       		sonnesued.postUpdate(0)
       		println("**Sonnenschutz Auf-Fahren. Sonne ist weg Süd- ")
logInfo("Sun_Protection","Sonnenschutz Süden - Stufe 5")

  		}
		
/* ################################################################# */
/*		Sonnenschutz WEST	 */
		if (SonneS_aus.state == 0 && sonnewest.state == 0 && tempmax >= 20 && azimuth >= 210 && elevation >=30) {
			mailActions.sendMail("abc@api.prowlapp.com", "Information", "Sonnenschutz West - Stufe 1")

	/*		Rollladen West	 */
			Schlaf_Garten_Rollo.sendCommand(hoehe2)
			Lea_Rollo.sendCommand(hoehe2)
			Esszimmer_links_Rollo.sendCommand(hoehe2)
			Esszimmer_rechts_Rollo.sendCommand(hoehe2)
			Kueche_links_Rollo.sendCommand(hoehe2)

			sonnewest.postUpdate(1)
			println("**Sonnenschutz weil warm -West- ")
logInfo("Sun_Protection","Sonnenschutz Westen - Stufe 1")

		} else if (SonneS_aus.state == 0 && sonnewest.state == 1 && azimuth >= 282 && elevation <= 20) { //azi 270
			mailActions.sendMail("abc@api.prowlapp.com", "Information", "Sonnenschutz West - Stufe 2")

	/*		Rollladen West	 */
			Schlaf_Garten_Rollo.sendCommand(hoehe3)
			Lea_Rollo.sendCommand(hoehe3)
			Esszimmer_links_Rollo.sendCommand(hoehe5)
			Esszimmer_rechts_Rollo.sendCommand(hoehe5)
			Kueche_links_Rollo.sendCommand(hoehe5)

			sonnewest.postUpdate(2)
			println("**Sonne -West- ")		
logInfo("Sun_Protection","Sonnenschutz Westen - Stufe 2")

		} else if (SonneS_aus.state == 0 && sonnewest.state == 2 && azimuth >= 285 && elevation <= 15) { //azi 270
			mailActions.sendMail("abc@api.prowlapp.com", "Information", "Sonnenschutz West - Stufe 3")

	/*		Rollladen West	 */
			Schlaf_Garten_Rollo.sendCommand(hoehe5)
			Lea_Rollo.sendCommand(hoehe5)

			sonnewest.postUpdate(0)
			println("**Sonne -West- ")		
logInfo("Sun_Protection","Sonnenschutz Westen - Stufe 3")

		}
end

Jetzt freue ich mich auf Euer Feedback und Verbesserungsvorschläge. z.B. Vergleich von Temperatur und Grad der Bewölkung? Alternativ habe ich im Norden und bald auch im Süden einen Helligkeitssensor von Theben, was ich noch etwas sinnvoller als den Grad der Bewölkung eines Wetterdienstes finde. Evtl. baut man die Rule auf Helligkeit und setzt dort im Variablenteil einen Wert basierend auf Bewölkung, sofern man keinen Helligkeitssensor hat?

Viele Grüße
int5749

[udo1toni]

Hmm...

Es gibt schon die eine oder andere Sache, die ich anders lösen würde...

Der erste Punkt ist eine Bedingung, die in allen if-Anweisungen enthalten ist.

Code: Alles auswählen

if (SonneS_aus.state == 0 && 

ist der Beginn jeder einzelnen if-Anweisung. Letztlich ist das einfach der Hauptschalter, allerdings ein indirekter, denn der wird ja über die andere Rule geschaltet. Warum, erschließt sich mir nicht. Einfacher wäre es, zu Beginn der Rule eine Abbruchbedingung einzubauen:

Code: Alles auswählen

if(SunProtection.state != ON)
    return;

Es braucht dazu kein eigenes Item, die Prüfung auf eine Zahl ist hier sowieso eher zu meiden. Ist der Hauptschalter aus, so wird die Rule zwar gestartet, aber umgehend wieder beendet, das spart jede Menge Rechenzyklen.

Dann die globalen Variablen, das ist hier nicht sinnvoll, denn die Variablen werden innerhalb der Rule, in der sie gebraucht werden aktualisiert.
Aber auch die switch-case Anweisung ist hier sehr unpraktisch, weil dennoch die komplette Bedingung angegeben werden muss.

Code: Alles auswählen

switch (tempmax) {
		case (tempmax >= 20 && tempmax <=26): {hoehe1 = 85 hoehe2 = 75 hoehe3 = 55 hoehe4 =  45 hoehe5 =  0}  // Höhe des Rollos je nach Temperatur
		case (tempmax >= 27 && tempmax <=31): {hoehe1 = 90 hoehe2 = 80 hoehe3 = 55 hoehe4 = 50 hoehe5 = 0}
		case (tempmax >= 32 && tempmax <=45): {hoehe1 = 100 hoehe2 = 90 hoehe3 = 80 hoehe4 = 70 hoehe5 = 0} 
		default                             : {hoehe1 =  0 hoehe2 =  0 hoehe3 =  0 hoehe4 =  0 hoehe5 =  0}					
	}	

Mit einer sinnvoll aufgebauten if-else-Kette spart man hier enorm:

Code: Alles auswählen

    var Integer hoehe1 = 0
    var Integer hoehe2 = 0 
    var Integer hoehe3 = 0
    var Integer hoehe4 = 0
    var Integer hoehe5 = 0

    if(tempmax >= 45) {}
    else if(tempmax >= 32) {hoehe1 = 100 hoehe2 = 90 hoehe3 = 80 hoehe4 = 70 hoehe5 = 0} 
    else if(tempmax >= 27) {hoehe1 =  90 hoehe2 = 80 hoehe3 = 55 hoehe4 = 50 hoehe5 = 0}
    else if(tempmax >= 20) {hoehe1 =  85 hoehe2 = 75 hoehe3 = 55 hoehe4 = 45 hoehe5 = 0}
    else if(sonneost.state < 1 && sonnesued.state < 1 && sonnewest.state < 1) return;

Der Default Wert wird bei der lokalen Definition automatisch gesetzt, für die erste Bedingung (Temperatur über 45 Grad) muss also gar nichts passieren, deshalb ein leerer Codeblock {}
Durch die festgelegte Reihenfolge muss ich nur jeweils eine Grenze abfragen, die obere Grenze wurde ja schon unterschritten, sonst hätte die if-Anweisung den Codeblock schon übersprungen. Diese Technik kann man auch mit switch-case anwenden, auch hier wird von oben nach unten abgearbeitet, aber das große Potential kann switch-case nicht entfalten, da es keine größer als Bedingungen ohne weitere Angaben erlaubt.
Der letzte else-Block ist besonders interessant. Falls tempmax unter 20 ist, wird der jeweils erste Block für die Rollosteuerung nicht ausgeführt. Also kann auch die ganze Rule abgebrochen werden, so nicht einer der Abläufe bereits gestartet wurde. Auch hier werden wieder massig Zyklen gespart. Zusätzlich kann die Abfrage von tempmax in den Start-Bedingungen entfallen.

Übrig bleiben als Bedingungen Grenzbetrachtungen von azimut und elevation, abhängig von den jeweiligen Schritten der Beschattung auf den drei Hausseiten sowie die Steuerung der Rollos. Da bietet es sich an, die Rollos in Gruppen zusammenzufassen:

Code: Alles auswählen

gNord:
            Kueche_rechts_Rollo
            Flur_Rollo
gOst:
            Bad_Rollo
            Kind1_Strasse_Rollo
            GaesteWC_Rollo
gSued1:
            Terrasse_links_Fenster_Rollo
            Terrasse_links_Tuere_Rollo
            Terrasse_rechts_Tuere_Rollo
            Terrasse_rechts_Fenster_Rollo
gSued2:
            Kind1_Widerkehr_Rollo
            Schlaf_Widerkehr_Rollo

gWest1:
            Schlaf_Garten_Rollo
            Lea_Rollo
gWest2:
            Esszimmer_links_Rollo
            Esszimmer_rechts_Rollo
            Kueche_links_Rollo

Wann immer Du ein Item aus der entsprechenden Gruppe steuerst, tust Du das auch für alle anderen Items dieser Gruppe, es ist sogar so, dass sie alle den selben Befehl erhalten. Nun kannst Du die Group verwenden, um die Befehle zu senden. Das sieht dann so aus:

Code: Alles auswählen

gNord.members.forEach[i|i.sendCommand(hoehe3)]

Hier natürlich exemplarisch nur für die eine Gruppe.

Ohne die ganze Quaselei ist der Block nun relativ übersichtlich:

Code: Alles auswählen

    if(sonneost.state == 0 && azimuth >= 50 && azimuth <= 135 && elevation >=5) {
         gNord.members.forEach[i|i.sendCommand(hoehe3)]
          gOst.members.forEach[i|i.sendCommand(hoehe2)]
        gSued1.members.forEach[i|i.sendCommand(hoehe5)]
        gSued2.members.forEach[i|i.sendCommand(hoehe5)]
        gWest1.members.forEach[i|i.sendCommand(hoehe5)]
        gWest2.members.forEach[i|i.sendCommand(hoehe5)]
        sonneost.postUpdate(1)
    } else if(sonneost.state == 1 && azimuth >= 128 && elevation >= 10) {
        gNord.members.forEach[i|i.sendCommand(hoehe5)]
         gOst.members.forEach[i|i.sendCommand(hoehe2)]
        sonneost.postUpdate(2)
    } else if(sonneost.state == 2 && azimuth >= 220 && elevation <= 60) {
        gOst.members.forEach[i|i.sendCommand(hoehe5)]
        sonneost.postUpdate(0)
    }
    if(sonnesued.state == 0 && azimuth >= 120 && azimuth <= 250 && elevation >= 40) {
        gSued1.members.forEach[i|i.sendCommand(hoehe2)]
        gSued2.members.forEach[i|i.sendCommand(hoehe2)]
        sonnesued.postUpdate(1)
    } else if(sonnesued.state == 1 && azimuth >= 137) {
        gSued1.members.forEach[i|i.sendCommand(hoehe2)]
        gSued2.members.forEach[i|i.sendCommand(hoehe2)]
        sonnesued.postUpdate(2)
    } else if(sonnesued.state == 2 && azimuth >= 270) {
        gSued1.members.forEach[i|i.sendCommand(hoehe4)]
        sonnesued.postUpdate(3)
    } else if(sonnesued.state == 3 && azimuth >= 280 && elevation <= 13) {
        gSued1.members.forEach[i|i.sendCommand(hoehe5)]
        sonnesued.postUpdate(4)
    } else if(sonnesued.state == 4 && elevation <= 10) {
        gSued1.members.forEach[i|i.sendCommand(hoehe5)]
        gSued2.members.forEach[i|i.sendCommand(hoehe5)]
        sonnesued.postUpdate(0)
    }
    if(sonnewest.state == 0 && azimuth >= 210 && elevation >=30) {
        gWest1.members.forEach[i|i.sendCommand(hoehe2)]
        gWest2.members.forEach[i|i.sendCommand(hoehe2)]
        sonnewest.postUpdate(1)
    } else if(sonnewest.state == 1 && azimuth >= 282 && elevation <= 20) {
        gWest1.members.forEach[i|i.sendCommand(hoehe3)]
        gWest2.members.forEach[i|i.sendCommand(hoehe5)]
        sonnewest.postUpdate(2)
    } else if(sonnewest.state == 2 && azimuth >= 285 && elevation <= 15) {
        gWest1.members.forEach[i|i.sendCommand(hoehe5)]
        sonnewest.postUpdate(0)
    }

Aber so wirklich schön ist das immer noch nicht.

[int5749]

In Kürze vom Lager für die Nacht und dem iPad, genau schaue ich mir dies morgen Früh an

Hmm...

Es gibt schon die eine oder andere Sache, die ich anders lösen würde...

Alles andere hätte mich auch verwundert

Letztlich ist das einfach der Hauptschalter, allerdings ein indirekter, denn der wird ja über die andere Rule geschaltet. Warum, erschließt sich mir nicht. Einfacher wäre es, zu Beginn der Rule eine Abbruchbedingung einzubauen:

Dies habe ich so gelöst, da ich die Sonnenschutzautomatik aus verschiedenen Aktionen heraus schalten möchte/wollte
Z.B. wenn das Haus verlassen wird, Sonne scheint und Automatik aus
Oder manuell aktivieren, falls zwischendurch deaktiviert
Ich habe noch einen Button, der nur auf der Südseite die Rollloaden auf eine Position fährt, der ist nur sichtbar wenn Automatik aus ist
Letztlich wird morgens geschaut (wenn die Rollladen eigentlich hoch fahren) ob es warm wird und die Automatik statt dessen aktiviert wird.

Aber so wirklich schön ist das immer noch nicht.

Mal sehen, was ich davon morgen schon umsetzen kann (neben dem Stress in der Firma = Frühstücks und Mittagspause) und wie das Ganze dann in Summe aussieht.

Dir bis hierhin schon mal einen Dank!

[udo1toni]

Dies habe ich so gelöst, da ich die Sonnenschutzautomatik aus verschiedenen Aktionen heraus schalten möchte/wollte
Z.B. wenn das Haus verlassen wird, Sonne scheint und Automatik aus
Oder manuell aktivieren, falls zwischendurch deaktiviert

Gut, das ändert aber nichts an der Abbruchbedingung zu Beginn der Rule dann ist diese halt das schon vorhandene Item != 0.

Mir schwebt für die Funktion etwas anderes vor (aber da denke ich noch nach, wie ich das am besten umsetzen könnte), und zwar in der Form, dass zunächst alle Sollhöhen bestimmt werden (und das sollte schon in möglichst wenigen Gruppen geschehen) und anschließend alle Läden verfahren werden, deren Position in einer bestimmten Form abweicht.
Leider kann man aus der DSL heraus nicht auf die Metadaten der Items zugreifen, das wäre sehr hilfreich. Man könnte in den Metadaten die Sollhöhen speichern und auch eine Information vorsehen, wenn der betreffende Laden von der Automatik ausgeklammert werden soll. Dann steuert ein Override diese Information um und die Rule kümmert sich nur noch darum, alle Items, deren Automatik aktiv ist jeweils auf die Position zu fahren, die zu dem Zeitpunkt korrekt ist.
Man kann das natürlich über eine Hashmap nachbilden (alternativ über ungebundene Items), ist aber alles aufwändig.

[int5749]

So,

ich habe mir heute Morgen einfach mal ein paar Minuten Zeit gegönnt um das Feedback am PC mit VSC zu prüfen.

Dann die globalen Variablen, das ist hier nicht sinnvoll, denn die Variablen werden innerhalb der Rule, in der sie gebraucht werden aktualisiert.
Aber auch die switch-case Anweisung ist hier sehr unpraktisch, weil dennoch die komplette Bedingung angegeben werden muss.

Ja, das unterscheidet den Laien (mich) vom Fachmann Habe ich übernommen und umgebaut.

Frage: Du schreibst bei den Variablen die Typisierung aus. Welchen Vorteil hat "var Integer .." gegenüber "var int ..."?

Aber ....

Code: Alles auswählen

    var Integer hoehe1 = 0
    var Integer hoehe2 = 0 
    var Integer hoehe3 = 0
    var Integer hoehe4 = 0
    var Integer hoehe5 = 0

    if(tempmax >= 45) {}
    else if(tempmax >= 32) {hoehe1 = 100 hoehe2 = 90 hoehe3 = 80 hoehe4 = 70 hoehe5 = 0} 
    else if(tempmax >= 27) {hoehe1 =  90 hoehe2 = 80 hoehe3 = 55 hoehe4 = 50 hoehe5 = 0}
    else if(tempmax >= 20) {hoehe1 =  85 hoehe2 = 75 hoehe3 = 55 hoehe4 = 45 hoehe5 = 0}
    else if(sonneost.state < 1 && sonnesued.state < 1 && sonnewest.state < 1) return;

Sommit würde die Rule doch eigenlich nie durchlaufen, oder? Denn sonnexx.state ist ja am Morgen immer 0 und wird beim durchlaufen der Rule geändert.

Übrig bleiben als Bedingungen Grenzbetrachtungen von azimut und elevation, abhängig von den jeweiligen Schritten der Beschattung auf den drei Hausseiten sowie die Steuerung der Rollos. Da bietet es sich an, die Rollos in Gruppen zusammenzufassen:

Dies hatte ich tatsächlich schon vorbereitet (aus dem erlernten von früheren Tipps) aber noch nicht eingebaut :-/ Dies ist nun erfolgt

Der letzte else-Block ist besonders interessant. Falls tempmax unter 20 ist, wird der jeweils erste Block für die Rollosteuerung nicht ausgeführt. Also kann auch die ganze Rule abgebrochen werden, so nicht einer der Abläufe bereits gestartet wurde. Auch hier werden wieder massig Zyklen gespart. Zusätzlich kann die Abfrage von tempmax in den Start-Bedingungen entfallen.

Dies ist korrekt, jedoch müsste ich mir dann noch eine andere Lösung überlegen (eigenen Rule evtl.) um die Werte für "sonneost", "sonnesued" und "sonnewest" zu setzen. Denn jede Rolllade sollte eigentlich nur 1x gefahren werden, damit wir z.B. einzelne Rollladen in einem Zyklus verfahren können und nicht bei jeder Änderung von Azimut wieder auf den automatischen Wert gestellt werden.

Zudem habe ich es bisher noch nicht geschafft, später einzusteigen. Also wenn z.B. der Vormittag schattig war und die Automatik aus und wir dann Mittags die Automatik einschalten, braucht der Norden ja nicht mehr zu fahren, der Osten wahrscheinlich auch nicht. Und wenn, dann eben nur 1x.

Gut, das ändert aber nichts an der Abbruchbedingung zu Beginn der Rule dann ist diese halt das schon vorhandene Item != 0.

Das stimmt und ist offensichtich noch ein Restant => in der Bereinigung.

Leider kann man aus der DSL heraus nicht auf die Metadaten der Items zugreifen, das wäre sehr hilfreich. Man könnte in den Metadaten die Sollhöhen speichern und auch eine Information vorsehen, wenn der betreffende Laden von der Automatik ausgeklammert werden soll. Dann steuert ein Override diese Information um und die Rule kümmert sich nur noch darum, alle Items, deren Automatik aktiv ist jeweils auf die Position zu fahren, die zu dem Zeitpunkt korrekt ist.
Man kann das natürlich über eine Hashmap nachbilden (alternativ über ungebundene Items), ist aber alles aufwändig.

Klingt spannend

Neue/Alte Gruppen

Code: Alles auswählen

Group:Rollershutter:AVG gShutterNorth "Rollladen Norden [%d %%]"	<rollershutter>
Group:Rollershutter:AVG gShutterEast "Rollladen Osten [%d %%]"		<rollershutter>
Group:Rollershutter:AVG gShutterSouth "Rollladen Sueden [%d %%]"	<rollershutter>
	Group:Rollershutter:AVG gShutterSouthFirst "Rollladen Sueden OG [%d %%]"	<rollershutter>	(gShutterSouth)
	Group:Rollershutter:AVG gShutterSouthGround "Rollladen Sueden EG [%d %%]"	<rollershutter>	(gShutterSouth)
Group:Rollershutter:AVG gShutterWest "Rollladen Westen [%d %%]"		<rollershutter>
	Group:Rollershutter:AVG gShutterWestFirst "Rollladen Westen [%d %%]"		<rollershutter>	(gShutterWest)
	Group:Rollershutter:AVG gShutterWestGround "Rollladen Westen [%d %%]"		<rollershutter>	(gShutterWest)

Im Süden und Westen fahre ich manchmal Ober- und Erdgeschoß gemeinsam oder getrennt.

Den Code der Rule habe ich schon entsprechend angepasst, bin aber mit dem Abbruch und der fehlenden Sonnenverfolgung noch nicht ganz zufrieden.

[int5749]

Next Update:

Da nun - bei aktiver Automatik - in jedem Zyklus auch auf (0) geprüft wird, sollte durch den entsprechenden Azimut/Elevation auch später eingestiegen werden. Wenn eine Seite durch ist, setze ich den Wert (9) um sicher zu gehen.

In einer parallelen Rule reagiere ich auf einen Switch meines Hellihkeitssensors. Bei Tagesanbruch setze ich die 3 Werte dann wieder auf (0)

Dies ist noch warm und bisher nicht getestet, evtl. fällt ja schon direkt ein Denkfehler auf?

Aktuelle Rule (ohne Schwätzerei)

Code: Alles auswählen

rule "SunProtection"
when
	Item azimuth received update
then
	tempmax = (Weather_Temp_Max_0.state as DecimalType).intValue
	if(SunProtection.state != ON)
    return;

//	Fuellen der Variablen
	var int azimuth = (azimuth.state as DecimalType).intValue
	var int elevation = (elevation.state as DecimalType).intValue

// Höhe des Rollos je nach Temperatur
	if(tempmax >= 45) {}
	else if(tempmax >= 32) {hoehe1 = 100 hoehe2 = 90 hoehe3 = 80 hoehe4 = 70 hoehe5 = 0} 	
	else if(tempmax >= 27) {hoehe1 =  90 hoehe2 = 80 hoehe3 = 55 hoehe4 = 50 hoehe5 = 0}
	else if(tempmax >= 20) {hoehe1 =  85 hoehe2 = 75 hoehe3 = 55 hoehe4 = 45 hoehe5 = 0}
	else if(sonneost.state < 1 && sonnesued.state < 1 && sonnewest.state < 1) return;

// Sonnenschutz OST
		if	(sonneost.state == 0 && azimuth >= 50 && azimuth <= 135 && elevation >=5) {

			gShutterNorth.members.forEach[i|i.sendCommand(hoehe3)]
			gShutterEast.members.forEach[i|i.sendCommand(hoehe2)]
			gShutterSouth.members.forEach[i|i.sendCommand(hoehe5)]
			gShutterWest.members.forEach[i|i.sendCommand(hoehe5)]

			sonneost.postUpdate(1)

		} else if ((sonneost.state == 0 || sonneost.state == 1) && azimuth >= 128 && elevation >= 10) { // Sonne scheint jetzt von Süd-Ost.

			gShutterNorth.members.forEach[i|i.sendCommand(hoehe5)]
			gShutterEast.members.forEach[i|i.sendCommand(hoehe2)]

			sonneost.postUpdate(2)

		} else if ((sonneost.state == 0 || sonneost.state == 2) && azimuth >= 220 && elevation <= 60) {

			gShutterEast.members.forEach[i|i.sendCommand(hoehe5)]

			sonneost.postUpdate(9)
		
		}
		
// Sonnenschutz SÜD
		if (sonnesued.state == 0 && azimuth >= 120 && azimuth <= 250 && elevation >= 40) {

			gShutterSouth.members.forEach[i|i.sendCommand(hoehe2)]

       		sonnesued.postUpdate(1)

		} else if ((sonnesued.state == 0 || sonnesued.state == 1) && azimuth >= 137) {

			gShutterSouth.members.forEach[i|i.sendCommand(hoehe2)]

       		sonnesued.postUpdate(2)

		} else if ((sonnesued.state == 0 || sonnesued.state == 2) && azimuth >= 270) {

			gShutterSouthGround.members.forEach[i|i.sendCommand(hoehe4)]

       		sonnesued.postUpdate(3)

  		} else if ((sonnesued.state == 0 || sonnesued.state == 3) && azimuth >= 280 && elevation <= 13) {

			gShutterSouthGround.members.forEach[i|i.sendCommand(hoehe5)]

       		sonnesued.postUpdate(4)

  		} else if ((sonnesued.state == 0 || sonnesued.state == 4) && elevation <= 10) {

			gShutterSouthFirst.members.forEach[i|i.sendCommand(hoehe5)]

       		sonnesued.postUpdate(9)

  		}
		
// Sonnenschutz WEST
		if (sonnewest.state == 0 && azimuth >= 210 && elevation >=30) {

			gShutterWest.members.forEach[i|i.sendCommand(hoehe2)]

			sonnewest.postUpdate(1)

		} else if ((sonnewest.state == 0 || sonnewest.state == 1) && azimuth >= 282 && elevation <= 20) {

			gShutterWestFirst.members.forEach[i|i.sendCommand(hoehe3)]
			gShutterWestGround.members.forEach[i|i.sendCommand(hoehe5)]

			sonnewest.postUpdate(2)

		} else if ((sonnewest.state == 0 || sonnewest.state == 2) && azimuth >= 285 && elevation <= 15) {

			gShutterWestFirst.members.forEach[i|i.sendCommand(hoehe5)]

			sonnewest.postUpdate(9)

		}
end

[int5749]

Die Rule scheint - zumindest im ersten Testlauf - auch mit einem späteren Einstieg zu funktionieren.
Durch die virtuellen Schalter für sonneost, sued und west, wird jede Rolllade nur 1x pro Zyklus gefahren, daher würde ich auf einen Vergleich zur Abweichung durch manuelles verfahren verzichten.

Nun habe ich noch einige Punkte, bei denen ich Tipps gebrauchen könnte.

1) An welcher Stelle sollte ich die Abfrage der Helligkeit und ggfs der Bewälkung einbauen?
Hier schwebt mir vor, die Rollladen wieder etwas hoch zu fahren, wenn es bewölkt und unter eine gewissen Temperatur ist
Bewölkt heißt ja nicht kühl und die Wärme muss ja nicht durch die Scheibe schauen

2) kann ich auch mehrere Gruppen gleichzeitig filtern, um nur die entsprechenden Rollladen zu fahren?

Viele Grüße

[udo1toni]

Du kannst eine übergeordnete Gruppe nutzen und allMembers verwenden, das sind alle Member der Gruppe und der Untergruppe(n) Also z.B. eine Struktur

Code: Alles auswählen

Group allShutter
    Group allOGShutter (allShutter)
        Rollershutter OGShutter1 (allOGShutter)
        Rollershutter OGShutter2 (allOGShutter)
    Group allEGShutter (allShutter)
        Rollershutter EGShutter1 (allEGShutter)
        Rollershutter EGShutter2 (allEGShutter)
        Group livingShutter (allEGShutter)
            Rollershutter EGShutter3 (livingShutter)
            Rollershutter EGShutter4 (livingShutter)

kannst Du nutzen, um alle Shutter anzusprechen (allShutter.allMembers) oder nur alle im Erdgeschoss (allEGShutter.allMembers) oder nur die im Erdgeschoss ohne Wohnzimmer (allEGShutter.members) Wobei man die letzte Variante mit Vorsicht genießen sollte, also genau prüfen, ob sich openHAB tatsächlich so verhält, wie man das erwartet (es könnte sein, dass das Group Item livingShutter als normales Item angesprochen wird und dann die Befehle an seine Member weiter gibt)

[int5749]

Du kannst eine übergeordnete Gruppe nutzen und allMembers verwenden, das sind alle Member der Gruppe und der Untergruppe(n) Also z.B. eine Struktur

Stimmt, da war doch was. Du hast dies ja schon einmal erklärt, als Du meine Gardena Rule revolutioniert hast

Ich habe dies nun wie folgt angepasst, derzeit noch geschwätzig um einen Trockenlauf zu machen und exemplarisch für 1 Gebäudeseite.

Code: Alles auswählen

rule "SunProtection"
when
	Item azimuth received update
then
	tempmax = (Weather_Temp_Max_0.state as DecimalType).intValue
	if(SunProtection.state != ON)
    return;

//	Fuellen der Variablen
	var int azimuth = (azimuth.state as DecimalType).intValue
	var int elevation = (elevation.state as DecimalType).intValue

// Höhe des Rollos je nach Temperatur
	if(tempmax >= 45) {}
	else if(tempmax >= 32) {hoehe1 = 100 hoehe2 = 90 hoehe3 = 80 hoehe4 = 70 hoehe5 = 0} 	
	else if(tempmax >= 27) {hoehe1 =  90 hoehe2 = 80 hoehe3 = 55 hoehe4 = 50 hoehe5 = 0}
	else if(tempmax >= 2) {hoehe1 =  85 hoehe2 = 75 hoehe3 = 55 hoehe4 = 45 hoehe5 = 0}
	else if(sonneost.state < 1 && sonnesued.state < 1 && sonnewest.state < 1) return;

// Sonnenschutz OST
		if	(sonneost.state == 0 && azimuth >= 50 && azimuth <= 135 && elevation >=5) {

			gShutterNorth.allMembers.filter(f|(f.state as DecimalType).intValue!==hoehe3).forEach[ s|
//				s.sendCommand(hoehe3)
				logInfo("Shutter", s.name + " received Höhe {}", hoehe3)
			]
			gShutterEast.allMembers.filter(f|(f.state as DecimalType).intValue!==hoehe2).forEach[ s|
//				s.sendCommand(hoehe3)
				logInfo("Shutter", s.name + " received Höhe {}", hoehe2)
			]
			gShutterSouth.allMembers.filter(f|(f.state as DecimalType).intValue!==hoehe5).forEach[ s|
//				s.sendCommand(hoehe3)
				logInfo("Shutter", s.name + " received Höhe {}", hoehe5)
			]
			gShutterWest.allMembers.filter(f|(f.state as DecimalType).intValue!==hoehe5).forEach[ s|
//				s.sendCommand(hoehe3)
				logInfo("Shutter", s.name + " received Höhe {}", hoehe5)
			]

//			gShutterNorth.members.forEach[i|i.sendCommand(hoehe3)]
//			gShutterEast.members.forEach[i|i.sendCommand(hoehe2)]
//			gShutterSouth.members.forEach[i|i.sendCommand(hoehe5)]
//			gShutterWest.members.forEach[i|i.sendCommand(hoehe5)]

			sonneost.postUpdate(1)
logInfo("Sun_Protection","Sonnenschutz Ost - Stufe 1")

		} else if ((sonneost.state == 0 || sonneost.state == 1) && azimuth >= 128 && elevation >= 10) { // Sonne scheint jetzt von Süd-Ost.

			gShutterNorth.allMembers.filter(f|(f.state as DecimalType).intValue!==hoehe5).forEach[ s|
//				s.sendCommand(hoehe3)
				logInfo("Shutter", s.name + " received Höhe {}", hoehe5)
			]
			gShutterEast.allMembers.filter(f|(f.state as DecimalType).intValue!==hoehe2).forEach[ s|
//				s.sendCommand(hoehe3)
				logInfo("Shutter", s.name + " received Höhe {}", hoehe2)
			]
//			gShutterNorth.members.forEach[i|i.sendCommand(hoehe5)]
//			gShutterEast.members.forEach[i|i.sendCommand(hoehe2)]

			sonneost.postUpdate(2)
logInfo("Sun_Protection","Sonnenschutz Ost - Stufe 2")

		} else if ((sonneost.state == 0 || sonneost.state == 2) && azimuth >= 220 && elevation <= 60) {

			gShutterEast.allMembers.filter(f|(f.state as DecimalType).intValue!==hoehe5).forEach[ s|
//				s.sendCommand(hoehe3)
				logInfo("Shutter", s.name + " received Höhe {}", hoehe5)
			]
//			gShutterEast.members.forEach[i|i.sendCommand(hoehe5)]

			sonneost.postUpdate(9)
logInfo("Sun_Protection","Sonnenschutz Ost - Stufe 3")
		
		}
		
// Sonnenschutz SÜD

Was mir noch vorschwebt ist ein Abruch der Rule, wenn es regnet oder stark bewölkt ist. Dort würde ich dann die Werte sonneost, etc wieder auf 0 setzen und alle Rollos z.B. auf 25 oder 0 fahren. Wenn dann die Sonne wieder scheint, müsste es ja wieder in die einzelnen Phasen laufen?

[int5749]

Hallo zusammen,

nachdem die Rule zur Sonnenautomatik an sich gut funktioniert (freue mich aber immer über Verbesserungsvorschläge) kam nun ein Wunsch der Geschäftsführung: Bitte die Automatik nicht bei bewölktem Wetter starten.

Kurz überlegt: steigert den WAF, also klar bau ich ein.

Aber, es will noch nicht so wie ich will und hoffe, dass ihr meinen Fehler seht.

Es geht hierbei nicht um die Automatik an sich, sondern der Start derer. Dies habe ich über die folgende Rule implementiert.

Code: Alles auswählen

var Integer tempmax = 0

rule Rollladen_Task
when
    Time cron "0 30 08 ? * MON-SAT" or
    Time cron "0 00 09 ? * SUN"
then
	val mailActions = getActions("mail","mail:smtp:h478579470")
	tempmax = (Weather_Temp_Max_0.state as DecimalType).intValue

	logInfo("Shutter", "OneCallAPIweatherandforecast_Current_Conditionid: " + OneCallAPIweatherandforecast_Current_Conditionid.state.toString)
	logInfo("Shutter", "tempmax: " + tempmax.toString)
	logInfo("Shutter", "Night: " + Night.state.toString)
	logInfo("Shutter", "Comfort_Shutter: " + Comfort_Shutter.state.toString)
	logInfo("Shutter", "Holiday: " + Holiday.state.toString)

	if (Night.state == OFF && Comfort_Shutter.state == ON && Holiday.state == OFF && (tempmax < 20 || (tempmax >= 20 && (OneCallAPIweatherandforecast_Current_Conditionid.state != "800" || OneCallAPIweatherandforecast_Current_Conditionid.state  != "801")))) {
		logInfo("Shutter", "Rollladen fahren auf.")
		mailActions.sendMail("abcdefghijklmnop@api.prowlapp.com", ""+ tempmax + " Grad: " + OffsetDateTime.now().toString, "Rollladen fahren auf.")
		Rollladen.allMembers.filter(f|(f.state as DecimalType).intValue!==0).forEach[ s|
			s.sendCommand(UP)
			logInfo("Shutter", s.name + " received UP")
		]
		Lampe_Treppe.sendCommand(OFF)
	} else if (Night.state == OFF && Comfort_Shutter.state == ON && Holiday.state == OFF && tempmax >= 20 && (OneCallAPIweatherandforecast_Current_Conditionid.state == "800" || OneCallAPIweatherandforecast_Current_Conditionid.state == "801")) {
		SunProtection.postUpdate(ON)
	} else if (Night.state == ON) { //Comfort_Shutter.state == ON && Holiday.state == OFF && 
		mailActions.sendMail("abcdefghijklmnop@api.prowlapp.com", "Information: " + OffsetDateTime.now().toString, "Es ist noch Nacht, Rollladen bleiben unten.")
		if (t_night === null){
			t_night = createTimer(now.plusMinutes(10))[ |
				if (Night.state == ON) {
					mailActions.sendMail("abcdefghijklmnop@api.prowlapp.com", "Information: " + OffsetDateTime.now().toString, "Es ist immer noch Nacht, Rollladen bleiben unten.")
					t_night.reschedule(now.plusMinutes(10))
				} else {
					mailActions.sendMail("abcdefghijklmnop@api.prowlapp.com", "Information: " + OffsetDateTime.now().toString, "Rollladen fahren auf")
					Rollladen.allMembers.filter(f|(f.state as DecimalType).intValue!==0).forEach[ s|
						s.sendCommand(UP)
						logInfo("Shutter", s.name + " received UP")
					]
					Lampe_Treppe.sendCommand(OFF)
					t_night.cancel
					t_night = null
				}
			]
		}
	} else if (Holiday.state == ON) {
		mailActions.sendMail("abcdefghijklmnop@api.prowlapp.com", "" + SpecialDay + ": " + OffsetDateTime.now().toString, "Rollladen bleiben unten.")
	} else if (Comfort_Shutter.state == OFF) {
		mailActions.sendMail("abcdefghijklmnop@api.prowlapp.com", "Komfortfunktion aus: " + OffsetDateTime.now().toString, "Rollladen bleiben unten.")
	}
end

Heute Morgen war im Log

Code: Alles auswählen

2021-07-21 08:30:00.461 [INFO ] [rg.openhab.core.model.script.Shutter] - OneCallAPIweatherandforecast_Current_Conditionid: 800
2021-07-21 08:30:00.461 [INFO ] [rg.openhab.core.model.script.Shutter] - tempmax: 25
2021-07-21 08:30:00.477 [INFO ] [rg.openhab.core.model.script.Shutter] - Night: OFF
2021-07-21 08:30:00.477 [INFO ] [rg.openhab.core.model.script.Shutter] - Comfort_Shutter: ON
2021-07-21 08:30:00.477 [INFO ] [rg.openhab.core.model.script.Shutter] - Holiday: OFF

Trotzdem sind die Rollladen auf-gefahren und es wurde nicht die Sonnenautomatik aktiviert

Die ursprüngliche Abfrage (ohne Bewölkung) sah wie folgt aus

Code: Alles auswählen

	if (Comfort_Shutter.state == ON && Holiday.state == OFF && Night.state == OFF && tempmax < 20) {

und hat ohne Probleme funktioniert.

Viele Grüße und besten Dank