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

package/README.md

@@ -19,6 +19,8 @@ Node-RED的Modbus继电器控制节点，支持TCP/串口通信和MQTT集成，
 - **Symi开关集成**：自动识别并处理Symi私有协议按键事件，实现开关面板与继电器的双向同步
 - **HomeKit网桥**：一键桥接到Apple HomeKit，支持Siri语音控制，自动同步主站配置，名称可自定义
 - **智能写入队列**：所有写入操作串行执行，支持HomeKit群控160个继电器同时动作，流畅无卡顿
+- **可视化控制看板**：实时显示和控制所有继电器状态，美观易用，适合现场调试和日常监控
+- **自定义协议转换**：支持非标准485协议设备，窗帘循环控制，配置界面可测试发送
 - **多设备轮询**：支持最多10台Modbus从站设备，每台32路继电器
 - **智能轮询机制**：从站上报时自动暂停轮询，优先处理数据，避免冲突
 - **稳定可靠**：完整的内存管理、错误处理、断线重连，适合7x24小时长期运行
@@ -680,6 +682,102 @@ HomeKit网桥节点无需输入消息，自动同步主站配置和状态。
 - 配置信息持久化存储在~/.node-red/homekit-persist目录
 - 重启Node-RED后自动恢复配对状态，无需重新配对
 
+### 控制看板节点（客户友好模式）
+
+控制看板节点提供可视化界面，实时显示和控制所有从站的继电器状态，适合现场调试和日常监控。
+
+**配置参数**：
+- **节点名称**：控制看板的显示名称（默认：Modbus控制看板）
+- **主站节点**：选择要监控的Modbus主站节点（必填）
+
+**功能特性**：
+- **实时状态显示**：在配置界面中显示所有从站和线圈的实时状态
+- **一键控制**：点击按钮即可控制继电器开关，无需部署流程
+- **美观布局**：网格布局，按从站分组显示，一目了然
+- **名称同步**：自动同步HomeKit网桥配置的继电器名称
+- **快速响应**：状态实时更新（500ms轮询），响应迅速
+- **零开销**：不参与实际Modbus通信，不影响主站性能
+
+**使用步骤**：
+1. 在Node-RED中添加控制看板节点
+2. 选择已配置的Modbus主站节点
+3. 双击节点打开配置界面，即可看到所有继电器状态
+4. 点击按钮即可控制继电器开关（绿色=ON，红色=OFF）
+5. 部署流程后，节点会显示"监控中"状态
+
+**使用场景**：
+- **现场调试**：快速测试继电器是否正常工作
+- **日常监控**：实时查看所有继电器状态
+- **批量控制**：快速控制多个继电器
+- **客户演示**：美观的界面，适合向客户展示系统功能
+
+**技术细节**：
+- 使用HTTP API与主站通信，通过内部事件发送控制命令
+- 状态缓存机制，减少网络请求
+- 仅在配置界面打开时才轮询状态，关闭后自动停止
+- 与HomeKit网桥共享继电器名称配置，保持一致性
+
+**注意事项**：
+- 确保主站节点已正确配置并运行
+- 控制看板只在配置界面打开时才轮询状态
+- 继电器名称需在HomeKit网桥节点中配置
+- 本节点不参与实际Modbus通信，不会增加主站负担
+
+### 自定义协议节点
+
+自定义协议节点用于控制非标准Modbus协议的485设备，支持开关、窗帘、其他三种设备类型。
+
+**配置参数**：
+- **节点名称**：自定义协议节点的显示名称（默认：自定义协议）
+- **设备类型**：选择设备类型（开关/窗帘/其他）
+- **串口配置**：选择串口配置节点（必填）
+- **打开指令**：16进制打开指令（最多48字节）
+- **关闭指令**：16进制关闭指令（最多48字节）
+- **暂停指令**：16进制暂停指令（仅窗帘模式，最多48字节）
+
+**设备类型说明**：
+- **开关模式**：接收`true`发送打开指令，接收`false`发送关闭指令
+- **窗帘模式**：`true/false`交替触发，循环发送打开→关闭→暂停→打开...
+- **其他模式**：与开关模式相同，接收`true/false`发送对应指令
+
+**功能特性**：
+- **16进制配置**：支持空格分隔的16进制码，自动格式化为大写
+- **字节限制**：每个指令最多48字节，超出自动截断
+- **测试功能**：配置界面可直接点击"测试"按钮发送指令到串口总线
+- **持久化保存**：配置自动保存，重启后自动恢复
+- **连线方式**：从站开关 → 自定义协议 → debug节点
+
+**使用示例**：
+1. 在Node-RED中添加自定义协议节点
+2. 选择设备类型（例如：窗帘）
+3. 选择串口配置节点
+4. 输入16进制指令（例如：`01 05 00 00 FF 00 8C 3A`）
+5. 点击"测试"按钮验证指令是否正确
+6. 连线：从站开关 → 自定义协议 → debug节点
+7. 部署流程，触发从站开关即可发送自定义指令
+
+**窗帘模式示例**：
+```
+第1次收到true  → 发送"打开"指令（例如：01 05 00 00 FF 00 8C 3A）
+第2次收到false → 发送"关闭"指令（例如：01 05 00 00 00 00 CD CA）
+第3次收到true  → 发送"暂停"指令（例如：01 05 00 01 FF 00 DD FA）
+第4次收到false → 循环回到"打开"指令
+```
+
+**技术细节**：
+- 输入消息：`msg.payload = true/false`（从从站开关节点接收）
+- 输出消息：`msg.payload = Buffer`（16进制数据，可连线到debug节点）
+- 16进制字符串自动转换为Buffer格式
+- 支持空格、大小写混合输入，自动格式化
+- 窗帘模式内部维护状态索引，自动循环
+
+**注意事项**：
+- 16进制指令最多48字节
+- 窗帘模式需要配置三个指令（打开、关闭、暂停）
+- 测试功能需要先选择串口配置且串口已打开
+- 输出需要连线到debug节点才能发送到串口
+- 非标准协议设备数量不多时推荐使用连线方式
+
 ## 输出消息格式
 
 ### 主站节点
