node-red-contrib-symi-mesh 1.8.6 → 1.8.8

package/README.md

@@ -558,6 +558,8 @@ npm install node-red-contrib-home-assistant-websocket
 
 | 节点 | 用途 |
 |-----|------|
+| **Symi RS485 Sync** | RS485多机批量同步 |
+| **RS485调试** | 原始485字节流抓取显示 |
 | **Symi Gateway** | 网关连接（TCP/串口） |
 | **Symi MQTT** | MQTT桥接，设备发布到HA |
 | **Symi Device** | Flow中单设备控制/监听 |
@@ -702,6 +704,25 @@ node-red-contrib-symi-mesh/
 
 ## 更新日志
 
+### v1.8.8 (2026-01-14)
+
+**KNX 双向同步深度修复与协议鲁棒性增强**：
+- **分包与粘包彻底解决**：重构 `ProtocolHandler` 缓存机制，支持 **8+1 分包、多包连续粘包**等极端情况下的完整解析。通过 Buffer 累加与帧头部实时扫描技术，确保无论串口数据如何切分，都能还原为完整的协议帧。
+- **KNX 双向同步死循环修复**：
+    - **MAC 地址标准化**：统一所有节点（配置、事件、缓存）的 MAC 地址为小写且无冒号格式，彻底解决由于大小写不一致导致的“找不到映射”或“防死循环误杀”问题。
+    - **设备级回显消除**：引入 `allKnxAddrs` 关联检查，KNX 发出指令后，自动屏蔽该设备下所有关联地址（命令/状态/位置）的短时回显，防止自发自收导致的同步环路。
+- **4 键开关通道精准匹配**：修复多路开关状态上报时，`switch_1` 到 `switch_4` 的动态订阅逻辑，确保 Mesh 端的每一路状态都能精准同步到对应的 KNX 组地址。
+- **生产环境日志优化**：所有原始报文降级为 `debug` 级别，仅保留关键的同步逻辑日志为 `log` 级别，确保在长时间运行下不占用额外硬盘 IO，防止 Node-RED 变慢。
+- **三合一面板持久化增强**：完善 `symi-mesh-data` 目录下的 JSON 持久化逻辑，确保三合一设备类型在 Node-RED 重启后能立即恢复，无需重新探测。
+
+### v1.8.7 (2026-01-08)
+
+**生产环境日志优化与稳定性增强**：
+- **错误日志节流 (Throttling)**：在网关连接和 RS485 配置中引入 60 秒节流机制，同类网络错误（如 `ECONNREFUSED`）每分钟仅记录一次，彻底解决离线时的日志刷屏问题。
+- **日志级别降级**：将所有节点的 `node.error` 和 `node.warn` 统一降级为 `node.log` (Info 级别)，保持 Node-RED 控制台整洁，仅在调试模式下显示详细信息。
+- **TCP 客户端优化**：在 `tcp-client` 库级别拦截常见的网络波动报错，提升系统在高频重连场景下的静默稳定性。
+- **全量节点适配**：完成 MQTT、HA同步、云端同步、RS485、KNX 等所有功能节点的日志规范化清理。
+
 ### v1.8.6 (2026-01-07)
 
 **核心修复与同步增强**：

package/lib/tcp-client.js

@@ -111,7 +111,7 @@ class TCPClient extends EventEmitter {
                 // 只在首次连接或重要错误时记录，避免大量重复日志
                 // ECONNRESET通常是网络波动，不记录错误
                 else if (!this.connected && error.code !== 'ECONNREFUSED' && error.code !== 'ECONNRESET') {
-                    this.logger.error('TCP client error:', error.message);
+                    this.logger.log('TCP client error: ' + error.message);
                 }
 
                 // 确保错误不会导致uncaught exception

package/nodes/rs485-debug.js

@@ -145,12 +145,13 @@ module.exports = function(RED) {
         });
 
         node.rs485Config.on('disconnected', function() {
-            node.warn('RS485连接已断开');
+            node.log('RS485连接已断开');
             updateStatus();
         });
 
         node.rs485Config.on('error', function(err) {
-            node.error('RS485错误: ' + err.message);
+            // 降级为 log，避免控制台报错
+            node.log('RS485错误: ' + err.message);
             node.status({ fill: 'red', shape: 'ring', text: '错误: ' + err.message });
         });
 
@@ -177,7 +178,7 @@ module.exports = function(RED) {
                     handleFrame(frame, 'TX');
                     node.log('手动发送: ' + formatHex(frame));
                 } else if (!node.rs485Config.connected) {
-                    node.warn('RS485未连接，无法发送');
+                    node.log('RS485未连接，无法发送');
                 }
             }
         });

package/nodes/symi-485-bridge.js

@@ -954,7 +954,7 @@ module.exports = function(RED) {
             });
         } catch (e) {
             node.mappings = [];
-            node.error(`映射配置解析失败: ${e.message}`);
+            node.log(`映射配置解析失败: ${e.message}`);
         }
 
         if (!node.gateway) {
@@ -1000,12 +1000,12 @@ module.exports = function(RED) {
         };
 
         const onRS485Disconnected = () => {
-            node.warn(`[RS485 Bridge] 已断开 ${rs485Info}`);
+            node.log(`[RS485 Bridge] 已断开 ${rs485Info}`);
             node.status({ fill: 'yellow', shape: 'ring', text: `已断开 ${rs485Info}` });
         };
 
         const onRS485Error = (err) => {
-            node.error(`[RS485 Bridge] 连接错误 ${rs485Info}: ${err.message}`);
+            node.log(`[RS485 Bridge] 连接错误 ${rs485Info}: ${err.message}`);
             node.status({ fill: 'red', shape: 'ring', text: `错误 ${rs485Info}` });
         };
 
@@ -1247,7 +1247,7 @@ module.exports = function(RED) {
                             const hexStr = frame.toString('hex').toUpperCase().match(/.{2}/g).join(' ');
                             node.log(`[Mesh->杜亚] ${actionName}: ${hexStr}`);
                         }).catch(err => {
-                            node.error(`[Mesh->杜亚] 发送失败: ${err.message}`);
+                            node.log(`[Mesh->杜亚] 发送失败: ${err.message}`);
                         });
                     }
                     
