@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.0 (11/2026)
*/
// *** 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.0';
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) {
const voll = ZIEL_DP + '.' + id;
if (!existsState(voll)) {
await createStateAsync(voll, wert, Object.assign({ read: true, write: false }, common));
await setStateAsync(voll, wert, true);
return;
}
const s = getState(voll);
if (!s || s.val !== wert) await setStateAsync(voll, wert, true);
}
// wie schreibe(), aber mit voller ID (für die Tagestabellen)
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 s = getState(voll);
if (!s || s.val !== wert) await setStateAsync(voll, wert, true);
}
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] = 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, { name: 'Tageswerte ' + MONATSNAME[Number(mm) - 1] + ' ' + j, type: 'json', role: '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, 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);