Navigation

    Logo
    • Register
    • Login
    • Search
    • Recent
    • Tags
    • Unread
    • Categories
    • Unreplied
    • Popular
    • GitHub
    • Docu
    • Hilfe
    1. Home
    2. Deutsch
    3. Skripten / Logik
    4. JavaScript
    5. Shelly Verbrauchs-Historie für Tag, Woche, Monat, Jahr

    NEWS

    • Neuer Blog: Fotos und Eindrücke aus Solingen

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

    • ioBroker goes Matter ... Matter Adapter in Stable

    Shelly Verbrauchs-Historie für Tag, Woche, Monat, Jahr

    This topic has been deleted. Only users with topic management privileges can see it.
    • ingranu
      ingranu last edited by

      Hallo zusammen

      Ich benutze seit einiger Zeit das Script und bin sehr zufrieden.
      Nun habe ich bei mir Shelly Plus1 PM verbaut, da diese mit MQTT laufen habe ich eine zweite Instanz mit dem Adapter Shelly.1 am laufen.

      Wie kann ich das Script nun anpassen damit auch diese Werte aufgenommen werden? Kann ich das so machen:

      // Datenpunkt der Shelly (Standard: shelly.0)
      
      var shelly_dp = "shelly.0";
      var shelly_dp = "shelly.1";
      
      T 1 Reply Last reply Reply Quote 0
      • T
        ticaki Developer @ingranu last edited by

        @ingranu
        Nein, pro Instanz 1 Skript

        ingranu 2 Replies Last reply Reply Quote 0
        • ingranu
          ingranu @ticaki last edited by

          @ticaki ok danke

          1 Reply Last reply Reply Quote 0
          • ingranu
            ingranu @ticaki last edited by

            @ticaki Kann ich einfach nochmals das Script kopieren und dann:

            // Datenpunkt der Shelly (Standard: shelly.0)
            var shelly_dp = "shelly.1";
            

            So einstellen? Oder gibt das Probleme mit den bestehden Ordner 0_userdata ?

            T SKB 2 Replies Last reply Reply Quote 0
            • T
              ticaki Developer @ingranu last edited by

              @ingranu
              Ich kann mir das Script in 2h ansehen, es wird wahrscheinlich zu durcheinander führen wenn die beide den gleichen Ordner nutzen, denke mit geringfügigen Anpassungen sollte das gehen. Schaue ich mir an.

              1 Reply Last reply Reply Quote 0
              • SKB
                SKB Developer Most Active @ingranu last edited by

                @ingranu Wenn du auf die Instanz 1 per MQTT nur die empfängst, die du bei Instanz 0 nicht hast, kannst du dies so machen.

                ingranu 1 Reply Last reply Reply Quote 0
                • ingranu
                  ingranu @SKB last edited by

                  @skb Ja genau, also auf Instanz1 habe ich nur die MQTT device und auf Instanz 0 den rest.
                  Wie kann ich das nun machen?

                  Für beide jeweils einen Script nehmen, oder nur einen Script und den wie folgt anpassen:

                  // Datenpunkt der Shelly (Standard: shelly.0)
                  var shelly_dp = "shelly.0";
                  var shelly_dp = "shelly.1";
                  
                  S SKB 2 Replies Last reply Reply Quote 0
                  • S
                    SpacerX @ingranu last edited by SpacerX

                    @ingranu für jede Instanz ein Script. Einmal shelly.0 und einmal shelly.1 in dem Script eintragen.
                    Vorausgesetzt das kein Shelly mit beiden Instanzen verbunden ist sollte es unter ShellyVerbrauch auch keine Konflikte geben.
                    Wenn du sicher gehen willst kannst du auch Instanz 0 unter dem Zweig Shelly Verbrauch_0 und für die zweite Instanz 1 unter ShellyVerbrauch_1 abspeichern.

                    1 Reply Last reply Reply Quote 0
                    • SKB
                      SKB Developer Most Active @ingranu last edited by

                      @ingranu Für jede Instanz ein Skript und jeweils shelly.0 und Shelly.1

                      1 Reply Last reply Reply Quote 0
                      • ingranu
                        ingranu last edited by

                        Ok habe ich so gemacht, die Werte werden auch geschrieben.
                        Jedoch habe ich im Protokoll folgende Meldung:

                        172
                        
                        Log-Größe: 129.4 KB
                        Zeit
                        	
                        Nachricht
                        javascript.0
                        	2023-08-02 16:00:00.155	warn	at Immediate._onImmediate (/opt/iobroker/node_modules/@iobroker/js-controller-adapter/src/lib/adapter/adapter.js:5916:56)
                        javascript.0
                        	2023-08-02 16:00:00.155	warn	at Object.callback (/opt/iobroker/node_modules/iobroker.javascript/lib/sandbox.js:1255:38)
                        javascript.0
                        	2023-08-02 16:00:00.155	warn	getState "0_userdata.0.ShellyVerbrauch.SHPLG-S#7C87CEBA3D58#1.Relay0.heute" not found (3)
                        javascript.0
                        	2023-08-02 16:00:00.154	warn	at processImmediate (node:internal/timers:476:21)
                        

                        Das Gerät mit der ID: 7C87CEBA3D58 Gibt es aber garnicht.

                        SKB 1 Reply Last reply Reply Quote 0
                        • SKB
                          SKB Developer Most Active @ingranu last edited by

                          @ingranu unter beiden Instanzen nicht?

                          Vielleicht eine Leiche von vorherigen Tests?

                          Skript stoppen, Datenpunkt löschen, Skript starten.

                          ingranu 1 Reply Last reply Reply Quote 0
                          • ingranu
                            ingranu @SKB last edited by

                            @skb Nein nur unter einer Instanz. Habe auch alles gelöscht und das Skript neugestartet ohne Erfolg.
                            Kann ich über das Terminal direkt was löschen ?

                            SKB 1 Reply Last reply Reply Quote 0
                            • SKB
                              SKB Developer Most Active @ingranu last edited by

                              @ingranu Ich denke, es ist besser, sogar in Zeile 26 im Skript, den Speicherort

                              // Hauptdatenpunkt unterhalb javascript
                              
                              var datenpunkt = "ShellyVerbrauch."; // Abschließender Punkt !!! WICHTIG !!!
                              

                              für die jeweilige Instanz anzupassen, da sich die Skripte sonst ggf. auch in die Quere kommen können.

                              Also in einem Skript:

                              var datenpunkt = "ShellyVerbrauch."; // Abschließender Punkt !!! WICHTIG !!!
                              

                              und

                              var datenpunkt = "ShellyVerbrauchIrgendwas."; // Abschließender Punkt !!! WICHTIG !!!
                              

                              im anderen Skript.

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

                                @SKB

                                Eine Frage zum Shelly Verbrauchs-Historie.
                                Bei mir werden nie Werte für gestern, letzte Woche, letztes Monat, letztes Jahr angezeigt.

                                IO-B50.JPG

                                Hast du eine Idee an was das liegen könnte?

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

                                  @SpacerX

                                  Ich habe zum Test seit gestern das Script von @SKB und dein Script parallel laufen.

                                  Jetzt ist mit aufgefallen, dass bei dem Script von SKB unter anderem der Wert "heute" 0 ist
                                  (kann aber nicht sein da ein Verbraucher an ist).

                                  Kann es sein, dass das Script nicht doppelt laufen darf - passiert dann irgend ein Murks?

                                  SKB 1 Reply Last reply Reply Quote 0
                                  • SKB
                                    SKB Developer Most Active @bitwicht last edited by

                                    @bitwicht was denkst du denn, wenn 2 Skripte auf einem Datenpunkt schreiben, was passiert?

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

                                      @SKB

                                      Ist es der selbe Datenpunkt ?

                                      Script SKB:
                                      javascript.0.ShellyVerbrauch.SHEM#244CAB4191C7#1.Emeter0.heute

                                      Script SpacerX
                                      v0_userdata.0.ShellyVerbrauch.SHEM#244CAB4191C7#1.Emeter0.heute

                                      Ich dachte die Datenpunkte sind unterschiedlich?
                                      Ich weiß nur nicht was das Script (intern) macht und versuche herauszufinden warum bei mir immer Werte fehlen

                                      SKB S 2 Replies Last reply Reply Quote 0
                                      • SKB
                                        SKB Developer Most Active @bitwicht last edited by

                                        @bitwicht Die Datenpunkte sind unterschiedlich, ja. Aber es scheint ja irgendwo Diskrepanzen zu geben.

                                        1 Reply Last reply Reply Quote 0
                                        • S
                                          SpacerX @bitwicht last edited by

                                          @bitwicht im Grunde genommen sind beide Skripte gleich, Ich habe nur den Speicherpfad der Datenpunkte nach 0:userdata.0 umgeleitet.

                                          Schau mal ob du die Skripte auch komplett kopiert hast. Es ist schon vorgekommen das unten eine Zeile fehlt und genau da steht der Aufruf zur Berechnung der Werte.

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

                                            @SpacerX @SKB

                                            Ich finde den Fehler einfach nicht warum es bei mir nicht geht.

                                            Hier die beiden Scripte die aktuell parallel laufen:

                                            Script SKB:

                                            /*
                                             * @copyright 2021 Stephan Kreyenborg <stephan@kreyenborg.koeln>
                                             *
                                             * @author 2021 Stephan Kreyenborg <stephan@kreyenborg.koeln>
                                             *
                                             * Dieses Skript dient zur freien Verwendung in ioBroker zur Verbrauchserfassung der Shelly Geräte.
                                             * Jegliche Verantwortung liegt beim Benutzer. Das Skript wurde unter Berücksichtigung der bestmöglichen Nutzung
                                             * und Performance entwickelt.
                                             * Der Entwickler versichert, das keine böswilligen Systemeingriffe im originalen Skript vorhanden sind.
                                             *
                                             * Sollte das Skript wider Erwarten nicht korrekt funktionieren, so hast Du jederzeit die Möglichkeit, Dich auf
                                             * https://www.kreyenborg.koeln
                                             * für Unterstützung zu melden. Jedes Skript besitzt seine eigene Kommentarseite, auf der,
                                             * nach zeitlicher Möglichkeit des Autors, Hilfe angeboten wird. Ein Anrecht hierauf besteht nicht!
                                             * 
                                             * Ansprüche gegenüber Dritten bestehen nicht. 
                                             * 
                                             * Skript Name:      Shelly-Verbrauch
                                             * Skript Version:   1.60
                                             * Erstell-Datum:    08. Oktober 2021 | Update: 20. Juli 2022
                                             * 
                                             */
                                            // Datenpunkte neu erstellen
                                            var ueberschreiben = false;
                                            // Hauptdatenpunkt unterhalb javascript
                                            var datenpunkt = "ShellyVerbrauch."; // Abschließender Punkt !!! WICHTIG !!!
                                            // Verbrauchs Objekte der einzelnen Shelly
                                            var objekt = ["gesamt", "dieses_jahr", "letztes_jahr", "letzter_monat", "dieser_monat", "letzte_woche",
                                                "diese_woche", "gestern", "heute", "alter_wert", "aktueller_wert"
                                            ];
                                            // Beschreibung der Objekte
                                            var beschreibung = ["Gesamter Vebrauch des Shelly", "Verbrauch aktuelles Jahr", "Verbrauch letztes Jahr",
                                                "Verbrauch letzten Monat", "Verbrauch aktueller Monat", "Verbrauch letzte Woche", "Verbrauch diese Woche",
                                                "Verbrauch gestern", "Verbrauch heute", "Messwert alt", "Messwert neu"
                                            ];
                                            // Datenpunkt der Shelly (Standard: shelly.0)
                                            var shelly_dp = "shelly.0";
                                            // Datenpunkte der Shelly (!!! Bitte nicht ändern !!!)
                                            var shellyDps = $('state[id=' + shelly_dp + '.*.*.Energy]');
                                            // Datenpunkte der Shelly 3EM DP
                                            var shelly3EMDps = $('state[id=' + shelly_dp + '.*.*.Total]');
                                            // Datenpunkte der Shelly 3EM DP - Total
                                            var shelly3EMTotalDps = $('state[id=' + shelly_dp + '.*.*.ConsumedPower]');
                                            // Datenpunkte der Shelly 3EM DP - Total
                                            var shelly3EMTotalReturned = $('state[id=' + shelly_dp + '.*.*.Total_Returned]');
                                            // Datenpunkte der Shelly Namen (!!! Bitte nicht ändern !!!)
                                            var shellyDpsName = $('state[id=' + shelly_dp + '.*.name]');
                                            // Shelly Verbrauch aktualisieren - nachts um 00:00 Uhr
                                            function shelly_vebrauch_tag() {
                                                // Nochmals das Tagesupdate durchlaufen, damit die restlichen Werte gelesen werden
                                                shelly_verbrauch_update();
                                                // Datumsvariable
                                                var heute = new Date();
                                                // Heute zu Gestern verschieben. Täglich um 00:00 Uhr
                                                verschiebe_verbrauch_objekt("heute", "gestern");
                                                log("Shelly Verbrauch: Werte für gestern und heute aktualisiert!");
                                                // aktuelle Woche in letzte Woche verschieben. Am Montag um 00:00 Uhr
                                                if (heute.getDay() === 1) {
                                                    verschiebe_verbrauch_objekt("diese_woche", "letzte_woche");
                                                    log("Shelly Verbrauch: Werte für diese und letzte Woche aktualisiert!");
                                                }
                                                // aktueller Monat in letzten Monat verschieben. Am 1. des Monats um 00:00 Uhr
                                                if (heute.getDate() === 1) {
                                                    verschiebe_verbrauch_objekt("dieser_monat", "letzter_monat");
                                                    log("Shelly Verbrauch: Werte für diesen und letzten Monat aktualisiert!");
                                                }
                                                // aktuelles Jahr in letztes Jahr verschieben. Am 1. des Monats am 1. Monat um 00:00 Uhr
                                                if (heute.getDate() === 1 && heute.getMonth() === 0) {
                                                    verschiebe_verbrauch_objekt("dieses_jahr", "letztes_jahr");
                                                    log("Shelly Verbrauch: Werte für dieses und letztes Jahr aktualisiert!");
                                                }
                                            }
                                            // Tagesverbrauch alle 15 Min von der Original Variable des Shelly in eigene Variable kopieren
                                            function shelly_verbrauch_update() {
                                                var anzahl_updates = 0;
                                                var anzahl_reboots = 0;
                                                var anzahl_gleich = 0;
                                                shellyDps.each(function (id, i) {
                                                    var shelly_verbrauch = getState(id).val;
                                                    // Einige Shelly haben keine Verbrauchswerte (noch nicht)
                                                    if (shelly_verbrauch != null) {
                                                        // Hole aktuellen Wert, um zu kontrollieren, ob ein Reboot stattgefunden hat
                                                        var aktueller_wert = getState(shelly_DP(id) + "aktueller_wert").val;
                                                        var alter_wert = 0;
                                                        // Prüfe alten und neuen Wert
                                                        if (shelly_verbrauch > aktueller_wert) {
                                                            // Verbrauchswert ist größer als alter Wert -> es wurde kein Reboot durchgeführt
                                                            setState(shelly_DP(id) + "alter_wert", aktueller_wert, true);
                                                            alter_wert = aktueller_wert;
                                                            anzahl_updates++;
                                                        }
                                                        if (aktueller_wert > shelly_verbrauch) {
                                                            // Verbrauchswert ist kleiner als alter Wert -> es wurde ein Reboot durchgeführt
                                                            setState(shelly_DP(id) + "alter_wert", 0, true);
                                                            alter_wert = 0;
                                                            anzahl_reboots++;
                                                        }
                                                        if (shelly_verbrauch == aktueller_wert) {
                                                            // Verbrauchswert ist gleich wie alter Wert -> kein Update notwendig
                                                            alter_wert = aktueller_wert;
                                                            anzahl_gleich++;
                                                        }
                                                        setState(shelly_DP(id) + "aktueller_wert", shelly_verbrauch, true);
                                                        // Alter und neuer Wert -> aktuelle Differenz
                                                        var verbrauch = parseFloat(shelly_verbrauch) - alter_wert;
                                                        // Tagesverbrauch aktualisieren
                                                        aktualisiere_vebrauch_objekt(shelly_DP(id), "heute", verbrauch);
                                                        // Wochenverbrauch aktualisieren
                                                        aktualisiere_vebrauch_objekt(shelly_DP(id), "diese_woche", verbrauch);
                                                        // Monatsverbrauch aktualisieren
                                                        aktualisiere_vebrauch_objekt(shelly_DP(id), "dieser_monat", verbrauch);
                                                        // Jahresverbrauch aktualisieren
                                                        aktualisiere_vebrauch_objekt(shelly_DP(id), "dieses_jahr", verbrauch);
                                                        // Gesamten Vebrauch aktualisieren
                                                        aktualisiere_vebrauch_objekt(shelly_DP(id), "gesamt", verbrauch);
                                                    }
                                                });
                                                shelly3EMDps.each(function (id, i) {
                                                    var shelly_verbrauch = getState(id).val;
                                                    // Einige Shelly haben keine Verbrauchswerte (noch nicht)
                                                    if (shelly_verbrauch != null) {
                                                        // Hole aktuellen Wert, um zu kontrollieren, ob ein Reboot stattgefunden hat
                                                        var aktueller_wert = getState(shelly_DP(id) + "aktueller_wert").val;
                                                        var alter_wert = 0;
                                                        // Prüfe alten und neuen Wert
                                                        if (shelly_verbrauch > aktueller_wert) {
                                                            // Verbrauchswert ist größer als alter Wert -> es wurde kein Reboot durchgeführt
                                                            setState(shelly_DP(id) + "alter_wert", aktueller_wert, true);
                                                            alter_wert = aktueller_wert;
                                                            anzahl_updates++;
                                                        }
                                                        if (aktueller_wert > shelly_verbrauch) {
                                                            // Verbrauchswert ist kleiner als alter Wert -> es wurde ein Reboot durchgeführt
                                                            setState(shelly_DP(id) + "alter_wert", 0, true);
                                                            alter_wert = 0;
                                                            anzahl_reboots++;
                                                        }
                                                        if (shelly_verbrauch == aktueller_wert) {
                                                            // Verbrauchswert ist gleich wie alter Wert -> kein Update notwendig
                                                            alter_wert = aktueller_wert;
                                                            anzahl_gleich++;
                                                        }
                                                        setState(shelly_DP(id) + "aktueller_wert", shelly_verbrauch, true);
                                                        // Alter und neuer Wert -> aktuelle Differenz
                                                        var verbrauch = parseFloat(shelly_verbrauch) - alter_wert;
                                                        // Tagesverbrauch aktualisieren
                                                        aktualisiere_vebrauch_objekt(shelly_DP(id), "heute", verbrauch);
                                                        // Wochenverbrauch aktualisieren
                                                        aktualisiere_vebrauch_objekt(shelly_DP(id), "diese_woche", verbrauch);
                                                        // Monatsverbrauch aktualisieren
                                                        aktualisiere_vebrauch_objekt(shelly_DP(id), "dieser_monat", verbrauch);
                                                        // Jahresverbrauch aktualisieren
                                                        aktualisiere_vebrauch_objekt(shelly_DP(id), "dieses_jahr", verbrauch);
                                                        // Gesamten Vebrauch aktualisieren
                                                        aktualisiere_vebrauch_objekt(shelly_DP(id), "gesamt", verbrauch);
                                                    }
                                                });
                                                shelly3EMTotalDps.each(function (id, i) {
                                                    var shelly_verbrauch = getState(id).val;
                                                    // Einige Shelly haben keine Verbrauchswerte (noch nicht)
                                                    if (shelly_verbrauch != null) {
                                                        // Hole aktuellen Wert, um zu kontrollieren, ob ein Reboot stattgefunden hat
                                                        var aktueller_wert = getState(shelly_DP(id) + "aktueller_wert").val;
                                                        var alter_wert = 0;
                                                        // Prüfe alten und neuen Wert
                                                        if (shelly_verbrauch > aktueller_wert) {
                                                            // Verbrauchswert ist größer als alter Wert -> es wurde kein Reboot durchgeführt
                                                            setState(shelly_DP(id) + "alter_wert", aktueller_wert, true);
                                                            alter_wert = aktueller_wert;
                                                            anzahl_updates++;
                                                        }
                                                        if (aktueller_wert > shelly_verbrauch) {
                                                            // Verbrauchswert ist kleiner als alter Wert -> es wurde ein Reboot durchgeführt
                                                            setState(shelly_DP(id) + "alter_wert", 0, true);
                                                            alter_wert = 0;
                                                            anzahl_reboots++;
                                                        }
                                                        if (shelly_verbrauch == aktueller_wert) {
                                                            // Verbrauchswert ist gleich wie alter Wert -> kein Update notwendig
                                                            alter_wert = aktueller_wert;
                                                            anzahl_gleich++;
                                                        }
                                                        setState(shelly_DP(id) + "aktueller_wert", shelly_verbrauch, true);
                                                        // Alter und neuer Wert -> aktuelle Differenz
                                                        var verbrauch = parseFloat(shelly_verbrauch) - alter_wert;
                                                        // Tagesverbrauch aktualisieren
                                                        aktualisiere_vebrauch_objekt(shelly_DP(id), "heute", verbrauch);
                                                        // Wochenverbrauch aktualisieren
                                                        aktualisiere_vebrauch_objekt(shelly_DP(id), "diese_woche", verbrauch);
                                                        // Monatsverbrauch aktualisieren
                                                        aktualisiere_vebrauch_objekt(shelly_DP(id), "dieser_monat", verbrauch);
                                                        // Jahresverbrauch aktualisieren
                                                        aktualisiere_vebrauch_objekt(shelly_DP(id), "dieses_jahr", verbrauch);
                                                        // Gesamten Vebrauch aktualisieren
                                                        aktualisiere_vebrauch_objekt(shelly_DP(id), "gesamt", verbrauch);
                                                    }
                                                });
                                                shelly3EMTotalReturned.each(function (id, i) {
                                                    var shelly_verbrauch = getState(id).val;
                                                    // Einige Shelly haben keine Verbrauchswerte (noch nicht)
                                                    if (shelly_verbrauch != null) {
                                                        // Hole aktuellen Wert, um zu kontrollieren, ob ein Reboot stattgefunden hat
                                                        var aktueller_wert = getState(shelly_DP(id, true) + "aktueller_wert").val;
                                                        var alter_wert = 0;
                                                        // Prüfe alten und neuen Wert
                                                        if (shelly_verbrauch > aktueller_wert) {
                                                            // Verbrauchswert ist größer als alter Wert -> es wurde kein Reboot durchgeführt
                                                            setState(shelly_DP(id, true) + "alter_wert", aktueller_wert, true);
                                                            alter_wert = aktueller_wert;
                                                            anzahl_updates++;
                                                        }
                                                        if (aktueller_wert > shelly_verbrauch) {
                                                            // Verbrauchswert ist kleiner als alter Wert -> es wurde ein Reboot durchgeführt
                                                            setState(shelly_DP(id, true) + "alter_wert", 0, true);
                                                            alter_wert = 0;
                                                            anzahl_reboots++;
                                                        }
                                                        if (shelly_verbrauch == aktueller_wert) {
                                                            // Verbrauchswert ist gleich wie alter Wert -> kein Update notwendig
                                                            alter_wert = aktueller_wert;
                                                            anzahl_gleich++;
                                                        }
                                                        setState(shelly_DP(id, true) + "aktueller_wert", shelly_verbrauch, true);
                                                        // Alter und neuer Wert -> aktuelle Differenz
                                                        var verbrauch = parseFloat(shelly_verbrauch) - alter_wert;
                                                        // Tagesverbrauch aktualisieren
                                                        aktualisiere_vebrauch_objekt(shelly_DP(id, true), "heute", verbrauch);
                                                        // Wochenverbrauch aktualisieren
                                                        aktualisiere_vebrauch_objekt(shelly_DP(id, true), "diese_woche", verbrauch);
                                                        // Monatsverbrauch aktualisieren
                                                        aktualisiere_vebrauch_objekt(shelly_DP(id, true), "dieser_monat", verbrauch);
                                                        // Jahresverbrauch aktualisieren
                                                        aktualisiere_vebrauch_objekt(shelly_DP(id, true), "dieses_jahr", verbrauch);
                                                        // Gesamten Vebrauch aktualisieren
                                                        aktualisiere_vebrauch_objekt(shelly_DP(id, true), "gesamt", verbrauch);
                                                    }
                                                });
                                                aktualisiere_namen();
                                                log("Shelly Verbrauch: Verbrauchswerte aktualisiert: " + anzahl_updates + " | Reboots korrigiert: " + anzahl_reboots + " | Unveränderte Werte: " + anzahl_gleich);
                                            }
                                            // aktualisiert das jeweilige Verbrauchs-Objekt und addiert den Verbrauch dazu
                                            function aktualisiere_vebrauch_objekt(dp, objekt, wert) {
                                                // Hole alten Verbrauch
                                                let alter_verbrauch = getState(dp + objekt).val;
                                                let verbrauch = 0;
                                                // Kein Wert vorhanden - nutze den übermittelten Wert
                                                if (alter_verbrauch < 1 || alter_verbrauch == null) {
                                                    verbrauch = parseFloat(wert)
                                                } else {
                                                    verbrauch = parseFloat(alter_verbrauch) + parseFloat(wert);
                                                }
                                                setState(dp + objekt, parseFloat(verbrauch.toFixed(2)), true);
                                            }
                                            // Verschiebt das jeweilige Verbrauchs-Objekt und nullt den Ursprung (Tag, Woche, Monat, Jahr)
                                            function verschiebe_verbrauch_objekt(von, nach) {
                                                $('state[id=*.' + datenpunkt + '*.*.' + von + ']').each(function (id, i) {
                                                    // Temporärer Gruppen-Datenpunkt
                                                    var tmp_dp = id.slice(0, -(von.length));
                                                    var verbrauch = getState(id).val;
                                                    if (verbrauch != null) {
                                                        setState(tmp_dp + nach, verbrauch, true);
                                                    }
                                                    // Setze "von" zurück
                                                    setState(id, 0, true);
                                                });
                                            }
                                            // Funktion um die aktuellen Namen des Shelly abzuholen
                                            function aktualisiere_namen() {
                                                if (typeof extendObject === "function") {
                                                    shellyDpsName.each(function (id, i) {
                                                        if (existsState(id)) {
                                                            setState(shelly_DP_Name(id), String(getState(id).val), true);
                                                            extendObject("javascript.0." + shelly_DP_Name_Main(id), {
                                                                common: {
                                                                    name: String(getState(id).val),
                                                                    desc: String(getState(id).val)
                                                                },
                                                                type: "channel"
                                                            });
                                                        }
                                                    });
                                                }
                                            }
                                            // Erstelle die benötigten Datenpunkte
                                            function datenpunkte_erstellen() {
                                                // Anzahl der gefundenen Shelly
                                                var anzahl = shellyDps.length;
                                                shellyDps.each(function (id, j) {
                                                    var initial_wert = 0.0;
                                                    for (var i = 0; i < objekt.length; i++) {
                                                        // Startwerte werden nur bei alter_wert und aktueller_wert eingetragen
                                                        if (i > 8) {
                                                            initial_wert = getState(id).val;
                                                        }
                                                        createState(shelly_DP(id) + objekt[i], initial_wert, ueberschreiben, {
                                                            name: beschreibung[i],
                                                            desc: beschreibung[i],
                                                            type: "number",
                                                            role: "value.power",
                                                            unit: "Wh"
                                                        });
                                                    }
                                                });
                                                // Anzahl der gefundenen Shelly 3EM
                                                var anzahl_3em = shelly3EMDps.length;
                                                shelly3EMDps.each(function (id, j) {
                                                    var initial_wert = 0.0;
                                                    for (var i = 0; i < objekt.length; i++) {
                                                        // Startwerte werden nur bei alter_wert und aktueller_wert eingetragen
                                                        if (i > 8) {
                                                            initial_wert = getState(id).val;
                                                        }
                                                        createState(shelly_DP(id) + objekt[i], initial_wert, ueberschreiben, {
                                                            name: beschreibung[i],
                                                            desc: beschreibung[i],
                                                            type: "number",
                                                            role: "value.power",
                                                            unit: "Wh"
                                                        });
                                                    }
                                                });
                                                // Anzahl der gefundenen Shelly 3EM - Total
                                                var anzahl_3em_total = shelly3EMTotalDps.length;
                                                shelly3EMTotalDps.each(function (id, j) {
                                                    var initial_wert = 0.0;
                                                    for (var i = 0; i < objekt.length; i++) {
                                                        // Startwerte werden nur bei alter_wert und aktueller_wert eingetragen
                                                        if (i > 8) {
                                                            initial_wert = getState(id).val;
                                                        }
                                                        createState(shelly_DP(id) + objekt[i], initial_wert, ueberschreiben, {
                                                            name: beschreibung[i],
                                                            desc: beschreibung[i],
                                                            type: "number",
                                                            role: "value.power",
                                                            unit: "Wh"
                                                        });
                                                    }
                                                });
                                                // Anzahl der gefundenen Shelly 3EM - Total
                                                var anzahl_3em_total_returned = shelly3EMTotalReturned.length;
                                                shelly3EMTotalReturned.each(function (id, j) {
                                                    var initial_wert = 0.0;
                                                    for (var i = 0; i < objekt.length; i++) {
                                                        // Startwerte werden nur bei alter_wert und aktueller_wert eingetragen
                                                        if (i > 8) {
                                                            initial_wert = getState(id).val;
                                                        }
                                                        createState(shelly_DP(id, true) + objekt[i], initial_wert, ueberschreiben, {
                                                            name: beschreibung[i],
                                                            desc: beschreibung[i],
                                                            type: "number",
                                                            role: "value.power",
                                                            unit: "Wh"
                                                        });
                                                    }
                                                });
                                                // Alle Datenpunkte erstellt. Frage ersten Verbrauch ab!
                                                log("Shelly Verbrauch: Datenpunkte erstellt! Erster Verbrauch steht nach 30 Sekunden zur Verfügung! Anzahl gefundener Shelly Datenpunkte: " + (anzahl_3em + anzahl + anzahl_3em_total + anzahl_3em_total_returned));
                                                setTimeout(shelly_verbrauch_update, 30000);
                                                // Datenpunkte für die Namen der Shelly erstellen
                                                shellyDpsName.each(function (id, j) {
                                                    createState(shelly_DP_Name(id), "", ueberschreiben, {
                                                        name: "Name des Shelly",
                                                        desc: "Name des Shelly",
                                                        type: "string",
                                                        role: "value",
                                                        unit: ""
                                                    });
                                                });
                                            }
                                            /**
                                             * Wenn 3EM DP, dann anderen Wert zurückgeben
                                             * @param {any} dp
                                             * @param {boolean} extended
                                             */
                                            function shelly_DP(dp, extended = false) {
                                                dp = dp.split(".");
                                                dp = datenpunkt + dp[2] + "." + dp[3];
                                                if (extended) {
                                                    dp = dp + "_Returned.";
                                                } else {
                                                    dp = dp + ".";
                                                }
                                                return dp;
                                            }
                                            function shelly_DP_Name(dp) {
                                                dp = dp.split(".");
                                                dp = datenpunkt + dp[2] + "." + dp[3];
                                                return dp;
                                            }
                                            function shelly_DP_Name_Main(dp) {
                                                dp = dp.split(".");
                                                dp = datenpunkt + dp[2];
                                                return dp;
                                            }
                                            function shelly_verbrauch_erster_start() {
                                                log("Shelly Verbrauch: Erster Start des Skriptes! Datenpunkte werden erstellt!");
                                                // Datenpunkte werden erstellt
                                                datenpunkte_erstellen();
                                            }
                                            // Erster Start und Initialisierung
                                            shelly_verbrauch_erster_start();
                                            // Alle 15 Minuten das Skript für den Tagesverbrauch ausführen
                                            schedule('*/15 * * * *', shelly_verbrauch_update);
                                            // Nachts um 24 Uhr werden die Werte in andere Variablen gespeichert, um den Verlauf zu erstellen
                                            schedule('0 0 * * *', shelly_vebrauch_tag);
                                            

                                            Script SpacerX

                                            /*
                                             * @copyright 2021 Stephan Kreyenborg <stephan@kreyenborg.koeln>
                                             *
                                             * @author 2021 Stephan Kreyenborg <stephan@kreyenborg.koeln>
                                             *
                                             * Dieses Skript dient zur freien Verwendung in ioBroker zur Verbrauchserfassung der Shelly Geräte.
                                             * Jegliche Verantwortung liegt beim Benutzer. Das Skript wurde unter Berücksichtigung der bestmöglichen Nutzung
                                             * und Performance entwickelt.
                                             * Der Entwickler versichert, das keine böswilligen Systemeingriffe im originalen Skript vorhanden sind.
                                             *
                                             * Sollte das Skript wider Erwarten nicht korrekt funktionieren, so hast Du jederzeit die Möglichkeit, Dich auf
                                             * https://www.kreyenborg.koeln
                                             * für Unterstützung zu melden. Jedes Skript besitzt seine eigene Kommentarseite, auf der,
                                             * nach zeitlicher Möglichkeit des Autors, Hilfe angeboten wird. Ein Anrecht hierauf besteht nicht!
                                             * 
                                             * Ansprüche gegenüber Dritten bestehen nicht. 
                                             * 
                                             * Skript Name:      Shelly-Verbrauch
                                             * Skript Version:   1.60
                                             * Erstell-Datum:    08. Oktober 2021 | Update: 20. Juli 2022 | Override Functions by SpacerX 26.09.2022 (Zeile 402)
                                             * 
                                             */
                                            // Datenpunkte neu erstellen
                                            var ueberschreiben = false;
                                            // Hauptdatenpunkt unterhalb javascript
                                            var datenpunkt = "ShellyVerbrauch."; // Abschließender Punkt !!! WICHTIG !!!
                                            // Verbrauchs Objekte der einzelnen Shelly
                                            var objekt = ["gesamt", "dieses_jahr", "letztes_jahr", "letzter_monat", "dieser_monat", "letzte_woche",
                                                "diese_woche", "gestern", "heute", "alter_wert", "aktueller_wert"
                                            ];
                                            // Beschreibung der Objekte
                                            var beschreibung = ["Gesamter Vebrauch des Shelly", "Verbrauch aktuelles Jahr", "Verbrauch letztes Jahr",
                                                "Verbrauch letzten Monat", "Verbrauch aktueller Monat", "Verbrauch letzte Woche", "Verbrauch diese Woche",
                                                "Verbrauch gestern", "Verbrauch heute", "Messwert alt", "Messwert neu"
                                            ];
                                            // Datenpunkt der Shelly (Standard: shelly.0)
                                            var shelly_dp = "shelly.0";
                                            // Datenpunkte der Shelly (!!! Bitte nicht ändern !!!)
                                            var shellyDps = $('state[id=' + shelly_dp + '.*.*.Energy]');
                                            // Datenpunkte der Shelly 3EM DP
                                            var shelly3EMDps = $('state[id=' + shelly_dp + '.*.*.Total]');
                                            // Datenpunkte der Shelly 3EM DP - Total
                                            var shelly3EMTotalDps = $('state[id=' + shelly_dp + '.*.*.ConsumedPower]');
                                            // Datenpunkte der Shelly 3EM DP - Total
                                            var shelly3EMTotalReturned = $('state[id=' + shelly_dp + '.*.*.Total_Returned]');
                                            // Datenpunkte der Shelly Namen (!!! Bitte nicht ändern !!!)
                                            var shellyDpsName = $('state[id=' + shelly_dp + '.*.name]');
                                            // Shelly Verbrauch aktualisieren - nachts um 00:00 Uhr
                                            function shelly_vebrauch_tag() {
                                                // Nochmals das Tagesupdate durchlaufen, damit die restlichen Werte gelesen werden
                                                shelly_verbrauch_update();
                                                // Datumsvariable
                                                var heute = new Date();
                                                // Heute zu Gestern verschieben. Täglich um 00:00 Uhr
                                                verschiebe_verbrauch_objekt("heute", "gestern");
                                                log("Shelly Verbrauch: Werte für gestern und heute aktualisiert!");
                                                // aktuelle Woche in letzte Woche verschieben. Am Montag um 00:00 Uhr
                                                if (heute.getDay() === 1) {
                                                    verschiebe_verbrauch_objekt("diese_woche", "letzte_woche");
                                                    log("Shelly Verbrauch: Werte für diese und letzte Woche aktualisiert!");
                                                }
                                                // aktueller Monat in letzten Monat verschieben. Am 1. des Monats um 00:00 Uhr
                                                if (heute.getDate() === 1) {
                                                    verschiebe_verbrauch_objekt("dieser_monat", "letzter_monat");
                                                    log("Shelly Verbrauch: Werte für diesen und letzten Monat aktualisiert!");
                                                }
                                                // aktuelles Jahr in letztes Jahr verschieben. Am 1. des Monats am 1. Monat um 00:00 Uhr
                                                if (heute.getDate() === 1 && heute.getMonth() === 0) {
                                                    verschiebe_verbrauch_objekt("dieses_jahr", "letztes_jahr");
                                                    log("Shelly Verbrauch: Werte für dieses und letztes Jahr aktualisiert!");
                                                }
                                            }
                                            // Tagesverbrauch alle 15 Min von der Original Variable des Shelly in eigene Variable kopieren
                                            function shelly_verbrauch_update() {
                                                var anzahl_updates = 0;
                                                var anzahl_reboots = 0;
                                                var anzahl_gleich = 0;
                                                shellyDps.each(function (id, i) {
                                                    var shelly_verbrauch = getState(id).val;
                                                    // Einige Shelly haben keine Verbrauchswerte (noch nicht)
                                                    if (shelly_verbrauch != null) {
                                                        // Hole aktuellen Wert, um zu kontrollieren, ob ein Reboot stattgefunden hat
                                                        var aktueller_wert = getState(shelly_DP(id) + "aktueller_wert").val;
                                                        var alter_wert = 0;
                                                        // Prüfe alten und neuen Wert
                                                        if (shelly_verbrauch > aktueller_wert) {
                                                            // Verbrauchswert ist größer als alter Wert -> es wurde kein Reboot durchgeführt
                                                            setState(shelly_DP(id) + "alter_wert", aktueller_wert, true);
                                                            alter_wert = aktueller_wert;
                                                            anzahl_updates++;
                                                        }
                                                        if (aktueller_wert > shelly_verbrauch) {
                                                            // Verbrauchswert ist kleiner als alter Wert -> es wurde ein Reboot durchgeführt
                                                            setState(shelly_DP(id) + "alter_wert", 0, true);
                                                            alter_wert = 0;
                                                            anzahl_reboots++;
                                                        }
                                                        if (shelly_verbrauch == aktueller_wert) {
                                                            // Verbrauchswert ist gleich wie alter Wert -> kein Update notwendig
                                                            alter_wert = aktueller_wert;
                                                            anzahl_gleich++;
                                                        }
                                                        setState(shelly_DP(id) + "aktueller_wert", shelly_verbrauch, true);
                                                        // Alter und neuer Wert -> aktuelle Differenz
                                                        var verbrauch = parseFloat(shelly_verbrauch) - alter_wert;
                                                        // Tagesverbrauch aktualisieren
                                                        aktualisiere_vebrauch_objekt(shelly_DP(id), "heute", verbrauch);
                                                        // Wochenverbrauch aktualisieren
                                                        aktualisiere_vebrauch_objekt(shelly_DP(id), "diese_woche", verbrauch);
                                                        // Monatsverbrauch aktualisieren
                                                        aktualisiere_vebrauch_objekt(shelly_DP(id), "dieser_monat", verbrauch);
                                                        // Jahresverbrauch aktualisieren
                                                        aktualisiere_vebrauch_objekt(shelly_DP(id), "dieses_jahr", verbrauch);
                                                        // Gesamten Vebrauch aktualisieren
                                                        aktualisiere_vebrauch_objekt(shelly_DP(id), "gesamt", verbrauch);
                                                    }
                                                });
                                                shelly3EMDps.each(function (id, i) {
                                                    var shelly_verbrauch = getState(id).val;
                                                    // Einige Shelly haben keine Verbrauchswerte (noch nicht)
                                                    if (shelly_verbrauch != null) {
                                                        // Hole aktuellen Wert, um zu kontrollieren, ob ein Reboot stattgefunden hat
                                                        var aktueller_wert = getState(shelly_DP(id) + "aktueller_wert").val;
                                                        var alter_wert = 0;
                                                        // Prüfe alten und neuen Wert
                                                        if (shelly_verbrauch > aktueller_wert) {
                                                            // Verbrauchswert ist größer als alter Wert -> es wurde kein Reboot durchgeführt
                                                            setState(shelly_DP(id) + "alter_wert", aktueller_wert, true);
                                                            alter_wert = aktueller_wert;
                                                            anzahl_updates++;
                                                        }
                                                        if (aktueller_wert > shelly_verbrauch) {
                                                            // Verbrauchswert ist kleiner als alter Wert -> es wurde ein Reboot durchgeführt
                                                            setState(shelly_DP(id) + "alter_wert", 0, true);
                                                            alter_wert = 0;
                                                            anzahl_reboots++;
                                                        }
                                                        if (shelly_verbrauch == aktueller_wert) {
                                                            // Verbrauchswert ist gleich wie alter Wert -> kein Update notwendig
                                                            alter_wert = aktueller_wert;
                                                            anzahl_gleich++;
                                                        }
                                                        setState(shelly_DP(id) + "aktueller_wert", shelly_verbrauch, true);
                                                        // Alter und neuer Wert -> aktuelle Differenz
                                                        var verbrauch = parseFloat(shelly_verbrauch) - alter_wert;
                                                        // Tagesverbrauch aktualisieren
                                                        aktualisiere_vebrauch_objekt(shelly_DP(id), "heute", verbrauch);
                                                        // Wochenverbrauch aktualisieren
                                                        aktualisiere_vebrauch_objekt(shelly_DP(id), "diese_woche", verbrauch);
                                                        // Monatsverbrauch aktualisieren
                                                        aktualisiere_vebrauch_objekt(shelly_DP(id), "dieser_monat", verbrauch);
                                                        // Jahresverbrauch aktualisieren
                                                        aktualisiere_vebrauch_objekt(shelly_DP(id), "dieses_jahr", verbrauch);
                                                        // Gesamten Vebrauch aktualisieren
                                                        aktualisiere_vebrauch_objekt(shelly_DP(id), "gesamt", verbrauch);
                                                    }
                                                });
                                                shelly3EMTotalDps.each(function (id, i) {
                                                    var shelly_verbrauch = getState(id).val;
                                                    // Einige Shelly haben keine Verbrauchswerte (noch nicht)
                                                    if (shelly_verbrauch != null) {
                                                        // Hole aktuellen Wert, um zu kontrollieren, ob ein Reboot stattgefunden hat
                                                        var aktueller_wert = getState(shelly_DP(id) + "aktueller_wert").val;
                                                        var alter_wert = 0;
                                                        // Prüfe alten und neuen Wert
                                                        if (shelly_verbrauch > aktueller_wert) {
                                                            // Verbrauchswert ist größer als alter Wert -> es wurde kein Reboot durchgeführt
                                                            setState(shelly_DP(id) + "alter_wert", aktueller_wert, true);
                                                            alter_wert = aktueller_wert;
                                                            anzahl_updates++;
                                                        }
                                                        if (aktueller_wert > shelly_verbrauch) {
                                                            // Verbrauchswert ist kleiner als alter Wert -> es wurde ein Reboot durchgeführt
                                                            setState(shelly_DP(id) + "alter_wert", 0, true);
                                                            alter_wert = 0;
                                                            anzahl_reboots++;
                                                        }
                                                        if (shelly_verbrauch == aktueller_wert) {
                                                            // Verbrauchswert ist gleich wie alter Wert -> kein Update notwendig
                                                            alter_wert = aktueller_wert;
                                                            anzahl_gleich++;
                                                        }
                                                        setState(shelly_DP(id) + "aktueller_wert", shelly_verbrauch, true);
                                                        // Alter und neuer Wert -> aktuelle Differenz
                                                        var verbrauch = parseFloat(shelly_verbrauch) - alter_wert;
                                                        // Tagesverbrauch aktualisieren
                                                        aktualisiere_vebrauch_objekt(shelly_DP(id), "heute", verbrauch);
                                                        // Wochenverbrauch aktualisieren
                                                        aktualisiere_vebrauch_objekt(shelly_DP(id), "diese_woche", verbrauch);
                                                        // Monatsverbrauch aktualisieren
                                                        aktualisiere_vebrauch_objekt(shelly_DP(id), "dieser_monat", verbrauch);
                                                        // Jahresverbrauch aktualisieren
                                                        aktualisiere_vebrauch_objekt(shelly_DP(id), "dieses_jahr", verbrauch);
                                                        // Gesamten Vebrauch aktualisieren
                                                        aktualisiere_vebrauch_objekt(shelly_DP(id), "gesamt", verbrauch);
                                                    }
                                                });
                                                shelly3EMTotalReturned.each(function (id, i) {
                                                    var shelly_verbrauch = getState(id).val;
                                                    // Einige Shelly haben keine Verbrauchswerte (noch nicht)
                                                    if (shelly_verbrauch != null) {
                                                        // Hole aktuellen Wert, um zu kontrollieren, ob ein Reboot stattgefunden hat
                                                        var aktueller_wert = getState(shelly_DP(id, true) + "aktueller_wert").val;
                                                        var alter_wert = 0;
                                                        // Prüfe alten und neuen Wert
                                                        if (shelly_verbrauch > aktueller_wert) {
                                                            // Verbrauchswert ist größer als alter Wert -> es wurde kein Reboot durchgeführt
                                                            setState(shelly_DP(id, true) + "alter_wert", aktueller_wert, true);
                                                            alter_wert = aktueller_wert;
                                                            anzahl_updates++;
                                                        }
                                                        if (aktueller_wert > shelly_verbrauch) {
                                                            // Verbrauchswert ist kleiner als alter Wert -> es wurde ein Reboot durchgeführt
                                                            setState(shelly_DP(id, true) + "alter_wert", 0, true);
                                                            alter_wert = 0;
                                                            anzahl_reboots++;
                                                        }
                                                        if (shelly_verbrauch == aktueller_wert) {
                                                            // Verbrauchswert ist gleich wie alter Wert -> kein Update notwendig
                                                            alter_wert = aktueller_wert;
                                                            anzahl_gleich++;
                                                        }
                                                        setState(shelly_DP(id, true) + "aktueller_wert", shelly_verbrauch, true);
                                                        // Alter und neuer Wert -> aktuelle Differenz
                                                        var verbrauch = parseFloat(shelly_verbrauch) - alter_wert;
                                                        // Tagesverbrauch aktualisieren
                                                        aktualisiere_vebrauch_objekt(shelly_DP(id, true), "heute", verbrauch);
                                                        // Wochenverbrauch aktualisieren
                                                        aktualisiere_vebrauch_objekt(shelly_DP(id, true), "diese_woche", verbrauch);
                                                        // Monatsverbrauch aktualisieren
                                                        aktualisiere_vebrauch_objekt(shelly_DP(id, true), "dieser_monat", verbrauch);
                                                        // Jahresverbrauch aktualisieren
                                                        aktualisiere_vebrauch_objekt(shelly_DP(id, true), "dieses_jahr", verbrauch);
                                                        // Gesamten Vebrauch aktualisieren
                                                        aktualisiere_vebrauch_objekt(shelly_DP(id, true), "gesamt", verbrauch);
                                                    }
                                                });
                                                aktualisiere_namen();
                                                log("Shelly Verbrauch: Verbrauchswerte aktualisiert: " + anzahl_updates + " | Reboots korrigiert: " + anzahl_reboots + " | Unveränderte Werte: " + anzahl_gleich);
                                            }
                                            // aktualisiert das jeweilige Verbrauchs-Objekt und addiert den Verbrauch dazu
                                            function aktualisiere_vebrauch_objekt(dp, objekt, wert) {
                                                // Hole alten Verbrauch
                                                let alter_verbrauch = getState(dp + objekt).val;
                                                let verbrauch = 0;
                                                // Kein Wert vorhanden - nutze den übermittelten Wert
                                                if (alter_verbrauch < 1 || alter_verbrauch == null) {
                                                    verbrauch = parseFloat(wert)
                                                } else {
                                                    verbrauch = parseFloat(alter_verbrauch) + parseFloat(wert);
                                                }
                                                setState(dp + objekt, parseFloat(verbrauch.toFixed(2)), true);
                                            }
                                            // Verschiebt das jeweilige Verbrauchs-Objekt und nullt den Ursprung (Tag, Woche, Monat, Jahr)
                                            function verschiebe_verbrauch_objekt(von, nach) {
                                                $('state[id=*.' + datenpunkt + '*.*.' + von + ']').each(function (id, i) {
                                                    // Temporärer Gruppen-Datenpunkt
                                                    var tmp_dp = id.slice(0, -(von.length));
                                                    var verbrauch = getState(id).val;
                                                    if (verbrauch != null) {
                                                        setState(tmp_dp + nach, verbrauch, true);
                                                    }
                                                    // Setze "von" zurück
                                                    setState(id, 0, true);
                                                });
                                            }
                                            // Funktion um die aktuellen Namen des Shelly abzuholen
                                            function aktualisiere_namen() {
                                                if (typeof extendObject === "function") {
                                                    shellyDpsName.each(function (id, i) {
                                                        if (existsState(id)) {
                                                            setState(shelly_DP_Name(id), String(getState(id).val), true);
                                                            extendObject("javascript.0." + shelly_DP_Name_Main(id), {
                                                                common: {
                                                                    name: String(getState(id).val),
                                                                    desc: String(getState(id).val)
                                                                },
                                                                type: "channel"
                                                            });
                                                        }
                                                    });
                                                }
                                            }
                                            // Erstelle die benötigten Datenpunkte
                                            function datenpunkte_erstellen() {
                                                // Anzahl der gefundenen Shelly
                                                var anzahl = shellyDps.length;
                                                shellyDps.each(function (id, j) {
                                                    var initial_wert = 0.0;
                                                    for (var i = 0; i < objekt.length; i++) {
                                                        // Startwerte werden nur bei alter_wert und aktueller_wert eingetragen
                                                        if (i > 8) {
                                                            initial_wert = getState(id).val;
                                                        }
                                                        createState(shelly_DP(id) + objekt[i], initial_wert, ueberschreiben, {
                                                            name: beschreibung[i],
                                                            desc: beschreibung[i],
                                                            type: "number",
                                                            role: "value.power",
                                                            unit: "Wh"
                                                        });
                                                    }
                                                });
                                                // Anzahl der gefundenen Shelly 3EM
                                                var anzahl_3em = shelly3EMDps.length;
                                                shelly3EMDps.each(function (id, j) {
                                                    var initial_wert = 0.0;
                                                    for (var i = 0; i < objekt.length; i++) {
                                                        // Startwerte werden nur bei alter_wert und aktueller_wert eingetragen
                                                        if (i > 8) {
                                                            initial_wert = getState(id).val;
                                                        }
                                                        createState(shelly_DP(id) + objekt[i], initial_wert, ueberschreiben, {
                                                            name: beschreibung[i],
                                                            desc: beschreibung[i],
                                                            type: "number",
                                                            role: "value.power",
                                                            unit: "Wh"
                                                        });
                                                    }
                                                });
                                                // Anzahl der gefundenen Shelly 3EM - Total
                                                var anzahl_3em_total = shelly3EMTotalDps.length;
                                                shelly3EMTotalDps.each(function (id, j) {
                                                    var initial_wert = 0.0;
                                                    for (var i = 0; i < objekt.length; i++) {
                                                        // Startwerte werden nur bei alter_wert und aktueller_wert eingetragen
                                                        if (i > 8) {
                                                            initial_wert = getState(id).val;
                                                        }
                                                        createState(shelly_DP(id) + objekt[i], initial_wert, ueberschreiben, {
                                                            name: beschreibung[i],
                                                            desc: beschreibung[i],
                                                            type: "number",
                                                            role: "value.power",
                                                            unit: "Wh"
                                                        });
                                                    }
                                                });
                                                // Anzahl der gefundenen Shelly 3EM - Total
                                                var anzahl_3em_total_returned = shelly3EMTotalReturned.length;
                                                shelly3EMTotalReturned.each(function (id, j) {
                                                    var initial_wert = 0.0;
                                                    for (var i = 0; i < objekt.length; i++) {
                                                        // Startwerte werden nur bei alter_wert und aktueller_wert eingetragen
                                                        if (i > 8) {
                                                            initial_wert = getState(id).val;
                                                        }
                                                        createState(shelly_DP(id, true) + objekt[i], initial_wert, ueberschreiben, {
                                                            name: beschreibung[i],
                                                            desc: beschreibung[i],
                                                            type: "number",
                                                            role: "value.power",
                                                            unit: "Wh"
                                                        });
                                                    }
                                                });
                                                // Alle Datenpunkte erstellt. Frage ersten Verbrauch ab!
                                                log("Shelly Verbrauch: Datenpunkte erstellt! Erster Verbrauch steht nach 30 Sekunden zur Verfügung! Anzahl gefundener Shelly Datenpunkte: " + (anzahl_3em + anzahl + anzahl_3em_total + anzahl_3em_total_returned));
                                                setTimeout(shelly_verbrauch_update, 30000);
                                                // Datenpunkte für die Namen der Shelly erstellen
                                                shellyDpsName.each(function (id, j) {
                                                    createState(shelly_DP_Name(id), "", ueberschreiben, {
                                                        name: "Name des Shelly",
                                                        desc: "Name des Shelly",
                                                        type: "string",
                                                        role: "value",
                                                        unit: ""
                                                    });
                                                });
                                            }
                                            /**
                                             * Wenn 3EM DP, dann anderen Wert zurückgeben
                                             * @param {any} dp
                                             * @param {boolean} extended
                                             */
                                            function shelly_DP(dp, extended = false) {
                                                dp = dp.split(".");
                                                dp = datenpunkt + dp[2] + "." + dp[3];
                                                if (extended) {
                                                    dp = dp + "_Returned.";
                                                } else {
                                                    dp = dp + ".";
                                                }
                                                return dp;
                                            }
                                            function shelly_DP_Name(dp) {
                                                dp = dp.split(".");
                                                dp = datenpunkt + dp[2] + "." + dp[3];
                                                return dp;
                                            }
                                            function shelly_DP_Name_Main(dp) {
                                                dp = dp.split(".");
                                                dp = datenpunkt + dp[2];
                                                return dp;
                                            }
                                            function shelly_verbrauch_erster_start() {
                                                log("Shelly Verbrauch: Erster Start des Skriptes! Datenpunkte werden erstellt!");
                                                // Datenpunkte werden erstellt
                                                datenpunkte_erstellen();
                                            }
                                            /*
                                             * Override Functions
                                             * @autor 2022 SpacerX <spacerx@rbe-base.de>
                                             * Überschreibt Funktionen um Datenpunkte unter 0_userdata.0 zu erstellen
                                             *
                                             *** START SpacerX ***/
                                            // Userdatenpunkt
                                            var userdir = "0_userdata.0."; // Abschließender Punkt !!! WICHTIG !!!
                                            /**
                                             * Letzten des Monats berechnen.
                                             * @param {Date} oHeute
                                             */
                                            function letzterDesMonats(oHeute) {
                                                return new Date(oHeute.getFullYear(), oHeute.getMonth() + 1, 0).getDate();
                                            }
                                            //Override at row 48
                                            // Shelly Verbrauch aktualisieren - nachts um 23:59 Uhr
                                            function shelly_vebrauch_tag() {
                                                // Nochmals das Tagesupdate durchlaufen, damit die restlichen Werte gelesen werden
                                                shelly_verbrauch_update();
                                                // Datumsvariable
                                                var heute = new Date();
                                                // Heute zu Gestern verschieben. Täglich um 23:59 Uhr
                                                verschiebe_verbrauch_objekt("heute", "gestern");
                                                log("Shelly Verbrauch: Werte für gestern und heute aktualisiert!");
                                                // aktuelle Woche in letzte Woche verschieben. Am Sonntag um 23:59 Uhr
                                                if (heute.getDay() === 0) {   /*line changed by spacerx (Sonntag=0, Montag=1)*/
                                                    verschiebe_verbrauch_objekt("diese_woche", "letzte_woche");
                                                    log("Shelly Verbrauch: Werte für diese und letzte Woche aktualisiert!");
                                                }
                                                // aktueller Monat in letzten Monat verschieben. Am letzten des Monats um 23:59 Uhr
                                                if (heute.getDate() === letzterDesMonats(heute)) {   /*line changed by spacerx*/
                                                    verschiebe_verbrauch_objekt("dieser_monat", "letzter_monat");
                                                    log("Shelly Verbrauch: Werte für diesen und letzten Monat aktualisiert!");
                                                }
                                                // aktuelles Jahr in letztes Jahr verschieben. Am letzten Tag des Jahres um 23:59 Uhr
                                                if (heute.getDate() === letzterDesMonats(heute) && heute.getMonth() === 11) { /*line changed by spacerx (Jan=0, Dez=11)*/
                                                    verschiebe_verbrauch_objekt("dieses_jahr", "letztes_jahr");
                                                    log("Shelly Verbrauch: Werte für dieses und letztes Jahr aktualisiert!");
                                                }
                                            }
                                            //Override at row 254
                                            //Verschiebt das jeweilige Verbrauchs-Objekt und nullt den Ursprung (Tag, Woche, Monat, Jahr)
                                            function verschiebe_verbrauch_objekt(von, nach) {
                                                $('state[id=' + userdir + datenpunkt + '*.*.' + von + ']').each(function (id, i) {   /*line changed by spacerx*/
                                                    // Temporärer Gruppen-Datenpunkt
                                                    var tmp_dp = id.slice(0, -(von.length));
                                                    var verbrauch = getState(id).val;
                                                    if (verbrauch != null) {
                                                        setState(tmp_dp + nach, verbrauch, true);
                                                    }
                                                    // Setze "von" zurück
                                                    setState(id, 0, true);
                                                });
                                            }
                                            //Override at row 267
                                            // Funktion um die aktuellen Namen des Shelly abzuholen
                                            function aktualisiere_namen() {
                                                if (typeof extendObject === "function") {
                                                    shellyDpsName.each(function (id, i) {
                                                        if (existsState(id)) {
                                                            setState(shelly_DP_Name(id), String(getState(id).val), true);
                                                            extendObject(shelly_DP_Name_Main(id), {   /*line changed by spacerx*/
                                                                common: {
                                                                    name: String(getState(id).val),
                                                                    desc: String(getState(id).val)
                                                                },
                                                                type: "channel"
                                                            });
                                                        }
                                                    });
                                                }
                                            }
                                            //Override at row 377
                                            function shelly_DP(dp, extended = false) {
                                                dp = dp.split(".");
                                                dp = userdir + datenpunkt + dp[2] + "." + dp[3];   /*line changed by spacerx*/
                                                if (extended) {
                                                    dp = dp + "_Returned.";
                                                } else {
                                                    dp = dp + ".";
                                                }
                                                return dp;
                                            }
                                            //Override at row 387
                                            function shelly_DP_Name(dp) {
                                                dp = dp.split(".");
                                                dp = userdir + datenpunkt + dp[2] + "." + dp[3];   /*line changed by spacerx*/
                                                return dp;
                                            }
                                            //Override at row 392
                                            function shelly_DP_Name_Main(dp) {
                                                dp = dp.split(".");
                                                dp = userdir + datenpunkt + dp[2];   /*line changed by spacerx*/
                                                return dp;
                                            }
                                            /*** END SpacerX ***/
                                            // Erster Start und Initialisierung
                                            shelly_verbrauch_erster_start();
                                            // Alle 15 Minuten das Skript für den Tagesverbrauch ausführen
                                            schedule('*/15 * * * *', shelly_verbrauch_update);
                                            /*** START Edit SpacerX ***/
                                            // Nachts um 24 Uhr werden die Werte in andere Variablen gespeichert, um den Verlauf zu erstellen
                                            //schedule('0 0 * * *', shelly_vebrauch_tag);
                                            // Nachts um 23:59 Uhr werden die Werte in andere Variablen gespeichert, um den Verlauf zu erstellen
                                            schedule('59 23 * * *', shelly_vebrauch_tag);
                                            /*** END Edit SpacerX ***/
                                            

                                            Ist es normal das bei jedem Shelly eine gleichnamiger Ordner mit _Returned angelegt wird?
                                            Beispiel: Emeter0 und Emeter0_Returned

                                            io-b55.JPG

                                            Im Protokoll gibt es keine Fehler, nur eine Info zB:

                                            script.js.Strom_Shelly_Verbrauchs-Historie: Shelly Verbrauch: Verbrauchswerte aktualisiert: 23 | Reboots korrigiert: 0 | Unveränderte Werte: 54
                                            

                                            Habt Ihr eine Idee warum das bei mir nicht geht?

                                            S 1 Reply Last reply Reply Quote 0
                                            • First post
                                              Last post

                                            Support us

                                            ioBroker
                                            Community Adapters
                                            Donate

                                            871
                                            Online

                                            31.9k
                                            Users

                                            80.1k
                                            Topics

                                            1.3m
                                            Posts

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