In Rule Item.state aus variablem Item-Name abfragen

[TorstenE]

Hallo Mitstreiter

Ich mach es ganz kurz

Code: Alles auswählen

...
var MeinItemName = "Esszimmer_Lampe_01_Brightness"

var ItemState = (MeinItemName).state
...

Das o.g. Beispiel funktioniert nicht, wie bekomme ich am einfachsten den State aus "Esszimmer_Lampe_01_Brightness" in die Variable "ItemState" ?

Danke

Torsten

[udo1toni]

Ganz kurz:
Mit der DSL so gar nicht.

Vorausgesetzt, alle betreffenden Items befinden sich in einer Gruppe, kannst Du es so lösen:

Code: Alles auswählen

...
var MeinItemName = "Esszimmer_Lampe_01_Brightness"

var ItemState = gGroupItem.members.filter[i|i.name == MeinItemName].head.state
...

es dürfte aber ohnehin elegantere Wege für die eigentliche Aufgabe geben - sobald ein Itemname in einem String gespeichert wird, um diesen Itemnamen anschließend zu nutzen, riecht es nach Verbesserungspotential

[TorstenE]

Hallo Udo,

ich stell mal die ganze Situation hier "ungefiltert" rein.
Es geht darum, Szenen in OH umzusetzen.
Im Prinzip werden einfach die State's der Items gesichert und beim Aufruf der Szene als Vorgabe herangezogen.
Natürlich können die einzelnen Werte auch über die UI angepasst werden.
Die ursprüngliche Lösung ist von hier: https://community.openhab.org/t/3-diffe ... b/42859/38

Der 2. Code-Block beschreibt eine "Szene".
Eine Szene besteht also aus einem
- Group-Item um alle Items der Szene zusammen zu halten.
- Switch um die Szene-Werte zu sichern
- Switch um die Szene auszulösen

Items, welche die Werte der States speichern.

