node-red-contrib-symi-modbus 2.6.8 → 2.7.2

package/nodes/modbus-master.js

@@ -147,6 +147,11 @@ module.exports = function(RED) {
         node.pollingPausedCount = 0; // 暂停轮询计数器
         node._discoveryPublished = false; // Discovery发布标志（避免重复）
 
+        // 写入队列机制（确保所有写入操作串行执行，避免锁竞争）
+        node.writeQueue = []; // 写入队列
+        node.isProcessingWrite = false; // 是否正在处理写入队列
+        node.writeQueueInterval = 20; // 写入队列处理间隔（20ms，确保快速响应）
+
         // 定期清理机制（每小时清理一次，防止内存泄漏）
         node.cleanupTimer = setInterval(() => {
             // 清理过期的错误日志记录
@@ -1157,33 +1162,66 @@ module.exports = function(RED) {
             }
         };
 
-        // 写单个线圈（带互斥锁和轮询暂停）
-        node.writeSingleCoil = async function(slaveId, coil, value) {
-            if (!node.isConnected) {
-                node.warn('Modbus未连接');
+        // 写入队列处理函数（串行执行所有写入操作）
+        node.processWriteQueue = async function() {
+            if (node.isProcessingWrite || node.writeQueue.length === 0) {
                 return;
             }
 
-            // 暂停轮询（写操作优先）
-            node.pausePolling = true;
-            const pauseStartTime = Date.now();
+            node.isProcessingWrite = true;
+
+            while (node.writeQueue.length > 0) {
+                const task = node.writeQueue.shift();
 
-            // 等待锁释放（最多等待1000ms，减少超时时间）
-            const maxWait = 1000;
-            const startWait = Date.now();
-            let waitCount = 0;
-            while (node.modbusLock && (Date.now() - startWait) < maxWait) {
-                await new Promise(resolve => setTimeout(resolve, 10));
-                waitCount++;
+                try {
+                    if (task.type === 'single') {
+                        await node._writeSingleCoilInternal(task.slaveId, task.coil, task.value);
+                    } else if (task.type === 'multiple') {
+                        await node._writeMultipleCoilsInternal(task.slaveId, task.startCoil, task.values);
+                    }
+
+                    // 写入成功，调用回调
+                    if (task.resolve) {
+                        task.resolve();
+                    }
+                } catch (err) {
+                    // 写入失败，调用错误回调
+                    if (task.reject) {
+                        task.reject(err);
+                    }
+                }
+
+                // 等待一段时间再处理下一个任务（20ms间隔，确保总线稳定）
+                if (node.writeQueue.length > 0) {
+                    await new Promise(resolve => setTimeout(resolve, node.writeQueueInterval));
+                }
             }
 
-            if (node.modbusLock) {
-                // 强制释放锁（避免死锁）
-                node.warn(`写入线圈等待超时(${waitCount * 10}ms)，强制释放锁: 从站${slaveId} 线圈${coil}`);
-                node.modbusLock = false;
+            node.isProcessingWrite = false;
+        };
+
+        // 写单个线圈（内部实现，不经过队列）
+        node._writeSingleCoilInternal = async function(slaveId, coil, value) {
+            if (!node.isConnected) {
+                throw new Error('Modbus未连接');
             }
-            
+
+            // 暂停轮询（写操作优先）
+            node.pausePolling = true;
+            const pauseStartTime = Date.now();
+
             try {
+                // 等待锁释放（最多等待100ms，因为有队列机制，不需要等太久）
+                const maxWait = 100;
+                const startWait = Date.now();
+                while (node.modbusLock && (Date.now() - startWait) < maxWait) {
+                    await new Promise(resolve => setTimeout(resolve, 10));
+                }
+
+                if (node.modbusLock) {
+                    throw new Error(`写入线圈等待锁超时: 从站${slaveId} 线圈${coil}`);
+                }
+
                 // 设置锁
                 node.modbusLock = true;
 
@@ -1201,7 +1239,7 @@ module.exports = function(RED) {
                 node.deviceStates[slaveId].coils[coil] = value;
 
                 node.log(`写入成功: 从站${slaveId} 线圈${coil} = ${value ? 'ON' : 'OFF'}`);
-                
+
                 // 发布到MQTT和触发事件
                 node.publishMqttState(slaveId, coil, value);
                 node.emit('stateUpdate', {
@@ -1209,11 +1247,11 @@ module.exports = function(RED) {
                     coil: coil,
                     value: value
                 });
-                
+
                 // 释放锁
                 node.modbusLock = false;
-                
-                // 延迟恢复轮询（给从站响应预留时间）
+
+                // 延迟恢复轮询（给从站响应预留时间，减少到20ms）
                 setTimeout(() => {
                     node.pausePolling = false;
                     const pauseDuration = Date.now() - pauseStartTime;
@@ -1221,56 +1259,70 @@ module.exports = function(RED) {
                         node.debug(`轮询暂停 ${pauseDuration}ms，跳过 ${node.pollingPausedCount} 次轮询`);
                         node.pollingPausedCount = 0;
                     }
-                }, 100);
-                
+                }, 20);
+
             } catch (err) {
                 // 释放锁
                 node.modbusLock = false;
-                
+
                 // 恢复轮询
                 node.pausePolling = false;
                 node.pollingPausedCount = 0;
-                
+
                 node.error(`写入线圈失败: 从站${slaveId} 线圈${coil} - ${err.message}`);
-                throw err;  // 抛出错误，让调用者知道失败
+                throw err;
             }
         };
+
+        // 写单个线圈（公共接口，通过队列执行）
+        node.writeSingleCoil = function(slaveId, coil, value) {
+            return new Promise((resolve, reject) => {
+                // 添加到队列
+                node.writeQueue.push({
+                    type: 'single',
+                    slaveId: slaveId,
+                    coil: coil,
+                    value: value,
+                    resolve: resolve,
+                    reject: reject
+                });
+
+                // 触发队列处理
+                node.processWriteQueue();
+            });
+        };
         
-        // 批量写入多个线圈（带互斥锁和轮询暂停）
-        node.writeMultipleCoils = async function(slaveId, startCoil, values) {
+        // 批量写入多个线圈（内部实现，不经过队列）
+        node._writeMultipleCoilsInternal = async function(slaveId, startCoil, values) {
             if (!node.isConnected) {
-                node.warn('Modbus未连接');
-                return;
+                throw new Error('Modbus未连接');
             }
-            
+
             // 暂停轮询（从站上报优先处理）
             node.pausePolling = true;
             const pauseStartTime = Date.now();
-            
-            // 等待锁释放（最多等待500ms）
-            const maxWait = 500;
-            const startWait = Date.now();
-            while (node.modbusLock && (Date.now() - startWait) < maxWait) {
-                await new Promise(resolve => setTimeout(resolve, 10));
-            }
-            
-            if (node.modbusLock) {
-                node.error(`批量写入线圈超时: 从站${slaveId} 起始线圈${startCoil} (等待锁释放超时)`);
-                // 恢复轮询
-                node.pausePolling = false;
-                return;
-            }
-            
+
             try {
+                // 等待锁释放（最多等待100ms）
+                const maxWait = 100;
+                const startWait = Date.now();
+                while (node.modbusLock && (Date.now() - startWait) < maxWait) {
+                    await new Promise(resolve => setTimeout(resolve, 10));
+                }
+
+                if (node.modbusLock) {
+                    throw new Error(`批量写入线圈等待锁超时: 从站${slaveId} 起始线圈${startCoil}`);
+                }
+
                 // 设置锁
                 node.modbusLock = true;
-                
+
                 node.client.setID(slaveId);
                 await node.client.writeCoils(startCoil, values);
-                
+
                 // 记录写入时间（用于暂停轮询）
                 node.lastWriteTime[slaveId] = Date.now();
-                
+
                 // 更新本地状态
                 for (let i = 0; i < values.length; i++) {
                     node.deviceStates[slaveId].coils[startCoil + i] = values[i];
@@ -1282,13 +1334,13 @@ module.exports = function(RED) {
                         value: values[i]
                     });
                 }
-                
+
                 node.debug(`批量写入成功: 从站${slaveId} 起始线圈${startCoil} 共${values.length}个线圈`);
-                
+
                 // 释放锁
                 node.modbusLock = false;
-                
-                // 延迟恢复轮询（给从站响应预留时间）
+
+                // 延迟恢复轮询（给从站响应预留时间，减少到20ms）
                 setTimeout(() => {
                     node.pausePolling = false;
                     const pauseDuration = Date.now() - pauseStartTime;
@@ -1296,20 +1348,38 @@ module.exports = function(RED) {
                         node.debug(`轮询暂停 ${pauseDuration}ms，跳过 ${node.pollingPausedCount} 次轮询`);
                         node.pollingPausedCount = 0;
                     }
-                }, 100);
-                
+                }, 20);
+
             } catch (err) {
                 // 释放锁
                 node.modbusLock = false;
-                
+
                 // 恢复轮询
                 node.pausePolling = false;
                 node.pollingPausedCount = 0;
-                
+
                 node.error(`批量写入线圈失败: 从站${slaveId} 起始线圈${startCoil} - ${err.message}`);
-                throw err; // 抛出错误，让调用者知道失败
+                throw err;
             }
         };
+
+        // 批量写入多个线圈（公共接口，通过队列执行）
+        node.writeMultipleCoils = function(slaveId, startCoil, values) {
+            return new Promise((resolve, reject) => {
+                // 添加到队列
+                node.writeQueue.push({
+                    type: 'multiple',
+                    slaveId: slaveId,
+                    startCoil: startCoil,
+                    values: values,
+                    resolve: resolve,
+                    reject: reject
+                });
+
+                // 触发队列处理
+                node.processWriteQueue();
+            });
+        };
         
         // 监听内部事件（从站开关节点发送的写入命令）
         // 这是免连线通信的核心机制

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "node-red-contrib-symi-modbus",
-  "version": "2.6.8",
-  "description": "Node-RED Modbus节点，支持TCP/串口通信、串口自动搜索、多设备轮询、可选MQTT集成（支持纯本地模式和MQTT模式）、Home Assistant自动发现、HomeKit网桥和物理开关面板双向同步，工控机长期稳定运行",
+  "version": "2.7.2",
+  "description": "Node-RED Modbus节点，支持TCP/串口通信、串口自动搜索、多设备轮询、可选MQTT集成（支持纯本地模式和MQTT模式）、Home Assistant自动发现、HomeKit网桥、可视化控制看板、自定义协议转换和物理开关面板双向同步，工控机长期稳定运行",
   "main": "nodes/modbus-master.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
@@ -38,7 +38,9 @@
       "mqtt-server-config": "nodes/mqtt-server-config.js",
       "serial-port-config": "nodes/serial-port-config.js",
       "modbus-debug": "nodes/modbus-debug.js",
-      "homekit-bridge": "nodes/homekit-bridge.js"
+      "homekit-bridge": "nodes/homekit-bridge.js",
+      "modbus-dashboard": "nodes/modbus-dashboard.js",
+      "custom-protocol": "nodes/custom-protocol.js"
     }
   },
   "dependencies": {