node-red-contrib-symi-modbus 2.9.13 → 2.9.14

package/README.md

@@ -950,32 +950,31 @@ HomeKit网桥节点无需输入消息，自动同步主站配置和状态。
 
 ## 版本历史
 
-### 2.9.13
-- **全量审计与生产环境验证**：完成了对整个代码库的深度审计，确认多主站实例隔离、内存自动清理和防死锁机制在复杂生产环境下 7x24 小时稳定运行。
-- **文档同步与规范化**：全面修复并补充了从站开关节点（modbus-slave-switch）的内置帮助文档，增加了 Mesh 模式和无线模式的详细配置说明。
-- **架构说明增强**：重构了 README 的核心特性章节，详细披露了智能分包/粘包处理、内存安全策略等工业级稳定性技术细节。
-- **发布质量保障**：完成了严格的本地安装测试和 npm pack 验证，确保发布包结构完整且生产环境安装无误。
-
-### 2.9.12
-- **Mesh 持久化优化**：Mesh 设备列表发现后自动保存到磁盘，网关离线或 Node-RED 重启后依然保留已配置的实体，无需重新扫描。
-- **协议拼包算法优化**：全面重构了 RS-485 拼包解析逻辑，引入循环缓冲区处理机制，完美解决工控机串口常见的**沾包、分包**问题，确保 Symi、Clowire 和 Mesh 协议在复杂电气环境下的通讯稳定性。
-- **门禁过滤功能**：在“继电器输出”节点中支持门禁 ID 过滤，支持“0=不过滤”模式，方便门禁联动场景。
-- **联动事件增强**：修复了从站开关节点未触发 `modbus:buttonPressed` 内部事件的问题，现在“继电器输出”节点可以完美绑定到 Symi/Clowire/Mesh 开关。
-- **稳定性提升**：优化了 Mesh 模式下的 LED 反馈逻辑和状态同步防抖。
-
-### 2.9.11
-- 增加对 Clowire (克伦威尔) 协议的支持。
-- 优化了 RS-485 拼包算法，解决工控机串口分包导致的数据解析失败。
+**v2.9.14 更新内容**：
+- **全协议指示灯同步优化**：重构了从站开关节点（modbus-slave-switch）的状态同步逻辑，将原有的 Mesh 模式高性能 LED 反馈机制扩展至所有协议（Symi、Clowire、RS-485），显著提升了群控场景下指示灯同步的准确率。
+- **非连续线圈配置支持**：优化了继电器控制逻辑，支持按键与非连续、跨从站线圈的灵活绑定，不再受限于线圈序号必须连续的物理约束。
+- **全局并发锁机制改进**：改进了全局 LED 反馈锁（Global Lock）机制，将锁定时间优化为 150ms，并引入了更精准的面板状态缓存（panelKey-based caching），有效解决了高频群控时个别按键指示灯同步失败的问题。
+- **稳定性与防抖增强**：统一了所有协议的指示灯同步防抖时间为 50ms，确保在继电器频繁动作时总线通信的有序与稳定。
+
+**v2.9.13 更新内容**：
+- **全量审计与生产环境验证**：确认多主站隔离、内存自动清理和防死锁机制稳定运行。
+- **文档规范化**：修复并补充了从站开关节点的内置帮助文档，增加 Mesh 和无线模式说明。
+- **发布质量保障**：完成严格的本地安装测试和 npm pack 验证。
+
+**v2.9.12 更新内容**：
+- **Mesh 持久化**：设备列表自动保存到磁盘，重启不丢失。
+- **RS-485 沾包处理**：重构拼包逻辑，引入循环缓冲区处理沾包、分包问题。
+- **门禁过滤**：继电器输出节点支持门禁 ID 过滤。
+- **事件联动**：修复 `modbus:buttonPressed` 事件，支持开关与继电器输出节点联动。
+
+**v2.9.11 更新内容**：
+- **Clowire 支持**：增加对克伦威尔协议的支持。
+- **拼包算法优化**：进一步解决工控机串口高频分包问题。
 
 **v2.9.10 更新内容**：
