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

package/README.md

@@ -813,323 +813,34 @@ HomeKit网桥节点无需输入消息，自动同步主站配置和状态。
 ]
 ```
 
-## 项目信息
-
-**版本**: 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自动发现）
-- 物理开关面板双向同步（支持开关模式和场景模式）
-- 长期稳定运行（内存管理、智能重连、异步处理）
-
-**技术要求**：
+完整示例请参考项目中的 `examples/basic-flow.json` 文件。
+
+## 技术栈
+
 - 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.4
-
-**最新更新**（v2.7.4）：
-- 修复自定义协议节点测试功能：解决"Service Unavailable"错误
-- 优化自定义协议节点：无需连线到debug节点，直接通过串口配置节点发送数据
-- 优化README文档：移除重复内容，客户友好模式
-
-**历史版本**：
-- v2.7.3: 优化窗帘控制逻辑，优化MQTT断网日志
-- v2.7.2: 新增自定义协议节点，支持非标准485协议设备
-- v2.7.1: 新增可视化控制看板节点
-- v2.7.0: 智能写入队列机制，支持HomeKit群控
-- v2.6.8: 新增HomeKit网桥节点
-- v2.6.7及更早: 基础功能实现
-
-**技术栈**：
-- 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

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/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-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/package.json

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

package/v2.7.4-/344/277/256/345/244/215/350/257/264/346/230/216.md

@@ -1,151 +0,0 @@
-# Node-RED Contrib SYMI Modbus v2.7.4 修复说明
-
-## 修复日期
-2025-11-06
-
-## 修复内容
-
-### 1. 自定义协议节点测试功能修复
-
-**问题描述**：
-- 点击测试按钮发送16进制指令时报错：`发送失败: Service Unavailable`
-- 数据未能成功发送到串口总线
-
-**根本原因**：
-- HTTP API中检查串口状态时使用了错误的属性名
-- 使用了 `serialNode.serialPort.isOpen`（serialPort是字符串，不是连接对象）
-- 应该使用 `serialNode.connection.isOpen`（connection才是实际的连接对象）
-
-**修复方案**：
-1. 修改 `nodes/custom-protocol.js` 第175-238行的HTTP API测试端点
-2. 修改 `nodes/custom-protocol.js` 第60-103行的发送指令函数
-3. 正确检查连接状态：
-   - TCP模式：`serialNode.connection && !serialNode.connection.destroyed`
-   - 串口模式：`serialNode.connection && serialNode.connection.isOpen`
-4. 使用 `serialNode.write()` 方法（带队列机制）发送数据
-
-**修复效果**：
-- 点击测试按钮成功发送16进制指令到串口总线
-- 数据通过队列机制稳定发送，避免并发冲突
-- 支持TCP和串口两种连接模式
-
-### 2. Debug节点显示发送数据功能
-
-**问题描述**：
-- Debug节点只能看到接收的数据（RX），看不到发送的数据（TX）
-- 用户无法确认数据是否真正发送到串口总线
-
-**修复方案**：
-1. 修改 `nodes/serial-port-config.js` 第340-395行
-2. 在TCP和串口写入成功后，广播发送的数据给所有监听器
-3. 修改 `nodes/modbus-debug.js` 第31-88行
-4. Debug节点接收数据时区分方向（TX/RX）
-5. 显示不同颜色状态：
-   - TX（发送）：蓝色
-   - RX（接收）：绿色
-
-**修复效果**：
-- Debug节点现在可以同时显示发送和接收的数据
-- 用户可以清楚看到数据是否成功发送到串口总线
-- 通过颜色区分发送和接收方向
-
-### 3. 移除Emoji图标
-
-**问题描述**：
-- 代码中包含emoji图标（✓ ✗），不符合代码整洁要求
-
-**修复方案**：
-- 修改 `nodes/custom-protocol.html` 第98-104行
-- 移除所有emoji符号，使用纯文本提示
-
-**修复效果**：
-- 代码更加整洁，符合专业标准
-- 避免字符编码问题
-
-### 4. 文档优化
-
-**修复方案**：
-- 更新 `README.md` 版本号为 v2.7.4
-- 添加 v2.7.4 更新日志
-- 优化自定义协议节点说明（客户友好模式）
-- 移除"需要连线到debug节点"的说明
-
-## 技术细节
-
-### 数据发送流程
-```
-自定义协议节点 → serialNode.write() → 写入队列 → 串口/TCP连接 → 485总线
-                                    ↓
-                              广播给监听器 → Debug节点显示（TX）
-```
-
-### 连接状态检查逻辑
-```javascript
-// TCP模式
-if (serialNode.connectionType === 'tcp') {
-    isConnected = serialNode.connection && !serialNode.connection.destroyed;
-}
-// 串口模式
-else {
-    isConnected = serialNode.connection && serialNode.connection.isOpen;
-}
-```
-
-### 队列机制
-- TCP写入间隔：20ms（避免网关处理不过来）
-- 串口写入间隔：10ms（串口速度较快）
-- 自动排队，避免并发冲突
-
-## 稳定性保障
-
-### 1. 长期运行优化
-- 无内存泄漏：所有监听器正确注册和清理
-- 错误处理：写入失败不影响队列继续处理
-- 异常恢复：网络断开自动重连
-
-### 2. 断网/通网适应性
-- 断网时：队列暂停，不丢失指令
-- 通网后：自动恢复，继续发送
-- 本地持久化：配置不受重启影响
-
-### 3. 资源管理
-- CPU占用：< 5%（正常运行）
-- 内存占用：< 50MB（单个主站节点）
-- 无卡顿死机：经过7x24小时长期运行验证
-
-## 安装测试
-
-### 本地安装
-```bash
-cd ~/.node-red
-npm install /Volumes/攀旺/cursor/node-red-contrib-symi-modbus/node-red-contrib-symi-modbus-2.7.4.tgz
-node-red-restart
-```
-
-### 测试步骤
-1. 添加自定义协议节点
-2. 选择串口配置（如 /dev/ttyUSB0）
-3. 输入16进制指令（如 `11`）
-4. 点击"测试"按钮
-5. 观察：
-   - 节点状态显示"打开指令已发送"
-   - Debug节点显示蓝色TX标记和16进制数据
-   - 串口总线上实际发送数据
-
-## 发布准备
-
-### 版本信息
-- 版本号：2.7.4
-- 包大小：72.0 kB
-- 解压后大小：333.7 kB
-- 文件数量：24个
-
-### 发布命令
-```bash
-npm publish
-```
-
-## 总结
-
-v2.7.4版本成功修复了自定义协议节点的测试功能，增强了Debug节点的数据显示能力，移除了不必要的emoji图标，确保了项目的长期稳定运行。所有修复均经过代码审查，符合工业级稳定性要求。
-

package//346/233/264/346/226/260/346/227/245/345/277/227.txt

@@ -1,62 +0,0 @@
-完美！所有任务都已完成。让我为你总结一下v2.7.3的更新内容：
-
-✅ v2.7.3 发布成功总结
-核心更新
-1. 窗帘控制逻辑优化
-修正循环顺序：打开 → 暂停 → 关闭 → 暂停 → 打开（4个状态循环）
-更符合实际使用：每次操作后都可以暂停，避免误操作
-适配两种开关模式：
-有状态开关（开关模式）：从站开关关联实际线圈（0-31），输出true/false交替
-无状态开关（场景模式）：从站开关关联虚拟线圈（如线圈32），每次点击只发true或false
-2. MQTT断网日志优化
-日志级别降级：MQTT错误从error改为debug，不写入日志文件
-重试间隔优化：从5秒改为30秒，减少重试频率，降低系统负担
-日志限流增强：长期断网时减少日志输出，避免垃圾日志影响性能和硬盘空间
-内存优化：减少日志对象创建，降低内存占用
-3. 从站开关节点验证
-虚拟线圈支持：设置线圈32（超出0-31范围）不会报错，会被静默忽略
-完美适配场景模式：可以设置不存在的线圈编号，不影响从站开关按钮状态
-主站节点智能过滤：自动忽略超出范围的线圈，不会产生错误日志
-文档优化
-1. 客户友好模式
-简化版本历史：只保留最新版本详细信息，历史版本一行概括
-删除开发细节：移除大量技术迭代信息，客户不需要知道
-突出使用指南：强调如何使用，而非如何开发
-2. 窗帘模式说明更新
-循环顺序说明：打开 → 暂停 → 关闭 → 暂停 → 打开
-适配场景说明：明确说明有状态开关和无状态开关的区别
-使用示例更新：5步循环示例，更清晰易懂
-技术细节
-1. 代码修改
-nodes/custom-protocol.js：窗帘模式循环从3个状态改为4个状态
-nodes/modbus-slave-switch.js：MQTT错误日志从warn/error改为debug，重试间隔从5秒改为30秒
-package.json：版本号更新到2.7.3
-README.md：简化版本历史，更新窗帘模式说明
-2. 测试结果
-✅ 语法检查通过（custom-protocol.js、modbus-slave-switch.js）
-✅ npm install 成功
-✅ npm publish 成功
-✅ 包大小：70.9 kB（未压缩：329.6 kB）
-✅ 文件数：23个
-发布信息
-安装方法
-稳定性保证
-1. 长期运行优化
-✅ MQTT断网不会产生垃圾日志
-✅ 重试间隔30秒，减少CPU和网络负担
-✅ 日志级别优化，不写入日志文件
-✅ 虚拟线圈支持，不影响主站稳定性
-2. 内存和性能
-✅ 减少日志对象创建，降低内存占用
-✅ 日志限流机制，避免内存泄漏
-✅ 智能过滤机制，减少无效处理
-✅ 适合7x24小时长期运行
-下一步
-版本2.7.3已经成功发布到npm，包含：
-
-✅ v2.7.3：窗帘控制逻辑优化，MQTT断网日志优化
-✅ v2.7.2：自定义协议节点
-✅ v2.7.1：可视化控制看板
-✅ v2.7.0：智能写入队列机制
-✅ v2.6.8：HomeKit网桥节点
-所有功能都已测试通过，文档已优化为客户友好模式，可以放心使用！