node-red-contrib-symi-mesh 1.3.1 → 1.6.1

package/nodes/symi-gateway.js

@@ -19,7 +19,7 @@ module.exports = function(RED) {
         this.baudRate = parseInt(config.baudRate) || 115200;
 
         this.client = null;
-        this.deviceManager = new DeviceManager(this.context(), this);
+        this.deviceManager = new DeviceManager(this.context(), this, this.id);
         this.protocolHandler = new ProtocolHandler();
         this.connected = false;
         this.deviceListComplete = false;
@@ -27,6 +27,7 @@ module.exports = function(RED) {
 
         // 状态事件处理队列 - 确保场景执行后的大量状态更新能被正确处理
         this.stateEventQueue = [];
+        this.maxQueueSize = 100; // 最大队列大小，防止内存泄漏
         this.isProcessingStateEvent = false;
         this.sceneExecutionInProgress = false;  // 场景执行中标志
         this.sceneExecutionTimer = null;  // 场景执行超时定时器
@@ -131,6 +132,11 @@ module.exports = function(RED) {
             // 清空队列
             this.stateEventQueue = [];
 
+            // 清理设备管理器资源
+            if (this.deviceManager) {
+                this.deviceManager.cleanup();
+            }
+
             done();
         });
     };
@@ -151,9 +157,15 @@ module.exports = function(RED) {
         if (frame.opcode === OP_RESP_DEVICE_LIST && frame.status === 0x00) {
             this.parseDeviceListFrame(frame);
         } else if (frame.isDeviceStatusEvent()) {
-            // 将状态事件加入队列处理
-            this.stateEventQueue.push(frame);
-            this.processStateEventQueue();
+            // 将状态事件加入队列处理，限制队列大小防止内存泄漏
+            if (this.stateEventQueue.length < this.maxQueueSize) {
+                this.stateEventQueue.push(frame);
+                this.processStateEventQueue();
+            } else {
+                this.debug(`状态事件队列已满(${this.maxQueueSize})，丢弃旧事件`);
+                this.stateEventQueue.shift(); // 移除最旧的事件
+                this.stateEventQueue.push(frame);
+            }
         } else if (frame.opcode === 0xB0) {
             // 控制命令响应
             this.debug(`[控制响应] 0xB0: ${frameHex} ${frame.status === 0 ? '(成功)' : '(失败)'}`)
@@ -214,12 +226,42 @@ module.exports = function(RED) {
                     this.debug(`${logPrefix} 地址=0x${event.networkAddress.toString(16).toUpperCase()}, 消息类型=0x${event.attrType.toString(16).toUpperCase()}, 参数=[${Array.from(event.parameters).map(p => '0x' + p.toString(16).toUpperCase()).join(', ')}]`);
                 }
 
+                // 获取更新前的三合一状态
+                const deviceBefore = this.deviceManager.getDeviceByAddress(event.networkAddress);
+                const wasThreeInOne = deviceBefore ? deviceBefore.isThreeInOne : false;
+
                 const device = this.deviceManager.updateDeviceState(
                     event.networkAddress,
                     event.attrType,
                     event.parameters
                 );
 
+                // 检测到新的三合一设备时记录日志
+                if (device && device.isThreeInOne && !wasThreeInOne) {
+                    const attrName = event.attrType === 0x68 ? '新风' : event.attrType === 0x6B ? '地暖' : '0x94';
+                    this.log(`[三合一检测] 收到 ${device.name} 的${attrName}响应 (0x${event.attrType.toString(16).toUpperCase()})，确认为三合一面板`);
+                }
+
+                // 检查是否是开关状态变化，且需要触发场景
+                if (device && event.attrType === 0x02 && !this.isQueryingStates && !this.sceneExecutionInProgress) {
+                    // 检查是否有按键状态变化
+                    if (device.lastChangedButtons && device.lastChangedButtons.length > 0) {
+                        for (const change of device.lastChangedButtons) {
+                            const sceneInfo = device.getButtonSceneId(change.button);
+                            if (sceneInfo) {
+                                this.log(`[按键场景] 检测到按键${change.button}(${sceneInfo.name})状态变化: ${change.oldState ? '开' : '关'} → ${change.newState ? '开' : '关'}, 触发场景${sceneInfo.sceneId}`);
+
+                                // 发送场景控制命令
+                                this.sendScene(sceneInfo.sceneId).then(() => {
+                                    this.log(`[按键场景] 场景${sceneInfo.sceneId}(${sceneInfo.name})控制命令已发送`);
+                                }).catch(err => {
+                                    this.error(`[按键场景] 场景${sceneInfo.sceneId}控制命令发送失败: ${err.message}`);
+                                });
+                            }
+                        }
+                    }
+                }
+
                 // 只在非查询状态期间才发送state-changed事件到MQTT
                 // 查询状态期间的事件只用于更新设备状态，不触发MQTT发布
                 if (device && !this.isQueryingStates) {
@@ -237,7 +279,8 @@ module.exports = function(RED) {
                     await new Promise(resolve => setImmediate(resolve));
                 }
             } catch (error) {
-                this.error(`Error parsing status event: ${error.message}`);
+                // 状态事件解析错误改为debug级别，避免干扰正常日志（通常是网络噪音或不完整数据包）
+                this.debug(`Error parsing status event: ${error.message}`);
             }
         }
 
@@ -265,24 +308,37 @@ module.exports = function(RED) {
         
         this.log(`Device ${index + 1}/${maxDevices}: ${device.name} @ 0x${networkAddress.toString(16).toUpperCase()}`);
         
-        // 对于温控器类型(0x0A)，需要通过查询0x94来判断是否是三合一
+        // 对于温控器类型(deviceType=10)，需要通过查询新风/地暖来判断是否是三合一
+        // 空调温控器和三合一都属于同一品类，只有通过主动查询才能区分
         if (deviceType === 10) {
-            device.needsThreeInOneCheck = true;
-            this.log(`温控器设备待检测，将通过0x94查询确认类型: ${device.name}`);
+            // 如果设备已经被确认为三合一或普通温控器，跳过检测
+            if (device.isThreeInOne) {
+                this.log(`[三合一检测] ${device.name} 已确认为三合一面板（从缓存恢复）`);
+            } else if (device.thermostatConfirmed) {
+                this.log(`[三合一检测] ${device.name} 已确认为普通温控器（从缓存恢复）`);
+            } else {
+                device.needsThreeInOneCheck = true;
+                this.log(`[三合一检测] 发现温控器类型设备: ${device.name}，将通过查询新风/地暖确认类型`);
+            }
         }
         
         if (index === maxDevices - 1) {
             this.log(`Device discovery complete: ${maxDevices} devices`);
-            
-            // 先查询设备状态，完成后再触发device-list-complete
+
+            // 立即标记设备列表完成，让设备在HA中可用
+            this.deviceListComplete = true;
+            this.emit('device-list-complete', this.deviceManager.getAllDevices());
+
+            // 在后台异步查询设备状态和确认三合一设备
             setTimeout(async () => {
-                this.isQueryingStates = true; // 开始查询状态
+                this.log('开始后台查询设备状态...');
+                this.isQueryingStates = true;
                 await this.queryAllDeviceStates();
-                this.isQueryingStates = false; // 查询完成
-                
-                this.deviceListComplete = true;
-                // 状态查询完成后才触发device-list-complete，确保设备类型已确认
-                this.emit('device-list-complete', this.deviceManager.getAllDevices());
+                this.isQueryingStates = false;
+                this.log('后台状态查询完成');
+
+                // 状态查询完成后，如果有设备类型变化（如三合一确认），重新发布MQTT Discovery
+                this.emit('device-states-synced', this.deviceManager.getAllDevices());
             }, 500);
         }
     };
@@ -296,9 +352,11 @@ module.exports = function(RED) {
                 let queryAttrs = [];
 
                 // 根据设备类型查询不同属性
-                if ([1, 2, 3].includes(device.deviceType)) {
-                    queryAttrs = [0x02]; // 开关状态
-                    this.log(`查询开关设备: ${device.name} (地址=0x${device.networkAddress.toString(16).toUpperCase()}, 路数=${device.channels})`);
+                if ([1, 2, 3, 39].includes(device.deviceType)) {
+                    // 6-8路开关使用0x45，1-4路使用0x02
+                    const msgType = (device.channels >= 6) ? 0x45 : 0x02;
+                    queryAttrs = [msgType];
+                    this.log(`查询开关设备: ${device.name} (地址=0x${device.networkAddress.toString(16).toUpperCase()}, 路数=${device.channels}, msgType=0x${msgType.toString(16).toUpperCase()})`);
                 } else if (device.deviceType === 9) {
                     queryAttrs = [0x02, 0x0E]; // 插卡取电：开关状态、插卡状态
                 } else if (device.deviceType === 4 || device.deviceType === 0x18) {
@@ -306,14 +364,16 @@ module.exports = function(RED) {
                 } else if (device.deviceType === 5) {
                     queryAttrs = [0x05, 0x06]; // 窗帘：运行状态、位置
                 } else if (device.deviceType === 10) {
-                    // 温控器类型：先查询三合一专用消息(0x68/0x6B)判断是否是三合一
+                    // 温控器类型：通过查询新风(0x68)和地暖(0x6B)来识别是否是三合一
+                    // 研发说明：空调温控器和三合一都是同一品类(deviceType=10)
+                    // 区分方法：主动查询新风/地暖状态，有反馈的是三合一，无反馈的是普通温控器
                     if (device.needsThreeInOneCheck) {
-                        this.log(`检测设备${device.name}是否为三合一面板...`);
-                        // 先查询0x68(新风开关)，如果有响应就是三合一
-                        queryAttrs = [0x68];
+                        this.log(`[三合一检测] 开始检测设备 ${device.name} (0x${device.networkAddress.toString(16).toUpperCase()})`);
+                        // 同时查询新风(0x68)和地暖(0x6B)，任意一个有响应就确认是三合一
+                        queryAttrs = [0x68, 0x6B];
                     } else if (device.isThreeInOne) {
                         // 已确认是三合一，查询完整状态
-                        queryAttrs = [0x16, 0x1B, 0x1C, 0x1D, 0x68, 0x6A, 0x6B, 0x6C];
+                        queryAttrs = [0x02, 0x16, 0x1B, 0x1C, 0x1D, 0x68, 0x6A, 0x6B, 0x6C];
                     } else {
                         // 普通温控器
                         queryAttrs = [0x02, 0x16, 0x1B, 0x1C, 0x1D];
@@ -328,25 +388,34 @@ module.exports = function(RED) {
                 
                 // 等待设备响应，检查是否被标记为三合一
                 if (device.needsThreeInOneCheck) {
-                    await this.sleep(800); // 增加到800ms确保响应到达
+                    // 等待1.5秒确保响应到达（网络延迟可能较大）
+                    await this.sleep(1500);
+                    
+                    // 处理状态事件队列，确保所有响应都被处理
+                    await this.processStateEventQueue();
+                    
                     if (device.isThreeInOne) {
-                        this.log(`设备${device.name}确认为三合一面板，继续查询完整状态`);
+                        this.log(`[三合一检测] ${device.name} 确认为三合一面板`);
                         device.needsThreeInOneCheck = false;
                         this.deviceManager.saveDevices();
                         
-                        // 查询三合一的其他状态
-                        const threeInOneAttrs = [0x02, 0x16, 0x1B, 0x1C, 0x1D, 0x6A, 0x6B, 0x6C];
+                        // 查询三合一的完整状态
+                        this.log(`[三合一检测] 查询 ${device.name} 完整状态...`);
+                        const threeInOneAttrs = [0x02, 0x16, 0x1B, 0x1C, 0x1D, 0x6A, 0x6C];
                         for (const attr of threeInOneAttrs) {
                             const frame = this.protocolHandler.buildDeviceStatusQueryFrame(device.networkAddress, attr);
                             await this.client.sendFrame(frame, 2);
                             await this.sleep(150);
                         }
                     } else {
-                        this.log(`设备${device.name}确认为普通温控器`);
+                        this.log(`[三合一检测] ${device.name} 确认为普通温控器`);
                         device.needsThreeInOneCheck = false;
-                        device.thermostatConfirmed = true; // 标记为已确认的温控器
+                        device.thermostatConfirmed = true;
                         this.deviceManager.saveDevices();
-                        
+
+                        // 触发温控器确认事件
+                        this.emit('thermostat-confirmed', device);
+
                         // 查询温控器状态
                         const tempCtrlAttrs = [0x02, 0x16, 0x1B, 0x1C, 0x1D];
                         for (const attr of tempCtrlAttrs) {
@@ -422,8 +491,18 @@ module.exports = function(RED) {
             try {
                 // 从设备管理器获取当前状态
                 const device = this.deviceManager.getDeviceByAddress(networkAddr);
+
+                // 根据路数选择正确的msgType
+                // 1-4路使用0x02 (TYPE_ON_OFF)
+                // 6-8路使用0x45 (VD_GROUP_MSG_TYPE_1_8_ON_OFF)
+                let actualMsgType = attrType;
+                if (channels >= 6) {
+                    actualMsgType = 0x45; // VD_GROUP_MSG_TYPE_1_8_ON_OFF
+                    this.debug(`[开关控制] 6-8路开关使用msgType=0x45`);
+                }
+
                 let currentState = null;
-                
+
                 if (device && typeof device.getCurrentSwitchState === 'function') {
                     currentState = device.getCurrentSwitchState();
                     this.debug(`使用缓存状态: 0x${currentState.toString(16).toUpperCase()}`);
@@ -433,37 +512,40 @@ module.exports = function(RED) {
                 } else {
                     // 如果没有当前状态，查询一次
                     this.debug(`查询开关状态: 地址0x${networkAddr.toString(16).toUpperCase()}`);
-                    const queryFrame = this.protocolHandler.buildDeviceStatusQueryFrame(networkAddr, 0x02);
+                    const queryFrame = this.protocolHandler.buildDeviceStatusQueryFrame(networkAddr, actualMsgType);
                     await this.client.sendFrame(queryFrame, 2);
                     await this.sleep(200);
-                    
+
                     if (device && typeof device.getCurrentSwitchState === 'function') {
                         currentState = device.getCurrentSwitchState();
                     } else {
                         // 使用默认全关状态
-                        const defaultStates = { 2: 0x05, 3: 0x15, 4: 0x55, 6: 0x5555 };
+                        const defaultStates = { 2: 0x05, 3: 0x15, 4: 0x55, 6: 0x5555, 8: 0x5555 };
                         currentState = defaultStates[channels] || 0x55;
                         this.debug(`使用默认状态: 0x${currentState.toString(16).toUpperCase()}`);
                     }
                 }
-                
+
                 // 使用状态组合算法
+                this.debug(`[开关控制] 路数=${channels}, 目标路=${targetChannel}, 目标状态=${targetState ? '开' : '关'}, 当前状态=0x${currentState ? currentState.toString(16).toUpperCase() : 'null'}`);
                 const stateValue = this.protocolHandler.buildSwitchState(channels, targetChannel, targetState, currentState);
 
                 let controlParam;
                 let stateValueHex;
                 if (Buffer.isBuffer(stateValue)) {
-                    // 6路开关，2字节状态
+                    // 6-8路开关，2字节状态
                     controlParam = stateValue;
                     stateValueHex = stateValue.toString('hex').toUpperCase();
+                    this.debug(`[开关控制] 生成2字节状态值: 0x${stateValueHex} (${Array.from(stateValue).map(b => '0x' + b.toString(16).toUpperCase()).join(', ')})`);
                 } else {
                     // 1-4路开关，1字节状态
                     controlParam = Buffer.from([stateValue]);
                     stateValueHex = stateValue.toString(16).toUpperCase();
+                    this.debug(`[开关控制] 生成1字节状态值: 0x${stateValueHex}`);
                 }
 
-                this.debug(`发送开关控制: 地址0x${networkAddr.toString(16).toUpperCase()}, 第${targetChannel}路${targetState ? '开' : '关'}, 状态值0x${stateValueHex}`);
-                const frame = this.protocolHandler.buildDeviceControlFrame(networkAddr, attrType, controlParam);
+                this.log(`[开关控制] ${device.name} 第${targetChannel}路${targetState ? '开' : '关'}`);
+                const frame = this.protocolHandler.buildDeviceControlFrame(networkAddr, actualMsgType, controlParam);
                 return await this.client.sendFrame(frame, 1);
                 
             } catch (error) {