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

package/nodes/modbus-master.js

@@ -139,23 +139,56 @@ module.exports = function(RED) {
         node.isClosing = false;
         node.lastErrorLog = {}; // 记录每个从站的最后错误日志时间
         node.lastMqttErrorLog = 0; // MQTT错误日志时间
-        node.errorLogInterval = 10 * 60 * 1000; // 错误日志间隔：10分钟
+        node.errorLogInterval = 5 * 60 * 1000; // 错误日志间隔：5分钟（降低到5分钟，更快发现问题）
+        node.consecutiveErrors = {}; // 记录每个从站的连续错误次数
         node.modbusLock = false; // Modbus操作互斥锁（防止读写冲突）
         node.lastWriteTime = {}; // 记录每个从站的最后写入时间
         node.pausePolling = false; // 暂停轮询标志（从站上报时暂停）
         node.pollingPausedCount = 0; // 暂停轮询计数器
         node._discoveryPublished = false; // Discovery发布标志（避免重复）
+
+        // 定期清理机制（每小时清理一次，防止内存泄漏）
+        node.cleanupTimer = setInterval(() => {
+            // 清理过期的错误日志记录
+            const now = Date.now();
+            const cleanupThreshold = 24 * 60 * 60 * 1000; // 24小时
+
+            Object.keys(node.lastErrorLog).forEach(slaveId => {
+                if (now - node.lastErrorLog[slaveId] > cleanupThreshold) {
+                    delete node.lastErrorLog[slaveId];
+                }
+            });
+
+            Object.keys(node.consecutiveErrors).forEach(slaveId => {
+                if (now - (node.deviceStates[slaveId]?.lastTimeoutTime || 0) > cleanupThreshold) {
+                    delete node.consecutiveErrors[slaveId];
+                }
+            });
+
+            node.debug(`内存清理完成（错误日志记录数: ${Object.keys(node.lastErrorLog).length}）`);
+        }, 60 * 60 * 1000); // 每小时执行一次
         
         // 更新节点状态显示
         node.updateNodeStatus = function() {
             const modbusStatus = node.isConnected ? "Modbus-OK" : "Modbus-ERR";
-            const mqttStatus = node.mqttConnected ? "MQTT-OK" : "MQTT-ERR";
-            
-            if (node.isConnected && node.mqttConnected) {
+
+            // 如果MQTT未启用，显示"本地模式"
+            let mqttStatus;
+            if (!node.config.enableMqtt) {
+                mqttStatus = "本地模式";
+            } else {
+                mqttStatus = node.mqttConnected ? "MQTT-OK" : "MQTT-ERR";
+            }
+
+            // 状态显示逻辑
+            if (node.isConnected && (node.mqttConnected || !node.config.enableMqtt)) {
+                // Modbus已连接 且 (MQTT已连接 或 MQTT未启用)
                 node.status({fill: "green", shape: "dot", text: `${modbusStatus} ${mqttStatus}`});
             } else if (node.isConnected || node.mqttConnected) {
+                // Modbus已连接 或 MQTT已连接（部分连接）
                 node.status({fill: "yellow", shape: "ring", text: `${modbusStatus} ${mqttStatus}`});
             } else {
+                // 全部未连接
                 node.status({fill: "red", shape: "ring", text: `${modbusStatus} ${mqttStatus}`});
             }
         };
@@ -169,8 +202,7 @@ module.exports = function(RED) {
                 error: null,
                 config: slave,  // 保存该从站的配置
                 initialPublished: false,  // 标记是否已发布初始状态
-                timeoutCount: 0,        // 连续超时次数
-                isIgnored: false,       // 是否被临时忽略（超时次数过多时）
+                timeoutCount: 0,        // 连续超时次数（仅用于统计）
                 lastTimeoutTime: 0      // 最后一次超时时间
             };
         });
