node-red-contrib-symi-mesh 1.6.5 → 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' } }
@@ -374,6 +418,8 @@ module.exports = function(RED) {
             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}`);
                 }
@@ -452,11 +498,17 @@ module.exports = function(RED) {
             );
         };
 
-        // Find mapping for RS485 device
+        // Find mapping for RS485 device (返回第一个匹配，用于向后兼容)
         node.findRS485Mapping = function(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);
+        };
 
         // 获取映射的寄存器配置
         node.getRegistersForMapping = function(mapping) {
@@ -488,6 +540,7 @@ module.exports = function(RED) {
             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) {
@@ -498,11 +551,25 @@ module.exports = function(RED) {
             
             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, '');
+            
             // 遍历映射，只处理有对应变化的映射
             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)}`);
                 
                 const configChannel = mapping.meshChannel || 1;
                 const switchKey = `switch_${configChannel}`;
@@ -513,9 +580,221 @@ module.exports = function(RED) {
                 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;
+                }
+                
+                // 【自定义窗帘】处理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;
-                const hasCurtainChange = isCurtain && (
+                // 窗帘：如果是杜亚窗帘，跳过状态变化处理（已在curtain-control中处理）
+                const hasCurtainChange = isCurtain && !isCurtainControlled && (
                     changed.curtainAction !== undefined || 
                     changed.curtainPosition !== undefined || 
                     changed.curtainStatus !== undefined
@@ -523,10 +802,26 @@ module.exports = function(RED) {
                 const hasACChange = isAC && (
                     changed.targetTemp !== undefined || 
                     changed.acMode !== undefined || 
-                    changed.acFanSpeed !== 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) {
+                if (!hasSwitchChange && !hasCurtainChange && !hasACChange && !hasFreshAirChange && !hasFloorHeatingChange) {
                     continue;
                 }
                 
@@ -558,66 +853,119 @@ module.exports = function(RED) {
         };
 
         // 窗帘控制命令处理（立即同步，不等状态反馈）
+        // 同时支持杜亚窗帘和自定义窗帘
         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 || mapping.brand !== 'duya') continue;
+                if (mappingMacNormalized !== macNormalized) continue;
                 
-                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 = '暂停';
+                // ===== 杜亚窗帘 =====
+                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}%`;
+                    // 处理位置命令 (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}`);
+                        });
                     }
                 }
-                
-                if (frame) {
-                    // 立即发送，记录时间防止状态反馈重复发码
-                    node.lastCurtainControlTime = Date.now();  // 专门用于curtain-control事件
-                    node.lastMeshToRS485Time = Date.now();
-                    if (!node.lastSentTime) node.lastSentTime = {};
-                    node.lastSentTime[`duya_${mac}_${actionName}`] = Date.now();
+                // ===== 自定义窗帘 =====
+                else if (mapping.brand === 'custom' && mapping.device === 'custom_curtain' && mapping.customCodes) {
+                    const codes = mapping.customCodes;
                     
-                    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}`);
-                    });
+                    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}`);
+                        });
+                    }
                 }
             }
         };
@@ -642,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;
             }
             