@@ -1259,7 +1259,7 @@ module.exports = function(RED) {
                                 const hexStr = posFrame.toString('hex').toUpperCase().match(/.{2}/g).join(' ');
                                 node.log(`[Mesh->杜亚] 同步位置${currentPosition}%: ${hexStr}`);
                             }).catch(err => {
-                                node.error(`[Mesh->杜亚] 位置同步失败: ${err.message}`);
+                                node.log(`[Mesh->杜亚] 位置同步失败: ${err.message}`);
                             });
                         }, 100);
                     }
@@ -1320,7 +1320,7 @@ module.exports = function(RED) {
                         node.sendCustomCode(hexCode).then(() => {
                             node.log(`[Mesh->自定义窗帘] ${actionName}: ${hexCode}`);
                         }).catch(err => {
-                            node.error(`[Mesh->自定义窗帘] 发送失败: ${err.message}`);
+                            node.log(`[Mesh->自定义窗帘] 发送失败: ${err.message}`);
                         });
                     } else {
                         node.debug(`[Mesh->自定义窗帘] 无匹配码, action=${curtainAction}, status=${curtainStatus}`);
@@ -1485,7 +1485,7 @@ module.exports = function(RED) {
                             const hexStr = frame.toString('hex').toUpperCase();
                             node.log(`[Mesh控制->杜亚] 窗帘 ${actionName}, 立即发送: ${hexStr.match(/.{2}/g).join(' ')}`);
                         }).catch(err => {
-                            node.error(`[Mesh控制->杜亚] 发送失败: ${err.message}`);
+                            node.log(`[Mesh控制->杜亚] 发送失败: ${err.message}`);
                         });
                     }
                 }
@@ -1534,7 +1534,7 @@ module.exports = function(RED) {
                         node.sendCustomCode(hexCode).then(() => {
                             node.log(`[Mesh控制->自定义] 窗帘 ${actionName}, 立即发送: ${hexCode}`);
                         }).catch(err => {
-                            node.error(`[Mesh控制->自定义] 发送失败: ${err.message}`);
+                            node.log(`[Mesh控制->自定义] 发送失败: ${err.message}`);
                         });
                     }
                 }
@@ -1566,7 +1566,7 @@ module.exports = function(RED) {
         node.queueCommand = function(cmd) {
             // 队列过大时丢弃旧命令，防止内存溢出
             if (node.commandQueue.length >= MAX_QUEUE_SIZE) {
-                node.warn(`[RS485 Bridge] 命令队列已满(${MAX_QUEUE_SIZE})，丢弃最旧命令`);
+                node.log(`[RS485 Bridge] 命令队列已满(${MAX_QUEUE_SIZE})，丢弃最旧命令`);
                 node.commandQueue.shift();  // 丢弃最旧的命令
             }
             
@@ -1610,7 +1610,7 @@ module.exports = function(RED) {
                         // 命令之间延迟50ms
                         await node.sleep(50);
                     } catch (err) {
-                        node.error(`同步失败: ${err.message}`);
+                        node.log(`同步失败: ${err.message}`);
                     }
                 }
 
@@ -1787,7 +1787,7 @@ module.exports = function(RED) {
                             await node.sendCustomCode(hexCode);
                             node.log(`[Mesh->自定义] 开关(${foundKey}): ${switchValue ? '开' : '关'}, 发送: ${hexCode}`);
                         } else {
-                            node.warn(`[Mesh->自定义] 开关(${foundKey}): ${switchValue ? '开' : '关'}, 缺少${switchValue ? 'sendOn' : 'sendOff'}码`);
+                            node.log(`[Mesh->自定义] 开关(${foundKey}): ${switchValue ? '开' : '关'}, 缺少${switchValue ? 'sendOn' : 'sendOff'}码`);
                         }
                     }
                 }
@@ -1944,7 +1944,7 @@ module.exports = function(RED) {
                             await node.sendCustomCode(hexCode);
                             node.log(`[Mesh->自定义] 空调 ${key}=${value}, 发送: ${hexCode}`);
                         } else if (codeType) {
-                            node.warn(`[Mesh->自定义] 空调 ${key}=${value}, 缺少${codeType}码`);
+                            node.log(`[Mesh->自定义] 空调 ${key}=${value}, 缺少${codeType}码`);
                         }
                     }
                 }
@@ -2117,7 +2117,7 @@ module.exports = function(RED) {
                         }
                     }
                 } catch (err) {
-                    node.error(`RS485写入失败: ${meshKey}=${value}, ${err.message}`);
+                    node.log(`RS485写入失败: ${meshKey}=${value}, ${err.message}`);
                 }
             }
 
@@ -2129,7 +2129,7 @@ module.exports = function(RED) {
             if (!hexCode) return;
             const hexStr = hexCode.replace(/\s/g, '');
             if (!/^[0-9A-Fa-f]+$/.test(hexStr)) {
-                node.warn(`无效的十六进制码: ${hexCode}`);
+                node.log(`无效的十六进制码: ${hexCode}`);
                 return;
             }
             const frame = Buffer.from(hexStr, 'hex');
@@ -2159,10 +2159,10 @@ module.exports = function(RED) {
             }
             
             if (!meshDevice) {
-                node.warn(`[RS485->Mesh] 未找到Mesh设备: ${meshMac} (规范化: ${macNormalized})`);
+                node.log(`[RS485->Mesh] 未找到Mesh设备: ${meshMac} (规范化: ${macNormalized})`);
                 // 输出可用设备列表帮助调试
                 const allDevices = node.gateway.deviceManager?.getAllDevices() || [];
-                node.warn(`[RS485->Mesh] 可用设备: ${allDevices.map(d => d.macAddress).join(', ')}`);
+                node.log(`[RS485->Mesh] 可用设备: ${allDevices.map(d => d.macAddress).join(', ')}`);
                 return;
             }
             
@@ -2187,7 +2187,7 @@ module.exports = function(RED) {
                         node.log(`[杜亚->Mesh] 窗帘位置: ${pos}%`);
                     }
                 } catch (err) {
-                    node.error(`[杜亚->Mesh] 写入失败: ${err.message}`);
+                    node.log(`[杜亚->Mesh] 写入失败: ${err.message}`);
                 }
                 
                 node.status({ fill: 'blue', shape: 'dot', text: `杜亚同步 ${node.mappings.length}个` });
