node-red-contrib-symi-modbus 2.9.7 → 2.9.9

package/README.md

@@ -471,8 +471,8 @@ node-red-restart
   - 连接前彻底清理旧实例，避免资源泄漏
 - **互斥锁机制**：防止读写冲突导致的数据异常
 - **TCP永久连接**：
-  - 禁用TCP超时（永久连接），避免无数据时超时断开
-  - Keep-Alive心跳10秒间隔，确保连接活跃
+    - 禁用TCP超时（永久连接），避免无数据时超时断开
+    - Keep-Alive心跳10秒间隔，确保连接活跃
   - 适应客户长期不在家、总线无数据的场景
   - 网络故障自动重连，恢复后立即恢复通信
 
@@ -952,7 +952,35 @@ HomeKit网桥节点无需输入消息，自动同步主站配置和状态。
 
 ## 版本信息
 
-**当前版本**: v2.9.7 (2025-12-24)
+**当前版本**: v2.9.9 (2026-01-08)
+
+**v2.9.9 更新内容**：
+- **深度优化多 TCP 主站并发**：
+  - **独立主站标识**：为每个 TCP 主站生成唯一标识，支持多个 TCP 连接独立运行，互不干扰
+  - **全局实例管理**：建立全局实例表，解决多节点并发时的资源抢占和卡顿问题
+  - **TCP 参数调优**：
+    - 降低 TCP 超时时间至 1000ms，提升异常响应速度
+    - 启用 Keep-Alive（10秒心跳），确保长连接稳定性
+    - 开启 NoDelay，禁用 Nagle 算法，显著降低指令发送延迟
+  - **稳定性增强**：完善节点关闭时的资源释放逻辑，防止内存泄漏和连接残留
+
+**v2.9.8 更新内容**：
+- **新增品牌支持**：Clowire（克伦威尔）智能面板
+  - 支持Clowire 1-8键开关面板，与亖米面板使用方式完全一致
+  - 支持单击、双击、长按等按键事件（统一当作单击处理，触发一次状态切换）
+  - 支持红外感应器（有人/无人状态检测，复用按键背光灯配置buttonNumber=15）
+  - 支持LED指示灯双向同步（继电器状态→面板LED）
+  - 协议文档：`doc/Clowire-标准面板485协议-V1.3.md`
+- **界面优化**：
+  - 面板品牌下拉框新增"Clowire（克伦威尔）"选项
+  - Clowire默认面板地址为2（符合出厂设置）
+  - 节点标签显示品牌名称（如"Clowire[2]-按钮1"）
+  - 感应器复用按键背光灯配置（buttonNumber=15），无需单独配置
+- **协议实现**：
+  - 新增`clowire-protocol.js`协议模块
+  - 支持MODBUS RTU通讯格式（9600 8N1）
+  - 支持CRC16校验和帧尾0xAA
+  - 支持批量LED控制（0x25命令码）
 
 **v2.9.7 更新内容**：
 - **新增节点**：继电器输出节点（relay-output）

package/nodes/clowire-protocol.js

