Navigation

    Logo
    • Register
    • Login
    • Search
    • Recent
    • Tags
    • Unread
    • Categories
    • Unreplied
    • Popular
    • GitHub
    • Docu
    • Hilfe
    1. Home
    2. Deutsch
    3. Skripten / Logik
    4. [Vorlage] Anwesenheitssimulation - Script

    NEWS

    • ioBroker@Smart Living Forum Solingen, 14.06. - Agenda added

    • ioBroker goes Matter ... Matter Adapter in Stable

    • Monatsrückblick - April 2025

    [Vorlage] Anwesenheitssimulation - Script

    This topic has been deleted. Only users with topic management privileges can see it.
    • G
      giessener @Uli977 last edited by

      Hallo,
      ich habe hierzu eine alternatives Skript für mich gebastelt. Es verwendet keine Zufallszeiten, sondern einfach die Daten aus einem definierten Zeitraum aus der Historyinstanz (bei mir SQL). Fahre ich eine Woche weg, spiele ich einfach die letzte Woche ab und habe damit auch logische Lichtabfolgen. Ich habe es für 10 ids gebaut und es gibt keine Fehlerabfragen. Vielleicht hilft das ja auch jemandem von euch. Meine Scriptingfähigkeiten sind eher so Copy-Paste. Deshalb wiederholt sich hier auch 10mal der Code da ich sonst nicht wusste wie ich die asynchronen Arrays zusammen bekomme. Wer also Ideen zur Verbesserung hat, darf da gerne dran basteln. 😉

      //Das Script lädt eine Liste der Schaltvorgänge der angegebenen Datenpunkte für einen definierten Zeitraum und spielt diese dann nocheinmal ab. 
      
      
      var Zeitspanne = 604800000;                           //Wie weit in der Vergangenheit mit dem Replay begonnen werden soll in ms (Tag:86400000, Woche: 604800000 )
      var id1 ='sonoff.0.EG-KUECHE-Oberschranklicht.POWER';         //ids der zu Schaltenden Geraete
      var id2 ='sonoff.0.EG-KUECHE-Vitrinenlicht.POWER';
      var id3 ='sonoff.0.EG-HWR-Deckenlicht.POWER';
      var id4 ='sonoff.0.EG-FLUR-Deckenlicht.POWER';
      var id5 ='sonoff.0.EG-WZ-Wandlicht.POWER';
      var id6 ='sonoff.0.EG-WZ-Stehlampe.POWER';
      var id7 ='sonoff.0.EG-BAD-Deckenlicht.POWER';
      var id8 ='sonoff.0.OG-FLUR-Deckenlicht.POWER';
      var id9 ='sonoff.0.OG-BAD-Deckenlicht.POWER';
      var id10 ='sonoff.0.OG-OST-Deckenlicht.POWER';
      
      //id1
      var Pause1;
      sendTo('sql.0', 'getHistory', {                 //einlesen der Werte aus der History Instanz. Hier SQL
          id: id1,
          options: {
              start: new Date().getTime() - Zeitspanne,      //Ermitteln ab wann die Daten eingelesen werden sollen
              aggregate:  'onchange'
          }
      }, function (result) {
             
          j = 0;
          function schalten(j) {
              setState(id1 ,result.result[j].val);                                       //Schalten der id mit dem Wert nr j aus der Liste
              j++;
              if (j < result.result.length) {                                             //Falls Ende der Liste erreicht, aufhoeren
                  Pause1 = result.result[j].ts +Zeitspanne- new Date().getTime();          //Pause bis zum naesten Stateupdate berechnen
                  console.log('Zeit bis zum naesten Statusupdate von '+ id1 +' : ' + Pause1 + ' ms');
                  setTimeout (function () {schalten (j);}, Pause1);}                       //wieder aufrufen der Funktion verzoegert um die Pause
          }
          
          schalten (0);
          
      });
      //id2
      var Pause2;
      sendTo('sql.0', 'getHistory', {                 //einlesen der Werte aus der History Instanz. Hier SQL
          id: id2,
          options: {
              start: new Date().getTime() - Zeitspanne,      //Ermitteln ab wann die Daten eingelesen werden sollen
              aggregate:  'onchange'
          }
      }, function (result) {
             
          j = 0;
          function schalten(j) {
              setState(id2 ,result.result[j].val);                                       //Schalten der id mit dem Wert nr j aus der Liste
              j++;
              if (j < result.result.length) {                                             //Falls Ende der Liste erreicht, aufhoeren
                  Pause2 = result.result[j].ts +Zeitspanne- new Date().getTime();          //Pause bis zum naesten Stateupdate berechnen
                  console.log('Zeit bis zum naesten Statusupdate von '+ id2 +' : ' + Pause2 + ' ms');
                  setTimeout (function () {schalten (j);}, Pause2);}                       //wieder aufrufen der Funktion verzoegert um die Pause
          }
          
          schalten (0);
          
      });
      //id3
      var Pause3;
      sendTo('sql.0', 'getHistory', {                 //einlesen der Werte aus der History Instanz. Hier SQL
          id: id3,
          options: {
              start: new Date().getTime() - Zeitspanne,      //Ermitteln ab wann die Daten eingelesen werden sollen
              aggregate:  'onchange'
          }
      }, function (result) {
             
          j = 0;
          function schalten(j) {
              setState(id3 ,result.result[j].val);                                       //Schalten der id mit dem Wert nr j aus der Liste
              j++;
              if (j < result.result.length) {                                             //Falls Ende der Liste erreicht, aufhoeren
                  Pause3 = result.result[j].ts +Zeitspanne- new Date().getTime();          //Pause bis zum naesten Stateupdate berechnen
                  console.log('Zeit bis zum naesten Statusupdate von '+ id3 +' : ' + Pause3 + ' ms');
                  setTimeout (function () {schalten (j);}, Pause3);}                       //wieder aufrufen der Funktion verzoegert um die Pause
          }
          
          schalten (0);
          
      });
      //id4
      var Pause4;
      sendTo('sql.0', 'getHistory', {                 //einlesen der Werte aus der History Instanz. Hier SQL
          id: id4,
          options: {
              start: new Date().getTime() - Zeitspanne,      //Ermitteln ab wann die Daten eingelesen werden sollen
              aggregate:  'onchange'
          }
      }, function (result) {
             
          j = 0;
          function schalten(j) {
              setState(id4 ,result.result[j].val);                                       //Schalten der id mit dem Wert nr j aus der Liste
              j++;
              if (j < result.result.length) {                                             //Falls Ende der Liste erreicht, aufhoeren
                  Pause4 = result.result[j].ts +Zeitspanne- new Date().getTime();          //Pause bis zum naesten Stateupdate berechnen
                  console.log('Zeit bis zum naesten Statusupdate von '+ id4 +' : ' + Pause4 + ' ms');
                  setTimeout (function () {schalten (j);}, Pause4);}                       //wieder aufrufen der Funktion verzoegert um die Pause
          }
          
          schalten (0);
          
      });
      //id5
      var Pause5;
      sendTo('sql.0', 'getHistory', {                 //einlesen der Werte aus der History Instanz. Hier SQL
          id: id5,
          options: {
              start: new Date().getTime() - Zeitspanne,      //Ermitteln ab wann die Daten eingelesen werden sollen
              aggregate:  'onchange'
          }
      }, function (result) {
             
          j = 0;
          function schalten(j) {
              setState(id5 ,result.result[j].val);                                       //Schalten der id mit dem Wert nr j aus der Liste
              j++;
              if (j < result.result.length) {                                             //Falls Ende der Liste erreicht, aufhoeren
                  Pause5 = result.result[j].ts +Zeitspanne- new Date().getTime();          //Pause bis zum naesten Stateupdate berechnen
                  console.log('Zeit bis zum naesten Statusupdate von '+ id5 +' : ' + Pause5 + ' ms');
                  setTimeout (function () {schalten (j);}, Pause5);}                       //wieder aufrufen der Funktion verzoegert um die Pause
          }
          
          schalten (0);
          
      });
      //id6
      var Pause6;
      sendTo('sql.0', 'getHistory', {                 //einlesen der Werte aus der History Instanz. Hier SQL
          id: id6,
          options: {
              start: new Date().getTime() - Zeitspanne,      //Ermitteln ab wann die Daten eingelesen werden sollen
              aggregate:  'onchange'
          }
      }, function (result) {
             
          j = 0;
          function schalten(j) {
              setState(id6 ,result.result[j].val);                                       //Schalten der id mit dem Wert nr j aus der Liste
              j++;
              if (j < result.result.length) {                                             //Falls Ende der Liste erreicht, aufhoeren
                  Pause6 = result.result[j].ts +Zeitspanne- new Date().getTime();          //Pause bis zum naesten Stateupdate berechnen
                  console.log('Zeit bis zum naesten Statusupdate von '+ id6 +' : ' + Pause6 + ' ms');
                  setTimeout (function () {schalten (j);}, Pause6);}                       //wieder aufrufen der Funktion verzoegert um die Pause
          }
          
          schalten (0);
          
      });
      //id7
      var Pause7;
      sendTo('sql.0', 'getHistory', {                 //einlesen der Werte aus der History Instanz. Hier SQL
          id: id7,
          options: {
              start: new Date().getTime() - Zeitspanne,      //Ermitteln ab wann die Daten eingelesen werden sollen
              aggregate:  'onchange'
          }
      }, function (result) {
             
          j = 0;
          function schalten(j) {
              setState(id7 ,result.result[j].val);                                       //Schalten der id mit dem Wert nr j aus der Liste
              j++;
              if (j < result.result.length) {                                             //Falls Ende der Liste erreicht, aufhoeren
                  Pause7 = result.result[j].ts +Zeitspanne- new Date().getTime();          //Pause bis zum naesten Stateupdate berechnen
                  console.log('Zeit bis zum naesten Statusupdate von '+ id7 +' : ' + Pause7 + ' ms');
                  setTimeout (function () {schalten (j);}, Pause7);}                       //wieder aufrufen der Funktion verzoegert um die Pause
          }
          
          schalten (0);
          
      });
      //id8
      var Pause8;
      sendTo('sql.0', 'getHistory', {                 //einlesen der Werte aus der History Instanz. Hier SQL
          id: id8,
          options: {
              start: new Date().getTime() - Zeitspanne,      //Ermitteln ab wann die Daten eingelesen werden sollen
              aggregate:  'onchange'
          }
      }, function (result) {
             
          j = 0;
          function schalten(j) {
              setState(id8 ,result.result[j].val);                                       //Schalten der id mit dem Wert nr j aus der Liste
              j++;
              if (j < result.result.length) {                                             //Falls Ende der Liste erreicht, aufhoeren
                  Pause8 = result.result[j].ts +Zeitspanne- new Date().getTime();          //Pause bis zum naesten Stateupdate berechnen
                  console.log('Zeit bis zum naesten Statusupdate von '+ id8 +' : ' + Pause8 + ' ms');
                  setTimeout (function () {schalten (j);}, Pause8);}                       //wieder aufrufen der Funktion verzoegert um die Pause
          }
          
          schalten (0);
          
      });
      //id9
      var Pause9;
      sendTo('sql.0', 'getHistory', {                 //einlesen der Werte aus der History Instanz. Hier SQL
          id: id9,
          options: {
              start: new Date().getTime() - Zeitspanne,      //Ermitteln ab wann die Daten eingelesen werden sollen
              aggregate:  'onchange'
          }
      }, function (result) {
             
          j = 0;
          function schalten(j) {
              setState(id9 ,result.result[j].val);                                       //Schalten der id mit dem Wert nr j aus der Liste
              j++;
              if (j < result.result.length) {                                             //Falls Ende der Liste erreicht, aufhoeren
                  Pause9 = result.result[j].ts +Zeitspanne- new Date().getTime();          //Pause bis zum naesten Stateupdate berechnen
                  console.log('Zeit bis zum naesten Statusupdate von '+ id9 +' : ' + Pause9 + ' ms');
                  setTimeout (function () {schalten (j);}, Pause9);}                       //wieder aufrufen der Funktion verzoegert um die Pause
          }
          
          schalten (0);
          
      });
      //id10
      var Pause10;
      sendTo('sql.0', 'getHistory', {                 //einlesen der Werte aus der History Instanz. Hier SQL
          id: id10,
          options: {
              start: new Date().getTime() - Zeitspanne,      //Ermitteln ab wann die Daten eingelesen werden sollen
              aggregate:  'onchange'
          }
      }, function (result) {
             
          j = 0;
          function schalten(j) {
              setState(id10 ,result.result[j].val);                                       //Schalten der id mit dem Wert nr j aus der Liste
              j++;
              if (j < result.result.length) {                                             //Falls Ende der Liste erreicht, aufhoeren
                  Pause10 = result.result[j].ts +Zeitspanne- new Date().getTime();          //Pause bis zum naesten Stateupdate berechnen
                  console.log('Zeit bis zum naesten Statusupdate von '+ id10 +' : ' + Pause10 + ' ms');
                  setTimeout (function () {schalten (j);}, Pause10);}                       //wieder aufrufen der Funktion verzoegert um die Pause
          }
          
          schalten (0);
          
      });
      
      F Q 2 Replies Last reply Reply Quote 0
      • F
        FoxRo @giessener last edited by

        @looxer01
        Vielen Dank für Dein Skript.
        War eine wunderbare "Starthilfe" für meine Anwesenheitssimulation. Danke für die tolle Arbeit! 👍

        1 Reply Last reply Reply Quote 0
        • Q
          qwerty1896 @giessener last edited by

          @giessener

          Warum künstlich was erschaffen, was schon da ist. Echter geht's nicht! Top.

          1 Reply Last reply Reply Quote 0
          • T
            torsten3009 last edited by

            bekommt einer aktuell auch den Fehler?

            javascript.0 (1837) script.js.Anwesenheitsimulation: schedule(cron=*/0 * * * *): cannot create schedule

            T 1 Reply Last reply Reply Quote 0
            • T
              torsten3009 @torsten3009 last edited by

              @torsten3009 said in [Vorlage] Anwesenheitssimulation - Script:

              bekommt einer aktuell auch den Fehler?

              javascript.0 (1837) script.js.Anwesenheitsimulation: schedule(cron=*/0 * * * *): cannot create schedule

              ok, habe mal ab Zeile 169 angepasst:
              ALT:

              var cron1job = "*/"+cron1+" * * * *";       // CRON pattern aufgrund der Vorgabe in den Einstellungen
              var cron2job = "*/"+cron2+" * * * *";       // CRON pattern aufgrund der Vorgabe in den Einstellungen
              var cron3job = "*/"+cron3+" * * * *";       // CRON pattern aufgrund der Vorgabe in den Einstellungen
              var cron4job = "*/"+cron4+" * * * *";       // CRON pattern aufgrund der Vorgabe in den Einstellungen
              var cron5job = "*/"+cron5+" * * * *"; 
              
              var cron1job = "* "+cron1+" * * * *";       // CRON pattern aufgrund der Vorgabe in den Einstellungen
              var cron2job = "* "+cron2+" * * * *";       // CRON pattern aufgrund der Vorgabe in den Einstellungen
              var cron3job = "* "+cron3+" * * * *";       // CRON pattern aufgrund der Vorgabe in den Einstellungen
              var cron4job = "* "+cron4+" * * * *";       // CRON pattern aufgrund der Vorgabe in den Einstellungen
              var cron5job = "* "+cron5+" * * * *"; 
              

              jetzt kommt kein Fehler mehr

              S 1 Reply Last reply Reply Quote 0
              • S
                samxy @torsten3009 last edited by

                @torsten3009

                So wie ich das sehe, laufen dann die Cronjob auch nicht mehr korrekt.

                Die cron1 bis cron5 Variablen dürfen nicht den Wert 0 haben (das war bei mir z.B. beim nicht benutzten cron5 der Fall)
                Dann ergibt das */0 * * * * - was jetzt den Fehler erzeugt - richtig wäre für jede Minute * * * * * oder */1 * * *

                Es sollte reichen, wenn man die Deklaration der cron1 bis cron5 Variablen überprüft und sicherstellt, dass dort keine 0 steht. (im Skript so um Zeile 100)

                // Einstellung Check-schedule  - Voreinstellung z.B. alle 30  Minuten je IDGruppe - Damit wird je Lauf nach Zufaelligkeit je ein Geraet der IDGruppe eingeschaltet
                var cron1 = 2;  // checks alle x Minuten für IDGruppe1
                var cron2 = 15; //  checks alle x Minuten für IDGruppe2
                var cron3 = 15; //  checks alle x Minuten für IDGruppe3
                var cron4 = 5; //  checks alle x Minuten für IDGruppe4
                var cron5 = 5; //  checks alle x Minuten für IDGruppe5
                
                1 Reply Last reply Reply Quote 0
                • S
                  SoerenKaiser99 @looxer01 last edited by SoerenKaiser99

                  Hi @looxer01 da nun nach langem bei uns mal wieder ein Urlaub ansteht, wollte ich dein Skript eben mal ein wenig anpassen und nach unserem Umzug das erste mal wieder laufen lassen. Nun schmeisst es mir aber diesen Fehler aus:

                  javascript.0
                  2022-08-17 12:41:38.241	error	script.js.common.Schaltungen.Anwesenheitssimulation1: schedule(cron=*/0 * * * *): cannot create schedule
                  
                  javascript.0
                  2022-08-17 12:41:36.868	error	Error by canceling scheduled job "<Anonymous Job 34 2022-08-17T10:39:38.791Z>"
                  
                  javascript.0
                  2022-08-17 12:41:36.868	error	Error by canceling scheduled job "<Anonymous Job 33 2022-08-17T10:39:38.790Z>"
                  
                  javascript.0
                  2022-08-17 12:41:36.867	error	Error by canceling scheduled job "<Anonymous Job 32 2022-08-17T10:39:38.789Z>"
                  
                  javascript.0
                  2022-08-17 12:41:36.867	error	Error by canceling scheduled job "<Anonymous Job 31 2022-08-17T10:39:38.788Z>"
                  

                  Hast du eine Idee woran es liegen könnte? Ich habe schon den Datumswechsel raus genommen (nach 23:59:59)
                  Hier wäre meine config:


                  //..........Anwesenheitssimulation AWS
                  //..........Initiales Datum: 28.12.2015
                  //..........Autor: Looxer01
                  //..........Forum ioBroker
                  //..........http://forum.iobroker.com/posting.php?mode=post&f=21&sid=b3b2a31dae55081fedaf0ad9c8d74acd
                  //
                  //..........Änderungshistorie
                  //..........Version 0.10 Initial 28.12.2015
                  //..........Version 0.11 29.12.2015 Einstellungen um Astrozeiten erweitert (noch ohne Funktion)
                  //.........,Version 0.12 29.12.2015 EVENT Deaktivierung von AWS hinzugefügt: Schreiben Log und loeschen Schedules
                  //...............................................Aktivierung von AWS hihzugüfügt: Schreiben Log bei Aktivierung
                  //..........Version 0.13 29.12.2015 das Schreiben des externen Logs optional gemacht - unter Einstellungen auswaehlbar
                  //..........Version 0.20 29.12.2015 Astrozeit Funktion hinzugefügt. Astrozeit wird je IDGruppe auf true/false gesetzt und overruled die variablen zeit1von,zeit2von,zeit3von,zeit4von,zeit5von
                  //..........Version 0.30 29.12.2015 Umarbeitung zur Verkürzung des Scripts
                  //..........Version 0.31 30.12.2015 Fehlerbeseitigung in IDGruppen3 und 4 - einige Code Hygiene Massnahmen
                  //..................................Umbenennung der IDGruppen mit führend "ID" / Startverzögerungseinstellungen hinzugefügt
                  //..........Version 0.32 30.12.2015 umgestellt auf setStateDelayed / Startverzögerungsfunktion hinzugefügt.
                  //..........Version 0.33 31.12.2015 Fehler mit EVAL Funktion gefixt / Fehler mit Startverzoegerung und Einschaltzeiten gefixt
                  //..................................Funktion Anzahl von Geraete Teilnehmer zur Geraete ID bestimmung hinzugefügt
                  //..........Version 0.40 01.01.2016 Log-Pfad variablel gemacht // Log-File Format umgearbeitet und Headerline hinzugefügt fuer externes Log. Internes Log ueberarbeitet
                  //..........Version 0.41 02.01.2016 Funktionen von Baetz zum TimeInRange Check hinzugefuegt. Keine Globale Funktion mehr notwendig. -- Kommentarte ueberarbeitet
                  //..........Version 0.42 02.01.2015 Herkunftsnachweis für IsTimeInRange Funktion hinzugefuegt
                  //..................................Fehler zur zufaelligen Geraete Findung behoben. Das letzte Geraet wurde nie ausgewaehlt // Fehler im log "Gearaet wurde nicht eingeschaltet wurde gelogged auch wenn es eingeschaltet wurde"
                  //..........Version 0.43 03.01.2015 Wenn AWS auf inaktiv gesetzt wird, dann werden alle teilnehmenden Geraete ausgeschaltet - Dokumentation der Variablen / variablen deklaration nachgeholt fuer zwei Faelle
                  //..........Version 0.44 04.01.2015 Addieren der Einschaltverzoegerung zur Ausschaltzeit fuer die Ausschaltzeitberechnung // Fixed Fehler doppelte Schaltung fuer STATE geraete
                  //..........Version 0.45 04.01.2015 weiterer Fehler zur Berechnung der Ausschaltzeit korrigiert
                  //..........Version 0.50 04.01.2015 Beseitigung unnötiges Coding // Ueberpruefung ob Geraet existiert hinzugefuegt - LogMeldung falls nicht hinzugefuegt. - kein Javascript restart mehr, wenn geraet nicht existiert
                  //..........Version 0.60 04.01.2015 Ausschalten der Teilnehmer bei Deaktivierung optimiert. Ausschaltung optional gemacht / Astrozeit ueberarbeitet
                  //..................................Astrozeit auch fuer die bis Zeit hinzugefuegt. Damit lassen sich Schaltungen bis zum Sonnenaufgang umsetzen / weitere Codeoptimierungen
                  //..........Version 0.61 05.01.2015 Beim Ausschalten Verzoegerung zwischen Schaltvorgange eingebaut / Codeiptimierung bei den Gruppen Schedules / Fehler bei der GrpZufAnz und StartDelay beseitigt fuer Gruppen 2-5
                  //..........Version 0.65 06.01.2015 Reaktion bei bereits eigneschalteten Lampen variabel gemacht / Codeoptimierungen / ID fuer AWS-Aktiv ist jetzt variabel
                  //..........Version 0.70 26.01.2015 SetStateDelayed ist jetzt in javascript gefixt ab JS version 1.1.2 - Das Loeschen von Ein/Auschaltplanungen wird jetzt mit dem neuen Befehl clearStateDelayed gemacht
                  //..................................Vorläufig wurde das Merken der letzten Aktion geloescht, da es keine Verwendung im Moment hat
                  //..........Version 0.75 27.01.2015 Fehler beim Loeschen von Ein/Auschaltplanungen behoben - Es wurde nicht geloescht, wenn Verbraucher eingeschaltet bleiben sollen
                  //..........Version 0.80 28.04.2016 Fehler mit der Astrozeit, wenn die BisZeit < ist als die Astrozeit(von) beseitigt
                  //..........Version 0.90 23.12.2017 Einund Ausschaltbefehle jetzt als Variable einstellbar. Damit lassen sich auch andere Geräte einbindungen (z.B KNX mit 0 und 1). Level und STATE Geräte als Boolean und number identifziert
                  //..........Version 0.91 19.01.2018 Ein Ausschaltbefehl war noch nicht mit der Ausschaltvariable verknüpft
                  //..................................Die IDAWSaktiv war mit einem falschen Datenpunkt verknüpft
                  //..........Version 0.92.03.12.2018.Fehler behoben nach update auf JS 4.0.1 !fs.existsSync funktioniert nicht mehr ausgetausch mit fs.readFile
                  //..........Version 0.94.27.01.2019 Fehler behoben: Wenn Zeit in den nächsten Tag reichte, dann wurden beu Astronutzung die Start und Endzeiten nicht richtig berechnet
                  //................................. Sonnenaufgang und Sonnenuntergang können statt der Zeitangabe eingegeben werden.
                  //................................. In der VonZeit kann jetzt auch Sonnenaufgang eingegeben werden
                  //................................. Debug der Zeitenberechnung eingeführt
                  //
                  // Das Script wird aktiviert, wenn das Flag "Anwesenheitssteuerung gesetzt wird"
                  // HIER Einstellungen vornehmen............................................................................................

                  var KeyWordSunDown = "SunSet"; // SONNENUNTERGANG - Bitte dieses Keyword in ZeitxVon oder ZeitxBis eintragen wenn Astrozeit gewünscht ist
                  var KeyWordSunUp = "SunRise"; // SONNENAUFGANG - Bitte dieses Keyword in ZeitxVon oder ZeitxBis eintragen wenn Astrozeit gewünscht ist

                  // Bei Eingabe des Keywords bei den Zeiten werden die Astrozeiten verwendet
                  // Einstellungen der Aktivzeiten je IDGruppe von bis
                  var zeit1von = "18:00:00"; //Aktivzeit von IDGruppe1
                  var zeit1bis = "20:30:00"; //Aktivzeit bis IDGruppe1

                  var zeit2von = "20:15:00"; //Aktivzeit von IDGruppe2
                  var zeit2bis = "23:45:00"; //Aktivzeit bis IDGruppe2

                  var zeit3von = "20:30:00"; //Aktivzeit von IDGruppe3
                  var zeit3bis = "23:59:00"; //Aktivzeit bis IDGruppe3

                  var zeit4von = "21:20:00"; //Aktivzeit von IDGruppe4
                  var zeit4bis = "23:59:00"; //Aktivzeit bis IDGruppe4

                  var zeit5von = "21:00:00"; //Aktivzeit von IDGruppe5
                  var zeit5bis = "23:59:00"; //Aktivzeit bis IDGruppe5

                  // Einstellungen der zufaelligen Einschaltdauer je IDGruppe von bis
                  var ein1von = 5; // Minuten IDGruppe1 von
                  var ein1bis = 10; // Minuten IDGruppe1 bis
                  var ein2von = 20; // Minuten IDGruppe2 von
                  var ein2bis = 35; // Minuten IDGruppe2 bis
                  var ein3von = 2; // Minuten IDGruppe3 von
                  var ein3bis = 10; // Minuten IDGruppe3 bis
                  var ein4von = 5; // Minuten IDGruppe4 von
                  var ein4bis = 10; // Minuten IDGruppe4 bis
                  var ein5von = 10; // Minuten IDGruppe5 von
                  var ein5bis = 30; // Minuten IDGruppe5 bis

                  // Einstellung je Gruppe für die maximale Startverzögerung in Minuten
                  // bei 0 = keine Startverzögerung - bei z.B. 10 = Startverzögerung zwischen 0 und 10 in Minuten
                  //
                  var StartDelay1 = 2; // Maximale Startverzoegerung Gruppe1
                  var StartDelay2 = 2; // Maximale Startverzoegerung Gruppe2
                  var StartDelay3 = 2; // Maximale Startverzoegerung Gruppe3
                  var StartDelay4 = 5; // Maximale Startverzoegerung Gruppe4
                  var StartDelay5 = 0; // Maximale Startverzoegerung Gruppe5

                  // Einstellung Check-schedule - Voreinstellung z.B. alle 30 Minuten je IDGruppe - Damit wird je Lauf nach Zufaelligkeit je ein Geraet der IDGruppe eingeschaltet
                  var cron1 = 10; // checks alle x Minuten für IDGruppe1
                  var cron2 = 30; // checks alle x Minuten für IDGruppe2
                  var cron3 = 45; // checks alle x Minuten für IDGruppe3
                  var cron4 = 5; // checks alle x Minuten für IDGruppe4
                  var cron5 = 0; // checks alle x Minuten für IDGruppe5

                  // Einstellung teilnehmende Homematic Geräte je IDGruppe maximal 5 - Eingabe der Homematic ID
                  var IDGruppe11 = "shelly.0.SHSW-1#BA00D1#1.Relay0.Switch"; // Licht Wohnzimmer Büro
                  var IDGruppe12 = "shelly.0.SHSW-1#93B33A#1.Relay0.Switch"; // Licht schlafzimmer
                  var IDGruppe13 = "hue.0.Flur.allOn"; // Licht Flur unten;
                  var IDGruppe14 = "shelly.0.SHSW-1#93B0BA#1.Relay0.Switch"; // Licht Kinderbad
                  var IDGruppe15 = " "; // Licht Hobbyraum
                  var Grp1ZufAnz = 4; // Anzahl der Geräte zur zufälligen Bestimmung des Geraetes

                  var IDGruppe21 = "hue.0.Wohnzimmer.allOn"; // Licht Wohnzimmer
                  var IDGruppe22 = "hue.0.Esszimmer.allOn"; // Licht Terrassentuere
                  var IDGruppe23 = " "; // Licht Wohnzimmer Esstisch Stehlampe
                  var IDGruppe24 = " ";
                  var IDGruppe25 = " ";
                  var Grp2ZufAnz = 2; // Anzahl der Geräte zur zufälligen Bestimmung des Geraetes

                  var IDGruppe31 = "shelly.0.SHSW-1#93B0BA#1.Relay0.Switch"; // Licht Flur oben Wand;
                  var IDGruppe32 = "shelly.0.SHSW-1#93B33A#1.Relay0.Switch"; // Licht Flur oben unten;
                  var IDGruppe33 = " "; // Licht Kinderbad
                  var IDGruppe34 = " ";
                  var IDGruppe35 = " ";
                  var Grp3ZufAnz = 5; // Anzahl der Geräte zur zufälligen Bestimmung des Geraetes

                  var IDGruppe41 = "hue.0.Wohnzimmer.bri"; // Licht aussen Steinterrasse
                  var IDGruppe42 = " "; // Licht Kinderbad
                  var IDGruppe43 = " "; // Licht Schwimmbad Nebenlicht;
                  var IDGruppe44 = " ";
                  var IDGruppe45 = " ";
                  var Grp4ZufAnz = 1; // Anzahl der Geräte zur zufälligen Bestimmung des Geraetes

                  var IDGruppe51 = " ";
                  var IDGruppe52 = " ";
                  var IDGruppe53 = " ";
                  var IDGruppe54 = " ";
                  var IDGruppe55 = " ";
                  var Grp5ZufAnz = 5; // Anzahl der Geräte zur zufälligen Bestimmung des Geraetes

                  var logflag = true; // wenn auf true dann wird das logging in Datei /opt/iobroker/iobroker-data/AWSLog.csv eingeschaltet bei false vice versa

                  var ausflag = true; // Wenn AWS deaktiviert wird, dann werden alle Teilnehmer ausgeschaltet

                  // Experten-Einstellungen .......................................................................................................

                  var IDAWSaktiv = "0_userdata.0.Licht.Anwesenheitssimulation"; // in den objekten angelegte variable zur Bestimmung ob AWS aktiv ist - Kann auch ausgetauscht werden durch eine andere
                  var LogPath = "/opt/iobroker/iobroker-data/AWSLogTest.csv"; // Pfad und Dateiname des externen Logs
                  var IgnoreWhenOn = false; // bei true: Ignoriert den Schaltvorgang, wenn das Geraet bereits eingeschaltet war
                  var ErlieastSunDown = 16; // Die Stunde des fruehesten Sonnenuntergangs z.B. in Deutschlnad 16 Uhr
                  var EarliestSunUp = 4; // Die Stunde des fruehesten Sonnenuntergangs z.B. in Deutschlnad 4 Uhr
                  var LatestSunDown = 21; // Die Stunde des spätesten Sonnenuntergangs z.B. in Deutschlnad 21 Uhr
                  var LatestSunUp = 8; // Die Stunde des spätestens Sonnenuntergangs z.B. in Deutschlnad 8 Uhr

                  var EinschaltFlag = true; // Einschaltbefehl der Teilnehmer fuer Boolean Geräte
                  var AusschaltFlag = false; // Ausschaltbefehl der Teilnehmer fuer Boolean Geräte
                  var DimmAusschalt = 0; // Ausschaltbefehl fuer Number Geräte (Dimmer)
                  var DimmEinschalt = 100; // Einschaltbefehl fuer Number Geräte (Dimmer) = Einschaltlevel auf den geschaltet wird
                  var debug = false; // zusätzliche log Meldungen zur Analyse

                  // Ende Experten-Einstellungen .......................................................................................................

                  // globale Variablen
                  var fs = require('fs'); // enable write fuer externes log
                  var cron1job = "*/"+cron1+" * * * "; // CRON pattern aufgrund der Vorgabe in den Einstellungen
                  var cron2job = "
                  /"+cron2+" * * * "; // CRON pattern aufgrund der Vorgabe in den Einstellungen
                  var cron3job = "
                  /"+cron3+" * * * "; // CRON pattern aufgrund der Vorgabe in den Einstellungen
                  var cron4job = "
                  /"+cron4+" * * * "; // CRON pattern aufgrund der Vorgabe in den Einstellungen
                  var cron5job = "
                  /"+cron5+" * * * *"; // CRON pattern aufgrund der Vorgabe in den Einstellungen
                  var x = 0; // Geraetenummer der Gruppe, die zufaellig ausgewaehlt wurde
                  var y = 0; // Einschaltzdauer aufgrund der Zufallszahl in Millisekunden
                  var z = 0; // Einschaltverzögerung aufgrund der Zufallszahl
                  var string = " "; // Logstring
                  var logtext=" " ; // Kommentar im log
                  var objIDGruppe = " "; // uebergabe an Funktion der IDGruppe zum Schalten des Geraetes
                  var SpaceChk = new RegExp(/\s/); // pattern um zu pruefen ob eine IDGruppe blanks enthaelt

                  var SwitchTimes = []; // SwitchTimes wird genutzt um die Schaltzeiten zu merken. Das wird benötigt um Schaltzeiten die in den nächsten Tag reichen zu verwalten
                  // Struktur 0 = Schaltgruppe, 1 = vonZeit, 2 = bisZeit

                  // Aktivierungsflag anlegen beim ersten Start des Scripts
                  createState(IDAWSaktiv, true, {read: true, write: true, type: 'boolean', name: 'Anwesenheitssteuerungsflag', desc: 'Anwesenheitssteuerungsflag'});

                  // Execute IDGruppe1
                  //-------------------------------------------------------------------------------------------------------------------------------------------------------
                  schedule(cron1job, function() {
                  if (getState(IDAWSaktiv).val === true) { // AWS aktiv ?
                  if(IsTimeInRange(zeit1von, zeit1bis,1)) { // ist die "von"-Zeit innerhalb des aktuellen Zeitfensters ?
                  x = zufall(1,Grp1ZufAnz,x); // Ermittlung zufaelliges Geraet zum enschalten
                  z = zufall(0,StartDelay160,y)1000; // Ermittlung der Einschaltverzögerung aufgrund der Zufallszahl
                  y = zufall(ein1von
                  60,ein1bis
                  60,y)*1000; // Ermittlung der Einschaltzdauer aufgrund der Zufallszahl in Millisekunden
                  var IDGruppe = "IDGruppe1" + x; // Ermittlung Gruppenname z.B. IDGruppe11
                  if (x <= 5 && GeraetExists(IDGruppe)) { AWSSchaltung(IDGruppe,y,z); } // Geraetenummer muss 1 - 5 sein, dass Geraet muss existieren dann schalten
                  } // Ende Zeitcheck
                  } // Endeif für AWS-Aktivflag check
                  }); // end schedule IDGruppe1

                  // Execute IDGruppe2
                  //-------------------------------------------------------------------------------------------------------------------------------------------------------
                  schedule(cron2job, function() {
                  if (getState(IDAWSaktiv).val === true) { // AWS aktiv ?
                  if(IsTimeInRange(zeit2von, zeit2bis,2)) { // ist die "von"-Zeit innerhalb des aktuellen Zeitfensters ?
                  x = zufall(1,Grp2ZufAnz,x); // Ermittlung zufaelliges Geraet zum enschalten
                  z = zufall(0,StartDelay260,y)1000; // Ermittlung der Einschaltverzögerung aufgrund der Zufallszahl
                  y = zufall(ein2von
                  60,ein2bis
                  60,y)*1000; // Ermittlung der Einschaltzdauer aufgrund der Zufallszahl in Millisekunden
                  var IDGruppe = "IDGruppe2" + x; // Ermittlung Gruppenname z.B. IDGruppe21
                  if (x <= 5 && GeraetExists(IDGruppe)) { AWSSchaltung(IDGruppe,y,z); } // Geraetenummer muss 1 - 5 sein, dass Geraet muss existieren dann schalten
                  } // Ende Zeitcheck
                  } // Endeif für AWS-Aktivflag check
                  }); // end schedule IDGruppe2

                  // Execute IDGruppe3
                  //-------------------------------------------------------------------------------------------------------------------------------------------------------
                  schedule(cron3job, function() {
                  if (getState(IDAWSaktiv).val === true) { // AWS aktiv ?
                  if(IsTimeInRange(zeit3von, zeit3bis,3)) { // ist die "von"-Zeit innerhalb des aktuellen Zeitfensters ?
                  x = zufall(1,Grp3ZufAnz,x); // Ermittlung zufaelliges Geraet zum enschalten
                  z = zufall(0,StartDelay360,y)1000; // Ermittlung der Einschaltverzögerung aufgrund der Zufallszahl
                  y = zufall(ein3von
                  60,ein3bis
                  60,y)*1000; // Ermittlung der Einschaltzdauer aufgrund der Zufallszahl in Millisekunden
                  var IDGruppe = "IDGruppe3" + x; // Ermittlung Gruppenname z.B. IDGruppe31
                  if (x <= 5 && GeraetExists(IDGruppe)) { AWSSchaltung(IDGruppe,y,z); } // Geraetenummer muss 1 - 5 sein, dass Geraet muss existieren dann schalten
                  } // Ende Zeitcheck
                  } // Endeif für AWS-Aktivflag check
                  }); // end schedule IDGruppe3

                  // Execute IDGruppe4
                  //-------------------------------------------------------------------------------------------------------------------------------------------------------
                  schedule(cron4job, function() {
                  if (getState(IDAWSaktiv).val === true) { // AWS aktiv ?
                  if(IsTimeInRange(zeit4von, zeit4bis,4)) { // ist die "von"-Zeit innerhalb des aktuellen Zeitfensters ?
                  x = zufall(1,Grp4ZufAnz,x); // Ermittlung zufaelliges Geraet zum enschalten
                  z = zufall(0,StartDelay460,y)1000; // Ermittlung der Einschaltverzögerung aufgrund der Zufallszahl
                  y = zufall(ein4von
                  60,ein4bis
                  60,y)*1000; // Ermittlung der Einschaltzdauer aufgrund der Zufallszahl in Millisekunden
                  var IDGruppe = "IDGruppe4" + x; // Ermittlung Gruppenname z.B. IDGruppe41
                  if (x <= 5 && GeraetExists(IDGruppe)) { AWSSchaltung(IDGruppe,y,z); } // Geraetenummer muss 1 - 5 sein, dass Geraet muss existieren dann schalten
                  } // Ende Zeitcheck
                  } // Endeif für AWS-Aktivflag check
                  }); // end schedule IDGruppe4

                  // Execute IDGruppe5
                  //-------------------------------------------------------------------------------------------------------------------------------------------------------
                  schedule(cron5job, function() {
                  if (getState(IDAWSaktiv).val === true) { // AWS aktiv ?
                  if(IsTimeInRange(zeit5von, zeit5bis,5)) { // ist die "von"-Zeit innerhalb des aktuellen Zeitfensters ?
                  x = zufall(1,Grp5ZufAnz,x); // Ermittlung zufaelliges Geraet zum enschalten
                  z = zufall(0,StartDelay560,y)1000; // Ermittlung der Einschaltverzögerung aufgrund der Zufallszahl
                  y = zufall(ein5von
                  60,ein5bis
                  60,y)*1000; // Ermittlung der Einschaltzdauer aufgrund der Zufallszahl in Millisekunden
                  var IDGruppe = "IDGruppe5" + x; // Ermittlung Gruppenname z.B. IDGruppe51
                  if (x <= 5 && GeraetExists(IDGruppe)) { AWSSchaltung(IDGruppe,y,z); } // Geraetenummer muss 1 - 5 sein, dass Geraet muss existieren dann schalten
                  } // Ende Zeitcheck
                  } // Endeif für AWS-Aktivflag check
                  }); // end schedule IDGruppe5

                  // ------------------------Ruecksetzen der Timeouts /Ausschalten der teilnehmenden Geraete, wenn AWS-Aktiv auf false gesetzt wird--------------

                  on({id: IDAWSaktiv, val: false }, function(obj) // Event: wenn AWS Flag auf nicht aktiv gesetzt wurde
                  {

                  var objGruppeI =    " ";    // Baut die IDGruppe zusammen Position 1
                  var objGruppeJ =    " ";    // Baut die IDGruppe zusammen Position 2
                  var countobj   =    0;      //counter fuer Verzoegerungen zwischen den Ausschaltungen
                  var id;
                  var object;
                  
                  for (var i = 1; i <= 5; i++) {                                                              // Loop fuer die Gruppen-Nr
                      objGruppeI = "IDGruppe" + i;                                                        // Loop fuer die Geraete Nr der IDGruppen 1 - 5
                         for (var j = 1; j <= 5; j++) {                                                       // Loop Position 2 /1 - 5 )
                              objGruppeJ = objGruppeI + j ;                                               // Ermittlung Position 2
                              id = eval(objGruppeJ);
                              if (SpaceChk.test(id)) {                                                    // Check for  blanks
                              } else {                                                                    // keine blanks
                                  object = getObject(id);
                                  if (GeraetExists(objGruppeJ) === true) {                                // Gibt es das Geraet
                                      clearStateDelayed(id);                                              // Alle Pläne der Gruppe loeschen
                                      if (ausflag) {                                                      // sollen die Teilnehmer ausgeschaltet werden ? 
                                          if (object.common && object.common.type === 'boolean') {        // ist es ein STATE Geraet ?
                                              setStateDelayed(id, AusschaltFlag, countobj);               // ausschalten mit je  300 millisekunden wartezeit
                                          }
                                          if (object.common && object.common.type === 'number') {         // ist es ein LEVEL Geraet ?      
                                              setStateDelayed(id, DimmAusschalt, countobj);               // ausschalten mit je  300 millisekunden wartezeit
                                          }
                                      }                                                                   // endif check ob Geraete ausgeschaltet werden sollen
                                      countobj = countobj + 300;                                          // alle 300 millisekunden schalten
                                  } // endif fuer Geraetecheck und switch off
                              } // end Space Check
                        } //  Ende Position 2 Loop
                  }  // Ende Position 1 Loop
                  log("EVENT  AWS deaktiviert Der schedule zur geplanten Ausschaltung von Geraeten wurde zurueckgesetzt " ,"info");
                  string = ";;;;;;;AWS wurde deaktiviert - Der schedule zur geplanten Ausschaltung von Geraeten wurde zurueckgesetzt";           // bereite LOG vor
                  
                  writelog(string);                                                                           // schreibe LOG in Datei
                  if(debug ) { listcheckSwitch();}
                  

                  }); // ende on id

                  // ------------------------schreibe Log wenn AWS aktiviert wurde--------------------------------------

                  on({id: IDAWSaktiv, val: true }, function(obj) // Event: wenn AWS Flag auf nicht aktiv gesetzt wurde
                  {

                  log("EVENT AWS wurde aktiviert " ,"info");
                  string = ";;;;;;;AWS wurde aktiviert"; // bereite LOG vor
                  writelog(string);
                  if(debug ) { listcheckSwitch();}

                  }); // ende on id

                  // ------------------------ F U N K T I O N E N -------------------------------------------------------

                  //-----------------------------------------------------------------------------------------------------
                  // Diese Funktion schaltet die IDGruppenmitglieder der gerade zu berabeitenden IDGruppe
                  //-----------------------------------------------------------------------------------------------------
                  // neu
                  function AWSSchaltung(objIDGruppe,y,z) {
                  logtext = " ";
                  var id = eval(objIDGruppe);
                  var obj = getObject(id);
                  if (!obj) return;

                  if (obj.common && obj.common.type === 'boolean') {                          // ist es ein STATE Geraet ?
                     if  (getState(id).val == AusschaltFlag ) {                               // nur wenn noch nicht eingeschaltet
                        setStateDelayed(id, EinschaltFlag,  z);                                 // Licht an in z millisekunden
                  

                  // var timer = setTimeout(function (){
                  // setState(eval(objIDGruppe),0); }, z+y); //Licht aus in y millisekunden (Einschaltverzoegerung plus Einschaltdauer)
                  console.log('Routine AWSSchaltung - SET: ' + id + ' to false in ' + (z+y) + 'ms');
                  setStateDelayed(id, AusschaltFlag, z+y, false); //Licht aus in z+y millisekunden (Einschaltverzoegerung plus Einschaltdauer)
                  } else { // else - Geraet ist schon eingeschaltet
                  if (IgnoreWhenOn) { //keine Reaktion wenn Geraet bereits eingeschaltet war
                  logtext = "keine Aktion - Geraet war bereits eingeschaltet";
                  } else { // else - es soll uebersteuert werden mit den neuen werten
                  z = 0; // Einschaltverzoegerung setzen auf Null
                  console.log('Routine AWSSchaltung - SET: ' + id + ' to false in ' + (z+y) + 'ms');
                  setStateDelayed(id, AusschaltFlag, z+y, true ); //Licht aus in z+y millisekunden (Einschaltverzoegerung plus Einschaltdauer) ohne Einschaltverzoegerung
                  logtext = "Geraet war bereits eingeschaltet -- uebersteuert - ohne Einschaltverzoegerung - alter schedule geloescht- ";
                  } // endeif IgnoreWhenOn
                  } // Ende IF fuer Check ob bereits eingeschaltet
                  } // Ende IF für STATE Geraete

                  if (obj.common && obj.common.type === 'number') {                                             // ist es ein LEVEL Geraet ?
                     if  (getState(id).val == DimmAusschalt ) {                                   // nur wenn noch nicht eingeschaltet
                              console.log('Routine AWSSchaltung - SET: ' + id + ' to ' + (obj.common.max || 100) + ' in ' + z + 'ms');
                          setStateDelayed(id, obj.common.max || DimmEinschalt,  z);                                // Licht an in z millisekunden
                  

                  // var timer = setTimeout(function (){
                  // setState(eval(objIDGruppe),0); }, z+y); //Licht aus in y millisekunden (Einschaltverzoegerung plus Einschaltdauer)
                  console.log('Routine AWSSchaltung - SET: ' + id + ' to ' + (obj.common.min || 0) + ' in ' + (z+y) + 'ms');
                  setStateDelayed(id, obj.common.min || DimmAusschalt, z+y, false); //Licht aus in y millisekunden (Einschaltverzoegerung plus Einschaltdauer)
                  } else { // else - Geraet ist schon eingeschaltet
                  if (IgnoreWhenOn) { //keine Reaktion wenn Geraet bereits eingeschaltet war
                  logtext = "keine Aktion - Geraet war bereits eingeschaltet";
                  } else { // else - es soll uebersteuert werden mit den neuen werten
                  z = 0; // Einschaltverzoegerung setzen auf Null
                  console.log('Routine AWSSchaltung - SET: ' + id + ' to ' + (obj.common.min || DimmAusschalt) + ' sofort');
                  setStateDelayed(id, obj.common.min || DimmAusschalt, z+y, true); //Licht aus in z+y millisekunden (Einschaltverzoegerung plus Einschaltdauer) ohne Einschaltverzoegerung
                  logtext = "Geraet war bereits eingeschaltet -- uebersteuert - ohne Einschaltverzoegerung - alter schedule geloescht- ";
                  } // endeif IgnoreWhenOn
                  } // Ende IF fuer Check ob bereits eingeschaltet
                  } // Ende IF für LEVEL Geraete

                      var GeraeteName = getObject(id).common.name;                         // Name des Geraetes in Klartext
                      var now =    new Date();                                                            // store current date and time
                      var currSec = now.getTime();                                                        // millisekunden seit 01.01.1970 /current millisecs
                      var berechnEinZeit = millisecToDate( currSec + z);                                  // millisecs in Zeit umrechnen fuer die Einschaltzeit
                      var berechnAusZeit = millisecToDate(currSec + z + y);                               // millisecs in Zeit umrechnen fuer die Ausschaltzeit
                  

                  // WriteArray(objIDGruppe,timer, currSec + z, currSec + z + y) // Merken des Schaltvorganges
                  string = objIDGruppe+";" + id +";" + GeraeteName + ";" + z/1000 + ";" +y/1000+";"+berechnEinZeit + ";" + berechnAusZeit + ";" + logtext; // bereite LOG vor
                  log("Routine AWSSchaltung - EVENT " + objIDGruppe + "; " +id + "; " + GeraeteName + "; " + z/1000 + "; " + y/1000 + "; " + berechnEinZeit + "; " + berechnAusZeit + "; " + logtext, "info"); //Log schreiben
                  writelog(string); // schreibe LOG in Datei
                  logtext = " ";

                  } // Ende Funktion

                  //-----------------------------------------------------------------------------------------------------
                  // Funktion zur Bestimmung einer ganzzahligen Zufallszahl innerhalb vorgegebener min/max Werte
                  //-----------------------------------------------------------------------------------------------------
                  function zufall(low,high,back) {
                  back = Math.floor(Math.random() * (high - low + 1)) + low;
                  // log("EVENT AWS Zufallszahlen - low = " + low + "high = " + high + " back = " + back ,"info");
                  return back;
                  } // ende Funktion

                  //-----------------------------------------------------------------------------------------------------
                  // Funktion zur Ueberpruefung ob die angegebenen Geraete exisiteren
                  //-----------------------------------------------------------------------------------------------------
                  function GeraetExists(objGruppe) {
                  var back = false;
                  var id = eval(objGruppe);

                  if (SpaceChk.test(id)) { // objIDGruppe darf kein space enthalten // ist ein Geraet ueberhaupt zugeordnet ?
                  // log("Geraet hat kein assignment - Gruppe " + objGruppe, "info");
                  return back;
                  } // endif IDGruppe hat kein assignment

                  if (getState(id)) { // Existiert das Geraet ?
                  back = true;
                  } else {
                  log("Routine GeraetExists - Geraet existiert nicht - bitte in den Einstellungen ueberpruefen - Gruppe " + objGruppe, "info");
                  } // endif check on Geraet exists

                  return back;
                  } // ende Funktion

                  //-----------------------------------------------------------------------------------------------------
                  // Funktion schreibt einen Logeintrag in das Filesystem und auch in das interne Log-System
                  //-----------------------------------------------------------------------------------------------------
                  function writelog(string) {
                  if (logflag === true) {
                  // Zerlege Datum und Zeit in Variable
                  var now = new Date(); // store current date and time
                  var year = now.getFullYear();
                  var month = addZero(now.getMonth()+1);
                  var day = addZero(now.getDate());
                  var Thour = addZero(now.getHours());
                  var Tmin = addZero(now.getMinutes());
                  var Tsec = addZero(now.getSeconds());
                  var logdate = day + '.' + month + '.' + year;
                  var logtime = Thour + ':' + Tmin + ':' + Tsec;

                      fs.readFile(LogPath, 'utf8', function(err,data){
                          if (!err) {  // File existiert
                              fs.appendFileSync(LogPath, logdate+" ;"+logtime+" ;"+string + "\n");       // Füge Satz in Datei ein
                          }else{
                              log("Routine writelog - Logfile nicht gefunden - wird angelegt"), "info";
                              var headerLine= "Datum;Uhrzeit;Gruppe;GeraeteID;Geraetebezeichnung;Einschaltverzoegerung;LaengeSchaltzeit;ZeitEin berechnet;ZeitAus berechnet;Kommentar"   
                              fs.appendFileSync(LogPath, headerLine + "\n");       // Füge Satz in Datei ein
                              fs.appendFileSync(LogPath, logdate+" ;"+logtime+" ;"+string + "\n");       // Füge Satz in Datei ein
                          }
                      });       // ende Filecheck
                  } ; // Ende check on logflag
                  

                  } // Ende Funktion

                  //-----------------------------------------------------------------------------------------------------
                  // Funktion IsTimeInRange -
                  // Ermittlung ob die aktuelle Zeit in der vorgegebenen Schaltzeit liegt (inkl Astro)
                  //-----------------------------------------------------------------------------------------------------

                  function IsTimeInRange (zeitvon, zeitbis, Gruppe) {
                  var now = new Date();
                  var lower; // enthält Javascript datums/Zeitformat für die VOM Zeit
                  var upper; // enthält Javascript datums/Zeitformat für die BIS Zeit
                  var astrovonDown = zeitvon.includes(KeyWordSunDown); // Astrozeit VON Sonnenuntergang gesetzt
                  var astrovonUp = zeitvon.includes(KeyWordSunUp); // Astrozeit VON Sonnenaufgang gesetzt
                  var astrobisDown = zeitbis.includes(KeyWordSunDown); // Astrozeit BIS Sonnenuntergang gesetzt
                  var astrobisUp = zeitbis.includes(KeyWordSunUp); // Astrozeit BIS Sonnenaufgang gesetzt
                  var astrovon = false;
                  var astrobis = false;

                  var StatusSwichTimes =checkSwitchTime(Gruppe);
                  
                  if (StatusSwichTimes) {                                  // es gibt einen aktuellen Eintrag bzw laufende Schaltzeit fuer diese Gruppe
                      if(debug ) { log("Routine IsTimeInRange - Gruppe"+ Gruppe +  " ist im definierten Zeitrange - Schaltung ist aktiv", "info") }
                      return true; // in Tabelle SwitchTime gibt es noch einen gültigen Eintrag also zurück zur Schaltung
                  }
                  
                  
                  // bei Verwendung von Astrozeiten werden die errechneten Zeiten in lower und upper gespeichert
                  if (astrovonDown === true) {                            // Astrozeit gesetzt VON Zeit ist Sonnenuntergang
                      lower =  getAstroDate("sunsetStart");
                      astrovon = true;
                  }
                  if (astrovonUp === true) {                              // Astrozeit gesetzt VON Zeit ist Sonnenaufgang
                      lower =  getAstroDate("sunriseEnd");
                      astrovon = true;
                  }
                  if (astrobisDown === true) {                            // Astrozeit gesetzt BIS Zeit ist Sonnenuntergang
                      upper =  getAstroDate("sunsetStart");
                      if(astrovonDown) {                                  // wenn VonZeit = untergang und BisZeit = Untergang - dann muss bis Zeit nächster Tag sein
                          upper.setDate(upper.getDate() + 1);             // 1 Tag (24 Stunden ) addieren da der bis Wert wahrscheinlich am nächsten Tag liegen muss        
                      }
                      astrobis = true;
                  }
                  if (astrobisUp === true) {                              // Astrozeit gesetzt BIS Zeit ist Sonnenaufgang
                      upper =  getAstroDate("sunriseEnd");
                      if(astrovonDown) {                                    // wenn VonZeit = aufgang und BisZeit = Aufgang - dann muss BIS Zeit nächster Tag sein
                         upper.setDate(upper.getDate() + 1);              // 1 Tag (24 Stunden ) addieren da der bis Wert wahrscheinlich am nächsten Tag liegen muss    
                      }
                      astrobis = true;
                  }
                  
                  // Wenn keine Astrozeiten verwendet werden werden Zeiten anhand der Zeitangaben errechnet
                  if (!astrovon) {
                      lower = addTime(zeitvon);                       // switch on time  im berechenbaren Format
                  }
                  if (!astrobis) {
                      upper = addTime(zeitbis);                       // switch off time im berechenbaren Format
                  }
                  
                  // Sonderfall:wenn die Zeitangaben sind identisch - also bis zeit nächster Tag und von Zeit muss auf now liegen
                  if (zeitvon === zeitbis) { 
                      upper.setDate(upper.getDate() + 1); // 24 Stunden zur Bis-Zeit Hinzufügen 
                      lower = now;                                        // wenn z.B. von 23:00:00 bis 23:00:00 eingegeben wurde dann soll immer geschaltet werden
                  

                  }

                   // Wenn jetzt noch die VON Zeit kleiner also die BIS Zeit ist muss die BIS Zeit evt auf den nächsten Tag gelegt werden. (oder auch sie ist abgelaufen)
                  if (upper < lower) {                                    // Die von Zeit ist groesser als die bis Zeit
                      if(astrovonDown) {                                  // im Falle von Astrovon kann es sein, dass die bis Zeit in den nächsten Tag geht
                          if( upper.getHours()  < ErlieastSunDown ) {     // Uewberpruefen ob die BisZeit kleiner als der Schwellwert ist
                              upper.setDate(upper.getDate() + 1);         // 1 Tag (24 Stunden ) addieren da der bis Wert wahrscheinlich am nächsten Tag liegen muss 
                              if (debug) { log("Routine IsTimeInRange - Gruppe"+ Gruppe +" bei Astrovon die zeitbis started Morgen - AstroZeit Sonnenuntergang VON ist "+ lower ,"info");}
                          }
                      }
                      if(astrovonUp) {                                    // im Falle von Astrovon kann es sein, dass die bis Zeit in den nächsten Tag geht
                          if( upper.getHours()  < EarliestSunUp ) {       // Uewberpruefen ob die BisZeit kleiner als der Schwellwert ist
                              upper.setDate(upper.getDate() + 1);         // 1 Tag (24 Stunden ) addieren da der bis Wert wahrscheinlich am nächsten Tag liegen muss 
                              if (debug) { log("Routine IsTimeInRange - Gruppe"+ Gruppe + " bei Astrovon die zeitbis started Morgen - AstroZeit Sonnenaufgang VON ist "+ lower,"info");}
                          }
                      }
                  
                     if(astrobisDown) {                                   // im Falle von Astrovon kann es sein, dass die bis Zeit in den nächsten Tag geht
                          if( lower.getHours()  > LatestSunDown ) {       // Uewberpruefen ob die vonZeit groesser als der Schwellwert ist
                              upper.setDate(upper.getDate() + 1);         // 1 Tag (24 Stunden ) addieren da der bis Wert wahrscheinlich am nächsten Tag liegen muss 
                              if (debug) { log("Routine IsTimeInRange - Gruppe"+ Gruppe + " bei Astrovon die zeitbis started Morgen - AstroZeit Sonnenuntergang BIS ist "+ upper,"info");}
                          }
                      }
                      if(astrobisUp) {                                    // im Falle von Astrovon kann es sein, dass die bis Zeit in den nächsten Tag geht
                          if( lower.getHours()  > LatestSunDown ) {       // Uewberpruefen ob die VonZeit groesser als der Schwellwert ist
                              upper.setDate(upper.getDate() + 1);         // 1 Tag (24 Stunden ) addieren da der bis Wert wahrscheinlich am nächsten Tag liegen muss 
                              if (debug) { log("Routine IsTimeInRange - Gruppe"+ Gruppe + " bei Astrovon die zeitbis started Morgen- - AstroZeit Sonnenaufgang BIS  ist "+ upper,"info");}
                          }
                      }
                  
                      if (!astrovon && !astrobis) {                       // wenn keine Astrozeit gesetzt ist und die bis Zeit kleiner ist --> nächster Tag für die BisZeit
                          upper.setDate(upper.getDate() + 1);             // 1 Tag (24 Stunden ) addieren da der bis Wert wahrscheinlich am nächsten Tag liegen muss 
                      }
                  }
                  

                  if (debug) {log("Routine IsTimeInRange - Gruppe"+ Gruppe + " Berechnung der Zeiten: VON " + lower + " BIS " + upper,"info");}

                  // Wenn jetzt noch die BIS Zeit kleiner also die VON Zeit ist, dann ist die Zeit abgelaufen
                  if (upper < lower ) {                               // dies trifft zu wenn die astrozeit die realzeit eingeholt hat z.B. astrovon = 20:00 und bisZeit 19:00
                      if (debug) { log("Routine IsTimeInRange - Gruppe"+ Gruppe + " upper ist kleiner als lower - zurück Gruppe nicht (mehr) im Zeitrange false","info");}
                      return false;
                  }
                  if( now >= lower && now <= upper ) {
                      log("Routine IsTimeInRange - Gruppe"+ Gruppe + " aktuelle ist ist > als lower und kleiner als upper - Gruppe wird geschaltet (true)" );
                      UpdateSwithTime(Gruppe,lower,upper);
                      // if(debug ) { listcheckSwitch(Gruppe);}
                      return true;
                  } else {
                      log("Routine IsTimeInRange - Gruppe"+ Gruppe + " Zeit nicht im Zeitrange - keine Schaltung ")
                      return false;
                  }
                  

                  }

                  //-----------------------------------------------------------------------------------------------------
                  // Funktion checkSwithTime zum Finden in Tabelle SwitchTimes ob es einen Gültigen Eintrag innerhalb der Zeit gibt
                  // Struktur SwitchTimes: 0 = Schaltgruppe, 1 = vonZeit, 2 = bisZeit
                  //-----------------------------------------------------------------------------------------------------
                  function listcheckSwitch() {
                  for (var x in SwitchTimes) {
                  log("Routine listcheckSwitch - Gruppe" +SwitchTimes[x][0] + " Zeitvon " + SwitchTimes[x][1] + " Zeitbis " + SwitchTimes[x][2],"info");
                  }

                  }

                  //-----------------------------------------------------------------------------------------------------
                  // Funktion checkSwithTime zum Finden in Tabelle SwitchTimes ob es einen Gültigen Eintrag innerhalb der Zeit gibt
                  // Struktur SwitchTimes: 0 = Schaltgruppe, 1 = vonZeit, 2 = bisZeit
                  //-----------------------------------------------------------------------------------------------------
                  function checkSwitchTime(Gruppe) {
                  var now = new Date();

                  for (var x in SwitchTimes) {
                      if(SwitchTimes[x][0] === Gruppe) {
                          if( now >= SwitchTimes[x][1] && now <= SwitchTimes[x][2] ) {
                              return true;
                          }
                      }
                  }
                  return false;
                  

                  } // Ende Function checkSwitchTime

                  //-----------------------------------------------------------------------------------------------------
                  // Funktion UpdateSwithTime macht einen update auf die Tabelle für ausgelaufene Schaltzeiten und für neue
                  // Struktur SwitchTimes: 0 = Schaltgruppe, 1 = vonZeit, 2 = bisZeit
                  //-----------------------------------------------------------------------------------------------------
                  function UpdateSwithTime(Gruppe,VonZeit,BisZeit) {
                  for (var x in SwitchTimes) {
                  if(SwitchTimes[x][0] === Gruppe) {
                  if(debug){ log("Routine UpdateSwithTime - Gruppe " + Gruppe + " Switchtime Update VON " + VonZeit + " BIS " + BisZeit,"info" );}
                  SwitchTimes[Gruppe][1] = VonZeit;
                  SwitchTimes[Gruppe][2] = BisZeit;
                  return;
                  }
                  }
                  SwitchTimes.push([Gruppe, VonZeit, BisZeit]); // nicht gefunden - also hinzufügen
                  if(debug){ log("Routine UpdateSwithTime - Gruppe" + Gruppe + " Switchtime hinzufuegen VON " + VonZeit + " BIS " + BisZeit,"info" );}

                  }

                  //-----------------------------------------------------------------------------------------------------
                  // Funktion zur Erzeugung von führenden Nullen für das Datum Format
                  //-----------------------------------------------------------------------------------------------------
                  function addZero(i) {
                  if (i < 10) {
                  i = "0" + i;
                  }
                  return i;
                  } // Ende Funktion

                  //-----------------------------------------------------------------------------------------------------
                  // Funktion Millisekunden in Datum/Zeit umrechnen /wird für logging benoetigt
                  //-----------------------------------------------------------------------------------------------------
                  function millisecToDate(millisec) {
                  var time = new Date(millisec);
                  var Thour = addZero(time.getHours());
                  var Tmin = addZero(time.getMinutes());
                  var Tsec = addZero(time.getSeconds());
                  var datum = Thour + ':' + Tmin + ':' + Tsec;
                  return datum;
                  } // Ende Funktion

                  //-----------------------------------------------------------------------------------------------------
                  //Funktion addTime wandelt einen String mit Format 00:00:00 in rechenbare Zeit um
                  //-----------------------------------------------------------------------------------------------------
                  function addTime(strTime) {
                  var d = new Date();
                  d = new Date(d.getFullYear(), d.getMonth(), d.getDate())
                  var time = strTime.split(':');
                  d.setHours(time[0]);
                  d.setMinutes(time[1]);
                  d.setSeconds(time[2]);
                  return d;
                  }

                  Dank dir vorab!

                  gelöst Fehler gefunden:
                  Bei mir Zeile 172 bis 176 sind falsch, hier die richtige Version:

                  var cron1job = "* "+cron1+" * * * *";       // CRON pattern aufgrund der Vorgabe in den Einstellungen
                  var cron2job = "* "+cron2+" * * * *";       // CRON pattern aufgrund der Vorgabe in den Einstellungen
                  var cron3job = "* "+cron3+" * * * *";       // CRON pattern aufgrund der Vorgabe in den Einstellungen
                  var cron4job = "* "+cron4+" * * * *";       // CRON pattern aufgrund der Vorgabe in den Einstellungen
                  var cron5job = "* "+cron5+" * * * *"; 
                  
                  S 1 Reply Last reply Reply Quote 0
                  • S
                    skorpil @SoerenKaiser99 last edited by

                    @soerenkaiser99 sagte in [Vorlage] Anwesenheitssimulation - Script:

                    Hi @looxer01 da nun nach langem bei uns mal wieder ein Urlaub ansteht, wollte ich dein Skript eben mal ein wenig anpassen und nach unserem Umzug das erste mal wieder laufen lassen. Nun schmeisst es mir aber diesen Fehler aus:

                    javascript.0
                    2022-08-17 12:41:38.241	error	script.js.common.Schaltungen.Anwesenheitssimulation1: schedule(cron=*/0 * * * *): cannot create schedule
                    
                    javascript.0
                    2022-08-17 12:41:36.868	error	Error by canceling scheduled job "<Anonymous Job 34 2022-08-17T10:39:38.791Z>"
                    
                    javascript.0
                    2022-08-17 12:41:36.868	error	Error by canceling scheduled job "<Anonymous Job 33 2022-08-17T10:39:38.790Z>"
                    
                    javascript.0
                    2022-08-17 12:41:36.867	error	Error by canceling scheduled job "<Anonymous Job 32 2022-08-17T10:39:38.789Z>"
                    
                    javascript.0
                    2022-08-17 12:41:36.867	error	Error by canceling scheduled job "<Anonymous Job 31 2022-08-17T10:39:38.788Z>"
                    

                    Hast du eine Idee woran es liegen könnte? Ich habe schon den Datumswechsel raus genommen (nach 23:59:59)
                    Hier wäre meine config:


                    //..........Anwesenheitssimulation AWS
                    //..........Initiales Datum: 28.12.2015
                    //..........Autor: Looxer01
                    //..........Forum ioBroker
                    //..........http://forum.iobroker.com/posting.php?mode=post&f=21&sid=b3b2a31dae55081fedaf0ad9c8d74acd
                    //
                    //..........Änderungshistorie
                    //..........Version 0.10 Initial 28.12.2015
                    //..........Version 0.11 29.12.2015 Einstellungen um Astrozeiten erweitert (noch ohne Funktion)
                    //.........,Version 0.12 29.12.2015 EVENT Deaktivierung von AWS hinzugefügt: Schreiben Log und loeschen Schedules
                    //...............................................Aktivierung von AWS hihzugüfügt: Schreiben Log bei Aktivierung
                    //..........Version 0.13 29.12.2015 das Schreiben des externen Logs optional gemacht - unter Einstellungen auswaehlbar
                    //..........Version 0.20 29.12.2015 Astrozeit Funktion hinzugefügt. Astrozeit wird je IDGruppe auf true/false gesetzt und overruled die variablen zeit1von,zeit2von,zeit3von,zeit4von,zeit5von
                    //..........Version 0.30 29.12.2015 Umarbeitung zur Verkürzung des Scripts
                    //..........Version 0.31 30.12.2015 Fehlerbeseitigung in IDGruppen3 und 4 - einige Code Hygiene Massnahmen
                    //..................................Umbenennung der IDGruppen mit führend "ID" / Startverzögerungseinstellungen hinzugefügt
                    //..........Version 0.32 30.12.2015 umgestellt auf setStateDelayed / Startverzögerungsfunktion hinzugefügt.
                    //..........Version 0.33 31.12.2015 Fehler mit EVAL Funktion gefixt / Fehler mit Startverzoegerung und Einschaltzeiten gefixt
                    //..................................Funktion Anzahl von Geraete Teilnehmer zur Geraete ID bestimmung hinzugefügt
                    //..........Version 0.40 01.01.2016 Log-Pfad variablel gemacht // Log-File Format umgearbeitet und Headerline hinzugefügt fuer externes Log. Internes Log ueberarbeitet
                    //..........Version 0.41 02.01.2016 Funktionen von Baetz zum TimeInRange Check hinzugefuegt. Keine Globale Funktion mehr notwendig. -- Kommentarte ueberarbeitet
                    //..........Version 0.42 02.01.2015 Herkunftsnachweis für IsTimeInRange Funktion hinzugefuegt
                    //..................................Fehler zur zufaelligen Geraete Findung behoben. Das letzte Geraet wurde nie ausgewaehlt // Fehler im log "Gearaet wurde nicht eingeschaltet wurde gelogged auch wenn es eingeschaltet wurde"
                    //..........Version 0.43 03.01.2015 Wenn AWS auf inaktiv gesetzt wird, dann werden alle teilnehmenden Geraete ausgeschaltet - Dokumentation der Variablen / variablen deklaration nachgeholt fuer zwei Faelle
                    //..........Version 0.44 04.01.2015 Addieren der Einschaltverzoegerung zur Ausschaltzeit fuer die Ausschaltzeitberechnung // Fixed Fehler doppelte Schaltung fuer STATE geraete
                    //..........Version 0.45 04.01.2015 weiterer Fehler zur Berechnung der Ausschaltzeit korrigiert
                    //..........Version 0.50 04.01.2015 Beseitigung unnötiges Coding // Ueberpruefung ob Geraet existiert hinzugefuegt - LogMeldung falls nicht hinzugefuegt. - kein Javascript restart mehr, wenn geraet nicht existiert
                    //..........Version 0.60 04.01.2015 Ausschalten der Teilnehmer bei Deaktivierung optimiert. Ausschaltung optional gemacht / Astrozeit ueberarbeitet
                    //..................................Astrozeit auch fuer die bis Zeit hinzugefuegt. Damit lassen sich Schaltungen bis zum Sonnenaufgang umsetzen / weitere Codeoptimierungen
                    //..........Version 0.61 05.01.2015 Beim Ausschalten Verzoegerung zwischen Schaltvorgange eingebaut / Codeiptimierung bei den Gruppen Schedules / Fehler bei der GrpZufAnz und StartDelay beseitigt fuer Gruppen 2-5
                    //..........Version 0.65 06.01.2015 Reaktion bei bereits eigneschalteten Lampen variabel gemacht / Codeoptimierungen / ID fuer AWS-Aktiv ist jetzt variabel
                    //..........Version 0.70 26.01.2015 SetStateDelayed ist jetzt in javascript gefixt ab JS version 1.1.2 - Das Loeschen von Ein/Auschaltplanungen wird jetzt mit dem neuen Befehl clearStateDelayed gemacht
                    //..................................Vorläufig wurde das Merken der letzten Aktion geloescht, da es keine Verwendung im Moment hat
                    //..........Version 0.75 27.01.2015 Fehler beim Loeschen von Ein/Auschaltplanungen behoben - Es wurde nicht geloescht, wenn Verbraucher eingeschaltet bleiben sollen
                    //..........Version 0.80 28.04.2016 Fehler mit der Astrozeit, wenn die BisZeit < ist als die Astrozeit(von) beseitigt
                    //..........Version 0.90 23.12.2017 Einund Ausschaltbefehle jetzt als Variable einstellbar. Damit lassen sich auch andere Geräte einbindungen (z.B KNX mit 0 und 1). Level und STATE Geräte als Boolean und number identifziert
                    //..........Version 0.91 19.01.2018 Ein Ausschaltbefehl war noch nicht mit der Ausschaltvariable verknüpft
                    //..................................Die IDAWSaktiv war mit einem falschen Datenpunkt verknüpft
                    //..........Version 0.92.03.12.2018.Fehler behoben nach update auf JS 4.0.1 !fs.existsSync funktioniert nicht mehr ausgetausch mit fs.readFile
                    //..........Version 0.94.27.01.2019 Fehler behoben: Wenn Zeit in den nächsten Tag reichte, dann wurden beu Astronutzung die Start und Endzeiten nicht richtig berechnet
                    //................................. Sonnenaufgang und Sonnenuntergang können statt der Zeitangabe eingegeben werden.
                    //................................. In der VonZeit kann jetzt auch Sonnenaufgang eingegeben werden
                    //................................. Debug der Zeitenberechnung eingeführt
                    //
                    // Das Script wird aktiviert, wenn das Flag "Anwesenheitssteuerung gesetzt wird"
                    // HIER Einstellungen vornehmen............................................................................................

                    var KeyWordSunDown = "SunSet"; // SONNENUNTERGANG - Bitte dieses Keyword in ZeitxVon oder ZeitxBis eintragen wenn Astrozeit gewünscht ist
                    var KeyWordSunUp = "SunRise"; // SONNENAUFGANG - Bitte dieses Keyword in ZeitxVon oder ZeitxBis eintragen wenn Astrozeit gewünscht ist

                    // Bei Eingabe des Keywords bei den Zeiten werden die Astrozeiten verwendet
                    // Einstellungen der Aktivzeiten je IDGruppe von bis
                    var zeit1von = "18:00:00"; //Aktivzeit von IDGruppe1
                    var zeit1bis = "20:30:00"; //Aktivzeit bis IDGruppe1

                    var zeit2von = "20:15:00"; //Aktivzeit von IDGruppe2
                    var zeit2bis = "23:45:00"; //Aktivzeit bis IDGruppe2

                    var zeit3von = "20:30:00"; //Aktivzeit von IDGruppe3
                    var zeit3bis = "23:59:00"; //Aktivzeit bis IDGruppe3

                    var zeit4von = "21:20:00"; //Aktivzeit von IDGruppe4
                    var zeit4bis = "23:59:00"; //Aktivzeit bis IDGruppe4

                    var zeit5von = "21:00:00"; //Aktivzeit von IDGruppe5
                    var zeit5bis = "23:59:00"; //Aktivzeit bis IDGruppe5

                    // Einstellungen der zufaelligen Einschaltdauer je IDGruppe von bis
                    var ein1von = 5; // Minuten IDGruppe1 von
                    var ein1bis = 10; // Minuten IDGruppe1 bis
                    var ein2von = 20; // Minuten IDGruppe2 von
                    var ein2bis = 35; // Minuten IDGruppe2 bis
                    var ein3von = 2; // Minuten IDGruppe3 von
                    var ein3bis = 10; // Minuten IDGruppe3 bis
                    var ein4von = 5; // Minuten IDGruppe4 von
                    var ein4bis = 10; // Minuten IDGruppe4 bis
                    var ein5von = 10; // Minuten IDGruppe5 von
                    var ein5bis = 30; // Minuten IDGruppe5 bis

                    // Einstellung je Gruppe für die maximale Startverzögerung in Minuten
                    // bei 0 = keine Startverzögerung - bei z.B. 10 = Startverzögerung zwischen 0 und 10 in Minuten
                    //
                    var StartDelay1 = 2; // Maximale Startverzoegerung Gruppe1
                    var StartDelay2 = 2; // Maximale Startverzoegerung Gruppe2
                    var StartDelay3 = 2; // Maximale Startverzoegerung Gruppe3
                    var StartDelay4 = 5; // Maximale Startverzoegerung Gruppe4
                    var StartDelay5 = 0; // Maximale Startverzoegerung Gruppe5

                    // Einstellung Check-schedule - Voreinstellung z.B. alle 30 Minuten je IDGruppe - Damit wird je Lauf nach Zufaelligkeit je ein Geraet der IDGruppe eingeschaltet
                    var cron1 = 10; // checks alle x Minuten für IDGruppe1
                    var cron2 = 30; // checks alle x Minuten für IDGruppe2
                    var cron3 = 45; // checks alle x Minuten für IDGruppe3
                    var cron4 = 5; // checks alle x Minuten für IDGruppe4
                    var cron5 = 0; // checks alle x Minuten für IDGruppe5

                    // Einstellung teilnehmende Homematic Geräte je IDGruppe maximal 5 - Eingabe der Homematic ID
                    var IDGruppe11 = "shelly.0.SHSW-1#BA00D1#1.Relay0.Switch"; // Licht Wohnzimmer Büro
                    var IDGruppe12 = "shelly.0.SHSW-1#93B33A#1.Relay0.Switch"; // Licht schlafzimmer
                    var IDGruppe13 = "hue.0.Flur.allOn"; // Licht Flur unten;
                    var IDGruppe14 = "shelly.0.SHSW-1#93B0BA#1.Relay0.Switch"; // Licht Kinderbad
                    var IDGruppe15 = " "; // Licht Hobbyraum
                    var Grp1ZufAnz = 4; // Anzahl der Geräte zur zufälligen Bestimmung des Geraetes

                    var IDGruppe21 = "hue.0.Wohnzimmer.allOn"; // Licht Wohnzimmer
                    var IDGruppe22 = "hue.0.Esszimmer.allOn"; // Licht Terrassentuere
                    var IDGruppe23 = " "; // Licht Wohnzimmer Esstisch Stehlampe
                    var IDGruppe24 = " ";
                    var IDGruppe25 = " ";
                    var Grp2ZufAnz = 2; // Anzahl der Geräte zur zufälligen Bestimmung des Geraetes

                    var IDGruppe31 = "shelly.0.SHSW-1#93B0BA#1.Relay0.Switch"; // Licht Flur oben Wand;
                    var IDGruppe32 = "shelly.0.SHSW-1#93B33A#1.Relay0.Switch"; // Licht Flur oben unten;
                    var IDGruppe33 = " "; // Licht Kinderbad
                    var IDGruppe34 = " ";
                    var IDGruppe35 = " ";
                    var Grp3ZufAnz = 5; // Anzahl der Geräte zur zufälligen Bestimmung des Geraetes

                    var IDGruppe41 = "hue.0.Wohnzimmer.bri"; // Licht aussen Steinterrasse
                    var IDGruppe42 = " "; // Licht Kinderbad
                    var IDGruppe43 = " "; // Licht Schwimmbad Nebenlicht;
                    var IDGruppe44 = " ";
                    var IDGruppe45 = " ";
                    var Grp4ZufAnz = 1; // Anzahl der Geräte zur zufälligen Bestimmung des Geraetes

                    var IDGruppe51 = " ";
                    var IDGruppe52 = " ";
                    var IDGruppe53 = " ";
                    var IDGruppe54 = " ";
                    var IDGruppe55 = " ";
                    var Grp5ZufAnz = 5; // Anzahl der Geräte zur zufälligen Bestimmung des Geraetes

                    var logflag = true; // wenn auf true dann wird das logging in Datei /opt/iobroker/iobroker-data/AWSLog.csv eingeschaltet bei false vice versa

                    var ausflag = true; // Wenn AWS deaktiviert wird, dann werden alle Teilnehmer ausgeschaltet

                    // Experten-Einstellungen .......................................................................................................

                    var IDAWSaktiv = "0_userdata.0.Licht.Anwesenheitssimulation"; // in den objekten angelegte variable zur Bestimmung ob AWS aktiv ist - Kann auch ausgetauscht werden durch eine andere
                    var LogPath = "/opt/iobroker/iobroker-data/AWSLogTest.csv"; // Pfad und Dateiname des externen Logs
                    var IgnoreWhenOn = false; // bei true: Ignoriert den Schaltvorgang, wenn das Geraet bereits eingeschaltet war
                    var ErlieastSunDown = 16; // Die Stunde des fruehesten Sonnenuntergangs z.B. in Deutschlnad 16 Uhr
                    var EarliestSunUp = 4; // Die Stunde des fruehesten Sonnenuntergangs z.B. in Deutschlnad 4 Uhr
                    var LatestSunDown = 21; // Die Stunde des spätesten Sonnenuntergangs z.B. in Deutschlnad 21 Uhr
                    var LatestSunUp = 8; // Die Stunde des spätestens Sonnenuntergangs z.B. in Deutschlnad 8 Uhr

                    var EinschaltFlag = true; // Einschaltbefehl der Teilnehmer fuer Boolean Geräte
                    var AusschaltFlag = false; // Ausschaltbefehl der Teilnehmer fuer Boolean Geräte
                    var DimmAusschalt = 0; // Ausschaltbefehl fuer Number Geräte (Dimmer)
                    var DimmEinschalt = 100; // Einschaltbefehl fuer Number Geräte (Dimmer) = Einschaltlevel auf den geschaltet wird
                    var debug = false; // zusätzliche log Meldungen zur Analyse

                    // Ende Experten-Einstellungen .......................................................................................................

                    // globale Variablen
                    var fs = require('fs'); // enable write fuer externes log
                    var cron1job = "*/"+cron1+" * * * "; // CRON pattern aufgrund der Vorgabe in den Einstellungen
                    var cron2job = "
                    /"+cron2+" * * * "; // CRON pattern aufgrund der Vorgabe in den Einstellungen
                    var cron3job = "
                    /"+cron3+" * * * "; // CRON pattern aufgrund der Vorgabe in den Einstellungen
                    var cron4job = "
                    /"+cron4+" * * * "; // CRON pattern aufgrund der Vorgabe in den Einstellungen
                    var cron5job = "
                    /"+cron5+" * * * *"; // CRON pattern aufgrund der Vorgabe in den Einstellungen
                    var x = 0; // Geraetenummer der Gruppe, die zufaellig ausgewaehlt wurde
                    var y = 0; // Einschaltzdauer aufgrund der Zufallszahl in Millisekunden
                    var z = 0; // Einschaltverzögerung aufgrund der Zufallszahl
                    var string = " "; // Logstring
                    var logtext=" " ; // Kommentar im log
                    var objIDGruppe = " "; // uebergabe an Funktion der IDGruppe zum Schalten des Geraetes
                    var SpaceChk = new RegExp(/\s/); // pattern um zu pruefen ob eine IDGruppe blanks enthaelt

                    var SwitchTimes = []; // SwitchTimes wird genutzt um die Schaltzeiten zu merken. Das wird benötigt um Schaltzeiten die in den nächsten Tag reichen zu verwalten
                    // Struktur 0 = Schaltgruppe, 1 = vonZeit, 2 = bisZeit

                    // Aktivierungsflag anlegen beim ersten Start des Scripts
                    createState(IDAWSaktiv, true, {read: true, write: true, type: 'boolean', name: 'Anwesenheitssteuerungsflag', desc: 'Anwesenheitssteuerungsflag'});

                    // Execute IDGruppe1
                    //-------------------------------------------------------------------------------------------------------------------------------------------------------
                    schedule(cron1job, function() {
                    if (getState(IDAWSaktiv).val === true) { // AWS aktiv ?
                    if(IsTimeInRange(zeit1von, zeit1bis,1)) { // ist die "von"-Zeit innerhalb des aktuellen Zeitfensters ?
                    x = zufall(1,Grp1ZufAnz,x); // Ermittlung zufaelliges Geraet zum enschalten
                    z = zufall(0,StartDelay160,y)1000; // Ermittlung der Einschaltverzögerung aufgrund der Zufallszahl
                    y = zufall(ein1von
                    60,ein1bis
                    60,y)*1000; // Ermittlung der Einschaltzdauer aufgrund der Zufallszahl in Millisekunden
                    var IDGruppe = "IDGruppe1" + x; // Ermittlung Gruppenname z.B. IDGruppe11
                    if (x <= 5 && GeraetExists(IDGruppe)) { AWSSchaltung(IDGruppe,y,z); } // Geraetenummer muss 1 - 5 sein, dass Geraet muss existieren dann schalten
                    } // Ende Zeitcheck
                    } // Endeif für AWS-Aktivflag check
                    }); // end schedule IDGruppe1

                    // Execute IDGruppe2
                    //-------------------------------------------------------------------------------------------------------------------------------------------------------
                    schedule(cron2job, function() {
                    if (getState(IDAWSaktiv).val === true) { // AWS aktiv ?
                    if(IsTimeInRange(zeit2von, zeit2bis,2)) { // ist die "von"-Zeit innerhalb des aktuellen Zeitfensters ?
                    x = zufall(1,Grp2ZufAnz,x); // Ermittlung zufaelliges Geraet zum enschalten
                    z = zufall(0,StartDelay260,y)1000; // Ermittlung der Einschaltverzögerung aufgrund der Zufallszahl
                    y = zufall(ein2von
                    60,ein2bis
                    60,y)*1000; // Ermittlung der Einschaltzdauer aufgrund der Zufallszahl in Millisekunden
                    var IDGruppe = "IDGruppe2" + x; // Ermittlung Gruppenname z.B. IDGruppe21
                    if (x <= 5 && GeraetExists(IDGruppe)) { AWSSchaltung(IDGruppe,y,z); } // Geraetenummer muss 1 - 5 sein, dass Geraet muss existieren dann schalten
                    } // Ende Zeitcheck
                    } // Endeif für AWS-Aktivflag check
                    }); // end schedule IDGruppe2

                    // Execute IDGruppe3
                    //-------------------------------------------------------------------------------------------------------------------------------------------------------
                    schedule(cron3job, function() {
                    if (getState(IDAWSaktiv).val === true) { // AWS aktiv ?
                    if(IsTimeInRange(zeit3von, zeit3bis,3)) { // ist die "von"-Zeit innerhalb des aktuellen Zeitfensters ?
                    x = zufall(1,Grp3ZufAnz,x); // Ermittlung zufaelliges Geraet zum enschalten
                    z = zufall(0,StartDelay360,y)1000; // Ermittlung der Einschaltverzögerung aufgrund der Zufallszahl
                    y = zufall(ein3von
                    60,ein3bis
                    60,y)*1000; // Ermittlung der Einschaltzdauer aufgrund der Zufallszahl in Millisekunden
                    var IDGruppe = "IDGruppe3" + x; // Ermittlung Gruppenname z.B. IDGruppe31
                    if (x <= 5 && GeraetExists(IDGruppe)) { AWSSchaltung(IDGruppe,y,z); } // Geraetenummer muss 1 - 5 sein, dass Geraet muss existieren dann schalten
                    } // Ende Zeitcheck
                    } // Endeif für AWS-Aktivflag check
                    }); // end schedule IDGruppe3

                    // Execute IDGruppe4
                    //-------------------------------------------------------------------------------------------------------------------------------------------------------
                    schedule(cron4job, function() {
                    if (getState(IDAWSaktiv).val === true) { // AWS aktiv ?
                    if(IsTimeInRange(zeit4von, zeit4bis,4)) { // ist die "von"-Zeit innerhalb des aktuellen Zeitfensters ?
                    x = zufall(1,Grp4ZufAnz,x); // Ermittlung zufaelliges Geraet zum enschalten
                    z = zufall(0,StartDelay460,y)1000; // Ermittlung der Einschaltverzögerung aufgrund der Zufallszahl
                    y = zufall(ein4von
                    60,ein4bis
                    60,y)*1000; // Ermittlung der Einschaltzdauer aufgrund der Zufallszahl in Millisekunden
                    var IDGruppe = "IDGruppe4" + x; // Ermittlung Gruppenname z.B. IDGruppe41
                    if (x <= 5 && GeraetExists(IDGruppe)) { AWSSchaltung(IDGruppe,y,z); } // Geraetenummer muss 1 - 5 sein, dass Geraet muss existieren dann schalten
                    } // Ende Zeitcheck
                    } // Endeif für AWS-Aktivflag check
                    }); // end schedule IDGruppe4

                    // Execute IDGruppe5
                    //-------------------------------------------------------------------------------------------------------------------------------------------------------
                    schedule(cron5job, function() {
                    if (getState(IDAWSaktiv).val === true) { // AWS aktiv ?
                    if(IsTimeInRange(zeit5von, zeit5bis,5)) { // ist die "von"-Zeit innerhalb des aktuellen Zeitfensters ?
                    x = zufall(1,Grp5ZufAnz,x); // Ermittlung zufaelliges Geraet zum enschalten
                    z = zufall(0,StartDelay560,y)1000; // Ermittlung der Einschaltverzögerung aufgrund der Zufallszahl
                    y = zufall(ein5von
                    60,ein5bis
                    60,y)*1000; // Ermittlung der Einschaltzdauer aufgrund der Zufallszahl in Millisekunden
                    var IDGruppe = "IDGruppe5" + x; // Ermittlung Gruppenname z.B. IDGruppe51
                    if (x <= 5 && GeraetExists(IDGruppe)) { AWSSchaltung(IDGruppe,y,z); } // Geraetenummer muss 1 - 5 sein, dass Geraet muss existieren dann schalten
                    } // Ende Zeitcheck
                    } // Endeif für AWS-Aktivflag check
                    }); // end schedule IDGruppe5

                    // ------------------------Ruecksetzen der Timeouts /Ausschalten der teilnehmenden Geraete, wenn AWS-Aktiv auf false gesetzt wird--------------

                    on({id: IDAWSaktiv, val: false }, function(obj) // Event: wenn AWS Flag auf nicht aktiv gesetzt wurde
                    {

                    var objGruppeI =    " ";    // Baut die IDGruppe zusammen Position 1
                    var objGruppeJ =    " ";    // Baut die IDGruppe zusammen Position 2
                    var countobj   =    0;      //counter fuer Verzoegerungen zwischen den Ausschaltungen
                    var id;
                    var object;
                    
                    for (var i = 1; i <= 5; i++) {                                                              // Loop fuer die Gruppen-Nr
                        objGruppeI = "IDGruppe" + i;                                                        // Loop fuer die Geraete Nr der IDGruppen 1 - 5
                           for (var j = 1; j <= 5; j++) {                                                       // Loop Position 2 /1 - 5 )
                                objGruppeJ = objGruppeI + j ;                                               // Ermittlung Position 2
                                id = eval(objGruppeJ);
                                if (SpaceChk.test(id)) {                                                    // Check for  blanks
                                } else {                                                                    // keine blanks
                                    object = getObject(id);
                                    if (GeraetExists(objGruppeJ) === true) {                                // Gibt es das Geraet
                                        clearStateDelayed(id);                                              // Alle Pläne der Gruppe loeschen
                                        if (ausflag) {                                                      // sollen die Teilnehmer ausgeschaltet werden ? 
                                            if (object.common && object.common.type === 'boolean') {        // ist es ein STATE Geraet ?
                                                setStateDelayed(id, AusschaltFlag, countobj);               // ausschalten mit je  300 millisekunden wartezeit
                                            }
                                            if (object.common && object.common.type === 'number') {         // ist es ein LEVEL Geraet ?      
                                                setStateDelayed(id, DimmAusschalt, countobj);               // ausschalten mit je  300 millisekunden wartezeit
                                            }
                                        }                                                                   // endif check ob Geraete ausgeschaltet werden sollen
                                        countobj = countobj + 300;                                          // alle 300 millisekunden schalten
                                    } // endif fuer Geraetecheck und switch off
                                } // end Space Check
                          } //  Ende Position 2 Loop
                    }  // Ende Position 1 Loop
                    log("EVENT  AWS deaktiviert Der schedule zur geplanten Ausschaltung von Geraeten wurde zurueckgesetzt " ,"info");
                    string = ";;;;;;;AWS wurde deaktiviert - Der schedule zur geplanten Ausschaltung von Geraeten wurde zurueckgesetzt";           // bereite LOG vor
                    
                    writelog(string);                                                                           // schreibe LOG in Datei
                    if(debug ) { listcheckSwitch();}
                    

                    }); // ende on id

                    // ------------------------schreibe Log wenn AWS aktiviert wurde--------------------------------------

                    on({id: IDAWSaktiv, val: true }, function(obj) // Event: wenn AWS Flag auf nicht aktiv gesetzt wurde
                    {

                    log("EVENT AWS wurde aktiviert " ,"info");
                    string = ";;;;;;;AWS wurde aktiviert"; // bereite LOG vor
                    writelog(string);
                    if(debug ) { listcheckSwitch();}

                    }); // ende on id

                    // ------------------------ F U N K T I O N E N -------------------------------------------------------

                    //-----------------------------------------------------------------------------------------------------
                    // Diese Funktion schaltet die IDGruppenmitglieder der gerade zu berabeitenden IDGruppe
                    //-----------------------------------------------------------------------------------------------------
                    // neu
                    function AWSSchaltung(objIDGruppe,y,z) {
                    logtext = " ";
                    var id = eval(objIDGruppe);
                    var obj = getObject(id);
                    if (!obj) return;

                    if (obj.common && obj.common.type === 'boolean') {                          // ist es ein STATE Geraet ?
                       if  (getState(id).val == AusschaltFlag ) {                               // nur wenn noch nicht eingeschaltet
                          setStateDelayed(id, EinschaltFlag,  z);                                 // Licht an in z millisekunden
                    

                    // var timer = setTimeout(function (){
                    // setState(eval(objIDGruppe),0); }, z+y); //Licht aus in y millisekunden (Einschaltverzoegerung plus Einschaltdauer)
                    console.log('Routine AWSSchaltung - SET: ' + id + ' to false in ' + (z+y) + 'ms');
                    setStateDelayed(id, AusschaltFlag, z+y, false); //Licht aus in z+y millisekunden (Einschaltverzoegerung plus Einschaltdauer)
                    } else { // else - Geraet ist schon eingeschaltet
                    if (IgnoreWhenOn) { //keine Reaktion wenn Geraet bereits eingeschaltet war
                    logtext = "keine Aktion - Geraet war bereits eingeschaltet";
                    } else { // else - es soll uebersteuert werden mit den neuen werten
                    z = 0; // Einschaltverzoegerung setzen auf Null
                    console.log('Routine AWSSchaltung - SET: ' + id + ' to false in ' + (z+y) + 'ms');
                    setStateDelayed(id, AusschaltFlag, z+y, true ); //Licht aus in z+y millisekunden (Einschaltverzoegerung plus Einschaltdauer) ohne Einschaltverzoegerung
                    logtext = "Geraet war bereits eingeschaltet -- uebersteuert - ohne Einschaltverzoegerung - alter schedule geloescht- ";
                    } // endeif IgnoreWhenOn
                    } // Ende IF fuer Check ob bereits eingeschaltet
                    } // Ende IF für STATE Geraete

                    if (obj.common && obj.common.type === 'number') {                                             // ist es ein LEVEL Geraet ?
                       if  (getState(id).val == DimmAusschalt ) {                                   // nur wenn noch nicht eingeschaltet
                                console.log('Routine AWSSchaltung - SET: ' + id + ' to ' + (obj.common.max || 100) + ' in ' + z + 'ms');
                            setStateDelayed(id, obj.common.max || DimmEinschalt,  z);                                // Licht an in z millisekunden
                    

                    // var timer = setTimeout(function (){
                    // setState(eval(objIDGruppe),0); }, z+y); //Licht aus in y millisekunden (Einschaltverzoegerung plus Einschaltdauer)
                    console.log('Routine AWSSchaltung - SET: ' + id + ' to ' + (obj.common.min || 0) + ' in ' + (z+y) + 'ms');
                    setStateDelayed(id, obj.common.min || DimmAusschalt, z+y, false); //Licht aus in y millisekunden (Einschaltverzoegerung plus Einschaltdauer)
                    } else { // else - Geraet ist schon eingeschaltet
                    if (IgnoreWhenOn) { //keine Reaktion wenn Geraet bereits eingeschaltet war
                    logtext = "keine Aktion - Geraet war bereits eingeschaltet";
                    } else { // else - es soll uebersteuert werden mit den neuen werten
                    z = 0; // Einschaltverzoegerung setzen auf Null
                    console.log('Routine AWSSchaltung - SET: ' + id + ' to ' + (obj.common.min || DimmAusschalt) + ' sofort');
                    setStateDelayed(id, obj.common.min || DimmAusschalt, z+y, true); //Licht aus in z+y millisekunden (Einschaltverzoegerung plus Einschaltdauer) ohne Einschaltverzoegerung
                    logtext = "Geraet war bereits eingeschaltet -- uebersteuert - ohne Einschaltverzoegerung - alter schedule geloescht- ";
                    } // endeif IgnoreWhenOn
                    } // Ende IF fuer Check ob bereits eingeschaltet
                    } // Ende IF für LEVEL Geraete

                        var GeraeteName = getObject(id).common.name;                         // Name des Geraetes in Klartext
                        var now =    new Date();                                                            // store current date and time
                        var currSec = now.getTime();                                                        // millisekunden seit 01.01.1970 /current millisecs
                        var berechnEinZeit = millisecToDate( currSec + z);                                  // millisecs in Zeit umrechnen fuer die Einschaltzeit
                        var berechnAusZeit = millisecToDate(currSec + z + y);                               // millisecs in Zeit umrechnen fuer die Ausschaltzeit
                    

                    // WriteArray(objIDGruppe,timer, currSec + z, currSec + z + y) // Merken des Schaltvorganges
                    string = objIDGruppe+";" + id +";" + GeraeteName + ";" + z/1000 + ";" +y/1000+";"+berechnEinZeit + ";" + berechnAusZeit + ";" + logtext; // bereite LOG vor
                    log("Routine AWSSchaltung - EVENT " + objIDGruppe + "; " +id + "; " + GeraeteName + "; " + z/1000 + "; " + y/1000 + "; " + berechnEinZeit + "; " + berechnAusZeit + "; " + logtext, "info"); //Log schreiben
                    writelog(string); // schreibe LOG in Datei
                    logtext = " ";

                    } // Ende Funktion

                    //-----------------------------------------------------------------------------------------------------
                    // Funktion zur Bestimmung einer ganzzahligen Zufallszahl innerhalb vorgegebener min/max Werte
                    //-----------------------------------------------------------------------------------------------------
                    function zufall(low,high,back) {
                    back = Math.floor(Math.random() * (high - low + 1)) + low;
                    // log("EVENT AWS Zufallszahlen - low = " + low + "high = " + high + " back = " + back ,"info");
                    return back;
                    } // ende Funktion

                    //-----------------------------------------------------------------------------------------------------
                    // Funktion zur Ueberpruefung ob die angegebenen Geraete exisiteren
                    //-----------------------------------------------------------------------------------------------------
                    function GeraetExists(objGruppe) {
                    var back = false;
                    var id = eval(objGruppe);

                    if (SpaceChk.test(id)) { // objIDGruppe darf kein space enthalten // ist ein Geraet ueberhaupt zugeordnet ?
                    // log("Geraet hat kein assignment - Gruppe " + objGruppe, "info");
                    return back;
                    } // endif IDGruppe hat kein assignment

                    if (getState(id)) { // Existiert das Geraet ?
                    back = true;
                    } else {
                    log("Routine GeraetExists - Geraet existiert nicht - bitte in den Einstellungen ueberpruefen - Gruppe " + objGruppe, "info");
                    } // endif check on Geraet exists

                    return back;
                    } // ende Funktion

                    //-----------------------------------------------------------------------------------------------------
                    // Funktion schreibt einen Logeintrag in das Filesystem und auch in das interne Log-System
                    //-----------------------------------------------------------------------------------------------------
                    function writelog(string) {
                    if (logflag === true) {
                    // Zerlege Datum und Zeit in Variable
                    var now = new Date(); // store current date and time
                    var year = now.getFullYear();
                    var month = addZero(now.getMonth()+1);
                    var day = addZero(now.getDate());
                    var Thour = addZero(now.getHours());
                    var Tmin = addZero(now.getMinutes());
                    var Tsec = addZero(now.getSeconds());
                    var logdate = day + '.' + month + '.' + year;
                    var logtime = Thour + ':' + Tmin + ':' + Tsec;

                        fs.readFile(LogPath, 'utf8', function(err,data){
                            if (!err) {  // File existiert
                                fs.appendFileSync(LogPath, logdate+" ;"+logtime+" ;"+string + "\n");       // Füge Satz in Datei ein
                            }else{
                                log("Routine writelog - Logfile nicht gefunden - wird angelegt"), "info";
                                var headerLine= "Datum;Uhrzeit;Gruppe;GeraeteID;Geraetebezeichnung;Einschaltverzoegerung;LaengeSchaltzeit;ZeitEin berechnet;ZeitAus berechnet;Kommentar"   
                                fs.appendFileSync(LogPath, headerLine + "\n");       // Füge Satz in Datei ein
                                fs.appendFileSync(LogPath, logdate+" ;"+logtime+" ;"+string + "\n");       // Füge Satz in Datei ein
                            }
                        });       // ende Filecheck
                    } ; // Ende check on logflag
                    

                    } // Ende Funktion

                    //-----------------------------------------------------------------------------------------------------
                    // Funktion IsTimeInRange -
                    // Ermittlung ob die aktuelle Zeit in der vorgegebenen Schaltzeit liegt (inkl Astro)
                    //-----------------------------------------------------------------------------------------------------

                    function IsTimeInRange (zeitvon, zeitbis, Gruppe) {
                    var now = new Date();
                    var lower; // enthält Javascript datums/Zeitformat für die VOM Zeit
                    var upper; // enthält Javascript datums/Zeitformat für die BIS Zeit
                    var astrovonDown = zeitvon.includes(KeyWordSunDown); // Astrozeit VON Sonnenuntergang gesetzt
                    var astrovonUp = zeitvon.includes(KeyWordSunUp); // Astrozeit VON Sonnenaufgang gesetzt
                    var astrobisDown = zeitbis.includes(KeyWordSunDown); // Astrozeit BIS Sonnenuntergang gesetzt
                    var astrobisUp = zeitbis.includes(KeyWordSunUp); // Astrozeit BIS Sonnenaufgang gesetzt
                    var astrovon = false;
                    var astrobis = false;

                    var StatusSwichTimes =checkSwitchTime(Gruppe);
                    
                    if (StatusSwichTimes) {                                  // es gibt einen aktuellen Eintrag bzw laufende Schaltzeit fuer diese Gruppe
                        if(debug ) { log("Routine IsTimeInRange - Gruppe"+ Gruppe +  " ist im definierten Zeitrange - Schaltung ist aktiv", "info") }
                        return true; // in Tabelle SwitchTime gibt es noch einen gültigen Eintrag also zurück zur Schaltung
                    }
                    
                    
                    // bei Verwendung von Astrozeiten werden die errechneten Zeiten in lower und upper gespeichert
                    if (astrovonDown === true) {                            // Astrozeit gesetzt VON Zeit ist Sonnenuntergang
                        lower =  getAstroDate("sunsetStart");
                        astrovon = true;
                    }
                    if (astrovonUp === true) {                              // Astrozeit gesetzt VON Zeit ist Sonnenaufgang
                        lower =  getAstroDate("sunriseEnd");
                        astrovon = true;
                    }
                    if (astrobisDown === true) {                            // Astrozeit gesetzt BIS Zeit ist Sonnenuntergang
                        upper =  getAstroDate("sunsetStart");
                        if(astrovonDown) {                                  // wenn VonZeit = untergang und BisZeit = Untergang - dann muss bis Zeit nächster Tag sein
                            upper.setDate(upper.getDate() + 1);             // 1 Tag (24 Stunden ) addieren da der bis Wert wahrscheinlich am nächsten Tag liegen muss        
                        }
                        astrobis = true;
                    }
                    if (astrobisUp === true) {                              // Astrozeit gesetzt BIS Zeit ist Sonnenaufgang
                        upper =  getAstroDate("sunriseEnd");
                        if(astrovonDown) {                                    // wenn VonZeit = aufgang und BisZeit = Aufgang - dann muss BIS Zeit nächster Tag sein
                           upper.setDate(upper.getDate() + 1);              // 1 Tag (24 Stunden ) addieren da der bis Wert wahrscheinlich am nächsten Tag liegen muss    
                        }
                        astrobis = true;
                    }
                    
                    // Wenn keine Astrozeiten verwendet werden werden Zeiten anhand der Zeitangaben errechnet
                    if (!astrovon) {
                        lower = addTime(zeitvon);                       // switch on time  im berechenbaren Format
                    }
                    if (!astrobis) {
                        upper = addTime(zeitbis);                       // switch off time im berechenbaren Format
                    }
                    
                    // Sonderfall:wenn die Zeitangaben sind identisch - also bis zeit nächster Tag und von Zeit muss auf now liegen
                    if (zeitvon === zeitbis) { 
                        upper.setDate(upper.getDate() + 1); // 24 Stunden zur Bis-Zeit Hinzufügen 
                        lower = now;                                        // wenn z.B. von 23:00:00 bis 23:00:00 eingegeben wurde dann soll immer geschaltet werden
                    

                    }

                     // Wenn jetzt noch die VON Zeit kleiner also die BIS Zeit ist muss die BIS Zeit evt auf den nächsten Tag gelegt werden. (oder auch sie ist abgelaufen)
                    if (upper < lower) {                                    // Die von Zeit ist groesser als die bis Zeit
                        if(astrovonDown) {                                  // im Falle von Astrovon kann es sein, dass die bis Zeit in den nächsten Tag geht
                            if( upper.getHours()  < ErlieastSunDown ) {     // Uewberpruefen ob die BisZeit kleiner als der Schwellwert ist
                                upper.setDate(upper.getDate() + 1);         // 1 Tag (24 Stunden ) addieren da der bis Wert wahrscheinlich am nächsten Tag liegen muss 
                                if (debug) { log("Routine IsTimeInRange - Gruppe"+ Gruppe +" bei Astrovon die zeitbis started Morgen - AstroZeit Sonnenuntergang VON ist "+ lower ,"info");}
                            }
                        }
                        if(astrovonUp) {                                    // im Falle von Astrovon kann es sein, dass die bis Zeit in den nächsten Tag geht
                            if( upper.getHours()  < EarliestSunUp ) {       // Uewberpruefen ob die BisZeit kleiner als der Schwellwert ist
                                upper.setDate(upper.getDate() + 1);         // 1 Tag (24 Stunden ) addieren da der bis Wert wahrscheinlich am nächsten Tag liegen muss 
                                if (debug) { log("Routine IsTimeInRange - Gruppe"+ Gruppe + " bei Astrovon die zeitbis started Morgen - AstroZeit Sonnenaufgang VON ist "+ lower,"info");}
                            }
                        }
                    
                       if(astrobisDown) {                                   // im Falle von Astrovon kann es sein, dass die bis Zeit in den nächsten Tag geht
                            if( lower.getHours()  > LatestSunDown ) {       // Uewberpruefen ob die vonZeit groesser als der Schwellwert ist
                                upper.setDate(upper.getDate() + 1);         // 1 Tag (24 Stunden ) addieren da der bis Wert wahrscheinlich am nächsten Tag liegen muss 
                                if (debug) { log("Routine IsTimeInRange - Gruppe"+ Gruppe + " bei Astrovon die zeitbis started Morgen - AstroZeit Sonnenuntergang BIS ist "+ upper,"info");}
                            }
                        }
                        if(astrobisUp) {                                    // im Falle von Astrovon kann es sein, dass die bis Zeit in den nächsten Tag geht
                            if( lower.getHours()  > LatestSunDown ) {       // Uewberpruefen ob die VonZeit groesser als der Schwellwert ist
                                upper.setDate(upper.getDate() + 1);         // 1 Tag (24 Stunden ) addieren da der bis Wert wahrscheinlich am nächsten Tag liegen muss 
                                if (debug) { log("Routine IsTimeInRange - Gruppe"+ Gruppe + " bei Astrovon die zeitbis started Morgen- - AstroZeit Sonnenaufgang BIS  ist "+ upper,"info");}
                            }
                        }
                    
                        if (!astrovon && !astrobis) {                       // wenn keine Astrozeit gesetzt ist und die bis Zeit kleiner ist --> nächster Tag für die BisZeit
                            upper.setDate(upper.getDate() + 1);             // 1 Tag (24 Stunden ) addieren da der bis Wert wahrscheinlich am nächsten Tag liegen muss 
                        }
                    }
                    

                    if (debug) {log("Routine IsTimeInRange - Gruppe"+ Gruppe + " Berechnung der Zeiten: VON " + lower + " BIS " + upper,"info");}

                    // Wenn jetzt noch die BIS Zeit kleiner also die VON Zeit ist, dann ist die Zeit abgelaufen
                    if (upper < lower ) {                               // dies trifft zu wenn die astrozeit die realzeit eingeholt hat z.B. astrovon = 20:00 und bisZeit 19:00
                        if (debug) { log("Routine IsTimeInRange - Gruppe"+ Gruppe + " upper ist kleiner als lower - zurück Gruppe nicht (mehr) im Zeitrange false","info");}
                        return false;
                    }
                    if( now >= lower && now <= upper ) {
                        log("Routine IsTimeInRange - Gruppe"+ Gruppe + " aktuelle ist ist > als lower und kleiner als upper - Gruppe wird geschaltet (true)" );
                        UpdateSwithTime(Gruppe,lower,upper);
                        // if(debug ) { listcheckSwitch(Gruppe);}
                        return true;
                    } else {
                        log("Routine IsTimeInRange - Gruppe"+ Gruppe + " Zeit nicht im Zeitrange - keine Schaltung ")
                        return false;
                    }
                    

                    }

                    //-----------------------------------------------------------------------------------------------------
                    // Funktion checkSwithTime zum Finden in Tabelle SwitchTimes ob es einen Gültigen Eintrag innerhalb der Zeit gibt
                    // Struktur SwitchTimes: 0 = Schaltgruppe, 1 = vonZeit, 2 = bisZeit
                    //-----------------------------------------------------------------------------------------------------
                    function listcheckSwitch() {
                    for (var x in SwitchTimes) {
                    log("Routine listcheckSwitch - Gruppe" +SwitchTimes[x][0] + " Zeitvon " + SwitchTimes[x][1] + " Zeitbis " + SwitchTimes[x][2],"info");
                    }

                    }

                    //-----------------------------------------------------------------------------------------------------
                    // Funktion checkSwithTime zum Finden in Tabelle SwitchTimes ob es einen Gültigen Eintrag innerhalb der Zeit gibt
                    // Struktur SwitchTimes: 0 = Schaltgruppe, 1 = vonZeit, 2 = bisZeit
                    //-----------------------------------------------------------------------------------------------------
                    function checkSwitchTime(Gruppe) {
                    var now = new Date();

                    for (var x in SwitchTimes) {
                        if(SwitchTimes[x][0] === Gruppe) {
                            if( now >= SwitchTimes[x][1] && now <= SwitchTimes[x][2] ) {
                                return true;
                            }
                        }
                    }
                    return false;
                    

                    } // Ende Function checkSwitchTime

                    //-----------------------------------------------------------------------------------------------------
                    // Funktion UpdateSwithTime macht einen update auf die Tabelle für ausgelaufene Schaltzeiten und für neue
                    // Struktur SwitchTimes: 0 = Schaltgruppe, 1 = vonZeit, 2 = bisZeit
                    //-----------------------------------------------------------------------------------------------------
                    function UpdateSwithTime(Gruppe,VonZeit,BisZeit) {
                    for (var x in SwitchTimes) {
                    if(SwitchTimes[x][0] === Gruppe) {
                    if(debug){ log("Routine UpdateSwithTime - Gruppe " + Gruppe + " Switchtime Update VON " + VonZeit + " BIS " + BisZeit,"info" );}
                    SwitchTimes[Gruppe][1] = VonZeit;
                    SwitchTimes[Gruppe][2] = BisZeit;
                    return;
                    }
                    }
                    SwitchTimes.push([Gruppe, VonZeit, BisZeit]); // nicht gefunden - also hinzufügen
                    if(debug){ log("Routine UpdateSwithTime - Gruppe" + Gruppe + " Switchtime hinzufuegen VON " + VonZeit + " BIS " + BisZeit,"info" );}

                    }

                    //-----------------------------------------------------------------------------------------------------
                    // Funktion zur Erzeugung von führenden Nullen für das Datum Format
                    //-----------------------------------------------------------------------------------------------------
                    function addZero(i) {
                    if (i < 10) {
                    i = "0" + i;
                    }
                    return i;
                    } // Ende Funktion

                    //-----------------------------------------------------------------------------------------------------
                    // Funktion Millisekunden in Datum/Zeit umrechnen /wird für logging benoetigt
                    //-----------------------------------------------------------------------------------------------------
                    function millisecToDate(millisec) {
                    var time = new Date(millisec);
                    var Thour = addZero(time.getHours());
                    var Tmin = addZero(time.getMinutes());
                    var Tsec = addZero(time.getSeconds());
                    var datum = Thour + ':' + Tmin + ':' + Tsec;
                    return datum;
                    } // Ende Funktion

                    //-----------------------------------------------------------------------------------------------------
                    //Funktion addTime wandelt einen String mit Format 00:00:00 in rechenbare Zeit um
                    //-----------------------------------------------------------------------------------------------------
                    function addTime(strTime) {
                    var d = new Date();
                    d = new Date(d.getFullYear(), d.getMonth(), d.getDate())
                    var time = strTime.split(':');
                    d.setHours(time[0]);
                    d.setMinutes(time[1]);
                    d.setSeconds(time[2]);
                    return d;
                    }

                    Dank dir vorab!

                    gelöst Fehler gefunden:
                    Bei mir Zeile 172 bis 176 sind falsch, hier die richtige Version:

                    var cron1job = "* "+cron1+" * * * *";       // CRON pattern aufgrund der Vorgabe in den Einstellungen
                    var cron2job = "* "+cron2+" * * * *";       // CRON pattern aufgrund der Vorgabe in den Einstellungen
                    var cron3job = "* "+cron3+" * * * *";       // CRON pattern aufgrund der Vorgabe in den Einstellungen
                    var cron4job = "* "+cron4+" * * * *";       // CRON pattern aufgrund der Vorgabe in den Einstellungen
                    var cron5job = "* "+cron5+" * * * *"; 
                    

                    Was hast Du geändert? Was war das Ziel?

                    1 Reply Last reply Reply Quote 0
                    • B
                      Beowolf last edited by Beowolf

                      Hat sich erledigt - Firefox hat die Anzeige nicht aktualisiert. Nach einen manuellem Neuladen ist alles gut.

                      1 Reply Last reply Reply Quote 0
                      • L
                        LK1976 last edited by LK1976

                        Hallo Zusammen,

                        wer kann mir helfen. Nach einem Tag Laufzeit werden Schaltintervalle nicht mehr ausgeführt. Dann befindet sich im Log u. a. folgender Eintrag

                        error: javascript.0 (674) Error in callback: TypeError: Cannot set properties of undefined (setting '1')
                        
                        2023-02-11 21:50:00.005 - info: javascript.0 (674) script.js.Anwesenheitssimulation.Anwesenheitssimulation_AWS: Gruppe5 Berechnung der Zeiten: VON Sat Feb 11 2023 00:00:00 GMT+0100 (Central European Standard Time) BIS Sat Feb 11 2023 00:00:01 GMT+0100 (Central European Standard Time)
                        2023-02-11 21:50:00.006 - info: javascript.0 (674) script.js.Anwesenheitssimulation.Anwesenheitssimulation_AWS: Gruppe5 aktuelle Zeit nicht im Zeitrange - keine Schaltung
                        2023-02-11 21:50:00.010 - info: javascript.0 (674) script.js.Anwesenheitssimulation.Anwesenheitssimulation_AWS: Gruppe4 Berechnung der Zeiten: VON Sat Feb 11 2023 00:00:00 GMT+0100 (Central European Standard Time) BIS Sat Feb 11 2023 00:00:01 GMT+0100 (Central European Standard Time)
                        2023-02-11 21:50:00.010 - info: javascript.0 (674) script.js.Anwesenheitssimulation.Anwesenheitssimulation_AWS: Gruppe4 aktuelle Zeit nicht im Zeitrange - keine Schaltung
                        2023-02-11 21:50:00.016 - info: javascript.0 (674) script.js.Anwesenheitssimulation.Anwesenheitssimulation_AWS: Gruppe3 Berechnung der Zeiten: VON Sat Feb 11 2023 00:00:00 GMT+0100 (Central European Standard Time) BIS Sat Feb 11 2023 00:00:01 GMT+0100 (Central European Standard Time)
                        2023-02-11 21:50:00.016 - info: javascript.0 (674) script.js.Anwesenheitssimulation.Anwesenheitssimulation_AWS: Gruppe3 aktuelle Zeit nicht im Zeitrange - keine Schaltung
                        2023-02-11 21:50:00.021 - info: javascript.0 (674) script.js.Anwesenheitssimulation.Anwesenheitssimulation_AWS: Gruppe2 Berechnung der Zeiten: VON Sat Feb 11 2023 00:00:00 GMT+0100 (Central European Standard Time) BIS Sat Feb 11 2023 00:00:01 GMT+0100 (Central European Standard Time)
                        2023-02-11 21:50:00.021 - info: javascript.0 (674) script.js.Anwesenheitssimulation.Anwesenheitssimulation_AWS: Gruppe2 aktuelle Zeit nicht im Zeitrange - keine Schaltung
                        2023-02-11 21:50:00.028 - info: javascript.0 (674) script.js.Anwesenheitssimulation.Anwesenheitssimulation_AWS: Gruppe1 Berechnung der Zeiten: VON Sat Feb 11 2023 17:35:55 GMT+0100 (Central European Standard Time) BIS Sat Feb 11 2023 23:45:00 GMT+0100 (Central European Standard Time)
                        2023-02-11 21:50:00.028 - info: javascript.0 (674) script.js.Anwesenheitssimulation.Anwesenheitssimulation_AWS: Gruppe1 aktuelle Zeit ist größer als lower und kleiner als upper - Gruppe wird geschaltet (true)
                        2023-02-11 21:50:00.028 - info: javascript.0 (674) script.js.Anwesenheitssimulation.Anwesenheitssimulation_AWS: Gruppe 1 Switchtime Update VON Sat Feb 11 2023 17:35:55 GMT+0100 (Central European Standard Time) BIS Sat Feb 11 2023 23:45:00 GMT+0100 (Central European Standard Time)
                        2023-02-11 21:50:00.029 - error: javascript.0 (674) Error in callback: TypeError: Cannot set properties of undefined (setting '1')
                        2023-02-11 21:50:00.029 - error: javascript.0 (674) at UpdateSwitchTime (script.js.Anwesenheitssimulation.Anwesenheitssimulation_AWS:582:35)
                        2023-02-11 21:50:00.029 - error: javascript.0 (674) at IsTimeInRange (script.js.Anwesenheitssimulation.Anwesenheitssimulation_AWS:535:9)
                        2023-02-11 21:50:00.029 - error: javascript.0 (674) at Object. (script.js.Anwesenheitssimulation.Anwesenheitssimulation_AWS:188:8)
                        2023-02-11 21:50:00.030 - error: javascript.0 (674) at Job.job (/opt/iobroker/node_modules/iobroker.javascript/lib/sandbox.js:1595:34)
                        2023-02-11 21:50:00.030 - error: javascript.0 (674) at Job.invoke (/opt/iobroker/node_modules/node-schedule/lib/Job.js:171:15)
                        2023-02-11 21:50:00.030 - error: javascript.0 (674) at /opt/iobroker/node_modules/node-schedule/lib/Invocation.js:268:28
                        2023-02-11 21:50:00.030 - error: javascript.0 (674) at Timeout._onTimeout (/opt/iobroker/node_modules/node-schedule/lib/Invocation.js:228:7)
                        2023-02-11 21:50:00.030 - error: javascript.0 (674) at listOnTimeout (node:internal/timers:559:17)
                        2023-02-11 21:50:00.030 - error: javascript.0 (674) at processTimers (node:internal/timers:502:7)
                        2023-02-11 21:55:00.004 - info: javascript.0 (674) script.js.Anwesenheitssimulation.Anwesenheitssimulation_AWS: Gruppe1 Berechnung der Zeiten: VON Sat Feb 11 2023 17:35:55 GMT+0100 (Central European Standard Time) BIS Sat Feb 11 2023 23:45:00 GMT+0100 (Central European Standard Time)
                        2023-02-11 21:55:00.005 - info: javascript.0 (674) script.js.Anwesenheitssimulation.Anwesenheitssimulation_AWS: Gruppe1 aktuelle Zeit ist größer als lower und kleiner als upper - Gruppe wird geschaltet (true)
                        2023-02-11 21:55:00.005 - info: javascript.0 (674) script.js.Anwesenheitssimulation.Anwesenheitssimulation_AWS: Gruppe 1 Switchtime Update VON Sat Feb 11 2023 17:35:55 GMT+0100 (Central European Standard Time) BIS Sat Feb 11 2023 23:45:00 GMT+0100 (Central European Standard Time)
                        2023-02-11 21:55:00.005 - error: javascript.0 (674) Error in callback: TypeError: Cannot set properties of undefined (setting '1')
                        2023-02-11 21:55:00.006 - error: javascript.0 (674) at UpdateSwitchTime (script.js.Anwesenheitssimulation.Anwesenheitssimulation_AWS:582:35)
                        2023-02-11 21:55:00.006 - error: javascript.0 (674) at IsTimeInRange (script.js.Anwesenheitssimulation.Anwesenheitssimulation_AWS:535:9)
                        2023-02-11 21:55:00.006 - error: javascript.0 (674) at Object. (script.js.Anwesenheitssimulation.Anwesenheitssimulation_AWS:188:8)
                        2023-02-11 21:55:00.006 - error: javascript.0 (674) at Job.job (/opt/iobroker/node_modules/iobroker.javascript/lib/sandbox.js:1595:34)
                        2023-02-11 21:55:00.006 - error: javascript.0 (674) at Job.invoke (/opt/iobroker/node_modules/node-schedule/lib/Job.js:171:15)
                        2023-02-11 21:55:00.006 - error: javascript.0 (674) at /opt/iobroker/node_modules/node-schedule/lib/Invocation.js:268:28
                        2023-02-11 21:55:00.006 - error: javascript.0 (674) at Timeout._onTimeout (/opt/iobroker/node_modules/node-schedule/lib/Invocation.js:228:7)
                        2023-02-11 21:55:00.006 - error: javascript.0 (674) at listOnTimeout (node:internal/timers:559:17)
                        2023-02-11 21:55:00.007 - error: javascript.0 (674) at processTimers (node:internal/timers:502:7)
                        2023-02-11 21:55:00.013 - info: javascript.0 (674) script.js.Anwesenheitssimulation.Anwesenheitssimulation_AWS: Gruppe2 Berechnung der Zeiten: VON Sat Feb 11 2023 00:00:00 GMT+0100 (Central European Standard Time) BIS Sat Feb 11 2023 00:00:01 GMT+0100 (Central European Standard Time)
                        2023-02-11 21:55:00.013 - info: javascript.0 (674) script.js.Anwesenheitssimulation.Anwesenheitssimulation_AWS: Gruppe2 aktuelle Zeit nicht im Zeitrange - keine Schaltung
                        2023-02-11 21:55:00.019 - info: javascript.0 (674) script.js.Anwesenheitssimulation.Anwesenheitssimulation_AWS: Gruppe3 Berechnung der Zeiten: VON Sat Feb 11 2023 00:00:00 GMT+0100 (Central European Standard Time) BIS Sat Feb 11 2023 00:00:01 GMT+0100 (Central European Standard Time)
                        2023-02-11 21:55:00.019 - info: javascript.0 (674) script.js.Anwesenheitssimulation.Anwesenheitssimulation_AWS: Gruppe3 aktuelle Zeit nicht im Zeitrange - keine Schaltung
                        2023-02-11 21:55:00.024 - info: javascript.0 (674) script.js.Anwesenheitssimulation.Anwesenheitssimulation_AWS: Gruppe4 Berechnung der Zeiten: VON Sat Feb 11 2023 00:00:00 GMT+0100 (Central European Standard Time) BIS Sat Feb 11 2023 00:00:01 GMT+0100 (Central European Standard Time)
                        2023-02-11 21:55:00.025 - info: javascript.0 (674) script.js.Anwesenheitssimulation.Anwesenheitssimulation_AWS: Gruppe4 aktuelle Zeit nicht im Zeitrange - keine Schaltung
                        2023-02-11 21:55:00.030 - info: javascript.0 (674) script.js.Anwesenheitssimulation.Anwesenheitssimulation_AWS: Gruppe5 Berechnung der Zeiten: VON Sat Feb 11 2023 00:00:00 GMT+0100 (Central European Standard Time) BIS Sat Feb 11 2023 00:00:01 GMT+0100 (Central European Standard Time)
                        2023-02-11 21:55:00.032 - info: javascript.0 (674) script.js.Anwesenheitssimulation.Anwesenheitssimulation_AWS: Gruppe5 aktuelle Zeit nicht im Zeitrange - keine Schaltung
                        2023-02-11 22:00:00.004 - info: javascript.0 (674) script.js.Anwesenheitssimulation.Anwesenheitssimulation_AWS: Gruppe5 Berechnung der Zeiten: VON Sat Feb 11 2023 00:00:00 GMT+0100 (Central European Standard Time) BIS Sat Feb 11 2023 00:00:01 GMT+0100 (Central European Standard Time)
                        2023-02-11 22:00:00.004 - info: javascript.0 (674) script.js.Anwesenheitssimulation.Anwesenheitssimulation_AWS: Gruppe5 aktuelle Zeit nicht im Zeitrange - keine Schaltung
                        2023-02-11 22:00:00.010 - info: javascript.0 (674) script.js.Anwesenheitssimulation.Anwesenheitssimulation_AWS: Gruppe4 Berechnung der Zeiten: VON Sat Feb 11 2023 00:00:00 GMT+0100 (Central European Standard Time) BIS Sat Feb 11 2023 00:00:01 GMT+0100 (Central European Standard Time)
                        2023-02-11 22:00:00.010 - info: javascript.0 (674) script.js.Anwesenheitssimulation.Anwesenheitssimulation_AWS: Gruppe4 aktuelle Zeit nicht im Zeitrange - keine Schaltung
                        2023-02-11 22:00:00.018 - info: javascript.0 (674) script.js.Anwesenheitssimulation.Anwesenheitssimulation_AWS: Gruppe3 Berechnung der Zeiten: VON Sat Feb 11 2023 00:00:00 GMT+0100 (Central European Standard Time) BIS Sat Feb 11 2023 00:00:01 GMT+0100 (Central European Standard Time)
                        2023-02-11 22:00:00.018 - info: javascript.0 (674) script.js.Anwesenheitssimulation.Anwesenheitssimulation_AWS: Gruppe3 aktuelle Zeit nicht im Zeitrange - keine Schaltung
                        2023-02-11 22:00:00.022 - info: javascript.0 (674) script.js.Anwesenheitssimulation.Anwesenheitssimulation_AWS: Gruppe2 Berechnung der Zeiten: VON Sat Feb 11 2023 00:00:00 GMT+0100 (Central European Standard Time) BIS Sat Feb 11 2023 00:00:01 GMT+0100 (Central European Standard Time)
                        2023-02-11 22:00:00.023 - info: javascript.0 (674) script.js.Anwesenheitssimulation.Anwesenheitssimulation_AWS: Gruppe2 aktuelle Zeit nicht im Zeitrange - keine Schaltung
                        2023-02-11 22:00:00.028 - info: javascript.0 (674) script.js.Anwesenheitssimulation.Anwesenheitssimulation_AWS: Gruppe1 Berechnung der Zeiten: VON Sat Feb 11 2023 17:35:55 GMT+0100 (Central European Standard Time) BIS Sat Feb 11 2023 23:45:00 GMT+0100 (Central European Standard Time)
                        2023-02-11 22:00:00.028 - info: javascript.0 (674) script.js.Anwesenheitssimulation.Anwesenheitssimulation_AWS: Gruppe1 aktuelle Zeit ist größer als lower und kleiner als upper - Gruppe wird geschaltet (true)
                        2023-02-11 22:00:00.029 - info: javascript.0 (674) script.js.Anwesenheitssimulation.Anwesenheitssimulation_AWS: Gruppe 1 Switchtime Update VON Sat Feb 11 2023 17:35:55 GMT+0100 (Central European Standard Time) BIS Sat Feb 11 2023 23:45:00 GMT+0100 (Central European Standard Time)
                        2023-02-11 22:00:00.029 - error: javascript.0 (674) Error in callback: TypeError: Cannot set properties of undefined (setting '1')
                        2023-02-11 22:00:00.030 - error: javascript.0 (674) at UpdateSwitchTime (script.js.Anwesenheitssimulation.Anwesenheitssimulation_AWS:582:35)
                        2023-02-11 22:00:00.030 - error: javascript.0 (674) at IsTimeInRange (script.js.Anwesenheitssimulation.Anwesenheitssimulation_AWS:535:9)
                        2023-02-11 22:00:00.030 - error: javascript.0 (674) at Object. (script.js.Anwesenheitssimulation.Anwesenheitssimulation_AWS:188:8)
                        2023-02-11 22:00:00.030 - error: javascript.0 (674) at Job.job (/opt/iobroker/node_modules/iobroker.javascript/lib/sandbox.js:1595:34)
                        2023-02-11 22:00:00.030 - error: javascript.0 (674) at Job.invoke (/opt/iobroker/node_modules/node-schedule/lib/Job.js:171:15)
                        2023-02-11 22:00:00.030 - error: javascript.0 (674) at /opt/iobroker/node_modules/node-schedule/lib/Invocation.js:268:28
                        2023-02-11 22:00:00.030 - error: javascript.0 (674) at Timeout._onTimeout (/opt/iobroker/node_modules/node-schedule/lib/Invocation.js:228:7)
                        2023-02-11 22:00:00.031 - error: javascript.0 (674) at listOnTimeout (node:internal/timers:559:17)
                        2023-02-11 22:00:00.031 - error: javascript.0 (674) at processTimers (node:internal/timers:502:7)
                        

                        Nach einem Neustart der Instanz funktioniert es ca. 24 Std., bis dann wieder Intervalle nicht geschaltet werden und selbiger Fehlertext im Log erscheint.

                        Es wäre super nett, wenn mir jemand eine Lösung oder die Ursache mitteilen könnte. Ich selber bin leider mangels Programmierkenntnisse dazu nicht in der Lage.


                        Mod-Edit: Code/Log in Code Tags gepackt. Bitte benutzt die Code Tags Funktion -> </>
                        Hier gehts zur Hilfe.

                        paul53 1 Reply Last reply Reply Quote 0
                        • L
                          LK1976 @skorpil last edited by

                          @skorpil Ich habe dasselbe Problem, also dieselben Fehlereinträge im Log. Hast DU eine Lösung gefunden, woran es lag bzw. wie man das Problem lösen kann?

                          S 1 Reply Last reply Reply Quote 0
                          • S
                            skorpil @LK1976 last edited by

                            @lk1976 leider, nein!

                            1 Reply Last reply Reply Quote 0
                            • L
                              LK1976 @pix last edited by

                              @pix Hallo "Pix", kannst Du mein Problem am Ende dieses Forums lösen? Du scheinst Dich ja vor langer Zeit einmal mit dem Anwesenheitssimulator auseinandergesetzt zu haben. Ich selber verfüge leider nicht über das Know how es lösen zu können. Daher wäre ich Dir sehr dankbar, wenn Du mal schauen könntest. Vorab vielen Dank!

                              S 1 Reply Last reply Reply Quote 1
                              • S
                                skorpil @LK1976 last edited by

                                @lk1976 wer vielleicht auch helfen könnte ist @paul53.

                                1 Reply Last reply Reply Quote 0
                                • paul53
                                  paul53 @LK1976 last edited by

                                  @lk1976 sagte: im Log u. a. folgender Eintrag

                                  Was steht im Skript in den Zeilen 188, 535 und 582?

                                  S L 3 Replies Last reply Reply Quote 0
                                  • S
                                    skorpil @paul53 last edited by

                                    @paul53 obwohl ich nicht weiß, ob bei @LK1976 exakt das gleiche Script läuft, hier mal das meinige (sollten identisch sein):

                                    //..........Anwesenheitssimulation AWS
                                    //..........Initiales Datum: 28.12.2015
                                    //..........Autor: Looxer01
                                    //..........Forum ioBroker
                                    //..........http://forum.iobroker.com/posting.php?mode=post&f=21&sid=b3b2a31dae55081fedaf0ad9c8d74acd
                                    //
                                    //..........Änderungshistorie
                                    //..........Version 0.10 Initial 28.12.2015
                                    //..........Version 0.11 29.12.2015 Einstellungen um Astrozeiten erweitert (noch ohne Funktion)
                                    //.........,Version 0.12 29.12.2015 EVENT Deaktivierung von AWS hinzugefügt: Schreiben Log und loeschen Schedules
                                    //...............................................Aktivierung von AWS hihzugüfügt: Schreiben Log bei Aktivierung
                                    //..........Version 0.13 29.12.2015 das Schreiben des externen Logs optional gemacht - unter Einstellungen auswaehlbar
                                    //..........Version 0.20 29.12.2015 Astrozeit Funktion hinzugefügt. Astrozeit wird je IDGruppe auf true/false gesetzt und overruled die variablen zeit1von,zeit2von,zeit3von,zeit4von,zeit5von
                                    //..........Version 0.30 29.12.2015 Umarbeitung zur Verkürzung des Scripts
                                    //..........Version 0.31 30.12.2015 Fehlerbeseitigung in IDGruppen3 und 4 - einige Code Hygiene Massnahmen
                                    //..................................Umbenennung der IDGruppen mit führend "ID" / Startverzögerungseinstellungen hinzugefügt
                                    //..........Version 0.32 30.12.2015 umgestellt auf setStateDelayed / Startverzögerungsfunktion hinzugefügt.
                                    //..........Version 0.33 31.12.2015 Fehler mit EVAL Funktion gefixt / Fehler mit Startverzoegerung und Einschaltzeiten gefixt
                                    //..................................Funktion Anzahl von Geraete Teilnehmer zur Geraete ID bestimmung hinzugefügt
                                    //..........Version 0.40 01.01.2016 Log-Pfad variablel gemacht // Log-File Format umgearbeitet und Headerline hinzugefügt fuer externes Log. Internes Log ueberarbeitet
                                    //..........Version 0.41 02.01.2016 Funktionen von Baetz zum TimeInRange Check hinzugefuegt. Keine Globale Funktion mehr notwendig. -- Kommentarte ueberarbeitet
                                    //..........Version 0.42 02.01.2015 Herkunftsnachweis für IsTimeInRange Funktion hinzugefuegt
                                    //..................................Fehler zur zufaelligen Geraete Findung behoben. Das letzte Geraet wurde nie ausgewaehlt // Fehler im log "Gearaet wurde nicht eingeschaltet wurde gelogged auch wenn es eingeschaltet wurde"
                                    //..........Version 0.43 03.01.2015 Wenn AWS auf inaktiv gesetzt wird, dann werden alle teilnehmenden Geraete ausgeschaltet -  Dokumentation der Variablen / variablen deklaration nachgeholt fuer zwei Faelle
                                    //..........Version 0.44 04.01.2015 Addieren der Einschaltverzoegerung zur Ausschaltzeit fuer die Ausschaltzeitberechnung // Fixed Fehler doppelte Schaltung fuer STATE geraete
                                    //..........Version 0.45 04.01.2015 weiterer Fehler zur Berechnung der Ausschaltzeit korrigiert
                                    //..........Version 0.50 04.01.2015 Beseitigung unnötiges Coding // Ueberpruefung ob Geraet existiert hinzugefuegt - LogMeldung falls nicht hinzugefuegt. - kein Javascript restart mehr, wenn geraet nicht existiert
                                    //..........Version 0.60 04.01.2015 Ausschalten der Teilnehmer bei Deaktivierung optimiert. Ausschaltung optional gemacht / Astrozeit ueberarbeitet
                                    //..................................Astrozeit auch fuer die bis Zeit hinzugefuegt. Damit lassen sich Schaltungen bis zum Sonnenaufgang umsetzen / weitere Codeoptimierungen
                                    //..........Version 0.61 05.01.2015 Beim  Ausschalten Verzoegerung zwischen Schaltvorgange eingebaut  / Codeiptimierung bei den Gruppen Schedules / Fehler bei der  GrpZufAnz und StartDelay beseitigt fuer Gruppen 2-5
                                    //..........Version 0.65 06.01.2015 Reaktion bei bereits eigneschalteten Lampen variabel gemacht / Codeoptimierungen / ID fuer AWS-Aktiv ist jetzt variabel
                                    //..........Version 0.70 26.01.2015 SetStateDelayed ist jetzt in javascript gefixt ab JS version 1.1.2 - Das Loeschen von Ein/Auschaltplanungen wird jetzt mit dem neuen Befehl clearStateDelayed gemacht
                                    //..................................Vorläufig wurde das Merken der letzten Aktion geloescht, da es keine Verwendung im Moment hat
                                    //..........Version 0.75 27.01.2015 Fehler beim Loeschen von Ein/Auschaltplanungen behoben - Es wurde nicht geloescht, wenn Verbraucher eingeschaltet bleiben sollen
                                    //..........Version 0.80 28.04.2016 Fehler mit der Astrozeit, wenn die BisZeit < ist als die Astrozeit(von) beseitigt
                                    //..........Version 0.90 23.12.2017 Einund Ausschaltbefehle jetzt als Variable einstellbar. Damit lassen sich auch andere Geräte einbindungen (z.B KNX mit 0 und 1). Level und STATE Geräte als Boolean und number identifziert
                                    //..........Version 0.91 19.01.2018 Ein Ausschaltbefehl war noch nicht mit der Ausschaltvariable verknüpft
                                    //..................................Die IDAWSaktiv war mit einem falschen Datenpunkt verknüpft
                                    //..........Version 0.92.03.12.2018.Fehler behoben nach update auf JS 4.0.1 !fs.existsSync funktioniert nicht mehr ausgetausch mit fs.readFile
                                    //..........Version 0.94.27.01.2019 Fehler behoben: Wenn Zeit in den nächsten Tag reichte, dann wurden beu Astronutzung die Start und Endzeiten nicht richtig berechnet
                                    //................................. Sonnenaufgang und Sonnenuntergang können statt der Zeitangabe eingegeben werden. 
                                    //................................. In der VonZeit kann jetzt auch Sonnenaufgang eingegeben werden 
                                    //................................. Debug der Zeitenberechnung eingeführt
                                    //
                                    // Das Script wird aktiviert, wenn das Flag "Anwesenheitssteuerung gesetzt wird"
                                    // HIER Einstellungen vornehmen............................................................................................
                                    
                                    
                                    
                                    var KeyWordSunDown  = "SunSet";      // SONNENUNTERGANG - Bitte dieses Keyword in ZeitxVon oder ZeitxBis eintragen wenn Astrozeit gewünscht ist
                                    var KeyWordSunUp    = "SunRise";     // SONNENAUFGANG   - Bitte dieses Keyword in ZeitxVon oder ZeitxBis eintragen wenn Astrozeit gewünscht ist
                                    
                                    // Bei Eingabe des Keywords bei den Zeiten werden die Astrozeiten verwendet
                                    // Einstellungen der Aktivzeiten je IDGruppe von bis
                                    // Beispiel Zeiteingabe "23:30:00"
                                    
                                    var zeit1von = "SunSet";            //Aktivzeit von IDGruppe1
                                    var zeit1bis = "SunRise";          //Aktivzeit bis IDGruppe1
                                    
                                    var zeit2von = "SunSet";          //Aktivzeit von IDGruppe2
                                    var zeit2bis = "SunRise";          //Aktivzeit bis IDGruppe2
                                    
                                    var zeit3von = "SunSet";          //Aktivzeit von IDGruppe3
                                    var zeit3bis = "SunRise";          //Aktivzeit bis IDGruppe3
                                    
                                    var zeit4von = "SunSet";          //Aktivzeit von IDGruppe4
                                    var zeit4bis = "SunRise";          //Aktivzeit bis IDGruppe4
                                    
                                    var zeit5von = "SunSet";          //Aktivzeit von IDGruppe5
                                    var zeit5bis = "SunRise";          //Aktivzeit bis IDGruppe5
                                    
                                    
                                    
                                    // Einstellungen der zufaelligen Einschaltdauer je IDGruppe von bis
                                    var ein1von = 5;   // Minuten IDGruppe1 von
                                    var ein1bis = 40;   // Minuten IDGruppe1 bis
                                    
                                    var ein2von = 5;   // Minuten IDGruppe2 von
                                    var ein2bis = 40;   // Minuten IDGruppe2 bis
                                    
                                    var ein3von = 5;   // Minuten IDGruppe3 von
                                    var ein3bis = 10;   // Minuten IDGruppe3 bis
                                    
                                    var ein4von = 5;   // Minuten IDGruppe4 von
                                    var ein4bis = 10;   // Minuten IDGruppe4 bis
                                    
                                    var ein5von = 10;   // Minuten IDGruppe5 von
                                    var ein5bis = 30;   // Minuten IDGruppe5 bis
                                    
                                    
                                    // Einstellung je Gruppe für die  maximale  Startverzögerung in Minuten
                                    // bei 0 = keine Startverzögerung - bei z.B. 10 = Startverzögerung zwischen 0 und 10 in Minuten
                                    //
                                    var StartDelay1 = 19;   // Maximale Startverzoegerung Gruppe1
                                    var StartDelay2 = 17;   // Maximale Startverzoegerung Gruppe2
                                    var StartDelay3 = 0;   // Maximale Startverzoegerung Gruppe3
                                    var StartDelay4 = 0;   // Maximale Startverzoegerung Gruppe4
                                    var StartDelay5 = 0;   // Maximale Startverzoegerung Gruppe5
                                    
                                    
                                    
                                    
                                    // Einstellung Check-schedule  - Voreinstellung z.B. alle 30  Minuten je IDGruppe - Damit wird je Lauf nach Zufaelligkeit je ein Geraet der IDGruppe eingeschaltet
                                    var cron1 = 47;  // checks alle x Minuten für IDGruppe1
                                    var cron2 = 57; //  checks alle x Minuten für IDGruppe2
                                    var cron3 = 58; //  checks alle x Minuten für IDGruppe3
                                    var cron4 = 59; //  checks alle x Minuten für IDGruppe4
                                    var cron5 = 56; //  checks alle x Minuten für IDGruppe5
                                    
                                    
                                    
                                    // Einstellung teilnehmende Homematic Geräte je IDGruppe maximal 5 - Eingabe der Homematic ID
                                    var     IDGruppe11 = 'hm-rpc.0.JEQ0464470.1.STATE'/*Zw  Stecker 1 STATE*/ //Diele
                                    var     IDGruppe12 = 'hm-rpc.0.JEQ0461675.1.STATE'/*Zw  Stecker 2 STATE*/ //Treppenhaus
                                    var     IDGruppe13 = "  "; 
                                    var     IDGruppe14 = "  ";
                                    var     IDGruppe15 = "  ";
                                    var     Grp1ZufAnz = 2;              // Anzahl der Geräte zur zufälligen Bestimmung des Geraetes 
                                    
                                    var     IDGruppe21 = 'hm-rpc.0.KEQ0177570.1.STATE'/*Zw  Stecker 3 STATE*/  //Bügelzimmer
                                    var     IDGruppe22 = 'hm-rpc.0.LEQ0763719.1.STATE'/*LichtSch KellerAbgSeite:1 STATE*/
                                    var     IDGruppe23 = "  ";
                                    var     IDGruppe24 = "  ";
                                    var     IDGruppe25 = "  "; 
                                    var     Grp2ZufAnz = 2;              // Anzahl der Geräte zur zufälligen Bestimmung des Geraetes 
                                    
                                    
                                    var     IDGruppe31 =  "  ";
                                    var     IDGruppe32 =  "  "; 
                                    var     IDGruppe33 =  "  ";
                                    var     IDGruppe34 = "  ";
                                    var     IDGruppe35 = "  "; 
                                    var     Grp3ZufAnz = 5;              // Anzahl der Geräte zur zufälligen Bestimmung des Geraetes 
                                    
                                    
                                    var     IDGruppe41 = "  ";
                                    var     IDGruppe42 = "  ";
                                    var     IDGruppe43 = "  ";
                                    var     IDGruppe44 = "  ";
                                    var     IDGruppe45 = "  "; 
                                    var     Grp4ZufAnz = 3;              // Anzahl der Geräte zur zufälligen Bestimmung des Geraetes 
                                    
                                    
                                    var     IDGruppe51 = "  ";
                                    var     IDGruppe52 = "  "; 
                                    var     IDGruppe53 = "  ";
                                    var     IDGruppe54 = "  ";
                                    var     IDGruppe55 = "  ";
                                    var     Grp5ZufAnz = 5;              // Anzahl der Geräte zur zufälligen Bestimmung des Geraetes 
                                    
                                    
                                    var logflag = false;     // wenn auf true dann wird das logging in Datei /opt/iobroker/iobroker-data/AWSLog.csv eingeschaltet bei false vice versa
                                    
                                    var ausflag = true;     // Wenn AWS deaktiviert wird, dann werden alle Teilnehmer ausgeschaltet
                                    
                                    
                                    // Experten-Einstellungen .......................................................................................................
                                    
                                    var IDAWSaktiv = "javascript.0.Anwesenheitssteuerung.AWSTest";      // in den objekten angelegte variable zur Bestimmung ob AWS aktiv ist - Kann auch ausgetauscht werden durch eine andere
                                    var LogPath = "/opt/iobroker/iobroker-data/AWSLogTest.csv";         // Pfad und Dateiname des externen Logs
                                    var IgnoreWhenOn = false;                                           // bei true: Ignoriert den Schaltvorgang, wenn das Geraet bereits eingeschaltet war
                                    var ErlieastSunDown = 16;                                           // Die Stunde des fruehesten Sonnenuntergangs z.B. in Deutschlnad 16 Uhr
                                    var EarliestSunUp   = 4;                                            // Die Stunde des fruehesten Sonnenuntergangs z.B. in Deutschlnad 4 Uhr
                                    var LatestSunDown = 21;                                             // Die Stunde des spätesten Sonnenuntergangs z.B. in Deutschlnad 21 Uhr
                                    var LatestSunUp   = 8;                                              // Die Stunde des spätestens Sonnenuntergangs z.B. in Deutschlnad 8 Uhr
                                    
                                    
                                    var EinschaltFlag = true;                                           // Einschaltbefehl der Teilnehmer fuer Boolean Geräte
                                    var AusschaltFlag = false;                                          // Ausschaltbefehl der Teilnehmer fuer Boolean Geräte
                                    var DimmAusschalt = 0;                                              // Ausschaltbefehl fuer Number Geräte (Dimmer)
                                    var DimmEinschalt = 100;                                            // Einschaltbefehl fuer Number Geräte (Dimmer) = Einschaltlevel auf den geschaltet wird
                                    var debug = false;                                                   // zusätzliche log Meldungen zur Analyse
                                    
                                    // Ende Experten-Einstellungen .......................................................................................................
                                    
                                    // globale Variablen
                                    var fs = require('fs');                     // enable write fuer externes log
                                    var cron1job = "*/"+cron1+" * * * *";       // CRON pattern aufgrund der Vorgabe in den Einstellungen
                                    var cron2job = "*/"+cron2+" * * * *";       // CRON pattern aufgrund der Vorgabe in den Einstellungen
                                    var cron3job = "*/"+cron3+" * * * *";       // CRON pattern aufgrund der Vorgabe in den Einstellungen
                                    var cron4job = "*/"+cron4+" * * * *";       // CRON pattern aufgrund der Vorgabe in den Einstellungen
                                    var cron5job = "*/"+cron5+" * * * *";       // CRON pattern aufgrund der Vorgabe in den Einstellungen
                                    var x = 0;                                  // Geraetenummer der Gruppe, die zufaellig ausgewaehlt wurde
                                    var y = 0;                                  //  Einschaltzdauer aufgrund der Zufallszahl in Millisekunden
                                    var z = 0;                                  // Einschaltverzögerung aufgrund der Zufallszahl
                                    var string = " ";                           // Logstring
                                    var logtext=" " ;                           // Kommentar im log
                                    var objIDGruppe = " ";                      // uebergabe an Funktion der IDGruppe zum Schalten des Geraetes
                                    var SpaceChk = new RegExp(/\s/);            // pattern um zu pruefen ob eine IDGruppe blanks enthaelt
                                    
                                    var SwitchTimes = [];                         // SwitchTimes wird genutzt um die Schaltzeiten zu merken. Das wird benötigt um Schaltzeiten die in den nächsten Tag reichen zu verwalten
                                                                                  // Struktur 0 = Schaltgruppe, 1 = vonZeit, 2 = bisZeit
                                    
                                    
                                    // Aktivierungsflag anlegen beim ersten Start des Scripts
                                    createState(IDAWSaktiv, true, {read: true, write: true, type: 'boolean', name: 'Anwesenheitssteuerungsflag', desc: 'Anwesenheitssteuerungsflag'});
                                    
                                    
                                    
                                    // Execute IDGruppe1     
                                    //-------------------------------------------------------------------------------------------------------------------------------------------------------
                                    schedule(cron1job, function() {
                                    if  (getState(IDAWSaktiv).val === true) {     // AWS aktiv ?
                                        if(IsTimeInRange(zeit1von, zeit1bis,1)) {              // ist die "von"-Zeit innerhalb des aktuellen Zeitfensters ?
                                            x = zufall(1,Grp1ZufAnz,x);                                                 // Ermittlung zufaelliges Geraet zum enschalten
                                            z = zufall(0,StartDelay1*60,y)*1000;                                        // Ermittlung der Einschaltverzögerung aufgrund der Zufallszahl
                                            y = zufall(ein1von*60,ein1bis*60,y)*1000;                                   // Ermittlung der Einschaltzdauer aufgrund der Zufallszahl in Millisekunden
                                            var IDGruppe = "IDGruppe1" + x;                                             // Ermittlung Gruppenname z.B. IDGruppe11
                                            if (x <= 5 && GeraetExists(IDGruppe)) {    AWSSchaltung(IDGruppe,y,z);  }   // Geraetenummer muss 1 - 5 sein, dass Geraet muss existieren dann schalten
                                        } // Ende Zeitcheck
                                    }  // Endeif für AWS-Aktivflag check   
                                    }); // end schedule IDGruppe1
                                    
                                    
                                    // Execute IDGruppe2     
                                    //-------------------------------------------------------------------------------------------------------------------------------------------------------
                                    schedule(cron2job, function() {
                                    if  (getState(IDAWSaktiv).val === true) {     // AWS aktiv ?
                                        if(IsTimeInRange(zeit2von, zeit2bis,2)) {              // ist die "von"-Zeit innerhalb des aktuellen Zeitfensters ?
                                            x = zufall(1,Grp2ZufAnz,x);                                                 // Ermittlung zufaelliges Geraet zum enschalten
                                            z = zufall(0,StartDelay2*60,y)*1000;                                        // Ermittlung der Einschaltverzögerung aufgrund der Zufallszahl
                                            y = zufall(ein2von*60,ein2bis*60,y)*1000;                                   // Ermittlung der Einschaltzdauer aufgrund der Zufallszahl in Millisekunden
                                            var IDGruppe = "IDGruppe2" + x;                                             // Ermittlung Gruppenname z.B. IDGruppe21
                                            if (x <= 5 && GeraetExists(IDGruppe)) {    AWSSchaltung(IDGruppe,y,z);  }   // Geraetenummer muss 1 - 5 sein, dass Geraet muss existieren dann schalten
                                        } // Ende Zeitcheck
                                    }  // Endeif für AWS-Aktivflag check   
                                    }); // end schedule IDGruppe2
                                    
                                    
                                    // Execute IDGruppe3   
                                    //-------------------------------------------------------------------------------------------------------------------------------------------------------
                                    schedule(cron3job, function() {
                                    if  (getState(IDAWSaktiv).val === true) {     // AWS aktiv ?
                                       if(IsTimeInRange(zeit3von, zeit3bis,3)) {              // ist die "von"-Zeit innerhalb des aktuellen Zeitfensters ?
                                            x = zufall(1,Grp3ZufAnz,x);                                                 // Ermittlung zufaelliges Geraet zum enschalten
                                            z = zufall(0,StartDelay3*60,y)*1000;                                        // Ermittlung der Einschaltverzögerung aufgrund der Zufallszahl
                                            y = zufall(ein3von*60,ein3bis*60,y)*1000;                                   // Ermittlung der Einschaltzdauer aufgrund der Zufallszahl in Millisekunden
                                            var IDGruppe = "IDGruppe3" + x;                                             // Ermittlung Gruppenname z.B. IDGruppe31
                                            if (x <= 5 && GeraetExists(IDGruppe)) {    AWSSchaltung(IDGruppe,y,z);  }   // Geraetenummer muss 1 - 5 sein, dass Geraet muss existieren dann schalten
                                      } // Ende Zeitcheck
                                    }  // Endeif für AWS-Aktivflag check   
                                    }); // end schedule IDGruppe3
                                    
                                    
                                    
                                    // Execute IDGruppe4   
                                    //-------------------------------------------------------------------------------------------------------------------------------------------------------
                                    schedule(cron4job, function() {
                                    if  (getState(IDAWSaktiv).val === true) {     // AWS aktiv ?
                                         if(IsTimeInRange(zeit4von, zeit4bis,4)) {              // ist die "von"-Zeit innerhalb des aktuellen Zeitfensters ?
                                            x = zufall(1,Grp4ZufAnz,x);                                                 // Ermittlung zufaelliges Geraet zum enschalten
                                            z = zufall(0,StartDelay4*60,y)*1000;                                        // Ermittlung der Einschaltverzögerung aufgrund der Zufallszahl
                                            y = zufall(ein4von*60,ein4bis*60,y)*1000;                                   // Ermittlung der Einschaltzdauer aufgrund der Zufallszahl in Millisekunden
                                            var IDGruppe = "IDGruppe4" + x;                                             // Ermittlung Gruppenname z.B. IDGruppe41
                                            if (x <= 5 && GeraetExists(IDGruppe)) {    AWSSchaltung(IDGruppe,y,z);  }   // Geraetenummer muss 1 - 5 sein, dass Geraet muss existieren dann schalten
                                        } // Ende Zeitcheck
                                    }  // Endeif für AWS-Aktivflag check   
                                    }); // end schedule IDGruppe4
                                    
                                    
                                    
                                    // Execute IDGruppe5   
                                    //-------------------------------------------------------------------------------------------------------------------------------------------------------
                                    schedule(cron5job, function() {
                                    if  (getState(IDAWSaktiv).val === true) {     // AWS aktiv ?
                                         if(IsTimeInRange(zeit5von, zeit5bis,5)) {              // ist die "von"-Zeit innerhalb des aktuellen Zeitfensters ?
                                            x = zufall(1,Grp5ZufAnz,x);                                                 // Ermittlung zufaelliges Geraet zum enschalten
                                            z = zufall(0,StartDelay5*60,y)*1000;                                        // Ermittlung der Einschaltverzögerung aufgrund der Zufallszahl
                                            y = zufall(ein5von*60,ein5bis*60,y)*1000;                                   // Ermittlung der Einschaltzdauer aufgrund der Zufallszahl in Millisekunden
                                            var IDGruppe = "IDGruppe5" + x;                                             // Ermittlung Gruppenname z.B. IDGruppe51
                                            if (x <= 5 && GeraetExists(IDGruppe)) {    AWSSchaltung(IDGruppe,y,z);  }   // Geraetenummer muss 1 - 5 sein, dass Geraet muss existieren dann schalten
                                      } // Ende Zeitcheck
                                    }  // Endeif für AWS-Aktivflag check   
                                    }); // end schedule IDGruppe5
                                    
                                    
                                    
                                    
                                    
                                    // ------------------------Ruecksetzen der Timeouts /Ausschalten der teilnehmenden Geraete, wenn AWS-Aktiv auf false gesetzt wird--------------
                                    
                                    on({id: IDAWSaktiv, val: false }, function(obj)      // Event:  wenn AWS Flag auf nicht aktiv gesetzt wurde
                                    {
                                    
                                        var objGruppeI =    " ";    // Baut die IDGruppe zusammen Position 1
                                        var objGruppeJ =    " ";    // Baut die IDGruppe zusammen Position 2
                                        var countobj   =    0;      //counter fuer Verzoegerungen zwischen den Ausschaltungen
                                        var id;
                                        var object;
                                    
                                        for (var i = 1; i <= 5; i++) {                                                              // Loop fuer die Gruppen-Nr
                                            objGruppeI = "IDGruppe" + i;                                                        // Loop fuer die Geraete Nr der IDGruppen 1 - 5
                                               for (var j = 1; j <= 5; j++) {                                                       // Loop Position 2 /1 - 5 )
                                                    objGruppeJ = objGruppeI + j ;                                               // Ermittlung Position 2
                                                    id = eval(objGruppeJ);
                                                    if (SpaceChk.test(id)) {                                                    // Check for  blanks
                                                    } else {                                                                    // keine blanks
                                                        object = getObject(id);
                                                        if (GeraetExists(objGruppeJ) === true) {                                // Gibt es das Geraet
                                                            clearStateDelayed(id);                                              // Alle Pläne der Gruppe loeschen
                                                            if (ausflag) {                                                      // sollen die Teilnehmer ausgeschaltet werden ? 
                                                                if (object.common && object.common.type === 'boolean') {        // ist es ein STATE Geraet ?
                                                                    setStateDelayed(id, AusschaltFlag, countobj);               // ausschalten mit je  300 millisekunden wartezeit
                                                                }
                                                                if (object.common && object.common.type === 'number') {         // ist es ein LEVEL Geraet ?      
                                                                    setStateDelayed(id, DimmAusschalt, countobj);               // ausschalten mit je  300 millisekunden wartezeit
                                                                }
                                                            }                                                                   // endif check ob Geraete ausgeschaltet werden sollen
                                                            countobj = countobj + 300;                                          // alle 300 millisekunden schalten
                                                        } // endif fuer Geraetecheck und switch off
                                                    } // end Space Check
                                              } //  Ende Position 2 Loop
                                        }  // Ende Position 1 Loop
                                        log("EVENT  AWS deaktiviert Der schedule zur geplanten Ausschaltung von Geraeten wurde zurueckgesetzt " ,"info");
                                        string = ";;;;;;;AWS wurde deaktiviert - Der schedule zur geplanten Ausschaltung von Geraeten wurde zurueckgesetzt";           // bereite LOG vor
                                    
                                        writelog(string);                                                                           // schreibe LOG in Datei
                                        if(debug ) { listcheckSwitch();}
                                    }); // ende on id
                                    
                                    
                                    // ------------------------schreibe Log wenn AWS aktiviert wurde--------------------------------------
                                    
                                    on({id: IDAWSaktiv, val: true }, function(obj)       // Event:  wenn AWS Flag auf nicht aktiv gesetzt wurde
                                    {
                                    
                                    log("EVENT  AWS wurde aktiviert " ,"info");
                                    string = ";;;;;;;AWS wurde aktiviert";                                                  // bereite LOG vor
                                    writelog(string);     
                                    if(debug ) { listcheckSwitch();}
                                    
                                    }); // ende on id
                                    
                                    // ------------------------ F U N K T I O N E N -------------------------------------------------------
                                    
                                    //-----------------------------------------------------------------------------------------------------
                                    // Diese Funktion schaltet die IDGruppenmitglieder der gerade zu berabeitenden IDGruppe
                                    //-----------------------------------------------------------------------------------------------------
                                    // neu
                                    function AWSSchaltung(objIDGruppe,y,z) {
                                        logtext = " ";
                                        var id = eval(objIDGruppe);
                                        var obj = getObject(id);
                                        if (!obj) return;
                                    
                                       
                                        if (obj.common && obj.common.type === 'boolean') {                          // ist es ein STATE Geraet ?
                                           if  (getState(id).val == AusschaltFlag ) {                               // nur wenn noch nicht eingeschaltet
                                              setStateDelayed(id, EinschaltFlag,  z);                                 // Licht an in z millisekunden
                                    //          var timer = setTimeout(function (){                                                                             
                                    //             setState(eval(objIDGruppe),0);   }, z+y);                                //Licht aus in y millisekunden   (Einschaltverzoegerung plus Einschaltdauer)               
                                                    console.log('Routine AWSSchaltung - SET: ' + id + ' to false in ' + (z+y) + 'ms');
                                                   setStateDelayed(id, AusschaltFlag, z+y, false);                   //Licht aus in z+y millisekunden   (Einschaltverzoegerung plus Einschaltdauer)
                                           } else {                                                                         // else - Geraet ist schon eingeschaltet
                                               if (IgnoreWhenOn) {                                                          //keine  Reaktion wenn Geraet bereits eingeschaltet war
                                                    logtext = "keine Aktion - Geraet war bereits eingeschaltet";   
                                               } else {                                                                     // else - es soll uebersteuert werden mit den neuen werten
                                                    z = 0;                                                                  // Einschaltverzoegerung setzen auf Null
                                                    console.log('Routine AWSSchaltung - SET: ' + id + ' to false in ' + (z+y) + 'ms');
                                                    setStateDelayed(id, AusschaltFlag, z+y, true );                  //Licht aus in z+y millisekunden   (Einschaltverzoegerung plus Einschaltdauer) ohne Einschaltverzoegerung
                                                    logtext = "Geraet war bereits eingeschaltet -- uebersteuert - ohne Einschaltverzoegerung -  alter schedule geloescht- ";     
                                               }          // endeif IgnoreWhenOn
                                           }        // Ende IF fuer Check ob bereits eingeschaltet
                                        } // Ende IF für STATE Geraete
                                           
                                        if (obj.common && obj.common.type === 'number') {                                             // ist es ein LEVEL Geraet ?
                                           if  (getState(id).val == DimmAusschalt ) {                                   // nur wenn noch nicht eingeschaltet
                                                    console.log('Routine AWSSchaltung - SET: ' + id + ' to ' + (obj.common.max || 100) + ' in ' + z + 'ms');
                                                setStateDelayed(id, obj.common.max || DimmEinschalt,  z);                                // Licht an in z millisekunden
                                    //            var timer = setTimeout(function (){                                                                             
                                    //                setState(eval(objIDGruppe),0);   }, z+y);                             //Licht aus in y millisekunden   (Einschaltverzoegerung plus Einschaltdauer)               
                                                    console.log('Routine AWSSchaltung - SET: ' + id + ' to ' + (obj.common.min || 0) + ' in ' + (z+y) + 'ms');
                                                setStateDelayed(id, obj.common.min || DimmAusschalt, z+y, false);                          //Licht aus in y millisekunden   (Einschaltverzoegerung plus Einschaltdauer)
                                           } else {                                                                         // else - Geraet ist schon eingeschaltet
                                            if (IgnoreWhenOn) {                                                             //keine  Reaktion wenn Geraet bereits eingeschaltet war
                                                    logtext = "keine Aktion - Geraet war bereits eingeschaltet";   
                                               } else {                                                                     // else - es soll uebersteuert werden mit den neuen werten     
                                                    z = 0;                                                                  // Einschaltverzoegerung setzen auf Null
                                                    console.log('Routine AWSSchaltung - SET: ' + id + ' to ' + (obj.common.min || DimmAusschalt) + ' sofort');
                                                     setStateDelayed(id, obj.common.min || DimmAusschalt, z+y, true);                      //Licht aus in z+y millisekunden   (Einschaltverzoegerung plus Einschaltdauer) ohne Einschaltverzoegerung
                                                     logtext = "Geraet war bereits eingeschaltet -- uebersteuert - ohne Einschaltverzoegerung -  alter schedule geloescht- ";     
                                               }    // endeif IgnoreWhenOn
                                            }     // Ende IF fuer Check ob bereits eingeschaltet
                                         } // Ende IF für LEVEL Geraete
                                    
                                            var GeraeteName = getObject(id).common.name;                         // Name des Geraetes in Klartext
                                            var now =    new Date();                                                            // store current date and time
                                            var currSec = now.getTime();                                                        // millisekunden seit 01.01.1970 /current millisecs
                                            var berechnEinZeit = millisecToDate( currSec + z);                                  // millisecs in Zeit umrechnen fuer die Einschaltzeit
                                            var berechnAusZeit = millisecToDate(currSec + z + y);                               // millisecs in Zeit umrechnen fuer die Ausschaltzeit
                                    //        WriteArray(objIDGruppe,timer, currSec + z, currSec + z + y)                                             // Merken des Schaltvorganges
                                            string = objIDGruppe+";" + id +";" +  GeraeteName + ";" + z/1000 + ";" +y/1000+";"+berechnEinZeit + ";" + berechnAusZeit + ";" + logtext;     // bereite LOG vor
                                            log("Routine AWSSchaltung - EVENT " + objIDGruppe + "; " +id + "; " +  GeraeteName + "; " + z/1000 + "; " + y/1000 + "; " + berechnEinZeit + "; " + berechnAusZeit + "; " + logtext, "info");  //Log schreiben
                                            writelog(string);                                                               // schreibe LOG in Datei
                                            logtext = " ";
                                                   
                                    } // Ende Funktion
                                    
                                    
                                    //-----------------------------------------------------------------------------------------------------
                                    // Funktion zur Bestimmung einer ganzzahligen Zufallszahl innerhalb vorgegebener min/max Werte
                                    //-----------------------------------------------------------------------------------------------------
                                    function zufall(low,high,back) {
                                      back = Math.floor(Math.random() * (high - low + 1)) + low;   
                                    //  log("EVENT  AWS Zufallszahlen - low = " + low + "high = " + high + " back = " + back ,"info");
                                     return back;
                                    } // ende Funktion
                                    
                                    
                                    
                                    //-----------------------------------------------------------------------------------------------------
                                    // Funktion zur Ueberpruefung ob die angegebenen Geraete exisiteren
                                    //-----------------------------------------------------------------------------------------------------
                                    function GeraetExists(objGruppe) {
                                    var back = false;
                                    var id = eval(objGruppe);
                                      
                                    if (SpaceChk.test(id)) {                     // objIDGruppe darf kein space enthalten  // ist ein Geraet ueberhaupt zugeordnet ?
                                    //         log("Geraet hat kein assignment - Gruppe " + objGruppe, "info"); 
                                             return back;
                                     } //  endif IDGruppe hat kein assignment
                                    
                                    if  (getState(id))   { // Existiert das Geraet ?
                                            back = true;
                                        } else {     
                                            log("Routine GeraetExists - Geraet existiert nicht - bitte in den Einstellungen ueberpruefen - Gruppe " + objGruppe, "info"); 
                                    } //  endif check on Geraet exists
                                    
                                    return back;
                                    } // ende Funktion
                                    
                                    
                                    
                                    //-----------------------------------------------------------------------------------------------------
                                    // Funktion schreibt einen Logeintrag in das Filesystem und auch in das interne Log-System
                                    //-----------------------------------------------------------------------------------------------------
                                    function writelog(string) {
                                        if (logflag === true) {
                                         // Zerlege Datum und Zeit in Variable
                                            var now =    new Date(); // store current date and time
                                            var year =   now.getFullYear();
                                            var month =  addZero(now.getMonth()+1);
                                            var day =    addZero(now.getDate());
                                            var Thour =  addZero(now.getHours());
                                            var Tmin =   addZero(now.getMinutes());
                                            var Tsec =   addZero(now.getSeconds());
                                            var logdate = day + '.' + month + '.' + year;
                                            var logtime = Thour + ':' + Tmin + ':' + Tsec;
                                    
                                            fs.readFile(LogPath, 'utf8', function(err,data){
                                                if (!err) {  // File existiert
                                                    fs.appendFileSync(LogPath, logdate+" ;"+logtime+" ;"+string + "\n");       // Füge Satz in Datei ein
                                                }else{
                                                    log("Routine writelog - Logfile nicht gefunden - wird angelegt"), "info";
                                                    var headerLine= "Datum;Uhrzeit;Gruppe;GeraeteID;Geraetebezeichnung;Einschaltverzoegerung;LaengeSchaltzeit;ZeitEin berechnet;ZeitAus berechnet;Kommentar"   
                                                    fs.appendFileSync(LogPath, headerLine + "\n");       // Füge Satz in Datei ein
                                                    fs.appendFileSync(LogPath, logdate+" ;"+logtime+" ;"+string + "\n");       // Füge Satz in Datei ein
                                                }
                                            });       // ende Filecheck
                                        } ; // Ende check on logflag
                                        
                                    } // Ende Funktion
                                    
                                    
                                    //-----------------------------------------------------------------------------------------------------
                                    // Funktion IsTimeInRange - 
                                    // Ermittlung ob die aktuelle Zeit in der vorgegebenen Schaltzeit liegt (inkl Astro)
                                    //-----------------------------------------------------------------------------------------------------
                                    
                                    function IsTimeInRange (zeitvon, zeitbis, Gruppe) {
                                        var now = new Date();
                                        var lower;                                              // enthält Javascript datums/Zeitformat für die VOM Zeit
                                        var upper;                                              // enthält Javascript datums/Zeitformat für die BIS Zeit
                                        var astrovonDown = zeitvon.includes(KeyWordSunDown);    // Astrozeit VON Sonnenuntergang gesetzt
                                        var astrovonUp   = zeitvon.includes(KeyWordSunUp);      // Astrozeit VON Sonnenaufgang gesetzt
                                        var astrobisDown = zeitbis.includes(KeyWordSunDown);    // Astrozeit BIS Sonnenuntergang gesetzt
                                        var astrobisUp   = zeitbis.includes(KeyWordSunUp);      // Astrozeit BIS Sonnenaufgang gesetzt
                                        var astrovon = false;
                                        var astrobis = false;
                                    
                                        var StatusSwichTimes =checkSwitchTime(Gruppe);
                                        
                                        if (StatusSwichTimes) {                                  // es gibt einen aktuellen Eintrag bzw laufende Schaltzeit fuer diese Gruppe
                                            if(debug ) { log("Routine IsTimeInRange - Gruppe"+ Gruppe +  " ist im definierten Zeitrange - Schaltung ist aktiv", "info") }
                                            return true; // in Tabelle SwitchTime gibt es noch einen gültigen Eintrag also zurück zur Schaltung
                                        }
                                    
                                    
                                        // bei Verwendung von Astrozeiten werden die errechneten Zeiten in lower und upper gespeichert
                                        if (astrovonDown === true) {                            // Astrozeit gesetzt VON Zeit ist Sonnenuntergang
                                            lower =  getAstroDate("sunsetStart");
                                            astrovon = true;
                                        }
                                        if (astrovonUp === true) {                              // Astrozeit gesetzt VON Zeit ist Sonnenaufgang
                                            lower =  getAstroDate("sunriseEnd");
                                            astrovon = true;
                                        }
                                        if (astrobisDown === true) {                            // Astrozeit gesetzt BIS Zeit ist Sonnenuntergang
                                            upper =  getAstroDate("sunsetStart");
                                            if(astrovonDown) {                                  // wenn VonZeit = untergang und BisZeit = Untergang - dann muss bis Zeit nächster Tag sein
                                                upper.setDate(upper.getDate() + 1);             // 1 Tag (24 Stunden ) addieren da der bis Wert wahrscheinlich am nächsten Tag liegen muss        
                                            }
                                            astrobis = true;
                                        }
                                        if (astrobisUp === true) {                              // Astrozeit gesetzt BIS Zeit ist Sonnenaufgang
                                            upper =  getAstroDate("sunriseEnd");
                                            if(astrovonDown) {                                    // wenn VonZeit = aufgang und BisZeit = Aufgang - dann muss BIS Zeit nächster Tag sein
                                               upper.setDate(upper.getDate() + 1);              // 1 Tag (24 Stunden ) addieren da der bis Wert wahrscheinlich am nächsten Tag liegen muss    
                                            }
                                            astrobis = true;
                                        }
                                    
                                        // Wenn keine Astrozeiten verwendet werden werden Zeiten anhand der Zeitangaben errechnet
                                        if (!astrovon) {
                                            lower = addTime(zeitvon);                       // switch on time  im berechenbaren Format
                                        }
                                        if (!astrobis) {
                                            upper = addTime(zeitbis);                       // switch off time im berechenbaren Format
                                        }
                                    
                                        // Sonderfall:wenn die Zeitangaben sind identisch - also bis zeit nächster Tag und von Zeit muss auf now liegen
                                        if (zeitvon === zeitbis) { 
                                            upper.setDate(upper.getDate() + 1); // 24 Stunden zur Bis-Zeit Hinzufügen 
                                            lower = now;                                        // wenn z.B. von 23:00:00 bis 23:00:00 eingegeben wurde dann soll immer geschaltet werden
                                       }
                                    
                                         // Wenn jetzt noch die VON Zeit kleiner also die BIS Zeit ist muss die BIS Zeit evt auf den nächsten Tag gelegt werden. (oder auch sie ist abgelaufen)
                                        if (upper < lower) {                                    // Die von Zeit ist groesser als die bis Zeit
                                            if(astrovonDown) {                                  // im Falle von Astrovon kann es sein, dass die bis Zeit in den nächsten Tag geht
                                                if( upper.getHours()  < ErlieastSunDown ) {     // Uewberpruefen ob die BisZeit kleiner als der Schwellwert ist
                                                    upper.setDate(upper.getDate() + 1);         // 1 Tag (24 Stunden ) addieren da der bis Wert wahrscheinlich am nächsten Tag liegen muss 
                                                    if (debug) { log("Routine IsTimeInRange - Gruppe"+ Gruppe +" bei Astrovon die zeitbis started Morgen - AstroZeit Sonnenuntergang VON ist "+ lower ,"info");}
                                                }
                                            }
                                            if(astrovonUp) {                                    // im Falle von Astrovon kann es sein, dass die bis Zeit in den nächsten Tag geht
                                                if( upper.getHours()  < EarliestSunUp ) {       // Uewberpruefen ob die BisZeit kleiner als der Schwellwert ist
                                                    upper.setDate(upper.getDate() + 1);         // 1 Tag (24 Stunden ) addieren da der bis Wert wahrscheinlich am nächsten Tag liegen muss 
                                                    if (debug) { log("Routine IsTimeInRange - Gruppe"+ Gruppe + " bei Astrovon die zeitbis started Morgen - AstroZeit Sonnenaufgang VON ist "+ lower,"info");}
                                                }
                                            }
                                    
                                           if(astrobisDown) {                                   // im Falle von Astrovon kann es sein, dass die bis Zeit in den nächsten Tag geht
                                                if( lower.getHours()  > LatestSunDown ) {       // Uewberpruefen ob die vonZeit groesser als der Schwellwert ist
                                                    upper.setDate(upper.getDate() + 1);         // 1 Tag (24 Stunden ) addieren da der bis Wert wahrscheinlich am nächsten Tag liegen muss 
                                                    if (debug) { log("Routine IsTimeInRange - Gruppe"+ Gruppe + " bei Astrovon die zeitbis started Morgen - AstroZeit Sonnenuntergang BIS ist "+ upper,"info");}
                                                }
                                            }
                                            if(astrobisUp) {                                    // im Falle von Astrovon kann es sein, dass die bis Zeit in den nächsten Tag geht
                                                if( lower.getHours()  > LatestSunDown ) {       // Uewberpruefen ob die VonZeit groesser als der Schwellwert ist
                                                    upper.setDate(upper.getDate() + 1);         // 1 Tag (24 Stunden ) addieren da der bis Wert wahrscheinlich am nächsten Tag liegen muss 
                                                    if (debug) { log("Routine IsTimeInRange - Gruppe"+ Gruppe + " bei Astrovon die zeitbis started Morgen- - AstroZeit Sonnenaufgang BIS  ist "+ upper,"info");}
                                                }
                                            }
                                    
                                            if (!astrovon && !astrobis) {                       // wenn keine Astrozeit gesetzt ist und die bis Zeit kleiner ist --> nächster Tag für die BisZeit
                                                upper.setDate(upper.getDate() + 1);             // 1 Tag (24 Stunden ) addieren da der bis Wert wahrscheinlich am nächsten Tag liegen muss 
                                            }
                                        }
                                       if (debug) {log("Routine IsTimeInRange - Gruppe"+ Gruppe + " Berechnung der Zeiten: VON " + lower + " BIS " + upper,"info");}
                                    
                                    
                                    
                                        // Wenn jetzt noch die BIS Zeit kleiner also die VON Zeit ist, dann ist die Zeit abgelaufen
                                        if (upper < lower ) {                               // dies trifft zu wenn die astrozeit die realzeit eingeholt hat z.B. astrovon = 20:00 und bisZeit 19:00
                                            if (debug) { log("Routine IsTimeInRange - Gruppe"+ Gruppe + " upper ist kleiner als lower - zurück Gruppe nicht (mehr) im Zeitrange false","info");}
                                            return false;
                                        }
                                        if( now >= lower && now <= upper ) {
                                            log("Routine IsTimeInRange - Gruppe"+ Gruppe + " aktuelle ist ist > als lower und kleiner als upper - Gruppe wird geschaltet (true)" );
                                            UpdateSwithTime(Gruppe,lower,upper);
                                            // if(debug ) { listcheckSwitch(Gruppe);}
                                            return true;
                                        } else {
                                            log("Routine IsTimeInRange - Gruppe"+ Gruppe + " Zeit nicht im Zeitrange - keine Schaltung ")
                                            return false;
                                        }
                                    
                                    
                                    
                                    
                                    }
                                    
                                    
                                    //-----------------------------------------------------------------------------------------------------
                                    // Funktion checkSwithTime zum Finden in Tabelle SwitchTimes ob es einen Gültigen Eintrag innerhalb der Zeit gibt
                                    // Struktur SwitchTimes:  0 = Schaltgruppe, 1 = vonZeit, 2 = bisZeit
                                    //-----------------------------------------------------------------------------------------------------
                                    function listcheckSwitch() {
                                        for (var x in SwitchTimes) {
                                            log("Routine listcheckSwitch - Gruppe" +SwitchTimes[x][0] +  " Zeitvon " + SwitchTimes[x][1] +  " Zeitbis " +  SwitchTimes[x][2],"info");
                                        }
                                    
                                    }
                                    
                                    //-----------------------------------------------------------------------------------------------------
                                    // Funktion checkSwithTime zum Finden in Tabelle SwitchTimes ob es einen Gültigen Eintrag innerhalb der Zeit gibt
                                    // Struktur SwitchTimes:  0 = Schaltgruppe, 1 = vonZeit, 2 = bisZeit
                                    //-----------------------------------------------------------------------------------------------------
                                    function checkSwitchTime(Gruppe) {
                                        var now = new Date();
                                    
                                        for (var x in SwitchTimes) {
                                            if(SwitchTimes[x][0] === Gruppe) {
                                                if( now >= SwitchTimes[x][1] && now <= SwitchTimes[x][2] ) {
                                                    return true;
                                                }
                                            }
                                        }
                                        return false;
                                    } // Ende Function checkSwitchTime
                                    
                                    
                                    //-----------------------------------------------------------------------------------------------------
                                    // Funktion UpdateSwithTime macht einen update auf die Tabelle für ausgelaufene Schaltzeiten und für neue
                                    // Struktur SwitchTimes:  0 = Schaltgruppe, 1 = vonZeit, 2 = bisZeit
                                    //-----------------------------------------------------------------------------------------------------
                                    function UpdateSwithTime(Gruppe,VonZeit,BisZeit) {
                                        for (var x in SwitchTimes) {
                                            if(SwitchTimes[x][0] === Gruppe) {
                                                if(debug){  log("Routine UpdateSwithTime - Gruppe " + Gruppe + " Switchtime Update VON " + VonZeit + " BIS " + BisZeit,"info" );}
                                                SwitchTimes[Gruppe][1] = VonZeit;
                                                SwitchTimes[Gruppe][2] = BisZeit;
                                                return;
                                            }
                                        }
                                        SwitchTimes.push([Gruppe, VonZeit, BisZeit]); // nicht gefunden - also hinzufügen
                                        if(debug){  log("Routine UpdateSwithTime - Gruppe" + Gruppe + " Switchtime hinzufuegen VON " + VonZeit + " BIS " + BisZeit,"info" );}
                                    
                                    }
                                    
                                    //-----------------------------------------------------------------------------------------------------
                                    // Funktion zur Erzeugung von führenden Nullen für das Datum Format
                                    //-----------------------------------------------------------------------------------------------------
                                    function addZero(i) {
                                        if (i < 10) {
                                            i = "0" + i;
                                        }
                                        return i;
                                    } // Ende Funktion
                                    
                                     //-----------------------------------------------------------------------------------------------------
                                    // Funktion Millisekunden in Datum/Zeit  umrechnen /wird für logging benoetigt
                                    //-----------------------------------------------------------------------------------------------------
                                    function millisecToDate(millisec) {
                                            var time = new Date(millisec);
                                            var Thour =  addZero(time.getHours());
                                            var Tmin =   addZero(time.getMinutes());
                                            var Tsec =   addZero(time.getSeconds());
                                            var datum = Thour + ':' + Tmin + ':' + Tsec;
                                           return datum;
                                    } // Ende Funktion
                                    
                                    
                                    //-----------------------------------------------------------------------------------------------------
                                    //Funktion addTime wandelt einen String mit Format 00:00:00 in rechenbare Zeit um
                                    //-----------------------------------------------------------------------------------------------------
                                    function addTime(strTime) {
                                        var d = new Date();
                                        d = new Date(d.getFullYear(), d.getMonth(), d.getDate())
                                        var time = strTime.split(':');
                                        d.setHours(time[0]);
                                        d.setMinutes(time[1]);
                                        d.setSeconds(time[2]);
                                        return d;
                                    }
                                    
                                    
                                    
                                    
                                    
                                    paul53 1 Reply Last reply Reply Quote 0
                                    • paul53
                                      paul53 @skorpil last edited by paul53

                                      @skorpil sagte: sollten identisch sein

                                      Das sind sie nicht, was die Zeilennummern betrifft.

                                      1 Reply Last reply Reply Quote 1
                                      • L
                                        LK1976 @paul53 last edited by

                                        @paul53 Vielen Dank für die Bereitschaft helfen zu wollen. Ich nutze tatsächlich eine neuere Version des Skriptes, die ich jedoch erst am Montag Nachmittag posten kann. Daher bitte noch ein wenig Geduld, ich muss dafür erst zu Hause sein 😉

                                        S 1 Reply Last reply Reply Quote 1
                                        • S
                                          skorpil @LK1976 last edited by

                                          @lk1976 welche denn? Meine offenbar „alte“ moppert zwar immer mal wieder im Script herum, aber im großen und ganzen läuft sie. Wenn ich irgendwie helfen kann…

                                          L 1 Reply Last reply Reply Quote 0
                                          • L
                                            LK1976 @paul53 last edited by

                                            @paul53:

                                            Nochmals Danke und nun hier die angefragten Daten:

                                            In Zeile 188:
                                            if(IsTimeInRange(zeit1von, zeit1bis,1)) { // ist die VonZeit innerhalb des aktuellen Zeitfensters?

                                            In Zeile 535:
                                            UpdateSwitchTime(Gruppe,lower,upper);

                                            In Zeile 582:
                                            SwitchTime[Gruppe][1] = VonZeit;

                                            Der gesamte Code lautet:

                                            //..........Anwesenheitssimulation AWS
                                            //..........Initiales Datum: 28.12.2015
                                            //..........Autor: Looxer01
                                            //..........Forum ioBroker
                                            //..........https://forum.iobroker.net/topic/1671/vorlage-anwesenheitssimulation-script
                                            
                                            //..........Änderungshistorie
                                            //..........Version 0.10 Initial 28.12.2015
                                            //..........Version 0.11 29.12.2015 Einstellungen um Astrozeiten erweitert (noch ohne Funktion)
                                            //..........Version 0.12 29.12.2015 EVENT Deaktivierung von AWS hinzugefügt: Schreiben Log und löschen Schedules
                                            //..................................Aktivierung von AWS hinzugefügt: Schreiben Log bei Aktivierung
                                            //..........Version 0.13 29.12.2015 Das Schreiben des externen Logs optional gemacht - unter Einstellungen auswählbar
                                            //..........Version 0.20 29.12.2015 Astrozeit Funktion hinzugefügt / Astrozeit wird je IDGruppe auf true/false gesetzt und overruled die Variablen zeit1von, zeit2von, zeit3von, zeit4von und zeit5von
                                            //..........Version 0.30 29.12.2015 Umarbeitung zur Verkürzung des Scripts
                                            //..........Version 0.31 30.12.2015 Fehlerbeseitigung in IDGruppen 3 und 4 / einige Code-Hygiene-Maßnahmen
                                            //..................................Umbenennung der IDGruppen mit führend "ID" / Startverzögerungseinstellungen hinzugefügt
                                            //..........Version 0.32 30.12.2015 Umgestellt auf setStateDelayed / Startverzögerungsfunktion hinzugefügt
                                            //..........Version 0.33 31.12.2015 Fehler mit EVAL Funktion gefixt / Fehler mit Startverzögerung und Einschaltzeiten gefixt
                                            //..................................Funktion Anzahl von Geräte Teilnehmer zur Geräte-ID-Bestimmung hinzugefügt
                                            //..........Version 0.40 01.01.2016 Log-Pfad variabel gemacht / Log-File-Format umgearbeitet und Headerline hinzugefügt für externes Log / Internes Log überarbeitet
                                            //..........Version 0.41 02.01.2016 Funktionen von Bätz zum TimeInRange Check hinzugefügt / Keine globale Funktion mehr notwendig / Kommentare überarbeitet
                                            //..........Version 0.42 02.01.2015 Herkunftsnachweis für IsTimeInRange Funktion hinzugefügt
                                            //..................................Fehler zur zufälligen Gerätefindung behoben / Das letzte Gerät wurde nie ausgewählt / Fehler im Log "Gerät wurde nicht eingeschaltet" wurde gelogged, auch dann, wenn es eingeschaltet wurde
                                            //..........Version 0.43 03.01.2015 Wenn AWS auf inaktiv gesetzt wird, dann werden alle teilnehmenden Geräte ausgeschaltet / Dokumentation der Variablen / Variablendeklaration nachgeholt für zwei Fälle
                                            //..........Version 0.44 04.01.2015 Addieren der Einschaltverzögerung zur Ausschaltzeit für die Ausschaltzeitberechnung / Fixed Fehler doppelte Schaltung für STATE Geräte
                                            //..........Version 0.45 04.01.2015 Weiterer Fehler zur Berechnung der Ausschaltzeit korrigiert
                                            //..........Version 0.50 04.01.2015 Beseitigung unnötiges Coding / Überprüfung, ob Gerät existiert hinzugefügt / LogMeldung falls nicht hinzugefügt / Kein Javascript restart mehr, wenn Gerät nicht existiert
                                            //..........Version 0.60 04.01.2015 Ausschalten der Teilnehmer bei Deaktivierung optimiert / Ausschaltung optional gemacht / Astrozeit überarbeitet
                                            //..................................Astrozeit auch für die BisZeit hinzugefügt / Damit lassen sich Schaltungen bis zum Sonnenaufgang umsetzen / weitere Codeoptimierungen
                                            //..........Version 0.61 05.01.2015 Beim  Ausschalten Verzögerung zwischen Schaltvorgänge eingebaut / Codeoptimierung bei den Gruppen Schedules / Fehler bei der GrpZufAnz und StartDelay beseitigt für Gruppen 2 bis 5
                                            //..........Version 0.65 06.01.2015 Reaktion bei bereits eingeschalteten Lampen variabel gemacht / Codeoptimierungen / ID für AWS-Aktiv ist jetzt variabel
                                            //..........Version 0.70 26.01.2015 SetStateDelayed ist jetzt in javascript gefixt, ab JS version 1.1.2 / Das Löschen von Ein-/Auschaltplanungen wird jetzt mit dem neuen Befehl clearStateDelayed gemacht
                                            //..................................Vorläufig wurde das Merken der letzten Aktion gelöscht, da es keine Verwendung im Moment hat
                                            //..........Version 0.75 27.01.2015 Fehler beim Löschen von Ein-/Auschaltplanungen behoben / Es wurde nicht gelöscht, wenn Verbraucher eingeschaltet bleiben sollen
                                            //..........Version 0.80 28.04.2016 Fehler mit der Astrozeit, wenn die BisZeit kleiner ist als die Astrozeit(von) beseitigt
                                            //..........Version 0.90 23.12.2017 Ein- und Ausschaltbefehle jetzt als Variable einstellbar / Damit lassen sich auch andere Geräte einbinden (z. B. KNX mit 0 und 1) / Level und STATE Geräte als Boolean und number identifziert
                                            //..........Version 0.91 19.01.2018 Ein-/Ausschaltbefehl war noch nicht mit der Ausschaltvariable verknüpft
                                            //..................................Die IDAWSaktiv war mit einem falschen Datenpunkt verknüpft
                                            //..........Version 0.92.03.12.2018.Fehler behoben nach Update auf JS 4.0.1, fs.existsSync funktioniert nicht mehr, ausgetausch mit fs.readFile
                                            //..........Version 0.94.27.01.2019 Fehler behoben: Wenn Zeit in den nächsten Tag reichte, dann wurden bei Astronutzung die Start- und Endzeiten nicht richtig berechnet
                                            //................................. Sonnenaufgang und Sonnenuntergang können statt der Zeitangabe eingegeben werden
                                            //................................. In der VonZeit kann jetzt auch Sonnenaufgang eingegeben werden 
                                            //................................. Debug der Zeitenberechnung eingeführt
                                            
                                            // Das Script wird aktiviert, wenn das Flag "Anwesenheitssteuerung" gesetzt wird
                                            
                                            // HIER Einstellungen vornehmen............................................................................................
                                            
                                            var KeyWordSunDown  = "SunSet";     // SONNENUNTERGANG - Bitte dieses Keyword in ZeitxVon oder ZeitxBis eintragen wenn Astrozeit gewünscht ist
                                            var KeyWordSunUp    = "SunRise";    // SONNENAUFGANG   - Bitte dieses Keyword in ZeitxVon oder ZeitxBis eintragen wenn Astrozeit gewünscht ist
                                            
                                            
                                            // Bei Eingabe des Keywords bei den Zeiten werden die Astrozeiten verwendet
                                            // Einstellungen der Aktivzeiten je IDGruppe von bis
                                            var zeit1von = "SunSet";            //Aktivzeit von IDGruppe1
                                            var zeit1bis = "23:45:00";          //Aktivzeit bis IDGruppe1
                                            
                                            var zeit2von = "00:00:00";          //Aktivzeit von IDGruppe2
                                            var zeit2bis = "00:00:01";          //Aktivzeit bis IDGruppe2
                                            
                                            var zeit3von = "00:00:00";          //Aktivzeit von IDGruppe3
                                            var zeit3bis = "00:00:01";          //Aktivzeit bis IDGruppe3
                                            
                                            var zeit4von = "00:00:00";          //Aktivzeit von IDGruppe4
                                            var zeit4bis = "00:00:01";          //Aktivzeit bis IDGruppe4
                                            
                                            var zeit5von = "00:00:00";          //Aktivzeit von IDGruppe5
                                            var zeit5bis = "00:00:01";          //Aktivzeit bis IDGruppe5
                                            
                                            
                                            // Einstellungen der zufälligen Einschaltdauer je IDGruppe von bis
                                            var ein1von = 6;    // Minuten IDGruppe1 von
                                            var ein1bis = 10;   // Minuten IDGruppe1 bis
                                            var ein2von = 1;    // Minuten IDGruppe2 von
                                            var ein2bis = 5;    // Minuten IDGruppe2 bis
                                            var ein3von = 1;    // Minuten IDGruppe3 von
                                            var ein3bis = 5;    // Minuten IDGruppe3 bis
                                            var ein4von = 1;    // Minuten IDGruppe4 von
                                            var ein4bis = 5;    // Minuten IDGruppe4 bis
                                            var ein5von = 1;    // Minuten IDGruppe5 von
                                            var ein5bis = 5;    // Minuten IDGruppe5 bis
                                            
                                            
                                            // Einstellung je Gruppe für die maximale Startverzögerung in Minuten
                                            // bei 0 = keine Startverzögerung - bei z. B. 10 = Startverzögerung zwischen 0 und 10 in Minuten
                                            
                                            var StartDelay1 = 4;   // Maximale Startverzögerung Gruppe1
                                            var StartDelay2 = 0;   // Maximale Startverzögerung Gruppe2
                                            var StartDelay3 = 0;   // Maximale Startverzögerung Gruppe3
                                            var StartDelay4 = 0;   // Maximale Startverzögerung Gruppe4
                                            var StartDelay5 = 0;   // Maximale Startverzögerung Gruppe5
                                            
                                            
                                            // Einstellung Check-Schedule - Voreinstellung z. B. alle 30 Minuten je IDGruppe - Damit wird je Lauf, nach Zufälligkeit, je ein Gerät der IDGruppe eingeschaltet
                                            var cron1 = 5;   //  checks alle x Minuten für IDGruppe1
                                            var cron2 = 5;   //  checks alle x Minuten für IDGruppe2
                                            var cron3 = 5;   //  checks alle x Minuten für IDGruppe3
                                            var cron4 = 5;   //  checks alle x Minuten für IDGruppe4
                                            var cron5 = 5;   //  checks alle x Minuten für IDGruppe5
                                            
                                            
                                            // Einstellung teilnehmende Geräte je IDGruppe maximal 5 - Eingabe der ID
                                            var     IDGruppe11 = "alias.0.Steckdosen.Steckdose_TV-Simulator.SET"; // Steckdose TV-Simulator
                                            var     IDGruppe12 = "  "; // ...
                                            var     IDGruppe13 = "  "; // ... 
                                            var     IDGruppe14 = "  "; // ...
                                            var     IDGruppe15 = "  "; // ...
                                            var     Grp1ZufAnz = 1;              // Anzahl der Geräte zur zufälligen Bestimmung des Gerätes 
                                            
                                            var     IDGruppe21 = "  "; // ...
                                            var     IDGruppe22 = "  "; // ...
                                            var     IDGruppe23 = "  "; // ...
                                            var     IDGruppe24 = "  "; // ...
                                            var     IDGruppe25 = "  "; // ...
                                            var     Grp2ZufAnz = 0;              // Anzahl der Geräte zur zufälligen Bestimmung des Gerätes 
                                            
                                            var     IDGruppe31 = "  "; // ...
                                            var     IDGruppe32 = "  "; // ... 
                                            var     IDGruppe33 = "  "; // ...
                                            var     IDGruppe34 = "  "; // ...
                                            var     IDGruppe35 = "  "; // ... 
                                            var     Grp3ZufAnz = 0;              // Anzahl der Geräte zur zufälligen Bestimmung des Gerätes 
                                            
                                            var     IDGruppe41 = "  "; // ...
                                            var     IDGruppe42 = "  "; // ...
                                            var     IDGruppe43 = "  "; // ...
                                            var     IDGruppe44 = "  "; // ...
                                            var     IDGruppe45 = "  "; // ...
                                            var     Grp4ZufAnz = 0;              // Anzahl der Geräte zur zufälligen Bestimmung des Gerätes 
                                            
                                            var     IDGruppe51 = "  ";
                                            var     IDGruppe52 = "  "; 
                                            var     IDGruppe53 = "  ";
                                            var     IDGruppe54 = "  ";
                                            var     IDGruppe55 = "  ";
                                            var     Grp5ZufAnz = 0;              // Anzahl der Geräte zur zufälligen Bestimmung des Gerätes 
                                            
                                            
                                            var logflag = true;    // wenn auf true, dann wird das Logging in Datei /opt/iobroker/iobroker-data/AWSLog.csv eingeschaltet bei false vice versa
                                            
                                            var ausflag = true;     // wenn AWS deaktiviert wird, dann werden alle Teilnehmer ausgeschaltet
                                            
                                            
                                            // Experten-Einstellungen .......................................................................................................
                                            
                                            var IDAWSaktiv = "alias.0.Infopunkte.Anwesenheitssimulation.ACTUAL";             // in den Objekten angelegte Variable zur Bestimmung, ob AWS aktiv ist - kann auch ausgetauscht werden durch eine Andere
                                            var LogPath = "/opt/iobroker/iobroker-data/AWSLog.csv";                          // Pfad und Dateiname des externen Logs
                                            var IgnoreWhenOn = false;                                                        // bei true: Ignoriert den Schaltvorgang, wenn das Gerät bereits eingeschaltet war
                                            var ErlieastSunDown = 16;                                                        // Die Stunde des frühesten Sonnenuntergangs z. B. in Deutschland 16 Uhr
                                            var EarliestSunUp   = 4;                                                         // Die Stunde des frühesten Sonnenaufgangs z. B. in Deutschland 4 Uhr
                                            var LatestSunDown = 21;                                                          // Die Stunde des spätesten Sonnenuntergangs z. B. in Deutschland 21 Uhr
                                            var LatestSunUp   = 8;                                                           // Die Stunde des spätesten Sonnenaufgangs z. B. in Deutschland 8 Uhr
                                            
                                            var EinschaltFlag = true;                                           // Einschaltbefehl der Teilnehmer für Boolean Geräte
                                            var AusschaltFlag = false;                                          // Ausschaltbefehl der Teilnehmer für Boolean Geräte
                                            var DimmAusschalt = 0;                                              // Ausschaltbefehl für Number Geräte (Dimmer)
                                            var DimmEinschalt = 100;                                            // Einschaltbefehl für Number Geräte (Dimmer) = Einschaltlevel auf den geschaltet wird
                                            var debug = true;                                                  // zusätzliche Log Meldungen zur Analyse
                                            
                                            // Ende Experten-Einstellungen .......................................................................................................
                                            
                                            
                                            // globale Variablen
                                            var fs = require('fs');                     // enable write für externes Log
                                            var cron1job = "*/"+cron1+" * * * *";       // CRON pattern aufgrund der Vorgabe in den Einstellungen
                                            var cron2job = "*/"+cron2+" * * * *";       // CRON pattern aufgrund der Vorgabe in den Einstellungen
                                            var cron3job = "*/"+cron3+" * * * *";       // CRON pattern aufgrund der Vorgabe in den Einstellungen
                                            var cron4job = "*/"+cron4+" * * * *";       // CRON pattern aufgrund der Vorgabe in den Einstellungen
                                            var cron5job = "*/"+cron5+" * * * *";       // CRON pattern aufgrund der Vorgabe in den Einstellungen
                                            var x = 0;                                  // Gerätenummer der Gruppe, die zufällig ausgewählt wurde
                                            var y = 0;                                  // Einschaltdauer aufgrund der Zufallszahl in Millisekunden
                                            var z = 0;                                  // Einschaltverzögerung aufgrund der Zufallszahl
                                            var string = " ";                           // Logstring
                                            var logtext=" " ;                           // Kommentar im Log
                                            var objIDGruppe = " ";                      // Übergabe an Funktion der IDGruppe zum Schalten des Gerätes
                                            var SpaceChk = new RegExp(/\s/);            // pattern, um zu prüfen, ob eine IDGruppe blanks enthält
                                            
                                            var SwitchTime = [];                         // SwitchTime wird genutzt, um die Schaltzeiten zu merken. Das wird benötigt, um Schaltzeiten, die in den nächsten Tag reichen, zu verwalten.
                                                                                          // Struktur 0 = Schaltgruppe, 1 = vonZeit, 2 = bisZeit
                                            
                                            // Aktivierungsflag anlegen beim ersten Start des Scripts
                                            createState(IDAWSaktiv, true, {read: true, write: true, type: 'boolean', name: 'Anwesenheitssteuerungsflag', desc: 'Anwesenheitssteuerungsflag'});
                                            
                                            
                                            // Execute IDGruppe1     
                                            schedule(cron1job, function() {
                                            if  (getState(IDAWSaktiv).val === true) {     // AWS aktiv?
                                                if(IsTimeInRange(zeit1von, zeit1bis,1)) {              // ist die VonZeit innerhalb des aktuellen Zeitfensters?
                                                    x = zufall(1,Grp1ZufAnz,x);                                                 // Ermittlung zufälliges Gerät zum Einschalten
                                                    z = zufall(0,StartDelay1*60,y)*1000;                                        // Ermittlung der Einschaltverzögerung aufgrund der Zufallszahl
                                                    y = zufall(ein1von*60,ein1bis*60,y)*1000;                                   // Ermittlung der Einschaltdauer aufgrund der Zufallszahl in Millisekunden
                                                    var IDGruppe = "IDGruppe1" + x;                                             // Ermittlung Gruppenname z.B.  IDGruppe11
                                                    if (x <= 5 && GeraetExists(IDGruppe)) {    AWSSchaltung(IDGruppe,y,z);  }   // Gerätenummer muss 1 bis 5 sein, das Gerät muss existieren, dann schalten
                                                } // Ende Zeitcheck
                                            } // Endeif für AWS-Aktivflag check   
                                            }); // end Schedule IDGruppe1
                                            
                                            
                                            // Execute IDGruppe2     
                                            schedule(cron2job, function() {
                                            if  (getState(IDAWSaktiv).val === true) {     // AWS aktiv?
                                                if(IsTimeInRange(zeit2von, zeit2bis,2)) {              // ist die VonZeit innerhalb des aktuellen Zeitfensters?
                                                    x = zufall(1,Grp2ZufAnz,x);                                                 // Ermittlung zufälliges Gerät zum Einschalten
                                                    z = zufall(0,StartDelay2*60,y)*1000;                                        // Ermittlung der Einschaltverzögerung aufgrund der Zufallszahl
                                                    y = zufall(ein2von*60,ein2bis*60,y)*1000;                                   // Ermittlung der Einschaltdauer aufgrund der Zufallszahl in Millisekunden
                                                    var IDGruppe = "IDGruppe2" + x;                                             // Ermittlung Gruppenname z. B. IDGruppe21
                                                    if (x <= 5 && GeraetExists(IDGruppe)) {    AWSSchaltung(IDGruppe,y,z);  }   // Gerätenummer muss 1 bis 5 sein, das Gerät muss existieren, dann schalten
                                                } // Ende Zeitcheck
                                            } // Endeif für AWS-Aktivflag check   
                                            }); // end Schedule IDGruppe2
                                            
                                            
                                            // Execute IDGruppe3   
                                            schedule(cron3job, function() {
                                            if  (getState(IDAWSaktiv).val === true) {     // AWS aktiv?
                                               if(IsTimeInRange(zeit3von, zeit3bis,3)) {              // ist die VonZeit innerhalb des aktuellen Zeitfensters?
                                                    x = zufall(1,Grp3ZufAnz,x);                                                 // Ermittlung zufälliges Gerät zum Einschalten
                                                    z = zufall(0,StartDelay3*60,y)*1000;                                        // Ermittlung der Einschaltverzögerung aufgrund der Zufallszahl
                                                    y = zufall(ein3von*60,ein3bis*60,y)*1000;                                   // Ermittlung der Einschaltzdauer aufgrund der Zufallszahl in Millisekunden
                                                    var IDGruppe = "IDGruppe3" + x;                                             // Ermittlung Gruppenname z. B. IDGruppe31
                                                    if (x <= 5 && GeraetExists(IDGruppe)) {    AWSSchaltung(IDGruppe,y,z);  }   // Gerätenummer muss 1 bis 5 sein, das Gerät muss existieren, dann schalten
                                              } // Ende Zeitcheck
                                            } // Endeif für AWS-Aktivflag check   
                                            }); // end Schedule IDGruppe3
                                            
                                            
                                            // Execute IDGruppe4   
                                            schedule(cron4job, function() {
                                            if  (getState(IDAWSaktiv).val === true) {     // AWS aktiv?
                                                 if(IsTimeInRange(zeit4von, zeit4bis,4)) {              // ist die VonZeit innerhalb des aktuellen Zeitfensters?
                                                    x = zufall(1,Grp4ZufAnz,x);                                                 // Ermittlung zufälliges Gerät zum Einschalten
                                                    z = zufall(0,StartDelay4*60,y)*1000;                                        // Ermittlung der Einschaltverzögerung aufgrund der Zufallszahl
                                                    y = zufall(ein4von*60,ein4bis*60,y)*1000;                                   // Ermittlung der Einschaltdauer aufgrund der Zufallszahl in Millisekunden
                                                    var IDGruppe = "IDGruppe4" + x;                                             // Ermittlung Gruppenname z. B. IDGruppe41
                                                    if (x <= 5 && GeraetExists(IDGruppe)) {    AWSSchaltung(IDGruppe,y,z);  }   // Gerätenummer muss 1 bis 5 sein, das Gerät muss existieren, dann schalten
                                                } // Ende Zeitcheck
                                            } // Endeif für AWS-Aktivflag check   
                                            }); // end Schedule IDGruppe4
                                            
                                            
                                            // Execute IDGruppe5   
                                            schedule(cron5job, function() {
                                            if  (getState(IDAWSaktiv).val === true) {     // AWS aktiv?
                                                 if(IsTimeInRange(zeit5von, zeit5bis,5)) {              // ist die VonZeit innerhalb des aktuellen Zeitfensters?
                                                    x = zufall(1,Grp5ZufAnz,x);                                                 // Ermittlung zufälliges Gerät zum Einschalten
                                                    z = zufall(0,StartDelay5*60,y)*1000;                                        // Ermittlung der Einschaltverzögerung aufgrund der Zufallszahl
                                                    y = zufall(ein5von*60,ein5bis*60,y)*1000;                                   // Ermittlung der Einschaltdauer aufgrund der Zufallszahl in Millisekunden
                                                    var IDGruppe = "IDGruppe5" + x;                                             // Ermittlung Gruppenname z. B. IDGruppe51
                                                    if (x <= 5 && GeraetExists(IDGruppe)) {    AWSSchaltung(IDGruppe,y,z);  }   // Gerätenummer muss 1 bis 5 sein, das Gerät muss existieren, dann schalten
                                              } // Ende Zeitcheck
                                            }  // Endeif für AWS-Aktivflag check   
                                            }); // end Schedule IDGruppe5
                                            
                                            
                                            // Rücksetzen der Timeouts /Ausschalten der teilnehmenden Geräte, wenn AWS-Aktiv auf false gesetzt wird
                                            on({id: IDAWSaktiv, val: false }, function(obj)      // Event, wenn AWS Flag auf nicht aktiv gesetzt wurde
                                            {
                                            
                                                var objGruppeI =    " ";    // Baut die IDGruppe zusammen Position 1
                                                var objGruppeJ =    " ";    // Baut die IDGruppe zusammen Position 2
                                                var countobj   =    0;      // counter für Verzögerungen zwischen den Ausschaltungen
                                                var id;
                                                var object;
                                            
                                                for (var i = 1; i <= 5; i++) {                                                          // Loop für die Gruppennummer
                                                    objGruppeI = "IDGruppe" + i;                                                        // Loop für die Gerätenummer der IDGruppen 1 bis 5
                                                       for (var j = 1; j <= 5; j++) {                                                   // Loop Position 2 / 1 bis 5 )
                                                            objGruppeJ = objGruppeI + j ;                                               // Ermittlung Position 2
                                                            id = eval(objGruppeJ);
                                                            if (SpaceChk.test(id)) {                                                    // Check for blanks
                                                            } else {                                                                    // keine blanks
                                                                object = getObject(id);
                                                                if (GeraetExists(objGruppeJ) === true) {                                // Gibt es das Gerät
                                                                    clearStateDelayed(id);                                              // Alle Pläne der Gruppe löschen
                                                                    if (ausflag) {                                                      // sollen die Teilnehmer ausgeschaltet werden? 
                                                                        if (object.common && object.common.type === 'boolean') {        // ist es ein STATE Gerät?
                                                                            setStateDelayed(id, AusschaltFlag, countobj);               // ausschalten mit je 300 Millisekunden Wartezeit
                                                                        }
                                                                        if (object.common && object.common.type === 'number') {         // ist es ein LEVEL Gerät?      
                                                                            setStateDelayed(id, DimmAusschalt, countobj);               // ausschalten mit je 300 Millisekunden Wartezeit
                                                                        }
                                                                    }                                                                   // endif check ob Geräte ausgeschaltet werden sollen
                                                                    countobj = countobj + 300;                                          // alle 300 Millisekunden schalten
                                                                } // endif für Gerätecheck und switch off
                                                            } // end Space Check
                                                      } //  Ende Position 2 Loop
                                                }  // Ende Position 1 Loop
                                                log("AWS deaktiviert - Der Zeitplan zur geplanten Ausschaltung von Geräten wurde zurückgesetzt" ,"info");
                                                string = ";;;;;;;AWS wurde deaktiviert - Der Zeitplan zur geplanten Ausschaltung von Geräten wurde zurückgesetzt";           // bereite LOG vor
                                            
                                                writelog(string);                                                                           // schreibe LOG in Datei
                                                if(debug ) { listcheckSwitch();}
                                            }); // ende on id
                                            
                                            
                                            // schreibe Log wenn AWS aktiviert wurde
                                            on({id: IDAWSaktiv, val: true }, function(obj)       // Event, wenn AWS Flag auf nicht aktiv gesetzt wurde
                                            {
                                            
                                            log("AWS wurde aktiviert" ,"info");
                                            string = ";;;;;;;AWS wurde aktiviert";                                                  // bereite LOG vor
                                            writelog(string);     
                                            if(debug ) { listcheckSwitch();}
                                            
                                            }); // ende on id
                                            
                                            // F U N K T I O N E N
                                            
                                            //-----------------------------------------------------------------------------------------------------
                                            // Diese Funktion schaltet die IDGruppenmitglieder der gerade zu bearbeitenden IDGruppe
                                            //-----------------------------------------------------------------------------------------------------
                                            function AWSSchaltung(objIDGruppe,y,z) {
                                                logtext = " ";
                                                var id = eval(objIDGruppe);
                                                var obj = getObject(id);
                                                if (!obj) return;
                                               
                                                if (obj.common && obj.common.type === 'boolean') {                          // ist es ein STATE Gerät?
                                                   if  (getState(id).val == AusschaltFlag ) {                               // nur wenn noch nicht eingeschaltet
                                                      setStateDelayed(id, EinschaltFlag,  z);                                 // Licht an in z Millisekunden
                                            // var timer = setTimeout(function (){                                                                             
                                            // setState(eval(objIDGruppe),0);   }, z+y);                                // Licht aus in y Millisekunden (Einschaltverzögerung plus Einschaltdauer)               
                                                            console.log('Routine AWS-Schaltung - SET: ' + id + ' to false in ' + (z+y) + 'ms');
                                                           setStateDelayed(id, AusschaltFlag, z+y, false);                   // Licht aus in z+y Millisekunden (Einschaltverzögerung plus Einschaltdauer)
                                                   } else {                                                                         // else - Gerät ist schon eingeschaltet
                                                       if (IgnoreWhenOn) {                                                          // keine Reaktion, wenn Gerät bereits eingeschaltet war
                                                            logtext = "keine Aktion - Gerät war bereits eingeschaltet";   
                                                       } else {                                                                     // else - es soll mit den neuen Werten übersteuert werden 
                                                            z = 0;                                                                  // Einschaltverzögerung setzen auf Null
                                                            console.log('Routine AWS-Schaltung - SET: ' + id + ' to false in ' + (z+y) + 'ms');
                                                            setStateDelayed(id, AusschaltFlag, z+y, true );                  // Licht aus in z+y Millisekunden (Einschaltverzögerung plus Einschaltdauer) ohne Einschaltverzögerung
                                                            logtext = "Gerät war bereits eingeschaltet - übersteuert - ohne Einschaltverzögerung - alter Zeitplan gelöscht";     
                                                       } // endeif IgnoreWhenOn
                                                   } // Ende IF für Check, ob bereits eingeschaltet
                                                } // Ende IF für STATE Geräte
                                                   
                                                if (obj.common && obj.common.type === 'number') {                                             // ist es ein LEVEL Gerät?
                                                   if  (getState(id).val == DimmAusschalt ) {                                   // nur wenn noch nicht eingeschaltet
                                                            console.log('Routine AWS-Schaltung - SET: ' + id + ' to ' + (obj.common.max || 100) + ' in ' + z + 'ms');
                                                        setStateDelayed(id, obj.common.max || DimmEinschalt,  z);                                // Licht an in z Millisekunden
                                            // var timer = setTimeout(function (){                                                                             
                                            // setState(eval(objIDGruppe),0);   }, z+y);                             // Licht aus in y Millisekunden (Einschaltverzögerung plus Einschaltdauer)               
                                                            console.log('Routine AWS-Schaltung - SET: ' + id + ' to ' + (obj.common.min || 0) + ' in ' + (z+y) + 'ms');
                                                        setStateDelayed(id, obj.common.min || DimmAusschalt, z+y, false);                          // Licht aus in y Millisekunden (Einschaltverzögerung plus Einschaltdauer)
                                                   } else {                                                                         // else - Gerät ist schon eingeschaltet
                                                    if (IgnoreWhenOn) {                                                             // keine Reaktion, wenn Gerät bereits eingeschaltet war
                                                            logtext = "keine Aktion - Gerät war bereits eingeschaltet";   
                                                       } else {                                                                     // else - es soll mit den neuen Werten übersteuert werden     
                                                            z = 0;                                                                  // Einschaltverzögerung setzen auf Null
                                                            console.log('Routine AWS-Schaltung - SET: ' + id + ' to ' + (obj.common.min || DimmAusschalt) + ' sofort');
                                                             setStateDelayed(id, obj.common.min || DimmAusschalt, z+y, true);                      // Licht aus in z+y Millisekunden (Einschaltverzögerung plus Einschaltdauer) ohne Einschaltverzögerung
                                                             logtext = "Gerät war bereits eingeschaltet - übersteuert - ohne Einschaltverzögerung - alter Zeitplan gelöscht";     
                                                       } // endeif IgnoreWhenOn
                                                    } // Ende IF für Check, ob bereits eingeschaltet
                                                 } // Ende IF für LEVEL Geräte
                                            
                                                    var GeraeteName = getObject(id).common.name;                         // Name des Gerätes in Klartext
                                                    var now =    new Date();                                                            // store current date and time
                                                    var currSec = now.getTime();                                                        // Millisekunden seit 01.01.1970 / current millisecs
                                                    var berechnEinZeit = millisecToDate( currSec + z);                                  // millisecs in Zeit umrechnen für die Einschaltzeit
                                                    var berechnAusZeit = millisecToDate(currSec + z + y);                               // millisecs in Zeit umrechnen für die Ausschaltzeit
                                            // WriteArray(objIDGruppe,timer, currSec + z, currSec + z + y)                                             // Merken des Schaltvorganges
                                                    string = objIDGruppe+";" + id +";" +  GeraeteName + ";" + z/1000 + ";" +y/1000+";"+berechnEinZeit + ";" + berechnAusZeit + ";" + logtext;     // bereite LOG vor
                                                    log("Routine AWS-Schaltung - EVENT " + objIDGruppe + "; " +id + "; " +  GeraeteName + "; " + z/1000 + "; " + y/1000 + "; " + berechnEinZeit + "; " + berechnAusZeit + "; " + logtext, "info");  //Log schreiben
                                                    writelog(string);                                                               // schreibe LOG in Datei
                                                    logtext = " ";
                                                           
                                            } // Ende Funktion
                                            
                                            
                                            //-----------------------------------------------------------------------------------------------------
                                            // Funktion zur Bestimmung einer ganzzahligen Zufallszahl innerhalb vorgegebener min/max Werte
                                            //-----------------------------------------------------------------------------------------------------
                                            function zufall(low,high,back) {
                                              back = Math.floor(Math.random() * (high - low + 1)) + low;   
                                            // log("AWS Zufallszahlen - low = " + low + "high = " + high + " back = " + back ,"info");
                                             return back;
                                            } // ende Funktion
                                            
                                            
                                            //-----------------------------------------------------------------------------------------------------
                                            // Funktion zur Überprüfung, ob die angegebenen Geräte existieren
                                            //-----------------------------------------------------------------------------------------------------
                                            function GeraetExists(objGruppe) {
                                            var back = false;
                                            var id = eval(objGruppe);
                                              
                                            if (SpaceChk.test(id)) {                     // objIDGruppe darf kein space enthalten // ist ein Gerät überhaupt zugeordnet?
                                            //         log("Gerät hat kein assignment - Gruppe " + objGruppe, "info"); 
                                                     return back;
                                             } // endif IDGruppe hat kein assignment
                                            
                                            if  (getState(id))   { // Existiert das Gerät?
                                                    back = true;
                                                } else {     
                                                    log("Gerät existiert nicht - bitte in den Einstellungen überprüfen - Gruppe " + objGruppe, "info"); 
                                            } // endif check on GeraetExists
                                            
                                            return back;
                                            } // ende Funktion
                                            
                                            
                                            //-----------------------------------------------------------------------------------------------------
                                            // Funktion schreibt einen Logeintrag in das Filesystem und auch in das interne Log-System
                                            //-----------------------------------------------------------------------------------------------------
                                            function writelog(string) {
                                                if (logflag === true) {
                                                 // Zerlege Datum und Zeit in Variable
                                                    var now =    new Date(); // store current date and time
                                                    var year =   now.getFullYear();
                                                    var month =  addZero(now.getMonth()+1);
                                                    var day =    addZero(now.getDate());
                                                    var Thour =  addZero(now.getHours());
                                                    var Tmin =   addZero(now.getMinutes());
                                                    var Tsec =   addZero(now.getSeconds());
                                                    var logdate = day + '.' + month + '.' + year;
                                                    var logtime = Thour + ':' + Tmin + ':' + Tsec;
                                            
                                                    fs.readFile(LogPath, 'utf8', function(err,data){
                                                        if (!err) { // File existiert
                                                            fs.appendFileSync(LogPath, logdate+" ;"+logtime+" ;"+string + "\n");       // Füge Satz in Datei ein
                                                        }else{
                                                            log("Logfile nicht gefunden - wird angelegt"), "info";
                                                            var headerLine= "Datum;Uhrzeit;Gruppe;GeräteID;Gerätebezeichnung;Einschaltverzögerung;LängeSchaltzeit;ZeitEin berechnet;ZeitAus berechnet;Kommentar"   
                                                            fs.appendFileSync(LogPath, headerLine + "\n"); // Füge Satz in Datei ein
                                                            fs.appendFileSync(LogPath, logdate+" ;"+logtime+" ;"+string + "\n"); // Füge Satz in Datei ein
                                                        }
                                                    }); // ende Filecheck
                                                } ; // Ende check on logflag
                                                
                                            } // Ende Funktion
                                            
                                            
                                            //-----------------------------------------------------------------------------------------------------
                                            // Funktion IsTimeInRange 
                                            // Ermittlung ob die aktuelle Zeit in der vorgegebenen Schaltzeit liegt (inkl. Astro)
                                            //-----------------------------------------------------------------------------------------------------
                                            function IsTimeInRange (zeitvon, zeitbis, Gruppe) {
                                                var now = new Date();
                                                var lower;                                              // enthält Javascript datums/Zeitformat für die VON Zeit
                                                var upper;                                              // enthält Javascript datums/Zeitformat für die BIS Zeit
                                                var astrovonDown = zeitvon.includes(KeyWordSunDown);    // Astrozeit VON Sonnenuntergang gesetzt
                                                var astrovonUp   = zeitvon.includes(KeyWordSunUp);      // Astrozeit VON Sonnenaufgang gesetzt
                                                var astrobisDown = zeitbis.includes(KeyWordSunDown);    // Astrozeit BIS Sonnenuntergang gesetzt
                                                var astrobisUp   = zeitbis.includes(KeyWordSunUp);      // Astrozeit BIS Sonnenaufgang gesetzt
                                                var astrovon = false;
                                                var astrobis = false;
                                            
                                                var StatusSwitchTime =checkSwitchTime(Gruppe);
                                                
                                                if (StatusSwitchTime) {                                  // es gibt einen aktuellen Eintrag bzw. laufende Schaltzeit für diese Gruppe
                                                    if(debug ) { log("Gruppe"+ Gruppe +  " ist im definierten Zeitrange - Schaltung ist aktiv", "info") }
                                                    return true; // in Tabelle SwitchTime gibt es noch einen gültigen Eintrag, also zurück zur Schaltung
                                                }
                                            
                                                // bei Verwendung von Astrozeiten werden die errechneten Zeiten in lower und upper gespeichert
                                                if (astrovonDown === true) {                            // Astrozeit gesetzt VON Zeit ist Sonnenuntergang
                                                    lower =  getAstroDate("sunsetStart");
                                                    astrovon = true;
                                                }
                                                if (astrovonUp === true) {                              // Astrozeit gesetzt VON Zeit ist Sonnenaufgang
                                                    lower =  getAstroDate("sunriseEnd");
                                                    astrovon = true;
                                                }
                                                if (astrobisDown === true) {                            // Astrozeit gesetzt BIS Zeit ist Sonnenuntergang
                                                    upper =  getAstroDate("sunsetStart");
                                                    if(astrovonDown) {                                  // wenn VonZeit = Untergang und BisZeit = Untergang - dann muss bis Zeit nächster Tag sein
                                                        upper.setDate(upper.getDate() + 1);             // 1 Tag (24 Stunden) addieren, da der BisWert wahrscheinlich am nächsten Tag liegen muss        
                                                    }
                                                    astrobis = true;
                                                }
                                                if (astrobisUp === true) {                              // Astrozeit gesetzt BIS Zeit ist Sonnenaufgang
                                                    upper =  getAstroDate("sunriseEnd");
                                                    if(astrovonDown) {                                  // wenn VonZeit = Aufgang und BisZeit = Aufgang - dann muss BIS Zeit nächster Tag sein
                                                       upper.setDate(upper.getDate() + 1);              // 1 Tag (24 Stunden) addieren, da der BisWert wahrscheinlich am nächsten Tag liegen muss    
                                                    }
                                                    astrobis = true;
                                                }
                                            
                                                // Wenn keine Astrozeiten verwendet werden, werden Zeiten anhand der Zeitangaben errechnet
                                                if (!astrovon) {
                                                    lower = addTime(zeitvon);                       // switch on time im berechenbaren Format
                                                }
                                                if (!astrobis) {
                                                    upper = addTime(zeitbis);                       // switch off time im berechenbaren Format
                                                }
                                            
                                                // Sonderfall: wenn die Zeitangaben sind identisch - also BisZeit nächster Tag und VonZeit muss auf now liegen
                                                if (zeitvon === zeitbis) { 
                                                    upper.setDate(upper.getDate() + 1); // 24 Stunden zur BisZeit hinzufügen 
                                                    lower = now;                                        // wenn z. B. von 23:00:00 bis 23:00:00 eingegeben wurde, dann soll immer geschaltet werden
                                               }
                                            
                                                // Wenn jetzt noch die VON Zeit kleiner als die BIS Zeit ist, muss die BIS Zeit evtl. auf den nächsten Tag gelegt werden (oder auch sie ist abgelaufen)
                                                if (upper < lower) {                                    // Die VonZeit ist größer als die BisZeit
                                                    if(astrovonDown) {                                  // im Falle von Astrovon kann es sein, dass die BisZeit in den nächsten Tag geht
                                                        if( upper.getHours()  < ErlieastSunDown ) {     // Überprüfen, ob die BisZeit kleiner als der Schwellenwert ist
                                                            upper.setDate(upper.getDate() + 1);         // 1 Tag (24 Stunden) addieren, da der BisWert wahrscheinlich am nächsten Tag liegen muss 
                                                            if (debug) { log("Gruppe"+ Gruppe +" bei Astrovon die zeitbis started Morgen - AstroZeit Sonnenuntergang VON ist "+ lower ,"info");}
                                                        }
                                                    }
                                                    if(astrovonUp) {                                    // im Falle von Astrovon kann es sein, dass die BisZeit in den nächsten Tag geht
                                                        if( upper.getHours()  < EarliestSunUp ) {       // Überprüfen, ob die BisZeit kleiner als der Schwellenwert ist
                                                            upper.setDate(upper.getDate() + 1);         // 1 Tag (24 Stunden) addieren, da der BisWert wahrscheinlich am nächsten Tag liegen muss 
                                                            if (debug) { log("Gruppe"+ Gruppe + " bei Astrovon die zeitbis started Morgen - AstroZeit Sonnenaufgang VON ist "+ lower,"info");}
                                                        }
                                                    }
                                            
                                                   if(astrobisDown) {                                   // im Falle von Astrovon kann es sein, dass die BisZeit in den nächsten Tag geht
                                                        if( lower.getHours()  > LatestSunDown ) {       // Überprüfen, ob die VonZeit größer als der Schwellenwert ist
                                                            upper.setDate(upper.getDate() + 1);         // 1 Tag (24 Stunden) addieren, da der BisWert wahrscheinlich am nächsten Tag liegen muss 
                                                            if (debug) { log("Gruppe"+ Gruppe + " bei Astrovon die zeitbis started Morgen - AstroZeit Sonnenuntergang BIS ist "+ upper,"info");}
                                                        }
                                                    }
                                                    if(astrobisUp) {                                    // im Falle von Astrovon kann es sein, dass die BisZeit in den nächsten Tag geht
                                                        if( lower.getHours()  > LatestSunDown ) {       // Überprüfen, ob die VonZeit größer als der Schwellenwert ist
                                                            upper.setDate(upper.getDate() + 1);         // 1 Tag (24 Stunden) addieren, da der bis Wert wahrscheinlich am nächsten Tag liegen muss 
                                                            if (debug) { log("Gruppe"+ Gruppe + " bei Astrovon die zeitbis started Morgen- - AstroZeit Sonnenaufgang BIS  ist "+ upper,"info");}
                                                        }
                                                    }
                                            
                                                    if (!astrovon && !astrobis) {                       // wenn keine Astrozeit gesetzt ist und die BisZeit kleiner ist --> nächster Tag für die BisZeit
                                                        upper.setDate(upper.getDate() + 1);             // 1 Tag (24 Stunden) addieren, da der BisWert wahrscheinlich am nächsten Tag liegen muss 
                                                    }
                                                }
                                               if (debug) {log("Gruppe"+ Gruppe + " Berechnung der Zeiten: VON " + lower + " BIS " + upper,"info");}
                                            
                                                // Wenn jetzt noch die BIS Zeit kleiner also die VON Zeit ist, dann ist die Zeit abgelaufen
                                                if (upper < lower ) {                               // dies trifft zu, wenn die Astrozeit die Realzeit eingeholt hat z. B. astrovon = 20:00 und bisZeit 19:00
                                                    if (debug) { log("Gruppe"+ Gruppe + " upper ist kleiner als lower - zurück Gruppe nicht (mehr) im Zeitrange false","info");}
                                                    return false;
                                                }
                                                if( now >= lower && now <= upper ) {
                                                    log("Gruppe"+ Gruppe + " aktuelle Zeit ist größer als lower und kleiner als upper - Gruppe wird geschaltet (true)" );
                                                    UpdateSwitchTime(Gruppe,lower,upper);
                                                    // if(debug ) { listcheckSwitch(Gruppe);}
                                                    return true;
                                                } else {
                                                    log("Gruppe"+ Gruppe + " aktuelle Zeit nicht im Zeitrange - keine Schaltung")
                                                    return false;
                                                }
                                            }
                                            
                                            
                                            //-----------------------------------------------------------------------------------------------------
                                            // Funktion checkSwitchTime zum Finden in Tabelle SwitchTime, ob es einen gültigen Eintrag innerhalb der Zeit gibt
                                            // Struktur SwitchTime:  0 = Schaltgruppe, 1 = vonZeit, 2 = bisZeit
                                            //-----------------------------------------------------------------------------------------------------
                                            function listcheckSwitch() {
                                                for (var x in SwitchTime) {
                                                    log("Gruppe" + SwitchTime[x][0] +  " Zeitvon " + SwitchTime[x][1] +  " Zeitbis " +  SwitchTime[x][2],"info");
                                                }
                                            } // Ende Funktion
                                            
                                            
                                            //-----------------------------------------------------------------------------------------------------
                                            // Funktion checkSwitchTime zum Finden in Tabelle SwitchTime, ob es einen gültigen Eintrag innerhalb der Zeit gibt
                                            // Struktur SwitchTime:  0 = Schaltgruppe, 1 = vonZeit, 2 = bisZeit
                                            //-----------------------------------------------------------------------------------------------------
                                            function checkSwitchTime(Gruppe) {
                                                var now = new Date();
                                            
                                                for (var x in SwitchTime) {
                                                    if(SwitchTime[x][0] === Gruppe) {
                                                        if( now >= SwitchTime[x][1] && now <= SwitchTime[x][2] ) {
                                                            return true;
                                                        }
                                                    }
                                                }
                                                return false;
                                            } // Ende Funktion
                                            
                                            
                                            //-----------------------------------------------------------------------------------------------------
                                            // Funktion UpdateSwitchTime macht ein Update auf die Tabelle für ausgelaufene und für neue Schaltzeiten
                                            // Struktur SwitchTime:  0 = Schaltgruppe, 1 = vonZeit, 2 = bisZeit
                                            //-----------------------------------------------------------------------------------------------------
                                            function UpdateSwitchTime(Gruppe,VonZeit,BisZeit) {
                                                for (var x in SwitchTime) {
                                                    if(SwitchTime[x][0] === Gruppe) {
                                                        if(debug){  log("Gruppe " + Gruppe + " Switchtime Update VON " + VonZeit + " BIS " + BisZeit,"info" );}
                                                        SwitchTime[Gruppe][1] = VonZeit;
                                                        SwitchTime[Gruppe][2] = BisZeit;
                                                        return;
                                                    }
                                                }
                                                SwitchTime.push([Gruppe, VonZeit, BisZeit]); // nicht gefunden - also hinzufügen
                                                if(debug){  log("Gruppe" + Gruppe + " Switchtime hinzufügen VON " + VonZeit + " BIS " + BisZeit,"info" );}
                                            } // Ende Funktion
                                            
                                            
                                            //-----------------------------------------------------------------------------------------------------
                                            // Funktion zur Erzeugung von führenden Nullen für das Datum Format
                                            //-----------------------------------------------------------------------------------------------------
                                            function addZero(i) {
                                                if (i < 10) {
                                                    i = "0" + i;
                                                }
                                                return i;
                                            } // Ende Funktion
                                            
                                            
                                            //-----------------------------------------------------------------------------------------------------
                                            // Funktion Millisekunden in Datum/Zeit umrechnen // wird für logging benötigt
                                            //-----------------------------------------------------------------------------------------------------
                                            function millisecToDate(millisec) {
                                                    var time = new Date(millisec);
                                                    var Thour =  addZero(time.getHours());
                                                    var Tmin =   addZero(time.getMinutes());
                                                    var Tsec =   addZero(time.getSeconds());
                                                    var datum = Thour + ':' + Tmin + ':' + Tsec;
                                                   return datum;
                                            } // Ende Funktion
                                            
                                            
                                            //-----------------------------------------------------------------------------------------------------
                                            // Funktion addTime wandelt einen String mit Format 00:00:00 in rechenbare Zeit um
                                            //-----------------------------------------------------------------------------------------------------
                                            function addTime(strTime) {
                                                var d = new Date();
                                                d = new Date(d.getFullYear(), d.getMonth(), d.getDate())
                                                var time = strTime.split(':');
                                                d.setHours(time[0]);
                                                d.setMinutes(time[1]);
                                                d.setSeconds(time[2]);
                                                return d;
                                            } // Ende Funktion
                                            

                                            Kannst Du das Problem lösen?

                                            paul53 1 Reply Last reply Reply Quote 1
                                            • First post
                                              Last post

                                            Support us

                                            ioBroker
                                            Community Adapters
                                            Donate

                                            890
                                            Online

                                            31.7k
                                            Users

                                            79.8k
                                            Topics

                                            1.3m
                                            Posts

                                            40
                                            271
                                            52862
                                            Loading More Posts
                                            • Oldest to Newest
                                            • Newest to Oldest
                                            • Most Votes
                                            Reply
                                            • Reply as topic
                                            Log in to reply
                                            Community
                                            Impressum | Datenschutz-Bestimmungen | Nutzungsbedingungen
                                            The ioBroker Community 2014-2023
                                            logo