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

package/README.md

@@ -246,6 +246,34 @@ node-red-restart
 - 从站上报的数据得到优先处理
 - 系统响应迅速，状态同步及时
 
+## 调试节点（modbus-debug）
+
+用于抓取并显示原始RS485字节流数据（HEX），帮助定位串口或TCP网关下的Modbus通信问题。
+
+- 数据来源：
+  - 共享连接：`serial-port-config`（推荐，复用主站/从站的同一连接）
+  - 独立连接：`modbus-server-config`（直接连接TCP或串口）
+- 输出内容：
+  - `msg.payload`：格式化的HEX字符串（可选大写）
+  - `msg.buffer`：原始Buffer数据
+  - `msg.meta`：来源信息与连接参数（串口或TCP详情）
+  - `msg.timestamp`：时间戳（可选）
+- 显示控制：
+  - `maxBytes`：限制显示字节数，超过会截断并在`meta.truncated`标记
+
+使用步骤：
+1. 将 `modbus-debug` 节点拖入画布。
+2. 选择“数据来源”：
+   - 选“共享串口配置（serial-port-config）”以复用主站/从站连接；或
+   - 选“Modbus服务器（modbus-server-config）”进行独立直连。
+3. 可选：勾选“大写HEX”、勾选“时间戳”、设置“最大字节数”。
+4. 部署后，节点自动输出捕获到的原始数据。
+
+典型用法：
+- 联调TCP转RS485网关时，观察上行/下行原始数据帧是否完整。
+- 排查波特率/数据位/校验位配置是否正确（串口模式）。
+- 与 `modbus-master` 或 `modbus-slave-switch` 同时使用，定位现场设备通信异常。
+
 ### MQTT自动发现
 
 启用MQTT后，自动生成Home Assistant兼容的Discovery配置：
@@ -479,7 +507,7 @@ msg.payload = 1;      // 或 0
 
 ## 项目信息
 
-**版本**: v2.6.4
+**版本**: v2.6.6
 
 **核心功能**：
 - 支持多种Modbus协议（Telnet ASCII、RTU over TCP、Modbus TCP、Modbus RTU串口）
@@ -499,24 +527,34 @@ msg.payload = 1;      // 或 0
 - Node.js: >=14.0.0
 - Node-RED: >=2.0.0
 
-**最新更新（v2.6.4）**：
+**最新更新（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级别（按键、轮询、写入等）
-  - 默认不输出到日志文件，不占用硬盘空间
-  - 保留错误日志的10分钟限流机制
-  - 完善的内存清理机制，防止内存泄漏
-- **适合工控机长期运行**：
-  - 无debug节点时不产生日志
-  - 不会因日志增加硬盘占用
-  - 不会因日志增加内存占用
-  - 断网/MQTT断开也不会持续报错
+  - 高频操作日志改为debug级别
+  - 默认不输出到日志文件
+  - 完善的内存清理机制
 
 **v2.6.3更新**：
 - **🔥 MQTT可选配置**：完全兼容无MQTT环境
-  - 本地模式：纯串口通信，断网也能稳定运行
-  - MQTT模式：可选接入Home Assistant等第三方平台
-  - 智能切换：MQTT断开时自动切换到本地模式
-  - 状态显示：清晰区分当前运行模式
+  - 本地模式：纯串口通信
+  - MQTT模式：可选接入HA
+  - 智能切换和状态显示
 
 **性能优化**：
 - 轮询间隔优化：修复间隔计算逻辑，确保每个从站使用正确的轮询间隔