@@ -0,0 +1,409 @@
+/**
+ * Clowire 标准面板485协议实现
+ * 协议版本：V1.3
+ * 厂家：宁波星宏智能技术有限公司
+ * 
+ * 协议特点：
+ * - 基于 MODBUS RTU 通讯格式
+ * - 面板主动发送模式（按键按下时主动上报）
+ * - 支持单击、双击、三击、长按
+ * - 支持 LED 指示灯控制
+ * - 支持红外感应信号上报
+ * 
+ * 通讯帧格式：
+ * [面板地址][命令码][寄存器地址高][寄存器地址低][数据高][数据低][CRC低][CRC高][帧尾0xAA]
+ */
+
+module.exports = {
+    // 帧尾
+    FRAME_TAIL: 0xAA,
+    
+    // 广播地址
+    BROADCAST_ADDR: 0xFF,
+    
+    // 默认面板地址
+    DEFAULT_PANEL_ADDR: 0x02,
+    
+    // 命令码
+    CMD_READ: 0x03,           // 读取寄存器
+    CMD_WRITE: 0x06,          // 写入单个寄存器
+    CMD_BUTTON_EVENT: 0x20,   // 按键事件上报
+    CMD_BATCH_CONTROL: 0x25,  // 批量控制
+    
+    // 寄存器地址
+    REG_PANEL_ADDR: 0x1000,           // 面板地址
+    REG_BUTTON_S1: 0x1011,            // 按键S1状态
+    REG_BUTTON_S2: 0x1012,            // 按键S2状态
+    REG_BUTTON_S3: 0x1013,            // 按键S3状态
+    REG_BUTTON_S4: 0x1014,            // 按键S4状态
+    REG_BUTTON_S5: 0x1015,            // 按键S5状态
+    REG_BUTTON_S6: 0x1016,            // 按键S6状态
+    REG_BUTTON_S7: 0x1017,            // 按键S7状态
+    REG_BUTTON_S8: 0x1018,            // 按键S8状态
+    REG_DOUBLE_CLICK_INTERVAL: 0x1019, // 双击时间间隔
+    REG_TRIPLE_CLICK_INTERVAL: 0x101A, // 三击时间间隔
+    REG_LONG_PRESS_TIME: 0x101B,       // 长按时间
+    REG_BACKLIGHT: 0x1020,            // 字符背光
+    REG_LED1: 0x1021,                 // LED1指示灯
+    REG_LED2: 0x1022,                 // LED2指示灯
+    REG_LED3: 0x1023,                 // LED3指示灯
+    REG_LED4: 0x1024,                 // LED4指示灯
+    REG_LED5: 0x1025,                 // LED5指示灯
+    REG_LED6: 0x1026,                 // LED6指示灯
+    REG_LED7: 0x1027,                 // LED7指示灯
+    REG_LED8: 0x1028,                 // LED8指示灯
+    REG_SENSOR: 0x1040,               // 感应信号
+    REG_VERSION: 0x1041,              // 版本查询
+    REG_LONG_PRESS: 0x2050,           // 长按寄存器
+    
+    // 按键状态值
+    BUTTON_SINGLE_CLICK: 0x0080,  // 单击 (bit7=1)
+    BUTTON_DOUBLE_CLICK: 0x0040,  // 双击 (bit6=1)
+    BUTTON_TRIPLE_CLICK: 0x0020,  // 三击 (bit5=1)
+    BUTTON_LONG_PRESS: 0x0180,    // 长按
+    BUTTON_LONG_RELEASE: 0x01FE,  // 长按松开
+    
+    // 感应信号值
+    SENSOR_DETECTED: 0x0080,      // 有感应信号
+    SENSOR_NONE: 0x0000,          // 无感应信号
+    
+    /**
+     * 计算 MODBUS CRC16 校验
+     * @param {Buffer} buffer - 数据缓冲区
+     * @param {number} len - 数据长度（不包含CRC和帧尾）
+     * @returns {number} CRC16校验值（低字节在前）
+     */
+    calculateCRC16: function(buffer, len) {
+        let crc = 0xFFFF;
+        for (let i = 0; i < len; i++) {
+            crc ^= buffer[i];
+            for (let j = 0; j < 8; j++) {
+                if (crc & 0x0001) {
+                    crc = (crc >> 1) ^ 0xA001;
+                } else {
+                    crc >>= 1;
+                }
+            }
+        }
+        return crc;
+    },
+    
+    /**
+     * 构建LED指示灯控制指令
+     * @param {number} panelAddr - 面板地址（1-127）
+     * @param {number} buttonNumber - 按钮编号（1-8）
+     * @param {boolean} state - LED状态（true=开，false=关）
+     * @returns {Buffer} 完整的指令帧
+     */
+    buildLedControlCommand: function(panelAddr, buttonNumber, state) {
+        const buffer = Buffer.alloc(9);
+        let idx = 0;
+        
+        // 面板地址
+        buffer[idx++] = panelAddr;
+        // 命令码：写入单个寄存器
+        buffer[idx++] = this.CMD_WRITE;
+        // 寄存器地址（LED1=0x1021, LED2=0x1022, ...）
+        const regAddr = 0x1020 + buttonNumber;
+        buffer[idx++] = (regAddr >> 8) & 0xFF;  // 高字节
+        buffer[idx++] = regAddr & 0xFF;          // 低字节
+        // 数据（00 01=开，00 00=关）
+        buffer[idx++] = 0x00;
+        buffer[idx++] = state ? 0x01 : 0x00;
+        
+        // 计算CRC16
+        const crc = this.calculateCRC16(buffer, 6);
+        buffer[idx++] = crc & 0xFF;         // CRC低字节
+        buffer[idx++] = (crc >> 8) & 0xFF;  // CRC高字节
+        // 帧尾
+        buffer[idx++] = this.FRAME_TAIL;
+        
+        return buffer;
+    },
+    
+    /**
+     * 构建批量LED控制指令（使用0x25命令码）
+     * @param {number} panelAddr - 面板地址（1-127）
+     * @param {Array<boolean>} ledStates - LED状态数组（最多8个）
+     * @param {boolean} backlight - 字符背光状态
+     * @returns {Buffer} 完整的指令帧
+     */
+    buildBatchLedCommand: function(panelAddr, ledStates, backlight = true) {
+        const buffer = Buffer.alloc(11);
+        let idx = 0;
+        
+        // 广播地址
+        buffer[idx++] = this.BROADCAST_ADDR;
+        // 命令码：批量控制
+        buffer[idx++] = this.CMD_BATCH_CONTROL;
+        // 面板开始地址（高字节、低字节）
+        buffer[idx++] = 0x00;
+        buffer[idx++] = panelAddr;
+        // 连续面板数量（高字节、低字节）
+        buffer[idx++] = 0x00;
+        buffer[idx++] = 0x01;
+        
+        // 面板数据（2字节）
+        // 高字节：B8=背光，B9-B12=继电器（预留）
+        // 低字节：B0-B5=LED1-LED6
+        let highByte = backlight ? 0x01 : 0x00;  // B8=背光
+        let lowByte = 0x00;
+        
+        for (let i = 0; i < Math.min(ledStates.length, 6); i++) {
+            if (ledStates[i]) {
+                lowByte |= (1 << i);
+            }
+        }
+        
+        buffer[idx++] = highByte;
+        buffer[idx++] = lowByte;
+        
+        // 计算CRC16
+        const crc = this.calculateCRC16(buffer, 8);
+        buffer[idx++] = crc & 0xFF;         // CRC低字节
+        buffer[idx++] = (crc >> 8) & 0xFF;  // CRC高字节
+        // 帧尾
+        buffer[idx++] = this.FRAME_TAIL;
+        
+        return buffer;
+    },
+    
+    /**
+     * 构建字符背光控制指令
+     * @param {number} panelAddr - 面板地址（1-127）
+     * @param {boolean} state - 背光状态（true=开，false=关）
+     * @returns {Buffer} 完整的指令帧
+     */
+    buildBacklightCommand: function(panelAddr, state) {
+        const buffer = Buffer.alloc(9);
+        let idx = 0;
+        
+        buffer[idx++] = panelAddr;
+        buffer[idx++] = this.CMD_WRITE;
+        buffer[idx++] = 0x10;  // 寄存器地址高字节
+        buffer[idx++] = 0x20;  // 寄存器地址低字节（0x1020）
+        buffer[idx++] = 0x00;
+        buffer[idx++] = state ? 0x01 : 0x00;
+        
+        const crc = this.calculateCRC16(buffer, 6);
+        buffer[idx++] = crc & 0xFF;
+        buffer[idx++] = (crc >> 8) & 0xFF;
+        buffer[idx++] = this.FRAME_TAIL;
+        
+        return buffer;
+    },
+    
+    /**
+     * 解析接收到的协议帧
+     * @param {Buffer} buffer - 接收到的数据
+     * @returns {Object|null} 解析结果或null
+     */
+    parseFrame: function(buffer) {
+        if (!buffer || buffer.length < 9) {
+            return null;
+        }
+        
+        // 查找帧尾位置
+        let endIndex = -1;
+        for (let i = buffer.length - 1; i >= 0; i--) {
+            if (buffer[i] === this.FRAME_TAIL) {
+                endIndex = i;
+                break;
+            }
+        }
+        
+        if (endIndex === -1 || endIndex < 8) {
+            return null;
+        }
+        
+        // 提取帧数据（从开头到帧尾）
+        const frameBuffer = buffer.slice(0, endIndex + 1);
+        
+        // 验证CRC16
+        const dataLen = frameBuffer.length - 3;  // 不包含CRC(2字节)和帧尾(1字节)
+        const receivedCRC = frameBuffer[dataLen] | (frameBuffer[dataLen + 1] << 8);
+        const calculatedCRC = this.calculateCRC16(frameBuffer, dataLen);
+        
+        // CRC校验（宽松模式：按键事件允许CRC不匹配）
+        const cmdCode = frameBuffer[1];
+        const isButtonEvent = (cmdCode === this.CMD_BUTTON_EVENT || cmdCode === this.CMD_READ);
+        
+        if (receivedCRC !== calculatedCRC && !isButtonEvent) {
+            return null;
+        }
+        
+        // 解析帧
+        const frame = {
+            panelAddr: frameBuffer[0],
+            cmdCode: frameBuffer[1],
+            regAddrHigh: frameBuffer[2],
+            regAddrLow: frameBuffer[3],
+            regAddr: (frameBuffer[2] << 8) | frameBuffer[3],
+            dataHigh: frameBuffer[4],
+            dataLow: frameBuffer[5],
+            data: (frameBuffer[4] << 8) | frameBuffer[5],
+            crc: receivedCRC,
+            frameLength: frameBuffer.length
+        };
+        
+        return frame;
+    },
+    
+    /**
+     * 解析所有协议帧（处理粘包）
+     * @param {Buffer} buffer - 接收到的数据（可能包含多个帧）
+     * @returns {Array} 解析出的所有帧数组
+     */
+    parseAllFrames: function(buffer) {
+        const frames = [];
+        if (!buffer || buffer.length < 9) {
+            return frames;
+        }
+        
+        let offset = 0;
+        let maxIterations = 10;
+        
+        while (offset < buffer.length && maxIterations > 0) {
+            maxIterations--;
+            
+            // 查找帧尾
+            let endIndex = -1;
+            for (let i = offset; i < buffer.length; i++) {
+                if (buffer[i] === this.FRAME_TAIL) {
+                    endIndex = i;
+                    break;
+                }
+            }
+            
+            if (endIndex === -1) {
+                break;
+            }
+            
+            // 检查帧长度（最小9字节）
+            const frameLen = endIndex - offset + 1;
+            if (frameLen < 9) {
+                offset = endIndex + 1;
+                continue;
+            }
+            
+            // 提取帧
+            const frameBuffer = buffer.slice(offset, endIndex + 1);
+            const frame = this.parseFrame(frameBuffer);
+            
+            if (frame) {
+                frames.push(frame);
+            }
+            
+            offset = endIndex + 1;
+        }
+        
+        return frames;
+    },
+    
+    /**
+     * 检测是否是按键事件
+     * @param {Object} frame - 解析后的帧
+     * @returns {Object|null} 按键事件信息或null
+     */
+    detectButtonEvent: function(frame) {
+        if (!frame) return null;
+        
+        // 检查命令码是否是按键事件上报（0x20）或读取（0x03）
+        if (frame.cmdCode !== this.CMD_BUTTON_EVENT && frame.cmdCode !== this.CMD_READ) {
+            return null;
+        }
+        
+        // 检查寄存器地址是否在按键范围内（0x1011-0x1018）
+        if (frame.regAddr >= this.REG_BUTTON_S1 && frame.regAddr <= this.REG_BUTTON_S8) {
+            // 按键事件
+            const buttonNumber = frame.regAddr - this.REG_BUTTON_S1 + 1;  // 1-8
+            const data = frame.data;
+            
+            // 判断按键类型
+            let eventType = 'unknown';
+            let state = true;  // 默认触发状态
+            
+            if (data === this.BUTTON_SINGLE_CLICK || (data & 0x0080) !== 0) {
+                eventType = 'single_click';
+            } else if (data === this.BUTTON_DOUBLE_CLICK || (data & 0x0040) !== 0) {
+                eventType = 'double_click';
+            } else if (data === this.BUTTON_TRIPLE_CLICK || (data & 0x0020) !== 0) {
+                eventType = 'triple_click';
+            }
+            
+            return {
+                type: 'button',
+                panelAddr: frame.panelAddr,
+                buttonNumber: buttonNumber,
+                eventType: eventType,
+                state: state,
+                data: data,
+                raw: frame
+            };
+        }
+        
+        // 检查是否是长按事件（寄存器0x2050）
+        if (frame.regAddr === this.REG_LONG_PRESS) {
+            const buttonNumber = frame.dataHigh;  // 按键编号在高字节
+            const pressState = frame.dataLow;     // 按下状态在低字节
+            
+            return {
+                type: 'button',
+                panelAddr: frame.panelAddr,
+                buttonNumber: buttonNumber,
+                eventType: pressState === 0xFE ? 'long_press_release' : 'long_press',
+                state: pressState !== 0xFE,
+                data: frame.data,
+                raw: frame
+            };
+        }
+        
+        // 检查是否是感应信号（寄存器0x1040）
+        if (frame.regAddr === this.REG_SENSOR) {
+            const hasPresence = (frame.data & 0x0080) !== 0;
+            
+            return {
+                type: 'sensor',
+                panelAddr: frame.panelAddr,
+                sensorType: 'presence',
+                state: hasPresence,
+                data: frame.data,
+                raw: frame
+            };
+        }
+        
+        return null;
+    },
+    
+    /**
+     * 判断是否是Clowire协议帧
+     * @param {Buffer} buffer - 接收到的数据
+     * @returns {boolean} 是否是Clowire协议
+     */
+    isClowireFrame: function(buffer) {
+        if (!buffer || buffer.length < 9) {
+            return false;
+        }
+        
+        // 检查帧尾是否是0xAA
+        const lastByte = buffer[buffer.length - 1];
+        if (lastByte !== this.FRAME_TAIL) {
+            return false;
+        }
+        
+        // 检查命令码是否是Clowire支持的命令
+        const cmdCode = buffer[1];
+        const validCmds = [this.CMD_READ, this.CMD_WRITE, this.CMD_BUTTON_EVENT, this.CMD_BATCH_CONTROL];
+        if (!validCmds.includes(cmdCode)) {
+            return false;
+        }
+        
+        // 检查寄存器地址是否在Clowire范围内（0x1000-0x2FFF）
+        const regAddr = (buffer[2] << 8) | buffer[3];
+        if (regAddr < 0x1000 || regAddr > 0x2FFF) {
+            return false;
+        }
+        
+        return true;
+    }
+};

