Variablen für Schaltzeitpunkte im CuxD-Multi-Timer verwenden?

[werner07]

Guten Abend,
für eine Abwesenheitssimulation (AWS), die eine weitestgehend realistische Abfolge der Beleuchtungen realisiert, möchte ich den CuxD-Timer verwenden. Dazu möchte ich je Leuchte einige Einschaltzeitpunkte und die Dauer des Einschaltens definieren. Beide Werte sollen täglich pro Einschaltzeitpunkt variieren und deshalb als Variable definiert werden.

Den Schaltzeitpunkt um einen festen Wert zu verzögern ist mir nicht geglückt:
lt. Handbuch: S. 86 gilt: TIMER_SET string
„hh:mm:ss“ - auslösen um hh:mm:ss (absolut)
„+sss“ - akt. Timer um sss Sekunden erhöhen

dom.GetObject("CUxD.CUX2800001:1.TIMER_SET").State("18:18:00 +20"); !oder
dom.GetObject("CUxD.CUX2800001:1.TIMER_SET").State("18:24:00+20");

Der TIMER PRESET Eintrag sieht mit 18:18:00+20 richtig aus, aber keine Verzögerung der Auslösung
Alle anderen Versuche führen ebenfalls nicht weiter, meistens zu Syntax-Fehlern, z.B.:

dom.GetObject("CUxD.CUX2800001:1.TIMER_SET").State("12:59:00" "+20"); ! Syntax-Fehler
dom.GetObject("CUxD.CUX2800001:1.TIMER_SET").State("12:59:00"/"20"); ! keine Verzögerung, keine weitere Auslösung

Was mache ich falsch?
---------------------------------------------------------------------------------------------------------------------------
Mit dem nächsten Versuch, den Schaltzeitpunkt um einen Zufallswert zu verzögern war ich erfolgreicher:
lt. Handbuch S. 86 gilt: TIMER_SET string
„hh:mm:ss“ - auslösen um hh:mm:ss (absolut)
Erweiterung um Zufallswert:
„... rnnn*zzz“ - zufälliges Auslösen zwischen
<timer_set> und <timer_set>+nnn*zzz Sekunden. nnn
ist die zufällige Anzahl der Zeitschritte mit der Länge
zzz.

dom.GetObject("CUxD.CUX2800001:1.TIMER_SET").State("19:16:00r10*5"); ! ok
! r10 = random Anzahl von Schritten, um die das Auslösen verzögert wird, hier 10 mal
! * (multipliziert) mit der "Schrittdauer", hier 5 sec

Das funktioniert und stimmt auch mit dem Eintrag bei TIMER_PRESET überein
-------------------------------------

Nun ergibt das Ganze natürlich erst Sinn, wenn mehrere Schaltzeitpunkte, d.h. der CuxD Multi-Timer eingesetzt wird.
lt. Handbuch S. 86 gilt: TIMER_SET string
Erweiterung um mehrere Timer-Bereiche:
Mehrere TIMER_SET Strings können getrennt durch
einen Schrägstrich / nacheinander gestartet werden.

Im Forum steht dankenswerterweise statt des / immer | womit es auch funktioniert:

dom.GetObject("CUxD.CUX2800001:1.TIMER_SET").State("19:23:00r10*4|19:24:00r10*5|19:25:00r10*3|19:26:00r10*2");

Die Schaltzeitpunkte wurden mit +16, +50, +27, +18 sec Verzögerung ausgeführt, das sieht gut aus
--------------------------------------------------------------------------------------------

Jetzt sollen die Schaltzeitpunkte und Zufallswerte für die Verzögerungen als Variable eingesetzt werden, zunächst für einen Schaltzeitpunkt:

string random = "r8"; ! Maximale Anzahl Schritte der Verzögerung
string schritt = "*10"; ! Schrittlänge in sec inkl. Multiplikationszeichen *
object schalt = "19:45:00"; !Schaltzeitpunkt (frühester)

