node-red-contrib-symi-mesh 1.8.12 → 1.8.13

package/README.md

@@ -704,25 +704,19 @@ node-red-contrib-symi-mesh/
 
 ## 更新日志
 
-### v1.8.12 (2026-01-17)
-- **KNX场景同步优化**：新增“场景”设备类型支持，修复了KNX场景(DPT 17.001)触发Mesh开关的逻辑。
-    - **场景映射**：支持配置 KNX 场景号(1-64) 与 Mesh 开关状态(开/关) 的直接映射。
-    - **防死循环**：针对场景触发的单向特性，特别优化了防环路机制，确保 Mesh 状态变化后不会再次触发场景发送。
-- **UI兼容性恢复**：
-    - **字段扩展**：在经典界面中无缝集成了场景配置所需的“场景号”和“动作”字段。
-- **配置窗口优化**：保留了配置窗口的尺寸自动扩展功能，提供更宽敞的编辑视野。
-
-### v1.8.11 (2026-01-16)
+### v1.8.13 (2026-01-18)
+- **KNX 并发控制逻辑修复（关键更新）**：
+    - **禁止状态地址反向触发**：彻底修复了 KNX 总线在场景执行或多设备并发响应时，Mesh 设备出现“相反操作”或错误控制的问题。现在系统严格区分控制地址（Cmd）和状态地址（Status），严禁状态反馈报文触发对 Mesh 设备的控制指令。
+    - **Buffer 类型数据解析增强**：修复了当 KNX 节点传递 Buffer 类型数据（如 `<Buffer 01>`）时，系统错误解析为 `false` (关) 导致的操作反转问题。现在能正确识别 Buffer 格式的开关量。
+    - **并发稳定性**：优化了输入处理逻辑，在高并发场景下（如 KNX 场景同时触发几十个设备）能稳定运行，消除了因状态反馈震荡导致的逻辑错误。
 
-**核心稳定性修复**：
-- **僵尸节点彻底清除**：修复了在删除或修改 KNX 场景映射并重新部署后，旧的配置逻辑仍在后台运行的问题。
-    - **原因分析**：旧节点实例销毁时，未能完全解绑网关事件监听器，导致“僵尸节点”继续响应事件。
-    - **解决方案**：引入 `node.isClosed` 标志位，强制拦截销毁后的所有逻辑执行；同时修复了网关连接状态监听器的内存泄漏问题。
-- **内存泄漏修复**：将所有匿名事件监听器改为具名函数，确保在节点关闭时能被正确移除，防止多次部署后的内存累积。
-- **空指针异常防护**：在 `symi-gateway` 中增加了多处连接状态检查，防止网关断开后后台任务访问已销毁的客户端对象，彻底消除 `Cannot read properties of null (reading 'sendFrame')` 报错刷屏。
-- **UI 显示优化**：修复了 KNX 开关类型在配置列表中错误显示“扩展”列数据的问题，现在开关类型的扩展列将正确显示为“-”。
+### v1.8.10+ (2026-01-18)
 
-### v1.8.10 (2026-01-16)
+**KNX 并发控制逻辑修复（关键更新）**：
+- **禁止状态地址反向触发**：彻底修复了 KNX 总线在场景执行或多设备并发响应时，Mesh 设备出现“相反操作”或错误控制的问题。现在系统严格区分控制地址（Cmd）和状态地址（Status），严禁状态反馈报文触发对 Mesh 设备的控制指令。
+- **Buffer 类型数据解析增强**：修复了当 KNX 节点传递 Buffer 类型数据（如 `<Buffer 01>`）时，系统错误解析为 `false` (关) 导致的操作反转问题。现在能正确识别 Buffer 格式的开关量。
+- **并发稳定性**：优化了输入处理逻辑，在高并发场景下（如 KNX 场景同时触发几十个设备）能稳定运行，消除了因状态反馈震荡导致的逻辑错误。
+- **日志优化**：优化了 TCP 客户端和网关初始化逻辑，对连接超时和离线错误进行节流处理，避免在断网情况下日志刷屏。
 
 **新增功能**：
 - **KNX 场景联动支持**：新增“场景”设备类型，支持 Mesh 开关按键与 KNX 场景的双向联动。
@@ -738,127 +732,18 @@ node-red-contrib-symi-mesh/
             - **逻辑说明**：
                 - **KNX -> Mesh**：收到 KNX 场景号 -> Mesh 开关执行指定状态（如设为 0，则执行关）。
                 - **Mesh -> KNX**：Mesh 开关变为指定状态（如变为关） -> 发送 KNX 场景号。