package/nodes/modbus-master.js

@@ -3,7 +3,11 @@ module.exports = function(RED) {
     const ModbusRTU = require("modbus-serial");
     const mqtt = require("mqtt");
     const protocol = require("./lightweight-protocol");
-    
+
+    // 全局主站实例注册表（用于多主站独立运行，避免互相干扰）
+    // 每个主站节点有独立的Modbus客户端实例，互不影响
+    const masterInstances = new Map();
+
     // 串口列表API - 支持Windows、Linux、macOS所有串口设备
     RED.httpAdmin.get('/modbus-master/serialports', async function(req, res) {
         try {
@@ -90,13 +94,16 @@ module.exports = function(RED) {
     function ModbusMasterNode(config) {
         RED.nodes.createNode(this, config);
         const node = this;
-        
+
+        // 生成唯一的主站标识（用于多主站独立运行）
+        node.masterId = `master_${node.id}`;
+
         // 获取Modbus服务器配置节点
         node.modbusServerConfig = RED.nodes.getNode(config.modbusServer);
-        
+
         // 获取MQTT服务器配置节点
         node.mqttServerConfig = RED.nodes.getNode(config.mqttServer);
-        
+
         // 配置参数（从Modbus服务器配置节点读取）
         node.config = {
             connectionType: node.modbusServerConfig ? (node.modbusServerConfig.connectionType || "tcp") : "tcp",
@@ -120,13 +127,19 @@ module.exports = function(RED) {
             mqttPassword: node.mqttServerConfig ? (node.mqttServerConfig.credentials ? node.mqttServerConfig.credentials.password : "") : "",
             mqttBaseTopic: node.mqttServerConfig ? node.mqttServerConfig.baseTopic : "modbus/relay"
         };
-        
+
         // 验证Modbus服务器配置
         if (!node.modbusServerConfig) {
             node.warn('未配置Modbus服务器，将使用默认配置');
         }
-        
-        // Modbus客户端
+
+        // 记录主站配置信息（用于调试多主站问题）
+        const connInfo = node.config.connectionType === "tcp"
+            ? `TCP ${node.config.tcpHost}:${node.config.tcpPort}`
+            : `串口 ${node.config.serialPort}`;
+        node.log(`主站初始化: ${node.masterId}, 连接: ${connInfo}`);
+
+        // Modbus客户端（每个主站独立的客户端实例）
         node.client = new ModbusRTU();
         node.isConnected = false;
         node.pollTimer = null;
@@ -139,7 +152,7 @@ module.exports = function(RED) {
         node.isClosing = false;
         node.lastErrorLog = {}; // 记录每个从站的最后错误日志时间
         node.lastMqttErrorLog = 0; // MQTT错误日志时间
-        node.errorLogInterval = 5 * 60 * 1000; // 错误日志间隔：5分钟（降低到5分钟，更快发现问题）
+        node.errorLogInterval = 5 * 60 * 1000; // 错误日志间隔：5分钟
         node.consecutiveErrors = {}; // 记录每个从站的连续错误次数
         node.modbusLock = false; // Modbus操作互斥锁（防止读写冲突）
         node.lastWriteTime = {}; // 记录每个从站的最后写入时间
@@ -152,6 +165,15 @@ module.exports = function(RED) {
         node.isProcessingWrite = false; // 是否正在处理写入队列
         node.writeQueueInterval = 50; // 写入队列处理间隔（50ms，厂家推荐间隔，确保总线稳定）
 
+        // 注册到全局主站实例表（用于调试和监控）
+        masterInstances.set(node.masterId, {
+            nodeId: node.id,
+            connection: connInfo,
+            slaves: node.config.slaves.map(s => s.address),
+            startTime: Date.now()
+        });
+        node.log(`已注册主站实例，当前主站数量: ${masterInstances.size}`);
+
         // 定期清理机制（每小时清理一次，防止内存泄漏）
         node.cleanupTimer = setInterval(() => {
             // 清理过期的错误日志记录
@@ -244,7 +266,7 @@ module.exports = function(RED) {
                         throw new Error('TCP主机地址未配置，请在节点配置中填写Modbus服务器IP地址');
                     }
 
-                    const tcpMode = node.config.tcpMode || "telnet";
+                    const tcpMode = node.modbusServerConfig ? (node.modbusServerConfig.tcpMode || "telnet") : "telnet";
                     const modeNames = {
                         "telnet": "Telnet ASCII",
                         "rtu": "RTU over TCP",
@@ -253,24 +275,35 @@ module.exports = function(RED) {
 
                     node.log(`正在连接TCP网关（${modeNames[tcpMode]}）: ${node.config.tcpHost}:${node.config.tcpPort}...`);
 
+                    // TCP连接选项（优化多主站并发性能）
+                    const tcpOptions = {
+                        port: node.config.tcpPort,
+                        // 注意：modbus-serial内部会设置socket选项
+                    };
+
                     if (tcpMode === "telnet") {
-                        await node.client.connectTelnet(node.config.tcpHost, {
-                            port: node.config.tcpPort
-                        });
+                        await node.client.connectTelnet(node.config.tcpHost, tcpOptions);
                     } else if (tcpMode === "rtu") {
-                        await node.client.connectTcpRTUBuffered(node.config.tcpHost, {
-                            port: node.config.tcpPort
-                        });
+                        await node.client.connectTcpRTUBuffered(node.config.tcpHost, tcpOptions);
                     } else {
-                        await node.client.connectTCP(node.config.tcpHost, {
-                            port: node.config.tcpPort
-                        });
+                        await node.client.connectTCP(node.config.tcpHost, tcpOptions);
+                    }
+
+                    // 优化TCP socket设置（提升多主站并发性能）
+                    if (node.client._client) {
+                        // 启用TCP Keep-Alive，10秒间隔
+                        node.client._client.setKeepAlive(true, 10000);
+                        // 禁用Nagle算法，减少延迟
+                        node.client._client.setNoDelay(true);
+                        // 设置socket超时为0（永不超时，由Modbus层控制超时）
+                        node.client._client.setTimeout(0);
+                        node.log('TCP socket优化: Keep-Alive=10s, NoDelay=true');
                     }
 
                     node.log(`TCP网关连接成功（${modeNames[tcpMode]}）: ${node.config.tcpHost}:${node.config.tcpPort}`);
                 } else {
                     node.log(`正在连接串口: ${node.config.serialPort} @ ${node.config.serialBaudRate || 9600}bps...`);
-                    
+
                     await node.client.connectRTUBuffered(node.config.serialPort, {
                         baudRate: node.config.serialBaudRate || 9600,
                         dataBits: node.config.serialDataBits || 8,
@@ -278,12 +311,14 @@ module.exports = function(RED) {
                         parity: node.config.serialParity || 'none',
                         lock: false  // 禁用串口锁定，解决HassOS中"Cannot lock port"错误
                     });
-                    
+
                     node.log(`串口Modbus连接成功: ${node.config.serialPort} @ ${node.config.serialBaudRate || 9600}bps`);
                 }
 
-                // 设置超时时间（串口需要更长的超时时间，但不能太长以免影响轮询）
-                const timeout = node.config.connectionType === "serial" ? 3000 : 2000;
+                // 设置Modbus超时时间
+                // TCP模式：降低到1000ms，避免一个主站超时阻塞其他主站太久
+                // 串口模式：保持2000ms，串口通信需要更长时间
+                const timeout = node.config.connectionType === "serial" ? 2000 : 1000;
                 node.client.setTimeout(timeout);
                 node.log(`Modbus超时设置: ${timeout}ms`);
 
@@ -293,6 +328,13 @@ module.exports = function(RED) {
                         node.warn(`串口错误（已忽略）: ${err.message}`);
                     });
                 }
+
+                // TCP模式：设置socket错误处理器
+                if (node.client._client) {
+                    node.client._client.on('error', (err) => {
+                        node.warn(`TCP socket错误（已忽略）: ${err.message}`);
+                    });
+                }
                 
                 node.isConnected = true;
                 node.reconnectAttempts = 0;  // 重置重连计数
@@ -1525,6 +1567,12 @@ module.exports = function(RED) {
             node.isClosing = true;
             node.stopPolling();
 
+            // 从全局主站实例表中移除
+            if (node.masterId) {
+                masterInstances.delete(node.masterId);
+                node.log(`已注销主站实例 ${node.masterId}，剩余主站数量: ${masterInstances.size}`);
+            }
+
             // 移除内部事件监听器
             if (node.internalEventHandler) {
                 RED.events.removeListener('modbus:writeCoil', node.internalEventHandler);
@@ -1553,13 +1601,13 @@ module.exports = function(RED) {
             if (node.config.enableMqtt && node.mqttClient && node.mqttClient.connected) {
                 node.publishOfflineStatus();
             }
-            
+
             // 清理设备状态缓存（释放内存）
             node.deviceStates = {};
             node.lastErrorLog = {};
             node.lastWriteTime = {};
             node.lastMqttErrorLog = 0;
-            
+
             // 关闭Modbus连接
             if (node.client) {
                 try {

package/nodes/modbus-server-config.js

@@ -4,6 +4,7 @@ module.exports = function(RED) {
     function ModbusServerConfigNode(config) {
         RED.nodes.createNode(this, config);
         this.connectionType = config.connectionType;
+        this.tcpMode = config.tcpMode || "telnet";  // TCP模式：telnet/rtu/tcp
         this.tcpHost = config.tcpHost;
         this.tcpPort = parseInt(config.tcpPort) || 502;
         this.serialPort = config.serialPort;
@@ -12,7 +13,7 @@ module.exports = function(RED) {
         this.serialStopBits = parseInt(config.serialStopBits) || 1;
         this.serialParity = config.serialParity || "none";
     }
-    
+
     RED.nodes.registerType("modbus-server-config", ModbusServerConfigNode);
 };
 

package/nodes/modbus-slave-switch.html

@@ -15,6 +15,7 @@
             buttonType: {value: "switch"},  // 按钮类型：switch=开关模式，scene=场景模式，mesh=Mesh模式
             switchId: {value: 0, validate: RED.validators.number()},
             buttonNumber: {value: 1, validate: RED.validators.number()},
+
             // Mesh模式配置
             meshMacAddress: {value: ""},  // Mesh设备MAC地址
             meshShortAddress: {value: 0},  // Mesh设备短地址
@@ -39,7 +40,8 @@
                 // 开关模式和场景模式显示
                 const coilDisplay = this.targetCoilNumber || 1;
                 const btnLabel = this.buttonNumber == 15 ? '背光灯' : `按钮${this.buttonNumber}`;
-                return this.name || `开关${this.switchId}-${btnLabel} → 继电器${this.targetSlaveAddress}-${coilDisplay}路`;
+                const brandLabel = this.switchBrand === 'clowire' ? 'Clowire' : '开关';
+                return this.name || `${brandLabel}${this.switchId}-${btnLabel} → 继电器${this.targetSlaveAddress}-${coilDisplay}路`;
             }
         },
         oneditprepare: function() {
@@ -54,6 +56,17 @@
                 }
             });
 
+            // 品牌切换控制
+            $("#node-input-switchBrand").on("change", function() {
+                const brand = $(this).val();
+                if (brand === 'clowire') {
+                    // Clowire默认地址是2
+                    if ($("#node-input-switchId").val() === '0') {
+                        $("#node-input-switchId").val(2);
+                    }
+                }
+            });
+
             // 按钮类型切换控制显示/隐藏
             $("#node-input-buttonType").on("change", function() {
                 const buttonType = $(this).val();
@@ -268,12 +281,13 @@
         <label for="node-input-switchBrand" style="width: 110px;"><i class="fa fa-trademark"></i> 面板品牌</label>
         <select id="node-input-switchBrand" style="width: 200px;">
             <option value="symi">亖米（Symi）</option>
-            <option value="other1" disabled style="color: #999;">其他品牌1（待开发）</option>
-            <option value="other2" disabled style="color: #999;">其他品牌2（待开发）</option>
+            <option value="clowire">Clowire（克伦威尔）</option>
         </select>
         <span style="margin-left: 10px; font-size: 11px; color: #666; font-style: italic;">支持1-8键开关</span>
     </div>
 
+
+
     <div class="form-row">
         <label for="node-input-buttonType" style="width: 110px;"><i class="fa fa-cog"></i> 按钮类型</label>
         <select id="node-input-buttonType" style="width: 200px;">
@@ -388,8 +402,8 @@
                 配置说明
             </div>
             <div style="margin-bottom: 8px; padding-left: 10px;">
-                <strong>面板品牌：</strong><span style="color: #555;">亖米协议，支持1-8键开关</span><br>
-                <strong>开关ID：</strong><span style="color: #555;">物理面板RS-485地址（0-255）</span><br>
+                <strong>面板品牌：</strong><span style="color: #555;">亖米/Clowire协议，支持1-8键开关</span><br>
+                <strong>开关ID：</strong><span style="color: #555;">物理面板RS-485地址（亖米:0-255，Clowire:1-127，默认2）</span><br>
                 <strong>按钮编号：</strong><span style="color: #555;">面板按键序号（1-8）</span><br>
                 <strong>从站地址：</strong><span style="color: #555;">Modbus继电器地址（10-19）</span><br>
                 <strong>线圈编号：</strong><span style="color: #555;">继电器通道号（0-31）</span>
@@ -399,7 +413,8 @@
                     配置示例
                 </div>
                 <div style="background: white; padding: 8px; border-radius: 4px; border: 1px solid #c8e6c9; font-size: 11px; color: #555;">
-                    <strong>场景：</strong>亖米开关ID=0，按钮1 → 控制继电器10的线圈0<br>
+                    <strong>亖米：</strong>开关ID=0，按钮1 → 控制继电器10的线圈0<br>
+                    <strong>Clowire：</strong>开关ID=2，按钮1 → 控制继电器10的线圈0<br>
                     <strong>MQTT：</strong><code style="background: #f5f5f5; padding: 2px 6px; border-radius: 3px; color: #e91e63; font-family: monospace;">modbus/relay/10/0/set</code>
                 </div>
             </div>

package/nodes/modbus-slave-switch.js

@@ -2,6 +2,7 @@ module.exports = function(RED) {
     "use strict";
     const mqtt = require("mqtt");
     const protocol = require("./lightweight-protocol");
+    const clowireProtocol = require("./clowire-protocol");
     const meshProtocol = require("./mesh-protocol")(RED);
     const storage = require('node-persist');
     const path = require('path');
@@ -373,7 +374,7 @@ module.exports = function(RED) {
             mqttPassword: node.mqttServerConfig ? (node.mqttServerConfig.credentials ? node.mqttServerConfig.credentials.password : "") : "",
             mqttBaseTopic: node.mqttServerConfig ? node.mqttServerConfig.baseTopic : "modbus/relay",
             // 开关面板配置
-            switchBrand: config.switchBrand || "symi",         // 面板品牌（默认亖米）
+            switchBrand: config.switchBrand || "symi",         // 面板品牌（默认亖米，支持clowire）
             buttonType: config.buttonType || "switch",         // 按钮类型：switch=开关模式，scene=场景模式，mesh=Mesh模式
             switchId: parseInt(config.switchId) || 0,           // 开关ID（0-255，物理面板地址）
             buttonNumber: parseInt(config.buttonNumber) || 1,  // 按钮编号（1-8）
@@ -782,7 +783,13 @@ module.exports = function(RED) {
                     return;
                 }
 
-                // 使用parseAllFrames处理粘包，解析所有帧
+                // 根据品牌选择协议解析
+                if (node.config.switchBrand === 'clowire') {
+                    node.handleClowireData(data);
+                    return;
+                }
+
+                // 亖米协议：使用parseAllFrames处理粘包，解析所有帧
                 const frames = protocol.parseAllFrames(data);
                 if (!frames || frames.length === 0) {
                     return; // 静默忽略无效帧
@@ -864,6 +871,106 @@ module.exports = function(RED) {
             }
         };
 
+        // 处理Clowire协议数据
+        node.handleClowireData = function(data) {
+            try {
+                // 检查是否是Clowire协议帧
+                if (!clowireProtocol.isClowireFrame(data)) {
+                    return; // 静默忽略非Clowire帧
+                }
+
+                // 解析所有帧
+                const frames = clowireProtocol.parseAllFrames(data);
+                if (!frames || frames.length === 0) {
+                    return;
+                }
+
+                // 处理每一个帧
+                for (const frame of frames) {
+                    // 检测按键或感应事件
+                    const event = clowireProtocol.detectButtonEvent(frame);
+                    if (!event) {
+                        continue;
+                    }
+
+                    // 检查是否是我们监听的面板
+                    if (event.panelAddr !== node.config.switchId) {
+                        continue;
+                    }
+
+                    // 处理感应器事件（通道0x0F，buttonNumber=15）
+                    if (event.type === 'sensor' && node.config.buttonNumber === 15) {
+                        // 感应器模式：有人/无人状态，复用按键背光灯配置
+                        const debounceKey = `clowire-sensor-${node.config.switchId}-${node.config.targetSlaveAddress}`;
+                        const now = Date.now();
+                        const lastTriggerTime = globalDebounceCache.get(debounceKey) || 0;
+
+                        // 感应器防抖：500ms内只触发一次
+                        if (now - lastTriggerTime < 500) {
+                            continue;
+                        }
+                        globalDebounceCache.set(debounceKey, now);
+
+                        node.debug(`[Clowire感应] 面板${node.config.switchId} 感应状态: ${event.state ? '有人' : '无人'}`);
+
+                        // 更新状态并发送命令
+                        node.currentState = event.state;
+                        node.sendMqttCommand(event.state);
+
+                        // 输出消息
+                        node.send({
+                            payload: event.state,
+                            topic: `clowire_sensor_${node.config.switchId}`,
+                            switchId: node.config.switchId,
+                            sensorType: 'presence',
+                            targetSlave: node.config.targetSlaveAddress,
+                            targetCoil: node.config.targetCoilNumber
+                        });
+
+                        continue;
+                    }
+
+                    // 处理按键事件
+                    if (event.type === 'button' && event.buttonNumber === node.config.buttonNumber) {
+                        // 全局防抖
+                        const debounceKey = `clowire-${node.config.switchId}-${node.config.buttonNumber}-${node.config.targetSlaveAddress}`;
+                        const now = Date.now();
+                        const lastTriggerTime = globalDebounceCache.get(debounceKey) || 0;
+
+                        // 统一防抖时间200ms（单击、双击、长按都当作单击处理）
+                        if (now - lastTriggerTime < 200) {
+                            continue;
+                        }
+                        globalDebounceCache.set(debounceKey, now);
+
+                        // 设置触发源
+                        if (node.serialPortConfig && typeof node.serialPortConfig.setTriggerSource === 'function') {
+                            node.serialPortConfig.setTriggerSource(node.config.switchId);
+                        }
+
+                        node.debug(`[Clowire按键] 面板${node.config.switchId} 按键${node.config.buttonNumber} ${event.eventType}（当作单击处理）`);
+
+                        // 所有按键事件都当作单击处理：切换状态
+                        node.currentState = !node.currentState;
+                        node.sendMqttCommand(node.currentState);
+
+                        // 输出消息
+                        node.send({
+                            payload: node.currentState,
+                            topic: `clowire_switch_${node.config.switchId}_btn${node.config.buttonNumber}`,
+                            switchId: node.config.switchId,
+                            button: node.config.buttonNumber,
+                            eventType: 'single_click',  // 统一报告为单击
+                            targetSlave: node.config.targetSlaveAddress,
+                            targetCoil: node.config.targetCoilNumber
+                        });
+                    }
+                }
+            } catch (err) {
+                node.error(`解析Clowire数据失败: ${err.message}`);
+            }
+        };
+
         // 处理Mesh协议数据
         node.handleMeshData = function(data) {
             try {
@@ -1157,6 +1264,34 @@ module.exports = function(RED) {
 
                 const hexStr = command.toString('hex').toUpperCase().match(/.{1,2}/g).join(' ');
                 node.debug(`[Mesh LED] 控制帧已构建：[${hexStr}]`);
+            } else if (node.config.switchBrand === 'clowire') {
+                // Clowire品牌：使用Clowire协议发送LED反馈
+                const buttonNumber = node.config.buttonNumber;
+
+                // 防止重复发送
+                if (node.lastSentLedState.value === state && (now - node.lastSentLedState.timestamp) < 50) {
+                    node.debug(`跳过重复LED反馈（状态未变化，间隔${now - node.lastSentLedState.timestamp}ms）`);
+                    return;
+                }
+
+                node.lastSentLedState.value = state;
+                node.lastSentLedState.timestamp = now;
+
+                node.debug(`[Clowire LED发送] 面板${node.config.switchId} 按钮${buttonNumber} = ${state}`);
+
+                command = clowireProtocol.buildLedControlCommand(
+                    node.config.switchId,
+                    buttonNumber,
+                    state
+                );
+
+                if (!command) {
+                    node.error(`构建Clowire LED控制帧失败`);
+                    return;
+                }
+
+                const hexStr = command.toString('hex').toUpperCase().match(/.{1,2}/g).join(' ');
+                node.debug(`[Clowire LED] 控制帧已构建：[${hexStr}]`);
             } else {
                 // RS-485模式：使用轻量级协议
                 const deviceAddr = node.buttonDeviceAddr;

package/package.json

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