node-red-contrib-symi-mesh 1.7.0 → 1.7.1

package/README.md

@@ -382,6 +382,7 @@ npm install node-red-contrib-home-assistant-websocket
 - 支持与HA中任意实体同步
 - 配置灵活，易于调整
 
+
 ## 协议说明
 
 ### 核心协议格式
@@ -1254,6 +1255,30 @@ node-red-contrib-symi-mesh/
 
 ## 更新日志
 
+### v1.7.1 (2025-12-21)
+- **自定义协议全面修复**：完善自定义开关/窗帘/空调双向同步
+  - **空调风速控制**：修复风速变化事件触发机制
+    - 添加fanMode字段支持（mesh空调实际使用的字段）
+    - 修复DeviceInfo事件触发，正确发送device-state-changed事件
+    - 支持风速值1-4（1=高, 2=中, 3=低, 4=自动）
+    - 自动识别温控器0x02消息中的风速控制
+  - **空调开关控制**：修复开关状态变化事件触发
+    - 温控器0x02开关消息正确触发device-state-changed事件
+    - 自定义空调开关码（acSendOn/acSendOff）正确发送到RS485总线
+  - **RS485收码匹配**：修复hexStr格式处理
+    - hexStr完全去掉空格，确保标准格式（如030610330001BD27）
+    - 用户录入支持带空格格式（如01 06 10 34 00 01 0D 04）
+    - 自动匹配并触发mesh实体动作
+  - **事件系统优化**：
+    - DeviceInfo添加manager引用，正确触发事件
+    - 修复事件名称不匹配问题（stateChange -> device-state-changed）
+    - 确保所有自定义码双向同步正常
+  - **队列处理**：
+    - 命令队列顺序处理，防止并发冲突
+    - 500ms防死循环机制
+    - 队列限制100条，防止内存溢出
+  - **调试日志**：添加详细调试日志，方便排查问题
+
 ### v1.7.0 (2025-12-21)
 - **自定义协议增强**：RS485桥接节点自定义协议功能全面升级
   - 自定义开关：添加发开、发关、收开、收关4组码
@@ -1314,34 +1339,6 @@ node-red-contrib-symi-mesh/
   - 多设备类型：开关、调光灯、窗帘、空调、新风、地暖
   - 智能通道选择：根据Mesh设备实际路数显示可选通道
 
-### v1.6.6 (2025-12-09)
-- **三合一面板完整双向同步**：支持空调+新风+地暖独立RS485映射
-  - 三合一0x94协议完整解析：空调(开关/模式/风速/温度)、地暖(开关/温度)、新风(开关/风速)
-  - Mesh→RS485：三合一状态变化自动发送对应RS485帧
-  - RS485→Mesh：RS485帧自动同步到三合一面板对应功能
-  - 支持climateSwitch/climateMode/fanMode/floorHeatingSwitch/freshAirSwitch等字段
-- **开关双向同步修复**：修复米家App全开/全关只触发部分按键的问题
-  - 命令队列防抖逻辑修复：只有完全相同映射才合并，不同映射独立处理
-  - 支持同一Mesh设备多通道分别绑定不同RS485设备
-- **RS485多映射匹配**：修复同一从机地址多个映射时只匹配第一个的问题
-  - findAllRS485Mappings返回所有匹配的映射
-  - rs485Channel精确匹配：根据寄存器地址确定通道
-- **网络异常处理增强**：彻底修复Node.js 18+ AggregateError导致崩溃的问题
-  - 全局uncaughtException/unhandledRejection处理器
-  - TCP连接过程同步错误捕获
-  - 只捕获网络相关错误，不影响其他异常
-- **三合一面板自动识别**：设备列表API返回isThreeInOne标志
-- **窗帘双协议兼容**：同时支持米家和小程序两种控制协议
-  - 米家协议: `subOpcode=0x06, status: 0=打开中, 1=关闭中, 2=停止`
-  - 小程序协议: `subOpcode=0x05, status: 1=打开, 2=关闭, 3=停止`
-- **话语前湾协议完善**：
-  - 空调：客厅/主卧/次卧1/次卧2，寄存器0x0FA0-0x0FAF
-  - 地暖：客餐厅(60)/主卧(61)/次卧1(62)/次卧2(63)，寄存器0x0039/0x0043
-  - 新风：从机60，开关0x0039(开=1)，风速0x004B(高=2,低=0)
-- **地址输入修复**：允许从机地址为0（话语前湾空调地址是0）
-- **内存安全**：命令队列限制100条，节点关闭时清理所有缓存
-- **文档更新**：添加三合一面板RS485配置说明和协议对照表
-
 ## 许可证
 
 MIT License
