Rules: Triggern von nur einem Zustand innerhalb der ".map" Datei (IR Fernbedienung)

[Tomzk]

Hallo Zusammen,

ich komme bei folgender Fragestellung leider nicht auf eine Lösung/ Umweg, bzw. ist meine Suche in der Foren vielleicht falsch:
Triggern eines bestimmten Transfomationzustands durch eine Rule


Hintergrund:
Ich habe mir mittels eines WEMOS (ESP8266) eine Infrarot Fernbedienung für meine TV Geräte gebaut. Angesteuert wird der WEMOS über MQTT.

Folgendes Setting war notwendig:

Things:

Code: Alles auswählen

	Thing topic Wemos_2 "IR" {
    	Channels:
	    	Type string : ircode 	    "IR Test"         	 [ commandTopic="IR_Control_1/cmd" ]
			Type number : reachable		"IR Wifi Signal"     [ stateTopic="IR_Control_1/status/LWT" ]
	}

Die Items dazu:

Code: Alles auswählen

String                IR_Control                       "IR Control"                                                           (gIR_Control)                           {channel="mqtt:topic:mosquitto:Wemos_2:ircode"}
String                Test_String                      "Test String"

Für das absetzten bestimmter IR-Befehle war eine Transformation im Zusammenspiel mit einer Rule notwendig:

Transform:

Code: Alles auswählen

0=IRSEND,NEC,0x400501FE,32
1=IRSEND,NEC,0x400510EF,32
2=IRSEND,NEC,0x400557A8,32
3=IRSEND,NEC,0x400550AF,32
4=IRSEND,NEC,0x4005708F,32
5=IRSEND,NEC,0x400556A9,32
6=IRSEND,NEC,0x400555AA,32
7=IRSEND,NEC,0x400520DF,32
8=IRSEND,NEC,0x400541BE,32
9=IRSEND,NEC,0x400530CF,32
10=IRSEND,NEC,0x400531CE,32
11=IRSEND,NEC,0x400540BF,32
12=IRSEND,NEC,0x400542BD,32
13=IRSEND,NEC,0x4005807F,32

Rule:

Code: Alles auswählen

// IR Control (WEMOS)

rule "proxy IR mqtt"
when
    Item Test_String received command
then
    IR_Control.sendCommand(transform("MAP", "ircodes.map", receivedCommand.toString))
end

Die Darstellung/ Befehlsausgabe über die Sitemap klappt wunderbar über ein "String dummy item", bei dem ich die entsprechenden Befehle per mapping definiere.

Sitemap:

Code: Alles auswählen

Frame label="Logitech Z906" icon="sound" {
        Text item=Test_String
		Switch item=Test_String mappings=[0="Power"] label=""
		Switch item=Test_String mappings=[1="Input"] label=""
		Switch item=Test_String mappings=[2="Mute"] label=""
		Switch item=Test_String mappings=[3="Level"] label=""
		Switch item=Test_String mappings=[4="Effect"] label=""
		Switch item=Test_String mappings=[5="Volume -"] label=""
		Switch item=Test_String mappings=[6="Volume +"] label=""
		Switch item=Test_String mappings=[7="Input 1",8="Musik",9="TV",10="Input 4",11="Input 5"] label=""
    }

Ich habe eine Rule zur Schaltung einer Szene in meinem Wohnzimmer. Hier werden verschiedene Geräte/ Steckdosen geschalte.
Kann ich in diese Rule einen Befehl einbauen, dass wenn die Rule geschaltet wird, nur ein bestimmter Befehlt aus der Tranformation Map über das Item an den WEMOS gesendet wird?
Benötige ich für jeden Befehl eine eigene .map oder verschiedenen Dummy Items, wobei hier das Problem wäre, dass doch alle Dummys aktuell auf die gleiche .map zugreifen würden?

Hier noch die Rule:

Code: Alles auswählen

rule "Szene TV"
when
    Item Szene_TV changed from OFF to ON    // Schalter zum aktivieren der Szene
then
    WZ_TVLampe.sendCommand(ON)
    ShellyPlugS_7A35C0_Power.sendCommand(ON)    //Fernseher

// !!!! XXXXXX Befehl zum einschalten der Anlage über IR (Mapping des Stings = 0="POWER") 

    Szene_TV.sendCommand(OFF)               // Wiederausschalten des Szenenswitchs

end

Danke für die Unterstützung.

Gruß
Tom

[PeterA]

Also eigentlich kannst Du auch einen "String" als Command senden.

Ich sende z.B. an meinen Denon AVR verschiedene Strings um die Inputs zu wählen:

Code: Alles auswählen

DenonAVRX2000_MainZone_InputSource.sendCommand("SAT/CBL")

Bei Dir könnte das z.B. so aussehen:

Code: Alles auswählen

