node-red-contrib-symi-mesh 1.8.5 → 1.8.7

package/README.md

@@ -558,6 +558,8 @@ npm install node-red-contrib-home-assistant-websocket
 
 | 节点 | 用途 |
 |-----|------|
+| **Symi RS485 Sync** | RS485多机批量同步 |
+| **RS485调试** | 原始485字节流抓取显示 |
 | **Symi Gateway** | 网关连接（TCP/串口） |
 | **Symi MQTT** | MQTT桥接，设备发布到HA |
 | **Symi Device** | Flow中单设备控制/监听 |
@@ -702,6 +704,37 @@ node-red-contrib-symi-mesh/
 
 ## 更新日志
 
+### v1.8.7 (2026-01-08)
+
+**生产环境日志优化与稳定性增强**：
+- **错误日志节流 (Throttling)**：在网关连接和 RS485 配置中引入 60 秒节流机制，同类网络错误（如 `ECONNREFUSED`）每分钟仅记录一次，彻底解决离线时的日志刷屏问题。
+- **日志级别降级**：将所有节点的 `node.error` 和 `node.warn` 统一降级为 `node.log` (Info 级别)，保持 Node-RED 控制台整洁，仅在调试模式下显示详细信息。
+- **TCP 客户端优化**：在 `tcp-client` 库级别拦截常见的网络波动报错，提升系统在高频重连场景下的静默稳定性。
+- **全量节点适配**：完成 MQTT、HA同步、云端同步、RS485、KNX 等所有功能节点的日志规范化清理。
+
+### v1.8.6 (2026-01-07)
+
+**核心修复与同步增强**：
+- **网关初始化修复**：修复 `symi-gateway` 节点在初始化查询设备状态时的语法错误 (SyntaxError)，确保节点能正常加载。
+- **三合一属性路由优化**：优化 `symi-ha-sync` 路由逻辑，支持将 0x02 属性（开关）正确重定向至三合一子实体处理器，解决三合一面板状态同步失效问题。
+- **HA Climate 协议匹配**：修复 HA `climate` 实体协议不匹配问题，将空调/地暖开关操作映射为 `hvac_mode` (heat/cool/off)，解决同步时的 500 错误。
+- **风速同步双向修复**：
+    - **中英文映射支持**：在 `HA_TO_FAN_MODE` 中增加中文风速（高风/中风/低风/自动）映射，解决 HA 界面操作时的“未知风速值”警告。
+    - **Symi -> HA 值转换**：同步至 HA 时自动将英文风速转换为中文，匹配中文版 HA 实体要求，彻底解决同步时的 500 错误。
+    - **详细日志追踪**：增加 `[Symi->HA] 发送 HA 请求` 详细日志，包含完整的服务调用路径和 Payload。
+
+**三合一设备持久化优化**：
+- **文件持久化存储**：三合一设备类型信息保存到 `~/.node-red/symi-mesh-data/` 目录，实现永久记忆。
+- **检测逻辑优化**：延长检测等待时间至 10 秒（分 20 次检查），解决因网络延迟导致的识别失败。
+- **时序修复**：提前保存 `needsThreeInOneCheck` 状态，确保在响应到达时能正确触发持久化流程。
+
+**Mesh -> HA 同步增强**：
+- **状态缓存细粒度化**：采用 `StateCache` 实现 `{mac}_{subEntity}_{property}` 级别的精确对比，只同步真正变化的属性。
+- **调试日志增强**：三合一相关事件统一使用 `log` 级别输出，便于快速排查同步链路问题。
+
+**设备管理器功能增强**：
+- 新增 `markAsThreeInOne` / `markAsThermostat` 等持久化管理方法，提升系统重启后的设备恢复速度。
+
 ### v1.8.5 (2026-01-06)
 
 **通用同步工具类重构**：
@@ -803,8 +836,8 @@ Copyright (c) 2025 SYMI 亖米
 ---
 
 **作者**: SYMI 亖米
-**版本**: 1.8.5
+**版本**: 1.8.6
 **协议**: 蓝牙MESH网关（初级版）串口协议V1.0
-**最后更新**: 2026-01-06
+**最后更新**: 2026-01-07
 **仓库**: https://github.com/symi-daguo/node-red-contrib-symi-mesh
 **npm包**: https://www.npmjs.com/package/node-red-contrib-symi-mesh

package/lib/device-manager.js

@@ -4,6 +4,8 @@
  */
 
 const EventEmitter = require('events');
