Navigation

    Logo
    • Register
    • Login
    • Search
    • Recent
    • Tags
    • Unread
    • Categories
    • Unreplied
    • Popular
    • GitHub
    • Docu
    • Hilfe
    1. Home
    2. Deutsch
    3. Praktische Anwendungen (Showcase)
    4. [Linux Shell-Skript] WLAN-Wetterstation

    NEWS

    • ioBroker@Smart Living Forum Solingen, 14.06. - Agenda added

    • ioBroker goes Matter ... Matter Adapter in Stable

    • Monatsrückblick - April 2025

    [Linux Shell-Skript] WLAN-Wetterstation

    This topic has been deleted. Only users with topic management privileges can see it.
    • M
      MartyBr @jostereo last edited by

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

      Bildschirmfoto 2022-03-07 um 06.55.05.png

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

      Bildschirmfoto 2022-03-07 um 06.57.00.png

      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);
      }
      
      J 1 Reply Last reply Reply Quote 0
      • J
        jostereo @MartyBr last edited by

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

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

        Bildschirmfoto 2022-03-07 um 06.55.05.png

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

        Bildschirmfoto 2022-03-07 um 06.57.00.png

        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:

        ioBroker.JPG

        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.

        M SBorg 2 Replies Last reply Reply Quote 0
        • M
          MartyBr @jostereo last edited by

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

          1 Reply Last reply Reply Quote 0
          • SBorg
            SBorg Forum Testing Most Active @jostereo last edited by

            @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 😞

            1 Reply Last reply Reply Quote 1
            • M
              MartyBr last edited by

              @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:
              Bildschirmfoto 2022-03-10 um 06.58.56.png

              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.

              SBorg Latzi 2 Replies Last reply Reply Quote 0
              • SBorg
                SBorg Forum Testing Most Active @MartyBr last edited by

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

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

                "Leider" schon geprüft, das geht auch zügig. Nur mal eben die Influx umstellen kann ich mir derzeit nicht unbedingt erlauben. Da hängt bei mir noch einiges dran was laufen muss. Ich muss also Zeit mit einplanen notfalls das alles gleichzeitig umzustellen/patchen. Da ist die Wetterstation am unkritischsten falls sie halt nicht gleich auf Anhieb läuft. ...aber mein Bad ist mir aktuell am wichtigsten 😉
                Ist also nicht so, dass ich nicht will, ich kann halt aktuell einfach nur nicht. Aber mal drüber schauen, Gedanken machen etc. das geht immer 🙂

                "(null)" ist nicht gut, dass deutet auf ein "echtes" Problem hin. Wenn keine Daten zur Verfügung stehen, wie aktuell bei dir die März-Daten von 2021, dann gibt es immer 99.99 / 99999 Werte, um anzuzeigen, dass dies keine aktuellen Werte sind.
                Der "VorTag" wird aus der Influx gezogen. Da gäbe es eigentlich nur zwei Fehlerquellen:

                • er hat noch immer keine korrekte Verbindung zur Influx und die Abfrage schlägt fehl (müsste aber eine Fehlermeldung auftreten)
                • das Rückgabeformat ist anders als erwartet

                Ich tippe auf letzteres. Das war zB. bei V1.x eine Tabelle mit drei Spalten und in der 3. stand der Messwert. In V2 sind es dann ev. nur noch zwei Spalten, dann kann er natürlich die 3. Spalte bis zum Skt. Nimmerleinstag auslesen wollen, da wird nie ein Wert drin stehen. Oder das Format an sich hat sich geändert, oder...
                Da müsste man jetzt also nachschauen was die V2 da so liefert.

                M 1 Reply Last reply Reply Quote 0
                • M
                  MartyBr @SBorg last edited by

                  @sborg Alles gut. Ich wollte nur eine Rückmeldung geben. Die Statistik der Wetterdaten ist nicht lebenswichtig. Die Wetterstation funktioniert einwandfrei und ich bekomme darüber eine Menge an Daten.
                  Das Script ist toll und ich habe schon alle Systeme auf die neue Wetterstation umgestellt.
                  Vielen dank für deinen Einsatz 👍

                  SBorg 1 Reply Last reply Reply Quote 0
                  • SBorg
                    SBorg Forum Testing Most Active @MartyBr last edited by

                    @martybr Habe ich auch nicht anders aufgefasst (gerade eben nicht von wg. Quengelei "das muss jetzt aber").
                    Es liegt aber in der Art der Dinge, dass oftmals, auch schon hier, etwas gänzlich anders verstanden wurde als ich eigentlich meinte.
                    Bevor da nun der Eindruck entsteht "der hat nur keinen Bock", schreibe ich halt wie es aktuell ist.
                    ...und ich bin durchaus in der Lage mitzuteilen falls ich zu etwas keine Lust habe 😁

                    Aber es geht ja auch nichts verloren solange man die Daten in Influx loggt. Nur man kriegt sie halt aktuell so nicht korrekt per Skript heraus.

                    M da_Woody 2 Replies Last reply Reply Quote 0
                    • M
                      MartyBr @SBorg last edited by

                      @sborg Richtig. Lieber alles richtig stellen, es kann ja einiges Missverstanden werden. Die Stimmung auch hier im Forum (nicht in diesem Thread) ist schlechter geworden. Es sind schon einige gereizte Einträge geschrieben worden.
                      Das ist aber OT hier.

                      1 Reply Last reply Reply Quote 0
                      • da_Woody
                        da_Woody @SBorg last edited by

                        @sborg wiedermal meine meinung dazu.
                        es gibt user, die wollen die eierlegendewollmilchsau. ich beobachte das schon bei einigen adaptern, die ich selbst verwende.
                        als DEV bist du gewillt so viel wie möglich zu ermöglichen. 👍 aber irgendwann muss schluss sein! verbessern ja, aber auf jede kleine einstellung für einen user geht halt nicht.
                        das ist von mir absolut nicht böse gemeint, aber einer mag für genau sein "problem" eine einstellung, die aber der großteil nicht benötigt, aber eventuell die config des adapters verkompliziert.

                        @MartyBr siehe oben. 😉 die stimmung mit der weltlage trifft auch hier ein, leider. allerdings, wie schon getippt: für einen allgemeinenen wunsch eines einzelnen kann und soll nicht immer rücksicht genommen werden.

                        M SBorg 2 Replies Last reply Reply Quote 1
                        • M
                          MartyBr @da_Woody last edited by

                          @da_woody
                          Es geht hier nicht um einen Wunsch eines einzelnen Users. Hier in Github ist das Statistik Script veröffentlicht, welches für Influx Ver. 1 geschrieben wurde. das wird auch andere User interessieren, die ihre Datenbank auch auf Influx 2 upgedatet haben. Meine Frage geht nur in Richtung Anpassung auf Influx Ver. 2. Wenn ich wirklich der Einzige bin, der daran Interesse hat, dann verzichte ich gerne auf die Anpassung und versuche es alleine.

                          da_Woody 1 Reply Last reply Reply Quote 0
                          • da_Woody
                            da_Woody @MartyBr last edited by

                            @martybr sorry, du hast mich da falsch verstanden! schon klar, der umstieg von influx wird sicher mehrere interessieren.
                            ich wollte im zusammenhang nur aufgreifen, wie und warum teilweise die stimmung, leider, teilweise gereizt ist.
                            du hast auch recht, bei dem script gehts ja nicht um einen adapter. ist was anderes. ich wollte halt auf eben die teilweise angespannte stimmung hinweisen und um ruhe bitten...
                            ich hoffe, das ist ok für dich.

                            M 1 Reply Last reply Reply Quote 0
                            • M
                              MartyBr @da_Woody last edited by

                              @da_woody Das ist in Ordnung. Ich bin da genau deiner Meinung, Ruhe in den "Laden" zu bringen. Ich habe dich da wirklich falsch verstanden.
                              Okay, alles gut.

                              1 Reply Last reply Reply Quote 1
                              • SBorg
                                SBorg Forum Testing Most Active @da_Woody last edited by

                                @da_woody Sehe ich genauso. Es nutzt keinem das beste Skript/Adapter, wenn es zig Einstellmöglichkeiten hat aus denen keiner mehr so richtig schlau wird. Für mich muss so was fast rein intuitiv möglich sein, ohne ein dauerndes "wofür ist das denn gut?". Deswegen eine gute Balance aus "was gibt Sinn und was macht es Anwender freundlich sinnvoll konfigurierbar".
                                Allen kann man es eh nie Recht machen, aber ich bin auch einzelnen Userwünschen nicht pauschal abgeneigt, so lange ich da einfach einen Mehrnutzen sehe und es technisch noch sinnvoll ist (bringt ja auch nix wenn es nur auf einem Quadcore mit mega GHz und GBs an RAM läuft).

                                Aktuell die Influx V2 sehe ich auch nicht direkt als (einzelnen) Userwunsch (ich weiß, hat auch keiner behauptet 😉 ), sondern als Invest in die Zukunft. Gerade hinsichtlich dass der Adapter nun mittlerweile stable mit der V2 umgehen kann und die V2 eine GUI hat. Allerdings ist da halt auch noch anderes zu berücksichtigen, steht aber schon länger auf der ToDo-Liste.

                                Aus Dev-Sicht muss ich aber auch mal ganz unmissverständlich klarstellen: dies ist keine Demokratie, sondern eine Diktatur. Alleine der Dev bestimmt wo und wie es lang geht. Wünsche, Verbesserungs- oder Änderungsvorschläge dürfen und sollen auch geäußert werden. Man kann immer über alles reden, aber stellenweise schon fast die Arroganz anzunehmen (nicht hier im Projekt), dass muss jetzt aber auch umgesetzt werden, da verschlägt es mir schon die Sprache. Persönlich würde ich da mein Engagement überdenken.
                                Die Sourcen liegen bei fast allem offen und man kann es sich selbst (um-/bei-)programmieren...
                                ...käme da nicht immer die Ausrede "ich kann nicht programmieren"...
                                Dann kommt immer mein Standardspruch: "Ich auch nicht, aber eines morgens fiel ich aus dem Bett und konnte es". Wenn man etwas wirklich will findet man auch einen Weg. Auto fahren musste auch jeder lernen, zumindest mal die Verkehrsregeln. Da klappt es auch mit dem lernen wenn man Auto fahren möchte. Programmieren folgt auch nur reiner Logik, schreckt aber viele ab. Aber auch hier, es muss jetzt nicht jeder zwangsläufig programmieren lernen. Aber von Anderen erwarten ihre eigene "Faulheit, Unkenntnis (wie auch immer man es titulieren möchte)" quasi zu unterstützen indem sie ihre eigene Freizeit opfern, dass ist IMO mehr als frech.

                                Ich hatte auch schon folgende Post: "Wenn du das nicht einbaust, nutze ich deine Software nicht!"
                                An was mir diese "Drohung" vorbeigeht wird sich jeder denken können, aber ich verstehe nicht mal ansatzweise den Sinn dahinter? Bei YouTube würde ich sagen, klar, Abonnenten und Viewtime = Geld
                                Aber dieses Projekt ist völlig kostenlos, ich kriege keine Werbeprovisionen (nicht mal Hardware-Unterstützung seitens Hersteller), einen Boni für Downloads oder what ever. War, und ist auch nie das Ziel gewesen.
                                Es "tangiert mich also peripher" ob es jemand nutzt oder nicht. Ist aber trotzdem auch schön zu sehen, dass es immerhin etliche nutzen und sich irgendwo die viele Arbeit lohnt 🙂

                                da_Woody 1 Reply Last reply Reply Quote 6
                                • da_Woody
                                  da_Woody @SBorg last edited by

                                  @sborg gott.gif
                                  danke! endlich mal eine klare ansage! wenn ich dein posting zerpflücke und meinen senf dazugebe, hats keinen sinn.

                                  1 Reply Last reply Reply Quote 0
                                  • Negalein
                                    Negalein Global Moderator last edited by

                                    @SBorg

                                    Ich hab ein Problem mit der Regenmenge.

                                    Letzter Regen war am 23. 2. mit 3,5 mm

                                    1e87bf94-7839-4342-ab04-fd42d72044f7-image.png

                                    Am 12. 3. um 18:05 schrieb er plötzlich 56,8 mm in die DB.

                                    58f4355c-2b82-4ea3-a8f9-6dfbc8f36d7b-image.png

                                    Wie bring ich das auf 0 und warum wird da was geschrieben?

                                    SBorg 1 Reply Last reply Reply Quote 0
                                    • SBorg
                                      SBorg Forum Testing Most Active @Negalein last edited by

                                      @negalein Kann man schwer sagen. Gerade der Regenmesser ist mechanisch anfällig was Verschmutzung etc. angeht. Ev. hat da das entprellen nicht funktioniert, oder, oder...
                                      Da das Skript nur auswerten kann was es kriegt, ist da wohl der falsche Wert seitens der Station/Display zu Stande gekommen. Andernfalls müsstest du die Datenpakete mal mitloggen.

                                      Korrektur:

                                      • per Terminal influx auf dem Rechner mit InfluxDB
                                      • falls Authentication aktiviert ist: auth und dann Username + Passwort eingeben
                                      • use _hier_Datenbankname_
                                      • select * from "javascript.0.Wetterstation.Info.Letzte_Regenmenge" where value=56.8 and time<now()-5d
                                        • Pfad und ggf. Werte anpassen (hier Messwerte der letzten 5 Tage)
                                      • den/die passende/n Timestamp/s aus del Liste kopieren
                                      • delete from "javascript.0.Wetterstation.Info.Letzte_Regenmenge" where time=_den_timestamp_einfügen_

                                      In V1.x lassen sich leider nur die Werte einzeln per "Timestamp" löschen 😉

                                      Negalein 2 Replies Last reply Reply Quote 0
                                      • Negalein
                                        Negalein Global Moderator @SBorg last edited by

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

                                        javascript.0.Wetterstation.Info.Letzte_Regenmenge

                                        wird javascript.0.Wetterstation.Regen_Monat berechnet, oder kommt der auch aus der Station?
                                        Um den gehts eigentlich (oben vergessen zu schreiben).

                                        SBorg 1 Reply Last reply Reply Quote 0
                                        • SBorg
                                          SBorg Forum Testing Most Active @Negalein last edited by

                                          @negalein Direkt aus der Station. Sieht nach einem Firmware-Bug aus, vermutlich wegen dem Februar mit 28 Tagen. Anscheinend wurde da der Wert nicht resettet. Heute hat es bei mir in diesem Monat das erste Mal geregnet, da kann der Monatswert wohl nicht über dem aktuellen Wochenwert liegen...

                                          ...&weeklyrainin=0.480&monthlyrainin=2.772...
                                          

                                          Wahrscheinlich geht es dann nächsten Monat wieder. Wo soll man das jetzt melden... 🤷‍♂️

                                          Negalein 1 Reply Last reply Reply Quote 0
                                          • Negalein
                                            Negalein Global Moderator @SBorg last edited by

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

                                            Sieht nach einem Firmware-Bug aus, vermutlich wegen dem Februar mit 28 Tagen.

                                            sehr gut möglich.
                                            Eventuell liegt bei mir auch ein HW-Problem vor.
                                            Es regnet seit ca. 1 Stunde leicht (mal mehr, mal weniger), aber es zeigt nichts an.

                                            Wo soll man das jetzt melden... 🤷‍♂️

                                            Gute Frage. Und ob das was bringen würde bei Kim Jong-un? 😉

                                            SBorg 1 Reply Last reply Reply Quote 0
                                            • First post
                                              Last post

                                            Support us

                                            ioBroker
                                            Community Adapters
                                            Donate

                                            1.2k
                                            Online

                                            31.7k
                                            Users

                                            79.7k
                                            Topics

                                            1.3m
                                            Posts

                                            linux shell-script wetterstation wlan-wetterstation
                                            141
                                            5469
                                            3248362
                                            Loading More Posts
                                            • Oldest to Newest
                                            • Newest to Oldest
                                            • Most Votes
                                            Reply
                                            • Reply as topic
                                            Log in to reply
                                            Community
                                            Impressum | Datenschutz-Bestimmungen | Nutzungsbedingungen
                                            The ioBroker Community 2014-2023
                                            logo