iobroker.sigenergy 3.2.0 → 3.3.1

package/README.md

@@ -255,6 +255,19 @@ Status and power readings for the DC charger.
 
 ## Changelog
 
+### 3.3.1 (2026-09-07)
+- (ssbingo) fix: registers the device marks as not valid are no longer turned into plausible looking measurements. The protocol signals this by setting all bits ("Range:[0, 0xFFFFFFFE]. With value 0xFFFFFFFF, register is not valid.") and a device answers that way for a register that does not currently apply or that its firmware does not implement. The raw sentinel was scaled by the register gain, so it arrived as a reading that looks real: observed on a SigenStor EC 10.0 TP **with** a DC charger installed, `dcCharger.runningState` = 65535 (Appendix 14 only defines 0x00-0x0A), `dcCharger.dischargingCurrent` = 6553.5 A, `dcCharger.currentDischargingCapacity` = 42949672.95 kWh and `dcCharger.currentDischargingDuration` = 4294967295 s, while the neighbouring DC charger registers (rated power, PV generation, totals) returned real values. The same pattern appears outside the DC charger, e.g. `plant.currentCtrlCmdValue` = 655.35 %, `plant.mergedAlarm7` = 65535, `inverter.essMaxBatteryCellVoltage` = 65.535 V and the ESS/PCS/grid limit registers as 4294967.295 kW. Such registers now report no value instead
+- (ssbingo) fix: a register that reports no value no longer feeds the statistics calculation, which keeps the last known good reading instead
+
+### 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

package/io-package.json

