Temperatur Tendenz ermitteln

Einrichtung der openHAB Umgebung und allgemeine Konfigurationsthemen.

Moderatoren: seppy, udo1toni

Antworten
Benutzeravatar
PeterA
Beiträge: 1106
Registriert: 8. Feb 2019 12:12
Answers: 13

Re: Temperatur Tendenz ermitteln

Beitrag von PeterA »

So nun wollte ich das ganze mal "scharf schalten".
Jetzt meckert VSC an der Stelle "New Hashmap":

Code: Alles auswählen

import java.util.HashMap

val HashMap <String,String> hmRoller = New Hashmap[ "InnenDG"      -> "Shellyswitch25_745118_roller",                    // und so weiter,
                                                    "InnenDGKind1" -> "Shellyswitch25_00B713_roller",                    // für jeden Shutter ein Wertepaar
                                                    "InnenDGKind2" -> "Shellyswitch25_E58F7A_roller",
                                                    "InnenWHZ"     -> "Shellyswitch25_740A26_roller"
    ]

    rule "Update Kombi Item"
when
    Member of gTemp changed or
    Member of gFeuchte changed or
    Member of grAllshutters changed
then
    val String strSensor = triggeringItem.name.split("_").get(0)                                                        // Sensor bestimmen
    val String strShutter= triggeringItem.name.split("_").get(1)                                                        // Rollladen bestimmen
                                                                                                                        // zugehörige Items bestimmen
    val ItemTempTendenz =  gTempTendenz.members.findFirst[i|i.name.split("_").get(0) == strSensor] as StringItem        // Item für Temperatur Tendenz bestimmen
    val ItemTempProxy   =    gTempProxy.members.findFirst[i|i.name.split("_").get(0) == strSensor] as NumberItem        // Proxy Item für Temperatur bestimmen
    val ItemHumTendenz  =   gHumTendenz.members.findFirst[i|i.name.split("_").get(0) == strSensor] as StringItem        // Item für Feuchte Tendenz bestimmen
    val ItemHumProxy    =     gHumProxy.members.findFirst[i|i.name.split("_").get(0) == strSensor] as NumberItem        // Proxy Item für Feuchte bestimmen
    val ItemTemp        =         gTemp.members.findFirst[i|i.name.split("_").get(0) == strSensor] as NumberItem        // Temperatur Item bestimmen
    val ItemHum         =          gHum.members.findFirst[i|i.name.split("_").get(0) == strSensor] as NumberItem        // Feuchte Item bestimmen
    val ItemKombi       =        gKombi.members.findFirst[i|i.name.split("_").get(0) == strSensor] as StringItem        // Kombi Item bestimmen
    val ItemShutter     = grAllshutters.members.findFirst[i|i.name == hmRoller.get(strShutter)]    as NumberItem        // Rolladen Pos Item bestimmen
                                                                                                                        // Werte bestimmen
    val Number nTempProxy = if(ItemTempProxy.state instanceof Number) (ItemTempProxy.state as Number) else 0            // Temperatur Proxy auslesen
    val Number nHumProxy  = if(ItemHumTendenz.state instanceof Number) (ItemHumTendenz.state as Number) else 0          // Feuchte  Proxy auslesen
    val Number nTemp = if(ItemTemp.state instanceof Number) (ItemTemp.state as Number).floatValue else nTempProxy       // Temperatur auslesen
    val Number nHum  = if(ItemHum.state instanceof Number) (ItemHum.state as Number).floatValue else nHumProxy          // Feuchte auslesen
    val Number nPos  = if(ItemShutter.state instanceof Number) (ItemShutter.state as Number) else 0                     // Rolladen Position auslesen
                                                                                                                        // Tendenz Temperatur
    var String strTempTendence = "⟷"                                                                                   // Default String für Tendenz Anzeige
    var String strTempMessage = "stagnierend"                                                                           // Default String für Tendenz Logmeldung
    if(nTemp > nTempProxy) {                                                                                            // falls aktuelle Temperatur höher als alte Temperatur
        strTempTendence = "⬆️"                                                                                          // String für Tendenz Anzeige steigend
        strTempMessage = "steigend"                                                                                     // String für Logmeldung steigend
    }
    if(nTemp < nTempProxy) {                                                                                            // falls aktuelle Temperatur geringer als alte Temperatur
        strTempTendence = "⬇️"                                                                                          // String für Tendenz Anzeige sinkend
        strTempMessage = "fallend"                                                                                      // String für Logmeldung sinkend
    }
    logInfo("temphum","Sensor {} Temperatur {}",strSensor,strTempMessage)                                               // Logmeldung ausgeben
    ItemTempProxy.postUpdate(nTemp)                                                                                     // Neue Temperatur in Proxy Item übernehmen
    ItemTempTendenz.postUpdate(strTempTendence)                                                                         // Tendenz Item setzen
                                                                                                                        // Tendenz Feuchte
    var String strHumTendence = "⟷"                                                                                    // Default String für Tendenz Anzeige
    var String strHumMessage = "stagnierend"                                                                            // Default String für Tendenz Logmeldung
    if(nHum > nHumProxy) {                                                                                              // falls aktuelle Feuchte höher als alte Feuchte
        strHumTendence = "⬆️"                                                                                           // String für Tendenz Anzeige steigend
        strHumMessage = "steigend"                                                                                      // String für Logmeldung steigend
    }
    if(nHum < nHumProxy) {                                                                                              // falls aktuelle Feuchte geringer als alte Feuchte
        strHumTendence = "⬇️"                                                                                           // String für Tendenz Anzeige sinkend
        strHumMessage = "fallend"                                                                                       // String für Logmeldung sinkend
    }
    logInfo("temphum","Sensor {} Feuchte {}",strSensor,strHumMessage)                                                   // Logmeldung ausgeben
    ItemHumProxy.postUpdate(nHum)                                                                                       // Neue Feuchte in Proxy Item übernehmen
    ItemHumTendenz.postUpdate(strHumTendence)                                                                           // Tendenz Item setzen
                                                                                                                        // Kombiitem setzen
    var String strKombi = strTempTendence + " " + nTemp.toString + " °C / " + strHumTendence + " " + nHum.toString + " %" // Kombinierter String ohne Shutter
    if(ItemShutter !== null)                                                                                            // Falls es ein passendes Shutteritem gibt
        strKombi = ItemShutter.state.toString + "% /" + strKombi                                                        // füge den Shutterstatus vorne an
    ItemKombi.postUpdate(strKombi)                                                                                      // Setze das Kombiitem
