node-red-contrib-symi-modbus 2.7.5 → 2.7.7

package/nodes/modbus-slave-switch.js

@@ -2,10 +2,256 @@ module.exports = function(RED) {
     "use strict";
     const mqtt = require("mqtt");
     const protocol = require("./lightweight-protocol");
+    const meshProtocol = require("./mesh-protocol")(RED);
+    const storage = require('node-persist');
+    const path = require('path');
+    const os = require('os');
 
     // 全局防抖缓存：防止多个节点重复处理同一个按键事件
     const globalDebounceCache = new Map();  // key: "switchId-buttonNumber", value: timestamp
     
+    // 初始化Mesh设备持久化存储
+    const meshPersistDir = path.join(RED.settings.userDir || os.homedir() + '/.node-red', 'mesh-devices-persist');
+    let meshStorageInitialized = false;
+
+    async function initMeshStorage() {
+        if (meshStorageInitialized) {
+            return;
+        }
+        try {
+            await storage.init({
+                dir: meshPersistDir,
+                stringify: JSON.stringify,
+                parse: JSON.parse,
+                encoding: 'utf8',
+                logging: false,
+                ttl: false,
+                expiredInterval: 2 * 60 * 1000,
+                forgiveParseErrors: true
+            });
+            meshStorageInitialized = true;
+            RED.log.info(`Mesh设备持久化存储初始化成功: ${meshPersistDir}`);
+        } catch (err) {
+            RED.log.error(`Mesh设备持久化存储初始化失败: ${err.message}`);
+            throw err;
+        }
+    }
+
+    // Mesh设备发现API（使用共享连接）
+    RED.httpAdmin.post('/symi-mesh/discover', async function(req, res) {
+        try {
+            const serialPortConfigId = req.body.serialPortConfig;
+            RED.log.info(`[Mesh设备发现] 收到请求，连接配置ID: ${serialPortConfigId}`);
+
+            if (!serialPortConfigId) {
+                RED.log.warn('[Mesh设备发现] 缺少连接配置参数');
+                return res.status(400).json({error: '缺少连接配置'});
+            }
+
+            // 获取配置节点
+            const serialPortConfig = RED.nodes.getNode(serialPortConfigId);
+            if (!serialPortConfig) {
+                RED.log.warn(`[Mesh设备发现] 连接配置节点不存在: ${serialPortConfigId}`);
+                return res.status(400).json({error: '连接配置不存在，请先创建RS-485连接配置'});
+            }
+
+            RED.log.info(`[Mesh设备发现] 配置节点类型: ${serialPortConfig.type || '未知'}`);
+            RED.log.info(`[Mesh设备发现] 连接类型: ${serialPortConfig.connectionType || '串口'}`);
+
+            // 初始化持久化存储
+            await initMeshStorage();
+
+            // 发送设备列表请求
+            const requestFrame = meshProtocol.buildGetDeviceListFrame();
+            RED.log.info(`[Mesh设备发现] 发送设备列表请求: ${requestFrame.toString('hex').toUpperCase()}`);
+
+            // 设置响应超时
+            let timeoutHandle;
+            let isCompleted = false;
+            let dataHandler = null;
+
+            const completeRequest = async (devices, reason) => {
+                if (isCompleted) return;
+                isCompleted = true;
+
+                clearTimeout(timeoutHandle);
+
+                // 注销数据监听器
+                if (dataHandler) {
+                    serialPortConfig.unregisterDataListener(dataHandler);
+                    RED.log.info(`[Mesh设备发现] 已注销数据监听器`);
+                }
+
+                if (devices.length === 0) {
+                    RED.log.warn(`[Mesh设备发现] 未发现设备 (${reason || '超时'})`);
+                } else {
+                    RED.log.info(`[Mesh设备发现] 发现 ${devices.length} 个设备`);
+
+                    // 持久化保存设备列表（MAC地址 → 短地址映射）
+                    const deviceMap = {};
+                    devices.forEach(device => {
+                        deviceMap[device.mac] = {
+                            shortAddr: device.shortAddr,
+                            type: device.type,
+                            buttons: device.buttons,
+                            lastUpdate: Date.now()
+                        };
+                        RED.log.info(`  - MAC: ${device.mac}, 短地址: ${device.shortAddr}, 类型: ${device.type}, 按键数: ${device.buttons}`);
+                    });
+
+                    await storage.setItem('meshDeviceMap', deviceMap);
+                    RED.log.info(`[Mesh设备发现] 设备列表已保存到持久化存储`);
+                }
+
+                res.json(devices);
+            };
+
+            timeoutHandle = setTimeout(() => {
+                RED.log.warn(`[Mesh设备发现] 5秒超时，未收到完整响应`);
+                completeRequest([], '超时');
+            }, 5000);
+
+            // 收集响应帧
+            const responseFrames = [];
+            let totalDevices = 0;
+            let receivedDevices = 0;
+            let buffer = Buffer.alloc(0);
+
+            dataHandler = (data) => {
+                // 拼接数据到缓冲区
+                buffer = Buffer.concat([buffer, data]);
+                RED.log.info(`[Mesh设备发现] 收到数据: ${data.toString('hex').toUpperCase()}, 缓冲区总长: ${buffer.length}`);
+
+                // 解析所有完整的帧
+                // 协议格式: 53 92 00 10 [总数] [索引] [MAC 6字节] [短地址 2字节] [vendor_id 2字节] [dev_type] [dev_sub_type] [online/status] [resv] [校验]
+                // 总长度: 1+1+1+1+16+1 = 21字节
+                while (buffer.length >= 21) {
+                    // 查找帧头 0x53
+                    const headerIndex = buffer.indexOf(0x53);
+                    if (headerIndex === -1) {
+                        buffer = Buffer.alloc(0);
+                        break;
+                    }
+
+                    if (headerIndex > 0) {
+                        buffer = buffer.slice(headerIndex);
+                    }
+
+                    if (buffer.length < 21) break;
+
+                    // 检查是否是设备列表响应 (0x53 0x92 0x00 0x10)
+                    if (buffer[1] !== 0x92 || buffer[2] !== 0x00 || buffer[3] !== 0x10) {
+                        buffer = buffer.slice(1);
+                        continue;
+                    }
+
+                    // 提取完整帧（21字节）
+                    const frame = buffer.slice(0, 21);
+                    buffer = buffer.slice(21);
+
+                    // 解析帧数据
+                    const deviceCount = frame[4]; // 设备总数
+                    const index = frame[5];       // 索引 (00, 01, 02...)
+                    const mac = Array.from(frame.slice(6, 12))
+                        .map(b => b.toString(16).padStart(2, '0'))
+                        .join(':');
+                    const shortAddr = frame[12] | (frame[13] << 8); // 小端序
+                    const vendorId = frame[14] | (frame[15] << 8);  // 小端序
+                    const devType = frame[16];
+                    const devSubType = frame[17]; // 按键数
+                    const online = frame[18];
+                    const resv = frame[19];
+                    const checksum = frame[20];
+
+                    RED.log.info(`[Mesh设备发现] 收到响应帧，索引: ${index}/${deviceCount-1}, 完整帧: ${frame.toString('hex').toUpperCase()}`);
+
+                    // 第一帧：记录设备总数
+                    if (totalDevices === 0) {
+                        totalDevices = deviceCount;
+                        RED.log.info(`[Mesh设备发现] 设备总数: ${totalDevices}`);
+                        if (totalDevices === 0) {
+                            completeRequest([], '网关下无设备');
+                            return;
+                        }
+                    }
+
+                    // 只保存开关类型的设备（devType=0x01或0x02）
+                    if ((devType === 0x01 || devType === 0x02) && devSubType > 0) {
+                        responseFrames.push({
+                            shortAddr,
+                            mac,
+                            type: devType,
+                            buttons: devSubType
+                        });
+                        RED.log.info(`  - 索引${index}: MAC=${mac}, 短地址=0x${shortAddr.toString(16).toUpperCase().padStart(4, '0')}, 类型=0x${devType.toString(16).toUpperCase()}, 按键数=${devSubType}, 在线=${online}`);
+                    } else {
+                        RED.log.debug(`  - 索引${index}: 跳过非开关设备，MAC=${mac}, 类型=0x${devType.toString(16).toUpperCase()}`);
+                    }
+
+                    receivedDevices++;
+                    RED.log.info(`[Mesh设备发现] 已收到 ${receivedDevices}/${totalDevices} 个设备数据帧`);
+
+                    // 如果收到所有设备数据，返回结果
+                    if (receivedDevices >= totalDevices) {
+                        RED.log.info(`[Mesh设备发现] 所有设备数据接收完成，共${responseFrames.length}个开关设备`);
+                        completeRequest(responseFrames, '完成');
+                        return;
+                    }
+                }
+            };
+
+            // 使用共享连接（TCP和串口都一样）
+            RED.log.info(`[Mesh设备发现] 使用共享连接（${serialPortConfig.connectionType}）`);
+
+            // 注册数据监听器
+            serialPortConfig.registerDataListener(dataHandler);
+
+            // 发送请求
+            try {
+                serialPortConfig.write(requestFrame, (err) => {
+                    if (err) {
+                        RED.log.error(`[Mesh设备发现] 发送请求失败: ${err.message}`);
+                        serialPortConfig.unregisterDataListener(dataHandler);
+                        completeRequest([], `发送失败: ${err.message}`);
+                    } else {
+                        RED.log.info(`[Mesh设备发现] 请求已发送，等待响应...`);
+                    }
+                });
+            } catch (err) {
+                RED.log.error(`[Mesh设备发现] 发送请求异常: ${err.message}`);
+                serialPortConfig.unregisterDataListener(dataHandler);
+                return res.status(500).json({error: `发送请求失败: ${err.message}`});
+            }
+
+        } catch (err) {
+            RED.log.error(`Mesh设备发现失败: ${err.message}`);
+            res.status(500).json({error: err.message});
+        }
+    });
+
+    // 获取已保存的Mesh设备列表API
+    RED.httpAdmin.get('/symi-mesh/devices', async function(req, res) {
+        try {
+            await initMeshStorage();
+            const deviceMap = await storage.getItem('meshDeviceMap') || {};
+
+            // 转换为数组格式
+            const devices = Object.keys(deviceMap).map(mac => {
+                return {
+                    mac: mac,
+                    shortAddr: deviceMap[mac].shortAddr,
+                    type: deviceMap[mac].type,
+                    buttons: deviceMap[mac].buttons
+                };
+            });
+
+            res.json(devices);
+        } catch (err) {
+            RED.log.error(`获取Mesh设备列表失败: ${err.message}`);
+            res.status(500).json({error: err.message});
+        }
+    });
+
     // 串口列表API - 支持Windows、Linux、macOS所有串口设备
     RED.httpAdmin.get('/modbus-slave-switch/serialports', async function(req, res) {
         try {
@@ -87,9 +333,15 @@ module.exports = function(RED) {
             mqttBaseTopic: node.mqttServerConfig ? node.mqttServerConfig.baseTopic : "modbus/relay",
             // 开关面板配置
             switchBrand: config.switchBrand || "symi",         // 面板品牌（默认亖米）
-            buttonType: config.buttonType || "switch",         // 按钮类型：switch=开关模式，scene=场景模式
+            buttonType: config.buttonType || "switch",         // 按钮类型：switch=开关模式，scene=场景模式，mesh=Mesh模式
             switchId: parseInt(config.switchId) || 0,           // 开关ID（0-255，物理面板地址）
             buttonNumber: parseInt(config.buttonNumber) || 1,  // 按钮编号（1-8）
+            // Mesh模式配置
+            meshMacAddress: config.meshMacAddress || "",        // Mesh设备MAC地址
+            meshShortAddress: parseInt(config.meshShortAddress) || 0,  // Mesh设备短地址
+            meshButtonNumber: parseInt(config.meshButtonNumber) || 1,  // Mesh按键编号（1-6）
+            meshTotalButtons: parseInt(config.meshTotalButtons) || 1,  // Mesh开关总路数（1-6）
+            // 目标继电器配置
             targetSlaveAddress: parseInt(config.targetSlaveAddress) || 10,  // 目标继电器从站地址
             targetCoilNumber: modbusCoilNumber  // 目标继电器线圈编号（0-31，从用户输入的1-32转换）
         };
@@ -101,6 +353,28 @@ module.exports = function(RED) {
         node.lastMqttErrorLog = 0; // MQTT错误日志时间
         node.errorLogInterval = 10 * 60 * 1000; // 错误日志间隔：10分钟
 
+        // Mesh模式状态缓存
+        node.meshCurrentStates = null;  // Mesh设备当前状态（用于保持其他路不变）
+
+        // Mesh模式：从持久化存储更新短地址（如果MAC地址对应的短地址发生变化）
+        if (node.config.buttonType === 'mesh' && node.config.meshMacAddress) {
+            initMeshStorage().then(async () => {
+                try {
+                    const deviceMap = await storage.getItem('meshDeviceMap') || {};
+                    const savedDevice = deviceMap[node.config.meshMacAddress];
+
+                    if (savedDevice && savedDevice.shortAddr !== node.config.meshShortAddress) {
+                        node.log(`Mesh设备短地址已更新: ${node.config.meshMacAddress} 从 ${node.config.meshShortAddress} 更新为 ${savedDevice.shortAddr}`);
+                        node.config.meshShortAddress = savedDevice.shortAddr;
+                    }
+                } catch (err) {
+                    node.warn(`更新Mesh设备短地址失败: ${err.message}`);
+                }
+            }).catch(err => {
+                node.warn(`初始化Mesh存储失败: ${err.message}`);
+            });
+        }
+
         // 命令队列（处理多个按键同时按下）- 带时间戳
         node.commandQueue = [];
         node.isProcessingCommand = false;
@@ -310,7 +584,13 @@ module.exports = function(RED) {
         // 处理RS-485接收到的数据
         node.handleRs485Data = function(data) {
             try {
-                // 解析轻量级协议帧
+                // 如果是Mesh模式，使用Mesh协议解析
+                if (node.config.buttonType === 'mesh') {
+                    node.handleMeshData(data);
+                    return;
+                }
+
+                // 解析轻量级协议帧（RS-485模式）
                 const frame = protocol.parseFrame(data);
                 if (!frame) {
                     return; // 静默忽略无效帧
@@ -379,7 +659,60 @@ module.exports = function(RED) {
                 node.error(`解析RS-485数据失败: ${err.message}`);
             }
         };
-        
+
+        // 处理Mesh协议数据
+        node.handleMeshData = function(data) {
+            try {
+                // 解析Mesh状态事件
+                const event = meshProtocol.parseStatusEvent(data);
+                if (!event) {
+                    return; // 静默忽略无效帧
+                }
+
+                // 检查是否是我们监听的Mesh设备
+                if (event.shortAddr !== node.config.meshShortAddress) {
+                    return; // 不是我们的设备，忽略
+                }
+
+                // 检查消息类型
+                if (event.msgType !== meshProtocol.PROTOCOL.MSG_TYPE_SWITCH &&
+                    event.msgType !== meshProtocol.PROTOCOL.MSG_TYPE_SWITCH_6) {
+                    return; // 不是开关状态，忽略
+                }
+
+                // 获取按钮状态
+                if (!event.states || event.states.length < node.config.meshButtonNumber) {
+                    return; // 状态数据不完整
+                }
+
+                const buttonState = event.states[node.config.meshButtonNumber - 1];
+                if (buttonState === null) {
+                    return; // 状态未知，忽略
+                }
+
+                // 全局防抖：防止多个节点重复处理同一个按键
+                const debounceKey = `mesh-${node.config.meshShortAddress}-${node.config.meshButtonNumber}`;
+                const now = Date.now();
+                const lastTriggerTime = globalDebounceCache.get(debounceKey) || 0;
+
+                // 全局防抖：200ms内只触发一次
+                if (now - lastTriggerTime < 200) {
+                    return; // 静默忽略重复触发
+                }
+                globalDebounceCache.set(debounceKey, now);
+
+                // 更新当前状态缓存（用于后续控制时保持其他路不变）
+                node.meshCurrentStates = event.states;
+
+                // 发送命令到继电器
+                node.debug(`Mesh开关${buttonState ? 'ON' : 'OFF'}: MAC=${node.config.meshMacAddress} 按键${node.config.meshButtonNumber}`);
+                node.sendMqttCommand(buttonState);
+
+            } catch (err) {
+                node.error(`解析Mesh数据失败: ${err.message}`);
+            }
+        };
+
         // 发送命令到继电器（支持两种模式：MQTT模式和内部事件模式）
         node.sendMqttCommand = function(state) {
             // 模式1：MQTT模式（通过MQTT发送命令，由主站节点统一处理）
@@ -534,36 +867,54 @@ module.exports = function(RED) {
                 }
 
                 const state = item.state;
-                
+
                 try {
-                    // 使用初始化时计算的deviceAddr和channel
-                    // 当物理按键按下时，会更新为实际的deviceAddr和channel
-                    const deviceAddr = node.buttonDeviceAddr;
-                    const channel = node.buttonChannel;
-
-                    // 根据按钮类型选择协议类型
-                    // 开关模式：使用SET协议（0x03），面板LED需要接收SET指令
-                    // 场景模式：使用REPORT协议（0x04），面板LED需要接收REPORT指令
                     let command;
-                    if (node.config.buttonType === 'scene') {
-                        // 场景模式：使用REPORT协议
-                        command = protocol.buildSingleLightReport(
-                            node.config.switchId,  // 本地地址（面板地址）
-                            deviceAddr,            // 设备地址（从按键事件中获取）
-                            channel,               // 通道（从按键事件中获取）
-                            state
+
+                    if (node.config.buttonType === 'mesh') {
+                        // Mesh模式：发送Mesh控制帧
+                        command = meshProtocol.buildSwitchControlFrame(
+                            node.config.meshShortAddress,
+                            node.config.meshButtonNumber,
+                            node.config.meshTotalButtons,
+                            state,
+                            node.meshCurrentStates || null
                         );
+
+                        if (!command) {
+                            node.error(`构建Mesh控制帧失败`);
+                            continue;
+                        }
                     } else {
-                        // 开关模式（默认）：使用SET协议
-                        command = protocol.buildSingleLightCommand(
-                            node.config.switchId,  // 本地地址（面板地址）
-                            deviceAddr,            // 设备地址（从按键事件中获取）
-                            channel,               // 通道（从按键事件中获取）
-                            state
-                        );
+                        // RS-485模式：使用轻量级协议
+                        // 使用初始化时计算的deviceAddr和channel
+                        // 当物理按键按下时，会更新为实际的deviceAddr和channel
+                        const deviceAddr = node.buttonDeviceAddr;
+                        const channel = node.buttonChannel;
+
+                        // 根据按钮类型选择协议类型
+                        // 开关模式：使用SET协议（0x03），面板LED需要接收SET指令
+                        // 场景模式：使用REPORT协议（0x04），面板LED需要接收REPORT指令
+                        if (node.config.buttonType === 'scene') {
+                            // 场景模式：使用REPORT协议
+                            command = protocol.buildSingleLightReport(
+                                node.config.switchId,  // 本地地址（面板地址）
+                                deviceAddr,            // 设备地址（从按键事件中获取）
+                                channel,               // 通道（从按键事件中获取）
+                                state
+                            );
+                        } else {
+                            // 开关模式（默认）：使用SET协议
+                            command = protocol.buildSingleLightCommand(
+                                node.config.switchId,  // 本地地址（面板地址）
+                                deviceAddr,            // 设备地址（从按键事件中获取）
+                                channel,               // 通道（从按键事件中获取）
+                                state
+                            );
+                        }
                     }
 
-                    // 发送到RS-485总线（使用共享连接配置）
+                    // 发送到RS-485总线或Mesh网关（使用共享连接配置）
                     if (node.serialPortConfig) {
                         node.serialPortConfig.write(command, (err) => {
                             if (err) {
@@ -575,11 +926,17 @@ module.exports = function(RED) {
 
                                 // 输出调试日志，确认LED反馈已发送（包含协议帧十六进制）
                                 const hexStr = command.toString('hex').toUpperCase().match(/.{1,2}/g).join(' ');
-                                node.log(`LED反馈已发送：面板${node.config.switchId} 按钮${node.config.buttonNumber} 设备${deviceAddr} 通道${channel} = ${state ? 'ON' : 'OFF'} (${node.config.buttonType === 'scene' ? 'REPORT' : 'SET'}) [${hexStr}]`);
+                                if (node.config.buttonType === 'mesh') {
+                                    node.log(`Mesh LED反馈已发送：MAC=${node.config.meshMacAddress} 按钮${node.config.meshButtonNumber} = ${state ? 'ON' : 'OFF'} [${hexStr}]`);
+                                } else {
+                                    const deviceAddr = node.buttonDeviceAddr;
+                                    const channel = node.buttonChannel;
+                                    node.log(`LED反馈已发送：面板${node.config.switchId} 按钮${node.config.buttonNumber} 设备${deviceAddr} 通道${channel} = ${state ? 'ON' : 'OFF'} (${node.config.buttonType === 'scene' ? 'REPORT' : 'SET'}) [${hexStr}]`);
+                                }
                             }
                         });
                     } else {
-                        node.warn('RS-485连接未配置');
+                        node.warn('连接未配置');
                     }
 
                     // 队列间隔20ms（优化速度，确保200个节点能快速反馈）

package/nodes/serial-port-config.js

@@ -29,6 +29,10 @@ module.exports = function(RED) {
         node.reconnectTimer = null;  // 重连定时器
         node.reconnectAttempts = 0;  // 重连尝试次数
 
+        // 错误日志限流（避免断网时产生大量日志）
+        node.lastErrorLog = 0;  // 上次错误日志时间
+        node.errorLogInterval = 60 * 1000;  // 错误日志间隔：60秒
+
         // 数据监听器列表（每个从站开关节点注册一个）
         node.dataListeners = [];
 
@@ -81,15 +85,23 @@ module.exports = function(RED) {
                     }
                 });
 
-                // 监听错误
+                // 监听错误（限流日志）
                 node.connection.on('error', (err) => {
-                    node.error(`TCP连接错误: ${err.message}`);
+                    const now = Date.now();
+                    if (now - node.lastErrorLog > node.errorLogInterval) {
+                        node.error(`TCP连接错误: ${err.message}`);
+                        node.lastErrorLog = now;
+                    }
                     // 不在这里重连，在close事件中统一处理
                 });
 
                 // 监听关闭（统一的重连入口）
                 node.connection.on('close', (hadError) => {
-                    node.log(`TCP连接已关闭${hadError ? '（有错误）' : ''}`);
+                    const now = Date.now();
+                    if (now - node.lastErrorLog > node.errorLogInterval) {
+                        node.log(`TCP连接已关闭${hadError ? '（有错误）' : ''}`);
+                        node.lastErrorLog = now;
+                    }
 
                     // 清理连接对象
                     if (node.connection) {
@@ -103,7 +115,11 @@ module.exports = function(RED) {
                         const delay = Math.min(5000 * Math.pow(2, node.reconnectAttempts), 60000);  // 指数退避，最大60秒
                         node.reconnectAttempts++;
 
-                        node.log(`${delay/1000}秒后尝试重新连接TCP（第${node.reconnectAttempts}次）...`);
+                        const nowLog = Date.now();
+                        if (nowLog - node.lastErrorLog > node.errorLogInterval) {
+                            node.log(`${delay/1000}秒后尝试重新连接TCP（第${node.reconnectAttempts}次）...`);
+                            node.lastErrorLog = nowLog;
+                        }
 
                         node.reconnectTimer = setTimeout(() => {
                             node.reconnectTimer = null;
@@ -164,15 +180,23 @@ module.exports = function(RED) {
                     node.isOpening = false;
 
                     if (err) {
-                        node.error(`串口打开失败: ${err.message}`);
-                        
+                        const now = Date.now();
+                        if (now - node.lastErrorLog > node.errorLogInterval) {
+                            node.error(`串口打开失败: ${err.message}`);
+                            node.lastErrorLog = now;
+                        }
+
                         // 打开失败时也要触发重连（如果有监听器在使用）
                         if (!node.isClosing && node.dataListeners.length > 0) {
                             const delay = Math.min(5000 * Math.pow(2, node.reconnectAttempts), 60000);
                             node.reconnectAttempts++;
-                            
-                            node.log(`${delay/1000}秒后尝试重新打开串口（第${node.reconnectAttempts}次）...`);
-                            
+
+                            const nowLog = Date.now();
+                            if (nowLog - node.lastErrorLog > node.errorLogInterval) {
+                                node.log(`${delay/1000}秒后尝试重新打开串口（第${node.reconnectAttempts}次）...`);
+                                node.lastErrorLog = nowLog;
+                            }
+
                             node.reconnectTimer = setTimeout(() => {
                                 node.reconnectTimer = null;
                                 node.openSerialConnection();
@@ -191,25 +215,37 @@ module.exports = function(RED) {
                             try {
                                 listener(data);
                             } catch (err) {
-                                node.error(`数据监听器错误: ${err.message}`);
+                                const now = Date.now();
+                                if (now - node.lastErrorLog > node.errorLogInterval) {
+                                    node.error(`数据监听器错误: ${err.message}`);
+                                    node.lastErrorLog = now;
+                                }
                             }
                         });
                     });
 
-                    // 监听错误
+                    // 监听错误（限流日志）
                     node.connection.on('error', (err) => {
-                        node.error(`串口错误: ${err.message}`);
+                        const now = Date.now();
+                        if (now - node.lastErrorLog > node.errorLogInterval) {
+                            node.error(`串口错误: ${err.message}`);
+                            node.lastErrorLog = now;
+                        }
                         // 不在这里重连，在close事件中统一处理
                     });
 
                     // 监听关闭（统一的重连入口）
                     node.connection.on('close', (err) => {
-                        if (err) {
-                            node.log(`串口已关闭（错误: ${err.message}）`);
-                        } else {
-                            node.log('串口已关闭');
+                        const now = Date.now();
+                        if (now - node.lastErrorLog > node.errorLogInterval) {
+                            if (err) {
+                                node.log(`串口已关闭（错误: ${err.message}）`);
+                            } else {
+                                node.log('串口已关闭');
+                            }
+                            node.lastErrorLog = now;
                         }
-                        
+
                         // 清理连接对象
                         if (node.connection) {
                             try {
@@ -219,14 +255,18 @@ module.exports = function(RED) {
                             }
                             node.connection = null;
                         }
-                        
+
                         // 自动重连（如果不是主动关闭且有监听器在使用）
                         if (!node.isClosing && node.dataListeners.length > 0) {
                             const delay = Math.min(5000 * Math.pow(2, node.reconnectAttempts), 60000);  // 指数退避，最大60秒
                             node.reconnectAttempts++;
-                            
-                            node.log(`检测到串口断开，${delay/1000}秒后尝试重新连接（第${node.reconnectAttempts}次）...`);
-                            
+
+                            const nowLog = Date.now();
+                            if (nowLog - node.lastErrorLog > node.errorLogInterval) {
+                                node.log(`检测到串口断开，${delay/1000}秒后尝试重新连接（第${node.reconnectAttempts}次）...`);
+                                node.lastErrorLog = nowLog;
+                            }
+
                             node.reconnectTimer = setTimeout(() => {
                                 node.reconnectTimer = null;
                                 node.openSerialConnection();
@@ -251,6 +291,11 @@ module.exports = function(RED) {
             }
         };
 
+        // 获取连接对象（用于Mesh设备发现等场景）
+        node.getConnection = function() {
+            return node.connection;
+        };
+
         // 注册数据监听器
         node.registerDataListener = function(listener) {
             if (typeof listener !== 'function') {

package/package.json

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