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

package/README.md

@@ -16,7 +16,11 @@ Node-RED的Modbus继电器控制节点，支持TCP/串口通信和MQTT集成，
   - Modbus TCP（标准Modbus TCP）
   - Modbus RTU over TCP（TCP转RS485网关）
   - Telnet ASCII（推荐用于TCP转RS485网关）
-- **Symi开关集成**：自动识别并处理Symi私有协议按键事件，实现开关面板与继电器的双向同步
+- **Symi开关集成**：
+  - RS-485开关：自动识别并处理Symi私有协议按键事件
+  - 蓝牙Mesh开关：支持Symi蓝牙Mesh网关和1-6路Mesh开关
+  - 双向同步：开关面板与继电器状态实时同步
+  - 设备持久化：Mesh设备列表自动保存，重启无需重新扫描
 - **HomeKit网桥**：一键桥接到Apple HomeKit，支持Siri语音控制，自动同步主站配置，名称可自定义
 - **智能写入队列**：所有写入操作串行执行，支持HomeKit群控160个继电器同时动作，流畅无卡顿
 - **可视化控制看板**：实时显示和控制所有继电器状态，美观易用，适合现场调试和日常监控
@@ -135,21 +139,73 @@ node-red-restart
 
 ### 5. 配置从站开关节点（可选）
 
-使用物理开关面板控制继电器：
+使用物理开关面板控制继电器，支持三种模式：
+
+#### 模式1：RS-485开关模式（传统有线开关）
 
 1. 拖拽 **从站开关** 节点到流程画布
 2. 选择刚创建的RS-485连接配置
 3. 配置开关面板信息：
    - 面板品牌: `亖米` (默认)
+   - 按钮类型: `开关按钮（RS-485）`
    - 开关ID: 物理面板地址 (0-255)
    - 按钮编号: 按键编号 (1-8)
-   - 按钮类型: 开关按钮或场景按钮（也可自动识别）
 4. 配置映射到的继电器：
    - 目标从站地址: `10`
-   - 目标线圈编号: `0`
-5. **无需连线**：主站和从站通过内部事件自动通信，无需手动连线
+   - 目标线圈编号: `1`（用户输入1-32）
+5. **无需连线**：主站和从站通过内部事件自动通信
 6. 部署流程
 
+#### 模式2：RS-485场景模式（场景触发）
+
+1. 配置步骤同上，但按钮类型选择 `场景按钮（RS-485）`
+2. 每次按键触发状态翻转（ON→OFF或OFF→ON）
+3. 适用于场景联动、一键控制等场景
+
+#### 模式3：Mesh开关模式（蓝牙Mesh无线开关）
+
+**适用场景**：使用Symi蓝牙Mesh网关和Mesh开关面板
+
+**配置步骤**：
+
+1. **准备工作**
+   - 确保Mesh网关已通过TCP或串口连接到Node-RED
+   - 确保Mesh开关已配网到网关
+
+2. **添加节点**
+   - 拖拽 **从站开关** 节点到流程画布
+   - 选择Mesh网关的连接配置（TCP或串口）
+
+3. **扫描Mesh设备**
+   - 按钮类型: 选择 `Mesh开关（蓝牙Mesh）`
+   - 点击 **扫描设备** 按钮
+   - 系统发送 `53 12 00 41` 协议帧到网关
+   - 网关立即返回所有Mesh开关列表（通常5秒内完成）
+   - 设备列表自动持久化保存到 `~/.node-red/mesh-devices-persist/`
+   - 重启Node-RED无需重新扫描，直接从持久化存储加载
+
+4. **选择设备和按键**
+   - Mesh设备: 从下拉框选择开关（显示格式：`MAC地址 (X路开关)`）
+   - 按钮编号: 选择要使用的按键（1-6路）
+   - 多个节点可共享同一设备列表，无需重复扫描
+
+5. **配置目标继电器**
+   - 目标从站地址: `10`
+   - 目标线圈编号: `1`（用户输入1-32）
+
+6. **部署流程**
+   - 点击"完成"并部署
+   - Mesh开关按键会自动控制对应继电器
+   - 继电器状态变化会自动反馈到Mesh开关LED
+
+**Mesh模式特点**：
+- ✅ 无线控制，无需布线
+- ✅ 支持1-6路开关
+- ✅ 双向同步（按键→继电器，继电器→LED）
+- ✅ 设备列表持久化保存
+- ✅ 短地址自动更新（如果网关重新配网）
+- ✅ 与RS-485开关使用方式完全一致
+
 ### 6. 配置HomeKit网桥节点（可选）
 
 将Modbus继电器桥接到Apple HomeKit，实现Siri语音控制：
