node-red-contrib-symi-mesh 1.6.5 → 1.6.6

package/nodes/symi-485-config.js

@@ -126,7 +126,12 @@ module.exports = function(RED) {
                     });
 
                     node.client.on('error', (err) => {
-                        node.error(`RS485 TCP错误: ${err.message}`);
+                        // AggregateError特殊处理（Node.js 18+的IPv4/IPv6连接失败）
+                        if (err.name === 'AggregateError' || err.errors) {
+                            node.warn(`RS485 TCP连接失败: 无法连接到 ${node.host}:${node.port}`);
+                        } else {
+                            node.error(`RS485 TCP错误: ${err.message}`);
+                        }
                         node.emit('error', err);
                     });
 
@@ -146,7 +151,12 @@ module.exports = function(RED) {
                         }
                     });
 
-                    node.client.connect(node.port, node.host);
+                    // 使用try-catch包装connect，防止AggregateError导致崩溃
+                    try {
+                        node.client.connect(node.port, node.host);
+                    } catch (connectErr) {
+                        node.error(`RS485 TCP连接异常: ${connectErr.message}`);
+                    }
                 }
             } catch (err) {
                 node.error(`RS485连接失败: ${err.message}`);
@@ -168,7 +178,7 @@ module.exports = function(RED) {
             node.connected = false;
         };
 
-        // 处理接收数据（仅做帧解析，原始数据已在上层emit）
+        // 处理接收数据（支持Modbus RTU和杜亚协议）
         node.handleData = function(data) {
             node.receiveBuffer = Buffer.concat([node.receiveBuffer, data]);
             
@@ -178,8 +188,39 @@ module.exports = function(RED) {
                 node.warn('接收缓冲区溢出，已截断');
             }
             
-            // Modbus RTU最小帧长度为4字节
+            // 最小帧长度为4字节
             while (node.receiveBuffer.length >= 4) {
+                // ===== 杜亚协议检测 (55开头) =====
+                if (node.receiveBuffer[0] === 0x55 && node.receiveBuffer.length >= 7) {
+                    // 杜亚窗帘协议：55 [地址高] [地址低] 03 [数据] [CRC16低] [CRC16高]
+                    // 固定7字节（基本命令）或8字节（带百分比）
+                    const funcCode = node.receiveBuffer[3];
+                    let duyaLen = 7;
+                    if (funcCode === 0x03 && node.receiveBuffer.length >= 7) {
+                        const dataType = node.receiveBuffer[4];
+                        if (dataType === 0x04) {
+                            duyaLen = 8;  // 百分比命令多一个字节
+                        }
+                    }
+                    
+                    if (node.receiveBuffer.length >= duyaLen) {
+                        const frame = node.receiveBuffer.subarray(0, duyaLen);
+                        node.receiveBuffer = node.receiveBuffer.subarray(duyaLen);
+                        
+                        // 验证杜亚CRC16
+                        if (node.validateDuyaCRC(frame)) {
+                            node.emit('frame', frame);
+                        } else {
+                            node.debug(`杜亚CRC校验失败: ${frame.toString('hex').toUpperCase()}`);
+                            // CRC失败也尝试emit，让上层处理
+                            node.emit('frame', frame);
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                
+                // ===== 标准Modbus RTU协议 =====
                 const frameLen = node.getFrameLength(node.receiveBuffer);
                 if (frameLen === 0 || node.receiveBuffer.length < frameLen) break;
                 
@@ -191,6 +232,15 @@ module.exports = function(RED) {
                 }
             }
         };
+        
+        // 验证杜亚CRC16
+        node.validateDuyaCRC = function(frame) {
+            if (frame.length < 7) return false;
+            const data = frame.subarray(0, frame.length - 2);
+            const receivedCRC = frame.readUInt16LE(frame.length - 2);
+            const calculatedCRC = node.calculateCRC16(data);
+            return receivedCRC === calculatedCRC;
+        };
 
         // 获取帧长度
         node.getFrameLength = function(buffer) {

package/nodes/symi-device.js

@@ -171,13 +171,13 @@ module.exports = function(RED) {
                 command = { attrType: 0x04, param: Buffer.from([colorTemp]) };
                 
             } else if (msg.command === 'rgb' && typeof payload === 'object') {
-                // 五色调光：RGB+WW+CW，参数范围0-100（百分比）
-                const r = Math.max(0, Math.min(100, parseInt(payload.r || 0)));
-                const g = Math.max(0, Math.min(100, parseInt(payload.g || 0)));
-                const b = Math.max(0, Math.min(100, parseInt(payload.b || 0)));
-                const ww = Math.max(0, Math.min(100, parseInt(payload.ww || 0)));
-                const cw = Math.max(0, Math.min(100, parseInt(payload.cw || 0)));
-                command = { attrType: 0x11, param: Buffer.from([r, g, b, ww, cw]) };
+                // 五色调光：RGB+WW+CW，参数范围0-255
+                const r = Math.max(0, Math.min(255, parseInt(payload.r || 0)));
+                const g = Math.max(0, Math.min(255, parseInt(payload.g || 0)));
+                const b = Math.max(0, Math.min(255, parseInt(payload.b || 0)));
+                const ww = Math.max(0, Math.min(255, parseInt(payload.ww || 0)));
+                const cw = Math.max(0, Math.min(255, parseInt(payload.cw || 0)));
+                command = { attrType: 0x4C, param: Buffer.from([r, g, b, ww, cw]) };
                 
             } else if (typeof payload === 'boolean' || typeof payload === 'string') {
                 const value = typeof payload === 'boolean' ? payload : 

package/nodes/symi-gateway.js

@@ -7,6 +7,34 @@ const SerialClient = require('../lib/serial-client');
 const { DeviceManager } = require('../lib/device-manager');
 const { ProtocolHandler, parseStatusEvent, OP_RESP_DEVICE_LIST } = require('../lib/protocol');
 
+// 全局异常处理 - 防止AggregateError等网络错误导致Node-RED崩溃
+// 只在模块首次加载时设置一次
+if (!global._symiGatewayErrorHandlerSet) {
+    global._symiGatewayErrorHandlerSet = true;
+    
+    process.on('uncaughtException', (err) => {
+        // 只处理网络相关的错误，其他错误继续抛出
+        if (err.name === 'AggregateError' || 
+            (err.code && ['ECONNREFUSED', 'ECONNRESET', 'ETIMEDOUT', 'ENETUNREACH', 'EHOSTUNREACH'].includes(err.code))) {
+            console.error('[symi-gateway] 网络异常已捕获，避免崩溃:', err.message || err);
+            // 不重新抛出，防止崩溃
+        } else {
+            // 非网络错误，继续原有行为
+            throw err;
+        }
+    });
+    
+    process.on('unhandledRejection', (reason, promise) => {
+        // 检查是否是网络相关的Promise rejection
+        if (reason && (reason.name === 'AggregateError' || 
+            (reason.code && ['ECONNREFUSED', 'ECONNRESET', 'ETIMEDOUT', 'ENETUNREACH', 'EHOSTUNREACH'].includes(reason.code)))) {
+            console.error('[symi-gateway] 网络Promise rejection已捕获:', reason.message || reason);
+            // 不重新抛出，防止崩溃
+        }
+        // 其他rejection由Node-RED默认处理
+    });
+}
+
 module.exports = function(RED) {
     function SymiGatewayNode(config) {
         RED.nodes.createNode(this, config);
@@ -126,17 +154,22 @@ module.exports = function(RED) {
             this.parseDeviceListFrame(frame);
         } else if (frame.isDeviceStatusEvent()) {
             // 将状态事件加入队列处理，限制队列大小防止内存泄漏
+            // 同时记录接收时间，用于判断是否在0xB0之后
+            const frameWithTime = { frame, receiveTime: Date.now() };
             if (this.stateEventQueue.length < this.maxQueueSize) {
-                this.stateEventQueue.push(frame);
+                this.stateEventQueue.push(frameWithTime);
                 this.processStateEventQueue();
             } else {
                 this.debug(`状态事件队列已满(${this.maxQueueSize})，丢弃旧事件`);
                 this.stateEventQueue.shift(); // 移除最旧的事件
-                this.stateEventQueue.push(frame);
+                this.stateEventQueue.push(frameWithTime);
             }
         } else if (frame.opcode === 0xB0) {
-            // 控制命令响应
-            this.debug(`[控制响应] 0xB0: ${frameHex} ${frame.status === 0 ? '(成功)' : '(失败)'}`)
+            // 控制命令响应 - 记录时间戳，用于标记后续帧为用户控制
+            // 规则：53 B0 后面紧跟的第一个窗帘帧就是真实用户控制
+            // 注意：必须用时间戳而不是标记，因为队列中可能有旧帧等待处理
+            this.lastB0Time = Date.now();
+            this.log(`[控制响应] 0xB0: ${frameHex}，记录时间戳`)
         } else if (frame.opcode === 0xB4) {
             // 场景控制响应
             if (frame.status === 0) {
@@ -168,7 +201,9 @@ module.exports = function(RED) {
         this.isProcessingStateEvent = true;
 
         while (this.stateEventQueue.length > 0) {
-            const frame = this.stateEventQueue.shift();
+            const frameWithTime = this.stateEventQueue.shift();
+            const frame = frameWithTime.frame;
+            const receiveTime = frameWithTime.receiveTime;
 
             try {
                 const event = parseStatusEvent(frame);
@@ -233,12 +268,44 @@ module.exports = function(RED) {
                 // 只在非查询状态期间才发送state-changed事件到MQTT
                 // 查询状态期间的事件只用于更新设备状态，不触发MQTT发布
                 if (device && !this.isQueryingStates) {
+                    // 【兼容两种协议】判断用户控制：
+                    // 小程序协议: subOpcode=0x05 (NODE_ACK) = 设备确认执行命令
+                    // 米家协议: subOpcode=0x06 (NODE_STATUS) + status=0/1 = 用户操作
+                    // 
+                    // 米家协议特征：status=0(打开中)或status=1(关闭中)只会在用户操作时出现
+                    // 电机反馈通常是status=2(停止)或位置变化(attrType=0x06)
+                    const isCurtainEvent = (event.attrType === 0x05 || event.attrType === 0x06);
+                    let isUserControl = false;
+                    
+                    if (isCurtainEvent) {
+                        if (event.subOpcode === 0x05) {
+                            // NODE_ACK: 小程序协议，设备确认执行命令
+                            isUserControl = true;
+                        } else if (event.subOpcode === 0x06) {
+                            // NODE_STATUS: 米家协议
+                            if (event.attrType === 0x05) {
+                                // CURT_RUN_STATUS: 状态变化
+                                // status=0(打开中), status=1(关闭中), status=2(暂停) 都是用户控制
+                                const status = event.parameters && event.parameters.length > 0 ? event.parameters[0] : null;
+                                if (status === 0 || status === 1 || status === 2) {
+                                    isUserControl = true;
+                                }
+                            } else if (event.attrType === 0x06) {
+                                // CURT_RUN_PER_POS: 位置变化
+                                // 位置变化也需要同步，标记为用户控制
+                                isUserControl = true;
+                            }
+                        }
+                    }
+                    
                     this.emit('device-state-changed', {
                         device: device,
                         attrType: event.attrType,
                         parameters: event.parameters,
                         state: device.state,
-                        isSceneExecution: this.sceneExecutionInProgress  // 标记是否是场景执行导致的状态变化
+                        subOpcode: event.subOpcode,
+                        isUserControl: isUserControl,  // 0xB0后500ms内的第一个窗帘帧
+                        isSceneExecution: this.sceneExecutionInProgress
                     });
                 }
 
@@ -299,14 +366,19 @@ module.exports = function(RED) {
 
             // 在后台异步查询设备状态和确认三合一设备
             setTimeout(async () => {
-                this.log('开始后台查询设备状态...');
-                this.isQueryingStates = true;
-                await this.queryAllDeviceStates();
-                this.isQueryingStates = false;
-                this.log('后台状态查询完成');
-
-                // 状态查询完成后，如果有设备类型变化（如三合一确认），重新发布MQTT Discovery
-                this.emit('device-states-synced', this.deviceManager.getAllDevices());
+                try {
+                    this.log('开始后台查询设备状态...');
+                    this.isQueryingStates = true;
+                    await this.queryAllDeviceStates();
+                    this.isQueryingStates = false;
+                    this.log('后台状态查询完成');
+
+                    // 状态查询完成后，如果有设备类型变化（如三合一确认），重新发布MQTT Discovery
+                    this.emit('device-states-synced', this.deviceManager.getAllDevices());
+                } catch (err) {
+                    this.isQueryingStates = false;
+                    this.error(`后台查询设备状态失败: ${err.message}`);
+                }
             }, 500);
         }
     };

package/nodes/symi-mqtt.js

@@ -258,7 +258,7 @@ module.exports = function(RED) {
     SymiMQTTNode.prototype.publishAllDiscovery = function(devices, forceUpdate = false) {
         const node = this;
 
-        const supportedTypes = [1, 2, 3, 4, 5, 8, 9, 10, 0x18, 39];
+        const supportedTypes = [1, 2, 3, 4, 5, 8, 9, 10, 11, 0x18, 39];
 
         devices.forEach(device => {
             const macClean = device.macAddress.replace(/:/g, '').toLowerCase();
@@ -641,23 +641,24 @@ module.exports = function(RED) {
                 
             case 0x05:
                 // 窗帘运行状态反馈 (CURT_RUN_STATUS)
-                // 协议：0=空闲/到头, 1=打开中, 2=关闭中, 3=停止
-                if (state.curtainStatus !== undefined) {
-                    const curtainStates = { 0: 'stopped', 1: 'opening', 2: 'closing', 3: 'stopped' };
-                    const curtainState = curtainStates[state.curtainStatus] || 'stopped';
+                // 【兼容两种协议】：
+                // 米家协议: 0=打开中, 1=关闭中, 2=停止
+                // 小程序协议: 1=打开, 2=关闭, 3=停止
+                // 使用curtainAction（由device-manager解析）来发布状态
+                if (state.curtainAction !== undefined) {
                     publishes.push({
                         topic: `symi_mesh/${macClean}/cover/state`,
-                        payload: curtainState
+                        payload: state.curtainAction
                     });
-                    node.debug(`发布窗帘运行状态: ${curtainState} (原始值=${state.curtainStatus})`);
+                    node.debug(`发布窗帘运行状态: ${state.curtainAction} (原始值=${state.curtainStatus}, 协议=${state.curtainProtocol || 'unknown'})`);
                     
-                    // 到头(status=0)时也发布position，确保HA显示正确位置
-                    if (state.curtainStatus === 0 && state.curtainPosition !== undefined) {
+                    // 停止时也发布position，确保HA显示正确位置
+                    if (state.curtainAction === 'stopped' && state.curtainPosition !== undefined) {
                         publishes.push({
                             topic: `symi_mesh/${macClean}/cover/position`,
                             payload: state.curtainPosition.toString()
                         });
-                        node.debug(`窗帘到头，同时发布位置: ${state.curtainPosition}%`);
+                        node.debug(`窗帘停止，同时发布位置: ${state.curtainPosition}%`);
                     }
                 }
                 break;
@@ -672,14 +673,13 @@ module.exports = function(RED) {
                     node.debug(`发布窗帘位置: ${state.curtainPosition}%`);
                     
                     // 同时发布运行状态（确保HA正确显示）
-                    if (state.curtainStatus !== undefined) {
-                        const curtainStates = { 0: 'stopped', 1: 'opening', 2: 'closing', 3: 'stopped' };
-                        const curtainState = curtainStates[state.curtainStatus] || 'stopped';
+                    // 使用curtainAction（由device-manager解析，兼容米家和小程序协议）
+                    if (state.curtainAction !== undefined) {
                         publishes.push({
                             topic: `symi_mesh/${macClean}/cover/state`,
-                            payload: curtainState
+                            payload: state.curtainAction
                         });
-                        node.debug(`同时发布窗帘状态: ${curtainState}`);
+                        node.debug(`同时发布窗帘状态: ${state.curtainAction}`);
                     }
                 }
                 break;
@@ -1312,6 +1312,13 @@ module.exports = function(RED) {
             const action = actions[payload];
             if (action) {
                 commands.push({ attrType: 0x05, param: Buffer.from([action]) });
+                
+                // 发出窗帘控制事件，通知485桥用户的真实意图
+                this.emit('curtain-control', {
+                    mac: device.macAddress,
+                    action: payload  // 'OPEN', 'CLOSE', 'STOP'
+                });
+                this.debug(`[MQTT] 窗帘控制命令: ${payload}, MAC=${device.macAddress}`);
             }
             
         } else if (topic.includes('/position/set')) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-symi-mesh",
-  "version": "1.6.5",
+  "version": "1.6.6",
   "description": "Node-RED节点集合，用于通过TCP/串口连接Symi蓝牙Mesh网关，支持Home Assistant MQTT Discovery自动发现和云端数据同步",
   "main": "index.js",
   "scripts": {
@@ -39,7 +39,7 @@
   },
   "dependencies": {
     "axios": "^1.7.9",
-    "mqtt": "^5.3.0",
+    "mqtt": "^5.10.0",
     "serialport": "^12.0.0"
   },
   "engines": {