node-red-contrib-symi-mesh 1.6.3 → 1.6.5

package/README.md

@@ -1061,6 +1061,34 @@ node-red-contrib-symi-mesh/
 
 ## 更新日志
 
+### v1.6.5 (2025-12-06)
+- **杜亚窗帘协议**：原生支持杜亚窗帘协议(A6B6)，2字节地址，自动CRC16计算
+  - 帧格式：55 [地址高] [地址低] 03 [动作/位置] [CRC16低] [CRC16高]
+  - 支持打开(01)、关闭(02)、暂停(03)、百分比(04+位置)
+- **窗帘控制智能判断**：根据当前位置判断方向
+  - 位置>=50% + curtainStatus变化 → 发关闭码
+  - 位置<50% + curtainStatus变化 → 发打开码
+  - 暂停(curtainStatus=3)最高优先级
+- **窗帘百分比模式修复**：修复百分比控制后开/关命令失效的问题
+  - 百分比控制时进入百分比模式（inPosMode）
+  - 窗帘到位（curtainStatus=0）后自动退出百分比模式
+  - 退出后开/关命令可正常发送
+- **发码防抖**：500ms内不重复发相同码，避免Mesh状态混乱
+- **设备类型过滤**：映射只响应对应类型的状态变化
+- **RS485调试增强**：新增协议测试发送功能
+- **初始化延迟**：20秒，避免部署时误发命令
+
+### v1.6.4 (2025-12-05)
+- **代码优化**：移除未使用的 `three-in-one-detected` 事件监听器（死代码清理）
+- **TCP连接优化**：移除可能导致连接问题的keep-alive设置
+- **多从机支持修复**：修复只能配置从机ID1的问题，现在支持任意从机地址(1-255)
+- **映射数值类型修复**：确保address/meshChannel/rs485Channel字段为正确的数字类型
+
+### v1.6.3 (2025-12-05)
+- **自定义协议模式**：支持任意RS485十六进制码双向匹配
+- **按键寄存器优化**：只处理按键寄存器(0x1031-0x1036)，移除指示灯寄存器处理
+- **CRC校验正确**：发送帧与协议文档完全匹配
+
 ### v1.6.2 (2025-12-05)
 - **MQTT订阅修复**：修复闭包问题导致的设备MAC映射错误，确保HA实体可控
 - **内存泄漏修复**：节点关闭时正确移除gateway事件监听器，防止内存累积
@@ -1080,8 +1108,8 @@ Copyright (c) 2025 SYMI 亖米
 ## 关于
 
 **作者**: SYMI 亖米
-**版本**: 1.6.2
+**版本**: 1.6.5
 **协议**: 蓝牙MESH网关（初级版）串口协议V1.0
-**最后更新**: 2025-12-05
+**最后更新**: 2025-12-06
 **仓库**: https://github.com/symi-daguo/node-red-contrib-symi-mesh
 **npm包**: https://www.npmjs.com/package/node-red-contrib-symi-mesh

package/lib/device-manager.js

@@ -100,16 +100,9 @@ class DeviceInfo {
                 break;
             case 0x05:
                 // CURT_RUN_STATUS - 窗帘运行状态
-                // 0=到头/停止, 1=打开中, 2=关闭中, 3=停止
+                // 0=到头/停止, 1=打开中, 2=关闭中, 3=暂停
                 if (parameters.length > 0) {
-                    const newStatus = parameters[0];
-                    // 如果已经到头(status=0)，忽略后续的运行中状态(1或2)
-                    // 直到收到新的位置(0x06)或控制命令
-                    if (this.state.curtainStatus === 0 && (newStatus === 1 || newStatus === 2)) {
-                        // 窗帘已到头，忽略设备继续发送的运行状态
-                        return;
-                    }
-                    this.state.curtainStatus = newStatus;
+                    this.state.curtainStatus = parameters[0];
                 }
                 break;
             case 0x06:

package/lib/tcp-client.js

@@ -40,7 +40,7 @@ class TCPClient extends EventEmitter {
             }
 
             this.client = new net.Socket();
-            this.client.setKeepAlive(true, 30000);
+            // Keep-Alive 已移除 - 可能导致连接问题
             
             let resolved = false;
             let rejected = false;

package/nodes/rs485-debug.html

@@ -116,6 +116,45 @@
                 }
             });
 
+            // 发送测试
+            $('#btn-test-send').on('click', function() {
+                var hexInput = $('#test-hex-input').val().trim();
+                if (!hexInput) {
+                    $('#test-send-result').html('<span style="color:orange;">请输入16进制数据</span>');
+                    return;
+                }
+                var rs485ConfigId = $('#node-input-rs485Config').val();
+                if (!rs485ConfigId) {
+                    $('#test-send-result').html('<span style="color:red;">请先选择RS485连接</span>');
+                    return;
+                }
+                $('#btn-test-send').prop('disabled', true);
+                $('#test-send-result').html('<i class="fa fa-spinner fa-spin"></i> 发送中...');
+                $.ajax({
+                    url: '/rs485-debug/test-send',
+                    method: 'POST',
+                    contentType: 'application/json',
+                    data: JSON.stringify({ rs485ConfigId: rs485ConfigId, hex: hexInput }),
+                    success: function(res) {
+                        $('#test-send-result').html('<span style="color:green;">✓ 已发送: ' + res.hex + ' (' + res.bytes + '字节)</span>');
+                    },
+                    error: function(xhr) {
+                        var msg = xhr.responseJSON ? xhr.responseJSON.error : '发送失败';
+                        $('#test-send-result').html('<span style="color:red;">✗ ' + msg + '</span>');
+                    },
+                    complete: function() {
+                        $('#btn-test-send').prop('disabled', false);
+                    }
+                });
+            });
+            
+            // 回车发送
+            $('#test-hex-input').on('keypress', function(e) {
+                if (e.which === 13) {
+                    $('#btn-test-send').click();
+                }
+            });
+
             // 初始加载并启动自动刷新
             loadHistory();
             startAutoRefresh();
