iobroker.poolcontrol 1.3.32 → 1.3.34

package/lib/helpers/chemistryTdsHelper.js

@@ -2,8 +2,14 @@
 
 const { I18n } = require('@iobroker/adapter-core');
 
-const MAX_HISTORY_AGE_MS = 30 * 24 * 60 * 60 * 1000;
+const MAX_HISTORY_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+const MAX_HISTORY_SAMPLES = 672;
+const MAX_HISTORY_BYTES = 64 * 1024;
 const MIN_SAMPLE_INTERVAL_MS = 15 * 60 * 1000;
+const MAX_DAILY_HISTORY_AGE_MS = 32 * 24 * 60 * 60 * 1000;
+const MAX_DAILY_HISTORY_SAMPLES = 32;
+const MAX_DAILY_HISTORY_BYTES = 8 * 1024;
+const DAILY_REFERENCE_TOLERANCE_MS = 4 * 24 * 60 * 60 * 1000;
 
 const chemistryTdsHelper = {
     adapter: null,
@@ -170,7 +176,7 @@ const chemistryTdsHelper = {
             return;
         }
 
-        await this._processValue(source, rawValue, reason, true);
+        await this._processValue(source, rawValue, reason, source === 'manual');
     },
 
     _scheduleEvaluation(reason, delayMs = 500) {
@@ -289,7 +295,7 @@ const chemistryTdsHelper = {
 
         const history = await this._updateHistory(value, now, forceSample);
         const reference = await this._updateReference(value, now);
-        const trend = await this._calculateTrend(value, now, history);
+        const trend = await this._calculateTrend(value, now, history.samples, history.dailySamples);
         const evaluation = await this._evaluateTds(value, reference, trend);
 
         await this._writeTrend(trend);
@@ -373,16 +379,17 @@ const chemistryTdsHelper = {
 
     async _updateHistory(value, now, forceSample) {
         let samples = await this._readJsonArray('chemistry.tds.history.samples_json');
+        const dailySeedSamples = samples;
         const nowTs = now.getTime();
         const minTs = nowTs - MAX_HISTORY_AGE_MS;
 
-        samples = samples.filter(
-            sample => sample && Number(sample.ts) >= minTs && Number.isFinite(Number(sample.value)),
-        );
+        samples = samples.filter(sample => sample.ts >= minTs && sample.ts <= nowTs);
 
         const newest = samples.length ? samples[samples.length - 1] : null;
         const newestTs = newest ? Number(newest.ts) : 0;
-        const shouldStore = forceSample || !newest || nowTs - newestTs >= MIN_SAMPLE_INTERVAL_MS;
+        const withinSampleInterval = newest && nowTs - newestTs < MIN_SAMPLE_INTERVAL_MS;
+        const sameValue = newest && Number(newest.value) === value;
+        const shouldStore = !newest || !withinSampleInterval || (forceSample && !sameValue);
 
         if (shouldStore) {
             samples.push({
@@ -392,9 +399,12 @@ const chemistryTdsHelper = {
             });
         }
 
-        samples = samples.filter(sample => sample && Number(sample.ts) >= minTs);
+        samples = samples.filter(sample => sample.ts >= minTs && sample.ts <= nowTs).slice(-MAX_HISTORY_SAMPLES);
+
+        const preparedHistory = this._prepareHistoryForWrite(samples, 'chemistry.tds.history.samples_json');
+        samples = preparedHistory.samples;
 
-        await this._setString('chemistry.tds.history.samples_json', JSON.stringify(samples));
+        await this._setString('chemistry.tds.history.samples_json', preparedHistory.json);
         await this._setNumber('chemistry.tds.history.samples_count', samples.length);
 
         if (samples.length) {
@@ -410,7 +420,8 @@ const chemistryTdsHelper = {
             );
         }
 
-        return samples;
+        const dailySamples = await this._updateDailyHistory(dailySeedSamples, value, now, shouldStore);
+        return { samples, dailySamples };
     },
 
     async _updateReference(value, now) {
@@ -457,12 +468,16 @@ const chemistryTdsHelper = {
         this._scheduleEvaluation('reference_reset', 500);
     },
 
-    async _calculateTrend(currentValue, now, samples) {
+    async _calculateTrend(currentValue, now, samples, dailySamples) {
         const nowTs = now.getTime();
 
         const ref24h = this._findReferenceSample(samples, nowTs - 24 * 60 * 60 * 1000);
         const ref7d = this._findReferenceSample(samples, nowTs - 7 * 24 * 60 * 60 * 1000);
-        const ref30d = this._findReferenceSample(samples, nowTs - 30 * 24 * 60 * 60 * 1000);
+        const ref30d = this._findReferenceSample(
+            dailySamples,
+            nowTs - 30 * 24 * 60 * 60 * 1000,
+            DAILY_REFERENCE_TOLERANCE_MS,
+        );
 
         const delta24h = ref24h ? currentValue - ref24h.value : 0;
         const delta7d = ref7d ? currentValue - ref7d.value : 0;
@@ -483,7 +498,7 @@ const chemistryTdsHelper = {
         };
     },
 
-    _findReferenceSample(samples, targetTs) {
+    _findReferenceSample(samples, targetTs, toleranceMs = null) {
         if (!samples.length) {
             return null;
         }
@@ -493,7 +508,7 @@ const chemistryTdsHelper = {
 
         for (const sample of samples) {
             const ts = Number(sample.ts);
-            const value = Number(sample.value);
+            const value = Number(sample.value ?? sample.last);
 
             if (!Number.isFinite(ts) || !Number.isFinite(value)) {
                 continue;
@@ -511,7 +526,7 @@ const chemistryTdsHelper = {
             }
         }
 
-        return best;
+        return toleranceMs === null || bestDistance <= toleranceMs ? best : null;
     },
 
     _getOverallDirection(ref24h, ref7d, ref30d, delta24h, delta7d, delta30d) {
@@ -768,17 +783,264 @@ const chemistryTdsHelper = {
         return !!state?.val;
     },
 
+    async _updateDailyHistory(shortTermSamples, value, now, sampleStored) {
+        const id = 'chemistry.tds.history.daily_json';
+        let dailySamples = await this._readDailyJson(id);
+        const nowTs = now.getTime();
+        const minTs = nowTs - MAX_DAILY_HISTORY_AGE_MS;
+        const initializeFromSeeds = dailySamples.length === 0;
+
+        if (initializeFromSeeds) {
+            const legacyValueState = await this.adapter.getStateAsync('chemistry.tds.trend.reference_30d_value');
+            const legacyAtState = await this.adapter.getStateAsync('chemistry.tds.trend.reference_30d_at');
+            const legacyValue = Number(legacyValueState?.val);
+            const legacyTs = Number(legacyAtState?.val);
+
+            if (
+                Number.isFinite(legacyValue) &&
+                legacyValue >= 0 &&
+                legacyValue <= 10000 &&
+                Number.isFinite(legacyTs) &&
+                legacyTs >= minTs &&
+                legacyTs <= nowTs &&
+                !shortTermSamples.some(sample => this._dayKey(sample.ts) === this._dayKey(legacyTs))
+            ) {
+                this._addDailySample(dailySamples, legacyTs, legacyValue);
+            }
+
+            for (const sample of shortTermSamples) {
+                if (sample.ts >= minTs && sample.ts <= nowTs) {
+                    this._addDailySample(dailySamples, sample.ts, sample.value);
+                }
+            }
+            if (sampleStored) {
+                this._addDailySample(dailySamples, nowTs, value);
+            }
+        } else if (sampleStored) {
+            this._addDailySample(dailySamples, nowTs, value);
+        }
+
+        dailySamples = dailySamples
+            .filter(sample => sample.ts >= minTs && sample.ts <= nowTs)
+            .sort((a, b) => a.ts - b.ts)
+            .slice(-MAX_DAILY_HISTORY_SAMPLES);
+
+        const preparedHistory = this._prepareDailyHistoryForWrite(dailySamples, id);
+        await this._setString(id, preparedHistory.json);
+        return preparedHistory.samples;
+    },
+
+    _addDailySample(dailySamples, sampleTs, value) {
+        const day = this._dayKey(sampleTs);
+        const existing = dailySamples.find(sample => sample.day === day);
+
+        if (!existing) {
+            dailySamples.push({
+                day,
+                ts: this._dayStartTs(sampleTs),
+                min: value,
+                max: value,
+                avg: value,
+                last: value,
+                count: 1,
+            });
+            return;
+        }
+
+        existing.min = Math.min(existing.min, value);
+        existing.max = Math.max(existing.max, value);
+        existing.avg = (existing.avg * existing.count + value) / (existing.count + 1);
+        existing.last = value;
+        existing.count += 1;
+    },
+
+    async _readDailyJson(id) {
+        const state = await this.adapter.getStateAsync(id);
+        const rawValue = state?.val;
+
+        if (rawValue === null || rawValue === undefined || rawValue === '') {
+            return [];
+        }
+
+        if (typeof rawValue !== 'string') {
+            this.adapter.log.warn(`[chemistryTdsHelper] Ignoring non-string daily history state ${id}.`);
+            return [];
+        }
+
+        if (Buffer.byteLength(rawValue, 'utf8') > MAX_DAILY_HISTORY_BYTES) {
+            this.adapter.log.warn(`[chemistryTdsHelper] Ignoring oversized daily history state ${id} (> 8 KB).`);
+            return [];
+        }
+
+        try {
+            const parsed = JSON.parse(rawValue);
+            if (!Array.isArray(parsed)) {
+                return [];
+            }
+
+            const nowTs = Date.now();
+            const normalized = parsed
+                .map(sample => {
+                    const sourceTs = Number(sample?.ts);
+                    const legacyValue = Number(sample?.value);
+                    const min = Number(sample?.min ?? legacyValue);
+                    const max = Number(sample?.max ?? legacyValue);
+                    const avg = Number(sample?.avg ?? legacyValue);
+                    const last = Number(sample?.last ?? legacyValue);
+                    const count = sample?.count === undefined ? 1 : Number(sample.count);
+
+                    if (!Number.isFinite(sourceTs) || sourceTs <= 0 || sourceTs > nowTs) {
+                        return null;
+                    }
+                    if (
+                        !Number.isFinite(min) ||
+                        !Number.isFinite(max) ||
+                        !Number.isFinite(avg) ||
+                        !Number.isFinite(last) ||
+                        min < 0 ||
+                        max > 10000 ||
+                        min > max ||
+                        avg < min ||
+                        avg > max ||
+                        last < min ||
+                        last > max
+                    ) {
+                        return null;
+                    }
+                    if (!Number.isInteger(count) || count < 1 || count > 1000000) {
+                        return null;
+                    }
+
+                    return {
+                        day: this._dayKey(sourceTs),
+                        ts: this._dayStartTs(sourceTs),
+                        min,
+                        max,
+                        avg,
+                        last,
+                        count,
+                    };
+                })
+                .filter(Boolean)
+                .sort((a, b) => a.ts - b.ts);
+
+            const byDay = new Map();
+            for (const sample of normalized) {
+                if (!byDay.has(sample.day)) {
+                    byDay.set(sample.day, sample);
+                }
+            }
+            return [...byDay.values()].slice(-MAX_DAILY_HISTORY_SAMPLES);
+        } catch {
+            return [];
+        }
+    },
+
+    _prepareDailyHistoryForWrite(samples, id) {
+        let limitedSamples = samples.slice(-MAX_DAILY_HISTORY_SAMPLES);
+        let json = JSON.stringify(limitedSamples);
+        let trimmedForSize = false;
+
+        while (limitedSamples.length && Buffer.byteLength(json, 'utf8') > MAX_DAILY_HISTORY_BYTES) {
+            limitedSamples = limitedSamples.slice(1);
+            json = JSON.stringify(limitedSamples);
+            trimmedForSize = true;
+        }
+
+        if (trimmedForSize) {
+            this.adapter.log.warn(`[chemistryTdsHelper] Daily history ${id} was trimmed to stay within 8 KB.`);
+        }
+
+        if (Buffer.byteLength(json, 'utf8') > MAX_DAILY_HISTORY_BYTES) {
+            this.adapter.log.warn(`[chemistryTdsHelper] Daily history ${id} could not be limited; resetting it.`);
+            return { samples: [], json: '[]' };
+        }
+
+        return { samples: limitedSamples, json };
+    },
+
+    _dayKey(ts) {
+        const date = new Date(ts);
+        const year = String(date.getFullYear());
+        const month = String(date.getMonth() + 1).padStart(2, '0');
+        const day = String(date.getDate()).padStart(2, '0');
+        return [year, month, day].join('-');
+    },
+
+    _dayStartTs(ts) {
+        const date = new Date(ts);
+        date.setHours(0, 0, 0, 0);
+        return date.getTime();
+    },
+
     async _readJsonArray(id) {
         const state = await this.adapter.getStateAsync(id);
+        const rawValue = state?.val;
+
+        if (rawValue === null || rawValue === undefined || rawValue === '') {
+            return [];
+        }
+
+        if (typeof rawValue !== 'string') {
+            this.adapter.log.warn(`[chemistryTdsHelper] Ignoring non-string history state ${id}.`);
+            return [];
+        }
+
+        if (Buffer.byteLength(rawValue, 'utf8') > MAX_HISTORY_BYTES) {
+            this.adapter.log.warn(`[chemistryTdsHelper] Ignoring oversized history state ${id} (> 64 KB).`);
+            return [];
+        }
 
         try {
-            const parsed = JSON.parse(String(state?.val || '[]'));
-            return Array.isArray(parsed) ? parsed : [];
+            const parsed = JSON.parse(rawValue);
+            if (!Array.isArray(parsed)) {
+                return [];
+            }
+
+            const nowTs = Date.now();
+            return parsed
+                .map(sample => {
+                    const ts = Number(sample?.ts);
+                    const value = Number(sample?.value);
+                    if (!Number.isFinite(ts) || ts <= 0 || ts > nowTs) {
+                        return null;
+                    }
+                    if (!Number.isFinite(value) || value < 0 || value > 10000) {
+                        return null;
+                    }
+                    return { ts, time: this._formatDateTime(new Date(ts)), value };
+                })
+                .filter(Boolean)
+                .sort((a, b) => a.ts - b.ts)
+                .slice(-MAX_HISTORY_SAMPLES);
         } catch {
             return [];
         }
     },
 
+    _prepareHistoryForWrite(samples, id) {
+        let limitedSamples = samples.slice(-MAX_HISTORY_SAMPLES);
+        let json = JSON.stringify(limitedSamples);
+        let trimmedForSize = false;
+
+        while (limitedSamples.length && Buffer.byteLength(json, 'utf8') > MAX_HISTORY_BYTES) {
+            limitedSamples = limitedSamples.slice(1);
+            json = JSON.stringify(limitedSamples);
+            trimmedForSize = true;
+        }
+
+        if (trimmedForSize) {
+            this.adapter.log.warn(`[chemistryTdsHelper] History ${id} was trimmed to stay within 64 KB.`);
+        }
+
+        if (Buffer.byteLength(json, 'utf8') > MAX_HISTORY_BYTES) {
+            this.adapter.log.warn(`[chemistryTdsHelper] History ${id} could not be limited safely; resetting it.`);
+            return { samples: [], json: '[]' };
+        }
+
+        return { samples: limitedSamples, json };
+    },
+
     async _setString(id, value) {
         await this.adapter.setStateChangedAsync(id, { val: String(value ?? ''), ack: true });
     },

package/lib/helpers/debugLogHelper.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const MAX_DEBUG_LOG_BYTES = 64 * 1024;
+
 /**
  * debugLogHelper (SystemCheck-Version)
  * - Überwacht nur einen auswählbaren Bereich (z. B. pump.*, solar.*, runtime.*)
@@ -157,9 +159,9 @@ const debugLogHelper = {
             const current = (await this.adapter.getStateAsync('SystemCheck.debug_logs.log'))?.val || '';
             const newVal = current + this.buffer;
             await this.adapter.setStateAsync('SystemCheck.debug_logs.log', {
-                val: newVal.slice(-60000),
+                val: this._truncateUtf8(newVal, MAX_DEBUG_LOG_BYTES),
                 ack: true,
-            }); // max ~60k Zeichen
+            }); // hard limit: 64 KB UTF-8
             this.buffer = '';
             if (this.bufferTimer) {
                 this.adapter.clearTimeout(this.bufferTimer);
@@ -170,6 +172,19 @@ const debugLogHelper = {
         }
     },
 
+    _truncateUtf8(value, maxBytes) {
+        const buffer = Buffer.from(String(value ?? ''), 'utf8');
+        if (buffer.length <= maxBytes) {
+            return String(value ?? '');
+        }
+
+        let start = buffer.length - maxBytes;
+        while (start < buffer.length && (buffer[start] & 0xc0) === 0x80) {
+            start += 1;
+        }
+        return buffer.subarray(start).toString('utf8');
+    },
+
     /**
      * Löscht das Log komplett
      */

package/lib/helpers/runtimeHelper.js

@@ -304,6 +304,9 @@ const runtimeHelper = {
             };
             const write = (id, val) => this.adapter.setStateAsync(`circulation.plausibility.${id}`, { val, ack: true });
 
+            const enabledState = await this.adapter.getStateAsync('circulation.plausibility.000_enabled');
+            const plausibilityEnabled = enabledState?.val === false ? false : true;
+
             const currentPower = await readNumber('pump.current_power');
             const pumpMaxWatt = await readNumber('pump.pump_max_watt');
             const pumpPowerLph = await readNumber('pump.pump_power_lph');
@@ -313,6 +316,25 @@ const runtimeHelper = {
             const previousTotal =
                 this.lastPlausibilityDailyTotal === null ? Number(oldTotal) || 0 : this.lastPlausibilityDailyTotal;
 
+            if (!plausibilityEnabled) {
+                await write('00_status', 'disabled');
+                await write('01_level', 'info');
+                await write('02_message_key', 'circulation_plausibility_disabled');
+                await write('03_last_update', nowIso);
+                await write('10_power_warning', false);
+                await write('20_flow_warning', false);
+                await write('30_jump_warning', false);
+                await write('40_last_daily_total', previousTotal);
+                await write('41_current_daily_total', currentTotal);
+                await write('42_delta_liters', 0);
+                await write('43_elapsed_seconds', 0);
+                await write('44_max_plausible_delta_liters', 0);
+
+                this.lastPlausibilityDailyTotal = currentTotal;
+                this.lastPlausibilityCheckTs = nowMs;
+                return;
+            }
+
             const powerLimit = pumpMaxWatt > 0 ? pumpMaxWatt * 1.2 : 0;
             const flowLimit = pumpPowerLph > 0 ? pumpPowerLph * 1.2 : 0;
             let powerWarning = currentPower > 0 && powerLimit > 0 && currentPower > powerLimit;

package/lib/helpers/solarExtendedHelper.js

@@ -69,6 +69,35 @@ const solarExtendedHelper = {
             const isTimePriority = activeHelper === 'timeHelper';
             const actorConfigOk = controlObjectId !== '' && (controlType === 'boolean' || controlType === 'socket');
 
+            const poolReferenceStateId =
+                poolTemperatureSource === 'ground'
+                    ? 'temperature.ground.current'
+                    : poolTemperatureSource === 'surface'
+                      ? 'temperature.surface.current'
+                      : '';
+            const collectorDeltaState = await this.adapter.getStateAsync('temperature.collector.current');
+            const poolReferenceDeltaState = poolReferenceStateId
+                ? await this.adapter.getStateAsync(poolReferenceStateId)
+                : null;
+            const collectorDeltaValue = collectorDeltaState?.val;
+            const poolReferenceDeltaValue = poolReferenceDeltaState?.val;
+            const collectorDeltaNumber = Number(collectorDeltaValue);
+            const poolReferenceDeltaNumber = Number(poolReferenceDeltaValue);
+            const extendedDeltaValid =
+                collectorDeltaValue !== null &&
+                collectorDeltaValue !== undefined &&
+                collectorDeltaValue !== '' &&
+                poolReferenceDeltaValue !== null &&
+                poolReferenceDeltaValue !== undefined &&
+                poolReferenceDeltaValue !== '' &&
+                Number.isFinite(collectorDeltaNumber) &&
+                Number.isFinite(poolReferenceDeltaNumber);
+
+            await this.adapter.setStateChangedAsync('solar.extended.collector_pool_reference_delta', {
+                val: extendedDeltaValid ? Number((collectorDeltaNumber - poolReferenceDeltaNumber).toFixed(2)) : null,
+                ack: true,
+            });
+
             let configOk = false;
             let requestActive = false;
             let active = false;

package/lib/helpers/solarHelper.js

@@ -71,8 +71,26 @@ const solarHelper = {
             const hysteresis = (await this.adapter.getStateAsync('solar.hysteresis_active'))?.val;
 
             // Temperaturen laden
-            const collector = Number((await this.adapter.getStateAsync('temperature.collector.current'))?.val);
-            const pool = Number((await this.adapter.getStateAsync('temperature.surface.current'))?.val); // Oberfläche = Pooltemp
+            const collectorState = await this.adapter.getStateAsync('temperature.collector.current');
+            const poolState = await this.adapter.getStateAsync('temperature.surface.current');
+            const collectorValue = collectorState?.val;
+            const poolValue = poolState?.val;
+            const collector = Number(collectorValue);
+            const pool = Number(poolValue); // Oberfläche = Pooltemp
+            const solarDeltaValid =
+                collectorValue !== null &&
+                collectorValue !== undefined &&
+                collectorValue !== '' &&
+                poolValue !== null &&
+                poolValue !== undefined &&
+                poolValue !== '' &&
+                Number.isFinite(collector) &&
+                Number.isFinite(pool);
+
+            await this.adapter.setStateChangedAsync('solar.collector_surface_delta', {
+                val: solarDeltaValid ? Number((collector - pool).toFixed(2)) : null,
+                ack: true,
+            });
 
             // NEU: Absicherung gegen ungültige Werte
             if (isNaN(collector) || isNaN(pool)) {

package/lib/helpers/solarLogbookHelper.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const { I18n } = require('@iobroker/adapter-core');
+const MAX_LOGBOOK_BYTES = 64 * 1024;
 
 /**
  * solarLogbookHelper
@@ -261,7 +262,10 @@ const solarLogbookHelper = {
                 trimmedLog = [...dayLog, newLogItem].slice(-100);
             }
 
-            const dayLogText = this._buildDayLogText(trimmedLog);
+            const limitedLog = this._limitDayLogByBytes(trimmedLog);
+            trimmedLog = limitedLog.entries;
+            const dayLogJson = limitedLog.json;
+            const dayLogText = limitedLog.text;
 
             await this.adapter.setStateChangedAsync('analytics.insights.solar.logbook.current_entry', {
                 val: entry.text,
@@ -274,7 +278,7 @@ const solarLogbookHelper = {
             });
 
             await this.adapter.setStateChangedAsync('analytics.insights.solar.logbook.day_log_json', {
-                val: JSON.stringify(trimmedLog),
+                val: dayLogJson,
                 ack: true,
             });
 
@@ -518,6 +522,29 @@ const solarLogbookHelper = {
         return now.getTime() - lastTimestamp >= minIntervalMs;
     },
 
+    _limitDayLogByBytes(entries) {
+        let limitedEntries = entries.slice(-100);
+        let json = JSON.stringify(limitedEntries);
+        let text = this._buildDayLogText(limitedEntries);
+        let wasTrimmed = false;
+
+        while (
+            limitedEntries.length &&
+            (Buffer.byteLength(json, 'utf8') > MAX_LOGBOOK_BYTES || Buffer.byteLength(text, 'utf8') > MAX_LOGBOOK_BYTES)
+        ) {
+            limitedEntries = limitedEntries.slice(1);
+            json = JSON.stringify(limitedEntries);
+            text = this._buildDayLogText(limitedEntries);
+            wasTrimmed = true;
+        }
+
+        if (wasTrimmed) {
+            this.adapter.log.warn('[solarLogbookHelper] Day log was trimmed to keep JSON and text within 64 KB.');
+        }
+
+        return { entries: limitedEntries, json, text };
+    },
+
     _buildDayLogText(dayLog) {
         return dayLog.map(item => `${item.time} - ${item.text}`).join('\n');
     },
@@ -589,6 +616,11 @@ const solarLogbookHelper = {
             return [];
         }
 
+        if (Buffer.byteLength(jsonText, 'utf8') > MAX_LOGBOOK_BYTES) {
+            this.adapter.log.warn('[solarLogbookHelper] Oversized day_log_json was discarded before parsing.');
+            return [];
+        }
+
         try {
             const parsed = JSON.parse(jsonText);
             return Array.isArray(parsed) ? parsed : [];

package/lib/i18n/de.json

@@ -380,5 +380,6 @@
   "circulation_plausibility_power_warning": "Die Pumpenleistung ist im Verhältnis zur konfigurierten Maximalleistung unplausibel hoch.",
   "circulation_plausibility_flow_warning": "Der berechnete Durchfluss ist im Verhältnis zur konfigurierten Nennförderleistung unplausibel hoch.",
   "circulation_plausibility_daily_total_jump_warning": "Das Tagesumwälzvolumen ist schneller gestiegen als physikalisch plausibel.",
-  "circulation_plausibility_multiple_warnings": "Mehrere Plausibilitätswarnungen zur Umwälzberechnung sind aktiv."
+  "circulation_plausibility_multiple_warnings": "Mehrere Plausibilitätswarnungen zur Umwälzberechnung sind aktiv.",
+  "circulation_plausibility_disabled": "Die Plausibilitätsprüfung der Umwälzberechnung ist deaktiviert."
 }

package/lib/i18n/en.json

@@ -407,5 +407,6 @@
   "circulation_plausibility_power_warning": "Pump power is implausibly high compared to the configured maximum power.",
   "circulation_plausibility_flow_warning": "Calculated flow rate is implausibly high compared to the configured nominal flow.",
   "circulation_plausibility_daily_total_jump_warning": "Daily circulation volume increased faster than physically plausible.",
-  "circulation_plausibility_multiple_warnings": "Multiple circulation plausibility warnings are active."
+  "circulation_plausibility_multiple_warnings": "Multiple circulation plausibility warnings are active.",
+  "circulation_plausibility_disabled": "Circulation plausibility check is disabled."
 }

package/lib/i18n/es.json

@@ -403,6 +403,7 @@
   "circulation_plausibility_power_warning": "La potencia de la bomba es excesiva en relación con la potencia máxima configurada.",
   "circulation_plausibility_flow_warning": "El caudal calculado es excesivo en relación con el caudal nominal configurado.",
   "circulation_plausibility_daily_total_jump_warning": "El volumen diario de circulación ha aumentado más rápido de lo físicamente plausible.",
-  "circulation_plausibility_multiple_warnings": "Hay varias advertencias de plausibilidad de circulación activas."
+  "circulation_plausibility_multiple_warnings": "Hay varias advertencias de plausibilidad de circulación activas.",
+  "circulation_plausibility_disabled": "La comprobación de plausibilidad de la circulación está desactivada."
 }
 

package/lib/i18n/fr.json

@@ -403,5 +403,6 @@
   "circulation_plausibility_power_warning": "La puissance de la pompe est anormalement élevée par rapport à la puissance maximale configurée.",
   "circulation_plausibility_flow_warning": "Le débit calculé est anormalement élevé par rapport au débit nominal configuré.",
   "circulation_plausibility_daily_total_jump_warning": "Le volume quotidien de circulation a augmenté plus rapidement que physiquement plausible.",
-  "circulation_plausibility_multiple_warnings": "Plusieurs avertissements de plausibilité de circulation sont actifs."
+  "circulation_plausibility_multiple_warnings": "Plusieurs avertissements de plausibilité de circulation sont actifs.",
+  "circulation_plausibility_disabled": "La vérification de plausibilité de la circulation est désactivée."
 }

package/lib/i18n/it.json

@@ -403,5 +403,6 @@
   "circulation_plausibility_power_warning": "La potenza della pompa è eccessivamente alta rispetto alla potenza massima configurata.",
   "circulation_plausibility_flow_warning": "La portata calcolata è eccessivamente alta rispetto alla portata nominale configurata.",
   "circulation_plausibility_daily_total_jump_warning": "Il volume giornaliero di circolazione è aumentato più velocemente di quanto fisicamente plausibile.",
-  "circulation_plausibility_multiple_warnings": "Sono attivi più avvisi di plausibilità della circolazione."
+  "circulation_plausibility_multiple_warnings": "Sono attivi più avvisi di plausibilità della circolazione.",
+  "circulation_plausibility_disabled": "Il controllo di plausibilità della circolazione è disattivato."
 }

package/lib/i18n/nl.json

@@ -403,5 +403,6 @@
   "circulation_plausibility_power_warning": "Het pompvermogen is onwaarschijnlijk hoog ten opzichte van het ingestelde maximale vermogen.",
   "circulation_plausibility_flow_warning": "Het berekende debiet is onwaarschijnlijk hoog ten opzichte van het ingestelde nominale debiet.",
   "circulation_plausibility_daily_total_jump_warning": "Het dagelijkse circulatievolume is sneller gestegen dan fysiek plausibel.",
-  "circulation_plausibility_multiple_warnings": "Er zijn meerdere waarschuwingen voor circulatie-plausibiliteit actief."
+  "circulation_plausibility_multiple_warnings": "Er zijn meerdere waarschuwingen voor circulatie-plausibiliteit actief.",
+  "circulation_plausibility_disabled": "De plausibiliteitscontrole van de circulatie is uitgeschakeld."
 }

package/lib/i18n/pl.json

@@ -403,5 +403,6 @@
   "circulation_plausibility_power_warning": "Moc pompy jest nienaturalnie wysoka względem skonfigurowanej mocy maksymalnej.",
   "circulation_plausibility_flow_warning": "Obliczony przepływ jest nienaturalnie wysoki względem skonfigurowanego przepływu nominalnego.",
   "circulation_plausibility_daily_total_jump_warning": "Dzienna objętość obiegu wzrosła szybciej niż jest to fizycznie możliwe.",
-  "circulation_plausibility_multiple_warnings": "Aktywnych jest kilka ostrzeżeń dotyczących wiarygodności obiegu."
+  "circulation_plausibility_multiple_warnings": "Aktywnych jest kilka ostrzeżeń dotyczących wiarygodności obiegu.",
+  "circulation_plausibility_disabled": "Kontrola wiarygodności obiegu jest wyłączona."
 }