@@ -535,3 +573,284 @@ msg.payload = 1;      // 或 0
 **支持**:
 - 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-debug`（调试）
+- 如果未显示该分类或节点：
+  - 刷新浏览器缓存（Shift+刷新）
+  - 重启 Node-RED（如：`node-red-restart` 或系统服务方式）
+  - 在“节点管理（Manage Palette）”确认安装版本为 `v2.6.6`
+
+### 调试节点（modbus-debug）使用要点
+
+- 数据来源选择：`sourceType = serial`（共享串口）或 `modbus`（独立服务器）
+- 共享串口：需要选择并关联一个 `serial-port-config` 配置节点
+- 独立服务器：需要选择并关联一个 `modbus-server-config` 配置节点
+- HEX显示：可选大写、可选时间戳、`maxBytes` 控制显示长度
+- 输出：`msg.payload`（格式化HEX）、`msg.buffer`（原始Buffer）、`msg.meta`（来源信息）
+
+### v2.6.6 重要更新
+
+- 调试节点配置验证修复：根据所选数据来源类型（`serial`/`modbus`）动态校验，避免误报为“配置不正确”
+- 统一侧边栏分类：所有节点统一归类到 `SYMI-MODBUS`
+- 文档更新：补充节点分类、调试节点要点与常见问题处理
+
+典型用法：
+- 联调TCP转RS485网关时，观察上行/下行原始数据帧是否完整。
+- 排查波特率/数据位/校验位配置是否正确（串口模式）。
+- 与 `modbus-master` 或 `modbus-slave-switch` 同时使用，定位现场设备通信异常。
+
+### 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网络故障自动恢复
+  - 连接前彻底清理旧实例，避免资源泄漏
+- **互斥锁机制**：防止读写冲突导致的数据异常
+- **Keep-Alive心跳**：TCP连接启用30秒心跳检测
+
+## 技术规格
+
+### 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.6.6
+
+**核心功能**：
+- 支持多种Modbus协议（Telnet ASCII、RTU over TCP、Modbus TCP、Modbus RTU串口）
+- 多设备轮询（最多10台从站，每台32路继电器，轮询间隔100-10000ms可调）
+- Symi私有协议自动识别（支持两种485开关控制方式）
+- 智能轮询暂停机制（从站上报时自动暂停，处理完成后恢复）
+- 🔥 **双模式支持**（本地模式和MQTT模式可选切换，断网也能稳定运行）
+- MQTT集成（可选启用，Home Assistant自动发现，实体唯一性保证，QoS=0高性能发布）
+- 物理开关面板双向同步（亖米协议支持，LED反馈同步）
+- 共享连接架构（多个从站开关节点共享同一个串口/TCP连接，支持500+节点）
+- 长期稳定运行（内存管理、智能重连、错误日志限流、异步MQTT发布）
+
+**技术栈**：
+- modbus-serial: ^8.0.23（内部封装serialport，支持TCP和串口）
+- serialport: ^12.0.0（原生串口通信）
+- mqtt: ^5.14.1（最新稳定版，可选依赖）
+- Node.js: >=14.0.0
+- Node-RED: >=2.0.0

package/nodes/modbus-debug.html

@@ -0,0 +1,95 @@
+<script type="text/javascript">
+    RED.nodes.registerType('modbus-debug', {
+        category: 'SYMI-MODBUS',
+        color: '#C0DEED',
+        defaults: {
+            name: { value: '' },
+            sourceType: { value: 'serial' }, // serial | modbus
+            serialPortConfig: { 
+                value: '', 
+                type: 'serial-port-config', 
+                required: false,
+                validate: function(v) {
+                    var t = $("#node-input-sourceType").val() || this.sourceType || 'serial';
+                    if (t === 'serial') return !!v; // 串口模式需要选择配置
+                    return true; // 非串口模式不要求
+                }
+            },
+            modbusServer: { 
+                value: '', 
+                type: 'modbus-server-config', 
+                required: false,
+                validate: function(v) {
+                    var t = $("#node-input-sourceType").val() || this.sourceType || 'serial';
+                    if (t === 'modbus') return !!v; // 独立Modbus服务器模式需要选择配置
+                    return true; // 非modbus模式不要求
+                }
+            },
+            uppercase: { value: true },
+            includeTimestamp: { value: true },
+            maxBytes: { value: 0 }
+        },
+        inputs: 1,
+        outputs: 1,
+        icon: 'font-awesome/fa-eye',
+        label: function() { return this.name || 'modbus-debug'; },
+        oneditprepare: function() {
+            function toggleSources() {
+                var type = $("#node-input-sourceType").val();
+                if (type === 'serial') {
+                    $("#serial-select-wrap").show();
+                    $("#modbus-select-wrap").hide();
+                } else {
+                    $("#serial-select-wrap").hide();
+                    $("#modbus-select-wrap").show();
+                }
+            }
+            $("#node-input-sourceType").on('change', toggleSources);
+            toggleSources();
+        },
+        oneditsave: function() {}
+    });
+</script>
+
+<script type="text/x-red" data-template-name="modbus-debug">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> 名称</label>
+        <input type="text" id="node-input-name" placeholder="原始485调试">
+    </div>
+    <div class="form-row">
+        <label for="node-input-sourceType"><i class="fa fa-exchange"></i> 数据来源</label>
+        <select id="node-input-sourceType">
+            <option value="serial">共享串口配置 (serial-port-config)</option>
+            <option value="modbus">Modbus服务器配置 (modbus-server-config)</option>
+        </select>
+    </div>
+    <div class="form-row" id="serial-select-wrap">
+        <label for="node-input-serialPortConfig"><i class="fa fa-plug"></i> 串口配置</label>
+        <input type="text" id="node-input-serialPortConfig">
+    </div>
+    <div class="form-row" id="modbus-select-wrap" style="display:none">
+        <label for="node-input-modbusServer"><i class="fa fa-server"></i> Modbus服务器</label>
+        <input type="text" id="node-input-modbusServer">
+    </div>
+    <div class="form-row">
+        <label for="node-input-uppercase"><i class="fa fa-text-height"></i> 大写HEX</label>
+        <input type="checkbox" id="node-input-uppercase" style="width:auto" checked>
+    </div>
+    <div class="form-row">
+        <label for="node-input-includeTimestamp"><i class="fa fa-clock-o"></i> 包含时间戳</label>
+        <input type="checkbox" id="node-input-includeTimestamp" style="width:auto" checked>
+    </div>
+    <div class="form-row">
+        <label for="node-input-maxBytes"><i class="fa fa-filter"></i> 显示最大字节数 (0为不限制)</label>
+        <input type="number" id="node-input-maxBytes" min="0" step="1" placeholder="0">
+    </div>
+</script>
+
+<script type="text/x-red" data-help-name="modbus-debug">
+    <p>modbus-debug 节点用于抓取并显示原始485字节流，以十六进制格式输出，帮助调试串口或TCP网关下的Modbus通信。</p>
+    <ul>
+        <li><b>数据来源</b>：选择共享的 <code>serial-port-config</code>（推荐，复用主站/从站的同一连接），或选择 <code>modbus-server-config</code>（独立直连TCP/串口）。</li>
+        <li><b>输出</b>：<code>msg.payload</code> 为格式化HEX字符串；<code>msg.buffer</code>为原始Buffer；<code>msg.meta</code>包含来源与连接信息；若开启则包含 <code>msg.timestamp</code>。</li>
+        <li><b>显示最大字节数</b>：为避免控制台过载，可设置最大显示长度，超过则截断并在 meta.truncated 标记。</li>
+    </ul>
+</script>

package/nodes/modbus-debug.js

@@ -0,0 +1,199 @@
+module.exports = function(RED) {
+    "use strict";
+
+    const net = require("net");
+    let SerialPort;
+    try { SerialPort = require("serialport").SerialPort || require("serialport"); } catch (e) { SerialPort = null; }
+
+    function bufferToHex(buffer, uppercase) {
+        const hex = buffer.toString("hex");
+        const grouped = hex.match(/.{1,2}/g) || [];
+        const str = grouped.join(" ");
+        return uppercase ? str.toUpperCase() : str;
+    }
+
+    function ModbusDebugNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        node.name = config.name || "原始485调试";
+        node.sourceType = config.sourceType || "serial"; // serial | modbus
+        node.serialPortConfig = RED.nodes.getNode(config.serialPortConfig);
+        node.modbusServer = RED.nodes.getNode(config.modbusServer);
+        node.uppercase = config.uppercase !== false; // 默认大写显示
+        node.includeTimestamp = config.includeTimestamp !== false; // 默认包含时间戳
+        node.maxBytes = parseInt(config.maxBytes) || 0; // 0 表示不截断
+
+        // 本地独立连接（当来源选择 modbus-server-config 时使用）
+        node.localConnection = null;
+        node.localConnType = null; // tcp | serial
+
+        const sendHexMsg = (data) => {
+            if (!data || !Buffer.isBuffer(data) || data.length === 0) return;
+
+            let buf = data;
+            if (node.maxBytes > 0 && buf.length > node.maxBytes) {
+                buf = buf.subarray(0, node.maxBytes);
+            }
+
+            const hex = bufferToHex(buf, node.uppercase);
+            const meta = {
+                length: data.length,
+                displayedLength: buf.length,
+                truncated: node.maxBytes > 0 && data.length > node.maxBytes,
+            };
+
+            // 来源信息
+            if (node.sourceType === "serial" && node.serialPortConfig) {
+                meta.source = "serial-port-config";
+                meta.connectionType = node.serialPortConfig.connectionType;
+                if (node.serialPortConfig.connectionType === "tcp") {
+                    meta.tcpHost = node.serialPortConfig.tcpHost;
+                    meta.tcpPort = node.serialPortConfig.tcpPort;
+                } else {
+                    meta.serialPort = node.serialPortConfig.serialPort;
+                    meta.baudRate = node.serialPortConfig.baudRate;
+                    meta.dataBits = node.serialPortConfig.dataBits;
+                    meta.stopBits = node.serialPortConfig.stopBits;
+                    meta.parity = node.serialPortConfig.parity;
+                }
+            } else if (node.sourceType === "modbus" && node.modbusServer) {
+                meta.source = "modbus-server-config";
+                meta.connectionType = node.modbusServer.connectionType;
+                if (node.modbusServer.connectionType === "tcp") {
+                    meta.tcpHost = node.modbusServer.tcpHost;
+                    meta.tcpPort = node.modbusServer.tcpPort;
+                } else {
+                    meta.serialPort = node.modbusServer.serialPort;
+                    meta.baudRate = node.modbusServer.serialBaudRate;
+                    meta.dataBits = node.modbusServer.serialDataBits;
+                    meta.stopBits = node.modbusServer.serialStopBits;
+                    meta.parity = node.modbusServer.serialParity;
+                }
+            }
+
+            const msg = { payload: hex, buffer: data, meta };
+            if (node.includeTimestamp) msg.timestamp = Date.now();
+
+            node.send(msg);
+            node.status({ fill: "green", shape: "dot", text: `RX ${data.length}B` });
+        };
+
+        // 选择来源：共享串口配置 或 独立连接到 Modbus 服务器配置
+        const startListening = () => {
+            if (node.sourceType === "serial") {
+                if (!node.serialPortConfig) {
+                    node.status({ fill: "red", shape: "ring", text: "未选择串口配置" });
+                    node.error("未配置RS-485连接，请在节点中选择 serial-port-config 配置节点");
+                    return;
+                }
+                // 使用共享连接
+                try {
+                    node.serialPortConfig.registerDataListener(sendHexMsg);
+                    const desc = node.serialPortConfig.connectionType === "tcp"
+                        ? `TCP ${node.serialPortConfig.tcpHost}:${node.serialPortConfig.tcpPort}`
+                        : `串口 ${node.serialPortConfig.serialPort} @ ${node.serialPortConfig.baudRate}bps`;
+                    node.log(`modbus-debug 监听共享连接：${desc}`);
+                    node.status({ fill: "blue", shape: "ring", text: "监听中" });
+                } catch (err) {
+                    node.error(`注册数据监听器失败: ${err.message}`);
+                    node.status({ fill: "red", shape: "ring", text: "监听失败" });
+                }
+            } else if (node.sourceType === "modbus") {
+                if (!node.modbusServer) {
+                    node.status({ fill: "red", shape: "ring", text: "未选择Modbus服务器" });
+                    node.error("未配置Modbus服务器，请在节点中选择 modbus-server-config 配置节点");
+                    return;
+                }
+
+                // 独立建立原始连接以抓取数据
+                if (node.modbusServer.connectionType === "tcp") {
+                    try {
+                        node.localConnType = "tcp";
+                        node.localConnection = new net.Socket();
+                        node.localConnection.setKeepAlive(true, 30000);
+                        node.localConnection.connect(node.modbusServer.tcpPort, node.modbusServer.tcpHost, () => {
+                            node.log(`modbus-debug 已连接TCP：${node.modbusServer.tcpHost}:${node.modbusServer.tcpPort}`);
+                            node.status({ fill: "blue", shape: "dot", text: "TCP监听中" });
+                        });
+                        node.localConnection.on("data", sendHexMsg);
+                        node.localConnection.on("error", (err) => {
+                            node.warn(`TCP监听错误: ${err.message}`);
+                            node.status({ fill: "red", shape: "ring", text: "TCP错误" });
+                        });
+                        node.localConnection.on("close", () => {
+                            node.status({ fill: "grey", shape: "ring", text: "TCP已关闭" });
+                        });
+                    } catch (e) {
+                        node.error(`TCP初始化失败: ${e.message}`);
+                        node.status({ fill: "red", shape: "ring", text: "TCP初始化失败" });
+                    }
+                } else {
+                    // 串口
+                    if (!SerialPort) {
+                        node.error("未找到 serialport 模块，无法打开串口");
+                        node.status({ fill: "red", shape: "ring", text: "serialport缺失" });
+                        return;
+                    }
+                    try {
+                        node.localConnType = "serial";
+                        node.localConnection = new SerialPort({
+                            path: node.modbusServer.serialPort,
+                            baudRate: node.modbusServer.serialBaudRate || 9600,
+                            dataBits: node.modbusServer.serialDataBits || 8,
+                            stopBits: node.modbusServer.serialStopBits || 1,
+                            parity: node.modbusServer.serialParity || "none",
+                            autoOpen: true,
+                        });
+                        node.localConnection.on("open", () => {
+                            node.log(`modbus-debug 已打开串口：${node.modbusServer.serialPort}`);
+                            node.status({ fill: "blue", shape: "dot", text: "串口监听中" });
+                        });
+                        node.localConnection.on("data", sendHexMsg);
+                        node.localConnection.on("error", (err) => {
+                            node.warn(`串口监听错误: ${err.message}`);
+                            node.status({ fill: "red", shape: "ring", text: "串口错误" });
+                        });
+                        node.localConnection.on("close", () => {
+                            node.status({ fill: "grey", shape: "ring", text: "串口已关闭" });
+                        });
+                    } catch (e) {
+                        node.error(`串口初始化失败: ${e.message}`);
+                        node.status({ fill: "red", shape: "ring", text: "串口初始化失败" });
+                    }
+                }
+            }
+        };
+
+        startListening();
+
+        // 输入不做处理（预留写入功能），当前为纯监听输出节点
+        node.on("input", function(msg, send, done) { done(); });
+
+        // 关闭时清理
+        node.on("close", function(done) {
+            try {
+                if (node.sourceType === "serial" && node.serialPortConfig && typeof node.serialPortConfig.unregisterDataListener === "function") {
+                    node.serialPortConfig.unregisterDataListener(sendHexMsg);
+                }
+            } catch (e) {
+                node.warn(`注销监听器时出错: ${e.message}`);
+            }
+            try {
+                if (node.localConnection) {
+                    if (node.localConnType === "tcp") {
+                        try { node.localConnection.destroy(); } catch (e) { /* ignore */ }
+                    } else if (node.localConnType === "serial") {
+                        try { node.localConnection.close(); } catch (e) { /* ignore */ }
+                    }
+                    node.localConnection = null;
+                }
+            } catch (e) {
+                node.warn(`关闭本地连接时出错: ${e.message}`);
+            }
+            done();
+        });
+    }
+
+    RED.nodes.registerType("modbus-debug", ModbusDebugNode);
+};

package/nodes/modbus-master.html

@@ -1,6 +1,6 @@
 <script type="text/javascript">
     RED.nodes.registerType('modbus-master', {
-        category: 'modbus',
+        category: 'SYMI-MODBUS',
         color: '#3FADB5',
         defaults: {
             name: {value: "Modbus主站"},
@@ -35,8 +35,6 @@
                 }];
             }
             
-            // 移除旧的连接类型切换逻辑（现在使用服务器配置节点）
-            
             // 渲染从站列表
             function renderSlaveList() {
                 var container = $("#slave-list-container");
@@ -79,7 +77,6 @@
                         </div>
                     `);
                     