@@ -740,7 +838,7 @@ HomeKit网桥节点无需输入消息，自动同步主站配置和状态。
 
 ## 项目信息
 
-**版本**: v2.7.0
+**版本**: v2.7.2
 
 **核心功能**：
 - 支持多种Modbus协议（Telnet ASCII、RTU over TCP、Modbus TCP、Modbus RTU串口）
@@ -749,6 +847,8 @@ HomeKit网桥节点无需输入消息，自动同步主站配置和状态。
 - 🔥 **免连线通信**（主站和从站通过内部事件通信，无需连线）
 - 🔥 **HomeKit网桥**（一键桥接到Apple HomeKit，支持Siri语音控制）
 - 🔥 **智能写入队列**（所有写入操作串行执行，避免锁竞争，支持HomeKit群控）
+- 🔥 **可视化控制看板**（实时显示和控制所有继电器状态，美观易用）
+- 🔥 **自定义协议转换**（支持非标准485协议设备，窗帘循环控制）
 - MQTT集成（可选启用，Home Assistant自动发现）
 - 物理开关面板双向同步（支持开关模式和场景模式）
 - 长期稳定运行（内存管理、智能重连、异步处理）
@@ -757,71 +857,25 @@ HomeKit网桥节点无需输入消息，自动同步主站配置和状态。
 - Node.js: >=14.0.0
 - Node-RED: >=2.0.0
 
-**最新更新（v2.7.0）**：
-- **🔥 智能写入队列机制**：
-  - 所有写入操作（HomeKit、MQTT、内部事件）统一进入队列串行执行
-  - 彻底解决HomeKit群控时的锁竞争问题，不再出现"写入线圈等待超时"警告
-  - 写入间隔优化到20ms，确保快速响应（10个继电器同时动作仅需200ms）
-  - 队列自动处理，无需手动干预，确保总线稳定性
-  - 支持最多160个继电器（10台从站×16路）同时群控，流畅无卡顿
-- **性能优化**：
-  - 轮询恢复时间从100ms优化到20ms，提升响应速度5倍
-  - 锁等待超时从1000ms降低到100ms，快速检测异常
-  - 内存占用更低，CPU占用更少，适合长期运行
-
-**v2.6.8更新**：
-- **🔥 新增HomeKit网桥节点**：
-  - 一键桥接Modbus继电器到Apple HomeKit
-  - 自动同步主站配置的所有从站和继电器
-  - 支持在Node-RED中配置继电器友好名称
-  - 双向同步：HomeKit控制继电器，继电器状态实时同步到HomeKit
-  - 支持Siri语音控制和HomeKit自动化场景
-  - 持久化存储配对信息，重启后自动恢复
-  - 线圈0-15显示为开关，线圈16-31显示为插座（避免误触发）
-
-**v2.6.7更新**：
-- **🔥 修复LED反馈功能**：
-  - 主站轮询检测到状态变化时自动广播事件
-  - 从站开关节点监听状态变化并发送LED反馈到物理面板
-  - 支持开关模式（SET协议）和场景模式（REPORT协议）
-  - LED反馈队列间隔20ms，避免总线拥堵
-- **🔥 TCP连接稳定性优化**：
-  - 禁用TCP超时（永久连接），避免无数据时超时断开
-  - Keep-Alive间隔从30秒优化到10秒
-  - 适应客户长期不在家、总线无数据的场景
-- **日志优化**：
-  - 移除频繁的轮询日志（"轮询持续运行中"、"正在轮询从站X"）
-  - 轮询永久稳定运行，无需频繁确认
-  - 减少日志输出，降低硬盘占用
-
-**v2.6.6更新**：
-- **🔥 彻底解决MQTT日志刷屏问题**：
-  - 局域网IP检测优化：配置192.168.x.x等IP后不再尝试fallback地址
-  - 高频MQTT日志改为debug级别：broker候选、认证、重连等
-  - 默认不输出到日志文件和调试窗口
-  - 配置局域网IP后立即连接，不产生多余日志
-- **日志输出优化**：
-  - 连接成功/失败：仍使用log（重要信息）
-  - 重连尝试、fallback地址、认证信息：改为debug（调试信息）
-  - 仅启用debug模式时才在调试窗口显示
-  - 彻底解决日志刷屏和硬盘占用问题
-
-**v2.6.5更新**：
-- **🔥 修复MQTT报错问题**：从站开关节点新增"启用MQTT"勾选框
-  - 默认不启用MQTT，不会尝试连接
-  - 本地模式和MQTT模式自由切换
-
-**v2.6.4更新**：
-- **🔥 日志优化**：大幅减少日志输出，保证长期稳定运行
-  - 高频操作日志改为debug级别
-  - 默认不输出到日志文件
-  - 完善的内存清理机制
-
-**v2.6.3更新**：
-- **🔥 MQTT可选配置**：完全兼容无MQTT环境
-  - 本地模式：纯串口通信
-  - MQTT模式：可选接入HA
-  - 智能切换和状态显示
+**最新更新（v2.7.2）**：
+- **🔥 新增自定义协议节点**：
+  - 支持控制非标准Modbus协议的485设备
+  - 三种设备类型：开关（打开/关闭）、窗帘（打开/关闭/暂停循环）、其他（打开/关闭）
+  - 窗帘模式：true/false交替触发，循环发送打开→关闭→暂停→打开...
+  - 16进制指令配置，最多48字节，自动格式化
+  - 配置界面可直接测试发送指令到串口总线
+  - 配置持久化保存，重启后自动恢复
+  - 连线方式：从站开关 → 自定义协议 → debug节点
+
+**历史更新**：
+- **v2.7.1**：新增可视化控制看板节点，实时显示和控制所有继电器状态
+- **v2.7.0**：智能写入队列机制，解决HomeKit群控锁竞争问题，支持160个继电器同时群控
+- **v2.6.8**：新增HomeKit网桥节点，一键桥接到Apple HomeKit，支持Siri语音控制
+- **v2.6.7**：修复LED反馈功能，TCP连接稳定性优化，日志优化
+- **v2.6.6**：解决MQTT日志刷屏问题，局域网IP检测优化
+- **v2.6.5**：修复MQTT报错问题，新增"启用MQTT"勾选框
+- **v2.6.4**：日志优化，大幅减少日志输出
+- **v2.6.3**：MQTT可选配置，完全兼容无MQTT环境
 
 **性能优化**：
 - 轮询间隔优化：修复间隔计算逻辑，确保每个从站使用正确的轮询间隔
