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

package/README.md

@@ -56,7 +56,7 @@ node-red-restart
 **配置方法**：
 1. 主站节点：不启用MQTT或不配置MQTT服务器
 2. 从站开关节点：不配置MQTT服务器
-3. **无需连线**：主站和从站通过内部事件自动通信（v2.6.7+）
+3. **无需连线**：主站和从站通过内部事件自动通信
 
 **优势**：
 - ✅ 断网也能稳定运行
@@ -725,63 +725,35 @@ HomeKit网桥节点无需输入消息，自动同步主站配置和状态。
 
 ### 自定义协议节点
 
-自定义协议节点用于控制非标准Modbus协议的485设备，支持开关、窗帘、其他三种设备类型。
+用于控制非标准Modbus协议的485设备（如窗帘、特殊开关等）。
 
-**配置参数**：
-- **节点名称**：自定义协议节点的显示名称（默认：自定义协议）
-- **设备类型**：选择设备类型（开关/窗帘/其他）
-- **串口配置**：选择串口配置节点（必填）
-- **打开指令**：16进制打开指令（最多48字节）
-- **关闭指令**：16进制关闭指令（最多48字节）
-- **暂停指令**：16进制暂停指令（仅窗帘模式，最多48字节）
-
-**设备类型说明**：
-- **开关模式**：接收`true`发送打开指令，接收`false`发送关闭指令
-- **窗帘模式**：无论收到`true`还是`false`，都触发下一个指令，循环顺序：打开 → 暂停 → 关闭 → 暂停 → 打开...
-- **其他模式**：与开关模式相同，接收`true/false`发送对应指令
-
-**功能特性**：
-- **16进制配置**：支持空格分隔的16进制码，自动格式化为大写
-- **字节限制**：每个指令最多48字节，超出自动截断
-- **测试功能**：配置界面可直接点击"测试"按钮发送指令到串口总线
-- **持久化保存**：配置自动保存，重启后自动恢复
-- **连线方式**：从站开关 → 自定义协议 → debug节点
-
-**使用示例**：
-1. 在Node-RED中添加自定义协议节点
-2. 选择设备类型（例如：窗帘）
+**配置步骤**：
+1. 添加自定义协议节点到流程画布
+2. 选择设备类型（开关/窗帘/其他）
 3. 选择串口配置节点
-4. 输入16进制指令（例如：`01 05 00 00 FF 00 8C 3A`）
-5. 点击"测试"按钮验证指令是否正确
-6. 连线：从站开关 → 自定义协议 → debug节点
-7. 部署流程，触发从站开关即可发送自定义指令
-
-**窗帘模式示例**：
-```
-第1次收到true/false → 发送"打开"指令（例如：01 05 00 00 FF 00 8C 3A）
-第2次收到true/false → 发送"暂停"指令（例如：01 05 00 01 FF 00 DD FA）
-第3次收到true/false → 发送"关闭"指令（例如：01 05 00 00 00 00 CD CA）
-第4次收到true/false → 发送"暂停"指令（例如：01 05 00 01 FF 00 DD FA）
-第5次收到true/false → 循环回到"打开"指令
-```
+4. 输入16进制指令（空格分隔，自动格式化为大写）
+   - 打开指令：例如 `01 05 00 00 FF 00 8C 3A`
+   - 关闭指令：例如 `01 05 00 00 00 00 CD CA`
+   - 暂停指令：仅窗帘模式需要，例如 `01 05 00 01 FF 00 DD FA`
+5. 点击"测试"按钮验证指令是否正确发送
+6. 连线：从站开关 → 自定义协议节点
+7. 部署流程
 
-**适配两种开关模式**：
-- **有状态开关**（开关模式）：从站开关关联实际线圈，输出`true/false`交替
-- **无状态开关**（场景模式）：从站开关关联虚拟线圈（如线圈32），每次点击只发`true`或`false`
+**设备类型说明**：
+- **开关模式**：收到`true`发送打开指令，收到`false`发送关闭指令
+- **窗帘模式**：每次触发循环发送下一个指令（打开 → 暂停 → 关闭 → 暂停 → 打开...）
+- **其他模式**：与开关模式相同
 
-**技术细节**：
-- 输入消息：`msg.payload = true/false`（从从站开关节点接收）
-- 输出消息：`msg.payload = Buffer`（16进制数据，可连线到debug节点）
-- 16进制字符串自动转换为Buffer格式
-- 支持空格、大小写混合输入，自动格式化
-- 窗帘模式内部维护状态索引，自动循环（4个状态：打开→暂停→关闭→暂停）
+**使用场景**：
+- 窗帘控制：支持打开/暂停/关闭循环控制
+- 特殊开关：非标准Modbus协议的485设备
+- 自定义设备：任何需要发送固定16进制指令的设备
 
 **注意事项**：
