Navigation

    Logo
    • Register
    • Login
    • Search
    • Recent
    • Tags
    • Unread
    • Categories
    • Unreplied
    • Popular
    • GitHub
    • Docu
    • Hilfe
    1. Home
    2. Deutsch
    3. Skripten / Logik
    4. Stromverbrauchsrechnung mit NT HT Berücksichtigung - Script

    NEWS

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

    • ioBroker goes Matter ... Matter Adapter in Stable

    • Monatsrückblick - April 2025

    Stromverbrauchsrechnung mit NT HT Berücksichtigung - Script

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

      kann es sein, dass bei der Flot-Aufzeichnung des DP LetzterVerbrauch kWh Werte unter 0.05 kWh auf 0 abgerundet werden? (siehe violetter Linie).
      291_flot_edit.png
      in der Objektliste werden jedenfalls x Nachkomma-Stellen angezeigt.

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

        Dann stell doch mal auf 3 oder 4 Nachkommastellen um.

        Gruß

        Rainer

        1 Reply Last reply Reply Quote 0
        • S
          starfish last edited by

          hallo Rainer - hatte ich bereits gemacht (im Flot-Editor auf 4 Nachkommastellen eingestellt - oder wo meinst Du?) - aber bei der Historien-Einstellung ganz am Ende der Objektzeile sehe ich unter "Tabelle" nach wie vor nur 2 Stellen und der Abrundungseffekt auf 0 ist nach wie vor vorhanden.

          1 Reply Last reply Reply Quote 0
          • L
            looxer01 last edited by

            Hi,

            hast dir mal die Werte angesehen ?

            hab mal ein Beispiel angehängt.

            Sollte ja ähnlich bei dir aussehen ? vielleicht ist es ein Flot Anzeigeproblem.

            vG Looxer

            305_stromverbrauch.jpg

            1 Reply Last reply Reply Quote 0
            • S
              starfish last edited by

              hallo, bei mir siehts so aus:
              291_iobroker.admin_2_.png
              dazu muss ich anmerken, dass ich z.Zt. im Urlaub bin und der Stromverbrauch zu Hause nicht unbedingt sehr hoch ist. Aber 0 kann nicht sein. Ich könnte das Berechnungsintervall noch höher setzen, im Moment sinds die empfohlenen 30 Minuten für eine halbwegs vernünftige Auflösung (um Verbraucher zu identifizieren).

              Flot Anzeigeproblem glaube ich weniger, wo 0 ist zeigt er auch 0 an. Bei Deinem Skript kanns auch nicht liegen, das zeigt immer einen Verbrauch an (hat ja auch genug Nachkommastellen). Die Abrundung passiert wohl irgendwo dazwischen, bei der History resp. SQL-Speicherung.

              Diese Art Darstellung finde ich auch noch ganz gut: (wäre da nicht die chaotische Beschriftung der X-Achse)
              291_flot_edit_2_.png

              1 Reply Last reply Reply Quote 0
              • L
                looxer01 last edited by

                @starfish:

                Bei Deinem Skript kanns auch nicht liegen, das zeigt immer einen Verbrauch an (hat ja auch genug Nachkommastellen). `

                ich bin da nicht so sicher. Es gibt mehrere Stellen bei denen die Nachkommastellen abhanden kommen können.

                • Der Smartmeter liefert Werte üblicherweise in Wh und Nachkommastellen. Wenn keine Nachkommastellen geliefert werden ist das eine mögliche Quelle

                • Das Programm rechnet Wh in kWh um. Im Programm sind 4 Nachkommastellen vorgesehen (einstellbar). Das sollte nicht darunter liegen. Wenn der Smartmeter kWh liefert, dann sollte die Anzahl der Nachkommastellen erhöht werden, z.B. auf 8

                • Wenn die Werte zu klein werden dann sollte das Messintervall erhöht werden. Du hast 30 Minuten eingestellt. Stelle es mal auf 60 Minuten

                vG Looxer

                1 Reply Last reply Reply Quote 0
                • S
                  starfish last edited by

                  an welcher Stelle soll die Erhöhung der Nachkommastellen auf 8 gemacht werden - hier:

                    var RundungZaehler = 4;                      // Rundung fuer den Zaehler
                  ````?
                  
                  hier noch ein interessantes Bild (Zählerstand gespreizt bei 250W/div)
                  
                  trotz kontinuierlichem Anstieg der 0-Wert beim Delta …
                   ![291_flot_edit_3_.png](/assets/uploads/files/291_flot_edit_3_.png) 
                  1 Reply Last reply Reply Quote 0
                  • L
                    looxer01 last edited by

                    @starfish:

                    an welcher Stelle soll die Erhöhung der Nachkommastellen auf 8 gemacht werden - hier:

                      var RundungZaehler = 4;                      // Rundung fuer den Zaehler
                    ````?
                    
                    hier noch ein interessantes Bild (Zählerstand gespreizt bei 250W/div)
                    
                    trotz kontinuierlichem Anstieg der 0-Wert beim Delta …
                    
                    Flot Edit(3).png `  
                    

                    ja genau.

                    Auffällig ist, dass du nur zwei Nachkommastellen hast. Dafür muss es einen Grund geben.

                    Wobei es sein kann, dass es bei einzelnen Werten eben nur 2 Nachkommastellen gibt, definitiv aber nicht bei allen.

                    Wenn das keine Aenderung bringt, dann erhöhe die Messung auf 60 Minuten-

                    vG Looxer

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

                      Ich denke außerdem, dass die Datensammlung nur alle halbe Stunde stattfindet. Im Chart ist wahrscheinlich Linie und nicht Schritte eingestellt, so dass "bestenfalls" gerade um 06:00 ein Drop war, der zu dieser Form der Kurve geführt hat.

                      2 Nachkommastellen sind default bei der Erstellung von Charts, müssten ggf in den Optionen geändert werden.

                      Gruß

                      Rainer

                      1 Reply Last reply Reply Quote 0
                      • L
                        looxer01 last edited by

                        @Homoran:

                        Ich denke außerdem, dass die Datensammlung nur alle halbe Stunde stattfindet. Im Chart ist wahrscheinlich Linie und nicht Schritte eingestellt, so dass "bestenfalls" gerade um 06:00 ein Drop war, der zu dieser Form der Kurve geführt hat. `
                        Das würde bedeuten, dass kein Stromverbrauch innerhalb der gemessenen halben Stunde stattfand. Das dürfte eher unwahrscheinlich sein. Vielleicht war der Verbrauch aber so klein, dass abgerundet 0 raus kam. naja, auch ein Drop. Bei 2 Nachkommastellen und Messung in kWh würde das also bei <50 Watt passieren.

                        @Homoran:

                        2 Nachkommastellen sind default bei der Erstellung von Charts, müssten ggf in den Optionen geändert werden. `
                        jap, das wäre das o.g Ergebnis bei 2 Nachkommastellen

                        Ausserdem führt die Messung mit nur 2 Nachkommastellen auch zu einem falschen Zählerstand.

                        Ich mache das schon seit einigen Monaten und meine Zählerstände NT und HT sind korrekt. Die Genauigkeit also hoch.

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

                          Ich habe mir das Skript jetzt nicht intensiv angesehen,
                          @looxer01:

                          Das würde bedeuten, dass kein Stromverbrauch innerhalb der gemessenen halben Stunde stattfand. `
                          Wenn jedoch nur alle halbe Stunde der aktuelle Stromverbrauch abgerufen (oder geloggt) wird, und genau zu diesem Zeitpunkt gerade 0 war???

                          Für mich sieht der Chart so aus, als ob für den aktuellen Stromverbrauch nur alle 30 Minuten ein Wert existiert - keine Glättung!

                          Gruß

                          Rainer

                          1 Reply Last reply Reply Quote 0
                          • L
                            looxer01 last edited by

                            @Homoran:

                            Wenn jedoch nur alle halbe Stunde der aktuelle Stromverbrauch abgerufen (oder geloggt) wird, und genau zu diesem Zeitpunkt gerade 0 war??? `
                            Das Script rechnet mit Delta. AktuellerZaehlerstand minus Letzter Zaehlerstand = aktueller Verbrauch. Wenn alle 30 Minuten gemessen wird, dann ist das der aktuelle Verbrauch der letzten 30 Minuten.

                            vG Looxer

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

                              Danke!

                              dazu greift das Skript aber auf irgendwelche Datenpunkte ("Zählerstand alt" ?) zu.

                              Und dort sind mehr Nachkommastellen?

                              Gruß

                              Rainer

                              1 Reply Last reply Reply Quote 0
                              • L
                                looxer01 last edited by

                                @Homoran:

                                azu greift das Skript aber auf irgendwelche Datenpunkte ("Zählerstand alt" ?) zu.

                                Und dort sind mehr Nachkommastellen? `
                                aus meiner Sicht könnte da ein Problem sein. aber auch noch an anderen Stellen. Siehe vorheriger Post:
                                @looxer01:

                                Es gibt mehrere Stellen bei denen die Nachkommastellen abhanden kommen können.

                                • Der Smartmeter liefert Werte üblicherweise in Wh und Nachkommastellen. Wenn keine Nachkommastellen geliefert werden ist das eine mögliche Quelle

                                • Das Programm rechnet Wh in kWh um. Im Programm sind 4 Nachkommastellen vorgesehen (einstellbar). Das sollte nicht darunter liegen. Wenn der Smartmeter kWh liefert, dann sollte die Anzahl der Nachkommastellen erhöht werden, z.B. auf 8

                                • Wenn die Werte zu klein werden dann sollte das Messintervall erhöht werden. Du hast 30 Minuten eingestellt. Stelle es mal auf 60 Minuten `

                                1 Reply Last reply Reply Quote 0
                                • N
                                  noxx last edited by

                                  Moin

                                  ich nehme mal an, das man damit auch einen Gaszähler auswerten kann?

                                  Gruß

                                  1 Reply Last reply Reply Quote 0
                                  • L
                                    looxer01 last edited by

                                    Hi,
                                    @noxx:

                                    ich nehme mal an, das man damit auch einen Gaszähler auswerten kann? `
                                    im Prinzip ja. Das Besondere hier ist, dass das Script mit zwei Tarifen innerhalb von 24 Stunden umgehen kann, entsprechende Tarifumschaltungen durchführt. Das ist m.E. bei Gas kein Thema ?

                                    Für Gas sollte ansonsten auch z.B. der Betriebstundenzaehler funktionieren.

                                    vG Looxer

                                    1 Reply Last reply Reply Quote 0
                                    • S
                                      starfish last edited by

                                      @Homoran:

                                      Für mich sieht der Chart so aus, als ob für den aktuellen Stromverbrauch nur alle 30 Minuten ein Wert existiert - keine Glättung! `
                                      ich weiss jetzt nicht grad auf welches Beispiel Du Dich hier beziehst. Mein Verdacht geht nach einigen Tests in eine ganz andere Richtung. Irgendwas scheint mit Cron unsauber zu laufen. Nachdem ich das script eine Zeitlang ohne Eingriffe laufen liess, ergab sich folgendes Bild

                                      dabei fällt auf: h+00 und h+30 produzieren 0-Werte. Mittlerweile habe ich den modbus-adapter auf 3 Nachkommastellen eingestellt.

                                      Kann es sein, dass zu den obigen geraden Zeiten das script doppelt aufgerufen wird und als Folge ein Delta von 0 entsteht? (wie werden schedules gelöscht? -das script selbst und sogar den js-adapter habe ich jeweils neu gestartet)
                                      291_iobroker.admin_3_.png

                                      edit

                                      hier sieht man sehr schön, dass bei h+00 und h+30 auch getriggert wird, obwohl ich nur h+ 01,16,31,46 programmiert habe. Wie krieg ich die Einträge bei 00 und 30 weg? 291_iobroker.admin_4_.png

                                      1 Reply Last reply Reply Quote 0
                                      • L
                                        looxer01 last edited by

                                        Hi,

                                        @starfish:

                                        hier sieht man sehr schön, dass bei h+00 und h+30 auch getriggert wird, obwohl ich nur h+ 01,16,31,46 programmiert habe. Wie krieg ich die Einträge bei 00 und 30 weg? `
                                        poste doch mal den Code. Dann kann man besser sehen was passiert.

                                        Dann solltest du folgendes bedenken. Die Umschaltung NT zu HT und umgekehrt muss der Planung des Versorgungsunternehmens folgen.

                                        Wenn der z.B. Werktags um 20:00 umstellt, dann wirst du nie genau umschalten können, wenn du einen Plan hast der erst um 20:01 umschaltet. Dann verlierst du eine Minute. Mit der Zeit summiert sich das. Die Genauigkeit haengt davon ab wie genau du mit dem Versorgungsunternehmen synchronisieren kannst. Das klappt z.B. bei mir sehr gut.

                                        vG Looxer

                                        1 Reply Last reply Reply Quote 0
                                        • S
                                          starfish last edited by

                                          das mit der Synchronisation ist mir bewusst. Mir gehts ja auch nicht um einen Rechnungsvergleich, da dürfen schon kleinere Abweichungen drin liegen - aber das schau ich mir dann später an, wenn der Rest läuft. Was ich eben gut finde am Skript ist die feinere Auflösung beim Verbrauch.

                                          hier der Code, der eigentlich völlig Deinem Skript entspricht halt mit den nötigen Anpassungen und der cron Variante fürs debug.

                                          ! ````
                                          // Stromzaehler mit HT und NT Berechnung
                                          // Autor Looxer 26.11.2016 Version 0.5
                                          // Version 1.0 Script umgeschrieben
                                          //
                                          //
                                          // Die Schaltzeiten von WSW Strom NT sind Montag bis Samstag von 20.00 bis 6.00 Uhr und an Sonn- und Feiertagen in NRW ganztägig.
                                          // Feiertage sind durch den Feiertagsadapter definiert - nur die gesetzlichen Feiertage zählen (Heilig Abend oder Silvester zählen als Werktage)
                                          ! //-----------------------------------------------------------------------------------------------------
                                          // Einstellbereich
                                          //-----------------------------------------------------------------------------------------------------
                                          ! // Niedrig und Hochtarif-Schaltzeiten
                                          var NTEnde = 6; // Niedrigtarif Endezeit 06:00
                                          var NTStart = 20; // Niedrigtarif Startzeit 20:00
                                          ! // Verbrauchsrechnungs Zeitplanung
                                          var Zeitplan ="01,16,31,46 * * * *" ; // Cron Planung alle x Minuten für die Verbrauchsrechnung
                                          ! //Logging
                                          var logging = true; // logging enabled
                                          var logschedule = "50 23 * * *" ; // Cron - Zeitpunkt an dem das logfile geschrieben wird z.B. 23:50
                                          var LogPath = "/opt/iobroker/iobroker-data/Stromverbrauchslog.csv"; // Pfad und Dateiname des externen Logs
                                          ! // Allgemeine Parameter
                                          var RundungZaehler = 4; // Rundung fuer den Zaehler
                                          var path = 'javascript.0.Stromzaehler.'; // Pfad für create states

                                          // Einbindung Feiertagsadapter. Das ist Vorraussetzung für automatische HT / NT Umschaltung
                                          var StateFeiertagHeute = 'feiertage.0.heute.boolean'; // aus dem Feiertagsadapter

                                          ! // Hier ist der State des digitalen Zählers einzutragen. Der interne Zählerstand ist Ausgangspunkt für die Verbrauchsermittlung
                                          var StateDigizaehler= "modbus.0.inputRegisters.2801_Verbrauch";

                                          ! // Fortschreibung des digitalen Zählers aufgrund von StateDigizaehler
                                          var StateZaehlerLetzterDigi = path + 'Zaehlerstand.LetzterStandZaehlerDigital';
                                          ! // States für Manuelle Vorgaben - Aktuelle Zaehlerstände werden zwar errechnet können aber manuell korrigiert werden
                                          var StateZaehlerStartHT = path + 'ManuelleEingaben.JahresAnfangsZaehlerstandHT'; // abgelesener Stromzählerstand von der letzten Ablesung HT
                                          var StateZaehlerStartNT = path + 'ManuelleEingaben.JahresAnfangsZaehlerstandNT'; // abgelesener Stromzählerstand von der letzten Ablesung NT
                                          var StateAblesedatum = path + 'ManuelleEingaben.Ablesedatum'; // Ablesedatum - wichtig für Prognoserechnung
                                          var StateZaehlerAktHT = path + 'ManuelleEingaben.AktuellerZaehlerstandHT'; // Aktueller errechneter Zählerstand. Sollte mit dem realen Zähler übereinstimmgen HT
                                          var StateZaehlerAktNT = path + 'ManuelleEingaben.AktuellerZaehlerstandNT'; // Aktueller errechneter Zählerstand. Sollte mit dem realen Zähler übereinstimmgen NT
                                          var StatePreisAktuellHT = path + 'ManuelleEingaben.PreisAktuellHT'; // Preis pro kWh inkl Steuer vom Energieversorger HT
                                          var StatePreisAktuellNT = path + 'ManuelleEingaben.PreisAktuellNT'; // Preis pro kWh inkl Steuer vom Energieversorger NT
                                          var StateGrundPreisAktuell = path + 'ManuelleEingaben.GrundpreisAktuell'; // Verbrauchsunabhängiger Grundpreis vom Energieversorger
                                          var StateAbschlagAktuell = path + 'ManuelleEingaben.AbschlagAktuell'; // Momentaner monatlicher Abschlag zu zahlen an den Energieversorger

                                          // Verbrauchserte automatisch errechnet
                                          var StateVerbrauchHT = path + 'Verbrauch.JahresstromverbrauchHT';
                                          var StateVerbrauchNT = path + 'Verbrauch.JahresstromverbrauchNT';
                                          var StateVerbrauchGesamt = path + 'Verbrauch.JahresstromverbrauchGesamt';
                                          var StateVerbrauchMonatHT= path + 'Verbrauch.VerbrauchMonatHT';
                                          var StateVerbrauchMonatNT= path + 'Verbrauch.VerbrauchMonatNT';
                                          var StateVerbrauchMonatGesamt = path + 'Verbrauch.VerbrauchMonatGesamt';
                                          var StateLetzterVerbrauchkWh = path + 'Verbrauch.LetzterVerbrauchkWh';
                                          var StateVerbrauchkWhJason = path + 'Verbrauch.VerbrauchkWhJason';

                                          ! // Bewewertete Verbrauchswerte
                                          var StateVerbrauchBewertetHT = path + 'Kosten.JahresstromverbrauchBewertetHT';
                                          var StateVerbrauchBewertetNT = path + 'Kosten.JahresstromverbrauchBewertetNT';
                                          var StateVerbrauchBewertetGesamt =path + 'Kosten.JahresstromverbrauchBewertetGesamt';
                                          var StateVerbrauchMonatBew= path + 'Kosten.VerbrauchMonatBew';
                                          var StateUnterUeberDeckungBew= path + 'Kosten.UnterUeberDeckungBew';
                                          var StateVerbrauchEuroJason = path + 'Kosten.KostenEuroJason';
                                          ! // Aktueller Tarif HT oder NT
                                          var StateTarifAktuell = path + 'Tarif.TarifAktuell';
                                          ! // Prognosewerte werden automatisch berechnet
                                          var StatePrognoseVerbrauchJahrGesamt= path + 'Prognose.PrognoseVerbrauchJahrGesamt';
                                          var StatePrognosePreisNT = path + 'Prognose.PrognosePreisNT';
                                          var StatePrognosePreisHT = path + 'Prognose.PrognosePreisHT';
                                          var StatePrognoseKostenJahrGesamt = path + 'Prognose.PrognoseKostenJahrGesamt';
                                          var StatePrognoseJason = path + 'Prognose.PrognoseJason';
                                          ! //-----------------------------------------------------------------------------------------------------
                                          // Ende Einstellbereich
                                          //-----------------------------------------------------------------------------------------------------
                                          var fs = require('fs'); // enable write fuer externes log
                                          ! //-----------------------------------------------------------------------------------------------------
                                          // Erzeugen der nötigen Datenpunkte
                                          //-----------------------------------------------------------------------------------------------------
                                          createState(StateZaehlerStartHT, 0, {read: true, write: true, type: 'number', name: 'Jahresstartzaehlerstand Hochtarif kWh', desc: 'Der abgelesene Zaehlerstand zum Vorjahresende /Jahresanfang Hochtarif'});
                                          createState(StateZaehlerStartNT, 0, {read: true, write: true, type: 'number', name: 'Jahresstartzaehlerstand Niedrigtarif kWh', desc: 'Der abgelesene Zaehlerstand zum Vorjahresende /Jahresanfang Niedrigtarif'});
                                          createState(StateZaehlerAktHT, 0, {read: true, write: true, type: 'number', name: 'Aktueller Zaehlerstand Hochtarif kWh', desc: 'Der errechnete aktuelle Zaehlerstand zum Hochtarif'});
                                          createState(StateZaehlerAktNT, 0, {read: true, write: true, type: 'number', name: 'Aktueller Zaehlerstand Niedrigtarif kWh', desc: 'Der errechnete aktuelle Zaehlerstand zum Niedrigtarif'});
                                          createState(StateZaehlerLetzterDigi, 0, {read: true, write: true, type: 'number', name: 'Letzter Zaehlerstand Deltabildung kWh', desc: 'Das Delta wzischen letzter und aktueller Stand wird dem HT oder NT zugerechnet'});

                                          createState(StateVerbrauchHT, 0, {read: true, write: true, type: 'number', name: 'Jahresverbrauch Hochtarif kWh', desc: 'Der errechnete aktuelle Zaehlerstand zum Hochtarif'});
                                          createState(StateVerbrauchNT, 0, {read: true, write: true, type: 'number', name: 'Jahresverbrauch Niedrigtarif kWh', desc: 'Der errechnete aktuelle Zaehlerstand zum Niedrigtarif'});
                                          createState(StateVerbrauchBewertetNT, 0, {read: true, write: true, type: 'number', name: 'Jahresverbrauch bewerteter Niedrigtarif Euro', desc: 'Der errechnete aktuelle bewertete Zaehlerstand zum Hochtarif'});
                                          createState(StateVerbrauchBewertetHT, 0, {read: true, write: true, type: 'number', name: 'Jahresverbrauch bewerteter Hochtarif Euro', desc: 'Der errechnete aktuelle bewertete Zaehlerstand zum Hochtarif'});
                                          createState(StateVerbrauchGesamt, 0, {read: true, write: true, type: 'number', name: 'Jahresverbrauch Gesamt kWh', desc: 'Der errechnete aktuelle Zaehlerstand HT und NT addiert'});
                                          createState(StateVerbrauchBewertetGesamt, 0, {read: true, write: true, type: 'number', name: 'Jahresverbrauch bewerteter Verbrauch Euro', desc: 'Der errechnete aktuelle bewertete Verbrauch'});
                                          createState(StateVerbrauchkWhJason, "", {read: true, write: true, type: 'string', name: 'Verbrauchswerte kWh als Jason Tabelle', desc: 'Verbrauchswerte in kWh als Jason Tabelle'});
                                          createState(StateVerbrauchEuroJason, "", {read: true, write: true, type: 'string', name: 'Verbrauchswerte in Euro als Jason Tabelle', desc: 'Verbrauchswerte in Euro als Jason Tabelle'});
                                          createState(StateLetzterVerbrauchkWh, "", {read: true, write: true, type: 'number', name: 'Verbrauch kWh seit letzter Messung', desc: 'Verbrauchswert in kWh seit letzter Messung'});

                                          createState(StateTarifAktuell, 0, {read: true, write: true, type: 'string', name: 'Aktueller gueltiger Tarif', desc: 'Tarif der zur Zeit laeuft HT oder NT'});
                                          createState(StatePreisAktuellHT, 0, {read: true, write: true, type: 'number', name: 'Aktueller gueltiger Preis fuer Hochtarif Euro', desc: 'Preis der zur Zeit aktuell ist fuer Hochtarif'});
                                          createState(StatePreisAktuellNT, 0, {read: true, write: true, type: 'number', name: 'Aktueller gueltiger Preis fuer Niedrigtarif Euro', desc: 'Preis der zur Zeit aktuell ist fuer Niedrigtarif'});
                                          createState(StateGrundPreisAktuell, 0, {read: true, write: true, type: 'number', name: 'Aktueller gueltiger Grundpreis des Versorgers Euro', desc: 'Grundpreis der zur Zeit aktuell'});

                                          createState(StateAblesedatum, 0, {read: true, write: true, type: 'date', name: 'Ablesedatum', desc: 'Datum an dem abgelesen wurde'});
                                          createState(StateAbschlagAktuell, 0, {read: true, write: true, type: 'number', name: 'Aktueller monatlicher Abschlag Euro', desc: 'Monatliche Zahlung an den Versorger fuer Strom'});

                                          ! createState(StateVerbrauchMonatHT, 0, {read: true, write: true, type: 'number', name: 'Verbrauch auf Monat gerechnet fuer HT kWh', desc: 'Kalkulierter Verbrauch (Grundlage Istverbrauch) auf den Monat gerechnet fuer HT'});
                                          createState(StateVerbrauchMonatNT, 0, {read: true, write: true, type: 'number', name: 'Verbrauch auf Monat gerechnet fuer NT kWh', desc: 'Kalkulierter Verbrauch (Grundlage Istverbrauch) auf den Monat gerechnet fuer NT'});
                                          createState(StateVerbrauchMonatGesamt, 0, {read: true, write: true, type: 'number', name: 'Verbrauch auf Monat gerechnet Gesamt kWh', desc: 'Kalkulierter Verbrauch (Grundlage Istverbrauch) auf den Monat gerechnet Gesamt (HT und NT)'});
                                          createState(StatePrognoseVerbrauchJahrGesamt, 0, {read: true, write: true, type: 'number', name: 'Verbrauch auf Jahr gerechnet tariflos kWh', desc: 'Kalkulierter Verbrauch (Grundlage Istverbrauch) auf das Jahr gerechnet tariflos'});
                                          createState(StatePrognosePreisHT, 0, {read: true, write: true, type: 'number', name: 'Prognosepreis = Arbeitspreis plus Grundpreis basierend auf Prognoseverbrauch HT Euro', desc: 'Kalkulierter Preis inkl Grundpreis berechnet aufgrund des Prognoseverbrauchs HT'});
                                          createState(StatePrognosePreisNT, 0, {read: true, write: true, type: 'number', name: 'Prognosepreis = Arbeitspreis plus Grundpreis basierend auf Prognoseverbrauch NT Euro', desc: 'Kalkulierter Preis inkl Grundpreis berechnet aufgrund des Prognoseverbrauchs NT'});
                                          createState(StatePrognoseKostenJahrGesamt, 0, {read: true, write: true, type: 'number', name: 'Gesamte hochgerechnete Kosten für das laufende Jahr Euro', desc: 'Gesamtkosten hochgerechnet für das aktuelle Jahr'});
                                          createState(StateVerbrauchMonatBew, 0, {read: true, write: true, type: 'number', name: 'Verbrauch auf Monat gerechnet Euro', desc: 'Kalkulierter Verbrauch in Euro (Grundlage Istverbrauch) auf den Monat gerechnet'});
                                          createState(StateUnterUeberDeckungBew, 0, {read: true, write: true, type: 'number', name: 'Ueber od Unterdeckung auf Basis von Abschlagszahlung und Verbrauch Euro', desc: 'Ueber bzw Unterdeckung zwischen gezahltem Abschlag und hochgenrechneter Verbrauch'});
                                          createState(StatePrognoseJason, "", {read: true, write: true, type: 'string', name: 'Prognosewerte als Jason Tabelle', desc: 'Prognosewerte als Jason Tabelle'});
                                          ! //-----------------------------------------------------------------------------------------------------
                                          // Zeitplanung für updates
                                          //-----------------------------------------------------------------------------------------------------
                                          schedule(Zeitplan, Tarif_ermitteln); // alle 5 Minuten zur vollen Minute Verbrauch berechnen
                                          ! //-----------------------------------------------------------------------------------------------------
                                          // Zeitplanung für das Schreiben des Logs
                                          //-----------------------------------------------------------------------------------------------------
                                          schedule(logschedule, Log_schreiben); // alle 5 Minuten zur vollen Minute Verbrauch berechnen
                                          ! //-----------------------------------------------------------------------------------------------------
                                          // Ermittlung ob der HT oder NT angewendet werden muss
                                          //-----------------------------------------------------------------------------------------------------
                                          function Tarif_ermitteln () {
                                          ! var weekday = new Date().getDay; // Tag der Woche 1 = Monday
                                          var Thour = new Date().getHours();
                                          var TarifAktuell = getState(StateTarifAktuell).val;
                                          ! log("Stromzaehler schedule gestartet Aktueller Tarif ist "+ TarifAktuell ,"info");
                                          ! // Es ist ein Feiertag
                                          if( getState(StateFeiertagHeute).val === true) {
                                          log("Es ist Feiertag","info");
                                          if (TarifAktuell === "HT") {
                                          Verbrauch_berechnen ("HT");
                                          setState(StateTarifAktuell,"NT");
                                          TarifAktuell = "OK";
                                          }
                                          if (TarifAktuell === "NT") {
                                          Verbrauch_berechnen ("NT");
                                          TarifAktuell = "OK";
                                          }
                                          }
                                          // Es ist ein Sonntag
                                          if ( new Date().getDay() === 0 && TarifAktuell !== "OK") {
                                          if (TarifAktuell === "HT") {
                                          Verbrauch_berechnen ("HT");
                                          setState(StateTarifAktuell,"NT");
                                          TarifAktuell = "OK";
                                          }
                                          if (TarifAktuell === "NT") {
                                          Verbrauch_berechnen ("NT");
                                          TarifAktuell = "OK";
                                          }
                                          }

                                          // Es ist Niedrigtarif zwischen 20:00 und 06:00
                                          if( (Thour >= NTStart || Thour < NTEnde) && TarifAktuell !== "OK") { // groesser gleich 20:00 oder kleiner als 6:00
                                          if (TarifAktuell === "NT") {
                                          Verbrauch_berechnen ("NT");
                                          TarifAktuell = "OK";
                                          }
                                          if (TarifAktuell === "HT") {
                                          Verbrauch_berechnen ("HT");
                                          setState(StateTarifAktuell,"NT");
                                          TarifAktuell = "OK";
                                          }
                                          }

                                          // Es ist Hochtarif
                                          if( (Thour < NTStart && Thour >= NTEnde) && TarifAktuell !== "OK") { // kleiner als 20:00 und groesser gleich 6:00
                                          if (TarifAktuell === "NT") {
                                          Verbrauch_berechnen ("NT");
                                          setState(StateTarifAktuell,"HT");
                                          TarifAktuell = "OK";
                                          }
                                          if (TarifAktuell === "HT") {
                                          Verbrauch_berechnen ("HT");
                                          TarifAktuell = "OK";
                                          }
                                          }
                                          } // Ende Funktion

                                          ! //-----------------------------------------------------------------------------------------------------
                                          // Fortschreibung der Verbrauchswerte nach HT und NT getrennt
                                          //-----------------------------------------------------------------------------------------------------
                                          function Verbrauch_berechnen (AktTarif) {
                                          var Stromzaehlerstand = getState(StateDigizaehler).val; // abgesen aus Bcontrol
                                          var LetzterZaehlerstand = getState(StateZaehlerLetzterDigi).val ; // vorheriger Zaehlerstand
                                          var diffVerbrauch = (Stromzaehlerstand - LetzterZaehlerstand); //Differenzstand = verbrauchswert seit dem letzten Druchgang
                                          var StartHT = getState(StateZaehlerStartHT).val;
                                          var StartNT = getState(StateZaehlerStartNT).val;
                                          var zaehlerstand = 0;
                                          var PreisHT = getState(StatePreisAktuellHT).val;
                                          var PreisNT = getState(StatePreisAktuellNT).val;
                                          var VerbrauchHT = getState(StateVerbrauchHT).val;
                                          var VerbrauchNT = getState(StateVerbrauchNT).val;
                                          var VerbrauchBewGesamt = 0;
                                          var LetzterVerbrauch = 0;
                                          var PrognoseVerbrauchGesamt = getState(StatePreisAktuellHT).val;
                                          var PrognoseKostenGesamt = 0;
                                          var ProngoseKostenGesMonat= 0;
                                          var GrundPreisAktuell = getState(StateGrundPreisAktuell).val;
                                          var GrundPreisPrognose = 0;
                                          var UeberUnterDeckungGes = 0;
                                          var UeberUnterDeckungHT = 0;
                                          var UeberUnterDeckungNT = 0;
                                          var JahresUeberUnterdeckung = 0;
                                          var MonatsverbrauchHT = getState(StateVerbrauchMonatHT);
                                          var MonatsverbrauchNT = getState(StateVerbrauchMonatNT);
                                          var JahresverbrauchHTBew = 0;
                                          var JahresverbrauchNTBew = 0;
                                          var MonatsverbrauchGesamtBew = 0;
                                          var JahresverbrauchGesBew = 0;
                                          var JahresverbrauchGes = 0;
                                          var MonatsverbrauchGesamt = 0;
                                          var JasonString = "initial";
                                          ! // fuer die Prognose anzahl Tage seit der Ablesung errechnen
                                          var Ablesedatum = getState(StateAblesedatum).val;
                                          // var TimeSinceMillSec = new Date(Ablesedatum.substr(6, 4),Ablesedatum.substr(3, 2)-1,Ablesedatum.substr(0, 2)).getTime(); // Millisekunden aus dem Ablesedatum ermitteln
                                          var TimeSinceMillSec = new Date(Ablesedatum).getTime(); // Millisekunden seit dem Ablesen
                                          var TimeSinceLogging = new Date().getTime() - TimeSinceMillSec; // Millisekunden seit dem Ablesen
                                          var AnzTageSince = TimeSinceLogging / 1000 / 60 / 60 / 24; // Anzahl Tage seit dem Ablesen
                                          log("Anzahl tage seit letzter Ablesung " +AnzTageSince,"info" );
                                          ! //jetzt die Zaehlerstanbsberechnungen, Kosten und Prognose rechnen und speichern
                                          ! if (AktTarif === "HT") {
                                          // Differenzverbrauch seit der letzten Messung errechnen
                                          zaehlerstand = getState(StateZaehlerAktHT).val; // letzter aktueller Zaehlerstand
                                          zaehlerstand = zaehlerstand + diffVerbrauch; // neuer aktueller Zaehlerstand gerundet
                                          setState(StateZaehlerAktHT,round(zaehlerstand,RundungZaehler)); // speichern
                                          ! // Neuen Verbrauchswert in kWh errechnen und speichern
                                          VerbrauchHT = round(zaehlerstand - StartHT,RundungZaehler); // Verbrauch ist jetzt aktueller Zaehlerstand minus Startzaehlerstand log("ermittelter neuer Zaehlerstand " + VerbrauchHT,"info");
                                          setState(StateVerbrauchHT, VerbrauchHT); // speichern
                                          !
                                          log("Stromverbrauchsrechnung fuer HT abgeschlossen","info");
                                          ! } // ende endif HT
                                          ! if (AktTarif === "NT") {
                                          ! // Differenzverbrauch seit der letzten Messung errechnen
                                          zaehlerstand = getState(StateZaehlerAktNT).val; // letzter aktueller Zaehlerstand
                                          zaehlerstand = zaehlerstand + diffVerbrauch; // neuer aktueller Zaehlerstand gerundet
                                          setState(StateZaehlerAktNT,round(zaehlerstand,RundungZaehler)); // speichern
                                          ! // Neuen Verbrauchswert in kWh errechnen und speichern
                                          VerbrauchNT = round(zaehlerstand - StartNT,RundungZaehler); // Verbrauch ist jetzt aktueller Zaehlerstand minus Startzaehlerstand
                                          setState(StateVerbrauchNT, VerbrauchNT); // speichern
                                          ! log("Stromverbrauchsrechnung fuer NT abgeschlossen","info");
                                          } // ende endif NT
                                          ! // NT HT Unabhängige Routinen
                                          ! // Den zuletzt ausgelesenen BControl Zaehlerstand abspeichern
                                          setState(StateZaehlerLetzterDigi,Stromzaehlerstand); // den aktuellen digi stand speichern
                                          ! // Neuen GesamtVerbrauchswert in kWh errechnen und speichern
                                          JahresverbrauchGes = VerbrauchHT + VerbrauchNT; // neuer Jahresverbrauch
                                          // LetzterVerbrauch = JahresverbrauchGes - getState(StateVerbrauchGesamt).val; // neuer letzter Verbrauch
                                          setState(StateLetzterVerbrauchkWh, diffVerbrauch);
                                          setState(StateVerbrauchGesamt, JahresverbrauchGes);
                                          ! // Monatsverbrauch errechnen
                                          MonatsverbrauchHT = round(VerbrauchHT / AnzTageSince * 30,RundungZaehler);
                                          setState(StateVerbrauchMonatHT, MonatsverbrauchHT);
                                          MonatsverbrauchNT = round(VerbrauchNT / AnzTageSince * 30,RundungZaehler);
                                          setState(StateVerbrauchMonatNT, MonatsverbrauchNT); // Verbrauch durch Anzahl vergangener Tage mal 30
                                          MonatsverbrauchGesamt = round((VerbrauchNT / AnzTageSince * 30) + (VerbrauchHT / AnzTageSince * 30),0);
                                          setState(StateVerbrauchMonatGesamt, MonatsverbrauchGesamt);
                                          ! // Prognoseverbrauch in kWh fuer das Gesamtjahr
                                          PrognoseVerbrauchGesamt = round(( VerbrauchNT + VerbrauchHT) / AnzTageSince *30 * 12,0) ;
                                          setState ( StatePrognoseVerbrauchJahrGesamt, round(PrognoseVerbrauchGesamt,0));
                                          GrundPreisPrognose = GrundPreisAktuell / PrognoseVerbrauchGesamt;
                                          PreisNT = round(PreisNT + GrundPreisPrognose,6);
                                          setState ( StatePrognosePreisNT, PreisNT);
                                          PreisHT = round(PreisHT + GrundPreisPrognose,6);
                                          setState ( StatePrognosePreisHT, PreisHT);
                                          PrognoseKostenGesamt = round(( VerbrauchHT * PreisHT / AnzTageSince *30 * 12 ) + ( VerbrauchNT * PreisNT / AnzTageSince *30 * 12),2);
                                          setState ( StatePrognoseKostenJahrGesamt, PrognoseKostenGesamt);
                                          ProngoseKostenGesMonat = round(PrognoseKostenGesamt / 12,2);
                                          ! // Bewertung des neuen Verbrauchswert mit Prognosepreis
                                          JahresverbrauchNTBew = round(VerbrauchNT * PreisNT,2);
                                          setState(StateVerbrauchBewertetNT, JahresverbrauchNTBew); // bewerteter Jahreszaehlerstand errechnen
                                          JahresverbrauchHTBew = round(VerbrauchHT * PreisHT,2);
                                          setState(StateVerbrauchBewertetHT, JahresverbrauchHTBew); // bewerteter Jahreszaehlerstand errechnen
                                          JahresverbrauchHTBew = round(VerbrauchHT * PreisHT,2);
                                          VerbrauchBewGesamt = round((VerbrauchNT * PreisHT) + (VerbrauchHT * PreisHT),2);
                                          setState(StateVerbrauchBewertetGesamt, VerbrauchBewGesamt);
                                          MonatsverbrauchGesamtBew = round(PrognoseKostenGesamt/12,2);
                                          setState (StateVerbrauchMonatBew, MonatsverbrauchGesamtBew);

                                          ! // Ermittlung bewertete Ueber/Unterdeckung HT und NT
                                          UeberUnterDeckungHT = VerbrauchHT / AnzTageSince * 30 * PreisHT;
                                          UeberUnterDeckungNT = VerbrauchNT / AnzTageSince * 30 * PreisNT;
                                          JahresUeberUnterdeckung = round(((getState(StateAbschlagAktuell).val - UeberUnterDeckungHT - UeberUnterDeckungNT)*12),2);
                                          setState(StateUnterUeberDeckungBew, JahresUeberUnterdeckung);
                                          ! // jetzt Jason füllen fuer Verbrauch kWh
                                          // Jason (Headline1, ZeilenText, Headline2, Wert, DescriptionTxt, DescriptionValue, String) {
                                          JasonString = "initial";
                                          JasonString = JasonCreate ("Verbraeuche kWh", "Durchn Monatsverbrauch kWh HT+NT" , "Werte", MonatsverbrauchGesamt , "Durchn. Monatatsverbrauch" , "WertMonatsverbrauch kWh" , JasonString, false);
                                          JasonString = JasonString + JasonCreate ("Verbraeuche kWh", "Durchn Monatsverbrauch kWh HT" , "Werte", round(MonatsverbrauchHT,0) , "Durchn. Monatatsverbrauch HT " , "WertMonatsverbrauch HT kWh" , JasonString, false);
                                          JasonString = JasonString + JasonCreate ("Verbraeuche kWh", "Durchn Monatsverbrauch kWh NT" , "Werte", round(MonatsverbrauchNT,0) , "Durchn. Monatatsverbrauch NT " , "WertMonatsverbrauch NT kWh" , JasonString, false);
                                          JasonString = JasonString + JasonCreate ("Verbraeuche kWh", "Jahresstromverbrauch kWh HT+NT" , "Werte", round(JahresverbrauchGes,0) , "Gesamt Jahresstromverbrauch " , "WertJahresstromverbrauch kWh" , JasonString, false);
                                          JasonString = JasonString + JasonCreate ("Verbraeuche kWh", "Jahresstromverbrauch kWh HT" , "Werte", round(VerbrauchHT,0) , "Jahresstromverbrauch HT " , "Jahresstromverbrauch HT kWh" , JasonString, false);
                                          JasonString = JasonString + JasonCreate ("Verbraeuche kWh", "Jahresstromverbrauch kWh NT" , "Werte", round(VerbrauchNT,0) , "Jahresstromverbrauch NT " , "Jahresstromverbrauch NT kWh" , JasonString, true);
                                          setState(StateVerbrauchkWhJason, JasonString);
                                          ! // jetzt Jason füllen fuer Verbrauch Euro
                                          JasonString = "initial";
                                          JasonString = JasonCreate ("Verbraeuche Euro", "Jahresverbrauch Euro HT+NT" , "Werte", VerbrauchBewGesamt , "Jahresverbrauch in Euro HT + NT" , "WertJahresverbrauch Euro" , JasonString, false);
                                          JasonString = JasonString + JasonCreate ("Verbraeuche Euro", "Jahresverbrauch Euro HT" , "Werte", JahresverbrauchHTBew , "Jahresverbrauch HT Euro" , "WertJahresverbrauch HT Euro" , JasonString, false);
                                          JasonString = JasonString + JasonCreate ("Verbraeuche Euro", "Jahresverbrauch Euro NT" , "Werte", JahresverbrauchNTBew , "Jahresverbrauch NT Euro" , "WertJahresverbrauch NT Euro" , JasonString, false);
                                          JasonString = JasonString + JasonCreate ("Verbraeuche Euro", "Durchn Monatsverbrauch HT+NT" , "Werte", MonatsverbrauchGesamtBew , "Durchn. Monatatsverbrauch HT+NT Euro" , "WertMonatsverbrauch HT+NT Euro" , JasonString, true);
                                          setState(StateVerbrauchEuroJason, JasonString);
                                          ! // jetzt Jason füllen fuer Prognose
                                          JasonString = "initial";
                                          JasonString = JasonCreate ("Prognose", "Jahresverbrauch kWh HT+NT" , "Werte" , PrognoseVerbrauchGesamt , "Prognoseverbrauch kWh HT+NT" , "PrognoseWertJahresverbrauch Euro" , JasonString, false);
                                          JasonString = JasonString + JasonCreate ("Prognose", "Jahresverbrauch Euro HT+NT" , "Werte" , PrognoseKostenGesamt , "Prognose Verbrauch/Monat Eurot HT+NT" , "WertMPrognosekostenMonat HT+NT Euro" , JasonString, false);
                                          JasonString = JasonString + JasonCreate ("Prognose", "Verbrauch/Monat Euro HT+NT" , "Werte" , ProngoseKostenGesMonat , "Prognose Verbrauch/Monat Euro Eurot HT+NT" , "WertMPrognosekostenJahr HT+NT Euro" , JasonString, false);
                                          JasonString = JasonString + JasonCreate ("Prognose", "Prognosepreis Euro HT" , "Werte" , PreisHT , "Prognosepreis HT Euro" , "WertPrognosepreis HT Euro" , JasonString, false);
                                          JasonString = JasonString + JasonCreate ("Prognose", "Prognosepreis Euro NT" , "Werte" , PreisNT , "Jahresverbrauch NT Euro" , "WertJahresverbrauch NT Euro" , JasonString, false);
                                          JasonString = JasonString + JasonCreate ("Prognose", "Jahres-Abschlagsdeckung Euro", "Werte" , JahresUeberUnterdeckung , "Prognose Ueber-Unterdeckung" , "WertMPrognoseUeber-Unterdeckung HT+NT Euro" , JasonString, true);
                                          setState(StatePrognoseJason, JasonString);
                                          ! } // Ende Funktion
                                          ! //-----------------------------------------------------------------------------------------------------
                                          // Erstellung von jason strings zur Tabellendarstellung
                                          //-----------------------------------------------------------------------------------------------------
                                          function JasonCreate (Headline1, ZeilenText, Headline2, Wert, DescriptionTxt, DescriptionValue, string,close) {
                                          ! Headline1 = '{"' + Headline1+ '":';
                                          ZeilenText = '"' + ZeilenText + '",';
                                          Headline2 = '"' + Headline2+ '":';
                                          DescriptionTxt = '"' + DescriptionTxt + '":';
                                          DescriptionValue = '"' + DescriptionValue + '"}';
                                          ! if (string === "initial") {
                                          string = "[";
                                          } else {
                                          string /;
                                          }
                                          ! string = string + Headline1 + ZeilenText + Headline2 + Wert + "," + DescriptionTxt + DescriptionValue;
                                          ! if (close === true) {
                                          string = string + "]";
                                          } else {
                                          string = string + ",";
                                          }

                                          return string;
                                          

                                          } // Ende Funktion

                                          ! //-----------------------------------------------------------------------------------------------------
                                          // Funktion zur Erzeugung von 2 oder 3 führenden Nullen für das Datum Format
                                          //-----------------------------------------------------------------------------------------------------
                                          function addZero(i) {
                                          if (i < 10) {
                                          j = "00" + i;
                                          i = "0" + i;
                                          }
                                          if (i > 9 && i < 100) {
                                          j = "0" + i;
                                          }
                                          return {
                                          'zero2' : i,
                                          'zero3' : j
                                          };
                                          } // Ende Funktion
                                          ! //-----------------------------------------------------------------------------------------------------
                                          // Funktion zur Umwandlung in Zahlen mit Komma statt Punkt (excel)
                                          //-----------------------------------------------------------------------------------------------------
                                          ! function TauschePunktKomma(x) {
                                          var TextAusgabe = x.toString();
                                          TextAusgabe = TextAusgabe .replace(".",",");
                                          return TextAusgabe ;
                                          }
                                          ! //-----------------------------------------------------------------------------------------------------
                                          // Rundungsfunktion
                                          //-----------------------------------------------------------------------------------------------------
                                          function round(value, stellen) {
                                          ! value = parseFloat(value);
                                          if (!value) {return 0; }
                                          dez = parseInt(stellen,10);
                                          if (!stellen) { stellen=0; }
                                          var umrechnungsfaktor = Math.pow(10,stellen);
                                          return Math.round(value * umrechnungsfaktor) / umrechnungsfaktor;
                                          ! } // end function
                                          ! //-----------------------------------------------------------------------------------------------------
                                          // Funktion schreibt einen Logeintrag in das Filesystem und auch in das interne Log-System
                                          //-----------------------------------------------------------------------------------------------------
                                          function Log_schreiben() {
                                          // Zerlege Datum und Zeit in Variable
                                          var now = new Date(); // store current date and time
                                          var year = now.getFullYear();
                                          var month = addZero(now.getMonth()+1).zero2;
                                          var day = addZero(now.getDate()).zero2;
                                          var Thour = addZero(now.getHours()).zero2;
                                          var Tmin = addZero(now.getMinutes()).zero2;
                                          var Tsec = addZero(now.getSeconds()).zero2;
                                          var logdate = day + '.' + month + '.' + year;
                                          var logtime = Thour + ':' + Tmin + ':' + Tsec;
                                          var headerline = " ";
                                          var string = " ";
                                          ! if (logging === true) {
                                          string = TauschePunktKomma( getState(StateZaehlerAktHT).val) + ";"; // Aktueller Zaehlerstand NT
                                          string = string + TauschePunktKomma( getState(StateZaehlerAktNT).val) + ";"; // Aktueller Zaehlerstand HT
                                          string = string + TauschePunktKomma( getState(StateVerbrauchHT).val) + ";"; // Verbrauch kWh NT
                                          string = string + TauschePunktKomma( getState(StateVerbrauchNT).val) + ";"; // Verbrauch kWh HT
                                          string = string + TauschePunktKomma( getState(StateVerbrauchGesamt).val) + ";"; // Gesamtverbrauch
                                          string = string + TauschePunktKomma( getState(StatePreisAktuellHT).val) +";"; // Preis kWh HT
                                          string = string + TauschePunktKomma( getState(StatePreisAktuellNT).val) +";"; // Preis kWh NT
                                          string = string + TauschePunktKomma( getState(StateVerbrauchBewertetHT).val) +";";
                                          string = string + TauschePunktKomma( getState(StateVerbrauchBewertetNT).val) +";";
                                          string = string + TauschePunktKomma( getState(StateVerbrauchBewertetGesamt).val) +";";
                                          string = string + TauschePunktKomma( getState(StatePrognoseVerbrauchJahrGesamt).val) +";"; // Prognostizierter jahresverbrauch
                                          string = string + TauschePunktKomma( getState(StatePrognoseKostenJahrGesamt).val) +";"; // Prognostizierter jahreskosten

                                           // logging ist aktiviert
                                           if (fs.existsSync(LogPath)) {
                                              fs.appendFileSync(LogPath, logdate+" ;"+logtime+" ;"+string + "\n");            // Füge Satz in Datei ein
                                           } else {
                                              log("Stromverbrauchs-Logfile nicht gefunden - wird angelegt", "info");
                                              headerLine= "Datum;Uhrzeit;Zaehlerstand NT;Zaehlerstand HT;Verbr kWh HT;Verbr kWh NT;Gesamtverbrauch;Preis kWh HT;Preis kWh NT;Verbrauch Euro HT;Verbrauch Euro NT; Verbrauch Euro Gesamt; Progn.Jahresverbrauch; Progn.Jahreskosten";
                                              fs.appendFileSync(LogPath, headerLine + "\n");       // Füge Satz in Datei ein
                                              fs.appendFileSync(LogPath, logdate+" ;"+logtime+" ;"+string + "\n");            // Füge Satz in Datei ein   
                                          }  // Ende check on logflag
                                          log("Log geschrieben in File " + LogPath,"info");
                                          

                                          } // logging aktiviert fuer time kumulation

                                          ! } // Ende Funktion

                                          1 Reply Last reply Reply Quote 0
                                          • L
                                            looxer01 last edited by

                                            ….da fällt mir ein. Du kannst bei der History Einstellung Nullen ignorieren.

                                            Das sollte dein Problem erstmal lösen.

                                            Nullen werden ja eigentlich gar nicht erwartet. (Vorausgesetzt, dass deine Messintervalle nicht zu klein sind)

                                            vG Looxer

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

                                            Support us

                                            ioBroker
                                            Community Adapters
                                            Donate

                                            685
                                            Online

                                            31.7k
                                            Users

                                            79.6k
                                            Topics

                                            1.3m
                                            Posts

                                            5
                                            30
                                            4884
                                            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