dom.GetObject("CUxD.CUX2800001:1.TIMER_SET").State(schalt #random #schritt);
WriteLine(schalt #random #schritt); ! ok 1, 0, 7 Schritte mal 10 sec Verzögerung

Ausgabe
19:45:00r8*10 ! stimmt mit TIMER_PRESET überein, scheint zu funktionieren
--------------------------------------------------------------------------------------

Für einen Schaltzeitpunkt scheint das kein Problem zu sein. Beim Einsatz mehrerer Schaltpunkte (z.B. 3) im Multi-Timer scheitere ich allerdings:

string random1 = "r8"; ! Maximale Anzahl Schritte der Verzögerung
string random2 = "r20"; ! Maximale Anzahl Schritte der Verzögerung
string random3 = "r6"; ! Maximale Anzahl Schritte der Verzögerung

string schritt = "*10"; ! Schrittlänge in sec

object schalt1 = "19:54:00"; !Auslösezeitpunkt (frühester)
object schalt2 = "19:55:00"; !Auslösezeitpunkt (frühester)
object schalt3 = "19:56:00"; !Auslösezeitpunkt (frühester)

dom.GetObject("CUxD.CUX2800001:1.TIMER_SET").State(schalt1 #random1 #schritt|schalt2 #random2 #schritt|schalt3 #random3 #schritt);

WriteLine(schalt1 #random1 #schritt); ! im TIMER_PRESET: 19:54:00r819*1
WriteLine(schalt2 #random2 #schritt);
WriteLine(schalt3 #random3 #schritt); ! keine

Ausgabe
19:54:00r8*10
19:55:00r20*10
19:56:00r6*10

Während in der Ausgabe des Skripts sinnvolle Werte angezeigt werden, wird im TIMER_PRESET der WebUI ziemlicher Unsinn angezeigt, z.B. hier 19:54:00r819*1 ! Verschiedene weitere Versuche haben leider auch keine brauchbaren Ergebnisse gezeigt.

Falls das wichtig ist, getestet habe ich mit folgendem "Programm":

Was mache oder denke ich falsch, oder ist der Multi-Timer nicht dafür geeignet mit Variablen zu arbeiten?
Über sachdienliche Hinweise würde ich mich sehr freuen!

Viele Grüße
Werner07

[uwe111]

Hallo,

Der TIMER PRESET Eintrag sieht mit 18:18:00+20 richtig aus, aber keine Verzögerung der Auslösung

Nein, so einen Wert gibt es nicht. Wenn der Startzeitpunkt absolut ist, dann errechne ihn und setze einfach "18:18:20".
Versuche bitte zuerst, die Beispiele in der CUxD Doku zu verstehen.

dom.GetObject("CUxD.CUX2800001:1.TIMER_SET").State("18:18:00 +20"); !oder
dom.GetObject("CUxD.CUX2800001:1.TIMER_SET").State("18:24:00+20");

Wenn Du das wirklich vor hast, müsste es so aussehen:

Code: Alles auswählen

dom.GetObject("CUxD.CUX2800001:1.TIMER_SET").State("18:18:00");
dom.GetObject("CUxD.CUX2800001:1.TIMER_SET").State("+20");

Im Forum steht dankenswerterweise statt des / immer | womit es auch funktioniert:

dom.GetObject("CUxD.CUX2800001:1.TIMER_SET").State("19:23:00r10*4|19:24:00r10*5|19:25:00r10*3|19:26:00r10*2");

Der | ist als Trennzeichen obsolet. Richtig wäre:

Code: Alles auswählen

dom.GetObject("CUxD.CUX2800001:1.TIMER_SET").State("19:23:00r10*4/19:24:00r10*5/19:25:00r10*3/19:26:00r10*2");

Während in der Ausgabe des Skripts sinnvolle Werte angezeigt werden, wird im TIMER_PRESET der WebUI ziemlicher Unsinn angezeigt, z.B. hier 19:54:00r819*1 !

Weil Du in Deinem Script genau diesen Wert setzt.

Was mache oder denke ich falsch, oder ist der Multi-Timer nicht dafür geeignet mit Variablen zu arbeiten?
Über sachdienliche Hinweise würde ich mich sehr freuen!

Dein Fehler liegt im Zusammenfügen der Teilstrings per HM-Script. Das kannst Du eigentlich ganz einfach per WriteLine() testen.

Viele Grüße

Uwe

[werner07]

Hallo Uwe,

vielen Dank für Deine schnelle Antwort und dass Du Deine Zeit dafür verwendet hast!

Habe jetzt den gesamten Sonntag damit verbracht, intensiv nach einer Lösung für das Addieren zweier Zeitpunkte bzw. eines Zeitpunkts und einer Zeitdauer zu suchen (also rechnen mit "eigenen", nicht systeminternen Zeiten). Ich habe nicht ein einziges simples Beispiel für diese vermutlich simple Aufgabe gefunden. Hinweise im Forum an andere, es könnte an der Deklaration oder Initialisierung liegen, haben nicht weiter geholfen. Die Skript-Dokumentation reicht für mich definitiv nicht aus. Kannst Du - oder ein anderer Profi - mir da nochmal helfen?

Sollte das Problem gelöst sein, bin ich zuversichtlich, auch die restlichen Schwierigkeiten zu meistern. Die Zusammensetzung des Strings für Zeitpunkt und Verzögerung im Multi-Timer werde ich ersetzen durch eine vorgelagerte Berechnung (wenn ich ich dann weiß wie`s geht )!. Deinen Hinweis, WriteLine zum Testen zu benutzen habe ich nicht verstanden - im Beispiel zeigt WriteLine exakt das gewünschte Ergebnis. Nur im TIMER_PRESET steht was anderes? Ich kann es jedenfalls nicht interpretieren. Oder gibt es da etwa schon eine bekannte Lösung?

Viele Grüße
werner07

[uwe111]

Deinen Hinweis, WriteLine zum Testen zu benutzen habe ich nicht verstanden - im Beispiel zeigt WriteLine exakt das gewünschte Ergebnis. Nur im TIMER_PRESET steht was anderes?

Ich meinte z.B. so:

Code: Alles auswählen

...
string timerstring = schalt1 # random1 # schritt # "/" # schalt2 # random2 # schritt # "/" # schalt3 # random3 # schritt;
dom.GetObject("CUxD.CUX2800001:1.TIMER_SET").State(timerstring);
WriteLine(timerstring);

Viele Grüße

Uwe

[werner07]

Hallo Uwe,

vielen Dank für den zündenden Hinweis, bin total happy! Ohne wäre ich wohl nie drauf gekommen. Nach ein wenig probieren ist mein erster "dynamischer" Anwesenheitssimulator jetzt am Start. Wenn er sich jetzt auch noch so verhält, wie vorher mit EXCEL simuliert ...

Zwar benötige ich jetzt aktuell nicht mehr das Wissen um die Addition von Zeiten, aber es wurmt mich doch, da nicht dahinter zu kommen. Und irgendwann holt mich die Frage wieder ein:

Code: Alles auswählen

string time1 = "15:40:00";
string time2 = "00:50:30";
string timeS = time1 + time2;
WriteLine(timeS);   ! ergibt 15:40:0000:50:30.

Soweit klar, mit Strings ist schlecht rechnen.
Gefunden hatte ich:

Code: Alles auswählen

! Zeiten aus Stringvariable berechnen
! v0.1 (c) by Alchy
dom.GetObject(ID_SYSTEM_VARIABLES).State("12:30:00t");
dom.GetObject(ID_SYSTEM_VARIABLES).State("00:45:00");

object oEin = dom.GetObject(ID_SYSTEM_VARIABLES).Get("Wasser_Einschaltzeitpunkt"); ! Variable enthaelt string im Format 

"HH:MM:SS"
WriteLine(oEin);
object oDauer = dom.GetObject(ID_SYSTEM_VARIABLES).Get("Wasser_Einschaltdauer_Kreis_1");! Variable enthaelt string im 

Format "HH:MM:SS"
WriteLine(oDauer);
if( (oEin) && (oDauer)){
string ein = oEin.Value(); 
string dauer = oDauer.Value(); 
string res = (((("1970-01-01 " # ein ).ToTime() + (("1970-01-01 " #dauer).ToTime() + 3600))).Format("%H:%M:%S"));
WriteLine("Einschaltdauer endet um " #res #" Uhr");
}else{WriteLine("Variablen nicht vorhanden");}

Da ich mit den Variablen nicht klargekommen bin (die Variablen habe ich angelegt, aber das Skript hat sie nie als vorhanden erkannt), habe ich mal probiert, das Skript zu vereinfachen:

Code: Alles auswählen

object oEin = "12:00:00";     ! Variable enthaelt string im Format "HH:MM:SS"
WriteLine(oEin);                     ! 12:00:00	ok
object oDauer = "00:45:00";! Variable enthaelt string im Format "HH:MM:SS"
WriteLine(oDauer);                ! 00:45:00	ok
if( (oEin) && (oDauer)){         ! scheint mir eine Abfrage, ob die Variablen existieren zu sein?
string ein = oEin.Value();
WriteLine("ein " #ein);            ! ein 1970-01-01 00:59:59  ???         
string dauer = oDauer.Value();
WriteLine("dauer " #dauer);    ! dauer 1970-01-01 00:59:59   ???
string res = (((("1970-01-01 " # ein ).ToTime() + (("1970-01-01 " #dauer).ToTime() + 3600))).Format("%H:%M:%S"));
WriteLine("Einschaltdauer endet um " #res #" Uhr");  ! Einschaltdauer endet um 02:00:00 Uhr
}else{WriteLine("Variablen nicht vorhanden");}

Ausgabe:
12:00:00
00:45:00
ein 1970-01-01 00:59:59
dauer 1970-01-01 00:59:59
Einschaltdauer endet um 02:00:00 Uhr

Das ist offensichtlich nicht geglückt. Ja, wenn man auch nicht versteht, was da eigentlich passiert...

Bitte: Vielleicht würden ein paar zusätzliche Kommentare oder die Zerlegung in Teilschritte zum leichteren Verständnis verhelfen? Aufgeben würde ich ungern!

Nochmal tausend Dank und viele Grüße
werner07

[uwe111]

Zwar benötige ich jetzt aktuell nicht mehr das Wissen um die Addition von Zeiten, aber es wurmt mich doch, da nicht dahinter zu kommen.

Das findest Du hier: viewtopic.php?f=43&t=42113

Viele Grüße

Uwe

[werner07]

Hallo Uwe,
danke für den Link, auf den ich bei meiner Suche auch gestoßen war, der mir aber nicht wirklich geholfen hat.

Wonach ich bisher gesucht habe, war die Darstellung der Zeit als Zahl zum Rechnen im Gegensatz zur Darstellung als Zeichenkette (String). Wie z.B. bei EXCEL: Für den 1.1.2008 18:00 wäre 39448,74 ein für Rechenoperationen geeigneter Wert. Datum: 39448 = DATWERT("01.01.2008"), Zeit: 0,75 = ZEITWERT("18:00:00").

Bei HM-Skript scheint es, ähnlich wie bei Unix eine 32bit-Integerzahl zu geben, mit der jeder Zeitpunkt zwischen dem 1.1.1970 0 Uhr und dem 1.1.2037 sekundengenau angegeben werden kann (Teil 1 Sprachbeschreibung). Im Unterschied zu Unix wird die Zeitvariable aber immer als String dargestellt, egal ob sie vom Typ time (Zahl) oder string (Zeichenkette) ist:
string t = 2008-12-24 18:30:00 ! ist die absolute Zeit-Angabe (im Datumraum 1970-2037) als Zeichenkette
time t = @2008-12-24 18:00:00@ ! ist diesselbe absolute Zeit-Angabe (intern als Zahl), die allerdings nie als reiner Zahlwert zu sehen ist
Der Unix Zeitstempel in sec. wäre z.B.: 1230138000 www.unixtime.de/
! Wichtig zu wissen ist, dass der Zeitstempel 1970-01-01 00:00:00 als Integer den Wert -3600 (also nicht etwa 0) ergibt.
! D.h. dieser Betrag muss beim Ergebnis entsprechend berücksichtigt werden

Damit kann man mit gewissen Einschränkungen rechnen. Es interessiert hier aber nicht ein absoluter Zeitpunkt mit Datum und Uhrzeit sondern das Rechnen mit relativen Zeiten. Das kann eine Uhrzeit (ohne Datum) oder eine Zeitdauer sein.

Code: Alles auswählen

string ts1 = "18:30:00";          ! so könnte eine Zeitangabe aussehen
WriteLine(ts1);                     ! ergibt 18:30:00
time tt1 = ts1.ToTime();    
WriteLine(tt1);                     ! ergibt als Variable Typ time  1970-01-01 00:59:59
                                           ! eigenartigerweise wird diese Zeit nicht einfach zum Jahr 1970-01-01 hinzugefügt. 
integer ti1 = tt1.ToInteger();
WriteLine(ti1);                     ! ergibt als Variable Typ integer dann den entsprechend falschen Wert -1             
                                           ! und damit nichts, womit weitergearbeitet werden könnte

Tatsächlich enthalten Variable vom Typ time also immer eine absolute Zeitangabe (Zeitpunkt mit Datum und Uhrzeit).
Der Wert der Variable muss deshalb immer innerhalb des Definitionsraumes sein. Um das sicherzustellen, wird das
heutige Datum (statt 1970-01-01) verwendet:

Code: Alles auswählen

string ts1 = "2018-11-29 18:30:00";
WriteLine(ts1);            ! ergibt 2018-11-29 18:30:00
time tt1 = ts1.ToTime(); 
WriteLine(tt1);            ! ergibt 2018-11-29 18:30:00
integer ti1 = ts1.ToTime().ToInteger(); ! Umwandlung in Integer in einem Schritt 
WriteLine(ti1);
Ausgabe:
2018-11-29 18:30:00
1543512600         ! ergibt einen Zahlenwert, der identisch mit Unix-Zeitstempel 1543512600 in sec ist.

Aus diesem Zeitstempel lassen sich die relative Uhrzeit (Zeitdauer) durch Zerlegen des Zeitpunktes filtern:

Code: Alles auswählen

string ts1 = "2018-11-29 18:30:10";
WriteLine(ts1);            ! ergibt 2018-11-29 18:30:10 bzw. intern 1543512610 Sekunden
time tt1 = ts1.ToTime(); 
WriteLine(tt1);
integer tistd2 = tt1.Hour();    !Extrahieren der Stunden als Integer
WriteLine(tistd2);              ! ergibt 18
integer timin2 = tt1.Minute();  !Extrahieren der Minuten als Integer
WriteLine(timin2);              ! ergibt 30
integer tisek2 = tt1.Second();  !Extrahieren der Sekunden als Integer  
WriteLine(tisek2);              ! ergibt 10

integer tsumme = (tistd2*60*60)+(timin2*60)+(tisek2); 
WriteLine(tsumme);         ! 66610  das ist der gesuchte Wert von 18:30:10 in Sekunden mit dem man jetzt rechnen kann  

Bleibt die Frage, wie kann man zwei relative Zeiten, addieren? Tatsächlich habe ich im Forum bisher keine Methode gefunden, wie man zwei Zeiten, die als Variable vorliegen, addiert. Es wird stets eine Zeit zu einem absoluten Datumspunkt (z.B. der Systemzeit) addiert und dann die zu addierende Zeit (vorher(offline) in Sekunden gewandelt) als Konstante addiert (z.B. viewtopic.php?f=43&t=42113).

! Ergänzen der Zeitangabe um das heutige Datum im Programm, um eine gültige time-Variable zu erhalten

Code: Alles auswählen

string ts10 = "18:30:00";                  ! **** Erste Zeitvariable ***** 
WriteLine(ts10);
string dath = system.Date("%F");           ! heutiges Datum als Hilfsvariable z.B. 2018-11-29)
WriteLine(dath);
string ts11 = dath #" " #ts10;
WriteLine(ts11);                           ! Zeitpunkt 2018-11-29 18:30:00

string ts20 = "02:30:20";                  ! **** Zweite Zeitvariable ****
WriteLine(ts20);
string ts21 = dath #" " #ts20;
WriteLine(ts21);                           ! Zeitpunkt 2018-11-29 02:30:20

integer ti11 = ts11.ToTime().ToInteger();  ! Umwandeln in time format
WriteLine(ti11);                           ! ergibt  1543512600

time tt1 = ts11.ToTime(); 
WriteLine(tt1);                 ! 2018-11-29 18:30:00
integer tistd1 = tt1.Hour();    !Extrahieren der Stunden als Integer
WriteLine(tistd1);              ! ergibt 18
integer timin1 = tt1.Minute();  !Extrahieren der Minuten als Integer
WriteLine(timin1);              ! ergibt 30
integer tisek1 = tt1.Second();  !Extrahieren der Sekunden als Integer  
WriteLine(tisek1);              ! ergibt 0

integer tisum1 = (tistd1*60*60)+(timin1*60)+(tisek1);
WriteLine(tisum1);              ! ergibt 66600       **** Erste Variable ****

time tt2 = ts21.ToTime(); 
WriteLine(tt2);                 ! 2018-11-29 02:30:20
integer tistd2 = tt2.Hour();    !Extrahieren der Stunden als Integer
WriteLine(tistd2);              ! ergibt 2
integer timin2 = tt2.Minute();  !Extrahieren der Minuten als Integer
WriteLine(timin2);              ! ergibt 30
integer tisek2 = tt2.Second();  !Extrahieren der Sekunden als Integer  
WriteLine(tisek2);              ! ergibt 20

integer tisum2 = (tistd2*60*60)+(timin2*60)+(tisek2);
WriteLine(tisum2);                   !  9020 Sekunden **** Zweite Variable ****

integer tiadd = tisum1 + tisum2;
WriteLine(tiadd);                    ! 75620  
integer tisub = tisum1 - tisum2;
WriteLine(tisub);                    ! 57580

! Jetzt müssen die beiden Ergebnis Variablen wieder in das gewünschte String Format
! zurückgewandelt werden. Dabei sind die oben erwähnten 3600 Sekunden wieder abzuziehen.

Code: Alles auswählen

time ttadd = tiadd.ToTime() - 3600;
WriteLine(ttadd);                    ! 1970-01-01 21:00:20
time ttsub = tisub.ToTime() - 3600;
WriteLine(ttsub);                    ! 1970-01-01 15:59:40

string tsadd = ttadd.Format("%H:%M:%S");
WriteLine(tsadd);                    ! 21:00:20  *** Ergebnis der Addition ***
string tssub = ttsub.Format("%H:%M:%S");
WriteLine(tssub);                    ! 15:59:40  *** Ergebnis der Subtraktion ***

Das war's. Zumindest lassen sich so zwei relative Zeitangaben addieren/substrahieren.
Sieht für mich sehr aufwendig aus, fast schon nach workaround. Falls jemand einen besseren
Weg kennt, oder diesen Weg raffiniert verkürzen kann, bitte gerne posten!

Viele Grüße
werner07

[werner07]

Hallo,
in dem letzten Beitrag hatte ich die Addition bzw. Subtraktion der 3600 Sekunden, bedingt durch die Umwandlungen, nicht berücksichtigt. Das ist jetzt korrigiert!
Viele Grüße
werner07

[Lampi]

Hallo,

eine Variante, die ich zum Teil verwende um mit Zeiten zu rechnen:

Code: Alles auswählen

string a = "2018-12-02 12:00:00";
string b = "1970-01-01 02:00:00";

WriteLine(a.ToTime()+b.ToTime());
WriteLine(a.ToTime()-b.ToTime());
WriteLine("");

time c = @2018-12-02 12:00:00@;
time d = @1970-01-01 02:00:00@;

WriteLine(c+d);
WriteLine(c-d);

Gruß

[werner07]

Hallo,

danke! Das sieht recht einfach aus. Welche Befehle müssten jetzt noch davor/danach eingefügt werden, wenn die Zeiten als Variable im string Format "12:00:00" und "01:00:00" vorliegen (also die Zeitdauern von einer Stunde und 12 Stunden, die ja addiert werden sollen)? Das Ergebnis sollte dann als string "13:00:00" bzw. "11:00:00" lauten.

Viele Grüße
werner07