end

Code: Alles auswählen

{
	"resource": "/Volumes/openHAB-conf/rules/SensorsInfoKombiGroups.rules",
	"owner": "_generated_diagnostic_collection_name_#0",
	"code": "org.eclipse.xtext.diagnostics.Diagnostic.Linking",
	"severity": 8,
	"message": "The method or field New is undefined",
	"startLineNumber": 3,
	"startColumn": 40,
	"endLineNumber": 3,
	"endColumn": 43
}

Code: Alles auswählen

{
	"resource": "/Volumes/openHAB-conf/rules/SensorsInfoKombiGroups.rules",
	"owner": "_generated_diagnostic_collection_name_#0",
	"code": "org.eclipse.xtext.diagnostics.Diagnostic.Syntax",
	"severity": 8,
	"message": "missing EOF at 'Hashmap'",
	"startLineNumber": 3,
	"startColumn": 44,
	"endLineNumber": 3,
	"endColumn": 51
}
- OpenHab 2.4
#PWRUP

Benutzeravatar
PeterA
Beiträge: 1106
Registriert: 8. Feb 2019 12:12
Answers: 13

Re: Temperatur Tendenz ermitteln

Beitrag von PeterA »

Ok habe es geändert nun meckert VSC nicht mehr....

Code: Alles auswählen

import java.util.HashMap

val HashMap <String,String> hmRoller = newHashMap(  "InnenDG"      -> "Shellyswitch25_745118_roller",                    // und so weiter,
                                                    "InnenDGKind1" -> "Shellyswitch25_00B713_roller",                    // für jeden Shutter ein Wertepaar
                                                    "InnenDGKind2" -> "Shellyswitch25_E58F7A_roller",
                                                    "InnenWHZ"     -> "Shellyswitch25_740A26_roller"
)

    rule "Update Kombi Item"
when
    Member of gTemp changed or
    Member of gFeuchte changed or
    Member of grAllshutters changed
