Weiter zum Inhalt
  • Home
  • Aktuell
  • 0 Ungelesen 0
  • Kategorien
  • Unreplied
  • Beliebt
  • GitHub
  • Docu
  • Hilfe
Skins
  • Hell
  • Brite
  • Cerulean
  • Cosmo
  • Flatly
  • Journal
  • Litera
  • Lumen
  • Lux
  • Materia
  • Minty
  • Morph
  • Pulse
  • Sandstone
  • Simplex
  • Sketchy
  • Spacelab
  • United
  • Yeti
  • Zephyr
  • Dunkel
  • Cyborg
  • Darkly
  • Quartz
  • Slate
  • Solar
  • Superhero
  • Vapor

  • Standard: (Kein Skin)
  • Kein Skin
Einklappen
ioBroker Logo

Community Forum

donate donate
  1. ioBroker Community Home
  2. Deutsch
  3. Praktische Anwendungen (Showcase)
  4. [Linux Shell-Skript] WLAN-Wetterstation

NEWS

  • iobroker.click: Visualisierungen und Vorlagen für ioBroker
    BluefoxB
    Bluefox
    13
    1
    340

  • Monatsrückblick Oktober 2026 ist online!
    BluefoxB
    Bluefox
    11
    1
    443

  • Mitmachen: Sprich „ioBroker“ ein – für ein lokales Aktivierungswort
    BluefoxB
    Bluefox
    6
    1
    574

[Linux Shell-Skript] WLAN-Wetterstation

Geplant Angeheftet Gesperrt Verschoben Praktische Anwendungen (Showcase)
linuxshell-scriptwetterstationwlan-wetterstation
5.8k Beiträge 156 Kommentatoren 5.8m Aufrufe 137 Beobachtet
  • Älteste zuerst
  • Neuste zuerst
  • Meiste Stimmen
Antworten
  • In einem neuen Thema antworten
