Stromverbrauchsrechnung mit NT HT Berücksichtigung - Script
-
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
-
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
-
Danke!
dazu greift das Skript aber auf irgendwelche Datenpunkte ("Zählerstand alt" ?) zu.
Und dort sind mehr Nachkommastellen?
Gruß
Rainer
-
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 `
-
-
Moin
ich nehme mal an, das man damit auch einen Gaszähler auswerten kann?
Gruß
-
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
-
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 Bilddabei 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)
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?
-
Hi,
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
-
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
-
….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
-
ja, workarounds gibts wohl einige. Ich habe nun aus der Not eine Tugend gemacht und die beiden Geister-Trigger mit ins Boot geholt und zusätzlich noch die cron-Zeiten 15 und 45 Minuten definiert. Daraus entsteht eine viertelstündliche Berechnung des Verbrauchs um h+00,15,30,45 ohne Nullwerte. Ist zwar ein Murks, aber es funktioniert. Die Herkunft der Geister-Trigger ist aber nach wie vor ein Rätsel.
Edit 15.8.: Problem gelöst
hab das Skript unter anderem Namen nochmals installiert. Seither ist der Fehler nicht mehr aufgetaucht. Eine Erklärung für das Problem habe ich nicht. Entstanden ist es beim Editieren des Skripts bzw. beim Ändern des cron-Eintrags von halbstündlich auf alle 10 Minuten. In der Folge wurde das Skript bei 00 und 30 Minuten doppelt aufgerufen, wodurch ein Delta von 0 entstand. Die Skriptaufrufe dazwischen erfolgten korrekt.
