Navigation

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

    NEWS

    • Neuer Blog: Fotos und Eindrücke aus Solingen

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

    • ioBroker goes Matter ... Matter Adapter in Stable

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

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

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

      instanznummer

      ich denke ja.
      Screenshot_20240602_172301.png

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

        @abc123 und kommen überhaupt Werte beim shelly rein?

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

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

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

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

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

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

              Kann mal jemand die Objektstruktur von so einem Pro3Em zeigen?

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

                @rboen
                teste mal diese Variante.
                Grüße

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

                  @abc123 Das meinte ich doch!

                  Die Datenpunkte des Pro3em sind anders benannt.

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

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

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

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

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

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

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

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

                      @SpacerX
                      Ist das so i.O.?

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

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

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

                          @spacerx Super Danke. Die "Variante 3" funktioniert prima

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

                            @abc123 Genauso sollte es sein, Dankeschön

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

                              @abc123

                              Hallo, habe über Google diesen Beitrag gefunden und das war genau was ich suchte.

                              Direkt den Script kopiert und bei mir eingefügt. Den Shelly findet er holt sich Aktueller Wert und Alter Wert unter EMData0 und EMData0_Returned mehr passiert leider nicht. Bekomme keine Fehlermeldungen.

                              Kann mir dort jemand weiterhelfen ?

                              Gruß Moe

                              Hat sich erledigt. Fehler gefunden. Shelly war nicht mit dem IOBroker via MQTT Verbunden

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

                              Support us

                              ioBroker
                              Community Adapters
                              Donate

                              527
                              Online

                              31.9k
                              Users

                              80.1k
                              Topics

                              1.3m
                              Posts

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