node-red-contrib-symi-mesh 1.2.3

package/nodes/symi-mqtt.js

@@ -0,0 +1,1113 @@
+/**
+ * Symi MQTT Bridge Node
+ * 提供Home Assistant MQTT Discovery和状态同步
+ */
+
+const mqtt = require('mqtt');
+const { generateDiscoveryConfig, generateStateTopics, convertStateValue } = require('../lib/mqtt-helper');
+
+module.exports = function(RED) {
+    function SymiMQTTNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+        
+        node.gateway = RED.nodes.getNode(config.gateway);
+        node.mqttBroker = config.mqttBroker;
+        node.mqttUsername = config.mqttUsername;
+        node.mqttPassword = config.mqttPassword;
+        node.mqttPrefix = config.mqttPrefix || 'homeassistant';
+        
+        if (!node.gateway) {
+            node.error('未配置网关');
+            node.status({ fill: 'red', shape: 'ring', text: '未配置网关' });
+            return;
+        }
+        
+        node.mqttClient = null;
+        node.publishedDevices = new Set();
+        node.subscriptions = new Map();
+        
+        node.status({ fill: 'yellow', shape: 'ring', text: '连接中' });
+        
+        node.connectMQTT();
+        
+        node.gateway.on('device-list-complete', (devices) => {
+            if (node.mqttClient && node.mqttClient.connected) {
+                setTimeout(() => {
+                    node.log(`网关设备列表同步完成，发布${devices.length}个设备到MQTT`);
+                    node.publishAllDiscovery(devices);
+                }, 500);
+            } else {
+                node.warn('设备列表已完成但MQTT未连接，等待MQTT连接后发布');
+            }
+        });
+        
+        node.gateway.on('gateway-connected', () => {
+            node.log('网关已连接，等待设备发现完成');
+        });
+        
+        node.gateway.on('gateway-disconnected', () => {
+            node.log('网关已断开');
+        });
+        
+        node.gateway.on('device-state-changed', (eventData) => {
+            if (node.mqttClient && node.mqttClient.connected) {
+                node.publishDeviceState(eventData);
+            }
+        });
+        
+        
+        node.on('close', (done) => {
+            if (node.mqttClient && node.mqttClient.connected) {
+                const devices = node.gateway.deviceManager.getAllDevices();
+                devices.forEach(device => {
+                    const macClean = device.macAddress.replace(/:/g, '').toLowerCase();
+                    node.mqttClient.publish(`symi_mesh/${macClean}/availability`, 'offline', { retain: true });
+                });
+                
+                setTimeout(() => {
+                    node.mqttClient.end(false, {}, done);
+                }, 200);
+            } else {
+                done();
+            }
+        });
+    }
+
+    SymiMQTTNode.prototype.connectMQTT = function() {
+        const node = this;
+        
+        try {
+            const options = {
+                clientId: `symi-mesh-${Math.random().toString(16).substring(2, 10)}`,
+                clean: true,
+                reconnectPeriod: 5000
+            };
+            
+            if (node.mqttUsername) {
+                options.username = node.mqttUsername;
+                options.password = node.mqttPassword;
+            }
+            
+            node.mqttClient = mqtt.connect(node.mqttBroker, options);
+            
+            node.mqttClient.on('message', (topic, message) => {
+                node.log(`[MQTT消息] topic=${topic}, message=${message.toString()}`);
+                node.handleMQTTMessage(topic, message);
+            });
+            
+            node.mqttClient.on('connect', () => {
+                node.log('MQTT已连接');
+                node.status({ fill: 'green', shape: 'dot', text: '已连接' });
+                
+                // MQTT重连后需要重新发布设备（因为broker可能重启了）
+                node.publishedDevices.clear();
+                node.subscriptions.clear();
+                
+                if (node.gateway.deviceListComplete) {
+                    const devices = node.gateway.deviceManager.getAllDevices();
+                    setTimeout(() => {
+                        node.log(`MQTT重连后重新发布${devices.length}个设备`);
+                        node.publishAllDiscovery(devices);
+                    }, 1000);
+                }
+            });
+            
+            node.mqttClient.on('reconnect', () => {
+                node.log('MQTT正在重连...');
+                node.status({ fill: 'yellow', shape: 'ring', text: '重连中' });
+            });
+            
+            node.mqttClient.on('error', (error) => {
+                node.error(`MQTT错误: ${error.message}`);
+                node.status({ fill: 'red', shape: 'ring', text: '错误' });
+            });
+            
+            node.mqttClient.on('offline', () => {
+                node.status({ fill: 'yellow', shape: 'ring', text: '离线' });
+            });
+            
+        } catch (error) {
+            node.error(`MQTT连接失败: ${error.message}`);
+            node.status({ fill: 'red', shape: 'ring', text: '失败' });
+        }
+    };
+
+    SymiMQTTNode.prototype.publishAllDiscovery = function(devices) {
+        const node = this;
+        
+        const supportedTypes = [1, 2, 3, 4, 5, 8, 9, 10, 0x18];
+        
+        devices.forEach(device => {
+            const macClean = device.macAddress.replace(/:/g, '').toLowerCase();
+            
+            // 跳过正在检测中的设备（等待三合一识别完成）
+            if (device.needsThreeInOneCheck) {
+                node.log(`设备${device.name}正在检测类型，跳过发布（等待识别完成）`);
+                return; // 不添加到publishedDevices，等识别完成后再发布
+            }
+            
+            // 跳过温控器类型但未确认的设备（防止在识别过程中被提前发布）
+            if (device.deviceType === 10 && !device.isThreeInOne && !device.thermostatConfirmed) {
+                node.log(`温控器${device.name}尚未确认类型，跳过发布`);
+                return;
+            }
+            
+            // 三合一设备通过isThreeInOne标记识别，不依赖deviceType
+            if (!supportedTypes.includes(device.deviceType) && !device.isThreeInOne) {
+                node.log(`跳过非支持设备: ${device.name} (type=${device.deviceType})`);
+                return;
+            }
+            
+            if (node.publishedDevices.has(macClean)) {
+                node.log(`设备已发布，跳过: ${device.name}`);
+                return;
+            }
+            
+            const configs = generateDiscoveryConfig(device, node.mqttPrefix);
+            const topics = generateStateTopics(device);
+            
+            node.log(`发布设备 ${device.name} (${configs.length}个实体)`);
+            
+            // 先立即发布availability: online，确保HA认为设备可用
+            node.mqttClient.publish(`symi_mesh/${macClean}/availability`, 'online', { retain: true }, (err) => {
+                if (err) {
+                    node.error(`发布availability失败: ${err.message}`);
+                }
+            });
+            
+            // 延迟发布discovery config，确保availability先到达
+            configs.forEach((config, index) => {
+                setTimeout(() => {
+                    node.mqttClient.publish(config.topic, config.payload, { retain: true }, (err) => {
+                        if (err) {
+                            node.error(`发布discovery失败: ${config.topic}, ${err.message}`);
+                        }
+                    });
+                }, index * 50 + 100);
+            });
+            
+            topics.command.forEach(topic => {
+                if (!node.subscriptions.has(topic)) {
+                    node.mqttClient.subscribe(topic, (err) => {
+                        if (!err) {
+                            node.subscriptions.set(topic, device.macAddress);
+                            node.log(`订阅topic: ${topic} → ${device.macAddress}`);
+                        } else {
+                            node.error(`订阅失败: ${topic}, ${err.message}`);
+                        }
+                    });
+                }
+            });
+            
+            // 发布初始状态 - 在discovery config发布后
+            setTimeout(() => {
+                publishInitialDeviceState(device, node);
+            }, configs.length * 50 + 300);
+            
+            node.publishedDevices.add(macClean);
+        });
+    };
+
+    // 发布设备初始状态
+    function publishInitialDeviceState(device, node) {
+        const macClean = device.macAddress.replace(/:/g, '').toLowerCase();
+        
+        // 先发布availability: online，确保HA实体可用
+        node.mqttClient.publish(`symi_mesh/${macClean}/availability`, 'online', { retain: true }, (err) => {
+            if (err) {
+                node.error(`发布availability失败: ${err.message}`);
+            }
+        });
+        
+        // 根据设备类型发布默认状态
+        switch (device.deviceType) {
+            case 1:
+            case 2:
+            case 3: // 零火开关、单火开关、智能插座
+                for (let i = 1; i <= device.channels; i++) {
+                    const channelSuffix = device.channels === 1 ? '' : `_${i}`;
+                    node.mqttClient.publish(`symi_mesh/${macClean}/switch${channelSuffix}/state`, 'OFF', { retain: true });
+                }
+                break;
+                
+            case 0x09: // 插卡取电
+                node.mqttClient.publish(`symi_mesh/${macClean}/switch/state`, 'OFF', { retain: true });
+                node.mqttClient.publish(`symi_mesh/${macClean}/card_sensor/state`, 'OFF', { retain: true });
+                break;
+                
+            case 4: // 双色调光灯（支持亮度+色温）
+                const dualLightState = {
+                    state: 'OFF',
+                    brightness: 0,
+                    color_mode: 'color_temp',
+                    color_temp: 350  // 默认中间色温
+                };
+                node.mqttClient.publish(`symi_mesh/${macClean}/light/state`, JSON.stringify(dualLightState), { retain: true });
+                break;
+                
+            case 0x18: // 五色调光灯（支持RGB+色温）
+                const fiveColorLightState = {
+                    state: 'OFF',
+                    brightness: 0,
+                    color_mode: 'rgb',
+                    color: { r: 255, g: 255, b: 255 }
+                };
+                node.mqttClient.publish(`symi_mesh/${macClean}/light/state`, JSON.stringify(fiveColorLightState), { retain: true });
+                break;
+                
+            case 0x05: // 窗帘
+                node.mqttClient.publish(`symi_mesh/${macClean}/cover/state`, 'closed', { retain: true });
+                node.mqttClient.publish(`symi_mesh/${macClean}/cover/position`, '0', { retain: true });
+                break;
+                
+            case 8: // 人体感应
+                node.mqttClient.publish(`symi_mesh/${macClean}/binary_sensor/state`, 'OFF', { retain: true });
+                break;
+                
+            case 10: // 温控器
+                // 发布初始状态到各个独立topic
+                node.mqttClient.publish(`symi_mesh/${macClean}/climate/current_temp`, '20.0', { retain: true });
+                node.mqttClient.publish(`symi_mesh/${macClean}/climate/target_temp`, '20.0', { retain: true });
+                node.mqttClient.publish(`symi_mesh/${macClean}/climate/mode`, 'off', { retain: true });
+                node.mqttClient.publish(`symi_mesh/${macClean}/climate/fan_mode`, 'auto', { retain: true });
+                break;
+        }
+        
+        // 三合一设备的初始状态（通过isThreeInOne标记识别）
+        // 空调使用climate主题（与温控器一致）
+        if (device.isThreeInOne) {
+            node.mqttClient.publish(`symi_mesh/${macClean}/climate/mode`, 'off', { retain: true });
+            node.mqttClient.publish(`symi_mesh/${macClean}/climate/target_temp`, '20', { retain: true });
+            node.mqttClient.publish(`symi_mesh/${macClean}/climate/current_temp`, '20', { retain: true });
+            node.mqttClient.publish(`symi_mesh/${macClean}/climate/fan_mode`, 'auto', { retain: true });
+            node.mqttClient.publish(`symi_mesh/${macClean}/fresh_air/state`, 'OFF', { retain: true });
+            node.mqttClient.publish(`symi_mesh/${macClean}/fresh_air/speed`, '0', { retain: true });
+            node.mqttClient.publish(`symi_mesh/${macClean}/fresh_air/mode`, 'auto', { retain: true });
+            node.mqttClient.publish(`symi_mesh/${macClean}/fresh_air/direction`, 'forward', { retain: true });
+            node.mqttClient.publish(`symi_mesh/${macClean}/floor_heating/mode`, 'off', { retain: true });
+            node.mqttClient.publish(`symi_mesh/${macClean}/floor_heating/target_temp`, '20', { retain: true });
+            node.mqttClient.publish(`symi_mesh/${macClean}/floor_heating/current_temp`, '20', { retain: true });
+        }
+        
+        node.log(`发布设备 ${device.name} 初始状态`);
+    }
+
+    SymiMQTTNode.prototype.publishDeviceState = function(eventData) {
+        const node = this;
+        const device = eventData.device;
+        const state = eventData.state;
+        const attrType = eventData.attrType;
+        const macClean = device.macAddress.replace(/:/g, '').toLowerCase();
+        
+        let publishes = [];
+        
+        // 注意：不在每次状态更新时发布availability，避免日志泛滥
+        // availability只在设备发现完成时发布一次
+        // publishes.push({
+        //     topic: `symi_mesh/${macClean}/availability`,
+        //     payload: 'online'
+        // });
+        
+        switch (attrType) {
+            case 0x02:
+                // 开关状态反馈 (TYPE_ON_OFF)
+                // 窗帘(type=5)不使用0x02，忽略避免误操作
+                if (device.deviceType === 5) {
+                    node.debug(`窗帘设备忽略0x02消息（窗帘使用0x05/0x06）`);
+                    break;
+                }
+                
+                if (device.isThreeInOne || device.deviceType === 10) {
+                    // 三合一和温控器的0x02表示空调开关（使用climate主题）
+                    if (state.switch) {
+                        // 开启状态：根据climateMode发布模式，如果没有模式则不发布（等待0x1D消息）
+                        if (state.climateMode) {
+                            const modeMap = { 1: 'cool', 2: 'heat', 3: 'fan_only', 4: 'dry' };
+                            const mode = modeMap[state.climateMode] || 'cool';
+                            publishes.push({
+                                topic: `symi_mesh/${macClean}/climate/mode`,
+                                payload: mode
+                            });
+                            node.log(`发布温控器模式: ${mode} (开关=ON, climateMode=${state.climateMode})`);
+                        } else {
+                            node.log(`温控器开启但模式未设置，等待0x1D消息`);
+                        }
+                    } else {
+                        // 关闭状态：明确发布off
+                        publishes.push({
+                            topic: `symi_mesh/${macClean}/climate/mode`,
+                            payload: 'off'
+                        });
+                        node.log(`发布温控器模式: off`);
+                    }
+                } else if (device.deviceType === 4 || device.deviceType === 0x18) {
+                    // 灯光开关：发布JSON格式
+                    const lightState = {
+                        state: state.switch ? 'ON' : 'OFF'
+                    };
+                    
+                    // 保留亮度、色温、RGB信息
+                    if (state.brightness !== undefined) {
+                        lightState.brightness = Math.round(state.brightness * 2.55);
+                    }
+                    
+                    if (device.deviceType === 4) {
+                        lightState.color_mode = 'color_temp';
+                        if (state.colorTemp !== undefined) {
+                            lightState.color_temp = convertStateValue('light', 0x04, state.colorTemp);
+                        }
+                    } else if (device.deviceType === 0x18) {
+                        lightState.color_mode = 'rgb';
+                        if (state.rgb) {
+                            lightState.color = { r: state.rgb.r, g: state.rgb.g, b: state.rgb.b };
+                        }
+                    }
+                    
+                    publishes.push({
+                        topic: `symi_mesh/${macClean}/light/state`,
+                        payload: JSON.stringify(lightState)
+                    });
+                    node.log(`发布灯光开关: ${lightState.state} (JSON)`);
+                } else if (device.deviceType === 9) {
+                    // 插卡取电器
+                    const switchState = convertStateValue('switch', 0x02, state.switch);
+                    publishes.push({
+                        topic: `symi_mesh/${macClean}/switch/state`,
+                        payload: switchState
+                    });
+                    node.log(`发布插卡取电器开关状态: ${switchState}`);
+                } else if (device.channels === 1) {
+                    const switchState = convertStateValue('switch', 0x02, state.switch);
+                    publishes.push({
+                        topic: `symi_mesh/${macClean}/switch/state`,
+                        payload: switchState
+                    });
+                    node.log(`发布开关状态: ${switchState}`);
+                } else {
+                    // 发布每个继电器的状态
+                    for (let i = 1; i <= device.channels; i++) {
+                        const value = state[`switch_${i}`];
+                        if (value !== undefined) {
+                            const switchState = convertStateValue('switch', 0x02, value);
+                            publishes.push({
+                                topic: `symi_mesh/${macClean}/switch_${i}/state`,
+                                payload: switchState
+                            });
+                            node.log(`发布开关路${i}: ${switchState}`);
+                        }
+                    }
+                }
+                break;
+                
+            case 0x0E:
+                // 插卡状态反馈 (CARD_DET_STATUS)
+                if (device.deviceType === 9) {
+                    const cardState = convertStateValue('binary_sensor', 0x0E, state.cardInserted);
+                    const switchState = convertStateValue('switch', 0x02, state.switch);
+                    const cardTopic = `symi_mesh/${macClean}/card_sensor/state`;
+                    const switchTopic = `symi_mesh/${macClean}/switch/state`;
+                    
+                    publishes.push({
+                        topic: cardTopic,
+                        payload: cardState
+                    });
+                    publishes.push({
+                        topic: switchTopic,
+                        payload: switchState
+                    });
+                    node.log(`发布插卡状态: ${cardState} → ${cardTopic}`);
+                    node.log(`发布开关状态: ${switchState} → ${switchTopic}`);
+                    node.log(`插卡原始值: cardInserted=${state.cardInserted}, switch=${state.switch}`);
+                }
+                break;
+                
+            case 0x03:
+                // 亮度反馈：使用JSON格式，完整保留现有状态
+                if (state.brightness !== undefined) {
+                    // 构建完整的灯光状态，保留RGB或色温信息
+                    const lightState = {
+                        state: state.switch ? 'ON' : 'OFF',
+                        brightness: Math.round(state.brightness * 2.55)  // 转换为0-255范围
+                    };
+                    
+                    // 根据设备类型设置color_mode
+                    if (device.deviceType === 0x18) {
+                        lightState.color_mode = 'rgb';
+                        if (state.rgb) {
+                            lightState.color = {
+                                r: state.rgb.r,
+                                g: state.rgb.g,
+                                b: state.rgb.b
+                            };
+                        } else {
+                            lightState.color = { r: 255, g: 255, b: 255 };
+                        }
+                    } else if (device.deviceType === 4) {
+                        lightState.color_mode = 'color_temp';
+                        if (state.colorTemp !== undefined) {
+                            lightState.color_temp = convertStateValue('light', 0x04, state.colorTemp);
+                        } else {
+                            lightState.color_temp = 350;
+                        }
+                    }
+                    
+                    publishes.push({
+                        topic: `symi_mesh/${macClean}/light/state`,
+                        payload: JSON.stringify(lightState)
+                    });
+                    node.log(`发布灯光亮度: ${state.brightness}% -> ${lightState.brightness}/255`);
+                }
+                break;
+                
+            case 0x04:
+                // 色温反馈：使用JSON格式，完整保留现有状态
+                if (state.colorTemp !== undefined) {
+                    const lightState = {
+                        state: state.switch !== false ? 'ON' : 'OFF',
+                        color_mode: 'color_temp',
+                        color_temp: convertStateValue('light', 0x04, state.colorTemp)
+                    };
+                    if (state.brightness !== undefined) {
+                        lightState.brightness = Math.round(state.brightness * 2.55);  // 转换为0-255范围
+                    } else {
+                        lightState.brightness = 255;  // 默认全亮
+                    }
+                    publishes.push({
+                        topic: `symi_mesh/${macClean}/light/state`,
+                        payload: JSON.stringify(lightState)
+                    });
+                    node.log(`发布灯光色温: ${state.colorTemp}% -> ${lightState.color_temp}mireds, 亮度: ${lightState.brightness}/255`);
+                }
+                break;
+                
+            case 0x05:
+                // 窗帘运行状态反馈 (CURT_RUN_STATUS)
+                // 协议：0=空闲/到头, 1=打开中, 2=关闭中, 3=停止
+                if (state.curtainStatus !== undefined) {
+                    const curtainStates = { 0: 'stopped', 1: 'opening', 2: 'closing', 3: 'stopped' };
+                    const curtainState = curtainStates[state.curtainStatus] || 'stopped';
+                    publishes.push({
+                        topic: `symi_mesh/${macClean}/cover/state`,
+                        payload: curtainState
+                    });
+                    node.log(`发布窗帘运行状态: ${curtainState} (原始值=${state.curtainStatus})`);
+                    
+                    // 到头(status=0)时也发布position，确保HA显示正确位置
+                    if (state.curtainStatus === 0 && state.curtainPosition !== undefined) {
+                        publishes.push({
+                            topic: `symi_mesh/${macClean}/cover/position`,
+                            payload: state.curtainPosition.toString()
+                        });
+                        node.log(`窗帘到头，同时发布位置: ${state.curtainPosition}%`);
+                    }
+                }
+                break;
+                
+            case 0x06:
+                // 窗帘位置反馈 (CURT_RUN_PER_POS)
+                if (state.curtainPosition !== undefined) {
+                    publishes.push({
+                        topic: `symi_mesh/${macClean}/cover/position`,
+                        payload: state.curtainPosition.toString()
+                    });
+                    node.log(`发布窗帘位置: ${state.curtainPosition}%`);
+                    
+                    // 同时发布运行状态（确保HA正确显示）
+                    if (state.curtainStatus !== undefined) {
+                        const curtainStates = { 0: 'stopped', 1: 'opening', 2: 'closing', 3: 'stopped' };
+                        const curtainState = curtainStates[state.curtainStatus] || 'stopped';
+                        publishes.push({
+                            topic: `symi_mesh/${macClean}/cover/state`,
+                            payload: curtainState
+                        });
+                        node.log(`同时发布窗帘状态: ${curtainState}`);
+                    }
+                }
+                break;
+                
+            case 0x0C:
+                // 人体感应器状态反馈 (HB_DET_STATUS)
+                if (state.motion !== undefined) {
+                    const motionState = convertStateValue('binary_sensor', 0x0C, state.motion);
+                    const motionTopic = `symi_mesh/${macClean}/binary_sensor/state`;
+                    publishes.push({
+                        topic: motionTopic,
+                        payload: motionState
+                    });
+                    node.log(`发布人体感应状态: ${motionState} → ${motionTopic}`);
+                    node.log(`人体感应原始值: motion=${state.motion}, MAC=${device.macAddress}`);
+                }
+                break;
+                
+            case 0x11:
+                // RGB反馈：使用JSON格式 (五色调光灯)
+                if (state.rgb) {
+                    const lightState = {
+                        state: 'ON',
+                        brightness: Math.round((state.rgb.r + state.rgb.g + state.rgb.b) / 3 * 2.55 / 255 * 100),
+                        color_mode: 'rgb',
+                        color: {
+                            r: state.rgb.r,
+                            g: state.rgb.g,
+                            b: state.rgb.b
+                        }
+                    };
+                    publishes.push({
+                        topic: `symi_mesh/${macClean}/light/state`,
+                        payload: JSON.stringify(lightState)
+                    });
+                    node.log(`发布RGB颜色: R=${state.rgb.r}, G=${state.rgb.g}, B=${state.rgb.b}`);
+                }
+                break;
+                
+            case 0x1B:
+                // 温控器/三合一目标温度反馈（1字节直接温度值）
+                // 注意：不自动推断开关状态，应该由0x02消息决定
+                if (state.targetTemp !== undefined) {
+                    // 三合一和温控器都使用climate主题
+                    publishes.push({
+                        topic: `symi_mesh/${macClean}/climate/target_temp`,
+                        payload: state.targetTemp.toString()
+                    });
+                    publishes.push({
+                        topic: `symi_mesh/${macClean}/climate/current_temp`,
+                        payload: state.targetTemp.toString()
+                    });
+                    // 只有当明确有switch状态且为true时，才发布模式
+                    if (state.switch !== false && state.climateMode) {
+                        const modeMap = { 1: 'cool', 2: 'heat', 3: 'fan_only', 4: 'dry' };
+                        const mode = modeMap[state.climateMode] || 'cool';
+                        publishes.push({
+                            topic: `symi_mesh/${macClean}/climate/mode`,
+                            payload: mode
+                        });
+                    }
+                }
+                break;
+                
+            case 0x1C:
+                // 温控器/三合一风速反馈 (0x1C单独消息)
+                // 协议值：1=高, 2=中, 3=低, 4=自动
+                if (state.fanMode !== undefined) {
+                    const fanMap = { 1: 'high', 2: 'medium', 3: 'low', 4: 'auto' };
+                    const fanMode = fanMap[state.fanMode] || 'auto';
+                    publishes.push({
+                        topic: `symi_mesh/${macClean}/climate/fan_mode`,
+                        payload: fanMode
+                    });
+                    node.log(`发布温控器风速: ${fanMode} (原始值=${state.fanMode})`);
+                }
+                break;
+                
+            case 0x1D:
+                // 温控器/三合一空调模式反馈（不影响地暖，地暖由0x6B单独控制）
+                if (state.climateMode !== undefined) {
+                    const modeMap = { 1: 'cool', 2: 'heat', 3: 'fan_only', 4: 'dry' };
+                    const mode = modeMap[state.climateMode] || 'off';
+                    publishes.push({
+                        topic: `symi_mesh/${macClean}/climate/mode`,
+                        payload: mode
+                    });
+                }
+                break;
+                
+            // 添加其他设备类型的状态发布
+            case 0x0A:
+                // 门磁传感器状态 (DOOR_SENSOR_STATUS)
+                if (state.doorOpen !== undefined) {
+                    const doorState = convertStateValue('binary_sensor', 0x0A, state.doorOpen);
+                    publishes.push({
+                        topic: `symi_mesh/${macClean}/binary_sensor/state`,
+                        payload: doorState
+                    });
+                    node.log(`发布门磁状态: ${doorState} (${state.doorOpen})`);
+                }
+                break;
+                
+            case 0x16:
+                // 温度传感器 (SENSOR_TEMP) - 温湿度传感器或温控器当前温度
+                if (state.temperature !== undefined) {
+                    publishes.push({
+                        topic: `symi_mesh/${macClean}/temperature/state`,
+                        payload: state.temperature.toFixed(1)
+                    });
+                    node.log(`发布温度: ${state.temperature.toFixed(1)}°C`);
+                }
+                // 温控器/三合一的当前温度也是0x16
+                if (state.currentTemp !== undefined && (device.deviceType === 10 || device.isThreeInOne)) {
+                    publishes.push({
+                        topic: `symi_mesh/${macClean}/climate/current_temp`,
+                        payload: state.currentTemp.toFixed(1)
+                    });
+                    if (device.isThreeInOne) {
+                        // 三合一设备：地暖也发布当前温度
+                        publishes.push({
+                            topic: `symi_mesh/${macClean}/floor_heating/current_temp`,
+                            payload: state.currentTemp.toFixed(1)
+                        });
+                    }
+                }
+                break;
+                
+            case 0x17:
+                // 湿度传感器 (SENSOR_HUMI)
+                if (state.humidity !== undefined) {
+                    publishes.push({
+                        topic: `symi_mesh/${macClean}/humidity/state`,
+                        payload: state.humidity.toString()
+                    });
+                    node.log(`发布湿度: ${state.humidity}%`);
+                }
+                break;
+                
+            case 0x0F:
+                // 门禁读卡器
+                if (state.cardId !== undefined) {
+                    publishes.push({
+                        topic: `symi_mesh/${macClean}/sensor/state`,
+                        payload: state.cardId
+                    });
+                }
+                if (state.accessGranted !== undefined) {
+                    publishes.push({
+                        topic: `symi_mesh/${macClean}/switch/state`,
+                        payload: convertStateValue('switch', state.accessGranted)
+                    });
+                }
+                break;
+                
+            case 0x68:
+                // 新风开关反馈
+                if (device.isThreeInOne) {
+                    const switchState = state.freshAirSwitch ? 'ON' : 'OFF';
+                    publishes.push({
+                        topic: `symi_mesh/${macClean}/fresh_air/state`,
+                        payload: switchState
+                    });
+                }
+                break;
+                
+            case 0x69:
+                // 新风模式反馈
+                if (device.isThreeInOne && state.freshAirMode !== undefined) {
+                    const modeText = state.freshAirMode === 0 ? 'forward' : 'reverse';
+                    publishes.push({
+                        topic: `symi_mesh/${macClean}/fresh_air/direction`,
+                        payload: modeText
+                    });
+                }
+                break;
+
+            case 0x6A:
+                // 新风风速反馈
+                if (device.isThreeInOne && state.freshAirSpeed !== undefined) {
+                    const fanMap = { 1: 'high', 2: 'medium', 3: 'low', 4: 'auto' };
+                    const fanMode = fanMap[state.freshAirSpeed] || 'auto';
+                    publishes.push({
+                        topic: `symi_mesh/${macClean}/fresh_air/mode`,
+                        payload: fanMode
+                    });
+                    const speedPercent = state.freshAirSpeed === 1 ? 100 :
+                                        state.freshAirSpeed === 2 ? 66 :
+                                        state.freshAirSpeed === 3 ? 33 : 50;
+                    publishes.push({
+                        topic: `symi_mesh/${macClean}/fresh_air/speed`,
+                        payload: speedPercent.toString()
+                    });
+                }
+                break;
+                
+            case 0x6B:
+                // 地暖开关反馈
+                if (device.isThreeInOne) {
+                    const mode = state.floorHeatingSwitch ? 'heat' : 'off';
+                    publishes.push({
+                        topic: `symi_mesh/${macClean}/floor_heating/mode`,
+                        payload: mode
+                    });
+                }
+                break;
+
+            case 0x6C:
+                // 地暖温度反馈
+                if (device.isThreeInOne && state.floorHeatingTemp !== undefined) {
+                    publishes.push({
+                        topic: `symi_mesh/${macClean}/floor_heating/target_temp`,
+                        payload: state.floorHeatingTemp.toString()
+                    });
+                    publishes.push({
+                        topic: `symi_mesh/${macClean}/floor_heating/current_temp`,
+                        payload: state.floorHeatingTemp.toString()
+                    });
+                }
+                break;
+                
+            case 0x94:
+                // 三合一设备完整状态
+                if (device.isThreeInOne) {
+                    // 发布新风状态
+                    if (state.freshAirSwitch !== undefined) {
+                        const switchState = state.freshAirSwitch ? 'ON' : 'OFF';
+                        publishes.push({
+                            topic: `symi_mesh/${macClean}/fresh_air/state`,
+                            payload: switchState
+                        });
+                    }
+
+                    // 发布新风方向
+                    if (state.freshAirMode !== undefined) {
+                        const modeText = state.freshAirMode === 0 ? 'forward' : 'reverse';
+                        publishes.push({
+                            topic: `symi_mesh/${macClean}/fresh_air/direction`,
+                            payload: modeText
+                        });
+                    }
+
+                    // 发布新风风速
+                    if (state.freshAirSpeed !== undefined) {
+                        const fanMap = { 0: 'auto', 1: 'low', 2: 'medium', 4: 'high' };
+                        const fanMode = fanMap[state.freshAirSpeed] || 'auto';
+                        publishes.push({
+                            topic: `symi_mesh/${macClean}/fresh_air/mode`,
+                            payload: fanMode
+                        });
+                        const speedPercent = state.freshAirSpeed === 4 ? 100 :
+                                            state.freshAirSpeed === 2 ? 66 :
+                                            state.freshAirSpeed === 1 ? 33 : 50;
+                        publishes.push({
+                            topic: `symi_mesh/${macClean}/fresh_air/speed`,
+                            payload: speedPercent.toString()
+                        });
+                    }
+                    
+                    // 发布空调状态
+                    if (state.climateSwitch !== undefined) {
+                        if (state.climateSwitch) {
+                            const modeMap = { 1: 'cool', 2: 'heat', 3: 'fan_only', 4: 'dry' };
+                            const currentMode = state.climateMode ? (modeMap[state.climateMode] || 'cool') : 'cool';
+                            publishes.push({
+                                topic: `symi_mesh/${macClean}/climate/mode`,
+                                payload: currentMode
+                            });
+                            if (state.targetTemp !== undefined) {
+                                publishes.push({
+                                    topic: `symi_mesh/${macClean}/climate/target_temp`,
+                                    payload: state.targetTemp.toString()
+                                });
+                            }
+                            if (state.fanMode !== undefined) {
+                                // 0x94消息中的空调风速值：0=自动, 1=低, 2=中, 4=高
+                                const fanMap = { 0: 'auto', 1: 'low', 2: 'medium', 4: 'high' };
+                                const fanMode = fanMap[state.fanMode] || 'auto';
+                                publishes.push({
+                                    topic: `symi_mesh/${macClean}/climate/fan_mode`,
+                                    payload: fanMode
+                                });
+                            }
+                        } else {
+                            publishes.push({
+                                topic: `symi_mesh/${macClean}/climate/mode`,
+                                payload: 'off'
+                            });
+                        }
+                    }
+                    
+                    // 发布地暖状态
+                    if (state.floorHeatingSwitch !== undefined) {
+                        const mode = state.floorHeatingSwitch ? 'heat' : 'off';
+                        publishes.push({
+                            topic: `symi_mesh/${macClean}/floor_heating/mode`,
+                            payload: mode
+                        });
+                    }
+
+                    // 发布地暖温度
+                    if (state.floorHeatingTemp !== undefined && state.floorHeatingTemp >= 18) {
+                        publishes.push({
+                            topic: `symi_mesh/${macClean}/floor_heating/target_temp`,
+                            payload: state.floorHeatingTemp.toString()
+                        });
+                        publishes.push({
+                            topic: `symi_mesh/${macClean}/floor_heating/current_temp`,
+                            payload: state.floorHeatingTemp.toString()
+                        });
+                    }
+                }
+                break;
+                
+            default:
+                // 未处理的消息类型
+                node.debug(`未处理的消息类型: 0x${attrType.toString(16)}, 设备: ${device.name}, 状态: ${JSON.stringify(state)}`);
+                break;
+        }
+        
+        // 发布所有状态更新
+        if (publishes.length > 0 && node.mqttClient && node.mqttClient.connected) {
+            publishes.forEach(p => {
+                node.mqttClient.publish(p.topic, p.payload, { retain: true });
+            });
+        }
+    };
+
+    SymiMQTTNode.prototype.handleMQTTMessage = function(topic, message) {
+        const node = this;
+        const deviceMac = node.subscriptions.get(topic);
+        
+        if (!deviceMac) {
+            node.warn(`未找到topic订阅: ${topic}`);
+            return;
+        }
+        
+        const device = node.gateway.getDevice(deviceMac);
+        if (!device) {
+            node.warn(`设备未找到: ${deviceMac}`);
+            return;
+        }
+        
+        const payload = message.toString();
+        node.log(`[MQTT收到] topic=${topic}, payload=${payload}, deviceType=${device.deviceType}, isThreeInOne=${device.isThreeInOne}`);
+        
+        const commands = node.parseMQTTCommand(topic, payload, device);
+        
+        if (commands && commands.length > 0) {
+            node.log(`[MQTT解析] 解析出${commands.length}个命令:`);
+            commands.forEach((cmd, idx) => {
+                node.log(`  命令${idx + 1}: attrType=0x${cmd.attrType.toString(16).toUpperCase()}, param=[${Array.from(cmd.param).map(p => '0x' + p.toString(16).toUpperCase()).join(', ')}]`);
+            });
+            
+            // 使用for循环而不是forEach以正确处理async
+            (async () => {
+                for (const command of commands) {
+                    const paramHex = Array.from(command.param).map(p => '0x' + p.toString(16).toUpperCase()).join(' ');
+                    node.log(`[MQTT发送] → 网关: addr=0x${device.networkAddress.toString(16).toUpperCase()}, attr=0x${command.attrType.toString(16).toUpperCase()}, param=[${paramHex}]`);
+                    try {
+                        await node.gateway.sendControl(device.networkAddress, command.attrType, command.param);
+                        node.log(`[MQTT发送] ✓ 成功: ${device.name}`);
+                        
+                        // 立即发布状态更新（optimistic update）
+                        node.publishCommandFeedback(device, command, payload, topic);
+                        
+                    } catch(err) {
+                        node.error(`[MQTT发送] ✗ 失败: ${err.message}`);
+                    }
+                }
+            })();
+        } else {
+            node.warn(`[MQTT解析] 无法解析命令 - topic: ${topic}, payload: ${payload}`);
+        }
+    };
+
+    SymiMQTTNode.prototype.publishCommandFeedback = function(device, command, payload, topic) {
+        const node = this;
+        const macClean = device.macAddress.replace(/:/g, '').toLowerCase();
+        
+        node.log(`反馈类型: attr=0x${command.attrType.toString(16)}, deviceType=${device.deviceType}, payload=${typeof payload === 'string' ? payload : JSON.stringify(payload)}`);
+        
+        // 根据命令类型立即发布状态反馈（optimistic update）
+        if (command.attrType === 0x02 && device.deviceType !== 4 && device.deviceType !== 0x18 && device.deviceType !== 10 && !device.isThreeInOne) {
+            // 普通开关控制反馈（排除灯光、温控器、三合一）
+            if (device.channels === 1 || device.deviceType === 9) {
+                const state = payload === 'ON' ? 'ON' : 'OFF';
+                // 更新设备缓存状态
+                device.state.switch = (payload === 'ON');
+                node.mqttClient.publish(`symi_mesh/${macClean}/switch/state`, state, { retain: false });
+                node.log(`立即反馈开关状态: ${state}`);
+            } else {
+                // 多路开关
+                const match = topic.match(/switch_(\d+)\/set/);
+                const channel = match ? parseInt(match[1]) : 1;
+                const state = payload === 'ON' ? 'ON' : 'OFF';
+                // 更新设备缓存状态
+                device.state[`switch_${channel}`] = (payload === 'ON');
+                node.mqttClient.publish(`symi_mesh/${macClean}/switch_${channel}/state`, state, { retain: false });
+                node.log(`立即反馈开关路${channel}状态: ${state}`);
+            }
+        } else if (command.attrType === 0x02 && (device.deviceType === 4 || device.deviceType === 0x18)) {
+            // 灯光开关控制 - 不需要optimistic update，等待53 80反馈
+            // 因为0x02命令后会立即收到53 80事件，optimistic update反而会造成状态混乱
+            node.debug(`灯光开关命令已发送，等待53 80反馈`);
+            
+        } else if (command.attrType === 0x03 || command.attrType === 0x04 || command.attrType === 0x4C) {
+            // 灯光亮度/色温/RGB控制 - 不需要optimistic update，等待53 80反馈
+            node.debug(`灯光调节命令已发送，等待53 80反馈`);
+        } else if (command.attrType === 0x05 || command.attrType === 0x06) {
+            // 窗帘控制反馈
+            if (command.attrType === 0x05) {
+                const actions = { 'OPEN': 'opening', 'CLOSE': 'closing', 'STOP': 'stopped' };
+                const state = actions[payload] || 'stopped';
+                node.mqttClient.publish(`symi_mesh/${macClean}/cover/state`, state, { retain: false });
+            } else if (command.attrType === 0x06) {
+                node.mqttClient.publish(`symi_mesh/${macClean}/cover/position`, payload, { retain: false });
+            }
+        } else if (command.attrType === 0x1B || command.attrType === 0x1C || command.attrType === 0x1D || (command.attrType === 0x02 && (device.deviceType === 10 || device.isThreeInOne))) {
+            // 温控器/三合一反馈 - 完全依赖53 80反馈，不做optimistic update
+            // 因为这些设备的状态会通过53 80事件准确上报，optimistic update会被53 80覆盖导致状态不一致
+            node.log(`温控器/三合一命令已发送(attr=0x${command.attrType.toString(16)})，等待53 80反馈`);
+        } else if (command.attrType === 0x68 || command.attrType === 0x6A || command.attrType === 0x6B || command.attrType === 0x6C) {
+            // 三合一专用消息 - 完全依赖53 80反馈
+            node.log(`三合一专用命令已发送(attr=0x${command.attrType.toString(16)})，等待53 80反馈`);
+        } else if (command.attrType === 0x03 && device.isThreeInOne && topic.includes('/fresh_air/')) {
+            // 三合一新风亮度/风速控制反馈
+            const speed = Math.round(parseFloat(payload));
+            node.mqttClient.publish(`symi_mesh/${macClean}/fresh_air/speed`, speed.toString(), { retain: false });
+            node.log(`立即反馈新风风速: ${speed}%`);
+        }
+    };
+
+    SymiMQTTNode.prototype.parseMQTTCommand = function(topic, payload, device) {
+        const commands = [];
+        
+        // 灯光JSON schema控制
+        if (topic.endsWith('/light/set')) {
+            try {
+                const json = JSON.parse(payload);
+                
+                if (json.state !== undefined) {
+                    const on = json.state === 'ON';
+                    commands.push({ attrType: 0x02, param: Buffer.from([on ? 0x02 : 0x01]) });
+                }
+                
+                if (json.brightness !== undefined) {
+                    const brightness = Math.round(json.brightness / 2.55);
+                    commands.push({ attrType: 0x03, param: Buffer.from([brightness]) });
+                }
+                
+                if (json.color_temp !== undefined) {
+                    // HA: 153mireds=冷白(6500K), 500mireds=暖白(2000K)
+                    // 协议：0%=暖白, 100%=冷白
+                    // 转换：mireds -> 百分比（反向）
+                    const colorTempPercent = Math.round((1 - (json.color_temp - 153) / (500 - 153)) * 100);
+                    commands.push({ attrType: 0x04, param: Buffer.from([colorTempPercent]) });
+                }
+                
+                if (json.color && json.color.r !== undefined) {
+                    // RGB使用0-255范围（标准RGB）
+                    const r = Math.max(0, Math.min(255, Math.round(json.color.r)));
+                    const g = Math.max(0, Math.min(255, Math.round(json.color.g)));
+                    const b = Math.max(0, Math.min(255, Math.round(json.color.b)));
+                    // 自动打开灯光
+                    if (json.state === undefined) {
+                        commands.unshift({ attrType: 0x02, param: Buffer.from([0x02]) });
+                    }
+                    // 五色调光RGB控制使用0x4C（不是0x11），5字节数据
+                    commands.push({ attrType: 0x4C, param: Buffer.from([r, g, b, 0, 0]) });
+                }
+                
+                return commands;
+            } catch(e) {
+                this.log(`JSON解析失败: ${e.message}`);
+                return [];
+            }
+        }
+        
+        // 开关控制
+        if (topic.includes('/switch')) {
+            if (device.deviceType === 9) {
+                // 插卡取电器：单路控制
+                const value = payload === 'ON';
+                commands.push({ attrType: 0x02, param: Buffer.from([value ? 0x02 : 0x01]) });
+            } else {
+                const match = topic.match(/switch_(\d+)\/set/);
+                const channel = match ? parseInt(match[1]) : 1;
+                const value = payload === 'ON';
+                
+                if (device.channels === 1) {
+                    commands.push({ attrType: 0x02, param: Buffer.from([value ? 0x02 : 0x01]) });
+                } else {
+                    // 多路开关：使用网关的状态组合算法
+                    // 传递参数：[channels, targetChannel, targetState]
+                    commands.push({ 
+                        attrType: 0x02, 
+                        param: Buffer.from([device.channels, channel, value ? 1 : 0]) 
+                    });
+                }
+            }
+        } else if (topic.includes('/fresh_air/') && device.isThreeInOne) {
+            // 三合一 - 新风控制（使用专用消息类型）
+            this.log(`[MQTT解析] 新风控制 - topic=${topic}, payload=${payload}, isThreeInOne=${device.isThreeInOne}`);
+            if (topic.endsWith('/fresh_air/set')) {
+                const value = payload === 'ON';
+                commands.push({ attrType: 0x68, param: Buffer.from([value ? 0x02 : 0x01]) });
+            } else if (topic.endsWith('/fresh_air/speed/set')) {
+                const speed = Math.max(0, Math.min(100, Math.round(parseFloat(payload))));
+                const level = speed === 0 ? 4 : (speed <= 33 ? 3 : speed <= 66 ? 2 : 1);
+                commands.push({ attrType: 0x68, param: Buffer.from([0x02]) });
+                commands.push({ attrType: 0x6A, param: Buffer.from([level]) });
+            } else if (topic.endsWith('/fresh_air/mode/set')) {
+                const fans = { 'high': 1, 'medium': 2, 'low': 3, 'auto': 4 };
+                const fan = fans[payload];
+                if (fan !== undefined) {
+                    commands.push({ attrType: 0x68, param: Buffer.from([0x02]) });
+                    commands.push({ attrType: 0x6A, param: Buffer.from([fan]) });
+                }
+            } else if (topic.endsWith('/fresh_air/direction/set')) {
+                const directions = { 'supply': 0, 'exhaust': 1, 'forward': 0, 'reverse': 1 };
+                const direction = directions[payload];
+                if (direction !== undefined) {
+                    commands.push({ attrType: 0x68, param: Buffer.from([0x02]) });
+                    commands.push({ attrType: 0x69, param: Buffer.from([direction]) });
+                }
+            }
+
+        } else if (topic.includes('/floor_heating/') && device.isThreeInOne) {
+            if (topic.endsWith('/floor_heating/target_temp/set')) {
+                const temp = Math.max(18, Math.min(32, Math.round(parseFloat(payload))));
+                commands.push({ attrType: 0x6B, param: Buffer.from([0x02]) });
+                commands.push({ attrType: 0x6C, param: Buffer.from([temp]) });
+            } else if (topic.endsWith('/floor_heating/mode/set')) {
+                const modes = { 'off': 0, 'heat': 1 };
+                const mode = modes[payload];
+                if (mode !== undefined) {
+                    commands.push({ attrType: 0x6B, param: Buffer.from([mode === 0 ? 0x01 : 0x02]) });
+                }
+            }
+
+        } else if (topic.endsWith('/target_temp/set')) {
+            const temp = Math.max(16, Math.min(30, Math.round(parseFloat(payload))));
+            commands.push({ attrType: 0x02, param: Buffer.from([0x02]) });
+            commands.push({ attrType: 0x1B, param: Buffer.from([temp]) });
+            
+        } else if (topic.includes('/climate/mode/set')) {
+            // 温控器/三合一空调模式
+            const modes = { 'off': 0, 'cool': 1, 'heat': 2, 'fan_only': 3, 'dry': 4 };
+            const mode = modes[payload];
+            if (mode !== undefined) {
+                if (mode === 0) {
+                    commands.push({ attrType: 0x02, param: Buffer.from([0x01]) });
+                    this.log(`[MQTT解析] 空调模式命令: 0x02=0x01 (关闭)`);
+                } else {
+                    // 先开启空调
+                    commands.push({ attrType: 0x02, param: Buffer.from([0x02]) });
+                    commands.push({ attrType: 0x1D, param: Buffer.from([mode]) });
+                    this.log(`[MQTT解析] 空调模式命令: 先开启(0x02) + 设置模式(0x1D=0x${mode.toString(16).toUpperCase()})`);
+                }
+            }
+            
+        } else if (topic.includes('/fan_mode/set')) {
+            // 温控器/三合一空调风速 (0x1C协议: 1=高, 2=中, 3=低, 4=自动)
+            const fans = { 'high': 1, 'medium': 2, 'low': 3, 'auto': 4 };
+            const fan = fans[payload];
+            if (fan !== undefined) {
+                commands.push({ attrType: 0x1C, param: Buffer.from([fan]) });
+                this.log(`[MQTT解析] 空调风速命令: 0x1C=0x${fan.toString(16).toUpperCase()} (${payload})`);
+            }
+            
+        } else if (topic.endsWith('/cover/set')) {
+            const actions = { 'OPEN': 0x01, 'CLOSE': 0x02, 'STOP': 0x03 };
+            const action = actions[payload];
+            if (action) {
+                commands.push({ attrType: 0x05, param: Buffer.from([action]) });
+            }
+            
+        } else if (topic.includes('/position/set')) {
+            const position = Math.max(0, Math.min(100, parseInt(payload)));
+            commands.push({ attrType: 0x06, param: Buffer.from([position]) });
+        }
+        
+        return commands;
+    };
+
+    RED.nodes.registerType('symi-mqtt', SymiMQTTNode);
+};
+