node-red-contrib-symi-mesh 1.7.1 → 1.7.3

package/nodes/symi-485-bridge.js

@@ -322,10 +322,521 @@ module.exports = function(RED) {
                         // 用户需要在映射中配置: customCodes.trigger
                     }
                 }
+            },
+            // ===== SYMI空调面板协议 =====
+            // 帧格式: 7E [本机地址] [数据类型] [数据长度] [设备类型] [品牌ID] [设备地址] [设备通道] [房间信息3字节] [操作码] [操作信息] [CRC8] 7D
+            // 数据类型: 0x01=应答, 0x02=查询, 0x03=设置, 0x04=上报
+            // 操作码: 0x01=电源, 0x02=模式, 0x03=风速, 0x04=温度
+            'symi': {
+                name: 'SYMI空调面板',
+                protocol: 'symi',
+                devices: {
+                    'climate': {
+                        name: '空调',
+                        type: 'climate',
+                        protocol: 'symi'
+                    }
+                }
+            },
+            // ===== 中弘VRF空调协议 =====
+            // 帧格式: [从机地址] [功能码] [控制值] [空调数量] [外机地址] [内机地址] [校验和]
+            // 功能码: 0x31=开关, 0x32=温度, 0x33=模式, 0x34=风速, 0x50=查询
+            // 模式: 0x01=制冷, 0x02=除湿, 0x04=送风, 0x08=制热
+            // 风速: 0x01=高, 0x02=中, 0x04=低
+            'zhonghong': {
+                name: '中弘VRF',
+                protocol: 'zhonghong',
+                devices: {
+                    'climate': {
+                        name: '空调',
+                        type: 'climate',
+                        protocol: 'zhonghong'
+                    }
+                }
             }
         }
     };
 
