node-red-contrib-symi-modbus 2.8.0 → 2.8.2

package/README.md

@@ -251,8 +251,8 @@ node-red-restart
 1. **HomeKit编组群控**：
    - 在HomeKit中创建房间或编组，可同时控制多个继电器
    - 例如：创建"客厅"编组，包含10个灯光开关，一键全开/全关
-   - 智能队列机制确保所有继电器按序快速执行，无超时警告
-   - 10个继电器同时动作仅需约200ms（20ms间隔×10）
+   - 智能优先队列机制确保触发源面板最快响应，其他继电器按序执行
+   - 10个继电器同时动作仅需约400ms（40ms间隔×10），触发源面板优先反馈
 
 2. **场景联动**：
    - 支持HomeKit场景（如"回家模式"、"离家模式"）
@@ -267,7 +267,8 @@ node-red-restart
    - 长期稳定运行，反复控制不会造成内存增加、卡顿或死机
 
 4. **技术细节**：
-   - 写入队列间隔：30ms（确保总线稳定）
+   - 写入队列间隔：40ms（确保总线稳定，优化指示灯反馈）
+   - 智能优先队列：触发源面板优先处理（500ms优先窗口）
    - 轮询恢复时间：20ms（快速响应）
    - 锁等待超时：100ms（快速检测异常）
    - 队列自动处理，无需手动干预
@@ -883,43 +884,57 @@ HomeKit网桥节点无需输入消息，自动同步主站配置和状态。
 
 ## 版本信息
 
-**当前版本**: v2.8.0
+**当前版本**: v2.8.2
 
-### v2.8.0 (2025-11-10)
+### v2.8.2 (2025-11-11)
 
-**重要更新**：
-- 优化指示灯反馈稳定性，统一队列间隔为30ms（TCP和串口）
-- 修复高频控制场景下指示灯反馈丢失问题
-- 提升批量控制时的总线稳定性
-
-**队列处理机制**（全局统一队列）：
-- **全局队列**：所有从站开关节点共享同一个全局队列（由serial-port-config管理）
-- **串行发送**：所有LED反馈按加入队列的顺序依次发送，间隔30ms（TCP和串口统一）
-- **完整性保证**：所有LED反馈都能正确发送，不会遗漏
-- **去重机制**：每个节点50ms内不重复发送相同状态，避免总线拥堵
-- **性能优化**：400个按键（50个8键开关）反馈耗时约12秒（30ms×400）
+**核心功能**：
+- **Mesh开关完整支持**：支持Symi蓝牙Mesh网关和1-6路Mesh开关，实现双向状态同步
+  - 全局共享状态管理：同一Mesh设备的多个按钮节点共享状态数组，确保LED反馈正确
+  - Mesh控制帧格式：完全兼容Symi Mesh协议，支持1/2/3/4/6路开关
+  - 设备持久化：Mesh设备列表自动保存，重启无需重新扫描
+  - LED状态同步：继电器状态变化时自动同步到Mesh开关LED指示灯
+  - **彻底解决Mesh开关LED不跟随继电器状态同步的问题**
+
+**重要修复**：
+- 修复Mesh LED反馈状态不同步问题：引入全局共享状态Map，所有按钮节点共享同一个状态数组
+- 修复Mesh控制帧格式错误：移除多余参数，修正长度字段，确保与Mesh网关协议一致
+- 修复部署后LED指示灯不同步问题：主站首次轮询时主动广播所有线圈状态
+- 优化初始化逻辑：从站开关节点无需查询状态，主站节点主动推送，更加高效可靠
+
+**稳定性增强**：
+- 完整的资源清理：所有定时器、监听器、连接在节点关闭时正确释放，防止内存泄漏
+- 断网重连机制：TCP连接断开后自动重连，不影响本地串口通信
+- 防抖机制：避免重复处理同一按键事件，防止死循环
+- 全局队列优化：40ms间隔 + 智能优先队列，确保长期稳定流畅运行
+- 串行发送：所有LED反馈按优先级和加入顺序依次发送，间隔40ms（TCP和串口统一）
+- 去重机制：每个节点50ms内不重复发送相同状态，避免总线拥堵
 
 **典型场景说明**：
 1. **场景1：单个继电器控制**