-- **日志系统优化 (解决日志占用问题)**：
-  - **彻底静默重连日志**：将 TCP/串口连接过程中的 `node.error` 降级为 `node.log` 或 `node.debug`，不再发送到 Node-RED 调试面板（Debug Tab），彻底解决重连期间日志刷屏问题。
-  - **智能过滤**：相同的连接错误在重试期间不再重复输出日志（每 10 分钟仅后台提醒一次）。
-  - **状态栏增强**：将具体错误信息（如“拒绝连接”、“串口不存在”）直接显示在节点状态文字中，无需查看日志即可掌握连接状况。
-- **多主站配置隔离修复**：
-  - 修复了多个Modbus主站节点在编辑时配置互相干扰的问题（通过Scoped Event Handler实现）
-  - 确保每个主站节点的从站列表配置完全独立，互不影响
-- **从站开关主站关联**：
+- **日志静默优化**：重连期间不再刷屏调试面板，错误信息显示在节点状态栏。
+- **多主站配置隔离**：修复多个主站节点配置互相干扰的问题。
+- **稳定性增强**：优化了内存管理和重连机制。
   - **新增关联主站功能**：从站开关节点新增"关联主站"配置项
   - **多主站支持**：支持选择特定的主站节点，解决多主站环境下相同从站地址冲突的问题
   - **智能过滤**：从站开关只响应关联主站的状态更新，避免误触发

package/nodes/modbus-slave-switch.js

@@ -609,171 +609,111 @@ module.exports = function(RED) {
                     node.debug(`收到首次轮询状态同步：从站${slave} 线圈${coil} = ${value ? 'ON' : 'OFF'}`);
                 }
 