Im untersten Code-Block werden die Items, welche beim "ausführen" der Szene "aktiviert" werden sollen praktisch im kompletten
Model (hier: "Grundstueck" gesucht, da diese ja "irgendwo" verstreut sein könnten.
Deshalb die Frage, ob die Items auch direkt angesprochen werden können.

Einfach fragen, wenn etwas unklar ist.

Torsten

Code: Alles auswählen

Group gScenes "Szenen"

Group gScenesStore     "Szenen Sichern"
Group gScenesExecute   "Szenen Ausführen"
Group gScenesItems     "Szenen Items"

Code: Alles auswählen

// "Szene Morgen" 
Group SceneMorgen              "Szene Morgen - Konfiguration"  (gScenes)

// Switch zum Sichern der    "Szene Morgen"
Switch SceneMorgen_Store   "Szene Morgen - Sichern"        (gScenesStore) ["Switchable"]

// Switch zum Ausführen der "Szene Morgen"
Switch SceneMorgen_Execute "Szene Morgen - Ausführen"      (gScenesExecute) ["Switchable"] {ga="Switch"[name="Morgen", roomHint="Szenen"]}

// Items der "Szene "Morgen", welche die States für die auszuführenden Items sichern
Dimmer SceneMorgen_Esszimmer_Lampe_01_Brightness     "Szene Morgen - Esszimmer Licht Helligkeit"  (SceneMorgen, gScenesItems)
Switch SceneMorgen_Bar_Steckdose_02_Control          "Szene Morgen - Bartisch Steckdose"          (SceneMorgen, gScenesItems)
Dimmer SceneMorgen_Wohnzimmer_Lampe_05_Brightness    "Szene Morgen - Wohnzimmer Stehlampe oben"   (SceneMorgen, gScenesItems)
Dimmer SceneMorgen_Wohnzimmer_Lampe_06_Brightness    "Szene Morgen - Wohnzimmer Stehlampe unten"  (SceneMorgen, gScenesItems)
Dimmer SceneMorgen_Bar_Lampe_01_Brightness           "Szene Morgen - Bar Deckenlicht Helligkeit"  (SceneMorgen, gScenesItems)
Switch SceneMorgen_Flur_Schalter_01_Control          "Szene Morgen - Flur Deckenlicht"            (SceneMorgen, gScenesItems)

Code: Alles auswählen

rule "Szene ausführen"
when
    Member of gScenesExecute received command ON
then

    // Stand: 18.12.2023

    // Führt die Szene aus, indem die Item-States in den SceneItems gesicherten werden

    // SceneMorgen_Esszimmer_Lampe_01_Control wurde als Scene-Item ermittelt, soll also einen
    // Wert sichern. Daraus ergibt sich auch das "State"-Item, von welchem der Wert gesichert 
    // werden soll
    //
    // Esszimmer_Lampe_01_Control => SceneMorgen_Esszimmer_Lampe_01_Control

    val String  SceneName = triggeringItem.name.split("_").get(0)
    val Integer SceneNameLength = SceneName.length

    // logInfo("Szene(e) ausführen", "SceneName \"{}\" ", SceneName)

    gScenesItems.members.filter[ i | i.name.split("_").get(0) == SceneName ].forEach[ i |

         val ItemName = i.name.substring(SceneNameLength + 1)
        // logInfo("Szene ausführen", "ItemName \"{}\" ", ItemName)
        if (i.state !== NULL) {
            (ItemName).sendCommand(i.state.toString)
        }
    ]

    triggeringItem.postUpdate(OFF)
end

Code: Alles auswählen

rule "Szene sichern"
when
	Member of gScenesStore received command ON
then
    // Sichert die einzelnen Werte der Items, welche zu dieser Szene gehören
    // Diese können auch in der UI manuell angepasst werden.

    // Der SzeneName wird aus Stringlänge "SceneMorgenConfig" ermittelt => "SceneMorgen"

    val String  SceneName = triggeringItem.name.split("_").get(0)
    val Integer SceneNameLength = SceneName.length

    // logInfo("Szene(e) sichern", "SceneName \"{}\" ", SceneName)

    // Durchläuft alle SceneItems, welche einen Item-Wert sichern sollen.
    // "SceneMorgen_Esszimmer_Lampe_01_Brightness", sichert den State von
    // "Esszimmer_Lampe_01_Brightnes"
    gScenesItems.members.filter[ i | i.name.split("_").get(0) == SceneName ].forEach[ i |

        // Generiert den zu sichernden Item-Name
        val ItemName = i.name.substring(SceneNameLength + 1)
        // logInfo("Szene(e) sichern", "ItemName zu sichern \"{}\" ", ItemName)

        // Ermittelt das Item (aus dem kompletten Model)
        var ItemState = Grundstueck.allMembers.filter[ y | y.name == ItemName].head.state

        if (ItemState !== NULL) {
            (i.name).sendCommand(ItemState.toString)
        }
    ]

    triggeringItem.postUpdate(OFF)
end

[udo1toni]

Was ich nicht so ganz verstehe: Wenn doch alle Items bereits in Gruppen organisiert sind, warum sammelst Du die Items nicht über diese Gruppen ein, sondern über eine Gruppe, auch alle möglichen anderen Items enthält?

Ich kann ja schon verstehen, dass man Szenen gerne verändern möchte, aber zumindest welche Items durch die Szene gesteuert werden, sollte eine fixe Sache sein und somit (in welcher Form auch immer) irgendwo konfiguriert sein, NICHT für Jeden über die UI, sondern vom Administrator festgelegt z.B. über Group Items und die Zugehörigkeit der Items zu diesen Gruppen.

Es gibt verschiedene Ansätze, Vergleichbares zu erreichen, eine Möglichkeit wäre z.B., für eine Szene einen Zeitpunkt zu speichern und beim Aufruf der Szene den Zeitpunkt zu wählen. Du nutzt dann die Persistence, um den Zustand aller Items zu diesem Zeitpunkt wiederherzustellen. Aber auch da muss natürlich für die Szene festgelegt sein, welche Items davon betroffen sind, und diese Zuordnung ist dann fix für diese Szene.

Eine weitere Frage, die mich an dieser Stelle immer umtreibt: Wie oft programmiert ihr die Szenen tatsächlich um? Ich nutze selbst Szenen seit 2006, weil mein Haus auf knx basiert, welches Szenensteuerung nativ beherrscht. Ich habe letztlich nur einen Raum (Wohnzimmer) in dem alle Lichtquellen über eine Szene innerhalb knx abgebildet sind. Die Szene kann mit verschiedenen Werten aufgerufen werden, für jeden Wert gibt es eine Taste, ich nutze von 32 möglichen aber nur drei, ich habe also drei Tasten, um drei Einstellungen der Szene aufzurufen. Dabei gilt, dass ein extra-langer Tastendruck auch zum Speichern des aktuellen Zustands auf dem Speicherplatz dienen kann, ich stelle also die gewünschte Beleuchtung ein, drücke die Taste extra lang und die Szene wird gespeichert.
Dieser extra lange Tastendruck kam in der Anfangszeit ab und zu zum Einsatz (mit ab und zu meine ich so was wie etwa zwei Mal im Jahr), zuletzt habe ich meine 12-Volt-Halogenlampen in der Decke gegen 230V-LED-Lampen ausgetauscht. In der Folge hat sich die Dimmerkurve (extrem) geändert, so dass ich also vor knapp vier Jahren mal wieder extra lange auf die Tasten gedrückt habe. Ansonsten werden die Szenen bei Bedarf aufgerufen, und das geschieht durchaus mehrfach täglich. Vor dem Umbau hatte ich die Szenen zuletzt ca. 2014 angefasst, weil ich da die Christbaumbeleuchtung mit in die Szenen integriert habe. Alles in allem kann ich also aus meiner Erfahrung sagen, dass die Szenen super statisch sind, statt täglich mehrfach acht Lichtschalter au immer die gleiche Weise zu bedienen, rufe ich eine Szene auf, in der diese acht Lichtquellen schon mit der richtigen Helligkeit hinterlegt sind, und da ändert sich auch nix.
Ich habe noch weitere Stellen, an denen ich Szenensteuerung verwende, das ist die Position der Rollläden bei der Beschattung. Aber auch da gilt: einmal eingestellt, ändert sich daran so gut wie nie mehr etwas.

Das heißt für mich auf openHAB bezogen: In meinen Augen lohnt der Aufwand für eine UI-gesteuerte Änderung von Szenen nicht. Ich als Administrator lege fest, welche Lichtquellen in einer Szene enthalten sind, außerdem lege ich fest, welche Helligkeiten angesteuert werden sollen. Beides kann ich auch auf Zuruf von einer Person, die etwas geändert haben möchte tun, die Person muss das nicht selbst können (wäre auch unpraktisch, weil dann vielleicht "meine" Szene plötzlich anders gestaltet ist als von mir gewohnt)

[TorstenE]

Hallo Udo,

dachte ich mir schon, dass so eine "Art" Antwort kommt. Den Ansatz, dass Szenen "fest definiert" sind, egal wie technisch
umgesetzt, habe ich auch zuerst gehabt. Dass diese wenn einmal festgelegt nicht mehr groß geändert werden ist auch klar.
Ich wollte die von mir aufgezeigt Lösung hier nochmal zeigen, wie einfach es ist, relativ schnell Szenen in OH umzusetzen ohne
viele Rules & Co. schreiben zu müssen. Auch um zu zeigen, dass Szenen nicht zwangsweise vom Admin zementiert werden.

Das KNX dies nativ kann ist klar. Ich bin mir aber noch nicht sicher ob ich die Szenen trotzdem über OH realisiere.
Auslöser für meine ganze Aktion ist dieser Video https://www.youtube.com/watch?v=ft53OjipEDo&t=1204s

Ich würde mich freuen, wenn sich noch mehr hier an einer Diskussion beteiligen.

Und Udo, es freut mich jedes mal über einen "anregenden und lehrreichen" Austausch mit Dir

In diesem Sinne an alle hier, Frohe Weihnachten

Torsten

[udo1toni]

Ja, aber auch in dem Video wird ja eine Administrationsoberfläche verwendet.
Du kannst in openHAB auch "ganz einfach" Szenen über die UI erstellen, seit OH4 gibt es ja sogar eine eigene Rubrik dafür. Szenen sind dann allerdings einfach nur Snapshots über eine festgelegte Gruppe von Items, das heißt, ich kann den aktuellen Wert dieser Items speichern und per Befehl wieder abrufen.
Wenn ein Nicht-Admin das können soll, sollte er zumindest ein rudimentäres Verständnis der dahinter liegenden Technik haben, oder er muss halt mit gewissen Einschränkungen leben (wie gesagt... knx Szenen -> langer Tastendruck speichert die aktuellen Werte, kurzter Tastendruck ruft die Szene auf. Welche Aktorkanäle an der Szene beteiligt sind, lässt sich aber nicht vom Anwender ändern, genau wie z.B. die Übergangszeiten. Ich habe bei mir auch Auf-/Abblendzeiten definiert, das hat natürlich nur bei Dimmern sichtbare Auswirkungen.

All das kann man auch mit openHAB abbilden, wenn es sein muss auch über einen langen Tastendruck auf einen Taster, aber ganz sicher nicht ohne Regeln, denn das ist Sinn und Zweck von Rules, es geht um Automation, hier also die Funktion automatisch alle Helligkeiten einer bestimmten Gruppe Aktoren zu speichern bzw. automatisch alle Helligkeitswerte wiederherzustellen, statt jeden Kanal einzeln von Hand einzustellen.

Oder man nutzt halt die vorhandene UI, allerdings dann die Administrationsseite, die ist für solche Dinge gedacht.

Frohe Weihnachten

[TorstenE]

Wow - fängt wie Weihnachten an

Die "Szene" in OH4 ist doch Klasse, das hatte ich mir noch gar nicht angesehen, habe noch
alte Szenen im Kopf. - Das reicht vollkommen aus.
So eine UI-Szene macht genau das, über was wir hier diskutieren, klopf ich meine Idee
gleich in die Tonne.

ABER:
Du weist schon welche Frage kommt.
Kann man diese Szenen auch über Files abbilden ?

UND:
Wie lässt sich so eine Scene aus einer Rule heraus auslösen ?

[udo1toni]

Zu Frage eins: Eher nicht (wäre jetzt ja auch so ziemlich das komplette Gegenteil von dem, was Du erreichen willst - oder anders: Szenen kannst Du als simple Rules schreiben, wenn Du sie als Text definieren willst - siehe oben...)

Zu Frage zwei: Du kannst eine UI Rule anlegen und dort die Szene aufrufen. Dieser Rule kannst Du ein Item als Trigger definieren. Schlussendlich kannst Du dieses Item über Deine Rule steuern.

Alternativ kannst Du in der Code Ansicht auch Trigger für Szenen definieren.

Und spätestens an dieser Stelle sollte klar sein, wie wenig sinnvoll das Ganze ist, denn all das geht und ging auch vorher schon über die "normalen" Rules, nur mit viel mehr Möglichkeiten. Steht halt nicht "Szene" dran, so what.

[TorstenE]

"So what" - scheint auch ein wenig so, dass es in OH einfach nicht ganz einheitlich zu geht.

Aber Du hast Rechte, die "normalen" Rules erfülle als einzige Lösung "alle" Kriterien.

[udo1toni]

"So what" - scheint auch ein wenig so, dass es in OH einfach nicht ganz einheitlich zu geht.

Das war vielleicht ein wenig flapsig Aber: Am Anfang war die Rule (höhö...) und das war es.
Anschließend kamen Leute ohne Ahnung (im openHAB Kontext) und beschwerten sich, dass es ja kein xy gäbe. Also wurde xy dazu erfunden. Man hätte natürlich auch eine Rule verwenden können, aber nun gibt es zusätzlich noch xy.
Es gibt massig Dinge, die tatsächlich nur schwer oder vielleicht sogar gar nicht mit Rules lösbar sind, aber es gibt halt auch jede Menge Dinge, die nur eingebaut wurden, damit openHAB offiziell eine Funktion bietet, die ein Konkurrenzprodukt bietet, obwohl openHAB das schon lange vorher konnte, nur halt nicht unter dem Namen (Szenen sind da nur ein Detail).

Es gab z.B. lange Zeit keine Möglichkeit, Timer über die UI zu erstellen, und ich war auch ein Anwender, der das anfangs doof fand. Der Gira HS bietet dafür eine schicke Oberfläche, also muss das doch wichtig sein...
Aber nein, die Wahrheit ist, dass das Gros der Anwender die Schaltuhren aus Analogzeiten so gewohnt ist, dass sie gar nicht in Betracht ziehen, dass diese nur eine Notlösung eines Problems darstellen. Da kommen dann Aussagen wie "übers Jahr geht die Sonne ja unterschiedlich auf, deshalb will ich die Schaltzeiten auch anpassen können!" und da fällt man echt vom Glauben ab, warum man dann überhaupt eine Zeitsteuerung nutzt, wo es doch um eine nach Helligkeit oder Sonnenstand geführte Steuerung gehen sollte (was openHAB nun mal perfekt beherrscht).
Aber in der Zwischenzeit ist auch das Geschichte und es gibt - Tada - Timer in der UI, zum Einstellen. Ging auch vorher mit Rules, war aber umständlich (wenn es denn über die UI zugänglich sein sollte). Wie oft wird das tatsächlich verwendet (also, die fertige Funktion, Zeiten über die UI einzustellen, nicht das Feature als solches)?
Und DAS ist der Grund, warum "das alles" in openHAB nicht so ganz einheitlich ist, weil Dinge nachgerüstet wurden, die zum Teil gar nicht gebraucht werden, weil es auch so schon geht.

Was hingegen wirklich sinnvoll ist, ist die UI, auch wenn ich selbst die Konfiguration über Textdateien absolut bevorzuge, und die "Endanwender UI" ist natürlich super flexibel mit all ihren Möglichkeiten.