-                    // 添加hover效果
                     slaveRow.hover(
                         function() { $(this).css("box-shadow", "0 4px 12px rgba(0,0,0,0.15)"); },
                         function() { $(this).css("box-shadow", "0 2px 6px rgba(0,0,0,0.08)"); }
@@ -88,33 +85,28 @@
                     container.append(slaveRow);
                 });
                 
-                // 更新删除按钮状态（至少保留1个从站）
                 if (node.slaves.length === 1) {
                     $(".btn-delete-slave").prop("disabled", true).css("opacity", "0.4").css("cursor", "not-allowed");
                 }
                 
-                // 更新添加按钮状态（最多10个从站）
                 if (node.slaves.length >= 10) {
                     $("#btn-add-slave").prop("disabled", true).css("opacity", "0.5").css("cursor", "not-allowed");
                 } else {
                     $("#btn-add-slave").prop("disabled", false).css("opacity", "1").css("cursor", "pointer");
                 }
                 
-                // 添加按钮hover效果
                 $("#btn-add-slave").hover(
                     function() { if (!$(this).prop("disabled")) $(this).css("background", "linear-gradient(135deg, #66bb6a 0%, #5cb85c 100%)"); },
                     function() { if (!$(this).prop("disabled")) $(this).css("background", "linear-gradient(135deg, #5cb85c 0%, #4cae4c 100%)"); }
                 );
             }
             
