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.
    • S
      SpacerX @bitwicht last edited by SpacerX

      @bitwicht das ist auch richtig so. Die Plug S messen keine Einspeisungen. Also nicht Rückwärts. Der Em kann in beide Richtungen einen Wert ermitteln. Plug S nicht.
      Es werden nur Datenpunkte angelegt die auch von den Shelly‘s zur Verfügung gestellt werden.
      z.B. wird auch ein Pfad für den shelly 1 angelegt aber keine Datenpunkte für Messungen weil dieser das nicht kann.

      O 1 Reply Last reply Reply Quote 0
      • O
        opöl @SpacerX last edited by

        @skb und @spacerx ,

        auch ich nutze auch Euer Shelly Script. Vielen Dank für Eure Arbeit.

        Da ich aber auch Nous Steckdosen habe, habe ich versucht, Euer Script entsprechend zu adaptieren.
        Leider reichen meine Java Kenntnisse noch nicht ganz aus. Die Zählerstände werden korrekt angezeigt, das Aktualisieren der Tages- Wochen und Monatswerte durchblicke ich aber noch nicht.

        Daher zwei Fragen an Euch:

        Ist es OK, Euer Script für Nous Steckdosen anzupassen und mit Hinweis auf Eure ursprüngliche Leistung hier zu veröffentlichen?

        Kann ich von Euch Unterstützung bekommen um die Aktualisierung in den Griff zu bekommen?

        Ich stehe natürlich als Tester und für die Lieferung von benötigtem Input zur Verfügung.

        Gruß

        SKB 1 Reply Last reply Reply Quote 0
        • SKB
          SKB Developer Most Active @opöl last edited by

          @opöl Für dein Skript erstellst Du bitte einen neuen Beitrag, da es nichts mehr mit den Originalen Shelly Skripten zu tun hat.

          Da die Skripte so gesehen unter MIT laufen, kannst du es vollständig oder in Teilen kopieren und verändern.

          1 Reply Last reply Reply Quote 0
          • J
            JohnnyBahama last edited by JohnnyBahama

            Musste meine Maschine neu aufsetzen. Habe das Skript vorher einwand frei nutzen können. Jetzt geht es nicht und ich sehe nicht warum.
            DP sind alle angelegt worden, aber keiner davon wird aktualisiert.

            EDIT: Lag nicht am Skript sondern an den Shellys. Da kamen keine Werte im DP Energy. Einmal an die Cloud lassen, dann geht es wieder.

            1 Reply Last reply Reply Quote 0
            • wcag22
              wcag22 @frankthegreat last edited by

              @frankthegreat
              Eigentlich nicht...
              Hatte damals sofort funktioniert. Ich hatte die Aktualisierungsrate lediglich von 15min auf 5min gesetzt (Zeile 456).
              Und in Zeile 289

               if (alter_verbrauch < 1 || alter_verbrauch == null) {
              

              auf ">0.1" ändern. Gab da wohl Fehler, wenn der Verbrauch zu klein war...

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

                Hallo zusammen.
                @SKB

                Das Script lief die letzten Wochen ohne Probleme.
                Jetzt habe ich aber das Problem, dass plötzlich manchen Zähler bei -null- anfangen.

                Änderungen habe ich keinen Vorgenommen (ich war seit 1,2 Wochen nicht auf dem PI angemeldet).
                Ich habe nur im Grafana gesehen, dass die Messungen komplett falsch sein müssen.

                Hier ein Bild von der Historie:
                Screenshot 2024-03-06 082546.png

                Im Log habe ich zur dieser Uhrzeit folgende Einträge gefunden:

                2024-03-03 20:15:00.026 - info: javascript.0 (1122) script.js.Strom_Shelly_Verbrauch-Historie_mqtt: Shelly Verbrauch: Verbrauchswerte aktualisiert: 1 | Reboots korrigiert: 0 | Unveränderte Werte: 0
                2024-03-03 20:15:00.089 - info: javascript.0 (1122) script.js.Strom_Shelly_Verbrauchs-Historie: Shelly Verbrauch: Verbrauchswerte aktualisiert: 19 | Reboots korrigiert: 1 | Unveränderte Werte: 57
                

                Wie kann ich herausfinden warum das Script nicht sauber läuft?
                Sind die Messwerte jetzt alle unbrauchbar?

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

                  @bitwicht
                  Wenn ich das richtig sehe, wertest Du an dieser Stelle den aktuellen Wert aus.
                  Im Log ist zu sehen, dass es einen reboot gab, der korrigiert wurde. Beim reboot werden die shellys zurückgesetzt, daher also Null.
                  Im shelly script müsstet Du mal auf den DP-Wert gesamt schauen, der sollte fortgeführt sein.

                  Ergänzung:

                  shellyscript.png

                  Ich habe auch etwas gebraucht, um die Logik hinter den Werten zu verstehen.
                  Eigentlich ganz einfach 🙂

                  Die aufgelaufenen Werte werden in kurzem Interval in andere DP kopiert. Werden die Shelly beim reboot zurückgesetzt, sind zwar die aktuellen Werte in dem Moment gleich Null, die alten Werte sind aber noch vorhanden.

                  Wenn nach reboot die neuen Werte kleiner als die alten Werte sind, wird das von script ausgewertet und korrigiert.
                  Die alten Werte werden nun mit den neuen Werten weitergeführt (summiert).
                  Ich hatte mir damals so eine Art "Denkhilfe" gebastelt 🙂

                  Shelly Gesamtverbrauch nach reboot = Shelly Gesamtverbrauch vor reboot + Messwert neu
                  Shelly Gesamtverbrauch nach reboot = Shelly Gesamtverbrauch nach reboot - Messert neu
                  Shelly Gesamtverbrauch vor reboot = Shelly Gesamtverbrauch nach reboot - Messwert neu
                  Gesamtverbrauch heute = Verbrauch heute vor reboot + aktueller Messwert
                  Gesamtverbrauch heute - aktueller Messwert (akt. Verbrauch) = Verbrauch heute vor reboot

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

                    @wcag22

                    Verdammt, dann habe ich mal wieder den falschen Wert erwischt 😞
                    Danke, der Gesamt ist noch da.

                    1 Reply Last reply Reply Quote 0
                    • A
                      abc123 last edited by

                      Wie kann ich denn herausfinden warum bei mir keine DP erstellt werden?```
                      Ich nutze einen Shelly 3EMPro mit aktueller FW (1.3.2-g)

                      code_text
                      2.6.2024, 15:57:12.176	[info ]: javascript.0 (218) Start JavaScript script.js.Skript_1 (Javascript/js)
                      2.6.2024, 15:57:12.211	[info ]: javascript.0 (218) script.js.Skript_1: Shelly Verbrauch: Erster Start des Skriptes! Datenpunkte werden erstellt!
                      2.6.2024, 15:57:12.212	[info ]: javascript.0 (218) script.js.Skript_1: Shelly Verbrauch: Datenpunkte erstellt! Erster Verbrauch steht nach 30 Sekunden zur Verfügung! Anzahl gefundener Shelly Datenpunkte: 0
                      2.6.2024, 15:57:12.223	[info ]: javascript.0 (218) script.js.Skript_1: registered 0 subscriptions, 2 schedules, 0 messages, 0 logs and 0 file subscriptions
                      2.6.2024, 15:57:42.214	[info ]: javascript.0 (218) script.js.Skript_1: Shelly Verbrauch: Verbrauchswerte aktualisiert: 0 | Reboots korrigiert: 0 | Unveränderte Werte: 0
                      2.6.2024, 16:00:00.050	[info ]: javascript.0 (218) script.js.Skript_1: Shelly Verbrauch: Verbrauchswerte aktualisiert: 0 | Reboots korrigiert: 0 | Unveränderte Werte: 0
                      2.6.2024, 16:15:00.016	[info ]: javascript.0 (218) script.js.Skript_1: Shelly Verbrauch: Verbrauchswerte aktualisiert: 0 | Reboots korrigiert: 0 | Unveränderte Werte: 0
                      
                      

                      Screenshot_20240602_162801.png

                      crunchip 1 Reply Last reply Reply Quote 0
                      • crunchip
                        crunchip Forum Testing Most Active @abc123 last edited by crunchip

                        @abc123 stimmt im script die instanznummer?

                        var shelly_dp = "shelly.0";
                        
                        1 Reply Last reply Reply Quote 0
                        • A
                          abc123 last edited by

                          @crunchip sagte in Shelly Verbrauchs-Historie für Tag, Woche, Monat, Jahr:

                          instanznummer

                          ich denke ja.
                          Screenshot_20240602_172301.png

                          crunchip 1 Reply Last reply Reply Quote 0
                          • crunchip
                            crunchip Forum Testing Most Active @abc123 last edited by

                            @abc123 und kommen überhaupt Werte beim shelly rein?

                            1 Reply Last reply Reply Quote 0
                            • A
                              abc123 last edited by abc123

                              Ja, der Shelly-Adapter läuft. Alle Werten werten im Shelly-Adapter angezeigt. Im Script leider nicht.

                              R 1 Reply Last reply Reply Quote 0
                              • R
                                rboen @abc123 last edited by

                                @abc123 Hei, hast du schon eine Lösung gefunden? Bei mir verhält sich die Geschichte genauso wie bei dir...

                                S A 2 Replies Last reply Reply Quote 0
                                • S
                                  SpacerX @rboen last edited by

                                  @rboen Man müsste mal schauen ob die Datenpunkte beim Pro3Em genau so benannt sind wie bei dem 3EM.
                                  in dem oberen log steht ja 0 gefundene Datenpunkte.

                                  Kann mal jemand die Objektstruktur von so einem Pro3Em zeigen?

                                  1 Reply Last reply Reply Quote 0
                                  • A
                                    abc123 @rboen last edited by

                                    @rboen
                                    teste mal diese Variante.
                                    Grüße

                                    
                                    /*
                                    
                                     * @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 Pro3EM DP
                                    
                                    var shelly3EMDps = $('state[id=' + shelly_dp + '.*.*.TotalActiveEnergy]');
                                    
                                    
                                    
                                    // Datenpunkte der Shelly Pro3EM DP - Total
                                    
                                    var shelly3EMTotalReturned = $('state[id=' + shelly_dp + '.*.*.TotalActiveReturnEnergy]');
                                    
                                    
                                    
                                    // 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 < 0.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 1 Minuten das Skript für den Tagesverbrauch ausführen
                                    
                                    schedule('*/1 * * * *', 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);
                                    
                                    
                                    S R Moe 3 Replies Last reply Reply Quote 0
                                    • S
                                      SpacerX @abc123 last edited by SpacerX

                                      @abc123 Das meinte ich doch!

                                      Die Datenpunkte des Pro3em sind anders benannt.

                                      Jetzt gibt es 2 Wege das zum laufen zu bringen.
                                      Einmal die Bitte an den Entwickler des Shelly Adapter die Datenpunkte gleich zu benennen oder es so wie du zu machen, die Abfrage der Datenpunkte in das Skript einzupflegen.

                                      Leiter ist bis jetzt niemand meiner Bitte nachgekommen mal den Objektbaum eines Pro3em zu zeigen.

                                      Jetzt haben wir die Dritte variante des Skript. Aber bitte.

                                      Dann gebt wenigstens bescheid wenn das so läuft dann werde ich meine Variante anpassen, vielleicht kommt bei mir ja auch mal so ein Plus3em Gerät an.

                                      Noch mal die Bitte mal einen Objektbaum dieses Gerätes zu Veröffentlichen.
                                      Im Quellcode das Adapters sollte ich auch fündig werden, hab nur gerade nicht die Not darin rum zu stöbern.

                                      A R 2 Replies Last reply Reply Quote 0
                                      • A
                                        abc123 @SpacerX last edited by abc123

                                        @spacerx
                                        die Variante die ich oben gepostet habe läuft mit dem 3EMpro. Die Datenpunkte sind entsprechend geändert.
                                        Grüße
                                        Edit: den Objektbaum bekommst du gleich auch noch. Ich weiß noch nicht wie ich ihn am besten kopiere.

                                        A 1 Reply Last reply Reply Quote 0
                                        • A
                                          abc123 @abc123 last edited by abc123

                                          @SpacerX
                                          Ist das so i.O.?

                                          EM0
                                          
                                          ActivePowerA
                                          ActivePowerB
                                          ActivePowerC
                                          ApparentPowerA
                                          ApparentPowerB
                                          ApparentPowerC
                                          ChannelName
                                          CurrentA
                                          CurrentB
                                          CurrentC
                                          CurrentN
                                          PowerFactorA
                                          PowerFactorB
                                          PowerFactorC
                                          TotalActivePower
                                          TotalApparentPower
                                          TotalCurrent
                                          VoltageA
                                          VoltageB
                                          VoltageC
                                          
                                          MData0
                                          
                                          TotalActiveEnergy
                                          TotalActiveEnergyA
                                          TotalActiveEnergyB
                                          TotalActiveEnergyC
                                          TotalActiveReturnEnergy
                                          TotalActiveReturnEnergy
                                          TotalActiveReturnEnergyA
                                          TotalActiveReturnEnergyB
                                          TotalActiveReturnEnergyC
                                          
                                          
                                          S 1 Reply Last reply Reply Quote 1
                                          • S
                                            SpacerX @abc123 last edited by

                                            @abc123 ok. Mit dem Bild aus deinem Anderen Beitrag wegen Saldierung passt das schon.
                                            Danke.

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

                                            Support us

                                            ioBroker
                                            Community Adapters
                                            Donate

                                            817
                                            Online

                                            31.9k
                                            Users

                                            80.2k
                                            Topics

                                            1.3m
                                            Posts

                                            24
                                            134
                                            16074
                                            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