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

package/README.md

@@ -816,6 +816,70 @@ HomeKit网桥节点无需输入消息，自动同步主站配置和状态。
 - 测试功能需先选择串口配置
 - 无需连线到debug节点，直接通过串口配置节点发送数据
 
+### 继电器输出节点（relay-output）
+
+用于控制Modbus继电器，支持**绑定从站开关触发源**或接收外部输入，**无需连线到主站**。
+
+**核心特性**：
+- 从站开关、继电器输出、主站之间**完全无需连线**
+- 共享RS-485连接配置，支持多个节点共用
+- 支持绑定从站开关作为触发源（内部事件通信）
+- 支持外部设备触发（如海康门禁）
+- 支持延时执行（0-60000毫秒），实现级联开灯效果
+- 配置持久化保存，断电断网恢复后正常工作
+
+**配置参数**：
+
+*RS-485连接配置*：
+- **连接配置**：选择已配置的RS-485连接（支持TCP网关或串口），多个节点共享
+
+*按键触发配置*：
+- **面板品牌**：开关面板品牌，目前支持亖米（Symi）
+- **按钮类型**：开关按钮/场景按钮/输入端触发（外部设备）
+- **开关ID**：物理面板地址（0-255）
+- **按钮编号**：按键编号(1-8，15=背光灯)
+- **门禁ID**：可选，0=不过滤，>0=只响应指定门禁编号
+
+*目标继电器配置*：
+- **从站地址**：要控制的Modbus从站地址(1-247)
+- **继电器路数**：要控制的继电器通道(1-32)
+
+*动作配置*：
+- **动作**：打开/关闭/跟随输入/翻转状态
+- **延时**：执行延时（0-60000毫秒），用于实现级联开灯效果
+- **忽略释放信号**：只响应按下信号
+
+**使用示例**：
+
+**示例1：按键触发继电器（无需任何连线）**
+```
+配置：开关ID=1，按钮编号=3，从站地址=10，继电器路数=1，动作=打开
+效果：当开关1的按钮3被按下时，自动控制从站10的1路继电器打开
+```
+
+**示例2：一个按键控制多路继电器（级联开灯）**
+```
+继电器输出1: 开关ID=1, 按钮=3, 继电器=1路, 延时=0ms, 动作=打开
+继电器输出2: 开关ID=1, 按钮=3, 继电器=2路, 延时=500ms, 动作=打开
+继电器输出3: 开关ID=1, 按钮=3, 继电器=3路, 延时=1000ms, 动作=打开
+```
+
+**示例3：海康门禁触发（使用输入端）**
+```
+海康门禁事件 → 继电器输出(按钮类型=输入端触发, 从站地址=10, 继电器=1路, 门禁ID=4)
+```
+
+**工作原理**：
+- 节点监听 `modbus:buttonPressed` 事件（按键触发）
+- 通过 `modbus:writeCoil` 事件发送控制命令到主站
+- 实现按键 → 继电器输出 → 主站之间的无连线通信
+
+**稳定性保障**：
+- 长期运行不卡顿、不死机、内存不溢出
+- 无调试数据输出，具备生产条件长期运行
+- 断电断网恢复后正常工作
+- 内置防抖和状态检测机制，不会出现设备反复开关进入死循环
+
 ## 输出消息格式
 
 ### 主站节点
@@ -888,7 +952,48 @@ HomeKit网桥节点无需输入消息，自动同步主站配置和状态。
 
 ## 版本信息
 