@@ -830,6 +884,7 @@ HomeKit网桥节点无需输入消息，自动同步主站配置和状态。
 - 减少调试日志输出，降低CPU占用
 - 互斥锁机制确保读写操作不冲突
 - 共享连接配置节点，避免串口资源冲突
+- 写入队列20ms间隔，快速响应，总线稳定
 
 **许可证**: MIT License
 
@@ -844,11 +899,17 @@ HomeKit网桥节点无需输入消息，自动同步主站配置和状态。
 ### 节点与分类（Palette）
 
 - 侧边栏分类名：`SYMI-MODBUS`
-- 包含节点：`modbus-master`（主站）、`modbus-slave-switch`（从站开关）、`modbus-debug`（调试）
+- 包含节点：
+  - `modbus-master`（主站）
+  - `modbus-slave-switch`（从站开关）
+  - `modbus-dashboard`（控制看板）
+  - `homekit-bridge`（HomeKit网桥）
+  - `custom-protocol`（自定义协议）
+  - `modbus-debug`（调试）
 - 如果未显示该分类或节点：
   - 刷新浏览器缓存（Shift+刷新）
   - 重启 Node-RED（如：`node-red-restart` 或系统服务方式）
-  - 在“节点管理（Manage Palette）”确认安装版本为 `v2.6.6`
+  - 在“节点管理（Manage Palette）”确认安装版本为最新版
 
 ### 调试节点（modbus-debug）使用要点
 
@@ -1106,7 +1167,7 @@ msg.payload = 1;      // 或 0
 
 ## 项目信息
 
-**版本**: v2.7.0
+**版本**: v2.7.2
 
 **核心功能**：
 - 支持多种Modbus协议（Telnet ASCII、RTU over TCP、Modbus TCP、Modbus RTU串口）
@@ -1117,6 +1178,8 @@ msg.payload = 1;      // 或 0
 - 🔥 **免连线通信**（主站和从站通过内部事件通信，无需连线，支持本地模式和MQTT模式）
 - 🔥 **HomeKit网桥**（一键桥接到Apple HomeKit，支持Siri语音控制，名称可自定义）
 - 🔥 **智能写入队列**（所有写入操作串行执行，避免锁竞争，支持HomeKit群控）
+- 🔥 **可视化控制看板**（实时显示和控制所有继电器状态，美观易用，客户友好）
+- 🔥 **自定义协议转换**（支持非标准485协议设备，窗帘循环控制，配置界面可测试）
 - MQTT集成（可选启用，Home Assistant自动发现，实体唯一性保证，QoS=0高性能发布）
 - 物理开关面板双向同步（亖米协议支持，LED反馈同步，支持开关模式和场景模式）
 - 共享连接架构（多个从站开关节点共享同一个串口/TCP连接，支持500+节点）

package/nodes/custom-protocol.html

