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

package/README.md

@@ -539,9 +539,38 @@ Mesh 四键开关 第2路 ↔ RS485 六键开关 第5路  地址:2   ✓ 支持
 
 | 品牌 | 支持设备 |
 |-----|---------|
-| 话语前湾 | 空调、地暖、新风、窗帘、1-8键开关 |
+| 话语前湾 | 空调（客厅/主卧/次卧1/次卧2）、地暖、新风、窗帘、1-8键开关 |
+| 通用Modbus | 各类标准Modbus设备 |
+| 自定义协议 | 任意485码匹配（开关/窗帘/场景） |
 
-> 如需扩展其他品牌协议，请联系技术支持
+### 自定义协议模式
+
+当内置协议无法满足需求时，可使用"自定义协议"模式，手动录入RS485十六进制码进行双向匹配：
+
+#### 自定义开关
+- **打开码**：当Mesh开关打开时发送此码，收到此码时触发Mesh开关打开
+- **关闭码**：当Mesh开关关闭时发送此码，收到此码时触发Mesh开关关闭
+
+#### 自定义窗帘
+- **打开码**：Mesh窗帘打开 ↔ RS485打开命令
+- **关闭码**：Mesh窗帘关闭 ↔ RS485关闭命令
+- **停止码**：Mesh窗帘停止 ↔ RS485停止命令
+
+#### 配置示例
+```
+品牌: 自定义协议
+类型: 自定义窗帘
+打开码: 55 02 02 03 01 49 44
+关闭码: 55 02 02 03 02 09 45
+停止码: 55 02 02 03 03 C8 85
+```
+
+#### 工作原理
+1. **Mesh→RS485**：Mesh设备状态变化时，发送对应的自定义码
+2. **RS485→Mesh**：收到的RS485帧与自定义码匹配，触发对应Mesh设备
+3. **防死循环**：500ms内不重复触发，避免Mesh→RS485→Mesh循环
+
+> 自定义码支持任意长度的十六进制字符串，支持空格分隔（如 `55 01 01` 或 `550101`）
 
 ### 注意事项
 
@@ -1032,7 +1061,7 @@ node-red-contrib-symi-mesh/
 
 ## 更新日志
 
-### v1.6.0 (2025-12-03)
+### v1.6.2 (2025-12-05)
 - **MQTT订阅修复**：修复闭包问题导致的设备MAC映射错误，确保HA实体可控
 - **内存泄漏修复**：节点关闭时正确移除gateway事件监听器，防止内存累积
 - **三合一面板完善**：空调/新风/地暖控制和状态反馈全面优化
@@ -1051,8 +1080,8 @@ Copyright (c) 2025 SYMI 亖米
 ## 关于
 
 **作者**: SYMI 亖米
-**版本**: 1.6.0
+**版本**: 1.6.2
 **协议**: 蓝牙MESH网关（初级版）串口协议V1.0
-**最后更新**: 2025-12-03
+**最后更新**: 2025-12-05
 **仓库**: https://github.com/symi-daguo/node-red-contrib-symi-mesh
 **npm包**: https://www.npmjs.com/package/node-red-contrib-symi-mesh

package/nodes/symi-485-bridge.html

@@ -159,7 +159,7 @@
                 }
 
                 mappings.forEach(function(m, idx) {
-                    var row = $('<div class="mapping-row" data-idx="' + idx + '"></div>');
+                    var row = $('<div class="mapping-row" data-idx="' + idx + '" style="flex-wrap:wrap;"></div>');
                     row.html(
                         '<div class="mesh-col">' +
                         '  <select class="mesh-select">' + getMeshOptions(m.meshMac) + '</select>' +
@@ -179,6 +179,10 @@
                         '<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);
+                    // 如果是自定义协议，显示自定义码输入框
+                    if (m.brand === 'custom' && m.device) {
+                        updateCustomCodesVisibility(row, m.brand, m.device, idx);
+                    }
                 });
 
                 bindEvents();
@@ -194,9 +198,11 @@
                     var brandId = $(this).val();
                     row.find('.device-select').html(getDeviceOptions(brandId, ''));
                     row.find('.rs485-ch-wrap').empty();
+                    row.find('.custom-codes-row').remove();  // 移除自定义码区域
                     mappings[idx].brand = brandId;
                     mappings[idx].device = '';
                     mappings[idx].rs485Channel = 1;
+                    mappings[idx].customCodes = {};
                 });
 
                 container.find('.device-select').off('change').on('change', function() {
@@ -208,6 +214,8 @@
                     // 更新RS485按键选择
                     row.find('.rs485-ch-wrap').html(getRS485ChannelOptions(brandId, deviceId, 1));
                     mappings[idx].rs485Channel = 1;
+                    // 显示/隐藏自定义码输入区域
+                    updateCustomCodesVisibility(row, brandId, deviceId, idx);
                     bindEvents(); // 重新绑定新添加的元素事件
                 });
 
@@ -242,11 +250,73 @@
                     mappings.splice(idx, 1);
                     renderMappings();
                 });