then
    val String strSensor  = triggeringItem.name.split("_").get(0)                                                       // Sensor bestimmen
    val String strShutter = triggeringItem.name.split("_").get(1)                                                       // Rollladen bestimmen
                                                                                                                        // zugehörige Items bestimmen
    val ItemTempTendenz =  gTempTendenz.members.findFirst[i|i.name.split("_").get(0) == strSensor] as StringItem        // Item für Temperatur Tendenz bestimmen
    val ItemTempProxy   =    gTempProxy.members.findFirst[i|i.name.split("_").get(0) == strSensor] as NumberItem        // Proxy Item für Temperatur bestimmen
    val ItemHumTendenz  =   gHumTendenz.members.findFirst[i|i.name.split("_").get(0) == strSensor] as StringItem        // Item für Feuchte Tendenz bestimmen
    val ItemHumProxy    =     gHumProxy.members.findFirst[i|i.name.split("_").get(0) == strSensor] as NumberItem        // Proxy Item für Feuchte bestimmen
    val ItemTemp        =         gTemp.members.findFirst[i|i.name.split("_").get(0) == strSensor] as NumberItem        // Temperatur Item bestimmen
    val ItemHum         =          gHum.members.findFirst[i|i.name.split("_").get(0) == strSensor] as NumberItem        // Feuchte Item bestimmen
    val ItemKombi       =        gKombi.members.findFirst[i|i.name.split("_").get(0) == strSensor] as StringItem        // Kombi Item bestimmen
    val ItemShutter     = grAllshutters.members.findFirst[i|i.name == hmRoller.get(strShutter)]    as NumberItem        // Rolladen Pos Item bestimmen
                                                                                                                        // Werte bestimmen
    val Number nTempProxy = if(ItemTempProxy.state instanceof Number) (ItemTempProxy.state as Number) else 0            // Temperatur Proxy auslesen
    val Number nHumProxy  = if(ItemHumTendenz.state instanceof Number) (ItemHumTendenz.state as Number) else 0          // Feuchte  Proxy auslesen
    val Number nTemp = if(ItemTemp.state instanceof Number) (ItemTemp.state as Number).floatValue else nTempProxy       // Temperatur auslesen
    val Number nHum  = if(ItemHum.state instanceof Number) (ItemHum.state as Number).floatValue else nHumProxy          // Feuchte auslesen
    //val Number nPos  = if(ItemShutter.state instanceof Number) (ItemShutter.state as Number) else 0                     // Rolladen Position auslesen
                                                                                                                        // Tendenz Temperatur
    var String strTempTendence = "⟷"                                                                                   // Default String für Tendenz Anzeige
    var String strTempMessage = "stagnierend"                                                                           // Default String für Tendenz Logmeldung
    if(nTemp > nTempProxy) {                                                                                            // falls aktuelle Temperatur höher als alte Temperatur
        strTempTendence = "⬆️"                                                                                          // String für Tendenz Anzeige steigend
        strTempMessage = "steigend"                                                                                     // String für Logmeldung steigend
    }
    if(nTemp < nTempProxy) {                                                                                            // falls aktuelle Temperatur geringer als alte Temperatur
        strTempTendence = "⬇️"                                                                                          // String für Tendenz Anzeige sinkend
        strTempMessage = "fallend"                                                                                      // String für Logmeldung sinkend
    }
    logInfo("temphum","Sensor {} Temperatur {}",strSensor,strTempMessage)                                               // Logmeldung ausgeben
    ItemTempProxy.postUpdate(nTemp)                                                                                     // Neue Temperatur in Proxy Item übernehmen
    ItemTempTendenz.postUpdate(strTempTendence)                                                                         // Tendenz Item setzen
                                                                                                                        // Tendenz Feuchte
    var String strHumTendence = "⟷"                                                                                    // Default String für Tendenz Anzeige
    var String strHumMessage = "stagnierend"                                                                            // Default String für Tendenz Logmeldung
    if(nHum > nHumProxy) {                                                                                              // falls aktuelle Feuchte höher als alte Feuchte
        strHumTendence = "⬆️"                                                                                           // String für Tendenz Anzeige steigend
        strHumMessage = "steigend"                                                                                      // String für Logmeldung steigend
    }
    if(nHum < nHumProxy) {                                                                                              // falls aktuelle Feuchte geringer als alte Feuchte
        strHumTendence = "⬇️"                                                                                           // String für Tendenz Anzeige sinkend
        strHumMessage = "fallend"                                                                                       // String für Logmeldung sinkend
    }
    logInfo("temphum","Sensor {} Feuchte {}",strSensor,strHumMessage)                                                   // Logmeldung ausgeben
    ItemHumProxy.postUpdate(nHum)                                                                                       // Neue Feuchte in Proxy Item übernehmen
    ItemHumTendenz.postUpdate(strHumTendence)                                                                           // Tendenz Item setzen
                                                                                                                        // Kombiitem setzen
    var String strKombi = strTempTendence + " " + nTemp.toString + " °C / " + strHumTendence + " " + nHum.toString + " %" // Kombinierter String ohne Shutter
    if(ItemShutter !== null)                                                                                            // Falls es ein passendes Shutteritem gibt
        strKombi = ItemShutter.state.toString + "% /" + strKombi                                                        // füge den Shutterstatus vorne an
    ItemKombi.postUpdate(strKombi)                                                                                      // Setze das Kombiitem
end
- OpenHab 2.4
#PWRUP

Benutzeravatar
PeterA
Beiträge: 1106
Registriert: 8. Feb 2019 12:12
Answers: 13

Re: Temperatur Tendenz ermitteln

Beitrag von PeterA »

Irgendwie scheint das mit der HasMap noch nicht zu funktionieren...

Code: Alles auswählen

2020-09-09 23:04:41.652 [vent.ItemStateChangedEvent] - Shellyswitch25_740A26_roller changed from 71 to 100
Der Rollladen wurde geschlossen.

Aber die Rule hat kein postUpdate auf das entsprechende Item ausgeführt.
- OpenHab 2.4
#PWRUP

Benutzeravatar
PeterA
Beiträge: 1106
Registriert: 8. Feb 2019 12:12
Answers: 13

Re: Temperatur Tendenz ermitteln

Beitrag von PeterA »

Bin nun einen Schritt weiter. So wie es scheint kann man Items nicht aus SubGroups filtern.
Rule nun mal so geändert und eine von beiden Rollladengruppen eingetragen.

Code: Alles auswählen

import java.util.HashMap

val HashMap <String,String> hmRoller = newHashMap(  "InnenDG"      -> "Shellyswitch25_745118_roller",                    // und so weiter,
                                                    "InnenDGKind1" -> "Shellyswitch25_00B713_roller",                    // für jeden Shutter ein Wertepaar
                                                    "InnenDGKind2" -> "Shellyswitch25_E58F7A_roller",
                                                    "InnenWHZ"     -> "Shellyswitch25_740A26_roller"
)

    rule "Update Kombi Item"
when
    Member of gTemp changed or
    Member of gHum changed or
    Member of gruppeRolladen_Sued changed