-- 16进制指令最多48字节
-- 窗帘模式需要配置三个指令（打开、关闭、暂停）
-- 测试功能需要先选择串口配置且串口已打开
-- 输出需要连线到debug节点才能发送到串口
-- 非标准协议设备数量不多时推荐使用连线方式
+- 每个指令最多48字节
+- 窗帘模式需配置三个指令（打开、关闭、暂停）
+- 测试功能需先选择串口配置
+- 无需连线到debug节点，直接通过串口配置节点发送数据
 
 ## 输出消息格式
 
@@ -841,323 +813,34 @@ HomeKit网桥节点无需输入消息，自动同步主站配置和状态。
 ]
 ```
 
-## 项目信息
+完整示例请参考项目中的 `examples/basic-flow.json` 文件。
 
-**版本**: v2.7.2
+## 技术栈
 
-**核心功能**：
-- 支持多种Modbus协议（Telnet ASCII、RTU over TCP、Modbus TCP、Modbus RTU串口）
-- 多设备轮询（最多10台从站，每台32路继电器，轮询间隔100-10000ms可调）
-- 🔥 **双模式支持**（本地模式和MQTT模式可选切换，断网也能稳定运行）
-- 🔥 **免连线通信**（主站和从站通过内部事件通信，无需连线）
-- 🔥 **HomeKit网桥**（一键桥接到Apple HomeKit，支持Siri语音控制）
-- 🔥 **智能写入队列**（所有写入操作串行执行，避免锁竞争，支持HomeKit群控）
-- 🔥 **可视化控制看板**（实时显示和控制所有继电器状态，美观易用）
-- 🔥 **自定义协议转换**（支持非标准485协议设备，窗帘循环控制）
-- MQTT集成（可选启用，Home Assistant自动发现）
-- 物理开关面板双向同步（支持开关模式和场景模式）
-- 长期稳定运行（内存管理、智能重连、异步处理）
-
-**技术要求**：
 - Node.js: >=14.0.0
 - Node-RED: >=2.0.0
+- modbus-serial: ^8.0.23
+- serialport: ^12.0.0
+- mqtt: ^5.14.1（可选）
+- hap-nodejs: ^1.2.0
+- node-persist: ^4.0.4
 
-## 许可证
+## 版本信息
 
-MIT License
+**当前版本**: v2.7.5
 
-## 作者
+**更新内容**：
+- 修复从站开关节点LED反馈重复发送问题
+- 优化状态变化广播机制，避免重复触发
+- 增强队列处理稳定性，确保所有状态正确传递
+- 改进日志输出，便于问题排查
 
-symi-daguo
-- NPM: https://www.npmjs.com/~symi-daguo
-- GitHub: https://github.com/symi-daguo
+## 许可证
 
-## 支持
+MIT License
+
+## 支持与反馈
 
+- GitHub: https://github.com/symi-daguo/node-red-contrib-symi-modbus
 - Issues: https://github.com/symi-daguo/node-red-contrib-symi-modbus/issues
 - NPM: https://www.npmjs.com/package/node-red-contrib-symi-modbus
-
-### 节点与分类（Palette）
-
-- 侧边栏分类名：`SYMI-MODBUS`
-- 包含节点：
-  - `modbus-master`（主站）
-  - `modbus-slave-switch`（从站开关）
-  - `modbus-dashboard`（控制看板）
-  - `homekit-bridge`（HomeKit网桥）
-  - `custom-protocol`（自定义协议）
-  - `modbus-debug`（调试）
-- 如果未显示该分类或节点：
-  - 刷新浏览器缓存（Shift+刷新）
-  - 重启 Node-RED（如：`node-red-restart` 或系统服务方式）
-  - 在“节点管理（Manage Palette）”确认安装版本为最新版
-
-### 调试节点（modbus-debug）使用要点
-
-- 数据来源选择：`sourceType = serial`（共享串口）或 `modbus`（独立服务器）
-- 共享串口：需要选择并关联一个 `serial-port-config` 配置节点
-- 独立服务器：需要选择并关联一个 `modbus-server-config` 配置节点
-- HEX显示：可选大写、可选时间戳、`maxBytes` 控制显示长度
-- 输出：`msg.payload`（格式化HEX）、`msg.buffer`（原始Buffer）、`msg.meta`（来源信息）
-
-
-### MQTT自动发现
-
-启用MQTT后，自动生成Home Assistant兼容的Discovery配置：
-- **唯一性保证**：每个实体使用稳定的`unique_id`，避免重复生成
-- **设备分组**：同一从站的所有继电器自动分组到一个设备下
-- **状态持久化**：使用`retain=true`确保状态持久化
-- **在线状态**：自动发布设备可用性状态
-
-### 配置持久化
-
-所有节点配置自动保存到Node-RED的flows文件中：
-- 从站地址、线圈范围、轮询间隔
-- MQTT服务器配置
-- 开关面板映射关系
-
-部署后配置永久生效，重启Node-RED后自动恢复。
-
-### 长期稳定运行
-
-针对工控机24/7长期运行优化：
-- **内存管理**：自动清理缓存，释放无用对象
-- **事件监听器清理**：关闭时移除所有监听器，防止内存泄漏
-- **智能日志限流**：错误日志10分钟输出一次，避免日志刷屏
-- **智能重连机制**：
-  - Modbus连接断开自动重连（指数退避：5秒→10秒→20秒...最大60秒）
-  - MQTT连接断开自动重连（支持多地址fallback）
-  - 串口拔插自动检测并重连
-  - TCP网络故障自动恢复
-  - 连接前彻底清理旧实例，避免资源泄漏
-- **互斥锁机制**：防止读写冲突导致的数据异常
-- **TCP永久连接**：
-  - 禁用TCP超时（永久连接），避免无数据时超时断开
-  - Keep-Alive心跳10秒间隔，确保连接活跃
-  - 适应客户长期不在家、总线无数据的场景
-  - 网络故障自动重连，恢复后立即恢复通信
-
-## 技术规格
-
-### Modbus协议
-
-- **协议类型**：Modbus TCP / Modbus RTU
-- **底层库**：modbus-serial ^8.0.23（内部封装serialport，支持TCP和串口）
-- **功能码支持**：0x01（读线圈）、0x05（写单个线圈）、0x0F（写多个线圈）
-- **从站地址范围**：1-247（建议从10开始）
-- **线圈数量**：每台设备32个（0-31）
-- **最大设备数**：10台同时轮询
-- **轮询间隔**：默认200ms（建议300-500ms，支持100-10000ms）
-- **串口配置**：9600 8-N-1（波特率9600，8数据位，无校验，1停止位）
-- **超时设置**：5000ms（TCP和串口通用）
-
-### 兼容性
-
-- **Node.js**: >= 14.0.0
-- **Node-RED**: >= 2.0.0
-- **MQTT Broker**: Mosquitto / EMQX / Any MQTT 3.1.1/5.0
-- **Home Assistant**: 2024.x+（MQTT Discovery标准）
-- **操作系统**: Windows / Linux / macOS / HassOS
-
-## Home Assistant集成
-
-### 自动发现
-
-启用MQTT后，设备自动出现在Home Assistant中：
-- 实体ID: `switch.relay_{从站地址}_{线圈编号}`
-- 设备名称: `Modbus继电器-{从站地址}`
-- 自动分组: 同一从站的所有继电器分组到一个设备
-
-### MQTT主题结构
-
-```
-状态主题: modbus/relay/{从站}/{线圈}/state
-命令主题: modbus/relay/{从站}/{线圈}/set
-可用性主题: modbus/relay/{从站}/availability
-发现主题: homeassistant/switch/modbus_relay_{从站}_{线圈}/config
-```
-
-## 故障排除
-
-### 串口连接失败
-
-**Linux**:
-```bash
-# 查看串口设备
-ls -l /dev/ttyUSB* /dev/ttyS*
-
-# 添加用户到dialout组（需要重新登录）
-sudo usermod -a -G dialout $USER
-```
-
-**macOS**:
-```bash
-# 查看串口设备（注意macOS使用cu.*而不是tty.*）
-ls -l /dev/cu.*
-```
-
-**Docker/HassOS**:
-```yaml
-# 在docker-compose.yml或HassOS插件配置中添加设备映射
-devices:
-  - /dev/ttyUSB0:/dev/ttyUSB0
-```
-
-### MQTT连接失败
-
-1. 确认MQTT broker正在运行：
-   ```bash
-   # Linux
-   sudo systemctl status mosquitto
-   
-   # macOS
-   brew services list | grep mosquitto
-   ```
-
-2. 测试MQTT连接：
-   ```bash
-   mosquitto_sub -h localhost -t test
-   ```
-
-3. 检查Node-RED日志中的MQTT连接信息
-
-### 主站轮询不工作
-
-1. **检查从站配置**：确认已添加所有从站设备（如10、11、12、13）
-2. **检查轮询间隔**：默认200ms，建议300-500ms（多台从站时避免总线拥堵）
-3. **查看Node-RED调试日志**：部署后查看日志中的轮询信息
-4. **检查串口波特率**：确认波特率为9600（与从站设备一致）
-5. **检查从站地址**：确认从站地址正确（1-247）
-6. **确认从站设备在线**：使用Modbus调试工具测试从站是否响应
-7. **检查MQTT连接**：确保MQTT broker地址正确，轮询不依赖MQTT但状态发布需要MQTT
-8. **测试连接**：
-   - TCP连接问题：先用 `modbus-serial` 单独测试TCP连接
-   - 串口问题：先用 `serialport` 单独测试串口通信
-
-### 从站开关无响应
-
-1. 检查RS-485连接是否正常
-2. 确认开关面板地址和按钮编号正确
-3. 检查MQTT连接状态
-4. 查看Node-RED日志中的协议解析信息
-
-## 输入消息格式
-
-### 主站节点
-
-```javascript
-// 启动轮询
-msg.payload = {cmd: "start"};
-
-// 停止轮询
-msg.payload = {cmd: "stop"};
-
-// 写单个线圈
-msg.payload = {
-    cmd: "writeCoil",
-    slave: 10,      // 从站地址
-    coil: 0,        // 线圈编号
-    value: true     // true=开, false=关
-};
-
-// 批量写多个线圈
-msg.payload = {
-    cmd: "writeCoils",
-    slave: 10,      // 从站地址
-    startCoil: 0,   // 起始线圈
-    values: [true, false, true, false]  // 线圈值数组
-};
-```
-
-### 从站开关节点
-
-```javascript
-// 发送开关命令
-msg.payload = true;   // 或 false
-msg.payload = "ON";   // 或 "OFF"
-msg.payload = 1;      // 或 0
-```
-
-## 输出消息格式
-
-### 主站节点
-
-```javascript
-{
-    payload: {
-        slave: 10,                // 从站地址
-        coils: [true, false, ...], // 线圈状态数组
-        timestamp: 1234567890     // 时间戳
-    }
-}
-```
-
-### 从站开关节点
-
-```javascript
-{
-    payload: true,                    // 开关状态
-    topic: "switch_0_btn1",          // 主题
-    switchId: 0,                     // 开关面板ID
-    button: 1,                       // 按钮编号
-    targetSlave: 10,                 // 目标从站地址
-    targetCoil: 0                    // 目标线圈编号
-}
-```
-
-## 性能指标
-
-- **内存占用**：< 50MB（单个主站节点，轮询10个设备）
-- **CPU占用**：< 5%（正常轮询状态）
-- **连接延迟**：Modbus响应 < 100ms，MQTT发布 < 50ms
-- **稳定运行**：经过工控机7x24小时长期运行验证
-- **容错能力**：Modbus从站离线不影响其他从站，MQTT断线自动重连
-
-## 示例Flow
-
-```json
-[
-    {
-        "id": "modbus-master-1",
-        "type": "modbus-master",
-        "name": "主站",
-        "connectionType": "serial",
-        "serialPort": "/dev/ttyUSB0",
-        "serialBaudRate": 9600,
-        "slaves": [
-            {"address": 10, "coilStart": 0, "coilEnd": 31, "pollInterval": 200},
-            {"address": 11, "coilStart": 0, "coilEnd": 31, "pollInterval": 200},
-            {"address": 12, "coilStart": 0, "coilEnd": 31, "pollInterval": 200},
-            {"address": 13, "coilStart": 0, "coilEnd": 31, "pollInterval": 200}
-        ],
-        "enableMqtt": true,
-        "mqttServer": "mqtt-config-1"
-    }
-]
-```
-
-## 项目信息
-
-**当前版本**: v2.7.3
-
-**最新更新**（v2.7.3）：
-- 优化窗帘控制逻辑：打开 → 暂停 → 关闭 → 暂停 → 打开（循环），更符合实际使用场景
-- 优化MQTT断网日志：长期断网时减少日志输出，避免垃圾日志影响性能和硬盘空间
-- 重试间隔优化：从5秒改为30秒，减少重试频率，降低系统负担
-- 日志级别优化：MQTT错误从error改为debug，不写入日志文件
-
-**技术栈**：
-- Node.js: >=14.0.0
-- Node-RED: >=2.0.0
-- modbus-serial: ^8.0.23
-- serialport: ^12.0.0
-- mqtt: ^5.14.1（可选）
-- hap-nodejs: ^1.2.0
-- node-persist: ^4.0.4
-
-**历史版本**：
-- v2.7.2: 新增自定义协议节点，支持非标准485协议设备
-- v2.7.1: 新增可视化控制看板节点
-- v2.7.0: 智能写入队列机制，支持HomeKit群控
-- v2.6.8: 新增HomeKit网桥节点
-- v2.6.7及更早: 基础功能实现

package/examples/basic-flow.json

@@ -1,26 +1,27 @@
 [
+    {
+        "id": "modbus_server_config_1",
+        "type": "modbus-server-config",
+        "name": "Modbus服务器",
+        "connectionType": "tcp",
+        "tcpHost": "127.0.0.1",
+        "tcpPort": "502"
+    },
     {
         "id": "modbus_master_1",
         "type": "modbus-master",
         "name": "Modbus主站",
-        "connectionType": "tcp",
-        "tcpHost": "127.0.0.1",
-        "tcpPort": "502",
-        "serialPort": "COM1",
-        "serialBaudRate": "9600",
-        "serialDataBits": "8",
-        "serialStopBits": "1",
-        "serialParity": "none",
-        "slaveStartAddress": "10",
-        "slaveCount": "1",
-        "coilStart": "0",
-        "coilEnd": "31",
-        "pollInterval": "100",
+        "serverConfig": "modbus_server_config_1",
+        "slaves": [
+            {
+                "address": 10,
+                "coilStart": 0,
+                "coilEnd": 31,
+                "pollInterval": 300
+            }
+        ],
         "enableMqtt": false,
-        "mqttBroker": "mqtt://localhost:1883",
-        "mqttUsername": "",
-        "mqttPassword": "",
-        "mqttBaseTopic": "modbus/relay",
+        "mqttConfig": "",
         "x": 320,
         "y": 140,
         "wires": [["debug_1"]]

package/nodes/custom-protocol.html

@@ -95,13 +95,13 @@
                     }),
                     success: function(result) {
                         if (result.success) {
-                            RED.notify('✓ ' + cmdName + '指令已发送: ' + hexString, 'success');
+                            RED.notify(cmdName + '指令已发送: ' + hexString, 'success');
                         } else {
-                            RED.notify('✗ 发送失败: ' + result.error, 'error');
+                            RED.notify('发送失败: ' + result.error, 'error');
                         }
                     },
                     error: function(err) {
-                        RED.notify('✗ 发送失败: ' + err.statusText, 'error');
+                        RED.notify('发送失败: ' + err.statusText, 'error');
                     }
                 });
             }

package/nodes/custom-protocol.js

@@ -64,20 +64,42 @@ module.exports = function(RED) {
                 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);
+            // 直接通过串口配置节点发送数据
+            if (!serialNode || !serialNode.connection) {
+                node.error('串口连接未建立');
+                node.status({fill: "red", shape: "ring", text: "连接未建立"});
+                return;
+            }
+
+            // 检查连接状态
+            var isConnected = false;
+            if (serialNode.connectionType === 'tcp') {
+                isConnected = serialNode.connection && !serialNode.connection.destroyed;
+            } else {
+                isConnected = serialNode.connection && serialNode.connection.isOpen;
+            }
+
+            if (!isConnected) {
+                node.error('串口/TCP连接未打开');
+                node.status({fill: "red", shape: "ring", text: "连接未打开"});
+                return;
+            }
+
+            // 使用串口配置节点的write方法（带队列机制）
+            serialNode.write(buffer, function(err) {
+                if (err) {
+                    node.error('发送失败: ' + err.message);
+                    node.status({fill: "red", shape: "ring", text: "发送失败"});
+                } else {
+                    node.log(cmdName + '指令已发送: ' + buffer.toString('hex').toUpperCase());
+                    node.status({fill: "green", shape: "dot", text: cmdName + " (" + buffer.length + "字节)"});
+
+                    // 3秒后清除状态
+                    setTimeout(function() {
+                        node.status({fill: "blue", shape: "ring", text: "就绪"});
+                    }, 3000);
+                }
+            });
         }
 
         // 处理输入消息
@@ -180,22 +202,36 @@ module.exports = function(RED) {
             }
             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
-                        });
-                    }
-                });
+            // 检查连接状态
+            if (!serialNode.connection) {
+                res.status(503).json({success: false, error: '连接未建立'});
+                return;
+            }
+
+            var isConnected = false;
+            if (serialNode.connectionType === 'tcp') {
+                isConnected = !serialNode.connection.destroyed;
             } else {
-                res.status(503).json({success: false, error: '串口未打开'});
+                isConnected = serialNode.connection.isOpen;
             }
+
+            if (!isConnected) {
+                res.status(503).json({success: false, error: '连接未打开'});
+                return;
+            }
+
+            // 使用串口配置节点的write方法（带队列机制）
+            serialNode.write(buffer, function(err) {
+                if (err) {
+                    res.json({success: false, error: err.message});
+                } else {
+                    res.json({
+                        success: true,
+                        message: cmdName + '指令已发送',
+                        bytes: buffer.length
+                    });
+                }
+            });
         } catch (err) {
             res.status(500).json({success: false, error: err.message});
         }

package/nodes/homekit-bridge.html

@@ -51,6 +51,11 @@
                 renderRelayNameConfig();
             });
 
+            // 添加刷新按钮
+            $("#btn-refresh-homekit").on("click", function() {
+                renderRelayNameConfig();
+            });
+
             // 初始渲染
             renderRelayNameConfig();
             
@@ -148,10 +153,13 @@
 
     <div class="form-row">
         <label for="node-input-masterNode"><i class="fa fa-microchip"></i> 主站节点</label>
-        <select id="node-input-masterNode" style="width: 70%;">
+        <select id="node-input-masterNode" style="width: 55%;">
             <option value="">请选择主站节点</option>
         </select>
-        <div style="font-size: 11px; color: #999; margin-top: 5px;">选择要桥接的Modbus主站节点</div>
+        <button type="button" id="btn-refresh-homekit" class="red-ui-button" style="margin-left: 5px;">
+            <i class="fa fa-refresh"></i> 刷新
+        </button>
+        <div style="font-size: 11px; color: #999; margin-top: 5px;">选择要桥接的Modbus主站节点，点击刷新按钮更新显示</div>
     </div>
 
     <hr style="margin: 20px 0; border: none; border-top: 1px solid #e0e0e0;">

package/nodes/modbus-dashboard.html

@@ -222,6 +222,15 @@
                 }
             });
 
+            // 添加刷新按钮
+            $("#btn-refresh-dashboard").on("click", function() {
+                stopPolling();
+                renderDashboard();
+                if (masterNodeSelect.val()) {
+                    startPolling();
+                }
+            });
+
             // 初始渲染
             renderDashboard();
             if (node.masterNode) {
@@ -244,10 +253,13 @@
 
     <div class="form-row">
         <label for="node-input-masterNode"><i class="fa fa-microchip"></i> 主站节点</label>
-        <select id="node-input-masterNode" style="width: 70%;">
+        <select id="node-input-masterNode" style="width: 55%;">
             <option value="">请选择主站节点</option>
         </select>
-        <div style="font-size: 11px; color: #999; margin-top: 5px;">选择要监控的Modbus主站节点</div>
+        <button type="button" id="btn-refresh-dashboard" class="red-ui-button" style="margin-left: 5px;">
+            <i class="fa fa-refresh"></i> 刷新
+        </button>
+        <div style="font-size: 11px; color: #999; margin-top: 5px;">选择要监控的Modbus主站节点，点击刷新按钮更新显示</div>
     </div>
 
     <div class="form-row" style="margin-top: 20px;">

package/nodes/modbus-debug.js

@@ -28,9 +28,12 @@ module.exports = function(RED) {
         node.localConnection = null;
         node.localConnType = null; // tcp | serial
 
-        const sendHexMsg = (data) => {
+        const sendHexMsg = (data, direction) => {
             if (!data || !Buffer.isBuffer(data) || data.length === 0) return;
 
+            // direction: 'received' (接收) 或 'sent' (发送)
+            const isSent = direction === 'sent';
+
             let buf = data;
             if (node.maxBytes > 0 && buf.length > node.maxBytes) {
                 buf = buf.subarray(0, node.maxBytes);
@@ -41,6 +44,7 @@ module.exports = function(RED) {
                 length: data.length,
                 displayedLength: buf.length,
                 truncated: node.maxBytes > 0 && data.length > node.maxBytes,
+                direction: isSent ? 'TX' : 'RX'
             };
 
             // 来源信息
@@ -76,7 +80,11 @@ module.exports = function(RED) {
             if (node.includeTimestamp) msg.timestamp = Date.now();
 
             node.send(msg);
-            node.status({ fill: "green", shape: "dot", text: `RX ${data.length}B` });
+
+            // 状态显示：TX=发送，RX=接收
+            const statusText = isSent ? `TX ${data.length}B` : `RX ${data.length}B`;
+            const statusColor = isSent ? "blue" : "green";
+            node.status({ fill: statusColor, shape: "dot", text: statusText });
         };
 
         // 选择来源：共享串口配置 或 独立连接到 Modbus 服务器配置

package/nodes/modbus-master.js

@@ -1170,6 +1170,10 @@ module.exports = function(RED) {
 
             node.isProcessingWrite = true;
 
+            // 记录队列开始处理时间
+            const queueStartTime = Date.now();
+            const queueLength = node.writeQueue.length;
+
             while (node.writeQueue.length > 0) {
                 const task = node.writeQueue.shift();
 
@@ -1189,6 +1193,8 @@ module.exports = function(RED) {
                     if (task.reject) {
                         task.reject(err);
                     }
+                    // 写入失败不中断队列，继续处理下一个任务
+                    node.warn(`队列任务失败，继续处理下一个任务: ${err.message}`);
                 }
 
                 // 等待一段时间再处理下一个任务（20ms间隔，确保总线稳定）
@@ -1197,6 +1203,12 @@ module.exports = function(RED) {
                 }
             }
 
+            // 队列处理完成，输出统计信息
+            const queueDuration = Date.now() - queueStartTime;
+            if (queueLength > 1) {
+                node.debug(`写入队列处理完成：${queueLength}个任务，耗时${queueDuration}ms`);
+            }
+
             node.isProcessingWrite = false;
         };
 
@@ -1236,6 +1248,7 @@ module.exports = function(RED) {
                 node.lastWriteTime[slaveId] = Date.now();
 
                 // 更新本地状态
+                const oldValue = node.deviceStates[slaveId].coils[coil];
                 node.deviceStates[slaveId].coils[coil] = value;
 
                 node.log(`写入成功: 从站${slaveId} 线圈${coil} = ${value ? 'ON' : 'OFF'}`);
@@ -1248,6 +1261,17 @@ module.exports = function(RED) {
                     value: value
                 });
 
+                // 只在状态真正改变时广播状态变化事件（用于LED反馈）
+                // 避免重复广播导致LED反馈死循环
+                if (oldValue !== value) {
+                    RED.events.emit('modbus:coilStateChanged', {
+                        slave: slaveId,
+                        coil: coil,
+                        value: value,
+                        source: 'write'
+                    });
+                }
+
                 // 释放锁
                 node.modbusLock = false;
 
@@ -1325,14 +1349,29 @@ module.exports = function(RED) {
 
                 // 更新本地状态
                 for (let i = 0; i < values.length; i++) {
-                    node.deviceStates[slaveId].coils[startCoil + i] = values[i];
+                    const coilIndex = startCoil + i;
+                    const oldValue = node.deviceStates[slaveId].coils[coilIndex];
+                    const newValue = values[i];
+
+                    node.deviceStates[slaveId].coils[coilIndex] = newValue;
+
                     // 发布到MQTT和触发事件
-                    node.publishMqttState(slaveId, startCoil + i, values[i]);
+                    node.publishMqttState(slaveId, coilIndex, newValue);
                     node.emit('stateUpdate', {
                         slave: slaveId,
-                        coil: startCoil + i,
-                        value: values[i]
+                        coil: coilIndex,
+                        value: newValue
                     });
+
+                    // 只在状态真正改变时广播状态变化事件（用于LED反馈）
+                    if (oldValue !== newValue) {
+                        RED.events.emit('modbus:coilStateChanged', {
+                            slave: slaveId,
+                            coil: coilIndex,
+                            value: newValue,
+                            source: 'write'
+                        });
+                    }
                 }
 
                 node.debug(`批量写入成功: 从站${slaveId} 起始线圈${startCoil} 共${values.length}个线圈`);
@@ -1396,18 +1435,10 @@ module.exports = function(RED) {
             node.log(`收到内部事件：从站${slave} 线圈${coil} = ${value ? 'ON' : 'OFF'}`);
 
             try {
-                // 执行写入操作
+                // 执行写入操作（writeSingleCoil内部已经会广播状态变化事件）
                 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'}`);