@@ -2246,7 +2246,7 @@ module.exports = function(RED) {
                             node.log(`[自定义->Mesh] 窗帘: ${value} (动作码${action})`);
                         }
                     } catch (err) {
-                        node.error(`Mesh写入失败: ${key}=${value}, ${err.message}`);
+                        node.log(`Mesh写入失败: ${key}=${value}, ${err.message}`);
                     }
                 }
                 
@@ -2356,7 +2356,7 @@ module.exports = function(RED) {
                         node.log(`[RS485->Mesh] 新风风速: RS485值${value} -> Mesh值${meshSpeed}`);
                     }
                 } catch (err) {
-                    node.error(`Mesh写入失败: ${key}=${value}, ${err.message}`);
+                    node.log(`Mesh写入失败: ${key}=${value}, ${err.message}`);
                 }
             }
 
@@ -2418,7 +2418,7 @@ module.exports = function(RED) {
         // 发送RS485帧（通过配置节点）
         node.sendRS485Frame = async function(frame) {
             if (!node.rs485Config || !node.rs485Config.connected) {
-                node.warn('RS485未连接，无法发送数据');
+                node.log('RS485未连接，无法发送数据');
                 return;
             }
             try {
@@ -2439,7 +2439,7 @@ module.exports = function(RED) {
                     timestamp: new Date().toISOString()
                 });
             } catch (err) {
-                node.error(`RS485发送失败: ${err.message}`);
+                node.log(`RS485发送失败: ${err.message}`);
             }
         };
 
@@ -2511,7 +2511,7 @@ module.exports = function(RED) {
                     }
                     
                     if (!foundMapping) {
-                        node.warn(`[杜亚] 未找到匹配的映射, 帧地址=${duyaData.addrHigh}:${duyaData.addrLow}，请检查RS485桥配置`);
+                        node.log(`[杜亚] 未找到匹配的映射, 帧地址=${duyaData.addrHigh}:${duyaData.addrLow}，请检查RS485桥配置`);
                     }
                 } else {
                     node.debug(`[杜亚帧检测] 解析失败，可能funcCode不是0x03`);
@@ -2566,7 +2566,7 @@ module.exports = function(RED) {
                         // 转换为中弘命令
                         const zhCmd = convertSymiToZhonghong(symiData, mapping);
                         if (!zhCmd) {
-                            node.warn(`[SYMI->Zhonghong] 未知操作码: ${symiData.opCode}`);
+                            node.log(`[SYMI->Zhonghong] 未知操作码: ${symiData.opCode}`);
                             continue;
                         }
                         
@@ -2589,7 +2589,7 @@ module.exports = function(RED) {
                                 timestamp: new Date().toISOString()
                             });
                         }).catch(err => {
-                            node.error(`[SYMI->Zhonghong] 发送失败: ${err.message}`);
+                            node.log(`[SYMI->Zhonghong] 发送失败: ${err.message}`);
                         });
                         
                         return;
@@ -2681,7 +2681,7 @@ module.exports = function(RED) {
                             timestamp: new Date().toISOString()
                         });
                     }).catch(err => {
-                        node.error(`[Zhonghong->SYMI] 发送失败: ${err.message}`);
+                        node.log(`[Zhonghong->SYMI] 发送失败: ${err.message}`);
                     });
                     
                     return;

package/nodes/symi-485-config.js

@@ -66,6 +66,17 @@ module.exports = function(RED) {
         node.receiveBuffer = Buffer.alloc(0);
         node.users = [];
 
+        // 限流错误日志
+        node._lastErrorLog = 0;
+        node._ERROR_LOG_INTERVAL = 60000;
+        node.logErrorThrottled = function(msg) {
+            const now = Date.now();
+            if (now - node._lastErrorLog > node._ERROR_LOG_INTERVAL) {
+                node._lastErrorLog = now;
+                node.log(msg);
+            }
+        };
+
         // 注册使用者
         node.register = function(userNode) {
             if (!node.users.includes(userNode)) {
@@ -94,7 +105,7 @@ module.exports = function(RED) {
             try {
                 if (node.connectionType === 'serial') {
                     if (!node.serialPort) {
-                        node.error('未配置串口');
+                        node.log('未配置串口');
                         return;
                     }
                     
@@ -122,7 +133,7 @@ module.exports = function(RED) {
                     });
 
                     node.client.on('error', (err) => {
-                        node.error(`RS485串口错误: ${err.message}`);
+                        node.logErrorThrottled(`RS485串口错误: ${err.message}`);
                         node.emit('error', err);
                     });
 
@@ -146,7 +157,7 @@ module.exports = function(RED) {
 
                 } else if (node.connectionType === 'tcp') {
                     if (!node.host) {
-                        node.error('未配置TCP主机');
+                        node.log('未配置TCP主机');
                         return;
                     }
 
@@ -170,7 +181,7 @@ module.exports = function(RED) {
                         if (err.name === 'AggregateError' || err.errors) {
                             node.debug(`RS485 TCP连接失败: 无法连接到 ${node.host}:${node.port}`);
                         } else {
-                            node.error(`RS485 TCP错误: ${err.message}`);
+                            node.logErrorThrottled(`RS485 TCP错误: ${err.message}`);
                         }
                         node.emit('error', err);
                     });
@@ -199,11 +210,11 @@ module.exports = function(RED) {
                             family: 4  // 强制IPv4，避免IPv6连接失败导致AggregateError
                         });
                     } catch (connectErr) {
-                        node.error(`RS485 TCP连接异常: ${connectErr.message}`);
+                        node.log(`RS485 TCP连接异常: ${connectErr.message}`);
                     }
                 }
             } catch (err) {
-                node.error(`RS485连接失败: ${err.message}`);
+                node.log(`RS485连接失败: ${err.message}`);
             }
         };
 