-- **日志优化**：
-    - **错误限流**：当 Mesh 网关离线时，KNX 同步节点会自动抑制重复的连接错误日志（1分钟内只显示一次），避免日志刷屏。
-    - **网络噪音过滤**：TCP 客户端自动过滤常见的网络连接错误（如 EHOSTUNREACH），减少生产环境的日志干扰。
-
-### 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)
-
-**生产环境日志优化与稳定性增强**：
-- **错误日志节流 (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)
-
-**核心修复与同步增强**：
-- **网关初始化修复**：修复 `symi-gateway` 节点在初始化查询设备状态时的语法错误 (SyntaxError)，确保节点能正常加载。
-- **三合一属性路由优化**：优化 `symi-ha-sync` 路由逻辑，支持将 0x02 属性（开关）正确重定向至三合一子实体处理器，解决三合一面板状态同步失效问题。
-- **HA Climate 协议匹配**：修复 HA `climate` 实体协议不匹配问题，将空调/地暖开关操作映射为 `hvac_mode` (heat/cool/off)，解决同步时的 500 错误。
-- **风速同步双向修复**：
-    - **中英文映射支持**：在 `HA_TO_FAN_MODE` 中增加中文风速（高风/中风/低风/自动）映射，解决 HA 界面操作时的“未知风速值”警告。
-    - **Symi -> HA 值转换**：同步至 HA 时自动将英文风速转换为中文，匹配中文版 HA 实体要求，彻底解决同步时的 500 错误。
-    - **详细日志追踪**：增加 `[Symi->HA] 发送 HA 请求` 详细日志，包含完整的服务调用路径和 Payload。
-
-**三合一设备持久化优化**：
-- **文件持久化存储**：三合一设备类型信息保存到 `~/.node-red/symi-mesh-data/` 目录，实现永久记忆。
-- **检测逻辑优化**：延长检测等待时间至 10 秒（分 20 次检查），解决因网络延迟导致的识别失败。
-- **时序修复**：提前保存 `needsThreeInOneCheck` 状态，确保在响应到达时能正确触发持久化流程。
-
-**Mesh -> HA 同步增强**：
-- **状态缓存细粒度化**：采用 `StateCache` 实现 `{mac}_{subEntity}_{property}` 级别的精确对比，只同步真正变化的属性。
-- **调试日志增强**：三合一相关事件统一使用 `log` 级别输出，便于快速排查同步链路问题。
-
-**设备管理器功能增强**：
-- 新增 `markAsThreeInOne` / `markAsThermostat` 等持久化管理方法，提升系统重启后的设备恢复速度。
-
-### v1.8.5 (2026-01-06)
-
-**通用同步工具类重构**：
-- 新增 `lib/sync-utils.js` 通用同步工具模块
-- 统一 SyncUtils 类：提供防环路逻辑，支持不同设备类型的超时配置
-- 统一 StateCache 类：状态缓存对比，避免重复同步
-- 统一 SyncQueue 类：同步命令队列管理，支持高负载场景
-
-**所有同步节点统一使用 SyncUtils**：
-- HA同步节点 (`symi-ha-sync.js`) 使用 SyncUtils 替代原有防环路实现
-- MQTT同步节点 (`symi-mqtt-sync.js`) 使用 SyncUtils 替代原有防环路实现
-- KNX桥接节点 (`symi-knx-bridge.js`) 重构使用 SyncUtils，移除独立的 LOOP_PREVENTION_MS
-- RS485桥接节点 (`symi-485-bridge.js`) 重构使用 SyncUtils，统一防环路逻辑
-- 统一超时配置：普通设备2秒、窗帘30秒、亮度800ms
-
-**MQTT品牌同步三合一子实体支持**：
-- 新增 `meshSubEntity` 映射字段，支持三合一面板子实体映射
-- 空调子实体 → HYQW type 12 (开关/温度/模式/风速)
-- 新风子实体 → HYQW type 36 (开关/风速)
-- 地暖子实体 → HYQW type 16 (开关/温度)
-- 双向同步：HYQW设备状态变化自动同步到Mesh三合一面板
-
-**代码质量优化**：
-- 消除重复的防环路代码，所有同步节点共用 SyncUtils
-- 节点关闭时正确调用 SyncUtils.destroy() 清理资源
-- 减少内存泄漏风险，统一时间戳清理机制
-
-**三合一状态缓存细粒度优化**：
-- HA同步节点使用 StateCache 实现细粒度状态对比
-- 缓存key格式优化为 `{mac}_{subEntity}_{property}`
-- 只同步真正变化的属性，减少冗余HA API调用
-- 支持空调、新风、地暖各属性独立变化检测
-
-### v1.8.4 (2026-01-06)
-
-**HA同步节点窗帘双向同步重大修复**：
-- 实现"谁发起控制就只听谁的命令"逻辑，彻底解决窗帘双向同步死循环问题
-- Mesh控制时：只同步位置到HA，不发送动作命令
-- HA控制时：发送动作/位置到Mesh，运动过程中忽略Mesh的所有反馈
-- 停止后延迟5秒释放控制权，确保延迟反馈也被正确过滤
-- 只处理HA的`opening`/`closing`状态，忽略`open`/`closed`状态反馈
-
-**其他优化**：
-- 修复HA state_changed事件解析，支持更多消息格式变体
-- 优化空调同步逻辑：只在开关状态真正变化时同步
-- 优化调光同步逻辑：HA发起调光时忽略Mesh步进反馈
-- 增加状态变化检测：无变化时跳过处理
-- 过滤sensor类型实体，避免不必要的处理
-
-**MQTT品牌同步协议修复**：
-- 窗帘设备协议修复：修复窗帘fn=1功能码的正确解析
-- 设备类型独立处理：重构syncToMesh和syncToMqtt函数
-- 完整功能码支持：灯具、空调、窗帘、地暖、新风
-
-**三合一面板深度集成**：
-- 子设备选择：HA同步节点新增三合一子设备选择功能
-- 完整属性同步：支持空调、新风、地暖的全功能双向同步
-
-**稳定性修复**：
-- 修复Mesh控制窗帘时HA反向发送命令导致窗帘停止的问题
-- 修复HA控制窗帘时Mesh反馈导致循环控制的问题
-- 修复窗帘打开命令被防死循环机制阻止的问题
-- 修复空调off->off重复日志的问题
+
+**历史版本功能合并 (v1.8.4 - v1.8.10)**：
+- **三合一面板深度集成**：
+    - 完整支持空调、新风、地暖的全功能双向同步。
+    - 持久化存储设备类型，重启后自动恢复，无需重复探测。
+    - 优化了状态缓存机制，只同步真正变化的属性，减少资源消耗。
+- **稳定性增强**：
+    - **错误日志节流**：在网关连接和 RS485 配置中引入节流机制，彻底解决离线时的日志刷屏问题。
+    - **通用同步工具类**：重构了所有同步节点（HA、MQTT、KNX、RS485），统一使用 `SyncUtils` 类进行防环路和状态缓存管理。
+    - **窗帘同步修复**：实现了"谁发起控制就只听谁的命令"逻辑，彻底解决窗帘双向同步死循环问题。
+    - **协议鲁棒性**：增强了分包与粘包处理，修复了 Buffer 类型数据解析问题。
+
 
 ## 常见问题排查
 