@@ -0,0 +1,276 @@
+<script type="text/javascript">
+    RED.nodes.registerType('custom-protocol', {
+        category: 'SYMI-MODBUS',
+        color: '#FF9800',
+        defaults: {
+            name: {value: "自定义协议"},
+            deviceType: {value: "switch", required: true},
+            serialConfig: {value: "", type: "serial-port-config", required: true},
+            openCmd: {value: ""},
+            closeCmd: {value: ""},
+            pauseCmd: {value: ""}
+        },
+        inputs: 1,
+        outputs: 1,
+        icon: "font-awesome/fa-code",
+        label: function() {
+            var typeNames = {
+                'switch': '开关',
+                'curtain': '窗帘',
+                'other': '其他'
+            };
+            var typeName = typeNames[this.deviceType] || '自定义';
+            return this.name || (typeName + "协议");
+        },
+        oneditprepare: function() {
+            var node = this;
+
+            // 设备类型切换
+            $("#node-input-deviceType").on("change", function() {
+                var deviceType = $(this).val();
+                if (deviceType === "curtain") {
+                    $("#pause-cmd-row").show();
+                } else {
+                    $("#pause-cmd-row").hide();
+                }
+            });
+
+            // 初始化显示
+            if (node.deviceType === "curtain") {
+                $("#pause-cmd-row").show();
+            } else {
+                $("#pause-cmd-row").hide();
+            }
+
+            // 16进制输入验证和格式化
+            function validateHexInput(input) {
+                var value = $(input).val().trim();
+                // 移除所有非16进制字符
+                value = value.replace(/[^0-9A-Fa-f\s]/g, '');
+                // 自动添加空格分隔
+                value = value.replace(/\s+/g, '').match(/.{1,2}/g);
+                if (value) {
+                    value = value.join(' ').toUpperCase();
+                    // 限制48字节
+                    var bytes = value.split(' ');
+                    if (bytes.length > 48) {
+                        bytes = bytes.slice(0, 48);
+                        value = bytes.join(' ');
+                        RED.notify('指令长度已限制为48字节', 'warning');
+                    }
+                } else {
+                    value = '';
+                }
+                $(input).val(value);
+                return value;
+            }
+
+            // 绑定输入验证
+            $("#node-input-openCmd, #node-input-closeCmd, #node-input-pauseCmd").on("blur", function() {
+                validateHexInput(this);
+            });
+
+            // 测试按钮功能
+            function sendTestCommand(hexString, cmdName) {
+                if (!hexString || hexString.trim() === '') {
+                    RED.notify('请先输入16进制指令', 'warning');
+                    return;
+                }
+
+                var serialConfig = $("#node-input-serialConfig").val();
+                if (!serialConfig) {
+                    RED.notify('请先选择串口配置', 'warning');
+                    return;
+                }
+
+                // 发送测试命令
+                $.ajax({
+                    url: '/custom-protocol/test',
+                    method: 'POST',
+                    contentType: 'application/json',
+                    data: JSON.stringify({
+                        serialConfig: serialConfig,
+                        hexString: hexString,
+                        cmdName: cmdName
+                    }),
+                    success: function(result) {
+                        if (result.success) {
+                            RED.notify('✓ ' + cmdName + '指令已发送: ' + hexString, 'success');
+                        } else {
+                            RED.notify('✗ 发送失败: ' + result.error, 'error');
+                        }
+                    },
+                    error: function(err) {
+                        RED.notify('✗ 发送失败: ' + err.statusText, 'error');
+                    }
+                });
+            }
+
+            // 绑定测试按钮
+            $("#btn-test-open").on("click", function() {
+                var hexString = validateHexInput("#node-input-openCmd");
+                sendTestCommand(hexString, '打开');
+            });
+
+            $("#btn-test-close").on("click", function() {
+                var hexString = validateHexInput("#node-input-closeCmd");
+                sendTestCommand(hexString, '关闭');
+            });
+
+            $("#btn-test-pause").on("click", function() {
+                var hexString = validateHexInput("#node-input-pauseCmd");
+                sendTestCommand(hexString, '暂停');
+            });
+        },
+        oneditsave: function() {
+            // 保存前验证和格式化
+            validateHexInput("#node-input-openCmd");
+            validateHexInput("#node-input-closeCmd");
+            if (this.deviceType === "curtain") {
+                validateHexInput("#node-input-pauseCmd");
+            }
+        }
+    });
+
+    // 辅助函数
+    function validateHexInput(selector) {
+        var input = $(selector);
+        var value = input.val().trim();
+        value = value.replace(/[^0-9A-Fa-f\s]/g, '');
+        value = value.replace(/\s+/g, '').match(/.{1,2}/g);
+        if (value) {
+            value = value.join(' ').toUpperCase();
+            var bytes = value.split(' ');
+            if (bytes.length > 48) {
+                bytes = bytes.slice(0, 48);
+                value = bytes.join(' ');
+            }
+        } else {
+            value = '';
+        }
+        input.val(value);
+        return value;
+    }
+</script>
+
+<script type="text/html" data-template-name="custom-protocol">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> 节点名称</label>
+        <input type="text" id="node-input-name" placeholder="自定义协议">
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-deviceType"><i class="fa fa-cog"></i> 设备类型</label>
+        <select id="node-input-deviceType" style="width: 70%;">
+            <option value="switch">开关（打开/关闭）</option>
+            <option value="curtain">窗帘（打开/关闭/暂停循环）</option>
+            <option value="other">其他（打开/关闭）</option>
+        </select>
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-serialConfig"><i class="fa fa-plug"></i> 串口配置</label>
+        <input type="text" id="node-input-serialConfig" style="width: 70%;">
+    </div>
+
+    <div class="form-row">
+        <label style="width: 100%; font-weight: bold; margin-top: 15px; margin-bottom: 10px;">
+            <i class="fa fa-code"></i> 16进制指令配置（最多48字节）
+        </label>
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-openCmd"><i class="fa fa-arrow-up"></i> 打开指令</label>
+        <input type="text" id="node-input-openCmd" placeholder="例如: 01 05 00 00 FF 00 8C 3A" style="width: 50%;">
+        <button type="button" id="btn-test-open" class="red-ui-button" style="margin-left: 5px;">
+            <i class="fa fa-play"></i> 测试
+        </button>
+        <div style="font-size: 11px; color: #999; margin-top: 5px; margin-left: 105px;">
+            输入16进制码，空格分隔，自动格式化
+        </div>
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-closeCmd"><i class="fa fa-arrow-down"></i> 关闭指令</label>
+        <input type="text" id="node-input-closeCmd" placeholder="例如: 01 05 00 00 00 00 CD CA" style="width: 50%;">
+        <button type="button" id="btn-test-close" class="red-ui-button" style="margin-left: 5px;">
+            <i class="fa fa-play"></i> 测试
+        </button>
+    </div>
+
+    <div class="form-row" id="pause-cmd-row" style="display: none;">
+        <label for="node-input-pauseCmd"><i class="fa fa-pause"></i> 暂停指令</label>
+        <input type="text" id="node-input-pauseCmd" placeholder="例如: 01 05 00 01 FF 00 DD FA" style="width: 50%;">
+        <button type="button" id="btn-test-pause" class="red-ui-button" style="margin-left: 5px;">
+            <i class="fa fa-play"></i> 测试
+        </button>
+        <div style="font-size: 11px; color: #999; margin-top: 5px; margin-left: 105px;">
+            仅窗帘模式需要配置
+        </div>
+    </div>
+
+    <div class="form-row" style="margin-top: 20px;">
+        <div style="padding: 10px; background: #f0f8ff; border-left: 4px solid #2196F3; border-radius: 4px;">
+            <strong>使用说明：</strong><br>
+            <ul style="margin: 5px 0; padding-left: 20px; font-size: 12px;">
+                <li><strong>开关/其他模式</strong>: true发送打开指令，false发送关闭指令</li>
+                <li><strong>窗帘模式</strong>: true/false交替触发，循环发送打开→关闭→暂停→打开...</li>
+                <li>16进制码自动格式化为大写，空格分隔</li>
+                <li>点击"测试"按钮可直接发送到串口总线验证</li>
+                <li>配置自动持久化保存</li>
+            </ul>
+        </div>
+    </div>
+</script>
+
+<script type="text/html" data-help-name="custom-protocol">
+    <p>自定义协议节点，用于控制非标准Modbus协议的485设备。</p>
+    
+    <h3>功能特性</h3>
+    <ul>
+        <li>支持三种设备类型：开关、窗帘、其他</li>
+        <li>窗帘模式支持打开/关闭/暂停循环控制</li>
+        <li>16进制指令配置，最多48字节</li>
+        <li>配置界面可直接测试发送指令</li>
+        <li>配置持久化保存</li>
+    </ul>
+    
+    <h3>设备类型说明</h3>
+    <dl>
+        <dt>开关模式</dt>
+        <dd>接收true发送打开指令，接收false发送关闭指令</dd>
+        
+        <dt>窗帘模式</dt>
+        <dd>true/false交替触发，循环发送：打开→关闭→暂停→打开...</dd>
+        
+        <dt>其他模式</dt>
+        <dd>与开关模式相同，接收true/false发送对应指令</dd>
+    </dl>
+    
+    <h3>输入消息</h3>
+    <p>从从站开关节点接收：</p>
+    <pre>msg.payload = true/false</pre>
+    
+    <h3>输出消息</h3>
+    <p>输出Buffer格式的16进制数据，可连线到debug节点发送到串口：</p>
+    <pre>msg.payload = Buffer</pre>
+    
+    <h3>使用示例</h3>
+    <ol>
+        <li>配置串口节点</li>
+        <li>选择设备类型（开关/窗帘/其他）</li>
+        <li>输入16进制指令（空格分隔）</li>
+        <li>点击"测试"按钮验证指令是否正确</li>
+        <li>连线：从站开关 → 自定义协议 → debug节点</li>
+        <li>部署流程，触发从站开关即可发送自定义指令</li>
+    </ol>
+    
+    <h3>注意事项</h3>
+    <ul>
+        <li>16进制指令最多48字节</li>
+        <li>窗帘模式需要配置三个指令（打开、关闭、暂停）</li>
+        <li>测试功能需要先选择串口配置</li>
+        <li>输出需要连线到debug节点才能发送到串口</li>
+    </ul>
+</script>
+

