// 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 = "*/30 * * * *" ; // 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= "b-control-em.0.Teridian_Total_Kanal.Zählerstand_Positive_Wirkarbeit_tariflos"; // 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