rule "Szene TV"
when
    Item Szene_TV changed from OFF to ON    // Schalter zum aktivieren der Szene
then
    WZ_TVLampe.sendCommand(ON)
    ShellyPlugS_7A35C0_Power.sendCommand(ON)    	         //Fernseher
    IR_Control.sendCommand("IRSEND,NEC,0x400501FE,32") // !!!! XXXXXX Befehl zum einschalten der Anlage über IR (Mapping des Stings = 0="POWER") 
    Szene_TV.sendCommand(OFF)                                       // Wiederausschalten des Szenenswitchs

end

[Tomzk]

Ohje..

Danke Peter, es funktioniert. So simple aber genial.
Ich würde mal behaupten da stand ich auf dem Schlauch.

Gruß
Tom

[peter-pan]

...wie wär's noch mit einer kleinen Verzögerung zwischen Ein-und Ausschalten ?

Code: Alles auswählen

rule "Szene TV"
when
    Item Szene_TV changed from OFF to ON    // Schalter zum aktivieren der Szene
then
    WZ_TVLampe.sendCommand(ON)
    ShellyPlugS_7A35C0_Power.sendCommand(ON)    	         //Fernseher
    IR_Control.sendCommand("IRSEND,NEC,0x400501FE,32") // !!!! XXXXXX Befehl zum einschalten der Anlage über IR (Mapping des Stings = 0="POWER") 
//    Szene_TV.sendCommand(OFF)                                       // Wiederausschalten des Szenenswitchs
    createTimer(now.plusSeconds(5), [ |
    Szene_TV.sendCommand(OFF)                                          // Ausschalten nach 5 Sekunden
   ])
end

[Tomzk]

Sehr gute Idee, da bin ich gerade dran gewesen, da ich auch Warten muss bis die Geräte hochgefahren sind und entsprechend auf Befehle reagieren können.
Die Timer Konstellation funktioniert, sollte aber keine nicht bedachten Probleme geben?

Code: Alles auswählen

rule "Szene TV"
when
    Item Szene_TV changed from OFF to ON                       // Schalter zum aktivieren der Szene
then
    WZ_TVLampe.sendCommand(ON)
    ShellyPlugS_7A35C0_Power.sendCommand(ON)                   //Fernseher
    createTimer(now.plusSeconds (15))[|                        // Abwarten bis ESP hochgefahren ist
        IR_Control.sendCommand("IRSEND,NEC,0x400501FE,32")     // Logitech Z906 "Power" --> (ircodes.map)
        createTimer(now.plusSeconds (5))[|                     // Abwarten bis Anlage an ist  
            IR_Control.sendCommand("IRSEND,NEC,0x400530CF,32") // Logitech Z906 "Input 3/ TV" --> (ircodes.map)
        ]
    ]
    createTimer(now.plusSeconds (5))[|                         // Ausschalten nach 5 Sekunden
        Szene_TV.sendCommand(OFF)                              // Wiederausschalten des Szenenswitchs
    ]
end

[peter-pan]

..nö. Ich bin zwar kein Experte, was die Timer anbelangt, aber ich denke nicht, dass da Probleme entstehen könnten

[PeterA]

Fast... und Udo wird auch schimpfen
Einen Timer sollte man zu Beginn immer Initialisieren...
Und auch innerhalb der Rule Prüfen ob er schon läuft und ggf. die Rule vorzeitig Abbrechen und auch den Timer wenn notwendig
Abbrechen und "nullen"

Siehe bei meinem letzten Projekt hier:

viewtopic.php?p=25132#p25132

Code: Alles auswählen

// globale Variablen zu Beginn der Datei definieren
var Timer tCheck = null                                                     // Timer für Receivercheck
var Integer iTry = 1                                                        // Zähler Startversuche

rule "Satreceiver Startup Check"
when
    Item ShellyPlugS_06 changed to ON                                       // SAT eingeschaltet