@@ -181,6 +220,18 @@
         <input type="number" id="node-input-maxMessages" min="10" max="1000" style="width:70%">
     </div>
 
+    <div class="debug-section">
+        <h4><i class="fa fa-paper-plane"></i> 发送测试</h4>
+        <div style="display:flex; gap:8px; align-items:center;">
+            <input type="text" id="test-hex-input" placeholder="输入16进制数据，如: 55 01 01 03 01 B9 00" 
+                   style="flex:1; font-family:monospace; padding:6px;">
+            <button type="button" id="btn-test-send" class="red-ui-button" style="min-width:80px;">
+                <i class="fa fa-send"></i> 发送
+            </button>
+        </div>
+        <div id="test-send-result" style="margin-top:6px; font-size:11px; color:#666;"></div>
+    </div>
+
     <div class="debug-section">
         <h4><i class="fa fa-terminal"></i> 通信数据预览 <span id="debug-status" style="font-weight:normal;color:#888;font-size:11px;"></span></h4>
         <div id="debug-history"></div>

package/nodes/rs485-debug.js

@@ -217,4 +217,47 @@ module.exports = function(RED) {
             res.json({ success: false, error: '节点未找到' });
         }
     });
+
+    // API: 测试发送十六进制数据
+    RED.httpAdmin.post('/rs485-debug/test-send', function(req, res) {
+        const { rs485ConfigId, hex } = req.body || {};
+        
+        if (!rs485ConfigId) {
+            return res.status(400).json({ error: '未指定RS485连接' });
+        }
+        if (!hex) {
+            return res.status(400).json({ error: '未指定发送数据' });
+        }
+        
+        // 解析16进制字符串
+        const hexClean = hex.replace(/[\s,]/g, '');
+        if (!/^[0-9A-Fa-f]+$/.test(hexClean)) {
+            return res.status(400).json({ error: '无效的16进制格式' });
+        }
+        if (hexClean.length % 2 !== 0) {
+            return res.status(400).json({ error: '16进制长度必须是偶数' });
+        }
+        
+        const buffer = Buffer.from(hexClean, 'hex');
+        const formattedHex = buffer.toString('hex').toUpperCase().match(/.{2}/g).join(' ');
+        
+        // 获取RS485配置节点
+        const rs485Config = RED.nodes.getNode(rs485ConfigId);
+        if (!rs485Config) {
+            return res.status(404).json({ error: 'RS485连接节点未找到，请先部署' });
+        }
+        
+        if (!rs485Config.connected) {
+            return res.status(503).json({ error: 'RS485未连接' });
+        }
+        
+        // 发送数据
+        rs485Config.send(buffer)
+            .then(() => {
+                res.json({ success: true, hex: formattedHex, bytes: buffer.length });
+            })
+            .catch(err => {
+                res.status(500).json({ error: err.message });
+            });
+    });
 };

package/nodes/symi-485-bridge.html

@@ -160,6 +160,18 @@
 
                 mappings.forEach(function(m, idx) {
                     var row = $('<div class="mapping-row" data-idx="' + idx + '" style="flex-wrap:wrap;"></div>');
+                    // 杜亚窗帘使用2字节地址
+                    var addrHtml = '';
+                    if (m.brand === 'duya') {
+                        addrHtml = '<div class="addr-col duya-addr" style="display:flex;gap:2px;">' +
+                            '<input type="number" class="addr-high" value="' + (m.addrHigh || 1) + '" min="0" max="255" style="width:40px;" title="地址高字节" placeholder="高">' +
+                            '<input type="number" class="addr-low" value="' + (m.addrLow || 1) + '" min="0" max="255" style="width:40px;" title="地址低字节" placeholder="低">' +
+                            '</div>';
+                    } else {
+                        addrHtml = '<div class="addr-col normal-addr">' +
+                            '<input type="number" class="addr-input" value="' + (m.address || 1) + '" min="1" max="255" title="Modbus地址">' +
+                            '</div>';
+                    }
                     row.html(
                         '<div class="mesh-col">' +
                         '  <select class="mesh-select">' + getMeshOptions(m.meshMac) + '</select>' +
@@ -173,9 +185,7 @@
                         '  <select class="device-select">' + getDeviceOptions(m.brand, m.device) + '</select>' +
                         '  <span class="rs485-ch-wrap">' + getRS485ChannelOptions(m.brand, m.device, m.rs485Channel || 1) + '</span>' +
                         '</div>' +
-                        '<div class="addr-col">' +
-                        '  <input type="number" class="addr-input" value="' + (m.address || 1) + '" min="1" max="255" title="Modbus地址">' +
-                        '</div>' +
+                        addrHtml +
                         '<div class="del-col"><button type="button" class="red-ui-button red-ui-button-small btn-remove" title="删除"><i class="fa fa-times"></i></button></div>'
                     );
                     container.append(row);
@@ -203,6 +213,12 @@
                     mappings[idx].device = '';
                     mappings[idx].rs485Channel = 1;
                     mappings[idx].customCodes = {};
+                    // 杜亚窗帘切换地址输入框
+                    if (brandId === 'duya') {
+                        mappings[idx].addrHigh = 1;
+                        mappings[idx].addrLow = 1;
+                    }
+                    renderMappings();  // 重新渲染以更新地址输入框
                 });
 
                 container.find('.device-select').off('change').on('change', function() {
@@ -245,6 +261,16 @@
                     mappings[idx].address = parseInt($(this).val()) || 1;
                 });
 
