iobroker.sigenergy 1.3.0 → 1.3.4

package/README.md

@@ -156,6 +156,15 @@ MIT License — Copyright (c) 2025 ioBroker Community
 ---
 
 ## Changelog
+### 1.3.4 (2026-03-13)
+* (ssbingo) Fix CI: add mocha to devDependencies so test:package script can run
+
+### 1.3.3 (2026-03-13)
+* (ssbingo) Fix duplicate @param JSDoc warning caused by missing closing tag in modbus.js
+
+### 1.3.2 (2026-03-13)
+* (ssbingo) Code quality fixes: unused variables removed, JSDoc documentation completed, lexical declaration in switch-case fixed
+
 ### 1.3.0 (2026-03-13)
 * (ssbingo) Multilingual documentation updated
 

package/io-package.json

@@ -1,20 +1,20 @@
 {
   "common": {
     "name": "sigenergy",
-    "version": "1.3.0",
+    "version": "1.3.4",
     "news": {
-      "1.3.0": {
-        "en": "Multilingual documentation updated",
-        "de": "Dokumentation mehrsprachig angepasst",
-        "ru": "Многоязычная документация обновлена",
-        "pt": "Documentação multilingue atualizada",
-        "nl": "Meertalige documentatie bijgewerkt",
-        "fr": "Documentation multilingue mise à jour",
-        "it": "Documentazione multilingue aggiornata",
-        "es": "Documentación multilingüe actualizada",
-        "pl": "Wielojęzyczna dokumentacja zaktualizowana",
-        "uk": "Багатомовна документація оновлена",
-        "zh-cn": "多语言文档已更新"
+      "1.3.4": {
+        "en": "Fix CI: add mocha to devDependencies so test:package script can run",
+        "de": "CI-Fix: mocha zu devDependencies hinzugefügt, damit das test:package-Skript ausgeführt werden kann",
+        "ru": "Исправление CI: добавлен mocha в devDependencies для работы скрипта test:package",
+        "pt": "Correção CI: mocha adicionado às devDependencies para que o script test:package possa ser executado",
+        "nl": "CI-fix: mocha toegevoegd aan devDependencies zodat het test:package-script kan worden uitgevoerd",
+        "fr": "Correction CI : mocha ajouté aux devDependencies pour permettre l'exécution du script test:package",
+        "it": "Fix CI: mocha aggiunto alle devDependencies per consentire l'esecuzione dello script test:package",
+        "es": "Fix CI: mocha añadido a devDependencies para que el script test:package pueda ejecutarse",
+        "pl": "Poprawka CI: dodano mocha do devDependencies, aby skrypt test:package mógł działać",
+        "uk": "Виправлення CI: додано mocha до devDependencies для запуску скрипта test:package",
+        "zh-cn": "CI修复：将mocha添加到devDependencies以便test:package脚本可以运行"
       }
     },
     "titleLang": {

package/lib/modbus.js

@@ -24,7 +24,7 @@ class ModbusConnection {
 
     /**
      * Connect to Modbus device
-     * @returns {Promise<boolean>}
+     * @returns {Promise<boolean>} Resolves to true if connection succeeded, false otherwise
      */
     async connect() {
         if (this.connecting) return false;
@@ -83,7 +83,7 @@ class ModbusConnection {
         if (this.client && this.client.isOpen) {
             try {
                 await this.client.close();
-            } catch (e) {
+            } catch {
                 // ignore
             }
         }
@@ -96,7 +96,7 @@ class ModbusConnection {
      * @param {number} slaveId - Slave address
      * @param {number} address - Register start address
      * @param {number} qty - Number of registers to read
-     * @returns {Promise<number[]>}
+     * @returns {Promise<number[]>} Resolves with an array of register values
      */
     async readInputRegisters(slaveId, address, qty) {
         if (!this.connected) {
@@ -112,7 +112,7 @@ class ModbusConnection {
      * @param {number} slaveId - Slave address
      * @param {number} address - Register start address
      * @param {number} qty - Number of registers to read
-     * @returns {Promise<number[]>}
+     * @returns {Promise<number[]>} Resolves with an array of register values
      */
     async readHoldingRegisters(slaveId, address, qty) {
         if (!this.connected) {
@@ -128,7 +128,7 @@ class ModbusConnection {
      * @param {number} slaveId - Slave address
      * @param {number} address - Register address
      * @param {number} value - Value to write
-     * @returns {Promise<void>}
+     * @returns {Promise<void>} Resolves when the register has been written
      */
     async writeSingleRegister(slaveId, address, value) {
         if (!this.connected) {
@@ -143,7 +143,7 @@ class ModbusConnection {
      * @param {number} slaveId - Slave address
      * @param {number} address - Start address
      * @param {number[]} values - Values array
-     * @returns {Promise<void>}
+     * @returns {Promise<void>} Resolves when all registers have been written
      */
     async writeMultipleRegisters(slaveId, address, values) {
         if (!this.connected) {
@@ -155,7 +155,7 @@ class ModbusConnection {
 
     /**
      * Test connection - used from admin
-     * @returns {Promise<{success: boolean, message: string}>}
+     * @returns {Promise<{success: boolean, message: string}>} Result object with success flag and human-readable message
      */
     async testConnection() {
         try {
@@ -169,7 +169,7 @@ class ModbusConnection {
 
             // Try reading plant system time as connectivity check
             this.client.setID(247);
-            const result = await this.client.readInputRegisters(30000, 2);
+            await this.client.readInputRegisters(30000, 2);
 
             if (!wasConnected) {
                 await this.disconnect();
@@ -193,7 +193,7 @@ class ModbusConnection {
      * @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}
+     * @returns {number|string} Parsed and optionally scaled register value; string for STRING type
      */
     static parseValue(rawData, type, gain) {
         let raw;
@@ -221,7 +221,7 @@ class ModbusConnection {
                       rawData[2] * Math.pow(2, 16) +
                       rawData[3];
                 break;
-            case "STRING":
+            case "STRING": {
                 // Each register holds 2 ASCII chars
                 let str = "";
                 for (let i = 0; i < rawData.length; i++) {
@@ -231,6 +231,7 @@ class ModbusConnection {
                     if (low !== 0) str += String.fromCharCode(low);
                 }
                 return str.trim();
+            }
             default:
                 raw = rawData[0];
         }

package/lib/statistics.js

@@ -1,196 +1,245 @@
-"use strict";
-
-/**
- * StatisticsCalculator - Computes derived statistical values for Sigenergy inverters
- * Includes house power, smoothing, and battery performance metrics.
- */
-class StatisticsCalculator {
-    constructor() {
-        this._history = {
-            essPower: [],   // kW: >0 charging, <0 discharging
-            pvPower: [],    // kW: PV generation
-            gridPower: [],  // kW: >0 import, <0 export
-            housePower: [], // kW: Calculated consumption (smoothed)
-            soc: [],        // %: Battery State of Charge
-        };
-        
-        // --- Smoothing & Filter Configuration ---
-        this._smoothingBuffer = []; 
-        this._smoothingWindow = 5;   // Average over the last 5 values
-        this._thresholdKW = 0.005;   // Ignore noise below 5 Watts
-        
-        this._maxHistory = 360;      // 1 hour at 10s intervals
-        this._dayStart = this._getTodayStart();
-        this._dayStats = this._getDefaultDayStats();
-    }
-
-    _getTodayStart() {
-        const d = new Date();
-        d.setHours(0, 0, 0, 0);
-        return d.getTime();
-    }
-
-    _getDefaultDayStats() {
-        return {
-            batteryFullTime: null,
-            batteryEmptyTime: null,
-            startSoc: null,
-            maxSoc: 0,
-            minSoc: 100,
-            chargeStartTime: null,
-        };
-    }
-
-    /**
-     * Central calculation of house consumption with filtering
-     * Formula: PV + Grid - Battery
-     */
-    _calculateSmoothHousePower(pv, grid, ess) {
-        let rawPower = (pv || 0) + (grid || 0) - (ess || 0);
-        
-        if (rawPower < this._thresholdKW) {
-            rawPower = 0;
-        }
-
-        this._smoothingBuffer.push(rawPower);
-        if (this._smoothingBuffer.length > this._smoothingWindow) {
-            this._smoothingBuffer.shift();
-        }
-
-        const sum = this._smoothingBuffer.reduce((a, b) => a + b, 0);
-        return sum / this._smoothingBuffer.length;
-    }
-
-    update(data) {
-        const now = Date.now();
-
-        const todayStart = this._getTodayStart();
-        if (todayStart !== this._dayStart) {
-            this._dayStart = todayStart;
-            this._dayStats = this._getDefaultDayStats();
-            this._smoothingBuffer = []; 
-        }
-
-        if (data.essPower !== undefined) this._history.essPower.push({ ts: now, v: data.essPower });
-        if (data.pvPower !== undefined) this._history.pvPower.push({ ts: now, v: data.pvPower });
-        if (data.gridPower !== undefined) this._history.gridPower.push({ ts: now, v: data.gridPower });
-
-        if (data.pvPower !== undefined && data.essPower !== undefined && data.gridPower !== undefined) {
-            const hp = this._calculateSmoothHousePower(data.pvPower, data.gridPower, data.essPower);
-            this._history.housePower.push({ ts: now, v: hp });
-        }
-
-        if (data.soc !== undefined) {
-            const soc = data.soc;
-            this._history.soc.push({ ts: now, v: soc });
-            
-            if (this._dayStats.startSoc === null) this._dayStats.startSoc = soc;
-            if (soc > this._dayStats.maxSoc) this._dayStats.maxSoc = soc;
-            if (soc < this._dayStats.minSoc) this._dayStats.minSoc = soc;
-
-            // Track daily battery metrics
-            if (soc >= 99.5 && this._dayStats.batteryFullTime === null) {
-                this._dayStats.batteryFullTime = now;
-            }
-            if (soc < 5 && this._dayStats.batteryEmptyTime === null) {
-                this._dayStats.batteryEmptyTime = now;
-            }
-            if (data.essPower > 0.1 && this._dayStats.chargeStartTime === null) {
-                this._dayStats.chargeStartTime = now;
-            }
-        }
-
-        Object.keys(this._history).forEach(key => this._trimHistory(key));
-    }
-
-    _trimHistory(key) {
-        if (this._history[key].length > this._maxHistory) {
-            this._history[key] = this._history[key].slice(-this._maxHistory);
-        }
-    }
-
-    // --- Battery Estimation Methods ---
-
-    calcTimeToFull(soc, essPower, ratedCapacity) {
-        if (essPower <= 0.05 || soc >= 100 || !ratedCapacity) return null;
-        const remainingEnergy = ratedCapacity * (100 - soc) / 100;
-        return Math.round((remainingEnergy / essPower) * 60);
-    }
-
-    calcTimeRemaining(soc, essPower, ratedCapacity, cutoffSoc = 10) {
-        if (essPower >= -0.05 || soc <= cutoffSoc || !ratedCapacity) return null;
-        const usableEnergy = ratedCapacity * (soc - cutoffSoc) / 100;
-        return Math.round((usableEnergy / Math.abs(essPower)) * 60);
-    }
-
-    calcBatteryCoverageToday() {
-        const gridHistory = this._history.gridPower.filter(e => e.ts >= this._dayStart);
-        const essHistory = this._history.essPower.filter(e => e.ts >= this._dayStart);
-        if (gridHistory.length < 2) return 0;
-
-        let coverageMs = 0;
-        for (let i = 1; i < gridHistory.length; i++) {
-            const dt = gridHistory[i].ts - gridHistory[i - 1].ts;
-            const gridVal = gridHistory[i].v;
-            // Find nearest ESS value
-            const essEntry = essHistory.reduce((prev, curr) => 
-                Math.abs(curr.ts - gridHistory[i].ts) < Math.abs(prev.ts - gridHistory[i].ts) ? curr : prev, essHistory[0]);
-            
-            // Covered if battery is discharging and grid import is near zero
-            if (essEntry && essEntry.v < -0.05 && gridVal < 0.02) {
-                coverageMs += dt;
-            }
-        }
-        return Math.round(coverageMs / 60000);
-    }
-
-    getStats(cd, config) {
-        const stats = {};
-        const currentHousePower = this._smoothingBuffer.length > 0 
-            ? this._smoothingBuffer[this._smoothingBuffer.length - 1] 
-            : 0;
-
-        // Battery Time Calculations
-        if (config.calcBatteryTimeToFull) {
-            stats.batteryTimeToFull = this.calcTimeToFull(cd.soc, cd.essPower, cd.ratedCapacity);
-        }
-        if (config.calcBatteryTimeRemaining) {
-            stats.batteryTimeRemaining = this.calcTimeRemaining(cd.soc, cd.essPower, cd.ratedCapacity, cd.cutoffSoc);
-        }
-        
-        // Daily Battery Statistics
-        if (config.calcBatteryDailyFull && this._dayStats.batteryFullTime) {
-            const start = this._dayStats.chargeStartTime || this._dayStart;
-            stats.batteryDailyChargeTime = Math.round((this._dayStats.batteryFullTime - start) / 60000);
-        }
-
-        if (config.calcBatteryCoverageTime) {
-            stats.batteryCoverageToday = this.calcBatteryCoverageToday();
-        }
-
-        // Efficiency Rates
-        if (config.calcSelfConsumptionRate) {
-            const export_ = cd.gridPower < 0 ? Math.abs(cd.gridPower) : 0;
-            const selfUsed = Math.max(0, (cd.pvPower || 0) - export_);
-            stats.selfConsumptionRate = cd.pvPower > 0.01 
-                ? Math.min(100, Math.round((selfUsed / cd.pvPower) * 1000) / 10) 
-                : 0;
-        }
-
-        if (config.calcAutarkyRate) {
-            const gridImport = Math.max(0, cd.gridPower || 0);
-            const fromLocal = Math.max(0, currentHousePower - gridImport);
-            stats.autarkyRate = currentHousePower > 0.01 
-                ? Math.min(100, Math.round((fromLocal / currentHousePower) * 1000) / 10) 
-                : 100;
-        }
-        
-        stats.housePower = currentHousePower;
-        stats.dayMaxSoc = this._dayStats.maxSoc;
-        stats.dayMinSoc = this._dayStats.minSoc;
-
-        return stats;
-    }
-}
-
-module.exports = StatisticsCalculator;
+"use strict";
+
+/**
+ * StatisticsCalculator - Computes derived statistical values for Sigenergy inverters
+ * Includes house power, smoothing, and battery performance metrics.
+ */
+class StatisticsCalculator {
+    /**
+     * Initialises internal history buffers and daily statistics tracking.
+     */
+    constructor() {
+        this._history = {
+            essPower: [],   // kW: >0 charging, <0 discharging
+            pvPower: [],    // kW: PV generation
+            gridPower: [],  // kW: >0 import, <0 export
+            housePower: [], // kW: Calculated consumption (smoothed)
+            soc: [],        // %: Battery State of Charge
+        };
+        
+        // --- Smoothing & Filter Configuration ---
+        this._smoothingBuffer = []; 
+        this._smoothingWindow = 5;   // Average over the last 5 values
+        this._thresholdKW = 0.005;   // Ignore noise below 5 Watts
+        
+        this._maxHistory = 360;      // 1 hour at 10s intervals
+        this._dayStart = this._getTodayStart();
+        this._dayStats = this._getDefaultDayStats();
+    }
+
+    /**
+     * Returns the Unix timestamp for the start of today (midnight).
+     * @returns {number} Milliseconds since epoch for today's midnight
+     */
+    _getTodayStart() {
+        const d = new Date();
+        d.setHours(0, 0, 0, 0);
+        return d.getTime();
+    }
+
+    /**
+     * Returns a fresh default daily statistics object.
+     * @returns {{batteryFullTime: null, batteryEmptyTime: null, startSoc: null, maxSoc: number, minSoc: number, chargeStartTime: null}} Default day stats
+     */
+    _getDefaultDayStats() {
+        return {
+            batteryFullTime: null,
+            batteryEmptyTime: null,
+            startSoc: null,
+            maxSoc: 0,
+            minSoc: 100,
+            chargeStartTime: null,
+        };
+    }
+
+    /**
+     * Central calculation of house consumption with filtering and smoothing.
+     * Formula: PV + Grid - Battery
+     * @param {number} pv - PV generation power in kW
+     * @param {number} grid - Grid power in kW (positive = import, negative = export)
+     * @param {number} ess - Battery power in kW (positive = charging, negative = discharging)
+     * @returns {number} Smoothed house power in kW
+     */
+    _calculateSmoothHousePower(pv, grid, ess) {
+        let rawPower = (pv || 0) + (grid || 0) - (ess || 0);
+        
+        if (rawPower < this._thresholdKW) {
+            rawPower = 0;
+        }
+
+        this._smoothingBuffer.push(rawPower);
+        if (this._smoothingBuffer.length > this._smoothingWindow) {
+            this._smoothingBuffer.shift();
+        }
+
+        const sum = this._smoothingBuffer.reduce((a, b) => a + b, 0);
+        return sum / this._smoothingBuffer.length;
+    }
+
+    /**
+     * Ingests a new set of current measurements and updates internal history.
+     * Resets daily stats automatically on day change.
+     * @param {object} data - Current measurement values (pvPower, gridPower, essPower, soc, etc.)
+     */
+    update(data) {
+        const now = Date.now();
+
+        const todayStart = this._getTodayStart();
+        if (todayStart !== this._dayStart) {
+            this._dayStart = todayStart;
+            this._dayStats = this._getDefaultDayStats();
+            this._smoothingBuffer = []; 
+        }
+
+        if (data.essPower !== undefined) this._history.essPower.push({ ts: now, v: data.essPower });
+        if (data.pvPower !== undefined) this._history.pvPower.push({ ts: now, v: data.pvPower });
+        if (data.gridPower !== undefined) this._history.gridPower.push({ ts: now, v: data.gridPower });
+
+        if (data.pvPower !== undefined && data.essPower !== undefined && data.gridPower !== undefined) {
+            const hp = this._calculateSmoothHousePower(data.pvPower, data.gridPower, data.essPower);
+            this._history.housePower.push({ ts: now, v: hp });
+        }
+
+        if (data.soc !== undefined) {
+            const soc = data.soc;
+            this._history.soc.push({ ts: now, v: soc });
+            
+            if (this._dayStats.startSoc === null) this._dayStats.startSoc = soc;
+            if (soc > this._dayStats.maxSoc) this._dayStats.maxSoc = soc;
+            if (soc < this._dayStats.minSoc) this._dayStats.minSoc = soc;
+
+            // Track daily battery metrics
+            if (soc >= 99.5 && this._dayStats.batteryFullTime === null) {
+                this._dayStats.batteryFullTime = now;
+            }
+            if (soc < 5 && this._dayStats.batteryEmptyTime === null) {
+                this._dayStats.batteryEmptyTime = now;
+            }
+            if (data.essPower > 0.1 && this._dayStats.chargeStartTime === null) {
+                this._dayStats.chargeStartTime = now;
+            }
+        }
+
+        Object.keys(this._history).forEach(key => this._trimHistory(key));
+    }
+
+    /**
+     * Trims a history array to the configured maximum length.
+     * @param {string} key - Key of the history array to trim (e.g. "essPower")
+     */
+    _trimHistory(key) {
+        if (this._history[key].length > this._maxHistory) {
+            this._history[key] = this._history[key].slice(-this._maxHistory);
+        }
+    }
+
+    // --- Battery Estimation Methods ---
+
+    /**
+     * Estimates minutes until the battery is fully charged.
+     * @param {number} soc - Current state of charge in percent
+     * @param {number} essPower - Current charging power in kW (must be positive)
+     * @param {number} ratedCapacity - Rated battery capacity in kWh
+     * @returns {number|null} Minutes to full, or null if charging is not active / battery is full
+     */
+    calcTimeToFull(soc, essPower, ratedCapacity) {
+        if (essPower <= 0.05 || soc >= 100 || !ratedCapacity) return null;
+        const remainingEnergy = ratedCapacity * (100 - soc) / 100;
+        return Math.round((remainingEnergy / essPower) * 60);
+    }
+
+    /**
+     * Estimates minutes of remaining battery discharge time.
+     * @param {number} soc - Current state of charge in percent
+     * @param {number} essPower - Current power in kW (must be negative for discharge)
+     * @param {number} ratedCapacity - Rated battery capacity in kWh
+     * @param {number} [cutoffSoc=10] - Minimum usable SoC threshold in percent
+     * @returns {number|null} Minutes remaining, or null if not discharging / already at cutoff
+     */
+    calcTimeRemaining(soc, essPower, ratedCapacity, cutoffSoc = 10) {
+        if (essPower >= -0.05 || soc <= cutoffSoc || !ratedCapacity) return null;
+        const usableEnergy = ratedCapacity * (soc - cutoffSoc) / 100;
+        return Math.round((usableEnergy / Math.abs(essPower)) * 60);
+    }
+
+    /**
+     * Calculates how many minutes today the battery covered the load without grid import.
+     * @returns {number} Coverage duration in minutes
+     */
+    calcBatteryCoverageToday() {
+        const gridHistory = this._history.gridPower.filter(e => e.ts >= this._dayStart);
+        const essHistory = this._history.essPower.filter(e => e.ts >= this._dayStart);
+        if (gridHistory.length < 2) return 0;
+
+        let coverageMs = 0;
+        for (let i = 1; i < gridHistory.length; i++) {
+            const dt = gridHistory[i].ts - gridHistory[i - 1].ts;
+            const gridVal = gridHistory[i].v;
+            // Find nearest ESS value
+            const essEntry = essHistory.reduce((prev, curr) => 
+                Math.abs(curr.ts - gridHistory[i].ts) < Math.abs(prev.ts - gridHistory[i].ts) ? curr : prev, essHistory[0]);
+            
+            // Covered if battery is discharging and grid import is near zero
+            if (essEntry && essEntry.v < -0.05 && gridVal < 0.02) {
+                coverageMs += dt;
+            }
+        }
+        return Math.round(coverageMs / 60000);
+    }
+
+    /**
+     * Computes all configured statistics and returns them as a flat object.
+     * @param {object} cd - Current data snapshot (soc, essPower, pvPower, gridPower, ratedCapacity, cutoffSoc)
+     * @param {object} config - Adapter configuration flags (calcBatteryTimeToFull, calcAutarkyRate, etc.)
+     * @returns {object} Computed statistics keyed by state name
+     */
+    getStats(cd, config) {
+        const stats = {};
+        const currentHousePower = this._smoothingBuffer.length > 0 
+            ? this._smoothingBuffer[this._smoothingBuffer.length - 1] 
+            : 0;
+
+        // Battery Time Calculations
+        if (config.calcBatteryTimeToFull) {
+            stats.batteryTimeToFull = this.calcTimeToFull(cd.soc, cd.essPower, cd.ratedCapacity);
+        }
+        if (config.calcBatteryTimeRemaining) {
+            stats.batteryTimeRemaining = this.calcTimeRemaining(cd.soc, cd.essPower, cd.ratedCapacity, cd.cutoffSoc);
+        }
+        
+        // Daily Battery Statistics
+        if (config.calcBatteryDailyFull && this._dayStats.batteryFullTime) {
+            const start = this._dayStats.chargeStartTime || this._dayStart;
+            stats.batteryDailyChargeTime = Math.round((this._dayStats.batteryFullTime - start) / 60000);
+        }
+
+        if (config.calcBatteryCoverageTime) {
+            stats.batteryCoverageToday = this.calcBatteryCoverageToday();
+        }
+
+        // Efficiency Rates
+        if (config.calcSelfConsumptionRate) {
+            const export_ = cd.gridPower < 0 ? Math.abs(cd.gridPower) : 0;
+            const selfUsed = Math.max(0, (cd.pvPower || 0) - export_);
+            stats.selfConsumptionRate = cd.pvPower > 0.01 
+                ? Math.min(100, Math.round((selfUsed / cd.pvPower) * 1000) / 10) 
+                : 0;
+        }
+
+        if (config.calcAutarkyRate) {
+            const gridImport = Math.max(0, cd.gridPower || 0);
+            const fromLocal = Math.max(0, currentHousePower - gridImport);
+            stats.autarkyRate = currentHousePower > 0.01 
+                ? Math.min(100, Math.round((fromLocal / currentHousePower) * 1000) / 10) 
+                : 100;
+        }
+        
+        stats.housePower = currentHousePower;
+        stats.dayMaxSoc = this._dayStats.maxSoc;
+        stats.dayMinSoc = this._dayStats.minSoc;
+
+        return stats;
+    }
+}
+
+module.exports = StatisticsCalculator;

package/main.js

@@ -25,12 +25,11 @@ const {
     INVERTER_READ_REGISTERS,
     DC_CHARGER_READ_REGISTERS,
     AC_CHARGER_READ_REGISTERS,
-    RUNNING_STATES,
 } = require("./lib/registers");
 
 class Sigenergy extends utils.Adapter {
     /**
-     * @param {Partial<utils.AdapterOptions>} [options]
+     * @param {Partial<utils.AdapterOptions>} [options] - Adapter options passed to the ioBroker core
      */
     constructor(options) {
         super({
@@ -280,6 +279,9 @@ class Sigenergy extends utils.Adapter {
     /**
      * Build optimized sequential read groups
      * Groups consecutive registers to minimize read requests
+     * @param {object[]} registers - Array of register definitions to group
+     * @param {number} maxQty - Maximum number of registers allowed per read request
+     * @returns {object[]} Array of grouped register read requests
      */
     _buildReadGroups(registers, maxQty) {
         if (!registers || registers.length === 0) return [];
@@ -324,8 +326,11 @@ class Sigenergy extends utils.Adapter {
 
     /**
      * Process a read group and set states
+     * @param {object} group - A read group as produced by _buildReadGroups
+     * @param {number[]} rawData - Raw register data returned by the Modbus read
+     * @param {string} _section - Logical section name for logging (unused, reserved for future use)
      */
-    async _processReadGroup(group, rawData, section) {
+    async _processReadGroup(group, rawData, _section) {
         for (const reg of group.registers) {
             try {
                 const slice = rawData.slice(reg.offset, reg.offset + reg.qty);
@@ -346,6 +351,8 @@ class Sigenergy extends utils.Adapter {
 
     /**
      * Store key values for statistics calculation
+     * @param {string} name - State ID of the register (e.g. "plant.essPower")
+     * @param {number|string} value - Parsed value of the register
      */
     _storeCurrentData(name, value) {
         const map = {
@@ -508,6 +515,8 @@ class Sigenergy extends utils.Adapter {
 
     /**
      * Handle state changes (for writable states)
+     * @param {string} id - Full state ID that changed
+     * @param {ioBroker.State | null | undefined} state - New state value, or null/undefined if deleted
      */
     onStateChange(id, state) {
         if (!state || state.ack) return;
@@ -517,6 +526,7 @@ class Sigenergy extends utils.Adapter {
 
     /**
      * Handle messages from admin (connection test, etc.)
+     * @param {ioBroker.Message} obj - Message object sent from admin or other adapters
      */
     async onMessage(obj) {
         if (!obj || !obj.command) return;
@@ -560,13 +570,14 @@ class Sigenergy extends utils.Adapter {
             const { SerialPort } = require("serialport");
             const ports = await SerialPort.list();
             return ports.map(p => ({ value: p.path, label: `${p.path}${p.manufacturer ? ` (${p.manufacturer})` : ""}` }));
-        } catch (e) {
+        } catch {
             return [];
         }
     }
 
     /**
      * Adapter shutdown
+     * @param {() => void} callback - Must be called after cleanup to signal shutdown completion
      */
     async onUnload(callback) {
         try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iobroker.sigenergy",
-  "version": "1.3.0",
+  "version": "1.3.4",
   "description": "ioBroker adapter for Sigenergy solar energy systems via Modbus TCP/RTU",
   "author": {
     "name": "ssbingo",
@@ -31,6 +31,7 @@
     "@iobroker/dev-server": "^0.8.0",
     "@iobroker/testing": "^5.2.2",
     "eslint": "^9.10.0",
+    "mocha": "^10.0.0",
     "@alcalzone/release-script": "^5.1.1",
     "@alcalzone/release-script-plugin-iobroker": "^5.1.2",
     "@alcalzone/release-script-plugin-license": "^5.1.1",