then
    val String strSensor  = triggeringItem.name.split("_").get(0)                                                       // Sensor bestimmen
    val String strShutter = triggeringItem.name.split("_").get(1)                                                       // Rollladen bestimmen
                                                                                                                        // zugehörige Items bestimmen
    val ItemTempTendenz =  gTempTendenz.members.findFirst[i|i.name.split("_").get(0) == strSensor] as StringItem        // Item für Temperatur Tendenz bestimmen
    val ItemTempProxy   =    gTempProxy.members.findFirst[i|i.name.split("_").get(0) == strSensor] as NumberItem        // Proxy Item für Temperatur bestimmen
    val ItemHumTendenz  =   gHumTendenz.members.findFirst[i|i.name.split("_").get(0) == strSensor] as StringItem        // Item für Feuchte Tendenz bestimmen
    val ItemHumProxy    =     gHumProxy.members.findFirst[i|i.name.split("_").get(0) == strSensor] as NumberItem        // Proxy Item für Feuchte bestimmen
    val ItemTemp        =         gTemp.members.findFirst[i|i.name.split("_").get(0) == strSensor] as NumberItem        // Temperatur Item bestimmen
    val ItemHum         =          gHum.members.findFirst[i|i.name.split("_").get(0) == strSensor] as NumberItem        // Feuchte Item bestimmen
    val ItemKombi       =        gKombi.members.findFirst[i|i.name.split("_").get(0) == strSensor] as StringItem        // Kombi Item bestimmen
    val ItemShutter     = gruppeRolladen_Sued.members.findFirst[i|i.name == hmRoller.get(strShutter)]    as NumberItem        // Rolladen Pos Item bestimmen
                                                                                                                        // Werte bestimmen
    val Number nTempProxy = if(ItemTempProxy.state instanceof Number) (ItemTempProxy.state as Number) else 0            // Temperatur Proxy auslesen
    val Number nHumProxy  = if(ItemHumTendenz.state instanceof Number) (ItemHumTendenz.state as Number) else 0          // Feuchte  Proxy auslesen
    val Number nTemp = if(ItemTemp.state instanceof Number) (ItemTemp.state as Number).floatValue else nTempProxy       // Temperatur auslesen
    val Number nHum  = if(ItemHum.state instanceof Number) (ItemHum.state as Number).floatValue else nHumProxy          // Feuchte auslesen
    //val Number nPos  = if(ItemShutter.state instanceof Number) (ItemShutter.state as Number) else 0                     // Rolladen Position auslesen
                                                                                                                        // Tendenz Temperatur
    var String strTempTendence = "⟷"                                                                                   // Default String für Tendenz Anzeige
    var String strTempMessage = "stagnierend"                                                                           // Default String für Tendenz Logmeldung
    if(nTemp > nTempProxy) {                                                                                            // falls aktuelle Temperatur höher als alte Temperatur
        strTempTendence = "⬆️"                                                                                          // String für Tendenz Anzeige steigend
        strTempMessage = "steigend"                                                                                     // String für Logmeldung steigend
    }
    if(nTemp < nTempProxy) {                                                                                            // falls aktuelle Temperatur geringer als alte Temperatur
        strTempTendence = "⬇️"                                                                                          // String für Tendenz Anzeige sinkend
        strTempMessage = "fallend"                                                                                      // String für Logmeldung sinkend
    }
    logInfo("temphum","Sensor {} Temperatur {}",strSensor,strTempMessage)                                               // Logmeldung ausgeben
    ItemTempProxy.postUpdate(nTemp)                                                                                     // Neue Temperatur in Proxy Item übernehmen
    ItemTempTendenz.postUpdate(strTempTendence)                                                                         // Tendenz Item setzen
                                                                                                                        // Tendenz Feuchte
    var String strHumTendence = "⟷"                                                                                    // Default String für Tendenz Anzeige
    var String strHumMessage = "stagnierend"                                                                            // Default String für Tendenz Logmeldung
    if(nHum > nHumProxy) {                                                                                              // falls aktuelle Feuchte höher als alte Feuchte
        strHumTendence = "⬆️"                                                                                           // String für Tendenz Anzeige steigend
        strHumMessage = "steigend"                                                                                      // String für Logmeldung steigend
    }
    if(nHum < nHumProxy) {                                                                                              // falls aktuelle Feuchte geringer als alte Feuchte
        strHumTendence = "⬇️"                                                                                           // String für Tendenz Anzeige sinkend
        strHumMessage = "fallend"                                                                                       // String für Logmeldung sinkend
    }
    logInfo("temphum","Sensor {} Feuchte {}",strSensor,strHumMessage)                                                   // Logmeldung ausgeben
    ItemHumProxy.postUpdate(nHum)                                                                                       // Neue Feuchte in Proxy Item übernehmen
    ItemHumTendenz.postUpdate(strHumTendence)                                                                           // Tendenz Item setzen
                                                                                                                        // Kombiitem setzen
    var String strKombi = strTempTendence + " " + nTemp.toString + " °C / " + strHumTendence + " " + nHum.toString + " %" // Kombinierter String ohne Shutter
    if(ItemShutter !== null)                                                                                            // Falls es ein passendes Shutteritem gibt
        strKombi = ItemShutter.state.toString + "% /" + strKombi                                                        // füge den Shutterstatus vorne an
    ItemKombi.postUpdate(strKombi)                                                                                      // Setze das Kombiitem