+const fs = require('fs');
+const path = require('path');
 
 const DEVICE_TYPE_NAMES = {
     0: '未知设备', 1: '零火开关', 2: '单火开关', 3: '智能插座',
@@ -266,9 +268,17 @@ class DeviceInfo {
                 // 收到0x68响应说明这是三合一面板（温控器不会响应0x68）
                 if (parameters.length > 0) {
                     // 首次收到0x68有效响应，标记为三合一
-                    if (!this.isThreeInOne && this.deviceType === 10) {
+                    const wasThreeInOne = this.isThreeInOne;
+                    if (!wasThreeInOne && this.deviceType === 10) {
                         this.isThreeInOne = true;
                         this.needsThreeInOneCheck = false;
+                        // 通知DeviceManager持久化三合一标记
+                        if (this.manager) {
+                            this.manager.logger.log(`[DeviceInfo] 0x68响应触发markAsThreeInOne: ${this.macAddress}, wasThreeInOne=${wasThreeInOne}`);
+                            this.manager.markAsThreeInOne(this.macAddress);
+                        } else {
+                            console.error(`[DeviceInfo] manager引用为空，无法持久化三合一标记: ${this.macAddress}`);
+                        }
                     }
                     this.state.freshAirSwitch = parameters[0] === 0x02;
                 } else if (this.isThreeInOne) {
@@ -285,9 +295,17 @@ class DeviceInfo {
                 // 新风风速 (1=高, 2=中, 3=低, 4=自动, 空参数=查询无结果)
                 // 收到0x6A响应也可以确认是三合一
                 if (parameters.length > 0) {
-                    if (!this.isThreeInOne && this.deviceType === 10) {
+                    const wasThreeInOne = this.isThreeInOne;
+                    if (!wasThreeInOne && this.deviceType === 10) {
                         this.isThreeInOne = true;
                         this.needsThreeInOneCheck = false;
+                        // 通知DeviceManager持久化三合一标记
+                        if (this.manager) {
+                            this.manager.logger.log(`[DeviceInfo] 0x6A响应触发markAsThreeInOne: ${this.macAddress}, wasThreeInOne=${wasThreeInOne}`);
+                            this.manager.markAsThreeInOne(this.macAddress);
+                        } else {
+                            console.error(`[DeviceInfo] 0x6A: manager引用为空，无法持久化三合一标记: ${this.macAddress}`);
+                        }
                     }
                     this.state.freshAirSpeed = parameters[0];
                 } else if (this.isThreeInOne) {
@@ -298,9 +316,17 @@ class DeviceInfo {
                 // 地暖开关 (0x02=开, 0x01=关, 空参数=查询无结果)
                 // 收到0x6B响应也可以确认是三合一
                 if (parameters.length > 0) {
-                    if (!this.isThreeInOne && this.deviceType === 10) {
+                    const wasThreeInOne = this.isThreeInOne;
+                    if (!wasThreeInOne && this.deviceType === 10) {
                         this.isThreeInOne = true;
                         this.needsThreeInOneCheck = false;
+                        // 通知DeviceManager持久化三合一标记
+                        if (this.manager) {
+                            this.manager.logger.log(`[DeviceInfo] 0x6B响应触发markAsThreeInOne: ${this.macAddress}, wasThreeInOne=${wasThreeInOne}`);
+                            this.manager.markAsThreeInOne(this.macAddress);
+                        } else {
+                            console.error(`[DeviceInfo] 0x6B: manager引用为空，无法持久化三合一标记: ${this.macAddress}`);
+                        }
                     }
                     this.state.floorHeatingSwitch = parameters[0] === 0x02;
                 } else if (this.isThreeInOne) {
@@ -318,9 +344,18 @@ class DeviceInfo {
                 // 三合一设备状态（0x94是消息类型，不是设备类型）
                 // 收到0x94消息（带有效参数）说明这是三合一面板
                 if (parameters.length >= 8) {
-                    if (!this.isThreeInOne && this.deviceType === 10) {
+                    const wasThreeInOne = this.isThreeInOne;
+                    if (!wasThreeInOne && this.deviceType === 10) {
                         this.isThreeInOne = true;
                         this.needsThreeInOneCheck = false;
+                        // 通知DeviceManager持久化三合一标记
+                        if (this.manager) {
+                            this.manager.logger.log(`[DeviceInfo] 0x94响应触发markAsThreeInOne: ${this.macAddress}, wasThreeInOne=${wasThreeInOne}`);
+                            this.manager.markAsThreeInOne(this.macAddress);
+                        } else {
+                            // manager为空时使用console
+                            console.error(`[DeviceInfo] manager引用为空，无法持久化三合一标记: ${this.macAddress}`);
+                        }
                     }
                     // 参数格式: [byte0, byte1, byte2(子类型标识), byte3, byte4, byte5(子类型标识2), ...]
                     // 新风: byte5=0x01
@@ -619,8 +654,121 @@ class DeviceManager extends EventEmitter {
         this.devices = new Map();
         this.macToAddress = new Map();
         this.addressToMac = new Map();
+        
+        // 三合一设备类型持久化存储文件路径
+        // 使用 Node-RED 用户目录下的文件存储
+        this.threeInOneStoragePath = this.getThreeInOneStoragePath();
+        this.threeInOneDevices = this.loadThreeInOneDevices();
+        
         this.loadDevices();
     }
+    
+    // 获取三合一设备存储文件路径
+    getThreeInOneStoragePath() {
+        try {
+            // 尝试使用 Node-RED 用户目录
+            const userDir = process.env.NODE_RED_HOME || 
+                           path.join(require('os').homedir(), '.node-red');
+            const storageDir = path.join(userDir, 'symi-mesh-data');
+            
+            this.logger.log(`[DeviceManager] 用户目录: ${userDir}`);
+            this.logger.log(`[DeviceManager] 存储目录: ${storageDir}`);
+            
+            // 确保目录存在
+            if (!fs.existsSync(storageDir)) {
+                this.logger.log(`[DeviceManager] 创建存储目录: ${storageDir}`);
+                fs.mkdirSync(storageDir, { recursive: true });
+            }
+            
+            const filePath = path.join(storageDir, `three-in-one-devices-${this.gatewayId}.json`);
+            this.logger.log(`[DeviceManager] 三合一设备存储文件路径: ${filePath}`);
+            return filePath;
+        } catch (e) {
+            this.logger.error(`[DeviceManager] 获取存储路径失败: ${e.message}`);
+            return null;
+        }
+    }
+    
+    // 从文件加载三合一设备列表
+    loadThreeInOneDevices() {
+        try {
+            this.logger.log(`[DeviceManager] 尝试加载三合一设备文件: ${this.threeInOneStoragePath}`);
+            if (this.threeInOneStoragePath && fs.existsSync(this.threeInOneStoragePath)) {
+                const data = fs.readFileSync(this.threeInOneStoragePath, 'utf8');
+                const parsed = JSON.parse(data);
+                this.logger.log(`[DeviceManager] 从文件加载了三合一设备: ${JSON.stringify(parsed)}`);
+                return parsed;
+            } else {
+                this.logger.log(`[DeviceManager] 三合一设备文件不存在，返回空对象`);
+            }
+        } catch (e) {
+            this.logger.error(`[DeviceManager] 加载三合一设备文件失败: ${e.message}`);
+        }
+        return {};
+    }
+    
+    // 保存三合一设备列表到文件
+    saveThreeInOneDevices() {
+        try {
+            if (this.threeInOneStoragePath) {
+                const content = JSON.stringify(this.threeInOneDevices, null, 2);
+                this.logger.log(`[DeviceManager] 正在保存三合一设备到: ${this.threeInOneStoragePath}`);
+                this.logger.log(`[DeviceManager] 保存内容: ${content}`);
+                fs.writeFileSync(this.threeInOneStoragePath, content);
+                this.logger.log(`[DeviceManager] 已保存 ${Object.keys(this.threeInOneDevices).length} 个三合一设备记录到文件`);
+            } else {
+                this.logger.error(`[DeviceManager] 存储路径为空，无法保存`);
+            }
+        } catch (e) {
+            this.logger.error(`[DeviceManager] 保存三合一设备文件失败: ${e.message}`);
+        }
+    }
+    
+    // 标记设备为三合一
+    markAsThreeInOne(mac) {
+        this.logger.log(`[DeviceManager] markAsThreeInOne被调用: mac=${mac}, 存储路径=${this.threeInOneStoragePath}`);
+        // 无论之前是什么状态，都更新为三合一
+        const existing = this.threeInOneDevices[mac];
+        this.logger.log(`[DeviceManager] 现有记录: ${JSON.stringify(existing)}`);
+        if (!existing || !existing.isThreeInOne) {
+            this.threeInOneDevices[mac] = {
+                confirmedAt: Date.now(),
+                isThreeInOne: true
+            };
+            this.saveThreeInOneDevices();
+            this.logger.log(`[DeviceManager] 设备 ${mac} 已永久标记为三合一面板`);
+        } else {
+            this.logger.log(`[DeviceManager] 设备 ${mac} 已经是三合一，跳过保存`);
+        }
+    }
+    
+    // 标记设备为普通温控器
+    markAsThermostat(mac) {
+        // 只有在没有记录时才标记为温控器（三合一优先级更高）
+        if (!this.threeInOneDevices[mac]) {
+            this.threeInOneDevices[mac] = {
+                confirmedAt: Date.now(),
+                isThreeInOne: false,
+                thermostatConfirmed: true
+            };
+            this.saveThreeInOneDevices();
+            this.logger.log(`[DeviceManager] 设备 ${mac} 已永久标记为普通温控器`);
+        }
+    }
+    
+    // 检查设备是否已确认为三合一
+    isConfirmedThreeInOne(mac) {
+        const result = this.threeInOneDevices[mac]?.isThreeInOne === true;
+        this.logger.log(`[DeviceManager] isConfirmedThreeInOne(${mac}): ${result}, 记录=${JSON.stringify(this.threeInOneDevices[mac])}`);
+        return result;
+    }
+    
+    // 检查设备是否已确认为普通温控器
+    isConfirmedThermostat(mac) {
+        const result = this.threeInOneDevices[mac]?.thermostatConfirmed === true;
+        this.logger.log(`[DeviceManager] isConfirmedThermostat(${mac}): ${result}`);
+        return result;
+    }
 
     loadDevices() {
         try {
@@ -630,14 +778,26 @@ class DeviceManager extends EventEmitter {
             
             Object.entries(saved).forEach(([mac, data]) => {
                 const device = new DeviceInfo(data, this);  // 传递manager引用
-                // 恢复三合一标记
-                if (data.isThreeInOne) {
+                
+                // 优先从文件存储恢复三合一标记（持久化）
+                if (this.isConfirmedThreeInOne(mac)) {
                     device.isThreeInOne = true;
-                }
-                // 恢复温控器确认标记
-                if (data.thermostatConfirmed) {
+                    device.needsThreeInOneCheck = false;
+                    this.logger.log(`[DeviceManager] 设备 ${mac} 从文件恢复为三合一面板`);
+                } else if (this.isConfirmedThermostat(mac)) {
                     device.thermostatConfirmed = true;
+                    device.needsThreeInOneCheck = false;
+                    this.logger.log(`[DeviceManager] 设备 ${mac} 从文件恢复为普通温控器`);
+                } else if (data.isThreeInOne) {
+                    // 兼容旧的context存储
+                    device.isThreeInOne = true;
+                    // 同时保存到文件存储
+                    this.markAsThreeInOne(mac);
+                } else if (data.thermostatConfirmed) {
+                    device.thermostatConfirmed = true;
+                    this.markAsThermostat(mac);
                 }
+                
                 // 恢复按键名称和配置
                 if (data.subDeviceNames) {
                     device.subDeviceNames = data.subDeviceNames;
@@ -698,6 +858,18 @@ class DeviceManager extends EventEmitter {
         
         if (!device) {
             device = new DeviceInfo(deviceData, this);
+            
+            // 新设备：检查文件存储中是否已有三合一标记
+            if (this.isConfirmedThreeInOne(mac)) {
+                device.isThreeInOne = true;
+                device.needsThreeInOneCheck = false;
+                this.logger.log(`[DeviceManager] 新设备 ${mac} 从文件恢复为三合一面板`);
+            } else if (this.isConfirmedThermostat(mac)) {
+                device.thermostatConfirmed = true;
+                device.needsThreeInOneCheck = false;
+                this.logger.log(`[DeviceManager] 新设备 ${mac} 从文件恢复为普通温控器`);
+            }
+            
             this.devices.set(mac, device);
             isNew = true;
         } else {
@@ -709,6 +881,16 @@ class DeviceManager extends EventEmitter {
             device.online = deviceData.online !== undefined ? deviceData.online : true;
             device.lastSeen = Date.now();
             
+            // 已存在的设备：确保三合一标记从文件存储恢复
+            if (!device.isThreeInOne && this.isConfirmedThreeInOne(mac)) {
+                device.isThreeInOne = true;
+                device.needsThreeInOneCheck = false;
+                this.logger.log(`[DeviceManager] 设备 ${mac} 从文件恢复为三合一面板`);
+            } else if (!device.thermostatConfirmed && this.isConfirmedThermostat(mac)) {
+                device.thermostatConfirmed = true;
+                device.needsThreeInOneCheck = false;
+            }
+            
             // 检查名称是否变化（如被标记为三合一）
             if (device.name !== oldName) {
                 nameChanged = true;

package/lib/tcp-client.js

@@ -111,7 +111,7 @@ class TCPClient extends EventEmitter {
                 // 只在首次连接或重要错误时记录，避免大量重复日志
                 // ECONNRESET通常是网络波动，不记录错误
                 else if (!this.connected && error.code !== 'ECONNREFUSED' && error.code !== 'ECONNRESET') {
-                    this.logger.error('TCP client error:', error.message);
+                    this.logger.log('TCP client error: ' + error.message);
                 }
 
                 // 确保错误不会导致uncaught exception

package/nodes/rs485-debug.js

@@ -145,12 +145,13 @@ module.exports = function(RED) {
         });
 
         node.rs485Config.on('disconnected', function() {
-            node.warn('RS485连接已断开');
+            node.log('RS485连接已断开');
             updateStatus();
         });
 
         node.rs485Config.on('error', function(err) {
-            node.error('RS485错误: ' + err.message);
+            // 降级为 log，避免控制台报错
+            node.log('RS485错误: ' + err.message);
             node.status({ fill: 'red', shape: 'ring', text: '错误: ' + err.message });
         });
 

package/nodes/symi-485-config.js

@@ -66,6 +66,17 @@ module.exports = function(RED) {
         node.receiveBuffer = Buffer.alloc(0);
         node.users = [];
 
+        // 限流错误日志
+        node._lastErrorLog = 0;
+        node._ERROR_LOG_INTERVAL = 60000;
+        node.logErrorThrottled = function(msg) {
+            const now = Date.now();
+            if (now - node._lastErrorLog > node._ERROR_LOG_INTERVAL) {
+                node._lastErrorLog = now;
+                node.log(msg);
+            }
+        };
+
         // 注册使用者
         node.register = function(userNode) {
             if (!node.users.includes(userNode)) {
@@ -122,7 +133,7 @@ module.exports = function(RED) {
                     });
 
                     node.client.on('error', (err) => {
-                        node.error(`RS485串口错误: ${err.message}`);
+                        node.logErrorThrottled(`RS485串口错误: ${err.message}`);
                         node.emit('error', err);
                     });
 
@@ -170,7 +181,7 @@ module.exports = function(RED) {
                         if (err.name === 'AggregateError' || err.errors) {
                             node.debug(`RS485 TCP连接失败: 无法连接到 ${node.host}:${node.port}`);
                         } else {
-                            node.error(`RS485 TCP错误: ${err.message}`);
+                            node.logErrorThrottled(`RS485 TCP错误: ${err.message}`);
                         }
                         node.emit('error', err);
                     });

package/nodes/symi-cloud-sync.js

@@ -332,7 +332,7 @@ module.exports = function(RED) {
                     msg.payload = { scene_id: scene.scene_id };
                     node.send(msg);
                 } else {
-                    node.warn(`场景ID ${msg.payload.scene_id} 不存在`);
+                    node.log(`场景ID ${msg.payload.scene_id} 不存在`);
                 }
             }
         });

package/nodes/symi-device.js

@@ -99,21 +99,21 @@ module.exports = function(RED) {
         node.on('input', async function(msg) {
             try {
                 if (!node.gateway.connected) {
-                    node.error('网关未连接');
+                    node.log('网关未连接');
                     return;
                 }
                 
                 if (!node.device) {
                     updateDevice();
                     if (!node.device) {
-                        node.error('设备未找到');
+                        node.log('设备未找到');
                         return;
                     }
                 }
                 
                 const command = node.parseInputCommand(msg);
                 if (!command) {
-                    node.warn('无效的命令格式');
+                    node.log('无效的命令格式');
                     return;
                 }
                 
@@ -122,7 +122,7 @@ module.exports = function(RED) {
                 node.status({ fill: 'green', shape: 'dot', text: '命令已发送' });
                 
             } catch (error) {
-                node.error(`控制失败: ${error.message}`);
+                node.log(`控制失败: ${error.message}`);
                 node.status({ fill: 'red', shape: 'dot', text: '控制失败' });
             }
         });

package/nodes/symi-gateway.js

@@ -70,6 +70,17 @@ module.exports = function(RED) {
         this.sceneExecutionInProgress = false;  // 场景执行中标志
         this.sceneExecutionTimer = null;  // 场景执行超时定时器
 
+        // 限流错误日志
+        this._lastErrorLog = 0;
+        this._ERROR_LOG_INTERVAL = 60000;
+        this.logErrorThrottled = function(msg) {
+            const now = Date.now();
+            if (now - this._lastErrorLog > this._ERROR_LOG_INTERVAL) {
+                this._lastErrorLog = now;
+                this.log(msg);
+            }
+        };
+
         this.log(`Initializing Symi Gateway: ${this.connectionType === 'tcp' ? `${this.host}:${this.port}` : this.serialPort}`);
         
         // 三合一设备检测已在 queryAllDeviceStates 中实现，无需额外事件监听
@@ -128,7 +139,7 @@ module.exports = function(RED) {
             
         } catch (error) {
             // 初始连接失败，但自动重连会继续尝试
-            this.error(`Initial connection failed: ${error.message}, will retry automatically`);
+            this.logErrorThrottled(`Initial connection failed: ${error.message}, will retry automatically`);
         }
 
         // 节点关闭时清理资源
@@ -138,6 +149,8 @@ module.exports = function(RED) {
                 clearTimeout(this.sceneExecutionTimer);
                 this.sceneExecutionTimer = null;
             }
+            
+
 
             // 清空队列
             this.stateEventQueue = [];
@@ -162,7 +175,22 @@ module.exports = function(RED) {
     SymiGatewayNode.prototype.handleFrame = function(frame) {
         // 使用debug记录详细frame信息，避免日志泛滥
         const frameHex = Buffer.from([frame.header, frame.opcode, ...(frame.status !== null ? [frame.status] : []), frame.length, ...frame.payload, frame.checksum]).toString('hex').toUpperCase();
-        this.debug(`[TCP Frame] 接收: ${frameHex} (opcode=0x${frame.opcode.toString(16).toUpperCase()})`);
+        
+        // 三合一相关的帧使用 log 级别
+        const isThreeInOneFrame = frame.opcode === 0x80 && frame.payload && frame.payload.length > 2 && 
+            [0x94, 0x68, 0x69, 0x6A, 0x6B, 0x6C].includes(frame.payload[2]);
+        
+        // 调试：打印所有 0x80 帧，确认是否收到三合一状态上报
+        if (frame.opcode === 0x80) {
+            const msgType = frame.payload && frame.payload.length > 2 ? frame.payload[2] : 'N/A';
+            this.debug(`[TCP Frame] 0x80帧: ${frameHex}, msgType=0x${typeof msgType === 'number' ? msgType.toString(16).toUpperCase() : msgType}, isThreeInOne=${isThreeInOneFrame}`);
+        }
+        
+        if (isThreeInOneFrame) {
+            this.debug(`[TCP Frame] 三合一帧: ${frameHex} (opcode=0x${frame.opcode.toString(16).toUpperCase()})`);
+        } else {
+            this.debug(`[TCP Frame] 接收: ${frameHex} (opcode=0x${frame.opcode.toString(16).toUpperCase()})`)
+        }
         
         if (frame.opcode === OP_RESP_DEVICE_LIST && frame.status === 0x00) {
             this.parseDeviceListFrame(frame);
@@ -243,9 +271,11 @@ module.exports = function(RED) {
 
                 // 记录状态事件
                 const logPrefix = this.sceneExecutionInProgress ? '[场景执行]' : '[状态事件]';
-                if (this.sceneExecutionInProgress) {
-                    // 场景执行期间使用log级别，便于查看
-                    this.log(`${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(', ')}]`);
+                // 三合一相关的 attrType 使用 log 级别，便于调试
+                const isThreeInOneAttr = [0x94, 0x68, 0x69, 0x6A, 0x6B, 0x6C].includes(event.attrType);
+                if (this.sceneExecutionInProgress || isThreeInOneAttr) {
+                    // 场景执行期间或三合一事件使用log级别，便于查看
+                    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(', ')}]`);
                 } else {
                     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(', ')}]`);
                 }
@@ -367,11 +397,27 @@ module.exports = function(RED) {
         // 对于温控器类型(deviceType=10)，需要通过查询新风/地暖来判断是否是三合一
         // 空调温控器和三合一都属于同一品类，只有通过主动查询才能区分
         if (deviceType === 10) {
-            // 如果设备已经被确认为三合一或普通温控器，跳过检测
-            if (device.isThreeInOne) {
-                this.log(`[三合一检测] ${device.name} 已确认为三合一面板（从缓存恢复）`);
+            // 优先检查文件持久化存储（最可靠）
+            const isFileConfirmedThreeInOne = this.deviceManager.isConfirmedThreeInOne(device.macAddress);
+            const isFileConfirmedThermostat = this.deviceManager.isConfirmedThermostat(device.macAddress);
+            
+            if (isFileConfirmedThreeInOne) {
+                // 文件中已确认为三合一，直接恢复，不需要重新检测
+                device.isThreeInOne = true;
+                device.needsThreeInOneCheck = false;
+                this.log(`[三合一检测] ${device.name} 从文件恢复为三合一面板（永久记录）`);
+            } else if (isFileConfirmedThermostat) {
+                // 文件中已确认为普通温控器
+                device.thermostatConfirmed = true;
+                device.needsThreeInOneCheck = false;
+                this.log(`[三合一检测] ${device.name} 从文件恢复为普通温控器（永久记录）`);
+            } else if (device.isThreeInOne) {
+                // 内存中已标记为三合一（可能是旧的context存储）
+                this.log(`[三合一检测] ${device.name} 已确认为三合一面板（从内存恢复）`);
+                // 同时保存到文件
+                this.deviceManager.markAsThreeInOne(device.macAddress);
             } else if (device.thermostatConfirmed) {
-                this.log(`[三合一检测] ${device.name} 已确认为普通温控器（从缓存恢复）`);
+                this.log(`[三合一检测] ${device.name} 已确认为普通温控器（从内存恢复）`);
             } else {
                 device.needsThreeInOneCheck = true;
                 this.log(`[三合一检测] 发现温控器类型设备: ${device.name}，将通过查询新风/地暖确认类型`);
@@ -441,6 +487,13 @@ module.exports = function(RED) {
                     }
                 }
                 
+                // 【重要】在发送查询之前保存检测标记状态
+                // 因为响应可能在sendFrame期间就到达，updateFromEvent会修改needsThreeInOneCheck
+                const wasCheckingThreeInOne = device.needsThreeInOneCheck;
+                if (device.deviceType === 10) {
+                    this.log(`[三合一检测] ${device.name} wasCheckingThreeInOne=${wasCheckingThreeInOne}, queryAttrs=[${queryAttrs.map(a => '0x' + a.toString(16)).join(',')}]`);
+                }
+                
                 for (const attr of queryAttrs) {
                     const frame = this.protocolHandler.buildDeviceStatusQueryFrame(device.networkAddress, attr);
                     await this.client.sendFrame(frame, 2);
@@ -448,30 +501,42 @@ module.exports = function(RED) {
                 }
                 
                 // 等待设备响应，检查是否被标记为三合一
-                if (device.needsThreeInOneCheck) {
-                    // 等待1.5秒确保响应到达（网络延迟可能较大）
-                    await this.sleep(1500);
-                    
-                    // 处理状态事件队列，确保所有响应都被处理
-                    await this.processStateEventQueue();
-                    
-                    if (device.isThreeInOne) {
-                        this.log(`[三合一检测] ${device.name} 确认为三合一面板`);
-                        device.needsThreeInOneCheck = false;
-                        this.deviceManager.saveDevices();
+                if (wasCheckingThreeInOne) {
+                    this.log(`[三合一检测] ${device.name} 进入等待循环，最多等待10秒...`);
+                    // 等待更长时间确保响应到达（网络延迟可能很大，最多等待10秒）
+                    // 分多次检查，一旦确认就立即继续
+                    let confirmed = false;
+                    for (let i = 0; i < 20; i++) {  // 20次 * 500ms = 10秒
+                        await this.sleep(500);
+                        await this.processStateEventQueue();
                         
-                        // 查询三合一的完整状态
-                        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);
+                        if (device.isThreeInOne) {
+                            confirmed = true;
+                            this.log(`[三合一检测] ${device.name} 确认为三合一面板（等待${(i+1)*0.5}秒后确认）`);
+                            device.needsThreeInOneCheck = false;
+                            // 使用文件持久化存储三合一标记
+                            this.deviceManager.markAsThreeInOne(device.macAddress);
+                            this.deviceManager.saveDevices();
+                            
+                            // 查询三合一的完整状态
+                            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);
+                            }
+                            break;
                         }
-                    } else {
-                        this.log(`[三合一检测] ${device.name} 确认为普通温控器`);
+                    }
+                    
+                    // 10秒后仍未确认为三合一，标记为普通温控器
+                    if (!confirmed && !device.isThreeInOne) {
+                        this.log(`[三合一检测] ${device.name} 确认为普通温控器（10秒内无三合一响应）`);
                         device.needsThreeInOneCheck = false;
                         device.thermostatConfirmed = true;
+                        // 使用文件持久化存储温控器标记
+                        this.deviceManager.markAsThermostat(device.macAddress);
                         this.deviceManager.saveDevices();
 
                         // 触发温控器确认事件
@@ -485,6 +550,11 @@ module.exports = function(RED) {
                             await this.sleep(150);
                         }
                     }
+                } else if (device.isThreeInOne && !this.deviceManager.isConfirmedThreeInOne(device.macAddress)) {
+                    // 设备已经被标记为三合一（可能在之前的响应中），但还没有持久化
+                    this.log(`[三合一检测] ${device.name} 已被标记为三合一，执行持久化`);
+                    this.deviceManager.markAsThreeInOne(device.macAddress);
+                    this.deviceManager.saveDevices();
                 }
             } catch(e) {
                 this.error(`查询设备${device.name}失败: ${e.message}`);

package/nodes/symi-ha-sync.js

@@ -64,7 +64,14 @@ module.exports = function(RED) {
     
     // 风速映射 (Mesh: 1=高, 2=中, 3=低, 4=自动)
     const FAN_MODE_TO_HA = { 1: 'high', 2: 'medium', 3: 'low', 4: 'auto' };
-    const HA_TO_FAN_MODE = { high: 1, medium: 2, low: 3, auto: 4 };
+    const HA_TO_FAN_MODE = { 
+        'high': 1, 'High': 1, 'HIGH': 1, 'strong': 1, '高风': 1, '强': 1,
+        'medium': 2, 'Medium': 2, 'MEDIUM': 2, 'middle': 2, '中风': 2, '中档': 2, '中': 2,
+        'low': 3, 'Low': 3, 'LOW': 3, 'weak': 3, '低风': 3, '弱': 3,
+        'auto': 4, 'Auto': 4, 'AUTO': 4, '自动': 4
+    };
+    // 专门用于发送给 HA 的风速映射（针对中文版 HA 实体）
+    const FAN_MODE_FOR_HA = { 1: '高风', 2: '中风', 3: '低风', 4: '自动' };
 
     function SymiHASyncNode(config) {
         RED.nodes.createNode(this, config);
@@ -110,7 +117,7 @@ module.exports = function(RED) {
             }
         } catch (e) {
             node.mappings = [];
-            node.error('映射配置解析失败: ' + e.message);
+            node.log('映射配置解析失败: ' + e.message);
         }
 
         node.commandQueue = [];
@@ -155,7 +162,7 @@ module.exports = function(RED) {
         
         if (configError) {
             node.status({ fill: 'red', shape: 'ring', text: configError });
-            node.warn(`[HA同步] ${configError}`);
+            node.log(`[HA同步] ${configError}`);
             // 不要return，继续注册input监听器
         } else {
             // 初始状态：只有Mesh→HA方向，等待HA输入连接
@@ -245,18 +252,35 @@ module.exports = function(RED) {
             const attrType = eventData.attrType;
             const state = eventData.state || {};
             
-            node.debug(`[Symi->HA] 设备状态变化: ${device.macAddress}, attrType=0x${attrType?.toString(16) || 'unknown'}, state=${JSON.stringify(state)}`);
+            // 对于三合一相关的 attrType，使用 log 级别以便调试
+            const isThreeInOneAttr = [ATTR_THREE_IN_ONE, ATTR_FRESH_AIR_SWITCH, ATTR_FRESH_AIR_MODE, 
+                ATTR_FRESH_AIR_SPEED, ATTR_FLOOR_HEATING_SWITCH, ATTR_FLOOR_HEATING_TEMP,
+                ATTR_TARGET_TEMP, ATTR_FAN_MODE, ATTR_CLIMATE_MODE].includes(attrType);
+            
+            if (isThreeInOneAttr) {
+                node.debug(`[Symi->HA] 三合一设备状态变化: ${device.macAddress}, attrType=0x${attrType?.toString(16) || 'unknown'}, isThreeInOne=${device.isThreeInOne}`);
+            } else {
+                node.debug(`[Symi->HA] 设备状态变化: ${device.macAddress}, attrType=0x${attrType?.toString(16) || 'unknown'}, state=${JSON.stringify(state)}`);
+            }
             
             // 遍历该设备的所有映射
             const deviceMappings = node.mappings.filter(m => 
                 m.symiMac.toLowerCase().replace(/:/g, '') === device.macAddress.toLowerCase().replace(/:/g, '')
             );
             if (deviceMappings.length === 0) {
-                node.debug(`[Symi->HA] 设备不在映射中: ${device.macAddress}`);
+                if (isThreeInOneAttr) {
+                    node.log(`[Symi->HA] 三合一设备不在映射中: ${device.macAddress}`);
+                } else {
+                    node.debug(`[Symi->HA] 设备不在映射中: ${device.macAddress}`);
+                }
                 return;
             }
             
-            node.debug(`[Symi->HA] 找到 ${deviceMappings.length} 个映射`);
+            if (isThreeInOneAttr) {
+                node.debug(`[Symi->HA] 找到 ${deviceMappings.length} 个映射: ${deviceMappings.map(m => `${m.symiKey}->${m.haEntityId}`).join(', ')}`);
+            } else {
+                node.debug(`[Symi->HA] 找到 ${deviceMappings.length} 个映射`);
+            }
             
             deviceMappings.forEach(mapping => {
                 // 检查同步模式 (0:双向, 1:Symi->HA, 2:HA->Symi)
@@ -271,50 +295,57 @@ module.exports = function(RED) {
                 // 根据attrType和实体类型处理
                 let syncData = null;
                 
-                switch (attrType) {
-                    case ATTR_SWITCH:  // 0x02 开关状态
-                        syncData = node.handleSwitchChange(device, mapping, state);
-                        break;
-                        
-                    case ATTR_BRIGHTNESS:  // 0x03 亮度
-                        if (domain === 'light') {
-                            syncData = node.handleBrightnessChange(device, mapping, state);
-                        }
-                        break;
-                        
-                    case ATTR_CURTAIN_STATUS:  // 0x05 窗帘运行状态
-                    case ATTR_CURTAIN_POSITION:  // 0x06 窗帘位置
-                        if (domain === 'cover') {
-                            syncData = node.handleCurtainChange(device, mapping, state, attrType);
-                        }
-                        break;
-                        
-                    case ATTR_TARGET_TEMP:  // 0x1B 目标温度
-                        if (domain === 'climate') {
-                            syncData = node.handleTemperatureChange(device, mapping, state);
-                        }
-                        break;
-                        
-                    case ATTR_FAN_MODE:  // 0x1C 风速
-                        if (domain === 'climate' || domain === 'fan') {
-                            syncData = node.handleFanModeChange(device, mapping, state);
-                        }
-                        break;
-                        
-                    case ATTR_CLIMATE_MODE:  // 0x1D 空调模式
-                        if (domain === 'climate') {
-                            syncData = node.handleClimateModeChange(device, mapping, state);
-                        }
-                        break;
-
-                    case ATTR_THREE_IN_ONE: // 0x94 三合一全量状态
-                    case ATTR_FRESH_AIR_SWITCH: // 0x68 新风开关
-                    case ATTR_FRESH_AIR_MODE: // 0x69 新风模式
-                    case ATTR_FRESH_AIR_SPEED: // 0x6A 新风风速
-                    case ATTR_FLOOR_HEATING_SWITCH: // 0x6B 地暖开关
-                    case ATTR_FLOOR_HEATING_TEMP: // 0x6C 地暖温度
-                        syncData = node.handleThreeInOneChange(device, mapping, state, attrType);
-                        break;
+                // 特殊处理：三合一设备的属性应该走三合一处理器
+                const useThreeInOneProcessor = device.isThreeInOne && (isThreeInOneAttr || attrType === ATTR_SWITCH);
+                
+                if (useThreeInOneProcessor) {
+                    syncData = node.handleThreeInOneChange(device, mapping, state, attrType);
+                } else {
+                    switch (attrType) {
+                        case ATTR_SWITCH:  // 0x02 开关状态
+                            syncData = node.handleSwitchChange(device, mapping, state);
+                            break;
+                            
+                        case ATTR_BRIGHTNESS:  // 0x03 亮度
+                            if (domain === 'light') {
+                                syncData = node.handleBrightnessChange(device, mapping, state);
+                            }
+                            break;
+                            
+                        case ATTR_CURTAIN_STATUS:  // 0x05 窗帘运行状态
+                        case ATTR_CURTAIN_POSITION:  // 0x06 窗帘位置
+                            if (domain === 'cover') {
+                                syncData = node.handleCurtainChange(device, mapping, state, attrType);
+                            }
+                            break;
+                            
+                        case ATTR_TARGET_TEMP:  // 0x1B 目标温度
+                            if (domain === 'climate') {
+                                syncData = node.handleTemperatureChange(device, mapping, state);
+                            }
+                            break;
+                            
+                        case ATTR_FAN_MODE:  // 0x1C 风速
+                            if (domain === 'climate' || domain === 'fan') {
+                                syncData = node.handleFanModeChange(device, mapping, state);
+                            }
+                            break;
+                            
+                        case ATTR_CLIMATE_MODE:  // 0x1D 空调模式
+                            if (domain === 'climate') {
+                                syncData = node.handleClimateModeChange(device, mapping, state);
+                            }
+                            break;
+    
+                        case ATTR_THREE_IN_ONE: // 0x94 三合一全量状态
+                        case ATTR_FRESH_AIR_SWITCH: // 0x68 新风开关
+                        case ATTR_FRESH_AIR_MODE: // 0x69 新风模式
+                        case ATTR_FRESH_AIR_SPEED: // 0x6A 新风风速
+                        case ATTR_FLOOR_HEATING_SWITCH: // 0x6B 地暖开关
+                        case ATTR_FLOOR_HEATING_TEMP: // 0x6C 地暖温度
+                            syncData = node.handleThreeInOneChange(device, mapping, state, attrType);
+                            break;
+                    }
                 }
                 
                 if (syncData) {
@@ -357,10 +388,44 @@ module.exports = function(RED) {
 
         // 处理三合一状态变化
         node.handleThreeInOneChange = function(device, mapping, state, attrType) {
-            const subType = mapping.symiKey; // 'aircon', 'fresh_air', 'floor_heating'
+            let subType = mapping.symiKey; // 'aircon'/'1', 'fresh_air'/'2', 'floor_heating'/'3'
+            
+            // 统一映射数字 ID 到字符串类型
+            if (subType === '1' || subType === 1) subType = 'aircon';
+            else if (subType === '2' || subType === 2) subType = 'fresh_air';
+            else if (subType === '3' || subType === 3) subType = 'floor_heating';
+            
             const mac = device.macAddress.toLowerCase().replace(/:/g, '');
             const changedData = [];
             
+            // 调试日志：记录收到的三合一事件
+            node.debug(`[Symi->HA] 三合一事件: mac=${mac}, subType=${subType}, attrType=0x${attrType.toString(16)}, state=${JSON.stringify(state)}`);
+            
+            // 根据 attrType 判断应该处理哪个子实体
+            // 0x94: 全量状态，处理所有子实体
+            // 0x68, 0x69, 0x6A: 新风相关
+            // 0x6B, 0x6C: 地暖相关
+            // 0x02, 0x1B, 0x1C, 0x1D: 空调相关
+            let shouldProcess = false;
+            if (attrType === ATTR_THREE_IN_ONE) {
+                // 0x94 全量状态，所有子实体都应该处理
+                shouldProcess = true;
+            } else if (attrType === ATTR_FRESH_AIR_SWITCH || attrType === ATTR_FRESH_AIR_MODE || attrType === ATTR_FRESH_AIR_SPEED) {
+                // 新风相关属性，只有 fresh_air 子实体处理
+                shouldProcess = (subType === 'fresh_air');
+            } else if (attrType === ATTR_FLOOR_HEATING_SWITCH || attrType === ATTR_FLOOR_HEATING_TEMP) {
+                // 地暖相关属性，只有 floor_heating 子实体处理
+                shouldProcess = (subType === 'floor_heating');
+            } else {
+                // 其他属性（如 0x02, 0x1B, 0x1C, 0x1D），只有 aircon 子实体处理
+                shouldProcess = (subType === 'aircon');
+            }
+            
+            if (!shouldProcess) {
+                node.debug(`[Symi->HA] 三合一跳过: attrType=0x${attrType.toString(16)} 不匹配 subType=${subType}`);
+                return null;
+            }
+            
             // 辅助函数：检查属性是否变化，使用细粒度缓存key
             const checkAndCacheProperty = (property, value, syncData) => {
                 if (value === undefined) return;
@@ -372,24 +437,33 @@ module.exports = function(RED) {
                 if (node.stateCache.hasChanged(cacheKey, value)) {
                     node.stateCache.update(cacheKey, value);
                     changedData.push(syncData);
-                    node.debug(`[三合一] ${subType}.${property} 变化: ${value}`);
+                    node.log(`[Symi->HA] 三合一 ${subType}.${property} 变化: ${value}`);
+                } else {
+                    node.debug(`[Symi->HA] 三合一 ${subType}.${property} 无变化: ${value}`);
                 }
             };
             
             // 1. 空调部分
             if (subType === 'aircon') {
+                // 将空调开关直接映射为 hvac_mode，以触发 HA 的 set_hvac_mode 服务
+                // 优先使用当前上报的模式，如果没有则使用缓存模式，最后兜底 cool
+                const currentMode = AC_MODE_TO_HA[state.climateMode] || AC_MODE_TO_HA[device.state.climateMode] || 'cool';
                 checkAndCacheProperty('switch', state.climateSwitch, 
-                    { type: 'switch', value: state.climateSwitch });
+                    { type: 'hvac_mode', value: state.climateSwitch ? currentMode : 'off', meshValue: state.climateMode });
+                
                 checkAndCacheProperty('temperature', state.targetTemp, 
                     { type: 'temperature', value: state.targetTemp });
+                
                 checkAndCacheProperty('mode', state.climateMode, 
                     { type: 'hvac_mode', value: AC_MODE_TO_HA[state.climateMode] || 'off', meshValue: state.climateMode });
+                
                 checkAndCacheProperty('fanSpeed', state.fanMode, 
                     { type: 'fan_mode', value: FAN_MODE_TO_HA[state.fanMode] || 'auto', meshValue: state.fanMode });
             }
             
             // 2. 新风部分
             else if (subType === 'fresh_air') {
+                // 新风如果是 fan 实体，可以使用 switch 类型（HA fan 支持 turn_on/off）
                 checkAndCacheProperty('switch', state.freshAirSwitch, 
                     { type: 'switch', value: state.freshAirSwitch });
                 checkAndCacheProperty('speed', state.freshAirSpeed, 
@@ -398,13 +472,16 @@ module.exports = function(RED) {
             
             // 3. 地暖部分
             else if (subType === 'floor_heating') {
+                // 地暖如果是 climate 实体，同样需要映射为 hvac_mode
                 checkAndCacheProperty('switch', state.floorHeatingSwitch, 
-                    { type: 'switch', value: state.floorHeatingSwitch });
+                    { type: 'hvac_mode', value: state.floorHeatingSwitch ? 'heat' : 'off' });
+                
                 checkAndCacheProperty('temperature', state.floorHeatingTemp, 
                     { type: 'temperature', value: state.floorHeatingTemp });
             }
             
             // 只返回真正变化的属性
+            node.log(`[Symi->HA] 三合一处理结果: subType=${subType}, changedData=${JSON.stringify(changedData)}`);
             return changedData.length > 0 ? changedData : null;
         };
 
@@ -530,14 +607,17 @@ module.exports = function(RED) {
                 const position = state.curtainPosition !== undefined ? state.curtainPosition : device.state.curtainPosition;
                 if (position === undefined) return null;
 
-                // 核心需求：忽略过程中的实时反馈指令
-                // 如果当前有任何控制方向的锁定（正在移动中），则忽略位置反馈
-                if (node.coverMoving[loopKey]) {
-                    node.debug(`[Symi->HA] 忽略移动中的实时位置反馈: ${position}%`);
-                    return null;
+                // 优化：允许在移动过程中上报位置，以便 HA 界面能看到动画
+                // 只有当锁定方向是 'ha' 且时间非常短（< 2s）时才认为是指令回显，予以忽略
+                if (node.coverMoving[loopKey] && node.coverMoving[loopKey].direction === 'ha') {
+                    const elapsed = now - node.coverMoving[loopKey].startTime;
+                    if (elapsed < 2000) {
+                        node.debug(`[Symi->HA] 忽略指令回显初期的位置反馈: ${position}%`);
+                        return null;
+                    }
                 }
 
-                // 没有移动锁定时，允许同步（例如初始同步或查询返回）
+                // 允许同步位置
                 return { type: 'position', value: position };
             }
             
@@ -968,6 +1048,8 @@ module.exports = function(RED) {
                                 if (meshFan !== undefined) {
                                     node.debug(`[HA->Symi] 空调风速: ${oldAttrs.fan_mode} -> ${attrs.fan_mode} (mesh: ${meshFan})`);
                                     syncDataList.push({ type: 'fan_mode', value: meshFan });
+                                } else {
+                                    node.warn(`[HA->Symi] 未知的空调风速值: "${attrs.fan_mode}"，请检查映射配置`);
                                 }
                             }
                         }
@@ -988,6 +1070,7 @@ module.exports = function(RED) {
                                 if (attrs.percentage > 66) meshFan = 1; // high
                                 else if (attrs.percentage > 33) meshFan = 2; // medium
                                 else if (attrs.percentage > 0) meshFan = 3; // low
+                                node.debug(`[HA->Symi] 新风百分比: ${attrs.percentage}% -> mesh: ${meshFan}`);
                                 syncDataList.push({ type: 'fan_mode', value: meshFan });
                             }
                         }
@@ -1081,7 +1164,13 @@ module.exports = function(RED) {
             try {
                 switch (syncData.type) {
                     case 'switch':
-                        service = syncData.value ? 'turn_on' : 'turn_off';
+                        if (domain === 'climate') {
+                            service = 'set_hvac_mode';
+                            // 默认开启模式为 cool，关闭为 off
+                            serviceData.hvac_mode = syncData.value ? 'cool' : 'off';
+                        } else {
+                            service = syncData.value ? 'turn_on' : 'turn_off';
+                        }
                         break;
                         
                     case 'brightness':
@@ -1125,15 +1214,23 @@ module.exports = function(RED) {
                         break;
                         
                     case 'fan_mode':
+                        // 根据 HA 的要求转换风速值
+                        let haFanMode = syncData.value;
                         if (domain === 'climate') {
                             service = 'set_fan_mode';
-                            serviceData.fan_mode = syncData.value;
+                            // 优先查找中文映射，解决 HA 报 500 错误的问题
+                            const meshValue = HA_TO_FAN_MODE[syncData.value];
+                            if (meshValue !== undefined && FAN_MODE_FOR_HA[meshValue]) {
+                                haFanMode = FAN_MODE_FOR_HA[meshValue];
+                            }
+                            serviceData.fan_mode = haFanMode;
                         } else if (domain === 'fan') {
-                            // 区分新风和普通风扇
-                            // 如果是新风且HA实体是fan
                             service = 'set_percentage';
                             const percentMap = { high: 100, medium: 66, low: 33, auto: 50 };
                             serviceData.percentage = percentMap[syncData.value] || 50;
+                        } else {
+                            service = 'set_fan_mode';
+                            serviceData.fan_mode = haFanMode;
                         }
                         break;
                         
@@ -1141,8 +1238,17 @@ module.exports = function(RED) {
                         return;
                 }
                 
+                // 如果 service 为空，说明该属性不支持同步到 HA
+                if (!service) {
+                    node.warn(`[Symi->HA] 属性 ${syncData.type} 在领域 ${domain} 下暂不支持同步`);
+                    return;
+                }
+                
+                // 确保使用正确的领域
                 const serviceDomain = (syncData.type === 'position' || syncData.type === 'curtain_stop' || syncData.type === 'curtain_action') ? 'cover' : domain;
                 
+                node.log(`[Symi->HA] 发送 HA 请求: ${serviceDomain}/${service}, 数据: ${JSON.stringify(serviceData)}`);
+                
                 await axios.post(`${baseURL}/api/services/${serviceDomain}/${service}`, serviceData, {
                     headers: {
                         'Authorization': `Bearer ${token}`,
@@ -1250,6 +1356,9 @@ module.exports = function(RED) {
             const { mapping, syncData } = cmd;
             const subType = mapping.symiKey;
             
+            // 调试日志：记录三合一控制请求
+            node.log(`[HA->Symi] 三合一控制请求: subType=${subType}, syncData=${JSON.stringify(syncData)}, networkAddr=0x${networkAddr.toString(16)}`);
+            
             // 动态获取gateway
             const currentGateway = gateway || (node.mqttNode && node.mqttNode.gateway);
             if (!currentGateway) {
@@ -1274,14 +1383,26 @@ module.exports = function(RED) {
                         case 'hvac_mode':
                             attrType = ATTR_CLIMATE_MODE;
                             // HA mode -> Mesh mode
-                            const haToMeshMode = { cool: 1, heat: 2, fan_only: 3, dry: 4, off: 0 };
-                            param = [haToMeshMode[syncData.value] || 1];
+                            const haToMeshMode = { 
+                                cool: 1, Cool: 1, COOL: 1,
+                                heat: 2, Heat: 2, HEAT: 2,
+                                fan_only: 3, Fan_only: 3, fan: 3,
+                                dry: 4, Dry: 4, DRY: 4,
+                                off: 0, Off: 0, OFF: 0
+                            };
+                            param = [haToMeshMode[syncData.value] !== undefined ? haToMeshMode[syncData.value] : 1];
                             break;
                         case 'fan_mode':
                             attrType = ATTR_FAN_MODE;
-                            // HA fan -> Mesh fan
-                            const haToMeshFan = { high: 1, medium: 2, low: 3, auto: 4 };
+                            // HA fan -> Mesh fan: high=1, medium=2, low=3, auto=4
+                            const haToMeshFan = { 
+                                high: 1, High: 1, HIGH: 1, strong: 1,
+                                medium: 2, Medium: 2, MEDIUM: 2, middle: 2,
+                                low: 3, Low: 3, LOW: 3, weak: 3,
+                                auto: 4, Auto: 4, AUTO: 4
+                            };
                             param = [haToMeshFan[syncData.value] || 4];
+                            node.log(`[HA->Symi] 空调风速: HA=${syncData.value} -> Mesh=${param[0]}`);
                             break;
                     }
                 } else if (subType === 'fresh_air') {
@@ -1293,8 +1414,13 @@ module.exports = function(RED) {
                             break;
                         case 'fan_mode':
                             attrType = ATTR_FRESH_AIR_SPEED;
-                            const haToMeshFan = { high: 1, medium: 2, low: 3, auto: 4 };
-                            param = [haToMeshFan[syncData.value] || 4];
+                            const haToMeshFanFresh = { 
+                                high: 1, High: 1, HIGH: 1, strong: 1,
+                                medium: 2, Medium: 2, MEDIUM: 2, middle: 2,
+                                low: 3, Low: 3, LOW: 3, weak: 3,
+                                auto: 4, Auto: 4, AUTO: 4
+                            };
+                            param = [haToMeshFanFresh[syncData.value] || 4];
                             break;
                     }
                 } else if (subType === 'floor_heating') {
@@ -1312,8 +1438,11 @@ module.exports = function(RED) {
                 }
                 
                 if (attrType && param) {
+                    node.log(`[HA->Symi] 发送控制命令: attrType=0x${attrType.toString(16)}, param=[${param.map(p => '0x' + p.toString(16)).join(', ')}]`);
                     await currentGateway.sendControl(networkAddr, attrType, param);
                     node.log(`[HA->Symi] ${mapping.haEntityId} -> ${mapping.symiName}(${subType}): ${syncData.type}=${JSON.stringify(syncData.value)}`);
+                } else {
+                    node.warn(`[HA->Symi] 三合一控制未匹配: subType=${subType}, syncData.type=${syncData.type}`);
                 }
                 
             } catch (err) {

package/nodes/symi-mqtt.js

@@ -1145,12 +1145,12 @@ module.exports = function(RED) {
                         node.publishCommandFeedback(device, command, payload, topic);
 
                     } catch(err) {
-                        node.error(`[MQTT发送] 失败: ${err.message}`);
+                        node.log(`[MQTT发送] 失败: ${err.message}`);
                     }
                 }
             })();
         } else {
-            node.warn(`[MQTT解析] 无法解析命令 - topic: ${topic}, payload: ${payload}`);
+            node.log(`[MQTT解析] 无法解析命令 - topic: ${topic}, payload: ${payload}`);
         }
     };
 

package/package.json

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