node-red-contrib-symi-mesh 1.2.3

package/lib/protocol.js

@@ -0,0 +1,510 @@
+/**
+ * Symi Gateway Protocol Implementation
+ * Converted from Python to JavaScript
+ */
+
+const PROTOCOL_HEADER = 0x53;
+const MIN_FRAME_LENGTH = 4;
+
+// Operation codes
+const OP_READ_DEVICE_LIST = 0x12;
+const OP_DEVICE_CONTROL = 0x30;
+const OP_TRANSPARENT_CONTROL = 0x40;
+const OP_EVENT_NODE_STATUS = 0x80;
+const OP_EVENT_TRANSPARENT_MSG = 0xC0;
+const OP_RESP_DEVICE_LIST = 0x92;
+const OP_RESP_DEVICE_CONTROL = 0xB0;
+const OP_SCENE_CONTROL = 0x31;
+const OP_DEVICE_STATUS_QUERY = 0x32;
+
+class ProtocolFrame {
+    constructor(header, opcode, length, payload, checksum, status = null) {
+        this.header = header;
+        this.opcode = opcode;
+        this.length = length;
+        this.payload = payload;
+        this.checksum = checksum;
+        this.status = status;
+    }
+
+    isResponse() {
+        return this.opcode >= 0x81;
+    }
+
+    isEvent() {
+        return this.opcode === OP_EVENT_NODE_STATUS || 
+               this.opcode === OP_EVENT_TRANSPARENT_MSG ||
+               (this.opcode === 0x90 && [0x02, 0x03, 0x04, 0x05, 0x06].includes(this.status));
+    }
+
+    isDeviceStatusEvent() {
+        return this.opcode === OP_EVENT_NODE_STATUS;
+    }
+
+    isTransparentEvent() {
+        return this.opcode === OP_EVENT_TRANSPARENT_MSG;
+    }
+}
+
+class ProtocolHandler {
+    constructor() {
+        this.buffer = Buffer.alloc(0);
+        this.lastDataTime = 0;
+        this.bufferTimeout = 10000; // 10 seconds
+    }
+
+    /**
+     * 构建开关状态值
+     * @param {number} channels - 开关路数 (1-6)
+     * @param {number} targetChannel - 目标路数 (1-6)
+     * @param {boolean} targetState - 目标状态 (true=开, false=关)
+     * @param {number|null} currentState - 当前状态值，null时使用默认全关状态
+     * @returns {number|Buffer} - 1-4路返回number，6路返回Buffer(2字节)
+     */
+    buildSwitchState(channels, targetChannel, targetState, currentState = null) {
+        // 验证参数
+        if (channels < 1 || channels > 6) {
+            throw new Error(`Invalid channels count: ${channels}, must be 1-6`);
+        }
+        if (targetChannel < 1 || targetChannel > channels) {
+            throw new Error(`Invalid target channel: ${targetChannel}, must be 1-${channels}`);
+        }
+
+        // 单路开关直接返回状态
+        if (channels === 1) {
+            return targetState ? 0x02 : 0x01;
+        }
+
+        // 多路开关状态组合
+        let stateValue;
+        
+        if (channels <= 4) {
+            // 1-4路开关使用1字节，默认全关状态
+            const defaultStates = {
+                2: 0x05, // 01 01 (2路全关)
+                3: 0x15, // 01 01 01 (3路全关)  
+                4: 0x55  // 01 01 01 01 (4路全关)
+            };
+            stateValue = currentState !== null ? currentState : defaultStates[channels];
+            
+            // 计算目标路的位位置 (每路2位)
+            const bitPos = (targetChannel - 1) * 2;
+            const mask = ~(0x03 << bitPos); // 清除目标位
+            const newBits = (targetState ? 0x02 : 0x01) << bitPos; // 新状态位
+            
+            stateValue = (stateValue & mask) | newBits;
+            return stateValue;
+        } else if (channels === 6) {
+            // 6路开关，2字节状态，小端序
+            const defaultState = 0x5555; // 全关状态
+            stateValue = currentState !== null ? currentState : defaultState;
+            
+            // 6路开关状态组合
+            const bitPos = (targetChannel - 1) * 2;
+            const mask = ~(0x03 << bitPos);
+            const newBits = (targetState ? 0x02 : 0x01) << bitPos;
+            
+            stateValue = (stateValue & mask) | newBits;
+            
+            // 返回小端序Buffer
+            return Buffer.from([stateValue & 0xFF, (stateValue >> 8) & 0xFF]);
+        }
+    }
+
+    /**
+     * 解析开关状态值
+     * @param {number|Buffer} stateValue - 状态值
+     * @param {number} channels - 开关路数
+     * @returns {Array<boolean>} - 每路的开关状态数组
+     */
+    parseSwitchState(stateValue, channels) {
+        let value;
+        if (Buffer.isBuffer(stateValue)) {
+            // 6路开关，小端序解析
+            value = stateValue[0] | (stateValue[1] << 8);
+        } else {
+            value = stateValue;
+        }
+
+        const states = [];
+        for (let i = 0; i < channels; i++) {
+            const bitPos = i * 2;
+            const bits = (value >> bitPos) & 0x03;
+            states.push(bits === 0x02); // 0x02=开, 0x01=关
+        }
+        return states;
+    }
+
+    calculateChecksum(data) {
+        let checksum = 0;
+        for (let i = 0; i < data.length; i++) {
+            checksum ^= data[i];
+        }
+        return checksum & 0xFF;
+    }
+
+    buildFrame(opcode, data = Buffer.alloc(0)) {
+        const header = PROTOCOL_HEADER;
+        const length = data.length;
+        
+        // Build frame without checksum
+        const frameWithoutChecksum = Buffer.concat([
+            Buffer.from([header, opcode, length]),
+            data
+        ]);
+        
+        // Calculate checksum
+        const checksum = this.calculateChecksum(frameWithoutChecksum);
+        
+        // Build complete frame
+        return Buffer.concat([frameWithoutChecksum, Buffer.from([checksum])]);
+    }
+
+    parseFrame(data) {
+        if (data.length < MIN_FRAME_LENGTH) {
+            return null;
+        }
+
+        const header = data[0];
+        if (header !== PROTOCOL_HEADER) {
+            return null;
+        }
+
+        const opcode = data[1];
+
+        // 0x80事件和响应都使用响应格式：53 [opcode] [status/sub_opcode] [length] [data] [checksum]
+        if (opcode >= 0x80) {
+            if (data.length < 5) {
+                return null;
+            }
+
+            const status = data[2];
+            const paramLength = data[3];
+            const expectedLength = 5 + paramLength;
+
+            if (data.length !== expectedLength) {
+                return null;
+            }
+
+            const payload = data.slice(4, 4 + paramLength);
+            const checksum = data[4 + paramLength];
+
+            // Verify checksum
+            const calculatedChecksum = this.calculateChecksum(data.slice(0, -1));
+            if (checksum !== calculatedChecksum) {
+                return null;
+            }
+
+            return new ProtocolFrame(header, opcode, paramLength, payload, checksum, status);
+        } else { // Send format
+            const paramLength = data[2];
+            const expectedLength = 4 + paramLength;
+            
+            if (data.length !== expectedLength) {
+                return null;
+            }
+
+            const payload = data.slice(3, 3 + paramLength);
+            const checksum = data[3 + paramLength];
+
+            const calculatedChecksum = this.calculateChecksum(data.slice(0, -1));
+            if (checksum !== calculatedChecksum) {
+                return null;
+            }
+
+            return new ProtocolFrame(header, opcode, paramLength, payload, checksum);
+        }
+    }
+
+    addData(data) {
+        const currentTime = Date.now();
+
+        // Check buffer timeout
+        if (this.buffer.length > 0 && (currentTime - this.lastDataTime) > this.bufferTimeout) {
+            this.buffer = Buffer.alloc(0);
+        }
+
+        this.buffer = Buffer.concat([this.buffer, data]);
+        this.lastDataTime = currentTime;
+        const frames = [];
+
+        while (this.buffer.length >= MIN_FRAME_LENGTH) {
+            // Look for frame header
+            let headerIndex = -1;
+            for (let i = 0; i < this.buffer.length; i++) {
+                if (this.buffer[i] === PROTOCOL_HEADER) {
+                    headerIndex = i;
+                    break;
+                }
+            }
+
+            if (headerIndex === -1) {
+                if (this.buffer.length > 2) {
+                    this.buffer = this.buffer.slice(-2);
+                } else {
+                    this.buffer = Buffer.alloc(0);
+                }
+                break;
+            }
+
+            if (headerIndex > 0) {
+                this.buffer = this.buffer.slice(headerIndex);
+            }
+
+            if (this.buffer.length < 3) {
+                break;
+            }
+
+            const opcode = this.buffer[1];
+            let totalFrameLength;
+
+            // 0x80和0xC0事件使用响应格式（5字节头部）
+            // 0x81及以上的响应也使用响应格式（5字节头部）
+            if (opcode >= 0x80) {
+                if (this.buffer.length < 4) {
+                    break;
+                }
+                const paramLength = this.buffer[3];
+                totalFrameLength = 5 + paramLength;
+            } else {
+                // 发送格式（4字节头部）
+                const paramLength = this.buffer[2];
+                totalFrameLength = 4 + paramLength;
+            }
+
+            if (totalFrameLength > 1024) {
+                this.buffer = this.buffer.slice(1);
+                continue;
+            }
+
+            if (this.buffer.length < totalFrameLength) {
+                break;
+            }
+
+            const frameData = this.buffer.slice(0, totalFrameLength);
+            const frame = this.parseFrame(frameData);
+            
+            if (frame) {
+                frames.push(frame);
+            }
+
+            this.buffer = this.buffer.slice(totalFrameLength);
+        }
+
+        return frames;
+    }
+
+    clearBuffer() {
+        this.buffer = Buffer.alloc(0);
+    }
+
+    buildReadDeviceListFrame() {
+        return this.buildFrame(OP_READ_DEVICE_LIST);
+    }
+
+    buildDeviceControlFrame(networkAddr, attrType, param = Buffer.alloc(0)) {
+        // 地址使用小端序（低字节在前）
+        const addrLow = networkAddr & 0xFF;
+        const addrHigh = (networkAddr >> 8) & 0xFF;
+        
+        let data;
+        
+        if (attrType === 0x02) { // Switch control
+            // 开关控制需要正确的状态组合
+            // param格式: [channels, targetChannel, targetState, currentState(可选)]
+            // 或者直接传入计算好的状态值: [stateValue] 或 [stateLow, stateHigh]
+            
+            if (param.length >= 3 && param[0] <= 6 && param[1] <= 6 && (param[2] === 0 || param[2] === 1)) {
+                // 使用状态组合算法 - 检查前3个参数是否符合状态组合格式
+                const channels = param[0];
+                const targetChannel = param[1]; 
+                const targetState = param[2] === 1;
+                const currentState = param.length > 3 ? param[3] : null;
+                
+                const stateValue = this.buildSwitchState(channels, targetChannel, targetState, currentState);
+                
+                if (Buffer.isBuffer(stateValue)) {
+                    // 6路开关，2字节状态
+                    data = Buffer.from([addrLow, addrHigh, 0x02, stateValue[0], stateValue[1]]);
+                } else {
+                    // 1-4路开关，1字节状态
+                    data = Buffer.from([addrLow, addrHigh, 0x02, stateValue]);
+                }
+            } else if (param.length === 2) {
+                // 6路开关直接状态值 (2字节)
+                data = Buffer.from([addrLow, addrHigh, 0x02, param[0], param[1]]);
+            } else {
+                // 1-4路开关直接状态值 (1字节)
+                const stateValue = param.length > 0 ? param[0] : 0x01;
+                data = Buffer.from([addrLow, addrHigh, 0x02, stateValue]);
+            }
+        } else if (attrType === 0x03 || attrType === 0x04) { // Brightness/Color temp
+            // 亮度和色温控制，参数范围0-100
+            const value = param.length > 0 ? Math.max(0, Math.min(100, param[0])) : 0;
+            data = Buffer.from([addrLow, addrHigh, attrType, value]);
+        } else if (attrType === 0x05) { // Curtain action
+            // 窗帘动作控制: 1=打开, 2=关闭, 3=停止
+            const action = param.length > 0 ? Math.max(1, Math.min(3, param[0])) : 1;
+            data = Buffer.from([addrLow, addrHigh, 0x05, action]);
+        } else if (attrType === 0x06) { // Curtain position
+            // 窗帘位置控制: 0-100百分比, 0xFF=未知
+            const position = param.length > 0 ? Math.max(0, Math.min(100, param[0])) : 0;
+            data = Buffer.from([addrLow, addrHigh, 0x06, position]);
+        } else if (attrType === 0x4C) { // RGB control (五色调光)
+            // 根据HA集成验证：五色调光RGB控制使用0x4C，5字节数据 [R, G, B, WW, CW]
+            // RGB范围0-255，WW和CW范围0-255
+            if (param.length >= 5) {
+                const rgbData = Buffer.from([
+                    Math.max(0, Math.min(255, param[0])),  // R: 0-255
+                    Math.max(0, Math.min(255, param[1])),  // G: 0-255
+                    Math.max(0, Math.min(255, param[2])),  // B: 0-255
+                    Math.max(0, Math.min(255, param[3])),  // WW: 0-255
+                    Math.max(0, Math.min(255, param[4]))   // CW: 0-255
+                ]);
+                data = Buffer.concat([Buffer.from([addrLow, addrHigh, 0x4C]), rgbData]);
+            } else if (param.length >= 3) {
+                // 只有RGB，没有WW和CW
+                const rgbData = Buffer.from([
+                    Math.max(0, Math.min(255, param[0])),
+                    Math.max(0, Math.min(255, param[1])),
+                    Math.max(0, Math.min(255, param[2])),
+                    0,  // WW默认0
+                    0   // CW默认0
+                ]);
+                data = Buffer.concat([Buffer.from([addrLow, addrHigh, 0x4C]), rgbData]);
+            } else {
+                data = Buffer.concat([Buffer.from([addrLow, addrHigh, 0x4C]), Buffer.from([0, 0, 0, 0, 0])]);
+            }
+        } else if (attrType === 0x1B) { // Climate temp (TMPC_TEMP)
+            // 根据协议文档3.5.1.12：1Byte 设置温度（16-30°C）
+            // 注意：这是直接温度值，不是温度*100！
+            const temp = param.length > 0 ? Math.max(16, Math.min(30, param[0])) : 20;
+            data = Buffer.from([addrLow, addrHigh, attrType, temp]);
+        } else if (attrType === 0x1C) { // Climate fan
+            const fanSpeed = param.length > 0 ? Math.max(1, Math.min(4, param[0])) : 1;
+            data = Buffer.from([addrLow, addrHigh, attrType, fanSpeed]);
+        } else if (attrType === 0x1D) { // Climate mode
+            const mode = param.length > 0 ? Math.max(1, Math.min(4, param[0])) : 1;
+            data = Buffer.from([addrLow, addrHigh, attrType, mode]);
+        } else if (attrType === 0x94) { // 三合一设备控制
+            // param格式: [subType, command, value]
+            // subType: 1=空调, 2=新风, 3=地暖
+            // command: 控制类型（开关、温度、模式等）
+            if (param.length >= 3) {
+                const subType = param[0];
+                const command = param[1];
+                const value = param[2];
+                
+                // 构建三合一控制数据包
+                // 这里需要根据实际设备协议调整
+                const controlData = Buffer.from([subType, command, value]);
+                data = Buffer.concat([Buffer.from([addrLow, addrHigh, attrType]), controlData]);
+            } else {
+                data = Buffer.concat([Buffer.from([addrLow, addrHigh, attrType]), param]);
+            }
+        } else {
+            data = Buffer.concat([Buffer.from([addrLow, addrHigh, attrType]), param]);
+        }
+        
+        return this.buildFrame(OP_DEVICE_CONTROL, data);
+    }
+
+    buildSceneControlFrame(sceneId) {
+        return this.buildFrame(OP_SCENE_CONTROL, Buffer.from([sceneId]));
+    }
+
+    buildDeviceStatusQueryFrame(networkAddr, msgType = 0x00) {
+        // 地址使用小端序（低字节在前）
+        const addrLow = networkAddr & 0xFF;
+        const addrHigh = (networkAddr >> 8) & 0xFF;
+        
+        if (msgType === 0x00) {
+            return this.buildFrame(OP_DEVICE_STATUS_QUERY, Buffer.from([addrLow, addrHigh]));
+        } else {
+            return this.buildFrame(OP_DEVICE_STATUS_QUERY, Buffer.from([addrLow, addrHigh, msgType]));
+        }
+    }
+
+    /**
+     * 构建开关控制帧（便捷方法）
+     * @param {number} networkAddr - 网络地址
+     * @param {number} channels - 开关路数 (1-6)
+     * @param {number} targetChannel - 目标路数 (1-6)
+     * @param {boolean} targetState - 目标状态 (true=开, false=关)
+     * @param {number|null} currentState - 当前状态值，null时需要先查询
+     * @returns {Buffer} - 控制帧数据
+     */
+    buildSwitchControlFrame(networkAddr, channels, targetChannel, targetState, currentState = null) {
+        const param = Buffer.from([channels, targetChannel, targetState ? 1 : 0]);
+        if (currentState !== null) {
+            const paramWithState = Buffer.concat([param, Buffer.from([currentState])]);
+            return this.buildDeviceControlFrame(networkAddr, 0x02, paramWithState);
+        } else {
+            return this.buildDeviceControlFrame(networkAddr, 0x02, param);
+        }
+    }
+}
+
+function parseStatusEvent(frame) {
+    if (!frame.isEvent() || frame.opcode !== OP_EVENT_NODE_STATUS) {
+        throw new Error('Not a status event frame');
+    }
+
+    if (frame.payload.length < 3) {
+        throw new Error('Status event payload too short');
+    }
+
+    // 0x80事件格式: 53 80 [status/sub_opcode] [length] [payload] [checksum]
+    // payload部分: [addr_low] [addr_high] [msg_type] [data...]
+    // 地址使用小端序（低字节在前）
+    // 
+    // 例: 53 80 05 04 9A 01 02 15 5E
+    //     opcode=80, status=05(sub_opcode), length=04
+    //     payload=[9A 01 02 15]（4字节）
+    //     9A 01=地址(小端序)=0x019A, 02=消息类型, 15=参数
+    const addrLow = frame.payload[0];
+    const addrHigh = frame.payload[1];
+    const networkAddress = addrLow | (addrHigh << 8);
+    const attrType = frame.payload[2];
+    const parameters = frame.payload.length > 3 ? frame.payload.slice(3) : Buffer.alloc(0);
+
+    return {
+        networkAddress,
+        attrType,
+        parameters,
+        subOpcode: frame.status
+    };
+}
+
+function parseTransparentEvent(frame) {
+    if (!frame.isEvent() || frame.opcode !== OP_EVENT_TRANSPARENT_MSG) {
+        throw new Error('Not a transparent event frame');
+    }
+
+    if (frame.payload.length < 2) {
+        throw new Error('Transparent event payload too short');
+    }
+
+    const networkAddress = (frame.payload[0] << 8) | frame.payload[1];
+    const transparentData = frame.payload.length > 2 ? frame.payload.slice(2) : Buffer.alloc(0);
+
+    return {
+        networkAddress,
+        transparentData
+    };
+}
+
+module.exports = {
+    ProtocolHandler,
+    ProtocolFrame,
+    parseStatusEvent,
+    parseTransparentEvent,
+    PROTOCOL_HEADER,
+    OP_READ_DEVICE_LIST,
+    OP_DEVICE_CONTROL,
+    OP_EVENT_NODE_STATUS,
+    OP_RESP_DEVICE_LIST,
+    OP_SCENE_CONTROL,
+    OP_DEVICE_STATUS_QUERY
+};
+