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

package/README.md

@@ -1032,7 +1032,7 @@ node-red-contrib-symi-mesh/
 
 ## 更新日志
 
-### v1.6.0 (2025-12-03)
+### v1.6.2 (2025-12-05)
 - **MQTT订阅修复**：修复闭包问题导致的设备MAC映射错误，确保HA实体可控
 - **内存泄漏修复**：节点关闭时正确移除gateway事件监听器，防止内存累积
 - **三合一面板完善**：空调/新风/地暖控制和状态反馈全面优化
@@ -1051,8 +1051,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.js

@@ -271,32 +271,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);
-
-        // 监听RS485连接事件
-        node.rs485Config.on('connected', () => {
-            node.status({ fill: 'green', shape: 'dot', text: `已连接 ${node.mappings.length}个映射` });
-        });
+        // 【重要】先绑定事件监听器，再注册到配置节点
+        // 定义事件处理函数（用于清理时移除）
+        const onRS485Connected = () => {
+            node.log(`[RS485 Bridge] 已连接到 ${rs485Info}`);
+            node.status({ fill: 'green', shape: 'dot', text: `已连接 ${rs485Info} (${node.mappings.length}个映射)` });
+        };
 
-        node.rs485Config.on('disconnected', () => {
-            node.status({ fill: 'yellow', shape: 'ring', text: '已断开' });
-        });
+        const onRS485Disconnected = () => {
+            node.warn(`[RS485 Bridge] 已断开 ${rs485Info}`);
+            node.status({ fill: 'yellow', shape: 'ring', text: `已断开 ${rs485Info}` });
+        };
 
-        node.rs485Config.on('error', (err) => {
-            node.status({ fill: 'red', shape: 'ring', text: '连接错误' });
-        });
+        const onRS485Error = (err) => {
+            node.error(`[RS485 Bridge] 连接错误 ${rs485Info}: ${err.message}`);
+            node.status({ fill: 'red', shape: 'ring', text: `错误 ${rs485Info}` });
+        };
 
-        // 监听RS485接收帧
-        node.rs485Config.on('frame', (frame) => {
+        const onRS485Frame = (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) {
@@ -426,23 +444,50 @@ module.exports = function(RED) {
         // Mesh -> Modbus 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.log(`[Mesh->RS485] 同步到从机${mapping.address}, 通道${mapping.meshChannel || 0}, 状态: ${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字段对应RS485的switch1/switch2等
+                    if (meshKey === 'switch' || meshKey === 'acSwitch') {
+                        // 根据映射中的通道号选择对应的寄存器
+                        const channel = mapping.meshChannel || 1;
+                        const switchRegKey = `switch${channel}`;
+                        const ledRegKey = `led${channel}`;
+                        
+                        // 同步开关状态
+                        if (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] 开关${channel}: ${value ? '开' : '关'} (寄存器0x${registers[switchRegKey].address.toString(16)})`);
+                        }
+                        // 同时同步指示灯状态
+                        if (registers[ledRegKey]) {
+                            const writeValue = value ? (registers[ledRegKey].on || 1) : (registers[ledRegKey].off || 0);
+                            await node.writeModbusRegister(mapping.address, registers[ledRegKey], writeValue);
+                            node.debug(`[Mesh->RS485] 指示灯${channel}: ${value ? '开' : '关'}`);
+                        }
                     }
+                    // 处理温控器属性
+                    else if ((meshKey === 'targetTemp' || meshKey === 'acTargetTemp') && registers.targetTemp) {
+                        await node.writeModbusRegister(mapping.address, registers.targetTemp, value);
+                        node.debug(`[Mesh->RS485] 目标温度: ${value}`);
+                    }
+                    else if (meshKey === 'acMode' && registers.mode) {
+                        await node.writeModbusRegister(mapping.address, registers.mode, value);
+                        node.debug(`[Mesh->RS485] 模式: ${value}`);
+                    }
+                    else if (meshKey === 'acFanSpeed' && registers.fanSpeed) {
+                        await node.writeModbusRegister(mapping.address, registers.fanSpeed, value);
+                        node.debug(`[Mesh->RS485] 风速: ${value}`);
+                    }
+                    else if (meshKey === 'brightness' && registers.brightness) {
+                        await node.writeModbusRegister(mapping.address, registers.brightness, value);
+                        node.debug(`[Mesh->RS485] 亮度: ${value}`);
+                    }
+                } catch (err) {
+                    node.error(`RS485写入失败: ${meshKey}=${value}, ${err.message}`);
                 }
             }
 
@@ -460,37 +505,54 @@ 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)]) }
-            };
+            node.log(`[RS485->Mesh] 同步到设备 ${mapping.meshMac}, 通道${mapping.meshChannel || 0}, 状态: ${JSON.stringify(state)}`);
 
             for (const [key, value] of Object.entries(state)) {
-                // 仅在Mesh设备支持此属性时同步
-                const m = attrMapping[key];
-                if (m) {
-                    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}`);
-                    } catch (err) {
-                        node.error(`Mesh写入失败: ${key}=${value}, ${err.message}`);
+                try {
+                    // 处理开关类型 (switch1, switch2, ... 或 led1, led2, ...)
+                    if (key.startsWith('switch')) {
+                        // 从键名提取通道号，如 switch1 -> 1, switch2 -> 2
+                        const channelFromKey = parseInt(key.replace('switch', '')) || 1;
+                        // 使用映射中配置的通道，或从键名获取
+                        const channel = mapping.meshChannel || channelFromKey;
+                        
+                        // Mesh开关控制：attrType=0x02, param=[通道, 开/关]
+                        const onOff = value ? 0x02 : 0x01;  // 0x02=开, 0x01=关
+                        const param = Buffer.from([channel - 1, onOff]);  // 通道从0开始
+                        
+                        await node.gateway.sendControl(meshDevice.networkAddress, 0x02, param);
+                        node.log(`[RS485->Mesh] 开关${channel}: ${value ? '开' : '关'}`);
+                    }
+                    // 处理指示灯（可选，某些场景需要同步指示灯状态）
+                    else if (key.startsWith('led')) {
+                        // 指示灯状态通常不需要同步回Mesh，仅记录
+                        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}`);
                 }
             }
 
@@ -559,26 +621,55 @@ module.exports = function(RED) {
             node.debug(`发送RS485帧: ${frame.toString('hex')}`);
         };
 
-        // 解析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;
+            }
 
             const registers = node.getRegistersForMapping(mapping);
-            if (!registers) return;
+            if (!registers) {
+                node.debug(`未找到设备${mapping.device}的寄存器定义`);
+                return;
+            }
 
             // 根据功能码解析数据
             let state = {};
-            if (fc === 0x03 || fc === 0x04) {
+            
+            if (fc === 0x06 || fc === 0x10) {
+                // 写单寄存器响应/写多寄存器响应 - 这是设备主动上报或写响应
+                // 格式: 从机地址 + 功能码 + 寄存器地址(2字节) + 值(2字节) + CRC
+                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 +678,19 @@ module.exports = function(RED) {
                         }
                     }
                 }
+            } else if (fc === 0x20) {
+                // 自定义功能码0x20 - 可能是批量上报
+                // 格式: 从机地址 + 0x20 + 起始寄存器(2字节) + 数量(2字节) + 数据... + CRC
+                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.queueCommand({
                     direction: 'modbus-to-mesh',
                     mapping: mapping,
@@ -697,13 +797,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/package.json

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