@@ -740,24 +1102,32 @@ module.exports = function(RED) {
                 let frame = null;
                 let actionName = '';
                 
-                const isRunning = currentStatus === 1 || currentStatus === 2;
+                // 【兼容两种协议】：
+                // 米家协议: 0=打开中, 1=关闭中, 2=停止
+                // 小程序协议: 1=打开, 2=关闭, 3=停止
+                // 使用curtainAction来判断动作（由device-manager解析）
+                const curtainAction = state.curtainAction;
                 
-                // 1. 暂停(status=3) → 立即发送暂停码
-                if (currentStatus === 3) {
+                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 = '暂停';
                 }
-                // 2. 运行状态(1/2)：根据当前位置判断方向
-                // 位置>=50（接近全开）→ 即将关闭 → 发关闭码
-                // 位置<50（接近全关）→ 即将打开 → 发打开码
-                else if (isRunning) {
-                    if (posForDirection >= 50) {
-                        frame = buildA6B6Frame(addrHigh, addrLow, 'close');
-                        actionName = '关闭';
-                    } else {
-                        frame = buildA6B6Frame(addrHigh, addrLow, 'open');
-                        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 && 
@@ -932,8 +1302,8 @@ module.exports = function(RED) {
                             node.log(`[Mesh->RS485] 从机${mapping.address} 按键${rs485Channel}: ${value ? '开' : '关'}`);
                         }
                     }
-                    // 空调开关
-                    else if (meshKey === 'acSwitch' && registers && registers.switch) {
+                    // 空调开关 (支持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);
@@ -944,46 +1314,100 @@ module.exports = function(RED) {
                         await node.writeModbusRegister(mapping.address, registers.targetTemp, value);
                         node.log(`[Mesh->RS485] 目标温度: ${value}°C`);
                     }
-                    // 空调模式 - Mesh值需要转换为RS485值
-                    // Mesh: 0=制冷, 1=制热, 2=送风, 3=除湿
-                    // A5B5: 1=制热, 2=制冷, 4=送风, 8=除湿
-                    else if (meshKey === 'acMode' && registers && registers.mode) {
-                        // 反向映射：从Mesh模式名找到RS485寄存器值
-                        let rs485Value = value;
-                        if (registers.mode.map) {
-                            const modeNames = { 0: 'cool', 1: 'heat', 2: 'fan', 3: 'dry' };
-                            const meshModeName = modeNames[value] || value;
-                            const found = Object.entries(registers.mode.map).find(([k, v]) => v === meshModeName);
-                            if (found) {
-                                rs485Value = parseInt(found[0]);
+                    // 空调模式 (支持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]);
+                                }
                             }
                         }
-                        await node.writeModbusRegister(mapping.address, registers.mode, rs485Value);
-                        node.log(`[Mesh->RS485] 空调模式: ${value} -> RS485值${rs485Value}`);
-                    }
-                    // 风速 - Mesh值需要转换为RS485值
-                    // Mesh: 0=自动, 1=低, 2=中, 3=高
-                    // A5B5: 1=低风, 2=中风, 3=高风
-                    else if (meshKey === 'acFanSpeed' && registers && registers.fanSpeed) {
-                        let rs485Value = value;
-                        if (registers.fanSpeed.map) {
-                            const speedNames = { 0: 'auto', 1: 'low', 2: 'medium', 3: '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.mode, rs485Value);
+                            node.log(`[Mesh->RS485] 空调模式: Mesh值${value} -> RS485值${rs485Value}`);
+                        }
+                    }
+                    // 风速 (支持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]);
+                                }
                             }
-                        } else {
-                            // 默认直接使用Mesh值
-                            rs485Value = value;
                         }
