iobroker.sun2000 2.2.0 → 2.3.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.4.10 or higher
+* ioBroker admin 7.6.17 or higher
 
 ## Documentation
 
@@ -65,6 +65,18 @@ browse in the [wiki](https://github.com/bolliy/ioBroker.sun2000/wiki)
 	Placeholder for the next version (at the beginning of the line):
 	### **WORK IN PROGRESS**
 -->
+### 2.3.0 (2025-10-21)
+* new release for npm migrates to Trusted Publishing
+
+### 2.2.1-alpha.0 (2025-10-21)
+* inverter control: add same state for startup and shutdown an inverter [#199](https://github.com/bolliy/ioBroker.sun2000/issues/199)
+* fix: Device status name has been corrected [#202](https://github.com/bolliy/ioBroker.sun2000/pull/202)
+* add undocumented device status `Shutdown: End of the ESS discharge process` 
+* emma control: new state ` emma.control.battery.ESSControlMode`. You can now configure EMMA with TOU-mode (Time of Use) to charge the battery from grid. [#200](https://github.com/bolliy/ioBroker.sun2000/discussions/200)
+* if an Emma is installed, some control states of the inverter are deactivated (read only). Mainly for the grid settings.
+* deprecated control states have been removed.
+* a workaround for issue [#582](https://github.com/yaacov/node-modbus-serial/issues/582) of node-modbus-serial has been implemented.
+
 ### 2.2.0 (2025-10-05)
 * dependency and configuration updates
 * new state `meter.derived.signConventionForPowerFeed-in` sign of meter.activePower that is currently being fed into the power grid

package/io-package.json

@@ -1,8 +1,34 @@
 {
   "common": {
     "name": "sun2000",
-    "version": "2.2.0",
+    "version": "2.3.0",
     "news": {
+      "2.3.0": {
+        "en": "new release for npm migrates to Trusted Publishing",
+        "de": "neue Veröffentlichung für npm migriert Trusted Publishing",
+        "ru": "новый релиз для npm перенесен в Trusted Publishing",
+        "pt": "nova versão para npm migra para a publicação confiável",
+        "nl": "nieuwe release voor npm-migraties naar Trusted Publishing",
+        "fr": "nouvelle version pour npm migre vers Trusted Publishing",
+        "it": "nuovo rilascio per npm migra a Trusted Publishing",
+        "es": "nueva versión para npm migrates a Trusted Publishing",
+        "pl": "nowa wersja dla migratów npm do zaufanej publikacji",
+        "uk": "новий реліз для npm migrats для Trusted Publishing",
+        "zh-cn": "npm 的新版本迁移到信任出版"
+      },
+      "2.2.1-alpha.0": {
+        "en": "inverter control: add same state for startup and shutdown an inverter [#199](https://github.com/bolliy/ioBroker.sun2000/issues/199)\nfix: Device status name has been corrected [#202](https://github.com/bolliy/ioBroker.sun2000/pull/202)\nadd undocumented device status `Shutdown: End of the ESS discharge process` \nemma control: new state ` emma.control.battery.ESSControlMode`. You can now configure EMMA with TOU-mode (Time of Use) to charge the battery from grid. [#200](https://github.com/bolliy/ioBroker.sun2000/discussions/200)\nif an Emma is installed, some control states of the inverter are deactivated (read only). Mainly for the grid settings.\ndeprecated control states have been removed.\na workaround for issue [#582](https://github.com/yaacov/node-modbus-serial/issues/582) of node-modbus-serial has been implemented.",
+        "de": "inverter-Steuerung: Fügen Sie den gleichen Zustand für Start und Abschaltung eines Inverters [#199](https://github.com/bolliy/ioBroker.sun2000/issues/199) hinzu\nbehoben: Gerätestatusname wurde korrigiert [#202](https://github.com/bolliy/ioBroker.sun2000/pull/202)\n`Shutdown: Ende des ESS-Entladungsvorgangs`\nemma control: new state ` emma.control.battery.ESSControlMode`. Sie können nun EMMA mit TOU-Modus (Time of Use) konfigurieren, um den Akku aus dem Netz zu laden. [#200](https://github.com/bolliy/ioBroker.sun2000/discussions/200)\nwenn eine Emma installiert ist, werden einige Steuerzustände des Wechselrichters deaktiviert (nur lesen). Hauptsächlich für die Netzeinstellungen.\ndeprekierte steuerzustände wurden entfernt.\nein workaround für ausgabe [#582](https://github.com/yaacov/node-modbus-serial/issues/582) von node-modbus-serial wurde implementiert.",
+        "ru": "инверторное управление: добавьте то же состояние для запуска и отключения инвертора [#199] (https://github.com/bolliy/ioBroker.sun2000/issues/199)\nисправление: имя статуса устройства было исправлено [#202] (https://github.com/bolliy/ioBroker.sun2000/pull/202)\nдобавить незарегистрированный статус устройства «Shutdown: End of the ESS discharge process»\nemma control: emma.control.battery.ESSControlMode. Теперь вы можете настроить EMMA с режимом TOU (Время использования) для зарядки батареи из сетки. [#200] (https://github.com/bolliy/ioBroker.sun2000/discussions/200)\nесли установлена Эмма, некоторые контрольные состояния инвертора деактивируются (только чтение). В основном для настроек сетки.\nустаревшие контрольные штаты были удалены.\nбыл реализован обходной путь для выпуска [#582] (https://github.com/yaacov/node-modbus-serial/issues/582) node-modbus-serial.",
+        "pt": "controle do inversor: adicione o mesmo estado para iniciar e desligar um inversor [#199](https://github.com/bolliy/ioBroker.sun2000/issues/199)\ncorreção: o nome do estado do dispositivo foi corrigido [#202] (https://github.com/bolliy/ioBroker.sun2000/pull/202)\nadicionar status do dispositivo não documentado `Shutdown: Fim do processo de descarga do ESS'\nemma control: novo estado `emma.control.battery.ESSControlMode`. Agora você pode configurar o EMMA com o modo TOU (Time of Use) para carregar a bateria da grade. [#200](https://github.com/bolliy/ioBroker.sun2000/discussions/200)\nse uma Emma estiver instalada, alguns estados de controle do inversor são desativados (apenas lidos). Principalmente para as configurações da grade.\nos estados de controlo desactualizados foram removidos.\numa solução alternativa para o problema [#582](https://github.com/yaacov/node-modbus-serial/issues/582) do nó-modbus-serial foi implementada.",
+        "nl": "inverter control: voeg dezelfde status toe voor het opstarten en afsluiten van een inverter [#199](https://github.com/bolliy/ioBroker.sun2000/issues/199)\nfix: De status van het apparaat is gecorrigeerd [#202](https://github.com/bolliy/ioBroker.sun2000/pull/202)\nstatus van niet-gedocumenteerd apparaat toevoegen: Afsluiten: Einde van het ESS-ontladingsproces\nemma control: nieuwe staat  U kunt nu EMMA configureren met de TOU-modus (Time of Use) om de batterij op te laden van het net. [#200](https://github.com/bolliy/ioBroker.sun2000/discussions/200)\nals een Emma is geïnstalleerd, worden sommige controletoestanden van de omvormer gedeactiveerd (alleen lezen). Vooral voor de rasterinstellingen.\nverouderde controlestaten zijn verwijderd.\ner is een oplossing gevonden voor nummer [#582](https://github.com/yaacov/node-modbus-serial/issues/582) van node-modbus-serial.",
+        "fr": "contrôle de l'onduleur: ajouter le même état pour le démarrage et l'arrêt d'un onduleur [#199](https://github.com/bolliy/ioBroker.sun2000/issues/199)\ncorrection : le nom de l'état du périphérique a été corrigé [#202](https://github.com/bolliy/ioBroker.sun2000/pull/202)\najouter l'état de l'appareil sans papiers `Shutdown: Fin du processus de décharge ESS'\ncontrôle emma: nouvel état ` emma.control.battery.ESSControlMode`. Vous pouvez maintenant configurer EMMA en mode TOU (Time of Use) pour charger la batterie à partir de la grille. [#200](https://github.com/bolliy/ioBroker.sun2000/discussions/200)\nsi une Emma est installée, certains états de contrôle de l'onduleur sont désactivés (lisez seulement). Principalement pour les paramètres de la grille.\nles états de contrôle dépréciés ont été supprimés.\nune solution de rechange pour l'émission [#582](https://github.com/yaacov/node-modbus-serial/issues/582) de nœud-modbus-serial a été mise en œuvre.",
+        "it": "controllo inverter: aggiungere lo stesso stato per l'avvio e l'arresto di un inverter [#199](https://github.com/bolliy/ioBroker.sun2000/issues/199)\nfix: Il nome dello stato del dispositivo è stato corretto [#202](https://github.com/bolliy/ioBroker.sun2000/pull/202)\naggiungere lo stato del dispositivo non documentato `Shutdown: Fine del processo di scarico ESS`\ncontrollo emma: nuovo stato ` emma.control.battery.ESSControlMode`. È ora possibile configurare EMMA con TOU-mode (Time of Use) per caricare la batteria dalla rete. [#200](https://github.com/bolliy/ioBroker.sun2000/discussions/200)\nse viene installata una Emma, alcuni stati di controllo dell'inverter sono disattivati (leggi solo). Principalmente per le impostazioni della griglia.\nstati di controllo deprecati sono stati rimossi.\nè stato implementato un workaround per il numero [#582](https://github.com/yaacov/node-modbus-serial/issues/582) di node-modbus-serial.",
+        "es": "control inverter: añadir el mismo estado para iniciar y cerrar un inverter [#199](https://github.com/bolliy/ioBroker.sun2000/issues/199)\nfijado: Se ha corregido el nombre del estado de los dispositivos [#202](https://github.com/bolliy/ioBroker.sun2000/pull/202)\nañadir estado de dispositivo no documentado `Shutdown: Final del proceso de descarga ESS`\nemma control: nuevo estado ` emma.control.battery.ESSControlMode`. Ahora puede configurar EMMA con TOU-mode (Time of Use) para cargar la batería de la red. [#200](https://github.com/bolliy/ioBroker.sun2000/discussions/200)\nsi se instala una Emma, se desactivan algunos estados de control del inversor (sólo lectura). Principalmente para la configuración de la red.\nestados de control deprecatados han sido eliminados.\na workaround for issue [#582](https://github.com/yaacov/node-modbus-serial/issues/582) of node-modbus-serial has been implemented.",
+        "pl": "inverter control: add same state for startup and shutdown an inverter [# 199] (https: / / github.com / bolliy / ioBroker.sun2000 / issues / 199)\nfix: Nazwa statusu urządzenia została poprawiona [# 202] (https: / / github.com / bolliy / ioBroker.sun2000 / pull / 202)\ndodać nieudokumentowany status urządzenia \"Wyłączenie: koniec procesu rozładowania ESS\"\nemma control: New state 'emma.control.battery.ESSControlMode'. Można teraz skonfigurować EMMA z TOU- mode (Time of Use), aby naładować baterię z siatki. [# 200] (https: / / github.com / bolliy / ioBroker.sun2000 / discussions / 200)\njeśli zainstalowana jest Emma, niektóre stany sterujące inwertera są wyłączone (tylko do odczytu). Głównie dla ustawień siatki.\nusunięto zdepregatowane stany kontrolne.\na workaround for issue [# 582] (https: / / github.com / yaacov / node- modbus- serial / issues / 582) of node- modbus- serial został wdrożony.",
+        "uk": "контроль інвертора: додати однаковий стан для запуску та відключення інвертора [#199](https://github.com/bolliy/ioBroker.sun2000/issues/199)\nвиправлено: Назва стану пристрою було виправлено [#202] (https://github.com/bolliy/ioBroker.sun2000/pull/202)\nдодати недокументований статус пристрою `Пошук: кінець процесу розряду ESS\nемма управління: новий стан ` emma.control.battery.ESSControlMode`. Ви можете налаштувати EMMA з TOU-mode (Time of Use) для зарядки акумулятора з сітки. [#200](https://github.com/bolliy/ioBroker.sun2000/discussions/200)\nякщо встановлений Емма, деактивуються деякі стани управління інвертором (прочитати тільки). В основному для налаштування сітки.\nвилучені стани керування.\n[#582](https://github.com/yaacov/node-modbus-serial/issues/582) вузла-modbus-serial.",
+        "zh-cn": "反转器控制:为启动和关闭添加相同状态的反转器[199](https://github.com/bolliy/ioBroker.sun2000/issues/199)\n固定: 设备状态名称已更正 [# 202] (https://github.com/bolliy/ioBroker.sun2000/pul/202)\n添加无文件设备状态“关闭:ESS放电过程结束”\nemma控制:新状态`emma.control.battery.ESS Control Mode'. 您现在可以用 TOU- mode( 使用时间) 配置 EMMA 从电网中充电 。 [# 200] (https://github.com/bolliy/ioBroker.sun2000/discussions/200)\n如果安装了Emma,反转器的某些控制状态就会失效(只读). 主要用于网格设置.\n贬值的控制状态已被取消.\n已落实了节点-modbus-serial[#582](https://github.com/yaacov/node-modbus-serial/issues/582)的工作."
+      },
       "2.2.0": {
         "en": "dependency and configuration updates\nnew state `meter.derived.signConventionForPowerFeed-in` sign of meter.activePower that is currently being fed into the power grid\nnew state `meter.derived.feed-inPower` electric power that is supplied to a grid (\"fed in\")",
         "de": "abhängigkeits- und konfigurationsupdates\nneuer Zustand `meter.derived.signConventionForPowerFeed-in` Zeichen von meter.active Strom, der derzeit in das Stromnetz eingespeist wird\nneue Zustand `meter.derived.feed-inPower` elektrische Leistung, die einem Netz zugeführt wird (\"fed in\")",
@@ -67,32 +93,6 @@
         "pl": "aktualizacji zależności\nfix: nadwyżka mocy podczas rozładowania akumulatora\ncontrol: nowa wartość kontrolna 'sun2000.0.control.usableSurplus.buverHysteresis'",
         "uk": "оновлення залежності\nвиправити: надлишок живлення при розряді акумулятора\n`sun2000.0.control.usableSurplus.bufferHysteresis`",
         "zh-cn": "更新依赖关系\n固定:电池放电时的剩余功率\n控制: 新的控制值 `sun2000.control.ulySurplus.bufferHysteresis'"
-      },
-      "1.4.0": {
-        "en": "control: new control state `sun2000.0.control.externalPower` #76\nfixed issue detected by repository checker #166",
-        "de": "steuerung: neuer Steuerzustand `sun2000.0.control.externalPower` #76\nbehobenes problem erkannt von repository checker #166",
-        "ru": "новый контрольный режим «sun2000.0.control.externalPower» #76\nфиксированная проблема, обнаруженная проверкой репозитория #166",
-        "pt": "controle: novo estado de controle `sun2000.0.control.externalPower` #76\nproblema fixo detectado pelo verificador de repositório #166",
-        "nl": "controle: nieuwe controle staat  #76\nvaste uitgifte gedetecteerd door repository checker #166",
-        "fr": "contrôle: nouvel état de contrôle `sun2000.0.control.externalPower` #76\nproblème corrigé détecté par le vérificateur de dépôt #166",
-        "it": "controllo: nuovo stato di controllo `sun2000.0.control.externalPower` #76\nproblema fisso rilevato da repository checker #166",
-        "es": "control: nuevo estado de control `sun2000.0.control.externalPower` #76\nnúmero fijo detectado por el repositorio #166",
-        "pl": "control: nowy stan kontroli 'sun2000.0.control.externalPower' # 76\nstała emisja wykryta przez kontroler repozytorium # 166",
-        "uk": "контроль: новий стан управління `sun2000.0.control.externalPower` #76\nвиправлено проблему, виявлену репозиторійною перевіркою #166",
-        "zh-cn": "控制:新的控制状态`sun 2000.0.control.external Power ' 76号\n仓库检查器检测到的固定问题 # 166"
-      },
-      "1.3.0": {
-        "en": "usableSurplusPower: new control state `sun2000.0.control.usableSurplus.allowNegativeValue`",
-        "de": "usableSurplusPower: neuer Steuerzustand `sun2000.0.control.usableSurplus.allowNegativeValue `",
-        "ru": "usableSurplusPower: новое состояние управления 'sun2000.0.control.usableSurplus.allowНегативная ценность пункт",
-        "pt": "usableSurplusPower: novo estado de controle `sun2000.0.control.usableSurplus.allowValue negativo \"",
-        "nl": "bruikbareSurplusPower: nieuwe controlestatus  Wat",
-        "fr": "utilisableSurplusPower: nouvel état de contrôle `sun2000.0.control.usableSurplus.allowNegativeValue \"",
-        "it": "usableSurplusPower: nuovo stato di controllo `sun2000.0.control.usableSurplus.allowValore negativo #",
-        "es": "usableSurplusPower: nuevo estado de control `sun2000.0.control.usableSurplus.allowNegativeValue `",
-        "pl": "usableSurplusPower: nowy stan kontroli 'Sun2000.0.control.usableSurplus.allowNegativeValue'",
-        "uk": "english, Українська, Français... й",
-        "zh-cn": "可用SurpusPower: 新的控制状态 `sun 2000.control.usurplus.allow NegativeValue ' `"
       }
     },
     "titleLang": {

package/lib/controls/emma_service_queue.js

@@ -0,0 +1,304 @@
+'use strict';
+const { deviceType, dataType } = require(`${__dirname}/../types.js`);
+class ServiceQueueMap {
+	constructor(adapterInstance, emma) {
+		this.adapter = adapterInstance;
+		this.log = this.adapter.logger;
+		this.inverterInfo = emma;
+		this._modbusClient = null;
+		this._serviceMap = new Map();
+		this._eventMap = new Map();
+		this._initialized = false;
+		this._name = 'emma control';
+
+		this.serviceFields = [
+			{
+				state: { id: 'battery.ESSControlMode', name: 'ESS control mode', type: 'number', unit: '', role: 'level', desc: 'reg:40000, len:1' },
+				type: deviceType.battery,
+				fn: async event => {
+					let ret = false;
+					if (event.value > 6) {
+						event.value = 2;
+					}
+					if (event.value < 2 || event.value === 3) {
+						event.value = 2;
+					}
+					if (this.isTestMode()) {
+						this.log.info(`${this._name}: the test mode is active, so the ESS control mode is always written to register 47086`);
+						ret = await this._writeRegisters(47086, dataType.numToArray(event.value, dataType.uint16));
+					} else {
+						ret = await this._writeRegisters(40000, dataType.numToArray(event.value, dataType.uint16));
+						/*
+						if (ret) {
+							this.inverterInfo.instance.stateCache.set(`emma.${event.id}`, event.value, { type: 'number' });
+						}
+						*/
+					}
+					return ret;
+				},
+			},
+			{
+				state: {
+					id: 'battery.tou.preferredUseOfSurplusPvPower',
+					name: '[Time of Use mode] Preferred use of surplus PV power',
+					type: 'boolean',
+					unit: '',
+					role: 'switch.enable',
+					desc: 'reg: 40001, len: 1',
+				},
+				type: deviceType.battery,
+				fn: async event => {
+					let ret = false;
+
+					if (this.isTestMode()) {
+						this.log.info(`${this._name}: the test mode is active, so the maximum power for charging batteries from grid not transferred`);
+						ret = true;
+					} else {
+						ret = await this._writeRegisters(40001, event.value === true ? [1] : [0]);
+					}
+					/*
+					if (ret) {
+						this.inverterInfo.instance.stateCache.set(`emma.${event.id}`, event.value);
+					}
+					*/
+					return ret;
+				},
+			},
+			{
+				state: {
+					id: 'battery.tou.maximumPowerForChargingFromGrid',
+					name: '[Time of Use mode] Maximum power for charging batteries from grid',
+					type: 'number',
+					unit: 'kW',
+					role: 'level.power',
+					desc: 'reg: 40002, len: 2',
+				},
+				type: deviceType.battery,
+				fn: async event => {
+					let ret = false;
+					if (event.value > 50) {
+						event.value = 50;
+					}
+					if (event.value < 0) {
+						event.value = 0;
+					}
+					if (this.isTestMode()) {
+						this.log.info(`${this._name}: the test mode is active, so the maximum power for charging batteries from grid not transferred`);
+						ret = true;
+					} else {
+						ret = await this._writeRegisters(40002, dataType.numToArray(event.value * 1000, dataType.uint32));
+					}
+					/*
+					if (ret) {
+						this.inverterInfo.instance.stateCache.set(`emma.${event.id}`, event.value, { type: 'number' });
+					}
+					*/
+					return ret;
+				},
+			},
+		];
+	}
+
+	async _init() {
+		if (this.inverterInfo.instance) {
+			for (const item of this.serviceFields) {
+				if (item?.state) {
+					this._serviceMap.set(item.state.id, item);
+				}
+			}
+
+			for (const entry of this._serviceMap.values()) {
+				//await this._initState('emma.control.',entry.state);
+				const path = `emma.control.`;
+				await this._initState(path, entry.state);
+				const state = await this.adapter.getState(path + entry.state.id);
+				if (state && state.ack === false) {
+					this.set(entry.state.id, state);
+				}
+			}
+			//subscribe all control states
+			this.adapter.subscribeStates(`emma.control*`);
+			this._initialized = true;
+
+			if (this.adapter.settings?.cb.tou && !this.isTestMode()) {
+				const essControlMode = await this._readHoldingRegisters(40000, 1);
+				//const tou = await this._readHoldingRegisters(40004,43); //first periode
+				if (essControlMode && essControlMode[0] !== 5) {
+					/*
+					127 - Working mode settings
+					2 : Maximise self consumptions (default)
+					5 : Time Of Use(Luna) - hilfreich bei dynamischem Stromtarif (z.B Tibber)
+
+					Time of Using charging and discharging periodes (siehe Table 5-6)
+					tCDP[3] = 127 - Working mode settings - load from grid (charge)
+					tCDP[3] = 383 - Working mode settings - self-consumption (discharge)
+					*/
+					const tCDP = [
+						1, 0, 1440, 127, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+					];
+					if (await this._writeRegisters(40004, tCDP)) {
+						this.inverterInfo.instance.addHoldingRegisters((40004, tCDP));
+						this.log.info(`${this._name}: The default TOU setting are transferred`);
+					}
+				}
+			}
+		}
+
+		if (this._initialized) {
+			this.log.info(`${this._name}: service queue initialized`);
+		}
+	}
+
+	/**
+	 * Checks if the device is in test mode
+	 * @returns {boolean} True if the device is in test mode, false otherwise
+	 */
+	isTestMode() {
+		return this.inverterInfo.instance?.isTestMode() || false;
+	}
+
+	/**
+	 * @description Check if the value of the event is a number and optionally round it to the nearest integer.
+	 * @param {object} event The event object
+	 * @param {boolean} [round] If true, the value is rounded to the nearest integer
+	 * @returns {boolean} True if the value is a number, false otherwise
+	 */
+	isNumber(event, round = true) {
+		if (isNaN(event.value)) {
+			return false;
+		}
+		if (round) event.value = Math.round(event.value);
+		return true;
+	}
+
+	get(id) {
+		return this._eventMap.get(id);
+	}
+
+	set(id, state) {
+		const service = this._serviceMap.get(id);
+		if (state && service) {
+			if (state.val !== null && !state.ack) {
+				this.log.info(`${this._name}: Event - state: emma.control.${id} changed: ${state.val} ack: ${state.ack}`);
+				const event = this._eventMap.get(id);
+				if (event) {
+					event.value = state.val;
+					event.ack = false;
+				} else {
+					this._eventMap.set(id, { id: id, value: state.val, ack: false });
+				}
+			}
+		}
+	}
+
+	/**
+	 * Processes pending events in the service queue and attempts to execute their associated functions.
+	 *
+	 * @async
+	 * @param {object} modbusClient - The modbus client instance used for communication.
+	 *
+	 * @description This function iterates over the events in the service queue, checking whether each event
+	 * can be processed. It verifies conditions such as battery presence and running status, and checks if the
+	 * event value is a number when required. If the event is successfully processed, it acknowledges the event
+	 * by setting its state in the adapter and removes it from the event map. If the event cannot be processed
+	 * after multiple attempts, it is discarded. The function initializes the service queue if it is not already
+	 * initialized and the adapter is connected.
+	 */
+
+	async process(modbusClient) {
+		this._modbusClient = modbusClient;
+
+		if (this._initialized) {
+			let count = 0;
+			for (const event of this._eventMap.values()) {
+				if (event.ack) {
+					continue;
+				} //allready done
+				const service = this._serviceMap.get(event.id);
+				if (!service.errorCount) {
+					service.errorCount = 0;
+				}
+				if (event.value !== null && service.fn) {
+					//check if battery is present and running
+					if (service.state.type === 'number') {
+						if (!this.isNumber(event)) {
+							this.log.warn(
+								`${this._name}: Event is discarded because the value ${event.value} is not a number. State: emma.control.${event.id}`,
+							);
+							this._eventMap.delete(event.id); //forget the event
+							continue;
+						}
+					}
+					count++;
+					if (await service.fn(event)) {
+						service.errorCount = 0;
+						try {
+							event.ack = true;
+							await this.adapter.setState(`emma.control.${event.id}`, { val: event.value, ack: true });
+							this._eventMap.delete(event.id);
+							this.log.info(`${this._name}: write state emma.control.${event.id} : ${event.value} ack: true`);
+						} catch {
+							this.log.warn(`${this._name}: Can not write state emma.control.${event.id}`);
+						}
+					} else {
+						service.errorCount++;
+						if (service.errorCount > 1) {
+							this._eventMap.delete(event.id); //forget it
+							this.log.info(`${this._name}: Event is discarded because it could not be processed. State: emma.control.${event.id}`);
+						}
+					}
+				}
+				if (count > 1) {
+					break;
+				} //max 2 Events
+			}
+		}
+		if (!this._initialized && this.adapter.isConnected) {
+			await this._init();
+		}
+	}
+
+	async _writeRegisters(address, data) {
+		try {
+			this.log.debug(`Try to write data to id/address/length ${this._modbusClient.id}/${address}/${data.length}`);
+			await this._modbusClient.writeRegisters(address, data);
+			this.inverterInfo.instance.addHoldingRegisters(address, data); //write also to the modbus read cache
+			return true;
+		} catch (err) {
+			this.log.warn(
+				`Error while writing to ${this._modbusClient.ipAddress} [Reg: ${address}, Len: ${data.length}, modbusID: ${this._modbusClient.id}] with: ${err.message}`,
+			);
+		}
+	}
+
+	async _readHoldingRegisters(address, length) {
+		try {
+			this.log.debug(`Try to read data to id/address/length ${this._modbusClient.id}/${address}/${length}`);
+			const data = await this._modbusClient.readHoldingRegisters(address, length);
+			return data;
+		} catch (err) {
+			this.log.warn(
+				`Error while reading from ${this._modbusClient.ipAddress} [Reg: ${address}, Len: ${length}, modbusID: ${this._modbusClient.id}] with: ${err.message}`,
+			);
+		}
+	}
+
+	//state
+	async _initState(path, state) {
+		await this.adapter.extendObject(path + state.id, {
+			type: 'state',
+			common: {
+				name: state.name,
+				type: state.type,
+				role: state.role,
+				unit: state.unit,
+				desc: state.desc,
+				read: true,
+				write: true,
+			},
+			native: {},
+		});
+	}
+}
+
+module.exports = ServiceQueueMap;

package/lib/controls/{service_queue.js → inverter_service_queue.js}

@@ -1,19 +1,62 @@
 'use strict';
-const { deviceType, dataType } = require(`${__dirname}/../types.js`);
+const { deviceType, driverClasses, dataType } = require(`${__dirname}/../types.js`);
+const tools = require(`${__dirname}/../tools.js`);
+
 class ServiceQueueMap {
-	constructor(adapterInstance, inverter) {
+	constructor(adapterInstance, device) {
 		this.adapter = adapterInstance;
 		this.log = this.adapter.logger;
-		this.inverterInfo = inverter;
+		this.inverterInfo = device;
 		this._modbusClient = null;
 		this._serviceMap = new Map();
 		this._eventMap = new Map();
 		this._initialized = false;
+		this._name = 'inverter control';
+		this._emmaAvailable = this.adapter.devices.find(d => d.driverClass == driverClasses.emma);
 
 		this.serviceFields = [
+			{
+				state: {
+					id: 'startup',
+					name: 'startup inverter',
+					type: 'boolean',
+					role: 'switch.enable',
+					desc: 'reg: 40200 , len: 1',
+				},
+				type: deviceType.inverter,
+				deactiveIfEmmaAvailable: true,
+				fn: async event => {
+					let ret = false;
+					if (event.value === true) {
+						ret = await this._writeRegisters(40200, [0]);
+						event.value = false;
+					}
+					return ret;
+				},
+			},
+			{
+				state: {
+					id: 'shutdown',
+					name: 'shutdown inverter',
+					type: 'boolean',
+					role: 'switch.enable',
+					desc: 'reg: 40201, len: 1',
+				},
+				deactiveIfEmmaAvailable: true,
+				type: deviceType.inverter,
+				fn: async event => {
+					let ret = false;
+					if (event.value === true) {
+						ret = await this._writeRegisters(40201, [0]);
+						event.value = false;
+					}
+					return ret;
+				},
+			},
 			{
 				state: { id: 'battery.chargeFromGridFunction', name: 'Charge from grid', type: 'boolean', role: 'switch.enable', desc: 'reg: 47087, len: 1' },
 				type: deviceType.battery,
+				deactiveIfEmmaAvailable: true,
 				fn: async event => {
 					const ret = await this._writeRegisters(47087, event.value === true ? [1] : [0]);
 					if (ret) {
@@ -72,8 +115,8 @@ class ServiceQueueMap {
 					return ret;
 				},
 			},
+			/* @deprecated
 			{
-				//@deprecated
 				state: {
 					id: 'battery.maximumChargePower',
 					name: 'MaximumChargePower',
@@ -91,12 +134,11 @@ class ServiceQueueMap {
 					if (event.value < 0) {
 						event.value = 0;
 					}
-					this.log.warn(`Control: maximumChargePower is deprecated use "maximumChargingPower" instead`);
+					this.log.warn(`${this._name}: maximumChargePower is deprecated use "maximumChargingPower" instead`);
 					return await this._writeRegisters(47075, dataType.numToArray(event.value, dataType.uint32));
 				},
 			},
 			{
-				//@deprecated
 				state: {
 					id: 'battery.maximumDischargePower',
 					name: 'MaximumDischargePower',
@@ -114,10 +156,11 @@ class ServiceQueueMap {
 					if (event.value < 0) {
 						event.value = 0;
 					}
-					this.log.warn(`Control: maximumDischargePower is deprecated use "maximumDischargingPower" instead`);
+					this.log.warn(`${this._name}: maximumDischargePower is deprecated use "maximumDischargingPower" instead`);
 					return await this._writeRegisters(47077, dataType.numToArray(event.value, dataType.uint32));
 				},
 			},
+			*/
 			{
 				state: {
 					id: 'battery.chargingCutoffCapacity',
@@ -200,6 +243,7 @@ class ServiceQueueMap {
 					if (event.value < 0) {
 						event.value = 2;
 					}
+
 					const ret = await this._writeRegisters(47086, dataType.numToArray(event.value, dataType.uint16));
 					if (ret) {
 						this.inverterInfo.instance.stateCache.set(`${this.inverterInfo.path}.${event.id}`, event.value, { type: 'number' });
@@ -528,41 +572,49 @@ class ServiceQueueMap {
 	}
 
 	async _init() {
+		const emmaAvailable = this.adapter.devices.find(d => d.driverClass == driverClasses.emma);
+
 		if (this.inverterInfo.instance) {
 			for (const item of this.serviceFields) {
-				//no battery - no controls
-				//if (item.type == deviceType.battery && this.inverterInfo.instance.numberBatteryUnits() === 0) continue;
-				if (item.type == deviceType.meter && !this.inverterInfo?.meter) {
-					continue;
-				}
-				if (item.type == deviceType.gridPowerControl && !this.inverterInfo?.meter) {
-					continue;
-				}
 				if (item?.state) {
+					if (item.type == deviceType.meter && !this.inverterInfo?.meter) {
+						//no meter - delete states if existing
+						item.state.write = false;
+						/*
+						await this._delState(`${this.inverterInfo.path}.control.${item.state.id}`);
+						continue;
+						*/
+					}
+					if (item.type == deviceType.gridPowerControl && !this.inverterInfo?.meter) {
+						//not meter - delete states if existing
+						item.state.write = false;
+						/*
+						await this._delState(`${this.inverterInfo.path}.control.${item.state.id}`);
+						continue;
+						*/
+					}
+					if (emmaAvailable && item?.deactiveIfEmmaAvailable) {
+						item.state.write = false;
+					}
+
 					this._serviceMap.set(item.state.id, item);
 				}
 			}
 
 			for (const entry of this._serviceMap.values()) {
-				//await this._initState(this.inverterInfo.path+'.control.',entry.state);
 				const path = `${this.inverterInfo.path}.control.`;
+
+				//create state
 				await this._initState(path, entry.state);
+
+				//get previous unacknowledged state
 				const state = await this.adapter.getState(path + entry.state.id);
 				if (state && state.ack === false) {
 					this.set(entry.state.id, state);
 				}
 			}
-			//upgrade
-			const tSOC = await this.adapter.getState(`${this.inverterInfo.path}.control.battery.targetSOC `);
-			if (tSOC) {
-				await this.adapter.delObject(`${this.inverterInfo.path}.control.battery.targetSOC `, { recursive: false });
-				if (tSOC.val !== null) {
-					await this.adapter.setState(`${this.inverterInfo.path}.control.battery.targetSOC`, { val: tSOC.val, ack: tSOC.ack });
-					if (tSOC.ack === false) {
-						this.set('battery.targetSOC', tSOC);
-					}
-				}
-			}
+
+			await this._upgrade(); //upgrade old states
 
 			this.adapter.subscribeStates(`${this.inverterInfo.path}.control*`);
 			this._initialized = true;
@@ -584,14 +636,40 @@ class ServiceQueueMap {
 						1, 0, 1440, 127, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 					];
 					if (await this._writeRegisters(47255, tCDP)) {
-						this.log.info('Control: The default TOU setting are transferred');
+						this.inverterInfo.instance.addHoldingRegisters(47255, tCDP);
+						this.log.info(`${this._name}: The default TOU setting are transferred to the inverter.`);
 					}
 				}
 			}
 		}
 
 		if (this._initialized) {
-			this.log.info('Control: Service queue initialized');
+			this.log.info(`${this._name}: Service queue initialized`);
+		}
+	}
+
+	/**
+	 * Upgrades deprecated states.
+	 * Checks if the old states exist and if so, deletes them and replaces them with the new ones.
+	 * @returns {Promise<void>}
+	 */
+	async _upgrade() {
+		if (await tools.existsState(this.adapter, `${this.inverterInfo.path}.control.battery.targetSOC `)) {
+			const tSOC = await this.adapter.getState(`${this.inverterInfo.path}.control.battery.targetSOC `);
+			await tools.deleteState(this.adapter, `${this.inverterInfo.path}.control.battery.targetSOC `);
+			if (tSOC && tSOC?.val !== null) {
+				await this.adapter.setState(`${this.inverterInfo.path}.control.battery.targetSOC`, { val: tSOC.val, ack: tSOC.ack });
+				if (tSOC?.ack === false) {
+					this.set('battery.targetSOC', tSOC);
+				}
+			}
+		}
+
+		if (await tools.existsState(this.adapter, `${this.inverterInfo.path}.control.battery.maximumChargePower`)) {
+			await tools.deleteState(this.adapter, `${this.inverterInfo.path}.control.battery.maximumChargePower`);
+		}
+		if (await tools.existsState(this.adapter, `${this.inverterInfo.path}.control.battery.maximumDischargePower`)) {
+			await tools.deleteState(this.adapter, `${this.inverterInfo.path}.control.battery.maximumDischargePower`);
 		}
 	}
 
@@ -617,7 +695,7 @@ class ServiceQueueMap {
 		const service = this._serviceMap.get(id);
 		if (state && service) {
 			if (state.val !== null && !state.ack) {
-				this.log.info(`Control: Event - state: ${this.inverterInfo.path}.control.${id} changed: ${state.val} ack: ${state.ack}`);
+				this.log.info(`${this._name}: Event - state: ${this.inverterInfo.path}.control.${id} changed: ${state.val} ack: ${state.ack}`);
 				const event = this._eventMap.get(id);
 				if (event) {
 					event.value = state.val;
@@ -628,11 +706,7 @@ class ServiceQueueMap {
 			}
 		}
 	}
-	/*
-	values() {
-		return this._map.values();
-	}
-    */
+
 	/**
 	 * Processes pending events in the service queue and attempts to execute their associated functions.
 	 *
@@ -665,10 +739,10 @@ class ServiceQueueMap {
 					//check if battery is present and running
 					if (service.type == deviceType.battery) {
 						if (this.inverterInfo.instance.numberBatteryUnits() === 0) {
-							this.log.warn(`Control: Event is discarded because no battery has been detected. `);
+							this.log.warn(`${this._name}: Event is discarded because no battery has been detected. `);
 							if (!this.adapter.isReady) {
 								this.log.warn(
-									'Control: The Adapter is not ready! Please check the value in the state sun2000.x.info.JSONhealth and the Log output.',
+									`${this._name}: The Adapter is not ready! Please check the value in the state sun2000.x.info.JSONhealth and the Log output.`,
 								);
 							}
 							this._eventMap.delete(event.id); //forget the event
@@ -677,7 +751,7 @@ class ServiceQueueMap {
 						const BatStatus = this.inverterInfo.instance.stateCache.get(`${this.inverterInfo.path}.battery.runningStatus`)?.value ?? -1;
 						if (BatStatus !== 2 && BatStatus !== 1 && BatStatus !== -1) {
 							this.log.warn(
-								`Control: Event is discarded because battery is not running. State: ${this.inverterInfo.path}.battery.runningStatus = ${BatStatus}. `,
+								`${this._name}: Event is discarded because battery is not running. State: ${this.inverterInfo.path}.battery.runningStatus = ${BatStatus}. `,
 							);
 							this._eventMap.delete(event.id); //forget the event
 							continue;
@@ -686,7 +760,7 @@ class ServiceQueueMap {
 					if (service.state.type === 'number') {
 						if (!this.isNumber(event)) {
 							this.log.warn(
-								`Control: Event is discarded because the value ${event.value} is not a number. State: ${this.inverterInfo.path}.control.${event.id}`,
+								`${this._name}: Event is discarded because the value ${event.value} is not a number. State: ${this.inverterInfo.path}.control.${event.id}`,
 							);
 							this._eventMap.delete(event.id); //forget the event
 							continue;
@@ -699,15 +773,15 @@ class ServiceQueueMap {
 							event.ack = true;
 							await this.adapter.setState(`${this.inverterInfo.path}.control.${event.id}`, { val: event.value, ack: true });
 							this._eventMap.delete(event.id);
-							this.log.info(`Control: write state ${this.inverterInfo.path}.control.${event.id} : ${event.value} ack: true`);
+							this.log.info(`${this._name}: write state ${this.inverterInfo.path}.control.${event.id} : ${event.value} ack: true`);
 						} catch {
-							this.log.warn(`Control: Can not write state ${this.inverterInfo.path}.control.${event.id}`);
+							this.log.warn(`${this._name}: Can not write state ${this.inverterInfo.path}.control.${event.id}`);
 						}
 					} else {
 						service.errorCount++;
 						if (service.errorCount > 1) {
 							this._eventMap.delete(event.id); //forget it
-							this.log.info(`Control: Event is discarded because it could not be processed. ${this.inverterInfo.path}.control.${event.id}`);
+							this.log.info(`${this._name}: Event is discarded because it could not be processed. ${this.inverterInfo.path}.control.${event.id}`);
 						}
 					}
 				}
@@ -757,7 +831,7 @@ class ServiceQueueMap {
 				unit: state.unit,
 				desc: state.desc,
 				read: true,
-				write: true,
+				write: state.write ?? true,
 			},
 			native: {},
 		});

package/lib/drivers/driver_base.js

@@ -21,7 +21,7 @@ class DriverBase {
 		this._deviceStatus = -1; //device shutdown or standby
 		this._regMap = new RegisterMap();
 
-		this.control = null; //Battery Charge control
+		this.control = null; //Sdongle Service Queue, Emma Service Queue
 		this.log = new Logging(this.adapter); //my own Logger
 
 		this.registerFields = [];
@@ -65,7 +65,26 @@ class DriverBase {
 	}
 
 	getHoldingRegisters(startAddr, length) {
-		return this._regMap.get(startAddr, length, this.adapter.isReady);
+		const data = this._regMap.get(startAddr, length, this.adapter.isReady);
+		if (this.isTestMode() && startAddr === 30302) {
+			this.log.info(`### TestMode ### get raw data from device/id/address/data ${this._name}/${this._modbusId}/${startAddr}/${data}`);
+		}
+		return data;
+	}
+
+	/**
+	 * Checks if the device is in test mode
+	 * @returns {boolean} True if the device is in test mode, false otherwise
+	 */
+	isTestMode() {
+		return false;
+	}
+
+	logHoldingRegisters(startAddr, length) {
+		if (startAddr === 30302) {
+			const data = this.getHoldingRegisters(startAddr, length);
+			this.log.info(`### TestMode ### read data from device/id/address/data ${this._name}/${this._modbusId}/${startAddr}/${data}`);
+		}
 	}
 
 	_fromArray(data, address, field) {
@@ -126,8 +145,7 @@ class DriverBase {
 	}
 
 	async _processRegister(reg, data) {
-		//0.4.x
-		this.addHoldingRegisters(reg.address, data);
+		this.addHoldingRegisters(reg.address, data); //store row Data of modbus registers
 
 		const path = this._getStatePath(reg.type);
 		//pre hook
@@ -257,6 +275,28 @@ class DriverBase {
 		return chargers;
 	}
 
+	/**
+	 * Updates the states of the device.
+	 *
+	 * This function sets the Modbus client, then calls the battery control and active power control
+	 * if the refresh rate is not high. It then iterates over the register fields and calls
+	 * the readHoldingRegisters function on the Modbus client to read the data from the registers.
+	 * For each register, it checks if the device is allowed to communicate with the Modbus network,
+	 * if the refresh rate is equal to the register's refresh rate, and if the register's checkIfActive
+	 * function returns true. If all conditions are met, it calls the _processRegister function to process
+	 * the data from the register.
+	 * If the refresh rate is low or empty, it checks if the last read time is older than the specified
+	 * interval. If so, it calls the readHoldingRegisters function to read the data from the register.
+	 * If any errors occur during the read operation, it catches the error and logs a warning message.
+	 * 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 {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.
+	 */
+
 	async updateStates(modbusClient, refreshRate, duration) {
 		this._modbusClient = modbusClient;
 

package/lib/drivers/driver_emma.js

@@ -1,15 +1,16 @@
 const { deviceType, driverClasses, dataRefreshRate, dataType } = require(`${__dirname}/../types.js`);
 const DriverBase = require(`${__dirname}/driver_base.js`);
+const ServiceQueueMap = require(`${__dirname}/../controls/emma_service_queue.js`);
 
 class Emma extends DriverBase {
-	constructor(stateInstance, inverter, options) {
-		super(stateInstance, inverter, {
+	constructor(stateInstance, device, options) {
+		super(stateInstance, device, {
 			name: 'emma',
 			driverClass: driverClasses.emma,
 			...options,
 		});
 
-		//this.stateCache.set(`meter.derived.directionOfPowerFlow`, 1, { type: 'number' }); //Emma build-in energy sensor
+		this.control = new ServiceQueueMap(this.adapter, this.deviceInfo); //emma service queue
 
 		//https://github.com/ioBroker/ioBroker.docs/blob/master/docs/en/dev/stateroles.md
 		const newFields = [
@@ -271,6 +272,14 @@ class Emma extends DriverBase {
 						register: { reg: 30348, type: dataType.uint64, gain: 100 },
 					},
 				],
+				postHook: path => {
+					if (this.isTestMode()) {
+						const value = 18000099;
+						this.log.info(`### TestMode ### set Emma inverterTotalAbsorbedEnergy 30302 - set to ${value} kWh`);
+						this.stateCache.set(`${path}emma.inverterTotalAbsorbedEnergy`, value, { type: 'number' });
+						this.addHoldingRegisters(30302, dataType.numToArray(value * 100, dataType.uint64)); //write also to the modbus read cache
+					}
+				},
 			},
 			{
 				address: 30354,
@@ -761,11 +770,21 @@ class Emma extends DriverBase {
 
 		this.registerFields.push.apply(this.registerFields, newFields);
 	}
+
+	// Override
+	/**
+	 * Checks if the device is in test mode
+	 * @returns {boolean} True if the device is in test mode, false otherwise
+	 * A device is considered in test mode if its modbus ID is not equal to 0.
+	 */
+	isTestMode() {
+		return this.modbusId !== 0;
+	}
 }
 
 class EmmaCharger extends DriverBase {
-	constructor(stateInstance, inverter, options) {
-		super(stateInstance, inverter, {
+	constructor(stateInstance, device, options) {
+		super(stateInstance, device, {
 			name: 'emmaCharger',
 			driverClass: driverClasses.emmaCharger,
 			...options,

package/lib/drivers/driver_inverter.js

@@ -3,7 +3,7 @@
 const { deviceType, driverClasses, storeType, getDeviceStatusInfo, batteryStatus, dataRefreshRate, dataType } = require(`${__dirname}/../types.js`);
 const { RiemannSum, isSunshine } = require(`${__dirname}/../tools.js`);
 const DriverBase = require(`${__dirname}/driver_base.js`);
-const ServiceQueueMap = require(`${__dirname}/../controls/service_queue.js`);
+const ServiceQueueMap = require(`${__dirname}/../controls/inverter_service_queue.js`);
 
 class InverterInfo extends DriverBase {
 	constructor(stateInstance, device) {

package/lib/modbus/modbus_connect.js

@@ -100,6 +100,8 @@ class ModbusConnect extends DeviceInterface {
 				this.client.close(() => {
 					resolve({});
 				});
+				//workaround for issue https://github.com/yaacov/node-modbus-serial/issues/582 with node-modbus-serial
+				resolve({});
 			} else {
 				resolve({});
 			}
@@ -134,10 +136,12 @@ class ModbusConnect extends DeviceInterface {
 	}
 
 	async _checkError(err) {
-		this.adapter.logger.debug(`Modbus error: ${JSON.stringify(err)}`);
+		this.log.debug(`Modbus error: ${JSON.stringify(err)}`);
 		if (err.modbusCode === undefined) {
 			this._adjustDelay(err, false);
 			await this.close();
+			//await this._destroy();
+			//await this.closing();
 			await this._create();
 			if (err.errno === 'ECONNREFUSED') {
 				this.log.warn('Has another device interrupted the modbus connection?');
@@ -146,6 +150,8 @@ class ModbusConnect extends DeviceInterface {
 		} else {
 			if (err.modbusCode === 0) {
 				await this.close();
+				//await this._destroy();
+				//await this.closing();
 				this._adjustDelay(err, false);
 				await this._create();
 			}
@@ -165,9 +171,10 @@ class ModbusConnect extends DeviceInterface {
 		} catch (err) {
 			this.log.warn(`Couldnt connect Modbus TCP to ${this.ipAddress}:${this.port} ${err.message}`);
 			await this._checkError(err);
+			let delay = 4000;
 			if (repeatCounter > 0) throw err;
-			let delay = 2000;
 			if (err.code == 'EHOSTUNREACH') delay *= 10;
+			this.log.debug(`Retry to connect Modbus TCP to ${this.ipAddress}:${this.port} in ${delay} ms`);
 			await this.wait(delay);
 			await this.connect(repeatCounter + 1);
 		}

package/lib/modbus/modbus_server.js

@@ -23,6 +23,7 @@ class ModbusServer {
 				await this._handleGetReg('getMultipleInputRegisters', startAddr, length, unitId, callback);
 			},
 			getMultipleHoldingRegisters: async (startAddr, length, unitId, callback) => {
+				//this.adapter.log.info(`getMultipleHolgingRegisters ${unitId} ${startAddr} len ${length}`);
 				await this._handleGetReg('getMultipleHoldingRegisters', startAddr, length, unitId, callback);
 			},
 			getCoil: (addr, unitId, callback) => {
@@ -141,12 +142,19 @@ class ModbusServer {
 	 * Special case: unitId 250 is mapped to the device with modbusId 0.
 	 */
 	getDeviceInstance(unitId) {
+		const realUnitId = unitId === 250 ? 0 : unitId;
 		for (const device of this.adapter.devices) {
 			if (device.instance) {
-				if (unitId === 250 && device.instance?.modbusId === 0) {
+				//for TestMode
+				if (realUnitId === 0 && device.instance.info?.name === 'emma') {
+					//if (this.adapter.settings.ms.log) {
+					this.log.info(
+						`### Modbus-proxy ###: check device ${device.instance._name} with id ${device.instance.modbusId} for unitId ${realUnitId} (TestMode active)`,
+					);
+					//}
 					return device.instance;
 				}
-				if (device.instance?.modbusId === unitId) {
+				if (device.instance?.modbusId === realUnitId) {
 					return device.instance;
 				}
 			}
@@ -164,15 +172,11 @@ class ModbusServer {
 	 */
 
 	async _handleGetReg(fnName, startAddr, length, unitId, callback) {
-		//this.adapter.log.debug('getMultipleHolgingRegisters '+unitId+' '+startAddr+' len '+length+' '+this._isConnected);
+		//this.adapter.log.info(`getMultipleHolgingRegisters ${unitId} ${startAddr} len ${length} ${this._isConnected}`);
 		try {
 			const device = this.getDeviceInstance(unitId);
 			if (device) {
-				//this.adapter.log.debug('Device Info '+JSON.stringify(device?.info));
 				const values = device.getHoldingRegisters(startAddr, length);
-				if (this.adapter.settings.ms.log) {
-					this.log.info(`Modbus-proxy: read data from id/address/data ${unitId}/${startAddr}/${values}`);
-				}
 
 				if (!this.adapter.isConnected) {
 					//this._addInfoStat('#WaitForConnected',startAddr, length, unitId);

package/lib/register.js

@@ -458,7 +458,7 @@ class Registers {
 								ret.message = "Can't read data from device! Please check the configuration.";
 							} else {
 								ret.errno = 102;
-								ret.message = 'Not all data can be read! Please inspect the sun2000 log.';
+								ret.message = 'Not all data can be read! Please inspect the adapter log.';
 							}
 							return ret;
 						}

package/lib/tools.js

@@ -314,6 +314,25 @@ function contains(r, val) {
 	return -1;
 }
 
+async function existsState(adapter, id, callback) {
+	if (typeof callback === 'function') {
+		adapter.getObject(id, (err, obj) => callback(err, obj && obj.type === 'state'));
+	} else {
+		const obj = await adapter.getObjectAsync(id);
+		if (obj) {
+			return obj.type === 'state';
+		}
+	}
+}
+
+async function deleteState(adapter, id, callback) {
+	if (typeof callback === 'function') {
+		adapter.delObject(id, { recursive: false }, callback);
+	} else {
+		return await adapter.delObjectAsync(id, { recursive: false });
+	}
+}
+
 module.exports = {
 	Logging,
 	StateMap,
@@ -324,4 +343,6 @@ module.exports = {
 	getAstroDate,
 	isSunshine,
 	contains,
+	existsState,
+	deleteState,
 };

package/lib/types.js

@@ -17,7 +17,7 @@ function getDeviceStatusInfo(value) {
 		case 0x0002:
 			return 'Standby: detecting irradiation';
 		case 0x0003:
-			return 'Standby: drid detecting';
+			return 'Standby: grid detecting';
 		case 0x0100:
 			return 'Starting';
 		case 0x0200:
@@ -46,6 +46,8 @@ function getDeviceStatusInfo(value) {
 			return 'Shutdown: rapid cutoff';
 		case 0x0308:
 			return 'Shutdown: input underpower';
+		case 0x030c:
+			return 'Shutdown: End of the ESS discharge process';
 		case 0x0401:
 			return 'Grid scheduling: cosPhi-P curve';
 		case 0x0402:
@@ -143,6 +145,14 @@ const dataType = {
 				return undefined;
 		}
 	},
+	/**
+	 * Converts a number to an array of type given.
+	 * It uses the size of the type to determine how to convert the number.
+	 * @param {number} num - The number to convert.
+	 * @param {symbol} type - The type to convert the number to.
+	 * @returns {Uint16Array} An array containing the converted number.
+	 * @throws {Error} If the type is not supported.
+	 */
 	numToArray(num, type) {
 		switch (this.size(type)) {
 			case 1: {
@@ -153,6 +163,16 @@ const dataType = {
 				const int16Array = new Uint16Array([(num & 0xffff0000) >> 16, num & 0xffff]);
 				return int16Array;
 			}
+			case 4: {
+				if (typeof num !== 'bigint') {
+					num = BigInt(num);
+				}
+				const parts = new Uint16Array(4);
+				for (let i = 0; i < 4; i++) {
+					parts[3 - i] = Number((num >> BigInt(i * 16)) & 0xffffn);
+				}
+				return parts;
+			}
 		}
 		throw false;
 	},

package/main.js

@@ -63,10 +63,8 @@ class Sun2000 extends utils.Adapter {
 			},
 		};
 
-		//v0.6.
 		this.logger = new Logging(this); //only for adapter
 
-		//1.1.0
 		this.control = new ConfigMap(this);
 
 		this.on('ready', this.onReady.bind(this));
@@ -470,7 +468,7 @@ class Sun2000 extends utils.Adapter {
 					this.devices.push({
 						index: 0,
 						duration: 0,
-						//modbusId: 1,
+						//modbusId: 1, --> testMode
 						modbusId: 0,
 						meter: true,
 						driverClass: driverClasses.emma,
@@ -551,7 +549,7 @@ class Sun2000 extends utils.Adapter {
 				}
 				const ret = this.state.CheckReadError(this.settings.lowInterval * 2);
 				this.logger.debug(JSON.stringify(this.modbusClient.info));
-				//v0.8.x
+
 				if (!this.isReady) {
 					this.isReady = this.isConnected && !ret.errno;
 				}
@@ -578,9 +576,9 @@ class Sun2000 extends utils.Adapter {
 			this.lastStateUpdatedLow = 0;
 			this.lastStateUpdatedHigh = 0;
 
-			if (sinceLastUpdate > this.settings.highInterval * 10) {
+			if (sinceLastUpdate > this.settings.lowInterval * 10) {
 				this.setState('info.JSONhealth', { val: '{errno:2, message: "Internal loop error"}', ack: true });
-				this.logger.warn('watchdog: restart Adapter...');
+				this.logger.error('watchdog: Internal loop error! Restart adapter...');
 				this.restart();
 			}
 		}, this.settings.lowInterval);
@@ -638,7 +636,7 @@ class Sun2000 extends utils.Adapter {
 				}
 				//this.log.info(`### state ${id} changed: ${state.val} (ack = ${state.ack})`);
 			}
-			// sun2000.0.inverter.0.config
+			// sun2000.0.control
 			if (idArray[2] == 'control') {
 				let serviceId = idArray[3];
 				for (let i = 4; i < idArray.length; i++) {
@@ -647,6 +645,18 @@ class Sun2000 extends utils.Adapter {
 				//this.log.info(`### id: ${serviceId} state ${id} changed: ${state.val} (ack = ${state.ack})`);
 				this.control.set(serviceId, state);
 			}
+			// sun2000.0.emma.control
+			if (idArray[2] == 'emma') {
+				const emma = this.devices.find(d => d.driverClass == driverClasses.emma);
+				if (emma && emma.instance && emma.instance.control) {
+					let serviceId = idArray[4];
+					for (let i = 5; i < idArray.length; i++) {
+						serviceId += `.${idArray[i]}`;
+					}
+					//this.log.info(`### state ${id} changed: ${state.val} (ack = ${state.ack})`);
+					emma.instance.control.set(serviceId, state);
+				}
+			}
 		} else {
 			// The state was deleted
 			this.logger.info(`state ${id} deleted`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iobroker.sun2000",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "sun2000",
   "author": {
     "name": "bolliy",
@@ -28,7 +28,7 @@
   },
   "dependencies": {
     "@iobroker/adapter-core": "^3.3.2",
-    "modbus-serial": "^8.0.22",
+    "modbus-serial": "^8.0.23",
     "suncalc2": "^1.8.1",
     "tcp-port-used": "^1.0.2"
   },