-                // Mesh模式：监听所有绑定到同一个面板的线圈，更新全局状态缓存
-                if (node.config.buttonType === 'mesh' && slave === node.config.targetSlaveAddress) {
-                    const meshAddr = node.config.meshShortAddress;
-                    if (!meshDeviceStates.has(meshAddr)) {
-                        // 初始化状态数组（全部设为null，表示未知状态）
-                        meshDeviceStates.set(meshAddr, new Array(node.config.meshTotalButtons).fill(null));
+                // 核心变量准备
+                const isMesh = (node.config.buttonType === 'mesh');
+                const panelKey = isMesh ? node.config.meshShortAddress : node.config.switchId;
+                const isButtonPress = (triggerSource === 'button-press' || triggerSource === 'scene-trigger');
+                const isInit = (triggerSource === 'init' || data.source === 'init');
+                const isRelayControl = !isButtonPress && !isInit;
+
+                // 更新全局状态缓存（用于所有协议的LED反馈优化）
+                if (panelKey) {
+                    if (!meshDeviceStates.has(panelKey)) {
+                        const totalButtons = isMesh ? node.config.meshTotalButtons : 8; // 非Mesh默认支持8路
+                        meshDeviceStates.set(panelKey, new Array(totalButtons).fill(null));
+                    }
+                    const states = meshDeviceStates.get(panelKey);
+                    
+                    // 计算按键索引
+                    let buttonIndex = -1;
+                    if (isMesh) {
+                        const baseCoil = node.config.targetCoilNumber - (node.config.meshButtonNumber - 1);
+                        buttonIndex = coil - baseCoil;
+                    } else if (slave === node.config.targetSlaveAddress) {
+                        // RS-485模式：假设线圈是连续的，或者通过targetCoilNumber定位
+                        // 这里我们优先处理当前节点绑定的按键
+                        if (coil === node.config.targetCoilNumber) {
+                            buttonIndex = node.config.buttonNumber - 1;
+                        }
                     }
 
-                    // 计算线圈对应的按钮编号（线圈0→按钮1，线圈1→按钮2，...）
-                    const baseCoil = node.config.targetCoilNumber - (node.config.meshButtonNumber - 1);
-                    const buttonIndex = coil - baseCoil;
-
-                    // 检查是否是同一个面板的线圈（线圈范围：baseCoil ~ baseCoil+totalButtons-1）
-                    if (buttonIndex >= 0 && buttonIndex < node.config.meshTotalButtons) {
-                        // 更新全局状态缓存
-                        const states = meshDeviceStates.get(meshAddr);
+                    if (buttonIndex >= 0 && buttonIndex < states.length) {
                         const oldValue = states[buttonIndex];
                         states[buttonIndex] = value;
                         const stateChanged = (oldValue !== value);
 
-                        // 核心修复：区分按键触发和继电器直接控制
-                        const isButtonPress = (triggerSource === 'button-press');
-                        const isInit = (triggerSource === 'init' || data.source === 'init');
-                        const isRelayControl = !isButtonPress && !isInit;
-
-                        // 继电器控制：所有同一面板的线圈变化都会重置定时器（只有按钮1节点负责）
-                        if (isRelayControl && stateChanged && node.config.meshButtonNumber === 1) {
+                        // 继电器控制：面板关联的任何线圈变化都会触发LED同步
+                        if (isRelayControl && stateChanged) {
                             const now = Date.now();
-
-                            // 获取或创建定时器对象
-                            let timerObj = meshLedDebounceTimers.get(meshAddr);
+                            let timerObj = meshLedDebounceTimers.get(panelKey);
 
                             if (!timerObj) {
-                                // 首次变化：创建新的定时器对象
                                 timerObj = {
                                     timer: null,
                                     nodeId: node.id,
                                     serialPortConfig: node.serialPortConfig,
-                                    firstChangeTime: now,  // 记录第一次变化的时间
-                                    changeCount: 0  // 记录变化次数
+                                    firstChangeTime: now,
+                                    changeCount: 0
                                 };
-                                meshLedDebounceTimers.set(meshAddr, timerObj);
+                                meshLedDebounceTimers.set(panelKey, timerObj);
                             }
 
-                            // 增加变化计数
                             timerObj.changeCount++;
+                            if (timerObj.timer) clearTimeout(timerObj.timer);
 
-                            // 清除之前的定时器
-                            if (timerObj.timer) {
-                                clearTimeout(timerObj.timer);
-                            }
-
-                            // 设置新的定时器：100ms内如果没有新的状态变化，才发送LED反馈
                             const capturedNode = node;
                             timerObj.timer = setTimeout(() => {
-                                // 检查是否是当前节点设置的定时器
-                                const currentTimerObj = meshLedDebounceTimers.get(meshAddr);
-                                if (currentTimerObj && currentTimerObj.nodeId === capturedNode.id) {
-                                    meshLedDebounceTimers.delete(meshAddr);
-                                    const currentStates = meshDeviceStates.get(meshAddr);
-
-                                    // 计算全局锁定时间：100ms（足够发送LED反馈，但不影响下一次按键）
-                                    const lockDuration = 100;
-                                    meshLedFeedbackGlobalLock = Date.now() + lockDuration;
-
-                                    // 发送LED反馈到物理开关面板（使用最新的完整状态）
-                                    const button1State = currentStates[0];  // 按钮1的状态
-                                    capturedNode.sendCommandToPanel(button1State);
+                                const currentTimerObj = meshLedDebounceTimers.get(panelKey);
+                                if (currentTimerObj) {
+                                    meshLedDebounceTimers.delete(panelKey);
+                                    
+                                    // 设置全局锁定：100ms内忽略面板状态上报
+                                    // 改进：使用更精准的锁定时间，并增加序列号或时间戳校验
+                                    meshLedFeedbackGlobalLock = Date.now() + 150; 
+
+                                    capturedNode.debug(`[LED反馈] 面板${panelKey} 继电器触发同步`);
+                                    capturedNode.sendCommandToPanel(capturedNode.currentState);
                                 }
-                            }, 100);
-                        }
-
-                        // 只有当前节点绑定的线圈变化时，才更新节点状态并触发按键LED反馈
-                        if (coil === node.config.targetCoilNumber) {
-                            // 更新当前节点状态
-                            node.currentState = value;
-                            node.lastStateChange.timestamp = Date.now();
-                            node.lastStateChange.value = value;
-
-                            if (stateChanged) {
-                                if (isButtonPress) {
-                                    // 按键触发：立即发送整个面板LED状态（快速响应）
-                                    node.debug(`[LED反馈] Mesh${meshAddr} 按钮${node.config.meshButtonNumber}: 按键触发，立即发送整个面板LED状态`);
-
-                                    // 设置全局锁定：100ms内忽略所有Mesh面板的状态上报（缩短锁定时间，避免影响下一次按键）
-                                    meshLedFeedbackGlobalLock = Date.now() + 100;
-
-                                    // 立即发送LED反馈（整个面板）
-                                    node.sendCommandToPanel(value);
-                                } else if (isInit) {
-                                    // 首次轮询：发送LED反馈（同步初始状态）
-                                    // 使用防抖机制，避免重复发送
-                                    if (!meshLedDebounceTimers.has(meshAddr)) {
-                                        const capturedNode = node;
-                                        const timer = setTimeout(() => {
-                                            const timerObj = meshLedDebounceTimers.get(meshAddr);
-                                            if (timerObj && timerObj.nodeId === capturedNode.id) {
-                                                meshLedDebounceTimers.delete(meshAddr);
-                                                const currentStates = meshDeviceStates.get(meshAddr);
-                                                capturedNode.debug(`[LED反馈] Mesh${meshAddr} 首次轮询，发送整个面板LED状态: ${JSON.stringify(currentStates)}`);
-
-                                                // 设置全局锁定：100ms内忽略所有Mesh面板的状态上报
-                                                meshLedFeedbackGlobalLock = Date.now() + 100;
-
-                                                capturedNode.sendCommandToPanel(value);
-                                            }
-                                        }, 200);  // 200ms防抖时间，等待所有初始状态收集完毕
-
-                                        meshLedDebounceTimers.set(meshAddr, {
-                                            timer: timer,
-                                            nodeId: node.id,
-                                            serialPortConfig: node.serialPortConfig
-                                        });
-
-                                        node.debug(`[LED防抖] Mesh${meshAddr} 按钮${node.config.meshButtonNumber}: 首次轮询，设置防抖定时器(200ms)`);
-                                    }
-                                }
-                            }
-
-                            // 更新节点状态显示
-                            node.updateStatus();
-
-                            // 输出状态消息（立即输出，不等待防抖）
-                            node.send({
-                                payload: value,
-                                topic: `switch_${node.config.switchId}_btn${node.config.buttonNumber}`,
-                                switchId: node.config.switchId,
-                                button: node.config.buttonNumber,
-                                targetSlave: node.config.targetSlaveAddress,
-                                targetCoil: node.config.targetCoilNumber
-                            });
+                            }, 50); // 50ms防抖
                         }
                     }
-                } else if (slave === node.config.targetSlaveAddress && coil === node.config.targetCoilNumber) {
-                    // RS-485模式或非Mesh模式：只处理自己绑定的线圈
-                    // 检查状态是否真正变化
-                    const stateChanged = (node.currentState !== value);
-                    
-                    // 区分触发源
-                    const isButtonPress = (triggerSource === 'button-press' || triggerSource === 'scene-trigger');
-                    const isInit = (data.source === 'init');  // 首次轮询
-                    const isPolling = (data.source === 'polling');  // 轮询变化
+                }
 
-                    // 更新当前状态
+                // 只有当前节点绑定的线圈变化时，才更新节点状态并处理后续逻辑
+                if (slave === node.config.targetSlaveAddress && coil === node.config.targetCoilNumber) {
+                    const stateChanged = (node.currentState !== value);
                     node.currentState = value;
                     node.lastStateChange.timestamp = Date.now();
                     node.lastStateChange.value = value;
 
-                    if (stateChanged && !isButtonPress) {
-                        // RS-485模式：状态变化且非按键触发时发送LED反馈
-                        // 按键触发的LED反馈已在handleRs485Data中发送，避免重复
-                        node.sendCommandToPanel(value);
+                    if (stateChanged) {
+                        if (isButtonPress) {
+                            // 按键触发：立即同步（高优先级）
+                            meshLedFeedbackGlobalLock = Date.now() + 150;
+                            node.sendCommandToPanel(value);
+                        } else if (isInit) {
+                            // 首次轮询：防抖同步
+                            if (panelKey && !meshLedDebounceTimers.has(panelKey)) {
+                                const capturedNode = node;
+                                const timer = setTimeout(() => {
+                                    if (meshLedDebounceTimers.has(panelKey)) {
+                                        meshLedDebounceTimers.delete(panelKey);
+                                        meshLedFeedbackGlobalLock = Date.now() + 150;
+                                        capturedNode.sendCommandToPanel(value);
+                                    }
+                                }, 200);
+                                meshLedDebounceTimers.set(panelKey, { timer, nodeId: node.id });
+                            }
+                        }
                     }
 
-                    // 更新节点状态显示
                     node.updateStatus();
 
-                    // 首次轮询时只同步内部状态和LED反馈，不发送消息到下游
-                    // 避免重启Node-RED时触发下游节点导致继电器动作
                     if (isInit) {
                         node.debug(`首次轮询状态同步：从站${slave} 线圈${coil} = ${value ? 'ON' : 'OFF'}（不发送到下游）`);
                         return;
                     }
 
-                    // 输出状态消息（仅在非首次轮询时发送）
                     node.send({
                         payload: value,
                         topic: `switch_${node.config.switchId}_btn${node.config.buttonNumber}`,
@@ -781,7 +721,7 @@ module.exports = function(RED) {
                         button: node.config.buttonNumber,
                         targetSlave: node.config.targetSlaveAddress,
                         targetCoil: node.config.targetCoilNumber,
-                        source: isPolling ? 'polling' : triggerSource  // 传递触发源
+                        source: (data.source === 'polling') ? 'polling' : triggerSource
                     });
                 }
             };

package/package.json

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