node-red-contrib-symi-mesh 1.6.6 → 1.6.8

package/nodes/symi-knx-bridge.js

@@ -0,0 +1,1110 @@
+/**
+ * Symi KNX Bridge Node - Mesh与KNX设备双向同步桥接
+ * 支持开关、窗帘等设备的双向状态同步
+ * 事件驱动架构，命令队列顺序处理，防死循环机制
+ * 
+ * 版本: 1.6.8
+ */
+
+module.exports = function(RED) {
+    
+    // 设备类型配置
+    const DEVICE_TYPES = {
+        'switch': { dpt: '1.001', name: '开关', hasChannel: true },
+        'light_mono': { dpt: '5.001', name: '单色调光', hasChannel: false },
+        'light_cct': { dpt: '5.001', name: '双色调光', hasChannel: false },
+        'light_rgb': { dpt: '232.600', name: 'RGB调光', hasChannel: false },
+        'light_rgbcw': { dpt: '251.600', name: 'RGBCW调光', hasChannel: false },
+        'cover': { dpt: '1.008', name: '窗帘', hasChannel: false },
+        'climate': { dpt: '9.001', name: '空调', hasChannel: false },
+        'fresh_air': { dpt: '1.001', name: '新风', hasChannel: false },
+        'floor_heating': { dpt: '9.001', name: '地暖', hasChannel: false }
+    };
+
+    function SymiKNXBridgeNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        // 基本配置
+        node.name = config.name || 'KNX Bridge';
+        node.gateway = RED.nodes.getNode(config.gateway);
+        
+        // 解析KNX实体库
+        let knxEntities = [];
+        try {
+            knxEntities = JSON.parse(config.knxEntities || '[]');
+        } catch (e) {
+            knxEntities = [];
+        }
+
+        // 解析实体映射
+        try {
+            const rawMappings = JSON.parse(config.mappings || '[]');
+            node.mappings = rawMappings.map(m => {
+                // 查找对应的KNX实体
+                const knxEntity = knxEntities.find(e => e.id === m.knxEntityId) || {};
+                const deviceType = knxEntity.type || 'switch';
+                
+                // 基础映射
+                const mapping = {
+                    meshMac: m.meshMac,
+                    meshChannel: parseInt(m.meshChannel) || 1,
+                    knxEntityId: m.knxEntityId,
+                    knxAddrCmd: knxEntity.cmdAddr || '',
+                    knxAddrStatus: knxEntity.statusAddr || '',
+                    deviceType: deviceType,
+                    invertPosition: knxEntity.invert || false,
+                    name: knxEntity.name || ''
+                };
+                
+                // 根据设备类型映射扩展地址到具体功能
+                // 参考HTML模板中的typeFields定义
+                switch (deviceType) {
+                    case 'light_mono':
+                        // 单色调光: 开关, 状态, 亮度
+                        mapping.knxAddrBrightness = knxEntity.ext1 || '';
+                        break;
+                    case 'light_cct':
+                        // 双色调光: 开关, 状态, 亮度, 色温
+                        mapping.knxAddrBrightness = knxEntity.ext1 || '';
+                        mapping.knxAddrColorTemp = knxEntity.ext2 || '';
+                        break;
+                    case 'light_rgb':
+                        // RGB调光: 开关, 状态, 亮度, RGB
+                        mapping.knxAddrBrightness = knxEntity.ext1 || '';
+                        mapping.knxAddrRGB = knxEntity.ext2 || '';
+                        break;
+                    case 'light_rgbcw':
+                        // RGBCW: 开关, 状态, 亮度, 色温, RGB
+                        mapping.knxAddrBrightness = knxEntity.ext1 || '';
+                        mapping.knxAddrColorTemp = knxEntity.ext2 || '';
+                        mapping.knxAddrRGB = knxEntity.ext3 || '';
+                        break;
+                    case 'cover':
+                        // 窗帘: 上下, 位置, 停止
+                        mapping.knxAddrPosition = knxEntity.statusAddr || '';
+                        mapping.knxAddrStop = knxEntity.ext1 || '';
+                        break;
+                    case 'climate':
+                        // 空调: 开关, 温度, 模式, 风速, 当前温度
+                        mapping.knxAddrTemp = knxEntity.statusAddr || '';
+                        mapping.knxAddrMode = knxEntity.ext1 || '';
+                        mapping.knxAddrFanSpeed = knxEntity.ext2 || '';
+                        mapping.knxAddrCurrentTemp = knxEntity.ext3 || '';
+                        break;
+                    case 'fresh_air':
+                        // 新风: 开关, 风速
+                        mapping.knxAddrFanSpeed = knxEntity.statusAddr || '';
+                        break;
+                    case 'floor_heating':
+                        // 地暖: 开关, 温度, 当前温度
+                        mapping.knxAddrTemp = knxEntity.statusAddr || '';
+                        mapping.knxAddrCurrentTemp = knxEntity.ext1 || '';
+                        break;
+                }
+                
+                // 收集所有KNX地址用于快速查找
+                mapping.allKnxAddrs = [
+                    mapping.knxAddrCmd,
+                    mapping.knxAddrStatus,
+                    mapping.knxAddrBrightness,
+                    mapping.knxAddrColorTemp,
+                    mapping.knxAddrRGB,
+                    mapping.knxAddrPosition,
+                    mapping.knxAddrStop,
+                    mapping.knxAddrTemp,
+                    mapping.knxAddrMode,
+                    mapping.knxAddrFanSpeed,
+                    mapping.knxAddrCurrentTemp
+                ].filter(addr => addr && addr.length > 0);
+                
+                return mapping;
+            }).filter(m => m.meshMac && m.knxAddrCmd);
+            
+            // 打印映射配置
+            node.mappings.forEach((m, i) => {
+                const typeConfig = DEVICE_TYPES[m.deviceType] || DEVICE_TYPES['switch'];
+                if (typeConfig.hasChannel) {
+                    node.log(`[映射${i+1}] ${m.name}: Mesh ${m.meshMac} CH${m.meshChannel} <-> KNX ${m.knxAddrCmd} (${typeConfig.name})`);
+                } else {
+                    node.log(`[映射${i+1}] ${m.name}: Mesh ${m.meshMac} <-> KNX ${m.knxAddrCmd} (${typeConfig.name})`);
+                }
+            });
+        } catch (e) {
+            node.mappings = [];
+            node.error(`映射配置解析失败: ${e.message}`);
+        }
+
+        if (!node.gateway) {
+            node.status({ fill: 'red', shape: 'ring', text: '未配置Mesh网关' });
+            return;
+        }
+
+        // 状态管理
+        node.commandQueue = [];
+        node.processing = false;
+        node.syncLock = false;
+        node.lastSyncTime = 0;
+        node.stateCache = {};           // Mesh设备状态缓存
+        node.knxStateCache = {};        // KNX设备状态缓存
+        node.lastMeshToKnx = {};        // 记录Mesh->KNX发送时间，防止回环
+        node.lastKnxToMesh = {};        // 记录KNX->Mesh发送时间，防止回环
+        
+        // 防死循环参数
+        const LOOP_PREVENTION_MS = 800;   // 800ms内不处理反向同步，防止回环
+        const DEBOUNCE_MS = 100;          // 100ms防抖
+        const MAX_QUEUE_SIZE = 100;       // 最大队列大小
+        
+        // 初始化标记
+        node.initializing = true;
+        node.initTimer = setTimeout(() => {
+            node.initializing = false;
+            node.log('[KNX Bridge] 初始化完成，开始同步');
+        }, 20000);  // 20秒初始化延迟
+
+        if (node.mappings.length === 0) {
+            node.status({ fill: 'grey', shape: 'ring', text: '请添加实体映射' });
+        } else {
+            node.status({ fill: 'yellow', shape: 'ring', text: `${node.mappings.length}个映射等待连接...` });
+        }
+
+        // ========== 辅助函数 ==========
+        
+        // 查找Mesh设备的映射
+        node.findMeshMapping = function(mac, channel) {
+            const macNormalized = (mac || '').toLowerCase().replace(/:/g, '');
+            return node.mappings.find(m => {
+                const mappingMac = (m.meshMac || '').toLowerCase().replace(/:/g, '');
+                return mappingMac === macNormalized && 
+                       (m.deviceType === 'cover' || m.meshChannel === channel);
+            });
+        };
+        
+        // 查找所有匹配MAC的映射
+        node.findAllMeshMappings = function(mac) {
+            const macNormalized = (mac || '').toLowerCase().replace(/:/g, '');
+            return node.mappings.filter(m => {
+                const mappingMac = (m.meshMac || '').toLowerCase().replace(/:/g, '');
+                return mappingMac === macNormalized;
+            });
+        };
+
+        // 查找KNX组地址的映射（检查所有相关地址）
+        node.findKnxMapping = function(groupAddr) {
+            return node.mappings.find(m => m.allKnxAddrs.includes(groupAddr));
+        };
+        
+        // 判断KNX地址的功能类型
+        node.getKnxAddrFunction = function(mapping, groupAddr) {
+            if (groupAddr === mapping.knxAddrCmd) return 'cmd';
+            if (groupAddr === mapping.knxAddrStatus) return 'status';
+            if (groupAddr === mapping.knxAddrBrightness) return 'brightness';
+            if (groupAddr === mapping.knxAddrColorTemp) return 'colorTemp';
+            if (groupAddr === mapping.knxAddrRGB) return 'rgb';
+            if (groupAddr === mapping.knxAddrPosition) return 'position';
+            if (groupAddr === mapping.knxAddrStop) return 'stop';
+            if (groupAddr === mapping.knxAddrTemp) return 'temp';
+            if (groupAddr === mapping.knxAddrMode) return 'mode';
+            if (groupAddr === mapping.knxAddrFanSpeed) return 'fanSpeed';
+            if (groupAddr === mapping.knxAddrCurrentTemp) return 'currentTemp';
+            return 'unknown';
+        };
+        
+        // 标准化DPT格式 (处理 "DPT1.001" 和 "1.001" 两种格式)
+        node.normalizeDpt = function(dpt) {
+            if (!dpt) return '';
+            const str = String(dpt).toUpperCase();
+            if (str.startsWith('DPT')) {
+                return str.substring(3);
+            }
+            return str;
+        };
+
+        // 检查是否应该阻止同步（防死循环）
+        node.shouldPreventSync = function(direction, key) {
+            const now = Date.now();
+            if (direction === 'mesh-to-knx') {
+                const lastKnxTime = node.lastKnxToMesh[key] || 0;
+                return (now - lastKnxTime) < LOOP_PREVENTION_MS;
+            } else {
+                const lastMeshTime = node.lastMeshToKnx[key] || 0;
+                return (now - lastMeshTime) < LOOP_PREVENTION_MS;
+            }
+        };
+
+        // 记录同步时间（用于防死循环）
+        node.recordSyncTime = function(direction, key) {
+            const now = Date.now();
+            if (direction === 'mesh-to-knx') {
+                node.lastMeshToKnx[key] = now;
+            } else {
+                node.lastKnxToMesh[key] = now;
+            }
+        };
+
+        // 延时函数
+        node.sleep = function(ms) {
+            return new Promise(resolve => setTimeout(resolve, ms));
+        };
+
+        // ========== Mesh设备状态变化处理 ==========
+        const handleMeshStateChange = (eventData) => {
+            // 只检查initializing，不检查syncLock
+            // syncLock会导致队列处理期间丢失事件，改用per-device时间戳防回环
+            if (node.initializing) return;
+            
+            const mac = eventData.device.macAddress;
+            const state = eventData.state || {};
+            
+            // 状态缓存比较
+            if (!node.stateCache[mac]) node.stateCache[mac] = {};
+            const cached = node.stateCache[mac];
+            const changed = {};
+            const isFirstState = Object.keys(cached).length === 0;
+            
+            for (const [key, value] of Object.entries(state)) {
+                if (cached[key] !== value) {
+                    changed[key] = value;
+                    cached[key] = value;
+                }
+            }
+            
+            if (Object.keys(changed).length === 0) return;
+            
+            // 首次收到状态时只缓存，不触发同步（避免启动时批量发码）
+            // 窗帘控制命令除外
+            const hasCurtainControl = changed.curtainStatus !== undefined;
+            if (isFirstState && !hasCurtainControl) {
+                node.debug(`[Mesh事件] MAC=${mac} 首次状态，仅缓存: ${JSON.stringify(changed)}`);
+                return;
+            }
+            
+            const macNormalized = mac.toLowerCase().replace(/:/g, '');
+            
+            // 遍历所有匹配的映射
+            const matchedMappings = node.findAllMeshMappings(mac);
+            if (matchedMappings.length === 0) {
+                node.debug(`[Mesh事件] MAC=${macNormalized} 无映射配置`);
+                return;
+            }
+            node.log(`[Mesh事件] MAC=${macNormalized}, 找到${matchedMappings.length}个映射, 变化: ${JSON.stringify(changed)}`);
+            
+            for (const mapping of matchedMappings) {
+                const loopKey = `${mac}_${mapping.meshChannel}`;
+                
+                // 防死循环检查
+                if (node.shouldPreventSync('mesh-to-knx', loopKey)) {
+                    node.log(`[Mesh->KNX] 跳过(防死循环): ${loopKey}`);
+                    continue;
+                }
+                
+                // 开关设备
+                if (mapping.deviceType === 'switch') {
+                    const switchKey = `switch_${mapping.meshChannel}`;
+                    if (changed[switchKey] !== undefined) {
+                        node.log(`[Mesh->KNX] 开关变化: ${mapping.name || eventData.device.name} CH${mapping.meshChannel} = ${changed[switchKey]}`);
+                        node.queueCommand({
+                            direction: 'mesh-to-knx',
+                            mapping: mapping,
+                            type: 'switch',
+                            value: changed[switchKey],
+                            key: loopKey
+                        });
+                    }
+                }
+                // 调光灯设备（单色、双色、RGB、RGBCW）
+                else if (mapping.deviceType.startsWith('light_')) {
+                    // 开关状态
+                    if (changed.switch !== undefined) {
+                        node.log(`[Mesh->KNX] 调光灯开关: ${mapping.name || eventData.device.name} = ${changed.switch}`);
+                        node.queueCommand({
+                            direction: 'mesh-to-knx',
+                            mapping: mapping,
+                            type: 'light_switch',
+                            value: changed.switch,
+                            key: loopKey
+                        });
+                    }
+                    // 亮度
+                    if (changed.brightness !== undefined) {
+                        node.log(`[Mesh->KNX] 调光灯亮度: ${mapping.name || eventData.device.name} = ${changed.brightness}%`);
+                        node.queueCommand({
+                            direction: 'mesh-to-knx',
+                            mapping: mapping,
+                            type: 'light_brightness',
+                            value: changed.brightness,
+                            key: loopKey
+                        });
+                    }
+                    // 色温
+                    if (changed.colorTemp !== undefined && (mapping.deviceType === 'light_cct' || mapping.deviceType === 'light_rgbcw')) {
+                        node.log(`[Mesh->KNX] 调光灯色温: ${mapping.name || eventData.device.name} = ${changed.colorTemp}`);
+                        node.queueCommand({
+                            direction: 'mesh-to-knx',
+                            mapping: mapping,
+                            type: 'light_color_temp',
+                            value: changed.colorTemp,
+                            key: loopKey
+                        });
+                    }
+                }
+                // 窗帘设备
+                else if (mapping.deviceType === 'cover') {
+                    if (!eventData.isUserControl) continue;
+                    
+                    if (changed.curtainAction !== undefined || changed.curtainStatus !== undefined) {
+                        const action = changed.curtainAction || state.curtainAction;
+                        node.log(`[Mesh->KNX] 窗帘动作: ${mapping.name || eventData.device.name} action=${action}`);
+                        node.queueCommand({
+                            direction: 'mesh-to-knx',
+                            mapping: mapping,
+                            type: 'cover_action',
+                            value: action,
+                            key: loopKey
+                        });
+                    }
+                    if (changed.curtainPosition !== undefined) {
+                        node.log(`[Mesh->KNX] 窗帘位置: ${mapping.name || eventData.device.name} pos=${changed.curtainPosition}%`);
+                        node.queueCommand({
+                            direction: 'mesh-to-knx',
+                            mapping: mapping,
+                            type: 'cover_position',
+                            value: changed.curtainPosition,
+                            key: loopKey
+                        });
+                    }
+                }
+                // 空调设备
+                else if (mapping.deviceType === 'climate') {
+                    if (changed.acSwitch !== undefined || changed.climateSwitch !== undefined) {
+                        const sw = changed.acSwitch !== undefined ? changed.acSwitch : changed.climateSwitch;
+                        node.log(`[Mesh->KNX] 空调开关: ${mapping.name || eventData.device.name} = ${sw}`);
+                        node.queueCommand({
+                            direction: 'mesh-to-knx',
+                            mapping: mapping,
+                            type: 'climate_switch',
+                            value: sw,
+                            key: loopKey
+                        });
+                    }
+                    if (changed.targetTemp !== undefined || changed.acTargetTemp !== undefined) {
+                        const temp = changed.targetTemp !== undefined ? changed.targetTemp : changed.acTargetTemp;
+                        node.log(`[Mesh->KNX] 空调温度: ${mapping.name || eventData.device.name} = ${temp}°C`);
+                        node.queueCommand({
+                            direction: 'mesh-to-knx',
+                            mapping: mapping,
+                            type: 'climate_temp',
+                            value: temp,
+                            key: loopKey
+                        });
+                    }
+                    if (changed.acMode !== undefined || changed.climateMode !== undefined) {
+                        const mode = changed.acMode !== undefined ? changed.acMode : changed.climateMode;
+                        node.log(`[Mesh->KNX] 空调模式: ${mapping.name || eventData.device.name} = ${mode}`);
+                        node.queueCommand({
+                            direction: 'mesh-to-knx',
+                            mapping: mapping,
+                            type: 'climate_mode',
+                            value: mode,
+                            key: loopKey
+                        });
+                    }
+                }
+                // 新风设备
+                else if (mapping.deviceType === 'fresh_air') {
+                    if (changed.freshAirSwitch !== undefined) {
+                        node.log(`[Mesh->KNX] 新风开关: ${mapping.name || eventData.device.name} = ${changed.freshAirSwitch}`);
+                        node.queueCommand({
+                            direction: 'mesh-to-knx',
+                            mapping: mapping,
+                            type: 'fresh_air_switch',
+                            value: changed.freshAirSwitch,
+                            key: loopKey
+                        });
+                    }
+                    if (changed.freshAirSpeed !== undefined) {
+                        node.log(`[Mesh->KNX] 新风风速: ${mapping.name || eventData.device.name} = ${changed.freshAirSpeed}`);
+                        node.queueCommand({
+                            direction: 'mesh-to-knx',
+                            mapping: mapping,
+                            type: 'fresh_air_speed',
+                            value: changed.freshAirSpeed,
+                            key: loopKey
+                        });
+                    }
+                }
+                // 地暖设备
+                else if (mapping.deviceType === 'floor_heating') {
+                    if (changed.floorHeatingSwitch !== undefined) {
+                        node.log(`[Mesh->KNX] 地暖开关: ${mapping.name || eventData.device.name} = ${changed.floorHeatingSwitch}`);
+                        node.queueCommand({
+                            direction: 'mesh-to-knx',
+                            mapping: mapping,
+                            type: 'floor_heating_switch',
+                            value: changed.floorHeatingSwitch,
+                            key: loopKey
+                        });
+                    }
+                    if (changed.floorHeatingTemp !== undefined) {
+                        node.log(`[Mesh->KNX] 地暖温度: ${mapping.name || eventData.device.name} = ${changed.floorHeatingTemp}°C`);
+                        node.queueCommand({
+                            direction: 'mesh-to-knx',
+                            mapping: mapping,
+                            type: 'floor_heating_temp',
+                            value: changed.floorHeatingTemp,
+                            key: loopKey
+                        });
+                    }
+                }
+            }
+        };
+
+        // ========== 命令队列处理 ==========
+        node.queueCommand = function(cmd) {
+            // 队列大小限制
+            if (node.commandQueue.length >= MAX_QUEUE_SIZE) {
+                node.warn(`[KNX Bridge] 命令队列已满(${MAX_QUEUE_SIZE})，丢弃最旧命令`);
+                node.commandQueue.shift();
+            }
+            
+            // 检查队列中是否有相同映射的命令（防抖）
+            const existing = node.commandQueue.find(c =>
+                c.direction === cmd.direction &&
+                c.mapping.meshMac === cmd.mapping.meshMac &&
+                c.mapping.meshChannel === cmd.mapping.meshChannel &&
+                c.type === cmd.type &&
+                Date.now() - (c.timestamp || 0) < DEBOUNCE_MS
+            );
+            
+            if (existing) {
+                existing.value = cmd.value;
+                node.debug(`[队列] 合并命令: ${cmd.key}`);
+                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 === 'mesh-to-knx') {
+                            await node.syncMeshToKnx(cmd);
+                        } else if (cmd.direction === 'knx-to-mesh') {
+                            await node.syncKnxToMesh(cmd);
+                        }
+                        await node.sleep(50);  // 命令间隔50ms
+                    } catch (err) {
+                        node.error(`同步失败: ${err.message}`);
+                    }
+                }
+            } finally {
+                node.processing = false;
+                node.lastSyncTime = Date.now();
+            }
+        };
+
+        // ========== Mesh -> KNX 同步 ==========
+        node.syncMeshToKnx = async function(cmd) {
+            const { mapping, type, value, key } = cmd;
+            
+            // 记录发送时间
+            node.recordSyncTime('mesh-to-knx', key);
+            
+            // 构建KNX消息并通过输出端口发送
+            let knxMsg = null;
+            
+            if (type === 'switch') {
+                // 开关: DPT 1.001, 使用boolean类型
+                knxMsg = {
+                    topic: mapping.knxAddrCmd,
+                    payload: value === true || value === 1,
+                    dpt: '1.001',
+                    knx: {
+                        destination: mapping.knxAddrCmd,
+                        dpt: '1.001',
+                        action: 'write'
+                    }
+                };
+                node.log(`[Mesh->KNX] 发送开关: ${mapping.knxAddrCmd} = ${value ? 'ON' : 'OFF'}`);
+            }
+            else if (type === 'cover_action') {
+                // 窗帘动作: opening->false(上), closing->true(下), stopped->true
+                // DPT 1.008: false=上(开), true=下(关)
+                if (value === 'opening') {
+                    knxMsg = {
+                        topic: mapping.knxAddrCmd,
+                        payload: false,
+                        dpt: '1.008',
+                        knx: {
+                            destination: mapping.knxAddrCmd,
+                            dpt: '1.008',
+                            action: 'write'
+                        }
+                    };
+                    node.log(`[Mesh->KNX] 发送窗帘: ${mapping.knxAddrCmd} = 上(开)`);
+                } else if (value === 'closing') {
+                    knxMsg = {
+                        topic: mapping.knxAddrCmd,
+                        payload: true,
+                        dpt: '1.008',
+                        knx: {
+                            destination: mapping.knxAddrCmd,
+                            dpt: '1.008',
+                            action: 'write'
+                        }
+                    };
+                    node.log(`[Mesh->KNX] 发送窗帘: ${mapping.knxAddrCmd} = 下(关)`);
+                } else if (value === 'stopped') {
+                    // 停止使用单独的停止地址
+                    const stopAddr = mapping.knxAddrStop || mapping.knxAddrCmd;
+                    knxMsg = {
+                        topic: stopAddr,
+                        payload: true,
+                        dpt: '1.010',
+                        knx: {
+                            destination: stopAddr,
+                            dpt: '1.010',
+                            action: 'write'
+                        }
+                    };
+                    node.log(`[Mesh->KNX] 发送窗帘: ${stopAddr} = 停止`);
+                }
+            }
+            else if (type === 'cover_position') {
+                // 窗帘位置: 0-100%
+                const pos = mapping.invertPosition ? (100 - value) : value;
+                const posAddr = mapping.knxAddrPosition || mapping.knxAddrStatus;
+                if (posAddr) {
+                    knxMsg = {
+                        topic: posAddr,
+                        payload: pos,
+                        knx: { destination: posAddr, dpt: '5.001', action: 'write' }
+                    };
+                    node.log(`[Mesh->KNX] 发送窗帘位置: ${posAddr} = ${pos}%`);
+                }
+            }
+            // 调光灯开关
+            else if (type === 'light_switch') {
+                knxMsg = {
+                    topic: mapping.knxAddrCmd,
+                    payload: value === true || value === 1,
+                    dpt: '1.001',
+                    knx: { destination: mapping.knxAddrCmd, dpt: '1.001', action: 'write' }
+                };
+                node.log(`[Mesh->KNX] 发送调光灯开关: ${mapping.knxAddrCmd} = ${value ? 'ON' : 'OFF'}`);
+            }
+            // 调光灯亮度
+            else if (type === 'light_brightness') {
+                const brightnessAddr = mapping.knxAddrBrightness || mapping.knxAddrStatus || mapping.knxAddrCmd;
+                if (brightnessAddr) {
+                    knxMsg = {
+                        topic: brightnessAddr,
+                        payload: Math.round(value * 255 / 100),
+                        knx: { destination: brightnessAddr, dpt: '5.001', action: 'write' }
+                    };
+                    node.log(`[Mesh->KNX] 发送调光灯亮度: ${brightnessAddr} = ${value}%`);
+                }
+            }
+            // 调光灯色温
+            else if (type === 'light_color_temp') {
+                const ctAddr = mapping.knxAddrColorTemp || mapping.knxAddrStatus;
+                if (ctAddr) {
+                    knxMsg = {
+                        topic: ctAddr,
+                        payload: value,
+                        knx: { destination: ctAddr, dpt: '5.001', action: 'write' }
+                    };
+                    node.log(`[Mesh->KNX] 发送调光灯色温: ${ctAddr} = ${value}`);
+                }
+            }
+            // 空调开关
+            else if (type === 'climate_switch') {
+                knxMsg = {
+                    topic: mapping.knxAddrCmd,
+                    payload: value === true || value === 1,
+                    dpt: '1.001',
+                    knx: { destination: mapping.knxAddrCmd, dpt: '1.001', action: 'write' }
+                };
+                node.log(`[Mesh->KNX] 发送空调开关: ${mapping.knxAddrCmd} = ${value ? 'ON' : 'OFF'}`);
+            }
+            // 空调温度
+            else if (type === 'climate_temp') {
+                const tempAddr = mapping.knxAddrTemp || mapping.knxAddrStatus || mapping.knxAddrCmd;
+                if (tempAddr) {
+                    knxMsg = {
+                        topic: tempAddr,
+                        payload: value,
+                        knx: { destination: tempAddr, dpt: '9.001', action: 'write' }
+                    };
+                    node.log(`[Mesh->KNX] 发送空调温度: ${tempAddr} = ${value}°C`);
+                }
+            }
+            // 空调模式
+            else if (type === 'climate_mode') {
+                const modeAddr = mapping.knxAddrMode || mapping.knxAddrStatus;
+                if (modeAddr) {
+                    // Mesh模式: 1=制冷, 2=制热, 3=送风, 4=除湿
+                    knxMsg = {
+                        topic: modeAddr,
+                        payload: value,
+                        knx: { destination: modeAddr, dpt: '20.102', action: 'write' }
+                    };
+                    node.log(`[Mesh->KNX] 发送空调模式: ${modeAddr} = ${value}`);
+                }
+            }
+            // 新风开关
+            else if (type === 'fresh_air_switch') {
+                knxMsg = {
+                    topic: mapping.knxAddrCmd,
+                    payload: value === true || value === 1,
+                    dpt: '1.001',
+                    knx: { destination: mapping.knxAddrCmd, dpt: '1.001', action: 'write' }
+                };
+                node.log(`[Mesh->KNX] 发送新风开关: ${mapping.knxAddrCmd} = ${value ? 'ON' : 'OFF'}`);
+            }
+            // 新风风速
+            else if (type === 'fresh_air_speed') {
+                const speedAddr = mapping.knxAddrFanSpeed || mapping.knxAddrStatus || mapping.knxAddrCmd;
+                if (speedAddr) {
+                    // Mesh风速: 1=高, 2=中, 3=低, 4=自动 -> 百分比
+                    const speedMap = { 1: 100, 2: 66, 3: 33, 4: 50 };
+                    knxMsg = {
+                        topic: speedAddr,
+                        payload: speedMap[value] || 50,
+                        knx: { destination: speedAddr, dpt: '5.001', action: 'write' }
+                    };
+                    node.log(`[Mesh->KNX] 发送新风风速: ${speedAddr} = ${speedMap[value] || 50}%`);
+                }
+            }
+            // 地暖开关
+            else if (type === 'floor_heating_switch') {
+                knxMsg = {
+                    topic: mapping.knxAddrCmd,
+                    payload: value === true || value === 1,
+                    dpt: '1.001',
+                    knx: { destination: mapping.knxAddrCmd, dpt: '1.001', action: 'write' }
+                };
+                node.log(`[Mesh->KNX] 发送地暖开关: ${mapping.knxAddrCmd} = ${value ? 'ON' : 'OFF'}`);
+            }
+            // 地暖温度
+            else if (type === 'floor_heating_temp') {
+                const tempAddr = mapping.knxAddrTemp || mapping.knxAddrStatus || mapping.knxAddrCmd;
+                if (tempAddr) {
+                    knxMsg = {
+                        topic: tempAddr,
+                        payload: value,
+                        knx: { destination: tempAddr, dpt: '9.001', action: 'write' }
+                    };
+                    node.log(`[Mesh->KNX] 发送地暖温度: ${tempAddr} = ${value}°C`);
+                }
+            }
+            
+            if (knxMsg) {
+                // knxUltimate官方格式: https://supergiovane.github.io/node-red-contrib-knx-ultimate/wiki/Device
+                // 必须包含: destination, payload, dpt, event
+                const sendMsg = {
+                    destination: knxMsg.knx.destination,
+                    payload: knxMsg.payload,
+                    dpt: knxMsg.dpt || knxMsg.knx.dpt,
+                    event: "GroupValue_Write"
+                };
+                
+                // 调试信息
+                const debugMsg = {
+                    topic: 'mesh-to-knx',
+                    payload: {
+                        direction: 'Mesh->KNX',
+                        knxAddr: knxMsg.knx.destination,
+                        value: knxMsg.payload,
+                        dpt: knxMsg.dpt || knxMsg.knx.dpt,
+                        meshMac: mapping.meshMac,
+                        channel: mapping.meshChannel,
+                        type: type
+                    },
+                    timestamp: new Date().toISOString()
+                };
+                
+                node.log(`[Mesh->KNX] 发送: destination=${sendMsg.destination}, payload=${sendMsg.payload}, dpt=${sendMsg.dpt}, event=${sendMsg.event}`);
+                
+                // 同时发送到两个输出端口（一次send调用）
+                node.send([sendMsg, debugMsg]);
+            }
+            
+            node.status({ fill: 'green', shape: 'dot', text: `Mesh→KNX ${node.mappings.length}个映射` });
+        };
+
+        // ========== KNX -> Mesh 同步 ==========
+        node.syncKnxToMesh = async function(cmd) {
+            const { mapping, type, value, key } = cmd;
+            
+            // 记录发送时间
+            node.recordSyncTime('knx-to-mesh', key);
+            
+            // 查找Mesh设备
+            const meshMac = mapping.meshMac || '';
+            const macNormalized = meshMac.toLowerCase().replace(/:/g, '');
+            let meshDevice = node.gateway.getDevice(meshMac);
+            
+            if (!meshDevice) {
+                meshDevice = node.gateway.getDevice(macNormalized);
+            }
+            if (!meshDevice) {
+                const allDevices = node.gateway.deviceManager?.getAllDevices() || [];
+                meshDevice = allDevices.find(d => {
+                    const devMac = (d.macAddress || '').toLowerCase().replace(/:/g, '');
+                    return devMac === macNormalized;
+                });
+            }
+            
+            if (!meshDevice) {
+                node.warn(`[KNX->Mesh] 未找到Mesh设备: ${meshMac}`);
+                return;
+            }
+            
+            try {
+                if (type === 'switch') {
+                    const channel = mapping.meshChannel || 1;
+                    const totalChannels = meshDevice.channels || 1;
+                    const param = Buffer.from([totalChannels, channel, value ? 1 : 0]);
+                    await node.gateway.sendControl(meshDevice.networkAddress, 0x02, param);
+                    node.log(`[KNX->Mesh] 发送开关: ${meshDevice.name} CH${channel} = ${value ? 'ON' : 'OFF'}`);
+                }
+                else if (type === 'cover_action') {
+                    const action = value === 'open' ? 1 : value === 'close' ? 2 : 3;
+                    const param = Buffer.from([action]);
+                    await node.gateway.sendControl(meshDevice.networkAddress, 0x05, param);
+                    node.log(`[KNX->Mesh] 发送窗帘: ${meshDevice.name} = ${value}`);
+                }
+                else if (type === 'cover_position') {
+                    const pos = mapping.invertPosition ? (100 - value) : value;
+                    const param = Buffer.from([pos]);
+                    await node.gateway.sendControl(meshDevice.networkAddress, 0x06, param);
+                    node.log(`[KNX->Mesh] 发送窗帘位置: ${meshDevice.name} = ${pos}%`);
+                }
+                // 调光灯开关
+                else if (type === 'light_switch') {
+                    const param = Buffer.from([value ? 0x02 : 0x01]);
+                    await node.gateway.sendControl(meshDevice.networkAddress, 0x02, param);
+                    node.log(`[KNX->Mesh] 发送调光灯开关: ${meshDevice.name} = ${value ? 'ON' : 'OFF'}`);
+                }
+                // 调光灯亮度
+                else if (type === 'light_brightness') {
+                    const param = Buffer.from([value]);
+                    await node.gateway.sendControl(meshDevice.networkAddress, 0x03, param);
+                    node.log(`[KNX->Mesh] 发送调光灯亮度: ${meshDevice.name} = ${value}%`);
+                }
+                // 调光灯色温
+                else if (type === 'light_color_temp') {
+                    const param = Buffer.from([value]);
+                    await node.gateway.sendControl(meshDevice.networkAddress, 0x04, param);
+                    node.log(`[KNX->Mesh] 发送调光灯色温: ${meshDevice.name} = ${value}`);
+                }
+                // 空调开关
+                else if (type === 'climate_switch') {
+                    const param = Buffer.from([value ? 0x01 : 0x00]);
+                    await node.gateway.sendControl(meshDevice.networkAddress, 0x1E, param);
+                    node.log(`[KNX->Mesh] 发送空调开关: ${meshDevice.name} = ${value ? 'ON' : 'OFF'}`);
+                }
+                // 空调温度
+                else if (type === 'climate_temp') {
+                    const param = Buffer.from([Math.round(value)]);
+                    await node.gateway.sendControl(meshDevice.networkAddress, 0x1B, param);
+                    node.log(`[KNX->Mesh] 发送空调温度: ${meshDevice.name} = ${value}°C`);
+                }
+                // 空调模式
+                else if (type === 'climate_mode') {
+                    const param = Buffer.from([value]);
+                    await node.gateway.sendControl(meshDevice.networkAddress, 0x1D, param);
+                    node.log(`[KNX->Mesh] 发送空调模式: ${meshDevice.name} = ${value}`);
+                }
+                // 空调风速
+                else if (type === 'climate_fan') {
+                    const param = Buffer.from([value]);
+                    await node.gateway.sendControl(meshDevice.networkAddress, 0x1C, param);
+                    node.log(`[KNX->Mesh] 发送空调风速: ${meshDevice.name} = ${value}`);
+                }
+                // 新风开关
+                else if (type === 'fresh_air_switch') {
+                    const param = Buffer.from([value ? 0x01 : 0x00]);
+                    await node.gateway.sendControl(meshDevice.networkAddress, 0x68, param);
+                    node.log(`[KNX->Mesh] 发送新风开关: ${meshDevice.name} = ${value ? 'ON' : 'OFF'}`);
+                }
+                // 新风风速
+                else if (type === 'fresh_air_speed') {
+                    const param = Buffer.from([value]);
+                    await node.gateway.sendControl(meshDevice.networkAddress, 0x68, param);
+                    node.log(`[KNX->Mesh] 发送新风风速: ${meshDevice.name} = ${value}`);
+                }
+                // 地暖开关
+                else if (type === 'floor_heating_switch') {
+                    const param = Buffer.from([value ? 0x01 : 0x00]);
+                    await node.gateway.sendControl(meshDevice.networkAddress, 0x6B, param);
+                    node.log(`[KNX->Mesh] 发送地暖开关: ${meshDevice.name} = ${value ? 'ON' : 'OFF'}`);
+                }
+                // 地暖温度
+                else if (type === 'floor_heating_temp') {
+                    const param = Buffer.from([Math.round(value)]);
+                    await node.gateway.sendControl(meshDevice.networkAddress, 0x6B, param);
+                    node.log(`[KNX->Mesh] 发送地暖温度: ${meshDevice.name} = ${value}°C`);
+                }
+                
+                // 输出调试信息
+                node.send([null, {
+                    topic: 'knx-to-mesh',
+                    payload: {
+                        direction: 'KNX→Mesh',
+                        mapping: {
+                            meshMac: mapping.meshMac,
+                            channel: mapping.meshChannel,
+                            knxAddr: cmd.sourceAddr
+                        },
+                        type: type,
+                        value: value
+                    },
+                    timestamp: new Date().toISOString()
+                }]);
+                
+            } catch (err) {
+                node.error(`[KNX->Mesh] 发送失败: ${err.message}`);
+            }
+            
+            node.status({ fill: 'blue', shape: 'dot', text: `KNX→Mesh ${node.mappings.length}个映射` });
+        };
+
+        // ========== 处理输入消息（来自KNX节点） ==========
+        node.on('input', function(msg, send, done) {
+            if (node.initializing) {
+                done && done();
+                return;
+            }
+            
+            // 从消息中提取KNX组地址
+            const groupAddr = msg.knx?.destination || msg.topic || '';
+            const value = msg.payload;
+            const dpt = node.normalizeDpt(msg.knx?.dpt || msg.dpt || '');
+            
+            if (!groupAddr) {
+                done && done();
+                return;
+            }
+            
+            // 查找映射
+            const mapping = node.findKnxMapping(groupAddr);
+            if (!mapping) {
+                node.debug(`[KNX输入] 未找到映射: ${groupAddr}`);
+                done && done();
+                return;
+            }
+            
+            // 确定地址功能（优先使用地址匹配，比DPT更可靠）
+            const addrFunc = node.getKnxAddrFunction(mapping, groupAddr);
+            const loopKey = `${mapping.meshMac}_${mapping.meshChannel}`;
+            
+            // 防死循环检查
+            if (node.shouldPreventSync('knx-to-mesh', loopKey)) {
+                node.debug(`[KNX->Mesh] 跳过同步(防死循环): ${loopKey}, addr=${groupAddr}`);
+                done && done();
+                return;
+            }
+            
+            node.log(`[KNX输入] 收到: ${groupAddr} = ${value}, DPT=${dpt}, 功能=${addrFunc}, 设备=${mapping.deviceType}`);
+            
+            // 根据设备类型和地址功能处理
+            if (mapping.deviceType === 'switch') {
+                // 开关命令（只处理cmd地址）
+                if (addrFunc === 'cmd' || addrFunc === 'status') {
+                    const switchValue = (value === 1 || value === true || value === 'on' || value === 'ON');
+                    node.queueCommand({
+                        direction: 'knx-to-mesh',
+                        mapping: mapping,
+                        type: 'switch',
+                        value: switchValue,
+                        key: loopKey,
+                        sourceAddr: groupAddr
+                    });
+                }
+            }
+            // 窗帘设备
+            else if (mapping.deviceType === 'cover') {
+                if (addrFunc === 'cmd') {
+                    // 上下命令: 0=上(开), 1=下(关)
+                    const action = (value === 0 || value === false) ? 'open' : 'close';
+                    node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'cover_action', value: action, key: loopKey, sourceAddr: groupAddr });
+                }
+                else if (addrFunc === 'stop') {
+                    node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'cover_action', value: 'stop', key: loopKey, sourceAddr: groupAddr });
+                }
+                else if (addrFunc === 'position' || addrFunc === 'status') {
+                    const pos = mapping.invertPosition ? (100 - (parseInt(value) || 0)) : (parseInt(value) || 0);
+                    node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'cover_position', value: pos, key: loopKey, sourceAddr: groupAddr });
+                }
+            }
+            // 调光灯设备
+            else if (mapping.deviceType.startsWith('light_')) {
+                if (addrFunc === 'cmd' || addrFunc === 'status') {
+                    // 开关
+                    const sw = (value === 1 || value === true);
+                    node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'light_switch', value: sw, key: loopKey, sourceAddr: groupAddr });
+                }
+                else if (addrFunc === 'brightness') {
+                    // 亮度 (KNX 0-255 -> Mesh 0-100)
+                    const brightness = Math.round((parseInt(value) || 0) * 100 / 255);
+                    node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'light_brightness', value: brightness, key: loopKey, sourceAddr: groupAddr });
+                }
+                else if (addrFunc === 'colorTemp') {
+                    // 色温
+                    node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'light_color_temp', value: parseInt(value) || 50, key: loopKey, sourceAddr: groupAddr });
+                }
+            }
+            // 空调设备
+            else if (mapping.deviceType === 'climate') {
+                if (addrFunc === 'cmd') {
+                    node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'climate_switch', value: value === 1 || value === true, key: loopKey, sourceAddr: groupAddr });
+                }
+                else if (addrFunc === 'temp' || addrFunc === 'status') {
+                    node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'climate_temp', value: parseFloat(value) || 24, key: loopKey, sourceAddr: groupAddr });
+                }
+                else if (addrFunc === 'mode') {
+                    node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'climate_mode', value: parseInt(value) || 1, key: loopKey, sourceAddr: groupAddr });
+                }
+                else if (addrFunc === 'fanSpeed') {
+                    // 风速
+                    node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'climate_fan', value: parseInt(value) || 1, key: loopKey, sourceAddr: groupAddr });
+                }
+            }
+            // 新风设备
+            else if (mapping.deviceType === 'fresh_air') {
+                if (addrFunc === 'cmd') {
+                    node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'fresh_air_switch', value: value === 1 || value === true, key: loopKey, sourceAddr: groupAddr });
+                }
+                else if (addrFunc === 'fanSpeed' || addrFunc === 'status') {
+                    // 百分比转风速: >66=高(1), >33=中(2), <=33=低(3)
+                    const pct = parseInt(value) || 0;
+                    const speed = pct > 66 ? 1 : pct > 33 ? 2 : 3;
+                    node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'fresh_air_speed', value: speed, key: loopKey, sourceAddr: groupAddr });
+                }
+            }
+            // 地暖设备
+            else if (mapping.deviceType === 'floor_heating') {
+                if (addrFunc === 'cmd') {
+                    node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'floor_heating_switch', value: value === 1 || value === true, key: loopKey, sourceAddr: groupAddr });
+                }
+                else if (addrFunc === 'temp' || addrFunc === 'status') {
+                    node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'floor_heating_temp', value: parseFloat(value) || 24, key: loopKey, sourceAddr: groupAddr });
+                }
+            }
+            
+            done && done();
+        });
+
+        // ========== 事件监听 ==========
+        
+        // 监听网关连接状态
+        node.gateway.on('gateway-connected', () => {
+            node.status({ fill: 'green', shape: 'ring', text: `网关已连接 ${node.mappings.length}个映射` });
+        });
+        
+        node.gateway.on('gateway-disconnected', () => {
+            node.status({ fill: 'red', shape: 'ring', text: '网关断开' });
+        });
+        
+        // 监听Mesh设备状态变化
+        node.gateway.on('device-state-changed', handleMeshStateChange);
+        
+        // ========== 场景执行事件处理 ==========
+        // 当收到场景执行通知时，查询所有已映射设备的状态
+        const handleSceneExecuted = (eventData) => {
+            if (node.initializing) return;
+            
+            node.log(`[场景执行] 检测到场景${eventData.sceneId}执行，延迟查询设备状态`);
+            
+            // 延迟300ms后查询设备状态，给设备执行时间
+            setTimeout(async () => {
+                // 收集所有已映射的唯一设备地址
+                const mappedAddresses = new Set();
+                for (const mapping of node.mappings) {
+                    const mac = node.normalizeMac(mapping.meshMac);
+                    const device = node.gateway.deviceManager.getDeviceByMac(mac);
+                    if (device && device.networkAddress) {
+                        mappedAddresses.add(device.networkAddress);
+                    }
+                }
+                
+                if (mappedAddresses.size === 0) {
+                    node.debug(`[场景执行] 没有已映射的设备需要查询`);
+                    return;
+                }
+                
+                node.log(`[场景执行] 查询${mappedAddresses.size}个设备的状态`);
+                
+                // 逐个查询设备状态
+                for (const addr of mappedAddresses) {
+                    try {
+                        // 查询开关状态 (0x02)
+                        const queryFrame = node.gateway.protocolHandler.buildDeviceStatusQueryFrame(addr, 0x02);
+                        await node.gateway.client.sendFrame(queryFrame, 2);
+                        await node.sleep(100);
+                    } catch (err) {
+                        node.debug(`[场景执行] 查询设备0x${addr.toString(16)}状态失败: ${err.message}`);
+                    }
+                }
+            }, 300);
+        };
+        
+        node.gateway.on('scene-executed', handleSceneExecuted);
+        
+        // ========== 清理 ==========
+        node.on('close', function(done) {
+            // 清除初始化定时器
+            if (node.initTimer) {
+                clearTimeout(node.initTimer);
+            }
+            
+            // 移除事件监听
+            if (node.gateway) {
+                node.gateway.removeListener('device-state-changed', handleMeshStateChange);
+                node.gateway.removeListener('scene-executed', handleSceneExecuted);
+            }
+            
+            // 清空队列和缓存
+            node.commandQueue = [];
+            node.stateCache = {};
+            node.knxStateCache = {};
+            node.lastMeshToKnx = {};
+            node.lastKnxToMesh = {};
+            
+            node.status({});
+            done();
+        });
+    }
+
+    RED.nodes.registerType('symi-knx-bridge', SymiKNXBridgeNode);
+
+    // ========== HTTP API：获取Mesh设备列表 ==========
+    RED.httpAdmin.get('/symi-knx-bridge/devices/:gatewayId', function(req, res) {
+        const gatewayNode = RED.nodes.getNode(req.params.gatewayId);
+        if (!gatewayNode || !gatewayNode.deviceManager) {
+            return res.json([]);
+        }
+        
+        const devices = gatewayNode.deviceManager.getAllDevices();
+        const result = devices.map(d => ({
+            mac: d.macAddress,
+            name: d.name,
+            type: d.getEntityType(),
+            channels: d.channels,
+            online: d.online
+        }));
+        
+        res.json(result);
+    });
+};