package/nodes/symi-cloud-sync.js

@@ -23,13 +23,13 @@ module.exports = function(RED) {
         node.selectedScenes = config.selectedScenes || [];
 
         if (!node.gateway) {
-            node.error('未配置网关');
+            node.log('未配置网关');
             node.status({ fill: 'red', shape: 'ring', text: '未配置网关' });
             return;
         }
 
         if (!node.appId || !node.appSecret) {
-            node.warn('未配置云端认证信息');
+            node.log('未配置云端认证信息');
             node.status({ fill: 'yellow', shape: 'ring', text: '未配置认证' });
             return;
         }
@@ -55,12 +55,12 @@ module.exports = function(RED) {
         
         const syncFromCloud = async () => {
             if (node.syncInProgress) {
-                node.warn('同步正在进行中，跳过');
+                node.log('同步正在进行中，跳过');
                 return;
             }
             
             if (!node.hotelId || !node.roomNo) {
-                node.warn('未配置酒店ID或房间号，跳过同步');
+                node.log('未配置酒店ID或房间号，跳过同步');
                 node.status({ fill: 'yellow', shape: 'ring', text: '未配置房间' });
                 return;
             }
@@ -96,7 +96,7 @@ module.exports = function(RED) {
                 node.status({ fill: 'green', shape: 'dot', text: `已同步 ${new Date().toLocaleTimeString()}` });
                 
             } catch (error) {
-                node.error(`云端同步失败: ${error.message}`);
+                node.log(`云端同步失败: ${error.message}`);
                 node.status({ fill: 'red', shape: 'ring', text: '同步失败' });
                 
                 const cached = loadCachedData();
@@ -112,7 +112,7 @@ module.exports = function(RED) {
         
         const applyCloudData = (cloudData) => {
             if (!cloudData || !cloudData.devices) {
-                node.warn('无可用的云端数据');
+                node.log('无可用的云端数据');
                 return;
             }
 
@@ -237,7 +237,7 @@ module.exports = function(RED) {
 
         const publishSceneButtons = (scenes) => {
             if (!node.mqttConfig || !node.mqttConfig.mqttClient) {
-                node.warn('MQTT客户端未连接，无法发布场景按钮');
+                node.log('MQTT客户端未连接，无法发布场景按钮');
                 return;
             }
 
@@ -256,7 +256,7 @@ module.exports = function(RED) {
 
                     mqttClient.publish(config.topic, config.payload, { retain: true }, (err) => {
                         if (err) {
-                            node.error(`发布场景按钮失败: ${scene.scene_name}, ${err.message}`);
+                            node.log(`发布场景按钮失败: ${scene.scene_name}, ${err.message}`);
                         } else {
                             node.log(`场景按钮已发布: ${scene.scene_name}`);
                         }
@@ -307,13 +307,13 @@ module.exports = function(RED) {
                                 node.gateway.sendScene(sceneId).then(() => {
                                     node.log(`[场景控制] 场景控制命令已发送: ${scene.scene_name} (ID: ${sceneId})`);
                                 }).catch(err => {
-                                    node.error(`[场景控制] 场景控制命令发送失败: ${err.message}`);
+                                    node.log(`[场景控制] 场景控制命令发送失败: ${err.message}`);
                                 });
                             } else {
-                                node.error('[场景控制] 网关未连接，无法执行场景');
+                                node.log('[场景控制] 网关未连接，无法执行场景');
                             }
                         } else {
-                            node.warn(`[场景控制] 场景ID ${sceneId} 未找到`);
+                            node.log(`[场景控制] 场景ID ${sceneId} 未找到`);
                         }
                     }
                 }
@@ -332,7 +332,7 @@ module.exports = function(RED) {
                     msg.payload = { scene_id: scene.scene_id };
                     node.send(msg);
                 } else {
-                    node.warn(`场景ID ${msg.payload.scene_id} 不存在`);
+                    node.log(`场景ID ${msg.payload.scene_id} 不存在`);
                 }
             }
         });

package/nodes/symi-device.js

@@ -31,7 +31,7 @@ module.exports = function(RED) {
         }
         
         if (!node.gateway) {
-            node.error('未配置网关');
+            node.log('未配置网关');
             node.status({ fill: 'red', shape: 'ring', text: '未配置网关' });
             return;
         }
@@ -99,21 +99,21 @@ module.exports = function(RED) {
         node.on('input', async function(msg) {
             try {
                 if (!node.gateway.connected) {
-                    node.error('网关未连接');
+                    node.log('网关未连接');
                     return;
                 }
                 
                 if (!node.device) {
                     updateDevice();
                     if (!node.device) {
-                        node.error('设备未找到');
+                        node.log('设备未找到');
                         return;
                     }
                 }
                 
                 const command = node.parseInputCommand(msg);
                 if (!command) {
-                    node.warn('无效的命令格式');
+                    node.log('无效的命令格式');
                     return;
                 }
                 
@@ -122,7 +122,7 @@ module.exports = function(RED) {
                 node.status({ fill: 'green', shape: 'dot', text: '命令已发送' });
                 
             } catch (error) {
-                node.error(`控制失败: ${error.message}`);
+                node.log(`控制失败: ${error.message}`);
                 node.status({ fill: 'red', shape: 'dot', text: '控制失败' });
             }
         });

package/nodes/symi-gateway.js

@@ -70,6 +70,17 @@ module.exports = function(RED) {
         this.sceneExecutionInProgress = false;  // 场景执行中标志
         this.sceneExecutionTimer = null;  // 场景执行超时定时器
 
+        // 限流错误日志
+        this._lastErrorLog = 0;
+        this._ERROR_LOG_INTERVAL = 60000;
+        this.logErrorThrottled = function(msg) {
+            const now = Date.now();
+            if (now - this._lastErrorLog > this._ERROR_LOG_INTERVAL) {
+                this._lastErrorLog = now;
+                this.log(msg);
+            }
+        };
+
         this.log(`Initializing Symi Gateway: ${this.connectionType === 'tcp' ? `${this.host}:${this.port}` : this.serialPort}`);
         
         // 三合一设备检测已在 queryAllDeviceStates 中实现，无需额外事件监听
@@ -128,7 +139,7 @@ module.exports = function(RED) {
             
         } catch (error) {
             // 初始连接失败，但自动重连会继续尝试
-            this.error(`Initial connection failed: ${error.message}, will retry automatically`);
+            this.logErrorThrottled(`Initial connection failed: ${error.message}, will retry automatically`);
         }
 
         // 节点关闭时清理资源

package/nodes/symi-ha-sync.js

@@ -117,7 +117,7 @@ module.exports = function(RED) {
             }
         } catch (e) {
             node.mappings = [];
-            node.error('映射配置解析失败: ' + e.message);
+            node.log('映射配置解析失败: ' + e.message);
         }
 
         node.commandQueue = [];
@@ -162,7 +162,7 @@ module.exports = function(RED) {
         
         if (configError) {
             node.status({ fill: 'red', shape: 'ring', text: configError });
-            node.warn(`[HA同步] ${configError}`);
+            node.log(`[HA同步] ${configError}`);
             // 不要return，继续注册input监听器
         } else {
             // 初始状态：只有Mesh→HA方向，等待HA输入连接
@@ -1049,7 +1049,7 @@ module.exports = function(RED) {
                                     node.debug(`[HA->Symi] 空调风速: ${oldAttrs.fan_mode} -> ${attrs.fan_mode} (mesh: ${meshFan})`);
                                     syncDataList.push({ type: 'fan_mode', value: meshFan });
                                 } else {
-                                    node.warn(`[HA->Symi] 未知的空调风速值: "${attrs.fan_mode}"，请检查映射配置`);
+                                    node.log(`[HA->Symi] 未知的空调风速值: "${attrs.fan_mode}"，请检查映射配置`);
                                 }
                             }
                         }
@@ -1138,7 +1138,7 @@ module.exports = function(RED) {
                         }
                         await node.sleep(50);
                     } catch (err) {
-                        node.error(`同步失败: ${err.message}`);
+                        node.log(`同步失败: ${err.message}`);
                     }
                 }
             } finally {
@@ -1240,7 +1240,7 @@ module.exports = function(RED) {
                 
                 // 如果 service 为空，说明该属性不支持同步到 HA
                 if (!service) {
-                    node.warn(`[Symi->HA] 属性 ${syncData.type} 在领域 ${domain} 下暂不支持同步`);
+                    node.log(`[Symi->HA] 属性 ${syncData.type} 在领域 ${domain} 下暂不支持同步`);
                     return;
                 }
                 
@@ -1260,7 +1260,7 @@ module.exports = function(RED) {
                 node.log(`[Symi->HA] ${mapping.symiName || mapping.symiMac} -> ${mapping.haEntityId}: ${syncData.type}=${JSON.stringify(syncData.value)}`);
                 
             } catch (err) {
-                node.error(`[Symi->HA] 调用失败: ${err.message}`);
+                node.log(`[Symi->HA] 调用失败: ${err.message}`);
             }
         };
 
@@ -1272,13 +1272,13 @@ module.exports = function(RED) {
             // 动态获取gateway（可能在初始化后才可用）
             const currentGateway = gateway || (node.mqttNode && node.mqttNode.gateway);
             if (!currentGateway) {
-                node.warn(`[HA->Symi] 网关未就绪，无法控制设备`);
+                node.log(`[HA->Symi] 网关未就绪，无法控制设备`);
                 return;
             }
             
             const device = currentGateway.getDevice(mapping.symiMac);
             if (!device) {
-                node.warn(`[HA->Symi] 设备未找到: ${mapping.symiMac}`);
+                node.log(`[HA->Symi] 设备未找到: ${mapping.symiMac}`);
                 return;
             }
             
@@ -1347,7 +1347,7 @@ module.exports = function(RED) {
                 node.log(`[HA->Symi] ${mapping.haEntityId} -> ${device.name || mapping.symiMac}: ${syncData.type}=${JSON.stringify(syncData.value)}`);
                 
             } catch (err) {
-                node.error(`[HA->Symi] 控制失败: ${err.message}`);
+                node.log(`[HA->Symi] 控制失败: ${err.message}`);
             }
         };
 
@@ -1362,7 +1362,7 @@ module.exports = function(RED) {
             // 动态获取gateway
             const currentGateway = gateway || (node.mqttNode && node.mqttNode.gateway);
             if (!currentGateway) {
-                node.warn(`[HA->Symi] 网关未就绪，无法控制三合一设备`);
+                node.log(`[HA->Symi] 网关未就绪，无法控制三合一设备`);
                 return;
             }
             
@@ -1442,11 +1442,11 @@ module.exports = function(RED) {
                     await currentGateway.sendControl(networkAddr, attrType, param);
                     node.log(`[HA->Symi] ${mapping.haEntityId} -> ${mapping.symiName}(${subType}): ${syncData.type}=${JSON.stringify(syncData.value)}`);
                 } else {
-                    node.warn(`[HA->Symi] 三合一控制未匹配: subType=${subType}, syncData.type=${syncData.type}`);
+                    node.log(`[HA->Symi] 三合一控制未匹配: subType=${subType}, syncData.type=${syncData.type}`);
                 }
                 
             } catch (err) {
-                node.error(`[HA->Symi] 三合一控制失败: ${err.message}`);
+                node.log(`[HA->Symi] 三合一控制失败: ${err.message}`);
             }
         };
 

package/nodes/symi-knx-bridge.js

@@ -137,7 +137,7 @@ module.exports = function(RED) {
             });
         } catch (e) {
             node.mappings = [];
-            node.error(`映射配置解析失败: ${e.message}`);
+            node.log(`映射配置解析失败: ${e.message}`);
         }
 
         if (!node.gateway) {
@@ -259,13 +259,14 @@ module.exports = function(RED) {
             // syncLock会导致队列处理期间丢失事件，改用per-device时间戳防回环
             if (node.initializing) return;
             
-            const mac = eventData.device.macAddress;
+            const mac = (eventData.device.macAddress || '').toLowerCase();
             const state = eventData.state || {};
             
             // 状态缓存比较
             if (!node.stateCache[mac]) node.stateCache[mac] = {};
             const cached = node.stateCache[mac];
             const changed = {};
+            
             const isFirstState = Object.keys(cached).length === 0;
             
             for (const [key, value] of Object.entries(state)) {
@@ -296,7 +297,7 @@ module.exports = function(RED) {
             node.log(`[Mesh事件] MAC=${macNormalized}, 找到${matchedMappings.length}个映射, 变化: ${JSON.stringify(changed)}`);
             
             for (const mapping of matchedMappings) {
-                const loopKey = `${mac}_${mapping.meshChannel}`;
+                const loopKey = `${mapping.meshMac}_${mapping.meshChannel}`;
                 
                 // 窗帘设备需要单独处理防死循环（动作和位置分开检查）
                 if (mapping.deviceType === 'cover') {
@@ -550,7 +551,7 @@ module.exports = function(RED) {
                         }
                         await node.sleep(50);  // 命令间隔50ms
                     } catch (err) {
-                        node.error(`同步失败: ${err.message}`);
+                        node.log(`同步失败: ${err.message}`);
                     }
                 }
             } finally {
@@ -928,7 +929,7 @@ module.exports = function(RED) {
                 }]);
                 
             } catch (err) {
-                node.error(`[KNX->Mesh] 发送失败: ${err.message}`);
+                node.log(`[KNX->Mesh] 发送失败: ${err.message}`);
             }
             
             node.status({ fill: 'blue', shape: 'dot', text: `KNX→Mesh ${node.mappings.length}个映射` });
@@ -941,6 +942,12 @@ module.exports = function(RED) {
                 return;
             }
             
+            // 如果是来自我们自己节点的 debug 输出，直接跳过
+            if (msg.topic === 'mesh-to-knx' || msg.topic === 'knx-to-mesh') {
+                done && done();
+                return;
+            }
+
             // 从消息中提取KNX组地址
             const groupAddr = msg.knx?.destination || msg.topic || '';
             const value = msg.payload;
@@ -951,14 +958,6 @@ module.exports = function(RED) {
                 return;
             }
             
-            // 检查是否是我们自己发出去的命令（防止自己发的命令被监听后又处理）
-            const lastSentTime = node.lastKnxAddrSent[groupAddr] || 0;
-            if (Date.now() - lastSentTime < DEFAULT_TIMEOUT) {
-                node.debug(`[KNX输入] 跳过(自己发的): ${groupAddr}`);
-                done && done();
-                return;
-            }
-            
             // 查找映射
             const mapping = node.findKnxMapping(groupAddr);
             if (!mapping) {
@@ -966,6 +965,19 @@ module.exports = function(RED) {
                 done && done();
                 return;
             }
+
+            // 检查是否是我们自己发出去的命令（防止自己发的命令被监听后又处理）
+            // 检查该设备的所有关联地址，只要有一个最近发送过，就认为是回显
+            const wasSentRecently = mapping.allKnxAddrs.some(addr => {
+                const lastSentTime = node.lastKnxAddrSent[addr] || 0;
+                return (Date.now() - lastSentTime) < DEFAULT_TIMEOUT;
+            });
+
+            if (wasSentRecently) {
+                node.debug(`[KNX输入] 跳过(自己发的回显): ${groupAddr} (设备: ${mapping.name})`);
+                done && done();
+                return;
+            }
             
             // 确定地址功能（优先使用地址匹配，比DPT更可靠）
             const addrFunc = node.getKnxAddrFunction(mapping, groupAddr);

package/nodes/symi-knx-ha-bridge.js

@@ -16,7 +16,7 @@ module.exports = function(RED) {
         try {
             knxEntities = JSON.parse(config.knxEntities || '[]');
         } catch (e) {
-            node.error('KNX实体配置解析失败: ' + e.message);
+            node.log('KNX实体配置解析失败: ' + e.message);
         }
 
         try {
@@ -52,7 +52,7 @@ module.exports = function(RED) {
             }
         } catch (e) {
             node.mappings = [];
-            node.error('映射配置解析失败: ' + e.message);
+            node.log('映射配置解析失败: ' + e.message);
         }
 
         node.commandQueue = [];
@@ -304,7 +304,7 @@ module.exports = function(RED) {
                         }
                         await node.sleep(50);
                     } catch (err) {
-                        node.error(`同步失败: ${err.message}`);
+                        node.log(`同步失败: ${err.message}`);
                     }
                 }
             } finally {
@@ -377,7 +377,7 @@ module.exports = function(RED) {
                     }]);
                 }
             } catch (err) {
-                node.error(`[KNX->HA] 调用HA服务失败: ${err.message}`);
+                node.log(`[KNX->HA] 调用HA服务失败: ${err.message}`);
             }
         };
 

