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

package/README.md

@@ -952,7 +952,25 @@ HomeKit网桥节点无需输入消息，自动同步主站配置和状态。
 
 ## 版本信息
 
-**当前版本**: v2.9.7 (2025-12-24)
+**当前版本**: v2.9.8 (2026-01-06)
+
+**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-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.8",
+  "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"