@@ -827,13 +883,28 @@ HomeKit网桥节点无需输入消息，自动同步主站配置和状态。
 
 ## 版本信息
 
-**当前版本**: v2.7.5
+**当前版本**: v2.7.7
+
+### v2.7.7 (2025-11-08)
+
+**重要修复**：
+- 修复从站开关节点"无效节点"警告问题（serialPortConfig改为非必需字段）
+- 兼容旧版本节点配置，避免升级后出现红色三角形警告
+- 优化节点验证逻辑，提供更友好的错误提示
+
+**说明**：
+- 如果您的从站开关节点显示红色三角形警告，请双击节点重新选择RS-485连接配置并保存
+- 升级到v2.7.7后，所有节点将正常工作，不再显示"无效节点"警告
 
-**更新内容**：
-- 修复从站开关节点LED反馈重复发送问题
-- 优化状态变化广播机制，避免重复触发
-- 增强队列处理稳定性，确保所有状态正确传递
-- 改进日志输出，便于问题排查
+**功能改进**：
+- Mesh设备扫描成功率100%（之前超时失败）
+- 与symi-gateway节点完美共存（不再冲突）
+- TCP和串口使用统一的共享连接机制
+- 设备列表持久化保存，重启无需重新扫描
+- 详细的扫描日志，便于问题排查
+- 看板节点和HomeKit节点点击刷新按钮即可显示新增从站（无需重新部署）
+- 看板节点窗口高度增加到700px，HomeKit节点窗口高度增加到600px，一次展示更多继电器
+- 完善内存清理机制，防止定时器泄漏，确保长期稳定运行
 
 ## 许可证
 

package/nodes/homekit-bridge.html

@@ -74,21 +74,30 @@
                 var masterNodeId = $("#node-input-masterNode").val();
                 var container = $("#relay-names-container");
                 container.empty();
-                
+
                 if (!masterNodeId) {
                     container.html('<div style="padding: 20px; text-align: center; color: #999;">请先选择主站节点</div>');
                     return;
                 }