-**当前版本**: v2.9.6 (2025-12-20)
+**当前版本**: 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）
+  - 支持**绑定从站开关按键**，实现按键→继电器→主站之间**完全无需连线**
+  - 共享RS-485连接配置，支持多个节点共用同一连接
+  - 按键触发配置：面板品牌、按钮类型、开关ID(0-255)、按钮编号(1-8)、门禁ID(可选)
+  - 目标配置：从站地址、继电器路数、动作(打开/关闭/跟随/翻转)、延时(0-60000ms)
+  - 支持延时执行，一个按键控制多路继电器实现级联开灯
+  - 配置持久化保存，断电断网恢复后正常工作
+  - 长期稳定运行，不卡顿、不死机、内存不溢出，无调试数据输出
+- **界面优化**：所有SYMI MODBUS节点左侧名称改为中文显示
+- **重要修复**：HassOS串口兼容性问题
+  - 修复"Cannot lock port"错误：在所有串口连接中添加`lock: false`参数
+  - 修复位置：`serial-port-config.js`和`modbus-master.js`的串口连接配置
+  - 适用场景：HassOS、Docker容器、以及其他不支持串口锁定的环境
+- **功能改进**：串口配置界面优化
+  - Modbus服务器配置：串口路径改为输入框+搜索按钮，支持手动输入（搜索不到也能使用）
+  - 显示完整串口参数：数据位（7/8）、停止位（1/2）、校验位（无/偶/奇）
+  - 添加更多波特率选项：1200/2400/4800/9600/19200/38400/57600/115200
+- **稳定性保障**：
+  - 串口配置持久化保存到Node-RED配置文件
+  - 断电断网恢复后自动重连，正常工作
+  - 无调试数据输出，适合生产环境长期运行
 
 **v2.9.6 更新内容**：
 - **重要修复**：485开关场景按钮的CRC校验兼容性问题

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/custom-protocol.html

@@ -2,6 +2,7 @@
     RED.nodes.registerType('custom-protocol', {
         category: 'SYMI MODBUS',
         color: '#FF9800',
+        paletteLabel: "自定义协议",
         defaults: {
             name: {value: "自定义协议"},
             deviceType: {value: "switch", required: true},

package/nodes/homekit-bridge.html

@@ -2,6 +2,7 @@
     RED.nodes.registerType('homekit-bridge', {
         category: 'SYMI MODBUS',
         color: '#FF9800',
+        paletteLabel: "HomeKit网桥",
         defaults: {
             name: {value: "HomeKit网桥"},
             bridgeName: {value: "Modbus继电器网桥"},

package/nodes/modbus-dashboard.html

@@ -2,6 +2,7 @@
     RED.nodes.registerType('modbus-dashboard', {
         category: 'SYMI MODBUS',
         color: '#4CAF50',
+        paletteLabel: "控制看板",
         defaults: {
             name: {value: "Modbus控制看板"},
             masterNode: {value: "", required: true}

package/nodes/modbus-debug.html

@@ -2,6 +2,7 @@
     RED.nodes.registerType('modbus-debug', {
         category: 'SYMI MODBUS',
         color: '#C0DEED',
+        paletteLabel: "调试",
         defaults: {
             name: { value: '' },
             sourceType: { value: 'serial' }, // 仅支持 serial（避免串口冲突）

package/nodes/modbus-master.html

@@ -2,6 +2,7 @@
     RED.nodes.registerType('modbus-master', {
         category: 'SYMI MODBUS',
         color: '#3FADB5',
+        paletteLabel: "主站",
         defaults: {
             name: {value: "Modbus主站"},
             modbusServer: {value: "", type: "modbus-server-config", required: true},

package/nodes/modbus-master.js

@@ -275,7 +275,8 @@ module.exports = function(RED) {
                         baudRate: node.config.serialBaudRate || 9600,
                         dataBits: node.config.serialDataBits || 8,
                         stopBits: node.config.serialStopBits || 1,
-                        parity: node.config.serialParity || 'none'
+                        parity: node.config.serialParity || 'none',
+                        lock: false  // 禁用串口锁定，解决HassOS中"Cannot lock port"错误
                     });
                     
                     node.log(`串口Modbus连接成功: ${node.config.serialPort} @ ${node.config.serialBaudRate || 9600}bps`);