Skip to content
  • Recent
  • Tags
  • 0 Unread 0
  • Categories
  • Unreplied
  • Popular
  • GitHub
  • Docu
  • Hilfe
Skins
  • Light
  • Brite
  • Cerulean
  • Cosmo
  • Flatly
  • Journal
  • Litera
  • Lumen
  • Lux
  • Materia
  • Minty
  • Morph
  • Pulse
  • Sandstone
  • Simplex
  • Sketchy
  • Spacelab
  • United
  • Yeti
  • Zephyr
  • Dark
  • Cyborg
  • Darkly
  • Quartz
  • Slate
  • Solar
  • Superhero
  • Vapor

  • Default (No Skin)
  • No Skin
Collapse
Logo
  1. ioBroker Community Home
  2. Deutsch
  3. Skripten / Logik
  4. [Vorlage] Anwesenheitssimulation - Script

NEWS

  • UPDATE 31.10.: Amazon Alexa - ioBroker Skill läuft aus ?
    apollon77A
    apollon77
    48
    3
    8.0k

  • Monatsrückblick – September 2025
    BluefoxB
    Bluefox
    13
    1
    1.8k

  • Neues Video "KI im Smart Home" - ioBroker plus n8n
    BluefoxB
    Bluefox
    15
    1
    2.0k

[Vorlage] Anwesenheitssimulation - Script

[Vorlage] Anwesenheitssimulation - Script

Scheduled Pinned Locked Moved Skripten / Logik
271 Posts 40 Posters 64.6k Views 36 Watching
  • Oldest to Newest
  • Newest to Oldest
  • Most Votes
Reply
  • Reply as topic
