/*..........Betriebsstundenzaehler BSZ Extended Version 0.60 ............Datum: 04.02.2016 ............Autor: Looxer01 ............Forum ioBroker ............http://forum.iobroker.com/posting.php?mode=post&f=21&sid=b3b2a31dae55081fedaf0ad9c8d74acd ............Änderungshistorie ............Version 0.25 Fehler in der update core Funktion behoben. Eine neue Spalte "refresh" hinzugefügt. (noch ohne Funktion) ............................Das soll spaeter dazu dienen, ein komplettes Set von Variablen zu loeschen und bei "true" und bei "false " neu zu erstellen ............Version 0.30 Logging ist implementiert und kann aktiviert werden - hISTORY ist implementiert und kann aktiviert werden fuer Monat und Jahr ............................Im Rahmen der History funktion wurde die freie Bezeichnung entfernt, da sie nirgendwo im Programm genutzt wurde ............................Refresh variable ist einstellbar. Vorläufige Funktion: Updates werden ignoriert falls auf true ............Version 0.40 Periodenabschluss (Nullen - Historiensicherung) und Refresh mit Nullung ueberarbeitet- Fehlerbeseitigung ............Version 0.60 Implementierung weiterer Methoden wie DELTA, CALC, ADD, SUB,BOOL Verallgemeinerung der Routinen um ggf weitere Methoden zu implementieren ............Version 0.65 Die Datenpunkte werden jetzt nicht nur zurückgesetzt sondern auch geloescht, wenn das loeschkennzeichen gesetzt wird ............................bei der Berechnung der Methoden Delta,Sub,Add,Calc ist ein Devisor eignefügt worden um leichter von Millisekunden auf Verbrauchswerte zu rechnen ............................Anpassungen bei Methoden CALC,ADD,SUB. . ADD und SUB sind nur fuer Zeitwerte relevant. (Input wird als Zeitwert in Millisekunden erwartet als Differenz wischen ein-und ausschalten) ............................Einfuehrung von BOOL um bool Werte für Graphanzeige mit offsets zu versehen ............................Sonderregelungen für von true abweichende Status für "Gerät ist eingeschaltet" hinzugefügt ............................Rechenregel ist jetzt auch für Methode TIME anwendbar. So kann auch im Betriebszähler die Anzahl der Stunden,Wochen,Monate, Minuten, Sekunden etc gespeichert werden ............................DELTAM - Methode hinzugefügt um automatische Tankmessungen zu unterstützen (absteigende gemeldete Werte) ............................ */ /* HIER Einstellungen vornehmen............................................................................................ -------------------------------------------------------------------------------------------- Position 1 = ist die Geraete-ID bzw Objekt ID - bitte nur gültige objekte eintragen - Es funktionieren alle LEVEL und STATE Geraete und alles was mit true und false belegt werden kann .............der Text "initial" muss eingetragen sein fuer nicht genutzte Zeilen Position 2 = der Variablenname unter dem die Betriebszeiten in ioBroker abgelegt werden. Wichtig: keine Sonderzeichen und keine Spaces verwenden. Statdessen aber Unterstriche eintragen Position 3 = History, Bei true werden die zeitabschnitte Monat und Jahr vor der Loeschung per Monat und Jahr gesichert (in ioBroker objekte) Position 4 = Variable DAY wird angelegt und kumuliert - täglicher refresh - keine Hochkomma Position 5 = Variable WEEK wird angelegt und kumuliert - wöchentlicher refresh - keine Hochkomma Position 6 = Variable MONTH wird angelegt und kumuliert - monatlicher refresh - keine Hochkomma Position 7 = Variable YEAR wird angelegt und kumuliert - Jährlicher refresh - keine Hochkomma Position 8 = Verwendung eines Zaehlers um die Statuswechsel (anzahl Schaltungen) zu zaehlen Position 9 = entweder ein Status wie true false etc ODER Sonderfunktionen .............bei LEVEL Geraeten eine Zahl zwischen 0 und 100 - Empfehlung 1. Bedeutet alle Level groesser gleich 1 werden als EIN gewertet .............delta = Deltamessung einer Zahl (hochzählen) zwischen letztem Wert und aktuellem Wert und fortschreibung dieser Zahl in die Zeitabschnitte (Anwendung z.B. Strommessung) .............deltam = Delta Minusmessung. wie delta aber die erwarteten Zahlen nehmen staendig ab .............add = Messung der Zeitdifferen zwichen und und Ausschaltung Anwendung von Formelwerten und addition der errechneten Werte (z.B umrechnen von Millisekundden in KG und anschliesende addition) .............sub = wie add nur subtraktion des wertes .............bool = Lokikwerte (true/false) werden umgerechnet in 0 und 1 und können z.B. mit Addition zu anderen Werten gerechnet werden (dient zur graphischen Darstellung) .............calc = Umwandlung von Boolean Werte durch Anwendung einer Formel oder Zeitmessung und Umwandlung der gemessenen Zeit .............Alle Funktionen können mit Rundung versehen werden und mit Faktoren um z.B. den Energieverbrauch zu berechnen (öl und Pellet) oder umrechnen in Euro oder von Wh in KWh etc (Tabelle special) Position 9 - 18 - Eingabe was gezaehlt werden soll. Jeder Eintrag erzeugt eine variable in den Objekten. Sobald ein Status des Homematic-ID gesetzt wird, wird die Zeit bzw. die Anzahl der Schaltvorgaenge gespeichert Status kann in hochkomma anagegeben werden z.B. '100' oder 100. Als eingeschaltet wird alles groesser gleich dem eingegebenen Wert berechnet (bei Sonderfunktionen werden die positionen 10 - 18 ignoriert) Position 19 = stop Refresh = true Es werden kene Daten mehr aktualsieirt. Solange Refresh auf true steht werden keine neuen Daten aufgezeichnet - standard ist also false Position 20 = Loesch Datenpunkte = True Es werden alle Daten geloescht - standard ist also false - damit geloescht wird muss auch stop refresh auf true stehen --------------------------------------------------------------------------------*/ var Gruppen = []; // 1.Homematic ID, 2.Feldname(no spaces) 3.History 4.DAY 5.Week 6.Month 7.Year 8.Switch 9 - 18 Status to log 19.stop 20.Loesch Gruppen[0] = ['hm-rpc.0.KEQ0178063.1.STATE' ,'Pellet' ,false ,true ,true ,true ,true ,true ,'false' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,false, false]; // Schneckenzeit Gruppen[1] = ['hm-rpc.0.KEQ0178063.1.STATE' ,'Pellet' ,true ,true ,true ,true ,true ,false ,'add' ,'false','' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,false, false]; // Kumuliert KG Gruppen[2] = ['hm-rpc.0.KEQ0178063.1.STATE' ,'Pellet' ,false ,true ,true ,true ,true ,false ,'add' ,'false','' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,false, false]; // Kumuliert Euro Gruppen[3] = ['hm-rpc.0.KEQ0178063.1.STATE' ,'Pellet' ,false ,false ,false ,false ,false ,false ,'sub' ,'false','' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,false, false]; // Restbestand KG Gruppen[4] = ['hm-rpc.0.KEQ0178063.1.STATE' ,'Pellet' ,false ,false ,false ,false ,false ,false ,'bool' ,'false','' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,false, false]; // Laufzeiten f.Graphik Gruppen[5] = ['initial' ,'Pellet' ,false ,true ,true ,true ,true ,true ,'true' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,false, false]; // Reserviert fuer Individuallogik Gruppen[6] = ['modbus.0.holdingRegisters.26_FA1_STATE', 'Oekofen_Status' ,false ,true ,true ,true ,true ,false ,'1' ,'2' ,'3' ,'4' ,'5' ,'7' ,'99' ,'' ,'' ,'' ,false, false]; Gruppen[7] = ['modbus.0.holdingRegisters.26_FA1_STATE', 'Pellet' ,false ,true ,true ,true ,true ,false ,'add' ,'7' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,false, false]; // Oekofen Gruppen[8] = ['initial' , '' ,true ,true ,true ,true ,true ,true ,'delta' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,true, false]; Gruppen[9] = ['hm-rpc.0.LEQ0150798.2.ENERGY_COUNTER', 'Strom_Kuehlschrank' ,false ,true ,true ,true ,true ,true ,'delta' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,false, false]; Gruppen[10] = ['hm-rpc.0.LEQ0183472.2.ENERGY_COUNTER', 'Strom_TV' ,true ,true ,true ,true ,true ,true ,'delta' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,true, false]; Gruppen[11] = ['hm-rpc.0.KEQ0965841.2.ENERGY_COUNTER', 'Strom_Oekofen' ,false ,true ,true ,true ,true ,true ,'delta' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,false, false]; Gruppen[12] = ['hm-rpc.0.KEQ0965841.2.ENERGY_COUNTER', 'Strom_Oekofen' ,true ,true ,true ,true ,true ,true ,'delta' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,false, false]; Gruppen[13] = ['hm-rpc.0.JEQ0036841.1.STATE' , 'PelletTest' ,false ,false ,false ,false ,false ,false ,'sub' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,true, false]; // Restbestand Gruppen[14] = ['hm-rpc.0.JEQ0036841.1.STATE' , 'PelletTest' ,true ,true ,true ,true ,true ,false ,'add' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,true, false]; // PelletKG Gruppen[15] = ['hm-rpc.0.JEQ0036841.1.STATE' , 'PelletTest' ,false ,true ,true ,true ,true ,false ,'add' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,true, false]; // Pellet Euro Gruppen[16] = ['hm-rpc.0.JEQ0199306.1.LEVEL' , 'Licht_WZ_EsstischDecke' ,true ,true ,true ,true ,true ,true ,'1' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,true, false]; Gruppen[17] = ['javascript.0.BSZ.Oelstand' , 'DELTAM-TEST' ,true ,true ,true ,true ,true ,false ,'deltam','' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,false, false]; Gruppen[18] = ['javascript.0.BSZ.Oelstand' , 'DELTAM-TEST' ,false ,true ,true ,true ,true ,false ,'deltam','' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,false, false]; Gruppen[19] = ['hm-rpc.0.JEQ0036841.1.STATE' , 'Licht_WZ_EsstischStehlampe' ,false ,true ,true ,true ,true ,false ,'add' ,'true' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,false, false]; Gruppen[20] = ['hm-rpc.0.JEQ0036841.1.STATE' , 'Licht_WZ_EsstischStehlampe' ,false ,true ,true ,true ,true ,true ,'add' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,false, false]; /*------------------------------------------------------------------------------- // Die folgende Tabelle dient zur Vergabe von Statusnamen zur besseren Lesbarkeit. Standard ist EIN Die ziffern im Array z.B. [0] korrespondieren mit der Gruppentabelle also Gruppen[0] gehört zu logname[0] Wird hier kein Feldname vergeben, dann wird Spalte 9-18 der Gruppentabelle als Feldname verwendet Beispiel: Zustand Lampe = EIN , Beispiel: Status 1 =Start, 2 = Heizung_Zuendung,3 = Softstart 4 = Heizung_Brennen, 5 = Heizung_Nachlauf etc ACHTUNG- keine spaces verwenden */ var logname = []; // Stat1 Stat2 Stat3 Stat4 Stat5 Stat6 Stat7 Stat8 Stat9 Stat10 logname[0] = ['Schneckenzeit','' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'']; logname[1] = ['PelletKG' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'']; logname[2] = ['PelletEURO' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'']; logname[3] = ['PelletRest' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'']; logname[4] = ['SchneckeSchalt','' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'']; logname[5] = ['EIN' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'']; logname[6] = ['Start' ,'Zuendung' ,'Softstart','Leistungsbrand' ,'Nachlauf' ,'Saugen' ,'Idle' ,'' ,'' ,'']; logname[7] = ['PelletTheor' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'']; logname[8] = ['EIN' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'']; logname[9] = ['kWh' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'']; logname[10] = ['kWh' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'']; logname[11] = ['kWH' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'']; logname[12] = ['EURO' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'']; logname[13] = ['EIN' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'']; logname[14] = ['PelletKG' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'']; logname[15] = ['PelletEuro' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'']; logname[16] = ['EIN' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'']; logname[17] = ['OELRest' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'']; logname[18] = ['OELEuro' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'']; logname[19] = ['LichtPellTheo','' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'']; logname[20] = ['LichPelletKG' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'' ,'']; // Tabelle "special" : hier werden für die Sonderfunktionen Delta, add, sub und calc Rechenregeln hinterlegt // Pos1 Rundung auf Nachkommastellen // Pos2 Addition1 mit dem angegebenen Wert erfolgt vor der Multiplikation mit dem Faktor aus Pos3 // Pos3 = Faktor für die Multiplikationen - Ein Faktor kann nur sinnvoll eingegeben werden, wenn zu diesem Zeitpunkt alle Werte auf Null stehen. //........Der Faktor kann nicht null sein. In diesem Fall wird 1 angenommen. //........Also entweder bei der Neueinrichtung bzw ein Refresh ist aller Werte ist erforderlich // Pos4 = Devisor um den Faktor lesbar zu machen z.B. Millisekunden Devisor für Sekunde = 1000 , Minute = 60000, Stunde = 3600000 //........Die Rechnung ist Faktor/Devisor / Wenn Devisor = blank oder 0, dann wird 1 angenommen // Pos5 = Addition2 mit dem angegebenen Wert erfolgt nach der Multiplikation mit dem Faktor aus Pos3 //........Formel: y=((x+add1)*faktor/devisor)+add2 / y = Ergebnis - x = eigehender Wert aus dem überwachten Datenpunkt //........y wird in die Indivduallogik geschickt um weiter zu berechnen // Pos6 ist vorgesehen, um Funktionen im Programm zu definieren die dann aufgerufen werden - Programmierung ist erforderlich // Pos7 nur fuer Methode Delta und DeltaM - bei Tanksensoren/Energiesensoren kommt es haeufig zu Schwankungen plus und minus - Hier wird die Grenze bestimmt bei der ein Tankvorgang sicher angenommen werden kann z.B. 100 Liter differenz //.......der Wert muss in der gemessenen Einheit angegeben werden. Z.B. Ultraschallsensoren senden in Liter. Dann ist die Zahl, die hier eingegeben werden muss ebenfalls Liter var special = []; // 1.Round 2.add1 3.Faktor 4. Devisor 5.add2 6.Individuallogik 7: DELTAM TANK Grenze special[0] = ['' ,'' ,'' ,'' ,'' ,'' ,'' ]; special[1] = ['2' ,'' ,'7.5' ,'60000' ,'' ,'' ,'' ]; // Umwandlung von Verbrauch in Millisekunden zu KG/Min = 7,5 KG/Min special[2] = ['2' ,'' ,'1.725' ,'60000' ,'' ,'' ,'' ]; // Euro pro Minute special[3] = ['2' ,'' ,'7.5' ,'60000' ,'' ,'' ,'' ]; // Zeit fuer ein KG special[4] = ['' ,'1' ,'' ,'' ,'' ,'' ,'' ]; // für die Graphische Auswertungen Ein = 2 / aus = 1 special[5] = ['' ,'' ,'' ,'' ,'' ,'' ,'' ]; special[6] = ['' ,'' ,'' ,'' ,'' ,'' ,'' ]; special[7] = ['2' ,'' ,'' ,'' ,'' ,'oekofen' ,'' ]; // Sonderlogik fuer Saugzeiten Oekofen special[8] = ['' ,'' ,'' ,'' ,'' ,'' ,'' ]; special[9] = ['3' ,'' ,'' ,'1000' ,'' ,'' ,'' ]; // Umwandlung von Wh in kWh special[10] = ['3' ,'' ,'0.001' ,'' ,'' ,'' ,'' ]; special[11] = ['2' ,'' ,'0.001' ,'' ,'' ,'' ,'100' ]; special[12] = ['2' ,'' ,'0.29' ,'1000' ,'' ,'' ,'100' ]; // Preis je kWh special[13] = ['2' ,'' ,'7.5' ,'60000' ,'' ,'' ,'' ]; // Pellet Restbestand special[14] = ['2' ,'' ,'7.5' ,'60000' ,'' ,'' ,'' ]; // Pellet KG special[15] = ['2' ,'' ,'1.725' ,'60000' ,'' ,'' ,'' ]; // Pellet Euro special[16] = ['' ,'' ,'' ,'' ,'' ,'' ,'' ]; special[17] = ['2' ,'' ,'' ,'' ,'' ,'' ,'100' ]; // DeltaM special[18] = ['2' ,'' ,'0.5' ,'' ,'' ,'' ,'100' ]; // DeltaM special[19] = ['2' ,'' ,'' ,'' ,'' ,'oekofen' ,'' ]; special[20] = ['2' ,'' ,'7.5' ,'60000' ,'' ,'' ,'' ]; // Licheinschalt Zeit fuer Pellettest // Es werden zur angegebenen Uhrzeit die Kumulationsvariablen bei beginn einer neuen Periode genullt (DAY,WEEK,MONTH,YEAR) // Zu dieser Zeit werden auch die Monatswerte und Jahreswerte gesichert falls History auf true steht var TimeSetStunde = "00"; // Bitte Uhrzeit - hier Stunde eingeben im 24 Stunden Format z.B. 00 für Mitternacht var TimeSetMinute = "07"; // Bitte Minuten eingeben z.B. 10 - = 00:10 für Null Uhr Zehn // logging in eine exterene EXCEL Datei - hier werden alle updates gesichert - wird vor allem zum debugging benoetigt Empfehlung false fuer produktiven Betrieb var logflag = false; // wenn auf true dann wird das logging in Datei /opt/iobroker/iobroker-data/BSZLog.csv eingeschaltet bei false vice versa // logging in eine exterene EXCEL Datei - hier werden alle Zeitabschnitte vor der Nullung gesichert - Empfehlung true fuer produktiven Betrieb var Timelogflag = false; // wenn auf true dann wird das logging in Datei /opt/iobroker/iobroker-data/BSZTimeLog.csv eingeschaltet bei false vice versa // fuer OSX und Windows MUSS der volle Pfad eingestellt werden (wenn die log flags auf true stehen) // Beispiel: /Users/looxer01/Documents/iobroker/iobroker-data/BSZLog.csv var LogPath = "/opt/iobroker/iobroker-data/BSZExtLog.csv"; // Pfad und Dateiname des externen Logs var TimeLogPath = "/opt/iobroker/iobroker-data/BSZExtTimeLog.csv"; // Pfad und Dateiname des externen Logs für die Zeitabschnitte täglich, wöchentlich monatlich jährlich // Ende Einstellungen ....................................................................................................... // Experten-Einstellungen ....................................................................................................... // die beiden Variablen regeln das abspeichern der ioBroker Variablen. Unter diesem Pfad sind sie in ioBroker javascript.0. zu finden var sysLocation = "BSZ.ZSystem"; // Speicherort der Systemvariablen var countLocation = "BSZ.ZCounter"; // Speicherort der Counter Variablen (Klartext Betriebszeiten) /* Ende Experten-Einstellungen ....................................................................................................... --------------------------------------------------------------------------------------------------------------------------------------*/ // Start des Programmablaufs bevor Trigger aufgerufen werden var SpaceChk = new RegExp(/\s/); // pattern um zu pruefen ob eine IDGruppe blanks enthaelt var fs = require('fs'); // enable write fuer externes log var string = " "; // Logstring var logtext=" " ; // Kommentar im log var FormTimeKum = "000:00:00:00"; // kumulierte Betriebsstunden im Format ddd:hh:mm:ss var FormTimeSingle = "000:00:00:00"; // kumulierte Betriebsstunden im Format ddd:hh:mm:ss var currSec = 0; // aktuelle Zeit in Millisekunden var GeraeteName = " "; // Bezeichnung des Geraetes var GeraeteStatus = " "; // Geraetestatus z.B. true / false var timediff = 0; // Variable Betriebszeit in MSec von letzter Einschaltzeit bis curren Ausschaltzeit var newkumtime = 0; // Variable neue berechnete kumulirete Zeit in MSec var LastMSec = 0; // Variable letzte Einschaltzeit in MSec var LastKumSec = 0; // Variable letzte kumulierte Zeit in MSec var DayKum = 0; // Rechenvariable taegliche kumulierte Werte var WeekKum = 0; // Rechenvariable woechentliche kumulierte Werte var MonthKum = 0; // Rechenvariable monatliche kumulierte Werte var YearKum = 0; // Rechenvariable jaehrliche kumulierte Werte var FormTimeDAY = "000:00:00:00"; // Rechenvariable taegliche formatierte Werte var FormTimeWEEK = "000:00:00:00"; // Rechenvariable woechentliche formatierte Werte var FormTimeMONTH = "000:00:00:00"; // Rechenvariable moantliche formatierte Werte var FormTimeYEAR = "000:00:00:00"; // Rechenvariable jaehrliche formatierte Werte var cronjob = TimeSetMinute + " " + TimeSetStunde +" * * *"; // Cron Schedule setzen var action = " "; // actiontext fuer Log var objGruppe = " "; // die iobroker bwz. HM object ID var objMSec = " "; // BSZ.SystemGrp00.MSec var objKum = " "; // BSZ.SystemGrp00.Kum var objTime = " "; // BSZ.Counter.Feldname var objSwitch = " "; // BSZ.Counter.Feldname // Aufbauen der Variablentabelle zur Übergabe and die Berechnungsfunktion (Geraetupdate) // umwandeln von bool txt in real bool // umwandeln von zahlen txt in real zahlen // dient zur sicheren Behandlung von "false " versus false und delta versus DELTA var GrpSystem = []; var zaehler2 = 0; var spaltenzaehler; var compare; for (var zaehler = 0, // Loop über das Array zaehler_array = Gruppen.length; // entsprechend der Anzahl der Eintragungen zaehler < zaehler_array; zaehler++) { // addiere eins für jeden Druchgang zaehler2 = addZero(zaehler).zero2; // fuehrende Null GrpSystem[zaehler] = [sysLocation + '.Grp' + zaehler2 + 'MSec', sysLocation + '.Grp' + zaehler2 + 'Kum', countLocation + "." + Gruppen[zaehler][1]]; // Erzeuge Eintragung ins Array for ( spaltenzaehler = 2; spaltenzaehler < 20; spaltenzaehler++) { // alle true und false texte in boolean umwandeln fr die Gruppentabelle compare = Gruppen[zaehler][spaltenzaehler]; if( typeof(compare) == "string") { compare = compare.toUpperCase(); if(compare === "TRUE") { Gruppen[zaehler][spaltenzaehler] = true; } // endif true if(compare === "FALSE") { Gruppen[zaehler][spaltenzaehler] = false; } // endif true if(compare === "DELTA" || compare === "DELTAM" || compare === "BOOL" || compare === "ADD" || compare === "SUB" || compare === "CALC") { Gruppen[zaehler][spaltenzaehler] = Gruppen[zaehler][spaltenzaehler].toUpperCase(); } // log("Gruppentabelle " + zaehler + " " + spaltenzaehler + " " + Gruppen[zaehler][spaltenzaehler],"info"); } // endif type ist string } // endfor spaltenzaehler Gruppen for ( spaltenzaehler = 0; spaltenzaehler < 7; spaltenzaehler++) { // alle nummern als text in zahlen umwandeln falsch wert nicht initial if(spaltenzaehler === 5) { continue; } // Spalte 5 ist text if( special[zaehler][spaltenzaehler] !== '') { special[zaehler][spaltenzaehler] = Number(special[zaehler][spaltenzaehler]); } } // endfor spaltenzaehler special } // Ende FOR // Anlegen der Variablen falls notwendig und loeschen wenn eingestellt CreateDelStates(); // Anlegen der Variablen in ioBroker // ------------------------T R I G G E R ------------------------------------------------------- on({id: Gruppen[0][0], valNe: 1000 }, function(obj) { if (obj.state.ack) { GeraetUpdate( 0 ); } }); // ende on id on({id: Gruppen[1][0], valNe: 1000 }, function(obj) { if (obj.state.ack) { GeraetUpdate( 1 ); } }); // ende on id on({id: Gruppen[2][0], valNe: 1000 }, function(obj) { if (obj.state.ack) { GeraetUpdate( 2 ); } }); // ende on id on({id: Gruppen[3][0], valNe: 1000 }, function(obj) { if (obj.state.ack) { GeraetUpdate( 3 ); } }); // ende on id on({id: Gruppen[4][0], valNe: 1000 }, function(obj) { if (obj.state.ack) { GeraetUpdate( 4 ); } }); // ende on id on({id: Gruppen[5][0], valNe: 1000 }, function(obj) { if (obj.state.ack) { GeraetUpdate( 5 ); } }); // ende on id on({id: Gruppen[6][0], valNe: 1000 }, function(obj) { if (obj.state.ack) { GeraetUpdate( 6 ); } }); // ende on id on({id: Gruppen[7][0], valNe: 1000 }, function(obj) { if (obj.state.ack) { GeraetUpdate( 7 ); } }); // ende on id on({id: Gruppen[8][0], valNe: 1000 }, function(obj) { if (obj.state.ack) { GeraetUpdate( 8 ); } }); // ende on id on({id: Gruppen[9][0], valNe: 1000 }, function(obj) { if (obj.state.ack) { GeraetUpdate( 9 ); } }); // ende on id on({id: Gruppen[10][0], valNe: 1000 }, function(obj) { if (obj.state.ack) { GeraetUpdate( 10 ); } }); // ende on id on({id: Gruppen[11][0], valNe: 1000 }, function(obj) { if (obj.state.ack) { GeraetUpdate( 11 ); } }); // ende on id on({id: Gruppen[12][0], valNe: 1000 }, function(obj) { if (obj.state.ack) { GeraetUpdate( 12 ); } }); // ende on id on({id: Gruppen[13][0], valNe: 1000 }, function(obj) { if (obj.state.ack) { GeraetUpdate( 13 ); } }); // ende on id on({id: Gruppen[14][0], valNe: 1000 }, function(obj) { if (obj.state.ack) { GeraetUpdate( 14 ); } }); // ende on id on({id: Gruppen[15][0], valNe: 1000 }, function(obj) { if (obj.state.ack) { GeraetUpdate( 15 ); } }); // ende on id on({id: Gruppen[16][0], valNe: 1000 }, function(obj) { if (obj.state.ack) { GeraetUpdate( 16 ); } }); // ende on id on({id: Gruppen[17][0], valNe: 1000 }, function(obj) { if (obj.state.ack) { GeraetUpdate( 17 ); } }); // ende on id on({id: Gruppen[18][0], valNe: 1000 }, function(obj) { if (obj.state.ack) { GeraetUpdate( 18 ); } }); // ende on id on({id: Gruppen[19][0], valNe: 1000 }, function(obj) { if (obj.state.ack) { GeraetUpdate( 19 ); } }); // ende on id on({id: Gruppen[20][0], valNe: 1000 }, function(obj) { if (obj.state.ack) { GeraetUpdate( 20 ); } }); // ende on id // ------------------------Aenderung des Status des Geraetes------------------------------------ //-------------------------Beim Einschalten wird die Zeit festgehalten ------------------------- //-------------------------Beim Ausschalten wird die Zeitdifferenz berechnet und gespeichert---- // jeden Tag werden die Betriebszaehler zurueckgesetzt schedule(cronjob, function() { // Planung fuer die Ruecksetzung entsprechend der Nutzervorgabe var month = addZero(new Date().getMonth()+1).zero2; // aktueller Monat var year = new Date().getFullYear(); // aktuelles jahr var day = addZero(new Date().getDate()).zero2; // Heutiger Tag var weekday = new Date().getDay(); // Tag der Woche 1 = Monday var zaehler2; for ( var zaehler = 0, // loop durch die Gruppendefinition zaehler_array = Gruppen.length; zaehler < zaehler_array; zaehler++) { if (Gruppen[zaehler][0] === "initial") { continue; } // Check Gueltigkeit object if (Gruppen[zaehler][18] === true) { continue; } // Objekt ist mit refresh gekennzeichnet - keine updates if (ObjectExists(Gruppen[zaehler][0]) === false) { continue; } // Objekt existiert noch mal im System checken TimeNull(zaehler,"TIME","day",false); // day werte zuruecksetzen TimeNull(zaehler,"SWITCH","day",false); // day werte zuruecksetzen TimeNull(zaehler,"DELTA","day",false); // day werte zuruecksetzen TimeNull(zaehler,"DELTAM","day",false); // day werte zuruecksetzen TimeNull(zaehler,"ADD","day",false); // day werte zuruecksetzen TimeNull(zaehler,"SUB","day",false); // day werte zuruecksetzen TimeNull(zaehler,"CALC","day",false); // day werte zuruecksetzen TimeNull(zaehler,"BOOL","day",false); // day werte zuruecksetzen if ( weekday === 1) { // wochenwechsel (montags) TimeNull(zaehler,"TIME","week",false); // wochen werte zuruecksetzen TimeNull(zaehler,"SWITCH","week",false); // wochen werte zuruecksetzen TimeNull(zaehler,"DELTA","week",false); // wochen werte zuruecksetzen TimeNull(zaehler,"DELTAM","week",false); // wochen werte zuruecksetzen TimeNull(zaehler,"ADD","week",false); // wochen werte zuruecksetzen TimeNull(zaehler,"SUB","week",false); // wochen werte zuruecksetzen TimeNull(zaehler,"CALC","week",false); // wochen werte zuruecksetzen TimeNull(zaehler,"BOOL","week",false); // wochen werte zuruecksetzen } if ( day === "01") { // monatswechsel TimeNull(zaehler,"TIME","month",true); // monats werte zuruecksetzen TimeNull(zaehler,"SWITCH","month",true); // monats werte zuruecksetzen TimeNull(zaehler,"DELTA","month",false); // wochen werte zuruecksetzen TimeNull(zaehler,"DELTAM","month",false); // wochen werte zuruecksetzen TimeNull(zaehler,"ADD","month",false); // wochen werte zuruecksetzen TimeNull(zaehler,"SUB","month",false); // wochen werte zuruecksetzen TimeNull(zaehler,"CALC","month",false); // wochen werte zuruecksetzen TimeNull(zaehler,"BOOL","month",false); // wochen werte zuruecksetzen } if ( day === "01" && month === "01") { // Jahreswechsel CreateDelStates(); // Bei jahrswechsel müssen die neuen Jahres/Monatsdaten angelegt werden TimeNull(zaehler,"TIME","year",true); // jahres werte zuruecksetzen TimeNull(zaehler,"SWITCH","year",true); // jahres werte zuruecksetzen TimeNull(zaehler,"DELTA","year",false); // jahres werte zuruecksetzen TimeNull(zaehler,"DELTAM","year",false); // jahres werte zuruecksetzen TimeNull(zaehler,"ADD","year",false); // jahres werte zuruecksetzen TimeNull(zaehler,"SUB","year",false); // jahres werte zuruecksetzen TimeNull(zaehler,"CALC","year",false); // jahres werte zuruecksetzen TimeNull(zaehler,"BOOL","year",false); // jahres werte zuruecksetzen } } // endfor log("EVENT Betriebsstundenzaehler werden zurueckgesetzt TAG:"+ day +" Wochentag " + weekday + "Monat " + month , "info"); // schreibe Log }); // end of schedule // ------------------------ F U N K T I O N E N ------------------------------------------------------- //----------------------------------------------------------------------------------------------------- // Core Update Funktion //----------------------------------------------------------------------------------------------------- function GeraetUpdate(nummer) { // nummer ist das Tabellenobjekt, das gerade den Status gewechselt hat //variablen auslesen var objGruppe = Gruppen[nummer][0]; // die iobroker bwz. HM object ID var objMSec = GrpSystem[nummer][0]; // BSZ.SystemGrp00.MSec var objKum = GrpSystem[nummer][1]; // BSZ.SystemGrp00.Kum var objTime = GrpSystem[nummer][2]; // BSZ.Counter.Feldname var objSwitch = GrpSystem[nummer][2]; // BSZ.Counter.Feldname var day = Gruppen[nummer][3]; // soll die tages statistik geführt werden ? var week = Gruppen[nummer][4]; // soll die wochen statistik geführt werden ? var month = Gruppen[nummer][5]; // soll die Monats statistik geführt werden ? var year = Gruppen[nummer][6]; // soll die Jahres statistik geführt werden ? var zaehler = 0; // zaehler für for schleifen var zaehler2 = 0; // zaehlerumwandlung mit führender Null var statusname = ''; // statustext aus der logname tabelle var GeraeteStatus = " "; // augenblickler status der gelesenen HM ID var geraetestatusC = "true"; // character als status als hilfsvariable (für Status des Geaetes/objektes) var gruppenstatusC = "true"; // character als status als hilfsvariable (für Gruppenstatus) var switchdiff; // Rechenvariable um eine Schaltung hinzuzufügen var LastKumSwitch; // letzte Anzahl von Schaltungen var rundung; // Rechnen fuer alle Methoden var faktor; // Rechnen fuer alle Methoden var devisor; // Rechnen fuer alle Methoden var lastvalue; // Rechnen fuer alle Methoden var newvalue; // Rechnen fuer alle Methoden var lastkumvalue; var lastkumvalueobj; var newkumvalue; var newkumvalueobj; var diffvalraw; var diffval; // Rechnen für alle Methoden var addition1; // Rechnen fuer alle Methoden var addition2; // Rechnen fuer alle Methoden var switchupdate = Gruppen[nummer][7]; // sollen switch updates gezaehlt werden ? var statusoverrule = false; // spezialfall wenn Geraete beim einschalten auf false statt auf true stehen var DeltaToleranz = special[nummer][6]; // fuer Delta und DeltaM bei Tanksensoren schwanken die Messwerte. Ab diesem Wert wird ein Tankvorgang angenommen, Ruecksetzen von Energiesensoren var individualFunc = false; // flag Individualfunktion anwenden if (Gruppen[nummer][18] === true) { return; } // eignestellt auf keine updates if (Gruppen[nummer][19] === true) { return; } // alle datenpunkte sollen genullt werden GeraeteName = getObject(objGruppe).common.name; // Auslesen der Bezeichnung des Geraetes currSec = new Date().getTime(); // Aktuelle Zeit millisekunden seit 01.01.1970 if (ObjectExists(objGruppe) === false) { // Objekt falsch definiert oder nicht angelegt return; // Abbruch } statusname = Gruppen[nummer][8]; if (logname[nummer][0] !== '') { // Gibt es einen Status in der logname tabelle ? wenn ja merken mit vorrang statusname = logname[nummer][0]; } // endif logname tabelle rundung = special[nummer][0]; // lesen Einstellung zur Rundung if(rundung === '') { rundung = 16; } else { // Wenn keine Rundung angegeben ist dann 16 rundung = Number(rundung); // Rundung umwandeln in Zahl } // endif rundung addition1 = Number(special[nummer][1]); // lesen Einstellung addition1 faktor = Number(special[nummer][2]); // lesen Einstellung Faktor if(faktor === 0) { faktor = 1; } // Null ist nicht erlaubt devisor = Number(special[nummer][3]); // lesen Einstellung Devisor if(devisor === 0) { devisor = 1; } // Null ist nicht erlabut faktor = faktor / devisor; // neuer Faktor addition2 = Number(special[nummer][4]); // lesen Einstellung addition2 objKum = objKum + "." + statusname; objMSec = objMSec + "." + statusname; objSwitch = objSwitch+ '.SWITCH.' + statusname; GeraeteStatus = getState(objGruppe).val; // Neuer Status des Geraetes geraetestatusC = GeraeteStatus.toString(); //wandle in character = z.B. "9" statt 9 statusoverrule = GeraeteStatus; // zunächst mal Gerätestatus merken if (GeraeteStatus === true) { // ist der aktuelle Status = true if (Gruppen[nummer][9] === false ) { // ist true overruled mit false ? statusoverrule = false; // dann reverse die logik } } //endif Status ist true if (GeraeteStatus === false) { // ist der aktuelle Status = false if (Gruppen[nummer][9] === false ) { // ist false overruled mit true ? statusoverrule = true; // dann reverse die logik } } //endif Status ist false if (typeof GeraeteStatus != "boolean") { // aktueller Gerätestatus ist nicht boolean if (Gruppen[nummer][9] === geraetestatusC) { statusoverrule = true; // wenn es nicht boolean ist und der Gerätestatus = dem eingetragenen dann gilt das Gerät als eingeschaltet } else { statusoverrule = false; } } // endif - es ist kein boolean if (typeof statusoverrule != "boolean") { // Problem aufgetreten ? log("hier ist ein Problem. Der Status haette boolean sein sollen, ist aber " + statusoverrule, "info"); // sollte nicht vorkommen } // bool datenpunkt if (Gruppen[nummer][8] === 'BOOL') { //Es ist ein bool datenpunkt objTime = objTime + '.BOOL.' + statusname; LastMSec = getState(objMSec).val; // lese letzten Wert newvalue = Number(getState(objGruppe).val); // lese aktuellen Wert aud dem veränderten Datenpunkt true = 1 false = 0 newvalue = newvalue + addition1; newvalue = newvalue * faktor; // Faktor anwenden newvalue = newvalue + addition2; if(special[nummer][5] !== '') { // Individualfunktionen newvalue = individual(special[nummer][5].toUpperCase(),nummer,newvalue); } writelog("A","BOOL" + ";" + "Change" + ";" + Gruppen[nummer][0] + ";" + GeraeteName + ";;;;" + newvalue ); newvalue = round(newvalue,rundung); // Rundung anwenden setState(objTime,newvalue); // Schreibe wert in variable if (statusoverrule === true && LastMSec === 0 ) { // Wenn Geraet keine Einschaltzeit hat und der Verbraucher nicht kleiner eingeschaltet wurde als in der Gruppen tabelle unter status, dann ignoriere setState(objMSec,currSec); // Einschaltzeit setzen } // endif Zeit wurde noch nicht gemessen if (statusoverrule === true && LastMSec > 0) { // da ist was schief gegangen - messung zurücksetzen setState(objMSec,0); // Einschaltzeit setzen } // endif Zeit wurde vorher gemessen - status sollte aber false sein - messung beenden if (statusoverrule === false && LastMSec > 0) { LastKumSec = getState(objKum).val; // lese kumulierten Wert timediff = currSec - LastMSec; // Berechnen der Zeitdifferenz newkumtime = LastKumSec + timediff; // Berechne die neue kumulierte Zeit setState(objKum,newkumtime); // Schreibe wert in variable setState(objMSec,0); } // endif check on false and zeit nicht gemessen ValKum(day,week,month,year,objKum,objTime,newvalue,newvalue,rundung); // update der Werte in täglichen, wöchentlichen, monatlichen, jährlichen einheiten wenn so gewünscht if(switchupdate) { LastKumSwitch = getState(objSwitch).val; // lese kumulierten Zaehlungen switchdiff = LastKumSwitch + 1; setState(objSwitch,switchdiff); // setzen plus ein Schaltvorgang SwitchKum(day,week,month,year,objSwitch); // update der switches in täglichen, wöchentlichen, monatlichen, jährlichen einheiten wenn so gewünscht } // endif Swtichupdate return; } // endif bool datenpunkt // calc datenpunkt if (Gruppen[nummer][8] === 'CALC') { //Es ist ein calc datenpunkt objTime = objTime + '.CALC.' + statusname; LastMSec = getState(objMSec).val; // lese letzten Wert if (statusoverrule === true && LastMSec === 0 ) { // Wenn Geraet keine Einschaltzeit hat und der Verbraucher nicht kleiner eingeschaltet wurde als in der Gruppen tabelle unter status, dann ignoriere setState(objMSec,currSec); // Einschaltzeit setzen } // endif Zeit wurde noch nicht gemessen if(statusoverrule === true && LastMSec > 0) { // etwas ist falsch gelaufen - messung abbrechen setState(objMSec,0); // Einschaltzeit setzen writelog("A","CALC" + ";" + "SetCurrTime" + ";" + Gruppen[nummer][0] + ";" + GeraeteName + ";;;;;" + currSec ); } // endif Zeit wurde vorher gemessen - status sollte aber false sein - messung beenden if(statusoverrule === false && LastMSec > 0) { LastKumSec = getState(objKum).val; // lese kumulierten Wert timediff = currSec - LastMSec; // Berechnen der Zeitdifferenz newkumtime = LastKumSec + timediff; // Berechne die neue kumulierte Zeit setState(objKum,newkumtime); // Schreibe wert in variable newvalue = timediff; // jetzt nur die Zeitdifferenz nehmen und kalkulieren newvalue = newvalue + addition1; // add1 anwenden newvalue = newvalue * faktor; // Faktor anwenden newvalue = newvalue + addition2; // add2 anwenden if(special[nummer][5] !== '') { // Individualfunktionen newvalue = individual(special[nummer][5].toUpperCase(),nummer,newvalue); } newvalue = round(newvalue,rundung); // Rundung anwenden setState(objTime,newvalue); // Schreibe wert in variable setState(objMSec,0); writelog("A","CALC" + ";" + "SaveCALCVal" + ";" + Gruppen[nummer][0] + ";" + GeraeteName + ";;;;;" + newvalue ); } // endif es ist ein zeit objekt und es war eingeschaltet ValKum(day,week,month,year,objKum,objTime,newvalue,newvalue,rundung); // update der Werte in täglichen, wöchentlichen, monatlichen, jährlichen einheiten wenn so gewünscht if(switchupdate) { LastKumSwitch = getState(objSwitch).val; // lese kumulierten Zaehlungen switchdiff = LastKumSwitch + 1; setState(objSwitch,switchdiff); // setzen plus ein Schaltvorgang SwitchKum(day,week,month,year,objSwitch); // update der switches in täglichen, wöchentlichen, monatlichen, jährlichen einheiten wenn so gewünscht } // endif Swtichupdate return; } // endif calc datenpunkt // add/sub datenpunkt - es wird angenommen, dass millisekunden gemessen wurden if (Gruppen[nummer][8] === 'SUB' || Gruppen[nummer][8] === 'ADD') { //Es ist ein sub datenpunkt objTime = objTime + "." + Gruppen[nummer][8].toUpperCase() + "." + statusname; LastMSec = getState(objMSec).val; // lese letzten Wert if (statusoverrule === true && LastMSec === 0 ) { // Wenn Geraet keine Einschaltzeit hat und der Verbraucher nicht kleiner eingeschaltet wurde als in der Gruppen tabelle unter status, dann ignoriere setState(objMSec,currSec); // Einschaltzeit setzen writelog("A", Gruppen[nummer][8] + ";" + "SetCurrTime" + ";" + Gruppen[nummer][0] + ";" + GeraeteName + ";;;;;" + currSec ); } // endif Zeit wurde noch nicht gemessen if(statusoverrule === true && LastMSec > 0) { // da ist was schief gegangen - messung zurücksetzen setState(objMSec,0); // Einschaltzeit setzen writelog("A", Gruppen[nummer][8] + ";" + "SetCurrTimeNull" + ";" + Gruppen[nummer][0] + ";" + GeraeteName + ";;;;;" + LastMSec ); } // endif Zeit wurde vorher gemessen - status sollte aber false sein - messung beenden if(statusoverrule === false && LastMSec > 0) { LastKumSec = getState(objKum).val; // lese kumulierten Wert - Millisekunden aus dem Systembereich lastvalue = getState(objTime).val; // lese kumulierten Wert - letzter umgerechnete Wert diffvalraw = currSec - LastMSec; // Berechnen der Zeitdifferenz newvalue = diffvalraw; // lese aktuellen Wert aud dem veränderten Datenpunkt if(special[nummer][5] !== '') { // Individualfunktionen newvalue = individual(special[nummer][5].toUpperCase(),nummer,diffvalraw); // hier kommt ein umgerechneter Wertaus der Individualfunktion zurück z.B. KG . log("newvalue aus Indiv" +newvalue,"info" ); individualFunc = true; } // endif Individualfunktion newvalue = newvalue + addition1; newvalue = newvalue * faktor; // Faktor anwenden newvalue = newvalue + addition2; if ( Gruppen[nummer][8] === 'ADD') { newvalue = lastvalue + newvalue; // neuer umgerechneter Wert für den Counter newkumtime = LastKumSec + diffvalraw; // neuer nicht umgerechneter Wert für den Systembereich } else { newvalue = lastvalue - newvalue; // neuer umgerechneter Wert für den Counter newkumtime = LastKumSec - diffvalraw; // neuer nicht umgerechneter Wert für den Systembereich } // endif check on add/sub setState(objKum,newkumtime); // Schreibe wert in variable setState(objMSec,0); newvalue = round(newvalue,rundung); // Neuer umgerechneter Gesamtwrt mit Rundung für den Counter setState(objTime,newvalue); // Schreibe neuen Wert in variable ValKum2(nummer, day,week,month,year,objKum,objTime,diffvalraw,addition1,addition2,faktor,rundung,individualFunc); // update der Werte in täglichen, wöchentlichen, monatlichen, jährlichen einheiten wenn so gewünscht setState(objMSec,0); // setzen Millisekunden auf Null um Fehlschaltungen zu vermeiden if(switchupdate) { LastKumSwitch = getState(objSwitch).val; // lese kumulierten Zaehlungen switchdiff = LastKumSwitch + 1; setState(objSwitch,switchdiff); // setzen plus ein Schaltvorgang SwitchKum(day,week,month,year,objSwitch); // update der switches in täglichen, wöchentlichen, monatlichen, jährlichen einheiten wenn so gewünscht } // endif Swtichupdate writelog("A",Gruppen[nummer][8] + ";" + "SetNewTime" +";" + Gruppen[nummer][0] + ";" + GeraeteName +";;;;;;" + timediff + ";;" + newkumtime); } // endif check on false and zeit nicht gemessen return; // ciao - nix mehr zu tun } // endif sub/add datenpunkt // delta datenpunkt - // Delta PLUS Rechnung if (Gruppen[nummer][8] === 'DELTA') { //Es ist ein DELTA datenpunkt objTime = objTime + '.DELTA.' + statusname; lastkumvalue = getState(objTime).val; // lese counter Zaehlungen lastkumvalueobj= getState(objKum).val; // lese system kumulierte Zaehlungen newkumvalue = Number(getState(objGruppe).val); // lese aktuellen Wert aud dem veränderten Datenpunkt newkumvalueobj = newkumvalue; // den unveraenderten Wert merken diffvalraw = newkumvalueobj - lastkumvalueobj; // Rohwert Differenz (also ohne Umrechnung) if(special[nummer][5] !== '') { // Individualfunktionen newkumvalue = individual(special[nummer][5].toUpperCase(),nummer,newkumvalue); individualFunc = true; } newkumvalue = newkumvalue + addition1; newkumvalue = newkumvalue * faktor; // Faktor anwenden newkumvalue = newkumvalue + addition2; diffval = diffvalraw; diffval = diffval + addition1; diffval = diffval * faktor; // Faktor anwenden diffval = diffval + addition2; if (lastkumvalueobj === 0) { diffval = 0; diffvalraw = 0; } // beim ersten Aufruf nicht den ganzen Wert übernehmen if (lastkumvalueobj-DeltaToleranz > newkumvalueobj ) { // Sonderfall, wenn z.B. der Energiezaehler zurücgesetz wurde oder ausgetauscht wurde dann ignorieren lastkumvalueobj = newkumvalueobj; diffval = 0; diffvalraw = 0; } setState(objMSec,diffvalraw); // Einschaltzeit setzen writelog("A","DELTA" + ";" + "Change" + ";" + Gruppen[nummer][0] + ";" + GeraeteName + ";;;" + newkumvalue + ";" + diffval ); setState(objKum,newkumvalueobj); // Schreibe wert in variable newkumvalue = round(newkumvalue,rundung); // Rundung anwendenden setState(objTime,newkumvalue); // den unveraenderten Wert in objKum schreiben ValKum2(nummer,day,week,month,year,objKum,objTime,diffvalraw,addition1,addition2,faktor,rundung,individualFunc); // update der Werte in täglichen, wöchentlichen, monatlichen, jährlichen einheiten wenn so gewünscht if(switchupdate) { LastKumSwitch = getState(objSwitch).val; // lese kumulierten Zaehlungen switchdiff = LastKumSwitch + 1; setState(objSwitch,switchdiff); // setzen plus ein Schaltvorgang SwitchKum(day,week,month,year,objSwitch); // update der switches in täglichen, wöchentlichen, monatlichen, jährlichen einheiten wenn so gewünscht } // endif Swtichupdate return; } // endif delta datenpunkt // deltaM datenpunkt - // Delta Minus Rechnung if (Gruppen[nummer][8] === 'DELTAM') { //Es ist ein DELTA datenpunkt objTime = objTime + '.DELTAM.' + statusname; lastkumvalue = getState(objTime).val; // lese kumulierte Zaehlungen lastkumvalueobj= getState(objKum).val; // lese system kumulierte Zaehlungen newkumvalue = Number(getState(objGruppe).val); // lese aktuellen Wert aud dem veränderten Datenpunkt newkumvalueobj = newkumvalue; // den unveraenderten Wert merken diffvalraw = lastkumvalueobj - newkumvalueobj; // Rohwert Differenz (also ohne Umrechnung) if(special[nummer][5] !== '') { // Individualfunktionen newkumvalue = individual(special[nummer][5].toUpperCase(),nummer,newkumvalue); individualFunc = true; } newkumvalue = newkumvalue + addition1; newkumvalue = newkumvalue * faktor; // Faktor anwenden newkumvalue = newkumvalue + addition2; diffval = diffvalraw; diffval = diffval + addition1; diffval = diffval * faktor; // Faktor anwenden diffval = diffval + addition2; if (lastkumvalueobj === 0 ) { diffval = 0;diffvalraw = 0; } // beim ersten Aufruf nicht den ganzen Wert übernehmen if (lastkumvalueobj+DeltaToleranz < newkumvalueobj ) { // Sonderfall, wenn z.B. getankt wurde dann ignorieren lastkumvalueobj = newkumvalueobj; diffval = 0; diffvalraw = 0; } setState(objMSec,diffvalraw); // Einschaltzeit setzen writelog("A","DELTA" + ";" + "Change" + ";" + Gruppen[nummer][0] + ";" + GeraeteName + ";;;" + newkumvalue + ";" + diffval ); setState(objKum,newkumvalueobj); // Schreibe wert in variable newkumvalue = round(newkumvalue,rundung); // Rundung anwenden setState(objTime,newkumvalue); // Schreibe Zeitformat in variable ValKum2(nummer,day,week,month,year,objKum,objTime,diffvalraw,addition1,addition2,faktor,rundung,individualFunc); // update der Werte in täglichen, wöchentlichen, monatlichen, jährlichen einheiten wenn so gewünscht if(switchupdate) { LastKumSwitch = getState(objSwitch).val; // lese kumulierten Zaehlungen switchdiff = LastKumSwitch + 1; setState(objSwitch,switchdiff); // setzen plus ein Schaltvorgang SwitchKum(day,week,month,year,objSwitch); // update der switches in täglichen, wöchentlichen, monatlichen, jährlichen einheiten wenn so gewünscht } // endif Swtichupdate return; } // endif delta datenpunkt if (GeraeteStatus === true) { geraetestatusC = "true"; } //wandle in character = "true" statt true if (GeraeteStatus === false) { geraetestatusC = "false"; } //wandle in character = "true" statt true // TIME Datenpunkt hier LEVEL Geraet if (objGruppe.match('LEVEL')) { // ist es ein LEVEL Geraet ? if (Gruppen[nummer][8] === '') { return; } // Gibt es einen Status in der Gruppentabelle ? wenn nein ciao - es wurd nur spalte 8 abgefragt if (Gruppen[nummer][18] === true) { return; } // Objekt ist mit refresh gekennzeichnet - keine updates LastMSec = getState(objMSec).val; // lese letzten Wert var statusvalue = parseInt(Gruppen[nummer][8],10); // in der Gruppentabelle Spalte 8 wird eine Zahl erwartet für LEVEL Geraete - in eine integer Zahl umwandeln if (GeraeteStatus >= statusvalue) { // Geraet wurde eingeschaltet - Einschaltzeit setzen if (LastMSec === 0 ) { // Wenn Geraet keine Einschaltzeit hat und der Verbraucher nicht kleiner eingeschaltet wurde als in der Gruppen tabelle unter status, dann ignoriere setState(objMSec,currSec); // Einschaltzeit setzen FormTimeSingle = TimeCalc(FormTimeSingle,currSec,nummer); // Zeit in lesbarem Format ddd:hh:mm:ss writelog("A","LEVEL" + ";" + "SetCurrTime" + ";" + Gruppen[nummer][0] + ";" + GeraeteName + ";" + GeraeteStatus + ";" + FormTimeSingle + ";" + currSec ); } } else { // Geraet wurde ausgeschaltet objTime = objTime + '.TIME.' + statusname; LastKumSec = getState(objKum).val; // lese kumulierten Wert if (LastMSec > 0 ) { // Geraet hatte eine Einschaltzeit gespeichert - jetzt rechnen und zurücksetzen timediff = currSec - LastMSec; // Berechnen der Zeitdifferenz if(special[nummer][5] !== '') { // Individualfunktionen timediff = individual(special[nummer][5].toUpperCase(),nummer,timediff); } FormTimeSingle = TimeCalc(FormTimeSingle,timediff,nummer); // laufzeit in lesbarem Format ddd:hh:mm:ss newkumtime = LastKumSec + timediff; // Berechne die neue kumulierte Zeit FormTimeKum = TimeCalc(FormTimeKum,newkumtime,nummer); // Berechne Betriebsstunden Zeitformat von millisekunden in dd:hh:mm:ss = FormTime setState(objKum,newkumtime); // Schreibe Zeitformat in variable setState(objTime,FormTimeKum); // Schreibe Zeitformat in variable TimeKum(day,week,month,year,objKum,objTime,timediff,nummer); // update der Zeiten in täglichen, wöchentlichen, monatlichen, jährlichen einheiten wenn so gewünscht setState(objMSec,0); // setzen Millisekunden auf Null um Fehlschaltungen zu vermeiden TimeKum(day,week,month,year,objKum,objTime,timediff,nummer); // update der Zeiten in täglichen, wöchentlichen, monatlichen, jährlichen einheiten wenn so gewünscht if(switchupdate) { LastKumSwitch = getState(objSwitch).val; // lese kumulierten Zaehlungen switchdiff = LastKumSwitch + 1; // den Schaltzaehler um 1 erhöhen setState(objSwitch,switchdiff); // setzen plus ein Schaltvorgang SwitchKum(day,week,month,year,objSwitch); // update der switches in täglichen, wöchentlichen, monatlichen, jährlichen einheiten wenn so gewünscht } // endif switchupdate writelog("A","LEVEL" + ";" + "SetNewTime" +";" + Gruppen[nummer][0] + ";" + GeraeteName +";" + GeraeteStatus + " ; ; ;" + FormTimeSingle + ";" + timediff + ";" + FormTimeKum +";" + newkumtime); } // endif statusname } // Geraet war vorher eingeschaltet return; // ciao - nix mehr zu tun } // endif es ist ein level Geraet // TIME Datenpunkt für NICHT LEVEL Geraete // Jetzt wird die Betriebszeit errechnet für den vorherigen Status und die Einschaltzeit zurückgesetzt for ( zaehler = 8; zaehler < 18; zaehler++) { // Spalte 8 - 18 fuer die Gruppentabelle entspriche logname -8 if (Gruppen[nummer][zaehler] === '') { continue; } // Statustabelle Status is initial - dann zurück zum loop if (Gruppen[nummer][18] === true) { continue; } // Objekt ist mit refresh gekennzeichnet - keine updates gruppenstatusC = Gruppen[nummer][zaehler].toString(); // status aus der Gruppentabelle in einen String umwandeln objMSec = GrpSystem[nummer][0]; statusname = Gruppen[nummer][zaehler]; // der status ist ein Teil des speicherpfades if (logname[nummer][zaehler-8] !== '') { // Gibt es einen Status in der logname tabelle ? wenn ja merken mit vorrang statusname = logname[nummer][zaehler-8]; } // endif logname tabelle // der aktuelle Status wird mit der Startzeit gespeichert if (geraetestatusC === gruppenstatusC ) { // der aktuelle geraete status wurde gefunden in der gruppentabelle objMSec = objMSec + "." + statusname; // setze pfad für MSec zusammen LastMSec = getState(objMSec).val; // lese letzten Wert setState(objMSec,currSec); // merken millisekunden zum Zeitpunkt "Einschalten" FormTimeSingle = TimeCalc(FormTimeSingle,currSec,nummer); // Zeit in lesbarem Format ddd:hh:mm:ss writelog("A","STATUS" + ";" + "SetCurrTime" + ";" + Gruppen[nummer][0] + ";" + GeraeteName +";" + GeraeteStatus + ";" + FormTimeSingle + ";" + currSec ); continue; // Statusbearbeitung aktueller Status beendet } // endif Gruppenstatus = aktueller status // jetzt die Status behandeln, wenn vorher mal eingeschaltet war objKum = GrpSystem[nummer][1]; objTime = GrpSystem[nummer][2]; objSwitch = GrpSystem[nummer][2]; zaehler2 = addZero(zaehler).zero2; objMSec = objMSec + "." + statusname; // vervollständige Pfadnamen objKum = objKum + "." + statusname; objTime = objTime + '.TIME.' + statusname; objSwitch = objSwitch+ '.SWITCH.' + statusname; LastMSec = getState(objMSec).val; // lese letzten Wert LastKumSec = getState(objKum).val; // lese kumulierten Wert if (LastMSec > 0 ) { // der letzte Status muss einen Wert haben und wird daraufhin berechnet // erst die Zeitwerte timediff = currSec - LastMSec; // Berechnen der Zeitdifferenz if(special[nummer][5] !== '') { // Individualfunktionen timediff = individual(special[nummer][5].toUpperCase(),nummer,timediff); } FormTimeSingle = TimeCalc(FormTimeSingle,timediff,nummer); // laufzeit in lesbarem Format ddd:hh:mm:ss newkumtime = LastKumSec + timediff; // Berechne die neue kumulierte Zeit FormTimeKum = TimeCalc(FormTimeKum,newkumtime,nummer); // Berechne Betriebsstunden Zeitformat von millisekunden in dd:hh:mm:ss = FormTime setState(objKum,newkumtime); // Schreibe Zeitformat in variable setState(objTime,FormTimeKum); // Schreibe Zeitformat in variable setState(objMSec,0); // setzen Millisekunden auf Null um Fehlschaltungen zu vermeiden TimeKum(day,week,month,year,objKum,objTime,timediff,nummer); // update der Zeiten in täglichen, wöchentlichen, monatlichen, jährlichen einheiten wenn so gewünscht // jetzt die Schaltzaehlung if(switchupdate) { LastKumSwitch = getState(objSwitch).val; // lese kumulierten Zaehlungen switchdiff = LastKumSwitch + 1; setState(objSwitch,switchdiff); // setzen plus ein Schaltvorgang SwitchKum(day,week,month,year,objSwitch); // update der switches in täglichen, wöchentlichen, monatlichen, jährlichen einheiten wenn so gewünscht } // endif switchupdate writelog("A","STATUS" + ";" + "SetNewTime" + ";" + Gruppen[nummer][0] + ";" + GeraeteName +";" + GeraeteStatus + "; ; ;" + FormTimeSingle + ";" + timediff + ";" + FormTimeKum +";" + newkumtime); } // endif LastMSec } // endfor } // ende Funktion //---------------------------------------------------------------------------------------------------- // Funktion Zeitabschnitte Nullen wird täglich aufgerufen oder wenn refresh eingestellt ist //----------------------------------------------------------------------------------------------------- function TimeNull(zaehler,type,periode,histupd) { // uebergabewerte // zaehler = momentane HM-ID // type = alle Methoden // periode = day, week, month, year // histupd (fortschreibung der historie = true / false) var month = addZero(new Date().getMonth()+1).zero2; // aktueller Monat var monthvor = addZero(new Date().getMonth()).zero2; // Vormonat if (month === "01") { monthvor = "12"; } // im Falle von jahreswechsel var year = new Date().getFullYear(); // aktuelles jahr var yearvor =new Date().getFullYear()-1; // Jahr fuer die Historyfortschreibung - also Vorjahr var statusname =""; // Statusname fur die Fortschreibung/Nullung var updateobj = " "; // Pfad fuer die TIME und SWITCH Variablen var histupdateobj; // Pfad fuer die Historyfortschreibung var kumvalue; // letzten Wert merken fuer das log var objGruppe = Gruppen[zaehler][0]; // die iobroker bwz. HM object ID var objMSec = GrpSystem[zaehler][0]; // BSZ.SystemGrp00.MSec var objKum = GrpSystem[zaehler][1]; // BSZ.SystemGrp00.Kum var objTime = GrpSystem[zaehler][2]; // BSZ.Counter.Feldname var objSwitch = GrpSystem[zaehler][2]; // BSZ.Counter.Feldname type = type.toUpperCase(); // umwandeln in Grossbuchstaben GeraeteName = getObject(objGruppe).common.name; // Auslesen der Bezeichnung des Geraetes for ( var statuszaehler = 8; statuszaehler < 18; statuszaehler++) { if (Gruppen[zaehler][statuszaehler] === '' ) {continue; } // kein Status dann nächster loop if (type === "DELTA" && Gruppen[zaehler][statuszaehler] !== type ) {continue; } // kein Status update für Methode dann nächster loop if (type === "ADD" && Gruppen[zaehler][statuszaehler] !== type ) {continue; } // kein Status update für Methode dann nächster loop if (type === "SUB" && Gruppen[zaehler][statuszaehler] !== type ) {continue; } // kein Status update für Methode dann nächster loop if (type === "CALC" && Gruppen[zaehler][statuszaehler] !== type ) {continue; } // kein Status update für Methode dann nächster loop if (type === "BOOL" && Gruppen[zaehler][statuszaehler] !== type ) {continue; } // kein Status update für Methode dann nächster loop if (type === "DELTAM" && Gruppen[zaehler][statuszaehler] !== type ) {continue; } // kein Status update für Methode dann nächster loop statusname = Gruppen[zaehler][statuszaehler]; // merken Status aus der Gruppentab if (logname[zaehler][statuszaehler-8] !== '') { // Gibt es einen Status in der logname tabelle ? wenn ja merken mit vorrang statusname = logname[zaehler][statuszaehler-8]; } // zurücksetzen der DAY variablen if (type !== "SWITCH" &&periode === "day" && Gruppen[zaehler][3] === true) { // Endif taegliche Summmierung aktiv ? updateobj = objTime + "." + type + "." + statusname + ".DAY"; updateobjb= objTime + "." + type + "." + statusname + ".DAY.BEFORE"; if (ObjectExists(updateobj)) { // Ist taegliche Betriebszeitenkumulation eingeschaltet ? kumvalue = getState(updateobj).val; // vor nullung noch den Wert merken setState(updateobj,0); // taeglicher Zaehler auf setState(updateobjb,kumvalue); // Vorperiode mit WErt aus aktueller Periode sichern updateobj = objKum + "." + statusname + ".DAY"; // das system kum objekt fuer TAG zurücksetzen setState(updateobj, 0); // zurücksetzen des system Kumulationsobjektes writelog("T",type + ";" + periode + ";" + Gruppen[zaehler][0] + ";" + GeraeteName +";" + updateobj+ ";" + kumvalue); // schreibe log in externe Datei // zurücksetzen der SWITCH DAY variablen } // Endif objekt existiert } // Endif taegliche Summmierung aktiv ? if (type === "SWITCH" && periode === "day" && Gruppen[zaehler][3] === true && Gruppen[zaehler][7] === true) { // sumierung und switch sind aktiv updateobj = objSwitch + "." + type + "." + statusname + ".DAY"; updateobjb= objSwitch + "." + type + "." + statusname + ".DAY.BEFORE"; if (ObjectExists(updateobj)) { // Ist taegliche Betriebszeitenkumulation eingeschaltet ? kumvalue = getState(updateobj).val; // vor nullung noch den Wert merken writelog("T",type + ";" + periode + ";" + Gruppen[zaehler][0] + ";" + GeraeteName +";" + updateobj+ ";" + kumvalue); // schreibe log in externe Datei setState(updateobj,0); // taeglicher Zaehler auf setState(updateobjb,kumvalue); // Vorperiode mit WErt aus aktueller Periode sichern } // endif geraet exister } // zurücksetzen der WEEK variablen if (type !== "SWITCH" && periode === "week" && Gruppen[zaehler][4] === true) { // wöchentliche summierung aktiv updateobj = objTime + "." + type + "." + statusname + ".WEEK"; // Pfad zusammensetzen updateobjb = objTime + "." + type + "." + statusname + ".WEEK.BEFORE"; if (ObjectExists(updateobj)) { // existiert das objekt ? kumvalue = getState(updateobj).val; // vor nullung noch den Wert merken setState(updateobj,0); // Wöchentlicher Zaehler auf 0 updateobj = objKum + "." + statusname + ".WEEK"; // das system kum objekt fuer WEEK zurücksetzen setState(updateobj, 0); // zurücksetzen des system Kumulationsobjektes setState(updateobjb,kumvalue); // Vorperiode mit WErt aus aktueller Periode sichern writelog("T",type + ";"+ periode + ";" + Gruppen[zaehler][0] + ";" + GeraeteName +";" + updateobj+ ";" + kumvalue); // schreibe log in externe Datei } // endif objekt existiert } // Endif woechentliche Summmierung aktiv ? if (type === "SWITCH" && periode === "week" && Gruppen[zaehler][4] === true && Gruppen[zaehler][7] === true) { // wöchentliche summierung und switch aktiv updateobj = objSwitch + "." + type + "." + statusname + ".WEEK"; // Pfad zusammensetzen updateobjb= objSwitch + "." + type + "." + statusname + ".WEEK.BEFORE"; if (ObjectExists(updateobj)) { // existiert das objekt ? kumvalue = getState(updateobj).val; // vor nullung noch den Wert merken setState(updateobj,0); // woechentlicher Zaehler auf 0 setState(updateobjb,kumvalue); // Vorperiode mit WErt aus aktueller Periode sichern writelog("T",type + ";" + periode + ";" + Gruppen[zaehler][0] + ";" + GeraeteName +";" + updateobj+ ";" + kumvalue); // schreibe log in externe Datei } // object existiert } // Endif woechentliche Summmierung und switch aktiv ? // zurücksetzen der MONTH variablen if (type !== "SWITCH" && periode === "month" && Gruppen[zaehler][5] === true) { // monatliche summierung aktiv updateobj = objTime + "." + type + "." + statusname + ".MONTH"; updateobjb= objTime + "." + type + "." + statusname + ".MONTH.BEFORE"; if (ObjectExists(updateobj)) { // existiert das Objekt ? kumvalue = getState(updateobj).val; // vor nullung noch den Wert merken setState(updateobj,0); // Wöchentlicher Zaehler auf 0 setState(updateobjb,kumvalue); // Vorperiode mit WErt aus aktueller Periode sichern writelog("T",type + ";" + periode + ";" + Gruppen[zaehler][0] + ";" + GeraeteName +";" + updateobj+ ";" + kumvalue); // schreibe log in externe Datei // evt zuerst den Monatswert in die Historie speichern if (Gruppen[zaehler][2] === true && histupd === true) { // soll History Variable soll angelegt werden ? histupdateobj = objTime + '.HISTORY.' + statusname +'.MONTH.'; // Pfad fuer History des nächsten Monats if (month === "01") { // Jahreswechsel setState(histupdateobj+yearvor+monthvor,kumvalue); // Jahreswechsel als vorjahr nehmen nur Neujahr } else { setState(histupdateobj+year+monthvor,kumvalue); // kein jahreswechsel also in letzten Monat speichern } } // endif History soll angelegt werden setState(updateobj,0); // Monatlicher Zaehler auf 0 für updateobj = objKum + "." + statusname + ".MONTH"; // das system kum objekt fuer Monat zurücksetzen setState(updateobj, 0); } // Endif objekt existiert } // Endif monatliche Summmierung aktiv ? if (type === "SWITCH" && periode === "month" && Gruppen[zaehler][5] === true && Gruppen[zaehler][7] === true) { // monatliche summierung und switch aktiv updateobj = objSwitch + "." + type + "." + statusname + ".MONTH"; updateobjb= objSwitch + "." + type + "." + statusname + ".MONTH.BEFORE"; if (ObjectExists(updateobj)) { // existiert das Objekt ? kumvalue = getState(updateobj).val; // vor nullung noch den Wert merken setState(updateobj,0); // monatlicher Zaehler auf 0 setState(updateobjb,kumvalue); // Vorperiode mit WErt aus aktueller Periode sichern writelog("T",type + ";" + periode + ";" + Gruppen[zaehler][0] + ";" + GeraeteName +";" + updateobj+ ";" + kumvalue); // schreibe log in externe Datei } // Endif objekt exists } // monatliche summierung und switch aktiv // zurücksetzen der YEAR variablen if (type !== "SWITCH" && periode === "year" && Gruppen[zaehler][6] === true) { // jaehrliche summierung aktiv updateobj = objTime + "." + type + "." + statusname + ".YEAR"; updateobjb= objTime + "." + type + "." + statusname + ".YEAR.BEFORE"; if (ObjectExists(updateobj)) { // existiert das Objekt ? kumvalue =getState(updateobj).val; // vor nullung noch den Wert merken // evt zuerst den Jahreswert in die Historie speichern if (Gruppen[zaehler][2] === true && histupd === true) { // soll History Variable angelegt werden ? histupdateobj = objTime + '.HISTORY.' + statusname +'.YEAR.'; // Pfad fuer History des nächsten Monats setState(histupdateobj+yearvor,kumvalue); // Wert in das letzte Jahr Monat speichern } // endif History soll angelegt werden setState(updateobj,0); // jaehrlicher Zaehler auf 0 updateobj = objKum + "." + statusname + ".YEAR"; // das system kum objekt fuer JAHR zurücksetzen setState(updateobj, 0); setState(updateobjb,kumvalue); // Vorperiode mit WErt aus aktueller Periode sichern writelog("T",type + ";" + periode + ";" + Gruppen[zaehler][0] + ";" + GeraeteName +";" + updateobj+ ";" + kumvalue); // schreibe log in externe Datei } // Endif objekt existis } // Endif jaehrliche Summmierung existent ? if (type === "SWITCH" && periode === "year" && Gruppen[zaehler][6] === true && Gruppen[zaehler][7] === true) { // jaehrliche summierung und switch aktiv updateobj = objSwitch + "." + type + "." + statusname + ".YEAR"; updateobjb= objSwitch + "." + type + "." + statusname + ".YEAR.BEFORE"; if (ObjectExists(updateobj)) { // Ist jaehrliche Betriebszeitenkumulation eingeschaltet ? kumvalue = getState(updateobj).val; // vor nullung noch den Wert merken setState(updateobj,0); // jaehrlicher Zaehler auf 0 setState(updateobjb,kumvalue); // Vorperiode mit WErt aus aktueller Periode sichern writelog("T",type + ";" + periode + ";" + Gruppen[zaehler][0] + ";" + GeraeteName +";" + updateobj+ ";" + kumvalue); // schreibe log in externe Datei } } } // endfor statusloop } // end function //----------------------------------------------------------------------------------------------------- // Funktion zum Anlegen der Variablen im System //----------------------------------------------------------------------------------------------------- function CreateDelStates(){ var zaehlerstatus = 0; var type = "TIME"; for (var zaehler = 0, zaehler_array = Gruppen.length; zaehler < zaehler_array; zaehler++) { zaehler2 = addZero(zaehler).zero2; if (Gruppen[zaehler][0] === "initial") { continue; } // Check Gueltigkeit object for ( zaehlerstatus = 8; zaehlerstatus < 18; zaehlerstatus++) { // Spalte 8 - 18 fuer die Gruppentabelle entspriche logname -8 if (Gruppen[zaehler][zaehlerstatus] === '') { continue; } //Status is initial if (type !== "TIME" && zaehlerstatus > 8) { break; // Multiple Status werden nur gebraucht fuer TIME Objekte } type = "TIME"; if (Gruppen[zaehler][8] === 'DELTA') { type = "DELTA"; } if (Gruppen[zaehler][8] === 'DELTAM') { type = "DELTAM"; } if (Gruppen[zaehler][8] === 'ADD') { type = "ADD"; } if (Gruppen[zaehler][8] === 'SUB') { type = "SUB"; } if (Gruppen[zaehler][8] === 'CALC') { type = "CALC"; } if (Gruppen[zaehler][8] === 'BOOL') { type = "BOOL"; } // Status fuer die Methoden anlegen CreateDelStateSingle(zaehler,zaehlerstatus,type,"method"); // anlegen fuer alle types (ausser hostory und switch ) bis zum statuslevel // Status fuer die system struktur anlegen if (Gruppen[zaehler][3] === true) { // soll eine DAY kumulations Variable angelegt werden ? CreateDelStateSingle(zaehler,zaehlerstatus,type,"SYSTEMday"); // anlegen fuer die System Struktur Periode } // endif Summierung soll angelegt werde if (Gruppen[zaehler][4] === true) { // soll eine week kumulations Variable angelegt werden ? CreateDelStateSingle(zaehler,zaehlerstatus,type,"SYSTEMweek"); // anlegen fuer die System Struktur Periode } // endif Summierung soll angelegt werde if (Gruppen[zaehler][5] === true) { // soll eine month kumulations Variable angelegt werden ? CreateDelStateSingle(zaehler,zaehlerstatus,type,"SYSTEMmonth"); // anlegen fuer die System Struktur Periode } // endif Summierung soll angelegt werde if (Gruppen[zaehler][6] === true) { // soll eine year kumulations Variable angelegt werden ? CreateDelStateSingle(zaehler,zaehlerstatus,type,"SYSTEMyear"); // anlegen fuer die System Struktur Periode } // endif Summierung soll angelegt werde // Methoden Struktur (ausser history und Status anlegen / loeschen) if (Gruppen[zaehler][3] === true) { // soll eine DAY kumulations Variable angelegt werden ? CreateDelStateSingle(zaehler,zaehlerstatus,type,"day"); } // endif Summierung soll angelegt werde if (Gruppen[zaehler][4] === true) { // soll eine week kumulations Variable angelegt werden ? CreateDelStateSingle(zaehler,zaehlerstatus,type,"week"); } // endif Summierung soll angelegt werde if (Gruppen[zaehler][5] === true) { // soll eine month kumulations Variable angelegt werden ? CreateDelStateSingle(zaehler,zaehlerstatus,type,"month"); } // endif Summierung soll angelegt werde if (Gruppen[zaehler][6] === true) { // soll eine year kumulations Variable angelegt werden ? CreateDelStateSingle(zaehler,zaehlerstatus,type,"year"); } // endif Summierung soll angelegt werde // Switch Stuktur anlengen / loeschen if (Gruppen[zaehler][7] === true ) { // Soll auch eine Switch Variable angelegt werden CreateDelStateSingle(zaehler,zaehlerstatus,"SWITCH","none"); if (Gruppen[zaehler][3] === true) { // soll eine DAY kumulations Variable angelegt werden ? CreateDelStateSingle(zaehler,zaehlerstatus,"SWITCH","day"); } if (Gruppen[zaehler][4] === true) { // soll eine week kumulations Variable angelegt werden ? CreateDelStateSingle(zaehler,zaehlerstatus,"SWITCH","week"); } if (Gruppen[zaehler][5] === true) { // soll eine month kumulations Variable angelegt werden ? CreateDelStateSingle(zaehler,zaehlerstatus,"SWITCH","month"); } if (Gruppen[zaehler][6] === true) { // soll eine year kumulations Variable angelegt werden ? CreateDelStateSingle(zaehler,zaehlerstatus,"SWITCH","year"); } } // endif Switch Variablen anzulegen ? // History Struktur anlegen/ loeschen if (Gruppen[zaehler][2] === true && Gruppen[zaehler][5] === true) { // Anlegen der Monats History Werte das laufende Jahr wenn Monatskumulation und Historie angeschaltet CreateDelStateSingle(zaehler,zaehlerstatus,"HISTORY","month"); } if (Gruppen[zaehler][2] === true && Gruppen[zaehler][6] === true) { // Anlegen der Jahres History Werte das laufende Jahr wenn Jahreskumulation und Historie angeschaltet CreateDelStateSingle(zaehler,zaehlerstatus,"HISTORY","year"); } } // Ende FOR Statuszaheler } // Ende FOR Gruppenzaehler } // ende Funktion //----------------------------------------------------------------------------------------------------- // Funktion zum Anlegen der Variablen im System - hier Statusinformationen //----------------------------------------------------------------------------------------------------- function CreateDelStateSingle(zeile,spalte,type,periode) { // Zeile = Zeile der Gruppentabelle // spalte = spalte der Gruppentabelle (status) // type = alle Methoden // periode = day week month year oder none var actionDel = false; if (Gruppen[zeile][19] === true && Gruppen[zeile][18] === true) { // wenn actionDel = true dann soll geloescht werden actionDel = true; } if (actionDel === false && Gruppen[zeile][18] === true) { // kein loeschen aber auch nicht anlegen da Refresh auf gestoppt gesetzt return; } var statusname = Gruppen[zeile][spalte]; if (logname[zeile][spalte-8] !== '') { // Gibt es einen Status in der logname tabelle ? wenn ja merken mit vorrang statusname = logname[zeile][spalte-8]; } if (statusname === '' ) { return; } var pathCount = countLocation + '.' + Gruppen[zeile][1]; var pathSysM = sysLocation + '.Grp' + addZero(zeile).zero2 + 'MSec.' + statusname; var pathSysK = sysLocation + '.Grp' + addZero(zeile).zero2 + 'Kum.' + statusname; var pathCLevel3 = pathCount + "." + type + "." + statusname; var pathHistM = pathCLevel3 + ".MONTH."; var pathHistY = pathCLevel3 + ".YEAR."; var pathCLevel4 = pathCLevel3 + ".DAY"; var pathCLevel4b= pathCLevel3 + ".YEAR.BEFORE"; var year = new Date().getFullYear(); var month = addZero(new Date().getMonth()+1).zero2; // aktueller Monat var yearvor =new Date().getFullYear()-1; // Jahr fuer die Historyfortschreibung - also Vorjahr if(periode === "method" ) { // Hier werden nur die Status der types angelegt (ohne perioden) if (actionDel === false) { createState(pathSysM , 0); // Anlegen systemeintrag msec createState(pathSysK , 0); // anlegen systemeintrag kum createState(pathCLevel3 , 0); } else { ObjectExistsDelState(pathSysM ); // loeschen systemeintrag msec ObjectExistsDelState(pathSysK ); // loeschen systemeintrag kum ObjectExistsDelState(pathCLevel3); // loeschen counteintrag oberster level } // endif del } if(type === "SWITCH" && periode === "none") { if (actionDel === false) { createState(pathCLevel3 , 0); } else { ObjectExistsDelState(pathCLevel3); // loeschen counteintrag oberster level } // endif del } if(periode === "SYSTEMday" ) { pathSysK = pathSysK + ".DAY"; if (actionDel === false) { createState(pathSysK , 0); } else { ObjectExistsDelState(pathSysK ); } // endif del } if(periode === "SYSTEMweek" ) { pathSysK = pathSysK + ".WEEK"; if (actionDel === false) { createState(pathSysK , 0); } else { ObjectExistsDelState(pathSysK ); } // endif del } if(periode === "SYSTEMmonth" ) { pathSysK = pathSysK + ".MONTH"; if (actionDel === false) { createState(pathSysK , 0); } else { ObjectExistsDelState(pathSysK ); } // endif del } if(periode === "SYSTEMyear" ) { pathSysK = pathSysK + ".YEAR"; if (actionDel === false) { createState(pathSysK , 0); } else { ObjectExistsDelState(pathSysK ); } // endif del } if(periode === 'day' && periode !== "none") { pathCLevel4 = pathCLevel3 + ".DAY"; pathCLevel4b= pathCLevel3 + ".DAY.BEFORE"; if (actionDel === false) { createState(pathCLevel4 , 0); createState(pathCLevel4b, 0); } else { ObjectExistsDelState(pathCLevel4 ); ObjectExistsDelState(pathCLevel4b); } // endif del } // endif periode if(periode === 'week' && periode !== "none") { pathCLevel4 = pathCLevel3 + ".WEEK"; pathCLevel4b= pathCLevel3 + ".WEEK.BEFORE"; if (actionDel === false) { createState(pathCLevel4 , 0); createState(pathCLevel4b, 0); } else { ObjectExistsDelState(pathCLevel4); ObjectExistsDelState(pathCLevel4b); } // endif del } // endif periode if(periode === 'month' && periode !== "none") { pathCLevel4 = pathCLevel3 + ".MONTH"; pathCLevel4b= pathCLevel3 + ".MONTH.BEFORE"; if (actionDel === false) { createState(pathCLevel4 , 0); createState(pathCLevel4b, 0); } else { ObjectExistsDelState(pathCLevel4 ); ObjectExistsDelState(pathCLevel4b); } // endif del } // endif periode if(periode === 'year' && periode !== "none") { pathCLevel4 = pathCLevel3 + ".YEAR"; pathCLevel4b= pathCLevel3 + ".YEAR.BEFORE"; if (actionDel === false) { createState(pathCLevel4 , 0); createState(pathCLevel4b, 0); } else { ObjectExistsDelState(pathCLevel4 ); ObjectExistsDelState(pathCLevel4b); } // endif del } // endif periode if (type === "HISTORY" && periode === "month") { for ( i = 1; i <= 12; i++) { month = addZero(i).zero2; // Monat mit führender null if (actionDel === false) { createState(pathHistM + year + month, 0); // alle Monate des jahres anlegen } else { ObjectExistsDelState(pathHistM + year + month); // alle Monate des jahres loeschen } // endif del } // endfor if (actionDel === false) { createState(pathHistM + yearvor + "12", 0); // letzten Monat vor Jahreswechsel anlegen } else { ObjectExistsDelState(pathHistM + yearvor + "12"); //letzten Monat vor Jahreswechsel loeschen } // endif del } // endif history if (type === "HISTORY" && periode === "year") { if (actionDel === false) { createState(pathHistY + year, 0); //Jahr anlegen createState(pathHistY + yearvor, 0); //Vorjahr anlegen } else { ObjectExistsDelState(pathHistY + year); //Jahr loeschen ObjectExistsDelState(pathHistY + yearvor); //Vorjahr loeschen } // endif del } // endif history } // ende Funktion //----------------------------------------------------------------------------------------------------- // Funktion schreibt einen Logeintrag in das Filesystem und auch in das interne Log-System //----------------------------------------------------------------------------------------------------- function writelog(type,string) { // 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 = " "; if (type === "A" ) { // log für Statuswechsel if (logflag === true) { // logging ist aktiviert if (fs.existsSync(LogPath)) { fs.appendFileSync(LogPath, logdate+" ;"+logtime+" ;"+string + "\n"); // Füge Satz in Datei ein } else { log("Logfile nicht gefunden - wird angelegt", "info"); headerLine= "Datum;Uhrzeit;Type;Activiry;HM-ID;Objektbezeichnung;Status;CurrentTime;CurrentTime MSec;DiffTime ;DiffTime MSec;KumTimeZeit;KumTime Msec"; fs.appendFileSync(LogPath, headerLine + "\n"); // Füge Satz in Datei ein fs.appendFileSync(LogPath, logdate+" ;"+logtime+" ;"+string + "\n"); // Füge Satz in Datei ein } // endif Filecheck } // logging aktiviert fuer statuswechsel } // type ist statuswechsel if (type === "T" ) { // log für Zeit-Kumulation if (Timelogflag === true) { // logging ist aktiviert if (fs.existsSync(TimeLogPath)) { fs.appendFileSync(TimeLogPath, logdate+" ;"+logtime+" ;"+string + "\n"); // Füge Satz in Datei ein } else { log("Timekumulations-Logfile nicht gefunden - wird angelegt", "info"); headerLine= "Datum;Uhrzeit;Type;Object;HM-ID;Objektbezeichnung;Pfad;genullter Wert"; fs.appendFileSync(TimeLogPath, headerLine + "\n"); // Füge Satz in Datei ein fs.appendFileSync(TimeLogPath, logdate+" ;"+logtime+" ;"+string + "\n"); // Füge Satz in Datei ein } // Ende check on logflag } // logging aktiviert fuer time kumulation } // log für statuswechsel } // Ende Funktion //----------------------------------------------------------------------------------------------------- // Loeschen eines States mit existent Abfrage //----------------------------------------------------------------------------------------------------- function ObjectExistsDelState(path) { if (getState(path)) { // Existiert der Datenpunkt ? deleteState(path); } // endif check on datenpunkt exists } // ende Funktion //----------------------------------------------------------------------------------------------------- // Ermittle Wochentag //----------------------------------------------------------------------------------------------------- function GetWeekday(nummer) { var weekdaytxt = "not valid"; if(nummer === 1 ) { weekdaytxt = "MO"; } if(nummer === 2 ) { weekdaytxt = "TU"; } if(nummer === 3 ) { weekdaytxt = "WE"; } if(nummer === 4 ) { weekdaytxt = "TH"; } if(nummer === 5 ) { weekdaytxt = "FR"; } if(nummer === 6 ) { weekdaytxt = "SA"; } if(nummer === 7 ) { weekdaytxt = "SU"; } return weekdaytxt; } // ende Funktion //----------------------------------------------------------------------------------------------------- // Funktion zur Ueberpruefung ob die angegebenen Geraete exisiteren //----------------------------------------------------------------------------------------------------- function ObjectExists(objGruppe) { back = false; if (SpaceChk.test(objGruppe)) { // objIDGruppe darf kein space enthalten // ist ein Geraet ueberhaupt zugeordnet ? return back; } // endif IDGruppe hat kein assignment if (getState(objGruppe)) { // Existiert das Geraet ? back = true; } else { log("Geraet existiert nicht - bitte in den Einstellungen ueberpruefen - Gruppe " + objGruppe, "info"); } // endif check on Geraet exists return back; } // ende Funktion //----------------------------------------------------------------------------------------------------- // Funktion zur Zeitdifferenzrechnung mit Format DDD:HH:MM:SS oder Umrechnung in andere Formate //----------------------------------------------------------------------------------------------------- function TimeCalc(time,diff,nummer) { // Millisekunden umrechnen in Tag Stunden Minuten Sekunden var rundung; var addition1; var addition2; var devisor; // Format DDDD:HH:MM:SS if(special[nummer][0] === '' && special[nummer][1] === '' && special[nummer][2] === '' && special[nummer][3] === '' && special[nummer][4] === '' ) { // keine Urechnungslogik hinterlegt var tag = addZero(Math.floor(diff / (1000*60*60*24))).zero3; diff = diff % (1000*60*60*24); var std = addZero(Math.floor(diff / (1000*60*60))).zero2; diff = diff % (1000*60*60); var min = addZero(Math.floor(diff / (1000*60))).zero2; diff = diff % (1000*60); var sec = addZero(Math.floor(diff / 1000)).zero2; time = tag + ":" + std + ":" + min + ":" + sec; // jetzt ddd:hh:mm:ss zusammensetzen return time; } // Es soll eine Zahl zurückgegeben werden z.B. Stunden rundung = special[nummer][0]; // lesen Einstellung zur Rundung if(rundung === '') { rundung = 16; } else { rundung = Number(rundung); } // endif // Wenn keine Rundung angegeben ist dann 16 addition1 = Number(special[nummer][1]); // lesen Einstellung addition1 faktor = Number(special[nummer][2]); // lesen Einstellung Faktor if(faktor === 0) { faktor = 1; } // Null ist nicht erlaubt devisor = Number(special[nummer][3]); // lesen Einstellung Devisor if(devisor === 0) { devisor = 1; } // Null ist nicht erlabut faktor = faktor / devisor; // neuer Faktor addition2 = Number(special[nummer][4]); // lesen Einstellung addition2 time = diff + addition1; // addition anwenden time = time * faktor; // Faktor anwenden time = time + addition2; // addition anwenden time = round(time,rundung); // Rundung anwenden return time; } //----------------------------------------------------------------------------------------------------- // 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 Speichern der Switches in die Zeitabschnitte //----------------------------------------------------------------------------------------------------- function SwitchKum(day,week,month,year,objSwitch) { if (day) { // update der taeglichen kumulierten Betriebszeit DayKum = getState(objSwitch+'.DAY').val; // Lese kumuoerte Tagesbetriebszeit DayKum = DayKum + 1; // addiere die ermittelte Betriebszeit setState(objSwitch+'.DAY',DayKum); // Schreibe die neue Betriebszeit } if (week) { WeekKum = getState(objSwitch+'.WEEK').val; WeekKum = WeekKum + 1; setState(objSwitch+'.WEEK',WeekKum); } if (month){ MonthKum = getState(objSwitch+'.MONTH').val; MonthKum = MonthKum + 1; setState(objSwitch+'.MONTH',MonthKum); } if (year) { YearKum = getState(objSwitch+'.YEAR').val; YearKum = YearKum + 1; setState(objSwitch+'.YEAR',YearKum); } } // endif function //----------------------------------------------------------------------------------------------------- // Funktion Kumulierte Zeitabschnitte ermitteln und speichern //----------------------------------------------------------------------------------------------------- function TimeKum(day,week,month,year,objKum,objCount,timediff,nummer) { var formattime = " "; if (day) { // update der taeglichen kumulierten Betriebszeit DayKum = getState(objKum+'.DAY').val; // Lese kumuoerte Tagesbetriebszeit DayKum = DayKum + timediff; // addiere die ermittelte Betriebszeit setState(objKum+'.DAY',DayKum); // Schreibe die neue Betriebszeit formattime = TimeCalc(formattime,DayKum,nummer); setState(objCount+'.DAY',formattime); } if (week) { WeekKum = getState(objKum+'.WEEK').val; WeekKum = WeekKum + timediff; setState(objKum+'.WEEK',WeekKum); formattime = TimeCalc(formattime,WeekKum,nummer); setState(objCount+'.WEEK',formattime); } if (month){ MonthKum = getState(objKum+'.MONTH').val; MonthKum = MonthKum + timediff; setState(objKum+'.MONTH',MonthKum); formattime = TimeCalc(formattime,MonthKum,nummer); setState(objCount+'.MONTH',formattime); } if (year) { YearKum = getState(objKum+'.YEAR').val; YearKum = YearKum + timediff; setState(objKum+'.YEAR',YearKum); formattime = TimeCalc(formattime,YearKum,nummer); setState(objCount+'.YEAR',formattime); } } // end function //----------------------------------------------------------------------------------------------------- // Funktion Kumulierte Werte ermitteln und speichern //----------------------------------------------------------------------------------------------------- function ValKum(day,week,month,year,objKum,objCount,valdiff,valdiffraw,stellen) { // day = true/false - soll day kumuliert werden // week= true/false - soll week kumuliert werden // month= true/false - soll month kumuliert werden // year= true/false - soll year kumuliert werden // objKum = Pfad zum Datenpunkt System.kum // objcount = Pfad zum Datenpunkt counter // valdiff = Wert zu speichern (dieses ist der Differenzwert umgerechnet mit der Formal aus tabelle special) // valdiffraw = Wert zu speichern (dieses ist der Differenzwert ohne Umrechnung) // stellen = Rundung fuer die count datenpunkte var valKum; var valCount; if (day) { // update der taeglichen kumulierten Betriebszeit valKum = getState(objKum+'.DAY').val; // Lese kumuoerte Tagesbetriebszeit valKum = valKum + valdiffraw; // addiere die ermittelte Betriebszeit valCount = getState(objCount+'.DAY').val; // Lese kumuoerte Tagesbetriebszeit valCount = valCount + valdiff; // addiere die ermittelte Betriebszeit setState(objKum+'.DAY',valKum); // Schreibe die neue Betriebszeit setState(objCount+'.DAY',round(valCount,stellen)); } if (week) { valKum = getState(objKum+'.WEEK').val; // Lese kumuoerte Tagesbetriebszeit valKum = valKum + valdiffraw; // addiere die ermittelte Betriebszeit valCount = getState(objCount+'.WEEK').val; // Lese kumuoerte Tagesbetriebszeit valCount = valCount + valdiff; // addiere die ermittelte Betriebszeit setState(objKum+'.WEEK',valKum); // Schreibe die neue Betriebszeit setState(objCount+'.WEEK',round(valCount,stellen)); } if (month){ valKum = getState(objKum+'.MONTH').val; // Lese kumuoerte Tagesbetriebszeit valKum = valKum + valdiffraw; // addiere die ermittelte Betriebszeit valCount = getState(objCount+'.MONTH').val; // Lese kumuoerte Tagesbetriebszeit valCount = valCount + valdiff; // addiere die ermittelte Betriebszeit setState(objKum+'.MONTH',valKum); // Schreibe die neue Betriebszeit setState(objCount+'.MONTH',round(valCount,stellen)); } if (year) { valKum = getState(objKum+'.YEAR').val; // Lese kumuoerte Tagesbetriebszeit valKum = valKum + valdiffraw; // addiere die ermittelte Betriebszeit valCount = getState(objCount+'.YEAR').val; // Lese kumuoerte Tagesbetriebszeit valCount = valCount + valdiff; // addiere die ermittelte Betriebszeit setState(objKum+'.YEAR',valKum); // Schreibe die neue Betriebszeit setState(objCount+'.YEAR',round(valCount,stellen)); } } // end function //----------------------------------------------------------------------------------------------------- // Funktion Kumulierte Werte ermitteln und speichern //----------------------------------------------------------------------------------------------------- function ValKum2(nummer,day,week,month,year,objKum,objCount,valdiffraw,addition1,addition2,faktor,stellen,individualFunc) { // nummer = Nummer der Gruppe // day = true/false - soll day kumuliert werden // week= true/false - soll week kumuliert werden // month= true/false - soll month kumuliert werden // year= true/false - soll year kumuliert werden // objKum = Pfad zum Datenpunkt System.kum // objcount = Pfad zum Datenpunkt counter // valdiff = Wert zu speichern (dieses ist der Differenzwert umgerechnet mit der Formal aus tabelle special) // valdiffraw = Wert zu speichern (dieses ist der Differenzwert ohne Umrechnung) // stellen = Rundung fuer die count datenpunkte // Individualfunktion anwenden var valKum; var valCount; var periode; if (day) { // update der taeglichen kumulierten Betriebszeit periode = ".DAY"; // gehoerige Periode zum pfad valKum = getState(objKum+'.DAY').val; // Lese letzte kumuoerte Perioden-Betriebszeit valKum = valKum + valdiffraw; // addiere die ermittelte Betriebszeit ohne Umrechnung valCount = valdiffraw; // counter vorbereiten if(individualFunc) { // Individualfunktionen valCount = individual(special[nummer][5].toUpperCase(),nummer,valdiffraw); // hier kommt ein umgerechneter Wertaus der Individualfunktion zurück z.B. KG . } // endif Individualfunktion valCount = valCount + addition1; // Addition1 anwenden valCount = valCount * faktor; // Faktor anwenden valCount = valCount + addition2; // Addition2 anwenden setState(objKum+periode,valKum); // Schreibe die neue Betriebszeit ohne Urechnung in den Systembereich valCount = valCount + getState(objCount+periode).val; // Addiere den neuen umgerechneten Deltawert in die Counterperiode setState(objCount+periode,round(valCount,stellen)); // Schreibe die neue Betriebszeit mit Urechnung in den Counter } if (week) { periode = ".WEEK"; // gehoerige Periode zum pfad valKum = getState(objKum+'.DAY').val; // Lese letzte kumuoerte Perioden-Betriebszeit valKum = valKum + valdiffraw; // addiere die ermittelte Betriebszeit ohne Umrechnung valCount = valdiffraw; // counter vorbereiten if(individualFunc) { // Individualfunktionen valCount = individual(special[nummer][5].toUpperCase(),nummer,valdiffraw); // hier kommt ein umgerechneter Wertaus der Individualfunktion zurück z.B. KG . } // endif Individualfunktion valCount = valCount + addition1; // Addition1 anwenden valCount = valCount * faktor; // Faktor anwenden valCount = valCount + addition2; // Addition2 anwenden setState(objKum+periode,valKum); // Schreibe die neue Betriebszeit ohne Urechnung in den Systembereich valCount = valCount + getState(objCount+periode).val; // Addiere den neuen umgerechneten Deltawert in die Counterperiode setState(objCount+periode,round(valCount,stellen)); // Schreibe die neue Betriebszeit mit Urechnung in den Counter } if (month){ periode = ".MONTH"; // gehoerige Periode zum pfad valKum = getState(objKum+'.DAY').val; // Lese letzte kumuoerte Perioden-Betriebszeit valKum = valKum + valdiffraw; // addiere die ermittelte Betriebszeit ohne Umrechnung valCount = valdiffraw; // counter vorbereiten if(individualFunc) { // Individualfunktionen valCount = individual(special[nummer][5].toUpperCase(),nummer,valdiffraw); // hier kommt ein umgerechneter Wertaus der Individualfunktion zurück z.B. KG . } // endif Individualfunktion valCount = valCount + addition1; // Addition1 anwenden valCount = valCount * faktor; // Faktor anwenden valCount = valCount + addition2; // Addition2 anwenden setState(objKum+periode,valKum); // Schreibe die neue Betriebszeit ohne Urechnung in den Systembereich valCount = valCount + getState(objCount+periode).val; // Addiere den neuen umgerechneten Deltawert in die Counterperiode setState(objCount+periode,round(valCount,stellen)); // Schreibe die neue Betriebszeit mit Urechnung in den Counter } if (year) { periode = ".YEAR"; // gehoerige Periode zum pfad valKum = getState(objKum+'.DAY').val; // Lese letzte kumuoerte Perioden-Betriebszeit valKum = valKum + valdiffraw; // addiere die ermittelte Betriebszeit ohne Umrechnung valCount = valdiffraw; // counter vorbereiten if(individualFunc) { // Individualfunktionen valCount = individual(special[nummer][5].toUpperCase(),nummer,valdiffraw); // hier kommt ein umgerechneter Wertaus der Individualfunktion zurück z.B. KG . } // endif Individualfunktion valCount = valCount + addition1; // Addition1 anwenden valCount = valCount * faktor; // Faktor anwenden valCount = valCount + addition2; // Addition2 anwenden setState(objKum+periode,valKum); // Schreibe die neue Betriebszeit ohne Urechnung in den Systembereich valCount = valCount + getState(objCount+periode).val; // Addiere den neuen umgerechneten Deltawert in die Counterperiode setState(objCount+periode,round(valCount,stellen)); // Schreibe die neue Betriebszeit mit Urechnung in den Counter } } // end function //----------------------------------------------------------------------------------------------------- // 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 //----------------------------------------------------------------------------------------------------- // Individualfunktionen //----------------------------------------------------------------------------------------------------- function individual(funktion,nummer,runtime) { // Funktion zur Verbrauchsert ermittlung Pelletverbrauch Oekofen // Vorgabewerte sind anzupassen // function - die individualfunktion // nummer die aktuelle bearbeitete Gruppe // runtime = Wert zur weiteren Verarbeitung z.B. Millisekunden log("funktion individual aufgerufen","info"); // Oekofen von Saugen zu pelletverbrauch if(funktion === "OEKOFEN") { log("funktion Oekofen aufgerufen","info"); // Werte zum Einstellen-------------------------------------------------------- var vorgpause = 6; // bei intervallsaugen die Anzahl Sekunden zwichen Intervallen var vorgintervall = 54; // laenge eines einzelnen Intervalls var vorgvorlauf = 32; // Saugzeit bevor die Schnecke läuft (Vakuum bilden) var vorgnachlauf = 15; // Laufzeit des Saugers nach stopp der schnecke var vorgverbrauch = 7.5; // Vorgabe der KG Ansaugleistung per Minute wenn die Schnecke läuft //---------------------------------------------------------------------------- // Allgemeine Variablen var anzlaeufe = 0; var anzpausen = 0; var totpausen = 0; var restlaufzeit = 0; var net1runtime; var verbrauch; var schneckenzeit; runtime = runtime / 1000; // Laufzeit in Sekunden // Berechne Anzahl Läufe und Pausen net1runtime = runtime - vorgvorlauf - vorgnachlauf; anzlaeufe = Math.floor(net1runtime / vorgintervall); anzpausen = anzlaeufe-1; //theoretische Restlaufzeit berechnen restlaufzeit = runtime - ( (anzlaeufe * vorgintervall) + vorgvorlauf + vorgnachlauf + (anzpausen * vorgpause )); //Korrektur anzahl laeufe und pausen falls notwendig if (restlaufzeit + vorgpause < 0 ) //Grenzfall wenn die Restzeit kleiner als null ist, dann muss anzahl läufe angepasst werden { anzlaeufe =anzlaeufe - 1; anzpausen = anzpausen - 1; restlaufzeit = runtime - ( (anzlaeufe * vorgintervall) + vorgvorlauf + vorgnachlauf + (anzpausen * vorgpause )); } // Verbrauch berechnen schneckenzeit = runtime - vorgvorlauf - vorgnachlauf - (anzpausen * vorgpause); // reine Schneckenlaufzeit berechnen verbrauch = schneckenzeit * vorgverbrauch/60 ; // Pelletverbrauch berechnen return verbrauch; } // endif Oekofen } // end function