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

package/nodes/symi-rs485-sync.js

@@ -0,0 +1,765 @@
+module.exports = function(RED) {
+    'use strict';
+
+    function SymiRS485SyncNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        node.name = config.name;
+        node.rs485ConfigA = RED.nodes.getNode(config.rs485ConfigA);
+        node.rs485ConfigB = RED.nodes.getNode(config.rs485ConfigB);
+        
+        // 解析映射配置
+        try {
+            node.mappings = JSON.parse(config.mappings || '[]');
+        } catch(e) {
+            node.mappings = [];
+        }
+
+        // 轮询配置
+        node.enablePolling = config.enablePolling !== false;
+        node.pollInterval = parseInt(config.pollInterval) || 1000;
+        node._pollTimer = null;
+        node._pollIndex = 0;
+
+        // 防抖时间戳，防止循环同步
+        node._lastSyncA = {};
+        node._lastSyncB = {};
+        const DEBOUNCE_MS = 2000;
+
+        // 状态缓存
+        node._stateCache = {};
+
+        if (!node.rs485ConfigA || !node.rs485ConfigB) {
+            node.status({ fill: 'red', shape: 'ring', text: '未配置RS485连接' });
+            return;
+        }
+
+        if (node.rs485ConfigA.id === node.rs485ConfigB.id) {
+            node.status({ fill: 'red', shape: 'ring', text: 'A/B不能是同一连接' });
+            return;
+        }
+
+        node.status({ fill: 'yellow', shape: 'dot', text: '初始化...' });
+
+        // 计算校验和（中弘协议）
+        function checksum(data) {
+            let sum = 0;
+            for (let i = 0; i < data.length; i++) {
+                sum += data[i];
+            }
+            return sum & 0xFF;
+        }
+
+        // 中弘VRF协议常量
+        const ZH_FUNC = {
+            CTRL_SWITCH: 0x31,
+            CTRL_TEMPERATURE: 0x32,
+            CTRL_MODE: 0x33,
+            CTRL_FAN_MODE: 0x34,
+            QUERY: 0x50
+        };
+
+        const ZH_MODE = {
+            COOL: 0x01,
+            DRY: 0x02,
+            FAN: 0x04,
+            HEAT: 0x08
+        };
+
+        const ZH_FAN = {
+            HIGH: 0x01,
+            MEDIUM: 0x02,
+            LOW: 0x04
+        };
+
+        // 获取配置值，支持0值
+        function getAddr(val, defaultVal) {
+            return val !== undefined ? val : defaultVal;
+        }
+
+        // 生成中弘VRF控制命令
+        function buildZhonghongCmd(cfg, action, value) {
+            const cmd = [
+                getAddr(cfg.slaveAddr, 1),
+                action,
+                value,
+                0x01,
+                getAddr(cfg.outdoorAddr, 1),
+                getAddr(cfg.indoorAddr, 0)  // 内机地址支持0
+            ];
+            cmd.push(checksum(cmd));
+            return Buffer.from(cmd);
+        }
+
+        // 生成中弘VRF查询命令
+        function buildZhonghongQueryCmd(cfg) {
+            const cmd = [
+                getAddr(cfg.slaveAddr, 1),
+                ZH_FUNC.QUERY,
+                0x01,
+                0x01,
+                getAddr(cfg.outdoorAddr, 1),
+                getAddr(cfg.indoorAddr, 0)  // 内机地址支持0
+            ];
+            cmd.push(checksum(cmd));
+            return Buffer.from(cmd);
+        }
+
+        // 解析中弘VRF响应 - 支持批量返回多个内机状态
+        function parseZhonghongResponse(data, cfg) {
+            if (data.length < 7) return null;
+            
+            const slaveAddr = data[0];
+            const expectedSlaveAddr = getAddr(cfg.slaveAddr, 1);
+            if (slaveAddr !== expectedSlaveAddr) return null;
+            
+            const func = data[1];
+            
+            // 查询响应: [从机] [0x50] [funcValue] [num] + [内机数据*num] + [校验和]
+            // 每个内机数据10字节: [外机] [内机] [开关] [温度] [模式] [风速] [当前温度] [x] [x] [x]
+            if (func === ZH_FUNC.QUERY) {
+                const funcValue = data[2];
+                if (funcValue !== 0x01) return null;
+                
+                const num = data[3];
+                if (num < 1) return null;
+                
+                const expectedLength = 4 + num * 10 + 1;
+                if (data.length < expectedLength) return null;
+                
+                // 解析所有内机状态
+                const climates = [];
+                for (let i = 0; i < num; i++) {
+                    const offset = 4 + i * 10;
+                    climates.push({
+                        outdoorAddr: data[offset],
+                        indoorAddr: data[offset + 1],
+                        power: data[offset + 2] === 0x01,
+                        targetTemp: data[offset + 3],
+                        mode: data[offset + 4],
+                        fanMode: data[offset + 5],
+                        currentTemp: data[offset + 6]
+                    });
+                }
+                
+                // 查找匹配的内机
+                const expectedOutdoor = getAddr(cfg.outdoorAddr, 1);
+                const expectedIndoor = getAddr(cfg.indoorAddr, 0);
+                
+                const matched = climates.find(c => 
+                    c.outdoorAddr === expectedOutdoor && c.indoorAddr === expectedIndoor
+                );
+                
+                if (matched) {
+                    return {
+                        type: 'status',
+                        power: matched.power,
+                        targetTemp: matched.targetTemp,
+                        currentTemp: matched.currentTemp,
+                        mode: matched.mode,
+                        fanMode: matched.fanMode
+                    };
+                }
+                
+                // 返回所有内机状态用于调试
+                return {
+                    type: 'batch_status',
+                    climates: climates
+                };
+            }
+            
+            // 控制响应
+            if (func >= ZH_FUNC.CTRL_SWITCH && func <= ZH_FUNC.CTRL_FAN_MODE) {
+                return {
+                    type: 'control_ack',
+                    func: func,
+                    value: data[2]
+                };
+            }
+            
+            return null;
+        }
+
+        // ===== SYMI空调面板协议 (0x60功能码, 主动上报) =====
+        // 帧格式: [地址] [0x60] [开关] [温度] [模式] [风速] [x] [x] [x] [校验和]
+        const SYMI_FUNC = 0x60;
+        
+        // SYMI模式值 -> 中弘模式值
+        const SYMI_TO_ZH_MODE = {
+            0x01: 0x01,  // 制冷 -> 制冷
+            0x02: 0x02,  // 除湿 -> 除湿
+            0x04: 0x04,  // 送风 -> 送风
+            0x08: 0x08   // 制热 -> 制热
+        };
+        
+        // 中弘模式值 -> SYMI模式值
+        const ZH_TO_SYMI_MODE = {
+            0x01: 0x01,  // 制冷
+            0x02: 0x02,  // 除湿
+            0x04: 0x04,  // 送风
+            0x08: 0x08   // 制热
+        };
+        
+        // SYMI风速值 -> 中弘风速值
+        const SYMI_TO_ZH_FAN = {
+            0x01: 0x04,  // 低风 -> 低风
+            0x02: 0x02,  // 中风 -> 中风
+            0x04: 0x01   // 高风 -> 高风
+        };
+        
+        // 中弘风速值 -> SYMI风速值
+        const ZH_TO_SYMI_FAN = {
+            0x01: 0x04,  // 高风
+            0x02: 0x02,  // 中风
+            0x04: 0x01   // 低风
+        };
+
+        // 计算SYMI校验和
+        function symiChecksum(data) {
+            let sum = 0;
+            for (let i = 0; i < data.length; i++) {
+                sum += data[i];
+            }
+            return sum & 0xFF;
+        }
+
+        // 生成SYMI空调面板控制命令
+        function buildSymiClimateCmd(cfg, opCode, value) {
+            const addr = cfg.address || 1;
+            // 获取当前缓存的状态
+            const cacheKey = `symi_${addr}`;
+            const cached = node._stateCache[cacheKey] || { power: 0, temp: 24, mode: 0x01, fan: 0x01 };
+            
+            let power = cached.power;
+            let temp = cached.temp;
+            let mode = cached.mode;
+            let fan = cached.fan;
+            
+            // 根据操作码更新对应值
+            if (opCode === 'power') {
+                power = value ? 0x01 : 0x00;
+            } else if (opCode === 'temp') {
+                temp = value;
+            } else if (opCode === 'mode') {
+                mode = ZH_TO_SYMI_MODE[value] || value;
+            } else if (opCode === 'fan') {
+                fan = ZH_TO_SYMI_FAN[value] || value;
+            }
+            
+            const cmd = Buffer.alloc(10);
+            cmd[0] = addr;
+            cmd[1] = SYMI_FUNC;
+            cmd[2] = power;
+            cmd[3] = temp;
+            cmd[4] = mode;
+            cmd[5] = fan;
+            cmd[6] = 0x01;
+            cmd[7] = 0x01;
+            cmd[8] = 0x00;
+            cmd[9] = symiChecksum(cmd.subarray(0, 9));
+            return cmd;
+        }
+
+        // 解析SYMI空调面板上报帧
+        function parseSymiClimateFrame(data, cfg) {
+            if (data.length < 10) return null;
+            
+            const addr = data[0];
+            const func = data[1];
+            
+            if (func !== SYMI_FUNC) return null;
+            if (addr !== (cfg.address || 1)) return null;
+            
+            // 验证校验和
+            const expectedChecksum = symiChecksum(data.subarray(0, 9));
+            if (data[9] !== expectedChecksum) {
+                return null;
+            }
+            
+            const power = data[2];
+            const targetTemp = data[3];
+            const mode = data[4];
+            const fanMode = data[5];
+            
+            return {
+                type: 'status',
+                power: power === 0x01,
+                targetTemp: targetTemp,
+                mode: mode,
+                fanMode: fanMode
+            };
+        }
+
+        // 同步状态：从A到B
+        function syncAtoB(mapping, state) {
+            const key = JSON.stringify({ a: mapping.configA, b: mapping.configB });
+            const now = Date.now();
+            
+            if (node._lastSyncB[key] && (now - node._lastSyncB[key]) < DEBOUNCE_MS) {
+                node.debug(`[A->B] 防抖跳过`);
+                return;
+            }
+            
+            node._lastSyncA[key] = now;
+            
+            node.log(`[A->B] 同步状态: ${JSON.stringify(state)}`);
+            
+            // 根据B侧协议生成命令
+            let cmd = null;
+            if (mapping.protocolB === 'zhonghong') {
+                if (state.power !== undefined) {
+                    cmd = buildZhonghongCmd(mapping.configB, ZH_FUNC.CTRL_SWITCH, state.power ? 0x01 : 0x00);
+                } else if (state.targetTemp !== undefined) {
+                    cmd = buildZhonghongCmd(mapping.configB, ZH_FUNC.CTRL_TEMPERATURE, state.targetTemp);
+                } else if (state.mode !== undefined) {
+                    cmd = buildZhonghongCmd(mapping.configB, ZH_FUNC.CTRL_MODE, state.mode);
+                } else if (state.fanMode !== undefined) {
+                    cmd = buildZhonghongCmd(mapping.configB, ZH_FUNC.CTRL_FAN_MODE, state.fanMode);
+                }
+            } else if (mapping.protocolB === 'symi_climate') {
+                // SYMI空调面板协议
+                if (state.power !== undefined) {
+                    cmd = buildSymiClimateCmd(mapping.configB, 'power', state.power);
+                } else if (state.targetTemp !== undefined) {
+                    cmd = buildSymiClimateCmd(mapping.configB, 'temp', state.targetTemp);
+                } else if (state.mode !== undefined) {
+                    cmd = buildSymiClimateCmd(mapping.configB, 'mode', state.mode);
+                } else if (state.fanMode !== undefined) {
+                    cmd = buildSymiClimateCmd(mapping.configB, 'fan', state.fanMode);
+                }
+            } else if (mapping.protocolB === 'custom') {
+                const codes = mapping.configB;
+                if (state.power === true && codes.sendOn) {
+                    cmd = Buffer.from(codes.sendOn.replace(/\s/g, ''), 'hex');
+                } else if (state.power === false && codes.sendOff) {
+                    cmd = Buffer.from(codes.sendOff.replace(/\s/g, ''), 'hex');
+                }
+            }
+            
+            if (cmd && node.rs485ConfigB) {
+                node.rs485ConfigB.send(cmd).then(() => {
+                    const hexStr = cmd.toString('hex').toUpperCase().match(/.{1,2}/g)?.join(' ') || '';
+                    node.log(`[A->B] 已发送到B: ${hexStr}`);
+                }).catch(err => {
+                    node.error(`[A->B] 发送失败: ${err.message}`);
+                });
+            }
+        }
+
+        // 同步状态：从B到A
+        function syncBtoA(mapping, state) {
+            const key = JSON.stringify({ a: mapping.configA, b: mapping.configB });
+            const now = Date.now();
+            
+            if (node._lastSyncA[key] && (now - node._lastSyncA[key]) < DEBOUNCE_MS) {
+                node.debug(`[B->A] 防抖跳过`);
+                return;
+            }
+            
+            node._lastSyncB[key] = now;
+            
+            node.log(`[B->A] 同步状态: ${JSON.stringify(state)}`);
+            
+            // 根据A侧协议生成命令
+            let cmd = null;
+            if (mapping.protocolA === 'zhonghong') {
+                if (state.power !== undefined) {
+                    cmd = buildZhonghongCmd(mapping.configA, ZH_FUNC.CTRL_SWITCH, state.power ? 0x01 : 0x00);
+                } else if (state.targetTemp !== undefined) {
+                    cmd = buildZhonghongCmd(mapping.configA, ZH_FUNC.CTRL_TEMPERATURE, state.targetTemp);
+                } else if (state.mode !== undefined) {
+                    cmd = buildZhonghongCmd(mapping.configA, ZH_FUNC.CTRL_MODE, state.mode);
+                } else if (state.fanMode !== undefined) {
+                    cmd = buildZhonghongCmd(mapping.configA, ZH_FUNC.CTRL_FAN_MODE, state.fanMode);
+                }
+            } else if (mapping.protocolA === 'symi_climate') {
+                // SYMI空调面板协议
+                if (state.power !== undefined) {
+                    cmd = buildSymiClimateCmd(mapping.configA, 'power', state.power);
+                } else if (state.targetTemp !== undefined) {
+                    cmd = buildSymiClimateCmd(mapping.configA, 'temp', state.targetTemp);
+                } else if (state.mode !== undefined) {
+                    cmd = buildSymiClimateCmd(mapping.configA, 'mode', state.mode);
+                } else if (state.fanMode !== undefined) {
+                    cmd = buildSymiClimateCmd(mapping.configA, 'fan', state.fanMode);
+                }
+            } else if (mapping.protocolA === 'custom') {
+                const codes = mapping.configA;
+                if (state.power === true && codes.sendOn) {
+                    cmd = Buffer.from(codes.sendOn.replace(/\s/g, ''), 'hex');
+                } else if (state.power === false && codes.sendOff) {
+                    cmd = Buffer.from(codes.sendOff.replace(/\s/g, ''), 'hex');
+                }
+            }
+            
+            if (cmd && node.rs485ConfigA) {
+                node.rs485ConfigA.send(cmd).then(() => {
+                    const hexStr = cmd.toString('hex').toUpperCase().match(/.{1,2}/g)?.join(' ') || '';
+                    node.log(`[B->A] 已发送到A: ${hexStr}`);
+                }).catch(err => {
+                    node.error(`[B->A] 发送失败: ${err.message}`);
+                });
+            }
+        }
+
+        // 处理A侧接收到的帧
+        function handleFrameA(frame) {
+            const hexStr = frame.toString('hex').toUpperCase().match(/.{1,2}/g)?.join(' ') || '';
+            node.debug(`[A侧收到] ${hexStr}`);
+            
+            // 先尝试解析为中弘VRF批量响应
+            if (frame.length >= 15 && frame[1] === ZH_FUNC.QUERY) {
+                const slaveAddr = frame[0];
+                const funcValue = frame[2];
+                const num = frame[3];
+                
+                if (funcValue === 0x01 && num >= 1) {
+                    const expectedLength = 4 + num * 10 + 1;
+                    if (frame.length >= expectedLength) {
+                        // 解析所有内机状态
+                        const climates = [];
+                        for (let i = 0; i < num; i++) {
+                            const offset = 4 + i * 10;
+                            climates.push({
+                                outdoorAddr: frame[offset],
+                                indoorAddr: frame[offset + 1],
+                                power: frame[offset + 2] === 0x01,
+                                targetTemp: frame[offset + 3],
+                                mode: frame[offset + 4],
+                                fanMode: frame[offset + 5],
+                                currentTemp: frame[offset + 6]
+                            });
+                        }
+                        
+                        node.log(`[A侧VRF] 收到${num}个内机状态`);
+                        
+                        // 为每个内机查找对应的映射并同步
+                        for (const climate of climates) {
+                            for (const mapping of node.mappings) {
+                                if (mapping.protocolA === 'zhonghong') {
+                                    const cfg = mapping.configA;
+                                    const expectedOutdoor = getAddr(cfg.outdoorAddr, 1);
+                                    const expectedIndoor = getAddr(cfg.indoorAddr, 0);
+                                    
+                                    if (climate.outdoorAddr === expectedOutdoor && climate.indoorAddr === expectedIndoor) {
+                                        const state = {
+                                            type: 'status',
+                                            power: climate.power,
+                                            targetTemp: climate.targetTemp,
+                                            currentTemp: climate.currentTemp,
+                                            mode: climate.mode,
+                                            fanMode: climate.fanMode
+                                        };
+                                        node.log(`[A->B] 内机${climate.outdoorAddr}-${climate.indoorAddr}: 开=${state.power}, 温=${state.targetTemp}, 模式=${state.mode}`);
+                                        syncAtoB(mapping, state);
+                                    }
+                                }
+                            }
+                        }
+                        return;
+                    }
+                }
+            }
+            
+            // 常规逐个映射处理
+            for (const mapping of node.mappings) {
+                let state = null;
+                
+                if (mapping.protocolA === 'zhonghong') {
+                    state = parseZhonghongResponse(frame, mapping.configA);
+                } else if (mapping.protocolA === 'symi_climate') {
+                    state = parseSymiClimateFrame(frame, mapping.configA);
+                    if (state) {
+                        const cacheKey = `symi_${mapping.configA.address || 1}`;
+                        node._stateCache[cacheKey] = {
+                            power: state.power ? 1 : 0,
+                            temp: state.targetTemp,
+                            mode: state.mode,
+                            fan: state.fanMode
+                        };
+                        state.mode = SYMI_TO_ZH_MODE[state.mode] || state.mode;
+                        state.fanMode = SYMI_TO_ZH_FAN[state.fanMode] || state.fanMode;
+                    }
+                } else if (mapping.protocolA === 'custom') {
+                    const codes = mapping.configA;
+                    const hexNoSpace = hexStr.replace(/\s/g, '');
+                    const recvOn = (codes.recvOn || '').replace(/\s/g, '').toUpperCase();
+                    const recvOff = (codes.recvOff || '').replace(/\s/g, '').toUpperCase();
+                    
+                    if (recvOn && hexNoSpace.includes(recvOn)) {
+                        state = { type: 'status', power: true };
+                    } else if (recvOff && hexNoSpace.includes(recvOff)) {
+                        state = { type: 'status', power: false };
+                    }
+                }
+                
+                if (state && state.type === 'status') {
+                    syncAtoB(mapping, state);
+                }
+            }
+        }
+
+        // 处理B侧接收到的帧
+        function handleFrameB(frame) {
+            const hexStr = frame.toString('hex').toUpperCase().match(/.{1,2}/g)?.join(' ') || '';
+            node.debug(`[B侧收到] ${hexStr}`);
+            
+            // 先尝试解析为中弘VRF批量响应
+            if (frame.length >= 15 && frame[1] === ZH_FUNC.QUERY) {
+                const funcValue = frame[2];
+                const num = frame[3];
+                
+                if (funcValue === 0x01 && num >= 1) {
+                    const expectedLength = 4 + num * 10 + 1;
+                    if (frame.length >= expectedLength) {
+                        const climates = [];
+                        for (let i = 0; i < num; i++) {
+                            const offset = 4 + i * 10;
+                            climates.push({
+                                outdoorAddr: frame[offset],
+                                indoorAddr: frame[offset + 1],
+                                power: frame[offset + 2] === 0x01,
+                                targetTemp: frame[offset + 3],
+                                mode: frame[offset + 4],
+                                fanMode: frame[offset + 5],
+                                currentTemp: frame[offset + 6]
+                            });
+                        }
+                        
+                        node.log(`[B侧VRF] 收到${num}个内机状态`);
+                        
+                        for (const climate of climates) {
+                            for (const mapping of node.mappings) {
+                                if (mapping.protocolB === 'zhonghong') {
+                                    const cfg = mapping.configB;
+                                    const expectedOutdoor = getAddr(cfg.outdoorAddr, 1);
+                                    const expectedIndoor = getAddr(cfg.indoorAddr, 0);
+                                    
+                                    if (climate.outdoorAddr === expectedOutdoor && climate.indoorAddr === expectedIndoor) {
+                                        const state = {
+                                            type: 'status',
+                                            power: climate.power,
+                                            targetTemp: climate.targetTemp,
+                                            currentTemp: climate.currentTemp,
+                                            mode: climate.mode,
+                                            fanMode: climate.fanMode
+                                        };
+                                        syncBtoA(mapping, state);
+                                    }
+                                }
+                            }
+                        }
+                        return;
+                    }
+                }
+            }
+            
+            // 常规逐个映射处理
+            for (const mapping of node.mappings) {
+                let state = null;
+                
+                if (mapping.protocolB === 'zhonghong') {
+                    state = parseZhonghongResponse(frame, mapping.configB);
+                } else if (mapping.protocolB === 'symi_climate') {
+                    state = parseSymiClimateFrame(frame, mapping.configB);
+                    if (state) {
+                        const cacheKey = `symi_${mapping.configB.address || 1}`;
+                        node._stateCache[cacheKey] = {
+                            power: state.power ? 1 : 0,
+                            temp: state.targetTemp,
+                            mode: state.mode,
+                            fan: state.fanMode
+                        };
+                        state.mode = SYMI_TO_ZH_MODE[state.mode] || state.mode;
+                        state.fanMode = SYMI_TO_ZH_FAN[state.fanMode] || state.fanMode;
+                    }
+                } else if (mapping.protocolB === 'custom') {
+                    const codes = mapping.configB;
+                    const hexNoSpace = hexStr.replace(/\s/g, '');
+                    const recvOn = (codes.recvOn || '').replace(/\s/g, '').toUpperCase();
+                    const recvOff = (codes.recvOff || '').replace(/\s/g, '').toUpperCase();
+                    
+                    if (recvOn && hexNoSpace.includes(recvOn)) {
+                        state = { type: 'status', power: true };
+                    } else if (recvOff && hexNoSpace.includes(recvOff)) {
+                        state = { type: 'status', power: false };
+                    }
+                }
+                
+                if (state && state.type === 'status') {
+                    syncBtoA(mapping, state);
+                }
+            }
+        }
+
+        // 事件处理函数
+        const onFrameA = (frame) => handleFrameA(frame);
+        const onFrameB = (frame) => handleFrameB(frame);
+        
+        const onConnectedA = () => {
+            node.log('[RS485 A] 已连接');
+            updateStatus();
+            checkAndStartPolling();
+        };
+        
+        const onConnectedB = () => {
+            node.log('[RS485 B] 已连接');
+            updateStatus();
+            checkAndStartPolling();
+        };
+        
+        const onDisconnectedA = () => {
+            node.log('[RS485 A] 已断开');
+            updateStatus();
+            stopPolling();
+        };
+        
+        const onDisconnectedB = () => {
+            node.log('[RS485 B] 已断开');
+            updateStatus();
+            stopPolling();
+        };
+
+        // 检查连接状态并启动轮询
+        function checkAndStartPolling() {
+            const connA = node.rs485ConfigA && node.rs485ConfigA._connected;
+            const connB = node.rs485ConfigB && node.rs485ConfigB._connected;
+            if (connA && connB && node.enablePolling && !node._pollTimer) {
+                startPolling();
+            }
+        }
+
+        // 启动轮询 - 只查询唯一的VRF外机，因为一次响应返回所有内机状态
+        function startPolling() {
+            if (node._pollTimer) return;
+            if (!node.enablePolling) return;
+            
+            // 收集所有需要轮询的VRF配置，按外机地址去重
+            const vrfConfigs = [];
+            const seen = new Set();
+            
+            for (const mapping of node.mappings) {
+                let cfg, rs485Config, side;
+                if (mapping.protocolA === 'zhonghong') {
+                    cfg = mapping.configA;
+                    rs485Config = node.rs485ConfigA;
+                    side = 'A';
+                } else if (mapping.protocolB === 'zhonghong') {
+                    cfg = mapping.configB;
+                    rs485Config = node.rs485ConfigB;
+                    side = 'B';
+                } else {
+                    continue;
+                }
+                
+                // 用从机地址+外机地址作为唯一键（同一外机下的所有内机共享一次查询）
+                const key = `${side}_${getAddr(cfg.slaveAddr, 1)}_${getAddr(cfg.outdoorAddr, 1)}`;
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    vrfConfigs.push({ cfg, rs485Config, side });
+                }
+            }
+            
+            if (vrfConfigs.length === 0) return;
+
+            node._vrfConfigs = vrfConfigs;
+            node._pollIndex = 0;
+            node._pollTimer = setInterval(pollNextVRF, node.pollInterval);
+            node.log(`[RS485 Sync] 启动轮询，间隔${node.pollInterval}ms，${vrfConfigs.length}个VRF外机，${node.mappings.length}组映射`);
+        }
+
+        // 停止轮询
+        function stopPolling() {
+            if (node._pollTimer) {
+                clearInterval(node._pollTimer);
+                node._pollTimer = null;
+            }
+        }
+
+        // 轮询函数 - 每次查询一个VRF外机，响应会包含该外机下所有内机状态
+        function pollNextVRF() {
+            if (!node._vrfConfigs || node._vrfConfigs.length === 0) return;
+
+            const { cfg, rs485Config, side } = node._vrfConfigs[node._pollIndex % node._vrfConfigs.length];
+            node._pollIndex++;
+
+            const cmd = buildZhonghongQueryCmd(cfg);
+            rs485Config.send(cmd).catch(() => {});
+        }
+
+        function updateStatus() {
+            const connA = node.rs485ConfigA && node.rs485ConfigA.connected;
+            const connB = node.rs485ConfigB && node.rs485ConfigB.connected;
+            
+            if (connA && connB) {
+                node.status({ fill: 'green', shape: 'dot', text: `同步中 (${node.mappings.length}组)` });
+            } else if (connA || connB) {
+                node.status({ fill: 'yellow', shape: 'dot', text: '部分连接' });
+            } else {
+                node.status({ fill: 'red', shape: 'ring', text: '未连接' });
+            }
+        }
+
+        // 绑定事件
+        node.rs485ConfigA.on('frame', onFrameA);
+        node.rs485ConfigA.on('connected', onConnectedA);
+        node.rs485ConfigA.on('disconnected', onDisconnectedA);
+        
+        node.rs485ConfigB.on('frame', onFrameB);
+        node.rs485ConfigB.on('connected', onConnectedB);
+        node.rs485ConfigB.on('disconnected', onDisconnectedB);
+
+        // 注册到配置节点
+        node.rs485ConfigA.register(node);
+        node.rs485ConfigB.register(node);
+
+        // 输出映射信息
+        node.mappings.forEach((m, idx) => {
+            node.log(`[映射${idx + 1}] ${m.protocolA} <-> ${m.protocolB}`);
+        });
+
+        updateStatus();
+        node.log(`[RS485 Sync] 初始化完成，${node.mappings.length}组映射，轮询${node.enablePolling ? '启用' : '禁用'}(${node.pollInterval}ms)`);
+
+        // 输入消息处理
+        node.on('input', function(msg) {
+            // 支持手动触发同步
+            if (msg.payload && msg.payload.action === 'query') {
+                // 发送查询命令到A侧
+                for (const mapping of node.mappings) {
+                    if (mapping.protocolA === 'zhonghong') {
+                        const cmd = buildZhonghongQueryCmd(mapping.configA);
+                        node.rs485ConfigA.send(cmd).catch(err => {
+                            node.error(`查询A失败: ${err.message}`);
+                        });
+                    }
+                }
+            }
+            
+            // 透传
+            node.send(msg);
+        });
+
+        // 清理
+        node.on('close', function(done) {
+            // 停止轮询
+            stopPolling();
+            
+            node.rs485ConfigA.removeListener('frame', onFrameA);
+            node.rs485ConfigA.removeListener('connected', onConnectedA);
+            node.rs485ConfigA.removeListener('disconnected', onDisconnectedA);
+            
+            node.rs485ConfigB.removeListener('frame', onFrameB);
+            node.rs485ConfigB.removeListener('connected', onConnectedB);
+            node.rs485ConfigB.removeListener('disconnected', onDisconnectedB);
+            
+            node.rs485ConfigA.deregister(node);
+            node.rs485ConfigB.deregister(node);
+            
+            done();
+        });
+    }
+
+    RED.nodes.registerType('symi-rs485-sync', SymiRS485SyncNode);
+};