iobroker.sun2000 2.3.7 → 2.4.0

package/README.md

@@ -30,7 +30,7 @@ Feel free to follow the discussions in the german [iobroker forum](https://forum
 ## Requirements
 * Node.js 20 or higher
 * ioBroker host (js-controller) 6.0.11 or higher
-* ioBroker admin 7.6.17 or higher
+* ioBroker admin 7.6.20 or higher
 
 ## Documentation
 
@@ -59,12 +59,21 @@ browse in the [wiki](https://github.com/bolliy/ioBroker.sun2000/wiki)
 * Huawei [`SmartLogger`](https://github.com/bolliy/ioBroker.sun2000/wiki/SmartLogger) integration: Monitors and manages the PV power system. The adapter saves the collected data in the same way as it does when read out the inverter directly.
 * Huawei [`Emma`](https://github.com/bolliy/ioBroker.sun2000/wiki/Emma) integration: The Modbus access, network connectivity (WiFi and Ethernet) and the DDSU/DTSU-666H smart meter functions are integrated in one unit - the use of the Sdongle becomes redundant. In addition Huawei EV chargers and load shedding/control (via selected Shelly devices) are supported and "intelligent" controlled.
 * Huawei [`Charger`](https://github.com/bolliy/ioBroker.sun2000/issues/171) via Emma integration: The chargers are automatically recognized and the data is saved in their own path. 
+* Statistics: Aggregates historical collected datapoints into time-based summaries (e.g. hourly, daily, monthly, yearly).
+In the medium term, these statistics should be able to be visualized in ioBroker VIS using the flexcharts adapter to create interactive diagrams for inverter performance and energy production.
+
+
 
 ## Changelog
 <!--
 	Placeholder for the next version (at the beginning of the line):
 	### **WORK IN PROGRESS**
 -->
+### 2.4.0 (2026-03-14)
+* fix: the order of bit assignment corrected of alarmsJSON
+* new state `inverter.x.emma.activeAlarmSN` and `inverter.x.emma.HistoricalAlarmSN` : emma alarms  [#226](https://github.com/bolliy/ioBroker.sun2000/issues/226)
+* statistics: Aggregates historical collected datapoints into time-based summaries (e.g. hourly, daily, monthly, yearly). The data is stored in the path `statistics` as JSON.
+
 ### 2.3.7 (2026-02-01)
 * deleted deprecated state `collected.usableSurplusPower`
 

package/io-package.json

@@ -1,8 +1,21 @@
 {
   "common": {
     "name": "sun2000",
-    "version": "2.3.7",
+    "version": "2.4.0",
     "news": {
+      "2.4.0": {
+        "en": "fix: the order of bit assignment corrected of alarmsJSON\nnew state `inverter.x.emma.activeAlarmSN` and `inverter.x.emma.HistoricalAlarmSN` : emma alarms  [#226](https://github.com/bolliy/ioBroker.sun2000/issues/226)\nstatistics: Aggregates historical collected datapoints into time-based summaries (e.g. hourly, daily, monthly, yearly). The data is stored in the path `statistics` as JSON.",
+        "de": "fix: die Reihenfolge der Bitzuweisung korrigiert von Alarmen JSON\nneuer Zustand `inverter.x.emma.activeAlarmSN` und `inverter.x.emma.HistoricalAlarmSN`: Emma alarms [#226](https://github.com/bolliy/ioBroker.sun2000/issues/226)\nstatistik: Aggregate historische gesammelte Datenpunkte in zeitbasierte Zusammenfassungen (z.B. stündlich, täglich, monatlich, jährlich). Die Daten werden im Pfad `statistics` als JSON gespeichert.",
+        "ru": "исправление: порядок назначения битов исправлен сигнализацией Джон\nновое состояние 'inverter.x.emma.activeAlarmSN' и 'inverter.x.emma.HistoricalAlarmSN': emma alarms [#226] (https://github.com/bolliy/ioBroker.sun2000/issues/226)\nстатистика: Собирает исторические собранные точки данных в основанные на времени резюме (например, почасовые, ежедневные, ежемесячные, годовые). Данные хранятся в «статистике» пути JSON.",
+        "pt": "corrigir: a ordem de atribuição de bits corrigida dos alarmes JSON\nnovo estado `inverter.x.emma.activeAlarmSN` e `inverter.x.emma.HistoricAlarmSN` : alarmes emma [#226](https://github.com/bolliy/ioBroker.sun2000/issues/226)\nestatísticas: Agrega pontos de dados históricos recolhidos em resumos baseados no tempo (por exemplo, horários, diários, mensais, anuais). Os dados são armazenados no caminho `statistics` como JSON.",
+        "nl": "fix: de volgorde van bittoewijzing gecorrigeerd van alarmen JSON\nnieuwe staat \nstatistieken: Verzamelt historische verzamelde datapunten in tijdgebaseerde samenvattingen (bv. uur, dag, maand, jaar). De gegevens worden opgeslagen in het pad .",
+        "fr": "correction : l'ordre d'attribution des bits corrigé des alarmes JSON\nnouvel état `inverter.x.emma.activeAlarmSN` et `inverter.x.emma.HistoricalAlarmSN`: emma alarms [#226](https://github.com/bolliy/ioBroker.sun2000/issues/226)\nstatistiques : Agrége les points de données historiques collectés en résumés chronologiques (p. ex. horaires, quotidiens, mensuels, annuels). Les données sont stockées dans le chemin `statistique` comme JSON.",
+        "it": "fix: l'ordine di bit assegnazione corretto di allarmi JSON\nnuovo stato `inverter.x.emma.activeAlarmSN` e `inverter.x.emma.HistoricalAlarmSN` : allarme emma [#226](https://github.com/bolliy/ioBroker.sun2000/problems/226)\nstatistiche: Aggrega i datapoint storici raccolti in riassunti basati sul tempo (es. orario, giornaliero, mensile, annuale). I dati vengono memorizzati nel percorso `statistics` come JSON.",
+        "es": "fijación: el orden de asignación de bits corregido de alarmas JSON\nnuevo estado `inverter.x.emma.activeAlarmSN` e `inverter.x.emma.HistoricalAlarmSN` : emma alarms [#226](https://github.com/bolliy/ioBroker.sun2000/issues/226)\nestadística: Aggregates historical collected datapoints into time-based summaries (e.g. hourly, daily, monthly, yearly). Los datos se almacenan en el camino 'estadística' como JSON.",
+        "pl": "fix: kolejność przypisywania bitów poprawionych alarmów JSON\nw języku angielskim:\nstatystyki: Zagregowane historyczne zbierane punkty danych w skróty czasowe (np. godzinowe, dzienne, miesięczne, roczne). Dane są przechowywane w ścieżce \"statystyki\" jako JSON.",
+        "uk": "фіксувати: порядок відведення біту виправлено тривоги Сонце\nновий стан `inverter.x.emma.activeAlarmSN` і `inverter.x.emma.HistoricalAlarmSN` : emma тривоги [#226](https://github.com/bolliy/ioBroker.sun2000/products/226)\nстатистика: Агрегати історичних зібраних точок даних на часові суми (наприклад, час, щоденно, щомісяця, рік). Дані зберігаються на шляху `statistics` як JSON.",
+        "zh-cn": "固定: 修改提醒的位任务顺序 贾森\n新状态`inverter.x.emma.active AlarmSN ' 和`inverter.x.emma. Historical AlarmSN ' : emma警报[# 226](https://github.com/bolliy/ioBroker.sun2000/issues/226)\n统计: 将历史收集的数据点汇总为时间摘要(如小时、每日、每月、每年)。 数据作为JSON储存在路径`统计'中."
+      },
       "2.3.7": {
         "en": "deleted deprecated state `collected.usableSurplusPower`",
         "de": "gelöschter deprecated state `collect.usableSurplusPower `",
@@ -80,19 +93,6 @@
         "pl": "pozwala ponownie 'control.battery.chargeFromGridFunction' podczas korzystania z Emmy",
         "uk": "дозволяє знову `control.battery.chargeЗ альбомуGridFunction` при використанні Емма",
         "zh-cn": "允许在使用 Emma 时再次使用 \" control.battery. charge from GridFunction \" "
-      },
-      "2.3.1": {
-        "en": "fix: handle potential null values in set method of RegisterMap",
-        "de": "fix: griff potenzielle Nullwerte in der eingestellten Methode des Registrierens Landkarte",
-        "ru": "исправление: обработка потенциальных нулевых значений в установленном методе Регистра Карта",
-        "pt": "corrigir: manusear valores nulos potenciais no método definido de Registro Mapa",
-        "nl": "fix: handle potentiële nulwaarden in set methode van Register Kaart",
-        "fr": "fix: gérer les valeurs null potentielles dans la méthode définie de Register Carte",
-        "it": "fix: gestire potenziali valori null nel metodo impostato di Registrazione Mappa",
-        "es": "fijación: manejar valores nulos potenciales en el método set de Registro Mapa",
-        "pl": "fix: obsługi potencjalnych wartości null w ustawieniu metody rejestru Mapa",
-        "uk": "виправити: обробляти потенціал null значення в встановленому методі Реєстру Мапа",
-        "zh-cn": "固定值:在设定的登记方法中处理潜在的无效值 地图"
       }
     },
     "titleLang": {
@@ -150,6 +150,7 @@
     "compact": true,
     "connectionType": "local",
     "dataSource": "poll",
+    "messagebox": true,
     "adminUI": {
       "config": "json"
     },
@@ -221,7 +222,7 @@
     ],
     "globalDependencies": [
       {
-        "admin": ">=7.6.17"
+        "admin": ">=7.6.20"
       }
     ],
     "plugins": {
@@ -247,6 +248,8 @@
     "ms_log": false,
     "sl_meterId": 11,
     "ds_bu": true,
+    "ds_bp": false,
+    "cb_tou": false,
     "integration": 0
   },
   "objects": [],

package/lib/drivers/driver_base.js

@@ -191,7 +191,7 @@ class DriverBase {
 
 	/**
 	 * Read the device list for a given modbusId.
-	 * @param {ModbusClient} modbusClient - The modbus client to use.
+	 * @param {object} modbusClient - The modbus client to use.
 	 * @param {number} [modbusId] - The modbus ID to query.
 	 * @returns {Promise<[number, { [key: string]: string }]>}
 	 * The first element of the array is the number of devices,
@@ -209,6 +209,7 @@ class DriverBase {
 			throw new Error(`readDeviceList: No answer for OID=0x${objectId.toString(16).toUpperCase()}: ${e.message}`);
 		}
 		const numDevices = parseInt(JSON.stringify(allInfo['135'] || '').replace(/[^0-9]/g, ''));
+		// @ts-expect-error - we know that the value is a string, but the type definition is incorrect
 		return [numDevices, allInfo];
 	}
 
@@ -293,7 +294,7 @@ class DriverBase {
 	 * If the error is a connection error, it stops the update loop.
 	 * Finally, it calls the _runPostUpdateHooks function to run any post update hooks and stores the states.
 	 *
-	 * @param {ModbusClient} modbusClient - The Modbus client to use for communication.
+	 * @param {object} modbusClient - The Modbus client to use for communication.
 	 * @param {dataRefreshRate} refreshRate - The refresh rate to use for updating the states.
 	 * @param {number} [duration] - The duration in milliseconds for which the states should be updated.
 	 * @returns {Promise<number>} - A promise that resolves to the number of registers read.

package/lib/drivers/driver_emma.js

@@ -784,6 +784,22 @@ class Emma extends DriverBase {
 					this.stateCache.set(`${path}emma.derived.systemTime`, fixTime(systemTime), { type: 'number' });
 				},
 			},
+			{
+				address: 65500,
+				length: 4,
+				info: 'Public Register Definitions',
+				refresh: dataRefreshRate.low,
+				states: [
+					{
+						state: { id: 'emma.activeAlarmSN', name: 'Active alarm SN', type: 'number', role: 'value', desc: 'reg:65500, len:2' },
+						register: { reg: 65500, type: dataType.uint32 },
+					},
+					{
+						state: { id: 'emma.HistoricalAlarmSN', name: 'Historical alarm SN', type: 'number', role: 'value', desc: 'reg:65502, len:2' },
+						register: { reg: 65502, type: dataType.uint32 },
+					},
+				],
+			},
 		];
 
 		this.registerFields.push.apply(this.registerFields, newFields);

package/lib/drivers/driver_inverter.js

@@ -1741,36 +1741,40 @@ class InverterSun2000 extends DriverBase {
 	//overload
 	get modbusAllowed() {
 		//if the modbus-device offline we cannot read or write anythink!
-		let modbusAllowed = true;
-		if (this.deviceInfo.index > 0) {
+		let allowModbus = true; //allowed = true;
+		//if integration = sDongle and only a slave inverter has not a meter.
+		if (this.adapter.settings.integration === 0 && !this.deviceInfo.meter) {
 			//I am a slave inverter
-			if (this.adapter.devices[0].driverClass === driverClasses.inverter && this.adapter.devices[0].instance) {
-				modbusAllowed = this.adapter.devices[0].instance.modbusAllowed; //first ask the master
+			//If the master inverter has a meter, ask the master if modbus is allowed.
+			if (this.adapter.devices[0].instance && this.adapter.devices[0].instance !== this.deviceInfo.instance) {
+				if (this.adapter.devices[0].driverClass === driverClasses.inverter && this.adapter.devices[0].meter) {
+					allowModbus = this.adapter.devices[0].instance.modbusAllowed; //first ask the master
+				}
 			}
 		}
-		if (modbusAllowed) {
+		if (allowModbus) {
 			//430 = SUN2000-8KTL-M2
 			if (this.deviceStatus === 0x0002) {
-				if (this.deviceInfo.index > 0 && this._modelId < 430) modbusAllowed = false;
+				if (this.deviceInfo.index > 0 && this._modelId < 430) allowModbus = false;
 			} //standby
 			if (this.deviceStatus >= 0x0300 && this.deviceStatus <= 0x0307) {
-				modbusAllowed = false;
+				allowModbus = false;
 			} //shutdown
 			if (this._errorCount > 3) {
-				modbusAllowed = false;
+				allowModbus = false;
 			}
 		}
 
-		if (!modbusAllowed && !this.log.quiet) {
+		if (!allowModbus && !this.log.quiet) {
 			this.log.info(`The inverter with modbus ID ${this._modbusId} is no longer accessible. That is why the logs are minimized.`);
 			this.log.beQuiet(true);
 		}
-		if (modbusAllowed && this.log.quiet) {
+		if (allowModbus && this.log.quiet) {
 			this.log.beQuiet(false);
 			this.log.info(`The inverter with modbus ID ${this._modbusId} is accessible again.`);
 			//this._errorCount = 0;
 		}
-		this._modbusAllowed = modbusAllowed;
+		this._modbusAllowed = allowModbus;
 		return this._modbusAllowed;
 	}
 

package/lib/register.js

@@ -4,6 +4,7 @@ const { deviceType, driverClasses, dataRefreshRate } = require(`${__dirname}/typ
 const { RiemannSum, StateMap } = require(`${__dirname}/tools.js`);
 const getDriverHandler = require(`${__dirname}/drivers/index.js`);
 const tools = require(`${__dirname}/tools.js`);
+const statistics = require(`${__dirname}/statistics.js`);
 
 class Registers {
 	constructor(adapterInstance) {
@@ -11,6 +12,7 @@ class Registers {
 		this.stateCache = new StateMap();
 
 		this.externalSum = new RiemannSum();
+		this.statistics = new statistics(adapterInstance, this.stateCache);
 
 		for (const device of this.adapter.devices) {
 			//DriverInfo Instance or Sdongle
@@ -19,7 +21,8 @@ class Registers {
 				device.instance = new handler(this, device);
 			}
 		}
-		//deleted deprecated states
+
+		//Upgrade to v2.3.7 - deleted deprecated states
 		if (
 			tools.existsState(this.adapter, `collected.usableSurplusPower`, (err, exists) => {
 				if (!err && exists) {
@@ -32,8 +35,8 @@ class Registers {
 			})
 		);
 
-		this.postProcessHooks = [];
-		this.inverterPostProcessHooks = [
+		//this.postProcessHooks = [];
+		this.postProcessHooks = [
 			{
 				refresh: dataRefreshRate.high,
 				states: [
@@ -56,16 +59,6 @@ class Registers {
 						unit: 'kW',
 						role: 'value.power',
 					},
-					/*
-					{
-						id: 'collected.usableSurplusPower',
-						name: 'usable surplus power',
-						type: 'number',
-						unit: 'kW',
-						role: 'value.power',
-						desc: 'depreciated: Please use collected.surplus.usablePower instead',
-					},
-					*/
 					{
 						id: 'collected.surplus.power',
 						name: 'surplus power',
@@ -190,18 +183,12 @@ class Registers {
 					this.stateCache.set('collected.activePower', actPower, { type: 'number', renew: true });
 					this.stateCache.set('collected.houseConsumption', houseConsum, { type: 'number' });
 					this.stateCache.set('collected.chargeDischargePower', chargeDischarge, { type: 'number' });
-					/*
-					this.stateCache.set('collected.usableSurplusPower', surplusArray[1], {
-						type: 'number',
-					});
-					*/
 					this.stateCache.set('collected.surplus.power', surplusArray[0], {
 						type: 'number',
 					});
 					this.stateCache.set('collected.surplus.usablePower', surplusArray[1], {
 						type: 'number',
 					});
-
 					this.stateCache.set('collected.externalPower', extPower, { type: 'number' });
 				},
 			},
@@ -329,7 +316,17 @@ class Registers {
 						feedinEnergy = this.stateCache.get('meter.positiveActiveEnergy')?.value ?? 0;
 						supplyFromGrid = this.stateCache.get('meter.reverseActiveEnergy')?.value ?? 0;
 					}
-					//stimmt leider nicht genau - bleibt aber erstmal bestehen
+					//NEU - Initialisierung
+					const gridExportStart = this.stateCache.get('collected.gridExportStart')?.value;
+					if (!gridExportStart && feedinEnergy !== 0) {
+						this.stateCache.set('collected.gridExportStart', feedinEnergy, { type: 'number' });
+					}
+					const gridImportStart = this.stateCache.get('collected.gridImportStart')?.value;
+					if (!gridImportStart && supplyFromGrid !== 0) {
+						this.stateCache.set('collected.gridImportStart', supplyFromGrid, { type: 'number' });
+					}
+
+					//stimmt wahrscheinlich nicht genau - bleibt aber erstmal bestehen
 					const conSum = enYield + supplyFromGrid - feedinEnergy;
 					this.stateCache.set('collected.consumptionSum', conSum, { type: 'number' });
 					// compute export and import today
@@ -360,7 +357,9 @@ class Registers {
 		];
 
 		//only Inverter
-		this.postProcessHooks.push.apply(this.postProcessHooks, this.inverterPostProcessHooks);
+		//this.postProcessHooks.push.apply(this.postProcessHooks, this.inverterPostProcessHooks);
+		this.postProcessHooks.push.apply(this.postProcessHooks, this.statistics.processHooks);
+
 		this._loadStates();
 	}
 
@@ -380,6 +379,17 @@ class Registers {
 			},
 			native: {},
 		});
+
+		if (state.initVal) {
+			const ret = await this.adapter.getState(state.id);
+			if (!ret || ret.val === null) {
+				try {
+					await this.adapter.setState(state.id, { val: state.initVal, ack: true });
+				} catch (err) {
+					this.adapter.log.warn(`Error while initializing ${state.id}, val=${state.initVal} err=${err.message}`);
+				}
+			}
+		}
 	}
 
 	async storeStates() {
@@ -411,7 +421,7 @@ class Registers {
 	 * its states. Logs an error if no device instance has been initialized.
 	 *
 	 * @param {object} device - The device object containing the instance and driverClass.
-	 * @param {ModbusClient} modbusClient - The Modbus client used for communication.
+	 * @param {object} modbusClient - The Modbus client used for communication.
 	 * @param {string} refreshRate - The rate at which data should be refreshed.
 	 * @param {number} duration - The duration for which the states should be updated.
 	 * @returns {Promise<number>} - Returns a promise that resolves to the number of states updated.
@@ -449,7 +459,7 @@ class Registers {
 					}
 				}
 				hook.initState = true;
-				hook.fn(this.adapter.devices);
+				hook.fn && hook.fn(this.adapter.devices);
 			}
 		}
 		this.storeStates(); //fire and forget
@@ -459,6 +469,7 @@ class Registers {
 	async _loadStates() {
 		let state = await this.adapter.getState('collected.gridExportStart');
 		this.stateCache.set('collected.gridExportStart', state?.val, { type: 'number', stored: true });
+		this.stateCache.set('collected.gridImportStart', state?.val, { type: 'number', stored: true });
 		state = await this.adapter.getState('collected.gridImportStart');
 		this.stateCache.set('collected.gridImportStart', state?.val, { type: 'number', stored: true });
 		state = await this.adapter.getState('collected.consumptionStart');
@@ -525,6 +536,7 @@ class Registers {
 	// one minute before midnight - perform housekeeping actions
 	//state
 	async mitnightProcess() {
+		this.statistics.mitNightProcess();
 		// copy current export/import kWh - used to compute daily import/export in kWh
 		const sign = this.stateCache.get('meter.derived.signConventionForPowerFeed-in')?.value ?? 1;
 		if (sign === -1) {
@@ -543,7 +555,7 @@ class Registers {
 				await device.instance.mitnightProcess();
 			}
 		}
-		this.storeStates(); //fire and forget
+		this.storeStates();
 	}
 }
 

package/lib/statistics.js

@@ -0,0 +1,731 @@
+/**
+statistics.js
+ 
+This module prepares statistical data based on historical datapoints from the
+Huawei SUN2000 inverter states. It aggregates raw values into structured
+time-based datasets (e.g., hourly, daily, monthly, yearly) that can be used
+for further analysis or visualization.
+ 
+The goal of this processing layer is to provide normalized statistical data
+independent from the raw state history.
+ 
+In the mid-term, these statistics are intended to be visualized graphically
+in ioBroker VIS using the ioBroker.flexcharts adapter.
+ */
+
+'use strict';
+
+const { dataRefreshRate, statisticsType } = require(`${__dirname}/types.js`);
+const tools = require(`${__dirname}/tools.js`);
+
+class statistics {
+	constructor(adapterInstance, stateCache) {
+		this.adapter = adapterInstance;
+		this.stateCache = stateCache;
+		this.taskTimer = null;
+		this.testing = false; // set to true for testing purposes
+		// initialize to current time to avoid immediate backfill on startup
+		//const nowInit = new Date();
+		this.lastExecution = {
+			hourly: undefined,
+			daily: undefined,
+			weekly: undefined,
+			monthly: undefined,
+			annual: undefined,
+		};
+
+		this.stats = [
+			{
+				sourceId: 'collected.consumptionToday',
+				targetPath: 'consumption',
+				unit: 'kWh',
+				type: statisticsType.deltaReset, // value is a total that resets at the start of the period, so we need to calculate the delta to get the actual consumption for the period
+			},
+			/*
+			{
+				sourceId: 'collected.consumptionSum',
+				targetPath: 'consumptionSum',
+				unit: 'kWh',
+				type: statisticsType.delta,
+			},
+			*/
+			{
+				sourceId: 'collected.dailySolarYield',
+				targetPath: 'solarYield',
+				unit: 'kWh',
+				type: statisticsType.deltaReset,
+			},
+			{ sourceId: 'collected.dailyInputYield', targetPath: 'inputYield', unit: 'kWh', type: statisticsType.deltaReset },
+			{
+				sourceId: 'collected.dailyExternalYield',
+				targetPath: 'externalYield',
+				unit: 'kWh',
+				type: statisticsType.deltaReset,
+			},
+			{ sourceId: 'collected.dailyEnergyYield', targetPath: 'energyYield', unit: 'kWh', type: statisticsType.deltaReset },
+			{
+				sourceId: 'collected.SOC',
+				targetPath: 'SOC',
+				unit: '%',
+				type: statisticsType.level, // value is a level that can go up and down, so we take the value as is without calculating delta
+			},
+			{ sourceId: 'collected.currentDayChargeCapacity', targetPath: 'chargeCapacity', unit: 'kWh', type: statisticsType.deltaReset },
+			{ sourceId: 'collected.currentDayDischargeCapacity', targetPath: 'dischargeCapacity', unit: 'kWh', type: statisticsType.deltaReset },
+			{ sourceId: 'collected.gridExportToday', targetPath: 'gridExport', unit: 'kWh', type: statisticsType.deltaReset },
+			{ sourceId: 'collected.gridImportToday', targetPath: 'gridImport', unit: 'kWh', type: statisticsType.deltaReset },
+		];
+
+		this.postProcessHooks = [
+			{
+				refresh: dataRefreshRate.low,
+				states: [
+					{
+						id: 'statistics.jsonHourly',
+						name: 'Hourly consumption JSON',
+						type: 'string',
+						role: 'json',
+						desc: 'Hourly consumption for last and current day per full hour',
+						initVal: '[]',
+					},
+					{
+						id: 'statistics.jsonDaily',
+						name: 'Daily consumption JSON',
+						type: 'string',
+						role: 'json',
+						desc: 'Daily consumption for current month per day',
+						initVal: '[]',
+					},
+					{
+						id: 'statistics.jsonWeekly',
+						name: 'Weekly consumption JSON',
+						type: 'string',
+						role: 'json',
+						desc: 'Weekly consumption for current year per week',
+						initVal: '[]',
+					},
+					{
+						id: 'statistics.jsonMonthly',
+						name: 'Monthly consumption JSON',
+						type: 'string',
+						role: 'json',
+						desc: 'Monthly consumption for current year per month',
+						initVal: '[]',
+					},
+					{
+						id: 'statistics.jsonAnnual',
+						name: 'Annual consumption JSON',
+						type: 'string',
+						role: 'json',
+						desc: 'Annual consumption per year',
+						initVal: '[]',
+					},
+					// a state where users may store a Flexcharts/eCharts options template
+					/*
+					{
+						id: 'statistics.flexChartTemplate',
+						name: 'Flexcharts template',
+						type: 'string',
+						role: 'json',
+						desc: 'Optional eCharts option object that will be merged into the default chart. Leave empty for the built‑in layout.',
+						initVal: '{}',
+					},
+					*/
+				],
+			},
+		];
+		this.initialize();
+	}
+
+	get processHooks() {
+		return this.postProcessHooks;
+	}
+
+	/**
+	 * Helper function to format date as ISO string with timezone offset.
+	 *
+	 * @param {Date} d - The date to format
+	 * @returns {string} ISO formatted date string with timezone offset
+	 */
+	_localIsoWithOffset(d) {
+		const pad = n => String(n).padStart(2, '0');
+		const year = d.getFullYear();
+		const month = pad(d.getMonth() + 1);
+		const day = pad(d.getDate());
+		const hours = pad(d.getHours());
+		const minutes = pad(d.getMinutes());
+		const seconds = pad(d.getSeconds());
+		const tzOffset = -d.getTimezoneOffset();
+		const sign = tzOffset >= 0 ? '+' : '-';
+		const absMin = Math.abs(tzOffset);
+		const offH = pad(Math.floor(absMin / 60));
+		const offM = pad(absMin % 60);
+		return `${year}-${month}-${day}T${hours}:${minutes}:${seconds}.000${sign}${offH}:${offM}`;
+	}
+
+	/**
+	 * Generic function to calculate consumption statistics for different time periods.
+	 *
+	 * @param {string} stateId - The state ID for storing the JSON
+	 * @param {string} consumptionKey - The state key for consumption value
+	 * @param {Date} periodStart - The start of the current period
+	 * @param {string} periodType - The type of period (hourly, daily, weekly, monthly, annual)
+	 * @returns {Promise<void>}
+	 */
+
+	async _calculateGeneric(stateId, periodStart, periodEnde) {
+		const toStr = this._localIsoWithOffset(periodEnde);
+		let jsonStr = this.stateCache.get(stateId)?.value ?? '[]';
+		let arr = [];
+		try {
+			arr = JSON.parse(jsonStr);
+			if (!Array.isArray(arr)) arr = [];
+		} catch {
+			arr = [];
+		}
+		let fromDate = periodStart;
+		let last = {};
+		if (arr.length > 0) {
+			last = arr[arr.length - 1];
+			// avoid duplicates
+			if (last.to === toStr) return false;
+			const lastToDate = new Date(last.to);
+			const toDate = new Date(toStr);
+			if (lastToDate >= periodStart || toDate <= periodStart) {
+				fromDate = lastToDate;
+			}
+		}
+
+		const entry = {
+			from: this._localIsoWithOffset(fromDate),
+			to: toStr,
+		};
+
+		for (const stat of this.stats) {
+			const source = this.stateCache.get(stat.sourceId)?.value;
+			if (source === null || source === undefined) {
+				this.adapter.logger.warn(`Source state ${stat.sourceId} not found statistic hook`);
+				continue;
+			}
+			let value = Number(source);
+			if (stat.type === statisticsType.delta || stat.type === statisticsType.deltaReset) {
+				const lastTotal = Number(last[stat.targetPath]?.['total'] ?? 0);
+				if (stat.type === statisticsType.deltaReset) {
+					//if (value >= lastTotal * 0.5) {
+					if (fromDate.getTime() !== periodStart.getTime()) {
+						// Delta-Berechnung
+						value -= lastTotal;
+					}
+				} else {
+					// Ein lastTotal-Wert vorhanden –> normale Delta-Berechnung
+					if (last[stat.targetPath]?.['total'] === undefined) {
+						// Kein lastTotal-Wert vorhanden –> wahrscheinlich erster Eintrag, Delta-Berechnung nicht möglich
+						this.adapter.logger.debug(`No total value found for ${stat.targetPath} in last entry, setting delta to 0`);
+						value = 0;
+					} else {
+						// Delta-Berechnung
+						value -= lastTotal;
+					}
+				}
+			}
+			value = Math.round((Number(value) + Number.EPSILON) * 1000) / 1000;
+			entry[stat.targetPath] = {
+				value: Number(value.toFixed(3)),
+			};
+
+			if (stat.type === statisticsType.delta || stat.type === statisticsType.deltaReset) {
+				entry[stat.targetPath].total = Number(source.toFixed(3));
+			}
+			entry[stat.targetPath].unit = stat.unit || 'kWh'; // can be extended for other stats with different units
+		}
+		arr.push(entry);
+
+		arr.sort((a, b) => Date.parse(a.to) - Date.parse(b.to));
+
+		this.stateCache.set(stateId, JSON.stringify(arr), { type: 'string' });
+		this.adapter.logger.debug(`Appended ${stateId} statistic ${toStr}`);
+	}
+
+	/**
+	 * Calculates and updates hourly consumption statistics.
+	 *
+	 * This function calculates the hourly consumption statistics based on the current day's data.
+	 * It retrieves the consumption data and updates the hourly consumption JSON accordingly.
+	 *
+	 * @returns {void}
+	 */
+	async _calculateHourly() {
+		const now = new Date();
+		if (this.testing) {
+			const state = await this.adapter.getState('statistics.jsonHourly');
+			this.stateCache.set('statistics.jsonHourly', state?.val ?? '[]', { type: 'string', stored: true });
+			now.setDate(now.getDate() + 1); // set to start of day for testing to have consistent results
+			now.setHours(1, 0, 0, 1); // set to 1ms after midnight to trigger hourly calculation for the new day
+		}
+		const startOfDay = new Date(now.getFullYear(), now.getMonth(), now.getDate(), 0, 0, 0, 0);
+		const lastHour = new Date(now.getFullYear(), now.getMonth(), now.getDate(), now.getHours(), 0, 0, 0);
+		this.adapter.log.debug('### Hourly execution triggered ###');
+		this._calculateGeneric('statistics.jsonHourly', startOfDay, lastHour) && (this.lastExecution.hourly = now); // only update last execution time if calculation was performed to avoid backfilling multiple hours at startup
+	}
+
+	async _clearGeneric(stateId, periodStart) {
+		let jsonStr = this.stateCache.get(stateId)?.value ?? '[]';
+		let arr = [];
+		try {
+			arr = JSON.parse(jsonStr);
+			if (!Array.isArray(arr)) arr = [];
+		} catch {
+			arr = [];
+		}
+
+		// Keep only entries within the window
+		arr = arr.filter(item => {
+			const ts = Date.parse(item.from);
+			return !Number.isNaN(ts) && ts >= periodStart.getTime();
+		});
+
+		this.stateCache.set(stateId, JSON.stringify(arr), { type: 'string' });
+	}
+
+	/**
+	 * Calculates and aggregates consumption statistics based on the given parameters.
+	 *
+	 * This function calculates and aggregates the consumption statistics based on the source entries within a specific window.
+	 * It retrieves the source entries, filters them based on the window, calculates the sum of consumption, and appends the result to the target array.
+	 *
+	 * @param {string} sourceStateId - The ID of the source state to retrieve entries from.
+	 * @param {string} targetStateId - The ID of the target state to append the aggregated result.
+	 * @param {Function} getWindow - A function that returns the start and end date of the window based on the current date.
+	 * @param {string} periodType - The type of period for which the aggregation is performed.
+	 * @returns {void}
+	 */
+	async _calculateAggregation(sourceStateId, targetStateId, getWindow, periodType) {
+		try {
+			const now = new Date();
+			const window = getWindow(now);
+			const fromDate = window.from;
+			const toDate = window.to;
+			if (now < toDate) {
+				this.adapter.logger.debug(`statistics.js: Skipping ${periodType} aggregation because current time is before end of aggregation window`);
+				return;
+			}
+			const toStr = this._localIsoWithOffset(toDate);
+
+			// Load target array
+			let jsonTarget = this.stateCache.get(targetStateId)?.value ?? '[]';
+			let targetArray = [];
+			try {
+				targetArray = JSON.parse(jsonTarget);
+				if (!Array.isArray(targetArray)) targetArray = [];
+			} catch {
+				targetArray = [];
+			}
+
+			// Avoid duplicates
+			const last = targetArray.length > 0 ? targetArray[targetArray.length - 1] : {};
+			if (last.to === toStr) return;
+
+			const target = {
+				from: this._localIsoWithOffset(fromDate),
+				to: toStr,
+			};
+
+			// Load source entries
+			let jsonStr = this.stateCache.get(sourceStateId)?.value ?? '[]';
+			let sourceEntries = [];
+			try {
+				sourceEntries = JSON.parse(jsonStr);
+				if (!Array.isArray(sourceEntries)) sourceEntries = [];
+			} catch {
+				sourceEntries = [];
+			}
+
+			// Keep only entries within the window
+			sourceEntries = sourceEntries.filter(item => {
+				const ts = Date.parse(item.from);
+				return !Number.isNaN(ts) && ts >= fromDate.getTime() && ts < toDate.getTime();
+			});
+			// If there are no source entries, we can skip the aggregation and avoid creating empty entries in the target array
+			if (sourceEntries.length > 0) {
+				this.adapter.logger.debug(
+					`statistics.js: Found ${sourceEntries.length} source entries for ${periodType} aggregation between ${fromDate.toISOString()} and ${toDate.toISOString()}`,
+				);
+
+				for (const stat of this.stats) {
+					// Sum consumption for the window
+					if (stat.type === statisticsType.level) continue; // Skip level statistics
+
+					let sum = 0;
+					/*
+					if (stat.type === statisticsType.average) {
+						stat.sum = sourceEntries.length > 0 ? sourceEntries[sourceEntries.length - 1]?.[stat.targetPath]?.['total'] : 0;
+					} else {
+					*/
+					try {
+						sourceEntries.forEach(entry => {
+							sum += Number(entry[stat.targetPath]?.['value'] ?? 0);
+						});
+					} catch (e) {
+						this.adapter.logger.warn(`statistics.js: Error during ${periodType} statistic aggregation: ${e.message}`);
+					}
+
+					sum = Math.round((Number(sum) + Number.EPSILON) * 1000) / 1000;
+
+					target[stat.targetPath] = {
+						value: Number(sum.toFixed(3)),
+						unit: stat.unit || 'kWh',
+					};
+				}
+
+				targetArray.push(target);
+			}
+
+			// Retention: keep entries from retention start onwards
+			/*
+			const retentionStart = getRetentionStart(now);
+			targetArray = targetArray.filter(item => {
+				const ts = Date.parse(item.from);
+				return !Number.isNaN(ts) && ts >= retentionStart.getTime();
+			});
+			*/
+
+			targetArray.sort((a, b) => Date.parse(a.to) - Date.parse(b.to));
+			this.stateCache.set(targetStateId, JSON.stringify(targetArray), { type: 'string' });
+			this.adapter.logger.debug(`Appended ${periodType} statistic ${toStr} `);
+			return true;
+		} catch (err) {
+			this.adapter.logger.warn(`Error during ${periodType} aggregation: ${err.message}`);
+		}
+	}
+
+	/**
+	 * Calculates and updates daily consumption statistics from hourly data.
+	 *
+	 * @returns {void}
+	 */
+	async _calculateDaily() {
+		this.adapter.log.debug('### Daily execution triggered ###');
+		this._calculateAggregation(
+			'statistics.jsonHourly',
+			'statistics.jsonDaily',
+			now => {
+				// aggregation window: previous day (day that just ended)
+				const today = new Date(now.getFullYear(), now.getMonth(), now.getDate(), 0, 0, 0, 0);
+				const yesterday = new Date(today);
+				yesterday.setDate(today.getDate() - 1);
+				return { from: yesterday, to: today };
+			},
+			'daily',
+		) && (this.lastExecution.daily = new Date()); // only update last execution time if aggregation was performed to avoid backfilling multiple days at startup
+	}
+
+	/**
+	 * Calculates and updates weekly consumption statistics from daily data.
+	 *
+	 * @returns {void}
+	 */
+	async _calculateWeekly() {
+		this.adapter.log.debug('### Weekly execution triggered ###');
+		this._calculateAggregation(
+			'statistics.jsonDaily',
+			'statistics.jsonWeekly',
+			now => {
+				// aggregation window: Monday to Sunday of the previous week (week that just ended)
+				const startday = new Date(now.getFullYear(), now.getMonth(), now.getDate(), 0, 0, 0, 0);
+				const lastday = new Date(startday);
+				// set to Monday of previous week
+				lastday.setDate(now.getDate() - (now.getDay() || 7) + 1); // set to Monday of actual week
+				startday.setDate(lastday.getDate() - 7); // set to Monday of previous week
+				return { from: startday, to: lastday };
+			},
+			'weekly',
+		) && (this.lastExecution.weekly = new Date()); // only update last execution time if aggregation was performed to avoid backfilling multiple weeks at startup
+	}
+
+	/**
+	 * Calculates and updates monthly consumption statistics from daily data.
+	 *
+	 * @returns {void}
+	 */
+	async _calculateMonthly() {
+		this.adapter.log.debug('### Monthly execution triggered ###');
+		this._calculateAggregation(
+			'statistics.jsonDaily',
+			'statistics.jsonMonthly',
+			now => {
+				// aggregation windowStart: previous month (month that just ended)
+				const thisMonth = new Date(now.getFullYear(), now.getMonth(), 1, 0, 0, 0, 0);
+				const prevMonth = new Date(now.getFullYear(), now.getMonth() - 1, 1, 0, 0, 0, 0);
+				return { from: prevMonth, to: thisMonth };
+			},
+			'monthly',
+		) && (this.lastExecution.monthly = new Date()); // only update last execution time if aggregation was performed to avoid backfilling multiple months at startup
+	}
+
+	/**
+	 * Calculates and updates annual consumption statistics from daily data.
+	 *
+	 * @returns {void}
+	 */
+	async _calculateAnnual() {
+		this.adapter.log.debug('### Annual execution triggered ###');
+		this._calculateAggregation(
+			'statistics.jsonDaily',
+			'statistics.jsonAnnual',
+			now => {
+				// aggregation window: previous year (year that just ended)
+				const thisYear = new Date(now.getFullYear(), 0, 1, 0, 0, 0, 0);
+				const prevYear = new Date(now.getFullYear() - 1, 0, 1, 0, 0, 0, 0);
+				return { from: prevYear, to: thisYear };
+			},
+			'annual',
+		) && (this.lastExecution.annual = new Date()); // only update last execution time if aggregation was performed to avoid backfilling multiple years at startup
+	}
+
+	/**
+	 * Initialize and schedule the unified task manager.
+	 * This task runs every minute and checks which statistics need to be calculated.
+	 */
+	async _initializeTask() {
+		const scheduleNextRun = () => {
+			const now = new Date();
+			const next = new Date(now);
+			if (this.testing) {
+				next.setMinutes(now.getMinutes() + 1, 0, 0); //every minute
+			} else {
+				next.setHours(next.getHours() + 1, 0, 0, 0); //every hour
+			}
+
+			// Skip executing tasks exactly at midnight to avoid running aggregated jobs
+			if (next.getHours() === 0 && next.getMinutes() === 0) {
+				next.setHours(next.getHours() + 1, 0, 0, 0); //every hour
+			}
+			const msToNextHour = next.getTime() - now.getTime();
+
+			if (this.taskTimer) {
+				this.adapter.clearTimeout(this.taskTimer);
+			}
+
+			this.taskTimer = this.adapter.setTimeout(async () => {
+				await this._executeScheduledTasks();
+				scheduleNextRun(); // reschedule for next hour
+			}, msToNextHour);
+		};
+		//await this._executeScheduledTasks(); // execute immediately on startup to catch up on any missed runs while the adapter was not running
+		// Schedule the next run
+		scheduleNextRun();
+	}
+	async _executeScheduledTasks() {
+		this._calculateHourly();
+		this._calculateDaily();
+		this._calculateWeekly();
+		this._calculateMonthly();
+		this._calculateAnnual();
+	}
+
+	/**
+	 * Executes every midnight and performs the following tasks:
+	 * - Execute all scheduled tasks to ensure that statistics are up to date.
+	 * - Clear old data based on retention policies.
+	 */
+	async mitNightProcess() {
+		const now = new Date();
+		await this._executeScheduledTasks();
+		// Clear old data based on retention policies
+		const startOfYear = new Date(now.getFullYear(), 0, 1, 0, 0, 0, 0);
+		await this._clearGeneric('statistics.jsonDaily', startOfYear);
+		await this._clearGeneric('statistics.jsonWeekly', startOfYear);
+		await this._clearGeneric('statistics.jsonMonthly', startOfYear);
+		await this._clearGeneric('statistics.jsonHourly', new Date(now.getFullYear(), now.getMonth(), now.getDate() - 1, 0, 0, 0, 0));
+	}
+
+	async initialize() {
+		// load consumption JSON states (keep as string)
+		let state = await this.adapter.getState('statistics.jsonHourly');
+		this.stateCache.set('statistics.jsonHourly', state?.val ?? '[]', { type: 'string', stored: true });
+
+		state = await this.adapter.getState('statistics.jsonDaily');
+		this.stateCache.set('statistics.jsonDaily', state?.val ?? '[]', { type: 'string', stored: true });
+
+		state = await this.adapter.getState('statistics.jsonWeekly');
+		this.stateCache.set('statistics.jsonWeekly', state?.val ?? '[]', { type: 'string', stored: true });
+
+		state = await this.adapter.getState('statistics.jsonMonthly');
+		this.stateCache.set('statistics.jsonMonthly', state?.val ?? '[]', { type: 'string', stored: true });
+
+		state = await this.adapter.getState('statistics.jsonAnnual');
+		this.stateCache.set('statistics.jsonAnnual', state?.val ?? '[]', { type: 'string', stored: true });
+
+		// load optional flexchart template
+		/*
+		state = await this.adapter.getState('statistics.flexChartTemplate');
+		this.stateCache.set('statistics.flexChartTemplate', state?.val ?? '{}', { type: 'string', stored: true });
+        */
+		// wait until consumptionToday and so on is available to avoid running the task before the initial state is loaded
+		/*
+		await tools.waitForValue(() => this.stateCache.get('collected.consumptionToday')?.value, 60000);
+		await tools.waitForValue(() => this.stateCache.get('collected.dailySolarYield')?.value, 60000);
+		await tools.waitForValue(() => this.stateCache.get('collected.SOC')?.value, 60000);
+		*/
+		await tools.waitForValue(() => this.stateCache.get('collected.accumulatedEnergyYield')?.value, 60000);
+		this.mitNightProcess(); // execute once on startup to catch up on any missed runs while the adapter was not running
+		this._initializeTask();
+	}
+
+	/**
+	 * Build a flexcharts/eCharts option object from stored statistics.
+	 * The returned object may be sent to a callback for flexcharts' script source.
+	 *
+	 * @param {string} myChart - one of 'hourly','daily','weekly','monthly','annual'
+	 * @returns {object} chart configuration
+	 */
+	_buildFlexchart(myChart) {
+		const IDS = {
+			hourly: 'statistics.jsonHourly',
+			daily: 'statistics.jsonDaily',
+			weekly: 'statistics.jsonWeekly',
+			monthly: 'statistics.jsonMonthly',
+			annual: 'statistics.jsonAnnual',
+		};
+		const id = IDS[myChart] || IDS.hourly;
+		let data = [];
+		try {
+			data = JSON.parse(this.stateCache.get(id)?.value ?? '[]');
+		} catch {
+			data = [];
+		}
+
+		// default chart configuration (based on flexcharts discussion example)
+		const chart = {
+			tooltip: { trigger: 'axis', axisPointer: { type: 'cross' } },
+			legend: { show: true, orient: 'horizontal', left: 'center', top: 25 },
+			title: { left: 'center', text: 'Statistics ' },
+			grid: { right: '20%' },
+			toolbox: { feature: { dataView: { show: true, readOnly: false }, restore: { show: true }, saveAsImage: { show: true } } },
+			xAxis: [{ type: 'category', axisTick: { alignWithLabel: true }, data: [] }],
+			yAxis: [{ type: 'value', position: 'left', alignTicks: true, axisLine: { show: true }, axisLabel: { formatter: '{value}' } }],
+			series: [],
+		};
+
+		// merge with user-provided template if available
+		const templateStr = this.stateCache.get('statistics.flexChartTemplate')?.value;
+		if (templateStr) {
+			try {
+				const templ = JSON.parse(templateStr);
+				for (const key of Object.keys(templ)) {
+					if (chart[key] && typeof chart[key] === 'object' && typeof templ[key] === 'object') {
+						// merge sub-objects shallowly
+						Object.assign(chart[key], templ[key]);
+					} else {
+						chart[key] = templ[key];
+					}
+				}
+			} catch (e) {
+				this.adapter.logger.warn(`statistics: invalid flexChartTemplate JSON: ${e.message}`);
+			}
+		}
+
+		// fill data arrays and collect units from stats definitions
+		const xAxis = [];
+		const seriesData = {};
+		const unitMap = {}; // targetPath -> unit string
+
+		for (const stat of this.stats) {
+			unitMap[stat.targetPath] = stat.unit || '';
+		}
+
+		for (const entry of data) {
+			const from = new Date(entry.from);
+			//const to = new Date(entry.to);
+			const xVal =
+				myChart === 'hourly'
+					? from.toLocaleTimeString('de-DE', { hour12: false, hour: '2-digit', minute: '2-digit' })
+					: from.toLocaleDateString('de-DE', { year: 'numeric', month: '2-digit', day: '2-digit' });
+			xAxis.push(xVal);
+			for (const stat of this.stats) {
+				const val = Number(entry[stat.targetPath]?.value ?? 0);
+				if (!seriesData[stat.targetPath]) {
+					seriesData[stat.targetPath] = [];
+				}
+				seriesData[stat.targetPath].push(Number(val.toFixed(3)));
+			}
+		}
+		chart.xAxis[0].data = xAxis;
+
+		// apply unit information to axis/tooltip if there is a single unit or per-series
+		const units = new Set(Object.values(unitMap).filter(u => u));
+		if (units.size === 1) {
+			const singleUnit = [...units][0];
+			// update default yAxis label and tooltip formatter
+			chart.yAxis[0].name = singleUnit ? `(${singleUnit})` : '';
+			chart.yAxis[0].axisLabel.formatter = `{value}${singleUnit ? ` ${singleUnit}` : ''}`;
+			chart.tooltip.formatter = params => {
+				if (!Array.isArray(params)) params = [params];
+				return params.map(p => `${p.seriesName}: ${p.value}${singleUnit ? ` ${singleUnit}` : ''}`).join('<br/>');
+			};
+		} else if (units.size > 1) {
+			// multiple units – show per-series unit in tooltip
+			chart.tooltip.formatter = params => {
+				if (!Array.isArray(params)) params = [params];
+				return params
+					.map(p => {
+						const u = unitMap[p.seriesName] || '';
+						return `${p.seriesName}: ${p.value}${u ? ` ${u}` : ''}`;
+					})
+					.join('<br/>');
+			};
+		}
+
+		// if chart.series was pre-populated by template use names, otherwise create default series
+		if (chart.series && chart.series.length > 0) {
+			chart.series.forEach(s => {
+				// try exact name first, otherwise case-insensitive lookup
+				let key = s.name;
+				if (seriesData[key]) {
+					s.data = seriesData[key];
+				} else {
+					// find matching key ignoring case
+					const found = Object.keys(seriesData).find(k => k.toLowerCase() === String(key).toLowerCase());
+					if (found) {
+						s.data = seriesData[found];
+					} else {
+						s.data = [];
+					}
+				}
+				// ensure unit is added from stats definitions if not present
+				if (!s.unit) {
+					let unitVal = unitMap[key];
+					if (!unitVal) {
+						const foundu = Object.keys(unitMap).find(k => k.toLowerCase() === String(key).toLowerCase());
+						if (foundu) unitVal = unitMap[foundu];
+					}
+					s.unit = unitVal || '';
+				}
+			});
+		} else {
+			chart.series = Object.keys(seriesData).map(name => ({
+				name,
+				type: 'line',
+				data: seriesData[name],
+				unit: unitMap[name] || '',
+			}));
+		}
+		chart.title.text += myChart;
+		return chart;
+	}
+
+	/**
+	 * Entry point for adapter to handle messages related to statistics/flexcharts.
+	 *
+	 * @param {{chart?: string}} message
+	 * @param {Function} callback
+	 */
+	handleFlexMessage(message, callback) {
+		const chartType = message?.chart || 'hourly';
+		const result = this._buildFlexchart(chartType);
+		if (callback && typeof callback === 'function') {
+			callback(result);
+		}
+	}
+}
+
+module.exports = statistics;

package/lib/tools.js

@@ -70,8 +70,10 @@ class StateMap {
 	}
 
 	set(id, value, options) {
-		if (options?.type == 'number' && isNaN(value)) {
-			return;
+		if (options?.type == 'number') {
+			if (typeof value !== 'number' || isNaN(value)) {
+				return;
+			}
 		}
 		if (value !== null) {
 			if (options?.type == 'number') {
@@ -170,6 +172,14 @@ class RiemannSum {
 		return this._lastDate ? this._lastDate : new Date();
 	}
 
+	/**
+	 * Adds the new value to calculate the Riemann sum.
+	 *
+	 * This function calculates the Riemann sum by adding the new value multiplied by the time elapsed since the last value,
+	 * updating the total sum. If the auto reset at midnight is enabled, it resets the sum at midnight.
+	 *
+	 * @param {number} newValue - The new value to be added for Riemann sum calculation.
+	 */
 	add(newValue) {
 		//Obersumme bilden
 		const now = new Date();
@@ -182,12 +192,12 @@ class RiemannSum {
 				0,
 				0, // ...at 00:00:00 hours
 			);
-			if (this.lastDate?.getTime() <= lastnight.getTime()) {
+			if (this.lastDate?.getTime() < lastnight.getTime()) {
 				this.reset();
 			}
 		}
 		if (!isNaN(newValue)) {
-			this._sum += (newValue * (now.getTime() - this.lastDate.getTime())) / 3600 / 1000; //Hour/Sekunden
+			this._sum += (newValue * (now.getTime() - this.lastDate.getTime())) / 3600000; //Hour/Sekunden
 			this._lastDate = now;
 		}
 	}
@@ -240,6 +250,30 @@ const createAsyncLock = () => {
 	};
 };
 
+/**
+ * Warten auf einen Wert, der von einer Funktion zurückgegeben wird.
+ * Der Wert wird alle 100ms geprüft. Wenn der Wert innerhalb der angegebenen Zeit nicht gesetzt wurde, wird ein Timeout-Fehler zurückgegeben.
+ * @param {Function} func - Die Funktion, die den Wert zurückgibt.
+ * @param {number} [timeout] - Die maximale Wartezeit in ms.
+ * @returns {Promise} - Ein Promise, das den Wert zurückgibt oder einen Timeout-Fehler wirft.
+ */
+const waitForValue = (func, timeout = 5000) => {
+	return new Promise((resolve, reject) => {
+		const timer = setInterval(() => {
+			const variable = func();
+			if (variable !== undefined && variable !== null) {
+				clearInterval(timer);
+				resolve(variable);
+			}
+			timeout -= 200;
+			if (timeout <= 0) {
+				clearInterval(timer);
+				reject('Timeout: Wert wurde nicht rechtzeitig gesetzt.');
+			}
+		}, 200); // alle 200ms prüfen
+	});
+};
+
 // Get longitude an latidude from system config
 async function getSystemData(adapter) {
 	const state = await adapter.getForeignObjectAsync('system.config');
@@ -343,6 +377,7 @@ module.exports = {
 	RegisterMap,
 	RiemannSum,
 	createAsyncLock,
+	waitForValue,
 	getSystemData,
 	getAstroDate,
 	isSunshine,

package/lib/types.js

@@ -258,6 +258,12 @@ const dataType = {
 	},
 };
 
+const statisticsType = {
+	deltaReset: 'deltaReset',
+	delta: 'delta',
+	level: 'level',
+};
+
 module.exports = {
 	modbusErrorMessages,
 	getDeviceStatusInfo,
@@ -267,4 +273,5 @@ module.exports = {
 	driverClasses,
 	storeType,
 	dataType,
+	statisticsType,
 };

package/main.js

@@ -70,7 +70,8 @@ class Sun2000 extends utils.Adapter {
 		this.on('ready', this.onReady.bind(this));
 		this.on('stateChange', this.onStateChange.bind(this));
 		// this.on('objectChange', this.onObjectChange.bind(this));
-		// this.on('message', this.onMessage.bind(this));
+		// enable message handling for statistics/flexcharts requests
+		this.on('message', this.onMessage.bind(this));
 		this.on('unload', this.onUnload.bind(this));
 	}
 
@@ -356,9 +357,9 @@ class Sun2000 extends utils.Adapter {
 			this.config.timeout = this.config.timeout * 1000;
 			this.updateConfig(this.config);
 		}
-		if (this.config.sl_active) {
+		if (this.config['sl_active']) {
 			//old Smartlogger
-			this.config.sl_active = false;
+			this.config['sl_active'] = false;
 			this.config.integration = 1;
 			this.updateConfig(this.config);
 		}
@@ -670,17 +671,22 @@ class Sun2000 extends utils.Adapter {
 	//  * Using this method requires "common.messagebox" property to be set to true in io-package.json
 	//  * @param {ioBroker.Message} obj
 	//  */
-	// onMessage(obj) {
-	// 	if (typeof obj === 'object' && obj.message) {
-	// 		if (obj.command === 'send') {
-	// 			// e.g. send email or pushover or whatever
-	// 			this.log.info('send command');
-
-	// 			// Send response in callback if required
-	// 			if (obj.callback) this.sendTo(obj.from, obj.command, 'Message received', obj.callback);
-	// 		}
-	// 	}
-	// }
+
+	// handle incoming messages (used by flexcharts script source)
+	onMessage(obj) {
+		if (typeof obj === 'object' && obj.message) {
+			// support a dedicated command 'statistics' to generate chart data
+			if (obj.command === 'statistics') {
+				if (this.state.statistics && typeof this.state.statistics.handleFlexMessage === 'function') {
+					this.state.statistics.handleFlexMessage(obj.message, result => {
+						if (obj.callback) this.sendTo(obj.from, obj.command, result, obj.callback);
+					});
+				} else {
+					if (obj.callback) this.sendTo(obj.from, obj.command, { error: 'statistics unavailable' }, obj.callback);
+				}
+			}
+		}
+	}
 }
 
 if (require.main !== module) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iobroker.sun2000",
-  "version": "2.3.7",
+  "version": "2.4.0",
   "description": "sun2000",
   "author": {
     "name": "bolliy",
@@ -33,15 +33,15 @@
     "tcp-port-used": "^1.0.2"
   },
   "devDependencies": {
-    "@alcalzone/release-script": "^5.0.0",
-    "@alcalzone/release-script-plugin-iobroker": "^4.0.0",
-    "@alcalzone/release-script-plugin-license": "^4.0.0",
-    "@alcalzone/release-script-plugin-manual-review": "^4.0.0",
+    "@alcalzone/release-script": "^5.1.1",
+    "@alcalzone/release-script-plugin-iobroker": "^5.1.2",
+    "@alcalzone/release-script-plugin-license": "^5.1.1",
+    "@alcalzone/release-script-plugin-manual-review": "^5.1.1",
     "@iobroker/adapter-dev": "^1.5.0",
     "@iobroker/eslint-config": "^2.2.0",
     "@iobroker/testing": "^5.2.2",
-    "@tsconfig/node20": "^20.1.8",
-    "@types/node": "^25.0.10",
+    "@tsconfig/node20": "^20.1.9",
+    "@types/node": "^25.5.0",
     "globals": "^16.5.0",
     "typescript": "~5.9.3"
   },