iobroker.sigenergy 1.2.5 → 1.3.3

package/README.md

@@ -156,6 +156,15 @@ MIT License — Copyright (c) 2025 ioBroker Community
 ---
 
 ## Changelog
+### 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
+
 ### 1.2.5 (2026-03-12)
 * (ssbingo) fixes
 
@@ -292,3 +301,7 @@ MIT License — Copyright (c) 2025 ioBroker Community
 - 🇷🇺 [Документация на русском](doc/ru/README.md)
 - 🇳🇱 [Nederlandse documentatie](doc/nl/README.md)
 - 🇫🇷 [Documentation française](doc/fr/README.md)
+- 🇮🇹 [Documentazione italiana](doc/it/README.md)
+- 🇪🇸 [Documentación en español](doc/es/README.md)
+- 🇵🇱 [Dokumentacja polska](doc/pl/README.md)
+- 🇵🇹 [Documentação portuguesa](doc/pt/README.md)

package/io-package.json

@@ -1,20 +1,20 @@
 {
   "common": {
     "name": "sigenergy",
-    "version": "1.2.5",
+    "version": "1.3.3",
     "news": {
-      "1.2.5": {
-        "en": "fixes",
-        "de": "Fehlerbehebungen",
-        "ru": "Исправления",
-        "pt": "Correções",
-        "nl": "Bugfixes",
-        "fr": "Corrections",
-        "it": "Correzioni",
-        "es": "Correcciones",
-        "pl": "Poprawki",
-        "uk": "Виправлення",
-        "zh-cn": "修复"
+      "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警告"
       }
     },
     "titleLang": {

package/lib/modbus.js

@@ -1,245 +1,267 @@
-"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>}
-     */
-    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 (e) {
-                // 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[]>}
-     */
-    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[]>}
-     */
-    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>}
-     */
-    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>}
-     */
-    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}>}
-     */
-    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);
-            const result = 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}
-     */
-    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;