YAWN – Yet Another anWesenheitssimulatioN

HMside · Beitrag von **HMside** » 26.09.2017, 16:44

Ich habe mir hier nicht alles durchgelesen, aber sofern das gewünschte log-File künftig unter /var/log/ abgelegt wird, sollte auch das verschicken möglich sein. Alternativ sollte es auch mit dem anlegen eines Links von /usr/local/etc/config/addons/www/email nach /tmp/ klappen.

ak1 · Beitrag von **ak1** » 26.09.2017, 20:33

HMside hat geschrieben:Ich habe mir hier nicht alles durchgelesen, aber sofern das gewünschte log-File künftig unter /var/log/ abgelegt wird, sollte auch das verschicken möglich sein. Alternativ sollte es auch mit dem anlegen eines Links von /usr/local/etc/config/addons/www/email nach /tmp/ klappen.

Danke für das Feedback. Ich bekomme es aber leider trotzdem nicht hin. Ich habe zwei Test-Log-Files nach /var/log/ kopiert, die dann auch unter /etc/config/addons/www/email/log/ zu finden sind.

Code: Alles auswählen

# pwd
/etc/config/addons/www/email/log
# ls
YAWN.269.log              lighttpd-access.log       messages
YAWN.269.log.txt          lighttpd-access.log.1.gz  messages.0
email.log                 lighttpd-error.log        ntpclient
hmserver.log              lighttpd-error.log.1.gz
# ls /var/log
YAWN.269.log              lighttpd-access.log       messages
YAWN.269.log.txt          lighttpd-access.log.1.gz  messages.0
email.log                 lighttpd-error.log        ntpclient
hmserver.log              lighttpd-error.log.1.gz
# /etc/config/addons/email/email 06

#

Wenn der Pfad zum Log-File meiner E-Mail Vorlage 06

Code: Alles auswählen

/etc/config/addons/www/email/log/YAWN.269.log

oder

Code: Alles auswählen

/etc/config/addons/www/email/log/YAWN.269.log.txt

ist, dann funktioniert es nicht.
Bei

Code: Alles auswählen

/etc/config/addons/www/email/log/hmserver.log

geht es sehr wohl.

Habe ich Dich missverstanden, oder sollte es so eigentlich funktionieren?

Danke
ak1

HMside · Beitrag von **HMside** » 27.09.2017, 07:45

ak1 hat geschrieben: Habe ich Dich missverstanden, oder sollte es so eigentlich funktionieren?

Sorry das klappt so leider doch noch nicht. Folgende Änderung bzw. Ergänzung der Datei

Code: Alles auswählen

/usr/local/etc/config/addons/email/email

ist erfolgreich. Zeile 129 bis 133

Code: Alles auswählen

if {$AttName == "messages"} {
    set AttNewName "CCU-Logfile-$date.log"
} elseif {$AttName == "hmserver.log"} {
set AttNewName "hmserver-$date.log"
}

Erweiterung durch:

Code: Alles auswählen

if {$AttName == "messages"} {
    set AttNewName "CCU-Logfile-$date.log"
} elseif {$AttName == "hmserver.log"} {
set AttNewName "hmserver-$date.log"
} else {set AttNewName $AttName}

Sofern die zu versendende Datei weiterhin unter /tmp/ liegt, braucht es zumdem einen Link.

Code: Alles auswählen

ln -s /tmp/ /usr/local/etc/config/addons/www/email/tmp/

ak1 · Beitrag von **ak1** » 27.09.2017, 21:06

Besten Dank!

Ich habe das email Skript entsprechend Deinen Vorgaben angepasst. Außerdem habe ich im TCL-Skript für das Schreiben des Logs den Pfad auf /var/log/ geändert.
Bei meinen ersten Tests funktionierte jetzt soweit alles. Mal sehen, ob der zeitgesteuerte Versand des Logfiles in den nächsten Tagen reibungslos funktioniert.

Nochmals: Danke für die Unterstützung!

ak1

honeoe · Beitrag von **honeoe** » 04.03.2018, 17:42

Hallo mal wieder,

obwohl ich vor geraumer Zeit gemeldet hatte, YAWN würde auch bei mir sauber laufen, stimmte da noch etwas nicht: der Timer wurde immer auf 5 Sekunden aufgezogen. Letztlich hat es so zwar alle Aktionen getriggert, aber sauber geht anders.

Daher habe ich mich jetzt noch einmal dran gesetzt, nachgeschaut und gebastelt. Es will aber einfach nicht laufen.

Stand jetzt:
1. Twilight.tcl - läuft dauerhaft und schreibt vollständige Logs bzw. setzt alle Systemvariablen korekt
2. Freier_Tag - läuft einwandfrei und schreibt die korrekten Werte in die Systemvariablen
3. calcActionTimes - läuft seit der Korrektur in 2016 und schreibt vollständige Logs bzw. setzt alle Systemvariablen korekt
4. LogMe.tcl - läuft einwandfrei, da Logs aus den manuellen Aufrufen dereinzelnen ActionPrg in die YAWN.xxx.log geschrieben worden sind

5. triggerActions - läuft noch nicht korekt, in CUx sehe ich die Ermittlung von Zufallszahlen, aber der Timer wird nicht gesetzt und das Log nicht geschrieben

6. ActionPrg - habe ich mittlerweile bereits 17 Stück angelegt, manuelle Auslösung führt die Aktion korrekt aus und schreibt das zugehörige Log, ohne Triger funktioniert nur die Automatik nicht
7. MailLogFile.tcl - es wird keine Mail versendet, darum kümmere ich mich später, die Lösung steht je schon hier im Forum

Zentrales Problem ist demnach triggerActions.