+                node.log(`内部事件写入成功：从站${slave} 线圈${coil} = ${value ? 'ON' : 'OFF'}`);
             } catch (err) {
                 node.error(`内部事件写入失败: 从站${slave} 线圈${coil} - ${err.message}`);
             }

package/nodes/modbus-slave-switch.js

@@ -118,6 +118,12 @@ module.exports = function(RED) {
             value: false
         };
 
+        // 防止LED反馈重复发送：记录最后一次LED反馈的时间戳和值
+        node.lastLedFeedback = {
+            timestamp: 0,
+            value: false
+        };
+
         // 节点初始化标志（用于静默初始化期间的警告）
         node.isInitializing = true;
 
@@ -469,10 +475,26 @@ module.exports = function(RED) {
                 return;
             }
 
-            // 清理过期队列项（超过3秒）
+            // 防止重复发送：如果状态相同且时间间隔小于100ms，跳过
             const now = Date.now();
+            const timeSinceLastFeedback = now - node.lastLedFeedback.timestamp;
+            const stateChanged = (state !== node.lastLedFeedback.value);
+
+            if (!stateChanged && timeSinceLastFeedback < 100) {
+                node.debug(`跳过重复LED反馈（状态未变化，间隔${timeSinceLastFeedback}ms）`);
+                return;
+            }
+
+            // 清理过期队列项（超过3秒）
             node.ledFeedbackQueue = node.ledFeedbackQueue.filter(item => (now - item.timestamp) < node.queueTimeout);
 