package/nodes/custom-protocol.js

@@ -0,0 +1,201 @@
+module.exports = function(RED) {
+    "use strict";
+
+    function CustomProtocolNode(config) {
+        RED.nodes.createNode(this, config);
+        var node = this;
+
+        // 配置
+        node.config = {
+            name: config.name || "自定义协议",
+            deviceType: config.deviceType || "switch",
+            serialConfig: config.serialConfig,
+            openCmd: config.openCmd || "",
+            closeCmd: config.closeCmd || "",
+            pauseCmd: config.pauseCmd || ""
+        };
+
+        // 窗帘模式的状态索引（0=打开, 1=关闭, 2=暂停）
+        node.curtainStateIndex = 0;
+
+        // 获取串口配置节点
+        var serialNode = RED.nodes.getNode(node.config.serialConfig);
+        if (!serialNode) {
+            node.error('未找到串口配置节点');
+            node.status({fill: "red", shape: "ring", text: "未配置串口"});
+            return;
+        }
+
+        // 16进制字符串转Buffer
+        function hexStringToBuffer(hexString) {
+            if (!hexString || hexString.trim() === '') {
+                return null;
+            }
+            
+            try {
+                // 移除空格和非16进制字符
+                var hex = hexString.replace(/\s+/g, '').replace(/[^0-9A-Fa-f]/g, '');
+                
+                // 确保是偶数长度
+                if (hex.length % 2 !== 0) {
+                    node.warn('16进制字符串长度必须为偶数: ' + hexString);
+                    return null;
+                }
+                
+                // 限制48字节
+                if (hex.length > 96) {
+                    hex = hex.substring(0, 96);
+                    node.warn('指令长度超过48字节，已截断');
+                }
+                
+                // 转换为Buffer
+                var buffer = Buffer.from(hex, 'hex');
+                return buffer;
+            } catch (err) {
+                node.error('16进制字符串转换失败: ' + err.message);
+                return null;
+            }
+        }
+
+        // 发送指令到串口
+        function sendCommand(buffer, cmdName) {
+            if (!buffer) {
+                node.warn('指令为空，跳过发送');
+                return;
+            }
+
+            // 输出消息（可连线到debug节点）
+            var msg = {
+                payload: buffer,
+                topic: 'custom-protocol',
+                command: cmdName
+            };
+            
+            node.send(msg);
+            node.status({fill: "green", shape: "dot", text: cmdName + " (" + buffer.length + "字节)"});
+            
+            // 3秒后清除状态
+            setTimeout(function() {
+                node.status({fill: "blue", shape: "ring", text: "就绪"});
+            }, 3000);
+        }
+
+        // 处理输入消息
+        node.on('input', function(msg) {
+            var value = msg.payload;
+            
+            // 只接受布尔值
+            if (typeof value !== 'boolean') {
+                node.warn('输入必须为true/false，当前类型: ' + typeof value);
+                return;
+            }
+
+            if (node.config.deviceType === 'curtain') {
+                // 窗帘模式：true/false交替触发，循环发送三个指令
+                var commands = [
+                    {name: '打开', hex: node.config.openCmd},
+                    {name: '关闭', hex: node.config.closeCmd},
+                    {name: '暂停', hex: node.config.pauseCmd}
+                ];
+                
+                // 获取当前指令
+                var currentCmd = commands[node.curtainStateIndex];
+                if (!currentCmd || !currentCmd.hex) {
+                    node.warn('窗帘模式缺少' + currentCmd.name + '指令配置');
+                    return;
+                }
+                
+                // 转换并发送
+                var buffer = hexStringToBuffer(currentCmd.hex);
+                if (buffer) {
+                    sendCommand(buffer, currentCmd.name);
+                    
+                    // 移动到下一个状态
+                    node.curtainStateIndex = (node.curtainStateIndex + 1) % 3;
+                }
+            } else {
+                // 开关/其他模式：true发送打开，false发送关闭
+                var cmdName = value ? '打开' : '关闭';
+                var hexString = value ? node.config.openCmd : node.config.closeCmd;
+                
+                if (!hexString) {
+                    node.warn(cmdName + '指令未配置');
+                    return;
+                }
+                
+                var buffer = hexStringToBuffer(hexString);
+                if (buffer) {
+                    sendCommand(buffer, cmdName);
+                }
+            }
+        });
+
+        // 初始状态
+        var typeNames = {
+            'switch': '开关',
+            'curtain': '窗帘',
+            'other': '其他'
+        };
+        var typeName = typeNames[node.config.deviceType] || '自定义';
+        node.status({fill: "blue", shape: "ring", text: typeName + "模式就绪"});
+
+        // 清理
+        node.on('close', function() {
+            node.status({});
+        });
+    }
+
+    RED.nodes.registerType("custom-protocol", CustomProtocolNode);
+
+    // HTTP API：测试发送指令
+    RED.httpAdmin.post('/custom-protocol/test', function(req, res) {
+        var serialConfigId = req.body.serialConfig;
+        var hexString = req.body.hexString;
+        var cmdName = req.body.cmdName;
+
+        if (!serialConfigId || !hexString) {
+            res.status(400).json({success: false, error: '参数错误'});
+            return;
+        }
+
+        // 获取串口配置节点
+        var serialNode = RED.nodes.getNode(serialConfigId);
+        if (!serialNode) {
+            res.status(404).json({success: false, error: '未找到串口配置节点'});
+            return;
+        }
+
+        try {
+            // 转换16进制字符串为Buffer
+            var hex = hexString.replace(/\s+/g, '').replace(/[^0-9A-Fa-f]/g, '');
+            if (hex.length % 2 !== 0) {
+                res.status(400).json({success: false, error: '16进制字符串长度必须为偶数'});
+                return;
+            }
+            if (hex.length > 96) {
+                hex = hex.substring(0, 96);
+            }
+            var buffer = Buffer.from(hex, 'hex');
+
+            // 发送到串口
+            if (serialNode.serialPort && serialNode.serialPort.isOpen) {
+                serialNode.serialPort.write(buffer, function(err) {
+                    if (err) {
+                        res.json({success: false, error: err.message});
+                    } else {
+                        res.json({
+                            success: true,
+                            message: cmdName + '指令已发送',
+                            bytes: buffer.length
+                        });
+                    }
+                });
+            } else {
+                res.status(503).json({success: false, error: '串口未打开'});
+            }
+        } catch (err) {
+            res.status(500).json({success: false, error: err.message});
+        }
+    });
+};
+