Anmelden zum Antworten
Dieses Thema wurde gelöscht. Nur Nutzer mit entsprechenden Rechten können es sehen.
  • SBorgS
    SBorgS
    SBorg
    Forum Testing Most Active
    schrieb am zuletzt editiert von
    #5829

    Hi, dafür gibt es schon einen Issue:
    https://github.com/SBorg2014/WLAN-Wetterstation/issues/87
    Ich bin, wie man am Datum des Issues sieht, auch schon länger dran, aber irgendwie will es mit der API V2 nicht funktionieren. Benutze ich eine der neuen URLs: Fehler - Seite nicht gefunden.
    Dann hatte ich eine die funktioniert, da schlägt dann der Login mit Station-ID und Station-PW fehl.
    Ich versuche es weiter 🙃

    LG SBorg ( SBorg auf GitHub)
    Projekte: Lebensmittelwarnung.de | WLAN-Wetterstation | PimpMyStation

    1 Antwort Letzte Antwort
    3
    • crunchipC
      crunchipC
      crunchip
      Developer Global Moderator Most Active Forum Testing
      schrieb am zuletzt editiert von crunchip
      #5830

      da ich das ganze Wettergedöns ne zeit lang schleifen lassen und auch nicht in Betrieb hatte, hab ich mich heute mal wieder dran gesetzt.
      nach wie vor verwende ich InfluxDB in V1.x, diesbezüglich habe ich mir ein neues Dashboard erstellt (Feinheiten fehlen allerdings noch).
      wer sichs mal ansehen möchte, json ist angehangen

      image.jpeg

      image.jpeg

      image.jpeg

      Wetterstation-Grafana-Import-fremdinstallation.json
      HINWEIS-Import-fremdinstallation.txt
      HINWEIS-Hintergrund.txt
      wetter-himmel.jpg

      @sborg ggf kann man es ja mit aufnehmen, wenn`s fertig ist

      umgestiegen von Proxmox auf Unraid

      SBorgS 1 Antwort Letzte Antwort
      1
      • crunchipC crunchip

        da ich das ganze Wettergedöns ne zeit lang schleifen lassen und auch nicht in Betrieb hatte, hab ich mich heute mal wieder dran gesetzt.
        nach wie vor verwende ich InfluxDB in V1.x, diesbezüglich habe ich mir ein neues Dashboard erstellt (Feinheiten fehlen allerdings noch).
        wer sichs mal ansehen möchte, json ist angehangen

        image.jpeg

        image.jpeg

        image.jpeg

        Wetterstation-Grafana-Import-fremdinstallation.json
        HINWEIS-Import-fremdinstallation.txt
        HINWEIS-Hintergrund.txt
        wetter-himmel.jpg

        @sborg ggf kann man es ja mit aufnehmen, wenn`s fertig ist

        SBorgS
        SBorgS
        SBorg
        Forum Testing Most Active
        schrieb am zuletzt editiert von
        #5831

        @crunchip Gerne. Da ich nichts logge, habe ich allerdings auch keinerlei Übersicht wie viele noch Influx V1 nutzen.


        Die V3.8.0 steht in den Startlöchern. Die Tests sahen bisher erfolgversprechend aus und ich denke der Haken kann bei Windy API V2 dran. Schlussendlich war das aber mehr "try and error" als echtes entwickeln.
        Die kommt dann die Tage, ich muss noch den Installer anpassen und noch eine Software organisieren, damit ich die neu hinzugekommene Funktion auch wirklich testen kann.
        Was dann (vorerst?) ab dem 01.01.2027 nicht mehr funktionieren wird: eine Station direkt per Skript bei Windy anzumelden. Dies muss man dann auf der HP von windy selbst erledigen. Schau ich mir zwar bei Gelegenheit auch mal an, aber aktuell bin ich von der API erst einmal bedient.

        LG SBorg ( SBorg auf GitHub)
        Projekte: Lebensmittelwarnung.de | WLAN-Wetterstation | PimpMyStation

        1 Antwort Letzte Antwort
        0
        • Chris76eC
          Chris76eC
          Chris76e
          schrieb am zuletzt editiert von Chris76e
          #5832

          @sborg Da hat mich Claude drauf Aufmerksam gemacht, kann das stimmen?

          Ich erkläre es am Ablauf. Das Skript rechnet jede Nacht um 01:13 den Vortag aus und addiert ihn zu den Monatswerten (Regenmenge Monat, Regentage, Min/Max, Durchschnitt). Am 15.10. kommt also der 14.10. dazu.
          
          Am 01.11. passiert aber etwas anderes:
          
          Zuerst speichert es den Oktober ab und setzt die Monatswerte auf null. Zu diesem Zeitpunkt sind darin nur der 1. bis 30.10. enthalten.
          Erst danach rechnet es den Vortag aus, also den 31.10. Der landet zwar im Vortag und damit in der Tagesliste, die die Wetterstatistik-Karte anzeigt.
          Danach steigt das Skript am Monatsersten aber aus, bevor es den Tag zu den Monats- und Jahreswerten addiert.
          
          Die Folge: In jedem Monat fehlt der letzte Tag in den Monatssummen, zum Beispiel beim Regen. Regnet es am 31.10. 10 mm, fehlen die in „Regenmenge Oktober“. Dasselbe gilt für die Jahreswerte wie Regentage, Gradtage und den Jahresdurchschnitt.  Und in der Tagesliste ist der 31. ganz normal drin. So läuft das schon immer im Original-Skript von SBorg, es hat nichts mit der Reparatur zu tun.
          
          Beheben ließe sich das mit einer kleinen Änderung: Am Monatsersten erst den Vortag addieren und dann den Monat speichern. Soll ich das vor dem 01.11. einbauen?
          
          Kannst du mir bitte sagen was du ändern würdest, gebe das erstmal so weiter
          
          Hier ist der Vorschlag zum Weitergeben: 
          vorschlag_monatsletzter.md
          
          Kurz gesagt:
          
          Den Monatsabschluss (speichern und zurücksetzen) ans Ende des Laufs verschieben, statt ihn am Anfang zu machen.
          Das frühe Aussteigen am Monatsersten streichen. Dann wird der Monatsletzte wie jeder andere Tag zu den Monats- und Jahreswerten addiert.
          Die Teiler für den Monats- und den Jahresdurchschnitt vom Vortag ableiten. Sonst würde am 1. der Durchschnitt nur aus einem einzigen Tag bestehen.
          Vor dem Speichern kurz warten, damit die eben geschriebenen Werte sicher drin sind.
          
          Umgesetzt ist noch nichts. Offen ist außerdem, ob die alten Monate, denen jeweils der letzte Tag fehlt, nachträglich korrigiert werden sollen
          
          SBorgS 1 Antwort Letzte Antwort
          0
          • Chris76eC Chris76e

            @sborg Da hat mich Claude drauf Aufmerksam gemacht, kann das stimmen?

            Ich erkläre es am Ablauf. Das Skript rechnet jede Nacht um 01:13 den Vortag aus und addiert ihn zu den Monatswerten (Regenmenge Monat, Regentage, Min/Max, Durchschnitt). Am 15.10. kommt also der 14.10. dazu.
            
            Am 01.11. passiert aber etwas anderes:
            
            Zuerst speichert es den Oktober ab und setzt die Monatswerte auf null. Zu diesem Zeitpunkt sind darin nur der 1. bis 30.10. enthalten.
            Erst danach rechnet es den Vortag aus, also den 31.10. Der landet zwar im Vortag und damit in der Tagesliste, die die Wetterstatistik-Karte anzeigt.
            Danach steigt das Skript am Monatsersten aber aus, bevor es den Tag zu den Monats- und Jahreswerten addiert.
            
            Die Folge: In jedem Monat fehlt der letzte Tag in den Monatssummen, zum Beispiel beim Regen. Regnet es am 31.10. 10 mm, fehlen die in „Regenmenge Oktober“. Dasselbe gilt für die Jahreswerte wie Regentage, Gradtage und den Jahresdurchschnitt.  Und in der Tagesliste ist der 31. ganz normal drin. So läuft das schon immer im Original-Skript von SBorg, es hat nichts mit der Reparatur zu tun.
            
            Beheben ließe sich das mit einer kleinen Änderung: Am Monatsersten erst den Vortag addieren und dann den Monat speichern. Soll ich das vor dem 01.11. einbauen?
            
            Kannst du mir bitte sagen was du ändern würdest, gebe das erstmal so weiter
            
            Hier ist der Vorschlag zum Weitergeben: 
            vorschlag_monatsletzter.md
            
            Kurz gesagt:
            
            Den Monatsabschluss (speichern und zurücksetzen) ans Ende des Laufs verschieben, statt ihn am Anfang zu machen.
            Das frühe Aussteigen am Monatsersten streichen. Dann wird der Monatsletzte wie jeder andere Tag zu den Monats- und Jahreswerten addiert.
            Die Teiler für den Monats- und den Jahresdurchschnitt vom Vortag ableiten. Sonst würde am 1. der Durchschnitt nur aus einem einzigen Tag bestehen.
            Vor dem Speichern kurz warten, damit die eben geschriebenen Werte sicher drin sind.
            
            Umgesetzt ist noch nichts. Offen ist außerdem, ob die alten Monate, denen jeweils der letzte Tag fehlt, nachträglich korrigiert werden sollen
            
            SBorgS
            SBorgS
            SBorg
            Forum Testing Most Active
            schrieb am zuletzt editiert von SBorg
            #5833

            @Chris76e "kann" nicht nur, dass ist völlig korrekt. Nur als Anmerkung (ich erwarte echt nicht, dass jeder den kpl. Thread liest/kennt): das steht schon zig mal hier im Thread, aber ich habe es schon länger nicht mehr erwähnt ^^

            Das Skript entstand Quick&Dirty auf einen Userwunsch (ohne wen zu verdächtigen, aber IMO war das @negalein ). Wirklich gepflegt habe ich es nie, nur bei groben Fehlern (wie letztens nach dem Update des Influx-Adapters) diese beseitigt. Nach den ersten 1-2 Monaten fiel das dann mit den fehlenden Werten am Monatsletzten auf. Daraufhin sah ich dann auch den "Designfehler" (+ wie auch Claude meint). Da ich das Skript aber selbst nicht nutze, habe ich dies auch nie gefixt, da mir immer die Zeit dafür fehlte oder ich es einfach wieder vergaß.
            Aus heutiger Sicht würde ich es auch so nicht mehr lösen. Schlichtweg zu Fehleranfällig, gerade mit dem schreiben/lesen der Datenpunkte oder fehlender Daten wenn es mal nicht laufen sollte. Ich würde mir heute die Daten direkt aus der InfluxDB ziehen.


            Kollege (für die Software der neuen Funktion) hat sich leider nach 10 Tagen noch immer nicht gemeldet. Ich würde die V3.8.0 vorher aber gerne damit testen (oder betreibt jemand ein PWS-Dashboard?). Hatte aber auch schon einen Vorteil: gestern fiel mir Issue #97 auf, den ich dann gleich noch fixen konnte.

            LG SBorg ( SBorg auf GitHub)
            Projekte: Lebensmittelwarnung.de | WLAN-Wetterstation | PimpMyStation

            1 Antwort Letzte Antwort
            0
            • Chris76eC
              Chris76eC
              Chris76e
              schrieb am zuletzt editiert von
              #5834

              Danke dir, @sborg! Ich lasse mir das Skript jetzt von Claude so umbauen, dass die Daten direkt aus InfluxDB kommen. Bis zum Monatswechsel laufen beide Versionen parallel, damit ich vergleichen kann, ob alles passt. Falls Interesse besteht, stelle ich das Skript danach gern hier rein.

              SBorgS 1 Antwort Letzte Antwort
              1
              • M
                M
                MyMeyer
                schrieb am zuletzt editiert von
                #5835

                Hallo , kann mir jemand sagen wieso mein Statistik Script im iob immer abstürtzt ? Hier der Auszug aus dem LOG:

                javascript.0 19:26:54.567 info
                start JavaScript (Javascript/js)
                javascript.0 19:26:54.568 info
                Wetterstation-Statistiken gestartet...
                javascript.0 19:26:54.569 info
                registered 0 subscriptions, 1 schedule, 0 messages, 0 logs and 0 file subscriptions
                javascript.0 19:28:00.015 info
                Auswertung durchgeführt...
                javascript.0 19:28:00.015 warn
                request package is deprecated - please use httpGet (or a stable lib like axios) instead!
                javascript.0 19:28:00.055 error
                Error in callback: TypeError: Reduce of empty array with no initial value
                javascript.0 19:28:00.056 error
                at Array.reduce (<anonymous>)
                javascript.0 19:28:00.056 error
                at Math.sum (script.js.common.Wetter_Statistik:191:53)
                javascript.0 19:28:00.056 error
                at Object.<anonymous> (script.js.common.Wetter_Statistik:192:38)
                javascript.0 19:28:00.056 error
                at Object.cbFunc [as cb] (/opt/iobroker/node_modules/iobroker.javascript/src/lib/sandbox.ts:4251:38)
                javascript.0 19:28:00.056 error
                at change (/opt/iobroker/node_modules/@iobroker/js-controller-adapter/src/lib/adapter/adapter.ts:11135:45)
                javascript.0 19:28:00.056 error
                at Immediate._onImmediate (file:///opt/iobroker/node_modules/@iobroker/db-states-redis/src/lib/states/statesInRedisClient.ts:383:37)
                javascript.0 19:28:00.056 error
                at processImmediate (node:internal/timers:484:21)
                javascript.0 19:28:00.056 error
                at process.callbackTrampoline (node:internal/async_hooks:130:17)
                javascript.0 19:28:00.648 error
                error: TypeError: Cannot read properties of null (reading '0')

                MyMeyer

                Hardware: Intel I5 mit ****Debian ProxMox OS: Debian **** <<< >>> Network with UniFi <<<
                HomeMatic CCU-2 (Wired und Funk) / Philips HUE / Echo.DOT / Echo.SHOW / Xiaomi Smart-Home / Xiaomi Robot Vacuum Cleaner / Synology DS 918+ / Shelly 1&2 <<<

                SBorgS 1 Antwort Letzte Antwort
                0
                • M MyMeyer

                  Hallo , kann mir jemand sagen wieso mein Statistik Script im iob immer abstürtzt ? Hier der Auszug aus dem LOG:

                  javascript.0 19:26:54.567 info
                  start JavaScript (Javascript/js)
                  javascript.0 19:26:54.568 info
                  Wetterstation-Statistiken gestartet...
                  javascript.0 19:26:54.569 info
                  registered 0 subscriptions, 1 schedule, 0 messages, 0 logs and 0 file subscriptions
                  javascript.0 19:28:00.015 info
                  Auswertung durchgeführt...
                  javascript.0 19:28:00.015 warn
                  request package is deprecated - please use httpGet (or a stable lib like axios) instead!
                  javascript.0 19:28:00.055 error
                  Error in callback: TypeError: Reduce of empty array with no initial value
                  javascript.0 19:28:00.056 error
                  at Array.reduce (<anonymous>)
                  javascript.0 19:28:00.056 error
                  at Math.sum (script.js.common.Wetter_Statistik:191:53)
                  javascript.0 19:28:00.056 error
                  at Object.<anonymous> (script.js.common.Wetter_Statistik:192:38)
                  javascript.0 19:28:00.056 error
                  at Object.cbFunc [as cb] (/opt/iobroker/node_modules/iobroker.javascript/src/lib/sandbox.ts:4251:38)
                  javascript.0 19:28:00.056 error
                  at change (/opt/iobroker/node_modules/@iobroker/js-controller-adapter/src/lib/adapter/adapter.ts:11135:45)
                  javascript.0 19:28:00.056 error
                  at Immediate._onImmediate (file:///opt/iobroker/node_modules/@iobroker/db-states-redis/src/lib/states/statesInRedisClient.ts:383:37)
                  javascript.0 19:28:00.056 error
                  at processImmediate (node:internal/timers:484:21)
                  javascript.0 19:28:00.056 error
                  at process.callbackTrampoline (node:internal/async_hooks:130:17)
                  javascript.0 19:28:00.648 error
                  error: TypeError: Cannot read properties of null (reading '0')

                  SBorgS
                  SBorgS
                  SBorg
                  Forum Testing Most Active
                  schrieb am zuletzt editiert von SBorg
                  #5836

                  Hi,
                  Version zu alt ?

                  @MyMeyer sagte:

                  javascript.0 19:26:54.568 info
                  Wetterstation-Statistiken gestartet...
                  ...
                  javascript.0 19:28:00.015 warn
                  request package is deprecated - please use httpGet (or a stable lib like axios) instead!

                  Hier kommt eigentlich schon seit zig Versionen "Wetterstation-Statistiken Vx.x.x gestartet..." und "request" wird auch schon Ewigkeiten nicht mehr benutzt da "deprecated". Ev. ist es jetzt wirklich nicht mehr funktionsfähig, da die Abkündigung IMO auch schon ein paar Jahre alt ist.

                  LG SBorg ( SBorg auf GitHub)
                  Projekte: Lebensmittelwarnung.de | WLAN-Wetterstation | PimpMyStation

                  1 Antwort Letzte Antwort
                  1
                  • Chris76eC Chris76e

                    Danke dir, @sborg! Ich lasse mir das Skript jetzt von Claude so umbauen, dass die Daten direkt aus InfluxDB kommen. Bis zum Monatswechsel laufen beide Versionen parallel, damit ich vergleichen kann, ob alles passt. Falls Interesse besteht, stelle ich das Skript danach gern hier rein.

                    SBorgS
                    SBorgS
                    SBorg
                    Forum Testing Most Active
                    schrieb am zuletzt editiert von
                    #5837

                    @Chris76e sagte:

                    Falls Interesse besteht, stelle ich das Skript danach gern hier rein.

                    Ganz vergessen, von mir aus immer gerne, vielleicht nutze ich es dann auch mal wenn es richtig funktioniert ^^

                    LG SBorg ( SBorg auf GitHub)
                    Projekte: Lebensmittelwarnung.de | WLAN-Wetterstation | PimpMyStation

                    Chris76eC 1 Antwort Letzte Antwort
                    0
                    • SBorgS
                      SBorgS
                      SBorg
                      Forum Testing Most Active
                      schrieb am zuletzt editiert von SBorg
                      #5838

                      Keine Antwort ist auch eine Antwort. Da ich nach über vier Wochen nun nichts mehr gehört habe bzgl. einer Testversion von PWS (erstaunlich für eine kostenlose Software), hier nun die neue Version:

                      Neues Release des Wetterstation WLAN-Skriptes auf GitHub V3.8.0

                      • + Weiterleitung der Wetterdaten (RAW) / Issue #96
                      • ~ Umstellung windy auf API V2 / Issue #87
                      • ~ Fix im Oktober fehlt beim Zeitstempel die "0" (Beispiel 18.1.2026) / Issue #97

                      Wie immer zu finden im GitHub


                      Update-Routine von Vorgängerversion:

                      • aktuellen WS-Updater nutzen

                        wget -O ws_updater.sh https://raw.githubusercontent.com/SBorg2014/WLAN-Wetterstation/master/ws_updater.sh
                      • ./ws_updater.sh im Installationsverzeichnis ausführen
                      • Menüpunkt "4" wählen und die Fragen beantworten

                      Update kann durchgeführt werden, neue Funktion und Bugfix (Fehler tritt aber erst wieder 10/2027 auf).
                      Update muss durchgeführt werden wenn man "windy" nutzt (neue API V2 ab 01.01.2027).


                      Windy-Nutzer müssen ihre Zugangsdaten neu in der wetterstation.conf eintragen, da man sich nun mittels einer individuellen Stationskennung und Passwort authentifizieren muss.
                      Dazu unter https://stations.windy.com/stations (Link steht nochmals in der "conf") einloggen, Station auswählen und bis "Connection" runter scrollen. Dort kann man sich dann beides in die Zwischenablage kopieren und entsprechend in die "conf" einfügen (natürlich nacheinander 😉 ).

                      Da die neue API nun auch die Sonneneinstrahlung unterstützt, wird diese nun ebenfalls übertragen:
                      Windy.png


                      Neues Feature Datenpaket RAW:
                      Es ist nun möglich das Datenpaket der Wetterstation (RAW=so wie es die Station liefert) weiterzuleiten oder selbst damit noch etwas anzustellen.
                      Als Beispiel ist eine Weiterleitung an ein PWS-Dashboard dabei. Es muss im Installationsverzeichnis lediglich eine Datei wetterdata_forward.sh existieren. Diese wird dann bei jedem empfangenen Paket ausgeführt. Aber Vorsicht, wird sind hier auf Betriebssystemebene. Soll heißen, das Wetterskript wird verlassen und das neue Skript gestartet und ausgeführt. Führt dies nun ins "Nirwana", wird das Wetterskript auch nicht mehr fortgesetzt! Wird das neue Skript korrekt beendet, wird auch das Wetterskript fortgesetzt.
                      So könnte man sich bspw. eine kleine Anzeige mit einem E Ink-Display und Akku für die Messwerte des Gewächshauses realisieren, ganz "out-of-the-box" ohne den ioB, Skripte etc.pp. nutzen zu müssen.
                      Anstelle der Weiterleitung an ein PWS-Dashboard kann man das Datenpaket auch an andere Empfänger schicken, solange die das WU-Protokoll verstehen.

                      LG SBorg ( SBorg auf GitHub)
                      Projekte: Lebensmittelwarnung.de | WLAN-Wetterstation | PimpMyStation

                      1 Antwort Letzte Antwort
                      1
                      • SBorgS SBorg

                        @Chris76e sagte:

                        Falls Interesse besteht, stelle ich das Skript danach gern hier rein.

                        Ganz vergessen, von mir aus immer gerne, vielleicht nutze ich es dann auch mal wenn es richtig funktioniert ^^

                        Chris76eC
                        Chris76eC
                        Chris76e
                        schrieb am zuletzt editiert von Chris76e
                        #5839

                        @SBorg

                        @SBorg wie versprochen, hier das Skript. Der Monatswechsel ist durch, beide Versionen sind parallel gelaufen und die Werte passen. Seit Anfang November läuft bei mir nur noch die neue Version, bisher ohne Probleme.

                        Kurz zur Erinnerung, warum ich umgebaut habe: Weil dein Skript die Werte jede Nacht weiterzählt, haben sich bei mir kleine Fehler aufsummiert. Der Monatsletzte fehlte in den Monats- und Jahreswerten, die Trockenperiode stand das ganze Jahr auf 0, und fiel ein Lauf aus (z. B. nach einem Update des influxdb-Adapters), fehlte der Tag einfach. Deshalb rechnet die neue Version, wie von dir vorgeschlagen, alles direkt aus der InfluxDB (mit KI-Unterstützung umgebaut).

                        Was macht das Skript?
                        Es rechnet jede Nacht die komplette Statistik neu aus den Messwerten in der InfluxDB. Dabei entsteht ein Tagesarchiv (ein Eintrag je Tag: Tiefst-, Höchst- und Durchschnittstemperatur, Böe, Regen, Tropennacht, Sonne, Solarenergie). Nachts werden nur die letzten 3 Tage aus Influx nachgeholt (dauert unter 1 Sekunde), alles andere wird aus dem Archiv gerechnet.

                        Die Datenpunkt-Struktur ist dieselbe wie bei deinem Skript (VorTag, aktueller_Monat, Vorjahres_Monat, Jahreswerte, Jahreswerte.VorJahre.<Jahr>, Data.<Jahr>.<Monat>, Rekordwerte), d. h. VIS-Widgets, Tabellen oder Home-Assistant-Anbindungen laufen ohne Änderung weiter.

                        Unterschiede zum Original
                        Kein Weiterzählen über Nacht: Fehlt ein Lauf, holt der nächste ihn automatisch nach. Fehler können sich nicht mehr aufsummieren.
                        Der Monatsletzte zählt mit.
                        Tropennacht nach DWD: Nacht von 18 bis 06 Uhr nicht unter 20 °C (zählt zum Tag des Morgens). Das Original zählt Tage mit Tiefstwert ≥ 20 °C, das ergibt deutlich weniger Tropennächte.
                        Trockenperiode = längste Folge von Tagen ohne Regentag (< 0,1 l/m²), auch über den Jahreswechsel.
                        Monats-/Jahresdurchschnitt = Mittel der Tagesmittel.
                        Neu: Tagestabellen je Monat unter …Statistik.Wetter.Tage.<Jahr>.<Monat> (JSON, ein Eintrag je Tag mit Tiefst-/Höchst-/Ø-Temperatur, Böe, Regen, Sonnenscheindauer in Minuten, Sonnenenergie Wh/m²). Damit braucht man kein extra Skript zum Sammeln der Tageswerte mehr.
                        Neu: Knopf Control.Neu_berechnen: lädt das Archiv komplett neu aus Influx.
                        Neu: Jahreswerte.Regensumme_Tage (Summe der Tagesregenmengen im laufenden Jahr, als Vergleichswert).
                        Weggefallen: Update-Check, AutoDelete/Reset-Schalter und das einstellbare Rekordwerte-Format (fest "41.6 °C im Juni 2025"). Die alten Control.*-Datenpunkte bleiben einfach unbenutzt stehen.
                        Kenntage wie gehabt: warm > 20, Sommertag ≥ 25, heiß ≥ 30, Wüste ≥ 35 (Höchstwert), kalt < 10, Eistag < 0 (Höchstwert), Frost < 0, sehr kalt < -10 (Tiefstwert), Regentag ≥ 0,1 l/m².
                        Voraussetzungen
                        WLAN-Wetterstation mit Standard-Datenstruktur
                        javascript-Adapter
                        influxdb-Adapter mit InfluxDB V2 (Flux-Abfragen). Bei mir getestet mit influxdb-Adapter 5.1.6.
                        Logging in InfluxDB für Aussentemperatur, Wind_max, Regen_Tag und optional Info.Sonnenschein_Tag, Info.Solarenergie_Tag, ohne Alias (das Measurement muss die Datenpunkt-ID sein, wie beim Original)
                        Einrichtung
                        Altes Statistik-Skript ausschalten (nicht löschen, falls man zurück will). Beide gleichzeitig laufen lassen geht nicht, weil sie in dieselben Datenpunkte schreiben.
                        Am besten vorher die Datenpunkte unter 0_userdata.0.Statistik.Wetter sichern (z. B. Objekte exportieren).
                        Neues JavaScript anlegen, Skript einfügen und oben die User-Einstellungen anpassen:
                        WET_DP: wo die Wetterstation-Datenpunkte liegen (wie im Wetterstation-Skript, Standard 0_userdata.0.Wetterstation)
                        INFLUX / BUCKET: Instanz und Bucket
                        ZIEL_DP: wohin die Statistik geschrieben wird (wie PRE_DP beim Original)
                        INFLUX_START: erster Tag mit Daten in der InfluxDB (JJJJ-MM-TT). Wichtig, weil alle Monate/Jahre davor nicht aus Influx kommen können: die alten Werte (Data.<Jahr>.<Monat> und Jahreswerte.VorJahre.<Jahr>) aus der Zeit vorher werden aus der vorhandenen Statistik übernommen.
                        MIT_SONNE: auf false, wenn Sonnenschein/Solarenergie nicht geloggt werden
                        Skript starten. Beim ersten Start wird das Tagesarchiv Monat für Monat mit 5 s Pause aus Influx geladen. Bei mir dauert das für rund 4,5 Jahre ca. 5 bis 6 Minuten. Den Fortschritt sieht man in Control.Statusmeldung, am Ende steht dort z. B. "erfolgreich: 1642 Tage 2022-05-04 bis 2026-10-31, 312 s".
                        Danach läuft es jede Nacht um 01:20 Uhr (einstellbar über ZEITPLAN).
                        Hinweise
                        Kleine Influx-Server: Bitte die Pause (PAUSE_MS) nicht auf 0 setzen. Mein erster Versuch hat die ganze Historie auf einmal abgefragt und den InfluxDB-Container (1 Kern, 2 GB) komplett lahmgelegt. Monatsweise mit Pause ist kein Problem, eine Monatsabfrage dauert 0,1 bis 0,3 s.
                        Rekordwerte zählen nur ab Beginn der Influx-Daten.
                        Der angefangene erste Monat (bei mir Mai 2022) wird nicht als Data.<Jahr>.<Monat> neu berechnet, dort bleibt der alte Wert stehen.
                        Durch die Neuberechnung können sich alte Werte leicht ändern (z. B. Regensummen um ein paar Hundertstel, Durchschnitt um bis zu 0,2 °C, Tropennächte nach DWD-Regel, fehlende Monatsletzte). Das ist gewollt, die neuen Werte passen jetzt zu den Rohdaten.
                        Zurück zum Original: neues Skript aus, altes wieder an, ggf. gesicherte Datenpunkte zurückspielen.
                        Nochmals danke für die Wetterstation und die Vorlage! Über Rückmeldungen, gerade von dir, freue ich mich.

                        /* Wetterstatistik direkt aus InfluxDB (für das WLAN-Wetterstation-Projekt von SBorg)
                         
                           Berechnet jede Nacht die komplette Wetterstatistik neu aus den in InfluxDB V2 geloggten Messwerten:
                           Vortag, aktueller Monat, Vorjahresmonat, Jahreswerte, Vorjahre, Monatsdaten (Data.<Jahr>.<Monat>),
                           Rekordwerte und Tagestabellen (Tage.<Jahr>.<Monat>).
                           Datenpunkt-Struktur wie im Statistik-Skript von SBorg (Wetterstation-Statistiken V2.0.x), damit
                           vorhandene Auswertungen (VIS, Home Assistant, Tabellen) weiter funktionieren.
                         
                           Idee und Datenstruktur: SBorg (https://github.com/SBorg2014/WLAN-Wetterstation) – vielen Dank!
                           Umbau "alles aus Influx neu rechnen": Chris76e (mit KI-Unterstützung)
                         
                           Unterschied zum Original:
                           - Kein Hochzählen über Nacht: fehlt ein Lauf, holt der nächste die letzten Tage nach; alles wird aus einem
                             Tagesarchiv (Control.Tagesarchiv) neu gerechnet. Monatsletzter zählt korrekt mit.
                           - Tropennacht nach DWD (Nacht 18–06 Uhr nicht unter 20 °C, zählt zum Tag des Morgens).
                           - Trockenperiode = längste Folge von Tagen ohne Regentag (< 0,1 l/m²), auch über den Jahreswechsel.
                           - Durchschnitt Monat/Jahr = Mittel der Tagesmittel.
                           - Zusätzlich Tagestabellen je Monat (Tiefst-/Höchst-/Ø-Temperatur, Böe, Regen, Sonnenscheindauer, Sonnenenergie).
                           - Knopf Control.Neu_berechnen: Tagesarchiv komplett neu aus Influx laden (Monat für Monat mit Pause).
                         
                           Kenntage: Sommertag >= 25, heißer Tag >= 30, Wüstentag >= 35, warmer Tag > 20 (Höchstwert);
                           kalter Tag Höchstwert < 10, Eistag Höchstwert < 0; Frosttag Tiefstwert < 0, sehr kalter Tag Tiefstwert < -10;
                           Regentag >= 0,1 l/m².
                         
                           Voraussetzungen: ioBroker javascript-Adapter, influxdb-Adapter mit InfluxDB V2 (Flux), Logging der
                           Datenpunkte Aussentemperatur, Wind_max, Regen_Tag (optional Info.Sonnenschein_Tag, Info.Solarenergie_Tag)
                           OHNE Alias (Measurement = Datenpunkt-ID). Getestet mit influxdb-Adapter 5.1.6.
                         
                           Wichtig: Das alte Statistik-Skript vorher ausschalten (nicht beide gleichzeitig laufen lassen).
                         
                           Version 1.4.1 (11/2026) – 1.4.1: vorhandene Datenpunkte mit anderem Typ (json/object) werden auf "string" korrigiert
                                                       (Warnung "You are assigning a string to the state ... which expects a object")
                        */
                         
                        // *** User-Einstellungen ***********************************************************************************
                        const WET_DP = '0_userdata.0.Wetterstation';           // wo liegen die Datenpunkte der Wetterstation (wie im Wetterstation-Skript) [default: 0_userdata.0.Wetterstation]
                        const INFLUX = 'influxdb.0';                           // Instanz des influxdb-Adapters
                        const BUCKET = 'iobroker';                             // Name des Buckets
                        const ZIEL_DP = '0_userdata.0.Statistik.Wetter';       // wohin die Statistik geschrieben wird (wie PRE_DP im SBorg-Skript)
                        const ALT_DP = ZIEL_DP;                                // Monate/Jahre VOR Beginn der Influx-Daten werden von hier übernommen (alte Statistik), sonst leer
                        const TAGE_DP = ZIEL_DP + '.Tage';                     // Tagestabellen <Jahr>.<Monat>
                        const INFLUX_START = '2022-05-04';                     // erster Tag mit Daten in InfluxDB (JJJJ-MM-TT) – unbedingt anpassen!
                        const MIT_SONNE = true;                                // false, wenn Info.Sonnenschein_Tag / Info.Solarenergie_Tag nicht geloggt werden
                        const ZEITZONE = 'Europe/Berlin';                      // für die Tagesgrenzen in Influx
                        const ZEITPLAN = '20 1 * * *';                         // wann rechnen (Minute Stunde * * *) [default 01:20 Uhr]
                        const NACHHOLEN_TAGE = 3;                              // jede Nacht die letzten x Tage neu aus Influx holen
                        const PAUSE_MS = 5000;                                 // Pause zwischen den Monaten beim kompletten Neuladen (schont kleine Influx-Server)
                        const NACHT_MIN_STUNDEN = 9;                           // so viele Stundenwerte (von 12) braucht eine Nacht für die Tropennacht-Prüfung
                        // *** ENDE User-Einstellungen – ab hier nichts mehr ändern **************************************************
                         
                        const VERSION = '1.4.1';
                        const START_TEILE = INFLUX_START.split('-').map(Number);
                        const INFLUX_START_DATUM = new Date(START_TEILE[0], START_TEILE[1] - 1, START_TEILE[2]);
                        // erster vollständiger Monat/Jahr mit Influx-Daten; davor wird aus ALT_DP übernommen
                        const ERSTER_INFLUX_MONAT = (() => { const d = new Date(START_TEILE[0], START_TEILE[1] - 1 + (START_TEILE[2] > 1 ? 1 : 0), 1);
                            return d.getFullYear() + '.' + (d.getMonth() < 9 ? '0' : '') + (d.getMonth() + 1); })();
                        const ERSTES_INFLUX_JAHR = (START_TEILE[1] === 1 && START_TEILE[2] === 1) ? START_TEILE[0] : START_TEILE[0] + 1;
                         
                        const MONATSNAME = ['Januar','Februar','März','April','Mai','Juni','Juli','August','September','Oktober','November','Dezember'];
                        const pad = n => (n < 10 ? '0' : '') + n;
                        const tagKey = d => d.getFullYear() + '-' + pad(d.getMonth() + 1) + '-' + pad(d.getDate());
                        const monatKey = d => d.getFullYear() + '.' + pad(d.getMonth() + 1);
                        const r2 = x => Math.round(x * 100) / 100;
                         
                        let laeuft = false;
                         
                        function abfrage(flux) {
                            return new Promise((resolve, reject) => {
                                sendTo(INFLUX, 'query', flux, { timeout: 60000 }, res => {
                                    if (!res || res.error) { reject(new Error(res ? String(res.error) : 'keine Antwort von ' + INFLUX)); return; }
                                    const zeilen = Array.isArray(res.result) && Array.isArray(res.result[0]) ? res.result[0] : (res.result || []);
                                    resolve(zeilen);
                                });
                            });
                        }
                         
                        function flux(messwert, every, fn, start, stop, offset) {
                            return 'from(bucket: "' + BUCKET + '") |> range(start: ' + Math.floor(start / 1000) + ', stop: ' + Math.floor(stop / 1000) + ')'
                                + ' |> filter(fn: (r) => r._measurement == "' + WET_DP + '.' + messwert + '" and r._field == "value")'
                                + ' |> aggregateWindow(every: ' + every + ', fn: ' + fn + (offset ? ', offset: ' + offset : '')
                                + ', createEmpty: false, timeSrc: "_start", location: {zone: "' + ZEITZONE + '", offset: 0s})'
                                + ' |> keep(columns: ["_time", "_value"])';
                        }
                         
                        const zeit = z => (typeof z.ts === 'number' ? z.ts : Date.parse(z._time));
                         
                        // Tageswerte für einen Zeitraum aus Influx (lokale Kalendertage): { 'JJJJ-MM-TT': [tmin, tmax, tmit, wind, regen, tropennacht 0/1, sonne s, solar Wh/m²] }
                        // Abfragen nacheinander und nur für kurze Zeiträume (die ganze Historie auf einmal kann einen kleinen Influx-Server überlasten)
                        async function bereichHolen(start, stop) {
                            const tmin = await abfrage(flux('Aussentemperatur', '1d', 'min', start, stop));
                            const tmax = await abfrage(flux('Aussentemperatur', '1d', 'max', start, stop));
                            const tmit = await abfrage(flux('Aussentemperatur', '1d', 'mean', start, stop));
                            const wind = await abfrage(flux('Wind_max', '1d', 'max', start, stop));
                            // Regen +72 s: der Tageszähler der Station springt erst kurz nach Mitternacht auf 0 (wie im SBorg-Skript). Auch der Bereich beginnt 72 s später,
                            // sonst landet der alte Vortageswert von 00:00 im ersten (abgeschnittenen) Fenster
                            const regen = await abfrage(flux('Regen_Tag', '1d', 'max', start + 72000, stop, '72s'));
                            const stunden = await abfrage(flux('Aussentemperatur', '1h', 'min', start - 6 * 3600000, stop));
                            // Tageszähler Sonnenschein (Sekunden) und Solarenergie (Wh/m²): wie Regen mit 72 s Versatz. Bewusst nicht Info.*_VorTag:
                            // der wird um 23:58 geloggt und ist manchmal noch der Wert vom Tag davor oder 0
                            const sonne = MIT_SONNE ? await abfrage(flux('Info.Sonnenschein_Tag', '1d', 'max', start + 72000, stop, '72s')) : [];
                            const solar = MIT_SONNE ? await abfrage(flux('Info.Solarenergie_Tag', '1d', 'max', start + 72000, stop, '72s')) : [];
                            const tage = {};
                            const tag = z => { const k = tagKey(new Date(zeit(z))); if (!tage[k]) tage[k] = {}; return tage[k]; };
                            tmin.forEach(z => { if (typeof z._value === 'number') tag(z).tmin = z._value; });
                            tmax.forEach(z => { if (typeof z._value === 'number') tag(z).tmax = z._value; });
                            tmit.forEach(z => { if (typeof z._value === 'number') tag(z).tmit = r2(z._value); });
                            const zusatz = {};
                            const merke = (liste, feld) => liste.forEach(z => {
                                if (typeof z._value !== 'number') return;
                                const k = tagKey(new Date(zeit(z)));
                                if (!zusatz[k]) zusatz[k] = {};
                                zusatz[k][feld] = Math.max(zusatz[k][feld] || 0, z._value);
                            });
                            merke(wind, 'wind');
                            merke(regen, 'regen');
                            merke(sonne, 'sonne');
                            merke(solar, 'solar');
                            // Nacht 18–06 Uhr: Stundenminima ab 18 Uhr zählen zum nächsten Tag (Morgen)
                            const naechte = {};
                            stunden.forEach(z => {
                                if (typeof z._value !== 'number') return;
                                const d = new Date(zeit(z)), h = d.getHours();
                                let morgen;
                                if (h >= 18) morgen = new Date(d.getFullYear(), d.getMonth(), d.getDate() + 1);
                                else if (h < 6) morgen = d;
                                else return;
                                const k = tagKey(morgen);
                                if (!naechte[k]) naechte[k] = { min: 99, n: 0 };
                                naechte[k].min = Math.min(naechte[k].min, z._value);
                                naechte[k].n++;
                            });
                            const erg = {};
                            Object.keys(tage).forEach(k => {
                                const t = tage[k];
                                if (typeof t.tmin !== 'number' || typeof t.tmax !== 'number' || typeof t.tmit !== 'number') return;
                                const [j, m, d] = k.split('-').map(Number);
                                const datum = new Date(j, m - 1, d).getTime();
                                if (datum < start || datum >= stop) return;
                                const z = zusatz[k] || {};
                                const n = naechte[k];
                                erg[k] = [t.tmin, t.tmax, t.tmit, z.wind || 0, z.regen || 0, (n && n.n >= NACHT_MIN_STUNDEN && n.min >= 20) ? 1 : 0, z.sonne || 0, z.solar || 0];
                            });
                            return erg;
                        }
                         
                        const pause = ms => new Promise(r => setTimeout(r, ms));
                         
                        // Tagesarchiv (Control.Tagesarchiv): wird beim ersten Start bzw. per Neu_berechnen monatsweise gefüllt,
                        // danach jede Nacht nur um die letzten Tage ergänzt (die letzten NACHHOLEN_TAGE werden neu geholt).
                        async function archivAktualisieren(heute, komplett) {
                            const id = ZIEL_DP + '.Control.Tagesarchiv';
                            let archiv = {};
                            if (!komplett && existsState(id)) { try { archiv = JSON.parse(getState(id).val || '{}'); } catch (e) { archiv = {}; } }
                            if (Object.keys(archiv).some(k => archiv[k].length < 8)) archiv = {};   // altes Archivformat (ohne Sonne/Solar) → neu laden
                            const stop = heute.getTime();
                            if (!Object.keys(archiv).length) {
                                // Nachladen Monat für Monat, mit Pause dazwischen
                                let von = new Date(INFLUX_START_DATUM.getFullYear(), INFLUX_START_DATUM.getMonth(), 1);
                                while (von.getTime() < stop) {
                                    const bis = new Date(von.getFullYear(), von.getMonth() + 1, 1);
                                    await schreibe('Control.Statusmeldung', 'lade Historie ' + monatKey(von) + ' …', S('Statusmeldungen'));
                                    Object.assign(archiv, await bereichHolen(von.getTime(), Math.min(bis.getTime(), stop)));
                                    von = bis;
                                    await pause(PAUSE_MS);
                                }
                            } else {
                                const von = new Date(heute.getFullYear(), heute.getMonth(), heute.getDate() - NACHHOLEN_TAGE);
                                Object.assign(archiv, await bereichHolen(von.getTime(), stop));
                            }
                            const sortiert = {};
                            Object.keys(archiv).sort().forEach(k => { sortiert[k] = archiv[k]; });
                            await schreibe('Control.Tagesarchiv', JSON.stringify(sortiert), S('Tageswerte aus InfluxDB [tmin, tmax, tmit, wind, regen, tropennacht, sonne s, solar Wh/m²]', 'json'));
                            return Object.keys(sortiert).filter(k => new Date(k + 'T00:00:00').getTime() < stop).map(k => {
                                const [j, m, d] = k.split('-').map(Number);
                                const datum = new Date(j, m - 1, d), a = sortiert[k];
                                return { key: k, datum: datum, monat: monatKey(datum), jahr: j, tmin: a[0], tmax: a[1], tmit: a[2], wind: a[3], regen: a[4], tropennacht: a[5] === 1, sonne: a[6], solar: a[7] };
                            });
                        }
                         
                        // Kenntage und Extremwerte über eine Liste von Tagen
                        function auswerten(tage) {
                            if (!tage.length) return null;
                            const a = {
                                Tiefstwert: Math.min(...tage.map(t => t.tmin)),
                                Hoechstwert: Math.max(...tage.map(t => t.tmax)),
                                Temp_Durchschnitt: r2(tage.reduce((s, t) => s + t.tmit, 0) / tage.length),
                                Max_Windboee: Math.max(...tage.map(t => t.wind)),
                                Max_Regenmenge: Math.max(...tage.map(t => t.regen)),
                                Regenmenge_Monat: r2(tage.reduce((s, t) => s + t.regen, 0)),
                                warme_Tage: 0, Sommertage: 0, heisse_Tage: 0, Frost_Tage: 0, kalte_Tage: 0, Eistage: 0,
                                sehr_kalte_Tage: 0, Wuestentage: 0, Tropennaechte: 0, Regentage: 0
                            };
                            tage.forEach(t => {
                                if (t.tmax > 20) a.warme_Tage++;
                                if (t.tmax >= 25) a.Sommertage++;
                                if (t.tmax >= 30) a.heisse_Tage++;
                                if (t.tmin < 0) a.Frost_Tage++;
                                if (t.tmax < 10) a.kalte_Tage++;
                                if (t.tmax < 0) a.Eistage++;
                                if (t.tmin < -10) a.sehr_kalte_Tage++;
                                if (t.tmax >= 35) a.Wuestentage++;
                                if (t.tropennacht) a.Tropennaechte++;
                                if (t.regen >= 0.1) a.Regentage++;
                            });
                            return a;
                        }
                         
                        // Trockenperioden: für jeden Tag die Länge der laufenden Folge ohne Regentag (Folge darf über den Jahreswechsel gehen)
                        function trockenFolgen(alleTage) {
                            let lauf = 0, vorher = null;
                            alleTage.forEach(t => {
                                if (vorher && (t.datum - vorher.datum) > 26 * 3600000) lauf = 0;   // Datenlücke unterbricht
                                lauf = t.regen >= 0.1 ? 0 : lauf + 1;
                                t.trocken = lauf;
                                vorher = t;
                            });
                        }
                         
                        function rekordText(wert, einheit, datum) {
                            if (einheit === 'Tage' && wert === 1) einheit = 'Tag';
                            return wert + ' ' + einheit + ' im ' + MONATSNAME[datum.getMonth()] + ' ' + datum.getFullYear();
                        }
                         
                        // Datenpunkt anlegen/schreiben, nur bei Änderung
                        async function schreibe(id, wert, common) {
                            await schreibeVoll(ZIEL_DP + '.' + id, wert, common);
                        }
                         
                        // wie schreibe(), aber mit voller ID (auch für die Tagestabellen).
                        // Hat ein vorhandener Datenpunkt einen anderen Typ (z. B. "json"/"object" statt "string"), wird nur der Typ
                        // im Objekt korrigiert – Wert und Historie bleiben, nichts muss gelöscht werden (1.4.1)
                        async function schreibeVoll(voll, wert, common) {
                            if (!existsState(voll)) {
                                await createStateAsync(voll, wert, Object.assign({ read: true, write: false }, common));
                                await setStateAsync(voll, wert, true);
                                return;
                            }
                            const obj = getObject(voll);
                            if (obj && obj.common && common.type && obj.common.type !== common.type) {
                                log('Statistik_aus_Influx: Typ von ' + voll + ' korrigiert: ' + obj.common.type + ' -> ' + common.type, 'info');
                                await extendObjectAsync(voll, { common: { type: common.type, role: common.role } });
                            }
                            const s = getState(voll);
                            if (!s || s.val !== wert) await setStateAsync(voll, wert, true);
                        }
                         
                        // alte Werte können als Objekt statt als Text gespeichert sein → immer als JSON-Text weitergeben
                        const alsText = v => (typeof v === 'string' ? v : JSON.stringify(v));
                         
                        const N = (name, unit) => ({ name: name, type: 'number', role: 'value', unit: unit });
                        const S = (name, role) => ({ name: name, type: 'string', role: role || 'text' });
                         
                        const MONATSFELDER = [
                            ['Tiefstwert', 'niedrigste Temperatur', '°C'], ['Hoechstwert', 'höchste Temperatur', '°C'],
                            ['Temperatur_Durchschnitt', 'Durchschnittstemperatur', '°C', 'Temp_Durchschnitt'],
                            ['Max_Windboee', 'stärkste Windböe', 'km/h'], ['Max_Regenmenge', 'maximale Regenmenge pro Tag', 'l/m²'],
                            ['Regenmenge_Monat', 'Regenmenge im Monat', 'l/m²'],
                            ['warme_Tage', 'Tage mit Höchstwert über 20 °C', 'Tage'], ['Sommertage', 'Tage mit Höchstwert ab 25 °C', 'Tage'],
                            ['heisse_Tage', 'Tage mit Höchstwert ab 30 °C', 'Tage'], ['Frost_Tage', 'Tage mit Tiefstwert unter 0 °C', 'Tage'],
                            ['kalte_Tage', 'Tage mit Höchstwert unter 10 °C', 'Tage'], ['Eistage', 'Tage mit Höchstwert unter 0 °C', 'Tage'],
                            ['sehr_kalte_Tage', 'Tage mit Tiefstwert unter -10 °C', 'Tage'], ['Wuestentage', 'Tage mit Höchstwert ab 35 °C', 'Tage'],
                            ['Tropennaechte', 'Nächte (18–06 Uhr) nicht unter 20 °C', 'Tage'], ['Regentage', 'Tage mit mindestens 0,1 l/m²', 'Tage']
                        ];
                         
                        // gleiche Feldreihenfolge wie SBorg in Data.<Jahr>.<Monat>
                        function monatsJson(a) {
                            return JSON.stringify([{
                                Tiefstwert: a.Tiefstwert, Hoechstwert: a.Hoechstwert, Temp_Durchschnitt: a.Temp_Durchschnitt, Max_Windboee: a.Max_Windboee,
                                Max_Regenmenge: a.Max_Regenmenge, Regenmenge_Monat: a.Regenmenge_Monat, warme_Tage: a.warme_Tage, Sommertage: a.Sommertage,
                                heisse_Tage: a.heisse_Tage, Frost_Tage: a.Frost_Tage, kalte_Tage: a.kalte_Tage, Eistage: a.Eistage, sehr_kalte_Tage: a.sehr_kalte_Tage,
                                Wuestentage: a.Wuestentage, Tropennaechte: a.Tropennaechte, Regentage: a.Regentage
                            }]);
                        }
                         
                        async function main(komplett) {
                            if (laeuft) return;
                            laeuft = true;
                            const beginn = Date.now();
                            try {
                                const jetzt = new Date();
                                const heute = new Date(jetzt.getFullYear(), jetzt.getMonth(), jetzt.getDate());
                                const gestern = new Date(heute.getFullYear(), heute.getMonth(), heute.getDate() - 1);
                                const J = heute.getFullYear(), aktMonat = monatKey(heute);
                         
                                const alleTage = await archivAktualisieren(heute, komplett === true);
                                if (!alleTage.length) throw new Error('keine Tageswerte aus InfluxDB');
                                trockenFolgen(alleTage);
                         
                                // Monate
                                const proMonat = {};
                                alleTage.forEach(t => { (proMonat[t.monat] = proMonat[t.monat] || []).push(t); });
                                const monate = {};   // Monatskey -> Auswertung (abgeschlossene Monate)
                                Object.keys(proMonat).forEach(m => { if (m >= ERSTER_INFLUX_MONAT && m < aktMonat) monate[m] = auswerten(proMonat[m]); });
                         
                                // Data.<Jahr>.<Monat>: vor Influx aus ALT_DP übernehmen
                                const dataJson = {};
                                $(ALT_DP + '.Data.*').each(id => {
                                    const m = id.substring((ALT_DP + '.Data.').length);
                                    if (/^\d{4}\.\d{2}$/.test(m) && m < ERSTER_INFLUX_MONAT) { const s = getState(id); if (s && s.val) dataJson[m] = alsText(s.val); }
                                });
                                Object.keys(monate).forEach(m => { dataJson[m] = monatsJson(monate[m]); });
                                for (const m of Object.keys(dataJson).sort()) {
                                    const [j, mm] = m.split('.');
                                    await schreibe('Data.' + m, dataJson[m], S('Monatsstatistik für ' + MONATSNAME[Number(mm) - 1] + ' ' + j, 'json'));
                                }
                         
                                // Tagestabellen (ein Eintrag je Tag, Sonnenscheindauer in Minuten)
                                for (const m of Object.keys(proMonat).sort()) {
                                    const [j, mm] = m.split('.');
                                    if (m < ERSTER_INFLUX_MONAT && existsState(TAGE_DP + '.' + j + '.' + mm)) continue;   // angefangenen ersten Monat nicht überschreiben, falls schon eine Tabelle da ist
                                    const text = '[' + proMonat[m].map(t => JSON.stringify({
                                        Tiefstwert: t.tmin, Hoechstwert: t.tmax, Durchschnitt: t.tmit, Max_Windboee: t.wind,
                                        Regenmenge_Tag: t.regen, Sonnenscheindauer: Math.floor(t.sonne / 60), SonnenEnergie: t.solar })).join(', ') + ']';
                                    await schreibeVoll(TAGE_DP + '.' + j + '.' + mm, text, S('Tageswerte ' + MONATSNAME[Number(mm) - 1] + ' ' + j, 'json'));
                                }
                         
                                // VorTag
                                const vt = alleTage[alleTage.length - 1];
                                if (vt.key !== tagKey(gestern)) log('Statistik_aus_Influx: keine Daten für gestern, letzter Tag ' + vt.key, 'warn');
                                await schreibe('VorTag.Temperatur_Tiefstwert', vt.tmin, N('niedrigste Tagestemperatur', '°C'));
                                await schreibe('VorTag.Temperatur_Hoechstwert', vt.tmax, N('höchste Tagestemperatur', '°C'));
                                await schreibe('VorTag.Temperatur_Durchschnitt', vt.tmit, N('Durchschnittstemperatur', '°C'));
                                await schreibe('VorTag.Regenmenge', vt.regen, N('Regenmenge vom Vortag', 'l/m²'));
                                await schreibe('VorTag.Windboee_max', vt.wind, N('stärkste Windböe vom Vortag', 'km/h'));
                         
                                // aktueller Monat (Tage bis gestern); am Monatsersten wie im Original: aktuelle Temperatur, Rest 0
                                let am = auswerten(proMonat[aktMonat] || []);
                                if (!am) {
                                    const t0 = getState(WET_DP + '.Aussentemperatur').val;
                                    am = auswerten([{ tmin: t0, tmax: t0, tmit: t0, wind: 0, regen: 0, tropennacht: false }]);
                                    MONATSFELDER.forEach(f => { if (f[2] === 'Tage') am[f[0]] = 0; });
                                }
                                for (const f of MONATSFELDER) await schreibe('aktueller_Monat.' + f[0], am[f[3] || f[0]], N(f[1], f[2]));
                         
                                // Vorjahresmonat
                                const vjKey = (J - 1) + '.' + pad(heute.getMonth() + 1);
                                let vj = null;
                                if (dataJson[vjKey]) { try { vj = JSON.parse(dataJson[vjKey])[0]; } catch (e) { vj = null; } }
                                for (const f of MONATSFELDER) {
                                    const w = vj && typeof vj[f[3] || f[0]] === 'number' ? vj[f[3] || f[0]] : 99999;
                                    await schreibe('Vorjahres_Monat.' + f[0], w, N(f[1], f[2]));
                                }
                         
                                // Jahreswerte
                                const jahrWerte = jahr => {
                                    const tage = alleTage.filter(t => t.jahr === jahr);
                                    const a = auswerten(tage);
                                    if (!a) return null;
                                    a.Trockenperiode = Math.max(0, ...tage.map(t => t.trocken));
                                    const mon = Object.keys(monate).filter(m => m.startsWith(jahr + '.')).map(m => monate[m].Regenmenge_Monat);
                                    a.Regenmengemonat = mon.length ? Math.max(...mon) : 0;
                                    return a;
                                };
                                let jw = jahrWerte(J);
                                if (!jw) jw = { Tiefstwert: 100, Hoechstwert: -100, Temp_Durchschnitt: 0, Trockenperiode: 0, Max_Regenmenge: 0, Regenmengemonat: 0,
                                                Max_Windboee: 0, Regenmenge_Monat: 0 };
                                const T = 'Tage';
                                const JF = [
                                    ['Temperatur_Hoechstwert', jw.Hoechstwert, 'höchste Tagestemperatur des Jahres', '°C'],
                                    ['Temperatur_Tiefstwert', jw.Tiefstwert, 'niedrigste Tagestemperatur des Jahres', '°C'],
                                    ['Temperatur_Durchschnitt', jw.Temp_Durchschnitt, 'Durchschnittstemperatur des Jahres', '°C'],
                                    ['Trockenperiode', jw.Trockenperiode, 'längste Periode ohne Regen', T],
                                    ['Regenmengetag', jw.Max_Regenmenge, 'höchste Regenmenge an einem Tag', 'l/m²'],
                                    ['Regenmengemonat', jw.Regenmengemonat, 'höchste Regenmenge eines abgeschlossenen Monats', 'l/m²'],
                                    ['Windboee_max', jw.Max_Windboee, 'stärkste Windböe des Jahres', 'km/h'],
                                    ['Gradtage_kalteTage', jw.kalte_Tage || 0, 'Tage mit Höchstwert unter 10 °C', T],
                                    ['Gradtage_warmeTage', jw.warme_Tage || 0, 'Tage mit Höchstwert über 20 °C', T],
                                    ['Gradtage_Sommertage', jw.Sommertage || 0, 'Tage mit Höchstwert ab 25 °C', T],
                                    ['Gradtage_heisseTage', jw.heisse_Tage || 0, 'Tage mit Höchstwert ab 30 °C', T],
                                    ['Gradtage_Frosttage', jw.Frost_Tage || 0, 'Tage mit Tiefstwert unter 0 °C', T],
                                    ['Gradtage_Eistage', jw.Eistage || 0, 'Tage mit Höchstwert unter 0 °C', T],
                                    ['Gradtage_sehrkalteTage', jw.sehr_kalte_Tage || 0, 'Tage mit Tiefstwert unter -10 °C', T],
                                    ['Gradtage_Wuestentage', jw.Wuestentage || 0, 'Tage mit Höchstwert ab 35 °C', T],
                                    ['Gradtage_Tropennaechte', jw.Tropennaechte || 0, 'Nächte (18–06 Uhr) nicht unter 20 °C', T],
                                    ['Regentage', jw.Regentage || 0, 'Regentage im Jahr', T],
                                    ['Regensumme_Tage', jw.Regenmenge_Monat || 0, 'Summe der Tagesregenmengen im Jahr (Vergleichswert)', 'l/m²']
                                ];
                                for (const f of JF) await schreibe('Jahreswerte.' + f[0], f[1], N(f[2], f[3]));
                         
                                // Vorjahre (gleiche Schlüssel/Reihenfolge wie SBorg)
                                const jahre = [];
                                for (let j = ERSTES_INFLUX_JAHR; j < J; j++) jahre.push(j);
                                const altJahre = [];
                                $(ALT_DP + '.Jahreswerte.VorJahre.*').each(id => { altJahre.push(id); });
                                for (const id of altJahre) {
                                    const j = Number(id.split('.').pop());
                                    if (j < ERSTES_INFLUX_JAHR) { const s = getState(id); if (s && s.val) await schreibe('Jahreswerte.VorJahre.' + j, alsText(s.val), S('Jahresstatistik ' + j, 'json')); }
                                }
                                const jahresDurchschnitt = {};
                                for (const j of jahre) {
                                    const a = jahrWerte(j);
                                    if (!a) continue;
                                    jahresDurchschnitt[j] = a.Temp_Durchschnitt;
                                    const json = JSON.stringify({ forecast: [{
                                        'Temperatur Tiefstwert': a.Tiefstwert, 'Temperatur Höchstwert': a.Hoechstwert, 'Temperatur Durchschnitt': a.Temp_Durchschnitt,
                                        'Regenmengetag': a.Max_Regenmenge, 'höchste Regenmengemonat': a.Regenmengemonat, 'Windböe': a.Max_Windboee,
                                        'Trockenperiode': a.Trockenperiode, 'kalte Tage': a.kalte_Tage, 'warme Tage': a.warme_Tage, 'Sommertage': a.Sommertage,
                                        'heiße Tage': a.heisse_Tage, 'Frosttage': a.Frost_Tage, 'Eistage': a.Eistage, 'sehr kalte Tage': a.sehr_kalte_Tage,
                                        'Wuestentage': a.Wuestentage, 'Tropennaechte': a.Tropennaechte, 'Regentage': a.Regentage }] });
                                    await schreibe('Jahreswerte.VorJahre.' + j, json, S('Jahresstatistik ' + j, 'json'));
                                }
                         
                                // Rekorde (nur Influx-Zeitraum; bei Gleichstand zählt das erste Auftreten)
                                const rekord = (feld, groesser) => {
                                    let best = null;
                                    alleTage.forEach(t => { if (best === null || (groesser ? t[feld] > best[feld] : t[feld] < best[feld])) best = t; });
                                    return best;
                                };
                                const rMax = rekord('tmax', true), rMin = rekord('tmin', false), rRegen = rekord('regen', true), rWind = rekord('wind', true), rTrocken = rekord('trocken', true);
                                let rMonat = null;
                                Object.keys(proMonat).sort().forEach(m => {
                                    const s = r2(proMonat[m].reduce((x, t) => x + t.regen, 0));
                                    if (!rMonat || s > rMonat.wert) rMonat = { wert: s, datum: proMonat[m][0].datum };
                                });
                                const RW = [
                                    ['Temp_Max', 'Temperatur_Spitzenhoechstwert', rMax.tmax, '°C', rMax.datum, 'höchste je gemessene Tagestemperatur'],
                                    ['Temp_Min', 'Temperatur_Spitzentiefstwert', rMin.tmin, '°C', rMin.datum, 'niedrigste je gemessene Tagestemperatur'],
                                    ['Regenmengetag', 'Regenmengetag', rRegen.regen, 'l/m²', rRegen.datum, 'höchste je gemessene Regenmenge an einem Tag'],
                                    ['Regenmengemonat', 'Regenmengemonat', rMonat.wert, 'l/m²', rMonat.datum, 'höchste je gemessene Regenmenge eines Monats'],
                                    ['Windboee', 'Windboee', rWind.wind, 'km/h', rWind.datum, 'stärkste je gemessene Windböe'],
                                    ['Trockenperiode', 'Trockenperiode', rTrocken.trocken, 'Tage', rTrocken.datum, 'längste je andauernde Trockenperiode']
                                ];
                                for (const r of RW) {
                                    await schreibe('Rekordwerte.value.' + r[0], r[2], N(r[5], r[3]));
                                    await schreibe('Rekordwerte.' + r[1], rekordText(r[2], r[3], r[4]), S(r[5]));
                                }
                                const jd = Object.keys(jahresDurchschnitt).map(Number);
                                if (jd.length) {
                                    let jMax = jd[0], jMin = jd[0];
                                    jd.forEach(j => { if (jahresDurchschnitt[j] > jahresDurchschnitt[jMax]) jMax = j; if (jahresDurchschnitt[j] < jahresDurchschnitt[jMin]) jMin = j; });
                                    await schreibe('Rekordwerte.value.Temp_Durchschnitt_Max', jahresDurchschnitt[jMax], N('höchster Jahrestemperaturdurchschnitt', '°C'));
                                    await schreibe('Rekordwerte.value.Temp_Durchschnitt_Min', jahresDurchschnitt[jMin], N('niedrigster Jahrestemperaturdurchschnitt', '°C'));
                                    await schreibe('Rekordwerte.Temperatur_Jahresdurchschnitt_Max', jahresDurchschnitt[jMax] + ' °C für ' + jMax, S('höchster Jahrestemperaturdurchschnitt'));
                                    await schreibe('Rekordwerte.Temperatur_Jahresdurchschnitt_Min', jahresDurchschnitt[jMin] + ' °C für ' + jMin, S('niedrigster Jahrestemperaturdurchschnitt'));
                                }
                         
                                const dauer = Math.round((Date.now() - beginn) / 1000);
                                await schreibe('Control.ScriptVersion', VERSION, S('Version von Statistik_aus_Influx'));
                                await schreibe('Control.Letzter_Lauf', new Date().toISOString(), S('Zeitpunkt des letzten Laufs', 'date'));
                                await schreibe('Control.Statusmeldung', 'erfolgreich: ' + alleTage.length + ' Tage ' + alleTage[0].key + ' bis ' + vt.key + ', ' + dauer + ' s', S('Statusmeldungen'));
                            } catch (e) {
                                log('Statistik_aus_Influx: ' + e.message, 'error');
                                try { await schreibe('Control.Statusmeldung', 'Fehler: ' + e.message, S('Statusmeldungen')); } catch (e2) { /* nichts */ }
                            } finally {
                                laeuft = false;
                            }
                        }
                         
                        schedule(ZEITPLAN, () => main(false));
                        // Knopf zum sofortigen Neuberechnen
                        createState(ZIEL_DP + '.Control.Neu_berechnen', false, { name: 'Statistik jetzt neu berechnen', type: 'boolean', role: 'button', read: true, write: true }, () => {
                            on({ id: ZIEL_DP + '.Control.Neu_berechnen', val: true, ack: false }, () => { setState(ZIEL_DP + '.Control.Neu_berechnen', false, true); main(true); });
                        });
                        setTimeout(() => main(false), 3000);
                         
                        
                        SBorgS 1 Antwort Letzte Antwort
                        1
                        • Chris76eC Chris76e

                          @SBorg

                          @SBorg wie versprochen, hier das Skript. Der Monatswechsel ist durch, beide Versionen sind parallel gelaufen und die Werte passen. Seit Anfang November läuft bei mir nur noch die neue Version, bisher ohne Probleme.

                          Kurz zur Erinnerung, warum ich umgebaut habe: Weil dein Skript die Werte jede Nacht weiterzählt, haben sich bei mir kleine Fehler aufsummiert. Der Monatsletzte fehlte in den Monats- und Jahreswerten, die Trockenperiode stand das ganze Jahr auf 0, und fiel ein Lauf aus (z. B. nach einem Update des influxdb-Adapters), fehlte der Tag einfach. Deshalb rechnet die neue Version, wie von dir vorgeschlagen, alles direkt aus der InfluxDB (mit KI-Unterstützung umgebaut).

                          Was macht das Skript?
                          Es rechnet jede Nacht die komplette Statistik neu aus den Messwerten in der InfluxDB. Dabei entsteht ein Tagesarchiv (ein Eintrag je Tag: Tiefst-, Höchst- und Durchschnittstemperatur, Böe, Regen, Tropennacht, Sonne, Solarenergie). Nachts werden nur die letzten 3 Tage aus Influx nachgeholt (dauert unter 1 Sekunde), alles andere wird aus dem Archiv gerechnet.

                          Die Datenpunkt-Struktur ist dieselbe wie bei deinem Skript (VorTag, aktueller_Monat, Vorjahres_Monat, Jahreswerte, Jahreswerte.VorJahre.<Jahr>, Data.<Jahr>.<Monat>, Rekordwerte), d. h. VIS-Widgets, Tabellen oder Home-Assistant-Anbindungen laufen ohne Änderung weiter.

                          Unterschiede zum Original
                          Kein Weiterzählen über Nacht: Fehlt ein Lauf, holt der nächste ihn automatisch nach. Fehler können sich nicht mehr aufsummieren.
                          Der Monatsletzte zählt mit.
                          Tropennacht nach DWD: Nacht von 18 bis 06 Uhr nicht unter 20 °C (zählt zum Tag des Morgens). Das Original zählt Tage mit Tiefstwert ≥ 20 °C, das ergibt deutlich weniger Tropennächte.
                          Trockenperiode = längste Folge von Tagen ohne Regentag (< 0,1 l/m²), auch über den Jahreswechsel.
                          Monats-/Jahresdurchschnitt = Mittel der Tagesmittel.
                          Neu: Tagestabellen je Monat unter …Statistik.Wetter.Tage.<Jahr>.<Monat> (JSON, ein Eintrag je Tag mit Tiefst-/Höchst-/Ø-Temperatur, Böe, Regen, Sonnenscheindauer in Minuten, Sonnenenergie Wh/m²). Damit braucht man kein extra Skript zum Sammeln der Tageswerte mehr.
                          Neu: Knopf Control.Neu_berechnen: lädt das Archiv komplett neu aus Influx.
                          Neu: Jahreswerte.Regensumme_Tage (Summe der Tagesregenmengen im laufenden Jahr, als Vergleichswert).
                          Weggefallen: Update-Check, AutoDelete/Reset-Schalter und das einstellbare Rekordwerte-Format (fest "41.6 °C im Juni 2025"). Die alten Control.*-Datenpunkte bleiben einfach unbenutzt stehen.
                          Kenntage wie gehabt: warm > 20, Sommertag ≥ 25, heiß ≥ 30, Wüste ≥ 35 (Höchstwert), kalt < 10, Eistag < 0 (Höchstwert), Frost < 0, sehr kalt < -10 (Tiefstwert), Regentag ≥ 0,1 l/m².
                          Voraussetzungen
                          WLAN-Wetterstation mit Standard-Datenstruktur
                          javascript-Adapter
                          influxdb-Adapter mit InfluxDB V2 (Flux-Abfragen). Bei mir getestet mit influxdb-Adapter 5.1.6.
                          Logging in InfluxDB für Aussentemperatur, Wind_max, Regen_Tag und optional Info.Sonnenschein_Tag, Info.Solarenergie_Tag, ohne Alias (das Measurement muss die Datenpunkt-ID sein, wie beim Original)
                          Einrichtung
                          Altes Statistik-Skript ausschalten (nicht löschen, falls man zurück will). Beide gleichzeitig laufen lassen geht nicht, weil sie in dieselben Datenpunkte schreiben.
                          Am besten vorher die Datenpunkte unter 0_userdata.0.Statistik.Wetter sichern (z. B. Objekte exportieren).
                          Neues JavaScript anlegen, Skript einfügen und oben die User-Einstellungen anpassen:
                          WET_DP: wo die Wetterstation-Datenpunkte liegen (wie im Wetterstation-Skript, Standard 0_userdata.0.Wetterstation)
                          INFLUX / BUCKET: Instanz und Bucket
                          ZIEL_DP: wohin die Statistik geschrieben wird (wie PRE_DP beim Original)
                          INFLUX_START: erster Tag mit Daten in der InfluxDB (JJJJ-MM-TT). Wichtig, weil alle Monate/Jahre davor nicht aus Influx kommen können: die alten Werte (Data.<Jahr>.<Monat> und Jahreswerte.VorJahre.<Jahr>) aus der Zeit vorher werden aus der vorhandenen Statistik übernommen.
                          MIT_SONNE: auf false, wenn Sonnenschein/Solarenergie nicht geloggt werden
                          Skript starten. Beim ersten Start wird das Tagesarchiv Monat für Monat mit 5 s Pause aus Influx geladen. Bei mir dauert das für rund 4,5 Jahre ca. 5 bis 6 Minuten. Den Fortschritt sieht man in Control.Statusmeldung, am Ende steht dort z. B. "erfolgreich: 1642 Tage 2022-05-04 bis 2026-10-31, 312 s".
                          Danach läuft es jede Nacht um 01:20 Uhr (einstellbar über ZEITPLAN).
                          Hinweise
                          Kleine Influx-Server: Bitte die Pause (PAUSE_MS) nicht auf 0 setzen. Mein erster Versuch hat die ganze Historie auf einmal abgefragt und den InfluxDB-Container (1 Kern, 2 GB) komplett lahmgelegt. Monatsweise mit Pause ist kein Problem, eine Monatsabfrage dauert 0,1 bis 0,3 s.
                          Rekordwerte zählen nur ab Beginn der Influx-Daten.
                          Der angefangene erste Monat (bei mir Mai 2022) wird nicht als Data.<Jahr>.<Monat> neu berechnet, dort bleibt der alte Wert stehen.
                          Durch die Neuberechnung können sich alte Werte leicht ändern (z. B. Regensummen um ein paar Hundertstel, Durchschnitt um bis zu 0,2 °C, Tropennächte nach DWD-Regel, fehlende Monatsletzte). Das ist gewollt, die neuen Werte passen jetzt zu den Rohdaten.
                          Zurück zum Original: neues Skript aus, altes wieder an, ggf. gesicherte Datenpunkte zurückspielen.
                          Nochmals danke für die Wetterstation und die Vorlage! Über Rückmeldungen, gerade von dir, freue ich mich.

                          /* Wetterstatistik direkt aus InfluxDB (für das WLAN-Wetterstation-Projekt von SBorg)
                           
                             Berechnet jede Nacht die komplette Wetterstatistik neu aus den in InfluxDB V2 geloggten Messwerten:
                             Vortag, aktueller Monat, Vorjahresmonat, Jahreswerte, Vorjahre, Monatsdaten (Data.<Jahr>.<Monat>),
                             Rekordwerte und Tagestabellen (Tage.<Jahr>.<Monat>).
                             Datenpunkt-Struktur wie im Statistik-Skript von SBorg (Wetterstation-Statistiken V2.0.x), damit
                             vorhandene Auswertungen (VIS, Home Assistant, Tabellen) weiter funktionieren.
                           
                             Idee und Datenstruktur: SBorg (https://github.com/SBorg2014/WLAN-Wetterstation) – vielen Dank!
                             Umbau "alles aus Influx neu rechnen": Chris76e (mit KI-Unterstützung)
                           
                             Unterschied zum Original:
                             - Kein Hochzählen über Nacht: fehlt ein Lauf, holt der nächste die letzten Tage nach; alles wird aus einem
                               Tagesarchiv (Control.Tagesarchiv) neu gerechnet. Monatsletzter zählt korrekt mit.
                             - Tropennacht nach DWD (Nacht 18–06 Uhr nicht unter 20 °C, zählt zum Tag des Morgens).
                             - Trockenperiode = längste Folge von Tagen ohne Regentag (< 0,1 l/m²), auch über den Jahreswechsel.
                             - Durchschnitt Monat/Jahr = Mittel der Tagesmittel.
                             - Zusätzlich Tagestabellen je Monat (Tiefst-/Höchst-/Ø-Temperatur, Böe, Regen, Sonnenscheindauer, Sonnenenergie).
                             - Knopf Control.Neu_berechnen: Tagesarchiv komplett neu aus Influx laden (Monat für Monat mit Pause).
                           
                             Kenntage: Sommertag >= 25, heißer Tag >= 30, Wüstentag >= 35, warmer Tag > 20 (Höchstwert);
                             kalter Tag Höchstwert < 10, Eistag Höchstwert < 0; Frosttag Tiefstwert < 0, sehr kalter Tag Tiefstwert < -10;
                             Regentag >= 0,1 l/m².
                           
                             Voraussetzungen: ioBroker javascript-Adapter, influxdb-Adapter mit InfluxDB V2 (Flux), Logging der
                             Datenpunkte Aussentemperatur, Wind_max, Regen_Tag (optional Info.Sonnenschein_Tag, Info.Solarenergie_Tag)
                             OHNE Alias (Measurement = Datenpunkt-ID). Getestet mit influxdb-Adapter 5.1.6.
                           
                             Wichtig: Das alte Statistik-Skript vorher ausschalten (nicht beide gleichzeitig laufen lassen).
                           
                             Version 1.4.1 (11/2026) – 1.4.1: vorhandene Datenpunkte mit anderem Typ (json/object) werden auf "string" korrigiert
                                                         (Warnung "You are assigning a string to the state ... which expects a object")
                          */
                           
                          // *** User-Einstellungen ***********************************************************************************
                          const WET_DP = '0_userdata.0.Wetterstation';           // wo liegen die Datenpunkte der Wetterstation (wie im Wetterstation-Skript) [default: 0_userdata.0.Wetterstation]
                          const INFLUX = 'influxdb.0';                           // Instanz des influxdb-Adapters
                          const BUCKET = 'iobroker';                             // Name des Buckets
                          const ZIEL_DP = '0_userdata.0.Statistik.Wetter';       // wohin die Statistik geschrieben wird (wie PRE_DP im SBorg-Skript)
                          const ALT_DP = ZIEL_DP;                                // Monate/Jahre VOR Beginn der Influx-Daten werden von hier übernommen (alte Statistik), sonst leer
                          const TAGE_DP = ZIEL_DP + '.Tage';                     // Tagestabellen <Jahr>.<Monat>
                          const INFLUX_START = '2022-05-04';                     // erster Tag mit Daten in InfluxDB (JJJJ-MM-TT) – unbedingt anpassen!
                          const MIT_SONNE = true;                                // false, wenn Info.Sonnenschein_Tag / Info.Solarenergie_Tag nicht geloggt werden
                          const ZEITZONE = 'Europe/Berlin';                      // für die Tagesgrenzen in Influx
                          const ZEITPLAN = '20 1 * * *';                         // wann rechnen (Minute Stunde * * *) [default 01:20 Uhr]
                          const NACHHOLEN_TAGE = 3;                              // jede Nacht die letzten x Tage neu aus Influx holen
                          const PAUSE_MS = 5000;                                 // Pause zwischen den Monaten beim kompletten Neuladen (schont kleine Influx-Server)
                          const NACHT_MIN_STUNDEN = 9;                           // so viele Stundenwerte (von 12) braucht eine Nacht für die Tropennacht-Prüfung
                          // *** ENDE User-Einstellungen – ab hier nichts mehr ändern **************************************************
                           
                          const VERSION = '1.4.1';
                          const START_TEILE = INFLUX_START.split('-').map(Number);
                          const INFLUX_START_DATUM = new Date(START_TEILE[0], START_TEILE[1] - 1, START_TEILE[2]);
                          // erster vollständiger Monat/Jahr mit Influx-Daten; davor wird aus ALT_DP übernommen
                          const ERSTER_INFLUX_MONAT = (() => { const d = new Date(START_TEILE[0], START_TEILE[1] - 1 + (START_TEILE[2] > 1 ? 1 : 0), 1);
                              return d.getFullYear() + '.' + (d.getMonth() < 9 ? '0' : '') + (d.getMonth() + 1); })();
                          const ERSTES_INFLUX_JAHR = (START_TEILE[1] === 1 && START_TEILE[2] === 1) ? START_TEILE[0] : START_TEILE[0] + 1;
                           
                          const MONATSNAME = ['Januar','Februar','März','April','Mai','Juni','Juli','August','September','Oktober','November','Dezember'];
                          const pad = n => (n < 10 ? '0' : '') + n;
                          const tagKey = d => d.getFullYear() + '-' + pad(d.getMonth() + 1) + '-' + pad(d.getDate());
                          const monatKey = d => d.getFullYear() + '.' + pad(d.getMonth() + 1);
                          const r2 = x => Math.round(x * 100) / 100;
                           
                          let laeuft = false;
                           
                          function abfrage(flux) {
                              return new Promise((resolve, reject) => {
                                  sendTo(INFLUX, 'query', flux, { timeout: 60000 }, res => {
                                      if (!res || res.error) { reject(new Error(res ? String(res.error) : 'keine Antwort von ' + INFLUX)); return; }
                                      const zeilen = Array.isArray(res.result) && Array.isArray(res.result[0]) ? res.result[0] : (res.result || []);
                                      resolve(zeilen);
                                  });
                              });
                          }
                           
                          function flux(messwert, every, fn, start, stop, offset) {
                              return 'from(bucket: "' + BUCKET + '") |> range(start: ' + Math.floor(start / 1000) + ', stop: ' + Math.floor(stop / 1000) + ')'
                                  + ' |> filter(fn: (r) => r._measurement == "' + WET_DP + '.' + messwert + '" and r._field == "value")'
                                  + ' |> aggregateWindow(every: ' + every + ', fn: ' + fn + (offset ? ', offset: ' + offset : '')
                                  + ', createEmpty: false, timeSrc: "_start", location: {zone: "' + ZEITZONE + '", offset: 0s})'
                                  + ' |> keep(columns: ["_time", "_value"])';
                          }
                           
                          const zeit = z => (typeof z.ts === 'number' ? z.ts : Date.parse(z._time));
                           
                          // Tageswerte für einen Zeitraum aus Influx (lokale Kalendertage): { 'JJJJ-MM-TT': [tmin, tmax, tmit, wind, regen, tropennacht 0/1, sonne s, solar Wh/m²] }
                          // Abfragen nacheinander und nur für kurze Zeiträume (die ganze Historie auf einmal kann einen kleinen Influx-Server überlasten)
                          async function bereichHolen(start, stop) {
                              const tmin = await abfrage(flux('Aussentemperatur', '1d', 'min', start, stop));
                              const tmax = await abfrage(flux('Aussentemperatur', '1d', 'max', start, stop));
                              const tmit = await abfrage(flux('Aussentemperatur', '1d', 'mean', start, stop));
                              const wind = await abfrage(flux('Wind_max', '1d', 'max', start, stop));
                              // Regen +72 s: der Tageszähler der Station springt erst kurz nach Mitternacht auf 0 (wie im SBorg-Skript). Auch der Bereich beginnt 72 s später,
                              // sonst landet der alte Vortageswert von 00:00 im ersten (abgeschnittenen) Fenster
                              const regen = await abfrage(flux('Regen_Tag', '1d', 'max', start + 72000, stop, '72s'));
                              const stunden = await abfrage(flux('Aussentemperatur', '1h', 'min', start - 6 * 3600000, stop));
                              // Tageszähler Sonnenschein (Sekunden) und Solarenergie (Wh/m²): wie Regen mit 72 s Versatz. Bewusst nicht Info.*_VorTag:
                              // der wird um 23:58 geloggt und ist manchmal noch der Wert vom Tag davor oder 0
                              const sonne = MIT_SONNE ? await abfrage(flux('Info.Sonnenschein_Tag', '1d', 'max', start + 72000, stop, '72s')) : [];
                              const solar = MIT_SONNE ? await abfrage(flux('Info.Solarenergie_Tag', '1d', 'max', start + 72000, stop, '72s')) : [];
                              const tage = {};
                              const tag = z => { const k = tagKey(new Date(zeit(z))); if (!tage[k]) tage[k] = {}; return tage[k]; };
                              tmin.forEach(z => { if (typeof z._value === 'number') tag(z).tmin = z._value; });
                              tmax.forEach(z => { if (typeof z._value === 'number') tag(z).tmax = z._value; });
                              tmit.forEach(z => { if (typeof z._value === 'number') tag(z).tmit = r2(z._value); });
                              const zusatz = {};
                              const merke = (liste, feld) => liste.forEach(z => {
                                  if (typeof z._value !== 'number') return;
                                  const k = tagKey(new Date(zeit(z)));
                                  if (!zusatz[k]) zusatz[k] = {};
                                  zusatz[k][feld] = Math.max(zusatz[k][feld] || 0, z._value);
                              });
                              merke(wind, 'wind');
                              merke(regen, 'regen');
                              merke(sonne, 'sonne');
                              merke(solar, 'solar');
                              // Nacht 18–06 Uhr: Stundenminima ab 18 Uhr zählen zum nächsten Tag (Morgen)
                              const naechte = {};
                              stunden.forEach(z => {
                                  if (typeof z._value !== 'number') return;
                                  const d = new Date(zeit(z)), h = d.getHours();
                                  let morgen;
                                  if (h >= 18) morgen = new Date(d.getFullYear(), d.getMonth(), d.getDate() + 1);
                                  else if (h < 6) morgen = d;
                                  else return;
                                  const k = tagKey(morgen);
                                  if (!naechte[k]) naechte[k] = { min: 99, n: 0 };
                                  naechte[k].min = Math.min(naechte[k].min, z._value);
                                  naechte[k].n++;
                              });
                              const erg = {};
                              Object.keys(tage).forEach(k => {
                                  const t = tage[k];
                                  if (typeof t.tmin !== 'number' || typeof t.tmax !== 'number' || typeof t.tmit !== 'number') return;
                                  const [j, m, d] = k.split('-').map(Number);
                                  const datum = new Date(j, m - 1, d).getTime();
                                  if (datum < start || datum >= stop) return;
                                  const z = zusatz[k] || {};
                                  const n = naechte[k];
                                  erg[k] = [t.tmin, t.tmax, t.tmit, z.wind || 0, z.regen || 0, (n && n.n >= NACHT_MIN_STUNDEN && n.min >= 20) ? 1 : 0, z.sonne || 0, z.solar || 0];
                              });
                              return erg;
                          }
                           
                          const pause = ms => new Promise(r => setTimeout(r, ms));
                           
                          // Tagesarchiv (Control.Tagesarchiv): wird beim ersten Start bzw. per Neu_berechnen monatsweise gefüllt,
                          // danach jede Nacht nur um die letzten Tage ergänzt (die letzten NACHHOLEN_TAGE werden neu geholt).
                          async function archivAktualisieren(heute, komplett) {
                              const id = ZIEL_DP + '.Control.Tagesarchiv';
                              let archiv = {};
                              if (!komplett && existsState(id)) { try { archiv = JSON.parse(getState(id).val || '{}'); } catch (e) { archiv = {}; } }
                              if (Object.keys(archiv).some(k => archiv[k].length < 8)) archiv = {};   // altes Archivformat (ohne Sonne/Solar) → neu laden
                              const stop = heute.getTime();
                              if (!Object.keys(archiv).length) {
                                  // Nachladen Monat für Monat, mit Pause dazwischen
                                  let von = new Date(INFLUX_START_DATUM.getFullYear(), INFLUX_START_DATUM.getMonth(), 1);
                                  while (von.getTime() < stop) {
                                      const bis = new Date(von.getFullYear(), von.getMonth() + 1, 1);
                                      await schreibe('Control.Statusmeldung', 'lade Historie ' + monatKey(von) + ' …', S('Statusmeldungen'));
                                      Object.assign(archiv, await bereichHolen(von.getTime(), Math.min(bis.getTime(), stop)));
                                      von = bis;
                                      await pause(PAUSE_MS);
                                  }
                              } else {
                                  const von = new Date(heute.getFullYear(), heute.getMonth(), heute.getDate() - NACHHOLEN_TAGE);
                                  Object.assign(archiv, await bereichHolen(von.getTime(), stop));
                              }
                              const sortiert = {};
                              Object.keys(archiv).sort().forEach(k => { sortiert[k] = archiv[k]; });
                              await schreibe('Control.Tagesarchiv', JSON.stringify(sortiert), S('Tageswerte aus InfluxDB [tmin, tmax, tmit, wind, regen, tropennacht, sonne s, solar Wh/m²]', 'json'));
                              return Object.keys(sortiert).filter(k => new Date(k + 'T00:00:00').getTime() < stop).map(k => {
                                  const [j, m, d] = k.split('-').map(Number);
                                  const datum = new Date(j, m - 1, d), a = sortiert[k];
                                  return { key: k, datum: datum, monat: monatKey(datum), jahr: j, tmin: a[0], tmax: a[1], tmit: a[2], wind: a[3], regen: a[4], tropennacht: a[5] === 1, sonne: a[6], solar: a[7] };
                              });
                          }
                           
                          // Kenntage und Extremwerte über eine Liste von Tagen
                          function auswerten(tage) {
                              if (!tage.length) return null;
                              const a = {
                                  Tiefstwert: Math.min(...tage.map(t => t.tmin)),
                                  Hoechstwert: Math.max(...tage.map(t => t.tmax)),
                                  Temp_Durchschnitt: r2(tage.reduce((s, t) => s + t.tmit, 0) / tage.length),
                                  Max_Windboee: Math.max(...tage.map(t => t.wind)),
                                  Max_Regenmenge: Math.max(...tage.map(t => t.regen)),
                                  Regenmenge_Monat: r2(tage.reduce((s, t) => s + t.regen, 0)),
                                  warme_Tage: 0, Sommertage: 0, heisse_Tage: 0, Frost_Tage: 0, kalte_Tage: 0, Eistage: 0,
                                  sehr_kalte_Tage: 0, Wuestentage: 0, Tropennaechte: 0, Regentage: 0
                              };
                              tage.forEach(t => {
                                  if (t.tmax > 20) a.warme_Tage++;
                                  if (t.tmax >= 25) a.Sommertage++;
                                  if (t.tmax >= 30) a.heisse_Tage++;
                                  if (t.tmin < 0) a.Frost_Tage++;
                                  if (t.tmax < 10) a.kalte_Tage++;
                                  if (t.tmax < 0) a.Eistage++;
                                  if (t.tmin < -10) a.sehr_kalte_Tage++;
                                  if (t.tmax >= 35) a.Wuestentage++;
                                  if (t.tropennacht) a.Tropennaechte++;
                                  if (t.regen >= 0.1) a.Regentage++;
                              });
                              return a;
                          }
                           
                          // Trockenperioden: für jeden Tag die Länge der laufenden Folge ohne Regentag (Folge darf über den Jahreswechsel gehen)
                          function trockenFolgen(alleTage) {
                              let lauf = 0, vorher = null;
                              alleTage.forEach(t => {
                                  if (vorher && (t.datum - vorher.datum) > 26 * 3600000) lauf = 0;   // Datenlücke unterbricht
                                  lauf = t.regen >= 0.1 ? 0 : lauf + 1;
                                  t.trocken = lauf;
                                  vorher = t;
                              });
                          }
                           
                          function rekordText(wert, einheit, datum) {
                              if (einheit === 'Tage' && wert === 1) einheit = 'Tag';
                              return wert + ' ' + einheit + ' im ' + MONATSNAME[datum.getMonth()] + ' ' + datum.getFullYear();
                          }
                           
                          // Datenpunkt anlegen/schreiben, nur bei Änderung
                          async function schreibe(id, wert, common) {
                              await schreibeVoll(ZIEL_DP + '.' + id, wert, common);
                          }
                           
                          // wie schreibe(), aber mit voller ID (auch für die Tagestabellen).
                          // Hat ein vorhandener Datenpunkt einen anderen Typ (z. B. "json"/"object" statt "string"), wird nur der Typ
                          // im Objekt korrigiert – Wert und Historie bleiben, nichts muss gelöscht werden (1.4.1)
                          async function schreibeVoll(voll, wert, common) {
                              if (!existsState(voll)) {
                                  await createStateAsync(voll, wert, Object.assign({ read: true, write: false }, common));
                                  await setStateAsync(voll, wert, true);
                                  return;
                              }
                              const obj = getObject(voll);
                              if (obj && obj.common && common.type && obj.common.type !== common.type) {
                                  log('Statistik_aus_Influx: Typ von ' + voll + ' korrigiert: ' + obj.common.type + ' -> ' + common.type, 'info');
                                  await extendObjectAsync(voll, { common: { type: common.type, role: common.role } });
                              }
                              const s = getState(voll);
                              if (!s || s.val !== wert) await setStateAsync(voll, wert, true);
                          }
                           
                          // alte Werte können als Objekt statt als Text gespeichert sein → immer als JSON-Text weitergeben
                          const alsText = v => (typeof v === 'string' ? v : JSON.stringify(v));
                           
                          const N = (name, unit) => ({ name: name, type: 'number', role: 'value', unit: unit });
                          const S = (name, role) => ({ name: name, type: 'string', role: role || 'text' });
                           
                          const MONATSFELDER = [
                              ['Tiefstwert', 'niedrigste Temperatur', '°C'], ['Hoechstwert', 'höchste Temperatur', '°C'],
                              ['Temperatur_Durchschnitt', 'Durchschnittstemperatur', '°C', 'Temp_Durchschnitt'],
                              ['Max_Windboee', 'stärkste Windböe', 'km/h'], ['Max_Regenmenge', 'maximale Regenmenge pro Tag', 'l/m²'],
                              ['Regenmenge_Monat', 'Regenmenge im Monat', 'l/m²'],
                              ['warme_Tage', 'Tage mit Höchstwert über 20 °C', 'Tage'], ['Sommertage', 'Tage mit Höchstwert ab 25 °C', 'Tage'],
                              ['heisse_Tage', 'Tage mit Höchstwert ab 30 °C', 'Tage'], ['Frost_Tage', 'Tage mit Tiefstwert unter 0 °C', 'Tage'],
                              ['kalte_Tage', 'Tage mit Höchstwert unter 10 °C', 'Tage'], ['Eistage', 'Tage mit Höchstwert unter 0 °C', 'Tage'],
                              ['sehr_kalte_Tage', 'Tage mit Tiefstwert unter -10 °C', 'Tage'], ['Wuestentage', 'Tage mit Höchstwert ab 35 °C', 'Tage'],
                              ['Tropennaechte', 'Nächte (18–06 Uhr) nicht unter 20 °C', 'Tage'], ['Regentage', 'Tage mit mindestens 0,1 l/m²', 'Tage']
                          ];
                           
                          // gleiche Feldreihenfolge wie SBorg in Data.<Jahr>.<Monat>
                          function monatsJson(a) {
                              return JSON.stringify([{
                                  Tiefstwert: a.Tiefstwert, Hoechstwert: a.Hoechstwert, Temp_Durchschnitt: a.Temp_Durchschnitt, Max_Windboee: a.Max_Windboee,
                                  Max_Regenmenge: a.Max_Regenmenge, Regenmenge_Monat: a.Regenmenge_Monat, warme_Tage: a.warme_Tage, Sommertage: a.Sommertage,
                                  heisse_Tage: a.heisse_Tage, Frost_Tage: a.Frost_Tage, kalte_Tage: a.kalte_Tage, Eistage: a.Eistage, sehr_kalte_Tage: a.sehr_kalte_Tage,
                                  Wuestentage: a.Wuestentage, Tropennaechte: a.Tropennaechte, Regentage: a.Regentage
                              }]);
                          }
                           
                          async function main(komplett) {
                              if (laeuft) return;
                              laeuft = true;
                              const beginn = Date.now();
                              try {
                                  const jetzt = new Date();
                                  const heute = new Date(jetzt.getFullYear(), jetzt.getMonth(), jetzt.getDate());
                                  const gestern = new Date(heute.getFullYear(), heute.getMonth(), heute.getDate() - 1);
                                  const J = heute.getFullYear(), aktMonat = monatKey(heute);
                           
                                  const alleTage = await archivAktualisieren(heute, komplett === true);
                                  if (!alleTage.length) throw new Error('keine Tageswerte aus InfluxDB');
                                  trockenFolgen(alleTage);
                           
                                  // Monate
                                  const proMonat = {};
                                  alleTage.forEach(t => { (proMonat[t.monat] = proMonat[t.monat] || []).push(t); });
                                  const monate = {};   // Monatskey -> Auswertung (abgeschlossene Monate)
                                  Object.keys(proMonat).forEach(m => { if (m >= ERSTER_INFLUX_MONAT && m < aktMonat) monate[m] = auswerten(proMonat[m]); });
                           
                                  // Data.<Jahr>.<Monat>: vor Influx aus ALT_DP übernehmen
                                  const dataJson = {};
                                  $(ALT_DP + '.Data.*').each(id => {
                                      const m = id.substring((ALT_DP + '.Data.').length);
                                      if (/^\d{4}\.\d{2}$/.test(m) && m < ERSTER_INFLUX_MONAT) { const s = getState(id); if (s && s.val) dataJson[m] = alsText(s.val); }
                                  });
                                  Object.keys(monate).forEach(m => { dataJson[m] = monatsJson(monate[m]); });
                                  for (const m of Object.keys(dataJson).sort()) {
                                      const [j, mm] = m.split('.');
                                      await schreibe('Data.' + m, dataJson[m], S('Monatsstatistik für ' + MONATSNAME[Number(mm) - 1] + ' ' + j, 'json'));
                                  }
                           
                                  // Tagestabellen (ein Eintrag je Tag, Sonnenscheindauer in Minuten)
                                  for (const m of Object.keys(proMonat).sort()) {
                                      const [j, mm] = m.split('.');
                                      if (m < ERSTER_INFLUX_MONAT && existsState(TAGE_DP + '.' + j + '.' + mm)) continue;   // angefangenen ersten Monat nicht überschreiben, falls schon eine Tabelle da ist
                                      const text = '[' + proMonat[m].map(t => JSON.stringify({
                                          Tiefstwert: t.tmin, Hoechstwert: t.tmax, Durchschnitt: t.tmit, Max_Windboee: t.wind,
                                          Regenmenge_Tag: t.regen, Sonnenscheindauer: Math.floor(t.sonne / 60), SonnenEnergie: t.solar })).join(', ') + ']';
                                      await schreibeVoll(TAGE_DP + '.' + j + '.' + mm, text, S('Tageswerte ' + MONATSNAME[Number(mm) - 1] + ' ' + j, 'json'));
                                  }
                           
                                  // VorTag
                                  const vt = alleTage[alleTage.length - 1];
                                  if (vt.key !== tagKey(gestern)) log('Statistik_aus_Influx: keine Daten für gestern, letzter Tag ' + vt.key, 'warn');
                                  await schreibe('VorTag.Temperatur_Tiefstwert', vt.tmin, N('niedrigste Tagestemperatur', '°C'));
                                  await schreibe('VorTag.Temperatur_Hoechstwert', vt.tmax, N('höchste Tagestemperatur', '°C'));
                                  await schreibe('VorTag.Temperatur_Durchschnitt', vt.tmit, N('Durchschnittstemperatur', '°C'));
                                  await schreibe('VorTag.Regenmenge', vt.regen, N('Regenmenge vom Vortag', 'l/m²'));
                                  await schreibe('VorTag.Windboee_max', vt.wind, N('stärkste Windböe vom Vortag', 'km/h'));
                           
                                  // aktueller Monat (Tage bis gestern); am Monatsersten wie im Original: aktuelle Temperatur, Rest 0
                                  let am = auswerten(proMonat[aktMonat] || []);
                                  if (!am) {
                                      const t0 = getState(WET_DP + '.Aussentemperatur').val;
                                      am = auswerten([{ tmin: t0, tmax: t0, tmit: t0, wind: 0, regen: 0, tropennacht: false }]);
                                      MONATSFELDER.forEach(f => { if (f[2] === 'Tage') am[f[0]] = 0; });
                                  }
                                  for (const f of MONATSFELDER) await schreibe('aktueller_Monat.' + f[0], am[f[3] || f[0]], N(f[1], f[2]));
                           
                                  // Vorjahresmonat
                                  const vjKey = (J - 1) + '.' + pad(heute.getMonth() + 1);
                                  let vj = null;
                                  if (dataJson[vjKey]) { try { vj = JSON.parse(dataJson[vjKey])[0]; } catch (e) { vj = null; } }
                                  for (const f of MONATSFELDER) {
                                      const w = vj && typeof vj[f[3] || f[0]] === 'number' ? vj[f[3] || f[0]] : 99999;
                                      await schreibe('Vorjahres_Monat.' + f[0], w, N(f[1], f[2]));
                                  }
                           
                                  // Jahreswerte
                                  const jahrWerte = jahr => {
                                      const tage = alleTage.filter(t => t.jahr === jahr);
                                      const a = auswerten(tage);
                                      if (!a) return null;
                                      a.Trockenperiode = Math.max(0, ...tage.map(t => t.trocken));
                                      const mon = Object.keys(monate).filter(m => m.startsWith(jahr + '.')).map(m => monate[m].Regenmenge_Monat);
                                      a.Regenmengemonat = mon.length ? Math.max(...mon) : 0;
                                      return a;
                                  };
                                  let jw = jahrWerte(J);
                                  if (!jw) jw = { Tiefstwert: 100, Hoechstwert: -100, Temp_Durchschnitt: 0, Trockenperiode: 0, Max_Regenmenge: 0, Regenmengemonat: 0,
                                                  Max_Windboee: 0, Regenmenge_Monat: 0 };
                                  const T = 'Tage';
                                  const JF = [
                                      ['Temperatur_Hoechstwert', jw.Hoechstwert, 'höchste Tagestemperatur des Jahres', '°C'],
                                      ['Temperatur_Tiefstwert', jw.Tiefstwert, 'niedrigste Tagestemperatur des Jahres', '°C'],
                                      ['Temperatur_Durchschnitt', jw.Temp_Durchschnitt, 'Durchschnittstemperatur des Jahres', '°C'],
                                      ['Trockenperiode', jw.Trockenperiode, 'längste Periode ohne Regen', T],
                                      ['Regenmengetag', jw.Max_Regenmenge, 'höchste Regenmenge an einem Tag', 'l/m²'],
                                      ['Regenmengemonat', jw.Regenmengemonat, 'höchste Regenmenge eines abgeschlossenen Monats', 'l/m²'],
                                      ['Windboee_max', jw.Max_Windboee, 'stärkste Windböe des Jahres', 'km/h'],
                                      ['Gradtage_kalteTage', jw.kalte_Tage || 0, 'Tage mit Höchstwert unter 10 °C', T],
                                      ['Gradtage_warmeTage', jw.warme_Tage || 0, 'Tage mit Höchstwert über 20 °C', T],
                                      ['Gradtage_Sommertage', jw.Sommertage || 0, 'Tage mit Höchstwert ab 25 °C', T],
                                      ['Gradtage_heisseTage', jw.heisse_Tage || 0, 'Tage mit Höchstwert ab 30 °C', T],
                                      ['Gradtage_Frosttage', jw.Frost_Tage || 0, 'Tage mit Tiefstwert unter 0 °C', T],
                                      ['Gradtage_Eistage', jw.Eistage || 0, 'Tage mit Höchstwert unter 0 °C', T],
                                      ['Gradtage_sehrkalteTage', jw.sehr_kalte_Tage || 0, 'Tage mit Tiefstwert unter -10 °C', T],
                                      ['Gradtage_Wuestentage', jw.Wuestentage || 0, 'Tage mit Höchstwert ab 35 °C', T],
                                      ['Gradtage_Tropennaechte', jw.Tropennaechte || 0, 'Nächte (18–06 Uhr) nicht unter 20 °C', T],
                                      ['Regentage', jw.Regentage || 0, 'Regentage im Jahr', T],
                                      ['Regensumme_Tage', jw.Regenmenge_Monat || 0, 'Summe der Tagesregenmengen im Jahr (Vergleichswert)', 'l/m²']
                                  ];
                                  for (const f of JF) await schreibe('Jahreswerte.' + f[0], f[1], N(f[2], f[3]));
                           
                                  // Vorjahre (gleiche Schlüssel/Reihenfolge wie SBorg)
                                  const jahre = [];
                                  for (let j = ERSTES_INFLUX_JAHR; j < J; j++) jahre.push(j);
                                  const altJahre = [];
                                  $(ALT_DP + '.Jahreswerte.VorJahre.*').each(id => { altJahre.push(id); });
                                  for (const id of altJahre) {
                                      const j = Number(id.split('.').pop());
                                      if (j < ERSTES_INFLUX_JAHR) { const s = getState(id); if (s && s.val) await schreibe('Jahreswerte.VorJahre.' + j, alsText(s.val), S('Jahresstatistik ' + j, 'json')); }
                                  }
                                  const jahresDurchschnitt = {};
                                  for (const j of jahre) {
                                      const a = jahrWerte(j);
                                      if (!a) continue;
                                      jahresDurchschnitt[j] = a.Temp_Durchschnitt;
                                      const json = JSON.stringify({ forecast: [{
                                          'Temperatur Tiefstwert': a.Tiefstwert, 'Temperatur Höchstwert': a.Hoechstwert, 'Temperatur Durchschnitt': a.Temp_Durchschnitt,
                                          'Regenmengetag': a.Max_Regenmenge, 'höchste Regenmengemonat': a.Regenmengemonat, 'Windböe': a.Max_Windboee,
                                          'Trockenperiode': a.Trockenperiode, 'kalte Tage': a.kalte_Tage, 'warme Tage': a.warme_Tage, 'Sommertage': a.Sommertage,
                                          'heiße Tage': a.heisse_Tage, 'Frosttage': a.Frost_Tage, 'Eistage': a.Eistage, 'sehr kalte Tage': a.sehr_kalte_Tage,
                                          'Wuestentage': a.Wuestentage, 'Tropennaechte': a.Tropennaechte, 'Regentage': a.Regentage }] });
                                      await schreibe('Jahreswerte.VorJahre.' + j, json, S('Jahresstatistik ' + j, 'json'));
                                  }
                           
                                  // Rekorde (nur Influx-Zeitraum; bei Gleichstand zählt das erste Auftreten)
                                  const rekord = (feld, groesser) => {
                                      let best = null;
                                      alleTage.forEach(t => { if (best === null || (groesser ? t[feld] > best[feld] : t[feld] < best[feld])) best = t; });
                                      return best;
                                  };
                                  const rMax = rekord('tmax', true), rMin = rekord('tmin', false), rRegen = rekord('regen', true), rWind = rekord('wind', true), rTrocken = rekord('trocken', true);
                                  let rMonat = null;
                                  Object.keys(proMonat).sort().forEach(m => {
                                      const s = r2(proMonat[m].reduce((x, t) => x + t.regen, 0));
                                      if (!rMonat || s > rMonat.wert) rMonat = { wert: s, datum: proMonat[m][0].datum };
                                  });
                                  const RW = [
                                      ['Temp_Max', 'Temperatur_Spitzenhoechstwert', rMax.tmax, '°C', rMax.datum, 'höchste je gemessene Tagestemperatur'],
                                      ['Temp_Min', 'Temperatur_Spitzentiefstwert', rMin.tmin, '°C', rMin.datum, 'niedrigste je gemessene Tagestemperatur'],
                                      ['Regenmengetag', 'Regenmengetag', rRegen.regen, 'l/m²', rRegen.datum, 'höchste je gemessene Regenmenge an einem Tag'],
                                      ['Regenmengemonat', 'Regenmengemonat', rMonat.wert, 'l/m²', rMonat.datum, 'höchste je gemessene Regenmenge eines Monats'],
                                      ['Windboee', 'Windboee', rWind.wind, 'km/h', rWind.datum, 'stärkste je gemessene Windböe'],
                                      ['Trockenperiode', 'Trockenperiode', rTrocken.trocken, 'Tage', rTrocken.datum, 'längste je andauernde Trockenperiode']
                                  ];
                                  for (const r of RW) {
                                      await schreibe('Rekordwerte.value.' + r[0], r[2], N(r[5], r[3]));
                                      await schreibe('Rekordwerte.' + r[1], rekordText(r[2], r[3], r[4]), S(r[5]));
                                  }
                                  const jd = Object.keys(jahresDurchschnitt).map(Number);
                                  if (jd.length) {
                                      let jMax = jd[0], jMin = jd[0];
                                      jd.forEach(j => { if (jahresDurchschnitt[j] > jahresDurchschnitt[jMax]) jMax = j; if (jahresDurchschnitt[j] < jahresDurchschnitt[jMin]) jMin = j; });
                                      await schreibe('Rekordwerte.value.Temp_Durchschnitt_Max', jahresDurchschnitt[jMax], N('höchster Jahrestemperaturdurchschnitt', '°C'));
                                      await schreibe('Rekordwerte.value.Temp_Durchschnitt_Min', jahresDurchschnitt[jMin], N('niedrigster Jahrestemperaturdurchschnitt', '°C'));
                                      await schreibe('Rekordwerte.Temperatur_Jahresdurchschnitt_Max', jahresDurchschnitt[jMax] + ' °C für ' + jMax, S('höchster Jahrestemperaturdurchschnitt'));
                                      await schreibe('Rekordwerte.Temperatur_Jahresdurchschnitt_Min', jahresDurchschnitt[jMin] + ' °C für ' + jMin, S('niedrigster Jahrestemperaturdurchschnitt'));
                                  }
                           
                                  const dauer = Math.round((Date.now() - beginn) / 1000);
                                  await schreibe('Control.ScriptVersion', VERSION, S('Version von Statistik_aus_Influx'));
                                  await schreibe('Control.Letzter_Lauf', new Date().toISOString(), S('Zeitpunkt des letzten Laufs', 'date'));
                                  await schreibe('Control.Statusmeldung', 'erfolgreich: ' + alleTage.length + ' Tage ' + alleTage[0].key + ' bis ' + vt.key + ', ' + dauer + ' s', S('Statusmeldungen'));
                              } catch (e) {
                                  log('Statistik_aus_Influx: ' + e.message, 'error');
                                  try { await schreibe('Control.Statusmeldung', 'Fehler: ' + e.message, S('Statusmeldungen')); } catch (e2) { /* nichts */ }
                              } finally {
                                  laeuft = false;
                              }
                          }
                           
                          schedule(ZEITPLAN, () => main(false));
                          // Knopf zum sofortigen Neuberechnen
                          createState(ZIEL_DP + '.Control.Neu_berechnen', false, { name: 'Statistik jetzt neu berechnen', type: 'boolean', role: 'button', read: true, write: true }, () => {
                              on({ id: ZIEL_DP + '.Control.Neu_berechnen', val: true, ack: false }, () => { setState(ZIEL_DP + '.Control.Neu_berechnen', false, true); main(true); });
                          });
                          setTimeout(() => main(false), 3000);
                           
                          
                          SBorgS
                          SBorgS
                          SBorg
                          Forum Testing Most Active
                          schrieb zuletzt editiert von
                          #5840

                          @Chris76e Supi, Danke (auch an die KI). Saubere Arbeit und sieht gut aus. Jetzt werde ich auch die Statistik mal nutzen.
                          Ich ergänze noch den Eingangstopic nach hierher.

                          LG SBorg ( SBorg auf GitHub)
                          Projekte: Lebensmittelwarnung.de | WLAN-Wetterstation | PimpMyStation

                          1 Antwort Letzte Antwort
                          1
                          • BoronsbruderB
                            BoronsbruderB
                            Boronsbruder
                            schrieb zuletzt editiert von
                            #5841

                            @chris76e

                            You are assigning a string to the state "0_userdata.0.Statistik.Wetter.Data.2022.04" which expects a object. Please fix your code to use a object or change the state type to string. This warning might become an error in future versions.

                            Müssen die existierenden Statistik Datenpunkte vorher gelöscht werden? (Die sind ja im Moment json und nicht string)
                            Wenn ja, werden diese dann wieder hergestellt?

                            1 Antwort Letzte Antwort
                            0
                            • Chris76eC
                              Chris76eC
                              Chris76e
                              schrieb zuletzt editiert von Chris76e
                              #5842

                              @boronsbruder
                              Danke für den Hinweis!

                              Nein, bitte nichts löschen. Die Warnung kommt daher, dass deine vorhandenen Datenpunkte unter Data.* (und evtl. Jahreswerte.VorJahre.*) den Typ "json" bzw. "object" haben, das Skript aber einen JSON-Text (Typ "string", Rolle "json") schreibt, genauso wie das Original von SBorg. Am Inhalt ändert das nichts, ioBroker meckert nur über den Typ.

                              Ich habe das Skript angepasst (Version 1.4.1, siehe unten): Findet es einen vorhandenen Datenpunkt mit anderem Typ, korrigiert es beim nächsten Lauf nur den Typ im Objekt auf "string". Wert und Historie bleiben erhalten, die Warnung verschwindet. Im Log steht dann einmalig je Datenpunkt eine Info-Zeile "Typ von … korrigiert: json -> string". Alte Werte, die als Objekt statt als Text gespeichert sind, werden dabei ebenfalls sauber als Text übernommen.

                              Wer die alte Version behalten will, kann den Typ auch von Hand ändern: Admin → Objekte → Datenpunkt bearbeiten (Stift) → Typ auf "string" stellen.

                              Warum löschen keine gute Idee ist: Das Skript baut zwar alle Monate und Jahre wieder auf, für die es Daten in der InfluxDB gibt. Monate und Jahre vor deinem INFLUX_START (z. B. das Data.2022.04 aus deiner Warnung, falls deine Influx-Daten erst danach anfangen) kann es aber nicht aus Influx berechnen. Die übernimmt es nur aus den vorhandenen Datenpunkten. Wenn du die löschst, sind diese alten Monate weg.

                              Falls jemand schon gelöscht hat: Ab dem ersten vollständigen Monat in Influx kommt nach dem nächsten Lauf alles wieder (oder sofort mit dem Knopf Control.Neu_berechnen). Ältere Werte nur aus einem Backup (z. B. BackItUp oder Objekt-Export).

                              /* Wetterstatistik direkt aus InfluxDB (für das WLAN-Wetterstation-Projekt von SBorg)
                               
                                 Berechnet jede Nacht die komplette Wetterstatistik neu aus den in InfluxDB V2 geloggten Messwerten:
                                 Vortag, aktueller Monat, Vorjahresmonat, Jahreswerte, Vorjahre, Monatsdaten (Data.<Jahr>.<Monat>),
                                 Rekordwerte und Tagestabellen (Tage.<Jahr>.<Monat>).
                                 Datenpunkt-Struktur wie im Statistik-Skript von SBorg (Wetterstation-Statistiken V2.0.x), damit
                                 vorhandene Auswertungen (VIS, Home Assistant, Tabellen) weiter funktionieren.
                               
                                 Idee und Datenstruktur: SBorg (https://github.com/SBorg2014/WLAN-Wetterstation) – vielen Dank!
                                 Umbau "alles aus Influx neu rechnen": Chris76e (mit KI-Unterstützung)
                               
                                 Unterschied zum Original:
                                 - Kein Hochzählen über Nacht: fehlt ein Lauf, holt der nächste die letzten Tage nach; alles wird aus einem
                                   Tagesarchiv (Control.Tagesarchiv) neu gerechnet. Monatsletzter zählt korrekt mit.
                                 - Tropennacht nach DWD (Nacht 18–06 Uhr nicht unter 20 °C, zählt zum Tag des Morgens).
                                 - Trockenperiode = längste Folge von Tagen ohne Regentag (< 0,1 l/m²), auch über den Jahreswechsel.
                                 - Durchschnitt Monat/Jahr = Mittel der Tagesmittel.
                                 - Zusätzlich Tagestabellen je Monat (Tiefst-/Höchst-/Ø-Temperatur, Böe, Regen, Sonnenscheindauer, Sonnenenergie).
                                 - Knopf Control.Neu_berechnen: Tagesarchiv komplett neu aus Influx laden (Monat für Monat mit Pause).
                               
                                 Kenntage: Sommertag >= 25, heißer Tag >= 30, Wüstentag >= 35, warmer Tag > 20 (Höchstwert);
                                 kalter Tag Höchstwert < 10, Eistag Höchstwert < 0; Frosttag Tiefstwert < 0, sehr kalter Tag Tiefstwert < -10;
                                 Regentag >= 0,1 l/m².
                               
                                 Voraussetzungen: ioBroker javascript-Adapter, influxdb-Adapter mit InfluxDB V2 (Flux), Logging der
                                 Datenpunkte Aussentemperatur, Wind_max, Regen_Tag (optional Info.Sonnenschein_Tag, Info.Solarenergie_Tag)
                                 OHNE Alias (Measurement = Datenpunkt-ID). Getestet mit influxdb-Adapter 5.1.6.
                               
                                 Wichtig: Das alte Statistik-Skript vorher ausschalten (nicht beide gleichzeitig laufen lassen).
                               
                                 Version 1.4.1 (11/2026) – 1.4.1: vorhandene Datenpunkte mit anderem Typ (json/object) werden auf "string" korrigiert
                                                             (Warnung "You are assigning a string to the state ... which expects a object")
                              */
                               
                              // *** User-Einstellungen ***********************************************************************************
                              const WET_DP = '0_userdata.0.Wetterstation';           // wo liegen die Datenpunkte der Wetterstation (wie im Wetterstation-Skript) [default: 0_userdata.0.Wetterstation]
                              const INFLUX = 'influxdb.0';                           // Instanz des influxdb-Adapters
                              const BUCKET = 'iobroker';                             // Name des Buckets
                              const ZIEL_DP = '0_userdata.0.Statistik.Wetter';       // wohin die Statistik geschrieben wird (wie PRE_DP im SBorg-Skript)
                              const ALT_DP = ZIEL_DP;                                // Monate/Jahre VOR Beginn der Influx-Daten werden von hier übernommen (alte Statistik), sonst leer
                              const TAGE_DP = ZIEL_DP + '.Tage';                     // Tagestabellen <Jahr>.<Monat>
                              const INFLUX_START = '2022-05-04';                     // erster Tag mit Daten in InfluxDB (JJJJ-MM-TT) – unbedingt anpassen!
                              const MIT_SONNE = true;                                // false, wenn Info.Sonnenschein_Tag / Info.Solarenergie_Tag nicht geloggt werden
                              const ZEITZONE = 'Europe/Berlin';                      // für die Tagesgrenzen in Influx
                              const ZEITPLAN = '20 1 * * *';                         // wann rechnen (Minute Stunde * * *) [default 01:20 Uhr]
                              const NACHHOLEN_TAGE = 3;                              // jede Nacht die letzten x Tage neu aus Influx holen
                              const PAUSE_MS = 5000;                                 // Pause zwischen den Monaten beim kompletten Neuladen (schont kleine Influx-Server)
                              const NACHT_MIN_STUNDEN = 9;                           // so viele Stundenwerte (von 12) braucht eine Nacht für die Tropennacht-Prüfung
                              // *** ENDE User-Einstellungen – ab hier nichts mehr ändern **************************************************
                               
                              const VERSION = '1.4.1';
                              const START_TEILE = INFLUX_START.split('-').map(Number);
                              const INFLUX_START_DATUM = new Date(START_TEILE[0], START_TEILE[1] - 1, START_TEILE[2]);
                              // erster vollständiger Monat/Jahr mit Influx-Daten; davor wird aus ALT_DP übernommen
                              const ERSTER_INFLUX_MONAT = (() => { const d = new Date(START_TEILE[0], START_TEILE[1] - 1 + (START_TEILE[2] > 1 ? 1 : 0), 1);
                                  return d.getFullYear() + '.' + (d.getMonth() < 9 ? '0' : '') + (d.getMonth() + 1); })();
                              const ERSTES_INFLUX_JAHR = (START_TEILE[1] === 1 && START_TEILE[2] === 1) ? START_TEILE[0] : START_TEILE[0] + 1;
                               
                              const MONATSNAME = ['Januar','Februar','März','April','Mai','Juni','Juli','August','September','Oktober','November','Dezember'];
                              const pad = n => (n < 10 ? '0' : '') + n;
                              const tagKey = d => d.getFullYear() + '-' + pad(d.getMonth() + 1) + '-' + pad(d.getDate());
                              const monatKey = d => d.getFullYear() + '.' + pad(d.getMonth() + 1);
                              const r2 = x => Math.round(x * 100) / 100;
                               
                              let laeuft = false;
                               
                              function abfrage(flux) {
                                  return new Promise((resolve, reject) => {
                                      sendTo(INFLUX, 'query', flux, { timeout: 60000 }, res => {
                                          if (!res || res.error) { reject(new Error(res ? String(res.error) : 'keine Antwort von ' + INFLUX)); return; }
                                          const zeilen = Array.isArray(res.result) && Array.isArray(res.result[0]) ? res.result[0] : (res.result || []);
                                          resolve(zeilen);
                                      });
                                  });
                              }
                               
                              function flux(messwert, every, fn, start, stop, offset) {
                                  return 'from(bucket: "' + BUCKET + '") |> range(start: ' + Math.floor(start / 1000) + ', stop: ' + Math.floor(stop / 1000) + ')'
                                      + ' |> filter(fn: (r) => r._measurement == "' + WET_DP + '.' + messwert + '" and r._field == "value")'
                                      + ' |> aggregateWindow(every: ' + every + ', fn: ' + fn + (offset ? ', offset: ' + offset : '')
                                      + ', createEmpty: false, timeSrc: "_start", location: {zone: "' + ZEITZONE + '", offset: 0s})'
                                      + ' |> keep(columns: ["_time", "_value"])';
                              }
                               
                              const zeit = z => (typeof z.ts === 'number' ? z.ts : Date.parse(z._time));
                               
                              // Tageswerte für einen Zeitraum aus Influx (lokale Kalendertage): { 'JJJJ-MM-TT': [tmin, tmax, tmit, wind, regen, tropennacht 0/1, sonne s, solar Wh/m²] }
                              // Abfragen nacheinander und nur für kurze Zeiträume (die ganze Historie auf einmal kann einen kleinen Influx-Server überlasten)
                              async function bereichHolen(start, stop) {
                                  const tmin = await abfrage(flux('Aussentemperatur', '1d', 'min', start, stop));
                                  const tmax = await abfrage(flux('Aussentemperatur', '1d', 'max', start, stop));
                                  const tmit = await abfrage(flux('Aussentemperatur', '1d', 'mean', start, stop));
                                  const wind = await abfrage(flux('Wind_max', '1d', 'max', start, stop));
                                  // Regen +72 s: der Tageszähler der Station springt erst kurz nach Mitternacht auf 0 (wie im SBorg-Skript). Auch der Bereich beginnt 72 s später,
                                  // sonst landet der alte Vortageswert von 00:00 im ersten (abgeschnittenen) Fenster
                                  const regen = await abfrage(flux('Regen_Tag', '1d', 'max', start + 72000, stop, '72s'));
                                  const stunden = await abfrage(flux('Aussentemperatur', '1h', 'min', start - 6 * 3600000, stop));
                                  // Tageszähler Sonnenschein (Sekunden) und Solarenergie (Wh/m²): wie Regen mit 72 s Versatz. Bewusst nicht Info.*_VorTag:
                                  // der wird um 23:58 geloggt und ist manchmal noch der Wert vom Tag davor oder 0
                                  const sonne = MIT_SONNE ? await abfrage(flux('Info.Sonnenschein_Tag', '1d', 'max', start + 72000, stop, '72s')) : [];
                                  const solar = MIT_SONNE ? await abfrage(flux('Info.Solarenergie_Tag', '1d', 'max', start + 72000, stop, '72s')) : [];
                                  const tage = {};
                                  const tag = z => { const k = tagKey(new Date(zeit(z))); if (!tage[k]) tage[k] = {}; return tage[k]; };
                                  tmin.forEach(z => { if (typeof z._value === 'number') tag(z).tmin = z._value; });
                                  tmax.forEach(z => { if (typeof z._value === 'number') tag(z).tmax = z._value; });
                                  tmit.forEach(z => { if (typeof z._value === 'number') tag(z).tmit = r2(z._value); });
                                  const zusatz = {};
                                  const merke = (liste, feld) => liste.forEach(z => {
                                      if (typeof z._value !== 'number') return;
                                      const k = tagKey(new Date(zeit(z)));
                                      if (!zusatz[k]) zusatz[k] = {};
                                      zusatz[k][feld] = Math.max(zusatz[k][feld] || 0, z._value);
                                  });
                                  merke(wind, 'wind');
                                  merke(regen, 'regen');
                                  merke(sonne, 'sonne');
                                  merke(solar, 'solar');
                                  // Nacht 18–06 Uhr: Stundenminima ab 18 Uhr zählen zum nächsten Tag (Morgen)
                                  const naechte = {};
                                  stunden.forEach(z => {
                                      if (typeof z._value !== 'number') return;
                                      const d = new Date(zeit(z)), h = d.getHours();
                                      let morgen;
                                      if (h >= 18) morgen = new Date(d.getFullYear(), d.getMonth(), d.getDate() + 1);
                                      else if (h < 6) morgen = d;
                                      else return;
                                      const k = tagKey(morgen);
                                      if (!naechte[k]) naechte[k] = { min: 99, n: 0 };
                                      naechte[k].min = Math.min(naechte[k].min, z._value);
                                      naechte[k].n++;
                                  });
                                  const erg = {};
                                  Object.keys(tage).forEach(k => {
                                      const t = tage[k];
                                      if (typeof t.tmin !== 'number' || typeof t.tmax !== 'number' || typeof t.tmit !== 'number') return;
                                      const [j, m, d] = k.split('-').map(Number);
                                      const datum = new Date(j, m - 1, d).getTime();
                                      if (datum < start || datum >= stop) return;
                                      const z = zusatz[k] || {};
                                      const n = naechte[k];
                                      erg[k] = [t.tmin, t.tmax, t.tmit, z.wind || 0, z.regen || 0, (n && n.n >= NACHT_MIN_STUNDEN && n.min >= 20) ? 1 : 0, z.sonne || 0, z.solar || 0];
                                  });
                                  return erg;
                              }
                               
                              const pause = ms => new Promise(r => setTimeout(r, ms));
                               
                              // Tagesarchiv (Control.Tagesarchiv): wird beim ersten Start bzw. per Neu_berechnen monatsweise gefüllt,
                              // danach jede Nacht nur um die letzten Tage ergänzt (die letzten NACHHOLEN_TAGE werden neu geholt).
                              async function archivAktualisieren(heute, komplett) {
                                  const id = ZIEL_DP + '.Control.Tagesarchiv';
                                  let archiv = {};
                                  if (!komplett && existsState(id)) { try { archiv = JSON.parse(getState(id).val || '{}'); } catch (e) { archiv = {}; } }
                                  if (Object.keys(archiv).some(k => archiv[k].length < 8)) archiv = {};   // altes Archivformat (ohne Sonne/Solar) → neu laden
                                  const stop = heute.getTime();
                                  if (!Object.keys(archiv).length) {
                                      // Nachladen Monat für Monat, mit Pause dazwischen
                                      let von = new Date(INFLUX_START_DATUM.getFullYear(), INFLUX_START_DATUM.getMonth(), 1);
                                      while (von.getTime() < stop) {
                                          const bis = new Date(von.getFullYear(), von.getMonth() + 1, 1);
                                          await schreibe('Control.Statusmeldung', 'lade Historie ' + monatKey(von) + ' …', S('Statusmeldungen'));
                                          Object.assign(archiv, await bereichHolen(von.getTime(), Math.min(bis.getTime(), stop)));
                                          von = bis;
                                          await pause(PAUSE_MS);
                                      }
                                  } else {
                                      const von = new Date(heute.getFullYear(), heute.getMonth(), heute.getDate() - NACHHOLEN_TAGE);
                                      Object.assign(archiv, await bereichHolen(von.getTime(), stop));
                                  }
                                  const sortiert = {};
                                  Object.keys(archiv).sort().forEach(k => { sortiert[k] = archiv[k]; });
                                  await schreibe('Control.Tagesarchiv', JSON.stringify(sortiert), S('Tageswerte aus InfluxDB [tmin, tmax, tmit, wind, regen, tropennacht, sonne s, solar Wh/m²]', 'json'));
                                  return Object.keys(sortiert).filter(k => new Date(k + 'T00:00:00').getTime() < stop).map(k => {
                                      const [j, m, d] = k.split('-').map(Number);
                                      const datum = new Date(j, m - 1, d), a = sortiert[k];
                                      return { key: k, datum: datum, monat: monatKey(datum), jahr: j, tmin: a[0], tmax: a[1], tmit: a[2], wind: a[3], regen: a[4], tropennacht: a[5] === 1, sonne: a[6], solar: a[7] };
                                  });
                              }
                               
                              // Kenntage und Extremwerte über eine Liste von Tagen
                              function auswerten(tage) {
                                  if (!tage.length) return null;
                                  const a = {
                                      Tiefstwert: Math.min(...tage.map(t => t.tmin)),
                                      Hoechstwert: Math.max(...tage.map(t => t.tmax)),
                                      Temp_Durchschnitt: r2(tage.reduce((s, t) => s + t.tmit, 0) / tage.length),
                                      Max_Windboee: Math.max(...tage.map(t => t.wind)),
                                      Max_Regenmenge: Math.max(...tage.map(t => t.regen)),
                                      Regenmenge_Monat: r2(tage.reduce((s, t) => s + t.regen, 0)),
                                      warme_Tage: 0, Sommertage: 0, heisse_Tage: 0, Frost_Tage: 0, kalte_Tage: 0, Eistage: 0,
                                      sehr_kalte_Tage: 0, Wuestentage: 0, Tropennaechte: 0, Regentage: 0
                                  };
                                  tage.forEach(t => {
                                      if (t.tmax > 20) a.warme_Tage++;
                                      if (t.tmax >= 25) a.Sommertage++;
                                      if (t.tmax >= 30) a.heisse_Tage++;
                                      if (t.tmin < 0) a.Frost_Tage++;
                                      if (t.tmax < 10) a.kalte_Tage++;
                                      if (t.tmax < 0) a.Eistage++;
                                      if (t.tmin < -10) a.sehr_kalte_Tage++;
                                      if (t.tmax >= 35) a.Wuestentage++;
                                      if (t.tropennacht) a.Tropennaechte++;
                                      if (t.regen >= 0.1) a.Regentage++;
                                  });
                                  return a;
                              }
                               
                              // Trockenperioden: für jeden Tag die Länge der laufenden Folge ohne Regentag (Folge darf über den Jahreswechsel gehen)
                              function trockenFolgen(alleTage) {
                                  let lauf = 0, vorher = null;
                                  alleTage.forEach(t => {
                                      if (vorher && (t.datum - vorher.datum) > 26 * 3600000) lauf = 0;   // Datenlücke unterbricht
                                      lauf = t.regen >= 0.1 ? 0 : lauf + 1;
                                      t.trocken = lauf;
                                      vorher = t;
                                  });
                              }
                               
                              function rekordText(wert, einheit, datum) {
                                  if (einheit === 'Tage' && wert === 1) einheit = 'Tag';
                                  return wert + ' ' + einheit + ' im ' + MONATSNAME[datum.getMonth()] + ' ' + datum.getFullYear();
                              }
                               
                              // Datenpunkt anlegen/schreiben, nur bei Änderung
                              async function schreibe(id, wert, common) {
                                  await schreibeVoll(ZIEL_DP + '.' + id, wert, common);
                              }
                               
                              // wie schreibe(), aber mit voller ID (auch für die Tagestabellen).
                              // Hat ein vorhandener Datenpunkt einen anderen Typ (z. B. "json"/"object" statt "string"), wird nur der Typ
                              // im Objekt korrigiert – Wert und Historie bleiben, nichts muss gelöscht werden (1.4.1)
                              async function schreibeVoll(voll, wert, common) {
                                  if (!existsState(voll)) {
                                      await createStateAsync(voll, wert, Object.assign({ read: true, write: false }, common));
                                      await setStateAsync(voll, wert, true);
                                      return;
                                  }
                                  const obj = getObject(voll);
                                  if (obj && obj.common && common.type && obj.common.type !== common.type) {
                                      log('Statistik_aus_Influx: Typ von ' + voll + ' korrigiert: ' + obj.common.type + ' -> ' + common.type, 'info');
                                      await extendObjectAsync(voll, { common: { type: common.type, role: common.role } });
                                  }
                                  const s = getState(voll);
                                  if (!s || s.val !== wert) await setStateAsync(voll, wert, true);
                              }
                               
                              // alte Werte können als Objekt statt als Text gespeichert sein → immer als JSON-Text weitergeben
                              const alsText = v => (typeof v === 'string' ? v : JSON.stringify(v));
                               
                              const N = (name, unit) => ({ name: name, type: 'number', role: 'value', unit: unit });
                              const S = (name, role) => ({ name: name, type: 'string', role: role || 'text' });
                               
                              const MONATSFELDER = [
                                  ['Tiefstwert', 'niedrigste Temperatur', '°C'], ['Hoechstwert', 'höchste Temperatur', '°C'],
                                  ['Temperatur_Durchschnitt', 'Durchschnittstemperatur', '°C', 'Temp_Durchschnitt'],
                                  ['Max_Windboee', 'stärkste Windböe', 'km/h'], ['Max_Regenmenge', 'maximale Regenmenge pro Tag', 'l/m²'],
                                  ['Regenmenge_Monat', 'Regenmenge im Monat', 'l/m²'],
                                  ['warme_Tage', 'Tage mit Höchstwert über 20 °C', 'Tage'], ['Sommertage', 'Tage mit Höchstwert ab 25 °C', 'Tage'],
                                  ['heisse_Tage', 'Tage mit Höchstwert ab 30 °C', 'Tage'], ['Frost_Tage', 'Tage mit Tiefstwert unter 0 °C', 'Tage'],
                                  ['kalte_Tage', 'Tage mit Höchstwert unter 10 °C', 'Tage'], ['Eistage', 'Tage mit Höchstwert unter 0 °C', 'Tage'],
                                  ['sehr_kalte_Tage', 'Tage mit Tiefstwert unter -10 °C', 'Tage'], ['Wuestentage', 'Tage mit Höchstwert ab 35 °C', 'Tage'],
                                  ['Tropennaechte', 'Nächte (18–06 Uhr) nicht unter 20 °C', 'Tage'], ['Regentage', 'Tage mit mindestens 0,1 l/m²', 'Tage']
                              ];
                               
                              // gleiche Feldreihenfolge wie SBorg in Data.<Jahr>.<Monat>
                              function monatsJson(a) {
                                  return JSON.stringify([{
                                      Tiefstwert: a.Tiefstwert, Hoechstwert: a.Hoechstwert, Temp_Durchschnitt: a.Temp_Durchschnitt, Max_Windboee: a.Max_Windboee,
                                      Max_Regenmenge: a.Max_Regenmenge, Regenmenge_Monat: a.Regenmenge_Monat, warme_Tage: a.warme_Tage, Sommertage: a.Sommertage,
                                      heisse_Tage: a.heisse_Tage, Frost_Tage: a.Frost_Tage, kalte_Tage: a.kalte_Tage, Eistage: a.Eistage, sehr_kalte_Tage: a.sehr_kalte_Tage,
                                      Wuestentage: a.Wuestentage, Tropennaechte: a.Tropennaechte, Regentage: a.Regentage
                                  }]);
                              }
                               
                              async function main(komplett) {
                                  if (laeuft) return;
                                  laeuft = true;
                                  const beginn = Date.now();
                                  try {
                                      const jetzt = new Date();
                                      const heute = new Date(jetzt.getFullYear(), jetzt.getMonth(), jetzt.getDate());
                                      const gestern = new Date(heute.getFullYear(), heute.getMonth(), heute.getDate() - 1);
                                      const J = heute.getFullYear(), aktMonat = monatKey(heute);
                               
                                      const alleTage = await archivAktualisieren(heute, komplett === true);
                                      if (!alleTage.length) throw new Error('keine Tageswerte aus InfluxDB');
                                      trockenFolgen(alleTage);
                               
                                      // Monate
                                      const proMonat = {};
                                      alleTage.forEach(t => { (proMonat[t.monat] = proMonat[t.monat] || []).push(t); });
                                      const monate = {};   // Monatskey -> Auswertung (abgeschlossene Monate)
                                      Object.keys(proMonat).forEach(m => { if (m >= ERSTER_INFLUX_MONAT && m < aktMonat) monate[m] = auswerten(proMonat[m]); });
                               
                                      // Data.<Jahr>.<Monat>: vor Influx aus ALT_DP übernehmen
                                      const dataJson = {};
                                      $(ALT_DP + '.Data.*').each(id => {
                                          const m = id.substring((ALT_DP + '.Data.').length);
                                          if (/^\d{4}\.\d{2}$/.test(m) && m < ERSTER_INFLUX_MONAT) { const s = getState(id); if (s && s.val) dataJson[m] = alsText(s.val); }
                                      });
                                      Object.keys(monate).forEach(m => { dataJson[m] = monatsJson(monate[m]); });
                                      for (const m of Object.keys(dataJson).sort()) {
                                          const [j, mm] = m.split('.');
                                          await schreibe('Data.' + m, dataJson[m], S('Monatsstatistik für ' + MONATSNAME[Number(mm) - 1] + ' ' + j, 'json'));
                                      }
                               
                                      // Tagestabellen (ein Eintrag je Tag, Sonnenscheindauer in Minuten)
                                      for (const m of Object.keys(proMonat).sort()) {
                                          const [j, mm] = m.split('.');
                                          if (m < ERSTER_INFLUX_MONAT && existsState(TAGE_DP + '.' + j + '.' + mm)) continue;   // angefangenen ersten Monat nicht überschreiben, falls schon eine Tabelle da ist
                                          const text = '[' + proMonat[m].map(t => JSON.stringify({
                                              Tiefstwert: t.tmin, Hoechstwert: t.tmax, Durchschnitt: t.tmit, Max_Windboee: t.wind,
                                              Regenmenge_Tag: t.regen, Sonnenscheindauer: Math.floor(t.sonne / 60), SonnenEnergie: t.solar })).join(', ') + ']';
                                          await schreibeVoll(TAGE_DP + '.' + j + '.' + mm, text, S('Tageswerte ' + MONATSNAME[Number(mm) - 1] + ' ' + j, 'json'));
                                      }
                               
                                      // VorTag
                                      const vt = alleTage[alleTage.length - 1];
                                      if (vt.key !== tagKey(gestern)) log('Statistik_aus_Influx: keine Daten für gestern, letzter Tag ' + vt.key, 'warn');
                                      await schreibe('VorTag.Temperatur_Tiefstwert', vt.tmin, N('niedrigste Tagestemperatur', '°C'));
                                      await schreibe('VorTag.Temperatur_Hoechstwert', vt.tmax, N('höchste Tagestemperatur', '°C'));
                                      await schreibe('VorTag.Temperatur_Durchschnitt', vt.tmit, N('Durchschnittstemperatur', '°C'));
                                      await schreibe('VorTag.Regenmenge', vt.regen, N('Regenmenge vom Vortag', 'l/m²'));
                                      await schreibe('VorTag.Windboee_max', vt.wind, N('stärkste Windböe vom Vortag', 'km/h'));
                               
                                      // aktueller Monat (Tage bis gestern); am Monatsersten wie im Original: aktuelle Temperatur, Rest 0
                                      let am = auswerten(proMonat[aktMonat] || []);
                                      if (!am) {
                                          const t0 = getState(WET_DP + '.Aussentemperatur').val;
                                          am = auswerten([{ tmin: t0, tmax: t0, tmit: t0, wind: 0, regen: 0, tropennacht: false }]);
                                          MONATSFELDER.forEach(f => { if (f[2] === 'Tage') am[f[0]] = 0; });
                                      }
                                      for (const f of MONATSFELDER) await schreibe('aktueller_Monat.' + f[0], am[f[3] || f[0]], N(f[1], f[2]));
                               
                                      // Vorjahresmonat
                                      const vjKey = (J - 1) + '.' + pad(heute.getMonth() + 1);
                                      let vj = null;
                                      if (dataJson[vjKey]) { try { vj = JSON.parse(dataJson[vjKey])[0]; } catch (e) { vj = null; } }
                                      for (const f of MONATSFELDER) {
                                          const w = vj && typeof vj[f[3] || f[0]] === 'number' ? vj[f[3] || f[0]] : 99999;
                                          await schreibe('Vorjahres_Monat.' + f[0], w, N(f[1], f[2]));
                                      }
                               
                                      // Jahreswerte
                                      const jahrWerte = jahr => {
                                          const tage = alleTage.filter(t => t.jahr === jahr);
                                          const a = auswerten(tage);
                                          if (!a) return null;
                                          a.Trockenperiode = Math.max(0, ...tage.map(t => t.trocken));
                                          const mon = Object.keys(monate).filter(m => m.startsWith(jahr + '.')).map(m => monate[m].Regenmenge_Monat);
                                          a.Regenmengemonat = mon.length ? Math.max(...mon) : 0;
                                          return a;
                                      };
                                      let jw = jahrWerte(J);
                                      if (!jw) jw = { Tiefstwert: 100, Hoechstwert: -100, Temp_Durchschnitt: 0, Trockenperiode: 0, Max_Regenmenge: 0, Regenmengemonat: 0,
                                                      Max_Windboee: 0, Regenmenge_Monat: 0 };
                                      const T = 'Tage';
                                      const JF = [
                                          ['Temperatur_Hoechstwert', jw.Hoechstwert, 'höchste Tagestemperatur des Jahres', '°C'],
                                          ['Temperatur_Tiefstwert', jw.Tiefstwert, 'niedrigste Tagestemperatur des Jahres', '°C'],
                                          ['Temperatur_Durchschnitt', jw.Temp_Durchschnitt, 'Durchschnittstemperatur des Jahres', '°C'],
                                          ['Trockenperiode', jw.Trockenperiode, 'längste Periode ohne Regen', T],
                                          ['Regenmengetag', jw.Max_Regenmenge, 'höchste Regenmenge an einem Tag', 'l/m²'],
                                          ['Regenmengemonat', jw.Regenmengemonat, 'höchste Regenmenge eines abgeschlossenen Monats', 'l/m²'],
                                          ['Windboee_max', jw.Max_Windboee, 'stärkste Windböe des Jahres', 'km/h'],
                                          ['Gradtage_kalteTage', jw.kalte_Tage || 0, 'Tage mit Höchstwert unter 10 °C', T],
                                          ['Gradtage_warmeTage', jw.warme_Tage || 0, 'Tage mit Höchstwert über 20 °C', T],
                                          ['Gradtage_Sommertage', jw.Sommertage || 0, 'Tage mit Höchstwert ab 25 °C', T],
                                          ['Gradtage_heisseTage', jw.heisse_Tage || 0, 'Tage mit Höchstwert ab 30 °C', T],
                                          ['Gradtage_Frosttage', jw.Frost_Tage || 0, 'Tage mit Tiefstwert unter 0 °C', T],
                                          ['Gradtage_Eistage', jw.Eistage || 0, 'Tage mit Höchstwert unter 0 °C', T],
                                          ['Gradtage_sehrkalteTage', jw.sehr_kalte_Tage || 0, 'Tage mit Tiefstwert unter -10 °C', T],
                                          ['Gradtage_Wuestentage', jw.Wuestentage || 0, 'Tage mit Höchstwert ab 35 °C', T],
                                          ['Gradtage_Tropennaechte', jw.Tropennaechte || 0, 'Nächte (18–06 Uhr) nicht unter 20 °C', T],
                                          ['Regentage', jw.Regentage || 0, 'Regentage im Jahr', T],
                                          ['Regensumme_Tage', jw.Regenmenge_Monat || 0, 'Summe der Tagesregenmengen im Jahr (Vergleichswert)', 'l/m²']
                                      ];
                                      for (const f of JF) await schreibe('Jahreswerte.' + f[0], f[1], N(f[2], f[3]));
                               
                                      // Vorjahre (gleiche Schlüssel/Reihenfolge wie SBorg)
                                      const jahre = [];
                                      for (let j = ERSTES_INFLUX_JAHR; j < J; j++) jahre.push(j);
                                      const altJahre = [];
                                      $(ALT_DP + '.Jahreswerte.VorJahre.*').each(id => { altJahre.push(id); });
                                      for (const id of altJahre) {
                                          const j = Number(id.split('.').pop());
                                          if (j < ERSTES_INFLUX_JAHR) { const s = getState(id); if (s && s.val) await schreibe('Jahreswerte.VorJahre.' + j, alsText(s.val), S('Jahresstatistik ' + j, 'json')); }
                                      }
                                      const jahresDurchschnitt = {};
                                      for (const j of jahre) {
                                          const a = jahrWerte(j);
                                          if (!a) continue;
                                          jahresDurchschnitt[j] = a.Temp_Durchschnitt;
                                          const json = JSON.stringify({ forecast: [{
                                              'Temperatur Tiefstwert': a.Tiefstwert, 'Temperatur Höchstwert': a.Hoechstwert, 'Temperatur Durchschnitt': a.Temp_Durchschnitt,
                                              'Regenmengetag': a.Max_Regenmenge, 'höchste Regenmengemonat': a.Regenmengemonat, 'Windböe': a.Max_Windboee,
                                              'Trockenperiode': a.Trockenperiode, 'kalte Tage': a.kalte_Tage, 'warme Tage': a.warme_Tage, 'Sommertage': a.Sommertage,
                                              'heiße Tage': a.heisse_Tage, 'Frosttage': a.Frost_Tage, 'Eistage': a.Eistage, 'sehr kalte Tage': a.sehr_kalte_Tage,
                                              'Wuestentage': a.Wuestentage, 'Tropennaechte': a.Tropennaechte, 'Regentage': a.Regentage }] });
                                          await schreibe('Jahreswerte.VorJahre.' + j, json, S('Jahresstatistik ' + j, 'json'));
                                      }
                               
                                      // Rekorde (nur Influx-Zeitraum; bei Gleichstand zählt das erste Auftreten)
                                      const rekord = (feld, groesser) => {
                                          let best = null;
                                          alleTage.forEach(t => { if (best === null || (groesser ? t[feld] > best[feld] : t[feld] < best[feld])) best = t; });
                                          return best;
                                      };
                                      const rMax = rekord('tmax', true), rMin = rekord('tmin', false), rRegen = rekord('regen', true), rWind = rekord('wind', true), rTrocken = rekord('trocken', true);
                                      let rMonat = null;
                                      Object.keys(proMonat).sort().forEach(m => {
                                          const s = r2(proMonat[m].reduce((x, t) => x + t.regen, 0));
                                          if (!rMonat || s > rMonat.wert) rMonat = { wert: s, datum: proMonat[m][0].datum };
                                      });
                                      const RW = [
                                          ['Temp_Max', 'Temperatur_Spitzenhoechstwert', rMax.tmax, '°C', rMax.datum, 'höchste je gemessene Tagestemperatur'],
                                          ['Temp_Min', 'Temperatur_Spitzentiefstwert', rMin.tmin, '°C', rMin.datum, 'niedrigste je gemessene Tagestemperatur'],
                                          ['Regenmengetag', 'Regenmengetag', rRegen.regen, 'l/m²', rRegen.datum, 'höchste je gemessene Regenmenge an einem Tag'],
                                          ['Regenmengemonat', 'Regenmengemonat', rMonat.wert, 'l/m²', rMonat.datum, 'höchste je gemessene Regenmenge eines Monats'],
                                          ['Windboee', 'Windboee', rWind.wind, 'km/h', rWind.datum, 'stärkste je gemessene Windböe'],
                                          ['Trockenperiode', 'Trockenperiode', rTrocken.trocken, 'Tage', rTrocken.datum, 'längste je andauernde Trockenperiode']
                                      ];
                                      for (const r of RW) {
                                          await schreibe('Rekordwerte.value.' + r[0], r[2], N(r[5], r[3]));
                                          await schreibe('Rekordwerte.' + r[1], rekordText(r[2], r[3], r[4]), S(r[5]));
                                      }
                                      const jd = Object.keys(jahresDurchschnitt).map(Number);
                                      if (jd.length) {
                                          let jMax = jd[0], jMin = jd[0];
                                          jd.forEach(j => { if (jahresDurchschnitt[j] > jahresDurchschnitt[jMax]) jMax = j; if (jahresDurchschnitt[j] < jahresDurchschnitt[jMin]) jMin = j; });
                                          await schreibe('Rekordwerte.value.Temp_Durchschnitt_Max', jahresDurchschnitt[jMax], N('höchster Jahrestemperaturdurchschnitt', '°C'));
                                          await schreibe('Rekordwerte.value.Temp_Durchschnitt_Min', jahresDurchschnitt[jMin], N('niedrigster Jahrestemperaturdurchschnitt', '°C'));
                                          await schreibe('Rekordwerte.Temperatur_Jahresdurchschnitt_Max', jahresDurchschnitt[jMax] + ' °C für ' + jMax, S('höchster Jahrestemperaturdurchschnitt'));
                                          await schreibe('Rekordwerte.Temperatur_Jahresdurchschnitt_Min', jahresDurchschnitt[jMin] + ' °C für ' + jMin, S('niedrigster Jahrestemperaturdurchschnitt'));
                                      }
                               
                                      const dauer = Math.round((Date.now() - beginn) / 1000);
                                      await schreibe('Control.ScriptVersion', VERSION, S('Version von Statistik_aus_Influx'));
                                      await schreibe('Control.Letzter_Lauf', new Date().toISOString(), S('Zeitpunkt des letzten Laufs', 'date'));
                                      await schreibe('Control.Statusmeldung', 'erfolgreich: ' + alleTage.length + ' Tage ' + alleTage[0].key + ' bis ' + vt.key + ', ' + dauer + ' s', S('Statusmeldungen'));
                                  } catch (e) {
                                      log('Statistik_aus_Influx: ' + e.message, 'error');
                                      try { await schreibe('Control.Statusmeldung', 'Fehler: ' + e.message, S('Statusmeldungen')); } catch (e2) { /* nichts */ }
                                  } finally {
                                      laeuft = false;
                                  }
                              }
                               
                              schedule(ZEITPLAN, () => main(false));
                              // Knopf zum sofortigen Neuberechnen
                              createState(ZIEL_DP + '.Control.Neu_berechnen', false, { name: 'Statistik jetzt neu berechnen', type: 'boolean', role: 'button', read: true, write: true }, () => {
                                  on({ id: ZIEL_DP + '.Control.Neu_berechnen', val: true, ack: false }, () => { setState(ZIEL_DP + '.Control.Neu_berechnen', false, true); main(true); });
                              });
                              setTimeout(() => main(false), 3000);
                               
                              
                              1 Antwort Letzte Antwort
                              1

                              Hey! Du scheinst an dieser Unterhaltung interessiert zu sein, hast aber noch kein Konto.

                              Hast du es satt, bei jedem Besuch durch die gleichen Beiträge zu scrollen? Wenn du dich für ein Konto anmeldest, kommst du immer genau dorthin zurück, wo du zuvor warst, und kannst dich über neue Antworten benachrichtigen lassen (entweder per E-Mail oder Push-Benachrichtigung). Du kannst auch Lesezeichen speichern und Beiträge positiv bewerten, um anderen Community-Mitgliedern deine Wertschätzung zu zeigen.

                              Mit deinem Input könnte dieser Beitrag noch besser werden 💗

                              Registrieren Anmelden
                              Antworten
                              • In einem neuen Thema antworten
                              Anmelden zum Antworten
                              • Älteste zuerst
                              • Neuste zuerst
                              • Meiste Stimmen


                              Support us

                              ioBroker
                              Community Adapters
                              Donate

                              545

                              Online

                              33.2k

                              Benutzer

                              84.3k

                              Themen

                              1.4m

                              Beiträge
                              Community
                              Impressum | Datenschutz-Bestimmungen | Nutzungsbedingungen | Einwilligungseinstellungen
                              ioBroker Community 2014-2026
                              logo
                              • Anmelden

                              • Du hast noch kein Konto? Registrieren

                              • Anmelden oder registrieren, um zu suchen
                              • Erster Beitrag
                                Letzter Beitrag
                              0
                              • Home
                              • Aktuell
                              • Ungelesen 0
                              • Kategorien
                              • Unreplied
                              • Beliebt
                              • GitHub
                              • Docu
                              • Hilfe