Log in to reply
This topic has been deleted. Only users with topic management privileges can see it.
  • L LJSven

    Welche Zeile ist das?

    L Offline
    L Offline
    looxer01
    wrote on last edited by
    #188

    @LJSven
    bei mir ist es ab Zeile 574. kann bei dir leicht verschoben sein, daher habe ich die vorherigen Zeilen hinzugefügt

    vg looxer

    1 Reply Last reply
    0
    • L Offline
      L Offline
      LJSven
      wrote on last edited by
      #189

      @looxer01 sagte in [Vorlage] Anwesenheitssimulation - Script:

      var now2 = new Date(); // store current date and time
      var currSec2 = now2.getTime(); // millisekunden seit 01.01.1970 /current millisecs
      var aktZeit = millisecToDate( currSec2); // millisecs in Zeit umrechnen fuer die Einschaltzeit
      log ("aktuelle Zeit "+ aktZeit);
      log("zeitvon "+ zeitvon);
      log("zeitbis "+ zeitbis);
      log("Gruppe "+ Gruppe);
      log("astrovonDown "+ astrovonDown);
      log("astrovonUp "+ astrovonUp);
      log("astrobisDown "+ astrobisDown);
      log("astrobisUp "+ astrobisUp);
      log("lower "+ lower);
      log("upper "+ upper);

      Habe ich gemacht. Hier die Antwort ->

      2019-07-18 14:15:00.073 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: aktuelle Zeit 14:15:00
      2019-07-18 14:15:00.074 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: zeitvon 20:00:00
      2019-07-18 14:15:00.074 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: zeitbis 03:00:00
      2019-07-18 14:15:00.074 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: Gruppe 4
      2019-07-18 14:15:00.074 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: astrovonDown false
      2019-07-18 14:15:00.074 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: astrovonUp false
      2019-07-18 14:15:00.074 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: astrobisDown false
      2019-07-18 14:15:00.075 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: astrobisUp false
      2019-07-18 14:15:00.075 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: lower Thu Jul 18 2019 20:00:00 GMT+0200 (CEST)
      2019-07-18 14:15:00.075 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: upper Fri Jul 19 2019 03:00:00 GMT+0200 (CEST)
      2019-07-18 14:15:00.075 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: Routine IsTimeInRange - Gruppe4 Zeit nicht im Zeitrange - keine Schaltung
      2019-07-18 14:15:00.085 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: aktuelle Zeit 14:15:00
      2019-07-18 14:15:00.086 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: zeitvon 20:15:00
      2019-07-18 14:15:00.086 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: zeitbis 22:45:00
      2019-07-18 14:15:00.086 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: Gruppe 5
      2019-07-18 14:15:00.086 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: astrovonDown false
      2019-07-18 14:15:00.086 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: astrovonUp false
      2019-07-18 14:15:00.086 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: astrobisDown false
      2019-07-18 14:15:00.086 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: astrobisUp false
      2019-07-18 14:15:00.087 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: lower Thu Jul 18 2019 20:15:00 GMT+0200 (CEST)
      2019-07-18 14:15:00.087 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: upper Thu Jul 18 2019 22:45:00 GMT+0200 (CEST)
      2019-07-18 14:15:00.087 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: Routine IsTimeInRange - Gruppe5 Zeit nicht im Zeitrange - keine Schaltung
      2019-07-18 14:15:00.093 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: aktuelle Zeit 14:15:00
      2019-07-18 14:15:00.093 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: zeitvon 23:30:00
      2019-07-18 14:15:00.093 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: zeitbis 01:00:00
      2019-07-18 14:15:00.093 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: Gruppe 3
      2019-07-18 14:15:00.093 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: astrovonDown false
      2019-07-18 14:15:00.093 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: astrovonUp false
      2019-07-18 14:15:00.093 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: astrobisDown false
      2019-07-18 14:15:00.094 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: astrobisUp false
      2019-07-18 14:15:00.094 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: lower Thu Jul 18 2019 23:30:00 GMT+0200 (CEST)
      2019-07-18 14:15:00.094 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: upper Fri Jul 19 2019 01:00:00 GMT+0200 (CEST)
      2019-07-18 14:15:00.094 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: Routine IsTimeInRange - Gruppe3 Zeit nicht im Zeitrange - keine Schaltung
      2019-07-18 14:15:00.098 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: aktuelle Zeit 14:15:00
      2019-07-18 14:15:00.099 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: zeitvon 19:30:00
      2019-07-18 14:15:00.099 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: zeitbis 23:00:00
      2019-07-18 14:15:00.099 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: Gruppe 2
      2019-07-18 14:15:00.099 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: astrovonDown false
      2019-07-18 14:15:00.099 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: astrovonUp false
      2019-07-18 14:15:00.099 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: astrobisDown false
      2019-07-18 14:15:00.099 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: astrobisUp false
      2019-07-18 14:15:00.100 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: lower Thu Jul 18 2019 19:30:00 GMT+0200 (CEST)
      2019-07-18 14:15:00.100 - info: javascript.0 script.js.common.Sonstige.Anwesenheitssimulation: upper Thu Jul 18 2019 23:00:00 GMT+0200 (CEST)
      
      1 Reply Last reply
      0
      • L Offline
        L Offline
        looxer01
        wrote on last edited by
        #190

        Gruppe1 ist nicht gelistet. Ich weiss nicht warum nicht
        Gruppe2 ist mit 19:30 (von Zeit) -

        hat Gruppe2 denn wie erwartet funktioniert ?

        1 Reply Last reply
        0
        • L Offline
          L Offline
          LJSven
          wrote on last edited by
          #191

          Gruppe 1 geht nicht
          Gruppe 2 scheint zu gehen
          Gruppe 5 (TV) geht nicht.

          Foto 22.07.19, 10 18 43.jpg

          1 Reply Last reply
          0
          • S Offline
            S Offline
            skorpil
            wrote on last edited by
            #192

            Im Anwesenheitsscript von @looxer01 erhalte ich folgende Fehlermeldung:

            2019-11-09 18:57:00.023 - info: javascript.0 (22758) script.js.common.Anwesenheitssimulation.Abwesenheitssimulation: Routine IsTimeInRange - Gruppe2 aktuelle ist ist > als lower und kleiner als upper - Gruppe wird geschaltet (true)
            2019-11-09 18:57:00.063 - error: javascript.0 (22758) Error in callback: TypeError: Cannot set property '1' of undefined
            2019-11-09 18:57:00.063 - error: javascript.0 (22758) at UpdateSwithTime (script.js.common.Anwesenheitssimulation.Abwesenheitssimulation:621:36)
            2019-11-09 18:57:00.063 - error: javascript.0 (22758) at IsTimeInRange (script.js.common.Anwesenheitssimulation.Abwesenheitssimulation:570:9)
            2019-11-09 18:57:00.064 - error: javascript.0 (22758) at Object. (script.js.common.Anwesenheitssimulation.Abwesenheitssimulation:219:8)
            2019-11-09 18:57:00.064 - error: javascript.0 (22758) at Job.nodeSchedule.scheduleJob [as job] (/opt/iobroker/node_modules/iobroker.javascript/lib/sandbox.js:1279:34)
            2019-11-09 18:57:00.064 - error: javascript.0 (22758) at Job.invoke (/opt/iobroker/node_modules/iobroker.javascript/node_modules/node-schedule/lib/schedule.js:173:10)
            2019-11-09 18:57:00.064 - error: javascript.0 (22758) at /opt/iobroker/node_modules/iobroker.javascript/node_modules/node-schedule/lib/schedule.js:543:11
            2019-11-09 18:57:00.064 - error: javascript.0 (22758) at Timeout._onTimeout (/opt/iobroker/node_modules/iobroker.javascript/node_modules/node-schedule/lib/schedule.js:501:7)
            2019-11-09 18:57:00.064 - error: javascript.0 (22758) at ontimeout (timers.js:498:11)
            2019-11-09 18:57:00.064 - error: javascript.0 (22758) at tryOnTimeout (timers.js:323:5)
            2019-11-09 18:57:00.064 - error: javascript.0 (22758) at Timer.listOnTimeout (timers.js:290:5)
            

            Kann mir einer der Fachleute helfen, das zu verstehen bzw. das Skript anzupassen? Ich benutze dieses Script "https://forum.iobroker.net/topic/1671/vorlage-anwesenheitssimulation-script/2", dass bisher auch ganz gut gelaufen ist.

            Danke für Eure Unterstützung.

            NegaleinN L 2 Replies Last reply
            0
            • S skorpil

              Im Anwesenheitsscript von @looxer01 erhalte ich folgende Fehlermeldung:

              2019-11-09 18:57:00.023 - info: javascript.0 (22758) script.js.common.Anwesenheitssimulation.Abwesenheitssimulation: Routine IsTimeInRange - Gruppe2 aktuelle ist ist > als lower und kleiner als upper - Gruppe wird geschaltet (true)
              2019-11-09 18:57:00.063 - error: javascript.0 (22758) Error in callback: TypeError: Cannot set property '1' of undefined
              2019-11-09 18:57:00.063 - error: javascript.0 (22758) at UpdateSwithTime (script.js.common.Anwesenheitssimulation.Abwesenheitssimulation:621:36)
              2019-11-09 18:57:00.063 - error: javascript.0 (22758) at IsTimeInRange (script.js.common.Anwesenheitssimulation.Abwesenheitssimulation:570:9)
              2019-11-09 18:57:00.064 - error: javascript.0 (22758) at Object. (script.js.common.Anwesenheitssimulation.Abwesenheitssimulation:219:8)
              2019-11-09 18:57:00.064 - error: javascript.0 (22758) at Job.nodeSchedule.scheduleJob [as job] (/opt/iobroker/node_modules/iobroker.javascript/lib/sandbox.js:1279:34)
              2019-11-09 18:57:00.064 - error: javascript.0 (22758) at Job.invoke (/opt/iobroker/node_modules/iobroker.javascript/node_modules/node-schedule/lib/schedule.js:173:10)
              2019-11-09 18:57:00.064 - error: javascript.0 (22758) at /opt/iobroker/node_modules/iobroker.javascript/node_modules/node-schedule/lib/schedule.js:543:11
              2019-11-09 18:57:00.064 - error: javascript.0 (22758) at Timeout._onTimeout (/opt/iobroker/node_modules/iobroker.javascript/node_modules/node-schedule/lib/schedule.js:501:7)
              2019-11-09 18:57:00.064 - error: javascript.0 (22758) at ontimeout (timers.js:498:11)
              2019-11-09 18:57:00.064 - error: javascript.0 (22758) at tryOnTimeout (timers.js:323:5)
              2019-11-09 18:57:00.064 - error: javascript.0 (22758) at Timer.listOnTimeout (timers.js:290:5)
              

              Kann mir einer der Fachleute helfen, das zu verstehen bzw. das Skript anzupassen? Ich benutze dieses Script "https://forum.iobroker.net/topic/1671/vorlage-anwesenheitssimulation-script/2", dass bisher auch ganz gut gelaufen ist.

              Danke für Eure Unterstützung.

              NegaleinN Offline
              NegaleinN Offline
              Negalein
              Global Moderator
              wrote on last edited by
              #193

              @skorpil sagte in [Vorlage] Anwesenheitssimulation - Script:

              Kann mir einer der Fachleute helfen

              Hallo

              Ich habe deinen Beitrag hierher verschoben.
              Passt besser zum eigentlichen Thread des Scripts!

              ° Node.js: 20.17.0 NPM: 10.8.2
              ° Proxmox, Ubuntu 22.04.3 LTS
              ° Fixer ---> iob fix

              1 Reply Last reply
              1
              • M Offline
                M Offline
                mcmuller
                wrote on last edited by mcmuller
                #194

                Danke für das schöne Skript! Beim Erstellen von IKEA-Tradfri-Gruppen hatte ich das Problem, daß in Zeile 335 auf "SKRIPT" gematched wird, der Tradfri-Adapter aber "skript"-Punkte anlegt. Wie kann ich das REGEX auf case-insensitive umbauen?

                if (eval(objIDGruppe).match('?i:STATE')) {
                oder
                if (eval(objIDGruppe).match('STATE/i')) {
                funktioniert nicht...

                ...vielleicht hat ja jemand das gleiche Problem.

                Grüße,
                mcmuller

                ioBroker auf FreeNAS (FreeBSD 11.1), CCU2, ALPHA2 FBH-Steuerung, Opensprinker, Frankies Poolcontroller, div. Prodinos, SMA Webbox, Enigma Receiver

                W 1 Reply Last reply
                0
                • M mcmuller

                  Danke für das schöne Skript! Beim Erstellen von IKEA-Tradfri-Gruppen hatte ich das Problem, daß in Zeile 335 auf "SKRIPT" gematched wird, der Tradfri-Adapter aber "skript"-Punkte anlegt. Wie kann ich das REGEX auf case-insensitive umbauen?

                  if (eval(objIDGruppe).match('?i:STATE')) {
                  oder
                  if (eval(objIDGruppe).match('STATE/i')) {
                  funktioniert nicht...

                  ...vielleicht hat ja jemand das gleiche Problem.

                  Grüße,
                  mcmuller

                  W Offline
                  W Offline
                  watcherkb
                  wrote on last edited by
                  #195

                  @looxer01
                  Habe das Script nun angewandt und bekomme eine Fehlermeldung. Kannst du mir helfen wo der Fehler sein könnte?

                  b334472c-8bf3-48cc-83cd-30d28f0fa2bb-image.png

                  CC2538+CC2592 PA-Zigbee-Funkmodul

                  1 Reply Last reply
                  0
                  • L Offline
                    L Offline
                    looxer01
                    wrote on last edited by
                    #196

                    Hi,
                    ich habs getestet und das Objekt ist aus meiner Sicht ok wie es dort beschrieben ist. Es funktioniert auf jeden Fall.
                    Der Javascript editor ist weniger tolerant als es früher der Fall war und manches kann ignoriert werden.
                    Das hier scheint mir dazuzugehören.

                    vG Looxer

                    W 1 Reply Last reply
                    0
                    • L looxer01

                      Hi,
                      ich habs getestet und das Objekt ist aus meiner Sicht ok wie es dort beschrieben ist. Es funktioniert auf jeden Fall.
                      Der Javascript editor ist weniger tolerant als es früher der Fall war und manches kann ignoriert werden.
                      Das hier scheint mir dazuzugehören.

                      vG Looxer

                      W Offline
                      W Offline
                      watcherkb
                      wrote on last edited by
                      #197

                      @looxer01
                      Hi,

                      funktionieren tut es bei mir auch. Hatte mich nur gewundert warum es dort angemeckert wird.
                      Danke für das tolle Script!

                      CC2538+CC2592 PA-Zigbee-Funkmodul

                      1 Reply Last reply
                      0
                      • Uli977U Offline
                        Uli977U Offline
                        Uli977
                        wrote on last edited by Uli977
                        #198

                        Hallo zusammen,

                        wenn ich den Anwesenheitssteuerungsflag ausschalte, dann bekomme ich diese Fehlermeldung.

                        fc556c95-e934-4c34-84f9-d0ca39a61447-image.png

                        81131914-f700-499a-bd47-9540c8b105b3-image.png
                        Habe nichts geändert in Zeilt 293 oder 296.

                        Woran liegt's?

                        Danke Euch!

                        EDIT: Fehler gefunden. Ich hatte noch unbekannte Geräte in den Gruppen!!!!!

                        G 1 Reply Last reply
                        0
                        • Uli977U Uli977

                          Hallo zusammen,

                          wenn ich den Anwesenheitssteuerungsflag ausschalte, dann bekomme ich diese Fehlermeldung.

                          fc556c95-e934-4c34-84f9-d0ca39a61447-image.png

                          81131914-f700-499a-bd47-9540c8b105b3-image.png
                          Habe nichts geändert in Zeilt 293 oder 296.

                          Woran liegt's?

                          Danke Euch!

                          EDIT: Fehler gefunden. Ich hatte noch unbekannte Geräte in den Gruppen!!!!!

                          G Offline
                          G Offline
                          giessener
                          wrote on last edited by
                          #199

                          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
                          0
                          • G giessener

                            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 Offline
                            F Offline
                            FoxRo
                            wrote on last edited by
                            #200

                            @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
                            0
                            • G giessener

                              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);
                                  
                              });
                              
                              Q Offline
                              Q Offline
                              qwerty1896
                              wrote on last edited by
                              #201

                              @giessener

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

                              1 Reply Last reply
                              0
                              • T Offline
                                T Offline
                                torsten3009
                                wrote on last edited by
                                #202

                                bekommt einer aktuell auch den Fehler?

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

                                T 1 Reply Last reply
                                0
                                • T torsten3009

                                  bekommt einer aktuell auch den Fehler?

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

                                  T Offline
                                  T Offline
                                  torsten3009
                                  wrote on last edited by
                                  #203

                                  @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
                                  0
                                  • T torsten3009

                                    @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 Offline
                                    S Offline
                                    samxy
                                    wrote on last edited by
                                    #204

                                    @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
                                    0
                                    • L looxer01

                                      Hallo Alle,

                                      aus aktuellem Anlass- Heimsuchung letzte Nacht von Unbekannten 😞 - fange ich an ein paar Sicherheitsmassnahmen umzusetzen.
                                      Die Ermittlung der zu schaltenden Geraete wird ueber eine Zufallszahl durchgeführt.
                                      Auch die Anschaltdauer und Einschaltverzoegerung wird über Zufallszahl geregelt.
                                      Der Ansatz ist folgender.

                                      • Es können beliebig viele Gruppen definiert werden für die jeweils andere Steuerungsdaten vorgebbar sind. (z.B. könnten Gruppen als Räume oder auch als Zeitabschnitte verstehbar sein z.B. Flur ab 22:00 Uhr, Wohnzimmer ab 20:15, Garten etc.)
                                      • Je Gruppe können folgende Vorgaben gemacht werden
                                      • Beliebig viele Geraete steuerbar
                                      • Geräte sind schaltbar für LEVEL und STATE - bei LEVEL wird immer von 0 und 100 ausgegangen
                                      • Zeitsteuerung: von - bis Uhrzeit - nur in dieser Zeit wird geschaltet - In den Zeiten kann auch ein gültiges Astro-Keyword verwendet werden. Also z.B. 20:00:00 als Zeit oder „sunset“ als Keyword
                                      • Zeitsteuerung: der Einchaltdauerbereich „von“ und „bis“ kann festgelegt werden. Die eigentliche Einschaltdauer wird per Zufallsgenerator für diesen Bereich ermittelt
                                      • Jobsteuerung :- Definition von Anzahl minuten für die die AWS aufgerufen wird. z.B. alle 30 Minuten
                                        Darüber hinaus kann über ein Flag die AWS ein oder ausgeschaltet werden. (wird automatisch angelegt)
                                        als Widget verwende ich ein HQ ON/OFF Widget, dass auf true/false toggeled
                                        305_anwesenheit.gif

                                      Des weiteren gibt es noch ein Extra Log das jede Aktion aufzeichnet. Das wird im CSV Format gemacht. So kann man die Datei auch mit Excel gut einlesen und verarbeiten. Das dient vor allem zur Optimierung der Einstellungen.
                                      Pfad und Name des Logs: /opt/iobroker/iobroker-data/AWSLog.csv
                                      Die Einstellungen müssen direkt im Script vorgenommen werden. Ist entsprechend mit Beispielen belegt für Gruppe1

                                      …...............................................................................................................................................

                                      hier mal Szenarios um zu zeigen was möglich ist


                                      1. In der Zeit von Dämmerung bis 20:15 ist viel Leben im Haus. Daher gehen die Lichter in verschiedenen Räumen an und aus.
                                      Gleichzeitig ist es im Wohnzimmer aber eher durchgehend beleuchtet
                                      Einstellungen Gruppe 1:
                                      Für Gruppe1 werden verschiedene IDs aus dem Haus zugeordnet, nicht jedoch Lampen aus dem Wohnzimmer
                                      IDGruppe11 bis IDGruppe15 - Einstellung der IDs
                                      Die zufällige Auswahl erfolgt durch eine Zufallsberechnung anhand der Anzahl der Gruppenmitglieder.
                                      Bei 5 Zeilen wird also jeweils eine zahl 1-5 ermittelt. Man kann z.B. auch eine Gruppe nicht belegen und so hin und wieder auch zufällig keine Schaltung zu haben.
                                      cron1 = 10 Minuten (alle 10 Minuten wird geprüft, ob eine Lampe eingeschaltet werden soll)
                                      StartDelay1 = 2 Minute (ist der maximale Delay - entspricht Abweichung von vollen Minuten)
                                      ein1von 5 ein1bis 10 (häufige an und aus Bewegungen)
                                      zeit1bis = "20:15:00"
                                      Gleichzeig werden in Gruppe2 z.B. zwei Lampen eingetragen und entsprechend justiert

                                      Einstellungen Gruppe 2
                                      cron2 = 30 Minuten (alle 30 Minuten wird geprüft, ob eine Lampe eingeschaltet werden soll)
                                      StartDelay2 = 2 Minute (ist der maximale Delay - entspricht abweichung von vollen Minuten)
                                      ein3von 20 ein3bis 35 (Wenig Bewegung im Wohnzimmer - überlappend mit dem Cron Job)
                                      Zeit2von „sunset“
                                      zeit2bis = "23:15:00"

                                      Die nächste Phase ist dann eher die Fernsehphase. (Gruppe 3 )

                                      Wohnzimmer ist durchgehend schwach beleuchtet.
                                      Von jetzt an bis in die Nacht geht unregelmaessig und fuer kurze Zeit das Licht im Flur und im Bad an
                                      Einstellungen Gruppe 3:
                                      GruppenIDs mit Lichter für Bad und Flur versehen (z.B 3 IDs)
                                      cron3 = 45 Minuten (alle 45 Minuten wird geprüft, ob eine Lampe eingeschaltet werden soll)
                                      StartDelay3 = 2 Minuten (ist der maximale Delay - entspricht abweichung von vollen Minuten)
                                      ein3von 2 ein3bis 10
                                      zeit3von = "21:00:00"
                                      zeit3bis = "03:00:00"


                                      noch ein Tipp:
                                      im Prinzip laesst sich mit dem Script alles schalten , da implizit auch eine Programmierschnittstelle enthalten ist
                                      somit laesst sich z.B. Musik einschalten, Sprachnachrichten aktivieren (z.B. Hundegebell ueber die Lautsprecher),
                                      Hue Lampen schalten, eben alles was irgendwie schaltbar ist

                                      Anlegen einer Variable die am Ende ein STATE enthaelt und Reaktion in einem eigenen Programm, wie z.B:

                                      createState('Anwesenheitssteuerung.Sonos.STATE',false);
                                      on({id: "Anwesenheitssteuerung.Sonos.STATE", val: true}, function(obj) {     }     // Event:  wenn Status gewechselt
                                      

                                      Durch Eintragen von: Anwesenheitssteuerung.Sonos.STATE in einer der IDs im Script
                                      laesst sich jetzt auf die Statusaenderung reagieren. z.B. einschalten der Musik oder eben ausschalten

                                      –-------------------------------------------------------------------------------------------------------------------------------------------------------

                                      Fuer diejenigen, die den Programmablauf verstehen wollen:

                                      Hauptablauf
                                      
                                         Initialisierung und Konfiguration
                                             Einstellungen wie Aktivzeiten, Einschaltdauer, Startverzögerung, Cron-Intervalle und zu steuernde Geräte pro Gruppe werden definiert.
                                             Experteneinstellungen wie Logging-Flags, Aktivierungs-ID, Pfad für das externe Log, etc. werden gesetzt.
                                             Falls Debugging aktiviert ist, wird eine Debug-Meldung ausgegeben.
                                      
                                         Konsistenzprüfung
                                             checkArrays(): Prüft, ob die Konfigurationen der Gruppen konsistent sind (gleiche Anzahl von Einträgen).
                                      
                                         Initialisieren der Schaltzeiten
                                             var SwitchTimes = []: Initialisiert ein Array, das alle aktuellen Schaltzeiten enthält.
                                      
                                         Astrozeiten Ausgeben
                                             Astrozeiten(): Gibt die aktuellen Astrozeiten aus, wenn Debugging aktiviert ist.
                                      
                                         Zustand Erstellen
                                             createStateAsync(): Legt den Zustand der Anwesenheitssteuerung an, falls noch nicht vorhanden.
                                      
                                         Initiales Schedule Erstellen
                                             if (getState(Config.IDAWSaktiv).val || !Config.CronOnlyIfAWStrue) { CreateSchedules(); }
                                             Wenn das Anwesenheitssteuerungs-Flag aktiv ist, werden die Schedules erstellt.
                                      
                                      Event-Handler
                                      
                                         AWS Aktivierungs-Handler
                                             on({ id: Config.IDAWSaktiv, val: true }, handleAWSAktivierung);
                                             Bei Aktivierung des AWS-Flags werden die Schedules erstellt und ein Aktivierungs-Log geschrieben.
                                      
                                         AWS Deaktivierungs-Handler
                                             on({ id: Config.IDAWSaktiv, val: false }, handleAWSDeaktivierung);
                                             Bei Deaktivierung des AWS-Flags werden die Schedules gelöscht, Geräte ausgeschaltet und ein Deaktivierungs-Log geschrieben.
                                      
                                      Funktionen
                                      
                                         executeSchedule(gruppe, index)
                                             Führt die notwendigen Schaltvorgänge für die angegebene Gruppe durch.
                                             Prüft, ob die aktuelle Zeit innerhalb der definierten Aktivzeiten liegt (IsTimeInRange).
                                             Wählt ein zufälliges Gerät und berechnet Einschaltverzögerung und -dauer.
                                             Führt die Schaltung durch (AWSSchaltung), falls das Gerät existiert und innerhalb des Zeitbereichs liegt.
                                      
                                         IsTimeInRange(zeitvon, zeitbis, Gruppe)
                                             Prüft, ob die aktuelle Zeit innerhalb der angegebenen Zeitbereiche (inkl. Astrozeiten) liegt.
                                             Gibt true zurück, wenn die aktuelle Zeit innerhalb des definierten Zeitbereichs liegt und aktualisiert die Schaltzeiten-Tabelle (UpdateSwitchTime).
                                      
                                         AWSSchaltung(id, einschaltdauer, verzoegerung, gruppe)
                                             Schaltet ein Gerät für eine bestimmte Dauer ein und nach Ablauf wieder aus.
                                             Loggt den Schaltvorgang und schreibt die Details in das Log-File (writelog).
                                      
                                         handleAWSDeaktivierung()
                                             Löscht die Schedules und schaltet alle teilnehmenden Geräte aus, wenn das AWS-Flag deaktiviert wird.
                                             Loggt die Deaktivierung und löscht alle geplanten Schaltvorgänge (clearStateDelayed).
                                      
                                         handleAWSAktivierung()
                                             Erstellt die Schedules, wenn das AWS-Flag aktiviert wird.
                                             Loggt die Aktivierung.
                                      
                                         zufall(min, max)
                                             Generiert eine zufällige Zahl zwischen min und max.
                                      
                                         GeraetExists(id)
                                             Prüft, ob ein Gerät existiert.
                                      
                                         writelog(string)
                                             Schreibt einen Logeintrag in das externe Log-File und das interne Log-System.
                                      
                                         listcheckSwitch()
                                             Listet die aktuellen Schaltzeiten auf.
                                      
                                         checkSwitchTime(Gruppe)
                                             Prüft, ob ein gültiger Eintrag innerhalb der Zeit für die angegebene Gruppe existiert.
                                      
                                         UpdateSwitchTime(Gruppe, VonZeit, BisZeit)
                                             Aktualisiert die Schaltzeiten-Tabelle für die angegebene Gruppe.
                                      
                                         addZero(i)
                                             Fügt führende Nullen für das Datumsformat hinzu.
                                      
                                         addTime(strTime)
                                             Wandelt eine Zeit im Format HH:MM:SS in ein berechenbares Datumsobjekt um.
                                      
                                         millisecToDate(millisec)
                                             Wandelt Millisekunden in ein Datum/Zeit-Format um.
                                      
                                         Astrozeiten()
                                             Listet die aktuellen Astrozeiten auf, wenn Debugging aktiviert ist.
                                      
                                         formatDate(date)
                                             Formatiert ein Datum für die Ausgabe der Astrozeiten.
                                      
                                      Zeitplan-Management
                                      
                                         CreateSchedules()
                                             Erstellt Zeitpläne für alle Gruppen basierend auf den definierten Cron-Intervallen und Aktivzeiten.
                                      
                                         DeleteSchedules()
                                             Löscht alle Zeitpläne, wenn das AWS-Flag deaktiviert wird.
                                      

                                      die AWS kann hier heruntergeladen werden:
                                      AWS_Vers1-30.txt

                                      S Offline
                                      S Offline
                                      SoerenKaiser99
                                      wrote on last edited by SoerenKaiser99
                                      #205

                                      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
                                      0
                                      • S 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 Offline
                                        S Offline
                                        skorpil
                                        wrote on last edited by
                                        #206

                                        @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
                                        0
                                        • B Offline
                                          B Offline
                                          Beowolf
                                          wrote on last edited by Beowolf
                                          #207

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

                                          Die Natur braucht nicht unseren Schutz, sie braucht unsere Abwesenheit.

                                          1 Reply Last reply
                                          0
                                          Reply
                                          • Reply as topic
                                          Log in to reply
                                          • Oldest to Newest
                                          • Newest to Oldest
                                          • Most Votes


                                          Support us

                                          ioBroker
                                          Community Adapters
                                          Donate

                                          634

                                          Online

                                          32.4k

                                          Users

                                          81.3k

                                          Topics

                                          1.3m

                                          Posts
                                          Community
                                          Impressum | Datenschutz-Bestimmungen | Nutzungsbedingungen
                                          ioBroker Community 2014-2025
                                          logo
                                          • Login

                                          • Don't have an account? Register

                                          • Login or register to search.
                                          • First post
                                            Last post
                                          0
                                          • Recent
                                          • Tags
                                          • Unread 0
                                          • Categories
                                          • Unreplied
                                          • Popular
                                          • GitHub
                                          • Docu
                                          • Hilfe