end
Nun triggert auch der hasmap Teil aber mit einer Fehlermeldung im Log:

Code: Alles auswählen

2020-09-10 09:54:37.703 [ome.event.ItemCommandEvent] - Item 'Shellyswitch25_00B713_roller' received command 20
2020-09-10 09:54:37.709 [nt.ItemStatePredictedEvent] - Shellyswitch25_00B713_roller predicted to become 20
2020-09-10 09:54:37.757 [vent.ItemStateChangedEvent] - Shellyswitch25_00B713_roller changed from 0 to 20
2020-09-10 09:54:49.462 [ERROR] [ntime.internal.engine.RuleEngineImpl] - Rule 'Update Kombi Item': cannot invoke method public org.eclipse.smarthome.core.types.State org.eclipse.smarthome.core.items.GenericItem.getState() on null
- OpenHab 2.4
#PWRUP

Benutzeravatar
udo1toni
Beiträge: 15265
Registriert: 11. Apr 2018 18:05
Answers: 245
Wohnort: Darmstadt

Re: Temperatur Tendenz ermitteln

Beitrag von udo1toni »

Du hast nichts davon gesagt, dass es sich um eine Gruppe mit Gruppen handelt ;)
Die Methode heißt dafür allMembers (anstatt members). Damit werden alle zur Gruppe gehörenden Items angesprochen, ob nun direkt oder indirekt.
openHAB4.3.5 stable in einem Debian-Container (bookworm) (Proxmox 8.4.1, LXC), mit openHABian eingerichtet

Benutzeravatar
PeterA
Beiträge: 1106
Registriert: 8. Feb 2019 12:12
Answers: 13

Re: Temperatur Tendenz ermitteln

Beitrag von PeterA »

Sorry das das untergegangen ist.

Rule geändert:

Code: Alles auswählen

mport java.util.HashMap

val HashMap <String,String> hmRoller = newHashMap(  "InnenDG"      -> "Shellyswitch25_745118_roller",                    // und so weiter,
                                                    "InnenDGKind1" -> "Shellyswitch25_00B713_roller",                    // für jeden Shutter ein Wertepaar
                                                    "InnenDGKind2" -> "Shellyswitch25_E58F7A_roller",
                                                    "InnenWHZ"     -> "Shellyswitch25_740A26_roller"
)

    rule "Update Kombi Item"
when
    Member of gTemp changed or
    Member of gHum changed or
    Member of grAllshutters changed
then
    val String strSensor  = triggeringItem.name.split("_").get(0)                                                       // Sensor bestimmen
    val String strShutter = triggeringItem.name.split("_").get(1)                                                       // Rollladen bestimmen
                                                                                                                        // zugehörige Items bestimmen
    val ItemTempTendenz =  gTempTendenz.members.findFirst[i|i.name.split("_").get(0) == strSensor] as StringItem        // Item für Temperatur Tendenz bestimmen
    val ItemTempProxy   =    gTempProxy.members.findFirst[i|i.name.split("_").get(0) == strSensor] as NumberItem        // Proxy Item für Temperatur bestimmen
    val ItemHumTendenz  =   gHumTendenz.members.findFirst[i|i.name.split("_").get(0) == strSensor] as StringItem        // Item für Feuchte Tendenz bestimmen
    val ItemHumProxy    =     gHumProxy.members.findFirst[i|i.name.split("_").get(0) == strSensor] as NumberItem        // Proxy Item für Feuchte bestimmen
    val ItemTemp        =         gTemp.members.findFirst[i|i.name.split("_").get(0) == strSensor] as NumberItem        // Temperatur Item bestimmen
    val ItemHum         =          gHum.members.findFirst[i|i.name.split("_").get(0) == strSensor] as NumberItem        // Feuchte Item bestimmen
    val ItemKombi       =        gKombi.members.findFirst[i|i.name.split("_").get(0) == strSensor] as StringItem        // Kombi Item bestimmen
    val ItemShutter     = grAllshutters.allMembers.findFirst[i|i.name == hmRoller.get(strShutter)]    as NumberItem        // Rolladen Pos Item bestimmen
                                                                                                                        // Werte bestimmen
    val Number nTempProxy = if(ItemTempProxy.state instanceof Number) (ItemTempProxy.state as Number) else 0            // Temperatur Proxy auslesen
    val Number nHumProxy  = if(ItemHumTendenz.state instanceof Number) (ItemHumTendenz.state as Number) else 0          // Feuchte  Proxy auslesen
    val Number nTemp = if(ItemTemp.state instanceof Number) (ItemTemp.state as Number).floatValue else nTempProxy       // Temperatur auslesen
    val Number nHum  = if(ItemHum.state instanceof Number) (ItemHum.state as Number).floatValue else nHumProxy          // Feuchte auslesen
    //val Number nPos  = if(ItemShutter.state instanceof Number) (ItemShutter.state as Number) else 0                     // Rolladen Position auslesen
                                                                                                                        // Tendenz Temperatur
    var String strTempTendence = "⟷"                                                                                   // Default String für Tendenz Anzeige
    var String strTempMessage = "stagnierend"                                                                           // Default String für Tendenz Logmeldung
    if(nTemp > nTempProxy) {                                                                                            // falls aktuelle Temperatur höher als alte Temperatur
        strTempTendence = "⬆️"                                                                                          // String für Tendenz Anzeige steigend
        strTempMessage = "steigend"                                                                                     // String für Logmeldung steigend
    }
    if(nTemp < nTempProxy) {                                                                                            // falls aktuelle Temperatur geringer als alte Temperatur
        strTempTendence = "⬇️"                                                                                          // String für Tendenz Anzeige sinkend
        strTempMessage = "fallend"                                                                                      // String für Logmeldung sinkend
    }
    logInfo("temphum","Sensor {} Temperatur {}",strSensor,strTempMessage)                                               // Logmeldung ausgeben
    ItemTempProxy.postUpdate(nTemp)                                                                                     // Neue Temperatur in Proxy Item übernehmen
    ItemTempTendenz.postUpdate(strTempTendence)                                                                         // Tendenz Item setzen
                                                                                                                        // Tendenz Feuchte
    var String strHumTendence = "⟷"                                                                                    // Default String für Tendenz Anzeige
    var String strHumMessage = "stagnierend"                                                                            // Default String für Tendenz Logmeldung
    if(nHum > nHumProxy) {                                                                                              // falls aktuelle Feuchte höher als alte Feuchte
        strHumTendence = "⬆️"                                                                                           // String für Tendenz Anzeige steigend
        strHumMessage = "steigend"                                                                                      // String für Logmeldung steigend
    }
    if(nHum < nHumProxy) {                                                                                              // falls aktuelle Feuchte geringer als alte Feuchte
        strHumTendence = "⬇️"                                                                                           // String für Tendenz Anzeige sinkend
        strHumMessage = "fallend"                                                                                       // String für Logmeldung sinkend
    }
    logInfo("temphum","Sensor {} Feuchte {}",strSensor,strHumMessage)                                                   // Logmeldung ausgeben
    ItemHumProxy.postUpdate(nHum)                                                                                       // Neue Feuchte in Proxy Item übernehmen
    ItemHumTendenz.postUpdate(strHumTendence)                                                                           // Tendenz Item setzen
                                                                                                                        // Kombiitem setzen
    var String strKombi = strTempTendence + " " + nTemp.toString + " °C / " + strHumTendence + " " + nHum.toString + " %" // Kombinierter String ohne Shutter
    if(ItemShutter !== null)                                                                                            // Falls es ein passendes Shutteritem gibt
        strKombi = ItemShutter.state.toString + "% /" + strKombi                                                        // füge den Shutterstatus vorne an
    ItemKombi.postUpdate(strKombi)                                                                                      // Setze das Kombiitem
