iobroker.sigenergy 3.1.2 → 3.3.0

package/README.md

@@ -49,7 +49,7 @@ Supports the Sigenergy Modbus Protocol V2.9 (released 2026-05-13).
 | Component | Minimum version |
 |-----------|-----------------|
 | **js-controller** | >= 6.0.11 |
-| **admin** | >= 8.0.0 |
+| **admin** | >= 7.8.23 |
 | **Node.js** | >= 22 |
 
 ---
@@ -255,6 +255,24 @@ Status and power readings for the DC charger.
 
 ## Changelog
 
+### 3.3.0 (2026-09-07)
+- (ssbingo) fix: when the device rejects a grouped register read with a Modbus exception, the registers of that group are now read one by one and only the register(s) the device does not implement are excluded from further polling. Previously a single unsupported register silently disabled its whole group for the rest of the adapter runtime, e.g. `dcCharger.runningState` (31513) never received a value when the discharging registers 31514–31518 of the same group were rejected
+- (ssbingo) feat: new state `info.protocolVersion` (number, e.g. `2.9`) next to the textual `info.protocolLevel`, so widgets and scripts can adapt to the detected protocol version without parsing strings
+- (ssbingo) feat: DC charger registers carry the protocol version that introduced them (`since`, from the V2.9 revision history: 31509–31511 V2.6, 31513 V2.8, 31514–31525 V2.9); registers newer than the detected protocol level are not requested, so a V2.8 device no longer gets its DC charger group rejected because of the V2.9 discharging registers
+- (ssbingo) chore: grouped register reading moved to `lib/readGroups.js` and covered by unit tests
+- (ssbingo) feat: all registers dated by the V2.9 revision history now carry `since` via a central `PROTOCOL_SINCE` table in `lib/registers.js` (plant 30088–30192 V2.6, 30194–30268 V2.7, 30276–30285 V2.8, 30272/30274/30286 V2.9, 40046–40048 V2.6, 40049–40068 V2.8, 40157–40159 V2.9, ESS preheating 50000–50183 V2.9; inverter 30613–30619 V2.6, 31066–31105 V2.8; DC charger 41002/41004 V2.9; all PSS and PID registers V2.9) and are skipped on devices with an older protocol level
+- (ssbingo) fix: the one-time control register read (FC03) and the SigenMicro reader use the same per-register fallback as the input register readers; the control registers are read after the protocol detection so the version gating applies to them as well; ESS preheating polling is skipped below protocol V2.9
+- (ssbingo) fix: corrected the protocol version marker in the names of the eleven cumulative energy states 30228-30268 from `(V2.8)` to `(V2.7)`; the revision history of the V2.9 protocol document lists the cumulative energy interface 30196-30268 under V2.7
+
+### 3.2.0 (2026-09-04)
+- (MMeinhardt1) feat: new state `statistics.emsWorkMode` exposing the EMS work mode as plain text, so consumers do not need the `common.states` lookup table
+- (MMeinhardt1) feat: added EMS work mode 6 (Virtual Power Plant) to the register description and the mode map
+- (MMeinhardt1) change: the `*HM` duration states now hold a bare `H:MM` value with unit `h`, instead of embedding an `h` suffix in the value itself
+- (MMeinhardt1) fix: statistics objects are created with `extendObjectAsync`, so corrected units and roles reach installations where the object already exists
+- (ssbingo) chore: admin minimum requirement lowered back to >= 7.8.23 to keep serving admin 7.x installations
+- (ssbingo) fix: restored the JSDoc parameter descriptions on `_formatMinutesAsHM` to keep `npm run lint` warning-free
+- (ssbingo) chore: repository checker findings — track `.vscode/settings.json` deliberately, bump `@alcalzone/release-script-plugin-license` to 5.2.2, pin `testing-action-deploy` to the major version again
+
 ### 3.1.2 (2026-08-06)
 - (ssbingo) chore: resolved all 28 npm audit findings (3 critical, 11 high) — development tooling only, the published adapter is unchanged
 - (ssbingo) chore: removed `@iobroker/dev-server`; it was the sole source of the critical findings via the deprecated `request` and `xmldom` packages, for which no fixed release exists. This also removes the `npm start` / `npm run watch` scripts

package/io-package.json

