node-red-contrib-symi-mesh 1.7.7 → 1.7.9

package/nodes/symi-ha-sync.js

@@ -0,0 +1,787 @@
+/**
+ * Symi HA Sync Node - Symi设备与Home Assistant实体双向同步
+ * 版本: 1.7.9
+ * 
+ * 支持的实体类型和属性：
+ * - light: on/off, brightness (0-255)
+ * - switch/input_boolean: on/off
+ * - cover: open/close/stop, position (0-100)
+ * - climate: on/off, temperature, hvac_mode, fan_mode
+ * - fan: on/off, speed
+ */
+
+module.exports = function(RED) {
+    const axios = require('axios');
+    
+    // 常量定义
+    const LOOP_PREVENTION_MS = 2000;  // 防死循环时间窗口
+    const DEBOUNCE_MS = 500;          // 防抖时间（窗帘/调光用）
+    const MAX_QUEUE_SIZE = 100;
+    const CLEANUP_INTERVAL_MS = 60000;
+    const TIMESTAMP_EXPIRE_MS = 60000;
+
+    // Mesh属性类型
+    const ATTR_SWITCH = 0x02;
+    const ATTR_BRIGHTNESS = 0x03;
+    const ATTR_CURTAIN_STATUS = 0x05;
+    const ATTR_CURTAIN_POSITION = 0x06;
+    const ATTR_TARGET_TEMP = 0x1B;
+    const ATTR_FAN_MODE = 0x1C;
+    const ATTR_CLIMATE_MODE = 0x1D;
+
+    // 空调模式映射
+    const AC_MODE_TO_HA = { 1: 'cool', 2: 'heat', 3: 'fan_only', 4: 'dry' };
+    const HA_TO_AC_MODE = { cool: 1, heat: 2, fan_only: 3, dry: 4, off: 0 };
+    
+    // 风速映射 (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 };
+
+    function SymiHASyncNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        node.name = config.name || 'HA同步';
+        node.mqttNode = RED.nodes.getNode(config.mqttConfig);
+        node.haServer = RED.nodes.getNode(config.haServer);
+        
+        // 解析映射配置
+        try {
+            const rawMappings = JSON.parse(config.mappings || '[]');
+            node.mappings = rawMappings.map(m => ({
+                symiMac: m.symiMac,
+                symiKey: parseInt(m.symiKey) || 1,
+                haEntityId: m.haEntityId,
+                symiName: m.symiName || '',
+                haEntityName: m.haEntityName || ''
+            })).filter(m => m.symiMac && m.haEntityId);
+            
+            if (node.mappings.length > 0) {
+                node.log(`[HA同步] 已加载 ${node.mappings.length} 个映射`);
+            }
+        } catch (e) {
+            node.mappings = [];
+            node.error('映射配置解析失败: ' + e.message);
+        }
+
+        node.commandQueue = [];
+        node.processing = false;
+        node.lastSymiToHa = {};
+        node.lastHaToSymi = {};
+        node.pendingDebounce = {};  // 防抖定时器
+        
+        node.status({ fill: 'yellow', shape: 'ring', text: '初始化中' });
+
+        // 检查配置
+        if (!node.mqttNode) {
+            node.status({ fill: 'red', shape: 'ring', text: '未配置MQTT节点' });
+            return;
+        }
+        if (!node.haServer) {
+            node.status({ fill: 'red', shape: 'ring', text: '未配置HA服务器' });
+            return;
+        }
+
+        // 获取Gateway引用
+        const gateway = node.mqttNode.gateway;
+        if (!gateway) {
+            node.status({ fill: 'red', shape: 'ring', text: 'MQTT节点未关联网关' });
+            return;
+        }
+
+        node.status({ fill: 'green', shape: 'dot', text: `运行中 (${node.mappings.length}组)` });
+
+        // 定期清理过期的防抖时间戳
+        node.cleanupInterval = setInterval(function() {
+            const now = Date.now();
+            for (const key in node.lastSymiToHa) {
+                if (now - node.lastSymiToHa[key] > TIMESTAMP_EXPIRE_MS) {
+                    delete node.lastSymiToHa[key];
+                }
+            }
+            for (const key in node.lastHaToSymi) {
+                if (now - node.lastHaToSymi[key] > TIMESTAMP_EXPIRE_MS) {
+                    delete node.lastHaToSymi[key];
+                }
+            }
+        }, CLEANUP_INTERVAL_MS);
+
+        // 防死循环检查 - 双向时间戳检查
+        node.shouldPreventSync = function(direction, key) {
+            const now = Date.now();
+            if (direction === 'symi-to-ha') {
+                const lastHaTime = node.lastHaToSymi[key] || 0;
+                return (now - lastHaTime) < LOOP_PREVENTION_MS;
+            } else {
+                const lastSymiTime = node.lastSymiToHa[key] || 0;
+                return (now - lastSymiTime) < LOOP_PREVENTION_MS;
+            }
+        };
+
+        node.recordSyncTime = function(direction, key) {
+            const now = Date.now();
+            if (direction === 'symi-to-ha') {
+                node.lastSymiToHa[key] = now;
+            } else {
+                node.lastHaToSymi[key] = now;
+            }
+        };
+
+        node.sleep = function(ms) {
+            return new Promise(resolve => setTimeout(resolve, ms));
+        };
+
+        // 查找映射
+        node.findMappingsBySymi = function(mac, key) {
+            return node.mappings.filter(m => 
+                m.symiMac.toLowerCase().replace(/:/g, '') === mac.toLowerCase().replace(/:/g, '') && 
+                m.symiKey === key
+            );
+        };
+
+        node.findMappingsByHa = function(entityId) {
+            return node.mappings.filter(m => m.haEntityId === entityId);
+        };
+
+        // 获取HA实体域
+        node.getEntityDomain = function(entityId) {
+            return entityId ? entityId.split('.')[0] : '';
+        };
+
+        // ========== 1. 监听Symi设备状态变化 (Symi -> HA) ==========
+        node.handleSymiStateChange = function(eventData) {
+            if (!eventData.device || !eventData.device.macAddress) return;
+            
+            const device = eventData.device;
+            const attrType = eventData.attrType;
+            const state = eventData.state || {};
+            
+            // 遍历该设备的所有映射
+            const deviceMappings = node.mappings.filter(m => 
+                m.symiMac.toLowerCase().replace(/:/g, '') === device.macAddress.toLowerCase().replace(/:/g, '')
+            );
+            if (deviceMappings.length === 0) return;
+            
+            deviceMappings.forEach(mapping => {
+                const domain = node.getEntityDomain(mapping.haEntityId);
+                const loopKey = `${mapping.symiMac}_${mapping.symiKey}_${mapping.haEntityId}`;
+                
+                // 根据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;
+                }
+                
+                if (syncData) {
+                    if (node.shouldPreventSync('symi-to-ha', loopKey)) {
+                        node.debug(`[Symi->HA] 跳过(防死循环): ${loopKey}`);
+                        return;
+                    }
+                    
+                    node.queueCommand({
+                        direction: 'symi-to-ha',
+                        mapping: mapping,
+                        syncData: syncData,
+                        key: loopKey
+                    });
+                }
+            });
+        };
+
+        // 处理开关状态变化
+        node.handleSwitchChange = function(device, mapping, state) {
+            let isOn = false;
+            
+            if (device.channels === 1) {
+                isOn = state.switch !== undefined ? state.switch : device.state.power;
+            } else {
+                // 多路开关
+                const channelKey = `switch_${mapping.symiKey}`;
+                isOn = state[channelKey] !== undefined ? state[channelKey] : device.state[channelKey];
+            }
+            
+            if (isOn === undefined) return null;
+            
+            return { type: 'switch', value: isOn };
+        };
+
+        // 处理亮度变化
+        node.handleBrightnessChange = function(device, mapping, state) {
+            const brightness = state.brightness !== undefined ? state.brightness : device.state.brightness;
+            if (brightness === undefined) return null;
+            
+            // Mesh亮度0-100，HA亮度0-255
+            const haBrightness = Math.round(brightness * 255 / 100);
+            return { type: 'brightness', value: haBrightness, meshValue: brightness };
+        };
+
+        // 处理窗帘变化（带防抖）
+        node.handleCurtainChange = function(device, mapping, state, attrType) {
+            const domain = node.getEntityDomain(mapping.haEntityId);
+            if (domain !== 'cover') return null;
+            
+            // 窗帘位置变化 - 使用防抖，只同步最终位置
+            if (attrType === ATTR_CURTAIN_POSITION) {
+                const position = state.curtainPosition !== undefined ? state.curtainPosition : device.state.curtainPosition;
+                if (position === undefined) return null;
+                
+                // 防抖处理：取消之前的定时器，设置新的
+                const debounceKey = `curtain_${mapping.symiMac}_${mapping.symiKey}`;
+                if (node.pendingDebounce[debounceKey]) {
+                    clearTimeout(node.pendingDebounce[debounceKey]);
+                }
+                
+                // 延迟同步，等待位置稳定
+                node.pendingDebounce[debounceKey] = setTimeout(() => {
+                    delete node.pendingDebounce[debounceKey];
+                    const loopKey = `${mapping.symiMac}_${mapping.symiKey}_${mapping.haEntityId}`;
+                    if (!node.shouldPreventSync('symi-to-ha', loopKey)) {
+                        node.queueCommand({
+                            direction: 'symi-to-ha',
+                            mapping: mapping,
+                            syncData: { type: 'position', value: position },
+                            key: loopKey
+                        });
+                    }
+                }, DEBOUNCE_MS);
+                
+                return null;  // 不立即同步
+            }
+            
+            // 窗帘运行状态 - 可选同步动作
+            if (attrType === ATTR_CURTAIN_STATUS) {
+                const action = state.curtainAction || device.state.curtainAction;
+                if (action === 'stopped') {
+                    return { type: 'curtain_stop' };
+                }
+            }
+            
+            return null;
+        };
+
+        // 处理温度变化
+        node.handleTemperatureChange = function(device, mapping, state) {
+            const temp = state.targetTemp !== undefined ? state.targetTemp : device.state.targetTemp;
+            if (temp === undefined) return null;
+            return { type: 'temperature', value: temp };
+        };
+
+        // 处理风速变化
+        node.handleFanModeChange = function(device, mapping, state) {
+            const fanMode = state.fanMode !== undefined ? state.fanMode : device.state.fanMode;
+            if (fanMode === undefined) return null;
+            
+            const haFanMode = FAN_MODE_TO_HA[fanMode] || 'auto';
+            return { type: 'fan_mode', value: haFanMode, meshValue: fanMode };
+        };
+
+        // 处理空调模式变化
+        node.handleClimateModeChange = function(device, mapping, state) {
+            const mode = state.climateMode !== undefined ? state.climateMode : device.state.climateMode;
+            if (mode === undefined) return null;
+            
+            const haMode = AC_MODE_TO_HA[mode] || 'off';
+            return { type: 'hvac_mode', value: haMode, meshValue: mode };
+        };
+
+        // 监听网关事件
+        gateway.on('device-state-changed', node.handleSymiStateChange);
+
+        // ========== 2. 监听HA状态变化 (HA -> Symi) ==========
+        
+        // 方式A: 通过Input输入 (server-state-changed节点)
+        node.on('input', function(msg) {
+            if (msg.data && msg.data.entity_id && msg.data.new_state) {
+                node.handleHaStateChange(msg.data.entity_id, msg.data.new_state, msg.data.old_state);
+            }
+        });
+        
+        // 方式B: 尝试订阅HA Server事件总线
+        if (node.haServer && node.haServer.eventBus) {
+            node.haEventHandler = (evt) => {
+                if (evt && evt.event_type === 'state_changed' && evt.data) {
+                    node.handleHaStateChange(evt.data.entity_id, evt.data.new_state, evt.data.old_state);
+                }
+            };
+            node.haServer.eventBus.on('ha_events:all', node.haEventHandler);
+            node.log('[HA同步] 已订阅HA事件总线');
+        }
+
+        node.handleHaStateChange = function(entityId, newState, oldState) {
+            if (!newState) return;
+            
+            const mappings = node.findMappingsByHa(entityId);
+            if (mappings.length === 0) return;
+            
+            const domain = node.getEntityDomain(entityId);
+            const attrs = newState.attributes || {};
+            const oldAttrs = oldState ? (oldState.attributes || {}) : {};
+            
+            mappings.forEach(mapping => {
+                const loopKey = `${mapping.symiMac}_${mapping.symiKey}_${mapping.haEntityId}`;
+                
+                // 根据实体类型提取变化
+                let syncDataList = [];
+                
+                switch (domain) {
+                    case 'switch':
+                    case 'input_boolean':
+                        if (!oldState || newState.state !== oldState.state) {
+                            if (newState.state === 'on' || newState.state === 'off') {
+                                syncDataList.push({ type: 'switch', value: newState.state === 'on' });
+                            }
+                        }
+                        break;
+                        
+                    case 'light':
+                        // 开关状态
+                        if (!oldState || newState.state !== oldState.state) {
+                            if (newState.state === 'on' || newState.state === 'off') {
+                                syncDataList.push({ type: 'switch', value: newState.state === 'on' });
+                            }
+                        }
+                        // 亮度变化（仅当灯开着时）
+                        if (newState.state === 'on' && attrs.brightness !== undefined) {
+                            if (!oldState || oldAttrs.brightness !== attrs.brightness) {
+                                // HA亮度0-255，Mesh亮度0-100
+                                const meshBrightness = Math.round(attrs.brightness * 100 / 255);
+                                syncDataList.push({ type: 'brightness', value: meshBrightness });
+                            }
+                        }
+                        break;
+                        
+                    case 'cover':
+                        // 窗帘位置
+                        if (attrs.current_position !== undefined) {
+                            if (!oldState || oldAttrs.current_position !== attrs.current_position) {
+                                syncDataList.push({ type: 'position', value: attrs.current_position });
+                            }
+                        }
+                        // 窗帘动作
+                        if (newState.state !== oldState?.state) {
+                            if (newState.state === 'open') {
+                                syncDataList.push({ type: 'curtain_action', value: 'open' });
+                            } else if (newState.state === 'closed') {
+                                syncDataList.push({ type: 'curtain_action', value: 'close' });
+                            }
+                        }
+                        break;
+                        
+                    case 'climate':
+                        // 开关状态
+                        if (!oldState || newState.state !== oldState.state) {
+                            const isOn = newState.state !== 'off' && newState.state !== 'unavailable';
+                            syncDataList.push({ type: 'switch', value: isOn });
+                        }
+                        // 目标温度
+                        if (attrs.temperature !== undefined) {
+                            if (!oldState || oldAttrs.temperature !== attrs.temperature) {
+                                syncDataList.push({ type: 'temperature', value: Math.round(attrs.temperature) });
+                            }
+                        }
+                        // HVAC模式
+                        if (attrs.hvac_mode !== undefined || newState.state !== oldState?.state) {
+                            const hvacMode = attrs.hvac_mode || newState.state;
+                            if (!oldState || (oldAttrs.hvac_mode || oldState.state) !== hvacMode) {
+                                const meshMode = HA_TO_AC_MODE[hvacMode];
+                                if (meshMode !== undefined) {
+                                    syncDataList.push({ type: 'hvac_mode', value: meshMode });
+                                }
+                            }
+                        }
+                        // 风速
+                        if (attrs.fan_mode !== undefined) {
+                            if (!oldState || oldAttrs.fan_mode !== attrs.fan_mode) {
+                                const meshFan = HA_TO_FAN_MODE[attrs.fan_mode];
+                                if (meshFan !== undefined) {
+                                    syncDataList.push({ type: 'fan_mode', value: meshFan });
+                                }
+                            }
+                        }
+                        break;
+                        
+                    case 'fan':
+                        // 开关
+                        if (!oldState || newState.state !== oldState.state) {
+                            if (newState.state === 'on' || newState.state === 'off') {
+                                syncDataList.push({ type: 'switch', value: newState.state === 'on' });
+                            }
+                        }
+                        // 风速
+                        if (attrs.percentage !== undefined) {
+                            if (!oldState || oldAttrs.percentage !== attrs.percentage) {
+                                // 百分比转风速档位
+                                let meshFan = 4; // auto
+                                if (attrs.percentage > 66) meshFan = 1; // high
+                                else if (attrs.percentage > 33) meshFan = 2; // medium
+                                else if (attrs.percentage > 0) meshFan = 3; // low
+                                syncDataList.push({ type: 'fan_mode', value: meshFan });
+                            }
+                        }
+                        break;
+                }
+                
+                // 队列同步命令
+                syncDataList.forEach(syncData => {
+                    if (node.shouldPreventSync('ha-to-symi', loopKey)) {
+                        node.debug(`[HA->Symi] 跳过(防死循环): ${loopKey} ${syncData.type}`);
+                        return;
+                    }
+                    
+                    node.queueCommand({
+                        direction: 'ha-to-symi',
+                        mapping: mapping,
+                        syncData: syncData,
+                        key: loopKey
+                    });
+                });
+            });
+        };
+
+        // ========== 队列处理 ==========
+        node.queueCommand = function(cmd) {
+            if (node.commandQueue.length >= MAX_QUEUE_SIZE) {
+                node.commandQueue.shift();
+            }
+            
+            // 去重：相同方向、相同映射、相同类型的命令在短时间内只保留最新的
+            const existing = node.commandQueue.findIndex(c =>
+                c.direction === cmd.direction &&
+                c.mapping.symiMac === cmd.mapping.symiMac &&
+                c.mapping.symiKey === cmd.mapping.symiKey &&
+                c.mapping.haEntityId === cmd.mapping.haEntityId &&
+                c.syncData.type === cmd.syncData.type &&
+                Date.now() - (c.timestamp || 0) < DEBOUNCE_MS
+            );
+            
+            if (existing >= 0) {
+                node.commandQueue[existing].syncData = cmd.syncData;
+                return;
+            }
+            
+            cmd.timestamp = Date.now();
+            node.commandQueue.push(cmd);
+            node.processQueue();
+        };
+
+        node.processQueue = async function() {
+            if (node.processing || node.commandQueue.length === 0) return;
+            node.processing = true;
+            
+            try {
+                while (node.commandQueue.length > 0) {
+                    const cmd = node.commandQueue.shift();
+                    try {
+                        if (cmd.direction === 'symi-to-ha') {
+                            await node.syncSymiToHa(cmd);
+                        } else {
+                            await node.syncHaToSymi(cmd);
+                        }
+                        await node.sleep(50);
+                    } catch (err) {
+                        node.error(`同步失败: ${err.message}`);
+                    }
+                }
+            } finally {
+                node.processing = false;
+            }
+        };
+
+        // ========== 执行 Symi -> HA ==========
+        node.syncSymiToHa = async function(cmd) {
+            const { mapping, syncData, key } = cmd;
+            node.recordSyncTime('symi-to-ha', key);
+            
+            if (!node.haServer || !node.haServer.credentials) return;
+            
+            const baseURL = node.haServer.credentials.host || 'http://localhost:8123';
+            const token = node.haServer.credentials.access_token;
+            if (!token) return;
+            
+            const domain = node.getEntityDomain(mapping.haEntityId);
+            let service = '';
+            let serviceData = { entity_id: mapping.haEntityId };
+            
+            try {
+                switch (syncData.type) {
+                    case 'switch':
+                        service = syncData.value ? 'turn_on' : 'turn_off';
+                        break;
+                        
+                    case 'brightness':
+                        service = 'turn_on';
+                        serviceData.brightness = syncData.value;  // 已经是0-255
+                        break;
+                        
+                    case 'position':
+                        service = 'set_cover_position';
+                        serviceData.position = syncData.value;
+                        break;
+                        
+                    case 'curtain_stop':
+                        service = 'stop_cover';
+                        break;
+                        
+                    case 'temperature':
+                        service = 'set_temperature';
+                        serviceData.temperature = syncData.value;
+                        break;
+                        
+                    case 'hvac_mode':
+                        service = 'set_hvac_mode';
+                        serviceData.hvac_mode = syncData.value;
+                        break;
+                        
+                    case 'fan_mode':
+                        if (domain === 'climate') {
+                            service = 'set_fan_mode';
+                            serviceData.fan_mode = syncData.value;
+                        } else if (domain === 'fan') {
+                            service = 'set_percentage';
+                            // 风速档位转百分比
+                            const percentMap = { high: 100, medium: 66, low: 33, auto: 50 };
+                            serviceData.percentage = percentMap[syncData.value] || 50;
+                        }
+                        break;
+                        
+                    default:
+                        return;
+                }
+                
+                const serviceDomain = (syncData.type === 'position' || syncData.type === 'curtain_stop') ? 'cover' : domain;
+                
+                await axios.post(`${baseURL}/api/services/${serviceDomain}/${service}`, serviceData, {
+                    headers: {
+                        'Authorization': `Bearer ${token}`,
+                        'Content-Type': 'application/json'
+                    },
+                    timeout: 5000
+                });
+                
+                node.log(`[Symi->HA] ${mapping.symiName || mapping.symiMac} -> ${mapping.haEntityId}: ${syncData.type}=${JSON.stringify(syncData.value)}`);
+                
+                // 输出到debug
+                node.send({
+                    topic: 'ha-sync/symi-to-ha',
+                    payload: {
+                        direction: 'Symi→HA',
+                        symiMac: mapping.symiMac,
+                        symiKey: mapping.symiKey,
+                        haEntityId: mapping.haEntityId,
+                        syncType: syncData.type,
+                        value: syncData.value,
+                        timestamp: Date.now()
+                    }
+                });
+                
+            } catch (err) {
+                node.error(`[Symi->HA] 调用失败: ${err.message}`);
+            }
+        };
+
+        // ========== 执行 HA -> Symi ==========
+        node.syncHaToSymi = async function(cmd) {
+            const { mapping, syncData, key } = cmd;
+            node.recordSyncTime('ha-to-symi', key);
+            
+            const device = gateway.getDevice(mapping.symiMac);
+            if (!device) {
+                node.warn(`[HA->Symi] 设备未找到: ${mapping.symiMac}`);
+                return;
+            }
+            
+            const networkAddr = device.networkAddress;
+            const channels = device.channels;
+            const targetChannel = mapping.symiKey;
+            
+            try {
+                let attrType, param;
+                
+                switch (syncData.type) {
+                    case 'switch':
+                        attrType = ATTR_SWITCH;
+                        param = [channels, targetChannel, syncData.value ? 1 : 0];
+                        break;
+                        
+                    case 'brightness':
+                        attrType = ATTR_BRIGHTNESS;
+                        // Mesh亮度0-100
+                        param = [syncData.value];
+                        break;
+                        
+                    case 'position':
+                        attrType = ATTR_CURTAIN_POSITION;
+                        param = [syncData.value];
+                        break;
+                        
+                    case 'curtain_action':
+                        attrType = ATTR_CURTAIN_STATUS;
+                        // 1=打开, 2=关闭, 3=停止
+                        const actionMap = { open: 1, close: 2, stop: 3 };
+                        param = [actionMap[syncData.value] || 3];
+                        break;
+                        
+                    case 'temperature':
+                        attrType = ATTR_TARGET_TEMP;
+                        param = [syncData.value];
+                        break;
+                        
+                    case 'hvac_mode':
+                        attrType = ATTR_CLIMATE_MODE;
+                        param = [syncData.value];
+                        break;
+                        
+                    case 'fan_mode':
+                        attrType = ATTR_FAN_MODE;
+                        param = [syncData.value];
+                        break;
+                        
+                    default:
+                        return;
+                }
+                
+                await gateway.sendControl(networkAddr, attrType, param);
+                
+                node.log(`[HA->Symi] ${mapping.haEntityId} -> ${device.name || mapping.symiMac}: ${syncData.type}=${JSON.stringify(syncData.value)}`);
+                
+                // 输出到debug
+                node.send({
+                    topic: 'ha-sync/ha-to-symi',
+                    payload: {
+                        direction: 'HA→Symi',
+                        haEntityId: mapping.haEntityId,
+                        symiMac: mapping.symiMac,
+                        symiKey: mapping.symiKey,
+                        syncType: syncData.type,
+                        value: syncData.value,
+                        attrType: attrType,
+                        timestamp: Date.now()
+                    }
+                });
+                
+            } catch (err) {
+                node.error(`[HA->Symi] 控制失败: ${err.message}`);
+            }
+        };
+
+        // ========== 节点关闭 ==========
+        node.on('close', function(done) {
+            if (node.cleanupInterval) {
+                clearInterval(node.cleanupInterval);
+            }
+            // 清理防抖定时器
+            for (const key in node.pendingDebounce) {
+                clearTimeout(node.pendingDebounce[key]);
+            }
+            node.pendingDebounce = {};
+            
+            if (gateway) {
+                gateway.removeListener('device-state-changed', node.handleSymiStateChange);
+            }
+            if (node.haServer && node.haServer.eventBus && node.haEventHandler) {
+                node.haServer.eventBus.removeListener('ha_events:all', node.haEventHandler);
+            }
+            node.commandQueue = [];
+            done();
+        });
+    }
+
+    RED.nodes.registerType('symi-ha-sync', SymiHASyncNode);
+
+    // ========== HTTP API ==========
+    
+    // 加载Symi设备
+    RED.httpAdmin.get('/symi-ha-sync/symi-devices/:id', function(req, res) {
+        const mqttNode = RED.nodes.getNode(req.params.id);
+        if (!mqttNode || !mqttNode.gateway) {
+            return res.json([]);
+        }
+        
+        try {
+            const devices = mqttNode.gateway.deviceManager.getAllDevices();
+            const list = devices.map(d => ({
+                name: d.name,
+                macAddress: d.macAddress,
+                channels: d.channels,
+                deviceType: d.deviceType,
+                entityType: d.getEntityType()
+            }));
+            res.json(list);
+        } catch (err) {
+            res.json([]);
+        }
+    });
+
+    // 加载HA实体 - 支持更多实体类型
+    RED.httpAdmin.get('/symi-ha-sync/ha-entities/:id', async function(req, res) {
+        try {
+            const serverNode = RED.nodes.getNode(req.params.id);
+            if (!serverNode || !serverNode.credentials) return res.json([]);
+            
+            const baseURL = serverNode.credentials.host || 'http://localhost:8123';
+            const token = serverNode.credentials.access_token;
+            
+            if (!token) return res.json([]);
+            
+            const response = await axios.get(`${baseURL}/api/states`, {
+                headers: { 'Authorization': `Bearer ${token}` },
+                timeout: 5000
+            });
+            
+            const entities = [];
+            // 支持的实体类型
+            const supportedDomains = ['switch', 'light', 'input_boolean', 'cover', 'climate', 'fan'];
+            
+            if (response.data && Array.isArray(response.data)) {
+                response.data.forEach(state => {
+                    if (!state || !state.entity_id) return;
+                    const domain = state.entity_id.split('.')[0];
+                    if (supportedDomains.includes(domain)) {
+                        entities.push({
+                            entity_id: state.entity_id,
+                            name: (state.attributes && state.attributes.friendly_name) || state.entity_id,
+                            type: domain
+                        });
+                    }
+                });
+            }
+            res.json(entities);
+        } catch (err) {
+            res.json([]);
+        }
+    });
+};