end
Rollladen bewegt:

Code: Alles auswählen

2020-09-10 19:58:49.822 [ome.event.ItemCommandEvent] - Item 'Shellyswitch25_745118_roller' received command 80
2020-09-10 19:58:49.857 [nt.ItemStatePredictedEvent] - Shellyswitch25_745118_roller predicted to become 80
2020-09-10 19:58:49.896 [vent.ItemStateChangedEvent] - Shellyswitch25_745118_roller changed from 100 to 80
Aber das Kombiitem bekommt kein Update mit der Rollladen Position.

Hier die betreffenden Items:

Code: Alles auswählen

String    InnenDG_TempTendenz               "Temperatur Tendenz [%s]"                 <temperature>       (gTempTendenz)
Number    InnenDG_TempProxy                 "InnenDGTemp. Proxy [%s]"                                     (gTempProxy)
String    InnenDG_HumTendenz                "Luftfeuchtigkeit Tendenz [%s]"           <humidity>          (gHumTendenz)
Number    InnenDG_HumProxy                  "InnenDGFeuchte Proxy [%s]"                                   (gHumProxy)
Number    InnenDG_Temp                      "InnenDGTemp. [%s]"                                           (gTemp)           {channel="jeelink:lacrosse:4:temperature"}
Number    InnenDG_Hum                       "InnenDGFeuchte [%s]"                                         (gHum)            {channel="jeelink:lacrosse:4:humidity"}
String    InnenDG_Kombi                     "Flur DG [%s]"                            <corridor>          (gKombi)
Das Item "InnenDG_Kombi" hätte hier noch die Rollladen Position bekommen müssen.

So sind die Rollladengruppen definiert:

Code: Alles auswählen

Group			grAllshutters
Group			gruppeRolladen_West (grAllshutters)			
Group			gruppeRolladen_Sued (grAllshutters)
- OpenHab 2.4
#PWRUP

Benutzeravatar
PeterA
Beiträge: 1106
Registriert: 8. Feb 2019 12:12
Answers: 13

Re: Temperatur Tendenz ermitteln

Beitrag von PeterA »

Oder müssen die Gruppen als Type Rollershutter definiert sein ?

Code: Alles auswählen

Group:Rollershutter			grAllshutters
Group:Rollershutter			gruppeRolladen_West (grAllshutters)			
Group:Rollershutter			gruppeRolladen_Sued (grAllshutters)
Unmittelbar als ich das geändert hatte kam Log folgendes:

Code: Alles auswählen

2020-09-10 20:44:05.418 [INFO ] [el.core.internal.ModelRepositoryImpl] - Refreshing model 'shading.items'

==> /var/log/openhab2/events.log <==

