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

package/nodes/symi-485-bridge.js

@@ -180,6 +180,46 @@ module.exports = function(RED) {
                         }
                     },
                     // ===== 地暖 (A3B3协议头) =====
+                    // 从机地址: 客餐厅=0x3C(60), 主卧=0x3D(61), 次卧1=0x3E(62), 次卧2=0x3F(63)
+                    // 开关: 0x0039, 开=0x02, 关=0x00
+                    // 温度: 0x0043
+                    'floor_heating_living': {
+                        name: '客餐厅地暖',
+                        type: 'climate',
+                        defaultAddress: 0x3C,
+                        registers: {
+                            switch: { address: 0x0039, type: 'holding', on: 2, off: 0 },
+                            targetTemp: { address: 0x0043, type: 'holding' }
+                        }
+                    },
+                    'floor_heating_master': {
+                        name: '主卧地暖',
+                        type: 'climate',
+                        defaultAddress: 0x3D,
+                        registers: {
+                            switch: { address: 0x0039, type: 'holding', on: 2, off: 0 },
+                            targetTemp: { address: 0x0043, type: 'holding' }
+                        }
+                    },
+                    'floor_heating_bedroom2_1': {
+                        name: '次卧1地暖',
+                        type: 'climate',
+                        defaultAddress: 0x3E,
+                        registers: {
+                            switch: { address: 0x0039, type: 'holding', on: 2, off: 0 },
+                            targetTemp: { address: 0x0043, type: 'holding' }
+                        }
+                    },
+                    'floor_heating_bedroom2_2': {
+                        name: '次卧2地暖',
+                        type: 'climate',
+                        defaultAddress: 0x3F,
+                        registers: {
+                            switch: { address: 0x0039, type: 'holding', on: 2, off: 0 },
+                            targetTemp: { address: 0x0043, type: 'holding' }
+                        }
+                    },
+                    // 通用地暖（自定义从机地址）
                     'floor_heating': {
                         name: '地暖',
                         type: 'climate',
@@ -189,9 +229,13 @@ module.exports = function(RED) {
                         }
                     },
                     // ===== 新风 (A3B3协议头) =====