package/nodes/symi-mqtt-brand.js

@@ -102,7 +102,7 @@ module.exports = function(RED) {
             const now = Date.now();
             if (now - node._lastErrorLog > 60000) {
                 node._lastErrorLog = now;
-                node.warn(msg);
+                node.log(msg);
             }
         }
 
@@ -121,7 +121,7 @@ module.exports = function(RED) {
 
             const uploadTopic = getUploadTopic();
             if (!uploadTopic) {
-                node.warn('品牌MQTT配置不完整：缺少项目代码或设备SN');
+                node.log('品牌MQTT配置不完整：缺少项目代码或设备SN');
                 return;
             }
 
@@ -152,7 +152,7 @@ module.exports = function(RED) {
                         if (!err) {
                             node.log(`已订阅: ${uploadTopic}`);
                         } else {
-                            node.error(`订阅失败: ${err.message}`);
+                            node.log(`订阅失败: ${err.message}`);
                         }
                     });
 
@@ -264,7 +264,7 @@ module.exports = function(RED) {
         // 发布控制命令
         node.publish = function(st, si, fn, fv) {
             if (!node._client || !node._connected) {
-                node.warn('品牌MQTT未连接，无法发送命令');
+                node.log('品牌MQTT未连接，无法发送命令');
                 return false;
             }
             

package/nodes/symi-mqtt-sync.js

@@ -155,7 +155,7 @@ module.exports = function(RED) {
             const now = Date.now();
             if (now - node._lastErrorLog > ERROR_LOG_INTERVAL) {
                 node._lastErrorLog = now;
-                node.warn(msg);
+                node.log(msg);
             }
         }
 
@@ -406,7 +406,7 @@ module.exports = function(RED) {
                     });
                 }
             } catch (e) {
-                node.warn(`[Brand→Mesh] 同步失败: ${e.message}`);
+                node.log(`[Brand→Mesh] 同步失败: ${e.message}`);
             }
         }
         