+
+                // 自定义码输入事件
+                container.find('.custom-code-on').off('change').on('change', function() {
+                    var idx = $(this).closest('.mapping-row').data('idx');
+                    mappings[idx].customCodes = mappings[idx].customCodes || {};
+                    mappings[idx].customCodes.on = $(this).val();
+                });
+                container.find('.custom-code-off').off('change').on('change', function() {
+                    var idx = $(this).closest('.mapping-row').data('idx');
+                    mappings[idx].customCodes = mappings[idx].customCodes || {};
+                    mappings[idx].customCodes.off = $(this).val();
+                });
+                container.find('.custom-code-open').off('change').on('change', function() {
+                    var idx = $(this).closest('.mapping-row').data('idx');
+                    mappings[idx].customCodes = mappings[idx].customCodes || {};
+                    mappings[idx].customCodes.open = $(this).val();
+                });
+                container.find('.custom-code-close').off('change').on('change', function() {
+                    var idx = $(this).closest('.mapping-row').data('idx');
+                    mappings[idx].customCodes = mappings[idx].customCodes || {};
+                    mappings[idx].customCodes.close = $(this).val();
+                });
+                container.find('.custom-code-stop').off('change').on('change', function() {
+                    var idx = $(this).closest('.mapping-row').data('idx');
+                    mappings[idx].customCodes = mappings[idx].customCodes || {};
+                    mappings[idx].customCodes.stop = $(this).val();
+                });
+                container.find('.custom-code-trigger').off('change').on('change', function() {
+                    var idx = $(this).closest('.mapping-row').data('idx');
+                    mappings[idx].customCodes = mappings[idx].customCodes || {};
+                    mappings[idx].customCodes.trigger = $(this).val();
+                });
+            }
+
+            // 更新自定义码输入区域的显示
+            function updateCustomCodesVisibility(row, brandId, deviceId, idx) {
+                row.find('.custom-codes-row').remove();
+                if (brandId !== 'custom') return;
+                
+                var codes = mappings[idx].customCodes || {};
+                var html = '<div class="custom-codes-row" style="width:100%;padding:8px;margin-top:6px;background:#fff8e1;border:1px dashed #ffa726;border-radius:4px;">';
+                html += '<div style="font-size:11px;color:#f57c00;margin-bottom:6px;"><i class="fa fa-code"></i> 自定义RS485码（十六进制，如: 55 01 01 03 01 B9 00）</div>';
+                
+                if (deviceId === 'custom_switch') {
+                    html += '<div style="display:flex;gap:8px;flex-wrap:wrap;">';
+                    html += '<label style="font-size:11px;">打开码: <input type="text" class="custom-code-on" value="' + (codes.on || '') + '" placeholder="55 01 01..." style="width:150px;padding:2px 4px;border:1px solid #ffb74d;border-radius:2px;font-size:11px;font-family:monospace;"></label>';
+                    html += '<label style="font-size:11px;">关闭码: <input type="text" class="custom-code-off" value="' + (codes.off || '') + '" placeholder="55 01 02..." style="width:150px;padding:2px 4px;border:1px solid #ffb74d;border-radius:2px;font-size:11px;font-family:monospace;"></label>';
+                    html += '</div>';
+                } else if (deviceId === 'custom_curtain') {
+                    html += '<div style="display:flex;gap:8px;flex-wrap:wrap;">';
+                    html += '<label style="font-size:11px;">打开码: <input type="text" class="custom-code-open" value="' + (codes.open || '') + '" placeholder="55 02 02 03 01..." style="width:150px;padding:2px 4px;border:1px solid #ffb74d;border-radius:2px;font-size:11px;font-family:monospace;"></label>';
+                    html += '<label style="font-size:11px;">关闭码: <input type="text" class="custom-code-close" value="' + (codes.close || '') + '" placeholder="55 02 02 03 02..." style="width:150px;padding:2px 4px;border:1px solid #ffb74d;border-radius:2px;font-size:11px;font-family:monospace;"></label>';
+                    html += '<label style="font-size:11px;">停止码: <input type="text" class="custom-code-stop" value="' + (codes.stop || '') + '" placeholder="55 02 02 03 03..." style="width:150px;padding:2px 4px;border:1px solid #ffb74d;border-radius:2px;font-size:11px;font-family:monospace;"></label>';
+                    html += '</div>';
+                } else if (deviceId === 'custom_scene') {
+                    html += '<div style="display:flex;gap:8px;">';
+                    html += '<label style="font-size:11px;">触发码: <input type="text" class="custom-code-trigger" value="' + (codes.trigger || '') + '" placeholder="55 01 01..." style="width:200px;padding:2px 4px;border:1px solid #ffb74d;border-radius:2px;font-size:11px;font-family:monospace;"></label>';
+                    html += '</div>';
+                }
+                html += '</div>';
+                row.append(html);
+                bindEvents();
             }
 
             // 添加新映射
             $('#btn-add-mapping').on('click', function() {
-                mappings.push({ meshMac: '', meshChannel: 0, brand: '', device: '', address: 1, rs485Channel: 1 });
+                mappings.push({ meshMac: '', meshChannel: 0, brand: '', device: '', address: 1, rs485Channel: 1, customCodes: {} });
                 renderMappings();
             });
 
