node-red-contrib-symi-modbus 2.8.9 → 2.9.1

package/README.md

@@ -888,7 +888,31 @@ HomeKit网桥节点无需输入消息，自动同步主站配置和状态。
 
 ## 版本信息
 
-**当前版本**: v2.8.9 (2025-11-13)
+**当前版本**: v2.9.1 (2025-12-13)
+
+**v2.9.1 更新内容**：
+- **重要修复**：RS-485开关指示灯同步问题
+  - 修复TCP粘包导致的协议帧解析失败问题
+  - 新增`parseAllFrames`函数，正确处理多个帧粘在一起的情况
+  - 根据协议的`dataLen`字段精确提取帧边界，确保每个帧都被正确解析
+- **重要修复**：Modbus控制看板部署失效问题
+  - 修复主站更新后重新部署导致看板无法正确显示的问题
+  - 部署时自动清空并重新初始化状态缓存
+  - 新增`refresh` API，点击刷新按钮从主站获取真实继电器状态
+- **优化**：控制看板刷新功能
+  - 刷新按钮现在会主动从主站获取最新的继电器状态
+  - 确保显示的状态与实际继电器状态同步
+- **优化**：指示灯反馈队列间隔调整为50ms
+  - TCP/串口写入间隔从40ms调整为50ms
+  - 触发源面板优先处理，确保按键响应流畅
+  - 按线圈顺序陆续反馈所有有动作的继电器指示灯
+
+**v2.9.0 更新内容**：
+- **重要修复**：一个按键现在可以控制多个不同从站的继电器
+  - 修复了全局防抖机制导致的问题：之前一个开关配置控制多个从站时，只有第一个从站会执行
+  - 现在支持：一个物理按键同时控制从站0A和0B的同一线圈，两个都会正确执行
+- 优化防抖key设计，包含目标从站地址，确保不同目标互不影响
+- RS-485开关、Mesh开关、Mesh场景模式均已修复
 
 **v2.8.9 更新内容**：
 - 新增Mesh开关无线模式支持，适用于场景触发按键

package/nodes/lightweight-protocol.js

@@ -201,7 +201,7 @@ module.exports = {
     },
     
     /**
-     * 解析接收到的协议帧
+     * 解析接收到的协议帧（支持粘包处理）
      * @param {Buffer} buffer - 接收到的数据
      * @returns {Object|null} 解析结果或null
      */
@@ -210,42 +210,172 @@ module.exports = {
             return null;
         }
         
