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

  • Standard: (Kein Skin)
  • Kein Skin
Einklappen
ioBroker Logo

Community Forum

donate donate
  1. ioBroker Community Home
  2. Deutsch
  3. Skripten / Logik
  4. JavaScript
  5. Shelly Verbrauchs-Historie für Tag, Woche, Monat, Jahr

NEWS

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

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

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

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

Geplant Angeheftet Gesperrt Verschoben JavaScript
134 Beiträge 24 Kommentatoren 22.9k Aufrufe 27 Watching
  • Älteste zuerst
  • Neuste zuerst
  • Meiste Stimmen
Antworten
  • In einem neuen Thema antworten
Anmelden zum Antworten
Dieses Thema wurde gelöscht. Nur Nutzer mit entsprechenden Rechten können es sehen.
  • B bitwicht

    @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 Offline
    S Offline
    SpacerX
    schrieb am zuletzt editiert von SpacerX
    #110

    @bitwicht wenn die 2 Scripte den gleichen Namen haben, dann hänge mal an eines de Scriptnamen einen Sufix an. Dann sollte auch im Infoprotokoll 2 mal die Info kommen mit den geänderten Werten. Sollte bei beiden gleich aus sehen. Ich kann da erst nach dem Wochenende genauer schauen hab nur mein Handy zur Hand.

    Wenn du kannst lösche alle Datenpunkte noch mal und starte die Skripte neu.

    DS720|Nuc8i3BEH|Proxmox|RaspberryMatic|ioBroker|influxDB2|Grafana

    1 Antwort Letzte Antwort
    0
    • B Offline
      B Offline
      bitwicht
      schrieb am zuletzt editiert von
      #111

      @SpacerX

      Die Scripte haben unterschiedliche nahmen.
      Je Script kommt auch ein Log Eintrag

      javascript.0
      2024-01-13 17:45:00.272	info	script.js.Strom_Shelly_Verbrauchs-Historie: Shelly Verbrauch: Verbrauchswerte aktualisiert: 30 | Reboots korrigiert: 0 | Unveränderte Werte: 47
      
      javascript.0
      2024-01-13 17:45:00.154	info	script.js.Strom_Shelly_Verbrauch_History_spacerX: Shelly Verbrauch: Verbrauchswerte aktualisiert: 30 | Reboots korrigiert: 0 | Unveränderte Werte: 47
      

      Ich habe von beide Scripte gestoppt, alle Datenpunkte gelöscht und neu gestartet.

      Es wird immer sofort bei den EM Emeter0 und Emeter0_Returned angelegt.
      Bei den PlugS wird kein__Returned angelegt.

      Schau einfach mal wenn du Zeit hast ob dir noch was auffällt.

      S 1 Antwort Letzte Antwort
      0
      • B bitwicht

        @SpacerX

        Die Scripte haben unterschiedliche nahmen.
        Je Script kommt auch ein Log Eintrag

        javascript.0
        2024-01-13 17:45:00.272	info	script.js.Strom_Shelly_Verbrauchs-Historie: Shelly Verbrauch: Verbrauchswerte aktualisiert: 30 | Reboots korrigiert: 0 | Unveränderte Werte: 47
        
        javascript.0
        2024-01-13 17:45:00.154	info	script.js.Strom_Shelly_Verbrauch_History_spacerX: Shelly Verbrauch: Verbrauchswerte aktualisiert: 30 | Reboots korrigiert: 0 | Unveränderte Werte: 47
        

        Ich habe von beide Scripte gestoppt, alle Datenpunkte gelöscht und neu gestartet.

        Es wird immer sofort bei den EM Emeter0 und Emeter0_Returned angelegt.
        Bei den PlugS wird kein__Returned angelegt.

        Schau einfach mal wenn du Zeit hast ob dir noch was auffällt.

        S Offline
        S Offline
        SpacerX
        schrieb am zuletzt editiert von SpacerX
        #112

        @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.

        DS720|Nuc8i3BEH|Proxmox|RaspberryMatic|ioBroker|influxDB2|Grafana

        O 1 Antwort Letzte Antwort
        0
        • S 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 Offline
          O Offline
          opöl
          schrieb am zuletzt editiert von
          #113

          @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ß

          SKBS 1 Antwort Letzte Antwort
          0
          • O opöl

            @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ß

            SKBS Offline
            SKBS Offline
            SKB
            Developer Most Active
            schrieb am zuletzt editiert von
            #114

            @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.

            ... wer nicht mit der Zeit geht, geht mit der Zeit ...

            Aktuelle Entwicklung: Energiefluss - erweitert (https://forum.iobroker.net/topic/64734)

            1 Antwort Letzte Antwort
            0
            • J Offline
              J Offline
              JohnnyBahama
              schrieb am zuletzt editiert von JohnnyBahama
              #115

              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 Antwort Letzte Antwort
              0
              • frankthegreatF frankthegreat

                @SKB Hallo, klingt sehr interessant.
                Muss denn im Script noch was angepasst werden?

                wcag22W Offline
                wcag22W Offline
                wcag22
                schrieb am zuletzt editiert von
                #116

                @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...

                Wenns nicht geht, wie man will - muss mans tun, wie man kann.
                1 Antwort Letzte Antwort
                0
                • B Offline
                  B Offline
                  bitwicht
                  schrieb am zuletzt editiert von bitwicht
                  #117

                  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?

                  wcag22W 1 Antwort Letzte Antwort
                  0
                  • B 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?

                    wcag22W Offline
                    wcag22W Offline
                    wcag22
                    schrieb am zuletzt editiert von wcag22
                    #118

                    @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

                    Wenns nicht geht, wie man will - muss mans tun, wie man kann.
                    1 Antwort Letzte Antwort
                    0
                    • B Offline
                      B Offline
                      bitwicht
                      schrieb am zuletzt editiert von
                      #119

                      @wcag22

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

                      1 Antwort Letzte Antwort
                      0
                      • A Offline
                        A Offline
                        abc123
                        schrieb am zuletzt editiert von
                        #120

                        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

                        crunchipC 1 Antwort Letzte Antwort
                        0
                        • A abc123

                          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

                          crunchipC Offline
                          crunchipC Offline
                          crunchip
                          Forum Testing Most Active
                          schrieb am zuletzt editiert von crunchip
                          #121

                          @abc123 stimmt im script die instanznummer?

                          var shelly_dp = "shelly.0";
                          

                          umgestiegen von Proxmox auf Unraid

                          1 Antwort Letzte Antwort
                          0
                          • A Offline
                            A Offline
                            abc123
                            schrieb am zuletzt editiert von
                            #122

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

                            instanznummer

                            ich denke ja.
                            Screenshot_20240602_172301.png

                            crunchipC 1 Antwort Letzte Antwort
                            0
                            • A abc123

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

                              instanznummer

                              ich denke ja.
                              Screenshot_20240602_172301.png

                              crunchipC Offline
                              crunchipC Offline
                              crunchip
                              Forum Testing Most Active
                              schrieb am zuletzt editiert von
                              #123

                              @abc123 und kommen überhaupt Werte beim shelly rein?

                              umgestiegen von Proxmox auf Unraid

                              1 Antwort Letzte Antwort
                              0
                              • A Offline
                                A Offline
                                abc123
                                schrieb am zuletzt editiert von abc123
                                #124

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

                                R 1 Antwort Letzte Antwort
                                0
                                • A abc123

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

                                  R Offline
                                  R Offline
                                  rboen
                                  schrieb am zuletzt editiert von
                                  #125

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

                                  S A 2 Antworten Letzte Antwort
                                  0
                                  • R rboen

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

                                    S Offline
                                    S Offline
                                    SpacerX
                                    schrieb am zuletzt editiert von
                                    #126

                                    @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?

                                    DS720|Nuc8i3BEH|Proxmox|RaspberryMatic|ioBroker|influxDB2|Grafana

                                    1 Antwort Letzte Antwort
                                    0
                                    • R rboen

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

                                      A Offline
                                      A Offline
                                      abc123
                                      schrieb am zuletzt editiert von
                                      #127

                                      @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 MoeM 3 Antworten Letzte Antwort
                                      0
                                      • A abc123

                                        @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 Offline
                                        S Offline
                                        SpacerX
                                        schrieb am zuletzt editiert von SpacerX
                                        #128

                                        @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.

                                        DS720|Nuc8i3BEH|Proxmox|RaspberryMatic|ioBroker|influxDB2|Grafana

                                        A R 2 Antworten Letzte Antwort
                                        0
                                        • S 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 Offline
                                          A Offline
                                          abc123
                                          schrieb am zuletzt editiert von abc123
                                          #129

                                          @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 Antwort Letzte Antwort
                                          0
                                          Antworten
                                          • In einem neuen Thema antworten
                                          Anmelden zum Antworten
                                          • Älteste zuerst
                                          • Neuste zuerst
                                          • Meiste Stimmen


                                          Support us

                                          ioBroker
                                          Community Adapters
                                          Donate

                                          574

                                          Online

                                          32.4k

                                          Benutzer

                                          81.5k

                                          Themen

                                          1.3m

                                          Beiträge
                                          Community
                                          Impressum | Datenschutz-Bestimmungen | Nutzungsbedingungen | Einwilligungseinstellungen
                                          ioBroker Community 2014-2025
                                          logo
                                          • Anmelden

                                          • Du hast noch kein Konto? Registrieren

                                          • Anmelden oder registrieren, um zu suchen
                                          • Erster Beitrag
                                            Letzter Beitrag
                                          0
                                          • Home
                                          • Aktuell
                                          • Tags
                                          • Ungelesen 0
                                          • Kategorien
                                          • Unreplied
                                          • Beliebt
                                          • GitHub
                                          • Docu
                                          • Hilfe