@@ -244,10 +276,17 @@ module.exports = function(RED) {
                     node.log(`串口Modbus连接成功: ${node.config.serialPort} @ ${node.config.serialBaudRate || 9600}bps`);
                 }
 
-                // 设置超时时间（串口需要更长的超时时间）
-                const timeout = node.config.connectionType === "serial" ? 10000 : 5000;
+                // 设置超时时间（串口需要更长的超时时间，但不能太长以免影响轮询）
+                const timeout = node.config.connectionType === "serial" ? 3000 : 2000;
                 node.client.setTimeout(timeout);
                 node.log(`Modbus超时设置: ${timeout}ms`);
+
+                // 设置错误处理器，防止未捕获的错误导致进程崩溃
+                if (node.client._port) {
+                    node.client._port.on('error', (err) => {
+                        node.warn(`串口错误（已忽略）: ${err.message}`);
+                    });
+                }
                 
                 node.isConnected = true;
                 node.reconnectAttempts = 0;  // 重置重连计数
@@ -259,12 +298,19 @@ module.exports = function(RED) {
                 node.lastMqttErrorLog = 0;
                 node._discoveryPublished = false;  // 重置Discovery发布标志
 
-                // 添加Symi按键事件监听（串口模式）
-                if (node.config.connectionType === "serial" && node.client._port) {
+                // 添加Symi按键事件监听（串口和TCP模式都支持）
+                if (node.client._port) {
+                    // 串口模式：直接监听串口数据
                     node.client._port.on('data', (data) => {
                         node.handleSymiButtonEvent(data);
                     });
                     node.log('已启用Symi按键事件监听（串口模式）');
+                } else if (node.client._client && node.config.connectionType === "tcp") {
+                    // TCP模式：监听TCP socket数据
+                    node.client._client.on('data', (data) => {
+                        node.handleSymiButtonEvent(data);
+                    });
+                    node.log('已启用Symi按键事件监听（TCP模式）');
                 }
 
                 // 立即启动轮询（不等待MQTT连接）
@@ -372,7 +418,7 @@ module.exports = function(RED) {
         // 连接MQTT（带智能重试和fallback）
         node.connectMqtt = function() {
             if (!node.config.enableMqtt) {
-                node.log('MQTT未启用 - 使用纯本地模式（仅串口通信）');
+                node.log('MQTT未启用 - 使用本地模式（内部事件通信）');
                 node.log('提示：如需Home Assistant集成，请在节点配置中启用MQTT');
                 return;
             }
@@ -729,6 +775,13 @@ module.exports = function(RED) {
         // 开始轮询（使用递归调用而非定时器，避免并发）
         node.startPolling = function() {
             if (node.isPolling) {
+                node.log('轮询已在运行中，跳过重复启动');
+                return;
+            }
+
+            // 检查从站配置
+            if (!node.config.slaves || node.config.slaves.length === 0) {
+                node.error('未配置从站设备，无法启动轮询');
                 return;
             }
 
@@ -737,22 +790,37 @@ module.exports = function(RED) {
             node.lastMqttErrorLog = 0;
 
             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(`========== 开始轮询 ${node.config.slaves.length} 个从站设备 ==========`);
+            node.log(`从站列表: ${slaveList}`);
             node.log(`Modbus连接: ${node.isConnected ? '已连接' : '未连接'}, MQTT连接: ${node.mqttConnected ? '已连接' : '未连接'}`);
             node.currentSlaveIndex = 0;
             node.isPolling = true;
+            node.pollingLoopCount = 0; // 轮询循环计数器
 
             // 使用递归调用实现轮询，确保不会并发
             const pollLoop = async () => {
-                if (!node.isPolling || !node.isConnected || node.isClosing) {
+                if (!node.isPolling) {
+                    node.log('轮询已停止（isPolling=false）');
+                    return;
+                }
+
+                if (!node.isConnected) {
+                    node.log('轮询已停止（Modbus未连接）');
+                    return;
+                }
+
+                if (node.isClosing) {
+                    node.log('轮询已停止（节点正在关闭）');
                     return;
                 }
 
                 // 获取当前从站配置（在轮询前获取，确保使用正确的间隔）
                 const currentSlave = node.config.slaves[node.currentSlaveIndex];
                 if (!currentSlave) {
-                    node.warn(`从站索引${node.currentSlaveIndex}无效，重置为0`);
+                    node.log(`从站索引${node.currentSlaveIndex}无效，重置为0`);
                     node.currentSlaveIndex = 0;
+                    // 继续轮询，不要中断
+                    node.pollTimer = setTimeout(pollLoop, 200);
                     return;
                 }
 
@@ -761,14 +829,26 @@ module.exports = function(RED) {
                 try {
                     await node.pollNextSlave();
                 } catch (err) {
-                    node.error(`轮询错误: ${err.message}`);
+                    // 捕获所有异常，防止轮询中断（只记录到日志文件，不输出到调试窗口）
+                    node.log(`轮询异常（已忽略，继续轮询）: ${err.message}`);
                 }
 
-                // 等待指定间隔后继续下一次轮询
+                // 移动到下一个从站
+                node.currentSlaveIndex = (node.currentSlaveIndex + 1) % node.config.slaves.length;
+
+                // 每完成一轮轮询，计数器加1
+                if (node.currentSlaveIndex === 0) {
+                    node.pollingLoopCount++;
+                    // 轮询计数器静默运行，不输出日志（避免日志过多）
+                    // 轮询会永久运行，无需频繁确认
+                }
+
+                // 等待指定间隔后继续下一次轮询（确保轮询永不停止）
                 node.pollTimer = setTimeout(pollLoop, interval);
             };
 
             // 立即开始轮询
+            node.log('立即启动轮询循环...');
             pollLoop();
         };
         
@@ -797,20 +877,19 @@ module.exports = function(RED) {
             // 获取当前从站配置
             const slave = node.config.slaves[node.currentSlaveIndex];
             if (!slave) {
-                node.warn(`从站索引${node.currentSlaveIndex}无效，重置为0`);
+                node.log(`从站索引${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;
 
@@ -818,15 +897,13 @@ module.exports = function(RED) {
             const lastWrite = node.lastWriteTime[slaveId] || 0;
             const timeSinceWrite = Date.now() - lastWrite;
             if (timeSinceWrite < 100) {
-                // 移动到下一个从站
-                node.currentSlaveIndex = (node.currentSlaveIndex + 1) % node.config.slaves.length;
+                // 跳过该从站（不移动索引，由pollLoop统一管理）
                 return;
             }
 
             // 检查锁状态（如果有写操作正在进行，跳过本次轮询）
             if (node.modbusLock) {
-                // 移动到下一个从站
-                node.currentSlaveIndex = (node.currentSlaveIndex + 1) % node.config.slaves.length;
+                // 跳过该从站（不移动索引，由pollLoop统一管理）
                 return;
             }
 
@@ -862,6 +939,17 @@ module.exports = function(RED) {
                             coil: coilIndex,
                             value: newValue
                         });
+
+                        // 广播状态变化事件（用于LED反馈）
+                        // 只在状态真正改变时广播（不包括首次轮询）
+                        if (!isFirstPoll && oldValue !== newValue) {
+                            RED.events.emit('modbus:coilStateChanged', {
+                                slave: slaveId,
+                                coil: coilIndex,
+                                value: newValue,
+                                source: 'polling'
+                            });
+                        }
                     }
                 }
 
@@ -877,7 +965,6 @@ module.exports = function(RED) {
 
                 // 轮询成功，重置超时计数
                 node.deviceStates[slaveId].timeoutCount = 0;
-                node.deviceStates[slaveId].isIgnored = false;
 
                 // 输出消息
                 const output = {
@@ -904,6 +991,12 @@ module.exports = function(RED) {
                 // 释放锁
                 node.modbusLock = false;
 
+                // 确保deviceState存在（防止未定义错误）
+                if (!node.deviceStates[slaveId]) {
+                    node.log(`从站${slaveId}状态未初始化，跳过错误记录`);
+                    return;
+                }
+
                 node.deviceStates[slaveId].error = err.message;
                 node.deviceStates[slaveId].lastTimeoutTime = Date.now();
 
@@ -920,26 +1013,18 @@ module.exports = function(RED) {
                 );
 
                 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;
-                        }
+                    // 只记录日志到文件，不输出到调试窗口（避免日志刷屏）
+                    if (shouldLog) {
+                        node.log(`从站${slaveId}轮询超时: ${err.message} (线圈${slave.coilStart}-${slave.coilEnd}) [连续超时${node.deviceStates[slaveId].timeoutCount}次]`);
+                        node.lastErrorLog[slaveId] = now;
                     }
                 } else {
-                    // 非超时错误，记录日志
+                    // 非超时错误（如CRC错误、总线干扰），记录日志到文件，不输出到调试窗口
                     if (shouldLog) {
-                        node.warn(`从站${slaveId}轮询失败: ${err.message} (线圈${slave.coilStart}-${slave.coilEnd})`);
+                        node.log(`从站${slaveId}轮询失败: ${err.message} (线圈${slave.coilStart}-${slave.coilEnd})`);
                         node.lastErrorLog[slaveId] = now;
                     }
                 }
@@ -992,28 +1077,32 @@ module.exports = function(RED) {
                 }
             }
 
-            // 移动到下一个从站
-            node.currentSlaveIndex = (node.currentSlaveIndex + 1) % node.config.slaves.length;
+            // 注意：不在这里移动索引，由pollLoop统一管理
+            // 这样可以确保每个从站都按照正确的间隔轮询
         };
         
         // 处理Symi按键事件（私有协议）
+        // 静默处理：只处理本节点相关的数据，忽略总线上的其他数据
         node.handleSymiButtonEvent = function(data) {
             try {
-                // 解析Symi协议帧
+                // 解析Symi协议帧（带CRC校验）
                 const frame = protocol.parseFrame(data);
                 if (!frame) {
-                    return; // 不是有效的Symi帧，忽略
+                    // 不是有效的Symi帧（CRC校验失败或格式错误），静默忽略
+                    return;
                 }
 
                 // 只处理SET类型(0x03)的按键事件，忽略REPORT类型(0x04)
                 // REPORT类型是面板对我们指令的确认，不是按键事件
                 if (frame.dataType !== 0x03) {
-                    return; // 不是按键事件
+                    // 不是按键事件，静默忽略
+                    return;
                 }
 
                 // 检查是否是灯光设备
                 if (frame.deviceType !== 0x01) {
-                    return; // 不是灯光设备
+                    // 不是灯光设备，静默忽略
+                    return;
                 }
 
                 // 提取按键信息
@@ -1021,8 +1110,6 @@ module.exports = function(RED) {
                 const channel = frame.channel;        // 通道号（1-8）
                 const state = frame.opInfo[0] === 0x01; // 状态（1=开，0=关）
 
-                node.debug(`Symi按键事件: 设备${deviceAddr} 通道${channel} 状态=${state ? 'ON' : 'OFF'}`);
-
                 // 查找对应的从站和线圈
                 // 假设：设备地址1对应从站10，设备地址2对应从站11，以此类推
                 // 通道号直接对应线圈号（1-8 → 0-7）
@@ -1032,16 +1119,18 @@ module.exports = function(RED) {
                 // 检查从站是否在配置中
                 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.debug(`Symi按键事件: 设备${deviceAddr} 通道${channel} 状态=${state ? 'ON' : 'OFF'}`);
                 node.debug(`Symi按键映射: 设备${deviceAddr}通道${channel} → 从站${slaveId}线圈${coilNumber}`);
 
                 // 写入线圈（异步，不阻塞）
@@ -1055,11 +1144,16 @@ module.exports = function(RED) {
                 if (node.client._port && node.client._port.write) {
                     node.client._port.write(responseFrame);
                     node.log(`Symi应答已发送(REPORT): 设备${deviceAddr} 通道${channel} 状态=${state ? 'ON' : 'OFF'}`);
+                } else if (node.client._client && node.client._client.write) {
+                    // TCP模式
+                    node.client._client.write(responseFrame);
+                    node.log(`Symi应答已发送(REPORT/TCP): 设备${deviceAddr} 通道${channel} 状态=${state ? 'ON' : 'OFF'}`);
                 }
 
             } catch (err) {
                 // 静默处理错误，避免干扰Modbus通信
-                // node.warn(`Symi按键事件处理错误: ${err.message}`);
+                // 总线上可能有各种数据，不是所有数据都能解析成功
+                // 只有真正的错误才输出日志
             }
         };
 
@@ -1092,17 +1186,21 @@ module.exports = function(RED) {
             try {
                 // 设置锁
                 node.modbusLock = true;
-                
+
                 node.client.setID(slaveId);
+
+                // 记录写入操作（帮助追踪总线数据来源）
+                node.log(`写入线圈: 从站${slaveId} 线圈${coil} = ${value ? 'ON' : 'OFF'}`);
+
                 await node.client.writeCoil(coil, value);
-                
+
                 // 记录写入时间（用于暂停轮询）
                 node.lastWriteTime[slaveId] = Date.now();
-                
+
                 // 更新本地状态
                 node.deviceStates[slaveId].coils[coil] = value;
-                
-                node.debug(`写入成功: 从站${slaveId} 线圈${coil} = ${value}`);
+
+                node.log(`写入成功: 从站${slaveId} 线圈${coil} = ${value ? 'ON' : 'OFF'}`);
                 
                 // 发布到MQTT和触发事件
                 node.publishMqttState(slaveId, coil, value);
@@ -1213,43 +1311,89 @@ module.exports = function(RED) {
             }
         };
         
-        // 处理输入消息
+        // 监听内部事件（从站开关节点发送的写入命令）
+        // 这是免连线通信的核心机制
+        node.internalEventHandler = async function(data) {
+            if (!data || typeof data !== 'object') {
+                return;
+            }
+
+            const slave = parseInt(data.slave);
+            const coil = parseInt(data.coil);
+            const value = Boolean(data.value);
+
+            // 输出日志确认收到事件
+            node.log(`收到内部事件：从站${slave} 线圈${coil} = ${value ? 'ON' : 'OFF'}`);
+
+            try {
+                // 执行写入操作
+                await node.writeSingleCoil(slave, coil, value);
+
+                // 写入成功后，广播状态变化事件（用于LED反馈）
+                RED.events.emit('modbus:coilStateChanged', {
+                    slave: slave,
+                    coil: coil,
+                    value: value,
+                    source: 'master'
+                });
+
+                node.log(`内部事件写入成功，已广播状态变化：从站${slave} 线圈${coil} = ${value ? 'ON' : 'OFF'}`);
+            } catch (err) {
+                node.error(`内部事件写入失败: 从站${slave} 线圈${coil} - ${err.message}`);
+            }
+        };
+
+        // 注册内部事件监听器
+        RED.events.on('modbus:writeCoil', node.internalEventHandler);
+        node.log('已注册内部事件监听器（免连线通信）');
+
+        // 处理输入消息（保留兼容性，支持连线模式）
         node.on('input', function(msg) {
             if (!msg.payload || typeof msg.payload !== 'object') {
                 return;
             }
-            
+
             const cmd = msg.payload.cmd;
-            
+
             switch(cmd) {
                 case 'start':
                     node.startPolling();
                     break;
-                    
+
                 case 'stop':
                     node.stopPolling();
                     break;
-                    
+
                 case 'writeCoil':
-                    if (msg.payload.slave && msg.payload.coil !== undefined && msg.payload.value !== undefined) {
-                        node.writeSingleCoil(
-                            msg.payload.slave,
-                            msg.payload.coil,
-                            msg.payload.value
-                        );
+                    if (msg.payload.slave !== undefined && msg.payload.coil !== undefined && msg.payload.value !== undefined) {
+                        const slave = parseInt(msg.payload.slave);
+                        const coil = parseInt(msg.payload.coil);
+                        const value = Boolean(msg.payload.value);
+
+                        node.writeSingleCoil(slave, coil, value).catch(err => {
+                            node.error(`连线模式写入失败: ${err.message}`);
+                        });
+                    } else {
+                        node.warn(`writeCoil命令参数不完整: slave=${msg.payload.slave}, coil=${msg.payload.coil}, value=${msg.payload.value}`);
                     }
                     break;
-                    
+
                 case 'writeCoils':
-                    if (msg.payload.slave && msg.payload.startCoil !== undefined && Array.isArray(msg.payload.values)) {
-                        node.writeMultipleCoils(
-                            msg.payload.slave,
-                            msg.payload.startCoil,
-                            msg.payload.values
-                        );
+                    if (msg.payload.slave !== undefined && msg.payload.startCoil !== undefined && Array.isArray(msg.payload.values)) {
+                        const slave = parseInt(msg.payload.slave);
+                        const startCoil = parseInt(msg.payload.startCoil);
+                        const values = msg.payload.values.map(v => Boolean(v));
+
+                        node.log(`接收到本地模式批量写入命令: 从站${slave} 起始线圈${startCoil} 共${values.length}个`);
+
+                        node.writeMultipleCoils(slave, startCoil, values).catch(err => {
+                            node.error(`本地模式批量写入失败: ${err.message}`);
+                        });
+                    } else {
+                        node.warn(`writeCoils命令参数不完整`);
                     }
                     break;
-                    
+
                 default:
                     node.warn(`未知命令: ${cmd}`);
             }
@@ -1274,13 +1418,25 @@ module.exports = function(RED) {
         node.on('close', function(done) {
             node.isClosing = true;
             node.stopPolling();
-            
+
+            // 移除内部事件监听器
+            if (node.internalEventHandler) {
+                RED.events.removeListener('modbus:writeCoil', node.internalEventHandler);
+                node.internalEventHandler = null;
+            }
+
             // 清除重连定时器
             if (node.reconnectTimer) {
                 clearTimeout(node.reconnectTimer);
                 node.reconnectTimer = null;
             }
-            
+
+            // 清除内存清理定时器
+            if (node.cleanupTimer) {
+                clearInterval(node.cleanupTimer);
+                node.cleanupTimer = null;
+            }
+
             // 发布离线状态到MQTT（让HA知道设备离线）
             if (node.config.enableMqtt && node.mqttClient && node.mqttClient.connected) {
                 node.publishOfflineStatus();

package/nodes/modbus-slave-switch.html

@@ -57,7 +57,8 @@
             <span style="font-size: 14px; font-weight: 600; color: #333;">RS-485连接配置</span>
         </label>
         <div style="font-size: 11px; color: #555; padding: 10px 12px; background: linear-gradient(135deg, #fff3cd 0%, #fffbe6 100%); border-left: 4px solid #ffc107; border-radius: 4px; box-shadow: 0 1px 3px rgba(0,0,0,0.08);">
-            <strong>说明：</strong>多个从站开关节点可以共享同一个RS-485连接配置（支持TCP网关或串口）
+            <strong>说明：</strong>多个从站开关节点可以共享同一个RS-485连接配置（支持TCP网关或串口）<br>
+            <strong>批量更换：</strong>如需更换连接配置，请先创建新配置，然后在配置节点侧边栏中删除旧配置，系统会提示你选择替换配置
         </div>
     </div>