-                        await node.writeModbusRegister(mapping.address, registers.fanSpeed, rs485Value);
-                        node.log(`[Mesh->RS485] 空调风速: ${value} -> RS485值${rs485Value}`);
+                        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}`);
                 }
@@ -1008,12 +1432,33 @@ 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) {
-                node.warn(`未找到Mesh设备: ${mapping.meshMac}`);
+                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(`[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;
             
@@ -1095,50 +1540,51 @@ module.exports = function(RED) {
                     else if (key.startsWith('led')) {
                         node.debug(`[RS485] 指示灯${key}: ${value}`);
                     }
-                    // 空调开关 - 0x1B是空调开关属性
+                    // 空调开关 - 0x02是开关属性 (0x01=关, 0x02=开)
                     else if (key === 'acSwitch' || (key === 'switch' && mapping.device && mapping.device.includes('ac'))) {
-                        const param = Buffer.from([value ? 1 : 0]);
-                        await node.gateway.sendControl(meshDevice.networkAddress, 0x1B, param);
+                        const param = Buffer.from([value ? 0x02 : 0x01]);
+                        await node.gateway.sendControl(meshDevice.networkAddress, 0x02, param);
                         node.log(`[RS485->Mesh] 空调开关: ${value ? '开' : '关'}`);
                     }
-                    // 目标温度 - 0x1C是目标温度属性
+                    // 目标温度 - 0x1B是目标温度属性
                     else if (key === 'targetTemp') {
                         const param = Buffer.from([Math.round(value)]);
-                        await node.gateway.sendControl(meshDevice.networkAddress, 0x1C, param);
+                        await node.gateway.sendControl(meshDevice.networkAddress, 0x1B, param);
                         node.log(`[RS485->Mesh] 目标温度: ${value}°C`);
                     }
-                    // 空调模式 - 0x16是模式属性
-                    // RS485: 1=制热, 2=制冷, 4=送风, 8=除湿
-                    // Mesh: 0=制冷, 1=制热, 2=送风, 3=除湿
+                    // 空调模式 - 0x1D是模式属性
+                    // RS485(话语前湾): 1=制热, 2=制冷, 4=送风, 8=除湿
+                    // Mesh协议: 1=制冷, 2=制热, 3=送风, 4=除湿
                     else if (key === 'mode') {
                         // 从RS485值或字符串转换为Mesh值
-                        let meshMode = 0;
+                        let meshMode = 1;  // 默认制冷
                         if (typeof value === 'string') {
-                            const modeMap = { 'cool': 0, 'heat': 1, 'fan': 2, 'dry': 3 };
-                            meshMode = modeMap[value] !== undefined ? modeMap[value] : 0;
+                            const modeMap = { 'cool': 1, 'heat': 2, 'fan': 3, 'dry': 4 };
+                            meshMode = modeMap[value] !== undefined ? modeMap[value] : 1;
                         } else {
-                            // RS485数值转Mesh值
-                            const rs485ToMesh = { 1: 1, 2: 0, 4: 2, 8: 3 };  // 1=heat->1, 2=cool->0, 4=fan->2, 8=dry->3
-                            meshMode = rs485ToMesh[value] !== undefined ? rs485ToMesh[value] : 0;
+                            // 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, 0x16, param);
+                        await node.gateway.sendControl(meshDevice.networkAddress, 0x1D, param);
                         node.log(`[RS485->Mesh] 空调模式: RS485值${value} -> Mesh值${meshMode}`);
                     }
-                    // 风速 - 0x1D是风速属性
-                    // RS485: 1=低风, 2=中风, 3=高风
-                    // Mesh: 0=自动, 1=低, 2=中, 3=高
+                    // 风速 - 0x1C是风速属性
+                    // RS485(话语前湾): 1=低风, 2=中风, 3=高风
+                    // Mesh协议: 1=高, 2=中, 3=低, 4=自动
                     else if (key === 'fanSpeed') {
-                        let meshSpeed = 0;
+                        let meshSpeed = 3;  // 默认低
                         if (typeof value === 'string') {
-                            const speedMap = { 'low': 1, 'medium': 2, 'high': 3, 'auto': 0 };
-                            meshSpeed = speedMap[value] !== undefined ? speedMap[value] : 0;
+                            const speedMap = { 'low': 3, 'medium': 2, 'high': 1, 'auto': 4 };
+                            meshSpeed = speedMap[value] !== undefined ? speedMap[value] : 3;
                         } else {
-                            // RS485数值直接对应Mesh值(1=低, 2=中, 3=高)
-                            meshSpeed = value;
+                            // 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, 0x1D, param);
+                        await node.gateway.sendControl(meshDevice.networkAddress, 0x1C, param);
                         node.log(`[RS485->Mesh] 空调风速: RS485值${value} -> Mesh值${meshSpeed}`);
                     }
                     else if (key === 'brightness') {
@@ -1146,6 +1592,37 @@ module.exports = function(RED) {
                         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}`);
                 }
@@ -1241,19 +1718,35 @@ 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') continue;
+                        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}`);
@@ -1284,15 +1777,24 @@ module.exports = function(RED) {
                             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())) {
@@ -1301,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
@@ -1363,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) {
@@ -1386,15 +1894,45 @@ module.exports = function(RED) {
                 return;
             }
 
-            // 根据功能码解析数据
-            let state = {};
+            // 解析寄存器地址和值
+            if (fc !== 0x06 && fc !== 0x10) {
+                // 暂不处理其他功能码
+                return;
+            }
             
-            if (fc === 0x06 || fc === 0x10) {
-                // 写单寄存器响应/写多寄存器响应 - 这是设备主动上报或写响应
-                const regAddr = frame.readUInt16BE(2);
-                const value = frame.readUInt16BE(4);
+            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}`);
+            
+            // 遍历所有匹配的映射，只处理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')) {
@@ -1408,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()
+                    });
+                }
             }
         };
 
@@ -1554,9 +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);
-            node.gateway.removeListener('curtain-control', handleCurtainControl);
+            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) {
@@ -1567,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();
         });
@@ -1603,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);