node-red-contrib-symi-mesh 1.8.7 → 1.8.9

package/README.md

@@ -704,6 +704,29 @@ node-red-contrib-symi-mesh/
 
 ## 更新日志
 
+### v1.8.9 (2026-01-14)
+
+**KNX 协议回显消除算法升级**：
+- **值校验机制**：在原有的“时间窗口”回显消除基础上，新增“状态值”深度比对。
+    - **原理**：当 KNX 收到消息时，不仅检查该设备最近是否发送过命令，还对比收到的值与发出的值是否一致。
+    - **效果**：彻底解决“Mesh 开 -> KNX 开 -> 立即 KNX 关”场景下，OFF 指令被误判为回显而被拦截的问题。只有当时间相近且值完全相同时，才判定为回显并忽略；值发生变化时，立即响应并同步，实现毫秒级双向跟随。
+**KNX 开关双向同步逻辑深度优化**：
+- **防死循环机制精细化**：将开关设备的防死循环锁从“设备+通道”级别细化到“设备+通道+状态值”级别。
+    - **修复场景**：KNX 控制打开（ON）后，立即手动关闭 Mesh 设备（OFF），旧版本会因死循环锁未过期而丢弃 OFF 状态上报。
+    - **新逻辑**：KNX 发送 ON 指令只锁定 Mesh->KNX 的 ON 上报，不影响 Mesh->KNX 的 OFF 上报，确保快速连续反向操作能 100% 同步。
+- **状态同步零延迟**：移除不必要的通用防抖检查，确保 Mesh 端的状态变化能毫秒级同步到 KNX 总线。
+
+### 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)
 
 **生产环境日志优化与稳定性增强**：

package/nodes/rs485-debug.js

@@ -178,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

