UPDATE 31.10.: Amazon Alexa - ioBroker Skill läuft aus ?

[MartyBr]

@rushmed
Ich habe nun auch das Statistik-Script in der aktuellen Version 1.0.1 installiert. Es liefert leider immer den Fehler

Fehler beim Lesen der InfluxDB: Invalid call

Hast du den String in

  //InfluxDB abfragen (Regen +1min Startverzögerung wg. ev. Ungenauigkeit der Systemzeit des Wetterstation-Displays)
            sendTo('influxdb.'+INFLUXDB_INSTANZ, 'query', 
            'select * FROM "' + WET_DP + '.Aussentemperatur" WHERE time >= ' + (start *1000000) + ' AND time <= ' + (end *1000000)
             + '; select * FROM "' + WET_DP + '.Wind_max" WHERE time >= '  + (start *1000000) + ' AND time <= ' + (end *1000000)
             + '; select * FROM "' + WET_DP + '.Regen_Tag" WHERE time >= ' + ((start+72000) *1000000) + ' AND time <= ' + (end *1000000)
         , function (result) {
             //Anlegen der Arrays + befüllen mit den relevanten Daten
            if (result.error) {
               console.error('Fehler beim Lesen der InfluxDB: '+result.error);
               Statusmeldung('Fehler beim Lesen der InfluxDB: '+result.error);
            } else {
                //console.log('Rows: ' + JSON.stringify(result.result[2]));
                for (let i = 0; i < result.result[0].length; i++) { temps[i] = result.result[0][i].value; }
                for (let i = 0; i < result.result[1].length; i++) { wind[i] = result.result[1][i].value; }
                for (let i = 0; i < result.result[2].length; i++) { regen[i] = result.result[2][i].value; }
            }    

auf InfluxDB V2 angepasst?

Edit:
Habe folgende Log-Einträge:

javascript.0
2022-03-02 09:18:07.870	info	Stop script script.js.Wetterstation.Statistik_Wetterstation

javascript.0
2022-03-02 09:16:00.189	warn	TypeError: Reduce of empty array with no initial value at Array.reduce (<anonymous>) at Object.cb (script.js.Wetterstation.Statistik_Wetterstation:741:43) at change (/opt/iobroker/node_modules/@iobroker/js-controller-adapter/src/lib/adapter/adapter.js:5809:71) at Immediate._onImmediate (/opt/iobroker/node_modules/@iobroker/db-states-redis/lib/states/statesInRedisClient.js:322:37) at processImmediate (internal/timers.js:464:21)

javascript.0
2022-03-02 09:16:00.185	warn	States system pmessage io.messagebox.system.adapter.javascript.0 {"command":"query","message":{"result":[],"error":"Invalid call"},"from":"system.adapter.influxdb.0","callback":{"message":"select * FROM \"0_userdata.0.Wetterstation.Aussentemperatur\" WHERE time >= 1646089200000000000 AND time <= 1646175599000000000; select * FROM \"0_userdata.0.Wetterstation.Wind_max\" WHERE time >= 1646089200000000000 AND time <= 1646175599000000000; select * FROM \"0_userdata.0.Wetterstation.Regen_Tag\" WHERE time >= 1646089272000000000 AND time <= 1646175599000000000","id":1,"ack":true,"time":1646208960014},"_id":61369237} Reduce of empty array with no initial value

javascript.0
2022-03-02 09:16:00.184	error	script.js.Wetterstation.Statistik_Wetterstation: Fehler beim Lesen der InfluxDB: Invalid call

influxdb.0
2022-03-02 09:16:00.158	error	queries: Error: 3 Error happened while processing 3 queries

influxdb.0
2022-03-02 09:16:00.158	warn	Error in query " select * FROM "0_userdata.0.Wetterstation.Regen_Tag" WHERE time >= 1646089272000000000 AND time <= 1646175599000000000": HttpError: error @1:2-1:8: undefined identifier selecterror @1:11-1:15: undefined identifier FROMerror @1:55-1:60: undefined identifier WHEREerror @1:61-1:65: (v:A) => time is not Equatableerror @1:89-1:92: undefined identifier ANDerror @1:93-1:97: (v:A) => time is not Equatable

influxdb.0
2022-03-02 09:16:00.151	warn	Error in query " select * FROM "0_userdata.0.Wetterstation.Wind_max" WHERE time >= 1646089200000000000 AND time <= 1646175599000000000": HttpError: error @1:2-1:8: undefined identifier selecterror @1:11-1:15: undefined identifier FROMerror @1:54-1:59: undefined identifier WHEREerror @1:60-1:64: (v:A) => time is not Equatableerror @1:88-1:91: undefined identifier ANDerror @1:92-1:96: (v:A) => time is not Equatable

influxdb.0
2022-03-02 09:16:00.141	warn	Error in query "select * FROM "0_userdata.0.Wetterstation.Aussentemperatur" WHERE time >= 1646089200000000000 AND time <= 1646175599000000000": HttpError: error @1:1-1:7: undefined identifier selecterror @1:10-1:14: undefined identifier FROMerror @1:61-1:66: undefined identifier WHEREerror @1:67-1:71: (v:A) => time is not Equatableerror @1:95-1:98: undefined identifier ANDerror @1:99-1:103: (v:A) => time is not Equatable

[SBorg]

Die 365Tage lassen wir mal außen vor, da muss man halt schon mindestens ein Jahr loggen ;)
Da aber "Heute" und "letzte 24h" im 15 Minuten-Raster generiert werden, liegen diese spätestens zur nächsten vollen (00, 15, 30 oder 45) Viertelstunde vor.
"Heute" ist allerdings um Mitternacht ein Sonderfall, da bedingt durch die Usereinstellungen wie viel Datenpunkte im RAM gehalten werden sollen, es nicht sichergestellt ist, dass wirklich schlag 0:00 Uhr auch schon ein Wert der Außentemperatur vorliegt (für "letzte 24h" wird immer mal ein Wert vorliegen, notfalls steht dann halt "(null)" da). Es könnte dann also sein, dass bis zum nächsten Update um 0:15 Uhr oftmals kein Messwert vorliegt/angezeigt wird.
Deswegen wird, falls kein Min-/Max-Wert ermittelt werden konnte, einfach die aktuelle Außentemperatur angezeigt. Würde in dem Fall ja stimmen, denn wenn ich nur einen Messwert habe, stellt der Min-, Max- und Durchschnittstemperatur gleichermaßen dar. Erst wenn ich einen davon abweichenden Messwert erhalte sind die drei unterschiedlich.

Lange Rede, kurzer Sinn. Das Fehlerbild zeigt eindeutig, das ihr keine Verbindung zur InfluxDB habt, deswegen sind die "24h" nur "(null)" (=kein Wert gelesen) und die Min-/Max-Temp identisch, da er auch hier nix aus der InfluxDB lesen konnte aber dann dafür die akt. Außentemperatur nutzt...

[MartyBr]

@sborg Das ist ja genau die Frage. Mit dem folgenden Code kann ich auf dem Influx-Server die Daten abrufen:

influx query 'from(bucket:"iobroker") |> range(start:-15m) |> filter(fn: (r) => r._measurement == "proxmox.0.node_pve.cpu")|> pivot(rowKey:["_time"], columnKey: ["_field"], valueColumn: "_value")'

Da bekomme ich auch Ergebnisse. Ich habe nun versucht, den Code im Statistik-Script anzupassen. Ich bekomme leider immer wieder Script Fehler:

           //InfluxDB abfragen (Regen +1min Startverzögerung wg. ev. Ungenauigkeit der Systemzeit des Wetterstation-Displays)
            sendTo('influxdb.'+INFLUXDB_INSTANZ, 'query', 
            ' FROM(bucket:"iobroker")' |> range(start:-1h) |> filter(fn: (r) => r["_measurement"] == WET_DP +".Aussentemperatur")|> pivot(rowKey:["_time"], columnKey: ["_field"], valueColumn: "_value")'
             + '; FROM(bucket:"iobroker")' |> range(start:-1h) |> filter(fn: (r) => r["_measurement"] == WET_DP +".Wind_max")|> pivot(rowKey:["_time"], columnKey: ["_field"], valueColumn: "_value")'
             + '; FROM(bucket:"iobroker")' |> range(start:-1h) |> filter(fn: (r) => r["_measurement"] == WET_DP +".Regen_Tag")|> pivot(rowKey:["_time"], columnKey: ["_field"], valueColumn: "_value")'
         , function (result) {
             //Anlegen der Arrays + befüllen mit den relevanten Daten
            if (result.error) {
               console.error('Fehler beim Lesen der InfluxDB: '+result.error);
               Statusmeldung('Fehler beim Lesen der InfluxDB: '+result.error);
            } else {
                //console.log('Rows: ' + JSON.stringify(result.result[2]));
                for (let i = 0; i < result.result[0].length; i++) { temps[i] = result.result[0][i].value; }
                for (let i = 0; i < result.result[1].length; i++) { wind[i] = result.result[1][i].value; }
                for (let i = 0; i < result.result[2].length; i++) { regen[i] = result.result[2][i].value; }
            }            

Vielleicht kann mir hier ein Fachmann helfen?

[Rushmed]

Ich nutze InfluxDB 2.1.1.
In der Conf habe ich die Zugangsdaten zu meiner auf V1 gemappten DB eingetragen die ich auch für den Zugriff mit Grafana nutze.

 #InfluxDB-Konfiguration / ohne InfluxDB alles leer lassen
  #IP und Port der API [xxx.xxx.xxx.xxx:xxxxx]
   INFLUX_API=192.168.178.20:8086
  #Name, User und Passwort der InfluxDB-Datenbank
   INFLUX_DB=ioBroker_db
   INFLUX_USER=USERNAME
   INFLUX_PASSWORD=PASSWORD

Reichen denn diese Zugangsdaten wirklich?
Um mit Grafana auf die gemappte DB zugreifen zu können muss zusätzlich:

eingestellt werden, wobei Value = Token MYTOKEN ist.

[MartyBr]

@rushmed Ich habe es genauso gemacht. Die Datenbank habe ich auf V1 gemalt und
influx v1 dbrp list
hat das erfolgreiche Mapping gezeigt.
Setzt du das unveränderte Statistik-Script ein?

[Rushmed]

@martybr ja

[MartyBr]

@rushmed Und es liefert Werte? Bei mir bricht es ab.
Ich habe keine Idee mehr :disappointed:

[Rushmed]

@martybr Du hast Recht. Ich hab das voll übersehen. Die Werte sind noch von vor meine Umstellung auf Influx2.

[MartyBr]

@rushmed
Du kannst den Status hier ablesen:

0_userdata.0.Statistik.Wetter.Control.Statusmeldung

[Rushmed]

@martybr Fehler beim Lesen der InfluxDB: Invalid call

[MartyBr]

@rushmed Wie bei mir. Das Script scheint nur bei Influx Version 1 zu laufen. Ich hatte weiter oben mal einen Versuch eingestellt, die Abfrage auf Influx Version zu ändern. Bekommen aber immer einen Error beim Speichern.
Die Abfragen hatte ich mir aus der Weboberfläche Influx geholt. Dort funktionieren sie und liefern Daten.
Ich komme da mit dem Script nicht weiter, vielleicht kann sich das jemand mal anschauen.

[SBorg]

@martybr sagte in [Linux Shell-Skript] WLAN-Wetterstation:

Ich hatte weiter oben mal einen Versuch eingestellt, die Abfrage auf Influx Version zu ändern. Bekommen aber immer einen Error beim Speichern.

Das wird auch so nicht funktionieren, da du die Syntax eines Influx-Querys nicht 1:1 in den "sendTo" des Javascript-Adapters übernehmen kannst. Der kann damit schlichtweg nichts anfangen.

Ich habe aktuell leider keine Zeit mir das selbst anzuschauen, da es nur mit "kleinen" Anpassungen auch nicht getan ist.

[jostereo]

@martybr sagte in [Linux Shell-Skript] WLAN-Wetterstation:

@sborg Das ist ja genau die Frage. Mit dem folgenden Code kann ich auf dem Influx-Server die Daten abrufen:

influx query 'from(bucket:"iobroker") |> range(start:-15m) |> filter(fn: (r) => r._measurement == "proxmox.0.node_pve.cpu")|> pivot(rowKey:["_time"], columnKey: ["_field"], valueColumn: "_value")'

Da bekomme ich auch Ergebnisse. Ich habe nun versucht, den Code im Statistik-Script anzupassen. Ich bekomme leider immer wieder Script Fehler:

           //InfluxDB abfragen (Regen +1min Startverzögerung wg. ev. Ungenauigkeit der Systemzeit des Wetterstation-Displays)
            sendTo('influxdb.'+INFLUXDB_INSTANZ, 'query', 
            ' FROM(bucket:"iobroker")' |> range(start:-1h) |> filter(fn: (r) => r["_measurement"] == WET_DP +".Aussentemperatur")|> pivot(rowKey:["_time"], columnKey: ["_field"], valueColumn: "_value")'
             + '; FROM(bucket:"iobroker")' |> range(start:-1h) |> filter(fn: (r) => r["_measurement"] == WET_DP +".Wind_max")|> pivot(rowKey:["_time"], columnKey: ["_field"], valueColumn: "_value")'
             + '; FROM(bucket:"iobroker")' |> range(start:-1h) |> filter(fn: (r) => r["_measurement"] == WET_DP +".Regen_Tag")|> pivot(rowKey:["_time"], columnKey: ["_field"], valueColumn: "_value")'
         , function (result) {
             //Anlegen der Arrays + befüllen mit den relevanten Daten
            if (result.error) {
               console.error('Fehler beim Lesen der InfluxDB: '+result.error);
               Statusmeldung('Fehler beim Lesen der InfluxDB: '+result.error);
            } else {
                //console.log('Rows: ' + JSON.stringify(result.result[2]));
                for (let i = 0; i < result.result[0].length; i++) { temps[i] = result.result[0][i].value; }
                for (let i = 0; i < result.result[1].length; i++) { wind[i] = result.result[1][i].value; }
                for (let i = 0; i < result.result[2].length; i++) { regen[i] = result.result[2][i].value; }
            }            

Vielleicht kann mir hier ein Fachmann helfen?

Ich habe das Statistikscript glaube ich für InfluxDB 2.0 angepasst.

Dafür benutze ich folgendes Flux Command. Ist die entsprechende Anpassung zu dem bestehenden Command für Version 1.0

'from(bucket: "iobroker") |> range(start: ' + (start / 1000) + ', stop: ' + (end / 1000) + ') |> filter(fn: (r) => r["_measurement"] == "' + WET_DP + '.Aussentemperatur") |> filter(fn: (r) => r["_field"] == "value");' +
        'from(bucket: "iobroker") |> range(start: ' + (start / 1000) + ', stop: ' + (end / 1000) + ') |> filter(fn: (r) => r["_measurement"] == "' + WET_DP + '.Wind_max") |> filter(fn: (r) => r["_field"] == "value");' +
        'from(bucket: "iobroker") |> range(start: ' + ((start + 72000) / 1000) + ', stop: ' + (end / 1000) + ') |> filter(fn: (r) => r["_measurement"] == "' + WET_DP + '.Regen_Tag") |> filter(fn: (r) => r["_field"] == "value")'

Ich bin der Meinung das das Script bei mir richtig funktioniert, allerdings habe ich das nicht bis ins Detail an den Messwerten überprüft. Die Messwerte werden allerdings geschrieben und auch vollständig berechnet.

Vielleicht kannst du den FLUX Command auch mal bei dir einbauen und dann testen ob es für dich läuft.

Influx Bucket heißt bei mir "iobroker", müsste natürlich notfalls angepasst werden.

Ich hatte damals längere Zeit damit verbracht die Zeitangaben entsprechende anzupassen, da der Timestamp Vergleich wohl in FLUX anders läuft als in V 1.0.

Gruß,

jostereo

[MartyBr]

@jostereo Super, das teste ich sofort. Ich gebe dir dann Rückmeldung.

Edit: 15:17 Uhr
Änderung Script funktioniert. Nun kann auch eine Influxdb Version2 ausgelesen werden.

Kleiner Schönheitsfehler: Ich musste in der letzten Zeile das Semikolon entfernen.

Herzlichen Dank
:+1:

[jostereo]

@martybr sagte in [Linux Shell-Skript] WLAN-Wetterstation:

@jostereo Super, das teste ich sofort. Ich gebe dir dann Rückmeldung.

Edit: 15:17 Uhr
Änderung Script funktioniert. Nun kann auch eine Influxdb Version2 ausgelesen werden.

Kleiner Schönheitsfehler: Ich musste in der letzten Zeile das Semikolon entfernen.

Herzlichen Dank
:+1:

Habe es oben mit dem Semikolon geändert.

Hatte das FLUX Command zu Debug Zwecken bei mir einer Variablen zu gewiesen, deswegen war am Ende noch das Semikolon.

Bin gespannt ob die Werte bei dir auch soweit passen.

Gruß,

[MartyBr]

@jostereo Die Werte wurden leider bis auf die Rekordwerte nicht aktualisiert.

Bei den Rekordwerten scheinen auch nur die "Regenmengemonat" und "Trockenperiode" aktualisiert zu werden.

Die lasse das Script noch einen Tag laufen.

Hier das vollständige Script:

/* Wetterstation-Statistiken 

   holt die Messdaten aus einer InfluxDB und erstellt eine Monats-, Vorjahresmonat- und
   Rekordwerte-Statistik
   Wichtig: funktioniert nur mit der Default-Datenstruktur des WLAN-Wetterstation-Skriptes!
            Auch keine Aliase unter Influx nutzen!

   (c)2020-2021 by SBorg
   V1.0.1 - 18.12.2021  ~Bugfixing "error: TypeError: Cannot read property '0' of null"
                        ~Wechsel zu axios
   V1.0.0 - 02.10.2021  ~Bugfixing Werte VorJahresMonat
                        +Kompatibilität mit JSC 3.3.x hergestellt (Änderung JSON -> Array)
                        ~Rekordwerte werden nun korrekt am Tag des Ereignisses gespeichert
   V0.2.2 - 01.02.2021  ~Bugfixing Regenmenge Jahr + Monat
   V0.2.1 - 21.01.2021  ~Bugfixing Rekordwerte Spitzenhöchst-/-tiefstwert
   V0.2.0 - 15.01.2021  ~Bugfixing Benennung DPs / Korrektur Regenmenge
   V0.1.9 - 09.01.2021  +Regenmenge eines kpl. Monats im Jahr und Rekord
   V0.1.8 - 08.01.2021  +max. Windböe für Gestern und Jahres-/Rekordwerte
   V0.1.7 - 03.01.2021  ~Fix für fehlerhafte/fehlende Speicherung Jahreswerte + Trockenperiode
   V0.1.6 - 30.12.2020  +Summe "Sommertage", "heiße Tage", "Frosttage", "Eistage" und "sehr kalte Tage" für das gesamte Jahr
   V0.1.5 - 29.12.2020  +Summe "kalte Tage" und "warme Tage" für das gesamte Jahr
   V0.1.4 - 26.12.2020  +max. Regenmenge pro Tag für Jahres-/Rekordwerte
   V0.1.3 - 11.11.2020  +Rekordwerte
   V0.1.2 - 14.10.2020  ~Fix "NaN" bei Regenmenge Monat
   V0.1.1 - 12.10.2020  +AutoReset Jahresstatistik
   V0.1.0 - 08.10.2020  +DP für Statusmeldungen / Reset Jahresstatistik / AutoDelete "Data"
                        +ScriptVersion / Update vorhanden / UpdateCheck abschaltbar
                        +Jahresstatistik Min-/Max-/Durchschnittstemperatur/Trockenperiode
   V0.0.7 - 19.09.2020  +Min.-/Max.-/Durchschnittstemperatur vom Vortag
   V0.0.6 - 18.09.2020  +Regenmenge Monat
   V0.0.5 - 17.09.2020  +Gradtage Vorjahr
   V0.0.4 - 16.09.2020  +Eistage (Max. unter 0°C) / sehr kalte Tage (Min. unter -10°C)
                        ~Frosttage (Korrektur: Tiefstwert unter 0°C)
   V0.0.3 - 15.09.2020  +Frosttage (Min. unter 0°C) / kalte Tage (Max. unter 10°C)
   V0.0.2 - 12.09.2020  +warme Tage über 20°C / Sommertage über 25°C / heiße Tage über 30°C
   V0.0.1 - 11.09.2020   erste Beta + Temp-Min/Temp-Max/Temp-Durchschnitt/max. Windböe/max. Regenmenge pro Tag

      ToDo: ---
      known issues: keine

*/



// *** User-Einstellungen **********************************************************************************************************************************
    const WET_DP='0_userdata.0.Wetterstation';        // wo liegen die Datenpunkte mit den Daten der Wetterstation  [default: javascript.0.Wetterstation]                          
    const INFLUXDB_INSTANZ='0';                       // unter welcher Instanz läuft die InfluxDB [default: 0]
    const PRE_DP='0_userdata.0.Statistik.Wetter';     // wo sollen die Statistikwerte abgelegt werden. Nur unter "0_userdata" oder "javascript" möglich!
    let REKORDWERTE_AUSGABEFORMAT="[WERT] im [MONAT] [JAHR]";   /* Wie soll die Ausgabe der Rekordwerte formatiert werden (Template-Vorlage)?
                                                                    [WERT]      = Messwert (zB. '22.42' bei Temperatur, '12' bei Tagen)
                                                                    [TAG]       = Tag (0-31)
                                                                    [MONAT]     = Monatsname (Januar, Februar,..., Dezember)
                                                                    [MONAT_ZAHL]= Monat als Zahl (01-12)
                                                                    [MONAT_KURZ]= Monatsname kurz (Jan, Feb,..., Dez)
                                                                    [JAHR]      = Jahreszahl vierstellig (2020)
                                                                 Die 'Units' wie bspw. "°C" oder "Tage" werden direkt aus dem Datenpunkt ergänzt. 
                                                                 [default: [WERT] im [MONAT] [JAHR] ] erzeugt als Beispiel im DP die 
                                                                 Ausgabe: "22.42 °C im Juni 2020"
                                                                */
    const ZEITPLAN = "3 1 * * *";                     // wann soll die Statistik erstellt werden (Minuten Stunde * * *) [default 1:03 Uhr] 
// *** ENDE User-Einstellungen *****************************************************************************************************************************




//ab hier gibt es nix mehr zu ändern :)
//first start?
const DP_Check='Rekordwerte.Regenmengemonat';
if (!existsState(PRE_DP+'.'+DP_Check)) { createDP(DP_Check); }

//Start des Scripts
    const ScriptVersion = "V1.0.1";
    let Tiefstwert, Hoechstwert, Temp_Durchschnitt, Max_Windboe, Max_Regenmenge, Regenmenge_Monat, warme_Tage, Sommertage;
    let heisse_Tage, Frost_Tage, kalte_Tage, Eistage, sehr_kalte_Tage, Trockenperiode_akt;
    let kalte_Tage_Jahr, warme_Tage_Jahr, Sommertage_Jahr, heisse_Tage_Jahr, Frosttage_Jahr, Eistage_Jahr, sehrkalte_Tage_Jahr;
    let monatstage = [31,28,31,30,31,30,31,31,30,31,30,31];
    let monatsname = ['Januar','Februar','März','April','Mai','Juni','Juli','August','September','Oktober','November','Dezember'];
    let monatsname_kurz = ['Jan','Feb','Mär','Apr','Mai','Jun','Jul','Aug','Sep','Okt','Nov','Dez'];
    console.log('Wetterstation-Statistiken gestartet...');
    setTimeout(Statusmeldung, 500);

//scheduler
    schedule(ZEITPLAN, main);


// ### Funktionen ###############################################################################################
async function main() {
    let result = [], temps = [], wind = [], regen = [], start, end, zeitstempel = new Date();
    start = new Date(zeitstempel.getFullYear(),zeitstempel.getMonth(),zeitstempel.getDate()-1,0,0,0);
    start = start.getTime();
    end = new Date(zeitstempel.getFullYear(),zeitstempel.getMonth(),zeitstempel.getDate()-1,23,59,59);
    end = end.getTime();

    //Jobs Monatserster
 if (zeitstempel.getDate() == 1) { 
     if (zeitstempel.getMonth() == 0) { //heute ist der 01.01. 

        //Rekordwerte (Temperatur-Durchschnitt) setzen
            //max Jahrestemperaturdurchschnitt
            let JahresTemperatur_Durchschnitt = getState(PRE_DP+'.Jahreswerte.Temperatur_Durchschnitt').val;
            if (getState(PRE_DP+'.Rekordwerte.value.Temp_Durchschnitt_Max').val < JahresTemperatur_Durchschnitt) {
                setState(PRE_DP+'.Rekordwerte.value.Temp_Durchschnitt_Max', JahresTemperatur_Durchschnitt, true);
                setState(PRE_DP+'.Rekordwerte.Temperatur_Jahresdurchschnitt_Max', JahresTemperatur_Durchschnitt+' für '+ (zeitstempel.getFullYear()-1), true);
                //, () => { Template_Rekordwerte('Temp_Durchschnitt_Max','Rekordwerte.Temperatur_Jahresdurchschnitt_Max'); });
            }  
            //min Jahrestemperaturdurchschnitt
            if (getState(PRE_DP+'.Rekordwerte.value.Temp_Durchschnitt_Min').val > JahresTemperatur_Durchschnitt) {
                setState(PRE_DP+'.Rekordwerte.value.Temp_Durchschnitt_Min', JahresTemperatur_Durchschnitt, true);
                setState(PRE_DP+'.Rekordwerte.Temperatur_Jahresdurchschnitt_Min', JahresTemperatur_Durchschnitt+' für '+ (zeitstempel.getFullYear()-1), true);
                //, () => { Template_Rekordwerte('Temp_Durchschnitt_Min','Rekordwerte.Temperatur_Jahresdurchschnitt_Min'); });
            }

        //Rekordwerte (Temperatur-Durchschnitt) einmalig resetten [InstallationsJahr +1]
        let Inst_Jahr = (new Date(getState(PRE_DP).ts)).getFullYear();
        if (zeitstempel.getFullYear() == Inst_Jahr+1) {
            setState(PRE_DP+'.Rekordwerte.value.Temp_Durchschnitt_Max', -99.99, true);
            setState(PRE_DP+'.Rekordwerte.value.Temp_Durchschnitt_Min',  99.99, true);
            setState(PRE_DP+'.Rekordwerte.Temperatur_Jahresdurchschnitt_Max' ,'' ,true);
            setState(PRE_DP+'.Rekordwerte.Temperatur_Jahresdurchschnitt_Min' ,'' ,true);
        }

        let mode=getState(PRE_DP+'.Control.AutoReset_Jahresstatistik').val;
        switch (mode) { //0=Aus, 1=Ein, 2=Ein+Backup
            case 0:
               break;

            case 1:
               Reset_Jahresstatistik();
               break;

            case 2:
               Backup_Jahresstatistik();
               Reset_Jahresstatistik();
               break;

            default:
               break;
        } // end switch

     } // end if 01.01.

   await speichern_Monat();  //vorherige Monatsstatistik speichern
   await VorJahr();          //Vorjahresmonatsstatistik ausführen
   
   /*DPs unabhängig ihres Wertes initial schreiben; wir nehmen die aktuelle Außentemperatur, da sie zum Start des Messzyklus
     Min, Max und Durchschnitt darstellt; Rest einfach nullen */
    let initialTemp=getState(WET_DP+'.Aussentemperatur').val;
    setState(PRE_DP+'.aktueller_Monat.Tiefstwert', initialTemp, true);
    setState(PRE_DP+'.aktueller_Monat.Hoechstwert', initialTemp, true);
    setState(PRE_DP+'.aktueller_Monat.Temperatur_Durchschnitt', initialTemp, true);
    setState(PRE_DP+'.aktueller_Monat.Max_Windboe', 0, true);
    setState(PRE_DP+'.aktueller_Monat.Max_Regenmenge', 0, true);
    setState(PRE_DP+'.aktueller_Monat.Regenmenge_Monat', 0, true);
    setState(PRE_DP+'.aktueller_Monat.warme_Tage', 0, true);
    setState(PRE_DP+'.aktueller_Monat.Sommertage', 0, true);
    setState(PRE_DP+'.aktueller_Monat.heisse_Tage', 0, true);
    setState(PRE_DP+'.aktueller_Monat.Frost_Tage', 0, true);
    setState(PRE_DP+'.aktueller_Monat.kalte_Tage', 0, true);
    setState(PRE_DP+'.aktueller_Monat.Eistage', 0, true);
    setState(PRE_DP+'.aktueller_Monat.sehr_kalte_Tage', 0, true);

    sleep(3000);
    
   if (getState(PRE_DP+'.Control.AutoDelete_Data').val >0) { AutoDelete_Data(); }
   //nun beenden
   return;

 }// End Jobs Monatserster

            //InfluxDB abfragen (Regen +1min Startverzögerung wg. ev. Ungenauigkeit der Systemzeit des Wetterstation-Displays)
            sendTo('influxdb.'+INFLUXDB_INSTANZ, 'query', 
            'from(bucket: "iobroker") |> range(start: ' + (start / 1000) + ', stop: ' + (end / 1000) + ') |> filter(fn: (r) => r["_measurement"] == "' + WET_DP + '.Aussentemperatur") |> filter(fn: (r) => r["_field"] == "value");' +
        'from(bucket: "iobroker") |> range(start: ' + (start / 1000) + ', stop: ' + (end / 1000) + ') |> filter(fn: (r) => r["_measurement"] == "' + WET_DP + '.Wind_max") |> filter(fn: (r) => r["_field"] == "value");' +
        'from(bucket: "iobroker") |> range(start: ' + ((start + 72000) / 1000) + ', stop: ' + (end / 1000) + ') |> filter(fn: (r) => r["_measurement"] == "' + WET_DP + '.Regen_Tag") |> filter(fn: (r) => r["_field"] == "value")'

         , function (result) {
             //Anlegen der Arrays + befüllen mit den relevanten Daten
            if (result.error) {
               console.error('Fehler beim Lesen der InfluxDB: '+result.error);
               Statusmeldung('Fehler beim Lesen der InfluxDB: '+result.error);
            } else {
                //console.log('Rows: ' + JSON.stringify(result.result[2]));
                for (let i = 0; i < result.result[0].length; i++) { temps[i] = result.result[0][i].value; }
                for (let i = 0; i < result.result[1].length; i++) { wind[i] = result.result[1][i].value; }
                for (let i = 0; i < result.result[2].length; i++) { regen[i] = result.result[2][i].value; }
            }           
                    
  //Temperaturen
    Tiefstwert = Math.min(...temps);
    Hoechstwert = Math.max(...temps);
    //Math.sum = (...temps) => Array.prototype.reduce.call(temps,(a,b) => a+b);
    const reducer = (accumulator, curr) => accumulator + curr;
    //Temp_Durchschnitt = Number((Math.sum(...temps)/temps.length).toFixed(2));
    let Temp_Durchschnitt = Number((temps.reduce(reducer)/temps.length).toFixed(2));
    let MonatsTemp_Durchschnitt = Math.round(((((getState(PRE_DP+'.aktueller_Monat.Temperatur_Durchschnitt').val)*(zeitstempel.getDate()-1))+Temp_Durchschnitt)/zeitstempel.getDate())*100)/100;
    if (Hoechstwert > 20) { warme_Tage = 1; } else { warme_Tage = 0; }
    if (Hoechstwert > 25) { Sommertage = 1; } else { Sommertage = 0; } 
    if (Hoechstwert > 30) { heisse_Tage = 1; } else { heisse_Tage = 0; } 
    if (Tiefstwert < 0) { Frost_Tage = 1; } else { Frost_Tage = 0; } 
    if (Hoechstwert < 10) { kalte_Tage = 1; } else { kalte_Tage = 0; }
    if (Hoechstwert < 0) { Eistage = 1; } else { Eistage = 0; }
    if (Tiefstwert < -10) { sehr_kalte_Tage = 1; } else { sehr_kalte_Tage = 0; }

  //Wind
    Max_Windboe = Math.max(...wind);      

  //Regen
    Max_Regenmenge = Math.max(...regen);
    

/* Debug-Consolenausgaben
    console.log('Daten ab ' + timeConverter(start));
    console.log('Daten bis ' + timeConverter(end));
    console.log('Erster Messwert: ' + new Date(result.result[0][0].ts).toISOString() + ' ***' + result.result[0][0].value);
    console.log('Letzter Messwert: ' + new Date(result.result[0][temps.length-1].ts).toISOString() + ' ***' + result.result[0][temps.length-1].value);
    console.log('Anzahl Datensätze: T_' + temps.length + '|W_' + wind.length + '|R_' + regen.length); */

// Tag des Jahres berechnen
   let Jahr = zeitstempel.getFullYear();
   let heutestart = Number(new Date(zeitstempel.setHours(0,0,0,0)));
   let neujahr = Number(new Date(Jahr,0,1));
   let difftage = (heutestart - neujahr) / (24*60*60*1000) + 1;
   let tag_des_jahres = Math.ceil(difftage);
   

   // Datenpunkte schreiben
   if (getState(PRE_DP+'.aktueller_Monat.Tiefstwert').val > Tiefstwert) {setState(PRE_DP+'.aktueller_Monat.Tiefstwert', Tiefstwert, true);}    
   if (getState(PRE_DP+'.aktueller_Monat.Hoechstwert').val < Hoechstwert) {setState(PRE_DP+'.aktueller_Monat.Hoechstwert', Hoechstwert, true);}    
   if (getState(PRE_DP+'.aktueller_Monat.Temperatur_Durchschnitt').val != MonatsTemp_Durchschnitt) {setState(PRE_DP+'.aktueller_Monat.Temperatur_Durchschnitt', MonatsTemp_Durchschnitt, true);}
   if (getState(PRE_DP+'.aktueller_Monat.Max_Windboe').val < Max_Windboe) {setState(PRE_DP+'.aktueller_Monat.Max_Windboe', Max_Windboe, true);}
   if (getState(PRE_DP+'.aktueller_Monat.Max_Regenmenge').val < Max_Regenmenge) {setState(PRE_DP+'.aktueller_Monat.Max_Regenmenge', Max_Regenmenge, true);}
   if (Max_Regenmenge > 0) {Regenmenge_Monat = getState(PRE_DP+'.aktueller_Monat.Regenmenge_Monat').val + Max_Regenmenge; setState(PRE_DP+'.aktueller_Monat.Regenmenge_Monat', Number((Regenmenge_Monat).toFixed(2)), true);}
   if (warme_Tage) {warme_Tage = getState(PRE_DP+'.aktueller_Monat.warme_Tage').val +1; setState(PRE_DP+'.aktueller_Monat.warme_Tage', warme_Tage, true);
                    warme_Tage_Jahr = getState(PRE_DP+'.Jahreswerte.Gradtage_warmeTage').val +1; setState(PRE_DP+'.Jahreswerte.Gradtage_warmeTage', warme_Tage_Jahr, true);}
   if (Sommertage) {Sommertage = getState(PRE_DP+'.aktueller_Monat.Sommertage').val +1; setState(PRE_DP+'.aktueller_Monat.Sommertage', Sommertage, true);
                    Sommertage_Jahr = getState(PRE_DP+'.Jahreswerte.Gradtage_Sommertage').val +1; setState(PRE_DP+'.Jahreswerte.Gradtage_Sommertage', Sommertage_Jahr, true);}
   if (heisse_Tage) {heisse_Tage = getState(PRE_DP+'.aktueller_Monat.heisse_Tage').val +1; setState(PRE_DP+'.aktueller_Monat.heisse_Tage', heisse_Tage, true);
                    heisse_Tage_Jahr = getState(PRE_DP+'.Jahreswerte.Gradtage_heisseTage').val +1; setState(PRE_DP+'.Jahreswerte.Gradtage_heisseTage', heisse_Tage_Jahr, true);}
   if (Frost_Tage) {Frost_Tage = getState(PRE_DP+'.aktueller_Monat.Frost_Tage').val +1; setState(PRE_DP+'.aktueller_Monat.Frost_Tage', Frost_Tage, true);
                    Frosttage_Jahr = getState(PRE_DP+'.Jahreswerte.Gradtage_Frosttage').val +1; setState(PRE_DP+'.Jahreswerte.Gradtage_Frosttage', Frosttage_Jahr, true);}
   if (kalte_Tage) {kalte_Tage = getState(PRE_DP+'.aktueller_Monat.kalte_Tage').val +1; setState(PRE_DP+'.aktueller_Monat.kalte_Tage', kalte_Tage, true);
                    kalte_Tage_Jahr = getState(PRE_DP+'.Jahreswerte.Gradtage_kalteTage').val +1; setState(PRE_DP+'.Jahreswerte.Gradtage_kalteTage', kalte_Tage_Jahr, true);}
   if (Eistage) {Eistage = getState(PRE_DP+'.aktueller_Monat.Eistage').val +1; setState(PRE_DP+'.aktueller_Monat.Eistage', Eistage, true);
                Eistage_Jahr = getState(PRE_DP+'.Jahreswerte.Gradtage_Eistage').val +1; setState(PRE_DP+'.Jahreswerte.Gradtage_Eistage', Eistage_Jahr, true);}
   if (sehr_kalte_Tage) {sehr_kalte_Tage = getState(PRE_DP+'.aktueller_Monat.sehr_kalte_Tage').val +1; setState(PRE_DP+'.aktueller_Monat.sehr_kalte_Tage', sehr_kalte_Tage, true);
                        sehrkalte_Tage_Jahr = getState(PRE_DP+'.Jahreswerte.Gradtage_sehrkalteTage').val +1; setState(PRE_DP+'.Jahreswerte.Gradtage_sehrkalteTage', sehrkalte_Tage_Jahr, true);}
   
    //VorTag
    setState(PRE_DP+'.VorTag.Temperatur_Tiefstwert', Tiefstwert, true);
    setState(PRE_DP+'.VorTag.Temperatur_Hoechstwert', Hoechstwert, true);
    setState(PRE_DP+'.VorTag.Temperatur_Durchschnitt', Temp_Durchschnitt, true);
    setState(PRE_DP+'.VorTag.Regenmenge', Max_Regenmenge, true);
    setState(PRE_DP+'.VorTag.Windboe_max', Max_Windboe, true);

    //Jahresstatistik
       //Temperatur
       if (getState(PRE_DP+'.Jahreswerte.Temperatur_Hoechstwert').val < Hoechstwert) {setState(PRE_DP+'.Jahreswerte.Temperatur_Hoechstwert', Hoechstwert, true);}
       if (getState(PRE_DP+'.Jahreswerte.Temperatur_Tiefstwert').val > Tiefstwert) {setState(PRE_DP+'.Jahreswerte.Temperatur_Tiefstwert', Tiefstwert, true);}
       //Temperaturdurchschnitt
       let JahresTemp_Durchschnitt=Math.round(((getState(PRE_DP+'.Jahreswerte.Temperatur_Durchschnitt').val * (tag_des_jahres-1) + Temp_Durchschnitt)/tag_des_jahres)*100)/100;
       setState(PRE_DP+'.Jahreswerte.Temperatur_Durchschnitt', JahresTemp_Durchschnitt, true);
       //Regenmenge
       if (getState(PRE_DP+'.Jahreswerte.Regenmengetag').val < Max_Regenmenge) {setState(PRE_DP+'.Jahreswerte.Regenmengetag', Max_Regenmenge, true);}
       //Windböe
       if (getState(PRE_DP+'.Jahreswerte.Windboe_max').val <= Max_Windboe) {setState(PRE_DP+'.Jahreswerte.Windboe_max', Max_Windboe, true);} 
    if (getState(WET_DP+'.Info.Letzter_Regen').val.match(/Tag/g)) { //nur setzen bei [Tag]en, nicht bei Stunden
        Trockenperiode_akt=parseInt(getState(WET_DP+'.Info.Letzter_Regen').val.replace(/[^0-9\.]/g, ''), 10);
        let Trockenperiode_alt=getState(PRE_DP+'.Jahreswerte.Trockenperiode').val;
        if (Trockenperiode_akt >= Trockenperiode_alt) { setState(PRE_DP+'.Jahreswerte.Trockenperiode', Trockenperiode_akt, true); }
    }

    //Rekordwerte
    Rekordwerte();

 });
 if (getState(PRE_DP+'.Control.Reset_Jahresstatistik').val === true) { Reset_Jahresstatistik(); }
 console.log('Auswertung durchgeführt...');
 if (getState(PRE_DP+'.Control.ScriptVersion_UpdateCheck').val) { check_update(); } // neue Script-Version vorhanden?
 Statusmeldung('erfolgreich');
} //end function main

function Reset_Jahresstatistik() {
        setState(PRE_DP+'.Jahreswerte.Temperatur_Tiefstwert',   100,  true);
        setState(PRE_DP+'.Jahreswerte.Temperatur_Hoechstwert',  -100, true);
        setState(PRE_DP+'.Jahreswerte.Temperatur_Durchschnitt', 0,    true);
        setState(PRE_DP+'.Jahreswerte.Trockenperiode',          0,    true);
        setState(PRE_DP+'.Jahreswerte.Regenmengetag',           0,    true);
        setState(PRE_DP+'.Jahreswerte.Regenmengemonat',         0,    true);
        setState(PRE_DP+'.Jahreswerte.Windboe_max',             0,    true);
        setState(PRE_DP+'.Jahreswerte.Gradtage_kalteTage',      0,    true);
        setState(PRE_DP+'.Jahreswerte.Gradtage_warmeTage',      0,    true);
        setState(PRE_DP+'.Jahreswerte.Gradtage_Sommertage',     0,    true);
        setState(PRE_DP+'.Jahreswerte.Gradtage_heisseTage',     0,    true);
        setState(PRE_DP+'.Jahreswerte.Gradtage_Frosttage',      0,    true);
        setState(PRE_DP+'.Jahreswerte.Gradtage_Eistage',        0,    true);
        setState(PRE_DP+'.Jahreswerte.Gradtage_sehrkalteTage',  0,    true);

        setState(PRE_DP+'.Control.Reset_Jahresstatistik', false, true);
} //end function

function AutoDelete_Data() {
    let AutoDelete = getState(PRE_DP+'.Control.AutoDelete_Data').val; //Anzahl Monate
    let zeitstempel = new Date();
    let startAD = new Date(zeitstempel.getFullYear(),zeitstempel.getMonth()-AutoDelete,1);
    let AutoDelete_Year = startAD.getFullYear();
    let AutoDelete_Month = startAD.getMonth();
    let DP_Years = []; //Jahresordnernamen

    $(PRE_DP+'.Data.*').each(function(DPID) {
        let OID=[],i=0;
        OID=DPID.replace(PRE_DP+'.Data.', '').split('.');
        if (typeof OID[1] === "undefined") { DP_Years[i]=OID[0]; i++; } //Jahresordnername sichern
        if ((Number(OID[0])<AutoDelete_Year) || (Number(OID[0])==AutoDelete_Year && Number(OID[1])<=AutoDelete_Month)) {
            deleteState(PRE_DP+'.Data.'+OID[0]+'.'+OID[1]);
        }
    }); //end selector

    //check ob Jahresordner leer ist + ggf. löschen
    for ( let i=0; i<DP_Years.length; i++ ) {
        let DP_Ordner_test=$(PRE_DP+'.Data.'+DP_Years[i]+'.*');
        if ( DP_Ordner_test.length == 0 ) { deleteState(PRE_DP+'.Data.'+DP_Years[i]); }
    }
    
} //end function

function speichern_Monat() {
    let zeitstempel = new Date();
    let datum = new Date(zeitstempel.getFullYear(),zeitstempel.getMonth(),zeitstempel.getDate()-2);
    let monatsdatenpunkt = '.Data.'+datum.getFullYear()+'.'+pad(datum.getMonth()+1); 
    //Datenpunkte lesen
    Tiefstwert=getState(PRE_DP+'.aktueller_Monat.Tiefstwert').val;
    Hoechstwert=getState(PRE_DP+'.aktueller_Monat.Hoechstwert').val;
    Temp_Durchschnitt=getState(PRE_DP+'.aktueller_Monat.Temperatur_Durchschnitt').val;
    Max_Windboe=getState(PRE_DP+'.aktueller_Monat.Max_Windboe').val;
    Max_Regenmenge=getState(PRE_DP+'.aktueller_Monat.Max_Regenmenge').val;
    Regenmenge_Monat=getState(PRE_DP+'.aktueller_Monat.Regenmenge_Monat').val;
    warme_Tage=getState(PRE_DP+'.aktueller_Monat.warme_Tage').val;
    Sommertage=getState(PRE_DP+'.aktueller_Monat.Sommertage').val;
    heisse_Tage=getState(PRE_DP+'.aktueller_Monat.heisse_Tage').val;
    Frost_Tage=getState(PRE_DP+'.aktueller_Monat.Frost_Tage').val;
    kalte_Tage=getState(PRE_DP+'.aktueller_Monat.kalte_Tage').val;
    Eistage=getState(PRE_DP+'.aktueller_Monat.Eistage').val;
    sehr_kalte_Tage=getState(PRE_DP+'.aktueller_Monat.sehr_kalte_Tage').val;
    //ggf. höchste Monatsregenmenge im Jahr schreiben
    if (getState(PRE_DP+'.Jahreswerte.Regenmengemonat').val <= Regenmenge_Monat) {setState(PRE_DP+'.Jahreswerte.Regenmengemonat', Regenmenge_Monat, true);} 
    let json = JSON.stringify([{"Tiefstwert": Tiefstwert, "Hoechstwert": Hoechstwert, "Temp_Durchschnitt": Temp_Durchschnitt, "Max_Windboe": Max_Windboe, 
        "Max_Regenmenge": Max_Regenmenge, "Regenmenge_Monat": Regenmenge_Monat, "warme_Tage": warme_Tage,
        "Sommertage": Sommertage, "heisse_Tage": heisse_Tage, "Frost_Tage": Frost_Tage, "kalte_Tage": kalte_Tage, "Eistage": Eistage, 
        "sehr_kalte_Tage": sehr_kalte_Tage}]);
    createState(PRE_DP+monatsdatenpunkt,'',{ name: "Monatsstatistik für "+monatsname[datum.getMonth()]+' '+datum.getFullYear(), type: "string", role: "json" }, () => { setState(PRE_DP+monatsdatenpunkt, json, true); }); 
} //end function

function VorJahr() {    
    let zeitstempel = new Date();
    let datum = new Date(zeitstempel.getFullYear(),zeitstempel.getMonth(),zeitstempel.getDate());
    let monatsdatenpunkt = '.Data.'+ (datum.getFullYear()-1) +'.'+pad(datum.getMonth()+1);
    if (existsState(PRE_DP+monatsdatenpunkt)) { //der einfache Weg: wir haben schon Daten vom Vorjahr...
        let VorJahr = JSON.parse(getState(PRE_DP+monatsdatenpunkt).val);
        //VorJahr = JSON.parse(VorJahr);
        setState(PRE_DP+'.Vorjahres_Monat.Tiefstwert', VorJahr[0].Tiefstwert, true);
        setState(PRE_DP+'.Vorjahres_Monat.Hoechstwert', VorJahr[0].Hoechstwert, true);
        setState(PRE_DP+'.Vorjahres_Monat.Temperatur_Durchschnitt', VorJahr[0].Temp_Durchschnitt, true); 
        setState(PRE_DP+'.Vorjahres_Monat.Max_Windboe', VorJahr[0].Max_Windboe, true); 
        setState(PRE_DP+'.Vorjahres_Monat.Max_Regenmenge', VorJahr[0].Max_Regenmenge, true);
        setState(PRE_DP+'.Vorjahres_Monat.Regenmenge_Monat', VorJahr[0].Regenmenge_Monat, true);
        setState(PRE_DP+'.Vorjahres_Monat.warme_Tage', VorJahr[0].warme_Tage, true);
        setState(PRE_DP+'.Vorjahres_Monat.Sommertage', VorJahr[0].Sommertage, true);
        setState(PRE_DP+'.Vorjahres_Monat.heisse_Tage', VorJahr[0].heisse_Tage, true);
        setState(PRE_DP+'.Vorjahres_Monat.Frost_Tage', VorJahr[0].Frost_Tage, true);
        setState(PRE_DP+'.Vorjahres_Monat.kalte_Tage', VorJahr[0].kalte_Tage, true);
        setState(PRE_DP+'.Vorjahres_Monat.Eistage', VorJahr[0].Eistage, true);
        setState(PRE_DP+'.Vorjahres_Monat.sehr_kalte_Tage', VorJahr[0].sehr_kalte_Tage, true);

    } else {
        //leider noch keine Daten vom Vorjahr; wir haben was zu tun...
        
                    //Werte setzen
                    let VRegenmenge_Monat=99999;
                    let Vwarme_Tage=99999;
                    let VSommertage=99999;
                    let Vheisse_Tage=99999;
                    let VFrost_Tage=99999;
                    let Vkalte_Tage=99999;
                    let VEistage=99999;
                    let Vsehr_kalte_Tage=99999;

        //Abfrage der Influx-Datenbank
        let start, end, result = [], temps = [], wind = [], regen = [];
        start = new Date(zeitstempel.getFullYear()-1,zeitstempel.getMonth(),1,0,0,0);
        start = start.getTime();
        end = new Date(zeitstempel.getFullYear()-1,zeitstempel.getMonth(),monatstage[zeitstempel.getMonth()],23,59,59);
        end = end.getTime();
            sendTo('influxdb.'+INFLUXDB_INSTANZ, 'query', 
             'select * FROM "' + WET_DP + '.Aussentemperatur" WHERE time >= ' + (start *1000000) + ' AND time <= ' + (end *1000000)
             + '; select * FROM "' + WET_DP + '.Wind_max" WHERE time >= '  + (start *1000000) + ' AND time <= ' + (end *1000000)
             + '; select * FROM "' + WET_DP + '.Regen_Tag" WHERE time >= ' + (start *1000000) + ' AND time <= ' + (end *1000000)
                , function (result) {
                //Anlegen der Arrays + befüllen mit den relevanten Daten
                if (result.error) {
                  console.error('Fehler: '+result.error);
                } else {
                 //falls keinerlei Daten vom Vorjahr vorhanden sind...
                   if (typeof result.result[0][0] === "undefined") {
                    //Arrays löschen und mit default-Wert initiieren   
                    temps.length=0;
                    temps[0]=99999; 
                    wind.length=0;
                    wind[0]=99999;
                    regen.length=0;
                    regen[0]=99999;

                   } else {               
                    for (let i = 0; i < result.result[0].length; i++) { temps[i] = result.result[0][i].value; }
                    for (let i = 0; i < result.result[1].length; i++) { wind[i] = result.result[1][i].value; }
                    for (let i = 0; i < result.result[2].length; i++) { regen[i] = result.result[2][i].value; }
                   }
                }           
      
                //Temperaturen
                let VTiefstwert = Math.min(...temps);
                let VHoechstwert = Math.max(...temps);
                const reducer = (accumulator, curr) => accumulator + curr;
                let VTemp_Durchschnitt = Number((temps.reduce(reducer)/temps.length).toFixed(2));

                //let's do Gradtage...
                let MonatsTag, MonatsTag_old, Temp, Hit = [false,false,false,false,false,false,false];
                //Reset der Gradtage je nachdem ob Daten vorhanden oder nicht
                if (typeof result.result[0][0] !== "undefined") { Vwarme_Tage=0, VSommertage=0, Vheisse_Tage=0, VFrost_Tage=0, Vkalte_Tage=0, VEistage=0, Vsehr_kalte_Tage=0; }
                
                for (let i = 0; i < result.result[0].length; i++) {
                    MonatsTag = new Date(result.result[0][i].ts).getDate();
                    if (MonatsTag != MonatsTag_old) { Hit=[false,false,false,false,false,false,false]; }
                    Temp = result.result[0][i].value;
                     if (Temp > 20 && Hit[0] == false) { Vwarme_Tage++; Hit[0] = true; }
                     if (Temp > 25 && Hit[1] == false) { VSommertage++; Hit[1] = true; }
                     if (Temp > 30 && Hit[2] == false) { Vheisse_Tage++; Hit[2] = true; }
                     if (Temp < 0 && Hit[3] == false) { VFrost_Tage++; Hit[3] = true; }
                     if (Temp < 10 && Hit[4] == false) { Vkalte_Tage++; Hit[4] = true; }
                     if (Temp < 0 && Hit[5] == false) { VEistage++; Hit[5] = true; }
                     if (Temp < -10 && Hit[6] == false) { Vsehr_kalte_Tage++; Hit[6] = true; }
                    MonatsTag_old=MonatsTag; 
                } 

                //Wind
                let VMax_Windboe = Math.max(...wind);

                //Regen
                let VMax_Regenmenge = Math.max(...regen);
                let VRegenmenge_Monat=0, Rain = [];
                for (let i = 0; i < result.result[2].length; i++) {
                    MonatsTag = new Date(result.result[2][i].ts).getDate();
                    Rain[i] = result.result[2][i].value;
                    if (MonatsTag != MonatsTag_old) {
                        VRegenmenge_Monat+= Math.max(...Rain);
                        Rain.length=0; }
                    MonatsTag_old=MonatsTag; 
                }
                if (typeof result.result[0][0] === "undefined") { VRegenmenge_Monat=99999; } //keine Daten vom Vorjahresmonat

                //DPs schreiben
                setState(PRE_DP+'.Vorjahres_Monat.Tiefstwert', VTiefstwert, true);
                setState(PRE_DP+'.Vorjahres_Monat.Hoechstwert', VHoechstwert, true);
                setState(PRE_DP+'.Vorjahres_Monat.Temperatur_Durchschnitt', VTemp_Durchschnitt, true);
                setState(PRE_DP+'.Vorjahres_Monat.Max_Windboe', VMax_Windboe, true);
                setState(PRE_DP+'.Vorjahres_Monat.Max_Regenmenge', VMax_Regenmenge, true);
                setState(PRE_DP+'.Vorjahres_Monat.Regenmenge_Monat', VRegenmenge_Monat, true);
                setState(PRE_DP+'.Vorjahres_Monat.warme_Tage', Vwarme_Tage, true);
                setState(PRE_DP+'.Vorjahres_Monat.Sommertage', VSommertage, true);
                setState(PRE_DP+'.Vorjahres_Monat.heisse_Tage', Vheisse_Tage, true);
                setState(PRE_DP+'.Vorjahres_Monat.Frost_Tage', VFrost_Tage, true);
                setState(PRE_DP+'.Vorjahres_Monat.kalte_Tage', Vkalte_Tage, true);
                setState(PRE_DP+'.Vorjahres_Monat.Eistage', VEistage, true);
                setState(PRE_DP+'.Vorjahres_Monat.sehr_kalte_Tage', Vsehr_kalte_Tage, true);

            }); //end sendTo
        
    } //end else  

} //end function


function timeConverter(UNIX_timestamp){
  let a = new Date(UNIX_timestamp);
  let months = ['Jan','Feb','Mär','Apr','Mai','Jun','Jul','Aug','Sep','Okt','Nov','Dez'];
  let year = a.getFullYear();
  let month = months[a.getMonth()];
  let date = a.getDate();
  let hour = a.getHours();
  let min = a.getMinutes();
  let sec = a.getSeconds();
  let time = pad(date) + '. ' + month + ' ' + year + ' ' + pad(hour) + ':' + pad(min) + ':' + pad(sec) ;
  return time;
}

function pad(n) {
    return n<10 ? '0'+n : n;
}

// Pause einlegen
function Sleep(milliseconds) {
 return new Promise(resolve => setTimeout(resolve, milliseconds));
}

// Statusmeldungen in DP schreiben
function Statusmeldung(Text) {
    if (typeof(Text) === "undefined") { //nur beim Start des Skriptes
        Text = 'Skript gestartet';
        setState(PRE_DP+'.Control.ScriptVersion', ScriptVersion, true);    
    }
    setState(PRE_DP+'.Control.Statusmeldung', Text, true);
}

// Test auf neue Skriptversion
function check_update() {
    const axios = require('axios');

    axios.get('https://github.com/SBorg2014/WLAN-Wetterstation/commits/master/wetterstation-statistik.js')
     .then(function (response) {
     
     // /<a aria-label="V.*[\r\n]+.*<\/a>/

     let regex = /">V.*<\/a>/ 
     , version = response.data.match(regex);

     if (version[0].match(ScriptVersion)) { 
         setState(PRE_DP+'.Control.ScriptVersion_Update','---',true); 
     } else {
         setState(PRE_DP+'.Control.ScriptVersion_Update','https://github.com/SBorg2014/WLAN-Wetterstation/blob/master/wetterstation-statistik.js',true);
         console.log('neue Script-Version verfügbar...');
     }

    })
        .catch((error) => {
        console.log(`Fehler: ${error}`);
    })
} // end function

// Jahresstatistik-Backup
function Backup_Jahresstatistik() {
    let Temperatur_Hoechstwert = getState(PRE_DP+'.Jahreswerte.Temperatur_Hoechstwert').val;
    let Temperatur_Tiefstwert = getState(PRE_DP+'.Jahreswerte.Temperatur_Tiefstwert').val;
    let Temperatur_Durchschnitt = getState(PRE_DP+'.Jahreswerte.Temperatur_Durchschnitt').val;
    let Regenmengetag = getState(PRE_DP+'.Jahreswerte.Regenmengetag').val;
    let Regenmengemonat = getState(PRE_DP+'.Jahreswerte.Regenmengemonat').val;
    let Windboe_max = getState(PRE_DP+'.Jahreswerte.Windboe_max').val;
    let Trockenperiode = getState(PRE_DP+'.Jahreswerte.Trockenperiode').val;
    let kalte_Tage_Jahr = getState(PRE_DP+'.Jahreswerte.Gradtage_kalteTage').val;
    let warme_Tage_Jahr = getState(PRE_DP+'.Jahreswerte.Gradtage_warmeTage').val;
    let Sommertage_Jahr = getState(PRE_DP+'.Jahreswerte.Gradtage_Sommertage').val;
    let heisse_Tage_Jahr = getState(PRE_DP+'.Jahreswerte.Gradtage_heisseTage').val;
    let Frosttage_Jahr = getState(PRE_DP+'.Jahreswerte.Gradtage_Frosttage').val;
    let Eistage_Jahr = getState(PRE_DP+'.Jahreswerte.Gradtage_Eistage').val;
    let sehrkalte_Tage_Jahr = getState(PRE_DP+'.Jahreswerte.Gradtage_sehrkalteTage').val;

    let json = JSON.stringify([{"Temperatur Tiefstwert": Temperatur_Tiefstwert, "Temperatur Höchstwert": Temperatur_Hoechstwert, "Temperatur Durchschnitt": Temperatur_Durchschnitt,
        "Regenmengetag": Regenmengetag, "höchste Regenmengemonat": Regenmengemonat, "Windböe": Windboe_max,
        "Trockenperiode": Trockenperiode,
        "kalte Tage": kalte_Tage_Jahr, "warme Tage": warme_Tage_Jahr, "Sommertage": Sommertage_Jahr, "heiße Tage": heisse_Tage_Jahr, "Frosttage": Frosttage_Jahr, "Eistage": Eistage_Jahr,
        "sehr kalte Tage": sehrkalte_Tage_Jahr}]);
    createState(PRE_DP+'.Jahreswerte.VorJahre.'+(new Date().getFullYear()-1), '', { name: "Jahresstatistik", type: "string", role: "json" }, () => { setState(PRE_DP+'.Jahreswerte.VorJahre.'+(new Date().getFullYear()-1), json, true) });
} // end function


function Rekordwerte() {
    //max Temp
    if (getState(PRE_DP+'.Rekordwerte.value.Temp_Max').val <= Hoechstwert) {
        setState(PRE_DP+'.Rekordwerte.value.Temp_Max', Hoechstwert, true, () => { Template_Rekordwerte('Temp_Max','Rekordwerte.Temperatur_Spitzenhoechstwert'); });
    }

    //min Temp
    if (getState(PRE_DP+'.Rekordwerte.value.Temp_Min').val >= Tiefstwert) {
        setState(PRE_DP+'.Rekordwerte.value.Temp_Min', Tiefstwert, true, () => { Template_Rekordwerte('Temp_Min','Rekordwerte.Temperatur_Spitzentiefstwert'); });
    }  

    //Regenmenge
    if (getState(PRE_DP+'.Rekordwerte.value.Regenmengetag').val <= Max_Regenmenge) {
        setState(PRE_DP+'.Rekordwerte.value.Regenmengetag', Max_Regenmenge, true, () => { Template_Rekordwerte('Regenmengetag','Rekordwerte.Regenmengetag'); });
    }
    Regenmenge_Monat = getState(PRE_DP+'.aktueller_Monat.Regenmenge_Monat').val;
    if (getState(PRE_DP+'.Rekordwerte.value.Regenmengemonat').val <= Regenmenge_Monat) {
        setState(PRE_DP+'.Rekordwerte.value.Regenmengemonat', Regenmenge_Monat, true, () => { Template_Rekordwerte('Regenmengemonat','Rekordwerte.Regenmengemonat'); });
    }

    //Windböe
    if (getState(PRE_DP+'.Rekordwerte.value.Windboe').val <= Max_Windboe) {
        setState(PRE_DP+'.Rekordwerte.value.Windboe', Max_Windboe, true, () => { Template_Rekordwerte('Windboe','Rekordwerte.Windboe'); });
    }

    //Trockenperiode
    if (getState(PRE_DP+'.Rekordwerte.value.Trockenperiode').val <= Trockenperiode_akt) {
        setState(PRE_DP+'.Rekordwerte.value.Trockenperiode', Trockenperiode_akt, true, () => { Template_Rekordwerte('Trockenperiode','Rekordwerte.Trockenperiode'); });
    }  

} // end function


async function Template_Rekordwerte(DatenPunkt, DatenPunktName) {
    await Sleep(5000);
    let wert = getState(PRE_DP+'.Rekordwerte.value.'+DatenPunkt).val;
    let unit = getObject(PRE_DP+'.Rekordwerte.value.'+DatenPunkt).common.unit;
    let REKORDWERTEAUSGABE="";
    
    //[WERT]
    if (REKORDWERTE_AUSGABEFORMAT.search("[WERT]") != -1) {
        REKORDWERTEAUSGABE = REKORDWERTE_AUSGABEFORMAT.replace("[WERT]", wert+' '+unit);
    } else { REKORDWERTEAUSGABE = REKORDWERTE_AUSGABEFORMAT; }

    //[TAG]
    REKORDWERTEAUSGABE = REKORDWERTEAUSGABE.replace("[TAG]", new Date((getState(PRE_DP+'.Rekordwerte.value.'+DatenPunkt).lc)-86400).getDate()); 

    //[MONAT]
    REKORDWERTEAUSGABE = REKORDWERTEAUSGABE.replace("[MONAT]", monatsname[new Date((getState(PRE_DP+'.Rekordwerte.value.'+DatenPunkt).lc)-86400).getMonth()]);

    //[MONAT_ZAHL]
    REKORDWERTEAUSGABE = REKORDWERTEAUSGABE.replace("[MONAT_ZAHL]", pad(new Date((getState(PRE_DP+'.Rekordwerte.value.'+DatenPunkt).lc)-86400).getMonth()+1));

    //[MONAT_KURZ]
    REKORDWERTEAUSGABE = REKORDWERTEAUSGABE.replace("[MONAT_KURZ]", monatsname_kurz[new Date((getState(PRE_DP+'.Rekordwerte.value.'+DatenPunkt).lc)-86400).getMonth()]);

    //[JAHR]
    REKORDWERTEAUSGABE = REKORDWERTEAUSGABE.replace("[JAHR]", new Date((getState(PRE_DP+'.Rekordwerte.value.'+DatenPunkt).lc)-86400).getFullYear());

    //Spezialpatch für 1 Tag
    if ((REKORDWERTEAUSGABE.search("Tage") != -1) && (wert == 1)) {
        REKORDWERTEAUSGABE = REKORDWERTEAUSGABE.replace("Tage", "Tag");
    }

    setState(PRE_DP+'.'+DatenPunktName, REKORDWERTEAUSGABE, true);                                                 
} // end function


//Datenpunkte anlegen
async function createDP(DP_Check) {
    console.log(PRE_DP + '.' + DP_Check + ' existiert nicht... Lege Datenstruktur an...');
    createState(PRE_DP,                                           '',   { name: 'Wetterstatistik',                              type: "folder" });
    createState(PRE_DP+'.aktueller_Monat',                        '',   { name: 'Statistik für den aktuellen Monat',            type: "folder" });
    createState(PRE_DP+'.Vorjahres_Monat',                        '',   { name: 'Statistik für den Monat des Vorjahres',        type: "folder" });
    createState(PRE_DP+'.Data',                                   '',   { name: 'bisherige Statistiken',                        type: "folder" });
    createState(PRE_DP+'.VorTag',                                 '',   { name: 'Werte von Gestern',                            type: "folder" });
    createState(PRE_DP+'.Control',                                '',   { name: 'Einstellungen, Meldungen',                     type: "folder" });
    createState(PRE_DP+'.Jahreswerte',                            '',   { name: 'Jahresstatistik',                              type: "folder" });
    createState(PRE_DP+'.Rekordwerte',                            '',   { name: 'Rekordwerte seit Aufzeichnungsbeginn',         type: "folder" });
    
    createState(PRE_DP+'.aktueller_Monat.Tiefstwert',             100,  { name: "niedrigste Temperatur",                        type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.aktueller_Monat.Hoechstwert',            -100, { name: "höchste Temperatur",                           type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.aktueller_Monat.Temperatur_Durchschnitt',0,    { name: "Durchschnittstemperatur",                      type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.aktueller_Monat.Max_Windboe',            0,    { name: "stärkste Windböe",                             type: "number", role: "state", unit: "km/h" });
    createState(PRE_DP+'.aktueller_Monat.Max_Regenmenge',         0,    { name: "maximale Regenmenge pro Tag",                  type: "number", role: "state", unit: "l/m²" });
    createState(PRE_DP+'.aktueller_Monat.Regenmenge_Monat',       0,    { name: "Regenmenge im Monat",                          type: "number", role: "state", unit: "l/m²" });
    createState(PRE_DP+'.aktueller_Monat.warme_Tage',             0,    { name: "Tage mit einer Temperatur über 20°",           type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.aktueller_Monat.Sommertage',             0,    { name: "Tage mit einer Temperatur über 25°",           type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.aktueller_Monat.heisse_Tage',            0,    { name: "Tage mit einer Temperatur über 30°",           type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.aktueller_Monat.Frost_Tage',             0,    { name: "Tage mit einer Mindesttemperatur unter 0°",    type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.aktueller_Monat.kalte_Tage',             0,    { name: "Tage mit einer Höchsttemperatur unter 10°",    type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.aktueller_Monat.Eistage',                0,    { name: "Tage mit einer Höchsttemperatur unter 0°",     type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.aktueller_Monat.sehr_kalte_Tage',        0,    { name: "Tage mit einer Mindesttemperatur unter -10°",  type: "number", role: "state", unit: "Tage" });

    createState(PRE_DP+'.Vorjahres_Monat.Tiefstwert',             99999, { name: "niedrigste Temperatur",                       type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.Vorjahres_Monat.Hoechstwert',            99999, { name: "höchste Temperatur",                          type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.Vorjahres_Monat.Temperatur_Durchschnitt',99999, { name: "Durchschnittstemperatur",                     type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.Vorjahres_Monat.Max_Windboe',            99999, { name: "stärkste Windböe",                            type: "number", role: "state", unit: "km/h" });
    createState(PRE_DP+'.Vorjahres_Monat.Max_Regenmenge',         99999, { name: "maximale Regenmenge pro Tag",                 type: "number", role: "state", unit: "l/m²" });
    createState(PRE_DP+'.Vorjahres_Monat.Regenmenge_Monat',       99999, { name: "Regenmenge im Monat",                         type: "number", role: "state", unit: "l/m²" });
    createState(PRE_DP+'.Vorjahres_Monat.warme_Tage',             99999, { name: "Tage mit einer Temperatur über 20°",          type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.Vorjahres_Monat.Sommertage',             99999, { name: "Tage mit einer Temperatur über 25°",          type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.Vorjahres_Monat.heisse_Tage',            99999, { name: "Tage mit einer Temperatur über 30°",          type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.Vorjahres_Monat.Frost_Tage',             99999, { name: "Tage mit einer Mindesttemperatur unter 0°",   type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.Vorjahres_Monat.kalte_Tage',             99999, { name: "Tage mit einer Höchsttemperatur unter 10°",   type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.Vorjahres_Monat.Eistage',                99999, { name: "Tage mit einer Höchsttemperatur unter 0°",    type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.Vorjahres_Monat.sehr_kalte_Tage',        99999, { name: "Tage mit einer Mindesttemperatur unter -10°", type: "number", role: "state", unit: "Tage" });

    createState(PRE_DP+'.VorTag.Temperatur_Tiefstwert',           99999, { name: "niedrigste Tagestemperatur",                  type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.VorTag.Temperatur_Hoechstwert',          99999, { name: "höchste Tagestemperatur",                     type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.VorTag.Temperatur_Durchschnitt',         99999, { name: "Durchschnittstemperatur",                     type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.VorTag.Regenmenge',                      0,     { name: "Regenmenge vom Vortag",                       type: "number", role: "state", unit: "l/m²" });
    createState(PRE_DP+'.VorTag.Windboe_max',                     0,     { name: "stärkste Windböe vom Vortag",                 type: "number", role: "state", unit: "km/h" });

    createState(PRE_DP+'.Jahreswerte.Temperatur_Hoechstwert',     -100,  { name: "höchste Tagestemperatur des Jahres",          type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.Jahreswerte.Temperatur_Tiefstwert',      100,   { name: "niedrigste Tagestemperatur des Jahres",       type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.Jahreswerte.Temperatur_Durchschnitt',    0,     { name: "Durchschnittstemperatur des Jahres",          type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.Jahreswerte.Trockenperiode',             0,     { name: "längste Periode ohne Regen",                  type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.Jahreswerte.Regenmengetag',              0,     { name: "höchste Regenmenge an einem Tag",             type: "number", role: "state", unit: "l/m²" });
    createState(PRE_DP+'.Jahreswerte.Regenmengemonat',            0,     { name: "höchste Regenmenge innerhalb eines Monats",   type: "number", role: "state", unit: "l/m²" });
    createState(PRE_DP+'.Jahreswerte.Windboe_max',                0,     { name: "stärkste Windböe des Jahres",                 type: "number", role: "state", unit: "km/h" });
    createState(PRE_DP+'.Jahreswerte.Gradtage_kalteTage',         0,     { name: "Tage mit einer Höchsttemperatur unter 10°",   type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.Jahreswerte.Gradtage_warmeTage',         0,     { name: "Tage mit einer Höchsttemperatur über 20°",    type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.Jahreswerte.Gradtage_Sommertage',        0,     { name: "Tage mit einer Höchsttemperatur über 25°",    type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.Jahreswerte.Gradtage_heisseTage',        0,     { name: "Tage mit einer Höchsttemperatur über 30°",    type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.Jahreswerte.Gradtage_Frosttage',         0,     { name: "Tage mit einer Tiefsttemperatur unter 0°",    type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.Jahreswerte.Gradtage_Eistage',           0,     { name: "Tage mit einer Höchsttemperatur unter 0°",    type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.Jahreswerte.Gradtage_sehrkalteTage',     0,     { name: "Tage mit einer Tiefsttemperatur unter -10°",  type: "number", role: "state", unit: "Tage" });

    createState(PRE_DP+'.Rekordwerte.value.Temp_Max',             -100,  { name: "Max. Tagestemperatur",                        type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.Rekordwerte.value.Temp_Min',             100,   { name: "Min. Tagestemperatur",                        type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.Rekordwerte.value.Trockenperiode',       0,     { name: "längste Trockenperiode",                      type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.Rekordwerte.value.Temp_Durchschnitt_Min',99.99, { name: "niedrigster Jahrestemperaturdurchschnitt",    type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.Rekordwerte.value.Temp_Durchschnitt_Max',-99.99,{ name: "höchster Jahrestemperaturdurchschnitt",       type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.Rekordwerte.value.Regenmengetag',        0,     { name: "höchste je gemessene Regenmenge an einem Tag",type: "number", role: "state", unit: "l/m²" });
    createState(PRE_DP+'.Rekordwerte.value.Regenmengemonat',      0,     { name: "höchste je gemessene Regenmenge eines Monats",type: "number", role: "state", unit: "l/m²" });
    createState(PRE_DP+'.Rekordwerte.value.Windboe',              0,     { name: "stärkste je gemessene Windböe"               ,type: "number", role: "state", unit: "km/h" });
    createState(PRE_DP+'.Rekordwerte.Temperatur_Spitzenhoechstwert', '', { name: "höchste je gemessene Tagestemperatur",        type: "string", role: "state" });
    createState(PRE_DP+'.Rekordwerte.Temperatur_Spitzentiefstwert',  '', { name: "niedrigste je gemessene Tagestemperatur",     type: "string", role: "state" });
    createState(PRE_DP+'.Rekordwerte.Temperatur_Jahresdurchschnitt_Max', '', { name: "höchster Jahrestemperaturdurchschnitt",   type: "string", role: "state" });
    createState(PRE_DP+'.Rekordwerte.Temperatur_Jahresdurchschnitt_Min', '', { name: "niedrigster Jahrestemperaturdurchschnitt",type: "string", role: "state" });
    createState(PRE_DP+'.Rekordwerte.Regenmengetag',             '',     { name: "höchste je gemessene Regenmenge an einem Tag",type: "string", role: "state" });
    createState(PRE_DP+'.Rekordwerte.Regenmengemonat',           '',     { name: "höchste je gemessene Regenmenge eines Monats",type: "string", role: "state" });
    createState(PRE_DP+'.Rekordwerte.Windboe',                   '',     { name: "stärkste je gemessene Windböe"               ,type: "string", role: "state" });
    createState(PRE_DP+'.Rekordwerte.Trockenperiode',            '',     { name: "längste je andauernde Trockenperiode",        type: "string", role: "state" });

    createState(PRE_DP+'.Control.Statusmeldung',                  '',    { name: "Statusmeldungen",                             type: "string", role: "state"});
    createState(PRE_DP+'.Control.Reset_Jahresstatistik',          false, { name: "Jahresstatistik zurücksetzen",                type: "boolean",role: "state"});
    createState(PRE_DP+'.Control.AutoReset_Jahresstatistik',      0,     { name: "Jahresstatistik zurücksetzen [0=Aus, 1=Ein, 2=Ein+Backup]",type: "number",role: "state"});
    createState(PRE_DP+'.Control.AutoDelete_Data',                0,     { name: "Data bereinigen? [0 = nie, 1...n = nach x Monaten]",  type: "number", role: "state"});
    createState(PRE_DP+'.Control.ScriptVersion',                  '',    { name: "aktuelle Versionsnummer des Statistik-Skriptes",type: "string",role: "state"});
    createState(PRE_DP+'.Control.ScriptVersion_Update',           '',    { name: "neue Version des Statistik-Skriptes vorhanden",type: "string",role: "state"});
    createState(PRE_DP+'.Control.ScriptVersion_UpdateCheck',      '',    { name: "Skript-Updatecheck ein-/ausschalten",         type: "boolean",role: "state"});
    await Sleep(5000);
}

[jostereo]

@martybr sagte in [Linux Shell-Skript] WLAN-Wetterstation:

@jostereo Die Werte wurden leider bis auf die Rekordwerte nicht aktualisiert.

Bei den Rekordwerten scheinen auch nur die "Regenmengemonat" und "Trockenperiode" aktualisiert zu werden.

Die lasse das Script noch einen Tag laufen.

Hier das vollständige Script:

/* Wetterstation-Statistiken 

   holt die Messdaten aus einer InfluxDB und erstellt eine Monats-, Vorjahresmonat- und
   Rekordwerte-Statistik
   Wichtig: funktioniert nur mit der Default-Datenstruktur des WLAN-Wetterstation-Skriptes!
            Auch keine Aliase unter Influx nutzen!

   (c)2020-2021 by SBorg
   V1.0.1 - 18.12.2021  ~Bugfixing "error: TypeError: Cannot read property '0' of null"
                        ~Wechsel zu axios
   V1.0.0 - 02.10.2021  ~Bugfixing Werte VorJahresMonat
                        +Kompatibilität mit JSC 3.3.x hergestellt (Änderung JSON -> Array)
                        ~Rekordwerte werden nun korrekt am Tag des Ereignisses gespeichert
   V0.2.2 - 01.02.2021  ~Bugfixing Regenmenge Jahr + Monat
   V0.2.1 - 21.01.2021  ~Bugfixing Rekordwerte Spitzenhöchst-/-tiefstwert
   V0.2.0 - 15.01.2021  ~Bugfixing Benennung DPs / Korrektur Regenmenge
   V0.1.9 - 09.01.2021  +Regenmenge eines kpl. Monats im Jahr und Rekord
   V0.1.8 - 08.01.2021  +max. Windböe für Gestern und Jahres-/Rekordwerte
   V0.1.7 - 03.01.2021  ~Fix für fehlerhafte/fehlende Speicherung Jahreswerte + Trockenperiode
   V0.1.6 - 30.12.2020  +Summe "Sommertage", "heiße Tage", "Frosttage", "Eistage" und "sehr kalte Tage" für das gesamte Jahr
   V0.1.5 - 29.12.2020  +Summe "kalte Tage" und "warme Tage" für das gesamte Jahr
   V0.1.4 - 26.12.2020  +max. Regenmenge pro Tag für Jahres-/Rekordwerte
   V0.1.3 - 11.11.2020  +Rekordwerte
   V0.1.2 - 14.10.2020  ~Fix "NaN" bei Regenmenge Monat
   V0.1.1 - 12.10.2020  +AutoReset Jahresstatistik
   V0.1.0 - 08.10.2020  +DP für Statusmeldungen / Reset Jahresstatistik / AutoDelete "Data"
                        +ScriptVersion / Update vorhanden / UpdateCheck abschaltbar
                        +Jahresstatistik Min-/Max-/Durchschnittstemperatur/Trockenperiode
   V0.0.7 - 19.09.2020  +Min.-/Max.-/Durchschnittstemperatur vom Vortag
   V0.0.6 - 18.09.2020  +Regenmenge Monat
   V0.0.5 - 17.09.2020  +Gradtage Vorjahr
   V0.0.4 - 16.09.2020  +Eistage (Max. unter 0°C) / sehr kalte Tage (Min. unter -10°C)
                        ~Frosttage (Korrektur: Tiefstwert unter 0°C)
   V0.0.3 - 15.09.2020  +Frosttage (Min. unter 0°C) / kalte Tage (Max. unter 10°C)
   V0.0.2 - 12.09.2020  +warme Tage über 20°C / Sommertage über 25°C / heiße Tage über 30°C
   V0.0.1 - 11.09.2020   erste Beta + Temp-Min/Temp-Max/Temp-Durchschnitt/max. Windböe/max. Regenmenge pro Tag

      ToDo: ---
      known issues: keine

*/



// *** User-Einstellungen **********************************************************************************************************************************
    const WET_DP='0_userdata.0.Wetterstation';        // wo liegen die Datenpunkte mit den Daten der Wetterstation  [default: javascript.0.Wetterstation]                          
    const INFLUXDB_INSTANZ='0';                       // unter welcher Instanz läuft die InfluxDB [default: 0]
    const PRE_DP='0_userdata.0.Statistik.Wetter';     // wo sollen die Statistikwerte abgelegt werden. Nur unter "0_userdata" oder "javascript" möglich!
    let REKORDWERTE_AUSGABEFORMAT="[WERT] im [MONAT] [JAHR]";   /* Wie soll die Ausgabe der Rekordwerte formatiert werden (Template-Vorlage)?
                                                                    [WERT]      = Messwert (zB. '22.42' bei Temperatur, '12' bei Tagen)
                                                                    [TAG]       = Tag (0-31)
                                                                    [MONAT]     = Monatsname (Januar, Februar,..., Dezember)
                                                                    [MONAT_ZAHL]= Monat als Zahl (01-12)
                                                                    [MONAT_KURZ]= Monatsname kurz (Jan, Feb,..., Dez)
                                                                    [JAHR]      = Jahreszahl vierstellig (2020)
                                                                 Die 'Units' wie bspw. "°C" oder "Tage" werden direkt aus dem Datenpunkt ergänzt. 
                                                                 [default: [WERT] im [MONAT] [JAHR] ] erzeugt als Beispiel im DP die 
                                                                 Ausgabe: "22.42 °C im Juni 2020"
                                                                */
    const ZEITPLAN = "3 1 * * *";                     // wann soll die Statistik erstellt werden (Minuten Stunde * * *) [default 1:03 Uhr] 
// *** ENDE User-Einstellungen *****************************************************************************************************************************




//ab hier gibt es nix mehr zu ändern :)
//first start?
const DP_Check='Rekordwerte.Regenmengemonat';
if (!existsState(PRE_DP+'.'+DP_Check)) { createDP(DP_Check); }

//Start des Scripts
    const ScriptVersion = "V1.0.1";
    let Tiefstwert, Hoechstwert, Temp_Durchschnitt, Max_Windboe, Max_Regenmenge, Regenmenge_Monat, warme_Tage, Sommertage;
    let heisse_Tage, Frost_Tage, kalte_Tage, Eistage, sehr_kalte_Tage, Trockenperiode_akt;
    let kalte_Tage_Jahr, warme_Tage_Jahr, Sommertage_Jahr, heisse_Tage_Jahr, Frosttage_Jahr, Eistage_Jahr, sehrkalte_Tage_Jahr;
    let monatstage = [31,28,31,30,31,30,31,31,30,31,30,31];
    let monatsname = ['Januar','Februar','März','April','Mai','Juni','Juli','August','September','Oktober','November','Dezember'];
    let monatsname_kurz = ['Jan','Feb','Mär','Apr','Mai','Jun','Jul','Aug','Sep','Okt','Nov','Dez'];
    console.log('Wetterstation-Statistiken gestartet...');
    setTimeout(Statusmeldung, 500);

//scheduler
    schedule(ZEITPLAN, main);


// ### Funktionen ###############################################################################################
async function main() {
    let result = [], temps = [], wind = [], regen = [], start, end, zeitstempel = new Date();
    start = new Date(zeitstempel.getFullYear(),zeitstempel.getMonth(),zeitstempel.getDate()-1,0,0,0);
    start = start.getTime();
    end = new Date(zeitstempel.getFullYear(),zeitstempel.getMonth(),zeitstempel.getDate()-1,23,59,59);
    end = end.getTime();

    //Jobs Monatserster
 if (zeitstempel.getDate() == 1) { 
     if (zeitstempel.getMonth() == 0) { //heute ist der 01.01. 

        //Rekordwerte (Temperatur-Durchschnitt) setzen
            //max Jahrestemperaturdurchschnitt
            let JahresTemperatur_Durchschnitt = getState(PRE_DP+'.Jahreswerte.Temperatur_Durchschnitt').val;
            if (getState(PRE_DP+'.Rekordwerte.value.Temp_Durchschnitt_Max').val < JahresTemperatur_Durchschnitt) {
                setState(PRE_DP+'.Rekordwerte.value.Temp_Durchschnitt_Max', JahresTemperatur_Durchschnitt, true);
                setState(PRE_DP+'.Rekordwerte.Temperatur_Jahresdurchschnitt_Max', JahresTemperatur_Durchschnitt+' für '+ (zeitstempel.getFullYear()-1), true);
                //, () => { Template_Rekordwerte('Temp_Durchschnitt_Max','Rekordwerte.Temperatur_Jahresdurchschnitt_Max'); });
            }  
            //min Jahrestemperaturdurchschnitt
            if (getState(PRE_DP+'.Rekordwerte.value.Temp_Durchschnitt_Min').val > JahresTemperatur_Durchschnitt) {
                setState(PRE_DP+'.Rekordwerte.value.Temp_Durchschnitt_Min', JahresTemperatur_Durchschnitt, true);
                setState(PRE_DP+'.Rekordwerte.Temperatur_Jahresdurchschnitt_Min', JahresTemperatur_Durchschnitt+' für '+ (zeitstempel.getFullYear()-1), true);
                //, () => { Template_Rekordwerte('Temp_Durchschnitt_Min','Rekordwerte.Temperatur_Jahresdurchschnitt_Min'); });
            }

        //Rekordwerte (Temperatur-Durchschnitt) einmalig resetten [InstallationsJahr +1]
        let Inst_Jahr = (new Date(getState(PRE_DP).ts)).getFullYear();
        if (zeitstempel.getFullYear() == Inst_Jahr+1) {
            setState(PRE_DP+'.Rekordwerte.value.Temp_Durchschnitt_Max', -99.99, true);
            setState(PRE_DP+'.Rekordwerte.value.Temp_Durchschnitt_Min',  99.99, true);
            setState(PRE_DP+'.Rekordwerte.Temperatur_Jahresdurchschnitt_Max' ,'' ,true);
            setState(PRE_DP+'.Rekordwerte.Temperatur_Jahresdurchschnitt_Min' ,'' ,true);
        }

        let mode=getState(PRE_DP+'.Control.AutoReset_Jahresstatistik').val;
        switch (mode) { //0=Aus, 1=Ein, 2=Ein+Backup
            case 0:
               break;

            case 1:
               Reset_Jahresstatistik();
               break;

            case 2:
               Backup_Jahresstatistik();
               Reset_Jahresstatistik();
               break;

            default:
               break;
        } // end switch

     } // end if 01.01.

   await speichern_Monat();  //vorherige Monatsstatistik speichern
   await VorJahr();          //Vorjahresmonatsstatistik ausführen
   
   /*DPs unabhängig ihres Wertes initial schreiben; wir nehmen die aktuelle Außentemperatur, da sie zum Start des Messzyklus
     Min, Max und Durchschnitt darstellt; Rest einfach nullen */
    let initialTemp=getState(WET_DP+'.Aussentemperatur').val;
    setState(PRE_DP+'.aktueller_Monat.Tiefstwert', initialTemp, true);
    setState(PRE_DP+'.aktueller_Monat.Hoechstwert', initialTemp, true);
    setState(PRE_DP+'.aktueller_Monat.Temperatur_Durchschnitt', initialTemp, true);
    setState(PRE_DP+'.aktueller_Monat.Max_Windboe', 0, true);
    setState(PRE_DP+'.aktueller_Monat.Max_Regenmenge', 0, true);
    setState(PRE_DP+'.aktueller_Monat.Regenmenge_Monat', 0, true);
    setState(PRE_DP+'.aktueller_Monat.warme_Tage', 0, true);
    setState(PRE_DP+'.aktueller_Monat.Sommertage', 0, true);
    setState(PRE_DP+'.aktueller_Monat.heisse_Tage', 0, true);
    setState(PRE_DP+'.aktueller_Monat.Frost_Tage', 0, true);
    setState(PRE_DP+'.aktueller_Monat.kalte_Tage', 0, true);
    setState(PRE_DP+'.aktueller_Monat.Eistage', 0, true);
    setState(PRE_DP+'.aktueller_Monat.sehr_kalte_Tage', 0, true);

    sleep(3000);
    
   if (getState(PRE_DP+'.Control.AutoDelete_Data').val >0) { AutoDelete_Data(); }
   //nun beenden
   return;

 }// End Jobs Monatserster

            //InfluxDB abfragen (Regen +1min Startverzögerung wg. ev. Ungenauigkeit der Systemzeit des Wetterstation-Displays)
            sendTo('influxdb.'+INFLUXDB_INSTANZ, 'query', 
            'from(bucket: "iobroker") |> range(start: ' + (start / 1000) + ', stop: ' + (end / 1000) + ') |> filter(fn: (r) => r["_measurement"] == "' + WET_DP + '.Aussentemperatur") |> filter(fn: (r) => r["_field"] == "value");' +
        'from(bucket: "iobroker") |> range(start: ' + (start / 1000) + ', stop: ' + (end / 1000) + ') |> filter(fn: (r) => r["_measurement"] == "' + WET_DP + '.Wind_max") |> filter(fn: (r) => r["_field"] == "value");' +
        'from(bucket: "iobroker") |> range(start: ' + ((start + 72000) / 1000) + ', stop: ' + (end / 1000) + ') |> filter(fn: (r) => r["_measurement"] == "' + WET_DP + '.Regen_Tag") |> filter(fn: (r) => r["_field"] == "value")'

         , function (result) {
             //Anlegen der Arrays + befüllen mit den relevanten Daten
            if (result.error) {
               console.error('Fehler beim Lesen der InfluxDB: '+result.error);
               Statusmeldung('Fehler beim Lesen der InfluxDB: '+result.error);
            } else {
                //console.log('Rows: ' + JSON.stringify(result.result[2]));
                for (let i = 0; i < result.result[0].length; i++) { temps[i] = result.result[0][i].value; }
                for (let i = 0; i < result.result[1].length; i++) { wind[i] = result.result[1][i].value; }
                for (let i = 0; i < result.result[2].length; i++) { regen[i] = result.result[2][i].value; }
            }           
                    
  //Temperaturen
    Tiefstwert = Math.min(...temps);
    Hoechstwert = Math.max(...temps);
    //Math.sum = (...temps) => Array.prototype.reduce.call(temps,(a,b) => a+b);
    const reducer = (accumulator, curr) => accumulator + curr;
    //Temp_Durchschnitt = Number((Math.sum(...temps)/temps.length).toFixed(2));
    let Temp_Durchschnitt = Number((temps.reduce(reducer)/temps.length).toFixed(2));
    let MonatsTemp_Durchschnitt = Math.round(((((getState(PRE_DP+'.aktueller_Monat.Temperatur_Durchschnitt').val)*(zeitstempel.getDate()-1))+Temp_Durchschnitt)/zeitstempel.getDate())*100)/100;
    if (Hoechstwert > 20) { warme_Tage = 1; } else { warme_Tage = 0; }
    if (Hoechstwert > 25) { Sommertage = 1; } else { Sommertage = 0; } 
    if (Hoechstwert > 30) { heisse_Tage = 1; } else { heisse_Tage = 0; } 
    if (Tiefstwert < 0) { Frost_Tage = 1; } else { Frost_Tage = 0; } 
    if (Hoechstwert < 10) { kalte_Tage = 1; } else { kalte_Tage = 0; }
    if (Hoechstwert < 0) { Eistage = 1; } else { Eistage = 0; }
    if (Tiefstwert < -10) { sehr_kalte_Tage = 1; } else { sehr_kalte_Tage = 0; }

  //Wind
    Max_Windboe = Math.max(...wind);      

  //Regen
    Max_Regenmenge = Math.max(...regen);
    

/* Debug-Consolenausgaben
    console.log('Daten ab ' + timeConverter(start));
    console.log('Daten bis ' + timeConverter(end));
    console.log('Erster Messwert: ' + new Date(result.result[0][0].ts).toISOString() + ' ***' + result.result[0][0].value);
    console.log('Letzter Messwert: ' + new Date(result.result[0][temps.length-1].ts).toISOString() + ' ***' + result.result[0][temps.length-1].value);
    console.log('Anzahl Datensätze: T_' + temps.length + '|W_' + wind.length + '|R_' + regen.length); */

// Tag des Jahres berechnen
   let Jahr = zeitstempel.getFullYear();
   let heutestart = Number(new Date(zeitstempel.setHours(0,0,0,0)));
   let neujahr = Number(new Date(Jahr,0,1));
   let difftage = (heutestart - neujahr) / (24*60*60*1000) + 1;
   let tag_des_jahres = Math.ceil(difftage);
   

   // Datenpunkte schreiben
   if (getState(PRE_DP+'.aktueller_Monat.Tiefstwert').val > Tiefstwert) {setState(PRE_DP+'.aktueller_Monat.Tiefstwert', Tiefstwert, true);}    
   if (getState(PRE_DP+'.aktueller_Monat.Hoechstwert').val < Hoechstwert) {setState(PRE_DP+'.aktueller_Monat.Hoechstwert', Hoechstwert, true);}    
   if (getState(PRE_DP+'.aktueller_Monat.Temperatur_Durchschnitt').val != MonatsTemp_Durchschnitt) {setState(PRE_DP+'.aktueller_Monat.Temperatur_Durchschnitt', MonatsTemp_Durchschnitt, true);}
   if (getState(PRE_DP+'.aktueller_Monat.Max_Windboe').val < Max_Windboe) {setState(PRE_DP+'.aktueller_Monat.Max_Windboe', Max_Windboe, true);}
   if (getState(PRE_DP+'.aktueller_Monat.Max_Regenmenge').val < Max_Regenmenge) {setState(PRE_DP+'.aktueller_Monat.Max_Regenmenge', Max_Regenmenge, true);}
   if (Max_Regenmenge > 0) {Regenmenge_Monat = getState(PRE_DP+'.aktueller_Monat.Regenmenge_Monat').val + Max_Regenmenge; setState(PRE_DP+'.aktueller_Monat.Regenmenge_Monat', Number((Regenmenge_Monat).toFixed(2)), true);}
   if (warme_Tage) {warme_Tage = getState(PRE_DP+'.aktueller_Monat.warme_Tage').val +1; setState(PRE_DP+'.aktueller_Monat.warme_Tage', warme_Tage, true);
                    warme_Tage_Jahr = getState(PRE_DP+'.Jahreswerte.Gradtage_warmeTage').val +1; setState(PRE_DP+'.Jahreswerte.Gradtage_warmeTage', warme_Tage_Jahr, true);}
   if (Sommertage) {Sommertage = getState(PRE_DP+'.aktueller_Monat.Sommertage').val +1; setState(PRE_DP+'.aktueller_Monat.Sommertage', Sommertage, true);
                    Sommertage_Jahr = getState(PRE_DP+'.Jahreswerte.Gradtage_Sommertage').val +1; setState(PRE_DP+'.Jahreswerte.Gradtage_Sommertage', Sommertage_Jahr, true);}
   if (heisse_Tage) {heisse_Tage = getState(PRE_DP+'.aktueller_Monat.heisse_Tage').val +1; setState(PRE_DP+'.aktueller_Monat.heisse_Tage', heisse_Tage, true);
                    heisse_Tage_Jahr = getState(PRE_DP+'.Jahreswerte.Gradtage_heisseTage').val +1; setState(PRE_DP+'.Jahreswerte.Gradtage_heisseTage', heisse_Tage_Jahr, true);}
   if (Frost_Tage) {Frost_Tage = getState(PRE_DP+'.aktueller_Monat.Frost_Tage').val +1; setState(PRE_DP+'.aktueller_Monat.Frost_Tage', Frost_Tage, true);
                    Frosttage_Jahr = getState(PRE_DP+'.Jahreswerte.Gradtage_Frosttage').val +1; setState(PRE_DP+'.Jahreswerte.Gradtage_Frosttage', Frosttage_Jahr, true);}
   if (kalte_Tage) {kalte_Tage = getState(PRE_DP+'.aktueller_Monat.kalte_Tage').val +1; setState(PRE_DP+'.aktueller_Monat.kalte_Tage', kalte_Tage, true);
                    kalte_Tage_Jahr = getState(PRE_DP+'.Jahreswerte.Gradtage_kalteTage').val +1; setState(PRE_DP+'.Jahreswerte.Gradtage_kalteTage', kalte_Tage_Jahr, true);}
   if (Eistage) {Eistage = getState(PRE_DP+'.aktueller_Monat.Eistage').val +1; setState(PRE_DP+'.aktueller_Monat.Eistage', Eistage, true);
                Eistage_Jahr = getState(PRE_DP+'.Jahreswerte.Gradtage_Eistage').val +1; setState(PRE_DP+'.Jahreswerte.Gradtage_Eistage', Eistage_Jahr, true);}
   if (sehr_kalte_Tage) {sehr_kalte_Tage = getState(PRE_DP+'.aktueller_Monat.sehr_kalte_Tage').val +1; setState(PRE_DP+'.aktueller_Monat.sehr_kalte_Tage', sehr_kalte_Tage, true);
                        sehrkalte_Tage_Jahr = getState(PRE_DP+'.Jahreswerte.Gradtage_sehrkalteTage').val +1; setState(PRE_DP+'.Jahreswerte.Gradtage_sehrkalteTage', sehrkalte_Tage_Jahr, true);}
   
    //VorTag
    setState(PRE_DP+'.VorTag.Temperatur_Tiefstwert', Tiefstwert, true);
    setState(PRE_DP+'.VorTag.Temperatur_Hoechstwert', Hoechstwert, true);
    setState(PRE_DP+'.VorTag.Temperatur_Durchschnitt', Temp_Durchschnitt, true);
    setState(PRE_DP+'.VorTag.Regenmenge', Max_Regenmenge, true);
    setState(PRE_DP+'.VorTag.Windboe_max', Max_Windboe, true);

    //Jahresstatistik
       //Temperatur
       if (getState(PRE_DP+'.Jahreswerte.Temperatur_Hoechstwert').val < Hoechstwert) {setState(PRE_DP+'.Jahreswerte.Temperatur_Hoechstwert', Hoechstwert, true);}
       if (getState(PRE_DP+'.Jahreswerte.Temperatur_Tiefstwert').val > Tiefstwert) {setState(PRE_DP+'.Jahreswerte.Temperatur_Tiefstwert', Tiefstwert, true);}
       //Temperaturdurchschnitt
       let JahresTemp_Durchschnitt=Math.round(((getState(PRE_DP+'.Jahreswerte.Temperatur_Durchschnitt').val * (tag_des_jahres-1) + Temp_Durchschnitt)/tag_des_jahres)*100)/100;
       setState(PRE_DP+'.Jahreswerte.Temperatur_Durchschnitt', JahresTemp_Durchschnitt, true);
       //Regenmenge
       if (getState(PRE_DP+'.Jahreswerte.Regenmengetag').val < Max_Regenmenge) {setState(PRE_DP+'.Jahreswerte.Regenmengetag', Max_Regenmenge, true);}
       //Windböe
       if (getState(PRE_DP+'.Jahreswerte.Windboe_max').val <= Max_Windboe) {setState(PRE_DP+'.Jahreswerte.Windboe_max', Max_Windboe, true);} 
    if (getState(WET_DP+'.Info.Letzter_Regen').val.match(/Tag/g)) { //nur setzen bei [Tag]en, nicht bei Stunden
        Trockenperiode_akt=parseInt(getState(WET_DP+'.Info.Letzter_Regen').val.replace(/[^0-9\.]/g, ''), 10);
        let Trockenperiode_alt=getState(PRE_DP+'.Jahreswerte.Trockenperiode').val;
        if (Trockenperiode_akt >= Trockenperiode_alt) { setState(PRE_DP+'.Jahreswerte.Trockenperiode', Trockenperiode_akt, true); }
    }

    //Rekordwerte
    Rekordwerte();

 });
 if (getState(PRE_DP+'.Control.Reset_Jahresstatistik').val === true) { Reset_Jahresstatistik(); }
 console.log('Auswertung durchgeführt...');
 if (getState(PRE_DP+'.Control.ScriptVersion_UpdateCheck').val) { check_update(); } // neue Script-Version vorhanden?
 Statusmeldung('erfolgreich');
} //end function main

function Reset_Jahresstatistik() {
        setState(PRE_DP+'.Jahreswerte.Temperatur_Tiefstwert',   100,  true);
        setState(PRE_DP+'.Jahreswerte.Temperatur_Hoechstwert',  -100, true);
        setState(PRE_DP+'.Jahreswerte.Temperatur_Durchschnitt', 0,    true);
        setState(PRE_DP+'.Jahreswerte.Trockenperiode',          0,    true);
        setState(PRE_DP+'.Jahreswerte.Regenmengetag',           0,    true);
        setState(PRE_DP+'.Jahreswerte.Regenmengemonat',         0,    true);
        setState(PRE_DP+'.Jahreswerte.Windboe_max',             0,    true);
        setState(PRE_DP+'.Jahreswerte.Gradtage_kalteTage',      0,    true);
        setState(PRE_DP+'.Jahreswerte.Gradtage_warmeTage',      0,    true);
        setState(PRE_DP+'.Jahreswerte.Gradtage_Sommertage',     0,    true);
        setState(PRE_DP+'.Jahreswerte.Gradtage_heisseTage',     0,    true);
        setState(PRE_DP+'.Jahreswerte.Gradtage_Frosttage',      0,    true);
        setState(PRE_DP+'.Jahreswerte.Gradtage_Eistage',        0,    true);
        setState(PRE_DP+'.Jahreswerte.Gradtage_sehrkalteTage',  0,    true);

        setState(PRE_DP+'.Control.Reset_Jahresstatistik', false, true);
} //end function

function AutoDelete_Data() {
    let AutoDelete = getState(PRE_DP+'.Control.AutoDelete_Data').val; //Anzahl Monate
    let zeitstempel = new Date();
    let startAD = new Date(zeitstempel.getFullYear(),zeitstempel.getMonth()-AutoDelete,1);
    let AutoDelete_Year = startAD.getFullYear();
    let AutoDelete_Month = startAD.getMonth();
    let DP_Years = []; //Jahresordnernamen

    $(PRE_DP+'.Data.*').each(function(DPID) {
        let OID=[],i=0;
        OID=DPID.replace(PRE_DP+'.Data.', '').split('.');
        if (typeof OID[1] === "undefined") { DP_Years[i]=OID[0]; i++; } //Jahresordnername sichern
        if ((Number(OID[0])<AutoDelete_Year) || (Number(OID[0])==AutoDelete_Year && Number(OID[1])<=AutoDelete_Month)) {
            deleteState(PRE_DP+'.Data.'+OID[0]+'.'+OID[1]);
        }
    }); //end selector

    //check ob Jahresordner leer ist + ggf. löschen
    for ( let i=0; i<DP_Years.length; i++ ) {
        let DP_Ordner_test=$(PRE_DP+'.Data.'+DP_Years[i]+'.*');
        if ( DP_Ordner_test.length == 0 ) { deleteState(PRE_DP+'.Data.'+DP_Years[i]); }
    }
    
} //end function

function speichern_Monat() {
    let zeitstempel = new Date();
    let datum = new Date(zeitstempel.getFullYear(),zeitstempel.getMonth(),zeitstempel.getDate()-2);
    let monatsdatenpunkt = '.Data.'+datum.getFullYear()+'.'+pad(datum.getMonth()+1); 
    //Datenpunkte lesen
    Tiefstwert=getState(PRE_DP+'.aktueller_Monat.Tiefstwert').val;
    Hoechstwert=getState(PRE_DP+'.aktueller_Monat.Hoechstwert').val;
    Temp_Durchschnitt=getState(PRE_DP+'.aktueller_Monat.Temperatur_Durchschnitt').val;
    Max_Windboe=getState(PRE_DP+'.aktueller_Monat.Max_Windboe').val;
    Max_Regenmenge=getState(PRE_DP+'.aktueller_Monat.Max_Regenmenge').val;
    Regenmenge_Monat=getState(PRE_DP+'.aktueller_Monat.Regenmenge_Monat').val;
    warme_Tage=getState(PRE_DP+'.aktueller_Monat.warme_Tage').val;
    Sommertage=getState(PRE_DP+'.aktueller_Monat.Sommertage').val;
    heisse_Tage=getState(PRE_DP+'.aktueller_Monat.heisse_Tage').val;
    Frost_Tage=getState(PRE_DP+'.aktueller_Monat.Frost_Tage').val;
    kalte_Tage=getState(PRE_DP+'.aktueller_Monat.kalte_Tage').val;
    Eistage=getState(PRE_DP+'.aktueller_Monat.Eistage').val;
    sehr_kalte_Tage=getState(PRE_DP+'.aktueller_Monat.sehr_kalte_Tage').val;
    //ggf. höchste Monatsregenmenge im Jahr schreiben
    if (getState(PRE_DP+'.Jahreswerte.Regenmengemonat').val <= Regenmenge_Monat) {setState(PRE_DP+'.Jahreswerte.Regenmengemonat', Regenmenge_Monat, true);} 
    let json = JSON.stringify([{"Tiefstwert": Tiefstwert, "Hoechstwert": Hoechstwert, "Temp_Durchschnitt": Temp_Durchschnitt, "Max_Windboe": Max_Windboe, 
        "Max_Regenmenge": Max_Regenmenge, "Regenmenge_Monat": Regenmenge_Monat, "warme_Tage": warme_Tage,
        "Sommertage": Sommertage, "heisse_Tage": heisse_Tage, "Frost_Tage": Frost_Tage, "kalte_Tage": kalte_Tage, "Eistage": Eistage, 
        "sehr_kalte_Tage": sehr_kalte_Tage}]);
    createState(PRE_DP+monatsdatenpunkt,'',{ name: "Monatsstatistik für "+monatsname[datum.getMonth()]+' '+datum.getFullYear(), type: "string", role: "json" }, () => { setState(PRE_DP+monatsdatenpunkt, json, true); }); 
} //end function

function VorJahr() {    
    let zeitstempel = new Date();
    let datum = new Date(zeitstempel.getFullYear(),zeitstempel.getMonth(),zeitstempel.getDate());
    let monatsdatenpunkt = '.Data.'+ (datum.getFullYear()-1) +'.'+pad(datum.getMonth()+1);
    if (existsState(PRE_DP+monatsdatenpunkt)) { //der einfache Weg: wir haben schon Daten vom Vorjahr...
        let VorJahr = JSON.parse(getState(PRE_DP+monatsdatenpunkt).val);
        //VorJahr = JSON.parse(VorJahr);
        setState(PRE_DP+'.Vorjahres_Monat.Tiefstwert', VorJahr[0].Tiefstwert, true);
        setState(PRE_DP+'.Vorjahres_Monat.Hoechstwert', VorJahr[0].Hoechstwert, true);
        setState(PRE_DP+'.Vorjahres_Monat.Temperatur_Durchschnitt', VorJahr[0].Temp_Durchschnitt, true); 
        setState(PRE_DP+'.Vorjahres_Monat.Max_Windboe', VorJahr[0].Max_Windboe, true); 
        setState(PRE_DP+'.Vorjahres_Monat.Max_Regenmenge', VorJahr[0].Max_Regenmenge, true);
        setState(PRE_DP+'.Vorjahres_Monat.Regenmenge_Monat', VorJahr[0].Regenmenge_Monat, true);
        setState(PRE_DP+'.Vorjahres_Monat.warme_Tage', VorJahr[0].warme_Tage, true);
        setState(PRE_DP+'.Vorjahres_Monat.Sommertage', VorJahr[0].Sommertage, true);
        setState(PRE_DP+'.Vorjahres_Monat.heisse_Tage', VorJahr[0].heisse_Tage, true);
        setState(PRE_DP+'.Vorjahres_Monat.Frost_Tage', VorJahr[0].Frost_Tage, true);
        setState(PRE_DP+'.Vorjahres_Monat.kalte_Tage', VorJahr[0].kalte_Tage, true);
        setState(PRE_DP+'.Vorjahres_Monat.Eistage', VorJahr[0].Eistage, true);
        setState(PRE_DP+'.Vorjahres_Monat.sehr_kalte_Tage', VorJahr[0].sehr_kalte_Tage, true);

    } else {
        //leider noch keine Daten vom Vorjahr; wir haben was zu tun...
        
                    //Werte setzen
                    let VRegenmenge_Monat=99999;
                    let Vwarme_Tage=99999;
                    let VSommertage=99999;
                    let Vheisse_Tage=99999;
                    let VFrost_Tage=99999;
                    let Vkalte_Tage=99999;
                    let VEistage=99999;
                    let Vsehr_kalte_Tage=99999;

        //Abfrage der Influx-Datenbank
        let start, end, result = [], temps = [], wind = [], regen = [];
        start = new Date(zeitstempel.getFullYear()-1,zeitstempel.getMonth(),1,0,0,0);
        start = start.getTime();
        end = new Date(zeitstempel.getFullYear()-1,zeitstempel.getMonth(),monatstage[zeitstempel.getMonth()],23,59,59);
        end = end.getTime();
            sendTo('influxdb.'+INFLUXDB_INSTANZ, 'query', 
             'select * FROM "' + WET_DP + '.Aussentemperatur" WHERE time >= ' + (start *1000000) + ' AND time <= ' + (end *1000000)
             + '; select * FROM "' + WET_DP + '.Wind_max" WHERE time >= '  + (start *1000000) + ' AND time <= ' + (end *1000000)
             + '; select * FROM "' + WET_DP + '.Regen_Tag" WHERE time >= ' + (start *1000000) + ' AND time <= ' + (end *1000000)
                , function (result) {
                //Anlegen der Arrays + befüllen mit den relevanten Daten
                if (result.error) {
                  console.error('Fehler: '+result.error);
                } else {
                 //falls keinerlei Daten vom Vorjahr vorhanden sind...
                   if (typeof result.result[0][0] === "undefined") {
                    //Arrays löschen und mit default-Wert initiieren   
                    temps.length=0;
                    temps[0]=99999; 
                    wind.length=0;
                    wind[0]=99999;
                    regen.length=0;
                    regen[0]=99999;

                   } else {               
                    for (let i = 0; i < result.result[0].length; i++) { temps[i] = result.result[0][i].value; }
                    for (let i = 0; i < result.result[1].length; i++) { wind[i] = result.result[1][i].value; }
                    for (let i = 0; i < result.result[2].length; i++) { regen[i] = result.result[2][i].value; }
                   }
                }           
      
                //Temperaturen
                let VTiefstwert = Math.min(...temps);
                let VHoechstwert = Math.max(...temps);
                const reducer = (accumulator, curr) => accumulator + curr;
                let VTemp_Durchschnitt = Number((temps.reduce(reducer)/temps.length).toFixed(2));

                //let's do Gradtage...
                let MonatsTag, MonatsTag_old, Temp, Hit = [false,false,false,false,false,false,false];
                //Reset der Gradtage je nachdem ob Daten vorhanden oder nicht
                if (typeof result.result[0][0] !== "undefined") { Vwarme_Tage=0, VSommertage=0, Vheisse_Tage=0, VFrost_Tage=0, Vkalte_Tage=0, VEistage=0, Vsehr_kalte_Tage=0; }
                
                for (let i = 0; i < result.result[0].length; i++) {
                    MonatsTag = new Date(result.result[0][i].ts).getDate();
                    if (MonatsTag != MonatsTag_old) { Hit=[false,false,false,false,false,false,false]; }
                    Temp = result.result[0][i].value;
                     if (Temp > 20 && Hit[0] == false) { Vwarme_Tage++; Hit[0] = true; }
                     if (Temp > 25 && Hit[1] == false) { VSommertage++; Hit[1] = true; }
                     if (Temp > 30 && Hit[2] == false) { Vheisse_Tage++; Hit[2] = true; }
                     if (Temp < 0 && Hit[3] == false) { VFrost_Tage++; Hit[3] = true; }
                     if (Temp < 10 && Hit[4] == false) { Vkalte_Tage++; Hit[4] = true; }
                     if (Temp < 0 && Hit[5] == false) { VEistage++; Hit[5] = true; }
                     if (Temp < -10 && Hit[6] == false) { Vsehr_kalte_Tage++; Hit[6] = true; }
                    MonatsTag_old=MonatsTag; 
                } 

                //Wind
                let VMax_Windboe = Math.max(...wind);

                //Regen
                let VMax_Regenmenge = Math.max(...regen);
                let VRegenmenge_Monat=0, Rain = [];
                for (let i = 0; i < result.result[2].length; i++) {
                    MonatsTag = new Date(result.result[2][i].ts).getDate();
                    Rain[i] = result.result[2][i].value;
                    if (MonatsTag != MonatsTag_old) {
                        VRegenmenge_Monat+= Math.max(...Rain);
                        Rain.length=0; }
                    MonatsTag_old=MonatsTag; 
                }
                if (typeof result.result[0][0] === "undefined") { VRegenmenge_Monat=99999; } //keine Daten vom Vorjahresmonat

                //DPs schreiben
                setState(PRE_DP+'.Vorjahres_Monat.Tiefstwert', VTiefstwert, true);
                setState(PRE_DP+'.Vorjahres_Monat.Hoechstwert', VHoechstwert, true);
                setState(PRE_DP+'.Vorjahres_Monat.Temperatur_Durchschnitt', VTemp_Durchschnitt, true);
                setState(PRE_DP+'.Vorjahres_Monat.Max_Windboe', VMax_Windboe, true);
                setState(PRE_DP+'.Vorjahres_Monat.Max_Regenmenge', VMax_Regenmenge, true);
                setState(PRE_DP+'.Vorjahres_Monat.Regenmenge_Monat', VRegenmenge_Monat, true);
                setState(PRE_DP+'.Vorjahres_Monat.warme_Tage', Vwarme_Tage, true);
                setState(PRE_DP+'.Vorjahres_Monat.Sommertage', VSommertage, true);
                setState(PRE_DP+'.Vorjahres_Monat.heisse_Tage', Vheisse_Tage, true);
                setState(PRE_DP+'.Vorjahres_Monat.Frost_Tage', VFrost_Tage, true);
                setState(PRE_DP+'.Vorjahres_Monat.kalte_Tage', Vkalte_Tage, true);
                setState(PRE_DP+'.Vorjahres_Monat.Eistage', VEistage, true);
                setState(PRE_DP+'.Vorjahres_Monat.sehr_kalte_Tage', Vsehr_kalte_Tage, true);

            }); //end sendTo
        
    } //end else  

} //end function


function timeConverter(UNIX_timestamp){
  let a = new Date(UNIX_timestamp);
  let months = ['Jan','Feb','Mär','Apr','Mai','Jun','Jul','Aug','Sep','Okt','Nov','Dez'];
  let year = a.getFullYear();
  let month = months[a.getMonth()];
  let date = a.getDate();
  let hour = a.getHours();
  let min = a.getMinutes();
  let sec = a.getSeconds();
  let time = pad(date) + '. ' + month + ' ' + year + ' ' + pad(hour) + ':' + pad(min) + ':' + pad(sec) ;
  return time;
}

function pad(n) {
    return n<10 ? '0'+n : n;
}

// Pause einlegen
function Sleep(milliseconds) {
 return new Promise(resolve => setTimeout(resolve, milliseconds));
}

// Statusmeldungen in DP schreiben
function Statusmeldung(Text) {
    if (typeof(Text) === "undefined") { //nur beim Start des Skriptes
        Text = 'Skript gestartet';
        setState(PRE_DP+'.Control.ScriptVersion', ScriptVersion, true);    
    }
    setState(PRE_DP+'.Control.Statusmeldung', Text, true);
}

// Test auf neue Skriptversion
function check_update() {
    const axios = require('axios');

    axios.get('https://github.com/SBorg2014/WLAN-Wetterstation/commits/master/wetterstation-statistik.js')
     .then(function (response) {
     
     // /<a aria-label="V.*[\r\n]+.*<\/a>/

     let regex = /">V.*<\/a>/ 
     , version = response.data.match(regex);

     if (version[0].match(ScriptVersion)) { 
         setState(PRE_DP+'.Control.ScriptVersion_Update','---',true); 
     } else {
         setState(PRE_DP+'.Control.ScriptVersion_Update','https://github.com/SBorg2014/WLAN-Wetterstation/blob/master/wetterstation-statistik.js',true);
         console.log('neue Script-Version verfügbar...');
     }

    })
        .catch((error) => {
        console.log(`Fehler: ${error}`);
    })
} // end function

// Jahresstatistik-Backup
function Backup_Jahresstatistik() {
    let Temperatur_Hoechstwert = getState(PRE_DP+'.Jahreswerte.Temperatur_Hoechstwert').val;
    let Temperatur_Tiefstwert = getState(PRE_DP+'.Jahreswerte.Temperatur_Tiefstwert').val;
    let Temperatur_Durchschnitt = getState(PRE_DP+'.Jahreswerte.Temperatur_Durchschnitt').val;
    let Regenmengetag = getState(PRE_DP+'.Jahreswerte.Regenmengetag').val;
    let Regenmengemonat = getState(PRE_DP+'.Jahreswerte.Regenmengemonat').val;
    let Windboe_max = getState(PRE_DP+'.Jahreswerte.Windboe_max').val;
    let Trockenperiode = getState(PRE_DP+'.Jahreswerte.Trockenperiode').val;
    let kalte_Tage_Jahr = getState(PRE_DP+'.Jahreswerte.Gradtage_kalteTage').val;
    let warme_Tage_Jahr = getState(PRE_DP+'.Jahreswerte.Gradtage_warmeTage').val;
    let Sommertage_Jahr = getState(PRE_DP+'.Jahreswerte.Gradtage_Sommertage').val;
    let heisse_Tage_Jahr = getState(PRE_DP+'.Jahreswerte.Gradtage_heisseTage').val;
    let Frosttage_Jahr = getState(PRE_DP+'.Jahreswerte.Gradtage_Frosttage').val;
    let Eistage_Jahr = getState(PRE_DP+'.Jahreswerte.Gradtage_Eistage').val;
    let sehrkalte_Tage_Jahr = getState(PRE_DP+'.Jahreswerte.Gradtage_sehrkalteTage').val;

    let json = JSON.stringify([{"Temperatur Tiefstwert": Temperatur_Tiefstwert, "Temperatur Höchstwert": Temperatur_Hoechstwert, "Temperatur Durchschnitt": Temperatur_Durchschnitt,
        "Regenmengetag": Regenmengetag, "höchste Regenmengemonat": Regenmengemonat, "Windböe": Windboe_max,
        "Trockenperiode": Trockenperiode,
        "kalte Tage": kalte_Tage_Jahr, "warme Tage": warme_Tage_Jahr, "Sommertage": Sommertage_Jahr, "heiße Tage": heisse_Tage_Jahr, "Frosttage": Frosttage_Jahr, "Eistage": Eistage_Jahr,
        "sehr kalte Tage": sehrkalte_Tage_Jahr}]);
    createState(PRE_DP+'.Jahreswerte.VorJahre.'+(new Date().getFullYear()-1), '', { name: "Jahresstatistik", type: "string", role: "json" }, () => { setState(PRE_DP+'.Jahreswerte.VorJahre.'+(new Date().getFullYear()-1), json, true) });
} // end function


function Rekordwerte() {
    //max Temp
    if (getState(PRE_DP+'.Rekordwerte.value.Temp_Max').val <= Hoechstwert) {
        setState(PRE_DP+'.Rekordwerte.value.Temp_Max', Hoechstwert, true, () => { Template_Rekordwerte('Temp_Max','Rekordwerte.Temperatur_Spitzenhoechstwert'); });
    }

    //min Temp
    if (getState(PRE_DP+'.Rekordwerte.value.Temp_Min').val >= Tiefstwert) {
        setState(PRE_DP+'.Rekordwerte.value.Temp_Min', Tiefstwert, true, () => { Template_Rekordwerte('Temp_Min','Rekordwerte.Temperatur_Spitzentiefstwert'); });
    }  

    //Regenmenge
    if (getState(PRE_DP+'.Rekordwerte.value.Regenmengetag').val <= Max_Regenmenge) {
        setState(PRE_DP+'.Rekordwerte.value.Regenmengetag', Max_Regenmenge, true, () => { Template_Rekordwerte('Regenmengetag','Rekordwerte.Regenmengetag'); });
    }
    Regenmenge_Monat = getState(PRE_DP+'.aktueller_Monat.Regenmenge_Monat').val;
    if (getState(PRE_DP+'.Rekordwerte.value.Regenmengemonat').val <= Regenmenge_Monat) {
        setState(PRE_DP+'.Rekordwerte.value.Regenmengemonat', Regenmenge_Monat, true, () => { Template_Rekordwerte('Regenmengemonat','Rekordwerte.Regenmengemonat'); });
    }

    //Windböe
    if (getState(PRE_DP+'.Rekordwerte.value.Windboe').val <= Max_Windboe) {
        setState(PRE_DP+'.Rekordwerte.value.Windboe', Max_Windboe, true, () => { Template_Rekordwerte('Windboe','Rekordwerte.Windboe'); });
    }

    //Trockenperiode
    if (getState(PRE_DP+'.Rekordwerte.value.Trockenperiode').val <= Trockenperiode_akt) {
        setState(PRE_DP+'.Rekordwerte.value.Trockenperiode', Trockenperiode_akt, true, () => { Template_Rekordwerte('Trockenperiode','Rekordwerte.Trockenperiode'); });
    }  

} // end function


async function Template_Rekordwerte(DatenPunkt, DatenPunktName) {
    await Sleep(5000);
    let wert = getState(PRE_DP+'.Rekordwerte.value.'+DatenPunkt).val;
    let unit = getObject(PRE_DP+'.Rekordwerte.value.'+DatenPunkt).common.unit;
    let REKORDWERTEAUSGABE="";
    
    //[WERT]
    if (REKORDWERTE_AUSGABEFORMAT.search("[WERT]") != -1) {
        REKORDWERTEAUSGABE = REKORDWERTE_AUSGABEFORMAT.replace("[WERT]", wert+' '+unit);
    } else { REKORDWERTEAUSGABE = REKORDWERTE_AUSGABEFORMAT; }

    //[TAG]
    REKORDWERTEAUSGABE = REKORDWERTEAUSGABE.replace("[TAG]", new Date((getState(PRE_DP+'.Rekordwerte.value.'+DatenPunkt).lc)-86400).getDate()); 

    //[MONAT]
    REKORDWERTEAUSGABE = REKORDWERTEAUSGABE.replace("[MONAT]", monatsname[new Date((getState(PRE_DP+'.Rekordwerte.value.'+DatenPunkt).lc)-86400).getMonth()]);

    //[MONAT_ZAHL]
    REKORDWERTEAUSGABE = REKORDWERTEAUSGABE.replace("[MONAT_ZAHL]", pad(new Date((getState(PRE_DP+'.Rekordwerte.value.'+DatenPunkt).lc)-86400).getMonth()+1));

    //[MONAT_KURZ]
    REKORDWERTEAUSGABE = REKORDWERTEAUSGABE.replace("[MONAT_KURZ]", monatsname_kurz[new Date((getState(PRE_DP+'.Rekordwerte.value.'+DatenPunkt).lc)-86400).getMonth()]);

    //[JAHR]
    REKORDWERTEAUSGABE = REKORDWERTEAUSGABE.replace("[JAHR]", new Date((getState(PRE_DP+'.Rekordwerte.value.'+DatenPunkt).lc)-86400).getFullYear());

    //Spezialpatch für 1 Tag
    if ((REKORDWERTEAUSGABE.search("Tage") != -1) && (wert == 1)) {
        REKORDWERTEAUSGABE = REKORDWERTEAUSGABE.replace("Tage", "Tag");
    }

    setState(PRE_DP+'.'+DatenPunktName, REKORDWERTEAUSGABE, true);                                                 
} // end function


//Datenpunkte anlegen
async function createDP(DP_Check) {
    console.log(PRE_DP + '.' + DP_Check + ' existiert nicht... Lege Datenstruktur an...');
    createState(PRE_DP,                                           '',   { name: 'Wetterstatistik',                              type: "folder" });
    createState(PRE_DP+'.aktueller_Monat',                        '',   { name: 'Statistik für den aktuellen Monat',            type: "folder" });
    createState(PRE_DP+'.Vorjahres_Monat',                        '',   { name: 'Statistik für den Monat des Vorjahres',        type: "folder" });
    createState(PRE_DP+'.Data',                                   '',   { name: 'bisherige Statistiken',                        type: "folder" });
    createState(PRE_DP+'.VorTag',                                 '',   { name: 'Werte von Gestern',                            type: "folder" });
    createState(PRE_DP+'.Control',                                '',   { name: 'Einstellungen, Meldungen',                     type: "folder" });
    createState(PRE_DP+'.Jahreswerte',                            '',   { name: 'Jahresstatistik',                              type: "folder" });
    createState(PRE_DP+'.Rekordwerte',                            '',   { name: 'Rekordwerte seit Aufzeichnungsbeginn',         type: "folder" });
    
    createState(PRE_DP+'.aktueller_Monat.Tiefstwert',             100,  { name: "niedrigste Temperatur",                        type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.aktueller_Monat.Hoechstwert',            -100, { name: "höchste Temperatur",                           type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.aktueller_Monat.Temperatur_Durchschnitt',0,    { name: "Durchschnittstemperatur",                      type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.aktueller_Monat.Max_Windboe',            0,    { name: "stärkste Windböe",                             type: "number", role: "state", unit: "km/h" });
    createState(PRE_DP+'.aktueller_Monat.Max_Regenmenge',         0,    { name: "maximale Regenmenge pro Tag",                  type: "number", role: "state", unit: "l/m²" });
    createState(PRE_DP+'.aktueller_Monat.Regenmenge_Monat',       0,    { name: "Regenmenge im Monat",                          type: "number", role: "state", unit: "l/m²" });
    createState(PRE_DP+'.aktueller_Monat.warme_Tage',             0,    { name: "Tage mit einer Temperatur über 20°",           type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.aktueller_Monat.Sommertage',             0,    { name: "Tage mit einer Temperatur über 25°",           type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.aktueller_Monat.heisse_Tage',            0,    { name: "Tage mit einer Temperatur über 30°",           type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.aktueller_Monat.Frost_Tage',             0,    { name: "Tage mit einer Mindesttemperatur unter 0°",    type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.aktueller_Monat.kalte_Tage',             0,    { name: "Tage mit einer Höchsttemperatur unter 10°",    type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.aktueller_Monat.Eistage',                0,    { name: "Tage mit einer Höchsttemperatur unter 0°",     type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.aktueller_Monat.sehr_kalte_Tage',        0,    { name: "Tage mit einer Mindesttemperatur unter -10°",  type: "number", role: "state", unit: "Tage" });

    createState(PRE_DP+'.Vorjahres_Monat.Tiefstwert',             99999, { name: "niedrigste Temperatur",                       type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.Vorjahres_Monat.Hoechstwert',            99999, { name: "höchste Temperatur",                          type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.Vorjahres_Monat.Temperatur_Durchschnitt',99999, { name: "Durchschnittstemperatur",                     type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.Vorjahres_Monat.Max_Windboe',            99999, { name: "stärkste Windböe",                            type: "number", role: "state", unit: "km/h" });
    createState(PRE_DP+'.Vorjahres_Monat.Max_Regenmenge',         99999, { name: "maximale Regenmenge pro Tag",                 type: "number", role: "state", unit: "l/m²" });
    createState(PRE_DP+'.Vorjahres_Monat.Regenmenge_Monat',       99999, { name: "Regenmenge im Monat",                         type: "number", role: "state", unit: "l/m²" });
    createState(PRE_DP+'.Vorjahres_Monat.warme_Tage',             99999, { name: "Tage mit einer Temperatur über 20°",          type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.Vorjahres_Monat.Sommertage',             99999, { name: "Tage mit einer Temperatur über 25°",          type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.Vorjahres_Monat.heisse_Tage',            99999, { name: "Tage mit einer Temperatur über 30°",          type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.Vorjahres_Monat.Frost_Tage',             99999, { name: "Tage mit einer Mindesttemperatur unter 0°",   type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.Vorjahres_Monat.kalte_Tage',             99999, { name: "Tage mit einer Höchsttemperatur unter 10°",   type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.Vorjahres_Monat.Eistage',                99999, { name: "Tage mit einer Höchsttemperatur unter 0°",    type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.Vorjahres_Monat.sehr_kalte_Tage',        99999, { name: "Tage mit einer Mindesttemperatur unter -10°", type: "number", role: "state", unit: "Tage" });

    createState(PRE_DP+'.VorTag.Temperatur_Tiefstwert',           99999, { name: "niedrigste Tagestemperatur",                  type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.VorTag.Temperatur_Hoechstwert',          99999, { name: "höchste Tagestemperatur",                     type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.VorTag.Temperatur_Durchschnitt',         99999, { name: "Durchschnittstemperatur",                     type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.VorTag.Regenmenge',                      0,     { name: "Regenmenge vom Vortag",                       type: "number", role: "state", unit: "l/m²" });
    createState(PRE_DP+'.VorTag.Windboe_max',                     0,     { name: "stärkste Windböe vom Vortag",                 type: "number", role: "state", unit: "km/h" });

    createState(PRE_DP+'.Jahreswerte.Temperatur_Hoechstwert',     -100,  { name: "höchste Tagestemperatur des Jahres",          type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.Jahreswerte.Temperatur_Tiefstwert',      100,   { name: "niedrigste Tagestemperatur des Jahres",       type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.Jahreswerte.Temperatur_Durchschnitt',    0,     { name: "Durchschnittstemperatur des Jahres",          type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.Jahreswerte.Trockenperiode',             0,     { name: "längste Periode ohne Regen",                  type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.Jahreswerte.Regenmengetag',              0,     { name: "höchste Regenmenge an einem Tag",             type: "number", role: "state", unit: "l/m²" });
    createState(PRE_DP+'.Jahreswerte.Regenmengemonat',            0,     { name: "höchste Regenmenge innerhalb eines Monats",   type: "number", role: "state", unit: "l/m²" });
    createState(PRE_DP+'.Jahreswerte.Windboe_max',                0,     { name: "stärkste Windböe des Jahres",                 type: "number", role: "state", unit: "km/h" });
    createState(PRE_DP+'.Jahreswerte.Gradtage_kalteTage',         0,     { name: "Tage mit einer Höchsttemperatur unter 10°",   type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.Jahreswerte.Gradtage_warmeTage',         0,     { name: "Tage mit einer Höchsttemperatur über 20°",    type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.Jahreswerte.Gradtage_Sommertage',        0,     { name: "Tage mit einer Höchsttemperatur über 25°",    type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.Jahreswerte.Gradtage_heisseTage',        0,     { name: "Tage mit einer Höchsttemperatur über 30°",    type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.Jahreswerte.Gradtage_Frosttage',         0,     { name: "Tage mit einer Tiefsttemperatur unter 0°",    type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.Jahreswerte.Gradtage_Eistage',           0,     { name: "Tage mit einer Höchsttemperatur unter 0°",    type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.Jahreswerte.Gradtage_sehrkalteTage',     0,     { name: "Tage mit einer Tiefsttemperatur unter -10°",  type: "number", role: "state", unit: "Tage" });

    createState(PRE_DP+'.Rekordwerte.value.Temp_Max',             -100,  { name: "Max. Tagestemperatur",                        type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.Rekordwerte.value.Temp_Min',             100,   { name: "Min. Tagestemperatur",                        type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.Rekordwerte.value.Trockenperiode',       0,     { name: "längste Trockenperiode",                      type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.Rekordwerte.value.Temp_Durchschnitt_Min',99.99, { name: "niedrigster Jahrestemperaturdurchschnitt",    type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.Rekordwerte.value.Temp_Durchschnitt_Max',-99.99,{ name: "höchster Jahrestemperaturdurchschnitt",       type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.Rekordwerte.value.Regenmengetag',        0,     { name: "höchste je gemessene Regenmenge an einem Tag",type: "number", role: "state", unit: "l/m²" });
    createState(PRE_DP+'.Rekordwerte.value.Regenmengemonat',      0,     { name: "höchste je gemessene Regenmenge eines Monats",type: "number", role: "state", unit: "l/m²" });
    createState(PRE_DP+'.Rekordwerte.value.Windboe',              0,     { name: "stärkste je gemessene Windböe"               ,type: "number", role: "state", unit: "km/h" });
    createState(PRE_DP+'.Rekordwerte.Temperatur_Spitzenhoechstwert', '', { name: "höchste je gemessene Tagestemperatur",        type: "string", role: "state" });
    createState(PRE_DP+'.Rekordwerte.Temperatur_Spitzentiefstwert',  '', { name: "niedrigste je gemessene Tagestemperatur",     type: "string", role: "state" });
    createState(PRE_DP+'.Rekordwerte.Temperatur_Jahresdurchschnitt_Max', '', { name: "höchster Jahrestemperaturdurchschnitt",   type: "string", role: "state" });
    createState(PRE_DP+'.Rekordwerte.Temperatur_Jahresdurchschnitt_Min', '', { name: "niedrigster Jahrestemperaturdurchschnitt",type: "string", role: "state" });
    createState(PRE_DP+'.Rekordwerte.Regenmengetag',             '',     { name: "höchste je gemessene Regenmenge an einem Tag",type: "string", role: "state" });
    createState(PRE_DP+'.Rekordwerte.Regenmengemonat',           '',     { name: "höchste je gemessene Regenmenge eines Monats",type: "string", role: "state" });
    createState(PRE_DP+'.Rekordwerte.Windboe',                   '',     { name: "stärkste je gemessene Windböe"               ,type: "string", role: "state" });
    createState(PRE_DP+'.Rekordwerte.Trockenperiode',            '',     { name: "längste je andauernde Trockenperiode",        type: "string", role: "state" });

    createState(PRE_DP+'.Control.Statusmeldung',                  '',    { name: "Statusmeldungen",                             type: "string", role: "state"});
    createState(PRE_DP+'.Control.Reset_Jahresstatistik',          false, { name: "Jahresstatistik zurücksetzen",                type: "boolean",role: "state"});
    createState(PRE_DP+'.Control.AutoReset_Jahresstatistik',      0,     { name: "Jahresstatistik zurücksetzen [0=Aus, 1=Ein, 2=Ein+Backup]",type: "number",role: "state"});
    createState(PRE_DP+'.Control.AutoDelete_Data',                0,     { name: "Data bereinigen? [0 = nie, 1...n = nach x Monaten]",  type: "number", role: "state"});
    createState(PRE_DP+'.Control.ScriptVersion',                  '',    { name: "aktuelle Versionsnummer des Statistik-Skriptes",type: "string",role: "state"});
    createState(PRE_DP+'.Control.ScriptVersion_Update',           '',    { name: "neue Version des Statistik-Skriptes vorhanden",type: "string",role: "state"});
    createState(PRE_DP+'.Control.ScriptVersion_UpdateCheck',      '',    { name: "Skript-Updatecheck ein-/ausschalten",         type: "boolean",role: "state"});
    await Sleep(5000);
}

Ich habe gerade mal bei mir geschaut, da sieht es wie folgt aus:

Bis auf "Rekordwerte -> Regenmengenmonat" sehen die Werte bei mir ganz gut aus, also alle gefüllt. Ob die jetzt bis ins Detail stimmen kann ich nicht direkt nachvollziehen.

Denke du musst da noch ein paar Tage warten. (Vielleicht sogar einen Monatswechsel, könnte ich mir vorstellen)
Wenn ich Zeit habe schaue ich mir oben den Punkt mal an, was da berechnet wird und warum dieses "null" (also ja eigentlich kein Wert) zurückgeliefert wird.

[MartyBr]

@jostereo Okay. Dann warte ich mal ein paar Tage.
Danke dir für deine schnelle Antwort.

[SBorg]

@jostereo sagte in [Linux Shell-Skript] WLAN-Wetterstation:

Denke du musst da noch ein paar Tage warten. (Vielleicht sogar einen Monatswechsel, könnte ich mir vorstellen)

Danke für das patchen :)
Wenn es dann geht, füge ich es als Option mit in das Skript ein. Vorher brauche ich aber Zeit und muss auch noch Influx nach V2 migrieren...

Ansonsten gilt: alles was bspw. einen Monat betrifft, kann auch erst zum nächsten 1. (wenn der Monat halt rum ist) bereitgestellt werden. Alles andere wäre ja sonst keine Statistik, sondern eine Hochrechnung.
Ich kann schlecht in Frankfurt sagen wenn ich von Hamburg nach München fahre, ich habe für die Strecke x Liter gebraucht. Ich kann zwar sagen bisher habe ich x Liter gebraucht und werde bis München geschätzt weitere y Liter brauchen. Erst in München kann ich wirklich sagen "Verbrauch lag bei xy Litern".

Die aktuelle Regenmenge bekomme ich ja auch zB. direkt aus dem Skript geliefert.

...und bei ~#393ff ist noch eine Influx-Abfrage ;)

---

btw: nicht nur das sich mein Umbau eh schon in die Länge zieht, jetzt verbrate ich bald noch mehr Zeit Material zu besorgen was noch bezahlbar ist und keine Lieferzeit bis zum Jahreswechsel hat :(

[MartyBr]

@sborg Ich habe auch die Zeile #393ff auf die neue Abfrage umgestellt. Das Script läuft ohne Fehler durch und liefert ein "erfolgreich" ab.
Leider werden zumindest die Daten vom Vortag nicht geschrieben:

Hier das vollständige Script:

/* Wetterstation-Statistiken 

   holt die Messdaten aus einer InfluxDB und erstellt eine Monats-, Vorjahresmonat- und
   Rekordwerte-Statistik
   Wichtig: funktioniert nur mit der Default-Datenstruktur des WLAN-Wetterstation-Skriptes!
            Auch keine Aliase unter Influx nutzen!

   (c)2020-2021 by SBorg
   V1.0.1 - 18.12.2021  ~Bugfixing "error: TypeError: Cannot read property '0' of null"
                        ~Wechsel zu axios
   V1.0.0 - 02.10.2021  ~Bugfixing Werte VorJahresMonat
                        +Kompatibilität mit JSC 3.3.x hergestellt (Änderung JSON -> Array)
                        ~Rekordwerte werden nun korrekt am Tag des Ereignisses gespeichert
   V0.2.2 - 01.02.2021  ~Bugfixing Regenmenge Jahr + Monat
   V0.2.1 - 21.01.2021  ~Bugfixing Rekordwerte Spitzenhöchst-/-tiefstwert
   V0.2.0 - 15.01.2021  ~Bugfixing Benennung DPs / Korrektur Regenmenge
   V0.1.9 - 09.01.2021  +Regenmenge eines kpl. Monats im Jahr und Rekord
   V0.1.8 - 08.01.2021  +max. Windböe für Gestern und Jahres-/Rekordwerte
   V0.1.7 - 03.01.2021  ~Fix für fehlerhafte/fehlende Speicherung Jahreswerte + Trockenperiode
   V0.1.6 - 30.12.2020  +Summe "Sommertage", "heiße Tage", "Frosttage", "Eistage" und "sehr kalte Tage" für das gesamte Jahr
   V0.1.5 - 29.12.2020  +Summe "kalte Tage" und "warme Tage" für das gesamte Jahr
   V0.1.4 - 26.12.2020  +max. Regenmenge pro Tag für Jahres-/Rekordwerte
   V0.1.3 - 11.11.2020  +Rekordwerte
   V0.1.2 - 14.10.2020  ~Fix "NaN" bei Regenmenge Monat
   V0.1.1 - 12.10.2020  +AutoReset Jahresstatistik
   V0.1.0 - 08.10.2020  +DP für Statusmeldungen / Reset Jahresstatistik / AutoDelete "Data"
                        +ScriptVersion / Update vorhanden / UpdateCheck abschaltbar
                        +Jahresstatistik Min-/Max-/Durchschnittstemperatur/Trockenperiode
   V0.0.7 - 19.09.2020  +Min.-/Max.-/Durchschnittstemperatur vom Vortag
   V0.0.6 - 18.09.2020  +Regenmenge Monat
   V0.0.5 - 17.09.2020  +Gradtage Vorjahr
   V0.0.4 - 16.09.2020  +Eistage (Max. unter 0°C) / sehr kalte Tage (Min. unter -10°C)
                        ~Frosttage (Korrektur: Tiefstwert unter 0°C)
   V0.0.3 - 15.09.2020  +Frosttage (Min. unter 0°C) / kalte Tage (Max. unter 10°C)
   V0.0.2 - 12.09.2020  +warme Tage über 20°C / Sommertage über 25°C / heiße Tage über 30°C
   V0.0.1 - 11.09.2020   erste Beta + Temp-Min/Temp-Max/Temp-Durchschnitt/max. Windböe/max. Regenmenge pro Tag

      ToDo: ---
      known issues: keine

*/



// *** User-Einstellungen **********************************************************************************************************************************
    const WET_DP='0_userdata.0.Wetterstation';        // wo liegen die Datenpunkte mit den Daten der Wetterstation  [default: javascript.0.Wetterstation]                          
    const INFLUXDB_INSTANZ='0';                       // unter welcher Instanz läuft die InfluxDB [default: 0]
    const PRE_DP='0_userdata.0.Statistik.Wetter';     // wo sollen die Statistikwerte abgelegt werden. Nur unter "0_userdata" oder "javascript" möglich!
    let REKORDWERTE_AUSGABEFORMAT="[WERT] im [MONAT] [JAHR]";   /* Wie soll die Ausgabe der Rekordwerte formatiert werden (Template-Vorlage)?
                                                                    [WERT]      = Messwert (zB. '22.42' bei Temperatur, '12' bei Tagen)
                                                                    [TAG]       = Tag (0-31)
                                                                    [MONAT]     = Monatsname (Januar, Februar,..., Dezember)
                                                                    [MONAT_ZAHL]= Monat als Zahl (01-12)
                                                                    [MONAT_KURZ]= Monatsname kurz (Jan, Feb,..., Dez)
                                                                    [JAHR]      = Jahreszahl vierstellig (2020)
                                                                 Die 'Units' wie bspw. "°C" oder "Tage" werden direkt aus dem Datenpunkt ergänzt. 
                                                                 [default: [WERT] im [MONAT] [JAHR] ] erzeugt als Beispiel im DP die 
                                                                 Ausgabe: "22.42 °C im Juni 2020"
                                                                */
    const ZEITPLAN = "3 1 * * *";                     // wann soll die Statistik erstellt werden (Minuten Stunde * * *) [default 1:03 Uhr] 
// *** ENDE User-Einstellungen *****************************************************************************************************************************




//ab hier gibt es nix mehr zu ändern :)
//first start?
const DP_Check='Rekordwerte.Regenmengemonat';
if (!existsState(PRE_DP+'.'+DP_Check)) { createDP(DP_Check); }

//Start des Scripts
    const ScriptVersion = "V1.0.1";
    let Tiefstwert, Hoechstwert, Temp_Durchschnitt, Max_Windboe, Max_Regenmenge, Regenmenge_Monat, warme_Tage, Sommertage;
    let heisse_Tage, Frost_Tage, kalte_Tage, Eistage, sehr_kalte_Tage, Trockenperiode_akt;
    let kalte_Tage_Jahr, warme_Tage_Jahr, Sommertage_Jahr, heisse_Tage_Jahr, Frosttage_Jahr, Eistage_Jahr, sehrkalte_Tage_Jahr;
    let monatstage = [31,28,31,30,31,30,31,31,30,31,30,31];
    let monatsname = ['Januar','Februar','März','April','Mai','Juni','Juli','August','September','Oktober','November','Dezember'];
    let monatsname_kurz = ['Jan','Feb','Mär','Apr','Mai','Jun','Jul','Aug','Sep','Okt','Nov','Dez'];
    console.log('Wetterstation-Statistiken gestartet...');
    setTimeout(Statusmeldung, 500);

//scheduler
    schedule(ZEITPLAN, main);


// ### Funktionen ###############################################################################################
async function main() {
    let result = [], temps = [], wind = [], regen = [], start, end, zeitstempel = new Date();
    start = new Date(zeitstempel.getFullYear(),zeitstempel.getMonth(),zeitstempel.getDate()-1,0,0,0);
    start = start.getTime();
    end = new Date(zeitstempel.getFullYear(),zeitstempel.getMonth(),zeitstempel.getDate()-1,23,59,59);
    end = end.getTime();

    //Jobs Monatserster
 if (zeitstempel.getDate() == 1) { 
     if (zeitstempel.getMonth() == 0) { //heute ist der 01.01. 

        //Rekordwerte (Temperatur-Durchschnitt) setzen
            //max Jahrestemperaturdurchschnitt
            let JahresTemperatur_Durchschnitt = getState(PRE_DP+'.Jahreswerte.Temperatur_Durchschnitt').val;
            if (getState(PRE_DP+'.Rekordwerte.value.Temp_Durchschnitt_Max').val < JahresTemperatur_Durchschnitt) {
                setState(PRE_DP+'.Rekordwerte.value.Temp_Durchschnitt_Max', JahresTemperatur_Durchschnitt, true);
                setState(PRE_DP+'.Rekordwerte.Temperatur_Jahresdurchschnitt_Max', JahresTemperatur_Durchschnitt+' für '+ (zeitstempel.getFullYear()-1), true);
                //, () => { Template_Rekordwerte('Temp_Durchschnitt_Max','Rekordwerte.Temperatur_Jahresdurchschnitt_Max'); });
            }  
            //min Jahrestemperaturdurchschnitt
            if (getState(PRE_DP+'.Rekordwerte.value.Temp_Durchschnitt_Min').val > JahresTemperatur_Durchschnitt) {
                setState(PRE_DP+'.Rekordwerte.value.Temp_Durchschnitt_Min', JahresTemperatur_Durchschnitt, true);
                setState(PRE_DP+'.Rekordwerte.Temperatur_Jahresdurchschnitt_Min', JahresTemperatur_Durchschnitt+' für '+ (zeitstempel.getFullYear()-1), true);
                //, () => { Template_Rekordwerte('Temp_Durchschnitt_Min','Rekordwerte.Temperatur_Jahresdurchschnitt_Min'); });
            }

        //Rekordwerte (Temperatur-Durchschnitt) einmalig resetten [InstallationsJahr +1]
        let Inst_Jahr = (new Date(getState(PRE_DP).ts)).getFullYear();
        if (zeitstempel.getFullYear() == Inst_Jahr+1) {
            setState(PRE_DP+'.Rekordwerte.value.Temp_Durchschnitt_Max', -99.99, true);
            setState(PRE_DP+'.Rekordwerte.value.Temp_Durchschnitt_Min',  99.99, true);
            setState(PRE_DP+'.Rekordwerte.Temperatur_Jahresdurchschnitt_Max' ,'' ,true);
            setState(PRE_DP+'.Rekordwerte.Temperatur_Jahresdurchschnitt_Min' ,'' ,true);
        }

        let mode=getState(PRE_DP+'.Control.AutoReset_Jahresstatistik').val;
        switch (mode) { //0=Aus, 1=Ein, 2=Ein+Backup
            case 0:
               break;

            case 1:
               Reset_Jahresstatistik();
               break;

            case 2:
               Backup_Jahresstatistik();
               Reset_Jahresstatistik();
               break;

            default:
               break;
        } // end switch

     } // end if 01.01.

   await speichern_Monat();  //vorherige Monatsstatistik speichern
   await VorJahr();          //Vorjahresmonatsstatistik ausführen
   
   /*DPs unabhängig ihres Wertes initial schreiben; wir nehmen die aktuelle Außentemperatur, da sie zum Start des Messzyklus
     Min, Max und Durchschnitt darstellt; Rest einfach nullen */
    let initialTemp=getState(WET_DP+'.Aussentemperatur').val;
    setState(PRE_DP+'.aktueller_Monat.Tiefstwert', initialTemp, true);
    setState(PRE_DP+'.aktueller_Monat.Hoechstwert', initialTemp, true);
    setState(PRE_DP+'.aktueller_Monat.Temperatur_Durchschnitt', initialTemp, true);
    setState(PRE_DP+'.aktueller_Monat.Max_Windboe', 0, true);
    setState(PRE_DP+'.aktueller_Monat.Max_Regenmenge', 0, true);
    setState(PRE_DP+'.aktueller_Monat.Regenmenge_Monat', 0, true);
    setState(PRE_DP+'.aktueller_Monat.warme_Tage', 0, true);
    setState(PRE_DP+'.aktueller_Monat.Sommertage', 0, true);
    setState(PRE_DP+'.aktueller_Monat.heisse_Tage', 0, true);
    setState(PRE_DP+'.aktueller_Monat.Frost_Tage', 0, true);
    setState(PRE_DP+'.aktueller_Monat.kalte_Tage', 0, true);
    setState(PRE_DP+'.aktueller_Monat.Eistage', 0, true);
    setState(PRE_DP+'.aktueller_Monat.sehr_kalte_Tage', 0, true);

    sleep(3000);
    
   if (getState(PRE_DP+'.Control.AutoDelete_Data').val >0) { AutoDelete_Data(); }
   //nun beenden
   return;

 }// End Jobs Monatserster

            //InfluxDB abfragen (Regen +1min Startverzögerung wg. ev. Ungenauigkeit der Systemzeit des Wetterstation-Displays)
            sendTo('influxdb.'+INFLUXDB_INSTANZ, 'query', 
            'from(bucket: "iobroker") |> range(start: ' + (start / 1000) + ', stop: ' + (end / 1000) + ') |> filter(fn: (r) => r["_measurement"] == "' + WET_DP + '.Aussentemperatur") |> filter(fn: (r) => r["_field"] == "value");' +
        'from(bucket: "iobroker") |> range(start: ' + (start / 1000) + ', stop: ' + (end / 1000) + ') |> filter(fn: (r) => r["_measurement"] == "' + WET_DP + '.Wind_max") |> filter(fn: (r) => r["_field"] == "value");' +
        'from(bucket: "iobroker") |> range(start: ' + ((start + 72000) / 1000) + ', stop: ' + (end / 1000) + ') |> filter(fn: (r) => r["_measurement"] == "' + WET_DP + '.Regen_Tag") |> filter(fn: (r) => r["_field"] == "value")'

         , function (result) {
             //Anlegen der Arrays + befüllen mit den relevanten Daten
            if (result.error) {
               console.error('Fehler beim Lesen der InfluxDB: '+result.error);
               Statusmeldung('Fehler beim Lesen der InfluxDB: '+result.error);
            } else {
                //console.log('Rows: ' + JSON.stringify(result.result[2]));
                for (let i = 0; i < result.result[0].length; i++) { temps[i] = result.result[0][i].value; }
                for (let i = 0; i < result.result[1].length; i++) { wind[i] = result.result[1][i].value; }
                for (let i = 0; i < result.result[2].length; i++) { regen[i] = result.result[2][i].value; }
            }           
                    
  //Temperaturen
    Tiefstwert = Math.min(...temps);
    Hoechstwert = Math.max(...temps);
    //Math.sum = (...temps) => Array.prototype.reduce.call(temps,(a,b) => a+b);
    const reducer = (accumulator, curr) => accumulator + curr;
    //Temp_Durchschnitt = Number((Math.sum(...temps)/temps.length).toFixed(2));
    let Temp_Durchschnitt = Number((temps.reduce(reducer)/temps.length).toFixed(2));
    let MonatsTemp_Durchschnitt = Math.round(((((getState(PRE_DP+'.aktueller_Monat.Temperatur_Durchschnitt').val)*(zeitstempel.getDate()-1))+Temp_Durchschnitt)/zeitstempel.getDate())*100)/100;
    if (Hoechstwert > 20) { warme_Tage = 1; } else { warme_Tage = 0; }
    if (Hoechstwert > 25) { Sommertage = 1; } else { Sommertage = 0; } 
    if (Hoechstwert > 30) { heisse_Tage = 1; } else { heisse_Tage = 0; } 
    if (Tiefstwert < 0) { Frost_Tage = 1; } else { Frost_Tage = 0; } 
    if (Hoechstwert < 10) { kalte_Tage = 1; } else { kalte_Tage = 0; }
    if (Hoechstwert < 0) { Eistage = 1; } else { Eistage = 0; }
    if (Tiefstwert < -10) { sehr_kalte_Tage = 1; } else { sehr_kalte_Tage = 0; }

  //Wind
    Max_Windboe = Math.max(...wind);      

  //Regen
    Max_Regenmenge = Math.max(...regen);
    

/* Debug-Consolenausgaben
    console.log('Daten ab ' + timeConverter(start));
    console.log('Daten bis ' + timeConverter(end));
    console.log('Erster Messwert: ' + new Date(result.result[0][0].ts).toISOString() + ' ***' + result.result[0][0].value);
    console.log('Letzter Messwert: ' + new Date(result.result[0][temps.length-1].ts).toISOString() + ' ***' + result.result[0][temps.length-1].value);
    console.log('Anzahl Datensätze: T_' + temps.length + '|W_' + wind.length + '|R_' + regen.length); */

// Tag des Jahres berechnen
   let Jahr = zeitstempel.getFullYear();
   let heutestart = Number(new Date(zeitstempel.setHours(0,0,0,0)));
   let neujahr = Number(new Date(Jahr,0,1));
   let difftage = (heutestart - neujahr) / (24*60*60*1000) + 1;
   let tag_des_jahres = Math.ceil(difftage);
   

   // Datenpunkte schreiben
   if (getState(PRE_DP+'.aktueller_Monat.Tiefstwert').val > Tiefstwert) {setState(PRE_DP+'.aktueller_Monat.Tiefstwert', Tiefstwert, true);}    
   if (getState(PRE_DP+'.aktueller_Monat.Hoechstwert').val < Hoechstwert) {setState(PRE_DP+'.aktueller_Monat.Hoechstwert', Hoechstwert, true);}    
   if (getState(PRE_DP+'.aktueller_Monat.Temperatur_Durchschnitt').val != MonatsTemp_Durchschnitt) {setState(PRE_DP+'.aktueller_Monat.Temperatur_Durchschnitt', MonatsTemp_Durchschnitt, true);}
   if (getState(PRE_DP+'.aktueller_Monat.Max_Windboe').val < Max_Windboe) {setState(PRE_DP+'.aktueller_Monat.Max_Windboe', Max_Windboe, true);}
   if (getState(PRE_DP+'.aktueller_Monat.Max_Regenmenge').val < Max_Regenmenge) {setState(PRE_DP+'.aktueller_Monat.Max_Regenmenge', Max_Regenmenge, true);}
   if (Max_Regenmenge > 0) {Regenmenge_Monat = getState(PRE_DP+'.aktueller_Monat.Regenmenge_Monat').val + Max_Regenmenge; setState(PRE_DP+'.aktueller_Monat.Regenmenge_Monat', Number((Regenmenge_Monat).toFixed(2)), true);}
   if (warme_Tage) {warme_Tage = getState(PRE_DP+'.aktueller_Monat.warme_Tage').val +1; setState(PRE_DP+'.aktueller_Monat.warme_Tage', warme_Tage, true);
                    warme_Tage_Jahr = getState(PRE_DP+'.Jahreswerte.Gradtage_warmeTage').val +1; setState(PRE_DP+'.Jahreswerte.Gradtage_warmeTage', warme_Tage_Jahr, true);}
   if (Sommertage) {Sommertage = getState(PRE_DP+'.aktueller_Monat.Sommertage').val +1; setState(PRE_DP+'.aktueller_Monat.Sommertage', Sommertage, true);
                    Sommertage_Jahr = getState(PRE_DP+'.Jahreswerte.Gradtage_Sommertage').val +1; setState(PRE_DP+'.Jahreswerte.Gradtage_Sommertage', Sommertage_Jahr, true);}
   if (heisse_Tage) {heisse_Tage = getState(PRE_DP+'.aktueller_Monat.heisse_Tage').val +1; setState(PRE_DP+'.aktueller_Monat.heisse_Tage', heisse_Tage, true);
                    heisse_Tage_Jahr = getState(PRE_DP+'.Jahreswerte.Gradtage_heisseTage').val +1; setState(PRE_DP+'.Jahreswerte.Gradtage_heisseTage', heisse_Tage_Jahr, true);}
   if (Frost_Tage) {Frost_Tage = getState(PRE_DP+'.aktueller_Monat.Frost_Tage').val +1; setState(PRE_DP+'.aktueller_Monat.Frost_Tage', Frost_Tage, true);
                    Frosttage_Jahr = getState(PRE_DP+'.Jahreswerte.Gradtage_Frosttage').val +1; setState(PRE_DP+'.Jahreswerte.Gradtage_Frosttage', Frosttage_Jahr, true);}
   if (kalte_Tage) {kalte_Tage = getState(PRE_DP+'.aktueller_Monat.kalte_Tage').val +1; setState(PRE_DP+'.aktueller_Monat.kalte_Tage', kalte_Tage, true);
                    kalte_Tage_Jahr = getState(PRE_DP+'.Jahreswerte.Gradtage_kalteTage').val +1; setState(PRE_DP+'.Jahreswerte.Gradtage_kalteTage', kalte_Tage_Jahr, true);}
   if (Eistage) {Eistage = getState(PRE_DP+'.aktueller_Monat.Eistage').val +1; setState(PRE_DP+'.aktueller_Monat.Eistage', Eistage, true);
                Eistage_Jahr = getState(PRE_DP+'.Jahreswerte.Gradtage_Eistage').val +1; setState(PRE_DP+'.Jahreswerte.Gradtage_Eistage', Eistage_Jahr, true);}
   if (sehr_kalte_Tage) {sehr_kalte_Tage = getState(PRE_DP+'.aktueller_Monat.sehr_kalte_Tage').val +1; setState(PRE_DP+'.aktueller_Monat.sehr_kalte_Tage', sehr_kalte_Tage, true);
                        sehrkalte_Tage_Jahr = getState(PRE_DP+'.Jahreswerte.Gradtage_sehrkalteTage').val +1; setState(PRE_DP+'.Jahreswerte.Gradtage_sehrkalteTage', sehrkalte_Tage_Jahr, true);}
   
    //VorTag
    setState(PRE_DP+'.VorTag.Temperatur_Tiefstwert', Tiefstwert, true);
    setState(PRE_DP+'.VorTag.Temperatur_Hoechstwert', Hoechstwert, true);
    setState(PRE_DP+'.VorTag.Temperatur_Durchschnitt', Temp_Durchschnitt, true);
    setState(PRE_DP+'.VorTag.Regenmenge', Max_Regenmenge, true);
    setState(PRE_DP+'.VorTag.Windboe_max', Max_Windboe, true);

    //Jahresstatistik
       //Temperatur
       if (getState(PRE_DP+'.Jahreswerte.Temperatur_Hoechstwert').val < Hoechstwert) {setState(PRE_DP+'.Jahreswerte.Temperatur_Hoechstwert', Hoechstwert, true);}
       if (getState(PRE_DP+'.Jahreswerte.Temperatur_Tiefstwert').val > Tiefstwert) {setState(PRE_DP+'.Jahreswerte.Temperatur_Tiefstwert', Tiefstwert, true);}
       //Temperaturdurchschnitt
       let JahresTemp_Durchschnitt=Math.round(((getState(PRE_DP+'.Jahreswerte.Temperatur_Durchschnitt').val * (tag_des_jahres-1) + Temp_Durchschnitt)/tag_des_jahres)*100)/100;
       setState(PRE_DP+'.Jahreswerte.Temperatur_Durchschnitt', JahresTemp_Durchschnitt, true);
       //Regenmenge
       if (getState(PRE_DP+'.Jahreswerte.Regenmengetag').val < Max_Regenmenge) {setState(PRE_DP+'.Jahreswerte.Regenmengetag', Max_Regenmenge, true);}
       //Windböe
       if (getState(PRE_DP+'.Jahreswerte.Windboe_max').val <= Max_Windboe) {setState(PRE_DP+'.Jahreswerte.Windboe_max', Max_Windboe, true);} 
    if (getState(WET_DP+'.Info.Letzter_Regen').val.match(/Tag/g)) { //nur setzen bei [Tag]en, nicht bei Stunden
        Trockenperiode_akt=parseInt(getState(WET_DP+'.Info.Letzter_Regen').val.replace(/[^0-9\.]/g, ''), 10);
        let Trockenperiode_alt=getState(PRE_DP+'.Jahreswerte.Trockenperiode').val;
        if (Trockenperiode_akt >= Trockenperiode_alt) { setState(PRE_DP+'.Jahreswerte.Trockenperiode', Trockenperiode_akt, true); }
    }

    //Rekordwerte
    Rekordwerte();

 });
 if (getState(PRE_DP+'.Control.Reset_Jahresstatistik').val === true) { Reset_Jahresstatistik(); }
 console.log('Auswertung durchgeführt...');
 if (getState(PRE_DP+'.Control.ScriptVersion_UpdateCheck').val) { check_update(); } // neue Script-Version vorhanden?
 Statusmeldung('erfolgreich');
} //end function main

function Reset_Jahresstatistik() {
        setState(PRE_DP+'.Jahreswerte.Temperatur_Tiefstwert',   100,  true);
        setState(PRE_DP+'.Jahreswerte.Temperatur_Hoechstwert',  -100, true);
        setState(PRE_DP+'.Jahreswerte.Temperatur_Durchschnitt', 0,    true);
        setState(PRE_DP+'.Jahreswerte.Trockenperiode',          0,    true);
        setState(PRE_DP+'.Jahreswerte.Regenmengetag',           0,    true);
        setState(PRE_DP+'.Jahreswerte.Regenmengemonat',         0,    true);
        setState(PRE_DP+'.Jahreswerte.Windboe_max',             0,    true);
        setState(PRE_DP+'.Jahreswerte.Gradtage_kalteTage',      0,    true);
        setState(PRE_DP+'.Jahreswerte.Gradtage_warmeTage',      0,    true);
        setState(PRE_DP+'.Jahreswerte.Gradtage_Sommertage',     0,    true);
        setState(PRE_DP+'.Jahreswerte.Gradtage_heisseTage',     0,    true);
        setState(PRE_DP+'.Jahreswerte.Gradtage_Frosttage',      0,    true);
        setState(PRE_DP+'.Jahreswerte.Gradtage_Eistage',        0,    true);
        setState(PRE_DP+'.Jahreswerte.Gradtage_sehrkalteTage',  0,    true);

        setState(PRE_DP+'.Control.Reset_Jahresstatistik', false, true);
} //end function

function AutoDelete_Data() {
    let AutoDelete = getState(PRE_DP+'.Control.AutoDelete_Data').val; //Anzahl Monate
    let zeitstempel = new Date();
    let startAD = new Date(zeitstempel.getFullYear(),zeitstempel.getMonth()-AutoDelete,1);
    let AutoDelete_Year = startAD.getFullYear();
    let AutoDelete_Month = startAD.getMonth();
    let DP_Years = []; //Jahresordnernamen

    $(PRE_DP+'.Data.*').each(function(DPID) {
        let OID=[],i=0;
        OID=DPID.replace(PRE_DP+'.Data.', '').split('.');
        if (typeof OID[1] === "undefined") { DP_Years[i]=OID[0]; i++; } //Jahresordnername sichern
        if ((Number(OID[0])<AutoDelete_Year) || (Number(OID[0])==AutoDelete_Year && Number(OID[1])<=AutoDelete_Month)) {
            deleteState(PRE_DP+'.Data.'+OID[0]+'.'+OID[1]);
        }
    }); //end selector

    //check ob Jahresordner leer ist + ggf. löschen
    for ( let i=0; i<DP_Years.length; i++ ) {
        let DP_Ordner_test=$(PRE_DP+'.Data.'+DP_Years[i]+'.*');
        if ( DP_Ordner_test.length == 0 ) { deleteState(PRE_DP+'.Data.'+DP_Years[i]); }
    }
    
} //end function

function speichern_Monat() {
    let zeitstempel = new Date();
    let datum = new Date(zeitstempel.getFullYear(),zeitstempel.getMonth(),zeitstempel.getDate()-2);
    let monatsdatenpunkt = '.Data.'+datum.getFullYear()+'.'+pad(datum.getMonth()+1); 
    //Datenpunkte lesen
    Tiefstwert=getState(PRE_DP+'.aktueller_Monat.Tiefstwert').val;
    Hoechstwert=getState(PRE_DP+'.aktueller_Monat.Hoechstwert').val;
    Temp_Durchschnitt=getState(PRE_DP+'.aktueller_Monat.Temperatur_Durchschnitt').val;
    Max_Windboe=getState(PRE_DP+'.aktueller_Monat.Max_Windboe').val;
    Max_Regenmenge=getState(PRE_DP+'.aktueller_Monat.Max_Regenmenge').val;
    Regenmenge_Monat=getState(PRE_DP+'.aktueller_Monat.Regenmenge_Monat').val;
    warme_Tage=getState(PRE_DP+'.aktueller_Monat.warme_Tage').val;
    Sommertage=getState(PRE_DP+'.aktueller_Monat.Sommertage').val;
    heisse_Tage=getState(PRE_DP+'.aktueller_Monat.heisse_Tage').val;
    Frost_Tage=getState(PRE_DP+'.aktueller_Monat.Frost_Tage').val;
    kalte_Tage=getState(PRE_DP+'.aktueller_Monat.kalte_Tage').val;
    Eistage=getState(PRE_DP+'.aktueller_Monat.Eistage').val;
    sehr_kalte_Tage=getState(PRE_DP+'.aktueller_Monat.sehr_kalte_Tage').val;
    //ggf. höchste Monatsregenmenge im Jahr schreiben
    if (getState(PRE_DP+'.Jahreswerte.Regenmengemonat').val <= Regenmenge_Monat) {setState(PRE_DP+'.Jahreswerte.Regenmengemonat', Regenmenge_Monat, true);} 
    let json = JSON.stringify([{"Tiefstwert": Tiefstwert, "Hoechstwert": Hoechstwert, "Temp_Durchschnitt": Temp_Durchschnitt, "Max_Windboe": Max_Windboe, 
        "Max_Regenmenge": Max_Regenmenge, "Regenmenge_Monat": Regenmenge_Monat, "warme_Tage": warme_Tage,
        "Sommertage": Sommertage, "heisse_Tage": heisse_Tage, "Frost_Tage": Frost_Tage, "kalte_Tage": kalte_Tage, "Eistage": Eistage, 
        "sehr_kalte_Tage": sehr_kalte_Tage}]);
    createState(PRE_DP+monatsdatenpunkt,'',{ name: "Monatsstatistik für "+monatsname[datum.getMonth()]+' '+datum.getFullYear(), type: "string", role: "json" }, () => { setState(PRE_DP+monatsdatenpunkt, json, true); }); 
} //end function

function VorJahr() {    
    let zeitstempel = new Date();
    let datum = new Date(zeitstempel.getFullYear(),zeitstempel.getMonth(),zeitstempel.getDate());
    let monatsdatenpunkt = '.Data.'+ (datum.getFullYear()-1) +'.'+pad(datum.getMonth()+1);
    if (existsState(PRE_DP+monatsdatenpunkt)) { //der einfache Weg: wir haben schon Daten vom Vorjahr...
        let VorJahr = JSON.parse(getState(PRE_DP+monatsdatenpunkt).val);
        //VorJahr = JSON.parse(VorJahr);
        setState(PRE_DP+'.Vorjahres_Monat.Tiefstwert', VorJahr[0].Tiefstwert, true);
        setState(PRE_DP+'.Vorjahres_Monat.Hoechstwert', VorJahr[0].Hoechstwert, true);
        setState(PRE_DP+'.Vorjahres_Monat.Temperatur_Durchschnitt', VorJahr[0].Temp_Durchschnitt, true); 
        setState(PRE_DP+'.Vorjahres_Monat.Max_Windboe', VorJahr[0].Max_Windboe, true); 
        setState(PRE_DP+'.Vorjahres_Monat.Max_Regenmenge', VorJahr[0].Max_Regenmenge, true);
        setState(PRE_DP+'.Vorjahres_Monat.Regenmenge_Monat', VorJahr[0].Regenmenge_Monat, true);
        setState(PRE_DP+'.Vorjahres_Monat.warme_Tage', VorJahr[0].warme_Tage, true);
        setState(PRE_DP+'.Vorjahres_Monat.Sommertage', VorJahr[0].Sommertage, true);
        setState(PRE_DP+'.Vorjahres_Monat.heisse_Tage', VorJahr[0].heisse_Tage, true);
        setState(PRE_DP+'.Vorjahres_Monat.Frost_Tage', VorJahr[0].Frost_Tage, true);
        setState(PRE_DP+'.Vorjahres_Monat.kalte_Tage', VorJahr[0].kalte_Tage, true);
        setState(PRE_DP+'.Vorjahres_Monat.Eistage', VorJahr[0].Eistage, true);
        setState(PRE_DP+'.Vorjahres_Monat.sehr_kalte_Tage', VorJahr[0].sehr_kalte_Tage, true);

    } else {
        //leider noch keine Daten vom Vorjahr; wir haben was zu tun...
        
                    //Werte setzen
                    let VRegenmenge_Monat=99999;
                    let Vwarme_Tage=99999;
                    let VSommertage=99999;
                    let Vheisse_Tage=99999;
                    let VFrost_Tage=99999;
                    let Vkalte_Tage=99999;
                    let VEistage=99999;
                    let Vsehr_kalte_Tage=99999;

        //Abfrage der Influx-Datenbank
        let start, end, result = [], temps = [], wind = [], regen = [];
        start = new Date(zeitstempel.getFullYear()-1,zeitstempel.getMonth(),1,0,0,0);
        start = start.getTime();
        end = new Date(zeitstempel.getFullYear()-1,zeitstempel.getMonth(),monatstage[zeitstempel.getMonth()],23,59,59);
        end = end.getTime();
            sendTo('influxdb.'+INFLUXDB_INSTANZ, 'query', 
            'from(bucket: "iobroker") |> range(start: ' + (start / 1000) + ', stop: ' + (end / 1000) + ') |> filter(fn: (r) => r["_measurement"] == "' + WET_DP + '.Aussentemperatur") |> filter(fn: (r) => r["_field"] == "value");' +
            'from(bucket: "iobroker") |> range(start: ' + (start / 1000) + ', stop: ' + (end / 1000) + ') |> filter(fn: (r) => r["_measurement"] == "' + WET_DP + '.Wind_max") |> filter(fn: (r) => r["_field"] == "value");' +
            'from(bucket: "iobroker") |> range(start: ' + ((start + 72000) / 1000) + ', stop: ' + (end / 1000) + ') |> filter(fn: (r) => r["_measurement"] == "' + WET_DP + '.Regen_Tag") |> filter(fn: (r) => r["_field"] == "value")'
                , function (result) {
                //Anlegen der Arrays + befüllen mit den relevanten Daten
                if (result.error) {
                  console.error('Fehler: '+result.error);
                } else {
                 //falls keinerlei Daten vom Vorjahr vorhanden sind...
                   if (typeof result.result[0][0] === "undefined") {
                    //Arrays löschen und mit default-Wert initiieren   
                    temps.length=0;
                    temps[0]=99999; 
                    wind.length=0;
                    wind[0]=99999;
                    regen.length=0;
                    regen[0]=99999;

                   } else {               
                    for (let i = 0; i < result.result[0].length; i++) { temps[i] = result.result[0][i].value; }
                    for (let i = 0; i < result.result[1].length; i++) { wind[i] = result.result[1][i].value; }
                    for (let i = 0; i < result.result[2].length; i++) { regen[i] = result.result[2][i].value; }
                   }
                }           
      
                //Temperaturen
                let VTiefstwert = Math.min(...temps);
                let VHoechstwert = Math.max(...temps);
                const reducer = (accumulator, curr) => accumulator + curr;
                let VTemp_Durchschnitt = Number((temps.reduce(reducer)/temps.length).toFixed(2));

                //let's do Gradtage...
                let MonatsTag, MonatsTag_old, Temp, Hit = [false,false,false,false,false,false,false];
                //Reset der Gradtage je nachdem ob Daten vorhanden oder nicht
                if (typeof result.result[0][0] !== "undefined") { Vwarme_Tage=0, VSommertage=0, Vheisse_Tage=0, VFrost_Tage=0, Vkalte_Tage=0, VEistage=0, Vsehr_kalte_Tage=0; }
                
                for (let i = 0; i < result.result[0].length; i++) {
                    MonatsTag = new Date(result.result[0][i].ts).getDate();
                    if (MonatsTag != MonatsTag_old) { Hit=[false,false,false,false,false,false,false]; }
                    Temp = result.result[0][i].value;
                     if (Temp > 20 && Hit[0] == false) { Vwarme_Tage++; Hit[0] = true; }
                     if (Temp > 25 && Hit[1] == false) { VSommertage++; Hit[1] = true; }
                     if (Temp > 30 && Hit[2] == false) { Vheisse_Tage++; Hit[2] = true; }
                     if (Temp < 0 && Hit[3] == false) { VFrost_Tage++; Hit[3] = true; }
                     if (Temp < 10 && Hit[4] == false) { Vkalte_Tage++; Hit[4] = true; }
                     if (Temp < 0 && Hit[5] == false) { VEistage++; Hit[5] = true; }
                     if (Temp < -10 && Hit[6] == false) { Vsehr_kalte_Tage++; Hit[6] = true; }
                    MonatsTag_old=MonatsTag; 
                } 

                //Wind
                let VMax_Windboe = Math.max(...wind);

                //Regen
                let VMax_Regenmenge = Math.max(...regen);
                let VRegenmenge_Monat=0, Rain = [];
                for (let i = 0; i < result.result[2].length; i++) {
                    MonatsTag = new Date(result.result[2][i].ts).getDate();
                    Rain[i] = result.result[2][i].value;
                    if (MonatsTag != MonatsTag_old) {
                        VRegenmenge_Monat+= Math.max(...Rain);
                        Rain.length=0; }
                    MonatsTag_old=MonatsTag; 
                }
                if (typeof result.result[0][0] === "undefined") { VRegenmenge_Monat=99999; } //keine Daten vom Vorjahresmonat

                //DPs schreiben
                setState(PRE_DP+'.Vorjahres_Monat.Tiefstwert', VTiefstwert, true);
                setState(PRE_DP+'.Vorjahres_Monat.Hoechstwert', VHoechstwert, true);
                setState(PRE_DP+'.Vorjahres_Monat.Temperatur_Durchschnitt', VTemp_Durchschnitt, true);
                setState(PRE_DP+'.Vorjahres_Monat.Max_Windboe', VMax_Windboe, true);
                setState(PRE_DP+'.Vorjahres_Monat.Max_Regenmenge', VMax_Regenmenge, true);
                setState(PRE_DP+'.Vorjahres_Monat.Regenmenge_Monat', VRegenmenge_Monat, true);
                setState(PRE_DP+'.Vorjahres_Monat.warme_Tage', Vwarme_Tage, true);
                setState(PRE_DP+'.Vorjahres_Monat.Sommertage', VSommertage, true);
                setState(PRE_DP+'.Vorjahres_Monat.heisse_Tage', Vheisse_Tage, true);
                setState(PRE_DP+'.Vorjahres_Monat.Frost_Tage', VFrost_Tage, true);
                setState(PRE_DP+'.Vorjahres_Monat.kalte_Tage', Vkalte_Tage, true);
                setState(PRE_DP+'.Vorjahres_Monat.Eistage', VEistage, true);
                setState(PRE_DP+'.Vorjahres_Monat.sehr_kalte_Tage', Vsehr_kalte_Tage, true);

            }); //end sendTo
        
    } //end else  

} //end function


function timeConverter(UNIX_timestamp){
  let a = new Date(UNIX_timestamp);
  let months = ['Jan','Feb','Mär','Apr','Mai','Jun','Jul','Aug','Sep','Okt','Nov','Dez'];
  let year = a.getFullYear();
  let month = months[a.getMonth()];
  let date = a.getDate();
  let hour = a.getHours();
  let min = a.getMinutes();
  let sec = a.getSeconds();
  let time = pad(date) + '. ' + month + ' ' + year + ' ' + pad(hour) + ':' + pad(min) + ':' + pad(sec) ;
  return time;
}

function pad(n) {
    return n<10 ? '0'+n : n;
}

// Pause einlegen
function Sleep(milliseconds) {
 return new Promise(resolve => setTimeout(resolve, milliseconds));
}

// Statusmeldungen in DP schreiben
function Statusmeldung(Text) {
    if (typeof(Text) === "undefined") { //nur beim Start des Skriptes
        Text = 'Skript gestartet';
        setState(PRE_DP+'.Control.ScriptVersion', ScriptVersion, true);    
    }
    setState(PRE_DP+'.Control.Statusmeldung', Text, true);
}

// Test auf neue Skriptversion
function check_update() {
    const axios = require('axios');

    axios.get('https://github.com/SBorg2014/WLAN-Wetterstation/commits/master/wetterstation-statistik.js')
     .then(function (response) {
     
     // /<a aria-label="V.*[\r\n]+.*<\/a>/

     let regex = /">V.*<\/a>/ 
     , version = response.data.match(regex);

     if (version[0].match(ScriptVersion)) { 
         setState(PRE_DP+'.Control.ScriptVersion_Update','---',true); 
     } else {
         setState(PRE_DP+'.Control.ScriptVersion_Update','https://github.com/SBorg2014/WLAN-Wetterstation/blob/master/wetterstation-statistik.js',true);
         console.log('neue Script-Version verfügbar...');
     }

    })
        .catch((error) => {
        console.log(`Fehler: ${error}`);
    })
} // end function

// Jahresstatistik-Backup
function Backup_Jahresstatistik() {
    let Temperatur_Hoechstwert = getState(PRE_DP+'.Jahreswerte.Temperatur_Hoechstwert').val;
    let Temperatur_Tiefstwert = getState(PRE_DP+'.Jahreswerte.Temperatur_Tiefstwert').val;
    let Temperatur_Durchschnitt = getState(PRE_DP+'.Jahreswerte.Temperatur_Durchschnitt').val;
    let Regenmengetag = getState(PRE_DP+'.Jahreswerte.Regenmengetag').val;
    let Regenmengemonat = getState(PRE_DP+'.Jahreswerte.Regenmengemonat').val;
    let Windboe_max = getState(PRE_DP+'.Jahreswerte.Windboe_max').val;
    let Trockenperiode = getState(PRE_DP+'.Jahreswerte.Trockenperiode').val;
    let kalte_Tage_Jahr = getState(PRE_DP+'.Jahreswerte.Gradtage_kalteTage').val;
    let warme_Tage_Jahr = getState(PRE_DP+'.Jahreswerte.Gradtage_warmeTage').val;
    let Sommertage_Jahr = getState(PRE_DP+'.Jahreswerte.Gradtage_Sommertage').val;
    let heisse_Tage_Jahr = getState(PRE_DP+'.Jahreswerte.Gradtage_heisseTage').val;
    let Frosttage_Jahr = getState(PRE_DP+'.Jahreswerte.Gradtage_Frosttage').val;
    let Eistage_Jahr = getState(PRE_DP+'.Jahreswerte.Gradtage_Eistage').val;
    let sehrkalte_Tage_Jahr = getState(PRE_DP+'.Jahreswerte.Gradtage_sehrkalteTage').val;

    let json = JSON.stringify([{"Temperatur Tiefstwert": Temperatur_Tiefstwert, "Temperatur Höchstwert": Temperatur_Hoechstwert, "Temperatur Durchschnitt": Temperatur_Durchschnitt,
        "Regenmengetag": Regenmengetag, "höchste Regenmengemonat": Regenmengemonat, "Windböe": Windboe_max,
        "Trockenperiode": Trockenperiode,
        "kalte Tage": kalte_Tage_Jahr, "warme Tage": warme_Tage_Jahr, "Sommertage": Sommertage_Jahr, "heiße Tage": heisse_Tage_Jahr, "Frosttage": Frosttage_Jahr, "Eistage": Eistage_Jahr,
        "sehr kalte Tage": sehrkalte_Tage_Jahr}]);
    createState(PRE_DP+'.Jahreswerte.VorJahre.'+(new Date().getFullYear()-1), '', { name: "Jahresstatistik", type: "string", role: "json" }, () => { setState(PRE_DP+'.Jahreswerte.VorJahre.'+(new Date().getFullYear()-1), json, true) });
} // end function


function Rekordwerte() {
    //max Temp
    if (getState(PRE_DP+'.Rekordwerte.value.Temp_Max').val <= Hoechstwert) {
        setState(PRE_DP+'.Rekordwerte.value.Temp_Max', Hoechstwert, true, () => { Template_Rekordwerte('Temp_Max','Rekordwerte.Temperatur_Spitzenhoechstwert'); });
    }

    //min Temp
    if (getState(PRE_DP+'.Rekordwerte.value.Temp_Min').val >= Tiefstwert) {
        setState(PRE_DP+'.Rekordwerte.value.Temp_Min', Tiefstwert, true, () => { Template_Rekordwerte('Temp_Min','Rekordwerte.Temperatur_Spitzentiefstwert'); });
    }  

    //Regenmenge
    if (getState(PRE_DP+'.Rekordwerte.value.Regenmengetag').val <= Max_Regenmenge) {
        setState(PRE_DP+'.Rekordwerte.value.Regenmengetag', Max_Regenmenge, true, () => { Template_Rekordwerte('Regenmengetag','Rekordwerte.Regenmengetag'); });
    }
    Regenmenge_Monat = getState(PRE_DP+'.aktueller_Monat.Regenmenge_Monat').val;
    if (getState(PRE_DP+'.Rekordwerte.value.Regenmengemonat').val <= Regenmenge_Monat) {
        setState(PRE_DP+'.Rekordwerte.value.Regenmengemonat', Regenmenge_Monat, true, () => { Template_Rekordwerte('Regenmengemonat','Rekordwerte.Regenmengemonat'); });
    }

    //Windböe
    if (getState(PRE_DP+'.Rekordwerte.value.Windboe').val <= Max_Windboe) {
        setState(PRE_DP+'.Rekordwerte.value.Windboe', Max_Windboe, true, () => { Template_Rekordwerte('Windboe','Rekordwerte.Windboe'); });
    }

    //Trockenperiode
    if (getState(PRE_DP+'.Rekordwerte.value.Trockenperiode').val <= Trockenperiode_akt) {
        setState(PRE_DP+'.Rekordwerte.value.Trockenperiode', Trockenperiode_akt, true, () => { Template_Rekordwerte('Trockenperiode','Rekordwerte.Trockenperiode'); });
    }  

} // end function


async function Template_Rekordwerte(DatenPunkt, DatenPunktName) {
    await Sleep(5000);
    let wert = getState(PRE_DP+'.Rekordwerte.value.'+DatenPunkt).val;
    let unit = getObject(PRE_DP+'.Rekordwerte.value.'+DatenPunkt).common.unit;
    let REKORDWERTEAUSGABE="";
    
    //[WERT]
    if (REKORDWERTE_AUSGABEFORMAT.search("[WERT]") != -1) {
        REKORDWERTEAUSGABE = REKORDWERTE_AUSGABEFORMAT.replace("[WERT]", wert+' '+unit);
    } else { REKORDWERTEAUSGABE = REKORDWERTE_AUSGABEFORMAT; }

    //[TAG]
    REKORDWERTEAUSGABE = REKORDWERTEAUSGABE.replace("[TAG]", new Date((getState(PRE_DP+'.Rekordwerte.value.'+DatenPunkt).lc)-86400).getDate()); 

    //[MONAT]
    REKORDWERTEAUSGABE = REKORDWERTEAUSGABE.replace("[MONAT]", monatsname[new Date((getState(PRE_DP+'.Rekordwerte.value.'+DatenPunkt).lc)-86400).getMonth()]);

    //[MONAT_ZAHL]
    REKORDWERTEAUSGABE = REKORDWERTEAUSGABE.replace("[MONAT_ZAHL]", pad(new Date((getState(PRE_DP+'.Rekordwerte.value.'+DatenPunkt).lc)-86400).getMonth()+1));

    //[MONAT_KURZ]
    REKORDWERTEAUSGABE = REKORDWERTEAUSGABE.replace("[MONAT_KURZ]", monatsname_kurz[new Date((getState(PRE_DP+'.Rekordwerte.value.'+DatenPunkt).lc)-86400).getMonth()]);

    //[JAHR]
    REKORDWERTEAUSGABE = REKORDWERTEAUSGABE.replace("[JAHR]", new Date((getState(PRE_DP+'.Rekordwerte.value.'+DatenPunkt).lc)-86400).getFullYear());

    //Spezialpatch für 1 Tag
    if ((REKORDWERTEAUSGABE.search("Tage") != -1) && (wert == 1)) {
        REKORDWERTEAUSGABE = REKORDWERTEAUSGABE.replace("Tage", "Tag");
    }

    setState(PRE_DP+'.'+DatenPunktName, REKORDWERTEAUSGABE, true);                                                 
} // end function


//Datenpunkte anlegen
async function createDP(DP_Check) {
    console.log(PRE_DP + '.' + DP_Check + ' existiert nicht... Lege Datenstruktur an...');
    createState(PRE_DP,                                           '',   { name: 'Wetterstatistik',                              type: "folder" });
    createState(PRE_DP+'.aktueller_Monat',                        '',   { name: 'Statistik für den aktuellen Monat',            type: "folder" });
    createState(PRE_DP+'.Vorjahres_Monat',                        '',   { name: 'Statistik für den Monat des Vorjahres',        type: "folder" });
    createState(PRE_DP+'.Data',                                   '',   { name: 'bisherige Statistiken',                        type: "folder" });
    createState(PRE_DP+'.VorTag',                                 '',   { name: 'Werte von Gestern',                            type: "folder" });
    createState(PRE_DP+'.Control',                                '',   { name: 'Einstellungen, Meldungen',                     type: "folder" });
    createState(PRE_DP+'.Jahreswerte',                            '',   { name: 'Jahresstatistik',                              type: "folder" });
    createState(PRE_DP+'.Rekordwerte',                            '',   { name: 'Rekordwerte seit Aufzeichnungsbeginn',         type: "folder" });
    
    createState(PRE_DP+'.aktueller_Monat.Tiefstwert',             100,  { name: "niedrigste Temperatur",                        type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.aktueller_Monat.Hoechstwert',            -100, { name: "höchste Temperatur",                           type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.aktueller_Monat.Temperatur_Durchschnitt',0,    { name: "Durchschnittstemperatur",                      type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.aktueller_Monat.Max_Windboe',            0,    { name: "stärkste Windböe",                             type: "number", role: "state", unit: "km/h" });
    createState(PRE_DP+'.aktueller_Monat.Max_Regenmenge',         0,    { name: "maximale Regenmenge pro Tag",                  type: "number", role: "state", unit: "l/m²" });
    createState(PRE_DP+'.aktueller_Monat.Regenmenge_Monat',       0,    { name: "Regenmenge im Monat",                          type: "number", role: "state", unit: "l/m²" });
    createState(PRE_DP+'.aktueller_Monat.warme_Tage',             0,    { name: "Tage mit einer Temperatur über 20°",           type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.aktueller_Monat.Sommertage',             0,    { name: "Tage mit einer Temperatur über 25°",           type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.aktueller_Monat.heisse_Tage',            0,    { name: "Tage mit einer Temperatur über 30°",           type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.aktueller_Monat.Frost_Tage',             0,    { name: "Tage mit einer Mindesttemperatur unter 0°",    type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.aktueller_Monat.kalte_Tage',             0,    { name: "Tage mit einer Höchsttemperatur unter 10°",    type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.aktueller_Monat.Eistage',                0,    { name: "Tage mit einer Höchsttemperatur unter 0°",     type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.aktueller_Monat.sehr_kalte_Tage',        0,    { name: "Tage mit einer Mindesttemperatur unter -10°",  type: "number", role: "state", unit: "Tage" });

    createState(PRE_DP+'.Vorjahres_Monat.Tiefstwert',             99999, { name: "niedrigste Temperatur",                       type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.Vorjahres_Monat.Hoechstwert',            99999, { name: "höchste Temperatur",                          type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.Vorjahres_Monat.Temperatur_Durchschnitt',99999, { name: "Durchschnittstemperatur",                     type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.Vorjahres_Monat.Max_Windboe',            99999, { name: "stärkste Windböe",                            type: "number", role: "state", unit: "km/h" });
    createState(PRE_DP+'.Vorjahres_Monat.Max_Regenmenge',         99999, { name: "maximale Regenmenge pro Tag",                 type: "number", role: "state", unit: "l/m²" });
    createState(PRE_DP+'.Vorjahres_Monat.Regenmenge_Monat',       99999, { name: "Regenmenge im Monat",                         type: "number", role: "state", unit: "l/m²" });
    createState(PRE_DP+'.Vorjahres_Monat.warme_Tage',             99999, { name: "Tage mit einer Temperatur über 20°",          type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.Vorjahres_Monat.Sommertage',             99999, { name: "Tage mit einer Temperatur über 25°",          type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.Vorjahres_Monat.heisse_Tage',            99999, { name: "Tage mit einer Temperatur über 30°",          type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.Vorjahres_Monat.Frost_Tage',             99999, { name: "Tage mit einer Mindesttemperatur unter 0°",   type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.Vorjahres_Monat.kalte_Tage',             99999, { name: "Tage mit einer Höchsttemperatur unter 10°",   type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.Vorjahres_Monat.Eistage',                99999, { name: "Tage mit einer Höchsttemperatur unter 0°",    type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.Vorjahres_Monat.sehr_kalte_Tage',        99999, { name: "Tage mit einer Mindesttemperatur unter -10°", type: "number", role: "state", unit: "Tage" });

    createState(PRE_DP+'.VorTag.Temperatur_Tiefstwert',           99999, { name: "niedrigste Tagestemperatur",                  type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.VorTag.Temperatur_Hoechstwert',          99999, { name: "höchste Tagestemperatur",                     type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.VorTag.Temperatur_Durchschnitt',         99999, { name: "Durchschnittstemperatur",                     type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.VorTag.Regenmenge',                      0,     { name: "Regenmenge vom Vortag",                       type: "number", role: "state", unit: "l/m²" });
    createState(PRE_DP+'.VorTag.Windboe_max',                     0,     { name: "stärkste Windböe vom Vortag",                 type: "number", role: "state", unit: "km/h" });

    createState(PRE_DP+'.Jahreswerte.Temperatur_Hoechstwert',     -100,  { name: "höchste Tagestemperatur des Jahres",          type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.Jahreswerte.Temperatur_Tiefstwert',      100,   { name: "niedrigste Tagestemperatur des Jahres",       type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.Jahreswerte.Temperatur_Durchschnitt',    0,     { name: "Durchschnittstemperatur des Jahres",          type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.Jahreswerte.Trockenperiode',             0,     { name: "längste Periode ohne Regen",                  type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.Jahreswerte.Regenmengetag',              0,     { name: "höchste Regenmenge an einem Tag",             type: "number", role: "state", unit: "l/m²" });
    createState(PRE_DP+'.Jahreswerte.Regenmengemonat',            0,     { name: "höchste Regenmenge innerhalb eines Monats",   type: "number", role: "state", unit: "l/m²" });
    createState(PRE_DP+'.Jahreswerte.Windboe_max',                0,     { name: "stärkste Windböe des Jahres",                 type: "number", role: "state", unit: "km/h" });
    createState(PRE_DP+'.Jahreswerte.Gradtage_kalteTage',         0,     { name: "Tage mit einer Höchsttemperatur unter 10°",   type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.Jahreswerte.Gradtage_warmeTage',         0,     { name: "Tage mit einer Höchsttemperatur über 20°",    type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.Jahreswerte.Gradtage_Sommertage',        0,     { name: "Tage mit einer Höchsttemperatur über 25°",    type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.Jahreswerte.Gradtage_heisseTage',        0,     { name: "Tage mit einer Höchsttemperatur über 30°",    type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.Jahreswerte.Gradtage_Frosttage',         0,     { name: "Tage mit einer Tiefsttemperatur unter 0°",    type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.Jahreswerte.Gradtage_Eistage',           0,     { name: "Tage mit einer Höchsttemperatur unter 0°",    type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.Jahreswerte.Gradtage_sehrkalteTage',     0,     { name: "Tage mit einer Tiefsttemperatur unter -10°",  type: "number", role: "state", unit: "Tage" });

    createState(PRE_DP+'.Rekordwerte.value.Temp_Max',             -100,  { name: "Max. Tagestemperatur",                        type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.Rekordwerte.value.Temp_Min',             100,   { name: "Min. Tagestemperatur",                        type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.Rekordwerte.value.Trockenperiode',       0,     { name: "längste Trockenperiode",                      type: "number", role: "state", unit: "Tage" });
    createState(PRE_DP+'.Rekordwerte.value.Temp_Durchschnitt_Min',99.99, { name: "niedrigster Jahrestemperaturdurchschnitt",    type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.Rekordwerte.value.Temp_Durchschnitt_Max',-99.99,{ name: "höchster Jahrestemperaturdurchschnitt",       type: "number", role: "state", unit: "°C" });
    createState(PRE_DP+'.Rekordwerte.value.Regenmengetag',        0,     { name: "höchste je gemessene Regenmenge an einem Tag",type: "number", role: "state", unit: "l/m²" });
    createState(PRE_DP+'.Rekordwerte.value.Regenmengemonat',      0,     { name: "höchste je gemessene Regenmenge eines Monats",type: "number", role: "state", unit: "l/m²" });
    createState(PRE_DP+'.Rekordwerte.value.Windboe',              0,     { name: "stärkste je gemessene Windböe"               ,type: "number", role: "state", unit: "km/h" });
    createState(PRE_DP+'.Rekordwerte.Temperatur_Spitzenhoechstwert', '', { name: "höchste je gemessene Tagestemperatur",        type: "string", role: "state" });
    createState(PRE_DP+'.Rekordwerte.Temperatur_Spitzentiefstwert',  '', { name: "niedrigste je gemessene Tagestemperatur",     type: "string", role: "state" });
    createState(PRE_DP+'.Rekordwerte.Temperatur_Jahresdurchschnitt_Max', '', { name: "höchster Jahrestemperaturdurchschnitt",   type: "string", role: "state" });
    createState(PRE_DP+'.Rekordwerte.Temperatur_Jahresdurchschnitt_Min', '', { name: "niedrigster Jahrestemperaturdurchschnitt",type: "string", role: "state" });
    createState(PRE_DP+'.Rekordwerte.Regenmengetag',             '',     { name: "höchste je gemessene Regenmenge an einem Tag",type: "string", role: "state" });
    createState(PRE_DP+'.Rekordwerte.Regenmengemonat',           '',     { name: "höchste je gemessene Regenmenge eines Monats",type: "string", role: "state" });
    createState(PRE_DP+'.Rekordwerte.Windboe',                   '',     { name: "stärkste je gemessene Windböe"               ,type: "string", role: "state" });
    createState(PRE_DP+'.Rekordwerte.Trockenperiode',            '',     { name: "längste je andauernde Trockenperiode",        type: "string", role: "state" });

    createState(PRE_DP+'.Control.Statusmeldung',                  '',    { name: "Statusmeldungen",                             type: "string", role: "state"});
    createState(PRE_DP+'.Control.Reset_Jahresstatistik',          false, { name: "Jahresstatistik zurücksetzen",                type: "boolean",role: "state"});
    createState(PRE_DP+'.Control.AutoReset_Jahresstatistik',      0,     { name: "Jahresstatistik zurücksetzen [0=Aus, 1=Ein, 2=Ein+Backup]",type: "number",role: "state"});
    createState(PRE_DP+'.Control.AutoDelete_Data',                0,     { name: "Data bereinigen? [0 = nie, 1...n = nach x Monaten]",  type: "number", role: "state"});
    createState(PRE_DP+'.Control.ScriptVersion',                  '',    { name: "aktuelle Versionsnummer des Statistik-Skriptes",type: "string",role: "state"});
    createState(PRE_DP+'.Control.ScriptVersion_Update',           '',    { name: "neue Version des Statistik-Skriptes vorhanden",type: "string",role: "state"});
    createState(PRE_DP+'.Control.ScriptVersion_UpdateCheck',      '',    { name: "Skript-Updatecheck ein-/ausschalten",         type: "boolean",role: "state"});
    await Sleep(5000);
}

Vielleicht kannst du das prüfen, wenn du deine Influx auf Version 2 gebracht hast und Zeit dafür findest.