-            // 添加从站
             $("#btn-add-slave").on("click", function() {
                 if (node.slaves.length >= 10) {
                     RED.notify("最多只能添加10个从站", "warning");
                     return;
                 }
                 
-                // 计算下一个从站地址（递增）
                 var lastAddress = node.slaves[node.slaves.length - 1].address;
                 var nextAddress = lastAddress + 1;
                 if (nextAddress > 247) nextAddress = 1;
@@ -129,7 +121,6 @@
                 renderSlaveList();
             });
             
-            // 删除从站
             $(document).on("click", ".btn-delete-slave", function() {
                 var index = parseInt($(this).data("index"));
                 if (node.slaves.length > 1) {
@@ -140,7 +131,6 @@
                 }
             });
             
-            // 更新从站数据
             $(document).on("change", ".slave-address, .slave-coil-start, .slave-coil-end, .slave-poll-interval", function() {
                 var index = parseInt($(this).data("index"));
                 var className = $(this).attr("class").split(" ")[0];
@@ -162,10 +152,8 @@
                 }
             });
             
-            // 初始化渲染
             renderSlaveList();
             
-            // MQTT开关
             $("#node-input-enableMqtt").on("change", function() {
                 if ($(this).is(":checked")) {
                     $(".form-row-mqtt").show();
@@ -174,24 +162,20 @@
                 }
             });
             
