node-red-contrib-symi-modbus 2.7.9 → 2.8.1

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. **技术细节**：
-   - 写入队列间隔：20ms（确保总线稳定）
+   - 写入队列间隔：40ms（确保总线稳定，优化指示灯反馈）
+   - 智能优先队列：触发源面板优先处理（500ms优先窗口）
    - 轮询恢复时间：20ms（快速响应）
    - 锁等待超时：100ms（快速检测异常）
    - 队列自动处理，无需手动干预
@@ -883,53 +884,49 @@ HomeKit网桥节点无需输入消息，自动同步主站配置和状态。
 
 ## 版本信息
 
-**当前版本**: v2.7.9
+**当前版本**: v2.8.1
 
-### v2.7.9 (2025-11-10)
+### v2.8.1 (2025-11-11)
 
 **重要更新**：
-- 优化Modbus通信稳定性，增强错误处理机制
-- 改进TCP连接管理，减少连接超时问题
-- 优化串口通信性能，提升响应速度
-- 修复特定条件下MQTT连接不稳定的问题
-- 增强Home Assistant自动发现功能的兼容性
-
-### v2.6.9 (2025-11-10)
-
-**重要修复**：
-- 修复LED反馈队列处理逻辑：移除本地队列，直接使用全局队列（serial-port-config统一管理）
-- 确保所有LED反馈按顺序串行发送，间隔20ms（TCP）或10ms（串口）
-- 修复多从站继电器同时变化时的LED反馈遗漏问题
-- 确保双控/多控场景下所有开关面板都能收到完整的状态反馈
-
-**队列处理机制**（全局统一队列）：
+- 优化指示灯反馈间隔为40ms（从30ms调整），进一步提升总线稳定性
+- 实现智能优先队列机制：触发场景的开关面板优先获得LED反馈
+- 提升用户体验：操作的面板最快响应，其他面板按序反馈
+
+**智能优先队列机制**：
+- **触发源优先**：当某个开关触发场景时，该开关面板的LED反馈会优先处理
+- **优先窗口**：触发后500ms内，该面板的所有LED反馈都会插入到队列前面
+- **用户体验优化**：用户操作的面板会最快看到反馈，其他面板即使慢一点也不会被察觉
 - **全局队列**：所有从站开关节点共享同一个全局队列（由serial-port-config管理）
-- **串行发送**：所有LED反馈按加入队列的顺序依次发送，间隔20ms（TCP）或10ms（串口）
+- **串行发送**：所有LED反馈按优先级和加入顺序依次发送，间隔40ms（TCP和串口统一）
 - **完整性保证**：所有LED反馈都能正确发送，不会遗漏
 - **去重机制**：每个节点50ms内不重复发送相同状态，避免总线拥堵
-- **性能优化**：400个按键（50个8键开关）反馈耗时约8秒（20ms×400）
 
 **典型场景说明**：
 1. **场景1：单个继电器控制**
-   - 按下开关 → 继电器动作 → LED反馈加入全局队列 → 20ms后发送
+   - 按下开关 → 设置触发源 → 继电器动作 → LED反馈优先加入队列 → 40ms后发送
+   - 该面板的LED反馈会优先处理，响应最快
 
 2. **场景2：批量控制（如17通道全开，16个继电器）**
-   - 触发17通道 → 1-16路继电器全开 → 所有绑定的LED反馈加入全局队列
+   - 触发17通道 → 设置触发源（操作的面板） → 1-16路继电器全开
    - 假设每个继电器绑定2个开关面板 = 32个LED反馈
-   - 按加入队列的顺序依次发送，耗时约640ms（20ms×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反馈加入全局队列
-   - 按顺序发送，间隔20ms，确保所有面板LED状态同步
+   - 如果是其中一个面板触发的，该面板优先反馈
+   - 另一个面板按顺序发送，间隔40ms
 
 5. **场景5：大规模部署（50个8键开关 = 400个按键）**
-   - 批量控制触发 → 所有LED反馈加入全局队列
-   - 按部署时的节点顺序依次发送，耗时约8秒（20ms×400）
+   - 批量控制触发 → 设置触发源 → 所有LED反馈加入全局队列
+   - 触发源面板优先反馈（用户最快看到响应）
+   - 其他面板按部署时的节点顺序依次发送，耗时约16秒（40ms×400）
    - 确保总线稳定，不会冲突或丢失
 
 ## 许可证

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/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 = 50; // 写入队列处理间隔（50ms，确保总线稳定，避免数据丢失）
+        node.writeQueueInterval = 40; // 写入队列处理间隔（40ms，确保总线稳定，避免数据丢失）
 
         // 定期清理机制（每小时清理一次，防止内存泄漏）
         node.cleanupTimer = setInterval(() => {
@@ -1197,7 +1197,7 @@ module.exports = function(RED) {
                     node.warn(`队列任务失败，继续处理下一个任务: ${err.message}`);
                 }
 
-                // 等待一段时间再处理下一个任务（20ms间隔，确保总线稳定）
+                // 等待一段时间再处理下一个任务（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: "从站开关"},

package/nodes/modbus-slave-switch.js

@@ -634,6 +634,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()})`);
                         // 场景模式：切换状态（每次触发时翻转）
@@ -695,6 +700,11 @@ module.exports = function(RED) {
                 // 更新当前状态缓存（用于后续控制时保持其他路不变）
                 node.meshCurrentStates = event.states;
 
+                // 设置触发源（用于优先队列）- 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}`);
                 node.sendMqttCommand(buttonState);
@@ -859,7 +869,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 +888,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) {
@@ -347,10 +351,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 +437,9 @@ module.exports = function(RED) {
                             });
                         });
 
-                        // TCP写入间隔（20ms，避免网关处理不过来）
+                        // TCP写入间隔（40ms，确保指示灯反馈稳定）
                         if (node.writeQueue.length > 0) {
-                            await new Promise(resolve => setTimeout(resolve, 20));
+                            await new Promise(resolve => setTimeout(resolve, 40));
                         }
                     } else {
                         if (!node.connection.isOpen) {
@@ -439,9 +471,9 @@ module.exports = function(RED) {
                             });
                         });
 
-                        // 串口写入间隔（10ms，串口速度较快）
+                        // 串口写入间隔（40ms，确保指示灯反馈稳定）
                         if (node.writeQueue.length > 0) {
-                            await new Promise(resolve => setTimeout(resolve, 10));
+                            await new Promise(resolve => setTimeout(resolve, 40));
                         }
                     }
                 } catch (err) {
@@ -513,7 +545,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.7.9",
+  "version": "2.8.1",
   "description": "Node-RED Modbus节点，支持TCP/串口通信、串口自动搜索、多设备轮询、可选MQTT集成（支持纯本地模式和MQTT模式）、Home Assistant自动发现、HomeKit网桥、可视化控制看板、自定义协议转换和物理开关面板双向同步，工控机长期稳定运行",
   "main": "nodes/modbus-master.js",
   "scripts": {