@@ -897,8 +782,8 @@ Copyright (c) 2025 SYMI 亖米
 ---
 
 **作者**: SYMI 亖米
-**版本**: 1.8.6
+**版本**: 1.8.13
 **协议**: 蓝牙MESH网关（初级版）串口协议V1.0
-**最后更新**: 2026-01-07
+**最后更新**: 2026-01-18
 **仓库**: https://github.com/symi-daguo/node-red-contrib-symi-mesh
 **npm包**: https://www.npmjs.com/package/node-red-contrib-symi-mesh

package/lib/tcp-client.js

@@ -51,7 +51,8 @@ class TCPClient extends EventEmitter {
                     if (this.client) {
                         this.client.destroy();
                     }
-                    this.logger.error('Connection timeout');
+                    // 超时通常也是网络问题，使用warn而不是error，并由上层逻辑决定是否显示
+                    // this.logger.error('Connection timeout'); // 移除错误日志，避免刷屏
                     this.handleDisconnect();
                     reject(new Error('Connection timeout'));
                 }
@@ -109,9 +110,9 @@ class TCPClient extends EventEmitter {
                     this.logger.warn(`TCP连接失败: 无法连接到 ${this.host}:${this.port}`);
                 }
                 // 只在首次连接或重要错误时记录，避免大量重复日志
