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

package/nodes/symi-485-config.js

@@ -6,6 +6,37 @@
 const { SerialPort } = require('serialport');
 const net = require('net');
 
+// 全局禁用 Happy Eyeballs 算法，防止 AggregateError 导致 Node-RED 崩溃
+// 这会影响所有使用 net.Socket 的模块（包括第三方模块如 KNX Ultimate）
+if (typeof net.setDefaultAutoSelectFamily === 'function') {
+    net.setDefaultAutoSelectFamily(false);
+}
+
+// 全局未捕获异常处理 - 防止网络错误导致 Node-RED 崩溃
+if (!global._symiErrorHandlerInstalled) {
+    global._symiErrorHandlerInstalled = true;
+    
+    process.on('uncaughtException', (err) => {
+        // 网络相关错误不崩溃
+        const netErrors = ['ECONNREFUSED', 'ECONNRESET', 'ETIMEDOUT', 'ENETUNREACH', 'EHOSTUNREACH', 'ENOTFOUND'];
+        if (err && err.code && netErrors.includes(err.code)) {
+            console.error('[symi] 网络错误已捕获，继续运行:', err.message);
+            return; // 不崩溃
+        }
+        // AggregateError
+        if (err && (err.name === 'AggregateError' || (err.errors && Array.isArray(err.errors)))) {
+            console.error('[symi] AggregateError已捕获:', err.message);
+            return; // 不崩溃
+        }
+        // 其他错误打印但不崩溃（保护Node-RED）
+        console.error('[symi] 未捕获异常:', err);
+    });
+    
+    process.on('unhandledRejection', (reason) => {
+        console.error('[symi] Promise rejection:', reason?.message || reason);
+    });
+}
+
 module.exports = function(RED) {
     
     function SymiRS485ConfigNode(config) {
@@ -114,7 +145,7 @@ module.exports = function(RED) {
 
                     node.client.on('connect', () => {
                         node.connected = true;
-                        node.warn(`[RS485] TCP已连接: ${node.host}:${node.port}`);
+                        node.log(`[RS485] TCP已连接: ${node.host}:${node.port}`);
                         node.emit('connected');
                     });
 
@@ -126,7 +157,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 +182,16 @@ module.exports = function(RED) {
                         }
                     });
 
-                    node.client.connect(node.port, node.host);
+                    // 使用family:4强制IPv4，避免Node.js 18+ Happy Eyeballs导致AggregateError
+                    try {
+                        node.client.connect({
+                            port: node.port,
+                            host: node.host,
+                            family: 4  // 强制IPv4，避免IPv6连接失败导致AggregateError
+                        });
+                    } catch (connectErr) {
+                        node.error(`RS485 TCP连接异常: ${connectErr.message}`);
+                    }
                 }
             } catch (err) {
                 node.error(`RS485连接失败: ${err.message}`);
@@ -168,7 +213,7 @@ module.exports = function(RED) {
             node.connected = false;
         };
 
-        // 处理接收数据（仅做帧解析，原始数据已在上层emit）
+        // 处理接收数据（支持Modbus RTU和杜亚协议）
         node.handleData = function(data) {
             node.receiveBuffer = Buffer.concat([node.receiveBuffer, data]);
             
@@ -178,8 +223,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 +267,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

@@ -2,11 +2,39 @@
  * Symi Gateway Configuration Node
  */
 
+const net = require('net');
 const TCPClient = require('../lib/tcp-client');
 const SerialClient = require('../lib/serial-client');
 const { DeviceManager } = require('../lib/device-manager');
 const { ProtocolHandler, parseStatusEvent, OP_RESP_DEVICE_LIST } = require('../lib/protocol');
 
+// 全局禁用 Happy Eyeballs 算法
+if (typeof net.setDefaultAutoSelectFamily === 'function') {
+    net.setDefaultAutoSelectFamily(false);
+}
+
+// 全局未捕获异常处理 - 防止网络错误导致 Node-RED 崩溃
+if (!global._symiErrorHandlerInstalled) {
+    global._symiErrorHandlerInstalled = true;
+    
+    process.on('uncaughtException', (err) => {
+        const netErrors = ['ECONNREFUSED', 'ECONNRESET', 'ETIMEDOUT', 'ENETUNREACH', 'EHOSTUNREACH', 'ENOTFOUND', 'EADDRNOTAVAIL'];
+        if (err && err.code && netErrors.includes(err.code)) {
+            console.error('[symi] 网络错误已捕获，继续运行:', err.message);
+            return;
+        }
+        if (err && (err.name === 'AggregateError' || (err.errors && Array.isArray(err.errors)))) {
+            console.error('[symi] AggregateError已捕获:', err.message);
+            return;
+        }
+        console.error('[symi] 未捕获异常:', err);
+    });
+    
+    process.on('unhandledRejection', (reason) => {
+        console.error('[symi] Promise rejection:', reason?.message || reason);
+    });
+}
+
 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);
         }
     };