-   - 按下开关 → 继电器动作 → LED反馈加入全局队列 → 30ms后发送
+   - 按下开关 → 设置触发源 → 继电器动作 → LED反馈优先加入队列 → 40ms后发送
+   - 该面板的LED反馈会优先处理，响应最快
 
 2. **场景2：批量控制（如17通道全开，16个继电器）**
-   - 触发17通道 → 1-16路继电器全开 → 所有绑定的LED反馈加入全局队列
+   - 触发17通道 → 设置触发源（操作的面板） → 1-16路继电器全开
    - 假设每个继电器绑定2个开关面板 = 32个LED反馈
-   - 按加入队列的顺序依次发送，耗时约960ms（30ms×32）
+   - 触发源面板的LED反馈优先处理（最快响应）
+   - 其他面板按加入队列的顺序依次发送，耗时约1280ms（40ms×32）
 
 3. **场景3：快速切换（如17通道全开后立即18通道全关）**
-   - 17通道触发 → 1-16路全开 → 32个LED反馈加入队列
-   - 18通道触发 → 1-16路全关 → 32个LED反馈加入队列
-   - 全局队列按顺序处理，确保所有面板最终显示正确状态
+   - 17通道触发 → 设置触发源 → 1-16路全开 → 触发源面板优先反馈
+   - 18通道触发 → 更新触发源 → 1-16路全关 → 新触发源面板优先反馈
+   - 全局队列按优先级和顺序处理，确保所有面板最终显示正确状态
 
 4. **场景4：双控开关（1个继电器绑定2个不同ID的开关面板）**
    - 继电器状态变化 → 2个LED反馈加入全局队列
-   - 按顺序发送，间隔30ms，确保所有面板LED状态同步
+   - 如果是其中一个面板触发的，该面板优先反馈
+   - 另一个面板按顺序发送，间隔40ms
 
 5. **场景5：大规模部署（50个8键开关 = 400个按键）**
-   - 批量控制触发 → 所有LED反馈加入全局队列
-   - 按部署时的节点顺序依次发送，耗时约12秒（30ms×400）
+   - 批量控制触发 → 设置触发源 → 所有LED反馈加入全局队列
+   - 触发源面板优先反馈（用户最快看到响应）
+   - 其他面板按部署时的节点顺序依次发送，耗时约16秒（40ms×400）
    - 确保总线稳定，不会冲突或丢失
 
 ## 许可证

package/RELEASE_CHECKLIST.md