@@ -1,8 +1,34 @@
 {
     "common": {
         "name": "sigenergy",
-        "version": "3.1.2",
+        "version": "3.3.0",
         "news": {
+            "3.3.0": {
+                "en": "(ssbingo) feat: registers are gated by the detected Modbus protocol version, so a device is no longer asked for registers its firmware does not know; rejected register groups are now retried register by register, so one unsupported register no longer silences its whole group; new state info.protocolVersion",
+                "de": "(ssbingo) feat: Register werden anhand der erkannten Modbus-Protokollversion gefiltert, damit ein Gerät nicht mehr nach Registern gefragt wird, die seine Firmware nicht kennt; abgelehnte Registergruppen werden jetzt einzeln nachgelesen, sodass ein nicht unterstütztes Register nicht mehr die ganze Gruppe stilllegt; neuer State info.protocolVersion",
+                "ru": "(ssbingo) feat: регистры фильтруются по обнаруженной версии протокола Modbus, поэтому устройство больше не запрашивается о регистрах, неизвестных его прошивке; отклонённые группы регистров перечитываются по одному, поэтому один неподдерживаемый регистр больше не блокирует всю группу; новое состояние info.protocolVersion",
+                "pt": "(ssbingo) feat: os registos são filtrados pela versão do protocolo Modbus detetada, pelo que o dispositivo deixa de ser questionado sobre registos que o seu firmware desconhece; os grupos rejeitados passam a ser lidos registo a registo, pelo que um registo não suportado deixa de silenciar todo o grupo; novo estado info.protocolVersion",
+                "nl": "(ssbingo) feat: registers worden gefilterd op de gedetecteerde Modbus-protocolversie, zodat een apparaat niet langer wordt bevraagd over registers die zijn firmware niet kent; geweigerde registergroepen worden nu register voor register gelezen, zodat één niet-ondersteund register niet meer de hele groep stillegt; nieuwe state info.protocolVersion",
+                "fr": "(ssbingo) feat : les registres sont filtrés selon la version du protocole Modbus détectée, de sorte qu'un appareil n'est plus interrogé sur des registres que son micrologiciel ignore ; les groupes rejetés sont désormais relus registre par registre, de sorte qu'un registre non pris en charge ne neutralise plus tout son groupe ; nouvel état info.protocolVersion",
+                "it": "(ssbingo) feat: i registri vengono filtrati in base alla versione del protocollo Modbus rilevata, così il dispositivo non viene più interrogato su registri che il suo firmware non conosce; i gruppi rifiutati vengono ora letti registro per registro, così un registro non supportato non azzera più l'intero gruppo; nuovo stato info.protocolVersion",
+                "es": "(ssbingo) feat: los registros se filtran según la versión del protocolo Modbus detectada, de modo que ya no se consulta al dispositivo por registros que su firmware desconoce; los grupos rechazados se leen ahora registro a registro, de modo que un registro no soportado ya no silencia todo su grupo; nuevo estado info.protocolVersion",
+                "pl": "(ssbingo) feat: rejestry są filtrowane według wykrytej wersji protokołu Modbus, więc urządzenie nie jest już pytane o rejestry nieznane jego oprogramowaniu; odrzucone grupy rejestrów są teraz odczytywane pojedynczo, więc jeden nieobsługiwany rejestr nie wyłącza już całej grupy; nowy stan info.protocolVersion",
+                "uk": "(ssbingo) feat: регістри фільтруються за виявленою версією протоколу Modbus, тому пристрій більше не запитують про регістри, невідомі його прошивці; відхилені групи регістрів тепер перечитуються по одному, тож один непідтримуваний регістр більше не блокує всю групу; новий стан info.protocolVersion",
+                "zh-cn": "(ssbingo) feat: 按检测到的 Modbus 协议版本过滤寄存器，不再向设备请求其固件不支持的寄存器；被拒绝的寄存器组改为逐个读取，单个不支持的寄存器不再导致整组失效；新增状态 info.protocolVersion"
+            },
+            "3.2.0": {
+                "en": "(MMeinhardt1) feat: EMS work mode as plain text, Virtual Power Plant mode, h:mm values now carry unit 'h' instead of a suffix; statistics objects are updated on every start. (ssbingo) chore: admin requirement lowered back to >=7.8.23",
+                "de": "(MMeinhardt1) feat: EMS-Betriebsmodus als Klartext, Modus Virtual Power Plant, h:mm-Werte tragen jetzt die Einheit 'h' statt eines Suffix; Statistik-Objekte werden bei jedem Start aktualisiert. (ssbingo) chore: admin-Anforderung zurück auf >=7.8.23",
+                "ru": "(MMeinhardt1) feat: режим работы EMS в виде текста, режим Virtual Power Plant, значения h:mm теперь имеют единицу 'h' вместо суффикса; объекты статистики обновляются при каждом запуске. (ssbingo) chore: требование к admin снижено до >=7.8.23",
+                "pt": "(MMeinhardt1) feat: modo de trabalho EMS como texto, modo Virtual Power Plant, valores h:mm passam a ter a unidade 'h' em vez de sufixo; os objetos de estatística são atualizados em cada arranque. (ssbingo) chore: requisito do admin reduzido para >=7.8.23",
+                "nl": "(MMeinhardt1) feat: EMS-werkmodus als tekst, modus Virtual Power Plant, h:mm-waarden krijgen nu eenheid 'h' in plaats van een achtervoegsel; statistiekobjecten worden bij elke start bijgewerkt. (ssbingo) chore: admin-vereiste terug naar >=7.8.23",
+                "fr": "(MMeinhardt1) feat : mode de fonctionnement EMS en texte clair, mode Virtual Power Plant, les valeurs h:mm portent désormais l'unité « h » au lieu d'un suffixe ; les objets de statistiques sont mis à jour à chaque démarrage. (ssbingo) chore : exigence admin ramenée à >=7.8.23",
+                "it": "(MMeinhardt1) feat: modalità di lavoro EMS come testo, modalità Virtual Power Plant, i valori h:mm ora hanno l'unità 'h' invece di un suffisso; gli oggetti statistici vengono aggiornati a ogni avvio. (ssbingo) chore: requisito admin riportato a >=7.8.23",
+                "es": "(MMeinhardt1) feat: modo de trabajo EMS como texto, modo Virtual Power Plant, los valores h:mm llevan ahora la unidad 'h' en lugar de un sufijo; los objetos de estadísticas se actualizan en cada arranque. (ssbingo) chore: requisito de admin reducido a >=7.8.23",
+                "pl": "(MMeinhardt1) feat: tryb pracy EMS jako tekst, tryb Virtual Power Plant, wartości h:mm mają teraz jednostkę 'h' zamiast sufiksu; obiekty statystyk są aktualizowane przy każdym starcie. (ssbingo) chore: wymaganie admin obniżone do >=7.8.23",
+                "uk": "(MMeinhardt1) feat: режим роботи EMS як текст, режим Virtual Power Plant, значення h:mm тепер мають одиницю 'h' замість суфікса; об'єкти статистики оновлюються при кожному запуску. (ssbingo) chore: вимогу до admin знижено до >=7.8.23",
+                "zh-cn": "(MMeinhardt1) feat: EMS 工作模式以纯文本提供、新增 Virtual Power Plant 模式、h:mm 值改用单位 'h' 而非后缀；统计对象在每次启动时更新。(ssbingo) chore: admin 要求下调回 >=7.8.23"
+            },
             "3.1.2": {
                 "en": "(ssbingo) chore: all npm audit findings resolved (28 -> 0); removed @iobroker/dev-server, which pulled in unpatchable deprecated packages. Development tooling only — the adapter itself is unchanged.",
                 "de": "(ssbingo) chore: alle npm-audit-Findings behoben (28 -> 0); @iobroker/dev-server entfernt, das nicht patchbare veraltete Pakete mitzog. Betrifft nur das Entwicklungs-Tooling — der Adapter selbst ist unverändert.",
@@ -121,7 +147,7 @@
         ],
         "globalDependencies": [
             {
-                "admin": ">=8.0.0"
+                "admin": ">=7.8.23"
             }
         ],
         "licenseInformation": {
@@ -245,6 +271,19 @@
             },
             "native": {}
         },
+        {
+            "_id": "info.protocolVersion",
+            "type": "state",
+            "common": {
+                "name": "Highest Modbus protocol version confirmed by probing (0 = below V2.6 or not detected yet)",
+                "type": "number",
+                "role": "value",
+                "read": true,
+                "write": false,
+                "def": 0
+            },
+            "native": {}
+        },
         {
             "_id": "info.modelType",
             "type": "state",

package/lib/readGroups.js

@@ -0,0 +1,217 @@
+'use strict';
+
+/**
+ * Grouped Modbus register reads.
+ *
+ * buildReadGroups() merges consecutive register definitions into as few
+ * Modbus requests as possible. readRegisterGroups() executes those requests
+ * and, when the device rejects a whole group with a Modbus exception
+ * (ILLEGAL FUNCTION / ILLEGAL DATA ADDRESS), falls back to reading the
+ * registers of that group one by one. Registers the device rejects
+ * individually are remembered and excluded from later polls, so a single
+ * unsupported register (e.g. one introduced in a newer protocol version or
+ * one that does not apply to the installed hardware) no longer prevents the
+ * other registers of its group from being read.
+ */
+
+/**
+ * @typedef {object} ReadLog
+ * @property {(msg: string) => void} debug - debug logger
+ * @property {(msg: string) => void} info - info logger
+ * @property {(msg: string) => void} warn - warn logger
+ */
+
+/**
+ * @typedef {object} ModbusError
+ * @property {string} message - error message
+ * @property {number} [modbusCode] - Modbus exception code, set by modbus-serial on exception responses
+ */
+
+/**
+ * Build optimized sequential read groups
+ *
+ * @param {object[]} registers - Register definitions ({ addr, qty, ... })
+ * @param {number} maxQty - Maximum registers per group
+ * @returns {object[]} Grouped register batches ({ startAddr, totalQty, registers })
+ */
+function buildReadGroups(registers, maxQty) {
+    if (!registers || registers.length === 0) {
+        return [];
+    }
+
+    const sorted = [...registers].sort((a, b) => a.addr - b.addr);
+    const groups = [];
+    let currentGroup = null;
+
+    for (const reg of sorted) {
+        if (!currentGroup) {
+            currentGroup = {
+                startAddr: reg.addr,
+                totalQty: reg.qty,
+                registers: [{ ...reg, offset: 0 }],
+            };
+        } else {
+            const expectedNext = currentGroup.startAddr + currentGroup.totalQty;
+            const gap = reg.addr - expectedNext;
+
+            if (gap >= 0 && gap <= 4 && currentGroup.totalQty + gap + reg.qty <= maxQty) {
+                const offset = reg.addr - currentGroup.startAddr;
+                currentGroup.totalQty = Math.max(currentGroup.totalQty, offset + reg.qty);
+                currentGroup.registers.push({ ...reg, offset });
+            } else {
+                groups.push(currentGroup);
+                currentGroup = {
+                    startAddr: reg.addr,
+                    totalQty: reg.qty,
+                    registers: [{ ...reg, offset: 0 }],
+                };
+            }
+        }
+    }
+    if (currentGroup) {
+        groups.push(currentGroup);
+    }
+    return groups;
+}
+
+/**
+ * Whether an error is a Modbus exception proving that the device does not
+ * implement the requested register(s). modbus-serial sets `modbusCode` on
+ * exception responses: 1 = ILLEGAL FUNCTION, 2 = ILLEGAL DATA ADDRESS.
+ * Other exception codes and transport errors (timeouts, socket errors)
+ * prove nothing about the register and must not exclude it.
+ *
+ * @param {ModbusError | null | undefined} err - Error thrown by the Modbus client
+ * @returns {boolean} true if the device rejected the register(s)
+ */
+function isRegisterRejected(err) {
+    return !!err && (err.modbusCode === 1 || err.modbusCode === 2);
+}
+
+/**
+ * Remember a register the device rejected and log it once.
+ *
+ * @param {string} section - Section name for the log message
+ * @param {object} reg - Register definition
+ * @param {Set<number>} unsupported - Set of rejected register addresses
+ * @param {ModbusError} err - The Modbus exception
+ * @param {ReadLog} log - Logger
+ */
+function markUnsupported(section, reg, unsupported, err, log) {
+    unsupported.add(reg.addr);
+    log.info(
+        `[${section}] register ${reg.addr} (${reg.name}) is not supported by this device ` +
+            `(${err.message}) - excluded from further polling`,
+    );
+}
+
+/**
+ * Read the registers of a rejected group one by one.
+ *
+ * @param {object} opts - Options, see readRegisterGroups()
+ * @param {string} opts.section - Section name
+ * @param {object} opts.group - The rejected group
+ * @param {Set<number>} opts.unsupported - Set of rejected register addresses
+ * @param {(addr: number, qty: number) => Promise<number[]>} opts.read - Register read function
+ * @param {(group: object, raw: number[]) => Promise<void>} opts.process - Group processing function
+ * @param {(ms: number) => Promise<void>} opts.sleep - Pause function
+ * @param {() => boolean} opts.isStopped - Shutdown check
+ * @param {ReadLog} opts.log - Logger
+ * @returns {Promise<void>} resolves when all registers were tried
+ */
+async function readGroupIndividually(opts) {
+    const { section, group, unsupported, read, process, sleep, isStopped, log } = opts;
+    for (const reg of group.registers) {
+        if (isStopped()) {
+            return;
+        }
+        try {
+            const raw = await read(reg.addr, reg.qty);
+            await process({ startAddr: reg.addr, totalQty: reg.qty, registers: [{ ...reg, offset: 0 }] }, raw);
+        } catch (err) {
+            if (isRegisterRejected(err)) {
+                markUnsupported(section, reg, unsupported, err, log);
+            } else {
+                log.debug(`[${section}] read error at ${reg.addr} (${reg.name}): ${err.message}`);
+            }
+        }
+        await sleep(50);
+    }
+}
+
+/**
+ * Read a register set in grouped requests with per-register fallback.
+ *
+ * @param {object} opts - Options
+ * @param {string} opts.section - Section name used in log messages (e.g. 'dcCharger')
+ * @param {object[]} opts.registers - Register definitions to read
+ * @param {number} opts.batchSize - Maximum registers per Modbus request
+ * @param {Set<number>} opts.unsupported - Addresses rejected by the device; extended by this call and excluded from grouping
+ * @param {Set<number>} opts.errorLogged - Group start addresses whose transport error was already logged at warn level
+ * @param {(addr: number, qty: number) => Promise<number[]>} opts.read - Reads `qty` registers starting at `addr`
+ * @param {(group: object, raw: number[]) => Promise<void>} opts.process - Processes the raw data of one group
+ * @param {(ms: number) => Promise<void>} opts.sleep - Pause between requests
+ * @param {() => boolean} opts.isStopped - Returns true while the adapter is shutting down
+ * @param {ReadLog} opts.log - Logger
+ * @returns {Promise<void>} resolves when all groups were processed
+ */
+async function readRegisterGroups(opts) {
+    const { section, batchSize, unsupported, errorLogged, read, process, sleep, isStopped, log } = opts;
+    const registers = opts.registers.filter(r => !unsupported.has(r.addr));
+    const groups = buildReadGroups(registers, batchSize);
+    log.debug(`[${section}] reading ${registers.length} register(s) in ${groups.length} group(s)`);
+
+    for (const group of groups) {
+        if (isStopped()) {
+            return;
+        }
+        try {
+            const raw = await read(group.startAddr, group.totalQty);
+            await process(group, raw);
+            await sleep(100);
+        } catch (err) {
+            if (!isRegisterRejected(err)) {
+                // Transport error, timeout or a non-conclusive exception: keep the
+                // group, warn once and simply retry on the next poll cycle.
+                if (!errorLogged.has(group.startAddr)) {
+                    errorLogged.add(group.startAddr);
+                    log.warn(
+                        `[${section}] register read error at ${group.startAddr} (qty ${group.totalQty}): ${err.message}`,
+                    );
+                } else {
+                    log.debug(`[${section}] read error at ${group.startAddr}: ${err.message}`);
+                }
+                continue;
+            }
+            if (group.registers.length === 1) {
+                markUnsupported(section, group.registers[0], unsupported, err, log);
+                continue;
+            }
+            log.debug(
+                `[${section}] group ${group.startAddr} (qty ${group.totalQty}) rejected by device ` +
+                    `(${err.message}) - reading its registers individually`,
+            );
+            await readGroupIndividually({ section, group, unsupported, read, process, sleep, isStopped, log });
+        }
+    }
+}
+
+/**
+ * Split registers into those supported by the detected protocol version and
+ * those introduced in a newer version (`reg.since`). With an unknown version
+ * (0 / undefined) nothing is skipped.
+ *
+ * @param {object[]} registers - Register definitions, optionally with `since`
+ * @param {number} protocolVersion - Detected protocol version (e.g. 2.8), 0 = unknown
+ * @returns {{ active: object[], skipped: object[] }} partitioned registers
+ */
+function filterByProtocolVersion(registers, protocolVersion) {
+    if (!protocolVersion || protocolVersion <= 0) {
+        return { active: registers, skipped: [] };
+    }
+    const skipped = registers.filter(r => typeof r.since === 'number' && r.since > protocolVersion);
+    const active = skipped.length > 0 ? registers.filter(r => !skipped.includes(r)) : registers;
+    return { active, skipped };
+}
+
+module.exports = { buildReadGroups, readRegisterGroups, isRegisterRejected, filterByProtocolVersion };

package/lib/registers.js

@@ -37,7 +37,7 @@ const PLANT_READ_REGISTERS = [
         gain: null,
         unit: '',
         role: 'value',
-        desc: 'EMS work mode: 0=MaxSelfConsumption,1=AI,2=TOU,5=FullFeedIn,7=RemoteEMS,9=Custom',
+        desc: 'EMS work mode: 0=MaxSelfConsumption,1=AI,2=TOU,5=FullFeedIn,6=VirtualPowerPlant,7=RemoteEMS,9=Custom',
     },
     {
         addr: 30004,
@@ -1155,7 +1155,7 @@ const PLANT_READ_REGISTERS = [
         gain: 100,
         unit: 'kWh',
         role: 'value.energy',
-        desc: 'Total common loads consumption (V2.8)',
+        desc: 'Total common loads consumption (V2.7)',
         feature: 'enableCumulativeEnergy',
     },
     {
@@ -1166,7 +1166,7 @@ const PLANT_READ_REGISTERS = [
         gain: 100,
         unit: 'kWh',
         role: 'value.energy',
-        desc: 'Total EVAC charged (V2.8)',
+        desc: 'Total EVAC charged (V2.7)',
         feature: 'enableCumulativeEnergy',
     },
     {
@@ -1177,7 +1177,7 @@ const PLANT_READ_REGISTERS = [
         gain: 100,
         unit: 'kWh',
         role: 'value.energy',
-        desc: 'Total self PV generation (V2.8)',
+        desc: 'Total self PV generation (V2.7)',
         feature: 'enableCumulativeEnergy',
     },
     {
@@ -1188,7 +1188,7 @@ const PLANT_READ_REGISTERS = [
         gain: 100,
         unit: 'kWh',
         role: 'value.energy',
-        desc: 'Total 3rd party generation (V2.8)',
+        desc: 'Total 3rd party generation (V2.7)',
         feature: 'enableCumulativeEnergy',
     },
     {
@@ -1199,7 +1199,7 @@ const PLANT_READ_REGISTERS = [
         gain: 100,
         unit: 'kWh',
         role: 'value.energy',
-        desc: 'Total ESS charged (V2.8)',
+        desc: 'Total ESS charged (V2.7)',
         feature: 'enableCumulativeEnergy',
     },
     {
@@ -1210,7 +1210,7 @@ const PLANT_READ_REGISTERS = [
         gain: 100,
         unit: 'kWh',
         role: 'value.energy',
-        desc: 'Total ESS discharged (V2.8)',
+        desc: 'Total ESS discharged (V2.7)',
         feature: 'enableCumulativeEnergy',
     },
     {
@@ -1221,7 +1221,7 @@ const PLANT_READ_REGISTERS = [
         gain: 100,
         unit: 'kWh',
         role: 'value.energy',
-        desc: 'Total EVDC charged (V2.8)',
+        desc: 'Total EVDC charged (V2.7)',
         feature: 'enableCumulativeEnergy',
     },
     {
@@ -1232,7 +1232,7 @@ const PLANT_READ_REGISTERS = [
         gain: 100,
         unit: 'kWh',
         role: 'value.energy',
-        desc: 'Total EVDC discharged (V2.8)',
+        desc: 'Total EVDC discharged (V2.7)',
         feature: 'enableCumulativeEnergy',
     },
     {
@@ -1243,7 +1243,7 @@ const PLANT_READ_REGISTERS = [
         gain: 100,
         unit: 'kWh',
         role: 'value.energy',
-        desc: 'Total imported energy (V2.8)',
+        desc: 'Total imported energy (V2.7)',
         feature: 'enableCumulativeEnergy',
     },
     {
@@ -1254,7 +1254,7 @@ const PLANT_READ_REGISTERS = [
         gain: 100,
         unit: 'kWh',
         role: 'value.energy',
-        desc: 'Total exported energy (V2.8)',
+        desc: 'Total exported energy (V2.7)',
         feature: 'enableCumulativeEnergy',
     },
     {
@@ -1265,7 +1265,7 @@ const PLANT_READ_REGISTERS = [
         gain: 100,
         unit: 'kWh',
         role: 'value.energy',
-        desc: 'Total oil generator energy (V2.8)',
+        desc: 'Total oil generator energy (V2.7)',
         feature: 'enableCumulativeEnergy',
     },
     // V2.9 — separate FC04 group (gap > 4 from 30087)
@@ -3313,6 +3313,7 @@ const EMS_WORK_MODES = {
     1: 'AI Mode',
     2: 'TOU',
     5: 'Full Feed-in to Grid',
+    6: 'Virtual Power Plant',
     7: 'Remote EMS',
     9: 'Custom',
 };
@@ -4980,6 +4981,80 @@ const DC_CHARGER_RUNNING_STATES = {
     0x0a: 'Preparing (Insulation)',
 };
 
+// ============================================================
+// Protocol version gating
+// ============================================================
+// Register address ranges and the Sigenergy Modbus protocol version that
+// introduced them, taken from the revision history of the protocol document
+// V2.9. Applied below as `since` to every register definition inside a range
+// (explicit `since` fields on a register take precedence). Registers newer
+// than the protocol level detected on the device are not polled, see
+// main.js _readRegisterGroups() / lib/readGroups.js filterByProtocolVersion().
+// Address spaces are per Modbus slave, so the ranges are kept per device family.
+const PROTOCOL_SINCE = {
+    plant: [
+        // V2.6 (2025-03-31)
+        { from: 30088, to: 30192, since: 2.6 }, // PV total generation, total load consumption, smart load 1-24
+        { from: 40046, to: 40048, since: 2.6 }, // ESS backup SOC, charge / discharge cut-off SOC
+        // V2.7 (2025-05-23) - the register table of the document labels 30228-30268
+        // "New statistics interface", the revision history dates 30196-30268 to V2.7
+        { from: 30194, to: 30268, since: 2.7 }, // third party inverter power, cumulative energy registers
+        // V2.8 (2025-11-28)
+        { from: 30276, to: 30285, since: 2.8 }, // grid code rated frequency / voltage, current control command, merged alarm 6 / 7, general / total load power
+        { from: 40049, to: 40068, since: 2.8 }, // active power regulation gradient, grid code registers
+        // V2.9 (2026-05-13)
+        { from: 30272, to: 30275, since: 2.9 }, // PV total daily generation, PV total generation of previous day
+        { from: 30286, to: 30286, since: 2.9 }, // ESS average cell temperature
+        { from: 40157, to: 40159, since: 2.9 }, // PCC power factor targets, grid power loss lockout alarm clear
+        { from: 50000, to: 50183, since: 2.9 }, // ESS preheating TOU registers
+    ],
+    inverter: [
+        // V2.6 (2025-03-31)
+        { from: 30613, to: 30619, since: 2.6 }, // power adjustment feedback values
+        { from: 31509, to: 31512, since: 2.6 }, // [DC Charger] PV daily / total generation
+        // V2.8 (2025-11-28)
+        { from: 31066, to: 31105, since: 2.8 }, // PV voltage / current of additional strings
+        { from: 31513, to: 31513, since: 2.8 }, // [DC Charger] running state
+        // V2.9 (2026-05-13)
+        { from: 31514, to: 31526, since: 2.9 }, // [DC Charger] discharging registers
+        { from: 41002, to: 41005, since: 2.9 }, // [DC Charger] max charging / discharging power limit
+    ],
+    pss: [{ from: 0, to: 65535, since: 2.9 }], // PSS registers were added in V2.9
+    pid: [{ from: 0, to: 65535, since: 2.9 }], // PID registers were added in V2.9
+};
+
+/**
+ * Set `since` on every register whose address falls into one of the ranges.
+ *
+ * @param {object[]} registers - Register definitions (mutated)
+ * @param {{ from: number, to: number, since: number }[]} ranges - Address ranges with protocol version
+ * @returns {object[]} the same array, for chaining
+ */
+function applySince(registers, ranges) {
+    for (const reg of registers) {
+        if (reg.since !== undefined) {
+            continue;
+        }
+        const hit = ranges.find(r => reg.addr >= r.from && reg.addr <= r.to);
+        if (hit) {
+            reg.since = hit.since;
+        }
+    }
+    return registers;
+}
+
+applySince(PLANT_READ_REGISTERS, PROTOCOL_SINCE.plant);
+applySince(PLANT_WRITE_REGISTERS, PROTOCOL_SINCE.plant);
+applySince(ESS_PREHEATING_WRITE_REGISTERS, PROTOCOL_SINCE.plant);
+applySince(INVERTER_READ_REGISTERS, PROTOCOL_SINCE.inverter);
+applySince(INVERTER_WRITE_REGISTERS, PROTOCOL_SINCE.inverter);
+applySince(DC_CHARGER_READ_REGISTERS, PROTOCOL_SINCE.inverter);
+applySince(DC_CHARGER_WRITE_REGISTERS, PROTOCOL_SINCE.inverter);
+applySince(PSS_READ_REGISTERS, PROTOCOL_SINCE.pss);
+applySince(PSS_WRITE_REGISTERS, PROTOCOL_SINCE.pss);
+applySince(PID_READ_REGISTERS, PROTOCOL_SINCE.pid);
+applySince(PID_WRITE_REGISTERS, PROTOCOL_SINCE.pid);
+
 module.exports = {
     PLANT_READ_REGISTERS,
     PLANT_WRITE_REGISTERS,
@@ -4998,4 +5073,6 @@ module.exports = {
     EMS_WORK_MODES,
     REMOTE_EMS_MODES,
     DC_CHARGER_RUNNING_STATES,
+    PROTOCOL_SINCE,
+    applySince,
 };

package/main.js

@@ -28,6 +28,7 @@ const {
     REMOTE_EMS_MODES,
     DC_CHARGER_RUNNING_STATES,
 } = require('./lib/registers');
+const { buildReadGroups, readRegisterGroups, filterByProtocolVersion } = require('./lib/readGroups');
 const SigenMicroScanner = require('./lib/scanner');
 const { getRegistersForDevice } = require('./lib/sigenMicroRegisters');
 const adapterVersion = require('./package.json').version;
@@ -134,6 +135,7 @@ class Sigenergy extends utils.Adapter {
         this._stopped = false;
         this._controlRegistersRead = false;
         this._protocolDetected = false;
+        this._protocolVersion = 0;
         this._emergencyWasOffGrid = false;
         this._emergencyStabilityTimer = null;
         this._emergencySwitchCount = 0;
@@ -141,12 +143,11 @@ class Sigenergy extends utils.Adapter {
         this._modelVerified = false;
         this._pvStringCount = 0;
         this._essPreheatingUnsupported = false;
-        this._plantUnsupportedGroups = new Set();
-        this._inverterUnsupportedGroups = new Set();
-        this._acChargerUnsupportedGroups = new Set();
-        this._dcChargerUnsupportedGroups = new Set();
-        this._pssUnsupportedGroups = new Set();
-        this._pidUnsupportedGroups = new Set();
+        // Per section: register addresses the device rejected (excluded from
+        // polling) and group start addresses whose read error was already logged.
+        this._unsupportedRegisters = {};
+        this._readErrorLogged = {};
+        this._sinceSkipLogged = {};
 
         this.on('ready', this.onReady.bind(this));
         this.on('stateChange', this.onStateChange.bind(this));
@@ -403,15 +404,17 @@ class Sigenergy extends utils.Adapter {
 
         try {
             if (this._caps.plant) {
-                if (!this._controlRegistersRead) {
-                    await this._readControlRegisters();
-                    this._controlRegistersRead = true;
-                }
                 if (!this._protocolDetected) {
                     // Only latch the flag if detection was conclusive (no transport
                     // errors). Otherwise retry on the next poll cycle.
                     this._protocolDetected = await this._detectProtocolLevel();
                 }
+                // Read the control registers after the protocol detection, so
+                // registers newer than the detected protocol level are skipped.
+                if (!this._controlRegistersRead) {
+                    await this._readControlRegisters();
+                    this._controlRegistersRead = true;
+                }
                 if (!this._modelVerified) {
                     await this._verifyModelType();
                 }
@@ -525,31 +528,58 @@ class Sigenergy extends utils.Adapter {
         return true;
     }
 
+    /**
+     * Read the input registers of one section (plant, inverter, acCharger,
+     * dcCharger, pss, pid) in grouped FC04 requests. If the device rejects a
+     * whole group, its registers are read one by one and only the rejected
+     * ones are excluded from further polls (see lib/readGroups.js).
+     *
+     * @param {string} section - Section name (log tag, key for the unsupported-register bookkeeping)
+     * @param {number} slaveId - Modbus slave id
+     * @param {object[]} registers - Register definitions
+     * @param {number} batchSize - Maximum registers per request
+     * @param {boolean} [holding] - Read holding registers (FC03) instead of input registers (FC04)
+     * @returns {Promise<void>} resolves when the section was read
+     */
+    async _readRegisterGroups(section, slaveId, registers, batchSize, holding = false) {
+        if (!this._unsupportedRegisters[section]) {
+            this._unsupportedRegisters[section] = new Set();
+            this._readErrorLogged[section] = new Set();
+        }
+        // Skip registers introduced in a newer protocol version than the one
+        // detected on the device (reg.since, only once detection succeeded).
+        const { active, skipped } = filterByProtocolVersion(registers, this._protocolVersion);
+        registers = active;
+        if (skipped.length > 0 && !this._sinceSkipLogged[section]) {
+            this._sinceSkipLogged[section] = true;
+            const list = skipped.map(r => `${r.addr} (${r.name}, V${r.since})`).join(', ');
+            this.log.info(
+                `[${section}] ${skipped.length} register(s) require a newer protocol version than detected ` +
+                    `(V${this._protocolVersion}) and are not polled: ${list}`,
+            );
+        }
+        this.log.debug(`Reading ${section} (slaveId=${slaveId})`);
+        await readRegisterGroups({
+            section,
+            registers,
+            batchSize,
+            unsupported: this._unsupportedRegisters[section],
+            errorLogged: this._readErrorLogged[section],
+            read: (addr, qty) =>
+                holding
+                    ? this.modbus.readHoldingRegisters(slaveId, addr, qty)
+                    : this.modbus.readInputRegisters(slaveId, addr, qty),
+            process: (group, raw) => this._processReadGroup(group, raw, section),
+            sleep: ms => this._sleep(ms),
+            isStopped: () => this._stopped,
+            log: this.log,
+        });
+    }
+
     async _readPlant() {
         const plantId = this.config.plantId || 247;
-        const batchSize = 120;
         const activeRegs = PLANT_READ_REGISTERS.filter(r => this._regActive(r));
-        const groups = this._buildReadGroups(activeRegs, batchSize);
-        this.log.debug(`Reading plant (slaveId=${plantId}): ${groups.length} group(s), ${activeRegs.length} registers`);
-
-        for (const group of groups) {
-            if (this._stopped) {
-                return;
-            }
-            try {
-                this.log.debug(`[plant] FC04 addr=${group.startAddr} qty=${group.totalQty}`);
-                const raw = await this.modbus.readInputRegisters(plantId, group.startAddr, group.totalQty);
-                await this._processReadGroup(group, raw, 'plant');
-                await this._sleep(100);
-            } catch (err) {
-                if (!this._plantUnsupportedGroups.has(group.startAddr)) {
-                    this._plantUnsupportedGroups.add(group.startAddr);
-                    this.log.warn(`Plant register read error at ${group.startAddr}: ${err.message}`);
-                } else {
-                    this.log.debug(`[plant] read error at ${group.startAddr}: ${err.message}`);
-                }
-            }
-        }
+        await this._readRegisterGroups('plant', plantId, activeRegs, 120);
     }
 
     /**
@@ -557,30 +587,8 @@ class Sigenergy extends utils.Adapter {
      */
     async _readInverter() {
         const inverterId = this.config.inverterId || 1;
-        const batchSize = 60;
         const activeRegs = INVERTER_READ_REGISTERS.filter(r => this._regActive(r));
-        const groups = this._buildReadGroups(activeRegs, batchSize);
-        this.log.debug(
-            `Reading inverter (slaveId=${inverterId}): ${groups.length} group(s),` + ` ${activeRegs.length} registers`,
-        );
-
-        for (const group of groups) {
-            if (this._stopped) {
-                return;
-            }
-            try {
-                const raw = await this.modbus.readInputRegisters(inverterId, group.startAddr, group.totalQty);
-                await this._processReadGroup(group, raw, 'inverter');
-                await this._sleep(100);
-            } catch (err) {
-                if (!this._inverterUnsupportedGroups.has(group.startAddr)) {
-                    this._inverterUnsupportedGroups.add(group.startAddr);
-                    this.log.warn(`Inverter register read error at ${group.startAddr}: ${err.message}`);
-                } else {
-                    this.log.debug(`[inverter] read error at ${group.startAddr}: ${err.message}`);
-                }
-            }
-        }
+        await this._readRegisterGroups('inverter', inverterId, activeRegs, 60);
     }
 
     /**
@@ -588,27 +596,7 @@ class Sigenergy extends utils.Adapter {
      */
     async _readAcCharger() {
         const acChargerId = this.config.acChargerId || 2;
-        const batchSize = 30;
-        const groups = this._buildReadGroups(AC_CHARGER_READ_REGISTERS, batchSize);
-        this.log.debug(`Reading AC charger (slaveId=${acChargerId}): ${groups.length} group(s)`);
-
-        for (const group of groups) {
-            if (this._stopped) {
-                return;
-            }
-            try {
-                const raw = await this.modbus.readInputRegisters(acChargerId, group.startAddr, group.totalQty);
-                await this._processReadGroup(group, raw, 'acCharger');
-                await this._sleep(100);
-            } catch (err) {
-                if (!this._acChargerUnsupportedGroups.has(group.startAddr)) {
-                    this._acChargerUnsupportedGroups.add(group.startAddr);
-                    this.log.warn(`AC Charger register read error at ${group.startAddr}: ${err.message}`);
-                } else {
-                    this.log.debug(`[acCharger] read error at ${group.startAddr}: ${err.message}`);
-                }
-            }
-        }
+        await this._readRegisterGroups('acCharger', acChargerId, AC_CHARGER_READ_REGISTERS, 30);
     }
 
     /**
@@ -616,77 +604,17 @@ class Sigenergy extends utils.Adapter {
      */
     async _readDcCharger() {
         const inverterId = this.config.inverterId || 1;
-        const batchSize = 10;
-        const groups = this._buildReadGroups(DC_CHARGER_READ_REGISTERS, batchSize);
-        this.log.debug(`Reading DC charger via inverter (slaveId=${inverterId}): ${groups.length} group(s)`);
-
-        for (const group of groups) {
-            if (this._stopped) {
-                return;
-            }
-            try {
-                const raw = await this.modbus.readInputRegisters(inverterId, group.startAddr, group.totalQty);
-                await this._processReadGroup(group, raw, 'dcCharger');
-                await this._sleep(100);
-            } catch (err) {
-                if (!this._dcChargerUnsupportedGroups.has(group.startAddr)) {
-                    this._dcChargerUnsupportedGroups.add(group.startAddr);
-                    this.log.warn(`DC Charger register read error at ${group.startAddr}: ${err.message}`);
-                } else {
-                    this.log.debug(`[dcCharger] read error at ${group.startAddr}: ${err.message}`);
-                }
-            }
-        }
+        await this._readRegisterGroups('dcCharger', inverterId, DC_CHARGER_READ_REGISTERS, 10);
     }
 
     async _readPss() {
         const pssId = this.config.pssSlaveId || 5;
-        const batchSize = 50;
-        const groups = this._buildReadGroups(PSS_READ_REGISTERS, batchSize);
-        this.log.debug(`Reading PSS (slaveId=${pssId}): ${groups.length} group(s)`);
-
-        for (const group of groups) {
-            if (this._stopped) {
-                return;
-            }
-            try {
-                const raw = await this.modbus.readInputRegisters(pssId, group.startAddr, group.totalQty);
-                await this._processReadGroup(group, raw, 'pss');
-                await this._sleep(100);
-            } catch (err) {
-                if (!this._pssUnsupportedGroups.has(group.startAddr)) {
-                    this._pssUnsupportedGroups.add(group.startAddr);
-                    this.log.warn(`PSS register read error at ${group.startAddr}: ${err.message}`);
-                } else {
-                    this.log.debug(`[pss] read error at ${group.startAddr}: ${err.message}`);
-                }
-            }
-        }
+        await this._readRegisterGroups('pss', pssId, PSS_READ_REGISTERS, 50);
     }
 
     async _readPid() {
         const pidId = this.config.pidSlaveId || 6;
-        const batchSize = 50;
-        const groups = this._buildReadGroups(PID_READ_REGISTERS, batchSize);
-        this.log.debug(`Reading PID (slaveId=${pidId}): ${groups.length} group(s)`);
-
-        for (const group of groups) {
-            if (this._stopped) {
-                return;
-            }
-            try {
-                const raw = await this.modbus.readInputRegisters(pidId, group.startAddr, group.totalQty);
-                await this._processReadGroup(group, raw, 'pid');
-                await this._sleep(100);
-            } catch (err) {
-                if (!this._pidUnsupportedGroups.has(group.startAddr)) {
-                    this._pidUnsupportedGroups.add(group.startAddr);
-                    this.log.warn(`PID register read error at ${group.startAddr}: ${err.message}`);
-                } else {
-                    this.log.debug(`[pid] read error at ${group.startAddr}: ${err.message}`);
-                }
-            }
-        }
+        await this._readRegisterGroups('pid', pidId, PID_READ_REGISTERS, 50);
     }
 
     async _readEssPreheating() {
@@ -698,7 +626,14 @@ class Sigenergy extends utils.Adapter {
         }
         const plantId = this.config.plantId || 247;
         const batchSize = 50;
-        const groups = this._buildReadGroups(ESS_PREHEATING_WRITE_REGISTERS, batchSize);
+        const { active, skipped } = filterByProtocolVersion(ESS_PREHEATING_WRITE_REGISTERS, this._protocolVersion);
+        if (active.length === 0 && skipped.length > 0) {
+            this.log.debug(
+                `[essPreheating] Skipping — registers require protocol V2.9, detected V${this._protocolVersion}`,
+            );
+            return;
+        }
+        const groups = this._buildReadGroups(active, batchSize);
         this.log.debug(`Reading ESS Preheating (slaveId=${plantId}): ${groups.length} group(s)`);
 
         let failCount = 0;
@@ -896,8 +831,12 @@ class Sigenergy extends utils.Adapter {
         }
 
         const levelStr = detectedLevel ? `>=${detectedLevel}` : 'pre-V2.6';
+        // Numeric twin of info.protocolLevel for consumers (widgets, scripts):
+        // highest confirmed protocol version, 0 = below V2.6.
+        this._protocolVersion = detectedLevel ? parseFloat(detectedLevel.replace(/^V/, '')) : 0;
         this.log.info(`Detected protocol level: ${levelStr} (firmware: ${firmwareVersion})`);
         await this.setStateAsync('info.protocolLevel', { val: levelStr, ack: true });
+        await this.setStateAsync('info.protocolVersion', { val: this._protocolVersion, ack: true });
         return true;
     }
 
@@ -950,51 +889,18 @@ class Sigenergy extends utils.Adapter {
 
         const plantRw = PLANT_WRITE_REGISTERS.filter(r => r.perm === 'RW' && this._regActive(r));
         if (plantRw.length > 0) {
-            for (const group of this._buildReadGroups(plantRw, 50)) {
-                if (this._stopped) {
-                    return;
-                }
-                try {
-                    const raw = await this.modbus.readHoldingRegisters(plantId, group.startAddr, group.totalQty);
-                    await this._processReadGroup(group, raw, 'control');
-                    await this._sleep(100);
-                } catch (err) {
-                    this.log.debug(`[controlRegs] plant addr=${group.startAddr}: ${err.message}`);
-                }
-            }
+            await this._readRegisterGroups('control.plant', plantId, plantRw, 50, true);
         }
 
         const invRw = INVERTER_WRITE_REGISTERS.filter(r => r.perm === 'RW' && this._regActive(r));
         if (invRw.length > 0) {
-            for (const group of this._buildReadGroups(invRw, 50)) {
-                if (this._stopped) {
-                    return;
-                }
-                try {
-                    const raw = await this.modbus.readHoldingRegisters(inverterId, group.startAddr, group.totalQty);
-                    await this._processReadGroup(group, raw, 'control');
-                    await this._sleep(100);
-                } catch (err) {
-                    this.log.debug(`[controlRegs] inverter addr=${group.startAddr}: ${err.message}`);
-                }
-            }
+            await this._readRegisterGroups('control.inverter', inverterId, invRw, 50, true);
         }
 
         if (this.config.hasDcCharger) {
             const dcRw = DC_CHARGER_WRITE_REGISTERS.filter(r => r.perm === 'RW');
             if (dcRw.length > 0) {
-                for (const group of this._buildReadGroups(dcRw, 50)) {
-                    if (this._stopped) {
-                        return;
-                    }
-                    try {
-                        const raw = await this.modbus.readHoldingRegisters(inverterId, group.startAddr, group.totalQty);
-                        await this._processReadGroup(group, raw, 'control');
-                        await this._sleep(100);
-                    } catch (err) {
-                        this.log.debug(`[controlRegs] dcCharger addr=${group.startAddr}: ${err.message}`);
-                    }
-                }
+                await this._readRegisterGroups('control.dcCharger', inverterId, dcRw, 50, true);
             }
         }
     }
@@ -1015,73 +921,22 @@ class Sigenergy extends utils.Adapter {
                 return;
             }
             const registers = getRegistersForDevice(device.slaveId);
-            const batchSize = 30;
-            const groups = this._buildReadGroups(registers, batchSize);
             this.log.debug(
-                `[SigenMicro] device slaveId=${device.slaveId}` +
-                    ` model='${device.model}': ${groups.length} group(s), ${registers.length} registers`,
+                `[SigenMicro] device slaveId=${device.slaveId} model='${device.model}': ${registers.length} registers`,
             );
-
-            for (const group of groups) {
-                if (this._stopped) {
-                    return;
-                }
-                try {
-                    const raw = await this.modbus.readInputRegisters(device.slaveId, group.startAddr, group.totalQty);
-                    await this._processReadGroup(group, raw, `sigenmicro.${device.slaveId}`);
-                    await this._sleep(100);
-                } catch (err) {
-                    this.log.warn(`SigenMicro ID ${device.slaveId} read error at ${group.startAddr}: ${err.message}`);
-                }
-            }
+            await this._readRegisterGroups(`sigenmicro.${device.slaveId}`, device.slaveId, registers, 30);
         }
     }
 
     /**
-     * Build optimized sequential read groups
+     * Build optimized sequential read groups (see lib/readGroups.js)
      *
      * @param {object[]} registers - Register definitions
      * @param {number} maxQty - Maximum registers per group
      * @returns {object[]} Grouped register batches
      */
     _buildReadGroups(registers, maxQty) {
-        if (!registers || registers.length === 0) {
-            return [];
-        }
-
-        const sorted = [...registers].sort((a, b) => a.addr - b.addr);
-        const groups = [];
-        let currentGroup = null;
-
-        for (const reg of sorted) {
-            if (!currentGroup) {
-                currentGroup = {
-                    startAddr: reg.addr,
-                    totalQty: reg.qty,
-                    registers: [{ ...reg, offset: 0 }],
-                };
-            } else {
-                const expectedNext = currentGroup.startAddr + currentGroup.totalQty;
-                const gap = reg.addr - expectedNext;
-
-                if (gap >= 0 && gap <= 4 && currentGroup.totalQty + gap + reg.qty <= maxQty) {
-                    const offset = reg.addr - currentGroup.startAddr;
-                    currentGroup.totalQty = Math.max(currentGroup.totalQty, offset + reg.qty);
-                    currentGroup.registers.push({ ...reg, offset });
-                } else {
-                    groups.push(currentGroup);
-                    currentGroup = {
-                        startAddr: reg.addr,
-                        totalQty: reg.qty,
-                        registers: [{ ...reg, offset: 0 }],
-                    };
-                }
-            }
-        }
-        if (currentGroup) {
-            groups.push(currentGroup);
-        }
-        return groups;
+        return buildReadGroups(registers, maxQty);
     }
 
     /**
@@ -1128,6 +983,7 @@ class Sigenergy extends utils.Adapter {
             'plant.essSoc': 'soc',
             'plant.essRatedEnergyCapacity': 'ratedCapacity',
             'plant.essDischargeSOC': 'cutoffSoc',
+            'plant.emsWorkMode': 'emsWorkMode',
             'inverter.pv1Voltage': 'pv1Voltage',
             'inverter.pv1Current': 'pv1Current',
             'inverter.pv2Voltage': 'pv2Voltage',
@@ -1141,15 +997,16 @@ class Sigenergy extends utils.Adapter {
     }
 
     /**
-     * Format a minute value as an "H:MMh" string (e.g. 83 -> "1:23h").
-     * Hours are not capped at 24. Distinguishes three cases so the caller's
-     * null-vs-undefined write semantics (see _updateStatistics) are preserved:
+     * Format a minute value as an "H:MM" string (e.g. 83 -> "1:23").
+     * Hours are not capped at 24.
+     * Distinguishes three cases so the caller's null-vs-undefined write
+     * semantics (see _updateStatistics) are preserved:
      *  - undefined  (statistic disabled via config)          -> undefined (skip write)
      *  - null / NaN (statistic enabled but currently N/A)     -> null (clears stale value)
-     *  - number                                                -> formatted "H:MMh" string
+     *  - number                                                -> formatted "H:MM" string
      *
      * @param {number|null|undefined} totalMinutes - Duration in minutes, or null/undefined per the cases above
-     * @returns {string|null|undefined} Formatted "H:MMh" string, or null/undefined mirroring the input case
+     * @returns {string|null|undefined} Formatted "H:MM" string, or null/undefined mirroring the input case
      */
     _formatMinutesAsHM(totalMinutes) {
         if (totalMinutes === undefined) {
@@ -1162,7 +1019,26 @@ class Sigenergy extends utils.Adapter {
         const abs = Math.round(Math.abs(totalMinutes));
         const hours = Math.floor(abs / 60);
         const minutes = abs % 60;
-        return `${sign}${hours}:${String(minutes).padStart(2, '0')}h`;
+        return `${sign}${hours}:${String(minutes).padStart(2, '0')}`;
+    }
+
+    /**
+     * Look up the plain-text label for the numeric EMS work mode (register
+     * 30003 / plant.emsWorkMode), using the same EMS_WORK_MODES map already
+     * used for the `common.states` metadata on plant.emsWorkMode. Unlike that
+     * metadata (only understood by UIs/tools that render `common.states`),
+     * this writes the human-readable text directly as the state value, so any
+     * consumer (VIS, Node-RED, external scripts) can use it without needing
+     * the lookup table.
+     *
+     * @param {number|undefined} mode - Raw value of plant.emsWorkMode
+     * @returns {string|undefined} Plain-text label, or undefined if mode hasn't been read yet
+     */
+    _formatEmsWorkMode(mode) {
+        if (mode === undefined) {
+            return undefined;
+        }
+        return EMS_WORK_MODES[mode] || `Unknown (${mode})`;
     }
 
     /**
@@ -1193,6 +1069,7 @@ class Sigenergy extends utils.Adapter {
             'statistics.housePower': statsValues.housePower,
             'statistics.currentSoc': statsValues.currentSoc,
             'statistics.currentPvPower': statsValues.currentPvPower,
+            'statistics.emsWorkMode': this._formatEmsWorkMode(this._currentData.emsWorkMode),
             'statistics.dayMaxSoc': statsValues.dayMaxSoc,
             'statistics.dayMinSoc': statsValues.dayMinSoc,
         };
@@ -1674,7 +1551,7 @@ class Sigenergy extends utils.Adapter {
                 id: 'statistics.batteryTimeToFullHM',
                 name: 'Time until battery is fully charged (h:mm)',
                 type: 'string',
-                unit: '',
+                unit: 'h',
                 role: 'text',
             },
             {
@@ -1688,7 +1565,7 @@ class Sigenergy extends utils.Adapter {
                 id: 'statistics.batteryTimeRemainingHM',
                 name: 'Battery time remaining at current load (h:mm)',
                 type: 'string',
-                unit: '',
+                unit: 'h',
                 role: 'text',
             },
             {
@@ -1702,7 +1579,7 @@ class Sigenergy extends utils.Adapter {
                 id: 'statistics.batteryDailyChargeTimeHM',
                 name: 'Today: cumulative time spent charging (h:mm)',
                 type: 'string',
-                unit: '',
+                unit: 'h',
                 role: 'text',
             },
             {
@@ -1716,7 +1593,7 @@ class Sigenergy extends utils.Adapter {
                 id: 'statistics.batteryCoverageTodayHM',
                 name: 'Today: time battery covered consumption (h:mm)',
                 type: 'string',
-                unit: '',
+                unit: 'h',
                 role: 'text',
             },
             {
@@ -1782,6 +1659,13 @@ class Sigenergy extends utils.Adapter {
                 unit: 'kW',
                 role: 'value.power',
             },
+            {
+                id: 'statistics.emsWorkMode',
+                name: 'EMS work mode (plain text)',
+                type: 'string',
+                unit: '',
+                role: 'text',
+            },
             {
                 id: 'statistics.dayMaxSoc',
                 name: 'Today maximum SOC',
@@ -1812,7 +1696,12 @@ class Sigenergy extends utils.Adapter {
                 },
                 native: {},
             };
-            await this.setObjectNotExistsAsync(s.id, statObj);
+            // extendObjectAsync (not setObjectNotExistsAsync) so that changes to
+            // an existing definition (e.g. a corrected unit or role) are applied
+            // on every adapter start, instead of being silently ignored forever
+            // once the object has been created once. The state's current value
+            // is untouched by this — only the object's common metadata is merged.
+            await this.extendObjectAsync(s.id, statObj);
         }
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iobroker.sigenergy",
-  "version": "3.1.2",
+  "version": "3.3.0",
   "description": "ioBroker adapter for Sigenergy solar energy systems via Modbus TCP/RTU",
   "author": {
     "name": "ssbingo",
@@ -30,12 +30,12 @@
   "devDependencies": {
     "@alcalzone/release-script": "^5.2.1",
     "@alcalzone/release-script-plugin-iobroker": "^5.2.0",
-    "@alcalzone/release-script-plugin-license": "^5.2.0",
+    "@alcalzone/release-script-plugin-license": "^5.2.2",
     "@alcalzone/release-script-plugin-manual-review": "^5.2.0",
     "@iobroker/adapter-dev": "^1.5.0",
     "@iobroker/eslint-config": "^2.3.4",
     "@iobroker/testing": "^5.3.0",
-    "@tsconfig/node22": "^22.0.5",
+    "@tsconfig/node22": "^22.0.6",
     "@types/node": "^22.20.1"
   },
   "main": "main.js",