node-red-contrib-symi-mesh 1.2.3

package/lib/device-manager.js

@@ -0,0 +1,575 @@
+/**
+ * Device Manager - Simplified version
+ * Manages device information and MAC/address mapping
+ */
+
+const EventEmitter = require('events');
+
+const DEVICE_TYPE_NAMES = {
+    0: '未知设备', 1: '零火开关', 2: '单火开关', 3: '智能插座',
+    4: '双色调光灯', 5: '智能窗帘', 6: '情景面板', 7: '门磁传感器',
+    8: '人体感应', 9: '插卡取电', 10: '温控器', 11: '温湿度传感器',
+    12: '情景开关', 0x14: '透传丛机', 0x18: '五色调光灯', 0x94: '三合一面板'
+};
+
+class DeviceInfo {
+    constructor(data) {
+        this.macAddress = data.macAddress;
+        this.networkAddress = data.networkAddress;
+        this.deviceType = data.deviceType;
+        this.deviceSubType = data.deviceSubType || 1;
+        this.vendorId = data.vendorId || 0x01A8;
+        this.name = data.name || this.generateName();
+        this.channels = this.getChannelCount();
+        this.online = data.online !== undefined ? data.online : true;
+        this.state = {};
+        this.lastSeen = Date.now();
+        this.isThreeInOne = false;
+    }
+
+    generateName() {
+        const macClean = this.macAddress.replace(/:/g, '').toLowerCase();
+        const macSuffix = macClean.slice(-12);
+        
+        // 三合一设备也使用温控器名称，保持设备标识不变
+        const typeName = DEVICE_TYPE_NAMES[this.deviceType] || 'Device';
+        return `${typeName}_${macSuffix}`;
+    }
+
+    getChannelCount() {
+        if ([1, 2, 3, 9, 12].includes(this.deviceType)) {
+            return this.deviceSubType;
+        }
+        return 1;
+    }
+
+    getEntityType() {
+        // 如果设备被标记为三合一，返回three_in_one类型
+        if (this.isThreeInOne) {
+            return 'three_in_one';
+        }
+        
+        const typeMap = {
+            1: 'switch', 2: 'switch', 3: 'switch', 4: 'light',
+            5: 'cover', 6: 'scene', 7: 'binary_sensor', 8: 'binary_sensor',
+            9: 'switch', 10: 'climate', 11: 'sensor', 12: 'switch',
+            0x14: 'scene', 0x18: 'light'
+        };
+        return typeMap[this.deviceType] || 'switch';
+    }
+
+    getDisplayName() {
+        const entityType = this.getEntityType();
+        if (entityType === 'switch' && this.channels > 1) {
+            return `${this.name} (${this.channels}路)`;
+        }
+        return this.name;
+    }
+
+    setState(key, value) {
+        this.state[key] = value;
+        this.lastSeen = Date.now();
+    }
+
+    updateFromEvent(attrType, parameters) {
+        this.lastSeen = Date.now();
+        
+        switch (attrType) {
+            case 0x02:
+                // TYPE_ON_OFF - 开关状态（仅用于开关、灯光、温控器）
+                // 窗帘(type=5)不使用0x02，忽略此消息避免误操作
+                if (this.deviceType !== 5) {
+                    this.handleSwitchState(parameters);
+                }
+                break;
+            case 0x03:
+                if (parameters.length > 0) {
+                    this.state.brightness = parameters[0];
+                    this.state.switch = parameters[0] > 0;
+                }
+                break;
+            case 0x04:
+                if (parameters.length > 0) this.state.colorTemp = parameters[0];
+                break;
+            case 0x05:
+                // CURT_RUN_STATUS - 窗帘运行状态
+                // 0=到头/停止, 1=打开中, 2=关闭中, 3=停止
+                if (parameters.length > 0) {
+                    const newStatus = parameters[0];
+                    // 如果已经到头(status=0)，忽略后续的运行中状态(1或2)
+                    // 直到收到新的位置(0x06)或控制命令
+                    if (this.state.curtainStatus === 0 && (newStatus === 1 || newStatus === 2)) {
+                        // 窗帘已到头，忽略设备继续发送的运行状态
+                        return;
+                    }
+                    this.state.curtainStatus = newStatus;
+                }
+                break;
+            case 0x06:
+                // CURT_RUN_PER_POS - 窗帘位置
+                if (parameters.length > 0) {
+                    this.state.curtainPosition = parameters[0];
+                    // 位置变化时清除到头标记，允许接收新的运行状态
+                }
+                break;
+            case 0x0A:
+                if (parameters.length > 0) this.state.door = parameters[0] === 0x01;
+                break;
+            case 0x0C:
+                if (parameters.length > 0) this.state.motion = parameters[0] === 0x01;
+                break;
+            case 0x0E:
+                // CARD_DET_STATUS - 插卡状态（1字节）
+                if (parameters.length > 0) {
+                    const cardValue = parameters[0];
+                    this.state.cardInserted = (cardValue === 0x01 || cardValue === 0x1);
+                    this.state.switch = this.state.cardInserted;
+                    // 注意：0x80 06格式可能包含多个msg_type组合，这里只取第一个字节
+                }
+                break;
+            case 0x11:
+                if (parameters.length >= 5) {
+                    this.state.rgb = {
+                        r: parameters[0], g: parameters[1], b: parameters[2],
+                        ww: parameters[3], cw: parameters[4]
+                    };
+                }
+                break;
+            case 0x16:
+                // SENSOR_TEMP - 温度传感器（2字节小端序，温度*100）
+                // 用于温湿度传感器和温控器当前温度
+                if (parameters.length >= 2) {
+                    const tempRaw = parameters[0] | (parameters[1] << 8);
+                    const tempValue = tempRaw / 100.0;
+                    // 温控器使用currentTemp，温湿度传感器使用temperature
+                    if (this.deviceType === 10) {
+                        this.state.currentTemp = tempValue;
+                    } else if (this.deviceType === 11) {
+                        this.state.temperature = tempValue;
+                    } else {
+                        // 其他设备两个字段都设置
+                        this.state.currentTemp = tempValue;
+                        this.state.temperature = tempValue;
+                    }
+                }
+                break;
+            case 0x17:
+                // SENSOR_HUMI - 湿度传感器（1字节，0-100%）
+                if (parameters.length > 0) this.state.humidity = parameters[0];
+                break;
+            case 0x1B:
+                // 目标温度TMPC_TEMP：1字节，直接温度值（16-30°C）
+                if (parameters.length > 0) {
+                    const temp = parameters[0];
+                    if (temp >= 5 && temp <= 35) {
+                        this.state.targetTemp = temp;
+                        // 不推断开关状态，完全由0x02消息决定
+                    }
+                }
+                break;
+            case 0x1C:
+                // 风速设置（温控器和三合一空调都使用）
+                if (parameters.length > 0) {
+                    this.state.fanMode = parameters[0];
+                }
+                break;
+            case 0x1D:
+                // 模式设置（温控器和三合一空调都使用）
+                // 协议值：1=制冷, 2=制热, 3=送风, 4=除湿
+                if (parameters.length > 0) {
+                    this.state.climateMode = parameters[0];
+                    // 不推断开关状态，完全由0x02消息决定
+                }
+                break;
+            case 0x68:
+                // 新风开关 (0x02=开, 0x01=关, 空参数=查询无结果)
+                // 收到0x68响应说明这是三合一面板（温控器不会响应0x68）
+                if (parameters.length > 0) {
+                    // 首次收到0x68有效响应，标记为三合一
+                    if (!this.isThreeInOne && this.deviceType === 10) {
+                        this.isThreeInOne = true;
+                        this.needsThreeInOneCheck = false;
+                    }
+                    this.state.freshAirSwitch = parameters[0] === 0x02;
+                } else if (this.isThreeInOne) {
+                    this.state.freshAirSwitch = false;
+                }
+                break;
+            case 0x69:
+                // 新风模式 (0x00=送风, 0x01=排风)
+                if (this.isThreeInOne && parameters.length > 0) {
+                    this.state.freshAirMode = parameters[0];
+                }
+                break;
+            case 0x6A:
+                // 新风风速 (1=高, 2=中, 3=低, 4=自动, 空参数=查询无结果)
+                // 收到0x6A响应也可以确认是三合一
+                if (parameters.length > 0) {
+                    if (!this.isThreeInOne && this.deviceType === 10) {
+                        this.isThreeInOne = true;
+                        this.needsThreeInOneCheck = false;
+                    }
+                    this.state.freshAirSpeed = parameters[0];
+                } else if (this.isThreeInOne) {
+                    this.state.freshAirSpeed = 4;
+                }
+                break;
+            case 0x6B:
+                // 地暖开关 (0x02=开, 0x01=关, 空参数=查询无结果)
+                // 收到0x6B响应也可以确认是三合一
+                if (parameters.length > 0) {
+                    if (!this.isThreeInOne && this.deviceType === 10) {
+                        this.isThreeInOne = true;
+                        this.needsThreeInOneCheck = false;
+                    }
+                    this.state.floorHeatingSwitch = parameters[0] === 0x02;
+                } else if (this.isThreeInOne) {
+                    this.state.floorHeatingSwitch = false;
+                }
+                break;
+            case 0x6C:
+                // 地暖温度 (1字节，18-32°C, 空参数=查询无结果)
+                if (this.isThreeInOne && parameters.length > 0) {
+                    this.state.floorHeatingTemp = parameters[0];
+                    this.state.floorHeatingSwitch = true;
+                }
+                break;
+            case 0x94:
+                // 三合一设备状态（0x94是消息类型，不是设备类型）
+                // 收到0x94消息（带有效参数）说明这是三合一面板
+                if (parameters.length >= 8) {
+                    if (!this.isThreeInOne && this.deviceType === 10) {
+                        this.isThreeInOne = true;
+                        this.needsThreeInOneCheck = false;
+                    }
+                    // 参数格式: [byte0, byte1, byte2(子类型标识), byte3, byte4, byte5(子类型标识2), ...]
+                    // 新风: byte5=0x01
+                    // 地暖: byte5=0x81 
+                    // 空调: byte2=0x81/0xC1
+                    this.handleThreeInOneState(parameters);
+                }
+                break;
+        }
+    }
+
+    handleThreeInOneState(parameters) {
+        if (parameters.length < 8) return;
+
+        // 0x94消息结构（完整8字节）- 根据研发提供的结构体定义
+        // byte0: out_addr - 外机地址
+        // byte1: in_addr - 内机地址
+        // byte2: bit[0-2]=fan_level(空调风速), bit[3-5]=ctrl_mode(空调模式), bit6=resv, bit7=air_onoff(空调开关)
+        // byte3: air_temp - 空调温度 (16-30°C)
+        // byte4: room_temp - 室温
+        // byte5: bit0=floor_en(地暖存在), bit[1-6]=resv2, bit7=floor_onoff(地暖开关)
+        // byte6: floor_temp - 地暖温度 (18-32°C)
+        // byte7: bit[0-2]=fresh_fan(新风风速), bit[3-4]=fresh_mode(新风模式), bit5=fresh_en(新风存在), bit6=resv1, bit7=fresh_onoff(新风开关)
+        
+        const byte0 = parameters[0];  // 外机地址
+        const byte1 = parameters[1];  // 内机地址
+        const byte2 = parameters[2];  // 空调状态
+        const byte3 = parameters[3];  // 空调温度
+        const byte4 = parameters[4];  // 室温
+        const byte5 = parameters[5];  // 地暖状态
+        const byte6 = parameters[6];  // 地暖温度
+        const byte7 = parameters[7];  // 新风状态
+        
+        // ============ 空调状态解析 (byte2, byte3, byte4) ============
+        // byte2: bit7=空调开关
+        const acOn = (byte2 & 0x80) !== 0;
+        this.state.climateSwitch = acOn;
+        
+        // byte2: bit[3-5]=空调模式 (0=制冷, 1=制热, 2=通风, 3=除湿, 4=自动)
+        const ctrlMode = (byte2 >> 3) & 0x07;
+        const modeMap = { 0: 1, 1: 2, 2: 3, 3: 4, 4: 1 }; // 0=冷→1(cool), 1=热→2(heat), 2=通风→3(fan_only), 3=除湿→4(dry), 4=自动→1(cool)
+        if (modeMap[ctrlMode] !== undefined) {
+            this.state.climateMode = modeMap[ctrlMode];
+        }
+        
+        // byte2: bit[0-2]=空调风速 (协议值: 0=自动, 1=低, 2=中, 4=高)
+        const fanLevel = byte2 & 0x07;
+        this.state.fanMode = fanLevel;
+        
+        // byte3: 空调设定温度 (16-30°C)
+        if (byte3 >= 16 && byte3 <= 30) {
+            this.state.targetTemp = byte3;
+        }
+        
+        // byte4: 室温
+        if (byte4 >= 10 && byte4 <= 50) {
+            this.state.currentTemp = byte4;
+        }
+        
+        // ============ 地暖状态解析 (byte5, byte6) ============
+        // byte5: bit7=地暖开关, bit0=地暖存在
+        const floorHeatingOn = (byte5 & 0x80) !== 0;
+        const floorHeatingEn = (byte5 & 0x01) !== 0;
+        this.state.floorHeatingSwitch = floorHeatingOn;
+        
+        // byte6: 地暖温度 (18-32°C)
+        if (byte6 >= 18 && byte6 <= 32) {
+            this.state.floorHeatingTemp = byte6;
+        }
+        
+        // ============ 新风状态解析 (byte7) ============
+        // byte7: bit7=新风开关
+        const freshAirOn = (byte7 & 0x80) !== 0;
+        this.state.freshAirSwitch = freshAirOn;
+        
+        // byte7: bit5=新风存在
+        const freshAirEn = (byte7 & 0x20) !== 0;
+
+        // byte7: bit4=新风模式 (0=送风forward, 1=排风reverse)
+        const freshMode = (byte7 >> 4) & 0x01;
+        this.state.freshAirMode = freshMode;
+        
+        // byte7: bit[0-2]=新风风速 (协议值: 0=自动, 1=低, 2=中, 4=高)
+        const freshFan = byte7 & 0x07;
+        this.state.freshAirSpeed = freshFan;
+        
+    }
+
+    parseClimateMode(modeValue) {
+        // 根据协议：1=制冷, 2=制热, 3=送风, 4=除湿
+        const modes = {
+            0x14: 'cool', 0x15: 'cool', 0x16: 'cool', 0x17: 'cool',
+            0x18: 'cool', 0x19: 'cool', 0x1B: 'heat', 0x1C: 'heat',
+            0x1D: 'fan_only', 0x1E: 'fan_only', 0x1F: 'fan_only',
+            0x20: 'dry'
+        };
+        return modes[modeValue] || 'off';
+    }
+
+    handleSwitchState(parameters) {
+        if (parameters.length === 0) return;
+        
+        // 根据协议：TYPE_ON_OFF，每2位表示1路开关，b01=关，b10=开
+        // 1-4路开关：1字节
+        // 5-6路开关：2字节，小端序
+        
+        if (this.channels === 1) {
+            // 单路开关
+            const value = parameters[0];
+            this.state.switch = value === 0x02;
+        } else if (this.channels <= 4) {
+            // 1-4路开关：1字节，每2位表示1路
+            const value = parameters[0];
+            // 保存原始状态值供控制时使用
+            this.state.switchState = value;
+            for (let i = 0; i < this.channels; i++) {
+                const bitPos = i * 2;
+                const bitValue = (value >> bitPos) & 0x03;
+                if (bitValue === 0x01) {
+                    this.state[`switch_${i + 1}`] = false;
+                } else if (bitValue === 0x02) {
+                    this.state[`switch_${i + 1}`] = true;
+                }
+            }
+        } else if (this.channels === 6) {
+            // 6路开关：2字节，小端序
+            let value;
+            if (parameters.length >= 2) {
+                // 小端序：低字节在前
+                value = parameters[0] | (parameters[1] << 8);
+            } else {
+                // 兼容1字节情况，只处理前4路
+                value = parameters[0];
+            }
+            
+            // 保存原始状态值供控制时使用
+            this.state.switchState = value;
+            
+            // 处理所有6路
+            for (let i = 0; i < 6; i++) {
+                const bitPos = i * 2;
+                const bitValue = (value >> bitPos) & 0x03;
+                if (bitValue === 0x01) {
+                    this.state[`switch_${i + 1}`] = false;
+                } else if (bitValue === 0x02) {
+                    this.state[`switch_${i + 1}`] = true;
+                }
+            }
+        }
+    }
+    
+    // 获取当前开关状态值（用于控制时组合状态）
+    getCurrentSwitchState() {
+        if (this.channels === 1) {
+            return this.state.switch ? 0x02 : 0x01;
+        } else if (this.channels <= 4) {
+            let stateValue = 0;
+            for (let i = 0; i < this.channels; i++) {
+                const bitPos = i * 2;
+                const channelState = this.state[`switch_${i + 1}`];
+                const bitValue = (channelState === true) ? 0x02 : 0x01;
+                stateValue |= (bitValue << bitPos);
+            }
+            return stateValue;
+        } else if (this.channels === 6) {
+            let stateValue = 0;
+            for (let i = 0; i < 6; i++) {
+                const bitPos = i * 2;
+                const channelState = this.state[`switch_${i + 1}`];
+                const bitValue = (channelState === true) ? 0x02 : 0x01;
+                stateValue |= (bitValue << bitPos);
+            }
+            return stateValue;
+        }
+        return null;
+    }
+}
+
+class DeviceManager extends EventEmitter {
+    constructor(context, logger = console) {
+        super();
+        this.context = context;
+        this.logger = logger;
+        this.devices = new Map();
+        this.macToAddress = new Map();
+        this.addressToMac = new Map();
+        this.loadDevices();
+    }
+
+    loadDevices() {
+        try {
+            const saved = this.context.get('symi_devices') || {};
+            const macMap = this.context.get('symi_mac_map') || {};
+            const addrMap = this.context.get('symi_addr_map') || {};
+            
+            Object.entries(saved).forEach(([mac, data]) => {
+                const device = new DeviceInfo(data);
+                // 恢复三合一标记
+                if (data.isThreeInOne) {
+                    device.isThreeInOne = true;
+                }
+                this.devices.set(mac, device);
+            });
+            
+            this.macToAddress = new Map(Object.entries(macMap));
+            this.addressToMac = new Map(Object.entries(addrMap).map(([k, v]) => [parseInt(k), v]));
+            
+            this.logger.log(`Loaded ${this.devices.size} devices from storage`);
+        } catch (error) {
+            this.logger.error('Error loading devices:', error);
+        }
+    }
+
+    saveDevices() {
+        try {
+            const devicesObj = {};
+            this.devices.forEach((device, mac) => {
+                devicesObj[mac] = {
+                    macAddress: device.macAddress,
+                    networkAddress: device.networkAddress,
+                    deviceType: device.deviceType,
+                    deviceSubType: device.deviceSubType,
+                    vendorId: device.vendorId,
+                    name: device.name,
+                    channels: device.channels,
+                    online: device.online,
+                    isThreeInOne: device.isThreeInOne || false
+                };
+            });
+            
+            const macMapObj = Object.fromEntries(this.macToAddress);
+            const addrMapObj = Object.fromEntries(
+                Array.from(this.addressToMac.entries()).map(([k, v]) => [k.toString(), v])
+            );
+            
+            this.context.set('symi_devices', devicesObj);
+            this.context.set('symi_mac_map', macMapObj);
+            this.context.set('symi_addr_map', addrMapObj);
+        } catch (error) {
+            this.logger.error('Error saving devices:', error);
+        }
+    }
+
+    addOrUpdateDevice(deviceData) {
+        const mac = deviceData.macAddress;
+        const addr = deviceData.networkAddress;
+        
+        let device = this.devices.get(mac);
+        let isNew = false;
+        let nameChanged = false;
+        
+        if (!device) {
+            device = new DeviceInfo(deviceData);
+            this.devices.set(mac, device);
+            isNew = true;
+        } else {
+            const oldName = device.name;
+            if (device.networkAddress !== addr) {
+                this.logger.log(`Device ${mac} address changed: 0x${device.networkAddress.toString(16)} -> 0x${addr.toString(16)}`);
+                device.networkAddress = addr;
+            }
+            device.online = deviceData.online !== undefined ? deviceData.online : true;
+            device.lastSeen = Date.now();
+            
+            // 检查名称是否变化（如被标记为三合一）
+            if (device.name !== oldName) {
+                nameChanged = true;
+            }
+        }
+        
+        this.macToAddress.set(mac, addr);
+        this.addressToMac.set(addr, mac);
+        
+        this.saveDevices();
+        this.emit('device-updated', device, isNew || nameChanged);
+        
+        return device;
+    }
+
+    getDeviceByMac(mac) {
+        return this.devices.get(mac);
+    }
+
+    getDeviceByAddress(addr) {
+        const mac = this.addressToMac.get(addr);
+        return mac ? this.devices.get(mac) : null;
+    }
+
+    getAllDevices() {
+        return Array.from(this.devices.values());
+    }
+
+    getDeviceList() {
+        return this.getAllDevices().map(d => ({
+            mac: d.macAddress,
+            name: d.getDisplayName(),
+            type: d.getEntityType(),
+            channels: d.channels,
+            online: d.online,
+            deviceType: d.isThreeInOne ? 0x94 : d.deviceType,
+            isThreeInOne: d.isThreeInOne || false
+        }));
+    }
+
+    updateDeviceState(addr, attrType, parameters) {
+        let device = this.getDeviceByAddress(addr);
+        
+        if (device) {
+            device.updateFromEvent(attrType, parameters);
+            this.saveDevices();
+            
+            // 所有消息都触发state-changed（包括0x94）
+            // 0x94用于面板物理操作的状态同步
+            this.emit('state-changed', device, attrType, parameters);
+            
+            return device;
+        }
+        return null;
+    }
+
+    clearAll() {
+        this.devices.clear();
+        this.macToAddress.clear();
+        this.addressToMac.clear();
+        this.context.set('symi_devices', {});
+        this.context.set('symi_mac_map', {});
+        this.context.set('symi_addr_map', {});
+    }
+}
+
+module.exports = { DeviceManager, DeviceInfo, DEVICE_TYPE_NAMES };
+