// Pelletverbraeuche und Heizungsstatistik // Autor Looxer01 25.12.2016 // //----------------------------------------------------------------------------------------------------- // Einstellbereich //----------------------------------------------------------------------------------------------------- //Logging var logging = false; // logging enabled var logschedule = "50 23 * * *" ; // Cron - Zeitpunkt an dem das logfile geschrieben wird z.B. 23:50 var LogPath = "/opt/iobroker/log/Pelletverbrauchslog.csv"; // Pfad und Dateiname des externen Logs // Schedule um den Jahreswechsel festzustellen var Jahreswechsel = "15 0 * * *" ; // Cron - Zeitpunkt an dem der Jahreswechsel festgestellt wird // Schedule Berechnung kumulierter Tagesverbrauch und Nullung var ScheduleVerbrauchKumDay = "58 23 * * *" ; // Cron - Zeitpunkt an dem der Jahreswechsel festgestellt wird // Allgemeine Parameter var RundungKG = 2; // Rundung fuer den Verbrauch var path = 'javascript.0.Heizung.'; // Pfad für create states // Hier ist der State für den Pelletvebrauch der durch den BSZ ermittelt wird var StatePelletBestandAktuell = "javascript.0.BSZ.Counter.Pellet.TIME.PelletRest"; // var StatePelletBestandAktuell = "javascript.0.Heizung.Test_Pelletbestand"; // Fortschreibung des Bestandes aufgrund des BSZ var StateLetzterPelletbestand = path + 'Bestand.LetzterPelletBestand'; var StateWertPelletbestand = path + 'Bestand.WertPelletBestand'; var StateBestandPelletJason = path + 'Bestand.PelletBestandJason'; // States für Manuelle Vorgaben - Aktuelle Zaehlerstände werden zwar errechnet können aber manuell korrigiert werden var StateMaxLagerbestand = path + 'ManuelleEingaben.MaxLagerbestand'; // var StatePelletPreis = path + 'ManuelleEingaben.PelletPreis'; // Aktueller Lagerbestand Pelletbestand var StatePelletBestandKorrektur = path + 'ManuelleEingaben.PelletBestandKorrektur'; // Verbrauchserte automatisch errechnet var StateVerbrauchPelletJahr = path + 'Verbrauch.JahresPelletverbrauch'; var StateVerbrauchPelletMonat = path + 'Verbrauch.MonatPelletverbrauch'; var StateLetzterVerbrauchPellet = path + 'Verbrauch.LetzterPelletverbrauch'; var StateVerbrauchPelletJason = path + 'Verbrauch.VerbrauchPelletJason'; // Bewewertete Verbrauchswerte var StateVerbrauchPelletBewJahr = path + 'Kosten.VerbrauchPelletBewJahr'; var StateVerbrauchPelletBewMonat = path + 'Kosten.VerbrauchPelletBewMonat'; var StateVerbrauchPelletBewJason = path + 'Kosten.VerbrauchPelletBewJason'; // Prognosewerte werden automatisch berechnet var StatePrognosePelletVerbrauchJahr = path + 'Prognose.PrognosePelletVerbrauchJahr'; var StatePrognosePelletVerbrauchMonat = path + 'Prognose.PrognosePelletVerbrauchMonat'; var StatePrognosePelletVerbrauchJahrBew = path + 'Prognose.PrognosePelletVerbrauchJahrBew'; var StatePrognosePelletVerbrauchMonatBew = path + 'Prognose.PrognosePelletVerbrauchMonatBew'; var StatePrognosePelletJason = path + 'Prognose.PrognosePelletJason'; // Pellet Tageswerte var StateSchneckenzeitDay = "javascript.0.BSZ.Counter.Pellet.TIME.Schneckenzeit.1-DAY"; var StateVerbrauchDayKum = path + 'Verbrauch.TagesPelletverbrauch'; var VerbrauchKumDayFactor = 8 // 8 kg gehen per Minute vom Silo in den Pelletzwischenspeicher // History pfad um die Prognose durchzuführen var Historypath = "javascript.0.BSZ.Counter.Pellet.TIME.PelletKG.HISTORY.3-MONTH."; // current Monat pfad für die Prognose var CurrMonatPath = "javascript.0.BSZ.Counter.Pellet.TIME.PelletKG.3-MONTH"; //----------------------------------------------------------------------------------------------------- // Ende Einstellbereich //----------------------------------------------------------------------------------------------------- var fs = require('fs'); // enable write fuer externes log var FlagBestandKorrektur = false; //----------------------------------------------------------------------------------------------------- // Erzeugen der nötigen Datenpunkte //----------------------------------------------------------------------------------------------------- createState(StateLetzterPelletbestand, 0, {read: true, write: true, type: 'number', name: 'Letzter Pelletbestand zur Differenzberechnung KG', desc: 'Der Differenzverbrauch wird für die grafische Darstellung benötigt'}); createState(StateWertPelletbestand, 0, {read: true, write: true, type: 'number', name: 'Pelletbestand bewertet Euro', desc: 'Bewerteter Pelletbestand zum aktuellen Preis'}); createState(StateBestandPelletJason, "", {read: true, write: true, type: 'string', name: 'Bestandswerte als Jason Tabelle', desc: 'Bestandwerte als Jason Tabelle'}); createState(StateMaxLagerbestand, 0, {read: true, write: true, type: 'number', name: 'Maxmaler Lagerbestand im Pelletlager KG', desc: 'Der maximale Lagerbestand ist der Auffüllstand bei Neulieferung von Pellets'}); createState(StatePelletBestandKorrektur, 0, {read: true, write: true, type: 'number', name: 'Korrektur Pelletbestand oder Tanken', desc: 'Korrektur des Pelletbestands ohne Aenderung von Verbrauchs/Prognosewerten'}); createState(StatePelletPreis, 0, {read: true, write: true, type: 'number', name: 'Aktueller Pelletpreis in Euro/Tonne', desc: 'Der aktuelle Pelletpreis wird für die Kostenberechnung genutzt'}); createState(StateVerbrauchPelletJahr, 0, {read: true, write: true, type: 'number', name: 'Jahresverbrauch Pellets KG', desc: 'Der errechnete aktuelle Pelletverbrauch bis zum akteullen Datum'}); createState(StateVerbrauchPelletMonat, 0, {read: true, write: true, type: 'number', name: 'Durchschnittlicher Pelletverbrauch/Monat', desc: 'Der errechnete aktuelle durschn.Monatsverbrauch in KG'}); createState(StateLetzterVerbrauchPellet, 0, {read: true, write: true, type: 'number', name: 'Letzter Pelletverbrauch in KG', desc: 'Letzter Pelletverbrauch wir benoetigt fuer History in KG'}); createState(StateVerbrauchDayKum, 0, {read: true, write: true, type: 'number', name: 'Pellet Tagesverbrauch kumuliert', desc: 'Pellet Tagesverbrauch kumuliert in KG'}); createState(StateVerbrauchPelletJason, "", {read: true, write: true, type: 'string', name: 'Verbrauchswerte KG als Jason Tabelle', desc: 'Verbrauchswerte in KG als Jason Tabelle'}); createState(StateVerbrauchPelletBewJahr, "", {read: true, write: true, type: 'number', name: 'Jahresverbrauch Pellets Euro', desc: 'Jahresverbrauch Pellets Euro bis zum aktuellen Datum'}); createState(StateVerbrauchPelletBewMonat, "", {read: true, write: true, type: 'number', name: 'Durchschnittlicher Pelletverbrauch/Monat Euro', desc: 'Durchschnittlicher aktueller Pelletverbrauch/Monat'}); createState(StateVerbrauchPelletBewJason, "", {read: true, write: true, type: 'string', name: 'Pelletverbrauchswerte in Euro als Jason Tabelle', desc: 'Pelletverbrauchswerte in Euro als Jason Tabelle'}); createState(StatePrognosePelletVerbrauchJahr, 0, {read: true, write: true, type: 'number', name: 'Prognosejahresverbrauch in KG', desc: 'Kalkulierter Verbrauch (Grundlage Istverbrauch) auf das Jahr gerechnet KG'}); createState(StatePrognosePelletVerbrauchMonat, 0, {read: true, write: true, type: 'number', name: 'Prognosemonatsverbrauch in KG', desc: 'Kalkulierter Verbrauch (Grundlage Istverbrauch) auf den Monat gerechnet KG'}); createState(StatePrognosePelletVerbrauchJahrBew, 0, {read: true, write: true, type: 'number', name: 'Prognosejahresverbrauch in Euro', desc: 'Kalkulierter Verbrauch (Grundlage Istverbrauch) auf das Jahr gerechnet Euro'}); createState(StatePrognosePelletVerbrauchMonatBew, 0, {read: true, write: true, type: 'number', name: 'Prognosemonatsverbrauch in Euro', desc: 'Kalkulierter Verbrauch (Grundlage Istverbrauch) auf den Monat gerechnet Euro'}); createState(StatePrognosePelletJason, "", {read: true, write: true, type: 'string', name: 'Pellet Prognosewerte als Jason Tabelle', desc: 'Pellet Prognosewerte als Jason Tabelle'}); //----------------------------------------------------------------------------------------------------- // Bestand wurde aus dem BSZ aktualisiert //----------------------------------------------------------------------------------------------------- on({id: StatePelletBestandAktuell, valNe: true }, function(obj) { // wenn der Pelletbestand fortgeschrieben wird if (FlagBestandKorrektur === true) { // es wurde eine Bestandskorrektur eingegeben - Keine Verbrauchsberechnung FlagBestandKorrektur = false; log("Bestandskorrektur erkannt","info"); } else { Verbrauchsrechnung(); //Auslösen der Verbrauchsrechnung log("Pelletverbrauchsrechnung gestartet","info"); } // ende endif else }); // Ende ON ID //----------------------------------------------------------------------------------------------------- // Bestandskorrektur darf keinen Verbrauch ausloesen //----------------------------------------------------------------------------------------------------- on({id: StatePelletBestandKorrektur, valNe: true }, function(obj) { // ende on id // wenn der Pelletbestand fortgeschrieben wird var PelletBestandKorrektur = getState(StatePelletBestandKorrektur).val; FlagBestandKorrektur = true; log("Bestandkorrektur eingegeben " + PelletBestandKorrektur,"info"); // den letzten Pelletbestand vor diesem abspeichern setState(StateLetzterPelletbestand, PelletBestandKorrektur); // aktuellen Pelletbestand setzen setState(StatePelletBestandAktuell, PelletBestandKorrektur); }); // Ende ON ID //----------------------------------------------------------------------------------------------------- // Zeitplanung für das Schreiben des Logs //----------------------------------------------------------------------------------------------------- schedule(logschedule, Log_schreiben); // alle 5 Minuten zur vollen Minute Verbrauch berechnen //----------------------------------------------------------------------------------------------------- // Zeitplanung für den Jahreswechsel //----------------------------------------------------------------------------------------------------- schedule(Jahreswechsel, function() { // Jahresechsel feststellen var now = new Date(); // store current date and time var month = addZero(now.getMonth()+1).zero2; var day = addZero(now.getDate()).zero2; if (month === "01" && day === "01") { // es ist der 01.01. setState(StateVerbrauchPelletJahr, 0); // Verbrauch zurücksetzen log("Jahrswechsel initiert - Pellet-Jahresverbrauch zurückgesetzt","info"); } }); // end schedule //----------------------------------------------------------------------------------------------------- // Zeitplanung für Berechnung des kumulierten Tagesverberbrauchs anhand der Schneckenlaufzeit von der CCU //----------------------------------------------------------------------------------------------------- schedule(ScheduleVerbrauchKumDay, function() { // Kurzvor Mitternach ermittlung des Tagesverbrauchs var TimeKumDay = getState(StateSchneckenzeitDay).val; var Tagesverbrauch = round(TimeKumDay / 60 / 1000 * VerbrauchKumDayFactor,2); // umrechnung millisekunden in KG bei 8KG pro minute, gerundet auf 2 Stellen setState(StateVerbrauchDayKum, Tagesverbrauch); // Schreiben des Tagesverbrauchs }); // end schedule //----------------------------------------------------------------------------------------------------- // Erstellung von jason strings zur Tabellendarstellung //----------------------------------------------------------------------------------------------------- function Verbrauchsrechnung () { var PelletBestandAktuell = getState(StatePelletBestandAktuell).val; // abgesen aus BSZ var PelletBestandLetzter = getState(StateLetzterPelletbestand).val ; // vorheriger Pelletbestand var PelletBestandBew = 0 ; // Bewerteter Pelletbestand var diffVerbrauch = (PelletBestandLetzter - PelletBestandAktuell); //Differenzstand = verbrauchswert seit dem letzten Druchgang var PreisPellet = getState(StatePelletPreis).val; var PelletVerbrauchJahrKG = getState(StateVerbrauchPelletJahr).val; var PelletVerbrauchMonatKG = getState(StateVerbrauchPelletMonat).val; var PelletVerbrauchJahrBew = 0; var PelletVerbrauchMonatBew = 0; var PrognosePelletVerbrauchKGMonat = 0; var PrognosePelletVerbrauchJahrKG = 0; var PrognosePelletVerbrauchMonatKG = 0; var PrognosePelletVerbrauchJahrEuro = 0; var PrognosePelletVerbrauchMonatEuro = 0; var JasonString = "initial"; // fuer die Prognose anzahl Tage seit der Ablesung errechnen var MessungStartDatum = new Date().getFullYear()+"-01-01"; // von Berechnung = 01.01. des aktuellen jahres // var TimeSinceMillSec = new Date(MessungStartDatum.substr(6, 4),MessungStartDatum.substr(3, 2)-1,MessungStartDatum.substr(0, 2)).getTime(); // Millisekunden aus dem Ablesedatum ermitteln var TimeSinceMillSec = new Date(MessungStartDatum).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 " + MessungStartDatum + " " + AnzTageSince,"info" ); //jetzt die Pelletverbrauchsechnungen, Kosten und Prognose rechnen und speichern // den letzten Pelletbestand vor diesem abspeichern setState(StateLetzterPelletbestand,PelletBestandAktuell); // speichern PelletBestandBew = round(PelletBestandAktuell * PreisPellet / 1000,0); setState(StateWertPelletbestand,PelletBestandBew); // Bewerteter Pelletbestand // den letzten Verbrauch speichern - darauf kann History gebildet werden setState(StateLetzterVerbrauchPellet,diffVerbrauch ); // speichern // Neuen JahresVerbrauchswert in KG und Euro errechnen und speichern PelletVerbrauchJahrKG = PelletVerbrauchJahrKG + diffVerbrauch; // setState(StateVerbrauchPelletJahr, PelletVerbrauchJahrKG); // speichern PelletVerbrauchJahrBew = round(PelletVerbrauchJahrKG * PreisPellet / 1000,2); setState(StateVerbrauchPelletBewJahr, PelletVerbrauchJahrBew); // speichern // Monatsverbrauch errechnen PelletVerbrauchMonatKG = round(PelletVerbrauchJahrKG / AnzTageSince * 30,0); setState(StateVerbrauchPelletMonat, PelletVerbrauchMonatKG); PelletVerbrauchMonatBew = round(PelletVerbrauchMonatKG * PreisPellet / 1000,2); setState(StateVerbrauchPelletBewMonat, PelletVerbrauchMonatBew); // speichern // Prognosewerte errechnen var currjahr = new Date().getFullYear(); var prevjahr = Number(new Date().getFullYear()) - 1; var currmonat = addZero(new Date().getMonth()+1).zero2; var historywert = 0; var prevhistorywert = 0; var histmonat = ""; var VerbrauchAktuellerMonat = 0; var anzTageDesMonats = Number(new Date().getDate()); // jetzt die Prognoseberechnen - loop ueber die 12 Monate for (var i = 1; i <= 12; i++) { // Loop fuer die Prognose auf Monate rechnend histmonat = addZero(i).zero2; historywert = GetHistory(currjahr,histmonat); if(historywert > 0 ) { // Case1 Monat schon abgeschlossen - diesen Verbrauchswert des aktuellen Jahres nehmen PrognosePelletVerbrauchJahrKG = PrognosePelletVerbrauchJahrKG + historywert; log("Prognosewert Case1 " + historywert + " fuer " + histmonat +currjahr + " hinzugerechnet","info" ); } if(historywert === 0 && histmonat != currmonat ) { // Case2 Den Verbrauchwert des letzten Jahres nehmen prevhistorywert = GetHistory(prevjahr,histmonat); PrognosePelletVerbrauchJahrKG = PrognosePelletVerbrauchJahrKG + prevhistorywert; log("Prognosewert Case2 " + prevhistorywert + " fuer " + histmonat +currjahr + " hinzugerechnet","info" ); } // endif history wert if(historywert === 0 && histmonat === currmonat ) { // Case3 die Prognose für den aktuellen Monat rechnen VerbrauchAktuellerMonat = getState(CurrMonatPath).val / anzTageDesMonats * 30; // Auslesen aus BSZ und hochrechnen auf den Monat PrognosePelletVerbrauchJahrKG = PrognosePelletVerbrauchJahrKG + VerbrauchAktuellerMonat; log("Prognosewert Case3 " + VerbrauchAktuellerMonat + " fuer " + histmonat +currjahr + " hinzugerechnet","info" ); } // ende wert ist null } // ende for setState(StatePrognosePelletVerbrauchJahr, round(PrognosePelletVerbrauchJahrKG,0)); // Prognosverbrauch Jahr KG setState(StatePrognosePelletVerbrauchMonat, round(PrognosePelletVerbrauchJahrKG / 12,0)); // Prognosverbrauch Monat KG setState(StatePrognosePelletVerbrauchJahrBew, round(PrognosePelletVerbrauchJahrKG * PreisPellet / 1000,2 )); // Prognosverbrauch Jahr Euro setState(StatePrognosePelletVerbrauchMonatBew, round(PrognosePelletVerbrauchJahrKG * PreisPellet / 1000 / 12,2)); // Prognosverbrauch Monat Euro log("Prognose fuer " + currjahr + " " + PrognosePelletVerbrauchJahrKG,"info" ); // jetzt Jason füllen fuer Bestand KG // Jason (Headline1, ZeilenText, Headline2, Wert, DescriptionTxt, DescriptionValue, String) { JasonString = "initial"; JasonString = JasonCreate ("Bestandswerte", "Pelletbestand KG" , "Werte", PelletBestandAktuell,"Pelletbestand KG" , "Pelletbestand KG" , JasonString, false); JasonString = JasonString + JasonCreate ("Bestandswerte", "Pelletbestand Euro" , "Werte", PelletBestandBew ,"Pelletbestand Euro", "Pelletbestand Euro", JasonString, true); setState(StateBestandPelletJason, JasonString); // jetzt Jason füllen fuer Verbrauch KG // Jason (Headline1, ZeilenText, Headline2, Wert, DescriptionTxt, DescriptionValue, String) { JasonString = "initial"; JasonString = JasonCreate ("Verbraeuche KG", "Pelletjahresverbrauch KG" , "Werte", round(PelletVerbrauchJahrKG,0) , "Gesamt JahresPelletVerbrauch " , "WertJahresverbrauch KG" , JasonString, false); JasonString = JasonString + JasonCreate ("Verbraeuche KG", "Durchn Pelletverbrauch/Monat KG" , "Werte", round(PelletVerbrauchMonatKG,0) , "Durchn. MonatatsPelletVerbrauch", "WertMonatsverbrauch KG" , JasonString, true); setState(StateVerbrauchPelletJason, JasonString); // jetzt Jason füllen fuer Verbrauch Euro JasonString = "initial"; JasonString = JasonCreate ("PelletVerbraeuche Euro", "Jahresverbrauch" , "Werte", PelletVerbrauchJahrBew , "Jahresverbrauch in Euro" , "WertJahresverbrauch Euro" , JasonString, false); JasonString = JasonString + JasonCreate ("PelletVerbraeuche Euro", "Durchn Monatsverbrauch" , "Werte", PelletVerbrauchMonatBew , "Durchn. MonatatsverbrauchEuro" , "WertMonatsverbrauch Euro" , JasonString, true); setState(StateVerbrauchPelletBewJason, JasonString); //jetzt Jason füllen fuer Prognose JasonString = "initial"; JasonString = JasonCreate ("Prognose", "Jahresverbrauch KG" , "Werte" , round(PrognosePelletVerbrauchJahrKG,0) ,"Prognoseverbrauch Jahr KG" , "Prognoseverbrauch Jahr KG" , JasonString, false); JasonString = JasonString + JasonCreate ("Prognose", "Monatsverbrauch KG" , "Werte" , round(PrognosePelletVerbrauchJahrKG / 12,0) ,"Prognose Verbrauch/Monat KG" , "Prognoseverbrauch Monat KG", JasonString, false); JasonString = JasonString + JasonCreate ("Prognose", "Jahresverbrauch Euro", "Werte" , round(PrognosePelletVerbrauchJahrKG * PreisPellet / 1000,2 ) ,"Prognose Verbrauch/Jahr Euro" , "MPrognosekosten Jahr Euro" , JasonString, false); JasonString = JasonString + JasonCreate ("Prognose", "Monatsverbrauch Euro", "Werte" , round(PrognosePelletVerbrauchJahrKG * PreisPellet / 1000 / 12,2),"Prognose Verbrauch/Monat Euro", "Prognosekosten Monat Euro" , JasonString, true); setState(StatePrognosePelletJason, JasonString); log("Pelletverbrauchsrechnung abgeschlossen","info"); } // Ende Funktion //----------------------------------------------------------------------------------------------------- // Lesen der History //----------------------------------------------------------------------------------------------------- function GetHistory (Jahr,Monat) { var Historypath_read = Historypath + Jahr + Monat; return getState(Historypath_read).val; } // 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) { var j= null; 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 var headerLine=null; 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