2020-09-10 20:44:05.458 [ome.event.ItemUpdatedEvent] - Item 'grAllshutters' has been updated.
2020-09-10 20:44:05.466 [ome.event.ItemUpdatedEvent] - Item 'gruppeRolladen_West' has been updated.
2020-09-10 20:44:05.474 [ome.event.ItemUpdatedEvent] - Item 'gruppeRolladen_Sued' has been updated.
2020-09-10 20:44:09.574 [GroupItemStateChangedEvent] - gruppeRolladen_Sued changed from NULL to UNDEF through Shellyswitch25_740A26_roller
2020-09-10 20:44:09.593 [GroupItemStateChangedEvent] - grAllshutters changed from NULL to UNDEF through gruppeRolladen_Sued
2020-09-10 20:44:09.946 [ERROR] [ntime.internal.engine.RuleEngineImpl] - Rule 'Update Kombi Item': cannot invoke method public org.eclipse.smarthome.core.types.State org.eclipse.smarthome.core.items.GenericItem.getState() on null
2020-09-10 20:44:16.773 [GroupItemStateChangedEvent] - gruppeRolladen_West changed from NULL to UNDEF through Shellyswitch25_E66E4E_roller
2020-09-10 20:44:17.037 [ERROR] [ntime.internal.engine.RuleEngineImpl] - Rule 'Update Kombi Item': cannot invoke method public org.eclipse.smarthome.core.types.State org.eclipse.smarthome.core.items.GenericItem.getState() on null
:?:
- OpenHab 2.4
#PWRUP

Benutzeravatar
udo1toni
Beiträge: 15265
Registriert: 11. Apr 2018 18:05
Answers: 245
Wohnort: Darmstadt

Re: Temperatur Tendenz ermitteln

Beitrag von udo1toni »

Ah. Nein, die Gruppe kann einfach so bleiben, wie ise ist, aber in der Rule musst Du natürlich den Platzhalter für das Rollershutter Item (val ItemShutter) als RollershutterItem definieren, nicht als NumberItem
openHAB4.3.5 stable in einem Debian-Container (bookworm) (Proxmox 8.4.1, LXC), mit openHABian eingerichtet

Benutzeravatar
PeterA
Beiträge: 1106
Registriert: 8. Feb 2019 12:12
Answers: 13

Re: Temperatur Tendenz ermitteln

Beitrag von PeterA »

Ok, habe ich geändert. Aber leider wird gibts kein Update des Items wenn der Rolladen in der Gruppe changed...
- OpenHab 2.4
#PWRUP

Benutzeravatar
udo1toni
Beiträge: 15265
Registriert: 11. Apr 2018 18:05
Answers: 245
Wohnort: Darmstadt

Re: Temperatur Tendenz ermitteln

Beitrag von udo1toni »

Ja, stimmt, das muss man natürlich auch berücksichtigen. Blöd nur, dass die Rollladenitems namentlich nicht zu den Sensoren passen. Es wird jetzt echt haarig, das alles zu berücksichtigen...

Obwohl... Eigentlich ist es gar nicht sooo schlimm...

Code: Alles auswählen

mport java.util.HashMap

val HashMap <String,String> hmRoller = newHashMap(  "InnenDG"      -> "Shellyswitch25_745118_roller",                  // von Sensor nach Shutter
                                                    "InnenDGKind1" -> "Shellyswitch25_00B713_roller",
                                                    "InnenDGKind2" -> "Shellyswitch25_E58F7A_roller",
                                                    "InnenWHZ"     -> "Shellyswitch25_740A26_roller"
)

val HashMap <String,String> hmSensor = newHashMap(  "Shellyswitch25_745118_roller" -> "InnenDG",                 // von Shutter nach Sensor
                                                    "Shellyswitch25_00B713_roller" -> "InnenDGKind1",
                                                    "Shellyswitch25_E58F7A_roller" -> "InnenDGKind2",
                                                    "Shellyswitch25_740A26_roller" -> "InnenWHZ"
)



rule "Update Kombi Item"
when
    Member of gTemp changed or
    Member of gHum changed or
    Member of grAllshutters changed