@@ -0,0 +1,99 @@
+# v2.8.2 发布前检查清单
+
+## 代码质量检查
+
+### 1. 资源管理 ✅
+- [x] 所有定时器在节点关闭时正确清理（clearTimeout/clearInterval）
+- [x] 所有事件监听器在节点关闭时正确移除（removeListener/removeAllListeners）
+- [x] 所有连接在节点关闭时正确关闭（TCP/串口/MQTT）
+- [x] 全局缓存合理管理，不会无限增长
+
+### 2. 内存泄漏防护 ✅
+- [x] modbus-slave-switch.js: 完整的close处理
+- [x] modbus-master.js: 完整的close处理
+- [x] serial-port-config.js: 完整的close处理
+- [x] 全局Map使用合理（globalDebounceCache, meshDeviceStates）
+
+### 3. 稳定性保障 ✅
+- [x] 断网重连机制：TCP连接断开后自动重连
+- [x] 防抖机制：避免重复处理同一按键事件（200ms防抖）
+- [x] 队列机制：40ms间隔串行发送，防止总线冲突
+- [x] 去重机制：50ms内不重复发送相同状态
+- [x] 初始化保护：部署期间不发送LED反馈
+
+### 4. Mesh功能完整性 ✅
+- [x] 全局共享状态管理：meshDeviceStates Map
+- [x] Mesh控制帧格式正确：移除多余参数，长度字段正确
+- [x] 设备持久化：自动保存和加载Mesh设备列表
+- [x] LED状态同步：继电器变化时自动同步到Mesh开关
+- [x] 支持1/2/3/4/6路Mesh开关
+
+### 5. 错误处理 ✅
+- [x] 所有异步操作都有try-catch
+- [x] 连接失败时有重连机制
+- [x] 错误日志清晰，便于排查问题
+
+## 文档完整性检查
+
+### 1. README.md ✅
+- [x] 版本号更新为v2.8.2
+- [x] 只保留最新版本的更新日志
+- [x] Mesh开关配置说明完整
+- [x] 安装步骤清晰
+- [x] 使用示例完整
+
+### 2. package.json ✅
+- [x] 版本号更新为2.8.2
+- [x] 依赖版本正确
+- [x] 关键词完整
+- [x] 仓库信息正确
+
+## 功能测试
+
+### 1. 基础功能 ✅
+- [x] Modbus主站轮询正常
+- [x] RS-485从站开关按键触发正常
+- [x] LED反馈正常
+
+### 2. Mesh功能 ✅
+- [x] Mesh设备扫描正常
+- [x] Mesh按键触发继电器正常
+- [x] 继电器状态变化同步到Mesh LED正常
+- [x] 无死循环问题
+
+### 3. 稳定性测试 ✅
+- [x] 长时间运行不卡顿
+- [x] 断网重连正常
+- [x] 重启Node-RED后状态恢复正常
+- [x] 无内存泄漏
+
+## 发布步骤
+
+1. ✅ 确认所有检查项通过
+2. ✅ 更新版本号（package.json和README.md）
+3. ⏳ 提交代码到Git
+4. ⏳ 发布到npm
+5. ⏳ 创建GitHub Release
+
+## 发布命令
+
+```bash
+# 1. 提交代码
+git add .
+git commit -m "Release v2.8.2: Mesh开关完整支持，修复LED同步问题"
+git push origin main
+
+# 2. 发布到npm
+npm publish
+
+# 3. 创建Git标签
+git tag v2.8.2
+git push origin v2.8.2
+```
+
+## 发布后验证
+
+- [ ] npm上版本号正确
+- [ ] 安装测试正常
+- [ ] 文档显示正确
+

package/nodes/custom-protocol.html