-                // ECONNRESET通常是网络波动，不记录错误
+                // ECONNRESET/EHOSTDOWN 通常是网络波动，不记录错误
                 // EHOSTUNREACH/ETIMEDOUT 也是常见网络错误，不记录
-                else if (!this.connected && !['ECONNREFUSED', 'ECONNRESET', 'EHOSTUNREACH', 'ETIMEDOUT'].includes(error.code)) {
+                else if (!this.connected && !['ECONNREFUSED', 'ECONNRESET', 'EHOSTUNREACH', 'EHOSTDOWN', 'ETIMEDOUT'].includes(error.code)) {
                     this.logger.log('TCP client error: ' + error.message);
                 }
 

package/nodes/symi-gateway.js

@@ -139,6 +139,7 @@ module.exports = function(RED) {
             
         } catch (error) {
             // 初始连接失败，但自动重连会继续尝试
+            // 使用节流日志，避免初始化时如果立刻连不上就刷屏
             this.logErrorThrottled(`Initial connection failed: ${error.message}, will retry automatically`);
         }
 

package/nodes/symi-knx-bridge.js

@@ -1086,11 +1086,20 @@ module.exports = function(RED) {
             // 确定地址功能（优先使用地址匹配，比DPT更可靠）
             const addrFunc = node.getKnxAddrFunction(mapping, groupAddr);
             
+            // 通用值解析：支持 Boolean, Number, String, Buffer
+            const parseBoolean = (val) => {
+                if (Buffer.isBuffer(val)) {
+                    return val.length > 0 && val[0] !== 0;
+                }
+                return (val === 1 || val === true || val === 'on' || val === 'ON' || val === '1');
+            };
+
             // 根据设备类型和地址功能处理
+            // 重要修复：严禁 Status/反馈地址触发控制逻辑，防止反向操作和死循环
             if (mapping.deviceType === 'switch') {
-                // 开关命令（只处理cmd地址）
-                if (addrFunc === 'cmd' || addrFunc === 'status') {
-                    const switchValue = (value === 1 || value === true || value === 'on' || value === 'ON');
+                // 开关命令（只处理cmd地址，忽略status地址）
+                if (addrFunc === 'cmd') {
+                    const switchValue = parseBoolean(value);
                     const loopKey = `${mapping.meshMac}_${mapping.meshChannel}_switch_${switchValue}`;
                     
                     // 防死循环检查
@@ -1100,7 +1109,7 @@ module.exports = function(RED) {
                         return;
                     }
 
-                    node.log(`[KNX输入] 收到: ${groupAddr} = ${value}, DPT=${dpt}, 功能=${addrFunc}, 设备=${mapping.deviceType}`);
+                    node.log(`[KNX->Mesh] 开关控制: ${mapping.name} CH${mapping.meshChannel} = ${switchValue ? 'ON' : 'OFF'}`);
                     node.queueCommand({
                         direction: 'knx-to-mesh',
                         mapping: mapping,
@@ -1111,20 +1120,20 @@ module.exports = function(RED) {
                     });
                 }
             }
-            // 场景触发逻辑 (新增)
+            // 场景触发逻辑
             else if (mapping.deviceType === 'scene') {
                 if (addrFunc === 'cmd') { // 场景通常只有一个组地址，这里我们用cmdAddr匹配
                     // 场景 DPT 17.001 实际上是 0-63 的整数
                     // 但有时也会用 DPT 5.001 (0-255)
-                    const receivedScene = parseInt(value) || 0;
+                    let receivedScene = 0;
+                    if (Buffer.isBuffer(value)) receivedScene = value[0];
+                    else receivedScene = parseInt(value) || 0;
+                    
                     const targetScene = parseInt(mapping.sceneNumber) || 1; // 配置的场景号 (1-64)
                     
                     // KNX场景值通常是 场景号-1 (例如场景1发送0)
                     // 但也有设备发送直接的场景号，这里我们兼容两种情况：
                     // 如果接收值 == 配置值，或者 接收值 == 配置值-1，都认为匹配
-                    // 更严谨的做法是：DPT 17.001 规定传输值 = 场景号 - 1
-                    // 所以如果配置的是1 (UI显示1)，实际收到应该是0
-                    // 我们这里做宽容匹配：
                     
                     let matched = false;
                     // 情况A: 标准 DPT 17.001, 收到值 = 场景号-1
@@ -1155,11 +1164,11 @@ module.exports = function(RED) {
                     }
                 }
             }
-            // 窗帘设备 - 简化逻辑：谁动谁跟，KNX可抢占控制权
+            // 窗帘设备
             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
+                const loopKey = `${mapping.meshMac}_${mapping.meshChannel}_cover`; // 窗帘使用通用key
                 
                 // KNX主动发起控制，直接抢占锁定（用户操作优先）
                 node.controlLock[deviceKey] = { controller: 'knx', lockUntil: now + COVER_CONTROL_LOCK_MS };
@@ -1176,13 +1185,18 @@ module.exports = function(RED) {
                     // 停止时解除锁定
                     delete node.controlLock[deviceKey];
                 }
-                else if (addrFunc === 'position' || addrFunc === 'status') {
-                    const pos = mapping.invertPosition ? (100 - (parseInt(value) || 0)) : (parseInt(value) || 0);
+                else if (addrFunc === 'position') { // 仅 position 地址触发，忽略 status
+                    let pos = 0;
+                    if (Buffer.isBuffer(value)) pos = value[0];
+                    else pos = parseInt(value) || 0;
+                    
+                    if (mapping.invertPosition) pos = 100 - pos;
+                    
                     node.log(`[KNX->Mesh] 窗帘位置: ${pos}%`);
                     node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'cover_position', value: pos, key: loopKey, sourceAddr: groupAddr });
                 }
             }
-            // 调光灯设备 - 简化逻辑：谁动谁跟，KNX可抢占控制权
+            // 调光灯设备
             else if (mapping.deviceType.startsWith('light_')) {
                 const deviceKey = `${(mapping.meshMac || '').toLowerCase().replace(/:/g, '')}_light`;
                 const now = Date.now();
@@ -1190,59 +1204,107 @@ module.exports = function(RED) {
                 // KNX主动发起控制，直接抢占锁定（用户操作优先）
                 node.controlLock[deviceKey] = { controller: 'knx', lockUntil: now + COVER_CONTROL_LOCK_MS };
                 
-                if (addrFunc === 'cmd' || addrFunc === 'status') {
+                if (addrFunc === 'cmd') { // 仅 cmd 地址触发，忽略 status
                     // 开关
-                    const sw = (value === 1 || value === true);
+                    const sw = parseBoolean(value);
+                    const loopKey = `${mapping.meshMac}_light_switch`;
+                    
+                    if (node.shouldPreventSync('knx-to-mesh', loopKey)) {
+                        node.debug(`[KNX->Mesh] 调光灯跳过: ${loopKey}`);
+                        done && done();
+                        return;
+                    }
+                    
                     node.log(`[KNX->Mesh] 调光灯开关: ${sw ? 'ON' : 'OFF'}`);
                     node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'light_switch', value: sw, key: loopKey, sourceAddr: groupAddr });
                 }
                 else if (addrFunc === 'brightness') {
                     // 亮度 (KNX 0-255 -> Mesh 0-100)
-                    const brightness = Math.round((parseInt(value) || 0) * 100 / 255);
+                    let val = 0;
+                    if (Buffer.isBuffer(value)) val = value[0];
+                    else val = parseInt(value) || 0;
+                    
+                    const brightness = Math.round(val * 100 / 255);
+                    const loopKey = `${mapping.meshMac}_light_brightness`;
+                    
+                    if (node.shouldPreventSync('knx-to-mesh', loopKey)) {
+                        done && done();
+                        return;
+                    }
+                    
                     node.log(`[KNX->Mesh] 调光灯亮度: ${brightness}%`);
                     node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'light_brightness', value: brightness, key: loopKey, sourceAddr: groupAddr });
                 }
                 else if (addrFunc === 'colorTemp') {
                     // 色温
-                    node.log(`[KNX->Mesh] 调光灯色温: ${value}`);
-                    node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'light_color_temp', value: parseInt(value) || 50, key: loopKey, sourceAddr: groupAddr });
+                    let ct = 0;
+                    if (Buffer.isBuffer(value)) ct = value[0];
+                    else ct = parseInt(value) || 50;
+                    
+                    const loopKey = `${mapping.meshMac}_light_ct`;
+                    if (node.shouldPreventSync('knx-to-mesh', loopKey)) return;
+                    
+                    node.log(`[KNX->Mesh] 调光灯色温: ${ct}`);
+                    node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'light_color_temp', value: ct, key: loopKey, sourceAddr: groupAddr });
                 }
             }
             // 空调设备
             else if (mapping.deviceType === 'climate') {
                 if (addrFunc === 'cmd') {
-                    node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'climate_switch', value: value === 1 || value === true, key: loopKey, sourceAddr: groupAddr });
+                    const sw = parseBoolean(value);
+                    node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'climate_switch', value: sw, key: `${mapping.meshMac}_climate_sw`, sourceAddr: groupAddr });
                 }