+            // 检查队列中是否已有相同状态的反馈（去重）
+            const hasSameState = node.ledFeedbackQueue.some(item => item.state === state);
+            if (hasSameState) {
+                node.debug(`队列中已有相同状态的LED反馈，跳过添加`);
+                return;
+            }
+
             // 加入LED反馈队列（带时间戳）
             // 注意：这里不指定协议类型，在发送时根据情况选择
             node.ledFeedbackQueue.push({ state, timestamp: now });
@@ -481,40 +503,36 @@ module.exports = function(RED) {
             node.processLedFeedbackQueue();
         };
         
-        // 处理LED反馈队列（基于面板ID的固定延迟）
+        // 处理LED反馈队列（20ms间隔串行发送）
         node.processLedFeedbackQueue = async function() {
             if (node.isProcessingLedFeedback || node.ledFeedbackQueue.length === 0) {
                 return;
             }
-            
+
             // 初始化期间不处理LED反馈（避免部署时大量LED同时发送）
             if (node.isInitializing) {
                 return;
             }
-            
+
             node.isProcessingLedFeedback = true;
-            
+
             // 清理过期队列项
             const now = Date.now();
             node.ledFeedbackQueue = node.ledFeedbackQueue.filter(item => (now - item.timestamp) < node.queueTimeout);
-            
-            // 基于面板ID的固定延迟，避免多个节点同时写入TCP冲突
-            // 面板1=100ms, 面板2=200ms, 面板3=300ms, 面板4=400ms...
-            // 这样不同面板的LED反馈永远不会同时发送
-            const fixedDelay = node.config.switchId * 100;
-            if (fixedDelay > 0) {
-                await new Promise(resolve => setTimeout(resolve, fixedDelay));
-            }
-            
+
+            // 记录队列开始处理时间
+            const queueStartTime = Date.now();
+            const queueLength = node.ledFeedbackQueue.length;
+
             while (node.ledFeedbackQueue.length > 0) {
                 const item = node.ledFeedbackQueue.shift();
-                
+
                 // 再次检查是否过期
                 if (Date.now() - item.timestamp >= node.queueTimeout) {
                     node.warn(`丢弃过期LED反馈（${Date.now() - item.timestamp}ms）`);
                     continue;
                 }
-                
+
                 const state = item.state;
                 
                 try {
@@ -551,6 +569,10 @@ module.exports = function(RED) {
                             if (err) {
                                 node.error(`LED反馈失败: ${err.message}`);
                             } else {
+                                // 记录最后一次LED反馈的时间戳和值
+                                node.lastLedFeedback.timestamp = Date.now();
+                                node.lastLedFeedback.value = state;
+
                                 // 输出调试日志，确认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}]`);
@@ -567,9 +589,16 @@ module.exports = function(RED) {
                     }
                 } catch (err) {
                     node.error(`发送LED反馈失败: ${err.message}`);
+                    // LED反馈失败不中断队列，继续处理下一个
                 }
             }
-            
+
+            // 队列处理完成，输出统计信息
+            const queueDuration = Date.now() - queueStartTime;
+            if (queueLength > 1) {
+                node.debug(`LED反馈队列处理完成：${queueLength}个任务，耗时${queueDuration}ms`);
+            }
+
             node.isProcessingLedFeedback = false;
         };
         
@@ -842,35 +871,50 @@ module.exports = function(RED) {
         
         // 处理输入消息
         node.on('input', function(msg) {
-            if (!node.mqttClient || !node.mqttClient.connected) {
-                node.warn('MQTT未连接');
-                return;
-            }
-            
             let value = false;
-            
+
             // 解析输入值
             if (typeof msg.payload === 'boolean') {
                 value = msg.payload;
             } else if (typeof msg.payload === 'string') {
-                value = (msg.payload.toLowerCase() === 'on' || 
-                         msg.payload.toLowerCase() === 'true' || 
+                value = (msg.payload.toLowerCase() === 'on' ||
+                         msg.payload.toLowerCase() === 'true' ||
                          msg.payload === '1');
             } else if (typeof msg.payload === 'number') {
                 value = (msg.payload !== 0);
             }
-            
-            // 发布命令到MQTT
-            const command = value ? 'ON' : 'OFF';
-            node.mqttClient.publish(node.commandTopic, command, { qos: 1 }, (err) => {
-                if (err) {
-                    node.error(`发布命令失败: ${err.message}`);
-                } else {
-                    node.log(`发送命令: ${command} 到 ${node.commandTopic}`);
-                    node.currentState = value;
-                    node.updateStatus();
-                }
+
+            // 更新当前状态
+            node.currentState = value;
+
+            // 输出消息到debug节点（无论是否使用MQTT）
+            node.send({
+                payload: value,
+                topic: `switch_${node.config.switchId}_btn${node.config.buttonNumber}`,
+                switchId: node.config.switchId,
+                button: node.config.buttonNumber,
+                targetSlave: node.config.targetSlaveAddress,
+                targetCoil: node.config.targetCoilNumber,
+                source: 'input'
             });
+
+            // 如果启用MQTT，发布命令到MQTT
+            if (node.mqttClient && node.mqttClient.connected) {
+                const command = value ? 'ON' : 'OFF';
+                node.mqttClient.publish(node.commandTopic, command, { qos: 1 }, (err) => {
+                    if (err) {
+                        node.error(`发布命令失败: ${err.message}`);
+                    } else {
+                        node.log(`发送命令: ${command} 到 ${node.commandTopic}`);
+                    }
+                });
+            } else {
+                // 本地模式：通过内部事件发送命令
+                node.sendMqttCommand(value);
+            }
+
+            // 更新状态显示
+            node.updateStatus();
         });
         
         // 节点关闭时清理

package/nodes/serial-port-config.js

@@ -345,6 +345,15 @@ module.exports = function(RED) {
                                     if (callback) callback(err);
                                     reject(err);
                                 } else {
+                                    // 广播发送的数据给所有监听器（包括debug节点）
+                                    node.dataListeners.forEach(listener => {
+                                        try {
+                                            listener(data, 'sent');
+                                        } catch (e) {
+                                            node.error('监听器处理发送数据失败: ' + e.message);
+                                        }
+                                    });
+
                                     if (callback) callback(null);
                                     resolve();
                                 }
@@ -370,6 +379,15 @@ module.exports = function(RED) {
                                     if (callback) callback(err);
                                     reject(err);
                                 } else {
+                                    // 广播发送的数据给所有监听器（包括debug节点）
+                                    node.dataListeners.forEach(listener => {
+                                        try {
+                                            listener(data, 'sent');
+                                        } catch (e) {
+                                            node.error('监听器处理发送数据失败: ' + e.message);
+                                        }
+                                    });
+
                                     if (callback) callback(null);
                                     resolve();
                                 }

package/package.json

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