@@ -1,6 +1,6 @@
 <script type="text/javascript">
     RED.nodes.registerType('custom-protocol', {
-        category: 'SYMI-MODBUS',
+        category: 'SYMI MODBUS',
         color: '#FF9800',
         defaults: {
             name: {value: "自定义协议"},

package/nodes/homekit-bridge.html

@@ -1,6 +1,6 @@
 <script type="text/javascript">
     RED.nodes.registerType('homekit-bridge', {
-        category: 'SYMI-MODBUS',
+        category: 'SYMI MODBUS',
         color: '#FF9800',
         defaults: {
             name: {value: "HomeKit网桥"},

package/nodes/mesh-protocol.js

@@ -114,17 +114,19 @@ module.exports = function(RED) {
         if (totalButtons === 1) {
             // 单路开关
             stateValue = state ? 0x02 : 0x01;
-            const buffer = Buffer.from([
-                PROTOCOL.HEADER,
-                PROTOCOL.OP_DEVICE_CONTROL,
-                0x05,  // Length
+            // 帧格式：[53] [30] [长度] [地址低] [地址高] [消息类型0x02] [状态值] [校验]
+            const data = Buffer.from([
                 shortAddr & 0xFF,
                 (shortAddr >> 8) & 0xFF,
-                0x00,  // ACK = 0
-                0x05,  // 重传5次
                 PROTOCOL.MSG_TYPE_SWITCH,
                 stateValue
             ]);
+            const buffer = Buffer.from([
+                PROTOCOL.HEADER,
+                PROTOCOL.OP_DEVICE_CONTROL,
+                data.length,  // Length = 4
+                ...data
+            ]);
             const checksum = calculateChecksum(buffer);
             return Buffer.concat([buffer, Buffer.from([checksum])]);
         } else if (totalButtons >= 2 && totalButtons <= 4) {
@@ -132,22 +134,34 @@ module.exports = function(RED) {
             if (currentStates && currentStates.length === totalButtons) {
                 stateValue = buildMultiSwitchState(currentStates, buttonNumber, state);
             } else {
-                // 如果没有当前状态，只设置目标按钮，其他位设为00（保持不变）
+                // 如果没有当前状态，使用默认全关状态，然后修改目标按钮
+                const defaultStates = {
+                    2: 0x05, // 01 01 (2路全关)
+                    3: 0x15, // 01 01 01 (3路全关)
+                    4: 0x55  // 01 01 01 01 (4路全关)
+                };
+                stateValue = defaultStates[totalButtons] || 0x55;
+
+                // 修改目标按钮的状态
                 const bitPos = (buttonNumber - 1) * 2;
-                stateValue = (state ? 0x02 : 0x01) << bitPos;
+                const mask = ~(0x03 << bitPos); // 清除目标位
+                const newBits = (state ? 0x02 : 0x01) << bitPos; // 新状态位
+                stateValue = (stateValue & mask) | newBits;
             }
 
-            const buffer = Buffer.from([
-                PROTOCOL.HEADER,
-                PROTOCOL.OP_DEVICE_CONTROL,
-                0x05,  // Length
+            // 帧格式：[53] [30] [长度] [地址低] [地址高] [消息类型0x02] [状态值] [校验]
+            const data = Buffer.from([
                 shortAddr & 0xFF,
                 (shortAddr >> 8) & 0xFF,
-                0x00,  // ACK = 0
-                0x05,  // 重传5次
                 PROTOCOL.MSG_TYPE_SWITCH,
                 stateValue
             ]);
+            const buffer = Buffer.from([
+                PROTOCOL.HEADER,
+                PROTOCOL.OP_DEVICE_CONTROL,
+                data.length,  // Length = 4
+                ...data
+            ]);
             const checksum = calculateChecksum(buffer);
             return Buffer.concat([buffer, Buffer.from([checksum])]);
         } else if (totalButtons === 6) {
@@ -156,23 +170,30 @@ module.exports = function(RED) {
             if (currentStates && currentStates.length === totalButtons) {
                 stateValue16 = buildMultiSwitchState(currentStates, buttonNumber, state);
             } else {
-                // 如果没有当前状态，只设置目标按钮，其他位设为00（保持不变）
+                // 如果没有当前状态，使用默认全关状态（0x5555），然后修改目标按钮
+                stateValue16 = 0x5555; // 6路全关
+
+                // 修改目标按钮的状态
                 const bitPos = (buttonNumber - 1) * 2;
-                stateValue16 = (state ? 0x02 : 0x01) << bitPos;
+                const mask = ~(0x03 << bitPos); // 清除目标位
+                const newBits = (state ? 0x02 : 0x01) << bitPos; // 新状态位
+                stateValue16 = (stateValue16 & mask) | newBits;
             }
 
-            const buffer = Buffer.from([
-                PROTOCOL.HEADER,
-                PROTOCOL.OP_DEVICE_CONTROL,
-                0x06,  // Length
+            // 帧格式：[53] [30] [长度] [地址低] [地址高] [消息类型0x02] [状态值低] [状态值高] [校验]
+            const data = Buffer.from([
                 shortAddr & 0xFF,
                 (shortAddr >> 8) & 0xFF,
-                0x00,  // ACK = 0
-                0x05,  // 重传5次
                 PROTOCOL.MSG_TYPE_SWITCH,
                 stateValue16 & 0xFF,
                 (stateValue16 >> 8) & 0xFF
             ]);
+            const buffer = Buffer.from([
+                PROTOCOL.HEADER,
+                PROTOCOL.OP_DEVICE_CONTROL,
+                data.length,  // Length = 5
+                ...data
+            ]);
             const checksum = calculateChecksum(buffer);
             return Buffer.concat([buffer, Buffer.from([checksum])]);
         }

package/nodes/modbus-dashboard.html

@@ -1,6 +1,6 @@
 <script type="text/javascript">
     RED.nodes.registerType('modbus-dashboard', {
-        category: 'SYMI-MODBUS',
+        category: 'SYMI MODBUS',
         color: '#4CAF50',
         defaults: {
             name: {value: "Modbus控制看板"},

package/nodes/modbus-debug.html

@@ -1,6 +1,6 @@
 <script type="text/javascript">
     RED.nodes.registerType('modbus-debug', {
-        category: 'SYMI-MODBUS',
+        category: 'SYMI MODBUS',
         color: '#C0DEED',
         defaults: {
             name: { value: '' },

package/nodes/modbus-master.html

@@ -1,6 +1,6 @@
 <script type="text/javascript">
     RED.nodes.registerType('modbus-master', {
-        category: 'SYMI-MODBUS',
+        category: 'SYMI MODBUS',
         color: '#3FADB5',
         defaults: {
             name: {value: "Modbus主站"},

package/nodes/modbus-master.js

@@ -150,7 +150,7 @@ module.exports = function(RED) {
         // 写入队列机制（确保所有写入操作串行执行，避免锁竞争）
         node.writeQueue = []; // 写入队列
         node.isProcessingWrite = false; // 是否正在处理写入队列
-        node.writeQueueInterval = 30; // 写入队列处理间隔（30ms，确保总线稳定，避免数据丢失）
+        node.writeQueueInterval = 40; // 写入队列处理间隔（40ms，确保总线稳定，避免数据丢失）
 
         // 定期清理机制（每小时清理一次，防止内存泄漏）
         node.cleanupTimer = setInterval(() => {
@@ -946,13 +946,14 @@ module.exports = function(RED) {
                         });
 
                         // 广播状态变化事件（用于LED反馈）
-                        // 只在状态真正改变时广播（不包括首次轮询）
-                        if (!isFirstPoll && oldValue !== newValue) {
+                        // 首次轮询：广播所有线圈状态（让从站开关节点初始化LED）
+                        // 后续轮询：只在状态真正改变时广播
+                        if (isFirstPoll || oldValue !== newValue) {
                             RED.events.emit('modbus:coilStateChanged', {
                                 slave: slaveId,
                                 coil: coilIndex,
                                 value: newValue,
-                                source: 'polling'
+                                source: isFirstPoll ? 'init' : 'polling'
                             });
                         }
                     }
@@ -1197,7 +1198,7 @@ module.exports = function(RED) {
                     node.warn(`队列任务失败，继续处理下一个任务: ${err.message}`);
                 }
 
-                // 等待一段时间再处理下一个任务（30ms间隔，确保总线稳定）
+                // 等待一段时间再处理下一个任务（40ms间隔，确保总线稳定）
                 if (node.writeQueue.length > 0) {
                     await new Promise(resolve => setTimeout(resolve, node.writeQueueInterval));
                 }

package/nodes/modbus-slave-switch.html

@@ -1,6 +1,6 @@
 <script type="text/javascript">
     RED.nodes.registerType('modbus-slave-switch', {
-        category: 'SYMI-MODBUS',
+        category: 'SYMI MODBUS',
         color: '#E9967A',
         defaults: {
             name: {value: "从站开关"},
@@ -179,10 +179,9 @@
             $("#node-input-enableMqtt").trigger("change");
             $("#node-input-buttonType").trigger("change");
 
-            // 如果是Mesh模式，加载已保存的设备列表
-            if (node.buttonType === 'mesh') {
-                loadSavedMeshDevices();
-            }
+            // 始终加载已保存的Mesh设备列表（无论当前是什么模式）
+            // 这样切换到Mesh模式时，列表已经加载好了
+            loadSavedMeshDevices();
         }
     });
 </script>

package/nodes/modbus-slave-switch.js

@@ -9,6 +9,10 @@ module.exports = function(RED) {
 
     // 全局防抖缓存：防止多个节点重复处理同一个按键事件
     const globalDebounceCache = new Map();  // key: "switchId-buttonNumber", value: timestamp
+
+    // 全局Mesh设备状态缓存（按短地址索引）
+    // 用于同一个Mesh设备的多个按钮节点共享状态数组
+    const meshDeviceStates = new Map();  // key: meshShortAddress, value: [state1, state2, ...]
     
     // 初始化Mesh设备持久化存储
     const meshPersistDir = path.join(RED.settings.userDir || os.homedir() + '/.node-red', 'mesh-devices-persist');
@@ -549,6 +553,19 @@ module.exports = function(RED) {
                     node.lastStateChange.timestamp = Date.now();
                     node.lastStateChange.value = value;
 
+                    // Mesh模式：更新全局共享状态缓存（用于构建正确的控制帧）
+                    if (node.config.buttonType === 'mesh') {
+                        const meshAddr = node.config.meshShortAddress;
+                        if (!meshDeviceStates.has(meshAddr)) {
+                            // 初始化状态数组（全部设为null，表示未知状态）
+                            meshDeviceStates.set(meshAddr, new Array(node.config.meshTotalButtons).fill(null));
+                        }
+                        // 更新对应按钮的状态
+                        const states = meshDeviceStates.get(meshAddr);
+                        states[node.config.meshButtonNumber - 1] = value;
+                        node.debug(`[Mesh状态更新] 设备${meshAddr} 按钮${node.config.meshButtonNumber} = ${value}, 完整状态=${JSON.stringify(states)}`);
+                    }
+
                     // 更新节点状态显示
                     node.updateStatus();
 
@@ -634,6 +651,11 @@ module.exports = function(RED) {
                     }
                     globalDebounceCache.set(debounceKey, now);
 
+                    // 设置触发源（用于优先队列）
+                    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()})`);
                         // 场景模式：切换状态（每次触发时翻转）
@@ -692,8 +714,21 @@ module.exports = function(RED) {
                 }
                 globalDebounceCache.set(debounceKey, now);
 
-                // 更新当前状态缓存（用于后续控制时保持其他路不变）
-                node.meshCurrentStates = event.states;
+                // 更新全局共享状态缓存（用于后续控制时保持其他路不变）
+                const meshAddr = node.config.meshShortAddress;
+                meshDeviceStates.set(meshAddr, event.states);
+                node.debug(`[Mesh按键] 设备${meshAddr} 状态更新=${JSON.stringify(event.states)}`);
+
+                // 初始化期间不发送控制命令（避免重启时Mesh开关状态覆盖继电器状态）
+                if (node.isInitializing) {
+                    node.debug(`初始化期间忽略Mesh按键事件：MAC=${node.config.meshMacAddress} 按键${node.config.meshButtonNumber}`);
+                    return;
+                }
+
+                // 设置触发源（用于优先队列）- Mesh使用短地址作为switchId
+                if (node.serialPortConfig && typeof node.serialPortConfig.setTriggerSource === 'function') {
+                    node.serialPortConfig.setTriggerSource(node.config.meshShortAddress);
+                }
 
                 // 发送命令到继电器
                 node.debug(`Mesh开关${buttonState ? 'ON' : 'OFF'}: MAC=${node.config.meshMacAddress} 按键${node.config.meshButtonNumber}`);
@@ -791,17 +826,21 @@ module.exports = function(RED) {
         // 发送控制指令到物理开关面板（控制指示灯等）
         // 直接发送到全局队列，由serial-port-config统一管理（20ms间隔串行发送）
         node.sendCommandToPanel = function(state) {
+            node.debug(`[sendCommandToPanel] 被调用：buttonType=${node.config.buttonType} state=${state} isInitializing=${node.isInitializing}`);
+
             // 检查连接状态
             if (!node.serialPortConfig || !node.serialPortConfig.connection) {
                 // 初始化期间静默警告
                 if (!node.isInitializing) {
                     node.warn('RS-485连接未建立，无法发送指示灯反馈');
                 }
+                node.debug(`[sendCommandToPanel] 连接未建立，退出`);
                 return;
             }
 
             // 初始化期间不发送LED反馈（避免部署时大量LED同时发送）
             if (node.isInitializing) {
+                node.debug(`[sendCommandToPanel] 初始化期间，跳过LED反馈`);
                 return;
             }
 
@@ -822,18 +861,27 @@ module.exports = function(RED) {
 
             if (node.config.buttonType === 'mesh') {
                 // Mesh模式：发送Mesh控制帧
+                // 从全局共享状态中获取当前设备的完整状态
+                const meshAddr = node.config.meshShortAddress;
+                const currentStates = meshDeviceStates.get(meshAddr) || null;
+
+                node.debug(`[Mesh LED] 准备发送：设备${meshAddr} 按钮${node.config.meshButtonNumber} = ${state}, 当前状态=${JSON.stringify(currentStates)}`);
+
                 command = meshProtocol.buildSwitchControlFrame(
                     node.config.meshShortAddress,
                     node.config.meshButtonNumber,
                     node.config.meshTotalButtons,
                     state,
-                    node.meshCurrentStates || null
+                    currentStates
                 );
 
                 if (!command) {
                     node.error(`构建Mesh控制帧失败`);
                     return;
                 }
+
+                const hexStr = command.toString('hex').toUpperCase().match(/.{1,2}/g).join(' ');
+                node.debug(`[Mesh LED] 控制帧已构建：[${hexStr}]`);
             } else {
                 // RS-485模式：使用轻量级协议
                 const deviceAddr = node.buttonDeviceAddr;
@@ -859,7 +907,11 @@ module.exports = function(RED) {
                 }
             }
 
-            // 直接发送到全局队列（由serial-port-config统一管理，20ms间隔串行发送）
+            // 直接发送到全局队列（由serial-port-config统一管理，40ms间隔串行发送）
+            // 传递优先级和switchId，触发源的面板会优先处理
+            const priority = 0;  // 默认优先级
+            const switchId = node.config.buttonType === 'mesh' ? node.config.meshShortAddress : node.config.switchId;
+
             node.serialPortConfig.write(command, (err) => {
                 if (err) {
                     node.error(`LED反馈失败: ${err.message}`);
@@ -874,7 +926,7 @@ module.exports = function(RED) {
                         node.log(`LED反馈已发送：面板${node.config.switchId} 按钮${node.config.buttonNumber} 设备${deviceAddr} 通道${channel} = ${state ? 'ON' : 'OFF'} (${node.config.buttonType === 'scene' ? 'REPORT' : 'SET'}) [${hexStr}]`);
                     }
                 }
-            });
+            }, priority, switchId);
         };
 
         // 更新节点状态显示

package/nodes/serial-port-config.js

@@ -40,6 +40,10 @@ module.exports = function(RED) {
         node.writeQueue = [];
         node.isWriting = false;
 
+        // 触发源跟踪（用于优先队列）
+        node.triggerSource = null;  // 当前触发场景的开关ID
+        node.triggerSourceTime = 0;  // 触发时间戳
+
         // 打开TCP连接
         node.openTcpConnection = function() {
             if (node.connection && !node.connection.destroyed) {
@@ -151,11 +155,16 @@ module.exports = function(RED) {
             }
 
             // 清理旧的串口实例（确保完全释放）
+            const needDelay = node.connection && node.connection.isOpen;
             if (node.connection) {
                 try {
                     node.connection.removeAllListeners();
                     if (node.connection.isOpen) {
-                        node.connection.close();
+                        node.connection.close((closeErr) => {
+                            if (closeErr) {
+                                node.debug(`串口关闭时出错: ${closeErr.message}`);
+                            }
+                        });
                     }
                 } catch (err) {
                     // 忽略清理错误
@@ -163,20 +172,25 @@ module.exports = function(RED) {
                 node.connection = null;
             }
 
-            node.isOpening = true;
+            // 如果之前串口是打开的，等待500ms让系统完全释放资源
+            const openDelay = needDelay ? 500 : 0;
 
-            try {
-                node.connection = new SerialPort({
-                    path: node.serialPort,
-                    baudRate: node.baudRate,
-                    dataBits: node.dataBits,
-                    parity: node.parity,
-                    stopBits: node.stopBits,
-                    autoOpen: false
-                });
+            setTimeout(() => {
+                node.isOpening = true;
 
-                // 打开串口
-                node.connection.open((err) => {
+                try {
+                    node.connection = new SerialPort({
+                        path: node.serialPort,
+                        baudRate: node.baudRate,
+                        dataBits: node.dataBits,
+                        parity: node.parity,
+                        stopBits: node.stopBits,
+                        autoOpen: false,
+                        lock: true  // 明确启用串口锁定
+                    });
+
+                    // 打开串口
+                    node.connection.open((err) => {
                     node.isOpening = false;
 
                     if (err) {
@@ -277,18 +291,19 @@ module.exports = function(RED) {
             } catch (err) {
                 node.isOpening = false;
                 node.error(`串口初始化失败: ${err.message}`);
-                
+
                 // 初始化失败时也要触发重连
                 if (!node.isClosing && node.dataListeners.length > 0) {
                     const delay = Math.min(5000 * Math.pow(2, node.reconnectAttempts), 60000);
                     node.reconnectAttempts++;
-                    
+
                     node.reconnectTimer = setTimeout(() => {
                         node.reconnectTimer = null;
                         node.openSerialConnection();
                     }, delay);
                 }
             }
+            }, openDelay);  // 关闭setTimeout
         };
 
         // 获取连接对象（用于Mesh设备发现等场景）
@@ -347,10 +362,38 @@ module.exports = function(RED) {
             }
         };
 
-        // 写入数据（带队列机制，防止并发冲突）
-        node.write = function(data, callback) {
+        // 设置触发源（用于优先队列）
+        node.setTriggerSource = function(switchId) {
+            node.triggerSource = switchId;
+            node.triggerSourceTime = Date.now();
+            // 500ms后清除触发源（避免长时间影响队列）
+            setTimeout(() => {
+                if (Date.now() - node.triggerSourceTime >= 500) {
+                    node.triggerSource = null;
+                }
+            }, 500);
+        };
+
+        // 写入数据（带队列机制，防止并发冲突，支持优先级）
+        node.write = function(data, callback, priority, switchId) {
             // 加入写入队列
-            node.writeQueue.push({ data, callback });
+            const queueItem = { data, callback, priority: priority || 0, switchId };
+
+            // 如果有优先级或者是触发源，插入到队列前面
+            if (priority > 0 || (switchId && switchId === node.triggerSource)) {
+                // 找到第一个非优先级项的位置
+                let insertIndex = 0;
+                for (let i = 0; i < node.writeQueue.length; i++) {
+                    if (node.writeQueue[i].priority === 0 && node.writeQueue[i].switchId !== node.triggerSource) {
+                        insertIndex = i;
+                        break;
+                    }
+                    insertIndex = i + 1;
+                }
+                node.writeQueue.splice(insertIndex, 0, queueItem);
+            } else {
+                node.writeQueue.push(queueItem);
+            }
 
             // 启动队列处理
             node.processWriteQueue();
@@ -405,9 +448,9 @@ module.exports = function(RED) {
                             });
                         });
 
-                        // TCP写入间隔（30ms，避免网关处理不过来）
+                        // TCP写入间隔（40ms，确保指示灯反馈稳定）
                         if (node.writeQueue.length > 0) {
-                            await new Promise(resolve => setTimeout(resolve, 30));
+                            await new Promise(resolve => setTimeout(resolve, 40));
                         }
                     } else {
                         if (!node.connection.isOpen) {
@@ -439,9 +482,9 @@ module.exports = function(RED) {
                             });
                         });
 
-                        // 串口写入间隔（30ms，确保指示灯反馈稳定）
+                        // 串口写入间隔（40ms，确保指示灯反馈稳定）
                         if (node.writeQueue.length > 0) {
-                            await new Promise(resolve => setTimeout(resolve, 30));
+                            await new Promise(resolve => setTimeout(resolve, 40));
                         }
                     }
                 } catch (err) {
@@ -513,7 +556,7 @@ module.exports = function(RED) {
     RED.nodes.registerType('serial-port-config', SerialPortConfigNode);
 
     // 提供串口搜索API
-    RED.httpAdmin.get('/serial-ports', async (req, res) => {
+    RED.httpAdmin.get('/serial-ports', async (_req, res) => {
         try {
             const { SerialPort } = require('serialport');
             const ports = await SerialPort.list();

package/package.json

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