openhabforum.de

Code: Alles auswählen

var Boolean bShadeStart = false
var Boolean bShadeEnd = false

rule "reset some vars"
when
   Time is midnight
then
    bShadeStart = false
    bShadeEnd = false
end

rule "Rollos Süd abfahren"
when 
    Item LokaleSonnendaten_Azimut changed
then
    logDebug('autoShutter', 'Regel (Rollo Süd runter) wurde gestartet')

    if(RolloautomatikSued.state != ON) {
        logDebug('autoShutter', 'Beende, da Automatik generell nicht aktiv')
        return;
    }
    if(bShadeStart) {
        logDebug('autoShutter', 'Automatik heute bereits einmal gelaufen, wird daher ignoriert')
        return;
    }
    if((LokaleSonnendaten_Azimut.state as Number).floatValue < (RolloAutomatikSuedAzimuthStart.state as Number)) {
        logDebug('autoShutter', 'Azimuth ({}) hat noch nicht Schwellwert ({}) erreicht',LokaleSonnendaten_Azimut.state,RolloAutomatikSuedAzimuthStart.state)
        return;
    }
    if((XiaomiHumidityPressureGarten_Temperature.state as Number).floatValue < (RolloAutomatikSuedTempMin.state as Number)) {
        logDebug('autoShutter', 'Mindest-Temperatur ({}) wurde nicht erreicht durch aktuelle Temperatur ({})',RolloAutomatikSuedTempMin.state,XiaomiHumidityPressureGarten_Temperature.state)
        return;
    }
    if((Localweatherandforecast_Bewolkung.state as Number).floatValue  > (RolloAutomatikSuedWolkenMax.state as Number)) {
        logDebug('autoShutter', 'Maximalbewölkung ({}) wurde überschritten ({})',RolloAutomatikSuedWolkenMax.state,Localweatherandforecast_Bewolkung.state)
        return;
    }
    if((LokaleSonnendaten_Position_Elevation.state as Number).floatValue < (RolloAutomatikSuedElevationEnde.state as Number)) {
        logDebug('autoShutter', 'Elevation für wieder abfahren ({}) ist groesser als aktuelle ({})',RolloAutomatikSuedElevationEnde.state,LokaleSonnendaten_Position_Elevation.state)
        return;
    }
    // Rollos runterfahren
    logDebug('autoShutter', 'Rollos werden abgefahren')
    val nZiel = RolloAutomatikZielwert.state as Number
    RollosSued.members.forEach[i|
        if(i.state <= nZiel) {
            logDebug('autoShutter', 'Fahre Rolladen {} auf {}%' + i.name,nZiel)
            i.sendCommand(nZiel)
        } else {
            logDebug('autoShutter', 'Rolladen ist bereits weiter geschlossen ({}%) als er geschlossen werden sollte und wird daher ignoriert',i.state)
        }
    ]
    // Letzte Ausführung mit entsprechendem Zeitstempel belegen
    sendBroadcastNotification("Verschattung Südseite aktiv") //Pushnachricht
    bShadeStart = true
    RolloAutomatikSuedStartLast.postUpdate(new DateTimeType(now))
end

rule "Rollo Süd wieder öffnen"
when 
    Item LokaleSonnendaten_Position_Elevation changed
then
    val String logPrefix = 'Rolloautomatik  - '
    logDebug('autoShutter', 'Regel (Rollo Süd hoch) wurde gestartet')

    if(RolloAutomatikSuedOeffnen.state != ON) {
        logDebug('autoShutter', 'Beende, da Automatik generell nicht aktiv')
        return;
    }
    if((LokaleSonnendaten_Position_Elevation.state as Number).floatValue > (RolloAutomatikSuedElevationEnde.state as Number)) {
        logDebug('autoShutter', 'Beende, da Elevation ({}) nicht kleiner der eingestellten Elevation ({}) war',LokaleSonnendaten_Position_Elevation.state,RolloAutomatikSuedElevationEnde.state)
        return;
    }
    if(!bShadeStart) {
        logDebug('autoShutter', 'Beende, da heute noch keine Ausführung stattfand. Demzufolge kann auch kein automatisches Öffnen gewollt sein')
        return;
    }
    if(bShadeEnd) {
        logDebug('autoShutter', 'Beende, da heute bereits ein automatisches Wiederhochfahren stattfand')
        return;
    }
    // Rollos wieder hoch
    logDebug('autoShutter', 'Rollos werden hinaufgefahren')
    val nZiel = RolloAutomatikZielwert.state as Number
    RollosSued.members.forEach[i|
        if(nZiel <= (i.state as Number) +5 && nZiel >= (i.state as Number) -5) {
            logDebug('autoShutter', 'Fahre Rolladen {} auf 0%',i.name)
            i.sendCommand(0)
        } else {
            logDebug('autoShutter', 'Fahre Rolladen {} nicht auf 0%, da dieser zwischenzeitlich manuell verändert wurde.',i.name)
        }
    ]
    // Letzte Ausführung mit entsprechendem Zeitstempel belegen
    sendBroadcastNotification("Verschattung Südseite beendet") //Pushnachricht
    RolloAutomatikSuedEndeLast.postUpdate(new DateTimeType())
    bShadeEnd = true
end

Code: Alles auswählen