@@ -1,8 +1,34 @@
 {
     "common": {
         "name": "sigenergy",
-        "version": "3.2.0",
+        "version": "3.3.1",
         "news": {
+            "3.3.1": {
+                "en": "(ssbingo) fix: registers the device marks as not valid (all bits set, 0xFFFF / 0xFFFFFFFF) are no longer scaled by the register gain into plausible looking measurements — observed as a 6553.5 A discharging current, 42949672.95 kWh and an out-of-range running state 65535 on the DC charger, and as 655.35 % or 65.535 V elsewhere. Such registers now report no value",
+                "de": "(ssbingo) fix: Register, die das Gerät als ungültig kennzeichnet (alle Bits gesetzt, 0xFFFF / 0xFFFFFFFF), werden nicht mehr über den Gain in plausibel aussehende Messwerte umgerechnet — sichtbar als 6553,5 A Entladestrom, 42949672,95 kWh und Betriebszustand 65535 beim DC-Charger sowie als 655,35 % oder 65,535 V an anderer Stelle. Solche Register liefern jetzt keinen Wert",
+                "ru": "(ssbingo) fix: регистры, помеченные устройством как недействительные (все биты установлены, 0xFFFF / 0xFFFFFFFF), больше не пересчитываются через коэффициент в правдоподобные значения — это проявлялось как ток разряда 6553,5 A, 42949672,95 кВт·ч и состояние 65535 у DC-зарядки, а также как 655,35 % или 65,535 В в других местах. Теперь такие регистры не возвращают значения",
+                "pt": "(ssbingo) fix: os registos que o dispositivo marca como inválidos (todos os bits a 1, 0xFFFF / 0xFFFFFFFF) deixam de ser convertidos pelo ganho em medições aparentemente plausíveis — surgiam como 6553,5 A de corrente de descarga, 42949672,95 kWh e o estado 65535 no carregador DC, e como 655,35 % ou 65,535 V noutros pontos. Esses registos passam a não devolver valor",
+                "nl": "(ssbingo) fix: registers die het apparaat als ongeldig markeert (alle bits gezet, 0xFFFF / 0xFFFFFFFF) worden niet langer via de gain omgerekend naar plausibel ogende metingen — zichtbaar als 6553,5 A ontlaadstroom, 42949672,95 kWh en status 65535 bij de DC-lader, en als 655,35 % of 65,535 V elders. Zulke registers geven nu geen waarde meer",
+                "fr": "(ssbingo) fix : les registres que l'appareil marque comme non valides (tous les bits à 1, 0xFFFF / 0xFFFFFFFF) ne sont plus convertis par le gain en mesures d'apparence plausible — cela apparaissait comme un courant de décharge de 6553,5 A, 42949672,95 kWh et l'état 65535 sur le chargeur DC, et comme 655,35 % ou 65,535 V ailleurs. Ces registres ne renvoient plus de valeur",
+                "it": "(ssbingo) fix: i registri che il dispositivo segnala come non validi (tutti i bit a 1, 0xFFFF / 0xFFFFFFFF) non vengono più convertiti dal gain in misure apparentemente plausibili — comparivano come corrente di scarica di 6553,5 A, 42949672,95 kWh e stato 65535 sul caricatore DC, e come 655,35 % o 65,535 V altrove. Tali registri ora non restituiscono alcun valore",
+                "es": "(ssbingo) fix: los registros que el dispositivo marca como no válidos (todos los bits a 1, 0xFFFF / 0xFFFFFFFF) ya no se convierten mediante la ganancia en mediciones de apariencia plausible — aparecían como una corriente de descarga de 6553,5 A, 42949672,95 kWh y el estado 65535 en el cargador DC, y como 655,35 % o 65,535 V en otros puntos. Esos registros ya no devuelven valor",
+                "pl": "(ssbingo) fix: rejestry oznaczone przez urządzenie jako nieprawidłowe (wszystkie bity ustawione, 0xFFFF / 0xFFFFFFFF) nie są już przeliczane przez wzmocnienie na wiarygodnie wyglądające pomiary — objawiało się to prądem rozładowania 6553,5 A, 42949672,95 kWh i stanem 65535 na ładowarce DC oraz 655,35 % lub 65,535 V w innych miejscach. Takie rejestry nie zwracają teraz wartości",
+                "uk": "(ssbingo) fix: регістри, позначені пристроєм як недійсні (усі біти встановлено, 0xFFFF / 0xFFFFFFFF), більше не перетворюються через коефіцієнт на правдоподібні вимірювання — це виглядало як струм розряду 6553,5 A, 42949672,95 кВт·год і стан 65535 на DC-зарядці та як 655,35 % або 65,535 В в інших місцях. Тепер такі регістри не повертають значення",
+                "zh-cn": "(ssbingo) fix: 设备标记为无效的寄存器（全部位为 1，0xFFFF / 0xFFFFFFFF）不再经增益换算成看似合理的测量值——此前表现为直流充电桩的 6553.5 A 放电电流、42949672.95 kWh 和超出范围的运行状态 65535，以及其他位置的 655.35 % 或 65.535 V。此类寄存器现在不再返回数值"
+            },
+            "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",
@@ -258,6 +284,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/modbus.js

@@ -269,13 +269,38 @@ class ModbusConnection {
         }
     }
 
+    /**
+     * Values the protocol uses to mark an unsigned register as "not valid",
+     * i.e. all bits set. The V2.9 document spells this out for the power
+     * limitation registers ("Range:[0, 0xFFFFFFFE]. With value 0xFFFFFFFF,
+     * register is not valid.") and devices apply the same convention to
+     * registers they do not implement — e.g. a SigenStor without a DC charger
+     * answers 0xFFFF for [DC Charger] running state 31513.
+     *
+     * Only the unsigned types are listed. The document does not define a
+     * sentinel for the signed types, and 0x7FFF / 0x7FFFFFFF are legal
+     * measurements there, so those must not be filtered.
+     */
+    static get INVALID_RAW() {
+        return {
+            U16: 0xffff,
+            U32: 0xffffffff,
+            U64: 18446744073709552000, // 2^64 - 1, as close as a double gets
+        };
+    }
+
     /**
      * Parse raw register data into a typed value
      *
+     * Returns null when the device marked the register as not valid (see
+     * INVALID_RAW). Without this, the sentinel is scaled by the gain and ends
+     * up as a plausible looking measurement — 0xFFFF with gain 10 becomes
+     * "6553.5 A", 0xFFFFFFFF with gain 1000 becomes "4294967.295 kW".
+     *
      * @param {number[]} rawData - Raw register data
      * @param {string} type - Data type (U16, S16, U32, S32, U64, STRING)
      * @param {number|null} gain - Scaling factor
-     * @returns {number|string|null} Decoded value
+     * @returns {number|string|null} Decoded value, or null if the register is not valid
      */
     static parseValue(rawData, type, gain) {
         let raw;
@@ -327,6 +352,11 @@ class ModbusConnection {
                 raw = rawData[0];
         }
 
+        const invalid = ModbusConnection.INVALID_RAW[type];
+        if (invalid !== undefined && raw === invalid) {
+            return null;
+        }
+
         if (gain && gain !== 1 && gain !== null) {
             return raw / gain;
         }

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

@@ -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)
@@ -4981,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,
@@ -4999,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);
     }
 
     /**
@@ -1136,9 +991,16 @@ class Sigenergy extends utils.Adapter {
             'inverter.pv3Voltage': 'pv3Voltage',
             'inverter.pv3Current': 'pv3Current',
         };
-        if (map[name] !== undefined) {
-            this._currentData[map[name]] = value;
+        if (map[name] === undefined) {
+            return;
+        }
+        // A null value means the device marked the register as not valid
+        // (see ModbusConnection.INVALID_RAW). Keep the last known good value
+        // instead, so the statistics are not poisoned by a single bad poll.
+        if (value === null) {
+            return;
         }
+        this._currentData[map[name]] = value;
     }
 
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iobroker.sigenergy",
-  "version": "3.2.0",
+  "version": "3.3.1",
   "description": "ioBroker adapter for Sigenergy solar energy systems via Modbus TCP/RTU",
   "author": {
     "name": "ssbingo",