package/nodes/modbus-dashboard.html

@@ -0,0 +1,396 @@
+<script type="text/javascript">
+    RED.nodes.registerType('modbus-dashboard', {
+        category: 'SYMI-MODBUS',
+        color: '#4CAF50',
+        defaults: {
+            name: {value: "Modbus控制看板"},
+            masterNode: {value: "", required: true}
+        },
+        inputs: 0,
+        outputs: 0,
+        icon: "font-awesome/fa-dashboard",
+        label: function() {
+            return this.name || "Modbus控制看板";
+        },
+        oneditprepare: function() {
+            var node = this;
+            var stateCache = {}; // 缓存所有线圈状态
+            var relayNamesCache = {}; // 缓存继电器名称
+
+            // 填充主站节点选择器
+            var masterNodeSelect = $("#node-input-masterNode");
+            masterNodeSelect.empty();
+            masterNodeSelect.append('<option value="">请选择主站节点</option>');
+
+            RED.nodes.eachNode(function(n) {
+                if (n.type === "modbus-master") {
+                    var label = n.name || `主站 ${n.id.substring(0, 8)}`;
+                    var selected = (n.id === node.masterNode) ? ' selected' : '';
+                    masterNodeSelect.append(`<option value="${n.id}"${selected}>${label}</option>`);
+                }
+            });
+
+            // 加载HomeKit网桥的名称配置
+            function loadRelayNames() {
+                RED.nodes.eachNode(function(n) {
+                    if (n.type === "homekit-bridge" && n.masterNode === node.masterNode) {
+                        if (n.relayNames) {
+                            relayNamesCache = Object.assign({}, n.relayNames);
+                        }
+                    }
+                });
+            }
+
+            // 获取继电器名称
+            function getRelayName(slaveAddr, coil) {
+                var key = slaveAddr + "_" + coil;
+                if (relayNamesCache[key]) {
+                    return relayNamesCache[key];
+                }
+                var relayType = coil < 16 ? "开关" : "插座";
+                return `${relayType}${coil + 1}`;
+            }
+
+            // 渲染控制面板
+            function renderDashboard() {
+                var masterNodeId = $("#node-input-masterNode").val();
+                var container = $("#dashboard-container");
+                container.empty();
+
+                if (!masterNodeId) {
+                    container.html('<div style="padding: 40px; text-align: center; color: #999; font-size: 14px;">请先选择主站节点</div>');
+                    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;
+                }
+
+                // 加载继电器名称
+                loadRelayNames();
+
+                // 遍历所有从站
+                masterNode.slaves.forEach(function(slave) {
+                    var slaveSection = $('<div class="slave-section">');
+                    
+                    var slaveHeader = $(`
+                        <div class="slave-header">
+                            <span class="slave-title">从站 ${slave.address}</span>
+                            <span class="slave-info">线圈 ${slave.coilStart}-${slave.coilEnd}</span>
+                        </div>
+                    `);
+                    
+                    var coilGrid = $('<div class="coil-grid">');
+                    
+                    for (var coil = slave.coilStart; coil <= slave.coilEnd; coil++) {
+                        var key = slave.address + "_" + coil;
+                        var relayName = getRelayName(slave.address, coil);
+                        var currentState = stateCache[key] || false;
+                        var stateClass = currentState ? 'state-on' : 'state-off';
+                        var stateText = currentState ? 'ON' : 'OFF';
+                        
+                        var coilItem = $(`
+                            <div class="coil-item">
+                                <div class="coil-header">
+                                    <span class="coil-name" title="${relayName}">${relayName}</span>
+                                    <span class="coil-number">线圈${coil}</span>
+                                </div>
+                                <div class="coil-control">
+                                    <button class="btn-toggle ${stateClass}" data-slave="${slave.address}" data-coil="${coil}">
+                                        <span class="state-text">${stateText}</span>
+                                    </button>
+                                </div>
+                            </div>
+                        `);
+                        
+                        coilGrid.append(coilItem);
+                    }
+                    
+                    slaveSection.append(slaveHeader);
+                    slaveSection.append(coilGrid);
+                    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);
+                });
+            }
+
+            // 更新按钮状态
+            function updateButtonState(button, state) {
+                if (state) {
+                    button.removeClass('state-off').addClass('state-on');
+                    button.find('.state-text').text('ON');
+                } else {
+                    button.removeClass('state-on').addClass('state-off');
+                    button.find('.state-text').text('OFF');
+                }
+            }
+
+            // 发送控制命令
+            function sendControlCommand(slaveAddr, coil, value) {
+                // 通过Node-RED的admin API发送注入命令
+                $.ajax({
+                    url: '/modbus-dashboard/control',
+                    method: 'POST',
+                    contentType: 'application/json',
+                    data: JSON.stringify({
+                        slave: slaveAddr,
+                        coil: coil,
+                        value: value
+                    }),
+                    success: function() {
+                        console.log(`控制命令已发送: 从站${slaveAddr} 线圈${coil} = ${value ? 'ON' : 'OFF'}`);
+                    },
+                    error: function(err) {
+                        console.error('控制命令发送失败:', err);
+                        RED.notify('控制命令发送失败', 'error');
+                    }
+                });
+            }
+
+            // 轮询状态更新（每500ms）
+            var pollInterval = null;
+            function startPolling() {
+                if (pollInterval) {
+                    clearInterval(pollInterval);
+                }
+                
+                pollInterval = setInterval(function() {
+                    var masterNodeId = $("#node-input-masterNode").val();
+                    if (!masterNodeId) return;
+                    
+                    $.ajax({
+                        url: '/modbus-dashboard/state',
+                        method: 'GET',
+                        success: function(data) {
+                            if (data && data.states) {
+                                // 更新状态缓存
+                                Object.keys(data.states).forEach(function(key) {
+                                    var oldState = stateCache[key];
+                                    var newState = data.states[key];
+                                    stateCache[key] = newState;
+                                    
+                                    // 如果状态变化，更新UI
+                                    if (oldState !== newState) {
+                                        var parts = key.split('_');
+                                        var slaveAddr = parts[0];
+                                        var coil = parts[1];
+                                        var button = $(`.btn-toggle[data-slave="${slaveAddr}"][data-coil="${coil}"]`);
+                                        if (button.length > 0) {
+                                            updateButtonState(button, newState);
+                                        }
+                                    }
+                                });
+                            }
+                        },
+                        error: function(err) {
+                            console.error('状态轮询失败:', err);
+                        }
+                    });
+                }, 500);
+            }
+
+            // 停止轮询
+            function stopPolling() {
+                if (pollInterval) {
+                    clearInterval(pollInterval);
+                    pollInterval = null;
+                }
+            }
+
+            // 监听主站节点选择变化
+            masterNodeSelect.on("change", function() {
+                renderDashboard();
+                stopPolling();
+                if ($(this).val()) {
+                    startPolling();
+                }
+            });
+
+            // 初始渲染
+            renderDashboard();
+            if (node.masterNode) {
+                startPolling();
+            }
+
+            // 对话框关闭时停止轮询
+            $("#node-dialog-cancel, #node-dialog-ok").on("click", function() {
+                stopPolling();
+            });
+        }
+    });
+</script>
+
+<script type="text/html" data-template-name="modbus-dashboard">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> 节点名称</label>
+        <input type="text" id="node-input-name" placeholder="Modbus控制看板">
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-masterNode"><i class="fa fa-microchip"></i> 主站节点</label>
+        <select id="node-input-masterNode" style="width: 70%;">
+            <option value="">请选择主站节点</option>
+        </select>
+        <div style="font-size: 11px; color: #999; margin-top: 5px;">选择要监控的Modbus主站节点</div>
+    </div>
+
+    <div class="form-row" style="margin-top: 20px;">
+        <label style="width: 100%; font-weight: bold; margin-bottom: 10px;">
+            <i class="fa fa-dashboard"></i> 控制面板
+        </label>
+        <div id="dashboard-container" style="
+            max-height: 500px;
+            overflow-y: auto;
+            border: 1px solid #ddd;
+            border-radius: 4px;
+            background: #fafafa;
+            padding: 10px;
+        "></div>
+    </div>
+
+    <style>
+        .slave-section {
+            margin-bottom: 20px;
+            background: white;
+            border-radius: 8px;
+            padding: 15px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        }
+        
+        .slave-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 15px;
+            padding-bottom: 10px;
+            border-bottom: 2px solid #4CAF50;
+        }
+        
+        .slave-title {
+            font-weight: bold;
+            font-size: 16px;
+            color: #333;
+        }
+        
+        .slave-info {
+            font-size: 12px;
+            color: #666;
+        }
+        
+        .coil-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));
+            gap: 10px;
+        }
+        
+        .coil-item {
+            background: #f9f9f9;
+            border: 1px solid #e0e0e0;
+            border-radius: 6px;
+            padding: 10px;
+        }
+        
+        .coil-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 8px;
+        }
+        
+        .coil-name {
+            font-weight: 500;
+            font-size: 13px;
+            color: #333;
+            overflow: hidden;
+            text-overflow: ellipsis;
+            white-space: nowrap;
+            max-width: 120px;
+        }
+        
+        .coil-number {
+            font-size: 11px;
+            color: #999;
+        }
+        
+        .coil-control {
+            display: flex;
+            justify-content: center;
+        }
+        
+        .btn-toggle {
+            width: 100%;
+            padding: 8px 16px;
+            border: none;
+            border-radius: 4px;
+            font-weight: bold;
+            font-size: 13px;
+            cursor: pointer;
+            transition: all 0.2s;
+        }
+        
+        .btn-toggle.state-on {
+            background: #4CAF50;
+            color: white;
+        }
+        
+        .btn-toggle.state-on:hover {
+            background: #45a049;
+        }
+        
+        .btn-toggle.state-off {
+            background: #f44336;
+            color: white;
+        }
+        
+        .btn-toggle.state-off:hover {
+            background: #da190b;
+        }
+    </style>
+</script>
+
+<script type="text/html" data-help-name="modbus-dashboard">
+    <p>Modbus控制看板节点，提供可视化界面显示和控制所有从站的继电器状态。</p>
+    
+    <h3>功能特性</h3>
+    <ul>
+        <li>实时显示所有从站和线圈的状态</li>
+        <li>支持直接点击按钮控制继电器开关</li>
+        <li>自动同步HomeKit网桥配置的继电器名称</li>
+        <li>美观的网格布局，按从站分组显示</li>
+        <li>状态实时更新（500ms轮询）</li>
+        <li>零额外开销，不参与实际Modbus通信</li>
+    </ul>
+    
+    <h3>使用步骤</h3>
+    <ol>
+        <li>选择已配置的Modbus主站节点</li>
+        <li>在配置界面中查看所有继电器状态</li>
+        <li>点击按钮即可控制继电器开关</li>
+        <li>部署流程后，节点会显示监控状态</li>
+    </ol>
+    
+    <h3>注意事项</h3>
+    <ul>
+        <li>确保主站节点已正确配置并运行</li>
+        <li>控制看板只在配置界面打开时才轮询状态</li>
+        <li>继电器名称与HomeKit网桥共享，修改需在HomeKit网桥节点中进行</li>
+        <li>本节点不参与实际Modbus通信，不会增加主站负担</li>
+    </ul>
+</script>
+