+                // 杜亚2字节地址输入
+                container.find('.addr-high').off('change').on('change', function() {
+                    var idx = $(this).closest('.mapping-row').data('idx');
+                    mappings[idx].addrHigh = parseInt($(this).val()) || 1;
+                });
+                container.find('.addr-low').off('change').on('change', function() {
+                    var idx = $(this).closest('.mapping-row').data('idx');
+                    mappings[idx].addrLow = parseInt($(this).val()) || 1;
+                });
+
                 container.find('.btn-remove').off('click').on('click', function() {
                     var idx = $(this).closest('.mapping-row').data('idx');
                     mappings.splice(idx, 1);

package/nodes/symi-485-bridge.js

@@ -235,6 +235,22 @@ module.exports = function(RED) {
                     'scene': { name: '场景', type: 'scene', registers: { trigger: { address: 0x0000, type: 'holding' } } }
                 }
             },
+            // ===== 杜亚窗帘协议 =====
+            // 帧格式: 55 [地址高] [地址低] 03 [数据] [CRC16高] [CRC16低]
+            // 数据: 01=打开, 02=关闭, 03=停止, 04+位置=百分比
+            // 地址: 2字节，如0101表示地址高=01，地址低=01
+            'duya': {
+                name: '杜亚窗帘',
+                protocol: 'duya',  // 标记使用专用协议
+                twoByteAddress: true,  // 标记使用2字节地址
+                devices: {
+                    'curtain': {
+                        name: '窗帘',
+                        type: 'cover',
+                        protocol: 'duya'
+                    }
+                }
+            },
             // ===== 自定义协议 - 用户可录入任意RS485码 =====
             'custom': {
                 name: '自定义协议',
@@ -262,6 +278,71 @@ module.exports = function(RED) {
         }
     };
 
+    // ===== 杜亚协议CRC16计算 =====
+    // 杜亚使用CRC16-MODBUS算法，低字节在前
+    function calcA6B6CRC(buffer) {
+        let crc = 0xFFFF;
+        for (let i = 0; i < buffer.length; i++) {
+            crc ^= buffer[i];
+            for (let j = 0; j < 8; j++) {
+                if (crc & 0x0001) {
+                    crc = (crc >> 1) ^ 0xA001;
+                } else {
+                    crc >>= 1;
+                }
+            }
+        }
+        // 返回低字节在前（小端序）
+        return [crc & 0xFF, (crc >> 8) & 0xFF];
+    }
+
+    // 构建A6B6窗帘控制帧
+    // 地址格式: 0x0102 表示地址高=01, 地址低=02
+    function buildA6B6Frame(addrHigh, addrLow, action, position) {
+        let data;
+        if (action === 'position' && position !== undefined) {
+            // 百分比控制: 55 addrH addrL 03 04 [位置] CRC
+            data = Buffer.from([0x55, addrHigh, addrLow, 0x03, 0x04, position]);
+        } else {
+            // 动作控制: 55 addrH addrL 03 [动作] CRC
+            const actionCode = action === 'open' ? 0x01 : action === 'close' ? 0x02 : 0x03;
+            data = Buffer.from([0x55, addrHigh, addrLow, 0x03, actionCode]);
+        }
+        const crc = calcA6B6CRC(data);
+        return Buffer.concat([data, Buffer.from(crc)]);
+    }
+
+    // 解析A6B6窗帘响应帧
+    function parseA6B6Frame(frame) {
+        if (frame.length < 7 || frame[0] !== 0x55) return null;
+        
+        const addrHigh = frame[1];
+        const addrLow = frame[2];
+        const funcCode = frame[3];
+        
+        if (funcCode !== 0x03) return null;
+        
+        const dataType = frame[4];
+        let result = {
+            address: (addrHigh << 8) | addrLow,
+            addrHigh: addrHigh,
+            addrLow: addrLow
+        };
+        
+        if (dataType === 0x01) {
+            result.action = 'open';
+        } else if (dataType === 0x02) {
+            result.action = 'close';
+        } else if (dataType === 0x03) {
+            result.action = 'stop';
+        } else if (dataType === 0x04 && frame.length >= 8) {
+            result.action = 'position';
+            result.position = frame[5];
+        }
+        
+        return result;
+    }
+
     function SymiRS485BridgeNode(config) {
         RED.nodes.createNode(this, config);
         const node = this;
@@ -273,9 +354,33 @@ module.exports = function(RED) {
         
         // 解析实体映射
         try {
-            node.mappings = JSON.parse(config.mappings || '[]');
+            const rawMappings = JSON.parse(config.mappings || '[]');
+            // 确保所有数值字段是正确类型
+            node.mappings = rawMappings.map(m => {
+                const mapping = {
+                    ...m,
+                    address: parseInt(m.address) || 1,
+                    meshChannel: parseInt(m.meshChannel) || 1,
+                    rs485Channel: parseInt(m.rs485Channel) || 1
+                };
+                // 杜亚窗帘使用2字节地址
+                if (m.brand === 'duya') {
+                    mapping.addrHigh = parseInt(m.addrHigh) || parseInt(m.address) || 1;
+                    mapping.addrLow = parseInt(m.addrLow) || parseInt(m.address) || 1;
+                }
+                return mapping;
+            });
+            // 打印所有映射配置便于调试
+            node.mappings.forEach((m, i) => {
+                if (m.brand === 'duya') {
+                    node.log(`[映射${i+1}] Mesh: ${m.meshMac} <-> 杜亚窗帘: 地址${m.addrHigh.toString(16).padStart(2,'0')} ${m.addrLow.toString(16).padStart(2,'0')}`);
+                } else {
+                    node.log(`[映射${i+1}] Mesh: ${m.meshMac} CH${m.meshChannel} <-> RS485: 从机${m.address} ${m.brand}/${m.device} CH${m.rs485Channel}`);
+                }
+            });
         } catch (e) {
             node.mappings = [];
+            node.error(`映射配置解析失败: ${e.message}`);
         }
 
         if (!node.gateway) {
@@ -349,7 +454,8 @@ module.exports = function(RED) {
 
         // Find mapping for RS485 device
         node.findRS485Mapping = function(address) {
-            return node.mappings.find(m => m.address === address);
+            const addr = parseInt(address);
+            return node.mappings.find(m => m.address === addr);
         };
 
         // 获取映射的寄存器配置
@@ -360,34 +466,73 @@ module.exports = function(RED) {
             return brand.devices[mapping.device].registers;
         };
 
+        // 状态缓存 - 用于检测真正变化的开关
+        node.stateCache = {};
+        // 首次启动标记 - 跳过初始状态同步
+        node.initializing = true;
+        // 启动后延迟20秒再开始同步（Mesh网关需要15秒以上完成设备发现）
+        setTimeout(() => {
+            node.initializing = false;
+            node.log('[RS485 Bridge] 初始化完成，开始同步');
+        }, 20000);
+
         // Mesh设备状态变化处理(事件驱动)
         const handleMeshStateChange = (eventData) => {
             if (node.syncLock) return;
+            if (node.initializing) return;
             
             const mac = eventData.device.macAddress;
             const state = eventData.state || {};
-            // channel可能是0-based或1-based，需要兼容处理
-            // Mesh事件中channel通常是0-based，UI配置的meshChannel是1-based
-            const eventChannel = state.channel !== undefined ? state.channel : -1;
             
-            node.debug(`[Mesh事件] MAC=${mac}, channel=${eventChannel}, state=${JSON.stringify(state)}`);
+            // 状态缓存比较，只处理真正变化的状态
+            if (!node.stateCache[mac]) node.stateCache[mac] = {};
+            const cached = node.stateCache[mac];
+            const changed = {};
             
-            // 查找匹配的映射 - 遍历所有映射找到MAC匹配的
+            for (const [key, value] of Object.entries(state)) {
+                if (cached[key] !== value) {
+                    changed[key] = value;
+                    cached[key] = value;
+                }
+            }
+            
+            if (Object.keys(changed).length === 0) return;  // 无变化
+            
+            node.log(`[Mesh事件] MAC=${mac}, 变化: ${JSON.stringify(changed)}`);
+            
+            // 遍历映射，只处理有对应变化的映射
             for (const mapping of node.mappings) {
                 if (mapping.meshMac !== mac) continue;
                 
-                // 通道匹配：meshChannel=0表示匹配所有，否则需要匹配具体通道
-                // UI的meshChannel是1-based，事件的channel可能是0-based
                 const configChannel = mapping.meshChannel || 1;
-                const matchChannel = (eventChannel === -1) || // 无channel信息，匹配所有
-                                    (eventChannel === configChannel) || // 1-based匹配
-                                    (eventChannel === configChannel - 1); // 0-based匹配
+                const switchKey = `switch_${configChannel}`;
+                const device = mapping.device || '';
                 
-                if (!matchChannel) continue;
+                // 根据映射设备类型检查是否有相关状态
+                const isSwitch = device.includes('switch') || device.includes('button');
+                const isCurtain = device.includes('curtain') || mapping.brand === 'duya';
+                const isAC = device.includes('ac') || device.includes('climate') || device.includes('thermostat');
+                
+                // 只有对应类型的状态变化才触发对应类型的映射
+                const hasSwitchChange = isSwitch && changed[switchKey] !== undefined;
+                const hasCurtainChange = isCurtain && (
+                    changed.curtainAction !== undefined || 
+                    changed.curtainPosition !== undefined || 
+                    changed.curtainStatus !== undefined
+                );
+                const hasACChange = isAC && (
+                    changed.targetTemp !== undefined || 
+                    changed.acMode !== undefined || 
+                    changed.acFanSpeed !== undefined
+                );
+                
+                if (!hasSwitchChange && !hasCurtainChange && !hasACChange) {
+                    continue;
+                }
                 
                 const registers = node.getRegistersForMapping(mapping);
                 
-                node.log(`[Mesh->RS485] ${eventData.device.name} 通道${configChannel} 状态变化: ${JSON.stringify(state)}`);
+                node.log(`[Mesh->RS485] ${eventData.device.name} CH${configChannel} 变化: ${JSON.stringify(changed)}`);
                 
                 // 输出调试信息到节点输出端口
                 node.send({
@@ -397,7 +542,7 @@ module.exports = function(RED) {
                         device: eventData.device.name,
                         mac: mac,
                         channel: configChannel,
-                        state: state
+                        state: changed
                     },
                     timestamp: new Date().toISOString()
                 });
@@ -406,11 +551,74 @@ module.exports = function(RED) {
                     direction: 'mesh-to-modbus', 
                     mapping: mapping,
                     registers: registers,
-                    state: state, 
+                    state: changed, 
                     timestamp: Date.now() 
                 });
+            }
+        };
+
+        // 窗帘控制命令处理（立即同步，不等状态反馈）
+        const handleCurtainControl = (eventData) => {
+            const mac = eventData.mac;
+            
+            node.log(`[curtain-control事件] MAC=${mac}, action=${eventData.action}, position=${eventData.position}`);
+            
+            // 查找杜亚窗帘映射（支持大小写和冒号格式）
+            const macNormalized = mac.toLowerCase().replace(/:/g, '');
+            for (const mapping of node.mappings) {
+                const mappingMacNormalized = (mapping.meshMac || '').toLowerCase().replace(/:/g, '');
+                if (mappingMacNormalized !== macNormalized || mapping.brand !== 'duya') continue;
+                
+                node.log(`[curtain-control] 匹配到杜亚映射: ${mapping.meshMac}`);
+                
+                const addrHigh = mapping.addrHigh || 1;
+                const addrLow = mapping.addrLow || 1;
                 
-                break; // 找到匹配的映射就停止
+                let frame = null;
+                let actionName = '';
+                
+                // 处理动作命令 (attrType=0x05)
+                if (eventData.action !== null) {
+                    if (eventData.action === 1) {
+                        frame = buildA6B6Frame(addrHigh, addrLow, 'open');
+                        actionName = '打开';
+                    } else if (eventData.action === 2) {
+                        frame = buildA6B6Frame(addrHigh, addrLow, 'close');
+                        actionName = '关闭';
+                    } else if (eventData.action === 3) {
+                        frame = buildA6B6Frame(addrHigh, addrLow, 'stop');
+                        actionName = '暂停';
+                    }
+                }
+                // 处理位置命令 (attrType=0x06)
+                else if (eventData.position !== null) {
+                    const pos = eventData.position;
+                    if (pos >= 95) {
+                        frame = buildA6B6Frame(addrHigh, addrLow, 'open');
+                        actionName = '打开';
+                    } else if (pos <= 5) {
+                        frame = buildA6B6Frame(addrHigh, addrLow, 'close');
+                        actionName = '关闭';
+                    } else {
+                        frame = buildA6B6Frame(addrHigh, addrLow, 'position', pos);
+                        actionName = `位置${pos}%`;
+                    }
+                }
+                
+                if (frame) {
+                    // 立即发送，记录时间防止状态反馈重复发码
+                    node.lastCurtainControlTime = Date.now();  // 专门用于curtain-control事件
+                    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}`);
+                    });
+                }
             }
         };
 
@@ -501,6 +709,87 @@ module.exports = function(RED) {
             // 记录发送时间（用于防死循环）
             node.lastMeshToRS485Time = Date.now();
             
+            // ===== 杜亚窗帘协议模式 =====
+            if (mapping.brand === 'duya') {
+                const addrHigh = mapping.addrHigh || 1;
+                const addrLow = mapping.addrLow || 1;
+                
+                // 缓存：记录 status 和 position
+                if (!node.curtainCache) node.curtainCache = {};
+                const cKey = `cc_${mapping.meshMac}`;
+                const cache = node.curtainCache[cKey] || { status: undefined, position: 50 };
+                
+                const lastStatus = cache.status;
+                const currentStatus = state.curtainStatus;
+                
+                // 【重要】先更新位置缓存，再判断方向
+                // 第一个事件通常同时包含 status 和 position
+                if (state.curtainPosition !== undefined) {
+                    cache.position = state.curtainPosition;
+                }
+                
+                // 判断方向时使用的位置：优先使用事件中的位置，否则使用缓存
+                const posForDirection = state.curtainPosition !== undefined ? state.curtainPosition : cache.position;
+                
+                // 更新状态缓存
+                if (currentStatus !== undefined) {
+                    cache.status = currentStatus;
+                }
+                node.curtainCache[cKey] = cache;
+                
+                let frame = null;
+                let actionName = '';
+                
+                const isRunning = currentStatus === 1 || currentStatus === 2;
+                
+                // 1. 暂停(status=3) → 立即发送暂停码
+                if (currentStatus === 3) {
+                    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 = '打开';
+                    }
+                }
+                // 3. 只有位置变化（没有状态变化），中间位置发百分比码
+                else if (state.curtainPosition !== undefined && 
+                         state.curtainStatus === undefined &&
+                         state.curtainPosition > 5 && state.curtainPosition < 95) {
+                    frame = buildA6B6Frame(addrHigh, addrLow, 'position', state.curtainPosition);
+                    actionName = `位置${state.curtainPosition}%`;
+                }
+                
+                if (frame) {
+                    // 全局防抖: 2秒内不重复发送开关码（过滤运行中的状态抖动）
+                    if (!node.lastSentTime) node.lastSentTime = {};
+                    const isOpenClose = (actionName === '打开' || actionName === '关闭');
+                    const cacheKey = isOpenClose ? `duya_${mapping.meshMac}_openclose` : `duya_${mapping.meshMac}_${actionName}`;
+                    const debounceTime = isOpenClose ? 2000 : 1500;  // 开关码用2秒防抖
+                    const now = Date.now();
+                    const lastTime = node.lastSentTime[cacheKey] || 0;
+                    
+                    if (now - lastTime < debounceTime) {
+                        node.debug(`[Mesh->杜亚] 窗帘 ${actionName} ${debounceTime}ms内防抖跳过`);
+                    } else {
+                        node.lastSentTime[cacheKey] = now;
+                        const hexStr = frame.toString('hex').toUpperCase();
+                        await node.sendRS485Frame(frame);
+                        node.log(`[Mesh->杜亚] 窗帘 ${actionName}, 位置${posForDirection}%, 发送: ${hexStr.match(/.{2}/g).join(' ')}`);
+                    }
+                }
+                
+                node.status({ fill: 'green', shape: 'dot', text: `杜亚同步 ${node.mappings.length}个` });
+                return;
+            }
+            
             // ===== 自定义协议模式 =====
             if (mapping.brand === 'custom' && mapping.customCodes) {
                 const codes = mapping.customCodes;
@@ -521,17 +810,63 @@ module.exports = function(RED) {
                 }
                 // 窗帘类型
                 else if (mapping.device === 'custom_curtain') {
-                    for (const [key, value] of Object.entries(state)) {
-                        if (key === 'position' || key === 'action') {
-                            let hexCode = null;
-                            if (value === 'open' || value === 100) hexCode = codes.open;
-                            else if (value === 'close' || value === 0) hexCode = codes.close;
-                            else if (value === 'stop') hexCode = codes.stop;
-                            
-                            if (hexCode) {
-                                await node.sendCustomCode(hexCode);
-                                node.log(`[Mesh->自定义] 窗帘: ${value}, 发送: ${hexCode}`);
-                            }
+                    node.log(`[Mesh->自定义] 窗帘状态: ${JSON.stringify(state)}`);
+                    
+                    // 优先级：curtainAction > curtainStatus > curtainPosition
+                    // 只发送一次，避免重复
+                    let hexCode = null;
+                    let actionName = '';
+                    
+                    // 1. 优先检查动作命令
+                    if (state.curtainAction !== undefined || state.action !== undefined) {
+                        const action = state.curtainAction || state.action;
+                        if (action === 1 || action === 'open') {
+                            hexCode = codes.open;
+                            actionName = '打开';
+                        } else if (action === 2 || action === 'close') {
+                            hexCode = codes.close;
+                            actionName = '关闭';
+                        } else if (action === 3 || action === 'stop') {
+                            hexCode = codes.stop;
+                            actionName = '停止';
+                        }
+                    }
+                    // 2. 其次检查运行状态
+                    else if (state.curtainStatus !== undefined) {
+                        if (state.curtainStatus === 1) {
+                            hexCode = codes.open;
+                            actionName = '打开(运行中)';
+                        } else if (state.curtainStatus === 2) {
+                            hexCode = codes.close;
+                            actionName = '关闭(运行中)';
+                        } else if (state.curtainStatus === 0 && codes.stop) {
+                            // 0=已停止，发送停止码
+                            hexCode = codes.stop;
+                            actionName = '停止';
+                        }
+                    }
+                    // 3. 最后检查位置（仅在极端位置时）
+                    else if (state.curtainPosition !== undefined) {
+                        if (state.curtainPosition >= 95) {
+                            hexCode = codes.open;
+                            actionName = '打开(位置>=95)';
+                        } else if (state.curtainPosition <= 5) {
+                            hexCode = codes.close;
+                            actionName = '关闭(位置<=5)';
+                        }
+                    }
+                    
+                    if (hexCode) {
+                        // 防抖：500ms内不重复发送相同命令
+                        const cacheKey = `curtain_${mapping.meshMac}_${hexCode}`;
+                        const now = Date.now();
+                        if (node.lastSentTime && node.lastSentTime[cacheKey] && now - node.lastSentTime[cacheKey] < 500) {
+                            node.debug(`[Mesh->自定义] 窗帘 ${actionName} 防抖跳过`);
+                        } else {
+                            if (!node.lastSentTime) node.lastSentTime = {};
+                            node.lastSentTime[cacheKey] = now;
+                            await node.sendCustomCode(hexCode);
+                            node.log(`[Mesh->自定义] 窗帘 ${actionName}, 发送: ${hexCode}`);
                         }
                     }
                 }
@@ -597,17 +932,53 @@ module.exports = function(RED) {
                             node.log(`[Mesh->RS485] 从机${mapping.address} 按键${rs485Channel}: ${value ? '开' : '关'}`);
                         }
                     }
+                    // 空调开关
+                    else if (meshKey === 'acSwitch' && registers && registers.switch) {
+                        const writeValue = value ? (registers.switch.on !== undefined ? registers.switch.on : 1) : 
+                                                   (registers.switch.off !== undefined ? registers.switch.off : 0);
+                        await node.writeModbusRegister(mapping.address, registers.switch, writeValue);
+                        node.log(`[Mesh->RS485] 空调开关: ${value ? '开' : '关'}`);
+                    }
+                    // 目标温度
                     else if ((meshKey === 'targetTemp' || meshKey === 'acTargetTemp') && registers && registers.targetTemp) {
                         await node.writeModbusRegister(mapping.address, registers.targetTemp, value);
-                        node.debug(`[Mesh->RS485] 目标温度: ${value}`);
+                        node.log(`[Mesh->RS485] 目标温度: ${value}°C`);
                     }
+                    // 空调模式 - Mesh值需要转换为RS485值
+                    // Mesh: 0=制冷, 1=制热, 2=送风, 3=除湿
+                    // A5B5: 1=制热, 2=制冷, 4=送风, 8=除湿
                     else if (meshKey === 'acMode' && registers && registers.mode) {
-                        await node.writeModbusRegister(mapping.address, registers.mode, value);
-                        node.debug(`[Mesh->RS485] 模式: ${value}`);
+                        // 反向映射：从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]);
+                            }
+                        }
+                        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) {
-                        await node.writeModbusRegister(mapping.address, registers.fanSpeed, value);
-                        node.debug(`[Mesh->RS485] 风速: ${value}`);
+                        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]);
+                            }
+                        } else {
+                            // 默认直接使用Mesh值
+                            rs485Value = value;
+                        }
+                        await node.writeModbusRegister(mapping.address, registers.fanSpeed, rs485Value);
+                        node.log(`[Mesh->RS485] 空调风速: ${value} -> RS485值${rs485Value}`);
                     }
                     else if (meshKey === 'brightness' && registers && registers.brightness) {
                         await node.writeModbusRegister(mapping.address, registers.brightness, value);
@@ -646,6 +1017,30 @@ module.exports = function(RED) {
 
             const channel = mapping.meshChannel || 1;
             
+            // ===== 杜亚窗帘协议模式 =====
+            if (cmd.duyaMode || mapping.brand === 'duya') {
+                node.log(`[杜亚->Mesh] 设备${mapping.meshMac}, 状态: ${JSON.stringify(state)}`);
+                
+                try {
+                    if (state.curtainAction !== undefined || state.action !== undefined) {
+                        const action = state.curtainAction || (state.action === 'open' ? 1 : state.action === 'close' ? 2 : 3);
+                        const param = Buffer.from([action]);
+                        await node.gateway.sendControl(meshDevice.networkAddress, 0x05, param);
+                        node.log(`[杜亚->Mesh] 窗帘动作: ${action === 1 ? '打开' : action === 2 ? '关闭' : '停止'}`);
+                    } else if (state.curtainPosition !== undefined || state.position !== undefined) {
+                        const pos = state.curtainPosition || state.position;
+                        const param = Buffer.from([pos]);
+                        await node.gateway.sendControl(meshDevice.networkAddress, 0x06, param);
+                        node.log(`[杜亚->Mesh] 窗帘位置: ${pos}%`);
+                    }
+                } catch (err) {
+                    node.error(`[杜亚->Mesh] 写入失败: ${err.message}`);
+                }
+                
+                node.status({ fill: 'blue', shape: 'dot', text: `杜亚同步 ${node.mappings.length}个` });
+                return;
+            }
+            
             // ===== 自定义协议模式 =====
             if (customMode || mapping.brand === 'custom') {
                 node.log(`[自定义->Mesh] 设备${mapping.meshMac}, 通道${channel}, 状态: ${JSON.stringify(state)}`);
@@ -661,14 +1056,16 @@ module.exports = function(RED) {
                         }
                         // 窗帘类型
                         else if (key === 'action' || key === 'position') {
-                            let action = 0x00;  // 停止
+                            // 窗帘动作: 1=打开, 2=关闭, 3=停止
+                            let action = 0x03;  // 停止
                             if (value === 'open') action = 0x01;  // 打开
                             else if (value === 'close') action = 0x02;  // 关闭
-                            else if (value === 'stop') action = 0x00;  // 停止
+                            else if (value === 'stop') action = 0x03;  // 停止
                             
                             const param = Buffer.from([action]);
-                            await node.gateway.sendControl(meshDevice.networkAddress, 0x04, param);
-                            node.log(`[自定义->Mesh] 窗帘: ${value}`);
+                            // 0x05是窗帘动作控制属性
+                            await node.gateway.sendControl(meshDevice.networkAddress, 0x05, param);
+                            node.log(`[自定义->Mesh] 窗帘: ${value} (动作码${action})`);
                         }
                     } catch (err) {
                         node.error(`Mesh写入失败: ${key}=${value}, ${err.message}`);
@@ -698,22 +1095,51 @@ module.exports = function(RED) {
                     else if (key.startsWith('led')) {
                         node.debug(`[RS485] 指示灯${key}: ${value}`);
                     }
+                    // 空调开关 - 0x1B是空调开关属性
+                    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);
+                        node.log(`[RS485->Mesh] 空调开关: ${value ? '开' : '关'}`);
+                    }
+                    // 目标温度 - 0x1C是目标温度属性
                     else if (key === 'targetTemp') {
                         const param = Buffer.from([Math.round(value)]);
                         await node.gateway.sendControl(meshDevice.networkAddress, 0x1C, param);
-                        node.debug(`[RS485->Mesh] 目标温度: ${value}`);
+                        node.log(`[RS485->Mesh] 目标温度: ${value}°C`);
                     }
+                    // 空调模式 - 0x16是模式属性
+                    // RS485: 1=制热, 2=制冷, 4=送风, 8=除湿
+                    // Mesh: 0=制冷, 1=制热, 2=送风, 3=除湿
                     else if (key === 'mode') {
-                        const modeMap = { 'cool': 0, 'heat': 1, 'fan': 2, 'dry': 3 };
-                        const param = Buffer.from([modeMap[value] !== undefined ? modeMap[value] : 0]);
+                        // 从RS485值或字符串转换为Mesh值
+                        let meshMode = 0;
+                        if (typeof value === 'string') {
+                            const modeMap = { 'cool': 0, 'heat': 1, 'fan': 2, 'dry': 3 };
+                            meshMode = modeMap[value] !== undefined ? modeMap[value] : 0;
+                        } 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;
+                        }
+                        const param = Buffer.from([meshMode]);
                         await node.gateway.sendControl(meshDevice.networkAddress, 0x16, param);
-                        node.debug(`[RS485->Mesh] 模式: ${value}`);
+                        node.log(`[RS485->Mesh] 空调模式: RS485值${value} -> Mesh值${meshMode}`);
                     }
+                    // 风速 - 0x1D是风速属性
+                    // RS485: 1=低风, 2=中风, 3=高风
+                    // Mesh: 0=自动, 1=低, 2=中, 3=高
                     else if (key === 'fanSpeed') {
-                        const speedMap = { 'high': 1, 'medium': 2, 'low': 3, 'auto': 4 };
-                        const param = Buffer.from([speedMap[value] !== undefined ? speedMap[value] : 4]);
+                        let meshSpeed = 0;
+                        if (typeof value === 'string') {
+                            const speedMap = { 'low': 1, 'medium': 2, 'high': 3, 'auto': 0 };
+                            meshSpeed = speedMap[value] !== undefined ? speedMap[value] : 0;
+                        } else {
+                            // RS485数值直接对应Mesh值(1=低, 2=中, 3=高)
+                            meshSpeed = value;
+                        }
+                        const param = Buffer.from([meshSpeed]);
                         await node.gateway.sendControl(meshDevice.networkAddress, 0x1D, param);
-                        node.debug(`[RS485->Mesh] 风速: ${value}`);
+                        node.log(`[RS485->Mesh] 空调风速: RS485值${value} -> Mesh值${meshSpeed}`);
                     }
                     else if (key === 'brightness') {
                         const param = Buffer.from([Math.round(value)]);
@@ -815,6 +1241,52 @@ module.exports = function(RED) {
             const hexStr = frame.toString('hex').toUpperCase();
             const hexFormatted = hexStr.match(/.{1,2}/g)?.join(' ') || '';
             
+            // ===== 杜亚窗帘协议检测 =====
+            if (frame[0] === 0x55 && frame.length >= 7) {
+                const duyaData = parseA6B6Frame(frame);
+                if (duyaData) {
+                    // 查找匹配的杜亚映射
+                    for (const mapping of node.mappings) {
+                        if (mapping.brand !== 'duya') continue;
+                        
+                        // 检查2字节地址是否匹配
+                        const mapAddrHigh = mapping.addrHigh || 1;
+                        const mapAddrLow = mapping.addrLow || 1;
+                        
+                        if (duyaData.addrHigh === mapAddrHigh && duyaData.addrLow === mapAddrLow) {
+                            // 防死循环: 1秒内忽略响应
+                            if (node.lastMeshToRS485Time && Date.now() - node.lastMeshToRS485Time < 1000) {
+                                node.debug(`[防循环] 忽略杜亚响应: ${hexFormatted}`);
+                                return;
+                            }
+                            
+                            node.log(`[杜亚->Mesh] 窗帘响应: ${duyaData.action}, 帧: ${hexFormatted}`);
+                            
+                            // 构建Mesh状态
+                            let meshState = {};
+                            if (duyaData.action === 'open') {
+                                meshState = { action: 'open', curtainAction: 1 };
+                            } else if (duyaData.action === 'close') {
+                                meshState = { action: 'close', curtainAction: 2 };
+                            } else if (duyaData.action === 'stop') {
+                                meshState = { action: 'stop', curtainAction: 3 };
+                            } else if (duyaData.action === 'position') {
+                                meshState = { position: duyaData.position, curtainPosition: duyaData.position };
+                            }
+                            
+                            node.queueCommand({
+                                direction: 'modbus-to-mesh',
+                                mapping: mapping,
+                                state: meshState,
+                                duyaMode: true,
+                                timestamp: Date.now()
+                            });
+                            return;
+                        }
+                    }
+                }
+            }
+            
             // 首先检查自定义码匹配（遍历所有映射）
             for (const mapping of node.mappings) {
                 if (mapping.brand === 'custom' && mapping.customCodes) {
@@ -998,6 +1470,7 @@ module.exports = function(RED) {
         // 事件监听 - Mesh网关共享，无冲突
         node.gateway.on('device-list-complete', init);
         node.gateway.on('device-state-changed', handleMeshStateChange);
+        node.gateway.on('curtain-control', handleCurtainControl);  // 窗帘控制立即同步
 
         if (node.gateway.deviceListComplete) {
             init();
@@ -1083,6 +1556,7 @@ module.exports = function(RED) {
             // 移除Mesh网关事件监听器
             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) {
@@ -1163,4 +1637,5 @@ module.exports = function(RED) {
             res.json([]);
         }
     });
+
 };

package/nodes/symi-485-config.js

@@ -114,9 +114,6 @@ module.exports = function(RED) {
 
                     node.client.on('connect', () => {
                         node.connected = true;
-                        // 启用TCP keep-alive，防止连接超时
-                        node.client.setKeepAlive(true, 30000);  // 30秒心跳
-                        node.client.setNoDelay(true);  // 禁用Nagle算法，立即发送
                         node.warn(`[RS485] TCP已连接: ${node.host}:${node.port}`);
                         node.emit('connected');
                     });

package/nodes/symi-gateway.js

@@ -34,39 +34,7 @@ module.exports = function(RED) {
 
         this.log(`Initializing Symi Gateway: ${this.connectionType === 'tcp' ? `${this.host}:${this.port}` : this.serialPort}`);
         
-        // 监听三合一设备检测事件
-        this.deviceManager.on('three-in-one-detected', async (device) => {
-            this.log(`三合一设备被识别，开始查询所有状态: ${device.name}`);
-            try {
-                // 查询环境温湿度（优先）
-                await this.sendControl(device.networkAddress, 0x16, Buffer.from([]));
-                await new Promise(r => setTimeout(r, 100));
-                await this.sendControl(device.networkAddress, 0x17, Buffer.from([]));
-                await new Promise(r => setTimeout(r, 100));
-                // 查询空调状态
-                await this.sendControl(device.networkAddress, 0x1B, Buffer.from([]));
-                await new Promise(r => setTimeout(r, 100));
-                await this.sendControl(device.networkAddress, 0x1C, Buffer.from([]));
-                await new Promise(r => setTimeout(r, 100));
-                await this.sendControl(device.networkAddress, 0x1D, Buffer.from([]));
-                await new Promise(r => setTimeout(r, 100));
-                // 查询新风状态
-                await this.sendControl(device.networkAddress, 0x68, Buffer.from([]));
-                await new Promise(r => setTimeout(r, 100));
-                await this.sendControl(device.networkAddress, 0x69, Buffer.from([]));
-                await new Promise(r => setTimeout(r, 100));
-                await this.sendControl(device.networkAddress, 0x6A, Buffer.from([]));
-                await new Promise(r => setTimeout(r, 100));
-                // 查询地暖状态
-                await this.sendControl(device.networkAddress, 0x6B, Buffer.from([]));
-                await new Promise(r => setTimeout(r, 100));
-                await this.sendControl(device.networkAddress, 0x6C, Buffer.from([]));
-                await new Promise(r => setTimeout(r, 100));
-                this.log(`三合一设备状态查询完成`);
-            } catch (error) {
-                this.warn(`三合一设备状态查询失败: ${error.message}`);
-            }
-        });
+        // 三合一设备检测已在 queryAllDeviceStates 中实现，无需额外事件监听
         
         this.connect();
         
@@ -556,7 +524,24 @@ module.exports = function(RED) {
         
         // 其他控制直接发送
         const frame = this.protocolHandler.buildDeviceControlFrame(networkAddr, attrType, param);
-        return await this.client.sendFrame(frame, 1);
+        const result = await this.client.sendFrame(frame, 1);
+        
+        // 发送窗帘控制命令事件（用于RS485桥接立即同步）
+        // 0x05=窗帘动作(1=开,2=关,3=停), 0x06=窗帘位置
+        if (attrType === 0x05 || attrType === 0x06) {
+            const device = this.deviceManager.getDeviceByAddress(networkAddr);
+            if (device) {
+                this.emit('curtain-control', {
+                    device: device,
+                    mac: device.macAddress,
+                    attrType: attrType,
+                    action: attrType === 0x05 ? param[0] : null,  // 1=开,2=关,3=停
+                    position: attrType === 0x06 ? param[0] : null
+                });
+            }
+        }
+        
+        return result;
     };
 
     SymiGatewayNode.prototype.sendScene = async function(sceneId) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-symi-mesh",
-  "version": "1.6.3",
+  "version": "1.6.5",
   "description": "Node-RED节点集合，用于通过TCP/串口连接Symi蓝牙Mesh网关，支持Home Assistant MQTT Discovery自动发现和云端数据同步",
   "main": "index.js",
   "scripts": {