@@ -105,7 +105,7 @@ module.exports = function(RED) {
             try {
                 if (node.connectionType === 'serial') {
                     if (!node.serialPort) {
-                        node.error('未配置串口');
+                        node.log('未配置串口');
                         return;
                     }
                     
@@ -157,7 +157,7 @@ module.exports = function(RED) {
 
                 } else if (node.connectionType === 'tcp') {
                     if (!node.host) {
-                        node.error('未配置TCP主机');
+                        node.log('未配置TCP主机');
                         return;
                     }
 
@@ -210,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} 未找到`);
                         }
                     }
                 }

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;
         }

package/nodes/symi-ha-sync.js

@@ -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) {
@@ -152,7 +152,8 @@ module.exports = function(RED) {
         node.lastSyncTime = 0;
         node.stateCache = {};           // Mesh设备状态缓存
         node.knxStateCache = {};        // KNX设备状态缓存
-        node.lastKnxAddrSent = {};      // 记录发送到KNX地址的时间，防止自己发的命令又被处理
+        node.lastKnxAddrSent = {};      // 记录发送到KNX地址的时间
+        node.lastKnxValueSent = {};     // 记录发送到KNX地址的值
         
         // 初始化通用同步工具类
         node.syncUtils = new SyncUtils({
@@ -259,13 +260,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,12 +298,17 @@ 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') {
                     // 窗帘的防死循环在内部单独处理，这里不跳过
-                } else {
+                } 
+                // 开关设备使用带值的精细化key，这里先不检查
+                else if (mapping.deviceType === 'switch') {
+                    // 在具体处理逻辑中检查
+                }
+                else {
                     // 其他设备统一防死循环检查
                     if (node.shouldPreventSync('mesh-to-knx', loopKey)) {
                         node.log(`[Mesh->KNX] 跳过(防死循环): ${loopKey}`);
@@ -313,13 +320,22 @@ module.exports = function(RED) {
                 if (mapping.deviceType === 'switch') {
                     const switchKey = `switch_${mapping.meshChannel}`;
                     if (changed[switchKey] !== undefined) {
-                        node.log(`[Mesh->KNX] 开关变化: ${mapping.name || eventData.device.name} CH${mapping.meshChannel} = ${changed[switchKey]}`);
+                        const val = changed[switchKey];
+                        const switchValue = (val === 1 || val === true || val === 'on' || val === 'ON');
+                        const specificLoopKey = `${loopKey}_switch_${switchValue}`;
+                        
+                        if (node.shouldPreventSync('mesh-to-knx', specificLoopKey)) {
+                            node.log(`[Mesh->KNX] 跳过(防死循环): ${specificLoopKey}`);
+                            continue;
+                        }
+
+                        node.log(`[Mesh->KNX] 开关变化: ${mapping.name || eventData.device.name} CH${mapping.meshChannel} = ${val}`);
                         node.queueCommand({
                             direction: 'mesh-to-knx',
                             mapping: mapping,
                             type: 'switch',
-                            value: changed[switchKey],
-                            key: loopKey
+                            value: val,
+                            key: specificLoopKey
                         });
                     }
                 }
@@ -550,7 +566,7 @@ module.exports = function(RED) {
                         }
                         await node.sleep(50);  // 命令间隔50ms
                     } catch (err) {
-                        node.error(`同步失败: ${err.message}`);
+                        node.log(`同步失败: ${err.message}`);
                     }
                 }
             } finally {
@@ -759,6 +775,7 @@ module.exports = function(RED) {
                 // 记录发送到的KNX地址和时间，防止自己发的命令又被处理
                 const destAddr = knxMsg.knx.destination;
                 node.lastKnxAddrSent[destAddr] = Date.now();
+                node.lastKnxValueSent[destAddr] = knxMsg.payload;
                 
                 // knxUltimate输入格式：topic + destination + payload + dpt + event
                 // topic: 当setTopicType=str时，knxUltimate使用msg.topic作为目标地址
@@ -928,7 +945,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 +958,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 +974,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,25 +981,44 @@ module.exports = function(RED) {
                 done && done();
                 return;
             }
-            
-            // 确定地址功能（优先使用地址匹配，比DPT更可靠）
-            const addrFunc = node.getKnxAddrFunction(mapping, groupAddr);
-            const loopKey = `${mapping.meshMac}_${mapping.meshChannel}`;
-            
-            // 防死循环检查（基于设备的双向同步防护）
-            if (node.shouldPreventSync('knx-to-mesh', loopKey)) {
-                node.debug(`[KNX->Mesh] 跳过同步(防死循环): ${loopKey}, addr=${groupAddr}`);
+
+            // 检查是否是我们自己发出去的命令（防止自己发的命令被监听后又处理）
+            // 检查该设备的所有关联地址，只要有一个最近发送过且值相同，就认为是回显
+            const isEcho = mapping.allKnxAddrs.some(addr => {
+                const lastSentTime = node.lastKnxAddrSent[addr] || 0;
+                const inWindow = (Date.now() - lastSentTime) < DEFAULT_TIMEOUT;
+                if (!inWindow) return false;
+                
+                // 如果在时间窗口内，进一步检查值是否相同
+                const lastValue = node.lastKnxValueSent[addr];
+                // 对于布尔值，直接比较；对于数字，允许微小误差？KNX通常是精确的
+                return msg.payload === lastValue;
+            });
+
+            if (isEcho) {
+                node.debug(`[KNX输入] 跳过(自己发的回显): ${groupAddr} (设备: ${mapping.name}, 值: ${msg.payload})`);
                 done && done();
                 return;
             }
             
-            node.log(`[KNX输入] 收到: ${groupAddr} = ${value}, DPT=${dpt}, 功能=${addrFunc}, 设备=${mapping.deviceType}`);
+            // 确定地址功能（优先使用地址匹配，比DPT更可靠）
+            const addrFunc = node.getKnxAddrFunction(mapping, groupAddr);
             
             // 根据设备类型和地址功能处理
             if (mapping.deviceType === 'switch') {
                 // 开关命令（只处理cmd地址）
                 if (addrFunc === 'cmd' || addrFunc === 'status') {
                     const switchValue = (value === 1 || value === true || value === 'on' || value === 'ON');
+                    const loopKey = `${mapping.meshMac}_${mapping.meshChannel}_switch_${switchValue}`;
+                    
+                    // 防死循环检查
+                    if (node.shouldPreventSync('knx-to-mesh', loopKey)) {
+                        node.debug(`[KNX->Mesh] 跳过同步(防死循环): ${loopKey}, addr=${groupAddr}`);
+                        done && done();
+                        return;
+                    }
+
+                    node.log(`[KNX输入] 收到: ${groupAddr} = ${value}, DPT=${dpt}, 功能=${addrFunc}, 设备=${mapping.deviceType}`);
                     node.queueCommand({
                         direction: 'knx-to-mesh',
                         mapping: mapping,
@@ -999,6 +1033,7 @@ module.exports = function(RED) {
             else if (mapping.deviceType === 'cover') {
                 const deviceKey = (mapping.meshMac || '').toLowerCase().replace(/:/g, '');
                 const now = Date.now();
+                const loopKey = `${mapping.meshMac}_${mapping.meshChannel}_cover`; // 窗帘使用通用key，因为有专门的controlLock
                 
                 // KNX主动发起控制，直接抢占锁定（用户操作优先）
                 node.controlLock[deviceKey] = { controller: 'knx', lockUntil: now + COVER_CONTROL_LOCK_MS };

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}`);
                         }
                     })();
 
@@ -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.7",
+  "version": "1.8.9",
   "description": "Node-RED节点集合，用于通过TCP/串口连接Symi蓝牙Mesh网关，支持Home Assistant MQTT Discovery自动发现和云端数据同步",
   "main": "nodes/symi-gateway.js",
   "scripts": {