package/nodes/modbus-dashboard.js

@@ -0,0 +1,98 @@
+module.exports = function(RED) {
+    "use strict";
+
+    // 全局状态缓存（所有dashboard节点共享）
+    var globalStateCache = {};
+
+    function ModbusDashboardNode(config) {
+        RED.nodes.createNode(this, config);
+        var node = this;
+
+        // 配置
+        node.config = {
+            name: config.name || "Modbus控制看板",
+            masterNode: config.masterNode
+        };
+
+        // 获取主站节点
+        var masterNode = RED.nodes.getNode(node.config.masterNode);
+        if (!masterNode) {
+            node.error('未找到主站节点');
+            node.status({fill: "red", shape: "ring", text: "未配置主站"});
+            return;
+        }
+
+        // 监听主站状态更新事件
+        node.stateUpdateHandler = function(data) {
+            if (!data || typeof data !== 'object') {
+                return;
+            }
+
+            var key = data.slave + "_" + data.coil;
+            globalStateCache[key] = data.value;
+        };
+
+        // 注册事件监听器
+        masterNode.on('stateUpdate', node.stateUpdateHandler);
+
+        // 初始化状态缓存（从主站获取当前状态）
+        if (masterNode.deviceStates) {
+            Object.keys(masterNode.deviceStates).forEach(function(slaveId) {
+                var deviceState = masterNode.deviceStates[slaveId];
+                if (deviceState && deviceState.coils) {
+                    deviceState.coils.forEach(function(value, coil) {
+                        var key = slaveId + "_" + coil;
+                        globalStateCache[key] = value;
+                    });
+                }
+            });
+        }
+
+        // 更新节点状态
+        node.status({fill: "green", shape: "dot", text: "监控中"});
+
+        // 清理
+        node.on('close', function() {
+            if (masterNode && node.stateUpdateHandler) {
+                masterNode.removeListener('stateUpdate', node.stateUpdateHandler);
+            }
+            node.status({});
+        });
+    }
+
+    RED.nodes.registerType("modbus-dashboard", ModbusDashboardNode);
+
+    // HTTP API：获取状态
+    RED.httpAdmin.get('/modbus-dashboard/state', function(req, res) {
+        res.json({
+            states: globalStateCache
+        });
+    });
+
+    // HTTP API：发送控制命令
+    RED.httpAdmin.post('/modbus-dashboard/control', function(req, res) {
+        var slave = parseInt(req.body.slave);
+        var coil = parseInt(req.body.coil);
+        var value = Boolean(req.body.value);
+
+        if (isNaN(slave) || isNaN(coil)) {
+            res.status(400).json({error: '参数错误'});
+            return;
+        }
+
+        // 发送内部事件（通过免连线通信机制）
+        RED.events.emit('modbus:writeCoil', {
+            slave: slave,
+            coil: coil,
+            value: value,
+            source: 'dashboard'
+        });
+
+        // 立即更新缓存（乐观更新）
+        var key = slave + "_" + coil;
+        globalStateCache[key] = value;
+
+        res.json({success: true});
+    });
+};
+

package/package.json

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