@@ -619,7 +619,7 @@ module.exports = function(RED) {
                     }
                 });
             } catch (e) {
-                node.warn(`[Mesh→Brand] 同步失败: ${e.message}`);
+                node.log(`[Mesh→Brand] 同步失败: ${e.message}`);
             }
         }
         

package/nodes/symi-mqtt.js

@@ -31,7 +31,7 @@ module.exports = function(RED) {
         node.gateway = RED.nodes.getNode(config.gateway);
 
         if (!node.gateway) {
-            node.error('未配置网关');
+            node.log('未配置网关');
             node.status({ fill: 'red', shape: 'ring', text: '未配置网关' });
             return;
         }
@@ -61,7 +61,7 @@ module.exports = function(RED) {
                     node.publishAllDiscovery(devices);
                 }, 3000);
             } else {
-                node.warn('设备列表已完成但MQTT未连接，等待MQTT连接后发布');
+                node.log('设备列表已完成但MQTT未连接，等待MQTT连接后发布');
             }
         };
         node.gateway.on('device-list-complete', node._handlers.deviceListComplete);
@@ -116,7 +116,7 @@ module.exports = function(RED) {
                                             node.subscriptions.set(topic, deviceMacForSub);
                                             node.log(`[三合一] 订阅成功: ${topic}`);
                                         } else {
-                                            node.error(`[三合一] 订阅失败: ${topic}`);
+                                            node.log(`[三合一] 订阅失败: ${topic}`);
                                         }
                                     });
                                 }
