Navigation

    Logo
    • Register
    • Login
    • Search
    • Recent
    • Tags
    • Unread
    • Categories
    • Unreplied
    • Popular
    • GitHub
    • Docu
    • Hilfe
    1. Home
    2. Deutsch
    3. Hardware
    4. Balkonkraftwerk + ioBroker: aktuell bestes Setup?

    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

    Balkonkraftwerk + ioBroker: aktuell bestes Setup?

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

      @bananajoe Als ioBroker und ESP-Bastler wäre ggfs auch eine Nachführung der Panels mit Steuerung über den ioBroker denkbar 😉

      www.pollin.de hat auf der "Restposten" Seite häufig recht kräftige 12 V Getriebemotoren im Angebot 😉

      Wahrscheinlich würde schon ein Kontrollieren nur der Elevation im Tagesgang einen Gewinn an Ausbeute bringen ...

      Rational wäre das aber nur zu begründen, wenn Aufstellflächen knapp werden. Ansonsten ist Kauf und Aufstellen weiterer Module wahrscheinlich eine wirtschaftlichere Lösung...

      Interessant wäre so ein Projekt aber sicherlich ....

      BananaJoe 1 Reply Last reply Reply Quote 0
      • BananaJoe
        BananaJoe Most Active @MartinP last edited by

        @martinp sagte in Balkonkraftwerk + ioBroker: aktuell bestes Setup?:

        Rational wäre das aber nur zu begründen, wenn Aufstellflächen knapp werden. Ansonsten ist Kauf und Aufstellen weiterer Module wahrscheinlich eine wirtschaftlichere Lösung...

        Jepp. Meine Module haben damals "nur" 185 Euro gekostet statt 230 Euro da wir über eine Palette bestellt haben.
        Aktuell bekomme ich die für unter 80 Euro pro Stück + 10 Euro Versand ...

        Und wenn man sich die Dinger an den Gartenzaun stellt oder - wie ich - an die Hauswand schrauben

        M 1 Reply Last reply Reply Quote 0
        • Homoran
          Homoran Global Moderator Administrators last edited by

          @mooly sagte in Balkonkraftwerk + ioBroker: aktuell bestes Setup?:

          Mein Gefühl sagt mir dass die 17 Grad der beste Kompromiss über das ganze Jahr sind

          naja!
          ich habe inzwischen meine beiden Meyer Burger Panels, mit 90° in Betrieb
          20240108_112751.jpg
          und kann @BananaJoe nur bestätigen, dass im Winterhalbjahr, die Ausbeute höher als auf dem Dach ist
          Das Dach hat nominal 5600, Die beiden Panels 760Wp

          Hier
          Screenshot_20240301-112155_Firefox.jpg
          habe ich die Winkel (Azimut - Elevation) in Relation zum senkrechten Auftreffen gerechnet.

          In unseren Breiten steht die Sonne zur Wintersonnenwende nur 15° hoch, im Sommer 65°
          da fehlen selbst im Sommer noch 25° bis zum senkrechten Auftreffen.

          MartinP 1 Reply Last reply Reply Quote 1
          • M
            mooly last edited by

            Ich habe noch eine andere Frage.

            Hat jemand einen Tipp wie ich ergänzende Verbrauchsdaten abfragen kann vom Shelly pro 3EM?

            Es gab hier mal ein Topic aus 2020 wo auf einen Link verwiesen wird:
            https://www.kreyenborg.koeln/shelly-verbrauchs-historie-fuer-tag-woche-monat-jahr/

            Funktioniert das noch? Gibt es nach 4 Jahren evtl eine elegantere Lösung? Oder nur die mit InfluxDB und Grafana?

            LG

            Homoran 1 Reply Last reply Reply Quote 0
            • Homoran
              Homoran Global Moderator Administrators @mooly last edited by

              @mooly sagte in Balkonkraftwerk + ioBroker: aktuell bestes Setup?:

              Gibt es nach 4 Jahren evtl eine elegantere Lösung?

              das musst du @skb fragen

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

                @homoran Das Skript unterstützt den Shelly Pro 3EM nicht, da ich keinen habe und irgendwie aktuell mit Projekten ausgelastet bin 🙂

                M 2 Replies Last reply Reply Quote 1
                • M
                  mooly @SKB last edited by

                  @skb

                  Schade 😞
                  Also wenn du einen Betatester brauchst: 👋

                  Gibt es Alternativen?

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

                    @mooly Wenn Du Personen suchst, die du unterstützen kannst: 🙌
                    Du kannst mir gerne den Shelly Pro 3EM spenden, dann kann ich die Dinge irgendwann einbauen 🙂

                    M 1 Reply Last reply Reply Quote 0
                    • MartinP
                      MartinP @Homoran last edited by

                      @homoran mit einer Schrägmontage mit 15° Elevation wäre die Elevation für die Wintersonnenwende optimal, und ansonsten zumindest optimaler, als bei 90°....
                      Sieht natürlich nicht so schön aus ...

                      Homoran 1 Reply Last reply Reply Quote 0
                      • M
                        mooly @SKB last edited by

                        @skb

                        Je nach Grad der Verzweiflung in den nächsten Tagen komme ich evtl darauf zurück 😂

                        Ich glaube viel ist da nicht anders als beim 3em. Das Skript ist wirklich genial.

                        Lieber Gruß

                        1 Reply Last reply Reply Quote 1
                        • Homoran
                          Homoran Global Moderator Administrators @MartinP last edited by Homoran

                          @martinp sagte in Balkonkraftwerk + ioBroker: aktuell bestes Setup?:

                          an mit einer Schrägmontage mit 15° Elevation wäre die Elevation für die Wintersonnenwende optimal

                          niemals.
                          15° Elevation (Sonne am Mittag) + 15° Schrägmontage sind -60° zur Senkrechten (= optimaler Ertrag).

                          Bei senkrecht montierten Panels liegst du mittags nur 15° aus der Senkrechten, früher und später sogar weniger

                          MartinP 1 Reply Last reply Reply Quote 0
                          • MartinP
                            MartinP @Homoran last edited by MartinP

                            @homoran Hmm verstehe ich nicht, wenn die Sonne 15° Elevation hat, heißt dass dass sie 15° über dem Horizont steht. Ich meinte die Montage so:

                            d1c9832f-55b6-486c-8390-f5cc2e281bfd-grafik.png

                            Mittags zur Wintersonnenwende optimal bei exakter Südausrichtung der Wand, auf der montiert wird.
                            Im Sommer zumindest optimaler, als wenn das Modul genau senkrecht an der Wand hängt.

                            Homoran 1 Reply Last reply Reply Quote 0
                            • Homoran
                              Homoran Global Moderator Administrators @MartinP last edited by

                              @martinp sagte in Balkonkraftwerk + ioBroker: aktuell bestes Setup?:

                              Ich meinte die Montage so:

                              dann ist das richtig.

                              hier ging es aber um Panels, die auf dem Garagendach liegen und nur um 15° aus der Waagerechten kommen

                              MartinP 1 Reply Last reply Reply Quote 0
                              • MartinP
                                MartinP @Homoran last edited by MartinP

                                @homoran Ich meinte die Panels auf diesem Bild aus einem Post von Dir - wenn man die unten ein wenig ausstellen würde.... wäre aber ggfs nicht mehr so unauffällig ...

                                https://forum.iobroker.net/assets/uploads/files/1709288470313-20240108_112751-resized.jpg

                                Homoran 1 Reply Last reply Reply Quote 0
                                • Homoran
                                  Homoran Global Moderator Administrators @MartinP last edited by Homoran

                                  @martinp ok. Es geht aber nicht um mich, ich bin unwichtig 😀

                                  Meine stehen eh zu weit vor, die sind mit 300mm Stockschrauben befestigt, damit im Sommer der Dachüberstand keinen Schatten drauf wirft.
                                  Da ist aber anscheinend noch Luft drin, dann könnte man oben kürzere Stockschrauben nehmen.

                                  Allerdings hatte ich tatsächlich drüber nachgedacht eine horizontale Nachführung zu bauen. Im Moment "blicken" die Module nach 130° (SO), wo im Winter gerade die Sonne aufgeht.
                                  Nach S zu klappen würde schon einiges bringen.

                                  Wird mit der Mechanik aber nicht gerade einfach, erst recht nicht die Windlast ausreichend abzufangen.

                                  EDIT:
                                  Hab gerade noch Abstandsdifferenz bei 1,75m Panellänge und 15° rechnen lassen
                                  Screenshot_20240301-141239_Firefox.jpg

                                  Das wären unten 45cm mehr als oben 😂

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

                                    @skb

                                    Sorry, ich muss nochmal Fragen:

                                    Könnte es sein, dass ich nur ein paar Dinge im Skript ändern müsste? z.B. nur den Namen? Von Shelly3EM auf Shellypro3EM? z.B. heisst der Ordner vom pro3em unter /Shelly shellypro3em#08f9e0e9baf0#1

                                    Ich habe die Hoffnung, dass ich das Skript doch noch zum Laufen bekomme. Ich habe es mal rüber kopiert, aber es werden keine neuen Objekte erstellt. (ich muss ja nichts machen, außer das Skript unter JScript rein zu kopieren und starten!?)

                                    Viele Grüße!

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

                                      @mooly Ich denke, da muss ein ganzer Bereich dazu und der EM Pro wird sicherlich paar Datenpunkte mehr haben.

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

                                        @skb

                                        Okay danke! ein Versuch war’s wert.. LG

                                        1 Reply Last reply Reply Quote 0
                                        • M
                                          mooly @BananaJoe last edited by

                                          @bananajoe

                                          Hey! Habe heute meine Module bekommen, klappt alles super (auch mit OpenDTU) auf anhieb alles klasse.

                                          Ich will nicht unbedingt einen neuen Thread auf machen. Habe meinen Verbrauch im Haus mit einem Shelly pro 3EM abgegriffen und das in Flot dargestellt. Jetzt kamen noch die "ist" Einspeisungsdaten dazu. Klappt alles.
                                          Jetzt experimentiere ich mit den pcforecast daten und würde diese gerne in Flot übertragen... das klappt aber nicht befürchte ich (weil andere Logik). Also bleibt mir wohl nix anderes übrig als auf FluxDB umzusteigen? Ich habe in einem anderen Thread gesehen, dass du damit wohl Erfahrung hast? 😄

                                          1 Reply Last reply Reply Quote 0
                                          • Ralle74
                                            Ralle74 @mooly last edited by Ralle74

                                            @mooly Ich hatte das gleiche Problem, hab es so gelöst:

                                            Das folgende Script (v1.60) im Javascript-Adapter neu anlegen (vielen Dank an Stephan Kreyenborg!)

                                            Falls du dieses Script schon am laufen hast, brauchst du die Zeilen 56 bis 60 für den Shelly Pro3EM einfach nur passend einfügen.
                                            Wenn es noch nicht läuft kopiere einfach das gesamte Script und füge es bei dir ein.

                                            /*
                                             * @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);
                                            

                                            Falls du nicht wie ich eine minütliche Aktualisierung brauchst, kannst du Zeile 470 und 471 einfach mit dem gewünschten Intervall ändern.
                                            Anschließend das Script neu laden und warten bis die Datenpunkte hinzugefügt wurden.
                                            Sollte dann in etwa so aussehen! Natürlich nur mit anderen Werten 😁
                                            ShellyPro3EM.PNG
                                            Zu finden sind die Datenpunkte dann wie immer unter javascript.0.ShellyVerbrauch
                                            Solltest du wie ich vorher den Shelly 3EM benutzt haben, kannst du bis auf die Datenpunkte "aktueller_wert" und "alter_wert" des Shelly Pro3EM die übrigen Werte mit den jeweiligen Werten des Shelly3EM.png
                                            überschreiben.
                                            Die beiden vorher angesprochenen Datenpunkte werden immer aus dem Shelly direkt ausgelesen und überschrieben, eine manuelle Änderung bringt da nichts.
                                            Ich hoffe das hilft dir weiter.

                                            Viele Grüße
                                            Ralle

                                            M D 2 Replies Last reply Reply Quote 1
                                            • First post
                                              Last post

                                            Support us

                                            ioBroker
                                            Community Adapters
                                            Donate

                                            950
                                            Online

                                            31.9k
                                            Users

                                            80.1k
                                            Topics

                                            1.3m
                                            Posts

                                            15
                                            96
                                            9376
                                            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