Code: Alles auswählen

    ! #############################################################

    ! Yet Another anWesenheitssimulatioN (YAWN)

    ! TriggerActions
    ! V1.1

    ! by Splunge

    ! #############################################################

    ! Beschreibung:
    ! Durchläuft die aktuelle Zeiten- und Aktionsliste
    ! Das erste Element ist das aktuelle Element. Dessen Aktion soll
    ! als nächstes ausgeführt werden. Dazu wird eine Systemvariable auf
    ! den entsprechenden Wert gesetzt. Dies triggert das entsprechende
    ! Programm
    ! Alle anderen Elemente werden in temporäre Listen geschrieben,
    ! die am Ende wieder in die Umgebungsvariablen für die Zeiten- und
    ! Aktionsliste geschrieben werden.
    ! Die Zeit der nächsten Aktion wird vorab bestimmt. Ist die gleich der
    ! Zeit der aktuellen Aktion, wird der Timer nicht auf diese Uhrzeit
    ! eingestellt, sondern auf 5 Sekunden.

    ! #############################################################

    ! Änderungen:
    ! V1.1: Fehlerkorrektur Kommentar in Zeile 104

    ! #############################################################

    ! Systemvoraussetzungen:
    ! - CUxD muss installiert sein (als Gerät muss der Timer eingerichtet sein)
    ! - LogMe.tcl muss vorhanden sein, wenn Logging verwendet werden soll

    ! #############################################################

    ! Ausführungszeitpunkt des Skriptes:
    ! wird durch den CUxD-Timer getriggert, wenn eine Aktion ansteht.

    ! #############################################################

    ! Umgebungsvariablen, die benötigt werden
    !
    ! lesend:
    ! "YAWN_ZeitenListe" (Typ Zeichenkette)
    ! "YAWN_AktionsListe" (Typ Zeichenkette)
    ! "YAWN_LogLevel" (Typ Integer - 0 bis 3)

    ! schreibend:
    ! "YAWN_LetzteAktion" (Typ Zahl)
    ! "YAWN_ZeitenListe" (Typ Zeichenkette)
    ! "YAWN_AktionsListe" (Typ Zeichenkette)
    ! #############################################################

    ! Variablendefinition
    string sortedTimes;         ! sortierte Werteliste
    string sortedActions;      ! sortierte Aktionsliste
    string currentAction;    ! aktuelle Aktion
    integer i;                     ! Schleifenindex
    string sepr = ",";         ! Listentrennzeichen
    string actValue;            ! aktueller Wert der unsortierten Liste
    integer currentTime;      ! aktuelle Aktionszeit
    integer nextTime;            ! nächste Aktionszeit
    string tmpTimes = "";      ! Hilfsliste für die Werte
    string tmpActions = "";   ! Hilfsliste für die Aktionen
    integer tmpStd;               ! Hilsvariable zur Berechnung der Tagessekunden
    integer tmpMin;               ! Hilsvariable zur Berechnung der Tagessekunden
    integer tmpSek;               ! Hilsvariable zur Berechnung der Tagessekunden
    integer tmpJetzt;            ! Enthält den aktuellen Zeitpunkt in Tagessekunden
    string timerWert;            ! Weckzeit für das nächste Ereignis
    integer LogLevel;            ! Level des Loggings (0 = Nichts, 1 = Aktionen, 2 = Berechnung und Aktionen, 3 = Alles)
    string logtext = "YAWN-Trigger gestartet..." # " _nl_ ";   ! Logtext
    boolean bRetrigger;         ! Merker, ob die aktuelle Aktion erneut getriggert werden muss, z.B. auf Grund einer Fehltriggerung dieses Skriptes

    sortedTimes = dom.GetObject('YAWN_ZeitenListe').State();
    sortedActions = dom.GetObject('YAWN_AktionsListe').State();
    LogLevel = dom.GetObject('YAWN_LogLevel').State();

    ! jetzige Uhrzeit ermitteln
    tmpStd = system.Date("%H").ToInteger();
    tmpMin = system.Date("%M").ToInteger();
    tmpSek = system.Date("%S").ToInteger();
    tmpJetzt = (tmpStd * 3600) + (tmpMin * 60) + tmpSek;

    ! alle Werte der aktuellen Liste durchlaufen
    if (sortedTimes.Length() > 0)
    {
       i = 0;
       bRetrigger = false;
       foreach(actValue,sortedTimes.Split(sepr))
       {
          ! Beim ersten Element die Zeit und Aktion als aktuelle Werte speichern
          if (i == 0)
          {
             currentTime = actValue.ToInteger();
             currentAction = sortedActions.StrValueByIndex(sepr,i);
			 
             ! Liegt die aktuelle Aktion im richtigen Zeitfenster (früher als jetzt plus max. 30 Sekunden)?
             if (currentTime <= tmpJetzt + 30)
             {
                ! Aktuelle Aktion triggern, indem die Systemvariable "YAWN_LetzteAktion" neu gesetzt wird.
                dom.GetObject('YAWN_LetzteAktion').State(currentAction.ToInteger());
				
                if (LogLevel >= 3)
                {
 				   logtext = logtext # "Aktion " # currentAction # " um " # currentTime # " getriggert..." # " _nl_ ";
                }
             }
             else
             {
                ! Ansonsten wahrscheinlich Fehltriggerung (zu früh). Aktion wieder in Liste aufnehmen und als nächste Aktion setzen
                nextTime = actValue.ToInteger();
                bRetrigger = true;
                	
				if (LogLevel >= 3)
                {
 				   logtext = logtext # "Aktion zu früh getriggert..." # " _nl_ ";
                }
				
                if (tmpTimes.Length() == 0)
                {
                   ! beim ersten Element noch kein Listentrennzeichen hinzufügen
                   tmpTimes = actValue;
                   tmpActions = sortedActions.StrValueByIndex(sepr,i);
                }
                else
                {
                   tmpTimes = tmpTimes # sepr # actValue;
                   tmpActions = tmpActions # sepr # sortedActions.StrValueByIndex(sepr,i);
                }
		     }
          }
          else
          {
             ! Beim zweiten Element die Zeit für die nächste Aktion speichern, wenn es keine Retriggerung gibt.
             if ((i == 1) && (bRetrigger == false))
             {
                nextTime = actValue.ToInteger();
             }
             
             ! ab dem zweiten Element die Zeiten und Aktionen in eine temporäre Liste speichern. Dies wird die neue Aktionsliste
             if (tmpTimes.Length() == 0)
             {
                ! beim ersten Element noch kein Listentrennzeichen hinzufügen
                tmpTimes = actValue;
                tmpActions = sortedActions.StrValueByIndex(sepr,i);
             }
             else
             {
                tmpTimes = tmpTimes # sepr # actValue;
                tmpActions = tmpActions # sepr # sortedActions.StrValueByIndex(sepr,i);
             }
             
          }
         i = i + 1;
       }
       
       ! Um aktuelles Element reduzierte Listen wieder in Systemvariablen zurückschreiben
       dom.GetObject('YAWN_ZeitenListe').State(tmpTimes);
       dom.GetObject('YAWN_AktionsListe').State(tmpActions);
       if (LogLevel >= 3)
       {
          logtext = logtext # "Neue Aktionszeiten: " # tmpTimes # " _nl_ ";
          logtext = logtext # "Neue Aktionenliste: " # tmpActions # " _nl_ ";
       }
       
       ! Timer für die nächste Aktion aufziehen
       if (nextTime == currentTime)
       {
          ! Wenn die nächste Aktion zum gleichen Zeitpunkt wie die aktuelle stattfinden soll,
          ! dann nicht den Timer auf die Uhrzeit einstellen, sondern auf 5 Sekunden aufziehen.
          ! So wird sichergestellt, dass die Systemvariable für die aktuelle Aktion verarbeitet
          ! werden kann
          dom.GetObject("CUxD.CUX2800002:2.TIMER_SET").State(5);
		  
          if (LogLevel >= 3)
          {
             logtext = logtext # "nächste Aktion zum gleichen Zeitpunkt: " # nextTime # "=" # currentTime # " => Timer neu aufgezogen auf 5 Sekunden" # " _nl_ ";
          }
       }
       else
       {
          if (nextTime > currentTime)
          {
             ! Timer auf nächste Uhrzeit einstellen
             tmpStd = nextTime/3600;
             tmpMin = (nextTime%3600)/60;
             tmpSek = nextTime%60;
          
             timerWert = tmpStd.ToString() # ":" # tmpMin.ToString() # ":" # tmpSek.ToString();
             
             dom.GetObject("CUxD.CUX2800002:2.TIMER_SET").State(timerWert);
			 
             if (LogLevel >= 3)
             {
                logtext = logtext # "nächste Aktion um: " # nextTime # " => Timer neu aufgezogen auf: " # timerWert # " _nl_ ";
             }
          }
       }
    }
	else
	{
		if (LogLevel >= 3)
             {
                logtext = logtext # "um: " # tmpJetzt # " _nl_ " # "YAWN_Zeitenliste jedoch leer" # " _nl_ ";
             }
	}

    ! ##############################################################
    ! Logfile wegschreiben
    if (LogLevel >= 3)
    {
       dom.GetObject("CUxD.CUX2801001:1.CMD_EXEC").State("/bin/tclsh /usr/local/addons/TCL/LogMe.tcl YAWN 1 "# logtext);
    }

Die Klickibunti (HM-WebUI) gibt dazu kein Fehler aus.

Auch das CUxD-Syslog zeigt nichts an.

Code: Alles auswählen

Mar  4 16:47:05 homematic-ccu2 daemon.debug cuxd[782]: CUX2801001:1 /bin/tclsh /usr/local/addons/TCL/Twilight.tcl XX.XX X.XX 3 Rxxxxxhausen XxXxXxXxXxXxXxXx
Mar  4 16:51:06 homematic-ccu2 daemon.debug cuxd[918]: CUX2801001:1 /bin/tclsh /usr/local/addons/TCL/LogMe.tcl YAWN 1 Feiertags-Skript gestartet... _nl_ Ostern ist dieses Jahr am: 01.04.2018 _nl_ Dieses Jahr ist kein Schaltjahr ! _nl_ Es ist gerade Wochenende _nl_ Es ist heute d
Mar  4 16:52:19 homematic-ccu2 daemon.debug cuxd[973]: CUX2801001:2 hexdump -d -n 2  /dev/urandom
Mar  4 16:52:19 homematic-ccu2 daemon.debug cuxd[976]: CUX2801001:2 hexdump -d -n 2  /dev/urandom
Mar  4 16:52:19 homematic-ccu2 daemon.debug cuxd[979]: CUX2801001:2 hexdump -d -n 2  /dev/urandom
Mar  4 16:52:19 homematic-ccu2 daemon.debug cuxd[982]: CUX2801001:2 hexdump -d -n 2  /dev/urandom
Mar  4 16:52:20 homematic-ccu2 daemon.debug cuxd[986]: CUX2801001:2 hexdump -d -n 2  /dev/urandom
Mar  4 16:52:20 homematic-ccu2 daemon.debug cuxd[989]: CUX2801001:2 hexdump -d -n 2  /dev/urandom
Mar  4 16:52:20 homematic-ccu2 daemon.debug cuxd[992]: CUX2801001:2 hexdump -d -n 2  /dev/urandom
Mar  4 16:52:20 homematic-ccu2 daemon.debug cuxd[995]: CUX2801001:2 hexdump -d -n 2  /dev/urandom

Aber im "Full Syslog" von CUx finden sich folgende Einträge:

Code: Alles auswählen

Mar  4 16:52:21 homematic-ccu2 local0.err ReGaHss: Error: IseESP::ScriptRuntimeError:     ! #############################################################      ! Yet Another anWesenheitssimulatioN (YAWN)      ! CalcActionTimes     ! V1.1      ! by Splunge      ! ##############

Es muss also irgendein Problem zwischen 'triggerActions' und CUx geben - ich bin allerdings mit meinem Latein am Ende. Was könnte da jetzt sein?

Für eure Hilfe wäre ich wirklich sehr dankbar!

honeoe · Beitrag von **honeoe** » 06.03.2018, 21:26

hier noch das CalcActions-Skript das in der Fehlermeldung des CUx auftaucht:

Code: Alles auswählen

    ! CalcActionTimes (YAWN)
    ! created by Splunge,
    ! editied by honeoe

    ! #############################################################

    ! Variablendefinition

    ! Variablen für die Sonnenauf/untergangszeiten
    time SA_Buergerlich;   ! Absolute Zeit des bürgerlichen Sonnenaufgangs
    time SU_Buergerlich;   ! Absolute Zeit des bürgerlichen Sonnenuntergangs
    time SA_Aufgang;            ! Absolute Zeit des Indoor Sonnenaufgangs
    time SU_Untergang;            ! Absolute Zeit des Indoor Sonnenuntergang

    ! Variablen für die Zufallszahl
    string tmpRand;      ! Hilfsvariable für Zufallszahl (inkl. Modulo für aktuelle Aktion)
    integer RAND;         ! Zufallszahl für Vormittag bzw. Nachmittag

    ! Variablen für die Zeitberechnung
    boolean freierTag;
    integer tmpStd;               ! Hilsvariable zur Berechnung der Tagessekunden
    integer tmpMin;               ! Hilsvariable zur Berechnung der Tagessekunden
    integer tmpSek;               ! Hilsvariable zur Berechnung der Tagessekunden
    integer tmpStartTime;      ! Startzeitpunkt der aktuellen Aktion in Tagessekungen
    integer tmpLowerLimit;   ! Unteres Limit in Tagessekunden
    integer tmpUpperLimit;   ! Oberes Limit in Tagessekunden
    integer tmpIfBefore;      ! Bedingungenszeitpunkt "wenn vor Zeitpunkt" in Tagessekunden
    integer tmpIfAfter;         ! Bedingungszeitpunkt "wenn nach Zeitpunkt" in Tagessekunden
    integer tmpJetzt;            ! Enthält den aktuellen Zeitpunkt in Tagessekunden
    integer tmpTwilight;      ! Hilfsvariable für Dämmerungszeiten
    string actAktion;            ! Aktuell berechnete Aktion

    ! Variablen für das Sortieren
    string unsortedTimes = "";      ! unsortierte Werteliste
    string unsortedActions = "";   ! unsortierte Aktionsliste
    string tmpTimes;                     ! Hilfsliste für die Werte
    string tmpActions;                  ! Hilfsliste für die Aktionen
    string sepr = ",";                  ! Listentrennzeichen
    integer i;                              ! Schleifenindex
    integer minIndex;                  ! Index des minimalen Elementes
    string actValue;                     ! aktueller Wert der unsortierten Liste
    integer minValue;                     ! kleinster gefundener Wert
    string sortedTimes = "";         ! sortierte Werteliste
    string sortedActions = "";      ! sortierte Aktionsliste

    ! Variablen für die Timersteuerung
    string timerWert;      ! Weckzeit für das erste Ereignis

    ! Variablen für das Logging
    integer LogLevel;         ! Level des Loggings (0 = Nichts, 1 = Aktionen, 2 = Berechnung und Aktionen, 3 = Alles)
    string logtext = "Aktionszeiten-Berechnung gestartet..." # " _nl_ ";   ! Logtext

    ! Logging-Status holen
    LogLevel = dom.GetObject('YAWN_LogLevel').State();
	
    ! #############################################################

    ! Sonnenauf- und -untergangszeiten holen
    SA_Buergerlich = (dom.GetObject('Sekunden_SA_Buergerlich').State()).ToTime();
    SU_Buergerlich = (dom.GetObject('Sekunden_SU_Buergerlich').State()).ToTime();
    SA_Aufgang = (dom.GetObject('Sekunden_SA_Aufgang').State()).ToTime();
    SU_Untergang = (dom.GetObject('Sekunden_SU_Untergang').State()).ToTime();

    ! Information ob freier Tag (Wochenende, Feiertag) holen
    freierTag = dom.GetObject('Freier_Tag').State();

    ! jetzige Uhrzeit ermitteln
    tmpStd = system.Date("%H").ToInteger();
    tmpMin = system.Date("%M").ToInteger();
    tmpSek = system.Date("%S").ToInteger();
    tmpJetzt = (tmpStd * 3600) + (tmpMin * 60) + tmpSek;

	! Logging
    if (LogLevel >= 2)
    {
       logtext = logtext # "Zeit jetzt ist: " # tmpJetzt # " - " # system.Date("%H:%M:%S") # " _nl_ ";
	
	   tmpStd = SA_Buergerlich.Hour();
       tmpMin = SA_Buergerlich.Minute();
       tmpSek = SA_Buergerlich.Second();
       tmpTwilight = (tmpStd * 3600) + (tmpMin * 60) + tmpSek;
       logtext = logtext # "Beginn Aufgangs-Dämmerung Bürgerlich: " # tmpTwilight # " - " # SA_Buergerlich.Format("%H:%M:%S") # " _nl_ ";

       tmpStd = SA_Aufgang.Hour();
       tmpMin = SA_Aufgang.Minute();
       tmpSek = SA_Aufgang.Second();
       tmpTwilight = (tmpStd * 3600) + (tmpMin * 60) + tmpSek;
       logtext = logtext # "Sonnenaufgang: " # tmpTwilight # " - " # SA_Aufgang.Format("%H:%M:%S") # " _nl_ ";

       tmpStd = SU_Untergang.Hour();
       tmpMin = SU_Untergang.Minute();
       tmpSek = SU_Untergang.Second();
       tmpTwilight = (tmpStd * 3600) + (tmpMin * 60) + tmpSek;
       logtext = logtext # "Sonnenuntergang: " # tmpTwilight # " - " # SU_Untergang.Format("%H:%M:%S") # " _nl_ ";
       
       tmpStd = SU_Buergerlich.Hour();
       tmpMin = SU_Buergerlich.Minute();
       tmpSek = SU_Buergerlich.Second();
       tmpTwilight = (tmpStd * 3600) + (tmpMin * 60) + tmpSek;
       logtext = logtext # "Ende Untergangs-Dämmerung Bürgerlich: " # tmpTwilight # " - " # SU_Buergerlich.Format("%H:%M:%S") # " _nl_ ";
    }
	
    ! #############################################################

    ! *************************************************************
    ! Aktion 00 - EXT Außenlampe Hauseingang morgens an
    ! um SA_Buergerlich - 20min, frühestens um 05:00
    ! *************************************************************
    actAktion = "00";

    tmpStd = SA_Buergerlich.Hour();
    tmpMin = SA_Buergerlich.Minute();
    tmpSek = SA_Buergerlich.Second();
    tmpStartTime = (tmpStd * 3600) + (tmpMin * 60) + tmpSek;

    tmpStartTime = tmpStartTime - (20 * 60);
       
    tmpStd = 5;
    tmpMin = 0;
    tmpSek = 0;
    tmpLowerLimit = (tmpStd * 3600) + (tmpMin * 60) + tmpSek;
       
    if (tmpStartTime < tmpLowerLimit)
    {
       tmpStartTime = tmpLowerLimit;
    }

    ! Aktion nur hinzufügen, wenn sie frühestens in 10 Sekunden stattfindet
    if (tmpStartTime >= tmpJetzt + 10)
    {
       if (unsortedTimes.Length() == 0)
       {
          ! beim ersten Element noch kein Listentrennzeichen hinzufügen
          unsortedTimes = tmpStartTime.ToString();
          unsortedActions = actAktion;
       }
       else
       {
          unsortedTimes = unsortedTimes # sepr # tmpStartTime.ToString();
          unsortedActions = unsortedActions # sepr # actAktion;
       }
    }
	
    ! *************************************************************
    ! Aktion 01 - EXT Außenlampe Hauseingang morgens aus
    ! um SA_Aufgang + 10min
    ! *************************************************************
    actAktion = "01";

    tmpStd = SA_Aufgang.Hour();
    tmpMin = SA_Aufgang.Minute();
    tmpSek = SA_Aufgang.Second();
    tmpStartTime = (tmpStd * 3600) + (tmpMin * 60) + tmpSek;

    tmpStartTime = tmpStartTime + (10 * 60);
       
       ! Aktion nur hinzufügen, wenn sie frühestens in 10 Sekunden stattfindet
       if (tmpStartTime >= tmpJetzt + 10)
       {
          if (unsortedTimes.Length() == 0)
          {
             ! beim ersten Element noch kein Listentrennzeichen hinzufügen
             unsortedTimes = tmpStartTime.ToString();
             unsortedActions = actAktion;
          }
          else
          {
             unsortedTimes = unsortedTimes # sepr # tmpStartTime.ToString();
             unsortedActions = unsortedActions # sepr # actAktion;
          }
       }
	
    ! *************************************************************
    ! Zufallszahl ermitteln
    ! *************************************************************

    dom.GetObject("CUxD.CUX2801001:2.CMD_SETS").State("hexdump -d -n 2  /dev/urandom");
    dom.GetObject("CUxD.CUX2801001:2.CMD_QUERY_RET").State(1);
    string tmpRand = dom.GetObject("CUxD.CUX2801001:2.CMD_RETS").State();
    RAND = (tmpRand.Substr(10)).ToInteger();

    if (LogLevel >= 2)
    {
       logtext = logtext # "Zufallszahl für Aktion 2ff : " # RAND # " _nl_ ";
    }
	
    ! *************************************************************
    ! Aktion 02 - Licht EG abends an
    ! um SU_Untergang - 10min, + Zufall(20min)
    ! *************************************************************
    actAktion = "02";
    
    tmpStd = SU_Untergang.Hour();
    tmpMin = SU_Untergang.Minute();
    tmpSek = SU_Untergang.Second();
    tmpStartTime = (tmpStd * 3600) + (tmpMin * 60) + tmpSek;

    tmpStartTime = tmpStartTime - (10 * 60);
       
    tmpStartTime = tmpStartTime + ((RAND % 21)*60);
	       
       ! Aktion nur hinzufügen, wenn sie frühestens in 10 Sekunden stattfindet
       if (tmpStartTime >= tmpJetzt + 10)
       {
          if (unsortedTimes.Length() == 0)
          {
             ! beim ersten Element noch kein Listentrennzeichen hinzufügen
             unsortedTimes = tmpStartTime.ToString();
             unsortedActions = actAktion;
          }
          else
          {
             unsortedTimes = unsortedTimes # sepr # tmpStartTime.ToString();
             unsortedActions = unsortedActions # sepr # actAktion;
          }
       }
	
    ! *************************************************************
    ! Aktion 03 - Licht EG abends aus
    ! um 23:30, + Zufall(45min)
    ! *************************************************************
    actAktion = "03";
    
    tmpStd = 23;
    tmpMin = 30;
    tmpSek = 0;
    tmpStartTime = (tmpStd * 3600) + (tmpMin * 60) + tmpSek;
       
    tmpStartTime = tmpStartTime + ((RAND % 46)*60);
	       
       ! Aktion nur hinzufügen, wenn sie frühestens in 10 Sekunden stattfindet
       if (tmpStartTime >= tmpJetzt + 10)
       {
          if (unsortedTimes.Length() == 0)
          {
             ! beim ersten Element noch kein Listentrennzeichen hinzufügen
             unsortedTimes = tmpStartTime.ToString();
             unsortedActions = actAktion;
          }
          else
          {
             unsortedTimes = unsortedTimes # sepr # tmpStartTime.ToString();
             unsortedActions = unsortedActions # sepr # actAktion;
          }
       }
	
    ! *************************************************************
    ! Zufallszahl ermitteln
    ! *************************************************************

    dom.GetObject("CUxD.CUX2801001:2.CMD_SETS").State("hexdump -d -n 2  /dev/urandom");
    dom.GetObject("CUxD.CUX2801001:2.CMD_QUERY_RET").State(1);
    string tmpRand = dom.GetObject("CUxD.CUX2801001:2.CMD_RETS").State();
    RAND = (tmpRand.Substr(10)).ToInteger();

    if (LogLevel >= 2)
    {
       logtext = logtext # "Zufallszahl für Aktion 4ff : " # RAND # " _nl_ ";
    }
	
    ! *************************************************************
    ! Aktion 04 - Rolladen EG hinten morgens auf
    ! WT: um 06:15 + Zufall(20min)
    ! WE: um 08:00 + Zufall(20min)
    ! *************************************************************
    actAktion = "04";

    if (freierTag == false)
    {
       tmpStd = 6;
       tmpMin = 15;
       tmpSek = 0;
    }
    else
    {
       tmpStd = 8;
       tmpMin = 0;
       tmpSek = 0;
    }
    tmpStartTime = (tmpStd * 3600) + (tmpMin * 60) + tmpSek;

    tmpStartTime = tmpStartTime + ((RAND % 21)*60);

    ! Aktion nur hinzufügen, wenn sie frühestens in 10 Sekunden stattfindet
    if (tmpStartTime >= tmpJetzt + 10)
    {
       if (unsortedTimes.Length() == 0)
       {
          ! beim ersten Element noch kein Listentrennzeichen hinzufügen
          unsortedTimes = tmpStartTime.ToString();
          unsortedActions = actAktion;
       }
       else
       {
          unsortedTimes = unsortedTimes # sepr # tmpStartTime.ToString();
          unsortedActions = unsortedActions # sepr # actAktion;
       }
    }
	
    ! *************************************************************
    ! Aktion 05 - Rolladen EG vorne morgens auf
    ! WT: um 07:30 + Zufall(30min)
    ! WE: um 08:30 + Zufall(30min)
    ! *************************************************************
    actAktion = "05";

    if (freierTag == false)
    {
       tmpStd = 7;
       tmpMin = 30;
       tmpSek = 0;
    }
    else
    {
       tmpStd = 8;
       tmpMin = 30;
       tmpSek = 0;
    }
    tmpStartTime = (tmpStd * 3600) + (tmpMin * 60) + tmpSek;

    tmpStartTime = tmpStartTime + ((RAND % 31)*60);

    ! Aktion nur hinzufügen, wenn sie frühestens in 10 Sekunden stattfindet
    if (tmpStartTime >= tmpJetzt + 10)
    {
       if (unsortedTimes.Length() == 0)
       {
          ! beim ersten Element noch kein Listentrennzeichen hinzufügen
          unsortedTimes = tmpStartTime.ToString();
          unsortedActions = actAktion;
       }
       else
       {
          unsortedTimes = unsortedTimes # sepr # tmpStartTime.ToString();
          unsortedActions = unsortedActions # sepr # actAktion;
       }
    }
	
    ! *************************************************************
    ! Zufallszahl ermitteln
    ! *************************************************************

    dom.GetObject("CUxD.CUX2801001:2.CMD_SETS").State("hexdump -d -n 2  /dev/urandom");
    dom.GetObject("CUxD.CUX2801001:2.CMD_QUERY_RET").State(1);
    string tmpRand = dom.GetObject("CUxD.CUX2801001:2.CMD_RETS").State();
    RAND = (tmpRand.Substr(10)).ToInteger();

    if (LogLevel >= 2)
    {
       logtext = logtext # "Zufallszahl für Aktion 6ff : " # RAND # " _nl_ ";
    }
	
    ! *************************************************************
    ! Aktion 06 - Rolladen EG hinten abends zu
    ! um SU_Buergerlich + 15min, + Zufall(15min), frühestens 18:00
    ! *************************************************************
    actAktion = "06";

    tmpStd = SU_Buergerlich.Hour();
    tmpMin = SU_Buergerlich.Minute();
    tmpSek = SU_Buergerlich.Second();
    tmpStartTime = (tmpStd * 3600) + (tmpMin * 60) + tmpSek;

    tmpStartTime = tmpStartTime + (15 * 60);
       
    tmpStd = 18;
    tmpMin = 0;
    tmpSek = 0;
    tmpLowerLimit = (tmpStd * 3600) + (tmpMin * 60) + tmpSek;
       
    if (tmpStartTime < tmpLowerLimit)
    {
       tmpStartTime = tmpLowerLimit;
    }

    tmpStartTime = tmpStartTime + ((RAND % 16)*60);
	
    ! Aktion nur hinzufügen, wenn sie frühestens in 10 Sekunden stattfindet
    if (tmpStartTime >= tmpJetzt + 10)
    {
       if (unsortedTimes.Length() == 0)
       {
          ! beim ersten Element noch kein Listentrennzeichen hinzufügen
          unsortedTimes = tmpStartTime.ToString();
          unsortedActions = actAktion;
       }
       else
       {
          unsortedTimes = unsortedTimes # sepr # tmpStartTime.ToString();
          unsortedActions = unsortedActions # sepr # actAktion;
       }
    }
	
    ! *************************************************************
    ! Aktion 07 - Rolladen EG vorne abends zu
    ! WT: um SU_Buergerlich + 15min, frühestens um 22:00, + Zufall(30min)
    ! WE: um SU_Buergerlich + 15min, frühestens um 23:00, + Zufall(30min)
    ! *************************************************************
    actAktion = "07";

    tmpStd = SU_Buergerlich.Hour();
    tmpMin = SU_Buergerlich.Minute();
    tmpSek = SU_Buergerlich.Second();
    tmpStartTime = (tmpStd * 3600) + (tmpMin * 60) + tmpSek;

    tmpStartTime = tmpStartTime + (15 * 60);
	
    if (freierTag == false)
    {
       tmpStd = 22;
       tmpMin = 0;
       tmpSek = 0;
       tmpLowerLimit = (tmpStd * 3600) + (tmpMin * 60) + tmpSek;
    }
    else
    {
       tmpStd = 23;
       tmpMin = 0;
       tmpSek = 0;
       tmpLowerLimit = (tmpStd * 3600) + (tmpMin * 60) + tmpSek;
    }
	
    if (tmpStartTime < tmpLowerLimit)
    {
       tmpStartTime = tmpLowerLimit;
    }
    
	tmpStartTime = tmpStartTime + ((RAND % 31)*60);

    ! Aktion nur hinzufügen, wenn sie frühestens in 10 Sekunden stattfindet
    if (tmpStartTime >= tmpJetzt + 10)
    {
       if (unsortedTimes.Length() == 0)
       {
          ! beim ersten Element noch kein Listentrennzeichen hinzufügen
          unsortedTimes = tmpStartTime.ToString();
          unsortedActions = actAktion;
       }
       else
       {
          unsortedTimes = unsortedTimes # sepr # tmpStartTime.ToString();
          unsortedActions = unsortedActions # sepr # actAktion;
       }
    }
	
    ! *************************************************************
    ! Zufallszahl ermitteln
    ! *************************************************************

    dom.GetObject("CUxD.CUX2801001:2.CMD_SETS").State("hexdump -d -n 2  /dev/urandom");
    dom.GetObject("CUxD.CUX2801001:2.CMD_QUERY_RET").State(1);
    string tmpRand = dom.GetObject("CUxD.CUX2801001:2.CMD_RETS").State();
    RAND = (tmpRand.Substr(10)).ToInteger();

    if (LogLevel >= 2)
    {
       logtext = logtext # "Zufallszahl für Aktion 8ff : " # RAND # " _nl_ ";
    }
	
    ! *************************************************************
    ! Aktion 08 - Rollade Gäste morgens auf
    ! WT: um 07:30 + Zufall(30min)
    ! WE: um 08:30 + Zufall(30min)
    ! *************************************************************
    actAktion = "08";

    if (freierTag == false)
    {
       tmpStd = 7;
       tmpMin = 30;
       tmpSek = 0;
    }
    else
    {
       tmpStd = 8;
       tmpMin = 30;
       tmpSek = 0;
    }
    tmpStartTime = (tmpStd * 3600) + (tmpMin * 60) + tmpSek;

    tmpStartTime = tmpStartTime + ((RAND % 31)*60);

    ! Aktion nur hinzufügen, wenn sie frühestens in 10 Sekunden stattfindet
    if (tmpStartTime >= tmpJetzt + 10)
    {
       if (unsortedTimes.Length() == 0)
       {
          ! beim ersten Element noch kein Listentrennzeichen hinzufügen
          unsortedTimes = tmpStartTime.ToString();
          unsortedActions = actAktion;
       }
       else
       {
          unsortedTimes = unsortedTimes # sepr # tmpStartTime.ToString();
          unsortedActions = unsortedActions # sepr # actAktion;
       }
    }
	
    ! *************************************************************
    ! Aktion 09 - Rollade Gäste abends zu
    ! um SU_Buergerlich + 15min, + Zufall(15min), frühestens 18:00
    ! *************************************************************
    actAktion = "09";

    tmpStd = SU_Buergerlich.Hour();
    tmpMin = SU_Buergerlich.Minute();
    tmpSek = SU_Buergerlich.Second();
    tmpStartTime = (tmpStd * 3600) + (tmpMin * 60) + tmpSek;

    tmpStartTime = tmpStartTime + (15 * 60);
       
    tmpStd = 18;
    tmpMin = 0;
    tmpSek = 0;
    tmpLowerLimit = (tmpStd * 3600) + (tmpMin * 60) + tmpSek;
       
    if (tmpStartTime < tmpLowerLimit)
    {
       tmpStartTime = tmpLowerLimit;
    }

    tmpStartTime = tmpStartTime + ((RAND % 16)*60);
	
    ! Aktion nur hinzufügen, wenn sie frühestens in 10 Sekunden stattfindet
    if (tmpStartTime >= tmpJetzt + 10)
    {
       if (unsortedTimes.Length() == 0)
       {
          ! beim ersten Element noch kein Listentrennzeichen hinzufügen
          unsortedTimes = tmpStartTime.ToString();
          unsortedActions = actAktion;
       }
       else
       {
          unsortedTimes = unsortedTimes # sepr # tmpStartTime.ToString();
          unsortedActions = unsortedActions # sepr # actAktion;
       }
    }
	
    ! *************************************************************
    ! Aktion 10 - Rollade Kind links morgens auf
    ! WT: um 07:30 + Zufall(30min)
    ! WE: um 09:30 + Zufall(30min)
    ! *************************************************************
    actAktion = "10";

    if (freierTag == false)
    {
       tmpStd = 7;
       tmpMin = 30;
       tmpSek = 0;
    }
    else
    {
       tmpStd = 9;
       tmpMin = 30;
       tmpSek = 0;
    }
    tmpStartTime = (tmpStd * 3600) + (tmpMin * 60) + tmpSek;

    tmpStartTime = tmpStartTime + ((RAND % 31)*60);

    ! Aktion nur hinzufügen, wenn sie frühestens in 10 Sekunden stattfindet
    if (tmpStartTime >= tmpJetzt + 10)
    {
       if (unsortedTimes.Length() == 0)
       {
          ! beim ersten Element noch kein Listentrennzeichen hinzufügen
          unsortedTimes = tmpStartTime.ToString();
          unsortedActions = actAktion;
       }
       else
       {
          unsortedTimes = unsortedTimes # sepr # tmpStartTime.ToString();
          unsortedActions = unsortedActions # sepr # actAktion;
       }
    }
	
    ! *************************************************************
    ! Aktion 11 - Rollade Kind links abends zu
    ! um 20:00 + Zufall(20min)
    ! *************************************************************
    actAktion = "11";

    tmpStd = 20;
    tmpMin = 0;
    tmpSek = 0;

    tmpStartTime = (tmpStd * 3600) + (tmpMin * 60) + tmpSek;

    tmpStartTime = tmpStartTime + ((RAND % 21)*60);

    ! Aktion nur hinzufügen, wenn sie frühestens in 10 Sekunden stattfindet
    if (tmpStartTime >= tmpJetzt + 10)
    {
       if (unsortedTimes.Length() == 0)
       {
          ! beim ersten Element noch kein Listentrennzeichen hinzufügen
          unsortedTimes = tmpStartTime.ToString();
          unsortedActions = actAktion;
       }
       else
       {
          unsortedTimes = unsortedTimes # sepr # tmpStartTime.ToString();
          unsortedActions = unsortedActions # sepr # actAktion;
       }
    }
	
    ! *************************************************************
    ! Zufallszahl ermitteln
    ! *************************************************************

    dom.GetObject("CUxD.CUX2801001:2.CMD_SETS").State("hexdump -d -n 2  /dev/urandom");
    dom.GetObject("CUxD.CUX2801001:2.CMD_QUERY_RET").State(1);
    string tmpRand = dom.GetObject("CUxD.CUX2801001:2.CMD_RETS").State();
    RAND = (tmpRand.Substr(10)).ToInteger();

    if (LogLevel >= 2)
    {
       logtext = logtext # "Zufallszahl für Aktion 12ff : " # RAND # " _nl_ ";
    }
	
    ! *************************************************************
    ! Aktion 12 - Licht Gäste abends an
    ! um SU_Untergang - 10min, + Zufall(20min)
    ! *************************************************************
    actAktion = "12";
    
    tmpStd = SU_Untergang.Hour();
    tmpMin = SU_Untergang.Minute();
    tmpSek = SU_Untergang.Second();
    tmpStartTime = (tmpStd * 3600) + (tmpMin * 60) + tmpSek;

    tmpStartTime = tmpStartTime - (10 * 60);
       
    tmpStartTime = tmpStartTime + ((RAND % 21)*60);
	       
       ! Aktion nur hinzufügen, wenn sie frühestens in 10 Sekunden stattfindet
       if (tmpStartTime >= tmpJetzt + 10)
       {
          if (unsortedTimes.Length() == 0)
          {
             ! beim ersten Element noch kein Listentrennzeichen hinzufügen
             unsortedTimes = tmpStartTime.ToString();
             unsortedActions = actAktion;
          }
          else
          {
             unsortedTimes = unsortedTimes # sepr # tmpStartTime.ToString();
             unsortedActions = unsortedActions # sepr # actAktion;
          }
       }
	
    ! *************************************************************
    ! Aktion 13 - Licht Gäste abends aus
    ! um 22:00, + Zufall(45min)
    ! *************************************************************
    actAktion = "13";
    
    tmpStd = 22;
    tmpMin = 0;
    tmpSek = 0;
    tmpStartTime = (tmpStd * 3600) + (tmpMin * 60) + tmpSek;
       
    tmpStartTime = tmpStartTime + ((RAND % 46)*60);
	       
       ! Aktion nur hinzufügen, wenn sie frühestens in 10 Sekunden stattfindet
       if (tmpStartTime >= tmpJetzt + 10)
       {
          if (unsortedTimes.Length() == 0)
          {
             ! beim ersten Element noch kein Listentrennzeichen hinzufügen
             unsortedTimes = tmpStartTime.ToString();
             unsortedActions = actAktion;
          }
          else
          {
             unsortedTimes = unsortedTimes # sepr # tmpStartTime.ToString();
             unsortedActions = unsortedActions # sepr # actAktion;
          }
       }
	
    ! *************************************************************
    ! Zufallszahl ermitteln
    ! *************************************************************

    dom.GetObject("CUxD.CUX2801001:2.CMD_SETS").State("hexdump -d -n 2  /dev/urandom");
    dom.GetObject("CUxD.CUX2801001:2.CMD_QUERY_RET").State(1);
    string tmpRand = dom.GetObject("CUxD.CUX2801001:2.CMD_RETS").State();
    RAND = (tmpRand.Substr(10)).ToInteger();

    if (LogLevel >= 2)
    {
       logtext = logtext # "Zufallszahl für Aktion 14ff : " # RAND # " _nl_ ";
    }
	
    ! *************************************************************
    ! Aktion 14 - Licht Kind links abends an
    ! um 18:00 + Zufall(20min)
    ! *************************************************************
    actAktion = "14";

    tmpStd = 18;
    tmpMin = 0;
    tmpSek = 0;

    tmpStartTime = (tmpStd * 3600) + (tmpMin * 60) + tmpSek;

    tmpStartTime = tmpStartTime + ((RAND % 21)*60);

    ! Aktion nur hinzufügen, wenn sie frühestens in 10 Sekunden stattfindet
    if (tmpStartTime >= tmpJetzt + 10)
    {
       if (unsortedTimes.Length() == 0)
       {
          ! beim ersten Element noch kein Listentrennzeichen hinzufügen
          unsortedTimes = tmpStartTime.ToString();
          unsortedActions = actAktion;
       }
       else
       {
          unsortedTimes = unsortedTimes # sepr # tmpStartTime.ToString();
          unsortedActions = unsortedActions # sepr # actAktion;
       }
    }
	
    ! *************************************************************
    ! Aktion 15 - Licht Kind links abends aus
    ! um 20:30 + Zufall(20min)
    ! *************************************************************
    actAktion = "15";

    tmpStd = 20;
    tmpMin = 30;
    tmpSek = 0;

    tmpStartTime = (tmpStd * 3600) + (tmpMin * 60) + tmpSek;

    tmpStartTime = tmpStartTime + ((RAND % 21)*60);

    ! Aktion nur hinzufügen, wenn sie frühestens in 10 Sekunden stattfindet
    if (tmpStartTime >= tmpJetzt + 10)
    {
       if (unsortedTimes.Length() == 0)
       {
          ! beim ersten Element noch kein Listentrennzeichen hinzufügen
          unsortedTimes = tmpStartTime.ToString();
          unsortedActions = actAktion;
       }
       else
       {
          unsortedTimes = unsortedTimes # sepr # tmpStartTime.ToString();
          unsortedActions = unsortedActions # sepr # actAktion;
       }
    }
	
    ! *************************************************************
    ! Zufallszahl ermitteln
    ! *************************************************************

    dom.GetObject("CUxD.CUX2801001:2.CMD_SETS").State("hexdump -d -n 2  /dev/urandom");
    dom.GetObject("CUxD.CUX2801001:2.CMD_QUERY_RET").State(1);
    string tmpRand = dom.GetObject("CUxD.CUX2801001:2.CMD_RETS").State();
    RAND = (tmpRand.Substr(10)).ToInteger();

    if (LogLevel >= 2)
    {
       logtext = logtext # "Zufallszahl für Aktion 16ff : " # RAND # " _nl_ ";
    }
	
    ! *************************************************************
    ! Aktion 16 - Rolladen Arbeit OG morgens auf
    ! WT: um 07:30 + Zufall(30min)
    ! WE: um 09:30 + Zufall(30min)
    ! *************************************************************
    actAktion = "16";

    if (freierTag == false)
    {
       tmpStd = 7;
       tmpMin = 30;
       tmpSek = 0;
    }
    else
    {
       tmpStd = 9;
       tmpMin = 30;
       tmpSek = 0;
    }
    tmpStartTime = (tmpStd * 3600) + (tmpMin * 60) + tmpSek;

    tmpStartTime = tmpStartTime + ((RAND % 31)*60);

    ! Aktion nur hinzufügen, wenn sie frühestens in 10 Sekunden stattfindet
    if (tmpStartTime >= tmpJetzt + 10)
    {
       if (unsortedTimes.Length() == 0)
       {
          ! beim ersten Element noch kein Listentrennzeichen hinzufügen
          unsortedTimes = tmpStartTime.ToString();
          unsortedActions = actAktion;
       }
       else
       {
          unsortedTimes = unsortedTimes # sepr # tmpStartTime.ToString();
          unsortedActions = unsortedActions # sepr # actAktion;
       }
    }
	
    ! *************************************************************
    ! Aktion 17 - Rolladen Arbeit OG abends zu
    ! um 22:30 + Zufall(30min)
    ! *************************************************************
    actAktion = "17";

    tmpStd = 22;
    tmpMin = 30;
    tmpSek = 0;

    tmpStartTime = (tmpStd * 3600) + (tmpMin * 60) + tmpSek;

    tmpStartTime = tmpStartTime + ((RAND % 31)*60);

    ! Aktion nur hinzufügen, wenn sie frühestens in 10 Sekunden stattfindet
    if (tmpStartTime >= tmpJetzt + 10)
    {
       if (unsortedTimes.Length() == 0)
       {
          ! beim ersten Element noch kein Listentrennzeichen hinzufügen
          unsortedTimes = tmpStartTime.ToString();
          unsortedActions = actAktion;
       }
       else
       {
          unsortedTimes = unsortedTimes # sepr # tmpStartTime.ToString();
          unsortedActions = unsortedActions # sepr # actAktion;
       }
    }
	
    ! *************************************************************
    ! Zufallszahl ermitteln
    ! *************************************************************

    dom.GetObject("CUxD.CUX2801001:2.CMD_SETS").State("hexdump -d -n 2  /dev/urandom");
    dom.GetObject("CUxD.CUX2801001:2.CMD_QUERY_RET").State(1);
    string tmpRand = dom.GetObject("CUxD.CUX2801001:2.CMD_RETS").State();
    RAND = (tmpRand.Substr(10)).ToInteger();

    if (LogLevel >= 2)
    {
       logtext = logtext # "Zufallszahl für Aktion 18ff : " # RAND # " _nl_ ";
    }
	
    ! *************************************************************
    ! Aktion 18 - Licht Arbeit OG abends an
    ! um 20:00 + Zufall(30min)
    ! *************************************************************
    actAktion = "18";

    tmpStd = 20;
    tmpMin = 0;
    tmpSek = 0;

    tmpStartTime = (tmpStd * 3600) + (tmpMin * 60) + tmpSek;

    tmpStartTime = tmpStartTime + ((RAND % 31)*60);

    ! Aktion nur hinzufügen, wenn sie frühestens in 10 Sekunden stattfindet
    if (tmpStartTime >= tmpJetzt + 10)
    {
       if (unsortedTimes.Length() == 0)
       {
          ! beim ersten Element noch kein Listentrennzeichen hinzufügen
          unsortedTimes = tmpStartTime.ToString();
          unsortedActions = actAktion;
       }
       else
       {
          unsortedTimes = unsortedTimes # sepr # tmpStartTime.ToString();
          unsortedActions = unsortedActions # sepr # actAktion;
       }
    }
	
    ! *************************************************************
    ! Aktion 19 - Licht Arbeit OG abends aus
    ! um 23:30 + Zufall(30min)
    ! *************************************************************
    actAktion = "19";

    tmpStd = 23;
    tmpMin = 30;
    tmpSek = 0;

    tmpStartTime = (tmpStd * 3600) + (tmpMin * 60) + tmpSek;

    tmpStartTime = tmpStartTime + ((RAND % 31)*60);

    ! Aktion nur hinzufügen, wenn sie frühestens in 10 Sekunden stattfindet
    if (tmpStartTime >= tmpJetzt + 10)
    {
       if (unsortedTimes.Length() == 0)
       {
          ! beim ersten Element noch kein Listentrennzeichen hinzufügen
          unsortedTimes = tmpStartTime.ToString();
          unsortedActions = actAktion;
       }
       else
       {
          unsortedTimes = unsortedTimes # sepr # tmpStartTime.ToString();
          unsortedActions = unsortedActions # sepr # actAktion;
       }
    }
	
    ! *************************************************************
    ! Aktion 20 - Licht DG abends aus
    ! um 23:30, + Zufall(45min)
    ! *************************************************************
    actAktion = "20";
    
    tmpStd = 23;
    tmpMin = 30;
    tmpSek = 0;
    tmpStartTime = (tmpStd * 3600) + (tmpMin * 60) + tmpSek;
       
    tmpStartTime = tmpStartTime + ((RAND % 46)*60);
	       
       ! Aktion nur hinzufügen, wenn sie frühestens in 10 Sekunden stattfindet
       if (tmpStartTime >= tmpJetzt + 10)
       {
          if (unsortedTimes.Length() == 0)
          {
             ! beim ersten Element noch kein Listentrennzeichen hinzufügen
             unsortedTimes = tmpStartTime.ToString();
             unsortedActions = actAktion;
          }
          else
          {
             unsortedTimes = unsortedTimes # sepr # tmpStartTime.ToString();
             unsortedActions = unsortedActions # sepr # actAktion;
          }
       }
	
    ! ##############################################################

    ! Zeiten und Aktionen chronologisch (aufsteigend) sortieren

    while (unsortedTimes.Length() > 0)
    {
       ! Suchhilfen initialisieren
       minValue = 2147483647;   ! Integer-Maximalwert
       minIndex = 0;
       i = 0;
       ! Werteliste durchlaufen und aktuellen Listenwert ermitteln
       foreach(actValue,unsortedTimes.Split(sepr))
       {
          ! Ist der aktuelle Listenwert kleiner als der aktuelle Minimalwert?
          if (actValue.ToInteger() < minValue)
          {
             ! dann Wert und Index zwischenspeichern
             minValue = actValue.ToInteger();
             minIndex = i;
          }
        i = i + 1;
       }
       
       ! Nach Durchlaufen der Werteliste, das Ergebnis wegschreiben und die zu sortierende Werteliste aktualisieren
       
       ! Ergebnis wegschreiben
       if (sortedTimes.Length() == 0)
       {
          ! beim ersten Element noch kein Listentrennzeichen hinzufügen
          sortedTimes = minValue.ToString();
          sortedActions = unsortedActions.StrValueByIndex(sepr,minIndex);
       }
       else
       {
          sortedTimes = sortedTimes # sepr # minValue.ToString();
          sortedActions = sortedActions # sepr # unsortedActions.StrValueByIndex(sepr,minIndex);
       }
       
       ! unsortierte Werteliste um gefundenen Minimalwert reduzieren, indem zunächst alle Elemente ausser dem Minimalelement in eine Hilfsliste kopiert werden.
       ! Anschließend wird die Hilfsliste in die zu sortierende Liste umkopiert.
       
       ! Hilfsvariablen initialisieren
       tmpTimes = "";
       tmpActions = "";
       i = 0;
       foreach(actValue,unsortedTimes.Split(sepr))
       {
          ! Wenn der aktuelle Index nicht dem des Minimalwertes entspricht, dann übernehmen
          if (i <> minIndex)
          {
             if (tmpTimes.Length() == 0)
             {
                ! beim ersten Element noch kein Listentrennzeichen hinzufügen
                tmpTimes = actValue;
                tmpActions = unsortedActions.StrValueByIndex(sepr,i);
             }
             else
             {
                tmpTimes = tmpTimes # sepr # actValue;
                tmpActions = tmpActions # sepr # unsortedActions.StrValueByIndex(sepr,i);
             }
          }
        i = i + 1;
       }
       ! neue zu sortierende Liste aus Hilfsliste übernehmen
      unsortedTimes = tmpTimes;
       unsortedActions = tmpActions;
    }

    dom.GetObject('YAWN_ZeitenListe').State(sortedTimes);
    dom.GetObject('YAWN_AktionsListe').State(sortedActions);

    if (LogLevel >= 2)
    {
       logtext = logtext # "Aktionszeiten: " # sortedTimes # " _nl_ ";
       logtext = logtext # "Aktionenliste: " # sortedActions # " _nl_ ";
    }
	
    ! ##############################################################

    ! Timer für erste Aktion aufziehen
    tmpStartTime = (sortedTimes.StrValueByIndex(sepr,0)).ToInteger();

    tmpStd = tmpStartTime/3600;
    tmpMin = (tmpStartTime%3600)/60;
    tmpSek = tmpStartTime%60;

    timerWert = tmpStd.ToString() # ":" # tmpMin.ToString() # ":" # tmpSek.ToString();

    dom.GetObject("CUxD.CUX2800002:2.TIMER_SET").State(timerWert);
	
    if (LogLevel >= 3)
    {
       logtext = logtext # "erste Aktion um: " # tmpStartTime # " => CUx-Timer aufgezogen auf: " # timerWert # " _nl_ ";
    }

    ! ##############################################################

    ! Logfile wegschreiben
    if (LogLevel >= 2)
    {
       dom.GetObject("CUxD.CUX2801001:1.CMD_EXEC").State("/bin/tclsh /usr/local/addons/TCL/LogMe.tcl YAWN 1 "# logtext);
    }

Jetzt sind es schon 2 Skripte, die nicht laufen, beide mit dem gleichen Fehler und ohne Angabe von Zeile und Spalte.

JRiemann · Beitrag von **JRiemann** » 06.03.2018, 21:34

Es wird daran liegen das die Skripte nicht auf aktuellem Stand sind.
Nutzer einer CCU können aktuell noch wählen welche Version der Rega (Legacy, Standard und Community) sie nutzen wollen.
Du bist aber jetzt auf RaspiMatic umgestiegen bei der grundsätzlich nur die Community-Version der Rega eingesetzt wird.
In einer aktuellen RaspiMatic sind also ALLE Neuerungen und Verbesserungen enthalten weit bevor diese auf einer CCU Anwendung finden.
Es kann also sein das CCU-Nutzer mit der Legacy oder Standard Version Deine Probleme nicht haben.

honeoe · Beitrag von **honeoe** » 06.03.2018, 21:46

äähhhmmm, wie kommst Du auf RaspiMatic ?

Ich habe eine CCU2 laufen und bin nicht umgestiegen. Das Projekt YAWN war von Anfnag an auch auf der CCU angelegt und kein RaspiMatic-Projekt.

Und übrigens, meine CCU2 läuft auf STANDARD.

honeoe · Beitrag von **honeoe** » 06.03.2018, 21:49

So,

mit dem erweiterten Logging konnte ich feststellen, dass das Skript bis kurz vor Ende durchläuft.

Das Problem scheint eine Zeitenberechnung zu machen:

Code: Alles auswählen

    tmpStd = tmpStartTime/3600;
    tmpMin = (tmpStartTime%3600)/60;
    tmpSek = tmpStartTime%60;

Demnach könnte die Vermutung mit den Änderungen der Skript-Anforderungen stimmen.

Es soll eine Zeit im Sekunden-Format in Stunden, Minuten und Sekunden getrennt werden. Weiß da jemand wo es hakane könnte?

Beitrag von **alchy** » 06.03.2018, 22:10

sofern tmpStartTime korrekt besetzt ist, sollten diese Zeilen nicht dein Problem sein.

Alchy

HomeMatic-Forum / FHZ-Forum