@@ -160,7 +160,7 @@ module.exports = function(RED) {
                                 node.subscriptions.set(topic, deviceMacForSub);
                                 node.debug(`订阅topic: ${topic} -> ${deviceMacForSub}`);
                             } else {
-                                node.error(`订阅失败: ${topic}, ${err.message}`);
+                                node.log(`订阅失败: ${topic}, ${err.message}`);
                             }
                         });
                     }
@@ -229,7 +229,7 @@ module.exports = function(RED) {
             if (!isAvailable) {
                 // 只在首次或每分钟记录一次警告，避免日志刷屏
                 if (!node._lastMqttWarn || Date.now() - node._lastMqttWarn > 60000) {
-                    node.warn(`MQTT broker ${host}:${port} 不可用，每30秒重试`);
+                    node.log(`MQTT broker ${host}:${port} 不可用，每30秒重试`);
                     node._lastMqttWarn = Date.now();
                 }
                 node.status({ fill: 'yellow', shape: 'ring', text: `Broker不可用 ${host}:${port}` });
@@ -254,7 +254,7 @@ module.exports = function(RED) {
             // 立即绑定错误处理
             node.mqttClient.on('error', (error) => {
                 if (error.code !== 'ECONNREFUSED' && error.code !== 'ENOTFOUND') {
-                    node.error(`MQTT错误: ${error.message}`);
+                    node.log(`MQTT错误: ${error.message}`);
                 }
                 node.status({ fill: 'red', shape: 'ring', text: '连接失败' });
             });
@@ -291,7 +291,7 @@ module.exports = function(RED) {
             });
             
         } catch (error) {
-            node.error(`MQTT连接失败: ${error.message}`);
+            node.log(`MQTT连接失败: ${error.message}`);
             node.status({ fill: 'red', shape: 'ring', text: '失败' });
         }
     };
