iobroker.sigenergy 1.3.3 → 1.3.4

package/README.md

@@ -156,6 +156,9 @@ 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
 

package/io-package.json

@@ -1,20 +1,20 @@
 {
   "common": {
     "name": "sigenergy",
-    "version": "1.3.3",
+    "version": "1.3.4",
     "news": {
-      "1.3.3": {
-        "en": "Fix duplicate @param JSDoc warning caused by missing closing tag in modbus.js",
-        "de": "Doppelten @param JSDoc-Hinweis durch fehlendes schließendes Tag in modbus.js behoben",
-        "ru": "Исправлено дублирующее предупреждение @param JSDoc из-за отсутствующего закрывающего тега в modbus.js",
-        "pt": "Corrigido aviso JSDoc @param duplicado causado por tag de fechamento ausente em modbus.js",
-        "nl": "Dubbele @param JSDoc-waarschuwing verholpen door ontbrekend sluitend label in modbus.js",
-        "fr": "Correction de l'avertissement JSDoc @param en double causé par une balise fermante manquante dans modbus.js",
-        "it": "Corretto avviso JSDoc @param duplicato causato da tag di chiusura mancante in modbus.js",
-        "es": "Corregida advertencia JSDoc @param duplicada causada por etiqueta de cierre faltante en modbus.js",
-        "pl": "Poprawiono zduplikowane ostrzeżenie JSDoc @param spowodowane brakującym tagiem zamykającym w modbus.js",
-        "uk": "Виправлено дубльоване попередження JSDoc @param через відсутній закриваючий тег у modbus.js",
-        "zh-cn": "修复modbus.js中因缺少闭合标签导致的重复@param JSDoc警告"
+      "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

@@ -1,267 +1,246 @@
-'use strict';
+"use strict";
 
-const ModbusRTU = require('modbus-serial');
+const ModbusRTU = require("modbus-serial");
 
 /**
  * ModbusConnection - Handles Modbus TCP and Serial connections
  * for Sigenergy solar systems
  */
 class ModbusConnection {
-	/**
-	 * @param {object} config - Connection configuration
-	 * @param {Function} logFn - Logging function
-	 */
-	constructor(config, logFn) {
-		this.config = config;
-		this.log = logFn || console;
-		this.client = new ModbusRTU();
-		this.connected = false;
-		this.connecting = false;
-		this._reconnectTimer = null;
-		this._requestQueue = [];
-		this._processing = false;
-	}
-
-	/**
-	 * Connect to Modbus device
-	 *
-	 * @returns {Promise<boolean>} Resolves to true if connection succeeded, false otherwise
-	 */
-	async connect() {
-		if (this.connecting) {
-			return false;
-		}
-		this.connecting = true;
-
-		try {
-			if (this.client.isOpen) {
-				await this.client.close();
-			}
-
-			this.client = new ModbusRTU();
-			this.client.setTimeout(this.config.timeout || 5000);
-
-			if (this.config.connectionType === 'tcp') {
-				this.log.debug(`Connecting Modbus TCP to ${this.config.tcpHost}:${this.config.tcpPort}`);
-				const connectTimeout = this.config.timeout || 5000;
-				await Promise.race([
-					this.client.connectTCP(this.config.tcpHost, {
-						port: this.config.tcpPort || 502,
-					}),
-					new Promise((_, reject) =>
-						setTimeout(
-							() => reject(new Error(`TCP connection timeout after ${connectTimeout}ms`)),
-							connectTimeout,
-						),
-					),
-				]);
-			} else {
-				// Serial RTU
-				this.log.debug(`Connecting Modbus RTU on ${this.config.serialPort}`);
-				await this.client.connectRTUBuffered(this.config.serialPort, {
-					baudRate: this.config.serialBaudRate || 9600,
-					dataBits: this.config.serialDataBits || 8,
-					parity: this.config.serialParity || 'none',
-					stopBits: this.config.serialStopBits || 1,
-				});
-			}
-
-			this.connected = true;
-			this.connecting = false;
-			this.log.info('Modbus connection established');
-			return true;
-		} catch (err) {
-			this.connected = false;
-			this.connecting = false;
-			this.log.error(`Modbus connection failed: ${err.message}`);
-			return false;
-		}
-	}
-
-	/**
-	 * Disconnect from Modbus device
-	 */
-	async disconnect() {
-		if (this._reconnectTimer) {
-			clearTimeout(this._reconnectTimer);
-			this._reconnectTimer = null;
-		}
-		if (this.client && this.client.isOpen) {
-			try {
-				await this.client.close();
-			} catch {
-				// ignore
-			}
-		}
-		this.connected = false;
-		this.log.info('Modbus disconnected');
-	}
-
-	/**
-	 * Read input registers (function code 0x04)
-	 *
-	 * @param {number} slaveId - Slave address
-	 * @param {number} address - Register start address
-	 * @param {number} qty - Number of registers to read
-	 * @returns {Promise<number[]>} Resolves with an array of register values
-	 */
-	async readInputRegisters(slaveId, address, qty) {
-		if (!this.connected) {
-			throw new Error('Not connected');
-		}
-		this.client.setID(slaveId);
-		const result = await this.client.readInputRegisters(address, qty);
-		return result.data;
-	}
-
-	/**
-	 * Read holding registers (function code 0x03)
-	 *
-	 * @param {number} slaveId - Slave address
-	 * @param {number} address - Register start address
-	 * @param {number} qty - Number of registers to read
-	 * @returns {Promise<number[]>} Resolves with an array of register values
-	 */
-	async readHoldingRegisters(slaveId, address, qty) {
-		if (!this.connected) {
-			throw new Error('Not connected');
-		}
-		this.client.setID(slaveId);
-		const result = await this.client.readHoldingRegisters(address, qty);
-		return result.data;
-	}
-
-	/**
-	 * Write single register (function code 0x06)
-	 *
-	 * @param {number} slaveId - Slave address
-	 * @param {number} address - Register address
-	 * @param {number} value - Value to write
-	 * @returns {Promise<void>} Resolves when the register has been written
-	 */
-	async writeSingleRegister(slaveId, address, value) {
-		if (!this.connected) {
-			throw new Error('Not connected');
-		}
-		this.client.setID(slaveId);
-		await this.client.writeRegister(address, value);
-	}
-
-	/**
-	 * Write multiple registers (function code 0x10)
-	 *
-	 * @param {number} slaveId - Slave address
-	 * @param {number} address - Start address
-	 * @param {number[]} values - Values array
-	 * @returns {Promise<void>} Resolves when all registers have been written
-	 */
-	async writeMultipleRegisters(slaveId, address, values) {
-		if (!this.connected) {
-			throw new Error('Not connected');
-		}
-		this.client.setID(slaveId);
-		await this.client.writeRegisters(address, values);
-	}
-
-	/**
-	 * Test connection - used from admin
-	 *
-	 * @returns {Promise<{success: boolean, message: string}>} Result object with success flag and human-readable message
-	 */
-	async testConnection() {
-		try {
-			const wasConnected = this.connected;
-			if (!this.connected) {
-				const ok = await this.connect();
-				if (!ok) {
-					return { success: false, message: 'Connection failed - check host/port settings' };
-				}
-			}
-
-			// Try reading plant system time as connectivity check
-			this.client.setID(247);
-			await this.client.readInputRegisters(30000, 2);
-
-			if (!wasConnected) {
-				await this.disconnect();
-			}
-
-			return {
-				success: true,
-				message: `Connection OK - Plant system time register accessible`,
-			};
-		} catch (err) {
-			this.connected = false;
-			return {
-				success: false,
-				message: `Connection test failed: ${err.message}`,
-			};
-		}
-	}
-
-	/**
-	 * Parse register value based on data type
-	 *
-	 * @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} Parsed and optionally scaled register value; string for STRING type
-	 */
-	static parseValue(rawData, type, gain) {
-		let raw;
-
-		switch (type) {
-			case 'U16':
-				raw = rawData[0];
-				break;
-			case 'S16':
-				raw = rawData[0];
-				if (raw > 32767) {
-					raw -= 65536;
-				}
-				break;
-			case 'U32':
-				raw = (rawData[0] << 16) | rawData[1];
-				raw = raw >>> 0; // ensure unsigned
-				break;
-			case 'S32':
-				raw = (rawData[0] << 16) | rawData[1];
-				if (raw > 2147483647) {
-					raw -= 4294967296;
-				}
-				break;
-			case 'U64':
-				// JavaScript can't handle 64-bit integers precisely, use approximation
-				raw =
-					rawData[0] * Math.pow(2, 48) +
-					rawData[1] * Math.pow(2, 32) +
-					rawData[2] * Math.pow(2, 16) +
-					rawData[3];
-				break;
-			case 'STRING': {
-				// Each register holds 2 ASCII chars
-				let str = '';
-				for (let i = 0; i < rawData.length; i++) {
-					const high = (rawData[i] >> 8) & 0xff;
-					const low = rawData[i] & 0xff;
-					if (high !== 0) {
-						str += String.fromCharCode(high);
-					}
-					if (low !== 0) {
-						str += String.fromCharCode(low);
-					}
-				}
-				return str.trim();
-			}
-			default:
-				raw = rawData[0];
-		}
-
-		if (gain && gain !== 1 && gain !== null) {
-			return raw / gain;
-		}
-		return raw;
-	}
+    /**
+     * @param {object} config - Connection configuration
+     * @param {function} logFn - Logging function
+     */
+    constructor(config, logFn) {
+        this.config = config;
+        this.log = logFn || console;
+        this.client = new ModbusRTU();
+        this.connected = false;
+        this.connecting = false;
+        this._reconnectTimer = null;
+        this._requestQueue = [];
+        this._processing = false;
+    }
+
+    /**
+     * Connect to Modbus device
+     * @returns {Promise<boolean>} Resolves to true if connection succeeded, false otherwise
+     */
+    async connect() {
+        if (this.connecting) return false;
+        this.connecting = true;
+
+        try {
+            if (this.client.isOpen) {
+                await this.client.close();
+            }
+
+            this.client = new ModbusRTU();
+            this.client.setTimeout(this.config.timeout || 5000);
+
+            if (this.config.connectionType === "tcp") {
+                this.log.debug(`Connecting Modbus TCP to ${this.config.tcpHost}:${this.config.tcpPort}`);
+                const connectTimeout = this.config.timeout || 5000;
+                await Promise.race([
+                    this.client.connectTCP(this.config.tcpHost, {
+                        port: this.config.tcpPort || 502,
+                    }),
+                    new Promise((_, reject) =>
+                        setTimeout(() => reject(new Error(`TCP connection timeout after ${connectTimeout}ms`)), connectTimeout)
+                    )
+                ]);
+            } else {
+                // Serial RTU
+                this.log.debug(`Connecting Modbus RTU on ${this.config.serialPort}`);
+                await this.client.connectRTUBuffered(this.config.serialPort, {
+                    baudRate: this.config.serialBaudRate || 9600,
+                    dataBits: this.config.serialDataBits || 8,
+                    parity: this.config.serialParity || "none",
+                    stopBits: this.config.serialStopBits || 1,
+                });
+            }
+
+            this.connected = true;
+            this.connecting = false;
+            this.log.info("Modbus connection established");
+            return true;
+        } catch (err) {
+            this.connected = false;
+            this.connecting = false;
+            this.log.error(`Modbus connection failed: ${err.message}`);
+            return false;
+        }
+    }
+
+    /**
+     * Disconnect from Modbus device
+     */
+    async disconnect() {
+        if (this._reconnectTimer) {
+            clearTimeout(this._reconnectTimer);
+            this._reconnectTimer = null;
+        }
+        if (this.client && this.client.isOpen) {
+            try {
+                await this.client.close();
+            } catch {
+                // ignore
+            }
+        }
+        this.connected = false;
+        this.log.info("Modbus disconnected");
+    }
+
+    /**
+     * Read input registers (function code 0x04)
+     * @param {number} slaveId - Slave address
+     * @param {number} address - Register start address
+     * @param {number} qty - Number of registers to read
+     * @returns {Promise<number[]>} Resolves with an array of register values
+     */
+    async readInputRegisters(slaveId, address, qty) {
+        if (!this.connected) {
+            throw new Error("Not connected");
+        }
+        this.client.setID(slaveId);
+        const result = await this.client.readInputRegisters(address, qty);
+        return result.data;
+    }
+
+    /**
+     * Read holding registers (function code 0x03)
+     * @param {number} slaveId - Slave address
+     * @param {number} address - Register start address
+     * @param {number} qty - Number of registers to read
+     * @returns {Promise<number[]>} Resolves with an array of register values
+     */
+    async readHoldingRegisters(slaveId, address, qty) {
+        if (!this.connected) {
+            throw new Error("Not connected");
+        }
+        this.client.setID(slaveId);
+        const result = await this.client.readHoldingRegisters(address, qty);
+        return result.data;
+    }
+
+    /**
+     * Write single register (function code 0x06)
+     * @param {number} slaveId - Slave address
+     * @param {number} address - Register address
+     * @param {number} value - Value to write
+     * @returns {Promise<void>} Resolves when the register has been written
+     */
+    async writeSingleRegister(slaveId, address, value) {
+        if (!this.connected) {
+            throw new Error("Not connected");
+        }
+        this.client.setID(slaveId);
+        await this.client.writeRegister(address, value);
+    }
+
+    /**
+     * Write multiple registers (function code 0x10)
+     * @param {number} slaveId - Slave address
+     * @param {number} address - Start address
+     * @param {number[]} values - Values array
+     * @returns {Promise<void>} Resolves when all registers have been written
+     */
+    async writeMultipleRegisters(slaveId, address, values) {
+        if (!this.connected) {
+            throw new Error("Not connected");
+        }
+        this.client.setID(slaveId);
+        await this.client.writeRegisters(address, values);
+    }
+
+    /**
+     * Test connection - used from admin
+     * @returns {Promise<{success: boolean, message: string}>} Result object with success flag and human-readable message
+     */
+    async testConnection() {
+        try {
+            const wasConnected = this.connected;
+            if (!this.connected) {
+                const ok = await this.connect();
+                if (!ok) {
+                    return { success: false, message: "Connection failed - check host/port settings" };
+                }
+            }
+
+            // Try reading plant system time as connectivity check
+            this.client.setID(247);
+            await this.client.readInputRegisters(30000, 2);
+
+            if (!wasConnected) {
+                await this.disconnect();
+            }
+
+            return {
+                success: true,
+                message: `Connection OK - Plant system time register accessible`
+            };
+        } catch (err) {
+            this.connected = false;
+            return {
+                success: false,
+                message: `Connection test failed: ${err.message}`
+            };
+        }
+    }
+
+    /**
+     * Parse register value based on data type
+     * @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} Parsed and optionally scaled register value; string for STRING type
+     */
+    static parseValue(rawData, type, gain) {
+        let raw;
+
+        switch (type) {
+            case "U16":
+                raw = rawData[0];
+                break;
+            case "S16":
+                raw = rawData[0];
+                if (raw > 32767) raw -= 65536;
+                break;
+            case "U32":
+                raw = (rawData[0] << 16) | rawData[1];
+                raw = raw >>> 0; // ensure unsigned
+                break;
+            case "S32":
+                raw = (rawData[0] << 16) | rawData[1];
+                if (raw > 2147483647) raw -= 4294967296;
+                break;
+            case "U64":
+                // JavaScript can't handle 64-bit integers precisely, use approximation
+                raw = rawData[0] * Math.pow(2, 48) +
+                      rawData[1] * Math.pow(2, 32) +
+                      rawData[2] * Math.pow(2, 16) +
+                      rawData[3];
+                break;
+            case "STRING": {
+                // Each register holds 2 ASCII chars
+                let str = "";
+                for (let i = 0; i < rawData.length; i++) {
+                    const high = (rawData[i] >> 8) & 0xFF;
+                    const low = rawData[i] & 0xFF;
+                    if (high !== 0) str += String.fromCharCode(high);
+                    if (low !== 0) str += String.fromCharCode(low);
+                }
+                return str.trim();
+            }
+            default:
+                raw = rawData[0];
+        }
+
+        if (gain && gain !== 1 && gain !== null) {
+            return raw / gain;
+        }
+        return raw;
+    }
 }
 
 module.exports = ModbusConnection;