@@ -256,14 +326,31 @@
         oneditsave: function() {
             var mappings = [];
             $('#mapping-list .mapping-row').each(function() {
-                mappings.push({
+                var m = {
                     meshMac: $(this).find('.mesh-select').val() || '',
                     meshChannel: parseInt($(this).find('.mesh-channel').val()) || 1,
                     brand: $(this).find('.brand-select').val() || '',
                     device: $(this).find('.device-select').val() || '',
                     address: parseInt($(this).find('.addr-input').val()) || 1,
                     rs485Channel: parseInt($(this).find('.rs485-channel').val()) || 1
-                });
+                };
+                // 保存自定义码
+                if (m.brand === 'custom') {
+                    m.customCodes = {};
+                    var on = $(this).find('.custom-code-on').val();
+                    var off = $(this).find('.custom-code-off').val();
+                    var open = $(this).find('.custom-code-open').val();
+                    var close = $(this).find('.custom-code-close').val();
+                    var stop = $(this).find('.custom-code-stop').val();
+                    var trigger = $(this).find('.custom-code-trigger').val();
+                    if (on) m.customCodes.on = on;
+                    if (off) m.customCodes.off = off;
+                    if (open) m.customCodes.open = open;
+                    if (close) m.customCodes.close = close;
+                    if (stop) m.customCodes.stop = stop;
+                    if (trigger) m.customCodes.trigger = trigger;
+                }
+                mappings.push(m);
             });
             this.mappings = JSON.stringify(mappings);
         }

package/nodes/symi-485-bridge.js

@@ -234,6 +234,30 @@ module.exports = function(RED) {
                     'fresh_air': { name: '新风', type: 'fan', registers: { switch: { address: 0x0000, type: 'coil' }, fanSpeed: { address: 0x0001, type: 'holding' } } },
                     'scene': { name: '场景', type: 'scene', registers: { trigger: { address: 0x0000, type: 'holding' } } }
                 }
+            },
+            // ===== 自定义协议 - 用户可录入任意RS485码 =====
+            'custom': {
+                name: '自定义协议',
+                devices: {
+                    'custom_switch': {
+                        name: '自定义开关',
+                        type: 'switch',
+                        customMode: true,  // 标记为自定义模式
+                        // 用户需要在映射中配置: customCodes.on, customCodes.off
+                    },
+                    'custom_curtain': {
+                        name: '自定义窗帘',
+                        type: 'cover',
+                        customMode: true,
+                        // 用户需要在映射中配置: customCodes.open, customCodes.close, customCodes.stop
+                    },
+                    'custom_scene': {
+                        name: '自定义场景',
+                        type: 'scene',
+                        customMode: true,
+                        // 用户需要在映射中配置: customCodes.trigger
+                    }
+                }
             }
         }
     };