@@ -343,7 +343,7 @@ module.exports = function(RED) {
             node.log(`[MQTT] 发布 ${device.name} availability: online`);
             node.mqttClient.publish(`symi_mesh/${macClean}/availability`, 'online', { retain: true }, (err) => {
                 if (err) {
-                    node.error(`发布availability失败: ${err.message}`);
+                    node.log(`发布availability失败: ${err.message}`);
                 } else {
                     node.log(`[MQTT] ${device.name} availability已发布`);
                 }
@@ -354,7 +354,7 @@ module.exports = function(RED) {
                 setTimeout(() => {
                     node.mqttClient.publish(config.topic, config.payload, { retain: true }, (err) => {
                         if (err) {
-                            node.error(`发布discovery失败: ${config.topic}, ${err.message}`);
+                            node.log(`发布discovery失败: ${config.topic}, ${err.message}`);
                         }
                     });
                 }, index * 50 + 100);
@@ -369,7 +369,7 @@ module.exports = function(RED) {
                             node.subscriptions.set(topic, deviceMacForSub);
                             node.log(`[MQTT] 订阅成功: ${topic}`);
                         } else {
-                            node.error(`[MQTT] 订阅失败: ${topic}, ${err.message}`);
+                            node.log(`[MQTT] 订阅失败: ${topic}, ${err.message}`);
                         }
                     });
                 }
@@ -389,13 +389,13 @@ module.exports = function(RED) {
         const topic = `symi_mesh/room_${roomNo}/scene/+/trigger`;
 
         if (!node.mqttClient || !node.mqttClient.connected) {
-            node.warn('MQTT客户端未连接，无法订阅场景触发');
+            node.log('MQTT客户端未连接，无法订阅场景触发');
             return;
         }
 
         node.mqttClient.subscribe(topic, (err) => {
             if (err) {
-                node.error(`订阅场景触发主题失败: ${err.message}`);
+                node.log(`订阅场景触发主题失败: ${err.message}`);
             } else {
                 node.log(`已订阅场景触发主题: ${topic}`);
             }
@@ -409,7 +409,7 @@ module.exports = function(RED) {
         // 先发布availability: online，确保HA实体可用
         node.mqttClient.publish(`symi_mesh/${macClean}/availability`, 'online', { retain: true }, (err) => {
             if (err) {
-                node.error(`发布availability失败: ${err.message}`);
+                node.log(`发布availability失败: ${err.message}`);
             }
         });
         
@@ -1049,7 +1049,7 @@ module.exports = function(RED) {
                 node.debug(`[MQTT发布] ${p.topic} = ${p.payload}`);
             });
         } else if (publishes.length > 0) {
-            node.warn(`[MQTT发布失败] MQTT未连接，无法发布${publishes.length}条消息`);
+            node.log(`[MQTT发布失败] MQTT未连接，无法发布${publishes.length}条消息`);
         }
     };
 
@@ -1067,7 +1067,7 @@ module.exports = function(RED) {
 
         if (!deviceMac) {
             // 输出当前所有订阅，帮助调试
-            node.warn(`[MQTT] 未找到topic订阅: ${topic}`);
+            node.log(`[MQTT] 未找到topic订阅: ${topic}`);
             node.debug(`[MQTT] 当前订阅列表 (${node.subscriptions.size}个):`);
             node.subscriptions.forEach((mac, t) => {
                 node.debug(`  ${t} -> ${mac}`);
@@ -1077,7 +1077,7 @@ module.exports = function(RED) {
 
         const device = node.gateway.getDevice(deviceMac);
         if (!device) {
-            node.warn(`[MQTT] 设备未找到: MAC=${deviceMac}, topic=${topic}`);
+            node.log(`[MQTT] 设备未找到: MAC=${deviceMac}, topic=${topic}`);
             return;
         }
         
@@ -1124,7 +1124,7 @@ module.exports = function(RED) {
                             await node.gateway.sendScene(sceneId);
                             node.log(`[MQTT场景] 场景${sceneId}(${sceneInfo.name})控制命令已发送`);
                         } catch(err) {
-                            node.error(`[MQTT场景] 场景触发失败: ${err.message}`);
+                            node.log(`[MQTT场景] 场景触发失败: ${err.message}`);
                         }
                     })();
 
@@ -1145,12 +1145,12 @@ module.exports = function(RED) {
                         node.publishCommandFeedback(device, command, payload, topic);
 
                     } catch(err) {
-                        node.error(`[MQTT发送] 失败: ${err.message}`);
+                        node.log(`[MQTT发送] 失败: ${err.message}`);
                     }
                 }
             })();
         } else {
-            node.warn(`[MQTT解析] 无法解析命令 - topic: ${topic}, payload: ${payload}`);
+            node.log(`[MQTT解析] 无法解析命令 - topic: ${topic}, payload: ${payload}`);
         }
     };
 
@@ -1361,7 +1361,7 @@ module.exports = function(RED) {
                         isUserControl: true
                     });
                 } else {
-                    node.warn(`[MQTT] 无法触发事件: device=${!!device}, gateway=${!!node.gateway}, deviceManager=${!!node.gateway?.deviceManager}`);
+                    node.log(`[MQTT] 无法触发事件: device=${!!device}, gateway=${!!node.gateway}, deviceManager=${!!node.gateway?.deviceManager}`);
                 }
             }
             

package/nodes/symi-rs485-sync.js

@@ -366,7 +366,7 @@ module.exports = function(RED) {
                     const hexStr = cmd.toString('hex').toUpperCase().match(/.{1,2}/g)?.join(' ') || '';
                     node.log(`[A->B] 已发送到B: ${hexStr}`);
                 }).catch(err => {
-                    node.error(`[A->B] 发送失败: ${err.message}`);
+                    node.log(`[A->B] 发送失败: ${err.message}`);
                 });
             }
         }
@@ -431,7 +431,7 @@ module.exports = function(RED) {
                     const hexStr = cmd.toString('hex').toUpperCase().match(/.{1,2}/g)?.join(' ') || '';
                     node.log(`[B->A] 已发送到A: ${hexStr}`);
                 }).catch(err => {
-                    node.error(`[B->A] 发送失败: ${err.message}`);
+                    node.log(`[B->A] 发送失败: ${err.message}`);
                 });
             }
         }
@@ -783,7 +783,7 @@ module.exports = function(RED) {
                     if (mapping.protocolA === 'zhonghong') {
                         const cmd = buildZhonghongQueryCmd(mapping.configA);
                         node.rs485ConfigA.send(cmd).catch(err => {
-                            node.error(`查询A失败: ${err.message}`);
+                            node.log(`查询A失败: ${err.message}`);
                         });
                     }
                 }

package/package.json

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