node-red-contrib-symi-modbus 2.5.0 → 2.5.3

package/nodes/modbus-master.js

@@ -2,6 +2,7 @@ module.exports = function(RED) {
     "use strict";
     const ModbusRTU = require("modbus-serial");
     const mqtt = require("mqtt");
+    const protocol = require("./lightweight-protocol");
     
     // 串口列表API - 支持Windows、Linux、macOS所有串口设备
     RED.httpAdmin.get('/modbus-master/serialports', async function(req, res) {
@@ -90,33 +91,41 @@ module.exports = function(RED) {
         RED.nodes.createNode(this, config);
         const node = this;
         
+        // 获取Modbus服务器配置节点
+        node.modbusServerConfig = RED.nodes.getNode(config.modbusServer);
+        
         // 获取MQTT服务器配置节点
         node.mqttServerConfig = RED.nodes.getNode(config.mqttServer);
         
-        // 配置参数
+        // 配置参数（从Modbus服务器配置节点读取）
         node.config = {
-            connectionType: config.connectionType,
-            tcpHost: config.tcpHost,
-            tcpPort: parseInt(config.tcpPort),
-            serialPort: config.serialPort,
-            serialBaudRate: parseInt(config.serialBaudRate),
-            serialDataBits: parseInt(config.serialDataBits),
-            serialStopBits: parseInt(config.serialStopBits),
-            serialParity: config.serialParity,
+            connectionType: node.modbusServerConfig ? (node.modbusServerConfig.connectionType || "tcp") : "tcp",
+            tcpHost: node.modbusServerConfig ? (node.modbusServerConfig.tcpHost || "127.0.0.1") : "127.0.0.1",
+            tcpPort: node.modbusServerConfig ? (parseInt(node.modbusServerConfig.tcpPort) || 502) : 502,
+            serialPort: node.modbusServerConfig ? (node.modbusServerConfig.serialPort || "/dev/ttyUSB0") : "/dev/ttyUSB0",
+            serialBaudRate: node.modbusServerConfig ? (parseInt(node.modbusServerConfig.serialBaudRate) || 9600) : 9600,
+            serialDataBits: node.modbusServerConfig ? (parseInt(node.modbusServerConfig.serialDataBits) || 8) : 8,
+            serialStopBits: node.modbusServerConfig ? (parseInt(node.modbusServerConfig.serialStopBits) || 1) : 1,
+            serialParity: node.modbusServerConfig ? (node.modbusServerConfig.serialParity || "none") : "none",
             slaves: config.slaves || [{
                 address: 10,
                 coilStart: 0,
                 coilEnd: 31,
                 pollInterval: 200
             }],
-            enableMqtt: config.enableMqtt,
+            enableMqtt: config.enableMqtt !== false,
             // 从config节点读取MQTT配置
-            mqttBroker: node.mqttServerConfig ? node.mqttServerConfig.broker : "",
+            mqttBroker: node.mqttServerConfig ? node.mqttServerConfig.broker : "mqtt://localhost:1883",
             mqttUsername: node.mqttServerConfig ? node.mqttServerConfig.username : "",
             mqttPassword: node.mqttServerConfig ? (node.mqttServerConfig.credentials ? node.mqttServerConfig.credentials.password : "") : "",
             mqttBaseTopic: node.mqttServerConfig ? node.mqttServerConfig.baseTopic : "modbus/relay"
         };
         
+        // 验证Modbus服务器配置
+        if (!node.modbusServerConfig) {
+            node.warn('未配置Modbus服务器，将使用默认配置');
+        }
+        
         // Modbus客户端
         node.client = new ModbusRTU();
         node.isConnected = false;
@@ -132,6 +141,9 @@ module.exports = function(RED) {
         node.errorLogInterval = 10 * 60 * 1000; // 错误日志间隔：10分钟
         node.modbusLock = false; // Modbus操作互斥锁（防止读写冲突）
         node.lastWriteTime = {}; // 记录每个从站的最后写入时间
+        node.pausePolling = false; // 暂停轮询标志（从站上报时暂停）
+        node.pollingPausedCount = 0; // 暂停轮询计数器
+        node._discoveryPublished = false; // Discovery发布标志（避免重复）
         
         // 更新节点状态显示
         node.updateNodeStatus = function() {
@@ -155,7 +167,10 @@ module.exports = function(RED) {
                 lastUpdate: null,
                 error: null,
                 config: slave,  // 保存该从站的配置
-                initialPublished: false  // 标记是否已发布初始状态
+                initialPublished: false,  // 标记是否已发布初始状态
+                timeoutCount: 0,        // 连续超时次数
+                isIgnored: false,       // 是否被临时忽略（超时次数过多时）
+                lastTimeoutTime: 0      // 最后一次超时时间
             };
         });
         
@@ -163,32 +178,75 @@ module.exports = function(RED) {
         node.connectModbus = async function() {
             try {
                 if (node.config.connectionType === "tcp") {
-                    await node.client.connectTCP(node.config.tcpHost, {
-                        port: node.config.tcpPort
-                    });
-                    node.log(`已连接到TCP Modbus: ${node.config.tcpHost}:${node.config.tcpPort}`);
+                    // 验证TCP主机地址
+                    if (!node.config.tcpHost || node.config.tcpHost.trim() === '') {
+                        throw new Error('TCP主机地址未配置，请在节点配置中填写Modbus服务器IP地址');
+                    }
+
+                    const tcpMode = node.config.tcpMode || "telnet";
+                    const modeNames = {
+                        "telnet": "Telnet ASCII",
+                        "rtu": "RTU over TCP",
+                        "tcp": "Modbus TCP"
+                    };
+
+                    node.log(`正在连接TCP网关（${modeNames[tcpMode]}）: ${node.config.tcpHost}:${node.config.tcpPort}...`);
+
+                    if (tcpMode === "telnet") {
+                        await node.client.connectTelnet(node.config.tcpHost, {
+                            port: node.config.tcpPort
+                        });
+                    } else if (tcpMode === "rtu") {
+                        await node.client.connectTcpRTUBuffered(node.config.tcpHost, {
+                            port: node.config.tcpPort
+                        });
+                    } else {
+                        await node.client.connectTCP(node.config.tcpHost, {
+                            port: node.config.tcpPort
+                        });
+                    }
+
+                    node.log(`TCP网关连接成功（${modeNames[tcpMode]}）: ${node.config.tcpHost}:${node.config.tcpPort}`);
                 } else {
                     await node.client.connectRTUBuffered(node.config.serialPort, {
-                        baudRate: node.config.serialBaudRate,
-                        dataBits: node.config.serialDataBits,
-                        stopBits: node.config.serialStopBits,
-                        parity: node.config.serialParity
+                        baudRate: node.config.serialBaudRate || 9600,
+                        dataBits: node.config.serialDataBits || 8,
+                        stopBits: node.config.serialStopBits || 1,
+                        parity: node.config.serialParity || 'none'
                     });
-                    node.log(`已连接到串口 Modbus: ${node.config.serialPort}`);
+                    node.log(`串口Modbus连接成功: ${node.config.serialPort} @ ${node.config.serialBaudRate || 9600}bps`);
                 }
-                
-                node.client.setTimeout(5000);
+
+                // 设置超时时间（串口需要更长的超时时间）
+                const timeout = node.config.connectionType === "serial" ? 10000 : 5000;
+                node.client.setTimeout(timeout);
+                node.log(`Modbus超时设置: ${timeout}ms`);
                 node.isConnected = true;
                 node.log(`Modbus已连接: ${node.config.connectionType === "tcp" ? `${node.config.tcpHost}:${node.config.tcpPort}` : node.config.serialPort}`);
                 node.updateNodeStatus();
-                
+
                 // 清除错误日志记录（重新部署或重连时允许再次显示错误）
                 node.lastErrorLog = {};
                 node.lastMqttErrorLog = 0;
-                
-                // 启动轮询
-                node.startPolling();
-                
+                node._discoveryPublished = false;  // 重置Discovery发布标志
+
+                // 添加Symi按键事件监听（串口模式）
+                if (node.config.connectionType === "serial" && node.client._port) {
+                    node.client._port.on('data', (data) => {
+                        node.handleSymiButtonEvent(data);
+                    });
+                    node.log('已启用Symi按键事件监听（串口模式）');
+                }
+
+                // 立即启动轮询（不等待MQTT连接）
+                // 修复：确保轮询在Modbus连接成功后立即启动，不依赖MQTT状态
+                if (!node.pollTimer) {
+                    node.log('Modbus连接成功，立即启动轮询...');
+                    node.startPolling();
+                } else {
+                    node.log('轮询已在运行中');
+                }
+
             } catch (err) {
                 node.error(`Modbus连接失败: ${err.message}`);
                 node.isConnected = false;
@@ -281,6 +339,7 @@ module.exports = function(RED) {
         // 连接MQTT（带智能重试和fallback）
         node.connectMqtt = function() {
             if (!node.config.enableMqtt) {
+                node.log('MQTT未启用，跳过MQTT连接');
                 return;
             }
             
@@ -299,7 +358,7 @@ module.exports = function(RED) {
             node.log(`正在连接MQTT broker: ${brokerCandidates[0]}`);
             
             const options = {
-                clientId: `modbus_master_${Math.random().toString(16).substr(2, 8)}`,
+                clientId: `modbus_master_${Math.random().toString(16).substring(2, 10)}`,
                 clean: false,  // 持久化会话，断线重连后继续接收消息
                 reconnectPeriod: 0,  // 禁用自动重连，我们手动管理
                 connectTimeout: 5000,  // 5秒连接超时
@@ -309,9 +368,7 @@ module.exports = function(RED) {
             if (node.config.mqttUsername) {
                 options.username = node.config.mqttUsername;
                 options.password = node.config.mqttPassword;
-                node.log(`MQTT认证: 用户名=${node.config.mqttUsername}, 密码已设置=${!!node.config.mqttPassword}`);
-            } else {
-                node.warn('MQTT未配置认证信息，如果broker需要认证将会连接失败');
+                node.log(`MQTT认证: 用户名=${node.config.mqttUsername}`);
             }
             
             // 尝试连接函数
@@ -332,18 +389,20 @@ module.exports = function(RED) {
                     node.mqttClient.on('connect', () => {
                         node.mqttConnected = true;
                         node.log(`MQTT已连接: ${brokerUrl}`);
-                        
+
                         // 成功连接后，更新配置的broker地址（下次优先使用成功的地址）
                         if (brokerUrl !== brokerCandidates[0]) {
                             node.log(`使用fallback地址成功: ${brokerUrl}（原配置: ${brokerCandidates[0]}）`);
                         }
-                        
-                        // 发送设备发现消息（Home Assistant MQTT Discovery）
-                        node.publishDiscovery();
-                        
+
+                        // 异步发送设备发现消息（避免阻塞事件循环）
+                        setImmediate(() => {
+                            node.publishDiscovery();
+                        });
+
                         // 订阅命令主题
                         node.subscribeCommands();
-                        
+
                         // 更新状态显示
                         node.updateNodeStatus();
                     });
@@ -454,6 +513,12 @@ module.exports = function(RED) {
                 return;
             }
             
+            // 检查是否已经发布过（避免重复）
+            if (node._discoveryPublished) {
+                node.log('Discovery已发布，跳过重复发布');
+                return;
+            }
+            
             let discoveryCount = 0;
             
             node.config.slaves.forEach((slave) => {
@@ -464,7 +529,7 @@ module.exports = function(RED) {
                 node.mqttClient.publish(availabilityTopic, 'online', { retain: true });
                 
                 for (let coil = slave.coilStart; coil <= slave.coilEnd; coil++) {
-                    // 使用稳定的唯一ID：从站地址_线圈编号
+                    // 使用稳定的唯一ID：从站地址_线圈编号（确保全局唯一）
                     const uniqueId = `modbus_relay_${slaveId}_${coil}`;
                     const objectId = `relay_${slaveId}_${coil}`;
                     const discoveryTopic = `homeassistant/switch/${uniqueId}/config`;
@@ -506,15 +571,11 @@ module.exports = function(RED) {
                     };
                     
                     // 发布发现消息（retain=true 确保HA重启后仍能发现）
+                    // 使用QoS=0避免阻塞，发现消息只需发送一次即可
                     node.mqttClient.publish(
                         discoveryTopic,
                         JSON.stringify(discoveryPayload),
-                        { retain: true, qos: 1 },
-                        (err) => {
-                            if (err) {
-                                node.error(`发布发现消息失败 ${uniqueId}: ${err.message}`);
-                            }
-                        }
+                        { retain: true, qos: 0 }
                     );
                     
                     discoveryCount++;
@@ -523,6 +584,9 @@ module.exports = function(RED) {
             
             const slaveAddresses = node.config.slaves.map(s => s.address).join(', ');
             node.log(`已发布 ${discoveryCount} 个MQTT发现消息（从站地址: ${slaveAddresses}）`);
+            
+            // 标记为已发布（避免重复）
+            node._discoveryPublished = true;
         };
         
         // 订阅命令主题
@@ -542,109 +606,179 @@ module.exports = function(RED) {
             });
         };
         
-        // 处理MQTT命令（异步）
+        // MQTT命令队列（去重 + 防抖）
+        node.mqttCommandQueue = new Map(); // key: "slaveId_coil", value: {slaveId, coil, value, timestamp}
+        node.mqttCommandTimer = null;
+        node.mqttCommandDebounceMs = 50; // 防抖时间：50ms
+
+        // 处理MQTT命令队列
+        node.processMqttCommandQueue = async function() {
+            if (node.mqttCommandQueue.size === 0) {
+                return;
+            }
+
+            // 获取所有待处理命令
+            const commands = Array.from(node.mqttCommandQueue.values());
+            node.mqttCommandQueue.clear();
+
+            // 按优先级排序：物理按键 > HA控制
+            // 这里简化处理，直接按时间戳排序（最新的优先）
+            commands.sort((a, b) => b.timestamp - a.timestamp);
+
+            // 批量执行命令
+            for (const cmd of commands) {
+                try {
+                    await node.writeSingleCoil(cmd.slaveId, cmd.coil, cmd.value);
+                } catch (err) {
+                    node.error(`MQTT命令执行失败: 从站${cmd.slaveId} 线圈${cmd.coil} - ${err.message}`);
+                }
+            }
+        };
+
+        // 处理MQTT命令（异步 + 去重 + 防抖）
         node.handleMqttCommand = async function(topic, message) {
             const parts = topic.split('/');
             if (parts.length < 4) {
                 return;
             }
-            
+
             const slaveId = parseInt(parts[parts.length - 3]);
             const coil = parseInt(parts[parts.length - 2]);
             const command = message.toString();
-            
+
             const value = (command === 'ON' || command === 'true' || command === '1');
-            
-            node.log(`MQTT命令: 从站${slaveId} 线圈${coil} = ${value}`);
-            
-            // 写入线圈（异步执行，捕获错误）
-            try {
-                await node.writeSingleCoil(slaveId, coil, value);
-            } catch (err) {
-                node.error(`MQTT命令执行失败: 从站${slaveId} 线圈${coil} - ${err.message}`);
+
+            // 添加到队列（去重：相同从站+线圈的命令只保留最新的）
+            const key = `${slaveId}_${coil}`;
+            node.mqttCommandQueue.set(key, {
+                slaveId,
+                coil,
+                value,
+                timestamp: Date.now()
+            });
+
+            // 防抖：延迟执行，合并短时间内的多个命令
+            if (node.mqttCommandTimer) {
+                clearTimeout(node.mqttCommandTimer);
             }
+
+            node.mqttCommandTimer = setTimeout(() => {
+                node.mqttCommandTimer = null;
+                node.processMqttCommandQueue();
+            }, node.mqttCommandDebounceMs);
         };
         
         // 发布MQTT状态
         node.publishMqttState = function(slaveId, coil, value) {
             if (!node.mqttClient || !node.mqttClient.connected) {
-                node.warn(`无法发布状态: MQTT未连接 (从站${slaveId} 线圈${coil})`);
+                // 不输出警告，避免日志过多
                 return;
             }
-            
+
             const stateTopic = `${node.config.mqttBaseTopic}/${slaveId}/${coil}/state`;
             const payload = value ? 'ON' : 'OFF';
-            
-            // 使用QoS=1确保消息送达，retain=true确保断线重连后可获取最新状态
-            node.mqttClient.publish(stateTopic, payload, { qos: 1, retain: true }, (err) => {
+
+            // 使用QoS=0提高性能，retain=true确保断线重连后可获取最新状态
+            // QoS=0不等待确认，避免阻塞轮询
+            node.mqttClient.publish(stateTopic, payload, { qos: 0, retain: true }, (err) => {
                 if (err) {
-                    node.warn(`发布状态失败: ${stateTopic} - ${err.message}`);
-                } else {
-                    node.log(`发布状态: ${stateTopic} = ${payload}`);
+                    // 只在首次错误时输出警告
+                    if (!node.lastMqttPublishError || Date.now() - node.lastMqttPublishError > 60000) {
+                        node.warn(`发布状态失败: ${stateTopic} - ${err.message}`);
+                        node.lastMqttPublishError = Date.now();
+                    }
                 }
             });
         };
         
-        // 开始轮询
+        // 开始轮询（使用递归调用而非定时器，避免并发）
         node.startPolling = function() {
-            if (node.pollTimer) {
+            if (node.isPolling) {
                 return;
             }
-            
+
             // 清除错误日志记录（重新开始轮询时允许显示错误）
             node.lastErrorLog = {};
             node.lastMqttErrorLog = 0;
-            
-            const slaveList = node.config.slaves.map(s => `从站${s.address}(线圈${s.coilStart}-${s.coilEnd})`).join(', ');
+
+            const slaveList = node.config.slaves.map(s => `从站${s.address}(线圈${s.coilStart}-${s.coilEnd},间隔${s.pollInterval}ms)`).join(', ');
             node.log(`开始轮询 ${node.config.slaves.length} 个从站设备: ${slaveList}`);
             node.log(`Modbus连接: ${node.isConnected ? '已连接' : '未连接'}, MQTT连接: ${node.mqttConnected ? '已连接' : '未连接'}`);
             node.currentSlaveIndex = 0;
-            
-            // 使用最小的轮询间隔
-            const minInterval = Math.min(...node.config.slaves.map(s => s.pollInterval));
-            
-            node.pollTimer = setInterval(() => {
-                node.pollNextSlave().catch(err => {
+            node.isPolling = true;
+
+            // 使用递归调用实现轮询，确保不会并发
+            const pollLoop = async () => {
+                if (!node.isPolling || !node.isConnected || node.isClosing) {
+                    return;
+                }
+
+                // 获取当前从站配置（在轮询前获取，确保使用正确的间隔）
+                const currentSlave = node.config.slaves[node.currentSlaveIndex];
+                if (!currentSlave) {
+                    node.warn(`从站索引${node.currentSlaveIndex}无效，重置为0`);
+                    node.currentSlaveIndex = 0;
+                    return;
+                }
+
+                const interval = currentSlave.pollInterval || 200;
+
+                try {
+                    await node.pollNextSlave();
+                } catch (err) {
                     node.error(`轮询错误: ${err.message}`);
-                });
-            }, minInterval);
-            
-            // 立即执行一次
-            node.pollNextSlave().catch(err => {
-                node.error(`轮询错误: ${err.message}`);
-            });
+                }
+
+                // 等待指定间隔后继续下一次轮询
+                node.pollTimer = setTimeout(pollLoop, interval);
+            };
+
+            // 立即开始轮询
+            pollLoop();
         };
         
         // 停止轮询
         node.stopPolling = function() {
+            node.isPolling = false;
             if (node.pollTimer) {
-                clearInterval(node.pollTimer);
+                clearTimeout(node.pollTimer);
                 node.pollTimer = null;
                 node.log('停止轮询');
             }
         };
         
-        // 轮询下一个从站
+        // 轮询下一个从站（串行执行，不会并发）
         node.pollNextSlave = async function() {
             if (!node.isConnected || node.isClosing) {
                 return;
             }
-            
-            // 检查互斥锁
-            if (node.modbusLock) {
-                return;  // 有写操作正在进行，跳过本次轮询
+
+            // 检查是否暂停轮询（从站上报时优先处理）
+            if (node.pausePolling) {
+                node.pollingPausedCount++;
+                return;  // 暂停轮询，优先处理从站上报
             }
-            
+
             // 获取当前从站配置
             const slave = node.config.slaves[node.currentSlaveIndex];
             if (!slave) {
+                node.warn(`从站索引${node.currentSlaveIndex}无效，重置为0`);
                 node.currentSlaveIndex = 0;
                 return;
             }
-            
+
             const slaveId = slave.address;
+            const deviceState = node.deviceStates[slaveId];
+
+            // 检查该从站是否被临时忽略（连续超时过多）
+            if (deviceState.isIgnored) {
+                // 移动到下一个从站
+                node.currentSlaveIndex = (node.currentSlaveIndex + 1) % node.config.slaves.length;
+                return;
+            }
+
             const coilCount = slave.coilEnd - slave.coilStart + 1;
-            
+
             // 检查是否刚写入过（写入后100ms内不轮询该从站，避免读到旧值）
             const lastWrite = node.lastWriteTime[slaveId] || 0;
             const timeSinceWrite = Date.now() - lastWrite;
@@ -653,33 +787,40 @@ module.exports = function(RED) {
                 node.currentSlaveIndex = (node.currentSlaveIndex + 1) % node.config.slaves.length;
                 return;
             }
-            
+
+            // 检查锁状态（如果有写操作正在进行，跳过本次轮询）
+            if (node.modbusLock) {
+                // 移动到下一个从站
+                node.currentSlaveIndex = (node.currentSlaveIndex + 1) % node.config.slaves.length;
+                return;
+            }
+
             try {
-                // 设置锁
+                // 设置锁（防止轮询期间有写操作）
                 node.modbusLock = true;
-                
+
                 node.client.setID(slaveId);
-                
+
                 // 读取线圈状态（功能码01）
                 const data = await node.client.readCoils(slave.coilStart, coilCount);
-                
-                // 释放锁
-                node.modbusLock = false;
-                
+
                 // 更新设备状态
                 const isFirstPoll = !node.deviceStates[slaveId].initialPublished;
                 let publishCount = 0;
-                
+
                 for (let i = 0; i < coilCount; i++) {
                     const coilIndex = slave.coilStart + i;
                     const oldValue = node.deviceStates[slaveId].coils[coilIndex];
                     const newValue = data.data[i];
-                    
+
                     node.deviceStates[slaveId].coils[coilIndex] = newValue;
-                    
+
                     // 第一次轮询或状态改变时，发布到MQTT和触发事件
                     if (isFirstPoll || oldValue !== newValue) {
-                        node.publishMqttState(slaveId, coilIndex, newValue);
+                        // 异步发布MQTT，不阻塞轮询
+                        setImmediate(() => {
+                            node.publishMqttState(slaveId, coilIndex, newValue);
+                        });
                         publishCount++;
                         node.emit('stateUpdate', {
                             slave: slaveId,
@@ -688,17 +829,21 @@ module.exports = function(RED) {
                         });
                     }
                 }
-                
+
                 if (isFirstPoll) {
-                    node.log(`从站${slaveId}首次轮询成功，发布${publishCount}个状态到MQTT`);
+                    node.log(`从站${slaveId}首次轮询成功，读取${coilCount}个线圈`);
                 } else if (publishCount > 0) {
-                    node.log(`从站${slaveId}状态变化，发布${publishCount}个更新到MQTT`);
+                    node.log(`从站${slaveId}状态变化: ${publishCount}个线圈`);
                 }
-                
+
                 node.deviceStates[slaveId].lastUpdate = Date.now();
                 node.deviceStates[slaveId].error = null;
-                node.deviceStates[slaveId].initialPublished = true;  // 标记已发布初始状态
-                
+                node.deviceStates[slaveId].initialPublished = true;
+
+                // 轮询成功，重置超时计数
+                node.deviceStates[slaveId].timeoutCount = 0;
+                node.deviceStates[slaveId].isIgnored = false;
+
                 // 输出消息
                 const output = {
                     payload: {
@@ -710,46 +855,78 @@ module.exports = function(RED) {
                         timestamp: node.deviceStates[slaveId].lastUpdate
                     }
                 };
-                
+
                 node.send(output);
-                
+
                 // 更新状态显示
                 node.updateNodeStatus();
-                
+
+                // 释放锁
+                node.modbusLock = false;
+
             } catch (err) {
+
                 // 释放锁
                 node.modbusLock = false;
-                
+
                 node.deviceStates[slaveId].error = err.message;
-                
+                node.deviceStates[slaveId].lastTimeoutTime = Date.now();
+
                 // 日志限流：每个从站的错误日志最多每10分钟输出一次
                 const now = Date.now();
                 const lastLogTime = node.lastErrorLog[slaveId] || 0;
                 const shouldLog = (now - lastLogTime) > node.errorLogInterval;
-                
-                if (shouldLog) {
-                    node.warn(`轮询从站${slaveId}失败（不影响其他从站）: ${err.message} [此错误将在10分钟后再次显示]`);
-                    node.lastErrorLog[slaveId] = now;
+
+                // 检查是否是超时错误
+                const isTimeout = err.message && (
+                    err.message.includes('Timed out') ||
+                    err.message.includes('ETIMEDOUT') ||
+                    err.message.includes('timeout')
+                );
+
+                if (isTimeout) {
+                    // 增加超时计数
+                    node.deviceStates[slaveId].timeoutCount++;
+
+                    // 连续超时5次后临时忽略该从站（避免拖慢其他从站）
+                    if (node.deviceStates[slaveId].timeoutCount >= 5) {
+                        node.deviceStates[slaveId].isIgnored = true;
+                        if (shouldLog) {
+                            node.warn(`从站${slaveId}连续超时${node.deviceStates[slaveId].timeoutCount}次，临时忽略该从站（重启或重新部署后恢复）`);
+                            node.lastErrorLog[slaveId] = now;
+                        }
+                    } else {
+                        if (shouldLog) {
+                            node.warn(`从站${slaveId}轮询失败: ${err.message} (线圈${slave.coilStart}-${slave.coilEnd}) [超时${node.deviceStates[slaveId].timeoutCount}/5]`);
+                            node.lastErrorLog[slaveId] = now;
+                        }
+                    }
+                } else {
+                    // 非超时错误，记录日志
+                    if (shouldLog) {
+                        node.warn(`从站${slaveId}轮询失败: ${err.message} (线圈${slave.coilStart}-${slave.coilEnd})`);
+                        node.lastErrorLog[slaveId] = now;
+                    }
                 }
-                
+
                 // 更新状态显示
                 node.updateNodeStatus();
-                
+
                 // 检测是否是连接断开错误
-                if (err.message && 
-                    (err.message.includes('ECONNRESET') || 
-                     err.message.includes('ETIMEDOUT') || 
+                if (err.message &&
+                    (err.message.includes('ECONNRESET') ||
+                     err.message.includes('ETIMEDOUT') ||
                      err.message.includes('ENOTCONN') ||
                      err.message.includes('Port Not Open'))) {
-                    
+
                     // 连接断开，尝试重连
                     if (shouldLog) {
                         node.warn('检测到连接断开，尝试重连...');
                     }
-                    
+
                     node.isConnected = false;
                     node.stopPolling();
-                    
+
                     // 关闭当前连接
                     if (node.client && node.client.isOpen) {
                         try {
@@ -758,7 +935,7 @@ module.exports = function(RED) {
                             // 忽略关闭错误
                         }
                     }
-                    
+
                     // 尝试重连
                     if (!node.isClosing && !node.reconnectTimer) {
                         node.reconnectTimer = setTimeout(() => {
@@ -768,28 +945,102 @@ module.exports = function(RED) {
                     }
                 }
             }
-            
+
             // 移动到下一个从站
             node.currentSlaveIndex = (node.currentSlaveIndex + 1) % node.config.slaves.length;
         };
         
-        // 写单个线圈（带互斥锁）
+        // 处理Symi按键事件（私有协议）
+        node.handleSymiButtonEvent = function(data) {
+            try {
+                // 解析Symi协议帧
+                const frame = protocol.parseFrame(data);
+                if (!frame) {
+                    return; // 不是有效的Symi帧，忽略
+                }
+
+                // 只处理SET类型(0x03)的按键事件，忽略REPORT类型(0x04)
+                // REPORT类型是面板对我们指令的确认，不是按键事件
+                if (frame.dataType !== 0x03) {
+                    return; // 不是按键事件
+                }
+
+                // 检查是否是灯光设备
+                if (frame.deviceType !== 0x01) {
+                    return; // 不是灯光设备
+                }
+
+                // 提取按键信息
+                const deviceAddr = frame.deviceAddr;  // 设备地址（1-255）
+                const channel = frame.channel;        // 通道号（1-8）
+                const state = frame.opInfo[0] === 0x01; // 状态（1=开，0=关）
+
+                node.log(`Symi按键事件: 设备${deviceAddr} 通道${channel} 状态=${state ? 'ON' : 'OFF'}`);
+
+                // 查找对应的从站和线圈
+                // 假设：设备地址1对应从站10，设备地址2对应从站11，以此类推
+                // 通道号直接对应线圈号（1-8 → 0-7）
+                const slaveId = 10 + (deviceAddr - 1);
+                const coilNumber = channel - 1;
+
+                // 检查从站是否在配置中
+                const slaveConfig = node.config.slaves.find(s => s.address === slaveId);
+                if (!slaveConfig) {
+                    node.warn(`Symi按键事件: 从站${slaveId}未配置，忽略`);
+                    return;
+                }
+
+                // 检查线圈是否在范围内
+                if (coilNumber < slaveConfig.coilStart || coilNumber > slaveConfig.coilEnd) {
+                    node.warn(`Symi按键事件: 线圈${coilNumber}不在从站${slaveId}的范围内（${slaveConfig.coilStart}-${slaveConfig.coilEnd}），忽略`);
+                    return;
+                }
+
+                node.log(`Symi按键映射: 设备${deviceAddr}通道${channel} → 从站${slaveId}线圈${coilNumber}`);
+
+                // 写入线圈（异步，不阻塞）
+                node.writeSingleCoil(slaveId, coilNumber, state).catch(err => {
+                    node.error(`Symi按键控制失败: ${err.message}`);
+                });
+
+                // 发送应答帧（REPORT类型0x04，反馈LED状态）
+                // 协议规定：面板发送0x03(SET)按键事件，主机应该用0x04(REPORT)反馈LED状态
+                const responseFrame = protocol.buildSingleLightReport(0x01, deviceAddr, channel, state);
+                if (node.client._port && node.client._port.write) {
+                    node.client._port.write(responseFrame);
+                    node.log(`Symi应答已发送(REPORT): 设备${deviceAddr} 通道${channel} 状态=${state ? 'ON' : 'OFF'}`);
+                }
+
+            } catch (err) {
+                // 静默处理错误，避免干扰Modbus通信
+                // node.warn(`Symi按键事件处理错误: ${err.message}`);
+            }
+        };
+
+        // 写单个线圈（带互斥锁和轮询暂停）
         node.writeSingleCoil = async function(slaveId, coil, value) {
             if (!node.isConnected) {
                 node.warn('Modbus未连接');
                 return;
             }
-            
-            // 等待锁释放（最多等待6秒，因为Modbus超时是5秒）
-            const maxWait = 6000;
+
+            // 暂停轮询（写操作优先）
+            node.pausePolling = true;
+            const pauseStartTime = Date.now();
+
+            // 等待锁释放（最多等待1000ms，减少超时时间）
+            const maxWait = 1000;
             const startWait = Date.now();
+            let waitCount = 0;
             while (node.modbusLock && (Date.now() - startWait) < maxWait) {
-                await new Promise(resolve => setTimeout(resolve, 50));
+                await new Promise(resolve => setTimeout(resolve, 10));
+                waitCount++;
             }
-            
+
             if (node.modbusLock) {
-                node.error(`写入线圈超时: 从站${slaveId} 线圈${coil} (等待锁释放超时，轮询可能阻塞)`);
-                return;
+                // 强制释放锁（避免死锁）
+                node.warn(`写入线圈等待超时(${waitCount * 10}ms)，强制释放锁: 从站${slaveId} 线圈${coil}`);
+                node.modbusLock = false;
             }
             
             try {
@@ -818,31 +1069,51 @@ module.exports = function(RED) {
                 // 释放锁
                 node.modbusLock = false;
                 
+                // 延迟恢复轮询（给从站响应预留时间）
+                setTimeout(() => {
+                    node.pausePolling = false;
+                    const pauseDuration = Date.now() - pauseStartTime;
+                    if (node.pollingPausedCount > 0) {
+                        node.log(`轮询暂停 ${pauseDuration}ms，跳过 ${node.pollingPausedCount} 次轮询`);
+                        node.pollingPausedCount = 0;
+                    }
+                }, 100);
+                
             } catch (err) {
                 // 释放锁
                 node.modbusLock = false;
                 
+                // 恢复轮询
+                node.pausePolling = false;
+                node.pollingPausedCount = 0;
+                
                 node.error(`写入线圈失败: 从站${slaveId} 线圈${coil} - ${err.message}`);
                 throw err;  // 抛出错误，让调用者知道失败
             }
         };
         
-        // 批量写入多个线圈（带互斥锁）
+        // 批量写入多个线圈（带互斥锁和轮询暂停）
         node.writeMultipleCoils = async function(slaveId, startCoil, values) {
             if (!node.isConnected) {
                 node.warn('Modbus未连接');
                 return;
             }
             
-            // 等待锁释放（最多等待6秒，因为Modbus超时是5秒）
-            const maxWait = 6000;
+            // 暂停轮询（从站上报优先处理）
+            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, 50));
+                await new Promise(resolve => setTimeout(resolve, 10));
             }
             
             if (node.modbusLock) {
-                node.error(`批量写入线圈超时: 从站${slaveId} 起始线圈${startCoil} (等待锁释放超时，轮询可能阻塞)`);
+                node.error(`批量写入线圈超时: 从站${slaveId} 起始线圈${startCoil} (等待锁释放超时)`);
+                // 恢复轮询
+                node.pausePolling = false;
                 return;
             }
             
@@ -873,10 +1144,24 @@ module.exports = function(RED) {
                 // 释放锁
                 node.modbusLock = false;
                 
+                // 延迟恢复轮询（给从站响应预留时间）
+                setTimeout(() => {
+                    node.pausePolling = false;
+                    const pauseDuration = Date.now() - pauseStartTime;
+                    if (node.pollingPausedCount > 0) {
+                        node.log(`轮询暂停 ${pauseDuration}ms，跳过 ${node.pollingPausedCount} 次轮询`);
+                        node.pollingPausedCount = 0;
+                    }
+                }, 100);
+                
             } catch (err) {
                 // 释放锁
                 node.modbusLock = false;
                 
+                // 恢复轮询
+                node.pausePolling = false;
+                node.pollingPausedCount = 0;
+                
                 node.error(`批量写入线圈失败: 从站${slaveId} 起始线圈${startCoil} - ${err.message}`);
                 throw err; // 抛出错误，让调用者知道失败
             }
@@ -955,29 +1240,49 @@ module.exports = function(RED) {
                 node.publishOfflineStatus();
             }
             
+            // 清理设备状态缓存（释放内存）
+            node.deviceStates = {};
+            node.lastErrorLog = {};
+            node.lastWriteTime = {};
+            node.lastMqttErrorLog = 0;
+            
             // 关闭Modbus连接
-            if (node.client && node.isConnected) {
+            if (node.client) {
                 try {
-                    node.client.close(() => {
-                        node.log('Modbus连接已关闭');
-                    });
+                    if (node.client.isOpen) {
+                        node.client.close(() => {
+                            node.log('Modbus连接已关闭');
+                        });
+                    }
                 } catch (err) {
                     node.warn(`关闭Modbus连接时出错: ${err.message}`);
                 }
+                node.client = null;  // 释放引用
             }
             
             // 关闭MQTT连接
-            if (node.mqttClient && node.mqttClient.connected) {
+            if (node.mqttClient) {
                 try {
-                    // 等待离线消息发送后再关闭
-                    setTimeout(() => {
-                        node.mqttClient.end(false, () => {
-                            node.log('MQTT连接已关闭');
-                            done();
-                        });
-                    }, 100);
+                    if (node.mqttClient.connected) {
+                        // 移除所有监听器（防止内存泄漏）
+                        node.mqttClient.removeAllListeners();
+                        
+                        // 等待离线消息发送后再关闭
+                        setTimeout(() => {
+                            node.mqttClient.end(false, () => {
+                                node.log('MQTT连接已关闭');
+                                node.mqttClient = null;  // 释放引用
+                                done();
+                            });
+                        }, 100);
+                    } else {
+                        node.mqttClient.removeAllListeners();
+                        node.mqttClient = null;
+                        done();
+                    }
                 } catch (err) {
                     node.warn(`关闭MQTT连接时出错: ${err.message}`);
+                    node.mqttClient = null;
                     done();
                 }
             } else {