@@ -271,32 +295,50 @@ module.exports = function(RED) {
         node.lastSyncTime = 0;
         node.pendingVerify = false;
 
+        // RS485连接信息
+        const rs485Info = node.rs485Config.connectionType === 'tcp' 
+            ? `${node.rs485Config.host}:${node.rs485Config.port}`
+            : node.rs485Config.serialPort;
+
         if (node.mappings.length === 0) {
             node.status({ fill: 'grey', shape: 'ring', text: '请添加实体映射' });
         } else {
-            node.status({ fill: 'yellow', shape: 'ring', text: '连接中...' });
+            node.status({ fill: 'yellow', shape: 'ring', text: `连接中 ${rs485Info}...` });
         }
 
-        // 注册到RS485配置节点
-        node.rs485Config.register(node);
+        // 【重要】先绑定事件监听器，再注册到配置节点
+        // 定义事件处理函数（用于清理时移除）
+        const onRS485Connected = () => {
+            node.log(`[RS485 Bridge] 已连接到 ${rs485Info}`);
+            node.status({ fill: 'green', shape: 'dot', text: `已连接 ${rs485Info} (${node.mappings.length}个映射)` });
+        };
 
-        // 监听RS485连接事件
-        node.rs485Config.on('connected', () => {
-            node.status({ fill: 'green', shape: 'dot', text: `已连接 ${node.mappings.length}个映射` });
-        });
+        const onRS485Disconnected = () => {
+            node.warn(`[RS485 Bridge] 已断开 ${rs485Info}`);
+            node.status({ fill: 'yellow', shape: 'ring', text: `已断开 ${rs485Info}` });
+        };
 
-        node.rs485Config.on('disconnected', () => {
-            node.status({ fill: 'yellow', shape: 'ring', text: '已断开' });
-        });
+        const onRS485Error = (err) => {
+            node.error(`[RS485 Bridge] 连接错误 ${rs485Info}: ${err.message}`);
+            node.status({ fill: 'red', shape: 'ring', text: `错误 ${rs485Info}` });
+        };
 
-        node.rs485Config.on('error', (err) => {
-            node.status({ fill: 'red', shape: 'ring', text: '连接错误' });
-        });
+        const onRS485Frame = (frame) => {
+            node.parseRS485Frame(frame);  // 使用新的解析函数，支持自定义码
+        };
 
-        // 监听RS485接收帧
-        node.rs485Config.on('frame', (frame) => {
-            node.parseModbusResponse(frame);
-        });
+        // 绑定事件监听器
+        node.rs485Config.on('connected', onRS485Connected);
+        node.rs485Config.on('disconnected', onRS485Disconnected);
+        node.rs485Config.on('error', onRS485Error);
+        node.rs485Config.on('frame', onRS485Frame);
+
+        // 保存处理函数引用，用于清理
+        node._rs485Handlers = { onRS485Connected, onRS485Disconnected, onRS485Error, onRS485Frame };
+
+        // 现在注册到RS485配置节点（这会触发连接）
+        node.rs485Config.register(node);
+        node.log(`[RS485 Bridge] 已注册到RS485配置: ${rs485Info}`);
 
         // 查找Mesh设备的映射配置
         node.findMeshMapping = function(mac, channel) {
@@ -324,23 +366,52 @@ module.exports = function(RED) {
             
             const mac = eventData.device.macAddress;
             const state = eventData.state || {};
-            const channel = state.channel || 0;
+            // channel可能是0-based或1-based，需要兼容处理
+            // Mesh事件中channel通常是0-based，UI配置的meshChannel是1-based
+            const eventChannel = state.channel !== undefined ? state.channel : -1;
             
-            // 查找匹配的映射
-            const mapping = node.findMeshMapping(mac, channel);
-            if (!mapping) return;
+            node.debug(`[Mesh事件] MAC=${mac}, channel=${eventChannel}, state=${JSON.stringify(state)}`);
             
-            const registers = node.getRegistersForMapping(mapping);
-            if (!registers) return;
-
-            node.log(`[Mesh->RS485] ${eventData.device.name} 状态变化`);
-            node.queueCommand({ 
-                direction: 'mesh-to-modbus', 
-                mapping: mapping,
-                registers: registers,
-                state: state, 
-                timestamp: Date.now() 
-            });
+            // 查找匹配的映射 - 遍历所有映射找到MAC匹配的
+            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匹配
+                
+                if (!matchChannel) continue;
+                
+                const registers = node.getRegistersForMapping(mapping);
+                
+                node.log(`[Mesh->RS485] ${eventData.device.name} 通道${configChannel} 状态变化: ${JSON.stringify(state)}`);
+                
+                // 输出调试信息到节点输出端口
+                node.send({
+                    topic: 'mesh-state-change',
+                    payload: {
+                        direction: 'Mesh→RS485',
+                        device: eventData.device.name,
+                        mac: mac,
+                        channel: configChannel,
+                        state: state
+                    },
+                    timestamp: new Date().toISOString()
+                });
+                
+                node.queueCommand({ 
+                    direction: 'mesh-to-modbus', 
+                    mapping: mapping,
+                    registers: registers,
+                    state: state, 
+                    timestamp: Date.now() 
+                });
+                
+                break; // 找到匹配的映射就停止
+            }
         };
 
         // RS485 device state change handler (event-driven)
@@ -423,35 +494,148 @@ module.exports = function(RED) {
             // 这是安全机制，不是轮询
         };
 
-        // Mesh -> Modbus sync
+        // Mesh -> Modbus/Custom sync
         node.syncMeshToModbus = async function(cmd) {
             const { mapping, registers, state } = cmd;
-            const stateMapping = {
-                'switch': 'switch', 'acSwitch': 'switch',
-                'targetTemp': 'targetTemp', 'acTargetTemp': 'targetTemp',
-                'acMode': 'mode', 'acFanSpeed': 'fanSpeed',
-                'brightness': 'brightness'
-            };
+            
+            // 记录发送时间（用于防死循环）
+            node.lastMeshToRS485Time = Date.now();
+            
+            // ===== 自定义协议模式 =====
+            if (mapping.brand === 'custom' && mapping.customCodes) {
+                const codes = mapping.customCodes;
+                
+                node.log(`[Mesh->自定义] 设备${mapping.device}, 状态: ${JSON.stringify(state)}`);
+                
+                // 开关类型
+                if (mapping.device === 'custom_switch') {
+                    for (const [key, value] of Object.entries(state)) {
+                        if (key === 'switch' || key === 'acSwitch') {
+                            const hexCode = value ? codes.on : codes.off;
+                            if (hexCode) {
+                                await node.sendCustomCode(hexCode);
+                                node.log(`[Mesh->自定义] 开关: ${value ? '开' : '关'}, 发送: ${hexCode}`);
+                            }
+                        }
+                    }
+                }
+                // 窗帘类型
+                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}`);
+                            }
+                        }
+                    }
+                }
+                // 场景类型
+                else if (mapping.device === 'custom_scene') {
+                    if (state.trigger && codes.trigger) {
+                        await node.sendCustomCode(codes.trigger);
+                        node.log(`[Mesh->自定义] 场景触发, 发送: ${codes.trigger}`);
+                    }
+                }
+                
+                node.status({ fill: 'green', shape: 'dot', text: `自定义同步 ${node.mappings.length}个` });
+                return;
+            }
+            
+            // ===== 标准Modbus协议模式 =====
+            const rs485Channel = mapping.rs485Channel || 1;  // RS485端的通道号
+            const meshChannel = mapping.meshChannel || 1;    // Mesh端的通道号
+            node.log(`[Mesh->RS485] 同步到从机${mapping.address}, Mesh通道${meshChannel}->RS485通道${rs485Channel}, 状态: ${JSON.stringify(state)}`);
 
             for (const [meshKey, value] of Object.entries(state)) {
-                const regKey = stateMapping[meshKey];
-                // Only sync if RS485 device has this register (partial sync support)
-                if (regKey && registers[regKey]) {
-                    try {
-                        await node.writeModbusRegister(mapping.address, registers[regKey], value);
-                        node.debug(`Mesh->RS485@${mapping.address}: ${meshKey}=${value}`);
-                    } catch (err) {
-                        node.error(`RS485写入失败: ${regKey}=${value}, ${err.message}`);
+                try {
+                    // 处理开关状态 - Mesh的switch_N字段对应RS485的switchN (0x1031-0x1036)
+                    // 只处理按键寄存器，不处理指示灯寄存器
+                    const switchMatch = meshKey.match(/^switch_(\d+)$/);
+                    if (switchMatch) {
+                        const meshSwitchChannel = parseInt(switchMatch[1]);
+                        // 只处理配置的Mesh通道
+                        if (meshSwitchChannel !== meshChannel) continue;
+                        
+                        // RS485端使用配置的rs485Channel (对应0x1031-0x1036)
+                        const switchRegKey = `switch${rs485Channel}`;
+                        
+                        if (registers && registers[switchRegKey]) {
+                            const writeValue = value ? (registers[switchRegKey].on || 1) : (registers[switchRegKey].off || 0);
+                            await node.writeModbusRegister(mapping.address, registers[switchRegKey], writeValue);
+                            
+                            // 输出发送的帧信息
+                            node.send({
+                                topic: 'rs485-tx',
+                                payload: {
+                                    direction: 'Mesh→RS485',
+                                    slaveAddr: mapping.address,
+                                    register: `0x${registers[switchRegKey].address.toString(16).toUpperCase()}`,
+                                    value: writeValue,
+                                    action: value ? '开' : '关'
+                                },
+                                timestamp: new Date().toISOString()
+                            });
+                            
+                            node.log(`[Mesh->RS485] 从机${mapping.address} 按键${rs485Channel} (0x${registers[switchRegKey].address.toString(16)}): ${value ? '开' : '关'}`);
+                        }
+                        continue;
+                    }
+                    
+                    // 兼容旧格式: switch, acSwitch
+                    if (meshKey === 'switch' || meshKey === 'acSwitch') {
+                        const switchRegKey = `switch${rs485Channel}`;
+                        
+                        if (registers && registers[switchRegKey]) {
+                            const writeValue = value ? (registers[switchRegKey].on || 1) : (registers[switchRegKey].off || 0);
+                            await node.writeModbusRegister(mapping.address, registers[switchRegKey], writeValue);
+                            node.log(`[Mesh->RS485] 从机${mapping.address} 按键${rs485Channel}: ${value ? '开' : '关'}`);
+                        }
                     }
+                    else if ((meshKey === 'targetTemp' || meshKey === 'acTargetTemp') && registers && registers.targetTemp) {
+                        await node.writeModbusRegister(mapping.address, registers.targetTemp, value);
+                        node.debug(`[Mesh->RS485] 目标温度: ${value}`);
+                    }
+                    else if (meshKey === 'acMode' && registers && registers.mode) {
+                        await node.writeModbusRegister(mapping.address, registers.mode, value);
+                        node.debug(`[Mesh->RS485] 模式: ${value}`);
+                    }
+                    else if (meshKey === 'acFanSpeed' && registers && registers.fanSpeed) {
+                        await node.writeModbusRegister(mapping.address, registers.fanSpeed, value);
+                        node.debug(`[Mesh->RS485] 风速: ${value}`);
+                    }
+                    else if (meshKey === 'brightness' && registers && registers.brightness) {
+                        await node.writeModbusRegister(mapping.address, registers.brightness, value);
+                        node.debug(`[Mesh->RS485] 亮度: ${value}`);
+                    }
+                } catch (err) {
+                    node.error(`RS485写入失败: ${meshKey}=${value}, ${err.message}`);
                 }
             }
 
             node.status({ fill: 'green', shape: 'dot', text: `同步 ${node.mappings.length}个映射` });
         };
 
-        // Modbus -> Mesh sync
+        // 发送自定义十六进制码
+        node.sendCustomCode = async function(hexCode) {
+            if (!hexCode) return;
+            const hexStr = hexCode.replace(/\s/g, '');
+            if (!/^[0-9A-Fa-f]+$/.test(hexStr)) {
+                node.warn(`无效的十六进制码: ${hexCode}`);
+                return;
+            }
+            const frame = Buffer.from(hexStr, 'hex');
+            await node.sendRS485Frame(frame);
+        };
+
+        // Modbus/Custom -> Mesh sync
         node.syncModbusToMesh = async function(cmd) {
-            const { mapping, registers, state } = cmd;
+            const { mapping, registers, state, customMode } = cmd;
             
             // 查找Mesh设备
             const meshDevice = node.gateway.getDevice(mapping.meshMac);
@@ -460,38 +644,85 @@ module.exports = function(RED) {
                 return;
             }
 
-            const attrMapping = {
-                'switch': { attrType: 0x02, param: (v) => Buffer.from([v ? 0x02 : 0x01]) },
-                'targetTemp': { attrType: 0x1C, param: (v) => Buffer.from([Math.round(v)]) },
-                'mode': {
-                    attrType: 0x16,
-                    param: (v) => {
-                        const map = { 'cool': 0, 'heat': 1, 'fan': 2, 'dry': 3 };
-                        return Buffer.from([map[v] !== undefined ? map[v] : 0]);
-                    }
-                },
-                'fanSpeed': {
-                    attrType: 0x1D,
-                    param: (v) => {
-                        const map = { 'high': 1, 'medium': 2, 'low': 3, 'auto': 4 };
-                        return Buffer.from([map[v] !== undefined ? map[v] : 4]);
-                    }
-                },
-                'brightness': { attrType: 0x03, param: (v) => Buffer.from([Math.round(v)]) }
-            };
-
-            for (const [key, value] of Object.entries(state)) {
-                // 仅在Mesh设备支持此属性时同步
-                const m = attrMapping[key];
-                if (m) {
+            const channel = mapping.meshChannel || 1;
+            
+            // ===== 自定义协议模式 =====
+            if (customMode || mapping.brand === 'custom') {
+                node.log(`[自定义->Mesh] 设备${mapping.meshMac}, 通道${channel}, 状态: ${JSON.stringify(state)}`);
+                
+                for (const [key, value] of Object.entries(state)) {
                     try {
-                        const param = typeof m.param === 'function' ? m.param(value) : m.param;
-                        await node.gateway.sendControl(meshDevice.networkAddress, m.attrType, param);
-                        node.debug(`RS485@${mapping.address}->Mesh: ${key}=${value}`);
+                        // 开关类型
+                        if (key === 'switch') {
+                            const onOff = value ? 0x02 : 0x01;
+                            const param = Buffer.from([channel - 1, onOff]);
+                            await node.gateway.sendControl(meshDevice.networkAddress, 0x02, param);
+                            node.log(`[自定义->Mesh] 开关${channel}: ${value ? '开' : '关'}`);
+                        }
+                        // 窗帘类型
+                        else if (key === 'action' || key === 'position') {
+                            let action = 0x00;  // 停止
+                            if (value === 'open') action = 0x01;  // 打开
+                            else if (value === 'close') action = 0x02;  // 关闭
+                            else if (value === 'stop') action = 0x00;  // 停止
+                            
+                            const param = Buffer.from([action]);
+                            await node.gateway.sendControl(meshDevice.networkAddress, 0x04, param);
+                            node.log(`[自定义->Mesh] 窗帘: ${value}`);
+                        }
                     } catch (err) {
                         node.error(`Mesh写入失败: ${key}=${value}, ${err.message}`);
                     }
                 }
+                
+                node.status({ fill: 'blue', shape: 'dot', text: `自定义同步 ${node.mappings.length}个` });
+                return;
+            }
+
+            // ===== 标准Modbus协议模式 =====
+            node.log(`[RS485->Mesh] 同步到设备 ${mapping.meshMac}, 通道${channel}, 状态: ${JSON.stringify(state)}`);
+
+            for (const [key, value] of Object.entries(state)) {
+                try {
+                    // 处理开关类型 (switch1, switch2, ... 或 led1, led2, ...)
+                    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]);
+                        
+                        await node.gateway.sendControl(meshDevice.networkAddress, 0x02, param);
+                        node.log(`[RS485->Mesh] 开关${ch}: ${value ? '开' : '关'}`);
+                    }
+                    else if (key.startsWith('led')) {
+                        node.debug(`[RS485] 指示灯${key}: ${value}`);
+                    }
+                    else if (key === 'targetTemp') {
+                        const param = Buffer.from([Math.round(value)]);
+                        await node.gateway.sendControl(meshDevice.networkAddress, 0x1C, param);
+                        node.debug(`[RS485->Mesh] 目标温度: ${value}`);
+                    }
+                    else if (key === 'mode') {
+                        const modeMap = { 'cool': 0, 'heat': 1, 'fan': 2, 'dry': 3 };
+                        const param = Buffer.from([modeMap[value] !== undefined ? modeMap[value] : 0]);
+                        await node.gateway.sendControl(meshDevice.networkAddress, 0x16, param);
+                        node.debug(`[RS485->Mesh] 模式: ${value}`);
+                    }
+                    else if (key === 'fanSpeed') {
+                        const speedMap = { 'high': 1, 'medium': 2, 'low': 3, 'auto': 4 };
+                        const param = Buffer.from([speedMap[value] !== undefined ? speedMap[value] : 4]);
+                        await node.gateway.sendControl(meshDevice.networkAddress, 0x1D, param);
+                        node.debug(`[RS485->Mesh] 风速: ${value}`);
+                    }
+                    else if (key === 'brightness') {
+                        const param = Buffer.from([Math.round(value)]);
+                        await node.gateway.sendControl(meshDevice.networkAddress, 0x03, param);
+                        node.debug(`[RS485->Mesh] 亮度: ${value}`);
+                    }
+                } catch (err) {
+                    node.error(`Mesh写入失败: ${key}=${value}, ${err.message}`);
+                }
             }
 
             node.status({ fill: 'blue', shape: 'dot', text: `同步 ${node.mappings.length}个映射` });
@@ -555,30 +786,160 @@ module.exports = function(RED) {
                 node.warn('RS485未连接，无法发送数据');
                 return;
             }
-            await node.rs485Config.send(frame);
-            node.debug(`发送RS485帧: ${frame.toString('hex')}`);
+            try {
+                const hexStr = frame.toString('hex').toUpperCase().match(/.{1,2}/g)?.join(' ') || '';
+                node.log(`[RS485 TX] 发送帧: ${hexStr}`);
+                
+                await node.rs485Config.send(frame);
+                
+                // 输出到节点端口
+                node.send({
+                    topic: 'rs485-frame-tx',
+                    payload: {
+                        direction: 'TX',
+                        hex: hexStr,
+                        slaveAddr: frame[0],
+                        funcCode: frame[1]
+                    },
+                    timestamp: new Date().toISOString()
+                });
+            } catch (err) {
+                node.error(`RS485发送失败: ${err.message}`);
+            }
         };
 
-        // 解析Modbus响应
+        // 解析原始RS485帧 - 支持标准Modbus和自定义码匹配
+        node.parseRS485Frame = function(frame) {
+            if (frame.length < 4) return;
+            
+            const hexStr = frame.toString('hex').toUpperCase();
+            const hexFormatted = hexStr.match(/.{1,2}/g)?.join(' ') || '';
+            
+            // 首先检查自定义码匹配（遍历所有映射）
+            for (const mapping of node.mappings) {
+                if (mapping.brand === 'custom' && mapping.customCodes) {
+                    const codes = mapping.customCodes;
+                    let matchedAction = null;
+                    
+                    // 开关类型：匹配on/off
+                    if (mapping.device === 'custom_switch') {
+                        if (codes.on && hexStr.includes(codes.on.replace(/\s/g, '').toUpperCase())) {
+                            matchedAction = { switch: true };
+                        } else if (codes.off && hexStr.includes(codes.off.replace(/\s/g, '').toUpperCase())) {
+                            matchedAction = { switch: false };
+                        }
+                    }
+                    // 窗帘类型：匹配open/close/stop
+                    else if (mapping.device === 'custom_curtain') {
+                        if (codes.open && hexStr.includes(codes.open.replace(/\s/g, '').toUpperCase())) {
+                            matchedAction = { position: 'open', action: 'open' };
+                        } else if (codes.close && hexStr.includes(codes.close.replace(/\s/g, '').toUpperCase())) {
+                            matchedAction = { position: 'close', action: 'close' };
+                        } else if (codes.stop && hexStr.includes(codes.stop.replace(/\s/g, '').toUpperCase())) {
+                            matchedAction = { position: 'stop', action: 'stop' };
+                        }
+                    }
+                    // 场景类型：匹配trigger
+                    else if (mapping.device === 'custom_scene') {
+                        if (codes.trigger && hexStr.includes(codes.trigger.replace(/\s/g, '').toUpperCase())) {
+                            matchedAction = { trigger: true };
+                        }
+                    }
+                    
+                    if (matchedAction) {
+                        // 防死循环：检查是否刚刚从Mesh发送过来
+                        if (node.lastMeshToRS485Time && Date.now() - node.lastMeshToRS485Time < 500) {
+                            node.debug(`[防循环] 忽略刚刚同步的帧: ${hexFormatted}`);
+                            return;
+                        }
+                        
+                        node.log(`[自定义码匹配] ${mapping.device}: ${JSON.stringify(matchedAction)}, 帧: ${hexFormatted}`);
+                        
+                        // 输出调试信息到节点输出端口
+                        node.send({
+                            topic: 'custom-code-match',
+                            payload: {
+                                direction: 'RS485→Mesh(自定义)',
+                                device: mapping.device,
+                                meshMac: mapping.meshMac,
+                                action: matchedAction,
+                                hex: hexFormatted
+                            },
+                            timestamp: new Date().toISOString()
+                        });
+                        
+                        node.queueCommand({
+                            direction: 'modbus-to-mesh',
+                            mapping: mapping,
+                            registers: null,
+                            state: matchedAction,
+                            customMode: true,
+                            timestamp: Date.now()
+                        });
+                        return; // 匹配到自定义码就不再继续
+                    }
+                }
+            }
+            
+            // 标准Modbus解析
+            node.parseModbusResponse(frame);
+        };
+
+        // 解析Modbus响应/上报帧（标准Modbus协议）
         node.parseModbusResponse = function(frame) {
+            if (frame.length < 6) return;
+            
             const slaveAddr = frame[0];
             const fc = frame[1];
             
             // 查找对应的映射
             const mapping = node.findRS485Mapping(slaveAddr);
-            if (!mapping) return;
+            if (!mapping) {
+                node.debug(`未找到从机${slaveAddr}的映射配置`);
+                return;
+            }
+
+            // 自定义模式不走标准Modbus解析
+            if (mapping.brand === 'custom') return;
 
             const registers = node.getRegistersForMapping(mapping);
-            if (!registers) return;
+            if (!registers) {
+                node.debug(`未找到设备${mapping.device}的寄存器定义`);
+                return;
+            }
+
+            // 防死循环：检查是否刚刚从Mesh发送过来
+            if (node.lastMeshToRS485Time && Date.now() - node.lastMeshToRS485Time < 500) {
+                node.debug(`[防循环] 忽略刚刚同步的Modbus帧`);
+                return;
+            }
 
             // 根据功能码解析数据
             let state = {};
-            if (fc === 0x03 || fc === 0x04) {
-                // 读寄存器响应
+            
+            if (fc === 0x06 || fc === 0x10) {
+                // 写单寄存器响应/写多寄存器响应 - 这是设备主动上报或写响应
+                const regAddr = frame.readUInt16BE(2);
+                const value = frame.readUInt16BE(4);
+                
+                // 查找匹配的寄存器定义
+                for (const [key, reg] of Object.entries(registers)) {
+                    if (reg.address === regAddr) {
+                        if (key.startsWith('switch') || key.startsWith('led')) {
+                            state[key] = value === (reg.on || 1);
+                        } else if (reg.map) {
+                            state[key] = reg.map[value] || value;
+                        } else {
+                            state[key] = value;
+                        }
+                        node.log(`[RS485] 从机${slaveAddr} 寄存器0x${regAddr.toString(16).toUpperCase()}: ${key}=${value}`);
+                        break;
+                    }
+                }
+            } else if (fc === 0x03 || fc === 0x04) {
                 const byteCount = frame[2];
                 for (let i = 0; i < byteCount / 2; i++) {
                     const value = frame.readUInt16BE(3 + i * 2);
-                    // 根据寄存器映射解析
                     for (const [key, reg] of Object.entries(registers)) {
                         if (reg.map) {
                             state[key] = reg.map[value] || value;
@@ -587,10 +948,32 @@ module.exports = function(RED) {
                         }
                     }
                 }
+            } else if (fc === 0x20) {
+                if (frame.length >= 9) {
+                    const startReg = frame.readUInt16BE(2);
+                    const count = frame.readUInt16BE(4);
+                    node.debug(`[RS485] 从机${slaveAddr} 自定义上报: 起始0x${startReg.toString(16)}, 数量${count}`);
+                }
             }
 
             if (Object.keys(state).length > 0) {
-                node.log(`[RS485->Mesh] 设备@${slaveAddr} 状态: ${JSON.stringify(state)}`);
+                node.log(`[RS485->Mesh] 设备@${slaveAddr} 状态变化: ${JSON.stringify(state)}`);
+                
+                // 输出调试信息到节点输出端口
+                node.send({
+                    topic: 'rs485-state-change',
+                    payload: {
+                        direction: 'RS485→Mesh',
+                        slaveAddr: slaveAddr,
+                        funcCode: fc,
+                        brand: mapping.brand,
+                        device: mapping.device,
+                        meshMac: mapping.meshMac,
+                        state: state
+                    },
+                    timestamp: new Date().toISOString()
+                });
+                
                 node.queueCommand({
                     direction: 'modbus-to-mesh',
                     mapping: mapping,
@@ -697,13 +1080,20 @@ module.exports = function(RED) {
 
         // 清理
         node.on('close', (done) => {
+            // 移除Mesh网关事件监听器
             node.gateway.removeListener('device-list-complete', init);
             node.gateway.removeListener('device-state-changed', handleMeshStateChange);
             
-            // 注销RS485配置节点
-            if (node.rs485Config) {
+            // 移除RS485配置节点事件监听器
+            if (node.rs485Config && node._rs485Handlers) {
+                node.rs485Config.removeListener('connected', node._rs485Handlers.onRS485Connected);
+                node.rs485Config.removeListener('disconnected', node._rs485Handlers.onRS485Disconnected);
+                node.rs485Config.removeListener('error', node._rs485Handlers.onRS485Error);
+                node.rs485Config.removeListener('frame', node._rs485Handlers.onRS485Frame);
                 node.rs485Config.deregister(node);
             }
+            
+            node.log('[RS485 Bridge] 节点已清理');
             done();
         });
     }

package/nodes/symi-485-config.js

@@ -114,6 +114,9 @@ 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/package.json

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