-                else if (addrFunc === 'temp' || addrFunc === 'status') {
-                    node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'climate_temp', value: parseFloat(value) || 24, key: loopKey, sourceAddr: groupAddr });
+                else if (addrFunc === 'temp') { // 忽略 status
+                    let temp = 24;
+                    // DPT 9.001 浮点数解析通常由 knx-ultimate 完成，这里假设是数字
+                    if (typeof value === 'number') temp = value;
+                    else temp = parseFloat(value) || 24;
+                    
+                    node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'climate_temp', value: temp, key: `${mapping.meshMac}_climate_temp`, sourceAddr: groupAddr });
                 }
                 else if (addrFunc === 'mode') {
-                    node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'climate_mode', value: parseInt(value) || 1, key: loopKey, sourceAddr: groupAddr });
+                    let mode = 1;
+                    if (Buffer.isBuffer(value)) mode = value[0];
+                    else mode = parseInt(value) || 1;
+                    
+                    node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'climate_mode', value: mode, key: `${mapping.meshMac}_climate_mode`, sourceAddr: groupAddr });
                 }
                 else if (addrFunc === 'fanSpeed') {
-                    // 风速
-                    node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'climate_fan', value: parseInt(value) || 1, key: loopKey, sourceAddr: groupAddr });
+                    let fan = 1;
+                    if (Buffer.isBuffer(value)) fan = value[0];
+                    else fan = parseInt(value) || 1;
+                    
+                    node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'climate_fan', value: fan, key: `${mapping.meshMac}_climate_fan`, sourceAddr: groupAddr });
                 }
             }
             // 新风设备
             else if (mapping.deviceType === 'fresh_air') {
                 if (addrFunc === 'cmd') {
-                    node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'fresh_air_switch', value: value === 1 || value === true, key: loopKey, sourceAddr: groupAddr });
+                    const sw = parseBoolean(value);
+                    node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'fresh_air_switch', value: sw, key: `${mapping.meshMac}_fa_sw`, sourceAddr: groupAddr });
                 }