-        // 检查帧头和帧尾
-        if (buffer[0] !== this.FRAME_HEADER || buffer[buffer.length - 1] !== this.FRAME_TAIL) {
-            return null;
+        // 查找帧头位置
+        let startIndex = -1;
+        for (let i = 0; i < buffer.length; i++) {
+            if (buffer[i] === this.FRAME_HEADER) {
+                startIndex = i;
+                break;
+            }
+        }
+        
+        if (startIndex === -1) {
+            return null; // 没有找到帧头
+        }
+        
+        // 从帧头开始检查是否有足够的数据
+        if (buffer.length - startIndex < 15) {
+            return null; // 数据不完整
+        }
+        
+        // 读取数据长度字段（第4个字节，索引3）
+        const dataLen = buffer[startIndex + 3];
+        
+        // 检查帧长度是否合理（数据长度就是整帧长度）
+        if (dataLen < 15 || dataLen > 64) {
+            return null; // 长度不合理
+        }
+        
+        // 检查是否有完整的帧数据
+        if (buffer.length - startIndex < dataLen) {
+            return null; // 数据不完整
+        }
+        
+        // 提取单个帧
+        const frameBuffer = buffer.slice(startIndex, startIndex + dataLen);
+        
+        // 检查帧尾
+        if (frameBuffer[frameBuffer.length - 1] !== this.FRAME_TAIL) {
+            return null; // 帧尾不正确
         }
         
         // 验证CRC8校验
-        const receivedCRC = buffer[buffer.length - 2];
-        const calculatedCRC = this.calculateCRC8(buffer, buffer.length);
+        const receivedCRC = frameBuffer[frameBuffer.length - 2];
+        const calculatedCRC = this.calculateCRC8(frameBuffer, frameBuffer.length);
         if (receivedCRC !== calculatedCRC) {
             return null; // 校验失败
         }
         
         // 解析数据
         const frame = {
-            localAddr: buffer[1],
-            dataType: buffer[2],
-            dataLen: buffer[3],
-            deviceType: buffer[4],
-            brandID: buffer[5],
-            deviceAddr: buffer[6],
-            channel: buffer[7],
-            roomNo: buffer[8],
-            roomType: buffer[9],
-            roomID: buffer[10],
-            opCode: buffer[11],
-            opInfo: []
+            localAddr: frameBuffer[1],
+            dataType: frameBuffer[2],
+            dataLen: frameBuffer[3],
+            deviceType: frameBuffer[4],
+            brandID: frameBuffer[5],
+            deviceAddr: frameBuffer[6],
+            channel: frameBuffer[7],
+            roomNo: frameBuffer[8],
+            roomType: frameBuffer[9],
+            roomID: frameBuffer[10],
+            opCode: frameBuffer[11],
+            opInfo: [],
+            frameLength: dataLen,  // 记录帧长度，用于粘包处理
+            startIndex: startIndex  // 记录帧起始位置，用于粘包处理
         };
         
         // 提取操作信息
-        for (let i = 12; i < buffer.length - 2; i++) {
-            frame.opInfo.push(buffer[i]);
+        for (let i = 12; i < frameBuffer.length - 2; i++) {
+            frame.opInfo.push(frameBuffer[i]);
         }
         
         return frame;
     },
     
+    /**
+     * 解析所有协议帧（处理粘包，返回所有帧）
+     * @param {Buffer} buffer - 接收到的数据（可能包含多个帧）
+     * @returns {Array} 解析出的所有帧数组
+     */
+    parseAllFrames: function(buffer) {
+        const frames = [];
+        if (!buffer || buffer.length < 15) {
+            return frames;
+        }
+        
+        let offset = 0;
+        let maxIterations = 10; // 防止无限循环
+        
+        while (offset < buffer.length && maxIterations > 0) {
+            maxIterations--;
+            
+            // 查找下一个帧头
+            let startIndex = -1;
+            for (let i = offset; i < buffer.length; i++) {
+                if (buffer[i] === this.FRAME_HEADER) {
+                    startIndex = i;
+                    break;
+                }
+            }
+            
+            if (startIndex === -1) {
+                break; // 没有更多帧头
+            }
+            
+            // 检查是否有足够的数据读取长度字段
+            if (buffer.length - startIndex < 4) {
+                break; // 数据不完整
+            }
+            
+            // 读取数据长度
+            const dataLen = buffer[startIndex + 3];
+            
+            // 检查帧长度是否合理
+            if (dataLen < 15 || dataLen > 64) {
+                offset = startIndex + 1; // 跳过这个字节继续搜索
+                continue;
+            }
+            
+            // 检查是否有完整的帧
+            if (buffer.length - startIndex < dataLen) {
+                break; // 数据不完整
+            }
+            
+            // 提取帧数据
+            const frameBuffer = buffer.slice(startIndex, startIndex + dataLen);
+            
+            // 检查帧尾
+            if (frameBuffer[frameBuffer.length - 1] !== this.FRAME_TAIL) {
+                offset = startIndex + 1; // 跳过继续搜索
+                continue;
+            }
+            
+            // 验证CRC
+            const receivedCRC = frameBuffer[frameBuffer.length - 2];
+            const calculatedCRC = this.calculateCRC8(frameBuffer, frameBuffer.length);
+            if (receivedCRC !== calculatedCRC) {
+                offset = startIndex + 1; // CRC错误，跳过继续搜索
+                continue;
+            }
+            
+            // 解析帧
+            const frame = {
+                localAddr: frameBuffer[1],
+                dataType: frameBuffer[2],
+                dataLen: frameBuffer[3],
+                deviceType: frameBuffer[4],
+                brandID: frameBuffer[5],
+                deviceAddr: frameBuffer[6],
+                channel: frameBuffer[7],
+                roomNo: frameBuffer[8],
+                roomType: frameBuffer[9],
+                roomID: frameBuffer[10],
+                opCode: frameBuffer[11],
+                opInfo: []
+            };
+            
+            // 提取操作信息
+            for (let i = 12; i < frameBuffer.length - 2; i++) {
+                frame.opInfo.push(frameBuffer[i]);
+            }
+            
+            frames.push(frame);
+            offset = startIndex + dataLen; // 移动到下一帧
+        }
+        
+        return frames;
+    },
+    
     /**
      * 检测是否是按键按下事件
      * @param {Object} frame - 解析后的帧

package/nodes/modbus-dashboard.html

@@ -237,13 +237,38 @@
                 }
             });
 
-            // 添加刷新按钮
+            // 添加刷新按钮（从主站重新获取真实状态）
             $("#btn-refresh-dashboard").on("click", function() {
-                stopPolling();
-                renderDashboard();
-                if (masterNodeSelect.val()) {
-                    startPolling();
+                var masterNodeId = masterNodeSelect.val();
+                if (!masterNodeId) {
+                    RED.notify('请先选择主站节点', 'warning');
+                    return;
                 }
+
+                stopPolling();
+
+                // 调用refresh API从主站重新获取真实状态
+                $.ajax({
+                    url: '/modbus-dashboard/refresh/' + masterNodeId,
+                    method: 'POST',
+                    success: function(data) {
+                        if (data && data.states) {
+                            // 更新本地缓存
+                            stateCache = Object.assign({}, data.states);
+                            console.log('状态已从主站刷新:', Object.keys(stateCache).length + '个线圈');
+                        }
+                        // 重新渲染UI
+                        renderDashboard();
+                        startPolling();
+                    },
+                    error: function(err) {
+                        console.error('刷新状态失败:', err);
+                        RED.notify('刷新状态失败: ' + (err.responseJSON ? err.responseJSON.error : err.statusText), 'error');
+                        // 即使失败也重新渲染
+                        renderDashboard();
+                        startPolling();
+                    }
+                });
             });
 
             // 初始渲染

package/nodes/modbus-dashboard.js

@@ -3,6 +3,9 @@ module.exports = function(RED) {
 
     // 全局状态缓存（所有dashboard节点共享）
     var globalStateCache = {};
+    
+    // 跟踪已注册的dashboard节点（用于部署时重新初始化）
+    var registeredDashboards = new Map();
 
     function ModbusDashboardNode(config) {
         RED.nodes.createNode(this, config);
@@ -14,6 +17,9 @@ module.exports = function(RED) {
             masterNode: config.masterNode
         };
 
+        // 保存主站节点ID用于后续引用
+        node.masterNodeId = config.masterNode;
+
         // 获取主站节点
         var masterNode = RED.nodes.getNode(node.config.masterNode);
         if (!masterNode) {
@@ -22,6 +28,17 @@ module.exports = function(RED) {
             return;
         }
 
+        // 部署时清空该主站相关的缓存并重新初始化
+        // 这样确保每次部署后状态从主站重新获取
+        if (masterNode.config && masterNode.config.slaves) {
+            masterNode.config.slaves.forEach(function(slave) {
+                for (var coil = slave.coilStart; coil <= slave.coilEnd; coil++) {
+                    var key = slave.address + "_" + coil;
+                    delete globalStateCache[key];
+                }
+            });
+        }
+
         // 监听主站状态更新事件
         node.stateUpdateHandler = function(data) {
             if (!data || typeof data !== 'object') {
@@ -48,6 +65,12 @@ module.exports = function(RED) {
             });
         }
 
+        // 注册到全局跟踪
+        registeredDashboards.set(node.id, {
+            masterNodeId: node.masterNodeId,
+            node: node
+        });
+
         // 更新节点状态
         node.status({fill: "green", shape: "dot", text: "监控中"});
 
@@ -56,6 +79,7 @@ module.exports = function(RED) {
             if (masterNode && node.stateUpdateHandler) {
                 masterNode.removeListener('stateUpdate', node.stateUpdateHandler);
             }
+            registeredDashboards.delete(node.id);
             node.status({});
         });
     }
@@ -87,6 +111,45 @@ module.exports = function(RED) {
         });
     });
 
+    // HTTP API：刷新状态（从主站重新获取真实状态）
+    RED.httpAdmin.post('/modbus-dashboard/refresh/:masterNodeId', function(req, res) {
+        var masterNodeId = req.params.masterNodeId;
+        var masterNode = RED.nodes.getNode(masterNodeId);
+
+        if (!masterNode) {
+            res.status(404).json({error: '主站节点不存在'});
+            return;
+        }
+
+        // 清空该主站相关的缓存
+        if (masterNode.config && masterNode.config.slaves) {
+            masterNode.config.slaves.forEach(function(slave) {
+                for (var coil = slave.coilStart; coil <= slave.coilEnd; coil++) {
+                    var key = slave.address + "_" + coil;
+                    delete globalStateCache[key];
+                }
+            });
+        }
+
+        // 从主站重新获取当前状态
+        if (masterNode.deviceStates) {
+            Object.keys(masterNode.deviceStates).forEach(function(slaveId) {
+                var deviceState = masterNode.deviceStates[slaveId];
+                if (deviceState && deviceState.coils) {
+                    deviceState.coils.forEach(function(value, coil) {
+                        var key = slaveId + "_" + coil;
+                        globalStateCache[key] = value;
+                    });
+                }
+            });
+        }
+
+        res.json({
+            success: true,
+            states: globalStateCache
+        });
+    });
+
     // HTTP API：发送控制命令
     RED.httpAdmin.post('/modbus-dashboard/control', function(req, res) {
         var slave = parseInt(req.body.slave);

package/nodes/modbus-master.js

@@ -150,7 +150,7 @@ module.exports = function(RED) {
         // 写入队列机制（确保所有写入操作串行执行，避免锁竞争）
         node.writeQueue = []; // 写入队列
         node.isProcessingWrite = false; // 是否正在处理写入队列
-        node.writeQueueInterval = 40; // 写入队列处理间隔（40ms，确保总线稳定，避免数据丢失）
+        node.writeQueueInterval = 50; // 写入队列处理间隔（50ms，厂家推荐间隔，确保总线稳定）
 
         // 定期清理机制（每小时清理一次，防止内存泄漏）
         node.cleanupTimer = setInterval(() => {

package/nodes/modbus-slave-switch.js

@@ -738,7 +738,7 @@ module.exports = function(RED) {
             RED.events.on('modbus:coilStateChanged', node.stateChangeListener);
         };
 
-        // 处理RS-485接收到的数据
+        // 处理RS-485接收到的数据（支持TCP粘包处理）
         node.handleRs485Data = function(data) {
             try {
                 // 如果是Mesh模式，使用Mesh协议解析
@@ -747,76 +747,80 @@ module.exports = function(RED) {
                     return;
                 }
 
-                // 解析轻量级协议帧（RS-485模式）
-                const frame = protocol.parseFrame(data);
-                if (!frame) {
+                // 使用parseAllFrames处理粘包，解析所有帧
+                const frames = protocol.parseAllFrames(data);
+                if (!frames || frames.length === 0) {
                     return; // 静默忽略无效帧
                 }
 
-                // 忽略 REPORT (0x04) 类型的帧（这是面板对我们指令的确认，不是按键事件）
-                // 只处理 SET (0x03) 类型的帧（真正的按键事件）
-                if (frame.dataType === 0x04) {
-                    return; // 静默忽略REPORT帧
-                }
-
-                // 检测是否是按键按下事件
-                const buttonEvent = protocol.detectButtonPress(frame);
-                if (!buttonEvent) {
-                    return; // 静默忽略非按键事件
-                }
+                // 处理每一个帧
+                for (const frame of frames) {
+                    // 忽略 REPORT (0x04) 类型的帧（这是面板对我们指令的确认，不是按键事件）
+                    // 只处理 SET (0x03) 类型的帧（真正的按键事件）
+                    if (frame.dataType === 0x04) {
+                        continue; // 静默忽略REPORT帧
+                    }
 
-                // 计算实际按键编号（Symi协议公式）
-                // 例如：devAddr=1,channel=1→按键1；devAddr=2,channel=1→按键5
-                const actualButtonNumber = buttonEvent.deviceAddr * 4 - 4 + buttonEvent.channel;
-
-                // 检查是否是我们监听的开关面板和按钮
-                // switchId对应本地地址（物理面板地址）
-                // buttonNumber对应实际按键编号（1-8）
-                if (buttonEvent.raw.localAddr === node.config.switchId && actualButtonNumber === node.config.buttonNumber) {
-                    // 保存原始的deviceAddr和channel，用于LED反馈
-                    const oldDeviceAddr = node.buttonDeviceAddr;
-                    const oldChannel = node.buttonChannel;
-                    node.buttonDeviceAddr = buttonEvent.deviceAddr;
-                    node.buttonChannel = buttonEvent.channel;
-
-                    // 输出调试日志，对比计算值和实际值
-                    if (oldDeviceAddr !== buttonEvent.deviceAddr || oldChannel !== buttonEvent.channel) {
-                        node.log(`按键事件更新LED反馈地址：计算值(设备${oldDeviceAddr} 通道${oldChannel}) → 实际值(设备${buttonEvent.deviceAddr} 通道${buttonEvent.channel})`);
+                    // 检测是否是按键按下事件
+                    const buttonEvent = protocol.detectButtonPress(frame);
+                    if (!buttonEvent) {
+                        continue; // 静默忽略非按键事件
                     }
 
-                    // 判断按钮类型：优先使用协议解析结果，其次使用配置
-                    const isSceneMode = buttonEvent.isSceneMode ||
-                                       node.config.buttonType === 'scene' ||
-                                       buttonEvent.deviceType === 0x07;
+                    // 计算实际按键编号（Symi协议公式）
+                    // 例如：devAddr=1,channel=1→按键1；devAddr=2,channel=1→按键5
+                    const actualButtonNumber = buttonEvent.deviceAddr * 4 - 4 + buttonEvent.channel;
+
+                    // 检查是否是我们监听的开关面板和按钮
+                    // switchId对应本地地址（物理面板地址）
+                    // buttonNumber对应实际按键编号（1-8）
+                    if (buttonEvent.raw.localAddr === node.config.switchId && actualButtonNumber === node.config.buttonNumber) {
+                        // 保存原始的deviceAddr和channel，用于LED反馈
+                        const oldDeviceAddr = node.buttonDeviceAddr;
+                        const oldChannel = node.buttonChannel;
+                        node.buttonDeviceAddr = buttonEvent.deviceAddr;
+                        node.buttonChannel = buttonEvent.channel;
+
+                        // 输出调试日志，对比计算值和实际值
+                        if (oldDeviceAddr !== buttonEvent.deviceAddr || oldChannel !== buttonEvent.channel) {
+                            node.log(`按键事件更新LED反馈地址：计算值(设备${oldDeviceAddr} 通道${oldChannel}) → 实际值(设备${buttonEvent.deviceAddr} 通道${buttonEvent.channel})`);
+                        }
 
-                    // 全局防抖：防止多个节点重复处理同一个按键
-                    const debounceKey = `${node.config.switchId}-${node.config.buttonNumber}`;
-                    const now = Date.now();
-                    const lastTriggerTime = globalDebounceCache.get(debounceKey) || 0;
+                        // 判断按钮类型：优先使用协议解析结果，其次使用配置
+                        const isSceneMode = buttonEvent.isSceneMode ||
+                                           node.config.buttonType === 'scene' ||
+                                           buttonEvent.deviceType === 0x07;
 
-                    // 全局防抖：200ms内只触发一次（开关和场景统一防抖时间）
-                    if (now - lastTriggerTime < 200) {
-                        return; // 静默忽略重复触发
-                    }
-                    globalDebounceCache.set(debounceKey, now);
+                        // 全局防抖：防止同一个按键的同一个目标重复触发
+                        // 包含targetSlaveAddress，允许一个按键控制多个不同从站的继电器
+                        const debounceKey = `${node.config.switchId}-${node.config.buttonNumber}-${node.config.targetSlaveAddress}`;
+                        const now = Date.now();
+                        const lastTriggerTime = globalDebounceCache.get(debounceKey) || 0;
 
-                    // 设置触发源（用于优先队列）
-                    if (node.serialPortConfig && typeof node.serialPortConfig.setTriggerSource === 'function') {
-                        node.serialPortConfig.setTriggerSource(node.config.switchId);
-                    }
+                        // 全局防抖：200ms内只触发一次（开关和场景统一防抖时间）
+                        if (now - lastTriggerTime < 200) {
+                            continue; // 静默忽略重复触发
+                        }
+                        globalDebounceCache.set(debounceKey, now);
 
-                    if (isSceneMode) {
-                        node.debug(`场景触发: 面板${node.config.switchId} 按键${node.config.buttonNumber} (opInfo=0x${buttonEvent.opInfo.toString(16).toUpperCase()})`);
-                        // 场景模式：切换状态（每次触发时翻转）
-                        node.currentState = !node.currentState;
-                        node.sendMqttCommand(node.currentState);
-                    } else {
-                        // 开关模式：根据状态发送ON/OFF
-                        node.debug(`开关${buttonEvent.state ? 'ON' : 'OFF'}: 面板${node.config.switchId} 按键${node.config.buttonNumber}`);
-                        node.sendMqttCommand(buttonEvent.state);
+                        // 设置触发源（用于优先队列）
+                        if (node.serialPortConfig && typeof node.serialPortConfig.setTriggerSource === 'function') {
+                            node.serialPortConfig.setTriggerSource(node.config.switchId);
+                        }
+
+                        if (isSceneMode) {
+                            node.debug(`场景触发: 面板${node.config.switchId} 按键${node.config.buttonNumber} (opInfo=0x${buttonEvent.opInfo.toString(16).toUpperCase()})`);
+                            // 场景模式：切换状态（每次触发时翻转）
+                            node.currentState = !node.currentState;
+                            node.sendMqttCommand(node.currentState);
+                        } else {
+                            // 开关模式：根据状态发送ON/OFF
+                            node.debug(`开关${buttonEvent.state ? 'ON' : 'OFF'}: 面板${node.config.switchId} 按键${node.config.buttonNumber}`);
+                            node.sendMqttCommand(buttonEvent.state);
+                        }
                     }
+                    // 不匹配的节点静默忽略，不输出任何日志
                 }
-                // 不匹配的节点静默忽略，不输出任何日志
             } catch (err) {
                 node.error(`解析RS-485数据失败: ${err.message}`);
             }
@@ -873,7 +877,8 @@ module.exports = function(RED) {
                 // 场景模式：跳过LED反馈锁和状态缓存检查，直接触发继电器
                 if (isSceneMode) {
                     // 场景模式：全局防抖（200ms内只触发一次）
-                    const debounceKey = `mesh-scene-${node.config.meshShortAddress}-${node.config.meshButtonNumber}`;
+                    // 包含targetSlaveAddress，允许一个按键控制多个不同从站的继电器
+                    const debounceKey = `mesh-scene-${node.config.meshShortAddress}-${node.config.meshButtonNumber}-${node.config.targetSlaveAddress}`;
                     const lastTriggerTime = globalDebounceCache.get(debounceKey) || 0;
 
                     if (now - lastTriggerTime < 200) {
@@ -912,8 +917,9 @@ module.exports = function(RED) {
                         return;
                     }
 
-                    // 第四步：全局防抖：防止多个节点重复处理同一个按键
-                    const debounceKey = `mesh-${node.config.meshShortAddress}-${node.config.meshButtonNumber}`;
+                    // 第四步：全局防抖：防止同一个按键的同一个目标重复触发
+                    // 包含targetSlaveAddress，允许一个按键控制多个不同从站的继电器
+                    const debounceKey = `mesh-${node.config.meshShortAddress}-${node.config.meshButtonNumber}-${node.config.targetSlaveAddress}`;
                     now = Date.now();
                     const lastTriggerTime = globalDebounceCache.get(debounceKey) || 0;
 

package/nodes/serial-port-config.js

@@ -452,9 +452,9 @@ module.exports = function(RED) {
                             });
                         });
 
-                        // TCP写入间隔（40ms，确保指示灯反馈稳定）
+                        // TCP写入间隔（50ms，厂家推荐间隔，确保指示灯反馈稳定）
                         if (node.writeQueue.length > 0) {
-                            await new Promise(resolve => setTimeout(resolve, 40));
+                            await new Promise(resolve => setTimeout(resolve, 50));
                         }
                     } else {
                         if (!node.connection.isOpen) {
@@ -486,9 +486,9 @@ module.exports = function(RED) {
                             });
                         });
 
-                        // 串口写入间隔（40ms，确保指示灯反馈稳定）
+                        // 串口写入间隔（50ms，厂家推荐间隔，确保指示灯反馈稳定）
                         if (node.writeQueue.length > 0) {
-                            await new Promise(resolve => setTimeout(resolve, 40));
+                            await new Promise(resolve => setTimeout(resolve, 50));
                         }
                     }
                 } catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-symi-modbus",
-  "version": "2.8.9",
+  "version": "2.9.1",
   "description": "Node-RED Modbus节点，支持TCP/串口通信、串口自动搜索、多设备轮询、可选MQTT集成（支持纯本地模式和MQTT模式）、Home Assistant自动发现、HomeKit网桥、可视化控制看板、自定义协议转换和物理开关面板双向同步，工控机长期稳定运行",
   "main": "nodes/modbus-master.js",
   "scripts": {