-            // 初始化MQTT显示
             $("#node-input-enableMqtt").trigger("change");
         },
         oneditsave: function() {
-            // 保存从站配置到节点
             this.slaves = this.slaves || [];
         }
     });
 </script>
 
 <script type="text/html" data-template-name="modbus-master">
-    <!-- 基本配置 -->
     <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>
     
-    <!-- Modbus服务器配置 -->
     <div class="form-row">
         <label for="node-input-modbusServer"><i class="fa fa-server"></i> Modbus服务器</label>
         <input type="text" id="node-input-modbusServer" placeholder="选择或添加Modbus服务器">

package/nodes/modbus-master.js

@@ -389,8 +389,8 @@ module.exports = function(RED) {
             let currentCandidateIndex = 0;
             let lastConnectAttempt = 0;
             
-            node.log(`MQTT broker候选地址: ${brokerCandidates.join(', ')}`);
-            node.log(`正在连接MQTT broker: ${brokerCandidates[0]}`);
+            node.debug(`MQTT broker候选地址: ${brokerCandidates.join(', ')}`);
+            node.debug(`正在连接MQTT broker: ${brokerCandidates[0]}`);
             
             const options = {
                 clientId: `modbus_master_${Math.random().toString(16).substring(2, 10)}`,
@@ -403,7 +403,7 @@ module.exports = function(RED) {
             if (node.config.mqttUsername) {
                 options.username = node.config.mqttUsername;
                 options.password = node.config.mqttPassword;
-                node.log(`MQTT认证: 用户名=${node.config.mqttUsername}`);
+                node.debug(`MQTT认证: 用户名=${node.config.mqttUsername}`);
             }
             
             // 尝试连接函数
@@ -427,7 +427,7 @@ module.exports = function(RED) {
 
                         // 成功连接后，更新配置的broker地址（下次优先使用成功的地址）
                         if (brokerUrl !== brokerCandidates[0]) {
-                            node.log(`使用fallback地址成功: ${brokerUrl}（原配置: ${brokerCandidates[0]}）`);
+                            node.debug(`使用fallback地址成功: ${brokerUrl}（原配置: ${brokerCandidates[0]}）`);
                         }
 
                         // 异步发送设备发现消息（避免阻塞事件循环）
@@ -491,7 +491,7 @@ module.exports = function(RED) {
                                 
                                 // 5秒后重试第一个地址
                                 setTimeout(() => {
-                                    node.log('重试连接MQTT broker...');
+                                    node.debug('重试连接MQTT broker...');
                                     tryConnect(brokerCandidates[0]);
                                 }, 5000);
                             } else {

package/nodes/modbus-slave-switch.html

@@ -1,12 +1,13 @@
 <script type="text/javascript">
     RED.nodes.registerType('modbus-slave-switch', {
-        category: 'modbus',
+        category: 'SYMI-MODBUS',
         color: '#E9967A',
         defaults: {
             name: {value: "从站开关"},
             // RS-485连接配置（共享配置节点）
             serialPortConfig: {value: "", type: "serial-port-config", required: true},
             // MQTT配置（可选）
+            enableMqtt: {value: false},  // 默认不启用MQTT
             mqttServer: {value: "", type: "mqtt-server-config", required: false},
             // 开关面板配置
             switchBrand: {value: "symi"},  // 品牌选择
@@ -24,6 +25,19 @@
             // 显示时直接使用用户输入的路数（1-32）
             const coilDisplay = this.targetCoilNumber || 1;
             return this.name || `开关${this.switchId}-按钮${this.buttonNumber} → 继电器${this.targetSlaveAddress}-${coilDisplay}路`;
+        },
+        oneditprepare: function() {
+            // MQTT开关控制显示/隐藏
+            $("#node-input-enableMqtt").on("change", function() {
+                if ($(this).is(":checked")) {
+                    $(".form-row-mqtt-slave").show();
+                } else {
+                    $(".form-row-mqtt-slave").hide();
+                }
+            });
+            
+            // 初始化显示状态
+            $("#node-input-enableMqtt").trigger("change");
         }
     });
 </script>
@@ -64,13 +78,19 @@
             <span style="margin-left: 8px; padding: 2px 8px; background: #e3f2fd; color: #1976d2; border-radius: 3px; font-size: 11px; font-weight: 500;">可选</span>
         </label>
         <div style="font-size: 11px; color: #555; padding: 10px 12px; background: linear-gradient(135deg, #e3f2fd 0%, #f0f7ff 100%); border-left: 4px solid #2196f3; border-radius: 4px; box-shadow: 0 1px 3px rgba(0,0,0,0.08);">
-            <strong>💡 提示：</strong>不配置MQTT则使用<strong>本地模式</strong>（纯串口通信），配置MQTT则使用<strong>MQTT模式</strong>（可接入Home Assistant等平台）
+            <strong>💡 提示：</strong>不启用MQTT则使用<strong>本地模式</strong>（通过连线控制），启用MQTT则使用<strong>MQTT模式</strong>（可接入Home Assistant）
         </div>
     </div>
     
     <div class="form-row">
+        <label for="node-input-enableMqtt" style="width: 110px;"><i class="fa fa-toggle-on"></i> 启用MQTT</label>
+        <input type="checkbox" id="node-input-enableMqtt" style="width: auto; margin-left: 5px; transform: scale(1.3); cursor: pointer;">
+        <span style="margin-left: 15px; font-size: 11px; color: #666; font-style: italic;">勾选后切换到MQTT模式</span>
+    </div>
+    
+    <div class="form-row form-row-mqtt-slave">
         <label for="node-input-mqttServer" style="width: 110px;"><i class="fa fa-server"></i> MQTT服务器</label>
-        <input type="text" id="node-input-mqttServer" placeholder="空" style="width: calc(70% - 110px);">
+        <input type="text" id="node-input-mqttServer" placeholder="选择MQTT服务器配置" style="width: calc(70% - 110px);">
         <div style="font-size: 11px; color: #888; margin-left: 110px; margin-top: 3px;">
             选择已配置的MQTT服务器（需与主站节点使用同一配置）
         </div>

package/nodes/modbus-slave-switch.js

@@ -79,8 +79,9 @@ module.exports = function(RED) {
 
         // 配置参数
         node.config = {
-            // 从MQTT配置节点读取MQTT配置
-            mqttBroker: node.mqttServerConfig ? node.mqttServerConfig.broker : "mqtt://localhost:1883",
+            // MQTT配置
+            enableMqtt: config.enableMqtt !== undefined ? config.enableMqtt : false,  // 是否启用MQTT（默认false）
+            mqttBroker: node.mqttServerConfig ? node.mqttServerConfig.broker : "",
             mqttUsername: node.mqttServerConfig ? node.mqttServerConfig.username : "",
             mqttPassword: node.mqttServerConfig ? (node.mqttServerConfig.credentials ? node.mqttServerConfig.credentials.password : "") : "",
             mqttBaseTopic: node.mqttServerConfig ? node.mqttServerConfig.baseTopic : "modbus/relay",
@@ -164,7 +165,7 @@ module.exports = function(RED) {
             
             // 如果是局域网IP，不启用fallback（用户明确指定了IP）
             if (isLanIp) {
-                node.log(`检测到局域网IP配置，将直接连接到 ${configuredBroker}，不启用fallback`);
+                node.debug(`检测到局域网IP配置 ${host}，只使用此地址`);
                 return candidates;
             }
             
@@ -509,27 +510,27 @@ module.exports = function(RED) {
         node.updateStatus = function() {
             const rs485Status = node.isRs485Connected ? 'OK' : 'ERR';
             const state = node.currentState ? 'ON' : 'OFF';
-            const hasMqttConfig = node.config.mqttBroker && node.config.mqttBroker.trim() !== '';
+            const mqttEnabled = node.config.enableMqtt === true;
             const mqttConnected = node.mqttClient && node.mqttClient.connected;
             
             // RS485连接正常
             if (node.isRs485Connected) {
-                if (!hasMqttConfig) {
-                    // 本地模式（未配置MQTT）
+                if (!mqttEnabled) {
+                    // 本地模式（未启用MQTT）
                     node.status({
                         fill: node.currentState ? "green" : "blue",
                         shape: "dot",
-                        text: `本地模式 RS485-${rs485Status} ${state}`
+                        text: `本地模式 ${state}`
                     });
                 } else if (mqttConnected) {
-                    // MQTT模式（已配置且已连接）
+                    // MQTT模式（已启用且已连接）
                     node.status({
                         fill: node.currentState ? "green" : "grey",
                         shape: "dot",
                         text: `MQTT模式 ${state}`
                     });
                 } else {
-                    // MQTT配置但未连接（使用本地模式）
+                    // MQTT已启用但未连接（使用本地模式）
                     node.status({
                         fill: node.currentState ? "green" : "blue",
                         shape: "ring",
@@ -548,10 +549,17 @@ module.exports = function(RED) {
         
         // 连接MQTT（带智能重试和fallback）
         node.connectMqtt = function() {
+            // 检查是否启用MQTT
+            if (!node.config.enableMqtt) {
+                node.log('MQTT未启用 - 使用本地模式（通过Node-RED连线控制）');
+                node.log('提示：将此节点连线到主站节点，即可实现本地控制');
+                return;
+            }
+            
             // 验证MQTT broker配置
             if (!node.config.mqttBroker || node.config.mqttBroker.trim() === '') {
-                node.log('MQTT未配置 - 使用本地模式（通过Node-RED连线控制）');
-                node.log('提示：将此节点连线到主站节点，即可实现本地控制');
+                node.warn('MQTT已启用但broker地址未配置 - 使用本地模式');
+                node.warn('提示：请在MQTT服务器配置节点中设置broker地址，或禁用MQTT功能');
                 return;
             }
             
@@ -560,8 +568,8 @@ module.exports = function(RED) {
             let currentCandidateIndex = 0;
             let lastConnectAttempt = 0;
             
-            node.log(`MQTT broker候选地址: ${brokerCandidates.join(', ')}`);
-            node.log(`正在连接MQTT broker: ${brokerCandidates[0]}`);
+            node.debug(`MQTT broker候选地址: ${brokerCandidates.join(', ')}`);
+            node.debug(`正在连接MQTT broker: ${brokerCandidates[0]}`);
             
             const options = {
                 clientId: `modbus_switch_${node.id}`,
@@ -574,7 +582,7 @@ module.exports = function(RED) {
             if (node.config.mqttUsername) {
                 options.username = node.config.mqttUsername;
                 options.password = node.config.mqttPassword;
-                node.log(`MQTT认证: 用户名=${node.config.mqttUsername}`);
+                node.debug(`MQTT认证: 用户名=${node.config.mqttUsername}`);
             }
             
             // 尝试连接函数
@@ -598,7 +606,7 @@ module.exports = function(RED) {
                         
                         // 成功连接后，更新配置的broker地址（下次优先使用成功的地址）
                         if (brokerUrl !== brokerCandidates[0]) {
-                            node.log(`使用fallback地址成功: ${brokerUrl}（原配置: ${brokerCandidates[0]}）`);
+                            node.debug(`使用fallback地址成功: ${brokerUrl}（原配置: ${brokerCandidates[0]}）`);
                         }
                         
                         node.updateStatus();
@@ -662,7 +670,7 @@ module.exports = function(RED) {
                                 
                                 // 5秒后重试第一个地址
                                 setTimeout(() => {
-                                    node.log('重试连接MQTT broker...');
+                                    node.debug('重试连接MQTT broker...');
                                     tryConnect(brokerCandidates[0]);
                                 }, 5000);
                             } else {

package/package.json

@@ -1,55 +1,59 @@
-{
-  "name": "node-red-contrib-symi-modbus",
-  "version": "2.6.4",
-  "description": "Node-RED Modbus节点，支持TCP/串口通信、串口自动搜索、多设备轮询、可选MQTT集成（支持纯本地模式和MQTT模式）、Home Assistant自动发现和物理开关面板双向同步，工控机长期稳定运行",
-  "main": "nodes/modbus-master.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "keywords": [
-    "node-red",
-    "modbus",
-    "modbus-tcp",
-    "modbus-rtu",
-    "relay",
-    "mqtt",
-    "automation",
-    "home-assistant",
-    "smart-home",
-    "iot",
-    "industrial",
-    "plc"
-  ],
-  "author": {
-    "name": "symi-daguo",
-    "email": "symi@example.com"
-  },
-  "license": "MIT",
-  "engines": {
-    "node": ">=14.0.0",
-    "npm": ">=6.0.0"
-  },
-  "node-red": {
-    "version": ">=2.0.0",
-    "nodes": {
-      "modbus-master": "nodes/modbus-master.js",
-      "modbus-slave-switch": "nodes/modbus-slave-switch.js",
-      "modbus-server-config": "nodes/modbus-server-config.js",
-      "mqtt-server-config": "nodes/mqtt-server-config.js",
-      "serial-port-config": "nodes/serial-port-config.js"
-    }
-  },
-  "dependencies": {
-    "modbus-serial": "^8.0.23",
-    "mqtt": "^5.14.1",
-    "serialport": "^12.0.0"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/symi-daguo/node-red-contrib-symi-modbus.git"
-  },
-  "bugs": {
-    "url": "https://github.com/symi-daguo/node-red-contrib-symi-modbus/issues"
-  },
-  "homepage": "https://github.com/symi-daguo/node-red-contrib-symi-modbus#readme"
-}
+{
+  "name": "node-red-contrib-symi-modbus",
+  "version": "2.6.6",
+  "description": "Node-RED Modbus节点，支持TCP/串口通信、串口自动搜索、多设备轮询、可选MQTT集成（支持纯本地模式和MQTT模式）、Home Assistant自动发现和物理开关面板双向同步，工控机长期稳定运行",
+  "main": "nodes/modbus-master.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "node-red",
+    "modbus",
+    "modbus-tcp",
+    "modbus-rtu",
+    "relay",
+    "mqtt",
+    "automation",
+    "home-assistant",
+    "smart-home",
+    "iot",
+    "industrial",
+    "plc"
+  ],
+  "author": {
+    "name": "symi-daguo",
+    "email": "symi@example.com"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=14.0.0",
+    "npm": ">=6.0.0"
+  },
+  "node-red": {
+    "version": ">=2.0.0",
+    "nodes": {
+      "modbus-master": "nodes/modbus-master.js",
+      "modbus-slave-switch": "nodes/modbus-slave-switch.js",
+      "modbus-server-config": "nodes/modbus-server-config.js",
+      "mqtt-server-config": "nodes/mqtt-server-config.js",
+      "serial-port-config": "nodes/serial-port-config.js",
+      "modbus-debug": "nodes/modbus-debug.js"
+    }
+  },
+  "dependencies": {
+    "modbus-serial": "^8.0.23",
+    "mqtt": "^5.14.1",
+    "serialport": "^12.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/symi-daguo/node-red-contrib-symi-modbus.git"
+  },
+  "bugs": {
+    "url": "https://github.com/symi-daguo/node-red-contrib-symi-modbus/issues"
+  },
+  "homepage": "https://github.com/symi-daguo/node-red-contrib-symi-modbus#readme",
+  "devDependencies": {
+    "node-red": "^4.1.1"
+  }
+}