then
    var String strSensor = triggeringItem.name.split("_").get(0)       // Sensor bestimmen. ACHTUNG! nun als var!!!
    if(triggeringItem.name.contains("Shellyswitch25")) {                                                                // Falls ein Rollershutter die Rule getriggert hat
        if(hmSensor.get(triggeringItem.name) !== null)                                                                  // Falls in der Hashmap enthalten
            strSensor = hmSensor.get(triggeringItem.name)                                                               // Ermittle Sensornamen
        else                                                                                                            // falls nicht in der Hashmap enthalten
            return;                                                                                                     // Rule abbrechen
    }
                                                                                                                        // zugehörige Items bestimmen
    val ItemTempTendenz =  gTempTendenz.members.findFirst[i|i.name.split("_").get(0) == strSensor] as StringItem        // Item für Temperatur Tendenz bestimmen
    val ItemTempProxy   =    gTempProxy.members.findFirst[i|i.name.split("_").get(0) == strSensor] as NumberItem        // Proxy Item für Temperatur bestimmen
    val ItemHumTendenz  =   gHumTendenz.members.findFirst[i|i.name.split("_").get(0) == strSensor] as StringItem        // Item für Feuchte Tendenz bestimmen
    val ItemHumProxy    =     gHumProxy.members.findFirst[i|i.name.split("_").get(0) == strSensor] as NumberItem        // Proxy Item für Feuchte bestimmen
    val ItemTemp        =         gTemp.members.findFirst[i|i.name.split("_").get(0) == strSensor] as NumberItem        // Temperatur Item bestimmen
    val ItemHum         =          gHum.members.findFirst[i|i.name.split("_").get(0) == strSensor] as NumberItem        // Feuchte Item bestimmen
    val ItemKombi       =        gKombi.members.findFirst[i|i.name.split("_").get(0) == strSensor] as StringItem        // Kombi Item bestimmen
    val ItemShutter     = grAllshutters.allMembers.findFirst[i|i.name == hmRoller.get(strSensor)]  as RollershutterItem // Rolladen Pos Item bestimmen
                                                                                                                        // Werte bestimmen
    val Number nTempProxy = if(ItemTempProxy.state instanceof Number) (ItemTempProxy.state as Number) else 0            // Temperatur Proxy auslesen
    val Number nHumProxy  = if(ItemHumTendenz.state instanceof Number) (ItemHumTendenz.state as Number) else 0          // Feuchte  Proxy auslesen
    val Number nTemp = if(ItemTemp.state instanceof Number) (ItemTemp.state as Number).floatValue else nTempProxy       // Temperatur auslesen
    val Number nHum  = if(ItemHum.state instanceof Number) (ItemHum.state as Number).floatValue else nHumProxy          // Feuchte auslesen
                                                                                                                        // Tendenz Temperatur
    var String strTempTendence = "⟷"                                                                                    // Default String für Tendenz Anzeige
    var String strTempMessage = "stagnierend"                                                                           // Default String für Tendenz Logmeldung
    if(nTemp > nTempProxy) {                                                                                            // falls aktuelle Temperatur höher als alte Temperatur
        strTempTendence = "⬆️"                                                                                          // String für Tendenz Anzeige steigend
        strTempMessage = "steigend"                                                                                     // String für Logmeldung steigend
    }
    if(nTemp < nTempProxy) {                                                                                            // falls aktuelle Temperatur geringer als alte Temperatur
        strTempTendence = "⬇️"                                                                                          // String für Tendenz Anzeige sinkend
        strTempMessage = "fallend"                                                                                      // String für Logmeldung sinkend
    }
    logInfo("temphum","Sensor {} Temperatur {}",strSensor,strTempMessage)                                               // Logmeldung ausgeben
    ItemTempProxy.postUpdate(nTemp)                                                                                     // Neue Temperatur in Proxy Item übernehmen
    ItemTempTendenz.postUpdate(strTempTendence)                                                                         // Tendenz Item setzen
                                                                                                                        // Tendenz Feuchte
    var String strHumTendence = "⟷"                                                                                    // Default String für Tendenz Anzeige
    var String strHumMessage = "stagnierend"                                                                            // Default String für Tendenz Logmeldung
    if(nHum > nHumProxy) {                                                                                              // falls aktuelle Feuchte höher als alte Feuchte
        strHumTendence = "⬆️"                                                                                           // String für Tendenz Anzeige steigend
        strHumMessage = "steigend"                                                                                      // String für Logmeldung steigend
    }
    if(nHum < nHumProxy) {                                                                                              // falls aktuelle Feuchte geringer als alte Feuchte
        strHumTendence = "⬇️"                                                                                           // String für Tendenz Anzeige sinkend
        strHumMessage = "fallend"                                                                                       // String für Logmeldung sinkend
    }
    logInfo("temphum","Sensor {} Feuchte {}",strSensor,strHumMessage)                                                   // Logmeldung ausgeben
    ItemHumProxy.postUpdate(nHum)                                                                                       // Neue Feuchte in Proxy Item übernehmen
    ItemHumTendenz.postUpdate(strHumTendence)                                                                           // Tendenz Item setzen
                                                                                                                        // Kombiitem setzen
    var String strKombi = strTempTendence + " " + nTemp.toString + " °C / " + strHumTendence + " " + nHum.toString + " %" // Kombinierter String ohne Shutter
    if(ItemShutter !== null)                                                                                            // Falls es ein passendes Shutteritem gibt
        strKombi = ItemShutter.state.toString + "% /" + strKombi                                                        // füge den Shutterstatus vorne an
    ItemKombi.postUpdate(strKombi)                                                                                      // Setze das Kombiitem
end
Die Rule triggert ja schon auf alle Rollershutter.
Nun muss die Rule entscheiden, ob sie durch einen Sensor oder einen Shutter getriggert wurde. Im ersten Fall tut sie, was sie schon vorher tat...
Im 2. Fall ermittelt sie durch eine 2. Hashmap den Sensor zum Shutter. Falls es keinen gibt (Ergebnis null) muss die Bearbeitung abgebrochen werden.
Ansonsten kennt die Rule nun den zugehörigen Sensor zum bewegten Shutter und kann die Werte neu bestimmen.
openHAB4.3.5 stable in einem Debian-Container (bookworm) (Proxmox 8.4.1, LXC), mit openHABian eingerichtet

Antworten