then
    if (ShellyPlugS_05_Proxy.state!=ON) {                                   // Wenn Denon nicht an, Abbruch
    logInfo("satreceiver","Denon noch nicht eingeschaltet, Abbruch.")
        return;
    }
    logInfo("satreceiver","Coolstream eingeschaltet, warte auf hochfahren.")
    if(tCheck !== null)                                                      // Timer läuft bereits
        return;                                                              // also Abbruch
    iTry = 1                                                                 // Zähler initialisieren
    tCheck = createTimer(now.plusSeconds(180), [|                            // lege Timer an
        if(ShellyPlugS_06.state==ON)  {                                      // Falls Receiver An
            if(CoolstreamTime.toString.contains("offline")){                 // Falls Offline
                iTry = iTry + 1                                              // Zähler erhöhen
                logInfo("satreceiver","Coolstream offline, schalte aus.")
                logInfo("satreceiver","{}. Versuch in 10 Sekunden.",iTry)
                ShellyPlugS_06.sendCommand(OFF)                              // Receiver OFF
                tCheck.reschedule(now.plusSeconds(10))                       // und in 10 Sekunden einschalten
            } else {                                                         // Falls Online
                tCheck = null                                                // Timer löschen
            }
        } else if(iTry < 4){                                                 // Falls Receiver Aus und noch nicht Maximum erreicht
            ShellyPlugS_06.sendCommand(ON)                                   // Receiver ON
            logInfo("satreceiver","Coolstream {}. Startversuch.",iTry)
            tCheck.reschedule(now.plusSeconds(180))                          // und in 180 Sekunden erneut prüfen
        } else {
            logWarn("satreceiver","Coolstream: Kein weiterer Startversuch!")
            sendBroadcastNotification("Satreceiver Startup: Coolstream ist nicht sauber hochgefahren" + " um " + now.toString("HH:mm") + " Uhr") //Allgemeine Warnung an alle 
            tCheck = null                                                      // Timer löschen
        }
    ])
end

[udo1toni]

[Tomzk]

Okey ich habe eine Globale Variable in meiner Ruledatei. Benutze sie dann scheinbar aber nicht.

Würde bedeuten ein einfaches createTimer... funktioniert, sollte aber durch den als globale Variable benannten Timer ersetzt werden, sprich wenn

// Globale Variablen
var Timer timer=null

dann timer = createTimer ....

Würde im Umkehrschluss heißen ich müsste wenn ich Timer im Timer habe mehrere definieren?
Ich habe es mal mit .reschedule.... probiert, da bin ich allerdings in ein endlos Loop gelandet.

Ist es richtig, dass man .reschedule nur verwendet, wenn man in einen Loop will und entsprechende if/ else mit Bedingungen verknüpft hat?

Oder gibt es eine andere Möglichkeit Timer x Sekunden mach y, nach weiteren x Sekunden mache z.
Und habe ich einen definierten Timer genullt, so kann ich diesen wiederverwenden?

mal mein Versuch:

Code: Alles auswählen

// Globale Variablen
var Timer timer=null
var Timer timer2=null

rule "Szene TV"
when
    Item Szene_TV changed from OFF to ON                       // Schalter zum aktivieren der Szene
then
    WZ_TVLampe.sendCommand(ON)
    ShellyPlugS_7A35C0_Power.sendCommand(ON)                   //Fernseher
    timer = createTimer(now.plusSeconds (15))[|                        // Abwarten bis ESP hochgefahren ist
        IR_Control.sendCommand("IRSEND,NEC,0x400501FE,32")     // Logitech Z906 "Power" --> (ircodes.map)
        timer2 = createTimer(now.plusSeconds (5))[|                     // Abwarten bis Anlage an ist  
            IR_Control.sendCommand("IRSEND,NEC,0x400530CF,32") // Logitech Z906 "Input 3/ TV" --> (ircodes.map)
            timer2 = null
        ]
    timer = null
    ]
    timer = createTimer(now.plusSeconds (5))[|                         // Ausschalten nach 5 Sekunden
        Szene_TV.sendCommand(OFF)                              // Wiederausschalten des Szenenswitchs
        timer = null
    ]
end

PS, ich sollte das Thema in "Allgemeines zu Timer" umbenennen , sorry Jungs aber danke für die Unterstützung

[udo1toni]

Benutze möglichst keine generischen Namen als Variablen. timer und timer2 sind zwar durchaus erlaubt, aber eben nichtssagend. tLicht oder tTreppenlicht hingegen sind sprechend. das t zu Beginn zeigt dann an, dass es sich um eine Timer Variable handelt. Das ist aber nur meine Art der Definition, das kannst Du natürlich handhaben wie Du willst.

Ein reschedule macht genau das, es plant den bestehenden Timer erneut ein. Wozu Du das verwendest, bleibt Dir überlassen.

Ich nutze reschedule gerne für Ablaufsteuerungen der Art: 1. Schritt tue dies, dann warte x Sekunden, 2. Schritt tue jenes, warte y Sekunden, 3. Schritt prüfe ob a erfüllt ist und wenn nicht tue das, warte z Sekunden, 4. Schritt mache dasda ...
Das geht sehr einfach mit einem Timer und einer globalen Zählvariable. Bei jedem Timerdurchlauf wird die Variable hochgezählt. Abhängig vom Variablenwert passiert bei jedem Timerdurchlauf etwas anderes.
Vorteil: Man benötigt nur einen Timer und eine Zählvariable, kann aber in der "Startrule" problemlos prüfen,ob der Timer bereits läuft und gegebenenfalls bestimmte Maßnahmen einleiten (sei es, dass man den Time zunächst cancelt oder dass man die Rule abbricht)