if(bShadeStart) {
        logDebug('autoShutter', 'Automatik heute bereits einmal gelaufen, wird daher ignoriert')
        return;

Code: Alles auswählen

var Boolean bShadeStart = false
var Boolean bShadeEnd = false

rule "reset some vars"
when
   Time is midnight
then
    bShadeStart = false
    bShadeEnd = false
end

rule "Rollos Süd abfahren"
when 
    Item LokaleSonnendaten_Azimut changed
then
    logInfo('autoShutter', 'Regel (Rollo Süd runter) wurde gestartet')

    if(RolloautomatikSued.state != ON) {
        logInfo('autoShutter', 'Beende, da Automatik generell nicht aktiv')
        return;
    }
    if(bShadeStart) {
        logInfo('autoShutter', 'Automatik heute bereits einmal gelaufen, wird daher ignoriert')
        return;
    }
    if((LokaleSonnendaten_Azimut.state as Number).floatValue < (RolloAutomatikSuedAzimuthStart.state as Number)) {
        logInfo('autoShutter', 'Azimuth ({}) hat noch nicht Schwellwert ({}) erreicht',LokaleSonnendaten_Azimut.state,RolloAutomatikSuedAzimuthStart.state)
        return;
    }
    if((XiaomiHumidityPressureGarten_Temperature.state as Number).floatValue < (RolloAutomatikSuedTempMin.state as Number)) {
        logInfo('autoShutter', 'Mindest-Temperatur ({}) wurde nicht erreicht durch aktuelle Temperatur ({})',RolloAutomatikSuedTempMin.state,XiaomiHumidityPressureGarten_Temperature.state)
        return;
    }
    if((Localweatherandforecast_Bewolkung.state as Number).floatValue  > (RolloAutomatikSuedWolkenMax.state as Number)) {
        logInfo('autoShutter', 'Maximalbewölkung ({}) wurde überschritten ({})',RolloAutomatikSuedWolkenMax.state,Localweatherandforecast_Bewolkung.state)
        return;
    }
    if((LokaleSonnendaten_Position_Elevation.state as Number).floatValue < (RolloAutomatikSuedElevationEnde.state as Number)) {
        logInfo('autoShutter', 'Elevation für wieder abfahren ({}) ist groesser als aktuelle ({})',RolloAutomatikSuedElevationEnde.state,LokaleSonnendaten_Position_Elevation.state)
        return;
    }
    // Rollos runterfahren
    logInfo('autoShutter', 'Rollos werden abgefahren')
    val nZiel = RolloAutomatikZielwert.state as Number
    RollosSued.members.forEach[i|
        if(i.state <= nZiel) {
            logInfo('autoShutter', 'Fahre Rolladen {} auf {}%' + i.name,nZiel)
            i.sendCommand(nZiel)
        } else {
            logInfo('autoShutter', 'Rolladen ist bereits weiter geschlossen ({}%) als er geschlossen werden sollte und wird daher ignoriert',i.state)
        }
    ]
    // Letzte Ausführung mit entsprechendem Zeitstempel belegen
    sendBroadcastNotification("Verschattung Südseite aktiv") //Pushnachricht
    bShadeStart = true
    RolloAutomatikSuedStartLast.postUpdate(new DateTimeType(now))
end

rule "Rollo Süd wieder öffnen"
when 
    Item LokaleSonnendaten_Position_Elevation changed
then
    val String logPrefix = 'Rolloautomatik  - '
    logInfo('autoShutter', 'Regel (Rollo Süd hoch) wurde gestartet')

    if(RolloAutomatikSuedOeffnen.state != ON) {
        logInfo('autoShutter', 'Beende, da Automatik generell nicht aktiv')
        return;
    }
    if((LokaleSonnendaten_Position_Elevation.state as Number).floatValue > (RolloAutomatikSuedElevationEnde.state as Number)) {
        logInfo('autoShutter', 'Beende, da Elevation ({}) nicht kleiner der eingestellten Elevation ({}) war',LokaleSonnendaten_Position_Elevation.state,RolloAutomatikSuedElevationEnde.state)
        return;
    }
    if(!bShadeStart) {
        logInfo('autoShutter', 'Beende, da heute noch keine Ausführung stattfand. Demzufolge kann auch kein automatisches Öffnen gewollt sein')
        return;
    }
    if(bShadeEnd) {
        logInfo('autoShutter', 'Beende, da heute bereits ein automatisches Wiederhochfahren stattfand')
        return;
    }
    // Rollos wieder hoch
    logInfo('autoShutter', 'Rollos werden hinaufgefahren')
    val nZiel = RolloAutomatikZielwert.state as Number
    RollosSued.members.forEach[i|
        if(nZiel <= (i.state as Number) +5 && nZiel >= (i.state as Number) -5) {
            logInfo('autoShutter', 'Fahre Rolladen {} auf 0%',i.name)
            i.sendCommand(0)
        } else {
            logInfo('autoShutter', 'Fahre Rolladen {} nicht auf 0%, da dieser zwischenzeitlich manuell verändert wurde.',i.name)
        }
    ]
    // Letzte Ausführung mit entsprechendem Zeitstempel belegen
    sendBroadcastNotification("Verschattung Südseite beendet") //Pushnachricht
    RolloAutomatikSuedEndeLast.postUpdate(new DateTimeType())
    bShadeEnd = true
end

Code: Alles auswählen

import java.util.Map
//import java.time.ZonedDateTime
//import java.time.LocalTime


var Boolean message = true

//val LocalDateTime MyJavaLocalDateTime = new LocalDateTime() // create a LocalDateTime value to work with`
//val DateTimeType MyDateTimeTypeFromJavaLocalDateTime = new DateTimeType(MyJavaLocalDateTime ) // conversion

//val DateTimeType MyDateTimeTypeTimestamp = DateTimeType.valueOf(now.toLocalDateTime().toString())

val String filename = "shutter.rules"

// Values und Variablen für die Verschattung

//val Number blindClosed = 100
//val Number blindOpen = 0
//val Number blindTranslucent = 35


//AutoShading: ist für die automatische Verschattung(runter und rauf) zuständig.
//ManualShading: damit kann ich wenn ich "anwesend" bin, die Rollläden auf die Positionen der Verschattung(targetHights) fahren. Da die automatische Verschattung wenn ich "anwesend" bin deaktiviert ist.
//ShutterControll: übernimmt die allgemeine Rollladebsteuerung, also z.B. Wochentags oder am Wochenende oder im Urlaub.
//Shading_Var: wird in der rule "Verschattung Variablen update" verwendet um zu schauen, ob die Boolean´s TRUE oder FALSE sind z.B. isActiveWest und gibt das dann im Log aus. Man das von "aussen (RESTAPI)" sonst nicht sehen ob sie TRUE oder FALSE sind. Der Reset setzt diese einfach wieder auf FALSE.

var Number closingAzimuth_east = 65
var Number closingAzimuth_south = 101
var Number closingAzimuth_west = 171
var Number closingAzimuth_north = 290

var Number closingCloudiness = 20   
val Number cloudHysteresis = 45         //die Mindestbewölkung in der letzten Stunde
var Number openingTemperature = 22
var Number closingTemperature = 24
val Number temperatureHysteresis = 4    //Temperaturabfall von min. 4 Grad in der letzten Stunde
val Number minPrecip = 5                //die Mindestmenge an Regen in der letzten Stunde

var Boolean isActiveWest = false
var Boolean isActiveEast = false
var Boolean isActiveSouth = false
var Boolean isActiveBalkon = false

val String logPrefix = "Rollläden - "

/* -------------  Verschattung FUNKTIONEN --------------------
*/
//-------------  Verschattung starten --------------------

val shadingStart = [GroupItem shutter |

        val String logPrefix = "Verschattung aktivieren - "

                val Map<String, Number> targetHights = newHashMap ( 
                    "EG_Arbeitszimmer_Ost" -> 75,
                    "EG_Arbeitszimmer_Sued" -> 75,
                    "EG_Jalousie_Essen_Tuere_West" -> 100,
                    "EG_Jalousie_Schiebetuere_rechts_Sued" -> 100,
                    "EG_Jalousie_Schiebetuere_Sued" -> 100,
                    "EG_Fenster_West" -> 75,
                    "EG_Tuere_Kueche" -> 60,
                    "OG_Ankleide" -> 75,
                    "OG_Elternschlafen_West" -> 75,
                    "OG_Elternschlafen_Sued" -> 75,
                    "OG_Kinderbad" -> 75,
                    "OG_Amelie_Sued" -> 75,
                    "OG_Amelie_Ost" -> 75,
                    "OG_Emil_Ost" -> 75,
                    "KG_Hobbyraum_Abstellraum" -> 75
                )
                // Rollladen werden geschlossen
                logInfo("rules", logPrefix + "Grenzwert wurden erreicht, Rollladen werden geschlossen")

                shutter.allMembers.forEach[ blind |
                    if ((blind.state as Number) < targetHights.get(blind.name.toString()).intValue) {
                        logInfo("rules", logPrefix + "Fahre Rollladen (" + blind.name.toString() + ") auf (" + targetHights.get(blind.name.toString()).intValue + ") %" )
                        blind.sendCommand(targetHights.get(blind.name.toString()).intValue)
                        //Pushnachricht versenden
                        //sendPushoverMessage(pushoverBuilder("Verschattung für " + blind.name.toString + " aktiviert, schließen auf " + targetHights.get(blind.name.toString()).toString() + " %"))
                    } else {
                        logInfo("rules", logPrefix + "Rollladen ist bereits weiter geschlossen (" + blind.state.toString() + "%) als er geschlossen werden sollte und wird daher ignoriert")
                    }
                ]
                AutoShading_Start_last.postUpdate(now.toLocalDateTime.toString())
    return true;
]

//-------------  Verschattung beenden -------------------
val shadingEnd = [GroupItem shutter |

        val String logPrefix = "Verschattung deaktivieren - "

                    val Map<String, Number> targetHights = newHashMap ( 
                        "EG_Arbeitszimmer_Ost" -> 75,
                        "EG_Arbeitszimmer_Sued" -> 75,
                        "EG_Jalousie_Essen_Tuere_West" -> 100,
                        "EG_Jalousie_Schiebetuere_rechts_Sued" -> 100,
                        "EG_Jalousie_Schiebetuere_Sued" -> 100,
                        "EG_Fenster_West" -> 75,
                        "EG_Tuere_Kueche" -> 60,
                        "OG_Ankleide" -> 75,
                        "OG_Elternschlafen_West" -> 75,
                        "OG_Elternschlafen_Sued" -> 75,
                        "OG_Kinderbad" -> 75,
                        "OG_Amelie_Sued" -> 75,
                        "OG_Amelie_Ost" -> 75,
                        "OG_Emil_Ost" -> 75,
                        "KG_Hobbyraum_Abstellraum" -> 75
                     )
                    // Rollladen öffnen
                    logInfo("rules", logPrefix + "Rollladen werden geoeffnet")

                    shutter.allMembers.forEach[ blind |
                       if ((blind.state as Number) == targetHights.get(blind.name.toString()).intValue) {
                            logInfo("rules", logPrefix + "Oeffne Rollladen: " + blind.name.toString())
                            blind.sendCommand(UP)
                            //Pushnachricht versenden                        
                            //sendPushoverMessage(pushoverBuilder("Verschattung für (" + blind.name.toString() + ") beendet, Rollladen wird geöffnet."))
                        } else {
                            logInfo("rules", logPrefix + "Rollladen: (" + blind.name.toString() + ") wird nicht geoeffnet, da dieser zwischenzeitlich manuell verändert wurde.")
                        }    
                    ]                         
                    // Letzte Ausführung mit entsprechendem Zeitstempel belegen
                    AutoShading_End_last.postUpdate(now.toLocalDateTime.toString())
                    

                    //Variablen zurücksetzen
                    isActiveWest = false
                    isActiveEast = false
                    isActiveSouth = false
    return true;
]

/* -------------  Verschattung RULES --------------------
*/
//-------------  Verschattung starten --------------------

rule "Verschattung starten"
when
    Item Azimuth changed
then
    val String logPrefix = "Verschattung aktivieren - "
    
    //Prüfung auf: Verschattungsautomatik an / ob es Tag ist / Jahreszeit
    if (AutoShading.state != ON) {                                                                  
        logInfo("rules", logPrefix + "Verschattung wird nicht ausgeführt, da deaktiviert.")
        return;
    }

    if (Tag_Nacht.state != OFF) {                                                                       
        logInfo("rules", logPrefix + "Verschattung wird nicht ausgeführt, es ist Nacht.")
        return;
    }

    if (Jahreszeit.state !="SPRING" && Jahreszeit.state!= "SUMMER") {                               
        logInfo("rules", logPrefix + "Verschattung wird nicht ausgeführt, da weder, Frühling noch Sommer.")
        return;
    }

    if (AutoShading_Start_last.state == NULL) {
        logInfo("rules", logPrefix + "Letzte Ausführung unbekannt, Belegung mit Initialwert (-1 Tag)")
        AutoShading_Start_last.postUpdate(now.toLocalDateTime.minusDays(1).toString())
        //AutoShading_Start_last.postUpdate(ZonedDateTime.now().minusDays(1).toString())
        return;
    }
    /*
    if (Wind_Event == true) {
        logInfo("rules", logPrefix + "Verschattung wird nicht ausgeführt, da Wind_Event ausgelöst wurde")
        return; }
    */
    /*
    //Markisenautomatik
        if (!isActiveBalkon) {
        //Azimuth ist größer als 181° (WEST)
            if ((Azimuth.state as Number) > (closingAzimuth_west)) {
                if ((BalkonTemperatursensor_Temperature.state as Number).floatValue > (AutoShading_Temp_min.state as Number) && (Home_Current_Cloudiness.state as Number).floatValue < (AutoShading_Cloudiness_max.state as Number)) { 
                    logInfo("rules", logPrefix + "Markise Balkon")
                    gBalkonRollladen.sendCommand(UP)
                    AutoShadingM_Start_last.postUpdate(now.toString())
                    isActiveBalkon = true;      
                }
            }    
        } else {
            logInfo("rules", logPrefix + "Verschattung für Balkon bereits aktiviert")
        }
    */
    //Rollladenautomatik
    
    if (gPR.state != OFF && gPR.state != NULL)  {                                                                           
        logInfo("rules", logPrefix + "Verschattung (Rollläden) wird nicht ausgeführt, Anwesenheit erkannt.")
        return;
    }
    
    // Items für Sitemap füllen
    if(AutoShading_Azimuth_east.state == NULL)    AutoShading_Azimuth_east.postUpdate(closingAzimuth_east)
    if(AutoShading_Azimuth_south.state == NULL)   AutoShading_Azimuth_south.postUpdate(closingAzimuth_south)
    if(AutoShading_Azimuth_west.state == NULL)    AutoShading_Azimuth_west.postUpdate(closingAzimuth_west)
    if(AutoShading_Temp_diff.state == NULL)       AutoShading_Temp_diff.postUpdate(temperatureHysteresis)
    if(AutoShading_Cloudiness_Hyst.state == NULL) AutoShading_Cloudiness_Hyst.postUpdate(cloudHysteresis)
    if(AutoShading_Rain_min.state == NULL)        AutoShading_Rain_min.postUpdate(minPrecip)
    
    if ((gTempOut.state as Number).floatValue <= (AutoShading_Temp_min.state as Number)) {
            logInfo("rules", logPrefix + "Verschattung (Rollläden) wird nicht ausgeführt, Mindesttemperatur von ({}) wurde nicht erreicht. Aktuelle Temperatur ({}) ", AutoShading_Temp_min.state, gTempOut.state)
            return;
    }
    
    if ((gHelligkeit.state as Number).floatValue <= (19000)) { 
            logInfo("rules", logPrefix + "Verschattung (Rollläden) wird nicht ausgeführt, Aktuelle Bewoelkung ({}) ueberschreitet den eingestellten Grenzwert von 19000 lux", Home_Current_Cloudiness.state)
            return;
    }
    /*
    if ((Home_Current_Cloudiness.state as Number).floatValue > (AutoShading_Cloudiness_max.state as Number)) { 
            logInfo("rules", logPrefix + "Verschattung (Rollläden) wird nicht ausgeführt, Aktuelle Bewoelkung ({}) ueberschreitet den eingestellten Grenzwert von ({})", Home_Current_Cloudiness.state, AutoShading_Cloudiness_max.state)
            return;
    }
    */
    if ((AutoShading_Elevation_end.state as Number) <= (Elevation.state as Number)) {
            logInfo("rules", logPrefix + "Verschattung (Rollläden) wird nicht ausgeführt, Elevation für das Beenden der Verschattung ({}) ist groesser als aktuelle ({}) ", AutoShading_Elevation_end.state, Elevation.state)
            return;
    }

    //Azimuth ist größer als 181° (WEST)
    if (!isActiveWest) { 
        if ((Azimuth.state as Number).floatValue > (closingAzimuth_west)) {
            logInfo("rules", logPrefix + "Verschattung für Rollläden WEST")
            isActiveWest = shadingStart.apply(gRollladenWest)
            return;
        }      
    } else {
            logInfo("rules", logPrefix + "Verschattung für Rollläden WEST bereits aktiviert")
        } 

    //Azimuth ist größer als 111° (SÜD)
if (!isActiveSouth) { 
        if ((Azimuth.state as Number).floatValue > (closingAzimuth_south) && (Azimuth.state as Number).floatValue < (closingAzimuth_west)) {
            logInfo("rules", logPrefix + "Verschattung für Rollläden SÜD")
            isActiveSouth = shadingStart.apply(gRollladenSouth)
            return;
        }
} else {
            logInfo("rules", logPrefix + "Verschattung für Rollläden SÜD bereits aktiviert")
        }

    //Azimuth ist größer als 65° (OST)
    if (!isActiveEast) { 
        if ((Azimuth.state as Number).floatValue > (closingAzimuth_east) && (Azimuth.state as Number).floatValue < (closingAzimuth_south)) {
            logInfo("rules", logPrefix + "Verschattung für Rollläden OST")
            isActiveEast = shadingStart.apply(gRollladenEast)
        return;
        }
    } else {
            logInfo("rules", logPrefix + "Verschattung für Rollläden OST bereits aktiviert")
        }
end

//-------------  Verschattung beenden --------------------

rule "Verschattung beenden"
when 
    Item Elevation changed
then   
    
    val String logPrefix = "Verschattung deaktivieren - "

    //Prüfung auf: Verschattungsautomatik an / ob es Tag ist / Jahreszeit
    if (AutoShading_End.state != ON) {                                                                  
        logInfo("rules", logPrefix + "Verschattung wird nicht ausgeführt, da deaktiviert.")
        return;
    }

    if (Tag_Nacht.state != OFF) {                                                                        
        logInfo("rules", logPrefix + "Verschattung wird nicht ausgeführt, es ist Nacht.")
        return;
    }

    if (Jahreszeit.state !="SPRING" && Jahreszeit.state!= "SUMMER") {                               
        logInfo("rules", logPrefix + "Verschattung wird nicht ausgeführt, da weder, Frühling noch Sommer.")
        return;
    }
            
    val Boolean isRainLastHour = (Home_Current_RainVolume.maximumSince(now.minusHours(1), "influxdb").state >= (minPrecip))
    logInfo("rules", logPrefix + "Rain " + isRainLastHour)
    
    val Boolean isCloudLastHour = (Home_Current_Cloudiness.averageSince(now.minusHours(1), "influxdb")as Number >= (cloudHysteresis))
    logInfo("rules", logPrefix + "Clouds " + isCloudLastHour )
    
    val Boolean isTemperature = ((gTempOut.state as Number).intValue < (gTempOut.minimumSince(now.minusHours(1), "influxdb").state as DecimalType -(temperatureHysteresis)))
    logInfo("rules", logPrefix + "Temperatur " + isTemperature)
    
    
    if (AutoShading_End_last.state === NULL || AutoShadingM_End_last.state === NULL) {
        logInfo("rules", logPrefix + "Letzte Ausführung unbekannt, Belegung mit Initialwert (-1 Tag)")
            AutoShading_End_last.postUpdate(now.toLocalDateTime.minusDays(1).toString())
            AutoShadingM_End_last.postUpdate(now.toLocalDateTime.minusDays(1).toString())
        }

    var String timeNow = now.toLocalDateTime().toString()
    //now.toString().substring(0,10)

    var String timeLastEnde = AutoShading_End_last.state.toString().substring(0,10)
    
    var String timeLastEndeM = AutoShadingM_End_last.state.toString().substring(0,10)

    if (timeLastEnde == timeNow && timeLastEndeM == timeNow) {
        logInfo("rules", logPrefix + "Beende, da heute bereits ein automatisches Hochfahren stattfand")
        return;
    }

    if (!isActiveWest && !isActiveEast && !isActiveSouth && !isActiveBalkon) {
        logInfo("rules", logPrefix + "Beende, da heute noch keine automatische Verschattung stattfand")
        return;
    }

    if (isTemperature) {
        logInfo("rules", logPrefix + "Verschattung beenden, Temperaturabfall von min. ({})° erkannt", temperatureHysteresis)
        //gBalkonRollladen.sendCommand(DOWN)
        AutoShadingM_End_last.postUpdate(now.toLocalDateTime.toString)
        shadingEnd.apply(gRollladen)
        return;
    }

    if ((gTempOut.state as Number).floatValue > (AutoShading_Temp_raise.state as Number)) {
        logInfo("rules", logPrefix + "Beende, aktuelle Temperatur ({})° ueberschreitet den eingestellten Grenzwert zum hochfahren von ({})°",gTempOut.state, AutoShading_Temp_raise.state )
        return;
    }

    if (isRainLastHour || isCloudLastHour) {
        logInfo("rules", logPrefix + "Verschattung beenden, Mindestregenmenge von ({}) mm oder druchschnittliche Bewölkung von ({}) % erreicht",minPrecip, cloudHysteresis)
        //gBalkonRollladen.sendCommand(DOWN)
        AutoShadingM_End_last.postUpdate(Date_Time.toString)
        shadingEnd.apply(gRollladen)
        return;
    }

    if ((Elevation.state as Number) > (AutoShading_Elevation_end.state as Number)) {
        logInfo("rules", logPrefix + "Beende, aktuelle Elevation ({}) ueberschreitet den eingestellten Grenzwert von ({}) ", Elevation.state, AutoShading_Elevation_end.state)
        return;
    }

    /*
        if (isActiveBalkon) {
        logInfo("rules", logPrefix + "Verschattung Balkon beenden")
        gBalkonRollladen.sendCommand(DOWN)
        AutoShadingM_End_last.postUpdate(now.toString())
    }
    */
    if (isActiveWest || isActiveEast || isActiveSouth ) {
        logInfo("rules", logPrefix + "Verschattung Rollläden beenden")
        shadingEnd.apply(gRollladen)
        return;
    }        
end


/* -------------  Verschattung Variablen zurücksetzen wenn kein automtisches hochfahren erfolgt --------------------
*/

rule "Verschattung Variablen zurücksetzen"
when
        Time cron "0 0 23 * * ?" or 
        Channel 'astro:sun:home:nauticDusk#event' triggered END 
then
        logInfo("rules", logPrefix + "Verschattung Variablen zurücksetzen")
        isActiveWest = false
        isActiveEast = false
        isActiveSouth = false
        isActiveBalkon = false
end

rule "Verschattung Variablen update"
when
        Item Shading_Var received command
then
        logInfo("rules", "Verschattung Variablen: " + receivedCommand)
        switch (receivedCommand) {
            case "queryState" : {
                        logInfo("rules", logPrefix + "Verschattung Variablen update")
                        if (isActiveWest) {
                            logInfo("rules", logPrefix + "Verschattung für Rollläden WEST aktiv")
                        } else { 
                            logInfo("rules", logPrefix + "Verschattung für Rollläden WEST inaktiv")
                        }
                        if (isActiveEast) {
                            logInfo("rules", logPrefix + "Verschattung für Rollläden OST aktiv")
                        } else { 
                            logInfo("rules", logPrefix + "Verschattung für Rollläden OST inaktiv")
                        }
                        if (isActiveSouth) {
                            logInfo("rules", logPrefix + "Verschattung für Rollläden SÜD aktiv")
                        } else { 
                            logInfo("rules", logPrefix + "Verschattung für Rollläden SÜD inaktiv")
                        }
                        /*if (isActiveBalkon) {
                            logInfo("rules", logPrefix + "Verschattung für Markise (Balkon) aktiv")
                        } else { 
                            logInfo("rules", logPrefix + "Verschattung für Markise (Balkon) inaktiv")
                        }*/
            }
            case "reset" : {
                    logInfo("rules", logPrefix + "Verschattung Variablen reset")
                    isActiveWest = false
                    isActiveEast = false
                    isActiveSouth = false
                    isActiveBalkon = false
                }
        }
        Shading_Var.postUpdate(NULL) 
end 

Code: Alles auswählen

2021-04-21 12:38:53.620 [INFO ] [org.openhab.core.model.script.rules ] - Verschattung aktivieren - Grenzwert wurden erreicht, Rollladen werden geschlossen
2021-04-21 12:38:53.623 [INFO ] [org.openhab.core.model.script.rules ] - Verschattung aktivieren - Rollladen ist bereits weiter geschlossen (77%) als er geschlossen werden sollte und wird daher ignoriert
2021-04-21 12:38:53.626 [ERROR] [internal.handler.ScriptActionHandler] - Script execution of rule with UID 'shutter-1' failed: cannot invoke method public abstract int java.lang.Number.intValue() on null in shutter
2021-04-21 12:43:53.589 [INFO ] [org.openhab.core.model.script.rules ] - Verschattung aktivieren - Verschattung für Rollläden SÜD
2021-04-21 12:43:53.601 [INFO ] [org.openhab.core.model.script.rules ] - Verschattung deaktivieren - Rain false
2021-04-21 12:43:53.612 [INFO ] [org.openhab.core.model.script.rules ] - Verschattung aktivieren - Grenzwert wurden erreicht, Rollladen werden geschlossen
2021-04-21 12:43:53.612 [INFO ] [org.openhab.core.model.script.rules ] - Verschattung deaktivieren - Clouds false
2021-04-21 12:43:53.616 [INFO ] [org.openhab.core.model.script.rules ] - Verschattung aktivieren - Rollladen ist bereits weiter geschlossen (77%) als er geschlossen werden sollte und wird daher ignoriert
2021-04-21 12:43:53.617 [INFO ] [org.openhab.core.model.script.rules ] - Verschattung deaktivieren - Temperatur false
2021-04-21 12:43:53.619 [INFO ] [org.openhab.core.model.script.rules ] - Verschattung deaktivieren - Beende, da heute noch keine automatische Verschattung stattfand
2021-04-21 12:43:53.621 [ERROR] [internal.handler.ScriptActionHandler] - Script execution of rule with UID 'shutter-1' failed: cannot invoke method public abstract int java.lang.Number.intValue() on null in shutter
2021-04-21 12:48:53.589 [INFO ] [org.openhab.core.model.script.rules ] - Verschattung aktivieren - Verschattung für Rollläden SÜD
2021-04-21 12:48:53.590 [INFO ] [org.openhab.core.model.script.rules ] - Verschattung deaktivieren - Rain false
2021-04-21 12:48:53.595 [INFO ] [org.openhab.core.model.script.rules ] - Verschattung deaktivieren - Clouds false
2021-04-21 12:48:53.599 [INFO ] [org.openhab.core.model.script.rules ] - Verschattung deaktivieren - Temperatur false
2021-04-21 12:48:53.600 [INFO ] [org.openhab.core.model.script.rules ] - Verschattung deaktivieren - Beende, da heute noch keine automatische Verschattung stattfand
2021-04-21 12:48:53.604 [INFO ] [org.openhab.core.model.script.rules ] - Verschattung aktivieren - Grenzwert wurden erreicht, Rollladen werden geschlossen
2021-04-21 12:48:53.605 [INFO ] [org.openhab.core.model.script.rules ] - Verschattung aktivieren - Rollladen ist bereits weiter geschlossen (77%) als er geschlossen werden sollte und wird daher ignoriert
2021-04-21 12:48:53.606 [ERROR] [internal.handler.ScriptActionHandler] - Script execution of rule with UID 'shutter-1' failed: cannot invoke method public abstract int java.lang.Number.intValue() on null in shutter
2021-04-21 12:53:53.587 [INFO ] [org.openhab.core.model.script.rules ] - Verschattung aktivieren - Verschattung für Rollläden SÜD
2021-04-21 12:53:53.593 [INFO ] [org.openhab.core.model.script.rules ] - Verschattung deaktivieren - Rain false
2021-04-21 12:53:53.596 [INFO ] [org.openhab.core.model.script.rules ] - Verschattung deaktivieren - Clouds false
2021-04-21 12:53:53.599 [INFO ] [org.openhab.core.model.script.rules ] - Verschattung deaktivieren - Temperatur false
2021-04-21 12:53:53.601 [INFO ] [org.openhab.core.model.script.rules ] - Verschattung deaktivieren - Beende, da heute noch keine automatische Verschattung stattfand
2021-04-21 12:53:53.614 [INFO ] [org.openhab.core.model.script.rules ] - Verschattung aktivieren - Grenzwert wurden erreicht, Rollladen werden geschlossen
2021-04-21 12:53:53.615 [INFO ] [org.openhab.core.model.script.rules ] - Verschattung aktivieren - Rollladen ist bereits weiter geschlossen (77%) als er geschlossen werden sollte und wird daher ignoriert
2021-04-21 12:53:53.616 [ERROR] [internal.handler.ScriptActionHandler] - Script execution of rule with UID 'shutter-1' failed: cannot invoke method public abstract int java.lang.Number.intValue() on null in shutter
2021-04-21 12:58:53.589 [INFO ] [org.openhab.core.model.script.rules ] - Verschattung aktivieren - Verschattung für Rollläden WEST
2021-04-21 12:58:53.592 [INFO ] [org.openhab.core.model.script.rules ] - Verschattung deaktivieren - Rain false
2021-04-21 12:58:53.600 [INFO ] [org.openhab.core.model.script.rules ] - Verschattung deaktivieren - Clouds false
2021-04-21 12:58:53.602 [INFO ] [org.openhab.core.model.script.rules ] - Verschattung aktivieren - Grenzwert wurden erreicht, Rollladen werden geschlossen
2021-04-21 12:58:53.606 [INFO ] [org.openhab.core.model.script.rules ] - Verschattung deaktivieren - Temperatur false
2021-04-21 12:58:53.607 [INFO ] [org.openhab.core.model.script.rules ] - Verschattung aktivieren - Fahre Rollladen (EG_Jalousie_Essen_Tuere_West) auf (100) %
2021-04-21 12:58:53.610 [INFO ] [org.openhab.core.model.script.rules ] - Verschattung aktivieren - Fahre Rollladen (OG_Ankleide) auf (75) %
2021-04-21 12:58:53.612 [ERROR] [internal.handler.ScriptActionHandler] - Script execution of rule with UID 'shutter-1' failed: cannot invoke method public abstract int java.lang.Number.intValue() on null in shutter
2021-04-21 12:58:53.620 [INFO ] [org.openhab.core.model.script.rules ] - Verschattung deaktivieren - Beende, da heute noch keine automatische Verschattung stattfand

Code: Alles auswählen

item=AutoShading_Temp_diff
item=AutoShading_Cloudiness_Hyst
item=AutoShading_Rain_min

Code: Alles auswählen

gInitializeOff
gInitializeOn

Code: Alles auswählen

Webview icon=none url="http://192.168.x.x:8080/static/chartTemperatureDay.html" height=28

Code: Alles auswählen

OW_localCurrentTemperature.state as Number
OW_localCurrentCloudiness.state as Number

Code: Alles auswählen

gTemperaturesOut
gCloudiness

Code: Alles auswählen

var boolean log = false

rule "Beschattungsautomatik Norden/Osten"
when Item i_1_1_40_Status_Helligkeit_Osten changed
then
    if (i_v_Tagesmodus.state==1)
    {
        val String logPrefix = 'BA_Norden_Osten - '
        if (log) logInfo('rules', logPrefix + 'Regel wurde gestartet')
        

        //Norden
        var String timeLast_N = 'xxxx-xx-xx'

        if (i_v_BA_Start_N_Last.state == NULL) {
            if (log) logInfo('rules', logPrefix + 'Erstmalige Ausführung, Belegung mit Initialwert Norden')
        } else {
            timeLast_N = i_v_BA_Start_N_Last.state.toString().substring(0,10)
        }
        //;

        //Osten
        var String timeLast_O = 'xxxx-xx-xx'

        if (i_v_BA_Start_O_Last.state == NULL) {
            if (log) logInfo('rules', logPrefix + 'Erstmalige Ausführung, Belegung mit Initialwert Osten')
        } else {
            timeLast_O = i_v_BA_Start_O_Last.state.toString().substring(0,10)
        }
        //;

        var String timeNow = now.toString().substring(0,10)

        //Norden
        if (i_v_BA_Automatik_Norden_Aktiv.state == ON) {
            if (timeNow != timeLast_N) {
                if (i_1_1_40_Status_Helligkeit_Osten.state > Integer::parseInt(i_v_BA_Helligkeit_Norden_Schliessen.state.toString())) {
                    if (log) logInfo('rules', logPrefix + 'Norden wird geschlossen')
                    
                    //Höhe Jalousien
                    g_BA_Norden_Hoehe.members.forEach[i|
                        if (i.state <= Integer::parseInt(i_v_BA_Zielhoehe_Jalousien.state.toString())) {
                            if (log) logInfo('rules', logPrefix + 'Fahre Norden (Hoehe) auf ' + i_v_BA_Zielhoehe_Jalousien.state.toString() + '%: ' + i.name)
                            i.sendCommand(Integer::parseInt(i_v_BA_Zielhoehe_Jalousien.state.toString()))
                        } else {
                            if (log) logInfo('rules', logPrefix + 'Norden ist bereits weiter geschlossen (' + i.state.toString() + '%) als er geschlossen werden sollte und wird daher ignoriert')
                        }
                    ]

                    //Winkel Jalousien
                    g_BA_Norden_Winkel.members.forEach[i|
                        if (i.state <= Integer::parseInt(i_v_BA_Zielwinkel_Jalousien.state.toString())) {
                            if (log) logInfo('rules', logPrefix + 'Fahre Norden (Winkel) auf ' + i_v_BA_Zielwinkel_Jalousien.state.toString() + '%: ' + i.name)
                            i.sendCommand(Integer::parseInt(i_v_BA_Zielwinkel_Jalousien.state.toString()))
                        } else {
                            if (log) logInfo('rules', logPrefix + 'Norden ist bereits weiter geschlossen (' + i.state.toString() + '%) als er geschlossen werden sollte und wird daher ignoriert')
                        }
                    ]

                    // Letzte Ausführung mit entsprechendem Zeitstempel belegen
                    i_v_BA_Start_N_Last.postUpdate(now.toString())
                }
            }
            else {
                if (log) logInfo('rules', logPrefix + 'Automatik Norden heute bereits einmal gelaufen, wird daher ignoriert')
            }
        } else {
            if (log) logInfo('rules', logPrefix + 'Beende, da Automatik Norden nicht aktiv')
        }
        

        //Osten
        if (i_v_BA_Automatik_Osten_Aktiv.state == ON) {
            if (timeNow != timeLast_O) {
                if (i_1_1_40_Status_Helligkeit_Osten.state > Integer::parseInt(i_v_BA_Helligkeit_Osten_Schliessen.state.toString())) {
                    if (log) logInfo('rules', logPrefix + 'Osten wird geschlossen')

                    //Höhe Rollladen
                    g_BA_Osten_Hoehe.members.forEach[i|
                        if (i.state <= Integer::parseInt(i_v_BA_Zielhoehe_Rollladen.state.toString())) {
                            if (log) logInfo('rules', logPrefix + 'Fahre Osten (Hoehe) auf ' + i_v_BA_Zielhoehe_Rollladen.state.toString() + '%: ' + i.name)
                            i.sendCommand(Integer::parseInt(i_v_BA_Zielhoehe_Rollladen.state.toString()))
                        } else {
                            if (log) logInfo('rules', logPrefix + 'Osten ist bereits weiter geschlossen (' + i.state.toString() + '%) als er geschlossen werden sollte und wird daher ignoriert')
                        }
                    ]

                    // Letzte Ausführung mit entsprechendem Zeitstempel belegen
                    i_v_BA_Start_O_Last.postUpdate(now.toString())
                }
            }
            else {
                if (log) logInfo('rules', logPrefix + 'Automatik Osten heute bereits einmal gelaufen, wird daher ignoriert')
            }
        } else {
            if (log) logInfo('rules', logPrefix + 'Beende, da Automatik Osten nicht aktiv')
        }
    }
    else
    {
        if (log) logInfo('rules', logPrefix + 'Tagmodus nicht aktiv - Logik übersprungen')
    }
end