@@ -1353,7 +1350,7 @@ Copyright (c) 2025 SYMI 亖米
 ## 关于
 
 **作者**: SYMI 亖米
-**版本**: 1.7.0
+**版本**: 1.7.1
 **协议**: 蓝牙MESH网关（初级版）串口协议V1.0
 **最后更新**: 2025-12-21
 **仓库**: https://github.com/symi-daguo/node-red-contrib-symi-mesh

package/lib/device-manager.js

@@ -13,7 +13,7 @@ const DEVICE_TYPE_NAMES = {
 };
 
 class DeviceInfo {
-    constructor(data) {
+    constructor(data, manager) {
         this.macAddress = data.macAddress;
         this.networkAddress = data.networkAddress;
         this.deviceType = data.deviceType;
@@ -25,6 +25,7 @@ class DeviceInfo {
         this.state = {};
         this.lastSeen = Date.now();
         this.isThreeInOne = false;
+        this.manager = manager; // 保存DeviceManager引用
     }
 
     generateName() {
@@ -199,7 +200,16 @@ class DeviceInfo {
             case 0x1C:
                 // 风速设置（温控器和三合一空调都使用）
                 if (parameters.length > 0) {
+                    const oldFanMode = this.state.fanMode;
                     this.state.fanMode = parameters[0];
+                    // 触发状态变化事件
+                    if (oldFanMode !== this.state.fanMode) {
+                        this.emit('stateChange', {
+                            device: this,
+                            state: { fanMode: this.state.fanMode },
+                            attrType: attrType
+                        });
+                    }
                 }
                 break;
             case 0x1D:
@@ -316,8 +326,10 @@ class DeviceInfo {
         }
         
         // byte2: bit[0-2]=空调风速 (协议值: 0=自动, 1=低, 2=中, 4=高)
+        // 统一转换为标准Mesh值: 1=高, 2=中, 3=低, 4=自动
         const fanLevel = byte2 & 0x07;
-        this.state.fanMode = fanLevel;
+        const fanMap = { 0: 4, 1: 3, 2: 2, 4: 1 };
+        this.state.fanMode = fanMap[fanLevel] || 3; // 默认低风
         
         // byte3: 空调设定温度 (16-30°C)
         if (byte3 >= 16 && byte3 <= 30) {
@@ -353,8 +365,10 @@ class DeviceInfo {
         this.state.freshAirMode = freshMode;
         
         // byte7: bit[0-2]=新风风速 (协议值: 0=自动, 1=低, 2=中, 4=高)
+        // 统一转换为标准Mesh值: 1=高, 2=中, 3=低, 4=自动
         const freshFan = byte7 & 0x07;
-        this.state.freshAirSpeed = freshFan;
+        const freshFanMap = { 0: 4, 1: 3, 2: 2, 4: 1 };
+        this.state.freshAirSpeed = freshFanMap[freshFan] || 4; // 默认自动
         
     }
 
@@ -385,7 +399,44 @@ class DeviceInfo {
         if (this.channels === 1) {
             // 单路开关
             const value = parameters[0];
-            this.state.switch = value === 0x02;
+            console.log(`[DeviceManager] handleSwitchState: deviceType=${this.deviceType}, channels=${this.channels}, value=${value}, name=${this.name}`);
+            // 温控器设备：0x02消息可能是开关或风速
+            if (this.deviceType === 10) {
+                console.log(`[DeviceManager] 温控器设备，检查风速: value=${value}`);
+                // 如果值是1-4，是风速控制
+                if (value >= 1 && value <= 4) {
+                    const oldFanMode = this.state.fanMode;
+                    this.state.fanMode = value;
+                    console.log(`[DeviceManager] 风速变化: ${oldFanMode} -> ${this.state.fanMode}`);
+                    // 总是触发事件，即使值没变
+                    console.log(`[DeviceManager] 触发fanMode事件`);
+                    // 注意：这里不能直接emit，因为这是DeviceInfo实例，不是DeviceManager
+                    // 需要通过DeviceManager来触发事件
+                    if (this.manager) {
+                        this.manager.emit('device-state-changed', {
+                            device: this,
+                            state: { fanMode: this.state.fanMode },
+                            attrType: 0x1C
+                        });
+                    }
+                } else {
+                    // 否则是开关控制
+                    console.log(`[DeviceManager] 开关控制: value=${value}`);
+                    const oldSwitch = this.state.switch;
+                    this.state.switch = value === 0x02;
+                    // 触发开关状态变化事件
+                    if (oldSwitch !== this.state.switch && this.manager) {
+                        console.log(`[DeviceManager] 触发switch事件: ${oldSwitch} -> ${this.state.switch}`);
+                        this.manager.emit('device-state-changed', {
+                            device: this,
+                            state: { switch: this.state.switch },
+                            attrType: 0x02
+                        });
+                    }
+                }
+            } else {
+                this.state.switch = value === 0x02;
+            }
         } else if (this.channels <= 4) {
             // 1-4路开关：通常1字节，但米家/面板操作可能发送2字节(0x45类型)
             let value;
@@ -601,7 +652,7 @@ class DeviceManager extends EventEmitter {
         let nameChanged = false;
         
         if (!device) {
-            device = new DeviceInfo(deviceData);
+            device = new DeviceInfo(deviceData, this);
             this.devices.set(mac, device);
             isNew = true;
         } else {

package/nodes/symi-485-bridge.js

@@ -524,6 +524,8 @@ module.exports = function(RED) {
 
         // 状态缓存 - 用于检测真正变化的开关
         node.stateCache = {};
+        // 空调模式缓存 - 用于温度控制时确定当前模式
+        node.climateCache = {};
         // 首次启动标记 - 跳过初始状态同步
         node.initializing = true;
         // 启动后延迟20秒再开始同步（Mesh网关需要15秒以上完成设备发现）
@@ -804,12 +806,22 @@ module.exports = function(RED) {
                 );
                 const hasACChange = isAC && (
                     changed.targetTemp !== undefined || 
+                    changed.acTargetTemp !== undefined ||
+                    changed.temperature !== undefined ||
                     changed.acMode !== undefined || 
+                    changed.climateMode !== undefined ||
+                    changed.mode !== undefined ||
                     changed.acFanSpeed !== undefined ||
-                    // 三合一面板使用climate前缀
+                    changed.fanSpeed !== undefined ||
+                    changed.climateFanSpeed !== undefined ||
+                    changed.fanMode !== undefined ||
+                    changed.fan_speed !== undefined ||
+                    changed.fanLevel !== undefined ||
+                    changed.fan_level !== undefined ||
+                    changed.speed !== undefined ||
+                    changed.acSwitch !== undefined ||
                     changed.climateSwitch !== undefined ||
-                    changed.climateMode !== undefined ||
-                    changed.fanMode !== undefined
+                    changed.switch !== undefined
                 );
                 // 新风设备检测
                 const isFreshAir = device.includes('fresh_air');
@@ -1233,25 +1245,50 @@ module.exports = function(RED) {
                 }
                 // 空调类型
                 else if (mapping.device === 'custom_climate') {
+                    node.log(`[自定义空调] 处理状态: ${JSON.stringify(state)}, codes存在: ${!!codes}`);
                     for (const [key, value] of Object.entries(state)) {
                         let hexCode = null;
-                        if (key === 'acSwitch' || key === 'climateSwitch') {
-                            hexCode = value ? codes.acSendOn : codes.acSendOff;
+                        
+                        // 1. 开关控制 (处理 acSwitch, climateSwitch, switch)
+                        if (key === 'acSwitch' || key === 'climateSwitch' || key === 'switch') {
+                            const isOn = value === true || value === 1 || value === '1' || value === 'on' || value === 'ON';
+                            hexCode = isOn ? (codes.acSendOn || codes.sendOn) : (codes.acSendOff || codes.sendOff);
+                            node.log(`[自定义空调] 开关控制: ${key}=${value}, isOn=${isOn}, hexCode=${hexCode}`);
                         }
-                        else if (key === 'acFanSpeed' || key === 'fanSpeed') {
-                            if (value === 1) hexCode = codes.fanSendHigh;
-                            else if (value === 2) hexCode = codes.fanSendMid;
-                            else if (value === 3) hexCode = codes.fanSendLow;
+                        // 2. 风速控制
+                        else if (['acFanSpeed', 'fanSpeed', 'climateFanSpeed', 'fanMode', 'fan_speed', 'fanLevel', 'fan_level', 'speed'].includes(key)) {
+                            const val = parseInt(value);
+                            node.log(`[自定义空调] 风速控制: ${key}=${value}, val=${val}`);
+                            // 标准Mesh协议: 1=高, 2=中, 3=低, 4=自动
+                            if (val === 1) {
+                                hexCode = codes.fanSendHigh;
+                                node.log(`[自定义空调] 高风, hexCode=${hexCode}`);
+                            }
+                            else if (val === 2) {
+                                hexCode = codes.fanSendMid;
+                                node.log(`[自定义空调] 中风, hexCode=${hexCode}`);
+                            }
+                            else if (val === 3 || val === 0 || val === 4) {
+                                hexCode = codes.fanSendLow;
+                                node.log(`[自定义空调] 低风, hexCode=${hexCode}`);
+                            }
                         }
-                        else if (key === 'acMode' || key === 'climateMode') {
+                        // 3. 模式控制
+                        else if (key === 'acMode' || key === 'climateMode' || key === 'mode') {
                             if (value === 1) hexCode = codes.modeSendCool;
                             else if (value === 2) hexCode = codes.modeSendHeat;
                             else if (value === 4) hexCode = codes.modeSendDry;
                             else if (value === 3) hexCode = codes.modeSendFan;
+                            
+                            // 更新缓存中的模式
+                            if (!node.climateCache[mapping.meshMac]) node.climateCache[mapping.meshMac] = {};
+                            node.climateCache[mapping.meshMac].mode = value;
                         }
-                        else if (key === 'targetTemp' || key === 'acTargetTemp') {
+                        // 4. 温度控制
+                        else if (key === 'targetTemp' || key === 'acTargetTemp' || key === 'temperature') {
                             const temp = Math.round(value);
-                            const mode = state.acMode || state.climateMode || 1; // 1=Cool, 2=Heat, 3=Fan, 4=Dry
+                            // 优先从当前变化中获取模式，否则从缓存中获取，默认制冷(1)
+                            const mode = state.acMode || state.climateMode || (node.climateCache[mapping.meshMac] ? node.climateCache[mapping.meshMac].mode : 1);
                             
                             // 1. 优先尝试特定温度码，如 tempSendCool16
                             const modeSuffix = (mode === 2) ? 'Heat' : 'Cool';
@@ -1529,19 +1566,44 @@ module.exports = function(RED) {
                 for (const [key, value] of Object.entries(state)) {
                     try {
                         // 开关类型
-                        if (key === 'switch') {
+                        if (key === 'switch' || key.startsWith('switch_')) {
+                            const ch = key.startsWith('switch_') ? parseInt(key.replace('switch_', '')) : channel;
                             const onOff = value ? 0x02 : 0x01;
-                            const param = Buffer.from([channel - 1, onOff]);
+                            const param = Buffer.from([ch - 1, onOff]);
+                            await node.gateway.sendControl(meshDevice.networkAddress, 0x02, param);
+                            node.log(`[自定义->Mesh] 开关${ch}: ${value ? '开' : '关'}`);
+                        }
+                        // 空调开关
+                        else if (key === 'acSwitch' || key === 'climateSwitch') {
+                            const param = Buffer.from([value ? 0x02 : 0x01]);
                             await node.gateway.sendControl(meshDevice.networkAddress, 0x02, param);
-                            node.log(`[自定义->Mesh] 开关${channel}: ${value ? '开' : '关'}`);
+                            node.log(`[自定义->Mesh] 空调开关: ${value ? '开' : '关'}`);
+                        }
+                        // 空调模式
+                        else if (key === 'acMode' || key === 'climateMode' || key === 'mode') {
+                            const param = Buffer.from([value]);
+                            await node.gateway.sendControl(meshDevice.networkAddress, 0x1D, param);
+                            node.log(`[自定义->Mesh] 空调模式: ${value}`);
+                        }
+                        // 空调风速
+                        else if (key === 'acFanSpeed' || key === 'fanMode' || key === 'fanSpeed') {
+                            const param = Buffer.from([value]);
+                            await node.gateway.sendControl(meshDevice.networkAddress, 0x1C, param);
+                            node.log(`[自定义->Mesh] 空调风速: ${value}`);
+                        }
+                        // 目标温度
+                        else if (key === 'acTargetTemp' || key === 'targetTemp') {
+                            const param = Buffer.from([Math.round(value)]);
+                            await node.gateway.sendControl(meshDevice.networkAddress, 0x1B, param);
+                            node.log(`[自定义->Mesh] 目标温度: ${value}°C`);
                         }
                         // 窗帘类型
-                        else if (key === 'action' || key === 'position') {
+                        else if (key === 'action' || key === 'position' || key === 'curtainAction' || key === 'curtainPosition') {
                             // 窗帘动作: 1=打开, 2=关闭, 3=停止
                             let action = 0x03;  // 停止
-                            if (value === 'open') action = 0x01;  // 打开
-                            else if (value === 'close') action = 0x02;  // 关闭
-                            else if (value === 'stop') action = 0x03;  // 停止
+                            if (value === 'open' || value === 1) action = 0x01;  // 打开
+                            else if (value === 'close' || value === 2) action = 0x02;  // 关闭
+                            else if (value === 'stop' || value === 3) action = 0x03;  // 停止
                             
                             const param = Buffer.from([action]);
                             // 0x05是窗帘动作控制属性
@@ -1751,7 +1813,7 @@ module.exports = function(RED) {
         node.parseRS485Frame = function(frame) {
             if (frame.length < 4) return;
             
-            const hexStr = frame.toString('hex').toUpperCase();
+            const hexStr = frame.toString('hex').toUpperCase().replace(/\s/g, ''); // 确保完全去掉空格
             const hexFormatted = hexStr.match(/.{1,2}/g)?.join(' ') || '';
             
             node.log(`[RS485收到] ${hexFormatted} (${frame.length}字节)`);
@@ -1829,24 +1891,30 @@ module.exports = function(RED) {
                     const codes = mapping.customCodes;
                     let matchedAction = null;
                     
-                    node.debug(`[自定义码检测] 检查映射: device=${mapping.device}, meshMac=${mapping.meshMac}, codes=${JSON.stringify(codes)}`);
+                    node.log(`[自定义码检测] 检查映射: device=${mapping.device}, meshMac=${mapping.meshMac}`);
                     
                     // 开关类型：匹配recvOn/recvOff
                     if (mapping.device === 'custom_switch') {
                         const recvOn = (codes.recvOn || '').replace(/\s/g, '').toUpperCase();
                         const recvOff = (codes.recvOff || '').replace(/\s/g, '').toUpperCase();
+                        node.log(`[自定义开关] recvOn=${recvOn}, recvOff=${recvOff}, hexStr=${hexStr}`);
+                        node.log(`[自定义开关] 包含recvOn? ${hexStr.includes(recvOn)}, 包含recvOff? ${hexStr.includes(recvOff)}`);
                         
                         // 翻转模式：收开码=收关码
                         if (recvOn && recvOff && recvOn === recvOff && hexStr.includes(recvOn)) {
                             const device = node.gateway.deviceManager.getDeviceByMac(mapping.meshMac);
-                            const currentState = device?.state?.switch || false;
+                            const channel = mapping.meshChannel || 1;
+                            const stateKey = mapping.meshChannel > 1 ? `switch_${channel}` : 'switch';
+                            const currentState = device?.state?.[stateKey] || false;
                             matchedAction = { switch: !currentState };
-                            node.log(`[自定义开关] 翻转: ${currentState} -> ${!currentState}`);
+                            node.log(`[自定义开关] 翻转: ${stateKey} ${currentState} -> ${!currentState}`);
                         } else {
                             if (recvOn && hexStr.includes(recvOn)) {
                                 matchedAction = { switch: true };
+                                node.log(`[自定义开关] 匹配到收开码`);
                             } else if (recvOff && hexStr.includes(recvOff)) {
                                 matchedAction = { switch: false };
+                                node.log(`[自定义开关] 匹配到收关码`);
                             }
                         }
                     }
@@ -1882,7 +1950,25 @@ module.exports = function(RED) {
                             matchedAction = { acFanSpeed: 3 };
                         }
                         else if (codes.modeRecvCool && hexStr.includes(codes.modeRecvCool.replace(/\s/g, '').toUpperCase())) {
-                            for (const m of modes) {
+                            matchedAction = { acMode: 1 };
+                        } else if (codes.modeRecvHeat && hexStr.includes(codes.modeRecvHeat.replace(/\s/g, '').toUpperCase())) {
+                            matchedAction = { acMode: 2 };
+                        } else if (codes.modeRecvDry && hexStr.includes(codes.modeRecvDry.replace(/\s/g, '').toUpperCase())) {
+                            matchedAction = { acMode: 4 };
+                        } else if (codes.modeRecvFan && hexStr.includes(codes.modeRecvFan.replace(/\s/g, '').toUpperCase())) {
+                            matchedAction = { acMode: 3 };
+                        }
+                        
+                        // 温度匹配 (独立于模式匹配，因为一帧可能同时包含模式和温度，或者只有温度)
+                        if (!matchedAction) {
+                            let foundTemp = false;
+                            const climateModes = [
+                                { suffix: 'Cool', val: 1 },
+                                { suffix: 'Heat', val: 2 }
+                            ];
+                            
+                            // 1. 优先匹配 16-30度 独立码
+                            for (const m of climateModes) {
                                 for (let t = 16; t <= 30; t++) {
                                     const key = `tempRecv${m.suffix}${t}`;
                                     const code = (codes[key] || '').replace(/\s/g, '').toUpperCase();
@@ -1912,7 +1998,6 @@ module.exports = function(RED) {
                                             const suffix = parts[1];
                                             if (hexStr.includes(prefix)) {
                                                 // 尝试从 hexStr 中提取温度
-                                                // 简单起见，如果包含前缀且后面有2位十六进制+后缀
                                                 const startIdx = hexStr.indexOf(prefix) + prefix.length;
                                                 const tempHex = hexStr.substring(startIdx, startIdx + 2);
                                                 const remaining = hexStr.substring(startIdx + 2);
@@ -1934,6 +2019,11 @@ module.exports = function(RED) {
                         }
                         
                         if (matchedAction) {
+                            // 更新缓存中的模式
+                            if (matchedAction.acMode !== undefined) {
+                                if (!node.climateCache[mapping.meshMac]) node.climateCache[mapping.meshMac] = {};
+                                node.climateCache[mapping.meshMac].mode = matchedAction.acMode;
+                            }
                             node.log(`[自定义空调] 匹配: ${JSON.stringify(matchedAction)}`);
                         }
                     }

package/nodes/symi-mqtt.js

@@ -1342,11 +1342,27 @@ module.exports = function(RED) {
             
         } else if (topic.includes('/fan_mode/set')) {
             // 温控器/三合一空调风速 (0x1C协议: 1=高, 2=中, 3=低, 4=自动)
+            node.log(`[MQTT] 收到风速控制: topic=${topic}, payload=${payload}`);
             const fans = { 'high': 1, 'medium': 2, 'low': 3, 'auto': 4 };
             const fan = fans[payload];
+            node.log(`[MQTT] 风速映射: ${payload} -> ${fan}`);
             if (fan !== undefined) {
                 commands.push({ attrType: 0x1C, param: Buffer.from([fan]) });
-                this.debug(`[MQTT解析] 空调风速命令: 0x1C=0x${fan.toString(16).toUpperCase()} (${payload})`);
+                node.log(`[MQTT解析] 空调风速命令: 0x1C=0x${fan.toString(16).toUpperCase()} (${payload})`);
+                
+                // 立即触发状态变化事件，通知RS485桥接节点
+                if (device && node.gateway && node.gateway.deviceManager) {
+                    node.log(`[MQTT] 触发风速状态变化事件: fanMode=${fan}`);
+                    device.state.fanMode = fan;
+                    node.gateway.deviceManager.emit('stateChange', {
+                        device: device,
+                        state: { fanMode: fan },
+                        attrType: 0x1C,
+                        isUserControl: true
+                    });
+                } else {
+                    node.warn(`[MQTT] 无法触发事件: device=${!!device}, gateway=${!!node.gateway}, deviceManager=${!!node.gateway?.deviceManager}`);
+                }
             }
             
         } else if (topic.endsWith('/cover/set')) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-symi-mesh",
-  "version": "1.7.0",
+  "version": "1.7.1",
   "description": "Node-RED节点集合，用于通过TCP/串口连接Symi蓝牙Mesh网关，支持Home Assistant MQTT Discovery自动发现和云端数据同步",
   "main": "nodes/symi-gateway.js",
   "scripts": {