+                    // 从机地址: 0x3C (60) - 与客餐厅地暖共用从机
+                    // 开关: 0x0039, 开=0x01, 关=0x00 (注意：与地暖开关值不同)
+                    // 风速: 0x004B, 高=0x02, 低=0x00
                     'fresh_air': {
                         name: '新风',
                         type: 'fan',
+                        defaultAddress: 0x3C,
                         registers: {
                             switch: { address: 0x0039, type: 'holding', on: 1, off: 0 },
                             fanSpeed: { address: 0x004B, type: 'holding', map: { 0: 'low', 2: 'high' } }
@@ -235,6 +279,22 @@ module.exports = function(RED) {
                     'scene': { name: '场景', type: 'scene', registers: { trigger: { address: 0x0000, type: 'holding' } } }
                 }
             },
+            // ===== 杜亚窗帘协议 =====
+            // 帧格式: 55 [地址高] [地址低] 03 [数据] [CRC16高] [CRC16低]
+            // 数据: 01=打开, 02=关闭, 03=停止, 04+位置=百分比
+            // 地址: 2字节，如0101表示地址高=01，地址低=01
+            'duya': {
+                name: '杜亚窗帘',
+                protocol: 'duya',  // 标记使用专用协议
+                twoByteAddress: true,  // 标记使用2字节地址
+                devices: {
+                    'curtain': {
+                        name: '窗帘',
+                        type: 'cover',
+                        protocol: 'duya'
+                    }
+                }
+            },
             // ===== 自定义协议 - 用户可录入任意RS485码 =====
             'custom': {
                 name: '自定义协议',
@@ -262,6 +322,71 @@ module.exports = function(RED) {
         }
     };
 
+    // ===== 杜亚协议CRC16计算 =====
+    // 杜亚使用CRC16-MODBUS算法，低字节在前
+    function calcA6B6CRC(buffer) {
+        let crc = 0xFFFF;
+        for (let i = 0; i < buffer.length; i++) {
+            crc ^= buffer[i];
+            for (let j = 0; j < 8; j++) {
+                if (crc & 0x0001) {
+                    crc = (crc >> 1) ^ 0xA001;
+                } else {
+                    crc >>= 1;
+                }
+            }
+        }
+        // 返回低字节在前（小端序）
+        return [crc & 0xFF, (crc >> 8) & 0xFF];
+    }
+
+    // 构建A6B6窗帘控制帧
+    // 地址格式: 0x0102 表示地址高=01, 地址低=02
+    function buildA6B6Frame(addrHigh, addrLow, action, position) {
+        let data;
+        if (action === 'position' && position !== undefined) {
+            // 百分比控制: 55 addrH addrL 03 04 [位置] CRC
+            data = Buffer.from([0x55, addrHigh, addrLow, 0x03, 0x04, position]);
+        } else {
+            // 动作控制: 55 addrH addrL 03 [动作] CRC
+            const actionCode = action === 'open' ? 0x01 : action === 'close' ? 0x02 : 0x03;
+            data = Buffer.from([0x55, addrHigh, addrLow, 0x03, actionCode]);
+        }
+        const crc = calcA6B6CRC(data);
+        return Buffer.concat([data, Buffer.from(crc)]);
+    }
+
+    // 解析A6B6窗帘响应帧
+    function parseA6B6Frame(frame) {
+        if (frame.length < 7 || frame[0] !== 0x55) return null;
+        
+        const addrHigh = frame[1];
+        const addrLow = frame[2];
+        const funcCode = frame[3];
+        
+        if (funcCode !== 0x03) return null;
+        
+        const dataType = frame[4];
+        let result = {
+            address: (addrHigh << 8) | addrLow,
+            addrHigh: addrHigh,
+            addrLow: addrLow
+        };
+        
+        if (dataType === 0x01) {
+            result.action = 'open';
+        } else if (dataType === 0x02) {
+            result.action = 'close';
+        } else if (dataType === 0x03) {
+            result.action = 'stop';
+        } else if (dataType === 0x04 && frame.length >= 8) {
+            result.action = 'position';
+            result.position = frame[5];
+        }
+        
+        return result;
+    }
+
     function SymiRS485BridgeNode(config) {
         RED.nodes.createNode(this, config);
         const node = this;
@@ -273,9 +398,35 @@ module.exports = function(RED) {
         
         // 解析实体映射
         try {
-            node.mappings = JSON.parse(config.mappings || '[]');
+            const rawMappings = JSON.parse(config.mappings || '[]');
+            // 确保所有数值字段是正确类型
+            node.mappings = rawMappings.map(m => {
+                const mapping = {
+                    ...m,
+                    address: parseInt(m.address) || 1,
+                    meshChannel: parseInt(m.meshChannel) || 1,
+                    rs485Channel: parseInt(m.rs485Channel) || 1
+                };
+                // 杜亚窗帘使用2字节地址
+                if (m.brand === 'duya') {
+                    mapping.addrHigh = parseInt(m.addrHigh) || parseInt(m.address) || 1;
+                    mapping.addrLow = parseInt(m.addrLow) || parseInt(m.address) || 1;
+                }
+                return mapping;
+            });
+            // 打印所有映射配置便于调试
+            node.mappings.forEach((m, i) => {
+                if (m.brand === 'duya') {
+                    node.log(`[映射${i+1}] Mesh: ${m.meshMac} <-> 杜亚窗帘: 地址${m.addrHigh.toString(16).padStart(2,'0')} ${m.addrLow.toString(16).padStart(2,'0')}`);
+                } else if (m.brand === 'custom' && m.customCodes) {
+                    node.log(`[映射${i+1}] Mesh: ${m.meshMac} <-> 自定义: ${m.device}, codes=${JSON.stringify(m.customCodes)}`);
+                } else {
+                    node.log(`[映射${i+1}] Mesh: ${m.meshMac} CH${m.meshChannel} <-> RS485: 从机${m.address} ${m.brand}/${m.device} CH${m.rs485Channel}`);
+                }
+            });
         } catch (e) {
             node.mappings = [];
+            node.error(`映射配置解析失败: ${e.message}`);
         }
 
         if (!node.gateway) {
@@ -347,9 +498,16 @@ module.exports = function(RED) {
             );
         };
 
-        // Find mapping for RS485 device
+        // Find mapping for RS485 device (返回第一个匹配，用于向后兼容)
         node.findRS485Mapping = function(address) {
-            return node.mappings.find(m => m.address === address);
+            const addr = parseInt(address);
+            return node.mappings.find(m => m.address === addr);
+        };
+        
+        // Find ALL mappings for RS485 device address (用于RS485->Mesh同步)
+        node.findAllRS485Mappings = function(address) {
+            const addr = parseInt(address);
+            return node.mappings.filter(m => m.address === addr);
         };
 
         // 获取映射的寄存器配置
@@ -360,34 +518,316 @@ module.exports = function(RED) {
             return brand.devices[mapping.device].registers;
         };
 
+        // 状态缓存 - 用于检测真正变化的开关
+        node.stateCache = {};
+        // 首次启动标记 - 跳过初始状态同步
+        node.initializing = true;
+        // 启动后延迟20秒再开始同步（Mesh网关需要15秒以上完成设备发现）
+        setTimeout(() => {
+            node.initializing = false;
+            node.log('[RS485 Bridge] 初始化完成，开始同步');
+        }, 20000);
+
         // Mesh设备状态变化处理(事件驱动)
         const handleMeshStateChange = (eventData) => {
             if (node.syncLock) return;
+            if (node.initializing) return;
             
             const mac = eventData.device.macAddress;
             const state = eventData.state || {};
-            // channel可能是0-based或1-based，需要兼容处理
-            // Mesh事件中channel通常是0-based，UI配置的meshChannel是1-based
-            const eventChannel = state.channel !== undefined ? state.channel : -1;
             
-            node.debug(`[Mesh事件] MAC=${mac}, channel=${eventChannel}, state=${JSON.stringify(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;  // 无变化
+            
+            // 首次收到设备状态时只记录缓存，不触发同步（避免启动时批量发码）
+            // 但窗帘状态(curtainStatus)除外，因为这是用户的控制命令
+            const hasCurtainStatusChange = changed.curtainStatus !== undefined;
+            if (isFirstState && !hasCurtainStatusChange) {
+                node.debug(`[Mesh事件] MAC=${mac} 首次状态，仅缓存: ${JSON.stringify(changed)}`);
+                return;
+            }
+            
+            node.log(`[Mesh事件] MAC=${mac}, 变化: ${JSON.stringify(changed)}`);
+            
+            // 规范化MAC地址用于比较
+            const macNormalized = mac.toLowerCase().replace(/:/g, '');
             
-            // 查找匹配的映射 - 遍历所有映射找到MAC匹配的
+            // 遍历映射，只处理有对应变化的映射
             for (const mapping of node.mappings) {
-                if (mapping.meshMac !== mac) continue;
+                const mappingMacNormalized = (mapping.meshMac || '').toLowerCase().replace(/:/g, '');
+                if (mappingMacNormalized !== macNormalized) continue;
+                
+                node.log(`[Mesh事件] 匹配到映射: brand=${mapping.brand}, device=${mapping.device}, codes=${JSON.stringify(mapping.customCodes)}`);
                 
-                // 通道匹配：meshChannel=0表示匹配所有，否则需要匹配具体通道
-                // UI的meshChannel是1-based，事件的channel可能是0-based
                 const configChannel = mapping.meshChannel || 1;
-                const matchChannel = (eventChannel === -1) || // 无channel信息，匹配所有
-                                    (eventChannel === configChannel) || // 1-based匹配
-                                    (eventChannel === configChannel - 1); // 0-based匹配
+                const switchKey = `switch_${configChannel}`;
+                const device = mapping.device || '';
+                
+                // 根据映射设备类型检查是否有相关状态
+                const isSwitch = device.includes('switch') || device.includes('button');
+                const isCurtain = device.includes('curtain') || mapping.brand === 'duya';
+                const isAC = device.includes('ac') || device.includes('climate') || device.includes('thermostat');
+                
+                // 【杜亚窗帘】处理Mesh面板控制同步到485
+                // 根据协议文档：
+                // - subOpcode=0x05 (NODE_ACK) = 设备确认执行命令，是用户控制
+                // - subOpcode=0x06 (NODE_STATUS) 在0xB0后1500ms内也是用户控制
+                // - attrType=0x05 (CURT_RUN_STATUS) = 状态: 1=开, 2=关, 3=停
+                // - attrType=0x06 (CURT_RUN_PER_POS) = 位置: 0-100%
+                if (mapping.brand === 'duya') {
+                    const now = Date.now();
+                    const curtainKey = `duya_curtain_${mac}`;
+                    
+                    // 只处理用户控制帧
+                    if (!eventData.isUserControl) {
+                        continue;  // 非用户控制（电机反馈），忽略
+                    }
+                    
+                    const addrHigh = mapping.addrHigh || 1;
+                    const addrLow = mapping.addrLow || 1;
+                    
+                    // 获取设备状态
+                    const device = node.gateway.deviceManager.getDeviceByMac(mac);
+                    const currentPosition = device ? device.state.curtainPosition : null;
+                    
+                    // 百分比控制 (attrType=0x06)
+                    // 只记录位置，不立即发送（等status=2时再判断是否发百分比）
+                    if (eventData.attrType === 0x06) {
+                        const position = eventData.parameters && eventData.parameters.length > 0 
+                            ? eventData.parameters[0] 
+                            : null;
+                        if (position !== null && position !== 0xFF) {
+                            // 记录最新位置，用于status=2时判断
+                            if (!node.curtainLastPos) node.curtainLastPos = {};
+                            node.curtainLastPos[curtainKey] = position;
+                            node.debug(`[Mesh->杜亚] 记录位置: ${position}%`);
+                        }
+                        continue;
+                    }
+                    
+                    // 状态控制 (attrType=0x05)
+                    if (eventData.attrType !== 0x05) {
+                        continue;
+                    }
+                    
+                    const newStatus = eventData.parameters && eventData.parameters.length > 0 
+                        ? eventData.parameters[0] 
+                        : null;
+                    
+                    // 忽略 null 值
+                    if (newStatus === null) {
+                        continue;
+                    }
+                    
+                    // 1秒防抖：避免重复发送相同状态
+                    if (!node.curtainDebounce) node.curtainDebounce = {};
+                    const debounceKey = `${curtainKey}_status_${newStatus}`;
+                    const lastTime = node.curtainDebounce[debounceKey] || 0;
+                    if (now - lastTime < 1000) {
+                        node.debug(`[Mesh->杜亚] 状态${newStatus}在1秒内重复, 忽略`);
+                        continue;
+                    }
+                    node.curtainDebounce[debounceKey] = now;
+                    
+                    node.log(`[Mesh->杜亚] 用户控制(subOpcode=0x${eventData.subOpcode.toString(16)}): status=${newStatus}, position=${currentPosition}%`);
+                    
+                    // 【米家协议状态处理】：
+                    // status=0 → 打开中 → 发open
+                    // status=1 → 关闭中 → 发close
+                    // status=2 → 停止 → 判断位置:
+                    //   - 位置=0% → 关闭到头，不发
+                    //   - 位置=100% → 打开到头，不发
+                    //   - 位置=其他 → 用户暂停或百分比控制，发stop+position
+                    
+                    let action = null, actionName = '';
+                    let sendPosition = false;
+                    
+                    if (newStatus === 0) {
+                        // 米家: 打开中
+                        action = 'open';
+                        actionName = '打开';
+                    } else if (newStatus === 1) {
+                        // 米家: 关闭中
+                        action = 'close';
+                        actionName = '关闭';
+                    } else if (newStatus === 2) {
+                        // 米家: 停止
+                        const pos = currentPosition !== null ? currentPosition : (node.curtainLastPos ? node.curtainLastPos[curtainKey] : 50);
+                        if (pos <= 2) {
+                            // 关闭到头，不发命令
+                            node.debug(`[Mesh->杜亚] 关闭到头(${pos}%)，不发命令`);
+                            continue;
+                        } else if (pos >= 98) {
+                            // 打开到头，不发命令
+                            node.debug(`[Mesh->杜亚] 打开到头(${pos}%)，不发命令`);
+                            continue;
+                        } else {
+                            // 中间位置停止，发stop + position
+                            action = 'stop';
+                            actionName = '暂停';
+                            sendPosition = true;
+                        }
+                    } else if (newStatus === 3) {
+                        // 小程序: 停止
+                        action = 'stop';
+                        actionName = '暂停';
+                    } else {
+                        continue;
+                    }
+                    
+                    // 发送动作命令
+                    if (action) {
+                        const frame = buildA6B6Frame(addrHigh, addrLow, action);
+                        node.sendRS485Frame(frame).then(() => {
+                            const hexStr = frame.toString('hex').toUpperCase().match(/.{2}/g).join(' ');
+                            node.log(`[Mesh->杜亚] ${actionName}: ${hexStr}`);
+                        }).catch(err => {
+                            node.error(`[Mesh->杜亚] 发送失败: ${err.message}`);
+                        });
+                    }
+                    
+                    // 发送位置命令（暂停时同步位置）
+                    if (sendPosition && currentPosition !== null && currentPosition > 2 && currentPosition < 98) {
+                        setTimeout(() => {
+                            const posFrame = buildA6B6Frame(addrHigh, addrLow, 'position', currentPosition);
+                            node.sendRS485Frame(posFrame).then(() => {
+                                const hexStr = posFrame.toString('hex').toUpperCase().match(/.{2}/g).join(' ');
+                                node.log(`[Mesh->杜亚] 同步位置${currentPosition}%: ${hexStr}`);
+                            }).catch(err => {
+                                node.error(`[Mesh->杜亚] 位置同步失败: ${err.message}`);
+                            });
+                        }, 100);  // 延迟100ms发送位置命令
+                    }
+                    continue;
+                }
                 
-                if (!matchChannel) continue;
+                // 【自定义窗帘】处理Mesh面板控制同步到485（逻辑同杜亚）
+                // 必须检查isUserControl，只有NODE_ACK(subOpcode=0x05)才是用户控制
+                if (mapping.brand === 'custom' && mapping.device === 'custom_curtain' && mapping.customCodes) {
+                    const now = Date.now();
+                    const curtainKey = `custom_curtain_${mac}`;
+                    
+                    // 【重要】只处理用户控制帧，忽略电机反馈
+                    if (!eventData.isUserControl) {
+                        continue;  // 非用户控制（NODE_STATUS），忽略
+                    }
+                    
+                    // 只处理窗帘状态事件 (attrType=0x05)
+                    if (eventData.attrType !== 0x05) {
+                        continue;
+                    }
+                    
+                    const newStatus = eventData.parameters && eventData.parameters.length > 0 
+                        ? eventData.parameters[0] 
+                        : null;
+                    
+                    // 忽略 null 值
+                    if (newStatus === null) {
+                        continue;
+                    }
+                    
+                    // 1秒防抖：避免重复发送相同状态（与杜亚窗帘一致）
+                    if (!node.curtainDebounce) node.curtainDebounce = {};
+                    const debounceKey = `${curtainKey}_status`;
+                    const lastTime = node.curtainDebounce[debounceKey] || 0;
+                    if (now - lastTime < 1000) {
+                        node.debug(`[Mesh->自定义窗帘] 状态1秒内重复, 忽略`);
+                        continue;
+                    }
+                    node.curtainDebounce[debounceKey] = now;
+                    
+                    // 【兼容两种协议】：
+                    // 米家协议: 0=打开中, 1=关闭中, 2=停止
+                    // 小程序协议: 1=打开, 2=关闭, 3=停止
+                    // 使用device.state.curtainAction来获取正确的动作
+                    const device = node.gateway.deviceManager.getDeviceByMac(mac);
+                    const curtainAction = device ? device.state.curtainAction : null;
+                    
+                    const codes = mapping.customCodes;
+                    let hexCode = null, actionName = '';
+                    
+                    if (curtainAction === 'opening' && codes.open) {
+                        hexCode = codes.open;
+                        actionName = '打开';
+                    } else if (curtainAction === 'closing' && codes.close) {
+                        hexCode = codes.close;
+                        actionName = '关闭';
+                    } else if (curtainAction === 'stopped' && codes.stop) {
+                        hexCode = codes.stop;
+                        actionName = '暂停';
+                    } else {
+                        // 回退：直接使用原始status值（兼容旧逻辑，小程序协议）
+                        if (newStatus === 1 && codes.open) {
+                            hexCode = codes.open; actionName = '打开';
+                        } else if (newStatus === 2 && codes.close) {
+                            hexCode = codes.close; actionName = '关闭';
+                        } else if (newStatus === 3 && codes.stop) {
+                            hexCode = codes.stop; actionName = '暂停';
+                        }
+                    }
+                    
+                    if (hexCode) {
+                        node.sendCustomCode(hexCode).then(() => {
+                            node.log(`[Mesh->自定义] ${actionName}: ${hexCode}`);
+                        }).catch(err => {
+                            node.error(`[Mesh->自定义] 发送失败: ${err.message}`);
+                        });
+                    }
+                    continue;
+                }
+                
+                // 其他窗帘类型标记
+                const isCurtainControlled = false;
+                
+                // 只有对应类型的状态变化才触发对应类型的映射
+                const hasSwitchChange = isSwitch && changed[switchKey] !== undefined;
+                // 窗帘：如果是杜亚窗帘，跳过状态变化处理（已在curtain-control中处理）
+                const hasCurtainChange = isCurtain && !isCurtainControlled && (
+                    changed.curtainAction !== undefined || 
+                    changed.curtainPosition !== undefined || 
+                    changed.curtainStatus !== undefined
+                );
+                const hasACChange = isAC && (
+                    changed.targetTemp !== undefined || 
+                    changed.acMode !== undefined || 
+                    changed.acFanSpeed !== undefined ||
+                    // 三合一面板使用climate前缀
+                    changed.climateSwitch !== undefined ||
+                    changed.climateMode !== undefined ||
+                    changed.fanMode !== undefined
+                );
+                // 新风设备检测
+                const isFreshAir = device.includes('fresh_air');
+                const hasFreshAirChange = isFreshAir && (
+                    changed.freshAirSwitch !== undefined ||
+                    changed.freshAirSpeed !== undefined
+                );
+                // 地暖设备检测
+                const isFloorHeating = device.includes('floor_heating');
+                const hasFloorHeatingChange = isFloorHeating && (
+                    changed.floorHeatingSwitch !== undefined ||
+                    changed.floorHeatingTemp !== undefined
+                );
+                
+                if (!hasSwitchChange && !hasCurtainChange && !hasACChange && !hasFreshAirChange && !hasFloorHeatingChange) {
+                    continue;
+                }
                 
                 const registers = node.getRegistersForMapping(mapping);
                 
-                node.log(`[Mesh->RS485] ${eventData.device.name} 通道${configChannel} 状态变化: ${JSON.stringify(state)}`);
+                node.log(`[Mesh->RS485] ${eventData.device.name} CH${configChannel} 变化: ${JSON.stringify(changed)}`);
                 
                 // 输出调试信息到节点输出端口
                 node.send({
@@ -397,7 +837,7 @@ module.exports = function(RED) {
                         device: eventData.device.name,
                         mac: mac,
                         channel: configChannel,
-                        state: state
+                        state: changed
                     },
                     timestamp: new Date().toISOString()
                 });
@@ -406,11 +846,127 @@ module.exports = function(RED) {
                     direction: 'mesh-to-modbus', 
                     mapping: mapping,
                     registers: registers,
-                    state: state, 
+                    state: changed, 
                     timestamp: Date.now() 
                 });
+            }
+        };
+
+        // 窗帘控制命令处理（立即同步，不等状态反馈）
+        // 同时支持杜亚窗帘和自定义窗帘
+        const handleCurtainControl = (eventData) => {
+            const mac = eventData.mac;
+            
+            node.log(`[curtain-control事件] MAC=${mac}, action=${eventData.action}, position=${eventData.position}`);
+            
+            // 查找窗帘映射（杜亚或自定义窗帘）
+            const macNormalized = mac.toLowerCase().replace(/:/g, '');
+            for (const mapping of node.mappings) {
+                const mappingMacNormalized = (mapping.meshMac || '').toLowerCase().replace(/:/g, '');
+                if (mappingMacNormalized !== macNormalized) continue;
                 
-                break; // 找到匹配的映射就停止
+                // ===== 杜亚窗帘 =====
+                if (mapping.brand === 'duya') {
+                    node.log(`[curtain-control] 匹配到杜亚映射: ${mapping.meshMac}`);
+                    
+                    const addrHigh = mapping.addrHigh || 1;
+                    const addrLow = mapping.addrLow || 1;
+                    
+                    let frame = null;
+                    let actionName = '';
+                    
+                    // 处理动作命令 (attrType=0x05)
+                    if (eventData.action !== null) {
+                        if (eventData.action === 1) {
+                            frame = buildA6B6Frame(addrHigh, addrLow, 'open');
+                            actionName = '打开';
+                        } else if (eventData.action === 2) {
+                            frame = buildA6B6Frame(addrHigh, addrLow, 'close');
+                            actionName = '关闭';
+                        } else if (eventData.action === 3) {
+                            frame = buildA6B6Frame(addrHigh, addrLow, 'stop');
+                            actionName = '暂停';
+                        }
+                    }
+                    // 处理位置命令 (attrType=0x06)
+                    else if (eventData.position !== null) {
+                        const pos = eventData.position;
+                        if (pos >= 95) {
+                            frame = buildA6B6Frame(addrHigh, addrLow, 'open');
+                            actionName = '打开';
+                        } else if (pos <= 5) {
+                            frame = buildA6B6Frame(addrHigh, addrLow, 'close');
+                            actionName = '关闭';
+                        } else {
+                            frame = buildA6B6Frame(addrHigh, addrLow, 'position', pos);
+                            actionName = `位置${pos}%`;
+                        }
+                    }
+                    
+                    if (frame) {
+                        // 立即发送，记录时间防止状态反馈重复发码
+                        node.lastCurtainControlTime = Date.now();
+                        node.lastMeshToRS485Time = Date.now();
+                        if (!node.lastSentTime) node.lastSentTime = {};
+                        node.lastSentTime[`duya_${mac}_${actionName}`] = Date.now();
+                        
+                        node.sendRS485Frame(frame).then(() => {
+                            const hexStr = frame.toString('hex').toUpperCase();
+                            node.log(`[Mesh控制->杜亚] 窗帘 ${actionName}, 立即发送: ${hexStr.match(/.{2}/g).join(' ')}`);
+                        }).catch(err => {
+                            node.error(`[Mesh控制->杜亚] 发送失败: ${err.message}`);
+                        });
+                    }
+                }
+                // ===== 自定义窗帘 =====
+                else if (mapping.brand === 'custom' && mapping.device === 'custom_curtain' && mapping.customCodes) {
+                    const codes = mapping.customCodes;
+                    
+                    node.log(`[curtain-control] 匹配到自定义窗帘映射: ${mapping.meshMac}`);
+                    
+                    let hexCode = null;
+                    let actionName = '';
+                    
+                    // 处理动作命令 (attrType=0x05): 1=打开, 2=关闭, 3=停止
+                    if (eventData.action !== null) {
+                        if (eventData.action === 1 && codes.open) {
+                            hexCode = codes.open;
+                            actionName = '打开';
+                        } else if (eventData.action === 2 && codes.close) {
+                            hexCode = codes.close;
+                            actionName = '关闭';
+                        } else if (eventData.action === 3 && codes.stop) {
+                            hexCode = codes.stop;
+                            actionName = '暂停';
+                        }
+                    }
+                    // 处理位置命令 (attrType=0x06)
+                    else if (eventData.position !== null) {
+                        const pos = eventData.position;
+                        if (pos >= 95 && codes.open) {
+                            hexCode = codes.open;
+                            actionName = '打开';
+                        } else if (pos <= 5 && codes.close) {
+                            hexCode = codes.close;
+                            actionName = '关闭';
+                        }
+                        // 自定义窗帘不支持百分比位置，只能发开/关
+                    }
+                    
+                    if (hexCode) {
+                        // 立即发送，记录时间防止状态反馈重复发码
+                        node.lastCurtainControlTime = Date.now();
+                        node.lastMeshToRS485Time = Date.now();
+                        if (!node.lastSentTime) node.lastSentTime = {};
+                        node.lastSentTime[`custom_curtain_${mac}_${hexCode}`] = Date.now();
+                        
+                        node.sendCustomCode(hexCode).then(() => {
+                            node.log(`[Mesh控制->自定义] 窗帘 ${actionName}, 立即发送: ${hexCode}`);
+                        }).catch(err => {
+                            node.error(`[Mesh控制->自定义] 发送失败: ${err.message}`);
+                        });
+                    }
+                }
             }
         };
 
@@ -434,16 +990,30 @@ module.exports = function(RED) {
             });
         };
 
-        // 命令队列顺序处理
+        // 命令队列顺序处理（限制最大100条，防止内存溢出）
+        const MAX_QUEUE_SIZE = 100;
         node.queueCommand = function(cmd) {
-            // 检查队列中是否有相似命令(防抖)
+            // 队列过大时丢弃旧命令，防止内存溢出
+            if (node.commandQueue.length >= MAX_QUEUE_SIZE) {
+                node.warn(`[RS485 Bridge] 命令队列已满(${MAX_QUEUE_SIZE})，丢弃最旧命令`);
+                node.commandQueue.shift();  // 丢弃最旧的命令
+            }
+            
+            // 检查队列中是否有完全相同映射的命令(防抖)
+            // 必须是同一个映射（meshMac + meshChannel + address + rs485Channel）才能合并
             const existing = node.commandQueue.find(c => 
                 c.direction === cmd.direction && 
+                c.mapping && cmd.mapping &&
+                c.mapping.meshMac === cmd.mapping.meshMac &&
+                c.mapping.meshChannel === cmd.mapping.meshChannel &&
+                c.mapping.address === cmd.mapping.address &&
+                c.mapping.rs485Channel === cmd.mapping.rs485Channel &&
                 Date.now() - c.timestamp < 100
             );
             if (existing) {
-                // 合并状态
+                // 合并状态（仅限完全相同的映射）
                 existing.state = { ...existing.state, ...cmd.state };
+                node.debug(`[队列] 合并相同映射的命令: ${cmd.mapping.meshMac} CH${cmd.mapping.meshChannel}`);
                 return;
             }
             
@@ -501,6 +1071,95 @@ module.exports = function(RED) {
             // 记录发送时间（用于防死循环）
             node.lastMeshToRS485Time = Date.now();
             
+            // ===== 杜亚窗帘协议模式 =====
+            if (mapping.brand === 'duya') {
+                const addrHigh = mapping.addrHigh || 1;
+                const addrLow = mapping.addrLow || 1;
+                
+                // 缓存：记录 status 和 position
+                if (!node.curtainCache) node.curtainCache = {};
+                const cKey = `cc_${mapping.meshMac}`;
+                const cache = node.curtainCache[cKey] || { status: undefined, position: 50 };
+                
+                const lastStatus = cache.status;
+                const currentStatus = state.curtainStatus;
+                
+                // 【重要】先更新位置缓存，再判断方向
+                // 第一个事件通常同时包含 status 和 position
+                if (state.curtainPosition !== undefined) {
+                    cache.position = state.curtainPosition;
+                }
+                
+                // 判断方向时使用的位置：优先使用事件中的位置，否则使用缓存
+                const posForDirection = state.curtainPosition !== undefined ? state.curtainPosition : cache.position;
+                
+                // 更新状态缓存
+                if (currentStatus !== undefined) {
+                    cache.status = currentStatus;
+                }
+                node.curtainCache[cKey] = cache;
+                
+                let frame = null;
+                let actionName = '';
+                
+                // 【兼容两种协议】：
+                // 米家协议: 0=打开中, 1=关闭中, 2=停止
+                // 小程序协议: 1=打开, 2=关闭, 3=停止
+                // 使用curtainAction来判断动作（由device-manager解析）
+                const curtainAction = state.curtainAction;
+                
+                if (curtainAction === 'opening') {
+                    frame = buildA6B6Frame(addrHigh, addrLow, 'open');
+                    actionName = '打开';
+                } else if (curtainAction === 'closing') {
+                    frame = buildA6B6Frame(addrHigh, addrLow, 'close');
+                    actionName = '关闭';
+                } else if (curtainAction === 'stopped') {
+                    frame = buildA6B6Frame(addrHigh, addrLow, 'stop');
+                    actionName = '暂停';
+                }
+                // 回退：如果curtainAction未设置，使用原始status值（小程序协议）
+                else if (currentStatus === 1) {
+                    frame = buildA6B6Frame(addrHigh, addrLow, 'open');
+                    actionName = '打开';
+                } else if (currentStatus === 2) {
+                    frame = buildA6B6Frame(addrHigh, addrLow, 'close');
+                    actionName = '关闭';
+                } else if (currentStatus === 3) {
+                    frame = buildA6B6Frame(addrHigh, addrLow, 'stop');
+                    actionName = '暂停';
+                }
+                // 3. 只有位置变化（没有状态变化），中间位置发百分比码
+                else if (state.curtainPosition !== undefined && 
+                         state.curtainStatus === undefined &&
+                         state.curtainPosition > 5 && state.curtainPosition < 95) {
+                    frame = buildA6B6Frame(addrHigh, addrLow, 'position', state.curtainPosition);
+                    actionName = `位置${state.curtainPosition}%`;
+                }
+                
+                if (frame) {
+                    // 全局防抖: 2秒内不重复发送开关码（过滤运行中的状态抖动）
+                    if (!node.lastSentTime) node.lastSentTime = {};
+                    const isOpenClose = (actionName === '打开' || actionName === '关闭');
+                    const cacheKey = isOpenClose ? `duya_${mapping.meshMac}_openclose` : `duya_${mapping.meshMac}_${actionName}`;
+                    const debounceTime = isOpenClose ? 2000 : 1500;  // 开关码用2秒防抖
+                    const now = Date.now();
+                    const lastTime = node.lastSentTime[cacheKey] || 0;
+                    
+                    if (now - lastTime < debounceTime) {
+                        node.debug(`[Mesh->杜亚] 窗帘 ${actionName} ${debounceTime}ms内防抖跳过`);
+                    } else {
+                        node.lastSentTime[cacheKey] = now;
+                        const hexStr = frame.toString('hex').toUpperCase();
+                        await node.sendRS485Frame(frame);
+                        node.log(`[Mesh->杜亚] 窗帘 ${actionName}, 位置${posForDirection}%, 发送: ${hexStr.match(/.{2}/g).join(' ')}`);
+                    }
+                }
+                
+                node.status({ fill: 'green', shape: 'dot', text: `杜亚同步 ${node.mappings.length}个` });
+                return;
+            }
+            
             // ===== 自定义协议模式 =====
             if (mapping.brand === 'custom' && mapping.customCodes) {
                 const codes = mapping.customCodes;
@@ -521,17 +1180,63 @@ module.exports = function(RED) {
                 }
                 // 窗帘类型
                 else if (mapping.device === 'custom_curtain') {
-                    for (const [key, value] of Object.entries(state)) {
-                        if (key === 'position' || key === 'action') {
-                            let hexCode = null;
-                            if (value === 'open' || value === 100) hexCode = codes.open;
-                            else if (value === 'close' || value === 0) hexCode = codes.close;
-                            else if (value === 'stop') hexCode = codes.stop;
-                            
-                            if (hexCode) {
-                                await node.sendCustomCode(hexCode);
-                                node.log(`[Mesh->自定义] 窗帘: ${value}, 发送: ${hexCode}`);
-                            }
+                    node.log(`[Mesh->自定义] 窗帘状态: ${JSON.stringify(state)}`);
+                    
+                    // 优先级：curtainAction > curtainStatus > curtainPosition
+                    // 只发送一次，避免重复
+                    let hexCode = null;
+                    let actionName = '';
+                    
+                    // 1. 优先检查动作命令
+                    if (state.curtainAction !== undefined || state.action !== undefined) {
+                        const action = state.curtainAction || state.action;
+                        if (action === 1 || action === 'open') {
+                            hexCode = codes.open;
+                            actionName = '打开';
+                        } else if (action === 2 || action === 'close') {
+                            hexCode = codes.close;
+                            actionName = '关闭';
+                        } else if (action === 3 || action === 'stop') {
+                            hexCode = codes.stop;
+                            actionName = '停止';
+                        }
+                    }
+                    // 2. 其次检查运行状态
+                    else if (state.curtainStatus !== undefined) {
+                        if (state.curtainStatus === 1) {
+                            hexCode = codes.open;
+                            actionName = '打开(运行中)';
+                        } else if (state.curtainStatus === 2) {
+                            hexCode = codes.close;
+                            actionName = '关闭(运行中)';
+                        } else if (state.curtainStatus === 0 && codes.stop) {
+                            // 0=已停止，发送停止码
+                            hexCode = codes.stop;
+                            actionName = '停止';
+                        }
+                    }
+                    // 3. 最后检查位置（仅在极端位置时）
+                    else if (state.curtainPosition !== undefined) {
+                        if (state.curtainPosition >= 95) {
+                            hexCode = codes.open;
+                            actionName = '打开(位置>=95)';
+                        } else if (state.curtainPosition <= 5) {
+                            hexCode = codes.close;
+                            actionName = '关闭(位置<=5)';
+                        }
+                    }
+                    
+                    if (hexCode) {
+                        // 防抖：500ms内不重复发送相同命令
+                        const cacheKey = `curtain_${mapping.meshMac}_${hexCode}`;
+                        const now = Date.now();
+                        if (node.lastSentTime && node.lastSentTime[cacheKey] && now - node.lastSentTime[cacheKey] < 500) {
+                            node.debug(`[Mesh->自定义] 窗帘 ${actionName} 防抖跳过`);
+                        } else {
+                            if (!node.lastSentTime) node.lastSentTime = {};
+                            node.lastSentTime[cacheKey] = now;
+                            await node.sendCustomCode(hexCode);
+                            node.log(`[Mesh->自定义] 窗帘 ${actionName}, 发送: ${hexCode}`);
                         }
                     }
                 }
@@ -597,22 +1302,112 @@ module.exports = function(RED) {
                             node.log(`[Mesh->RS485] 从机${mapping.address} 按键${rs485Channel}: ${value ? '开' : '关'}`);
                         }
                     }
+                    // 空调开关 (支持acSwitch和climateSwitch两种字段名)
+                    else if ((meshKey === 'acSwitch' || meshKey === 'climateSwitch') && registers && registers.switch) {
+                        const writeValue = value ? (registers.switch.on !== undefined ? registers.switch.on : 1) : 
+                                                   (registers.switch.off !== undefined ? registers.switch.off : 0);
+                        await node.writeModbusRegister(mapping.address, registers.switch, writeValue);
+                        node.log(`[Mesh->RS485] 空调开关: ${value ? '开' : '关'}`);
+                    }
+                    // 目标温度
                     else if ((meshKey === 'targetTemp' || meshKey === 'acTargetTemp') && registers && registers.targetTemp) {
                         await node.writeModbusRegister(mapping.address, registers.targetTemp, value);
-                        node.debug(`[Mesh->RS485] 目标温度: ${value}`);
+                        node.log(`[Mesh->RS485] 目标温度: ${value}°C`);
                     }
-                    else if (meshKey === 'acMode' && registers && registers.mode) {
-                        await node.writeModbusRegister(mapping.address, registers.mode, value);
-                        node.debug(`[Mesh->RS485] 模式: ${value}`);
+                    // 空调模式 (支持acMode和climateMode两种字段名)
+                    // Mesh协议: 1=制冷, 2=制热, 3=送风, 4=除湿
+                    // RS485(话语前湾): 1=制热, 2=制冷, 4=送风, 8=除湿
+                    else if ((meshKey === 'acMode' || meshKey === 'climateMode') && registers && registers.mode) {
+                        // Mesh值转RS485值
+                        const meshToRs485 = { 1: 2, 2: 1, 3: 4, 4: 8 };  // 1=cool->2, 2=heat->1, 3=fan->4, 4=dry->8
+                        let rs485Value = meshToRs485[value];
+                        if (rs485Value === undefined) {
+                            // 尝试使用寄存器map反向映射
+                            if (registers.mode.map) {
+                                const modeNames = { 1: 'cool', 2: 'heat', 3: 'fan', 4: 'dry' };
+                                const meshModeName = modeNames[value] || value;
+                                const found = Object.entries(registers.mode.map).find(([k, v]) => v === meshModeName);
+                                if (found) {
+                                    rs485Value = parseInt(found[0]);
+                                }
+                            }
+                        }
+                        if (rs485Value !== undefined) {
+                            await node.writeModbusRegister(mapping.address, registers.mode, rs485Value);
+                            node.log(`[Mesh->RS485] 空调模式: Mesh值${value} -> RS485值${rs485Value}`);
+                        }
                     }
-                    else if (meshKey === 'acFanSpeed' && registers && registers.fanSpeed) {
-                        await node.writeModbusRegister(mapping.address, registers.fanSpeed, value);
-                        node.debug(`[Mesh->RS485] 风速: ${value}`);
+                    // 风速 (支持acFanSpeed和fanMode两种字段名)
+                    // 三合一0x94协议: 0=自动, 1=低, 2=中, 4=高
+                    // RS485(话语前湾): 1=低风, 2=中风, 3=高风
+                    else if ((meshKey === 'acFanSpeed' || meshKey === 'fanMode') && registers && registers.fanSpeed) {
+                        // 三合一0x94协议值转RS485值: 1=低->1, 2=中->2, 4=高->3, 0=自动->1(默认低)
+                        const meshToRs485 = { 0: 1, 1: 1, 2: 2, 4: 3 };
+                        let rs485Value = meshToRs485[value];
+                        if (rs485Value === undefined) {
+                            // 尝试使用寄存器map反向映射
+                            if (registers.fanSpeed.map) {
+                                const speedNames = { 0: 'auto', 1: 'low', 2: 'medium', 4: 'high' };
+                                const meshSpeedName = speedNames[value] || value;
+                                const found = Object.entries(registers.fanSpeed.map).find(([k, v]) => v === meshSpeedName);
+                                if (found) {
+                                    rs485Value = parseInt(found[0]);
+                                }
+                            }
+                        }
+                        if (rs485Value !== undefined) {
+                            await node.writeModbusRegister(mapping.address, registers.fanSpeed, rs485Value);
+                            node.log(`[Mesh->RS485] 空调风速: Mesh值${value} -> RS485值${rs485Value}`);
+                        }
                     }
                     else if (meshKey === 'brightness' && registers && registers.brightness) {
                         await node.writeModbusRegister(mapping.address, registers.brightness, value);
                         node.debug(`[Mesh->RS485] 亮度: ${value}`);
                     }
+                    // ===== 地暖控制 =====
+                    // Mesh状态: floorHeatingSwitch (true/false), floorHeatingTemp (18-32)
+                    else if (meshKey === 'floorHeatingSwitch' && registers && registers.switch) {
+                        const writeValue = value ? (registers.switch.on !== undefined ? registers.switch.on : 2) : 
+                                                   (registers.switch.off !== undefined ? registers.switch.off : 0);
+                        await node.writeModbusRegister(mapping.address, registers.switch, writeValue);
+                        node.log(`[Mesh->RS485] 地暖开关: ${value ? '开' : '关'}, 值=${writeValue}`);
+                    }
+                    else if (meshKey === 'floorHeatingTemp' && registers && registers.targetTemp) {
+                        await node.writeModbusRegister(mapping.address, registers.targetTemp, value);
+                        node.log(`[Mesh->RS485] 地暖温度: ${value}°C`);
+                    }
+                    // ===== 新风控制 =====
+                    // Mesh状态: freshAirSwitch (true/false), freshAirSpeed (1=高,2=中,3=低,4=自动)
+                    else if (meshKey === 'freshAirSwitch' && registers && registers.switch) {
+                        const writeValue = value ? (registers.switch.on !== undefined ? registers.switch.on : 1) : 
+                                                   (registers.switch.off !== undefined ? registers.switch.off : 0);
+                        await node.writeModbusRegister(mapping.address, registers.switch, writeValue);
+                        node.log(`[Mesh->RS485] 新风开关: ${value ? '开' : '关'}, 值=${writeValue}`);
+                    }
+                    else if (meshKey === 'freshAirSpeed' && registers && registers.fanSpeed) {
+                        // Mesh新风风速: 1=高, 2=中, 3=低, 4=自动
+                        // 话语前湾新风: 0=低速, 2=高速
+                        const meshToRs485 = { 1: 2, 2: 2, 3: 0, 4: 0 };  // 高/中->高速, 低/自动->低速
+                        const rs485Value = meshToRs485[value] !== undefined ? meshToRs485[value] : 0;
+                        await node.writeModbusRegister(mapping.address, registers.fanSpeed, rs485Value);
+                        node.log(`[Mesh->RS485] 新风风速: Mesh值${value} -> RS485值${rs485Value}`);
+                    }
+                    // ===== 空调开关(兼容climateSwitch) =====
+                    else if (meshKey === 'climateSwitch' && registers && registers.switch) {
+                        const writeValue = value ? (registers.switch.on !== undefined ? registers.switch.on : 1) : 
+                                                   (registers.switch.off !== undefined ? registers.switch.off : 0);
+                        await node.writeModbusRegister(mapping.address, registers.switch, writeValue);
+                        node.log(`[Mesh->RS485] 空调开关(climateSwitch): ${value ? '开' : '关'}`);
+                    }
+                    // ===== 空调模式(兼容climateMode) =====
+                    else if (meshKey === 'climateMode' && registers && registers.mode) {
+                        const meshToRs485 = { 1: 2, 2: 1, 3: 4, 4: 8 };
+                        const rs485Value = meshToRs485[value];
+                        if (rs485Value !== undefined) {
+                            await node.writeModbusRegister(mapping.address, registers.mode, rs485Value);
+                            node.log(`[Mesh->RS485] 空调模式(climateMode): Mesh值${value} -> RS485值${rs485Value}`);
+                        }
+                    }
                 } catch (err) {
                     node.error(`RS485写入失败: ${meshKey}=${value}, ${err.message}`);
                 }
@@ -637,15 +1432,60 @@ module.exports = function(RED) {
         node.syncModbusToMesh = async function(cmd) {
             const { mapping, registers, state, customMode } = cmd;
             
-            // 查找Mesh设备
-            const meshDevice = node.gateway.getDevice(mapping.meshMac);
+            // 规范化MAC地址 - 尝试多种格式查找设备
+            const meshMac = mapping.meshMac || '';
+            const macNormalized = meshMac.toLowerCase().replace(/:/g, '');
+            
+            // 尝试多种格式查找Mesh设备
+            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(`未找到Mesh设备: ${mapping.meshMac}`);
+                node.warn(`[RS485->Mesh] 未找到Mesh设备: ${meshMac} (规范化: ${macNormalized})`);
+                // 输出可用设备列表帮助调试
+                const allDevices = node.gateway.deviceManager?.getAllDevices() || [];
+                node.warn(`[RS485->Mesh] 可用设备: ${allDevices.map(d => d.macAddress).join(', ')}`);
                 return;
             }
+            
+            node.log(`[RS485->Mesh] 找到设备: ${meshDevice.name}, MAC=${meshDevice.macAddress}, 网络地址=0x${meshDevice.networkAddress.toString(16)}`);
 
             const channel = mapping.meshChannel || 1;
             
+            // ===== 杜亚窗帘协议模式 =====
+            if (cmd.duyaMode || mapping.brand === 'duya') {
+                node.log(`[杜亚->Mesh] 设备${mapping.meshMac}, 状态: ${JSON.stringify(state)}`);
+                
+                try {
+                    if (state.curtainAction !== undefined || state.action !== undefined) {
+                        const action = state.curtainAction || (state.action === 'open' ? 1 : state.action === 'close' ? 2 : 3);
+                        const param = Buffer.from([action]);
+                        await node.gateway.sendControl(meshDevice.networkAddress, 0x05, param);
+                        node.log(`[杜亚->Mesh] 窗帘动作: ${action === 1 ? '打开' : action === 2 ? '关闭' : '停止'}`);
+                    } else if (state.curtainPosition !== undefined || state.position !== undefined) {
+                        const pos = state.curtainPosition || state.position;
+                        const param = Buffer.from([pos]);
+                        await node.gateway.sendControl(meshDevice.networkAddress, 0x06, param);
+                        node.log(`[杜亚->Mesh] 窗帘位置: ${pos}%`);
+                    }
+                } catch (err) {
+                    node.error(`[杜亚->Mesh] 写入失败: ${err.message}`);
+                }
+                
+                node.status({ fill: 'blue', shape: 'dot', text: `杜亚同步 ${node.mappings.length}个` });
+                return;
+            }
+            
             // ===== 自定义协议模式 =====
             if (customMode || mapping.brand === 'custom') {
                 node.log(`[自定义->Mesh] 设备${mapping.meshMac}, 通道${channel}, 状态: ${JSON.stringify(state)}`);
@@ -661,14 +1501,16 @@ module.exports = function(RED) {
                         }
                         // 窗帘类型
                         else if (key === 'action' || key === 'position') {
-                            let action = 0x00;  // 停止
+                            // 窗帘动作: 1=打开, 2=关闭, 3=停止
+                            let action = 0x03;  // 停止
                             if (value === 'open') action = 0x01;  // 打开
                             else if (value === 'close') action = 0x02;  // 关闭
-                            else if (value === 'stop') action = 0x00;  // 停止
+                            else if (value === 'stop') action = 0x03;  // 停止
                             
                             const param = Buffer.from([action]);
-                            await node.gateway.sendControl(meshDevice.networkAddress, 0x04, param);
-                            node.log(`[自定义->Mesh] 窗帘: ${value}`);
+                            // 0x05是窗帘动作控制属性
+                            await node.gateway.sendControl(meshDevice.networkAddress, 0x05, param);
+                            node.log(`[自定义->Mesh] 窗帘: ${value} (动作码${action})`);
                         }
                     } catch (err) {
                         node.error(`Mesh写入失败: ${key}=${value}, ${err.message}`);
@@ -698,28 +1540,89 @@ module.exports = function(RED) {
                     else if (key.startsWith('led')) {
                         node.debug(`[RS485] 指示灯${key}: ${value}`);
                     }
+                    // 空调开关 - 0x02是开关属性 (0x01=关, 0x02=开)
+                    else if (key === 'acSwitch' || (key === 'switch' && mapping.device && mapping.device.includes('ac'))) {
+                        const param = Buffer.from([value ? 0x02 : 0x01]);
+                        await node.gateway.sendControl(meshDevice.networkAddress, 0x02, param);
+                        node.log(`[RS485->Mesh] 空调开关: ${value ? '开' : '关'}`);
+                    }
+                    // 目标温度 - 0x1B是目标温度属性
                     else if (key === 'targetTemp') {
                         const param = Buffer.from([Math.round(value)]);
-                        await node.gateway.sendControl(meshDevice.networkAddress, 0x1C, param);
-                        node.debug(`[RS485->Mesh] 目标温度: ${value}`);
+                        await node.gateway.sendControl(meshDevice.networkAddress, 0x1B, param);
+                        node.log(`[RS485->Mesh] 目标温度: ${value}°C`);
                     }
+                    // 空调模式 - 0x1D是模式属性
+                    // RS485(话语前湾): 1=制热, 2=制冷, 4=送风, 8=除湿
+                    // Mesh协议: 1=制冷, 2=制热, 3=送风, 4=除湿
                     else if (key === 'mode') {
-                        const modeMap = { 'cool': 0, 'heat': 1, 'fan': 2, 'dry': 3 };
-                        const param = Buffer.from([modeMap[value] !== undefined ? modeMap[value] : 0]);
-                        await node.gateway.sendControl(meshDevice.networkAddress, 0x16, param);
-                        node.debug(`[RS485->Mesh] 模式: ${value}`);
+                        // 从RS485值或字符串转换为Mesh值
+                        let meshMode = 1;  // 默认制冷
+                        if (typeof value === 'string') {
+                            const modeMap = { 'cool': 1, 'heat': 2, 'fan': 3, 'dry': 4 };
+                            meshMode = modeMap[value] !== undefined ? modeMap[value] : 1;
+                        } else {
+                            // RS485(话语前湾)数值转Mesh值
+                            const rs485ToMesh = { 1: 2, 2: 1, 4: 3, 8: 4 };  // 1=heat->2, 2=cool->1, 4=fan->3, 8=dry->4
+                            meshMode = rs485ToMesh[value] !== undefined ? rs485ToMesh[value] : 1;
+                        }
+                        const param = Buffer.from([meshMode]);
+                        await node.gateway.sendControl(meshDevice.networkAddress, 0x1D, param);
+                        node.log(`[RS485->Mesh] 空调模式: RS485值${value} -> Mesh值${meshMode}`);
                     }
+                    // 风速 - 0x1C是风速属性
+                    // RS485(话语前湾): 1=低风, 2=中风, 3=高风
+                    // Mesh协议: 1=高, 2=中, 3=低, 4=自动
                     else if (key === 'fanSpeed') {
-                        const speedMap = { 'high': 1, 'medium': 2, 'low': 3, 'auto': 4 };
-                        const param = Buffer.from([speedMap[value] !== undefined ? speedMap[value] : 4]);
-                        await node.gateway.sendControl(meshDevice.networkAddress, 0x1D, param);
-                        node.debug(`[RS485->Mesh] 风速: ${value}`);
+                        let meshSpeed = 3;  // 默认低
+                        if (typeof value === 'string') {
+                            const speedMap = { 'low': 3, 'medium': 2, 'high': 1, 'auto': 4 };
+                            meshSpeed = speedMap[value] !== undefined ? speedMap[value] : 3;
+                        } else {
+                            // RS485(话语前湾)数值转Mesh值: 1=低->3, 2=中->2, 3=高->1
+                            const rs485ToMesh = { 1: 3, 2: 2, 3: 1 };
+                            meshSpeed = rs485ToMesh[value] !== undefined ? rs485ToMesh[value] : 3;
+                        }
+                        const param = Buffer.from([meshSpeed]);
+                        await node.gateway.sendControl(meshDevice.networkAddress, 0x1C, param);
+                        node.log(`[RS485->Mesh] 空调风速: RS485值${value} -> Mesh值${meshSpeed}`);
                     }
                     else if (key === 'brightness') {
                         const param = Buffer.from([Math.round(value)]);
                         await node.gateway.sendControl(meshDevice.networkAddress, 0x03, param);
                         node.debug(`[RS485->Mesh] 亮度: ${value}`);
                     }
+                    // ===== 地暖控制 (RS485->Mesh) =====
+                    // 地暖开关 - 0x6B是地暖开关属性 (0x02=开, 0x01=关)
+                    else if (key === 'floorHeatingSwitch') {
+                        const param = Buffer.from([value ? 0x02 : 0x01]);
+                        await node.gateway.sendControl(meshDevice.networkAddress, 0x6B, param);
+                        node.log(`[RS485->Mesh] 地暖开关: ${value ? '开' : '关'}`);
+                    }
+                    // 地暖温度 - 0x6C是地暖温度属性 (18-32°C)
+                    else if (key === 'floorHeatingTemp') {
+                        const temp = Math.max(18, Math.min(32, Math.round(value)));
+                        const param = Buffer.from([temp]);
+                        await node.gateway.sendControl(meshDevice.networkAddress, 0x6C, param);
+                        node.log(`[RS485->Mesh] 地暖温度: ${temp}°C`);
+                    }
+                    // ===== 新风控制 (RS485->Mesh) =====
+                    // 新风开关 - 0x68是新风开关属性 (0x02=开, 0x01=关)
+                    else if (key === 'freshAirSwitch') {
+                        const param = Buffer.from([value ? 0x02 : 0x01]);
+                        await node.gateway.sendControl(meshDevice.networkAddress, 0x68, param);
+                        node.log(`[RS485->Mesh] 新风开关: ${value ? '开' : '关'}`);
+                    }
+                    // 新风风速 - 0x6A是新风风速属性 (1=高,2=中,3=低,4=自动)
+                    else if (key === 'freshAirSpeed') {
+                        // 话语前湾新风: 0=低速, 2=高速 -> Mesh: 1=高,3=低
+                        let meshSpeed = 3;  // 默认低
+                        if (value === 2 || value === 'high') meshSpeed = 1;  // 高速
+                        else if (value === 0 || value === 'low') meshSpeed = 3;  // 低速
+                        const param = Buffer.from([meshSpeed]);
+                        await node.gateway.sendControl(meshDevice.networkAddress, 0x6A, param);
+                        node.log(`[RS485->Mesh] 新风风速: RS485值${value} -> Mesh值${meshSpeed}`);
+                    }
                 } catch (err) {
                     node.error(`Mesh写入失败: ${key}=${value}, ${err.message}`);
                 }
@@ -815,12 +1718,83 @@ module.exports = function(RED) {
             const hexStr = frame.toString('hex').toUpperCase();
             const hexFormatted = hexStr.match(/.{1,2}/g)?.join(' ') || '';
             
-            // 首先检查自定义码匹配（遍历所有映射）
+            node.log(`[RS485收到] ${hexFormatted} (${frame.length}字节)`);
+            
+            // ===== 杜亚窗帘协议检测 (55开头) =====
+            if (frame[0] === 0x55 && frame.length >= 7) {
+                node.log(`[杜亚帧检测] 检测到55帧头, 长度=${frame.length}, 开始解析...`);
+                const duyaData = parseA6B6Frame(frame);
+                if (duyaData) {
+                    node.log(`[杜亚帧解析] 成功! 地址高=${duyaData.addrHigh}, 地址低=${duyaData.addrLow}, 动作=${duyaData.action}`);
+                    
+                    // 查找匹配的杜亚映射
+                    let foundMapping = false;
+                    node.log(`[杜亚映射查找] 当前映射数: ${node.mappings.length}`);
+                    for (const mapping of node.mappings) {
+                        if (mapping.brand !== 'duya') {
+                            // 检查是否是自定义窗帘（也可能匹配55帧）
+                            if (mapping.brand === 'custom' && mapping.device === 'custom_curtain') {
+                                node.debug(`[杜亚映射] 发现自定义窗帘映射，将在后续自定义码匹配中处理`);
+                            }
+                            continue;
+                        }
+                        
+                        // 检查2字节地址是否匹配
+                        const mapAddrHigh = mapping.addrHigh || 1;
+                        const mapAddrLow = mapping.addrLow || 1;
+                        
+                        node.debug(`[杜亚映射检查] 配置地址=${mapAddrHigh}:${mapAddrLow}, 帧地址=${duyaData.addrHigh}:${duyaData.addrLow}`);
+                        
+                        if (duyaData.addrHigh === mapAddrHigh && duyaData.addrLow === mapAddrLow) {
+                            foundMapping = true;
+                            // 防死循环: 1秒内忽略响应
+                            if (node.lastMeshToRS485Time && Date.now() - node.lastMeshToRS485Time < 1000) {
+                                node.debug(`[防循环] 忽略杜亚响应: ${hexFormatted}`);
+                                return;
+                            }
+                            
+                            node.log(`[杜亚->Mesh] 窗帘响应: ${duyaData.action}, 帧: ${hexFormatted}`);
+                            
+                            // 构建Mesh状态
+                            let meshState = {};
+                            if (duyaData.action === 'open') {
+                                meshState = { action: 'open', curtainAction: 1 };
+                            } else if (duyaData.action === 'close') {
+                                meshState = { action: 'close', curtainAction: 2 };
+                            } else if (duyaData.action === 'stop') {
+                                meshState = { action: 'stop', curtainAction: 3 };
+                            } else if (duyaData.action === 'position') {
+                                meshState = { position: duyaData.position, curtainPosition: duyaData.position };
+                            }
+                            
+                            node.queueCommand({
+                                direction: 'modbus-to-mesh',
+                                mapping: mapping,
+                                state: meshState,
+                                duyaMode: true,
+                                timestamp: Date.now()
+                            });
+                            return;
+                        }
+                    }
+                    
+                    if (!foundMapping) {
+                        node.warn(`[杜亚] 未找到匹配的映射, 帧地址=${duyaData.addrHigh}:${duyaData.addrLow}，请检查RS485桥配置`);
+                    }
+                } else {
+                    node.debug(`[杜亚帧检测] 解析失败，可能funcCode不是0x03`);
+                }
+            }
+            
+            // 检查自定义码匹配（遍历所有映射）
+            node.log(`[自定义码检测] 开始匹配, 当前帧hex=${hexStr}, 映射数=${node.mappings.length}`);
             for (const mapping of node.mappings) {
                 if (mapping.brand === 'custom' && mapping.customCodes) {
                     const codes = mapping.customCodes;
                     let matchedAction = null;
                     
+                    node.debug(`[自定义码检测] 检查映射: device=${mapping.device}, meshMac=${mapping.meshMac}, codes=${JSON.stringify(codes)}`);
+                    
                     // 开关类型：匹配on/off
                     if (mapping.device === 'custom_switch') {
                         if (codes.on && hexStr.includes(codes.on.replace(/\s/g, '').toUpperCase())) {
@@ -829,14 +1803,24 @@ module.exports = function(RED) {
                             matchedAction = { switch: false };
                         }
                     }
-                    // 窗帘类型：匹配open/close/stop
+                    // 窗帘类型：匹配open/close/stop（只设置action，避免重复发码）
                     else if (mapping.device === 'custom_curtain') {
-                        if (codes.open && hexStr.includes(codes.open.replace(/\s/g, '').toUpperCase())) {
-                            matchedAction = { position: 'open', action: 'open' };
-                        } else if (codes.close && hexStr.includes(codes.close.replace(/\s/g, '').toUpperCase())) {
-                            matchedAction = { position: 'close', action: 'close' };
-                        } else if (codes.stop && hexStr.includes(codes.stop.replace(/\s/g, '').toUpperCase())) {
-                            matchedAction = { position: 'stop', action: 'stop' };
+                        const openCode = codes.open ? codes.open.replace(/\s/g, '').toUpperCase() : '';
+                        const closeCode = codes.close ? codes.close.replace(/\s/g, '').toUpperCase() : '';
+                        const stopCode = codes.stop ? codes.stop.replace(/\s/g, '').toUpperCase() : '';
+                        node.debug(`[自定义窗帘匹配] 帧hex=${hexStr}, open=${openCode}, close=${closeCode}, stop=${stopCode}`);
+                        
+                        if (openCode && hexStr.includes(openCode)) {
+                            matchedAction = { action: 'open' };
+                            node.log(`[自定义窗帘匹配] 匹配到打开码!`);
+                        } else if (closeCode && hexStr.includes(closeCode)) {
+                            matchedAction = { action: 'close' };
+                            node.log(`[自定义窗帘匹配] 匹配到关闭码!`);
+                        } else if (stopCode && hexStr.includes(stopCode)) {
+                            matchedAction = { action: 'stop' };
+                            node.log(`[自定义窗帘匹配] 匹配到停止码!`);
+                        } else {
+                            node.debug(`[自定义窗帘匹配] 未匹配到任何码`);
                         }
                     }
                     // 场景类型：匹配trigger
@@ -891,22 +1875,18 @@ module.exports = function(RED) {
             
             const slaveAddr = frame[0];
             const fc = frame[1];
+            const hexFormatted = frame.toString('hex').toUpperCase().match(/.{1,2}/g)?.join(' ') || '';
             
-            // 查找对应的映射
-            const mapping = node.findRS485Mapping(slaveAddr);
-            if (!mapping) {
-                node.debug(`未找到从机${slaveAddr}的映射配置`);
-                return;
-            }
-
-            // 自定义模式不走标准Modbus解析
-            if (mapping.brand === 'custom') return;
-
-            const registers = node.getRegistersForMapping(mapping);
-            if (!registers) {
-                node.debug(`未找到设备${mapping.device}的寄存器定义`);
+            node.log(`[Modbus解析] 从机=${slaveAddr}, 功能码=0x${fc.toString(16)}, 帧=${hexFormatted}`);
+            
+            // 查找所有匹配从机地址的映射
+            const allMappings = node.findAllRS485Mappings(slaveAddr);
+            if (allMappings.length === 0) {
+                node.debug(`[Modbus解析] 未找到从机${slaveAddr}的映射配置`);
                 return;
             }
+            
+            node.log(`[Modbus解析] 找到${allMappings.length}个匹配映射`);
 
             // 防死循环：检查是否刚刚从Mesh发送过来
             if (node.lastMeshToRS485Time && Date.now() - node.lastMeshToRS485Time < 500) {
@@ -914,15 +1894,45 @@ module.exports = function(RED) {
                 return;
             }
 
-            // 根据功能码解析数据
-            let state = {};
+            // 解析寄存器地址和值
+            if (fc !== 0x06 && fc !== 0x10) {
+                // 暂不处理其他功能码
+                return;
+            }
+            
+            const regAddr = frame.readUInt16BE(2);
+            const value = frame.readUInt16BE(4);
+            
+            // 根据寄存器地址确定是哪个rs485Channel
+            // 话语前湾开关寄存器：0x1031=CH1, 0x1032=CH2, 0x1033=CH3, 0x1034=CH4, 0x1035=CH5, 0x1036=CH6
+            let rs485ChannelFromReg = null;
+            if (regAddr >= 0x1031 && regAddr <= 0x1036) {
+                rs485ChannelFromReg = regAddr - 0x1030;  // 0x1031->1, 0x1032->2, ...
+            }
+            
+            node.log(`[Modbus解析] 寄存器=0x${regAddr.toString(16).toUpperCase()}, 值=${value}, rs485Channel=${rs485ChannelFromReg}`);
             
-            if (fc === 0x06 || fc === 0x10) {
-                // 写单寄存器响应/写多寄存器响应 - 这是设备主动上报或写响应
-                const regAddr = frame.readUInt16BE(2);
-                const value = frame.readUInt16BE(4);
+            // 遍历所有匹配的映射，只处理rs485Channel匹配的
+            for (const mapping of allMappings) {
+                // 自定义模式不走标准Modbus解析
+                if (mapping.brand === 'custom') continue;
+                
+                const mappingRs485Channel = mapping.rs485Channel || 1;
+                
+                // 如果是开关寄存器，检查rs485Channel是否匹配
+                if (rs485ChannelFromReg !== null && rs485ChannelFromReg !== mappingRs485Channel) {
+                    node.debug(`[Modbus解析] 跳过映射: rs485Channel不匹配 (帧=${rs485ChannelFromReg}, 映射=${mappingRs485Channel})`);
+                    continue;
+                }
+                
+                const registers = node.getRegistersForMapping(mapping);
+                if (!registers) {
+                    node.debug(`未找到设备${mapping.device}的寄存器定义`);
+                    continue;
+                }
                 
                 // 查找匹配的寄存器定义
+                let state = {};
                 for (const [key, reg] of Object.entries(registers)) {
                     if (reg.address === regAddr) {
                         if (key.startsWith('switch') || key.startsWith('led')) {
@@ -936,51 +1946,35 @@ module.exports = function(RED) {
                         break;
                     }
                 }
-            } else if (fc === 0x03 || fc === 0x04) {
-                const byteCount = frame[2];
-                for (let i = 0; i < byteCount / 2; i++) {
-                    const value = frame.readUInt16BE(3 + i * 2);
-                    for (const [key, reg] of Object.entries(registers)) {
-                        if (reg.map) {
-                            state[key] = reg.map[value] || value;
-                        } else {
-                            state[key] = value;
-                        }
-                    }
-                }
-            } else if (fc === 0x20) {
-                if (frame.length >= 9) {
-                    const startReg = frame.readUInt16BE(2);
-                    const count = frame.readUInt16BE(4);
-                    node.debug(`[RS485] 从机${slaveAddr} 自定义上报: 起始0x${startReg.toString(16)}, 数量${count}`);
-                }
-            }
-
-            if (Object.keys(state).length > 0) {
-                node.log(`[RS485->Mesh] 设备@${slaveAddr} 状态变化: ${JSON.stringify(state)}`);
                 
-                // 输出调试信息到节点输出端口
-                node.send({
-                    topic: 'rs485-state-change',
-                    payload: {
-                        direction: 'RS485→Mesh',
-                        slaveAddr: slaveAddr,
-                        funcCode: fc,
-                        brand: mapping.brand,
-                        device: mapping.device,
-                        meshMac: mapping.meshMac,
-                        state: state
-                    },
-                    timestamp: new Date().toISOString()
-                });
-                
-                node.queueCommand({
-                    direction: 'modbus-to-mesh',
-                    mapping: mapping,
-                    registers: registers,
-                    state: state,
-                    timestamp: Date.now()
-                });
+                if (Object.keys(state).length > 0) {
+                    node.log(`[RS485->Mesh] 映射匹配: meshMac=${mapping.meshMac}, meshCH=${mapping.meshChannel}, rs485CH=${mappingRs485Channel}, 状态=${JSON.stringify(state)}`);
+                    
+                    // 输出调试信息到节点输出端口
+                    node.send({
+                        topic: 'rs485-state-change',
+                        payload: {
+                            direction: 'RS485→Mesh',
+                            slaveAddr: slaveAddr,
+                            funcCode: fc,
+                            brand: mapping.brand,
+                            device: mapping.device,
+                            meshMac: mapping.meshMac,
+                            meshChannel: mapping.meshChannel,
+                            rs485Channel: mappingRs485Channel,
+                            state: state
+                        },
+                        timestamp: new Date().toISOString()
+                    });
+                    
+                    node.queueCommand({
+                        direction: 'modbus-to-mesh',
+                        mapping: mapping,
+                        registers: registers,
+                        state: state,
+                        timestamp: Date.now()
+                    });
+                }
             }
         };
 
@@ -998,6 +1992,7 @@ module.exports = function(RED) {
         // 事件监听 - Mesh网关共享，无冲突
         node.gateway.on('device-list-complete', init);
         node.gateway.on('device-state-changed', handleMeshStateChange);
+        node.gateway.on('curtain-control', handleCurtainControl);  // 窗帘控制立即同步
 
         if (node.gateway.deviceListComplete) {
             init();
@@ -1081,8 +2076,11 @@ module.exports = function(RED) {
         // 清理
         node.on('close', (done) => {
             // 移除Mesh网关事件监听器
-            node.gateway.removeListener('device-list-complete', init);
-            node.gateway.removeListener('device-state-changed', handleMeshStateChange);
+            if (node.gateway) {
+                node.gateway.removeListener('device-list-complete', init);
+                node.gateway.removeListener('device-state-changed', handleMeshStateChange);
+                node.gateway.removeListener('curtain-control', handleCurtainControl);
+            }
             
             // 移除RS485配置节点事件监听器
             if (node.rs485Config && node._rs485Handlers) {
@@ -1093,6 +2091,15 @@ module.exports = function(RED) {
                 node.rs485Config.deregister(node);
             }
             
+            // 清理缓存和队列，防止内存泄漏
+            node.stateCache = {};
+            node.commandQueue = [];
+            node.curtainDebounce = {};
+            node.curtainCache = {};
+            node.lastSentTime = {};
+            node.processing = false;
+            node.syncLock = false;
+            
             node.log('[RS485 Bridge] 节点已清理');
             done();
         });
@@ -1129,12 +2136,20 @@ module.exports = function(RED) {
                     displayName = (d.name || '设备') + '_' + macClean;
                 }
                 
+                // 三合一面板特殊处理
+                const isThreeInOne = d.isThreeInOne || false;
+                if (isThreeInOne) {
+                    displayName = '三合一面板_' + macClean;
+                }
+                
                 return {
                     mac: d.macAddress,
                     name: displayName,
                     originalName: d.name,
                     type: d.deviceType,
-                    channels: channels
+                    channels: channels,
+                    isThreeInOne: isThreeInOne,
+                    entityType: d.getEntityType ? d.getEntityType() : 'unknown'
                 };
             });
             res.json(devices);
@@ -1163,4 +2178,5 @@ module.exports = function(RED) {
             res.json([]);
         }
     });
+
 };