+    // ===== SYMI协议常量定义 =====
+    const SYMI_HEADER = 0x7E;
+    const SYMI_FOOTER = 0x7D;
+    const SYMI_DEVICE_TYPE_CLIMATE = 0x02;
+
+    // SYMI数据类型
+    const SYMI_DATA_TYPE = {
+        RESPONSE: 0x01,    // 应答
+        QUERY: 0x02,       // 查询
+        CONTROL: 0x03,     // 设置/控制
+        REPORT: 0x04       // 上报
+    };
+
+    // SYMI操作码
+    const SYMI_OP_CODE = {
+        POWER: 0x01,       // 电源控制
+        MODE: 0x02,        // 模式控制
+        FAN_SPEED: 0x03,   // 风速控制
+        TEMPERATURE: 0x04  // 温度控制
+    };
+
+    // SYMI模式值
+    const SYMI_MODE = {
+        AUTO: 0x00,
+        COOL: 0x01,
+        DEHUMIDIFY: 0x02,
+        FAN: 0x03,
+        HEAT: 0x04
+    };
+
+    // SYMI风速值
+    const SYMI_FAN_SPEED = {
+        AUTO: 0x00,
+        LOW: 0x01,
+        MEDIUM: 0x02,
+        HIGH: 0x03
+    };
+
+    // ===== 中弘协议常量定义 =====
+    const ZHONGHONG_FUNC = {
+        CTRL_SWITCH: 0x31,
+        CTRL_TEMPERATURE: 0x32,
+        CTRL_MODE: 0x33,
+        CTRL_FAN_MODE: 0x34,
+        QUERY: 0x50
+    };
+
+    const ZHONGHONG_MODE = {
+        COOL: 0x01,
+        DRY: 0x02,
+        FAN: 0x04,
+        HEAT: 0x08
+    };
+
+    const ZHONGHONG_FAN_SPEED = {
+        HIGH: 0x01,
+        MEDIUM: 0x02,
+        LOW: 0x04
+    };
+
+    // ===== 模式转换映射 =====
+    // SYMI模式 -> 中弘模式
+    const SYMI_TO_ZH_MODE = {
+        0x00: 0x01,  // auto -> cool
+        0x01: 0x01,  // cool -> cool
+        0x02: 0x02,  // dehumidify -> dry
+        0x03: 0x04,  // fan -> fan
+        0x04: 0x08   // heat -> heat
+    };
+
+    // 中弘模式 -> SYMI模式
+    const ZH_TO_SYMI_MODE = {
+        0x01: 0x01,  // cool -> cool
+        0x02: 0x02,  // dry -> dehumidify
+        0x04: 0x03,  // fan -> fan
+        0x08: 0x04   // heat -> heat
+    };
+
+    // SYMI风速 -> 中弘风速
+    const SYMI_TO_ZH_FAN = {
+        0x00: 0x04,  // auto -> low
+        0x01: 0x04,  // low -> low
+        0x02: 0x02,  // medium -> medium
+        0x03: 0x01   // high -> high
+    };
+
+    // 中弘风速 -> SYMI风速
+    const ZH_TO_SYMI_FAN = {
+        0x01: 0x03,  // high -> high
+        0x02: 0x02,  // medium -> medium
+        0x04: 0x01   // low -> low
+    };
+
+    // ===== SYMI协议核心函数 =====
+    
+    /**
+     * 计算SYMI CRC8 (XOR校验)
+     * @param {Buffer} data - 从帧头到操作信息的数据
+     * @returns {number} - CRC8值
+     */
+    function calcSymiCrc8(data) {
+        let crc = 0;
+        for (let i = 0; i < data.length; i++) {
+            crc ^= data[i];
+        }
+        return crc & 0xFF;
+    }
+
+    /**
+     * 解析SYMI帧
+     * @param {Buffer} frame - 原始帧数据
+     * @returns {Object|null} - 解析结果或null
+     */
+    function parseSymiFrame(frame) {
+        // 验证帧头帧尾
+        if (frame[0] !== SYMI_HEADER || frame[frame.length - 1] !== SYMI_FOOTER) {
+            return null;
+        }
+        
+        // 验证最小长度: 7E + localAddr + dataType + dataLen + ... + CRC + 7D
+        if (frame.length < 8) {
+            return null;
+        }
+        
+        const localAddr = frame[1];
+        const dataType = frame[2];
+        const dataLen = frame[3];
+        
+        // 验证长度: header(1) + localAddr(1) + dataType(1) + dataLen(1) + data(dataLen) + crc(1) + footer(1)
+        const expectedLen = 4 + dataLen + 2;
+        if (frame.length !== expectedLen) {
+            return null;
+        }
+        
+        // 验证CRC (从帧头到操作信息，不含CRC和帧尾)
+        const crcIndex = frame.length - 2;
+        const calculatedCrc = calcSymiCrc8(frame.slice(0, crcIndex));
+        if (frame[crcIndex] !== calculatedCrc) {
+            return null;
+        }
+        
+        // 解析数据部分
+        // 格式: deviceType(1) + brandId(1) + deviceAddr(1) + deviceChannel(1) + roomInfo(3) + opCode(1) + opData(n)
+        const data = frame.slice(4, 4 + dataLen);
+        
+        // 最小数据长度: deviceType + brandId + deviceAddr + deviceChannel + roomInfo(3) + opCode = 8
+        if (data.length < 8) {
+            return null;
+        }
+        
+        return {
+            localAddr,
+            dataType,
+            deviceType: data[0],
+            brandId: data[1],
+            deviceAddr: data[2],
+            deviceChannel: data[3],
+            roomInfo: data.slice(4, 7),
+            opCode: data[7],
+            opData: data.slice(8)
+        };
+    }
+
+    /**
+     * 构建SYMI帧
+     * @param {Object} params - 帧参数
+     * @returns {Buffer} - 完整帧
+     */
+    function buildSymiFrame(params) {
+        const {
+            localAddr,
+            dataType,
+            deviceType = SYMI_DEVICE_TYPE_CLIMATE,
+            brandId = 0x00,
+            deviceAddr,
+            deviceChannel,
+            roomInfo = Buffer.from([0x00, 0x00, 0x00]),
+            opCode,
+            opData
+        } = params;
+        
+        // 构建数据部分
+        const roomInfoBuf = Buffer.isBuffer(roomInfo) ? roomInfo : Buffer.from(roomInfo);
+        const opDataBuf = Buffer.isBuffer(opData) ? opData : Buffer.from(Array.isArray(opData) ? opData : [opData]);
+        
+        const data = Buffer.concat([
+            Buffer.from([deviceType, brandId, deviceAddr, deviceChannel]),
+            roomInfoBuf,
+            Buffer.from([opCode]),
+            opDataBuf
+        ]);
+        
+        // 构建帧（不含CRC和尾部）
+        const frameWithoutCrc = Buffer.concat([
+            Buffer.from([SYMI_HEADER, localAddr, dataType, data.length]),
+            data
+        ]);
+        
+        // 计算CRC
+        const crc = calcSymiCrc8(frameWithoutCrc);
+        
+        // 完整帧
+        return Buffer.concat([frameWithoutCrc, Buffer.from([crc, SYMI_FOOTER])]);
+    }
+
+    /**
+     * 构建SYMI状态上报帧 (用于Zhonghong->SYMI同步)
+     * @param {Object} params - 状态参数
+     * @returns {Buffer} - 完整帧
+     */
+    function buildSymiStatusFrame(params) {
+        const {
+            localAddr,
+            deviceAddr,
+            deviceChannel,
+            brandId = 0x00,
+            power,      // boolean
+            mode,       // SYMI mode value
+            fanSpeed,   // SYMI fan speed value
+            targetTemp, // 16-30
+            currentTemp // room temperature
+        } = params;
+        
+        // 状态上报数据: [switch, mode, fan, targetTemp, roomTemp]
+        const opData = Buffer.from([
+            power ? 0x01 : 0x00,
+            mode,
+            fanSpeed,
+            targetTemp,
+            currentTemp || targetTemp
+        ]);
+        
+        return buildSymiFrame({
+            localAddr,
+            dataType: SYMI_DATA_TYPE.REPORT,
+            deviceType: SYMI_DEVICE_TYPE_CLIMATE,
+            brandId,
+            deviceAddr,
+            deviceChannel,
+            opCode: 0x00, // 状态上报使用0x00
+            opData
+        });
+    }
+
+    // ===== 中弘协议核心函数 =====
+    
+    /**
+     * 计算中弘校验和 (求和取低8位)
+     * @param {Buffer|Array} data - 不含校验和的帧数据
+     * @returns {number} - 校验和
+     */
+    function calcZhonghongChecksum(data) {
+        let sum = 0;
+        for (let i = 0; i < data.length; i++) {
+            sum += data[i];
+        }
+        return sum & 0xFF;
+    }
+
+    /**
+     * 构建中弘控制帧
+     * @param {Object} cmd - 命令参数
+     * @returns {Buffer} - 完整帧
+     */
+    function buildZhonghongControlFrame(cmd) {
+        const frame = Buffer.from([
+            cmd.slaveAddr,
+            cmd.funcCode,
+            cmd.value,
+            0x01,  // 空调数量
+            cmd.outdoorAddr,
+            cmd.indoorAddr
+        ]);
+        
+        const checksum = calcZhonghongChecksum(frame);
+        return Buffer.concat([frame, Buffer.from([checksum])]);
+    }
+
+    /**
+     * 构建中弘查询帧
+     * @param {number} slaveAddr - 从机地址
+     * @param {number} outdoorAddr - 外机地址
+     * @param {number} indoorAddr - 内机地址
+     * @returns {Buffer} - 完整帧
+     */
+    function buildZhonghongQueryFrame(slaveAddr, outdoorAddr, indoorAddr) {
+        const frame = Buffer.from([
+            slaveAddr,
+            ZHONGHONG_FUNC.QUERY,  // 0x50 查询功能码
+            0x01,  // 单机查询
+            0x01,  // 空调数量
+            outdoorAddr,
+            indoorAddr
+        ]);
+        
+        const checksum = calcZhonghongChecksum(frame);
+        return Buffer.concat([frame, Buffer.from([checksum])]);
+    }
+
+    /**
+     * 解析中弘状态响应
+     * @param {Buffer} frame - 原始帧数据
+     * @param {number} expectedSlaveAddr - 期望的从机地址
+     * @returns {Object|null} - 解析结果或null
+     */
+    function parseZhonghongResponse(frame, expectedSlaveAddr) {
+        // 最小长度: slaveAddr + func + funcValue + num + (outdoor + indoor + status*8) + checksum
+        if (frame.length < 15) {
+            return null;
+        }
+        
+        const slaveAddr = frame[0];
+        const func = frame[1];
+        
+        // 验证从机地址
+        if (expectedSlaveAddr !== undefined && slaveAddr !== expectedSlaveAddr) {
+            return null;
+        }
+        
+        // 只处理查询响应
+        if (func !== ZHONGHONG_FUNC.QUERY) {
+            return null;
+        }
+        
+        const funcValue = frame[2];
+        const num = frame[3];
+        
+        // 状态查询响应 (funcValue=0x01)
+        if (funcValue !== 0x01) {
+            return null;
+        }
+        
+        // 计算期望长度: 4 + num * 10 + 1
+        const expectedLen = 4 + num * 10 + 1;
+        if (frame.length < expectedLen) {
+            return null;
+        }
+        
+        // 验证校验和
+        const checksum = calcZhonghongChecksum(frame.slice(0, expectedLen - 1));
+        if (frame[expectedLen - 1] !== checksum) {
+            return null;
+        }
+        
+        // 解析空调状态
+        const climates = [];
+        for (let i = 0; i < num; i++) {
+            const offset = 4 + i * 10;
+            climates.push({
+                outdoorAddr: frame[offset],
+                indoorAddr: frame[offset + 1],
+                onOff: frame[offset + 2] === 0x01,
+                targetTemp: frame[offset + 3],
+                mode: frame[offset + 4],
+                fanMode: frame[offset + 5],
+                currentTemp: frame[offset + 6]
+            });
+        }
+        
+        return {
+            slaveAddr,
+            funcValue,
+            num,
+            climates
+        };
+    }
+
+    // ===== 协议转换函数 =====
+    
+    /**
+     * 转换SYMI命令到中弘命令
+     * @param {Object} symiCmd - SYMI解析结果
+     * @param {Object} mapping - 映射配置
+     * @returns {Object|null} - 中弘命令或null
+     */
+    function convertSymiToZhonghong(symiCmd, mapping) {
+        const zhCmd = {
+            slaveAddr: mapping.zhSlaveAddr || 0x01,
+            outdoorAddr: mapping.zhOutdoorAddr || 0x01,
+            indoorAddr: mapping.zhIndoorAddr || 0x01
+        };
+        
+        switch (symiCmd.opCode) {
+            case SYMI_OP_CODE.POWER:
+                zhCmd.funcCode = ZHONGHONG_FUNC.CTRL_SWITCH;
+                zhCmd.value = symiCmd.opData[0] === 0x01 ? 0x01 : 0x00;
+                break;
+            case SYMI_OP_CODE.MODE:
+                zhCmd.funcCode = ZHONGHONG_FUNC.CTRL_MODE;
+                zhCmd.value = SYMI_TO_ZH_MODE[symiCmd.opData[0]] || ZHONGHONG_MODE.COOL;
+                break;
+            case SYMI_OP_CODE.FAN_SPEED:
+                zhCmd.funcCode = ZHONGHONG_FUNC.CTRL_FAN_MODE;
+                zhCmd.value = SYMI_TO_ZH_FAN[symiCmd.opData[0]] || ZHONGHONG_FAN_SPEED.LOW;
+                break;
+            case SYMI_OP_CODE.TEMPERATURE:
+                zhCmd.funcCode = ZHONGHONG_FUNC.CTRL_TEMPERATURE;
+                zhCmd.value = clampTemperature(symiCmd.opData[0]);
+                break;
+            default:
+                return null;
+        }
+        
+        return zhCmd;
+    }
+
+    /**
+     * 转换中弘状态到SYMI状态
+     * @param {Object} zhStatus - 中弘状态
+     * @param {Object} mapping - 映射配置
+     * @returns {Object} - SYMI状态帧参数
+     */
+    function convertZhonghongToSymi(zhStatus, mapping) {
+        return {
+            localAddr: mapping.symiLocalAddr || 0x01,
+            deviceAddr: mapping.symiDeviceAddr || 0x01,
+            deviceChannel: mapping.symiDeviceChannel || 0x00,
+            brandId: mapping.symiBrandId || 0x00,
+            power: zhStatus.onOff,
+            mode: ZH_TO_SYMI_MODE[zhStatus.mode] || SYMI_MODE.COOL,
+            fanSpeed: ZH_TO_SYMI_FAN[zhStatus.fanMode] || SYMI_FAN_SPEED.LOW,
+            targetTemp: zhStatus.targetTemp,
+            currentTemp: zhStatus.currentTemp
+        };
+    }
+
+    /**
+     * 温度范围限制 (16-30°C)
+     * @param {number} temp - 输入温度
+     * @returns {number} - 限制后的温度
+     */
+    function clampTemperature(temp) {
+        return Math.max(16, Math.min(30, temp));
+    }
+
+    // ===== RS485-to-RS485桥接状态缓存 =====
+    const climateStateCache = {};
+    const SYNC_COOLDOWN_MS = 1000;
+    const lastSyncTime = {};
+
+    /**
+     * 检查是否应该同步（防循环）
+     * @param {string} sourceKey - 源标识
+     * @returns {boolean} - 是否应该同步
+     */
+    function shouldSync(sourceKey) {
+        const now = Date.now();
+        if (lastSyncTime[sourceKey] && now - lastSyncTime[sourceKey] < SYNC_COOLDOWN_MS) {
+            return false;
+        }
+        lastSyncTime[sourceKey] = now;
+        return true;
+    }
+
+    /**
+     * 检查状态是否变化（去重）
+     * @param {string} cacheKey - 缓存键
+     * @param {Object} newState - 新状态
+     * @returns {boolean} - 是否有变化
+     */
+    function hasStateChanged(cacheKey, newState) {
+        const cached = climateStateCache[cacheKey];
+        if (!cached) {
+            climateStateCache[cacheKey] = { ...newState, lastUpdate: Date.now() };
+            return true;
+        }
+        
+        const changed = 
+            cached.power !== newState.power ||
+            cached.mode !== newState.mode ||
+            cached.fanSpeed !== newState.fanSpeed ||
+            cached.targetTemp !== newState.targetTemp;
+        
+        if (changed) {
+            climateStateCache[cacheKey] = { ...newState, lastUpdate: Date.now() };
+        }
+        
+        return changed;
+    }
+
     // ===== 杜亚协议CRC16计算 =====
     // 杜亚使用CRC16-MODBUS算法，低字节在前
     function calcA6B6CRC(buffer) {
@@ -528,11 +1039,11 @@ module.exports = function(RED) {
         node.climateCache = {};
         // 首次启动标记 - 跳过初始状态同步
         node.initializing = true;
-        // 启动后延迟20秒再开始同步（Mesh网关需要15秒以上完成设备发现）
+        // 启动后延迟5秒再开始同步（等待Mesh网关完成设备发现）
         setTimeout(() => {
             node.initializing = false;
             node.log('[RS485 Bridge] 初始化完成，开始同步');
-        }, 10000);  // 10秒初始化延迟
+        }, 5000);  // 5秒初始化延迟
 
         // Mesh设备状态变化处理(事件驱动)
         const handleMeshStateChange = (eventData) => {
@@ -540,7 +1051,7 @@ module.exports = function(RED) {
             if (node.initializing) return;
             
             const mac = eventData.device.macAddress;
-            const state = eventData.state || {};
+            let state = eventData.state || {};
             
             // 状态缓存比较，只处理真正变化的状态
             if (!node.stateCache[mac]) node.stateCache[mac] = {};
@@ -558,14 +1069,17 @@ module.exports = function(RED) {
             if (Object.keys(changed).length === 0) return;  // 无变化
             
             // 首次收到设备状态时只记录缓存，不触发同步（避免启动时批量发码）
-            // 但窗帘状态(curtainStatus)除外，因为这是用户的控制命令
+            // 但以下情况除外，因为这些是用户的控制命令：
+            // - 窗帘状态(curtainStatus)
+            // - 来自用户控制的事件(isUserControl=true)
             const hasCurtainStatusChange = changed.curtainStatus !== undefined;
-            if (isFirstState && !hasCurtainStatusChange) {
+            const isUserControlEvent = eventData.isUserControl === true;
+            if (isFirstState && !hasCurtainStatusChange && !isUserControlEvent) {
                 node.debug(`[Mesh事件] MAC=${mac} 首次状态，仅缓存: ${JSON.stringify(changed)}`);
                 return;
             }
             
-            node.log(`[Mesh事件] MAC=${mac}, 变化: ${JSON.stringify(changed)}`);
+            node.debug(`[Mesh事件] MAC=${mac}, 变化: ${JSON.stringify(changed)}`);
             
             // 规范化MAC地址用于比较
             const macNormalized = mac.toLowerCase().replace(/:/g, '');
@@ -575,7 +1089,7 @@ module.exports = function(RED) {
                 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)}`);
+                node.debug(`[Mesh事件] 匹配到映射: brand=${mapping.brand}, device=${mapping.device}`);
                 
                 const configChannel = mapping.meshChannel || 1;
                 const switchKey = `switch_${configChannel}`;
@@ -719,31 +1233,19 @@ module.exports = function(RED) {
                     continue;
                 }
                 
-                // 【自定义窗帘】处理Mesh面板控制同步到485（逻辑同杜亚）
+                // 【自定义窗帘】处理Mesh面板控制同步到485
                 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) {
+                    // 检查是否有窗帘状态变化
+                    if (changed.curtainStatus === undefined && changed.curtainAction === undefined) {
                         continue;
                     }
                     
-                    const newStatus = eventData.parameters && eventData.parameters.length > 0 
-                        ? eventData.parameters[0] 
-                        : null;
-                    
-                    // 忽略 null 值
-                    if (newStatus === null) {
-                        continue;
-                    }
+                    node.log(`[Mesh->自定义窗帘] ${eventData.device.name} 状态变化: ${JSON.stringify(changed)}`);
                     
-                    // 1秒防抖：避免重复发送相同状态（与杜亚窗帘一致）
+                    // 1秒防抖：避免重复发送相同状态
                     if (!node.curtainDebounce) node.curtainDebounce = {};
                     const debounceKey = `${curtainKey}_status`;
                     const lastTime = node.curtainDebounce[debounceKey] || 0;
@@ -753,42 +1255,42 @@ module.exports = function(RED) {
                     }
                     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 curtainAction = changed.curtainAction || eventData.device.state.curtainAction;
+                    const curtainStatus = changed.curtainStatus;
                     
                     const codes = mapping.customCodes;
                     let hexCode = null, actionName = '';
                     
-                    if (curtainAction === 'opening' && codes.open) {
-                        hexCode = codes.open;
+                    // 优先使用curtainAction判断
+                    if (curtainAction === 'opening' && codes.sendOpen) {
+                        hexCode = codes.sendOpen;
                         actionName = '打开';
-                    } else if (curtainAction === 'closing' && codes.close) {
-                        hexCode = codes.close;
+                    } else if (curtainAction === 'closing' && codes.sendClose) {
+                        hexCode = codes.sendClose;
                         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 = '暂停';
+                    } else if (curtainAction === 'stopped' && codes.sendStop) {
+                        hexCode = codes.sendStop;
+                        actionName = '停止';
+                    } else if (curtainStatus !== undefined) {
+                        // 回退：使用curtainStatus（小程序协议：1=开,2=关,3=停）
+                        if (curtainStatus === 1 && codes.sendOpen) {
+                            hexCode = codes.sendOpen; actionName = '打开';
+                        } else if (curtainStatus === 2 && codes.sendClose) {
+                            hexCode = codes.sendClose; actionName = '关闭';
+                        } else if ((curtainStatus === 0 || curtainStatus === 3) && codes.sendStop) {
+                            hexCode = codes.sendStop; actionName = '停止';
                         }
                     }
                     
                     if (hexCode) {
                         node.sendCustomCode(hexCode).then(() => {
-                            node.log(`[Mesh->自定义] ${actionName}: ${hexCode}`);
+                            node.log(`[Mesh->自定义窗帘] ${actionName}: ${hexCode}`);
                         }).catch(err => {
-                            node.error(`[Mesh->自定义] 发送失败: ${err.message}`);
+                            node.error(`[Mesh->自定义窗帘] 发送失败: ${err.message}`);
                         });
+                    } else {
+                        node.debug(`[Mesh->自定义窗帘] 无匹配码, action=${curtainAction}, status=${curtainStatus}`);
                     }
                     continue;
                 }
@@ -797,7 +1299,28 @@ module.exports = function(RED) {
                 const isCurtainControlled = false;
                 
                 // 只有对应类型的状态变化才触发对应类型的映射
-                const hasSwitchChange = isSwitch && changed[switchKey] !== undefined;
+                // 对于custom_switch，检查任意switch_*字段变化（因为用户可能控制任意一路）
+                let hasSwitchChange = false;
+                if (isSwitch) {
+                    // 检查配置的通道
+                    if (changed[switchKey] !== undefined) {
+                        hasSwitchChange = true;
+                    }
+                    // 对于custom品牌，只检查配置的通道或通用switch字段
+                    if (mapping.brand === 'custom' && !hasSwitchChange) {
+                        // 通用switch字段（单路开关或空调开关）
+                        if (changed.switch !== undefined || changed.acSwitch !== undefined || changed.climateSwitch !== undefined) {
+                            hasSwitchChange = true;
+                        }
+                    }
+                    // 非custom品牌也检查通用switch字段
+                    if (!hasSwitchChange && (changed.switch !== undefined || changed.acSwitch !== undefined)) {
+                        hasSwitchChange = true;
+                    }
+                }
+                
+                node.debug(`[Mesh事件] isSwitch=${isSwitch}, hasSwitchChange=${hasSwitchChange}, switchKey=${switchKey}`);
+                
                 // 窗帘：如果是杜亚窗帘，跳过状态变化处理（已在curtain-control中处理）
                 const hasCurtainChange = isCurtain && !isCurtainControlled && (
                     changed.curtainAction !== undefined || 
@@ -1179,17 +1702,59 @@ module.exports = function(RED) {
             if (mapping.brand === 'custom' && mapping.customCodes) {
                 const codes = mapping.customCodes;
                 
-                node.log(`[Mesh->自定义] 设备${mapping.device}, 状态: ${JSON.stringify(state)}`);
+                // 检查反馈选项：如果feedback=false，检查是否是RS485触发的状态变化
+                // 如果是RS485触发的（500ms内有同步记录），则跳过发送反馈码
+                const loopKey = `${mapping.meshMac}_${mapping.device}`;
+                if (mapping.feedback === false) {
+                    const lastSync = node.lastSyncTime ? node.lastSyncTime[loopKey] : 0;
+                    if (lastSync && Date.now() - lastSync < 500) {
+                        node.debug(`[Mesh->自定义] 反馈已禁用，跳过发送`);
+                        return;
+                    }
+                }
+                
+                node.debug(`[Mesh->自定义] 设备${mapping.device}, 状态: ${JSON.stringify(state)}`);
                 
                 // 开关类型
                 if (mapping.device === 'custom_switch') {
-                    for (const [key, value] of Object.entries(state)) {
-                        if (key === 'switch' || key === 'acSwitch' || key.startsWith('switch_')) {
-                            const hexCode = value ? codes.sendOn : codes.sendOff;
-                            if (hexCode) {
-                                await node.sendCustomCode(hexCode);
-                                node.log(`[Mesh->自定义] 开关: ${value ? '开' : '关'}, 发送: ${hexCode}`);
-                            }
+                    const configChannel = mapping.meshChannel || 1;
+                    const targetKey = `switch_${configChannel}`;
+                    
+                    // 查找开关状态：只检查配置的通道或通用switch字段
+                    let switchValue = undefined;
+                    let foundKey = null;
+                    
+                    // 1. 检查配置的通道
+                    if (state[targetKey] !== undefined) {
+                        switchValue = state[targetKey];
+                        foundKey = targetKey;
+                    }
+                    // 2. 回退到通用switch字段（单路开关或空调开关）
+                    if (switchValue === undefined && state.switch !== undefined) {
+                        switchValue = state.switch;
+                        foundKey = 'switch';
+                    }
+                    if (switchValue === undefined && state.acSwitch !== undefined) {
+                        switchValue = state.acSwitch;
+                        foundKey = 'acSwitch';
+                    }
+                    if (switchValue === undefined && state.climateSwitch !== undefined) {
+                        switchValue = state.climateSwitch;
+                        foundKey = 'climateSwitch';
+                    }
+                    
+                    if (switchValue !== undefined) {
+                        const hexCode = switchValue ? codes.sendOn : codes.sendOff;
+                        if (hexCode) {
+                            // 记录发送时间用于防死循环
+                            const loopKey = `${mapping.meshMac}_${mapping.device}`;
+                            if (!node.lastSyncTime) node.lastSyncTime = {};
+                            node.lastSyncTime[loopKey] = Date.now();
+                            
+                            await node.sendCustomCode(hexCode);
+                            node.log(`[Mesh->自定义] 开关(${foundKey}): ${switchValue ? '开' : '关'}, 发送: ${hexCode}`);
+                        } else {
+                            node.warn(`[Mesh->自定义] 开关(${foundKey}): ${switchValue ? '开' : '关'}, 缺少${switchValue ? 'sendOn' : 'sendOff'}码`);
                         }
                     }
                 }
@@ -1238,6 +1803,12 @@ module.exports = function(RED) {
                         } else {
                             if (!node.lastSentTime) node.lastSentTime = {};
                             node.lastSentTime[cacheKey] = now;
+                            
+                            // 记录发送时间用于防死循环
+                            const loopKey = `${mapping.meshMac}_${mapping.device}`;
+                            if (!node.lastSyncTime) node.lastSyncTime = {};
+                            node.lastSyncTime[loopKey] = now;
+                            
                             await node.sendCustomCode(hexCode);
                             node.log(`[Mesh->自定义] 窗帘 ${actionName}, 发送: ${hexCode}`);
                         }
@@ -1245,47 +1816,75 @@ module.exports = function(RED) {
                 }
                 // 空调类型
                 else if (mapping.device === 'custom_climate') {
-                    node.log(`[自定义空调] 处理状态: ${JSON.stringify(state)}, codes存在: ${!!codes}`);
+                    node.debug(`[自定义空调] 处理状态: ${JSON.stringify(state)}, codes存在: ${!!codes}`);
+                    
+                    // 记录发送时间用于防死循环
+                    const loopKey = `${mapping.meshMac}_${mapping.device}`;
+                    if (!node.lastSyncTime) node.lastSyncTime = {};
+                    
+                    // 去重处理：记录已处理的命令类型
+                    const processedTypes = new Set();
+                    
                     for (const [key, value] of Object.entries(state)) {
                         let hexCode = null;
+                        let codeType = '';
+                        let cmdCategory = ''; // 命令类别，用于去重
                         
-                        // 1. 开关控制 (处理 acSwitch, climateSwitch, switch)
+                        // 1. 开关控制 (处理 acSwitch, climateSwitch, switch) - 只处理一次
                         if (key === 'acSwitch' || key === 'climateSwitch' || key === 'switch') {
+                            cmdCategory = 'switch';
+                            if (processedTypes.has(cmdCategory)) continue; // 跳过重复
+                            processedTypes.add(cmdCategory);
+                            
                             const isOn = value === true || value === 1 || value === '1' || value === 'on' || value === 'ON';
                             hexCode = isOn ? (codes.acSendOn || codes.sendOn) : (codes.acSendOff || codes.sendOff);
-                            node.log(`[自定义空调] 开关控制: ${key}=${value}, isOn=${isOn}, hexCode=${hexCode}`);
+                            codeType = isOn ? 'acSendOn' : 'acSendOff';
                         }
-                        // 2. 风速控制
+                        // 2. 风速控制 - 只处理一次
                         else if (['acFanSpeed', 'fanSpeed', 'climateFanSpeed', 'fanMode', 'fan_speed', 'fanLevel', 'fan_level', 'speed'].includes(key)) {
+                            cmdCategory = 'fan';
+                            if (processedTypes.has(cmdCategory)) continue; // 跳过重复
+                            processedTypes.add(cmdCategory);
+                            
                             const val = parseInt(value);
-                            node.log(`[自定义空调] 风速控制: ${key}=${value}, val=${val}`);
                             // 标准Mesh协议: 1=高, 2=中, 3=低, 4=自动
                             if (val === 1) {
                                 hexCode = codes.fanSendHigh;
-                                node.log(`[自定义空调] 高风, hexCode=${hexCode}`);
+                                codeType = 'fanSendHigh';
                             }
                             else if (val === 2) {
                                 hexCode = codes.fanSendMid;
-                                node.log(`[自定义空调] 中风, hexCode=${hexCode}`);
+                                codeType = 'fanSendMid';
                             }
-                            else if (val === 3 || val === 0 || val === 4) {
+                            else if (val === 3) {
                                 hexCode = codes.fanSendLow;
-                                node.log(`[自定义空调] 低风, hexCode=${hexCode}`);
+                                codeType = 'fanSendLow';
+                            }
+                            else if (val === 4 || val === 0) {
+                                hexCode = codes.fanSendAuto;
+                                codeType = 'fanSendAuto';
                             }
                         }
-                        // 3. 模式控制
+                        // 3. 模式控制 - 只处理一次
                         else if (key === 'acMode' || key === 'climateMode' || key === 'mode') {
-                            if (value === 1) hexCode = codes.modeSendCool;
-                            else if (value === 2) hexCode = codes.modeSendHeat;
-                            else if (value === 4) hexCode = codes.modeSendDry;
-                            else if (value === 3) hexCode = codes.modeSendFan;
+                            cmdCategory = 'mode';
+                            if (processedTypes.has(cmdCategory)) continue;
+                            processedTypes.add(cmdCategory);
+                            
+                            if (value === 1) { hexCode = codes.modeSendCool; codeType = 'modeSendCool'; }
+                            else if (value === 2) { hexCode = codes.modeSendHeat; codeType = 'modeSendHeat'; }
+                            else if (value === 4) { hexCode = codes.modeSendDry; codeType = 'modeSendDry'; }
+                            else if (value === 3) { hexCode = codes.modeSendFan; codeType = 'modeSendFan'; }
                             
                             // 更新缓存中的模式
                             if (!node.climateCache[mapping.meshMac]) node.climateCache[mapping.meshMac] = {};
                             node.climateCache[mapping.meshMac].mode = value;
                         }
-                        // 4. 温度控制
+                        // 4. 温度控制 - 只处理一次
                         else if (key === 'targetTemp' || key === 'acTargetTemp' || key === 'temperature') {
+                            cmdCategory = 'temp';
+                            if (processedTypes.has(cmdCategory)) continue;
+                            processedTypes.add(cmdCategory);
                             const temp = Math.round(value);
                             // 优先从当前变化中获取模式，否则从缓存中获取，默认制冷(1)
                             const mode = state.acMode || state.climateMode || (node.climateCache[mapping.meshMac] ? node.climateCache[mapping.meshMac].mode : 1);
@@ -1308,8 +1907,11 @@ module.exports = function(RED) {
                         }
                         
                         if (hexCode) {
+                            node.lastSyncTime[loopKey] = Date.now();
                             await node.sendCustomCode(hexCode);
                             node.log(`[Mesh->自定义] 空调 ${key}=${value}, 发送: ${hexCode}`);
+                        } else if (codeType) {
+                            node.warn(`[Mesh->自定义] 空调 ${key}=${value}, 缺少${codeType}码`);
                         }
                     }
                 }
@@ -1568,10 +2170,10 @@ module.exports = function(RED) {
                         // 开关类型
                         if (key === 'switch' || key.startsWith('switch_')) {
                             const ch = key.startsWith('switch_') ? parseInt(key.replace('switch_', '')) : channel;
-                            const onOff = value ? 0x02 : 0x01;
-                            const param = Buffer.from([ch - 1, onOff]);
+                            const totalChannels = meshDevice.channels || 1;
+                            const param = Buffer.from([totalChannels, ch, value ? 1 : 0]);
                             await node.gateway.sendControl(meshDevice.networkAddress, 0x02, param);
-                            node.log(`[自定义->Mesh] 开关${ch}: ${value ? '开' : '关'}`);
+                            node.log(`[自定义->Mesh] 开关${ch}/${totalChannels}路: ${value ? '开' : '关'}`);
                         }
                         // 空调开关
                         else if (key === 'acSwitch' || key === 'climateSwitch') {
@@ -1628,12 +2230,11 @@ module.exports = function(RED) {
                     if (key.startsWith('switch')) {
                         const channelFromKey = parseInt(key.replace('switch', '')) || 1;
                         const ch = mapping.meshChannel || channelFromKey;
-                        
-                        const onOff = value ? 0x02 : 0x01;
-                        const param = Buffer.from([ch - 1, onOff]);
+                        const totalChannels = meshDevice.channels || 1;
+                        const param = Buffer.from([totalChannels, ch, value ? 1 : 0]);
                         
                         await node.gateway.sendControl(meshDevice.networkAddress, 0x02, param);
-                        node.log(`[RS485->Mesh] 开关${ch}: ${value ? '开' : '关'}`);
+                        node.log(`[RS485->Mesh] 开关${ch}/${totalChannels}路: ${value ? '开' : '关'}`);
                     }
                     else if (key.startsWith('led')) {
                         node.debug(`[RS485] 指示灯${key}: ${value}`);
@@ -1789,7 +2390,7 @@ module.exports = function(RED) {
             }
             try {
                 const hexStr = frame.toString('hex').toUpperCase().match(/.{1,2}/g)?.join(' ') || '';
-                node.log(`[RS485 TX] 发送帧: ${hexStr}`);
+                node.debug(`[RS485 TX] 发送帧: ${hexStr}`);
                 
                 await node.rs485Config.send(frame);
                 
@@ -1811,12 +2412,12 @@ module.exports = function(RED) {
 
         // 解析原始RS485帧 - 支持标准Modbus和自定义码匹配
         node.parseRS485Frame = function(frame) {
-            if (frame.length < 4) return;
+            if (frame.length < 2) return;  // 自定义码可能很短，改为2字节
             
             const hexStr = frame.toString('hex').toUpperCase().replace(/\s/g, ''); // 确保完全去掉空格
             const hexFormatted = hexStr.match(/.{1,2}/g)?.join(' ') || '';
             
-            node.log(`[RS485收到] ${hexFormatted} (${frame.length}字节)`);
+            node.log(`[RS485帧解析] 收到: ${hexFormatted} (${frame.length}字节)`);
             
             // ===== 杜亚窗帘协议检测 (55开头) =====
             if (frame[0] === 0x55 && frame.length >= 7) {
@@ -1884,21 +2485,190 @@ module.exports = function(RED) {
                 }
             }
             
+            // ===== SYMI空调面板协议检测 (7E开头7D结尾) =====
+            if (frame[0] === SYMI_HEADER && frame[frame.length - 1] === SYMI_FOOTER && frame.length >= 8) {
+                node.log(`[SYMI帧检测] 检测到7E...7D帧, 长度=${frame.length}`);
+                const symiData = parseSymiFrame(frame);
+                if (symiData) {
+                    node.log(`[SYMI帧解析] 成功! localAddr=${symiData.localAddr}, dataType=${symiData.dataType}, opCode=${symiData.opCode}`);
+                    
+                    // 只处理空调设备类型
+                    if (symiData.deviceType !== SYMI_DEVICE_TYPE_CLIMATE) {
+                        node.debug(`[SYMI] 非空调设备类型: ${symiData.deviceType}`);
+                        return;
+                    }
+                    
+                    // 查找匹配的SYMI->Zhonghong桥接映射
+                    for (const mapping of node.mappings) {
+                        if (mapping.brand !== 'symi' || !mapping.zhBridgeTarget) {
+                            continue;
+                        }
+                        
+                        // 检查SYMI地址是否匹配
+                        const symiLocalAddr = mapping.symiLocalAddr || 0x01;
+                        const symiDeviceAddr = mapping.symiDeviceAddr || 0x01;
+                        const symiDeviceChannel = mapping.symiDeviceChannel || 0x00;
+                        
+                        if (symiData.localAddr !== symiLocalAddr || 
+                            symiData.deviceAddr !== symiDeviceAddr ||
+                            symiData.deviceChannel !== symiDeviceChannel) {
+                            continue;
+                        }
+                        
+                        // 防循环检查
+                        const syncKey = `symi_${symiLocalAddr}_${symiDeviceAddr}_${symiDeviceChannel}`;
+                        if (!shouldSync(syncKey)) {
+                            node.debug(`[防循环] 忽略SYMI帧: ${hexFormatted}`);
+                            return;
+                        }
+                        
+                        // 只处理控制命令 (dataType=0x03)
+                        if (symiData.dataType !== SYMI_DATA_TYPE.CONTROL) {
+                            node.debug(`[SYMI] 非控制命令: dataType=${symiData.dataType}`);
+                            continue;
+                        }
+                        
+                        node.log(`[SYMI->Zhonghong] 控制命令: opCode=${symiData.opCode}, opData=${symiData.opData.toString('hex')}`);
+                        
+                        // 转换为中弘命令
+                        const zhCmd = convertSymiToZhonghong(symiData, mapping);
+                        if (!zhCmd) {
+                            node.warn(`[SYMI->Zhonghong] 未知操作码: ${symiData.opCode}`);
+                            continue;
+                        }
+                        
+                        // 构建并发送中弘控制帧
+                        const zhFrame = buildZhonghongControlFrame(zhCmd);
+                        node.sendRS485Frame(zhFrame).then(() => {
+                            const zhHex = zhFrame.toString('hex').toUpperCase().match(/.{2}/g).join(' ');
+                            node.log(`[SYMI->Zhonghong] 发送: ${zhHex}`);
+                            
+                            // 输出调试信息
+                            node.send({
+                                topic: 'symi-to-zhonghong',
+                                payload: {
+                                    direction: 'SYMI→Zhonghong',
+                                    symiOpCode: symiData.opCode,
+                                    zhFuncCode: zhCmd.funcCode,
+                                    zhValue: zhCmd.value,
+                                    frame: zhHex
+                                },
+                                timestamp: new Date().toISOString()
+                            });
+                        }).catch(err => {
+                            node.error(`[SYMI->Zhonghong] 发送失败: ${err.message}`);
+                        });
+                        
+                        return;
+                    }
+                    
+                    node.debug(`[SYMI] 未找到匹配的桥接映射`);
+                } else {
+                    node.debug(`[SYMI帧检测] CRC校验失败或格式错误`);
+                }
+            }
+            
+            // ===== 中弘VRF协议检测 (查询响应) =====
+            // 中弘响应帧: slaveAddr + 0x50 + funcValue + num + data... + checksum
+            if (frame.length >= 15 && frame[1] === ZHONGHONG_FUNC.QUERY) {
+                node.log(`[中弘帧检测] 检测到查询响应, 长度=${frame.length}`);
+                
+                // 查找匹配的Zhonghong->SYMI桥接映射
+                for (const mapping of node.mappings) {
+                    if (mapping.brand !== 'zhonghong' || !mapping.symiBridgeTarget) {
+                        continue;
+                    }
+                    
+                    const zhSlaveAddr = mapping.zhSlaveAddr || 0x01;
+                    const zhOutdoorAddr = mapping.zhOutdoorAddr || 0x01;
+                    const zhIndoorAddr = mapping.zhIndoorAddr || 0x01;
+                    
+                    // 验证从机地址
+                    if (frame[0] !== zhSlaveAddr) {
+                        continue;
+                    }
+                    
+                    const zhResponse = parseZhonghongResponse(frame, zhSlaveAddr);
+                    if (!zhResponse) {
+                        node.debug(`[中弘帧检测] 解析失败或校验错误`);
+                        continue;
+                    }
+                    
+                    // 查找匹配的空调状态
+                    const climate = zhResponse.climates.find(c => 
+                        c.outdoorAddr === zhOutdoorAddr && c.indoorAddr === zhIndoorAddr
+                    );
+                    
+                    if (!climate) {
+                        node.debug(`[中弘] 未找到匹配的空调: outdoor=${zhOutdoorAddr}, indoor=${zhIndoorAddr}`);
+                        continue;
+                    }
+                    
+                    // 防循环检查
+                    const syncKey = `zh_${zhSlaveAddr}_${zhOutdoorAddr}_${zhIndoorAddr}`;
+                    if (!shouldSync(syncKey)) {
+                        node.debug(`[防循环] 忽略中弘响应: ${hexFormatted}`);
+                        return;
+                    }
+                    
+                    // 状态去重检查
+                    const cacheKey = `zh_climate_${zhSlaveAddr}_${zhOutdoorAddr}_${zhIndoorAddr}`;
+                    const newState = {
+                        power: climate.onOff,
+                        mode: climate.mode,
+                        fanSpeed: climate.fanMode,
+                        targetTemp: climate.targetTemp
+                    };
+                    
+                    if (!hasStateChanged(cacheKey, newState)) {
+                        node.debug(`[中弘] 状态未变化，跳过同步`);
+                        continue;
+                    }
+                    
+                    node.log(`[Zhonghong->SYMI] 状态: power=${climate.onOff}, mode=${climate.mode}, fan=${climate.fanMode}, temp=${climate.targetTemp}°C`);
+                    
+                    // 转换为SYMI状态
+                    const symiParams = convertZhonghongToSymi(climate, mapping);
+                    
+                    // 构建并发送SYMI状态帧
+                    const symiFrame = buildSymiStatusFrame(symiParams);
+                    node.sendRS485Frame(symiFrame).then(() => {
+                        const symiHex = symiFrame.toString('hex').toUpperCase().match(/.{2}/g).join(' ');
+                        node.log(`[Zhonghong->SYMI] 发送: ${symiHex}`);
+                        
+                        // 输出调试信息
+                        node.send({
+                            topic: 'zhonghong-to-symi',
+                            payload: {
+                                direction: 'Zhonghong→SYMI',
+                                zhStatus: climate,
+                                symiParams: symiParams,
+                                frame: symiHex
+                            },
+                            timestamp: new Date().toISOString()
+                        });
+                    }).catch(err => {
+                        node.error(`[Zhonghong->SYMI] 发送失败: ${err.message}`);
+                    });
+                    
+                    return;
+                }
+            }
+            
             // 检查自定义码匹配（遍历所有映射）
-            node.log(`[自定义码检测] 开始匹配, 当前帧hex=${hexStr}, 映射数=${node.mappings.length}`);
+            node.debug(`[自定义码检测] 开始匹配, 当前帧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.log(`[自定义码检测] 检查映射: device=${mapping.device}, meshMac=${mapping.meshMac}`);
+                    node.debug(`[自定义码检测] 检查映射: device=${mapping.device}, meshMac=${mapping.meshMac}`);
                     
                     // 开关类型：匹配recvOn/recvOff
                     if (mapping.device === 'custom_switch') {
                         const recvOn = (codes.recvOn || '').replace(/\s/g, '').toUpperCase();
                         const recvOff = (codes.recvOff || '').replace(/\s/g, '').toUpperCase();
-                        node.log(`[自定义开关] recvOn=${recvOn}, recvOff=${recvOff}, hexStr=${hexStr}`);
-                        node.log(`[自定义开关] 包含recvOn? ${hexStr.includes(recvOn)}, 包含recvOff? ${hexStr.includes(recvOff)}`);
+                        node.debug(`[自定义开关] recvOn=${recvOn}, recvOff=${recvOff}`);
                         
                         // 翻转模式：收开码=收关码
                         if (recvOn && recvOff && recvOn === recvOff && hexStr.includes(recvOn)) {
@@ -1907,14 +2677,14 @@ module.exports = function(RED) {
                             const stateKey = mapping.meshChannel > 1 ? `switch_${channel}` : 'switch';
                             const currentState = device?.state?.[stateKey] || false;
                             matchedAction = { switch: !currentState };
-                            node.log(`[自定义开关] 翻转: ${stateKey} ${currentState} -> ${!currentState}`);
+                            node.debug(`[自定义开关] 翻转: ${stateKey} ${currentState} -> ${!currentState}`);
                         } else {
                             if (recvOn && hexStr.includes(recvOn)) {
                                 matchedAction = { switch: true };
-                                node.log(`[自定义开关] 匹配到收开码`);
+                                node.debug(`[自定义开关] 匹配到收开码`);
                             } else if (recvOff && hexStr.includes(recvOff)) {
                                 matchedAction = { switch: false };
-                                node.log(`[自定义开关] 匹配到收关码`);
+                                node.debug(`[自定义开关] 匹配到收关码`);
                             }
                         }
                     }
@@ -1926,13 +2696,13 @@ module.exports = function(RED) {
                         
                         if (recvOpen && hexStr.includes(recvOpen)) {
                             matchedAction = { action: 'open' };
-                            node.log(`[自定义窗帘] 收开码`);
+                            node.debug(`[自定义窗帘] 收开码`);
                         } else if (recvClose && hexStr.includes(recvClose)) {
                             matchedAction = { action: 'close' };
-                            node.log(`[自定义窗帘] 收关码`);
+                            node.debug(`[自定义窗帘] 收关码`);
                         } else if (recvStop && hexStr.includes(recvStop)) {
                             matchedAction = { action: 'stop' };
-                            node.log(`[自定义窗帘] 收停码`);
+                            node.debug(`[自定义窗帘] 收停码`);
                         }
                     }
                     // 空调类型：匹配收码
@@ -2024,7 +2794,7 @@ module.exports = function(RED) {
                                 if (!node.climateCache[mapping.meshMac]) node.climateCache[mapping.meshMac] = {};
                                 node.climateCache[mapping.meshMac].mode = matchedAction.acMode;
                             }
-                            node.log(`[自定义空调] 匹配: ${JSON.stringify(matchedAction)}`);
+                            node.debug(`[自定义空调] 匹配: ${JSON.stringify(matchedAction)}`);
                         }
                     }
                     // 场景类型：匹配trigger
@@ -2036,7 +2806,10 @@ module.exports = function(RED) {
                     
                     if (matchedAction) {
                         // 防死循环：检查是否刚刚从Mesh发送过来
-                        if (node.lastMeshToRS485Time && Date.now() - node.lastMeshToRS485Time < 500) {
+                        // 使用映射特定的时间戳，避免其他设备的同步影响
+                        const loopKey = `${mapping.meshMac}_${mapping.device}`;
+                        if (!node.lastSyncTime) node.lastSyncTime = {};
+                        if (node.lastSyncTime[loopKey] && Date.now() - node.lastSyncTime[loopKey] < 500) {
                             node.debug(`[防循环] 忽略刚刚同步的帧: ${hexFormatted}`);
                             return;
                         }
@@ -2056,6 +2829,9 @@ module.exports = function(RED) {
                             timestamp: new Date().toISOString()
                         });
                         
+                        // 记录同步时间用于防死循环
+                        node.lastSyncTime[loopKey] = Date.now();
+                        
                         node.queueCommand({
                             direction: 'modbus-to-mesh',
                             mapping: mapping,
@@ -2081,7 +2857,7 @@ module.exports = function(RED) {
             const fc = frame[1];
             const hexFormatted = frame.toString('hex').toUpperCase().match(/.{1,2}/g)?.join(' ') || '';
             
-            node.log(`[Modbus解析] 从机=${slaveAddr}, 功能码=0x${fc.toString(16)}, 帧=${hexFormatted}`);
+            node.debug(`[Modbus解析] 从机=${slaveAddr}, 功能码=0x${fc.toString(16)}`);
             
             // 查找所有匹配从机地址的映射
             const allMappings = node.findAllRS485Mappings(slaveAddr);
@@ -2090,7 +2866,7 @@ module.exports = function(RED) {
                 return;
             }
             
-            node.log(`[Modbus解析] 找到${allMappings.length}个匹配映射`);
+            node.debug(`[Modbus解析] 找到${allMappings.length}个匹配映射`);
 
             // 防死循环：检查是否刚刚从Mesh发送过来
             if (node.lastMeshToRS485Time && Date.now() - node.lastMeshToRS485Time < 500) {
@@ -2114,7 +2890,7 @@ module.exports = function(RED) {
                 rs485ChannelFromReg = regAddr - 0x1030;  // 0x1031->1, 0x1032->2, ...
             }
             
-            node.log(`[Modbus解析] 寄存器=0x${regAddr.toString(16).toUpperCase()}, 值=${value}, rs485Channel=${rs485ChannelFromReg}`);
+            node.debug(`[Modbus解析] 寄存器=0x${regAddr.toString(16).toUpperCase()}, 值=${value}, rs485Channel=${rs485ChannelFromReg}`);
             
             // 遍历所有匹配的映射，只处理rs485Channel匹配的
             for (const mapping of allMappings) {
@@ -2145,14 +2921,14 @@ module.exports = function(RED) {
                             state[key] = reg.map[value] || value;
                         } else {
                             state[key] = value;
+                            node.debug(`[RS485] 从机${slaveAddr} 寄存器0x${regAddr.toString(16).toUpperCase()}: ${key}=${value}`);
                         }
-                        node.log(`[RS485] 从机${slaveAddr} 寄存器0x${regAddr.toString(16).toUpperCase()}: ${key}=${value}`);
                         break;
                     }
                 }
                 
                 if (Object.keys(state).length > 0) {
-                    node.log(`[RS485->Mesh] 映射匹配: meshMac=${mapping.meshMac}, meshCH=${mapping.meshChannel}, rs485CH=${mappingRs485Channel}, 状态=${JSON.stringify(state)}`);
+                    node.debug(`[RS485->Mesh] 映射匹配: meshMac=${mapping.meshMac}, meshCH=${mapping.meshChannel}, rs485CH=${mappingRs485Channel}`);
                     
                     // 输出调试信息到节点输出端口
                     node.send({