-                else if (addrFunc === 'fanSpeed' || addrFunc === 'status') {
+                else if (addrFunc === 'fanSpeed') { // 忽略 status
                     // 百分比转风速: >66=高(1), >33=中(2), <=33=低(3)
-                    const pct = parseInt(value) || 0;
+                    let pct = 0;
+                    if (Buffer.isBuffer(value)) pct = value[0];
+                    else pct = parseInt(value) || 0;
+                    
                     const speed = pct > 66 ? 1 : pct > 33 ? 2 : 3;
-                    node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'fresh_air_speed', value: speed, key: loopKey, sourceAddr: groupAddr });
+                    node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'fresh_air_speed', value: speed, key: `${mapping.meshMac}_fa_speed`, sourceAddr: groupAddr });
                 }
             }
             // 地暖设备
             else if (mapping.deviceType === 'floor_heating') {
                 if (addrFunc === 'cmd') {
-                    node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'floor_heating_switch', value: value === 1 || value === true, key: loopKey, sourceAddr: groupAddr });
+                    const sw = parseBoolean(value);
+                    node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'floor_heating_switch', value: sw, key: `${mapping.meshMac}_fh_sw`, sourceAddr: groupAddr });
                 }
-                else if (addrFunc === 'temp' || addrFunc === 'status') {
-                    node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'floor_heating_temp', value: parseFloat(value) || 24, key: loopKey, sourceAddr: groupAddr });
+                else if (addrFunc === 'temp') { // 忽略 status
+                    let temp = 24;
+                    if (typeof value === 'number') temp = value;
+                    else temp = parseFloat(value) || 24;
+                    
+                    node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'floor_heating_temp', value: temp, key: `${mapping.meshMac}_fh_temp`, sourceAddr: groupAddr });
                 }
             }
             

package/package.json

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