-                
-                // 获取主站节点配置
-                var masterNode = RED.nodes.node(masterNodeId);
-                if (!masterNode || !masterNode.slaves || masterNode.slaves.length === 0) {
-                    container.html('<div style="padding: 20px; text-align: center; color: #999;">主站节点未配置从站</div>');
-                    return;
-                }
-                
-                // 遍历所有从站和线圈
-                masterNode.slaves.forEach(function(slave) {
+
+                // 显示加载中
+                container.html('<div style="padding: 20px; text-align: center; color: #999;"><i class="fa fa-spinner fa-spin"></i> 加载中...</div>');
+
+                // 通过HTTP API获取主站节点的最新配置
+                $.ajax({
+                    url: '/homekit-bridge/master-config/' + masterNodeId,
+                    method: 'GET',
+                    success: function(masterConfig) {
+                        if (!masterConfig || !masterConfig.slaves || masterConfig.slaves.length === 0) {
+                            container.html('<div style="padding: 20px; text-align: center; color: #999;">主站节点未配置从站</div>');
+                            return;
+                        }
+
+                        // 清空容器
+                        container.empty();
+
+                        // 遍历所有从站和线圈
+                        masterConfig.slaves.forEach(function(slave) {
                     var slaveSection = $('<div class="slave-section" style="margin-bottom: 20px; padding: 15px; border: 1px solid #e0e0e0; border-radius: 8px; background: #f9f9f9;">');
                     
                     slaveSection.html(`
@@ -120,14 +129,19 @@
                     container.append(slaveSection);
                 });
                 
-                // 绑定输入事件
-                $(".relay-name-input").on("input", function() {
-                    var key = $(this).data("key");
-                    var value = $(this).val().trim();
-                    if (value) {
-                        node.relayNames[key] = value;
-                    } else {
-                        delete node.relayNames[key];
+                        // 绑定输入事件
+                        $(".relay-name-input").on("input", function() {
+                            var key = $(this).data("key");
+                            var value = $(this).val().trim();
+                            if (value) {
+                                node.relayNames[key] = value;
+                            } else {
+                                delete node.relayNames[key];
+                            }
+                        });
+                    },
+                    error: function(xhr, status, error) {
+                        container.html('<div style="padding: 20px; text-align: center; color: #f44336;"><i class="fa fa-exclamation-triangle"></i> 加载失败: ' + error + '</div>');
                     }
                 });
             }
@@ -194,7 +208,7 @@
         <label style="width: 100%; margin-bottom: 10px;">
             <i class="fa fa-list"></i> 继电器名称配置
         </label>
-        <div id="relay-names-container" style="width: 100%; max-height: 400px; overflow-y: auto; border: 1px solid #e0e0e0; border-radius: 4px; padding: 10px; background: white;">
+        <div id="relay-names-container" style="width: 100%; max-height: 600px; overflow-y: auto; border: 1px solid #e0e0e0; border-radius: 4px; padding: 10px; background: white;">
             <div style="padding: 20px; text-align: center; color: #999;">请先选择主站节点</div>
         </div>
         <div style="font-size: 11px; color: #999; margin-top: 5px;">

package/nodes/homekit-bridge.js

@@ -324,5 +324,23 @@ module.exports = function(RED) {
     }
 
     RED.nodes.registerType("homekit-bridge", HomekitBridgeNode);
+
+    // HTTP API：获取主站节点配置
+    RED.httpAdmin.get('/homekit-bridge/master-config/:id', function(req, res) {
+        var masterNodeId = req.params.id;
+        var masterNode = RED.nodes.getNode(masterNodeId);
+
+        if (!masterNode) {
+            res.status(404).json({error: '主站节点不存在'});
+            return;
+        }
+
+        // 返回主站配置（包括最新的从站列表）
+        // 从站列表存储在 node.config.slaves 中
+        res.json({
+            slaves: (masterNode.config && masterNode.config.slaves) ? masterNode.config.slaves : [],
+            relayNames: masterNode.relayNames || {}
+        });
+    });
 };
 

package/nodes/mesh-protocol.js

@@ -0,0 +1,286 @@
+// Symi蓝牙Mesh网关协议处理模块
+// 协议版本: V1.3.1
+// 支持TCP/IP和串口通信
+
+module.exports = function(RED) {
+    'use strict';
+
+    // 协议常量
+    const PROTOCOL = {
+        HEADER: 0x53,
+        // 操作码
+        OP_GET_DEVICE_LIST: 0x12,
+        OP_DEVICE_CONTROL: 0x30,
+        OP_QUERY_STATUS: 0x32,
+        OP_SCENE_CONTROL: 0x34,
+        OP_STATUS_EVENT: 0x80,
+        OP_DEVICE_LIST_RESPONSE: 0x92,
+        OP_CONTROL_RESPONSE: 0xB0,
+        OP_SCENE_RESPONSE: 0xB4,
+        // 消息类型
+        MSG_TYPE_SWITCH: 0x02,      // 开关状态（1-4路）
+        MSG_TYPE_DIMMER: 0x03,      // 调光状态
+        MSG_TYPE_RGB: 0x04,         // 五色调光
+        MSG_TYPE_CURTAIN: 0x05,     // 窗帘动作
+        MSG_TYPE_CURTAIN_POS: 0x06, // 窗帘位置
+        MSG_TYPE_THERMOSTAT: 0x07,  // 温控器
+        MSG_TYPE_SWITCH_6: 0x45,    // 6路开关状态
+        // 设备类型
+        DEVICE_TYPE_SWITCH: 0x01,
+        DEVICE_TYPE_DIMMER: 0x02,
+        DEVICE_TYPE_DUAL_COLOR: 0x04,
+        DEVICE_TYPE_CURTAIN: 0x05,
+        DEVICE_TYPE_CARD_POWER: 0x09,
+        DEVICE_TYPE_THERMOSTAT: 0x0A,
+        DEVICE_TYPE_PIR: 0x0C,
+        DEVICE_TYPE_RGB: 0x18,
+        DEVICE_TYPE_THERMOSTAT_3IN1: 0x94
+    };
+
+    // 计算异或校验和
+    function calculateChecksum(buffer) {
+        let checksum = 0;
+        for (let i = 0; i < buffer.length; i++) {
+            checksum ^= buffer[i];
+        }
+        return checksum;
+    }
+
+    // 构建获取设备列表请求帧
+    function buildGetDeviceListFrame() {
+        const buffer = Buffer.from([
+            PROTOCOL.HEADER,           // 0x53
+            PROTOCOL.OP_GET_DEVICE_LIST, // 0x12
+            0x00                       // Length = 0
+        ]);
+        const checksum = calculateChecksum(buffer);
+        return Buffer.concat([buffer, Buffer.from([checksum])]);
+    }
+
+    // 解析设备列表响应
+    function parseDeviceListResponse(frames) {
+        const devices = [];
+        
+        for (let i = 0; i < frames.length; i++) {
+            const frame = frames[i];
+            
+            // 验证帧头
+            if (frame[0] !== PROTOCOL.HEADER || frame[1] !== PROTOCOL.OP_DEVICE_LIST_RESPONSE) {
+                continue;
+            }
+            
+            const sequence = frame[2];
+            const length = frame[3];
+            
+            if (sequence === 0x00) {
+                // 第一帧：设备总数
+                const totalDevices = frame[4];
+                continue;
+            }
+            
+            // 解析设备数据
+            let offset = 4;
+            while (offset + 10 <= frame.length - 1) {
+                const shortAddr = frame[offset] | (frame[offset + 1] << 8); // 小端序
+                const deviceType = frame[offset + 2];
+                const mac = Buffer.from([
+                    frame[offset + 3],
+                    frame[offset + 4],
+                    frame[offset + 5],
+                    frame[offset + 6],
+                    frame[offset + 7],
+                    frame[offset + 8]
+                ]);
+                const buttons = frame[offset + 9];
+                
+                devices.push({
+                    shortAddr: shortAddr,
+                    type: deviceType,
+                    mac: mac.toString('hex').toUpperCase().match(/.{2}/g).join(':'),
+                    buttons: buttons
+                });
+                
+                offset += 10;
+            }
+        }
+        
+        return devices;
+    }
+
+    // 构建开关控制帧（带当前状态，保持其他路不变）
+    function buildSwitchControlFrame(shortAddr, buttonNumber, totalButtons, state, currentStates) {
+        let stateValue;
+
+        if (totalButtons === 1) {
+            // 单路开关
+            stateValue = state ? 0x02 : 0x01;
+            const buffer = Buffer.from([
+                PROTOCOL.HEADER,
+                PROTOCOL.OP_DEVICE_CONTROL,
+                0x05,  // Length
+                shortAddr & 0xFF,
+                (shortAddr >> 8) & 0xFF,
+                0x00,  // ACK = 0
+                0x05,  // 重传5次
+                PROTOCOL.MSG_TYPE_SWITCH,
+                stateValue
+            ]);
+            const checksum = calculateChecksum(buffer);
+            return Buffer.concat([buffer, Buffer.from([checksum])]);
+        } else if (totalButtons >= 2 && totalButtons <= 4) {
+            // 2-4路开关：使用当前状态构建完整状态值
+            if (currentStates && currentStates.length === totalButtons) {
+                stateValue = buildMultiSwitchState(currentStates, buttonNumber, state);
+            } else {
+                // 如果没有当前状态，只设置目标按钮，其他位设为00（保持不变）
+                const bitPos = (buttonNumber - 1) * 2;
+                stateValue = (state ? 0x02 : 0x01) << bitPos;
+            }
+
+            const buffer = Buffer.from([
+                PROTOCOL.HEADER,
+                PROTOCOL.OP_DEVICE_CONTROL,
+                0x05,  // Length
+                shortAddr & 0xFF,
+                (shortAddr >> 8) & 0xFF,
+                0x00,  // ACK = 0
+                0x05,  // 重传5次
+                PROTOCOL.MSG_TYPE_SWITCH,
+                stateValue
+            ]);
+            const checksum = calculateChecksum(buffer);
+            return Buffer.concat([buffer, Buffer.from([checksum])]);
+        } else if (totalButtons === 6) {
+            // 6路开关：2字节状态值（小端序）
+            let stateValue16;
+            if (currentStates && currentStates.length === totalButtons) {
+                stateValue16 = buildMultiSwitchState(currentStates, buttonNumber, state);
+            } else {
+                // 如果没有当前状态，只设置目标按钮，其他位设为00（保持不变）
+                const bitPos = (buttonNumber - 1) * 2;
+                stateValue16 = (state ? 0x02 : 0x01) << bitPos;
+            }
+
+            const buffer = Buffer.from([
+                PROTOCOL.HEADER,
+                PROTOCOL.OP_DEVICE_CONTROL,
+                0x06,  // Length
+                shortAddr & 0xFF,
+                (shortAddr >> 8) & 0xFF,
+                0x00,  // ACK = 0
+                0x05,  // 重传5次
+                PROTOCOL.MSG_TYPE_SWITCH,
+                stateValue16 & 0xFF,
+                (stateValue16 >> 8) & 0xFF
+            ]);
+            const checksum = calculateChecksum(buffer);
+            return Buffer.concat([buffer, Buffer.from([checksum])]);
+        }
+
+        return null;
+    }
+
+    // 解析状态事件帧
+    function parseStatusEvent(frame) {
+        // 验证帧头
+        if (frame[0] !== PROTOCOL.HEADER || frame[1] !== PROTOCOL.OP_STATUS_EVENT) {
+            return null;
+        }
+
+        const subOp = frame[2];
+        const length = frame[3];
+        const shortAddr = frame[4] | (frame[5] << 8); // 小端序
+        const msgType = frame[6];
+
+        const event = {
+            subOp: subOp,
+            shortAddr: shortAddr,
+            msgType: msgType
+        };
+
+        // 根据消息类型解析状态
+        if (msgType === PROTOCOL.MSG_TYPE_SWITCH) {
+            // 1-4路开关状态
+            const stateValue = frame[7];
+            event.states = parseMultiSwitchState(stateValue, 4);
+        } else if (msgType === PROTOCOL.MSG_TYPE_SWITCH_6) {
+            // 6路开关状态
+            const stateLow = frame[7];
+            const stateHigh = frame[8];
+            const stateValue = stateLow | (stateHigh << 8);
+            event.states = parseMultiSwitchState(stateValue, 6);
+        } else if (msgType === PROTOCOL.MSG_TYPE_DIMMER) {
+            // 调光灯状态
+            event.brightness = frame[7];
+            event.colorTemp = frame[8];
+        } else if (msgType === PROTOCOL.MSG_TYPE_CURTAIN) {
+            // 窗帘动作状态
+            event.action = frame[7]; // 0=停止, 1=打开中, 2=关闭中
+        } else if (msgType === PROTOCOL.MSG_TYPE_CURTAIN_POS) {
+            // 窗帘位置状态
+            event.position = frame[7]; // 0-100%
+        }
+
+        return event;
+    }
+
+    // 解析多路开关状态值
+    function parseMultiSwitchState(stateValue, totalButtons) {
+        const states = [];
+
+        for (let i = 0; i < totalButtons; i++) {
+            const bitPos = i * 2;
+            const bits = (stateValue >> bitPos) & 0x03;
+
+            if (bits === 0x01) {
+                states.push(false); // 关
+            } else if (bits === 0x02) {
+                states.push(true);  // 开
+            } else {
+                states.push(null);  // 保持不变或未知
+            }
+        }
+
+        return states;
+    }
+
+    // 构建多路开关状态值（用于控制时保持其他路不变）
+    function buildMultiSwitchState(currentStates, buttonNumber, newState) {
+        let stateValue = 0;
+
+        for (let i = 0; i < currentStates.length; i++) {
+            const bitPos = i * 2;
+            let bits;
+
+            if (i === buttonNumber - 1) {
+                // 要改变的按钮
+                bits = newState ? 0x02 : 0x01;
+            } else {
+                // 保持不变的按钮
+                if (currentStates[i] === true) {
+                    bits = 0x02;
+                } else if (currentStates[i] === false) {
+                    bits = 0x01;
+                } else {
+                    bits = 0x00; // 保持不变
+                }
+            }
+
+            stateValue |= (bits << bitPos);
+        }
+
+        return stateValue;
+    }
+
+    return {
+        PROTOCOL,
+        calculateChecksum,
+        buildGetDeviceListFrame,
+        parseDeviceListResponse,
+        buildSwitchControlFrame,
+        parseStatusEvent,
+        parseMultiSwitchState,
+        buildMultiSwitchState
+    };
+};
+

package/nodes/modbus-dashboard.html

@@ -16,6 +16,7 @@
             var node = this;
             var stateCache = {}; // 缓存所有线圈状态
             var relayNamesCache = {}; // 缓存继电器名称
+            var pollInterval = null; // 轮询定时器（全局变量，用于清理）
 
             // 填充主站节点选择器
             var masterNodeSelect = $("#node-input-masterNode");
@@ -62,17 +63,27 @@
                     return;
                 }
 
-                var masterNode = RED.nodes.node(masterNodeId);
-                if (!masterNode || !masterNode.slaves || masterNode.slaves.length === 0) {
-                    container.html('<div style="padding: 40px; text-align: center; color: #999; font-size: 14px;">主站节点未配置从站</div>');
-                    return;
-                }
+                // 显示加载中
+                container.html('<div style="padding: 40px; text-align: center; color: #999; font-size: 14px;"><i class="fa fa-spinner fa-spin"></i> 加载中...</div>');
+
+                // 通过HTTP API获取主站节点的最新配置
+                $.ajax({
+                    url: '/modbus-dashboard/master-config/' + masterNodeId,
+                    method: 'GET',
+                    success: function(masterConfig) {
+                        if (!masterConfig || !masterConfig.slaves || masterConfig.slaves.length === 0) {
+                            container.html('<div style="padding: 40px; text-align: center; color: #999; font-size: 14px;">主站节点未配置从站</div>');
+                            return;
+                        }
 
-                // 加载继电器名称
-                loadRelayNames();
+                        // 加载继电器名称
+                        loadRelayNames();
 
-                // 遍历所有从站
-                masterNode.slaves.forEach(function(slave) {
+                        // 清空容器
+                        container.empty();
+
+                        // 遍历所有从站
+                        masterConfig.slaves.forEach(function(slave) {
                     var slaveSection = $('<div class="slave-section">');
                     
                     var slaveHeader = $(`
@@ -113,20 +124,25 @@
                     container.append(slaveSection);
                 });
 
-                // 绑定按钮点击事件
-                $(".btn-toggle").off("click").on("click", function() {
-                    var slaveAddr = parseInt($(this).data("slave"));
-                    var coil = parseInt($(this).data("coil"));
-                    var key = slaveAddr + "_" + coil;
-                    var currentState = stateCache[key] || false;
-                    var newState = !currentState;
-                    
-                    // 发送控制命令（通过HTTP API）
-                    sendControlCommand(slaveAddr, coil, newState);
-                    
-                    // 立即更新UI（乐观更新）
-                    stateCache[key] = newState;
-                    updateButtonState($(this), newState);
+                        // 绑定按钮点击事件
+                        $(".btn-toggle").off("click").on("click", function() {
+                            var slaveAddr = parseInt($(this).data("slave"));
+                            var coil = parseInt($(this).data("coil"));
+                            var key = slaveAddr + "_" + coil;
+                            var currentState = stateCache[key] || false;
+                            var newState = !currentState;
+
+                            // 发送控制命令（通过HTTP API）
+                            sendControlCommand(slaveAddr, coil, newState);
+
+                            // 立即更新UI（乐观更新）
+                            stateCache[key] = newState;
+                            updateButtonState($(this), newState);
+                        });
+                    },
+                    error: function(xhr, status, error) {
+                        container.html('<div style="padding: 40px; text-align: center; color: #f44336; font-size: 14px;"><i class="fa fa-exclamation-triangle"></i> 加载失败: ' + error + '</div>');
+                    }
                 });
             }
 
@@ -164,7 +180,6 @@
             }
 
             // 轮询状态更新（每500ms）
-            var pollInterval = null;
             function startPolling() {
                 if (pollInterval) {
                     clearInterval(pollInterval);
@@ -241,6 +256,27 @@
             $("#node-dialog-cancel, #node-dialog-ok").on("click", function() {
                 stopPolling();
             });
+        },
+        oneditcancel: function() {
+            // 取消编辑时停止轮询，防止内存泄漏
+            if (pollInterval) {
+                clearInterval(pollInterval);
+                pollInterval = null;
+            }
+        },
+        oneditsave: function() {
+            // 保存时停止轮询，防止内存泄漏
+            if (pollInterval) {
+                clearInterval(pollInterval);
+                pollInterval = null;
+            }
+        },
+        oneditdelete: function() {
+            // 删除节点时停止轮询，防止内存泄漏
+            if (pollInterval) {
+                clearInterval(pollInterval);
+                pollInterval = null;
+            }
         }
     });
 </script>
@@ -267,7 +303,7 @@
             <i class="fa fa-dashboard"></i> 控制面板
         </label>
         <div id="dashboard-container" style="
-            max-height: 500px;
+            max-height: 700px;
             overflow-y: auto;
             border: 1px solid #ddd;
             border-radius: 4px;

package/nodes/modbus-dashboard.js

@@ -62,6 +62,24 @@ module.exports = function(RED) {
 
     RED.nodes.registerType("modbus-dashboard", ModbusDashboardNode);
 
+    // HTTP API：获取主站节点配置
+    RED.httpAdmin.get('/modbus-dashboard/master-config/:id', function(req, res) {
+        var masterNodeId = req.params.id;
+        var masterNode = RED.nodes.getNode(masterNodeId);
+
+        if (!masterNode) {
+            res.status(404).json({error: '主站节点不存在'});
+            return;
+        }
+
+        // 返回主站配置（包括最新的从站列表）
+        // 从站列表存储在 node.config.slaves 中
+        res.json({
+            slaves: (masterNode.config && masterNode.config.slaves) ? masterNode.config.slaves : [],
+            relayNames: masterNode.relayNames || {}
+        });
+    });
+
     // HTTP API：获取状态
     RED.httpAdmin.get('/modbus-dashboard/state', function(req, res) {
         res.json({