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

package/README.md

@@ -704,17 +704,19 @@ node-red-contrib-symi-mesh/
 
 ## 更新日志
 
-### 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 场景的双向联动。
@@ -730,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 类型数据解析问题。
+
 
 ## 常见问题排查
 
@@ -889,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-ha-sync.html

@@ -250,96 +250,133 @@
             }
 
             // 渲染映射列表
-            function renderMappings() {
-                var container = $('#mapping-list');
-                container.empty();
-                
-                if (!mappings || !Array.isArray(mappings) || mappings.length === 0) {
-                    container.append('<div class="mapping-empty">暂无映射，点击下方按钮添加</div>');
-                    return;
-                }
-
-                mappings.forEach(function(m, idx) {
-                    try {
-                        var row = $('<div class="mapping-row" data-idx="' + idx + '"></div>');
-                        var symiOpts = getSymiOptions(m.symiMac, m.symiName);
-                        var keyOpts = getKeyOptions(m.symiMac, m.symiKey || 1, m.symiChannels, m.symiEntityType);
-                        var syncModeOpts = getSyncModeOptions(m.syncMode || 0);
-                        var haOpts = getHaOptions(m.haEntityId, m.haEntityName);
-                        
-                        row.html(
-                            '<div class="mapping-main">' +
-                            '<div class="symi-col">' +
-                            '  <select class="symi-select">' + symiOpts + '</select>' +
-                            '  <span class="symi-key-wrap">' + keyOpts + '</span>' +
-                            '</div>' +
-                            '<div class="arrow-col">' + syncModeOpts + '</div>' +
-                            '<div class="ha-col">' +
-                            '  <select class="ha-select">' + haOpts + '</select>' +
-                            '</div>' +
-                            '<div class="del-col"><button type="button" class="red-ui-button red-ui-button-small btn-remove" title="删除"><i class="fa fa-times"></i></button></div>' +
-                            '</div>'
-                        );
-                        container.append(row);
-                    } catch (err) {
-                        console.error("[symi-ha-sync] Render row error:", err, m);
+            $('#mapping-list').css('min-height','300px').editableList({
+                addItem: function(container, i, data) {
+                    var m = data;
+                    // 如果是新添加的项，初始化默认值
+                    if (!m.symiMac && !m.haEntityId) {
+                         m.symiMac = ''; m.symiName = ''; m.symiKey = 1; m.symiChannels = 1; m.symiDeviceType = '';
+                         m.symiEntityType = ''; m.syncMode = 0;
+                         m.haEntityId = ''; m.haEntityName = '';
                     }
-                });
 
-                bindEvents();
-            }
-
-            // 绑定事件
-            function bindEvents() {
-                var container = $('#mapping-list');
-                
-                container.find('.symi-select').off('change').on('change', function() {
-                    var row = $(this).closest('.mapping-row');
-                    var idx = row.data('idx');
-                    var mac = $(this).val();
-                    var opt = $(this).find('option:selected');
+                    var row = $('<div class="mapping-row" style="display:flex;align-items:center;gap:5px;padding:5px 0;"></div>').appendTo(container);
                     
-                    mappings[idx].symiMac = mac || '';
-                    mappings[idx].symiName = opt.data('name') || opt.text().replace(/ \[.*?\]/g, '');
-                    mappings[idx].symiChannels = parseInt(opt.data('channels')) || 1;
-                    mappings[idx].symiDeviceType = opt.data('devicetype') || '';
-                    mappings[idx].symiEntityType = opt.data('entitytype') || '';
-                    mappings[idx].symiKey = 1;
+                    var symiOpts = getSymiOptions(m.symiMac, m.symiName);
+                    var keyOpts = getKeyOptions(m.symiMac, m.symiKey || 1, m.symiChannels, m.symiEntityType);
+                    var syncModeOpts = getSyncModeOptions(m.syncMode || 0);
+                    var haOpts = getHaOptions(m.haEntityId, m.haEntityName);
                     
-                    row.find('.symi-key-wrap').html(getKeyOptions(mac, 1, mappings[idx].symiChannels, mappings[idx].symiEntityType));
-                    bindEvents();
-                });
-
-                container.find('.symi-key').off('change').on('change', function() {
-                    var idx = $(this).closest('.mapping-row').data('idx');
-                    mappings[idx].symiKey = parseInt($(this).val()) || 1;
-                });
+                    // Symi Column
+                    var symiCol = $('<div class="symi-col" style="flex:1;display:flex;gap:4px;min-width:0;"></div>').appendTo(row);
+                    var symiSelect = $('<select class="symi-select" style="flex:1;padding:4px;border:1px solid #81c784;border-radius:3px;background:#e8f5e9;font-size:12px;">' + symiOpts + '</select>').appendTo(symiCol);
+                    var symiKeyWrap = $('<span class="symi-key-wrap">' + keyOpts + '</span>').appendTo(symiCol);
+                    
+                    // Arrow Column
+                    var arrowCol = $('<div class="arrow-col" style="flex:0 0 100px;text-align:center;"></div>').appendTo(row);
+                    var syncModeSelect = $(syncModeOpts).appendTo(arrowCol).css({width:'100%',padding:'4px',border:'1px solid #ccc',borderRadius:'3px',fontSize:'11px'});
+                    
+                    // HA Column
+                    var haCol = $('<div class="ha-col" style="flex:1;min-width:0;"></div>').appendTo(row);
+                    var haSelect = $('<select class="ha-select" style="width:100%;padding:4px;border:1px solid #41BDF5;border-radius:3px;background:#e3f2fd;font-size:12px;">' + haOpts + '</select>').appendTo(haCol);
+
+                    // 绑定事件
+                    symiSelect.on('change', function() {
+                        var mac = $(this).val();
+                        var opt = $(this).find('option:selected');
+                        
+                        m.symiMac = mac || '';
+                        m.symiName = opt.data('name') || opt.text().replace(/ \[.*?\]/g, '');
+                        m.symiChannels = parseInt(opt.data('channels')) || 1;
+                        m.symiDeviceType = opt.data('devicetype') || '';
+                        m.symiEntityType = opt.data('entitytype') || '';
+                        m.symiKey = 1;
+                        
+                        symiKeyWrap.html(getKeyOptions(mac, 1, m.symiChannels, m.symiEntityType));
+                        // 重新绑定新生成的按键下拉框事件
+                        bindKeyEvents();
+                    });
 
-                container.find('.sync-mode').off('change').on('change', function() {
-                    var idx = $(this).closest('.mapping-row').data('idx');
-                    mappings[idx].syncMode = parseInt($(this).val()) || 0;
-                });
+                    function bindKeyEvents() {
+                        symiKeyWrap.find('.symi-key').on('change', function() {
+                            m.symiKey = parseInt($(this).val()) || 1;
+                        });
+                    }
+                    bindKeyEvents();
 
-                container.find('.ha-select').off('change').on('change', function() {
-                    var idx = $(this).closest('.mapping-row').data('idx');
-                    var opt = $(this).find('option:selected');
-                    mappings[idx].haEntityId = $(this).val();
-                    mappings[idx].haEntityName = opt.data('name') || opt.text().split(' (')[0].replace(/ \[.*?\]/g, '');
-                });
+                    syncModeSelect.on('change', function() {
+                        m.syncMode = parseInt($(this).val()) || 0;
+                    });
 
-                container.find('.btn-remove').off('click').on('click', function() {
-                    var idx = $(this).closest('.mapping-row').data('idx');
-                    mappings.splice(idx, 1);
-                    renderMappings();
-                });
+                    haSelect.on('change', function() {
+                        var opt = $(this).find('option:selected');
+                        m.haEntityId = $(this).val();
+                        m.haEntityName = opt.data('name') || opt.text().split(' (')[0].replace(/ \[.*?\]/g, '');
+                    });
+                    
+                    // 保存更新UI的方法供外部调用
+                    container.data('refreshUI', function() {
+                        var currentSymi = symiSelect.val();
+                        var currentKey = symiKeyWrap.find('.symi-key').val();
+                        var currentHa = haSelect.val();
+                        
+                        symiSelect.html(getSymiOptions(m.symiMac, m.symiName));
+                        // 如果之前选中的还在，保持选中；否则选中数据中的值
+                        if (symiSelect.find('option[value="'+currentSymi+'"]').length) symiSelect.val(currentSymi);
+                        
+                        // 刷新按键
+                        // 注意：如果设备列表变了，channels可能变了，所以要重新生成
+                        // 我们需要重新获取设备信息来确认channels
+                        // 但这里简单起见，我们假设 getKeyOptions 会处理
+                        // m.symiChannels 应该在 loadSymiDevices 时更新吗？
+                        // loadSymiDevices 更新了 symiDevices 数组
+                        // 我们需要从 symiDevices 中找到当前设备并更新 m.symiChannels
+                        var dev = symiDevices.find(d => d.macAddress === m.symiMac);
+                        if (dev) {
+                            m.symiChannels = dev.channels;
+                            m.symiEntityType = dev.entityType;
+                        }
+                        
+                        symiKeyWrap.html(getKeyOptions(m.symiMac, m.symiKey, m.symiChannels, m.symiEntityType));
+                        bindKeyEvents();
+                        
+                        haSelect.html(getHaOptions(m.haEntityId, m.haEntityName));
+                        if (haSelect.find('option[value="'+currentHa+'"]').length) haSelect.val(currentHa);
+                    });
+                },
+                sortable: true,
+                removable: true,
+                addButton: false,
+                height: 400
+            });
+            
+            function renderMappings() {
+                // 这个函数现在只用于初次加载
+                if (mappings && mappings.length > 0) {
+                    // 只有当列表为空时才添加，避免重复
+                    if ($('#mapping-list').editableList('items').length === 0) {
+                        mappings.forEach(function(m) {
+                            $('#mapping-list').editableList('addItem', m);
+                        });
+                    } else {
+                        // 如果列表不为空，说明是刷新操作，调用 refreshUI
+                        $('#mapping-list').editableList('items').each(function() {
+                            var refresh = $(this).data('refreshUI');
+                            if (refresh) refresh();
+                        });
+                    }
+                }
             }
 
+            // 绑定事件 (已移至 addItem 内部)
+            function bindEvents() {}
+
             // 刷新按钮
             $('#refresh-symi-btn').on('click', function() {
                 var btn = $(this);
                 btn.prop('disabled', true).find('i').addClass('fa-spin');
                 loadSymiDevices(function() {
-                    renderMappings();
+                    renderMappings(); // 这里会触发 refreshUI
                     btn.prop('disabled', false).find('i').removeClass('fa-spin');
                 });
             });
@@ -348,39 +385,48 @@
                 var btn = $(this);
                 btn.prop('disabled', true).find('i').addClass('fa-spin');
                 loadHaEntities(function() {
-                    renderMappings();
+                    renderMappings(); // 这里会触发 refreshUI
                     btn.prop('disabled', false).find('i').removeClass('fa-spin');
                 });
             });
 
             // 添加映射按钮
             $('#btn-add-mapping').on('click', function() {
-                mappings.push({ 
+                $('#mapping-list').editableList('addItem', { 
                     symiMac: '', symiName: '', symiKey: 1, symiChannels: 1, symiDeviceType: '',
                     symiEntityType: '', syncMode: 0,
                     haEntityId: '', haEntityName: ''
                 });
-                renderMappings();
-                var list = $('#mapping-list');
-                list.scrollTop(list.prop('scrollHeight'));
             });
 
             // 配置变化时重新加载
             $('#node-input-mqttConfig').on('change', function() {
                 setTimeout(function() {
-                    loadSymiDevices(renderMappings);
+                    loadSymiDevices(function() {
+                         // 清空列表并重新渲染，或者只是刷新？
+                         // 如果MQTT配置变了，设备列表完全不同，最好清空
+                         // 但如果用户已经配置了一些，清空会丢失数据
+                         // 所以我们尝试刷新，未找到的会显示红色
+                         renderMappings();
+                    });
                 }, 100);
             });
 
             $('#node-input-haServer').on('change', function() {
                 setTimeout(function() {
-                    loadHaEntities(renderMappings);
+                    loadHaEntities(function() {
+                        renderMappings();
+                    });
                 }, 100);
             });
 
             // 保存时更新所有数据
             node._saveAll = function() {
-                node.mappings = JSON.stringify(mappings);
+                var newMappings = [];
+                $('#mapping-list').editableList('items').each(function() {
+                    newMappings.push($(this).data('data'));
+                });
+                node.mappings = JSON.stringify(newMappings);
                 node.cachedSymiDevices = JSON.stringify(cachedSymiDevices);
                 node.cachedHaEntities = JSON.stringify(cachedHaEntities);
                 $('#node-input-mappings').val(node.mappings);
@@ -400,7 +446,7 @@
             var height = size.height;
             for (var i = 0; i < rows.length; i++) { height -= $(rows[i]).outerHeight(true); }
             height -= 120;
-            $('#mapping-list').css('max-height', Math.max(150, height) + 'px');
+            $('#mapping-list').editableList('height', Math.max(150, height));
         },
         oneditsave: function() {
             if (this._saveAll) { this._saveAll(); }

package/nodes/symi-knx-bridge.html

@@ -112,7 +112,7 @@
                 'climate': ['开关地址*','温度地址','模式地址','风速地址','当前温度'],
                 'fresh_air': ['开关地址*','风速地址'],
                 'floor_heating': ['开关地址*','温度地址','当前温度'],
-                'scene': ['KNX组地址*', '场景号(1-64)*', '绑定Mesh开关状态(1=开/0=关)*']
+                'scene': ['KNX组地址*', '场景号(1-64)*', '触发Mesh动作(1=开/0=关)*']
             };
             
             // 统一的添加/编辑KNX实体面板

package/nodes/symi-knx-bridge.js

@@ -107,6 +107,13 @@ module.exports = function(RED) {
                         mapping.knxAddrTemp = knxEntity.statusAddr || '';
                         mapping.knxAddrCurrentTemp = knxEntity.ext1 || '';
                         break;
+                    case 'scene':
+                        // 场景: 组地址(cmd), 场景号(ext1), 动作(ext2)
+                        // ext1: 场景号 1-64
+                        // ext2: 动作 1=开, 0=关
+                        mapping.sceneNumber = parseInt(knxEntity.ext1) || 1;
+                        mapping.sceneAction = (parseInt(knxEntity.ext2) === 1);
+                        break;
                 }
                 
                 // 收集所有KNX地址用于快速查找
@@ -357,20 +364,19 @@ module.exports = function(RED) {
                         
                         // 检查是否匹配配置的触发动作
                         if (switchValue === mapping.sceneAction) {
+                            // 场景命令 DPT 17.001 (1字节无符号整数)
+                            // payload = 场景号 - 1 (KNX wire format: 0-63)
+                            const scenePayload = mapping.sceneNumber - 1;
+                            
                             // 构造防死循环key
-                            // 注意：这里使用的是 knx-to-mesh 方向的记录来防止 mesh-to-knx 的发送
-                            // 即：如果最近收到了 KNX 场景命令导致 Mesh 变化，这里应该拦截
-                            const sceneLoopKey = `${loopKey}_scene_${mapping.sceneNumber}`;
+                            // 统一使用 KNX 值 (0-63) 作为 key 的一部分
+                            const sceneLoopKey = `${loopKey}_scene_${scenePayload}`;
                             
                             if (node.shouldPreventSync('mesh-to-knx', sceneLoopKey)) {
                                 node.log(`[Mesh->KNX] 跳过场景触发(防死循环): ${sceneLoopKey}`);
                                 continue;
                             }
                             
-                            // 场景命令 DPT 17.001 (1字节无符号整数)
-                            // payload = 场景号 - 1 (KNX wire format: 0-63)
-                            const scenePayload = mapping.sceneNumber - 1;
-                            
                             const knxMsg = {
                                 topic: mapping.knxAddrCmd,
                                 payload: scenePayload,
@@ -1080,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}`;
                     
                     // 防死循环检查
@@ -1094,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,
@@ -1105,11 +1120,55 @@ module.exports = function(RED) {
                     });
                 }
             }
-            // 窗帘设备 - 简化逻辑：谁动谁跟，KNX可抢占控制权
+            // 场景触发逻辑
+            else if (mapping.deviceType === 'scene') {
+                if (addrFunc === 'cmd') { // 场景通常只有一个组地址，这里我们用cmdAddr匹配
+                    // 场景 DPT 17.001 实际上是 0-63 的整数
+                    // 但有时也会用 DPT 5.001 (0-255)
+                    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，都认为匹配
+                    
+                    let matched = false;
+                    // 情况A: 标准 DPT 17.001, 收到值 = 场景号-1
+                    if (receivedScene === (targetScene - 1)) matched = true;
+                    // 情况B: 非标准或用户直接配置了0-63的原始值
+                    else if (receivedScene === targetScene) matched = true;
+
+                    if (matched) {
+                        const action = (mapping.sceneAction === 'on' || mapping.sceneAction === true || mapping.sceneAction === 1);
+                        const loopKey = `${mapping.meshMac}_${mapping.meshChannel}_scene_${receivedScene}`;
+                        
+                        // 防死循环
+                        if (node.shouldPreventSync('knx-to-mesh', loopKey)) {
+                            node.log(`[KNX->Mesh] 跳过场景触发(防死循环): ${loopKey}`);
+                            done && done();
+                            return;
+                        }
+
+                        node.log(`[KNX->Mesh] 场景触发: 收到场景${receivedScene+1} -> Mesh开关=${action?'ON':'OFF'}`);
+                        node.queueCommand({
+                            direction: 'knx-to-mesh',
+                            mapping: mapping,
+                            type: 'switch',
+                            value: action,
+                            key: loopKey,
+                            sourceAddr: groupAddr
+                        });
+                    }
+                }
+            }
+            // 窗帘设备
             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 };
@@ -1126,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();
@@ -1140,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/nodes/symi-knx-ha-bridge.html

@@ -17,17 +17,108 @@
         label: function() { return this.name || 'KNX HA桥接'; },
         oneditprepare: function() {
             const node = this;
-            let mappings = [], haEntities = [], knxEntities = [];
+            
+            // 设置编辑面板更宽更高
+            var panel = $('#dialog-form').parent();
+            if (panel.length) {
+                if (panel.width() < 1000) panel.css('width', '1000px');
+                if (panel.height() < 1000) panel.css('min-height', '1000px');
+            }
+            
+            let haEntities = [];
             const typeLabels = {switch:'开关',light_mono:'单调',light_cct:'双调',light_rgb:'RGB',light_rgbcw:'RGBCW',cover:'窗帘',climate:'空调',fresh_air:'新风',floor_heating:'地暖'};
 
-            try { mappings = JSON.parse(node.mappings || '[]'); } catch(e) { mappings = []; }
-            try { knxEntities = JSON.parse(node.knxEntities || '[]'); } catch(e) { knxEntities = []; }
+            // 初始化列表容器
+            $('#knx-list').css('min-height','300px').css('max-height','500px').editableList({
+                addItem: function(container, i, data) {
+                    const e = data;
+                    const ext = [e.ext1,e.ext2,e.ext3].filter(x=>x).join(',');
+                    const inv = e.type==='cover' ? '<input type="checkbox" class="e-inv" title="位置反转"'+(e.invert?' checked':'')+'>' : '';
+                    
+                    const row = $('<div class="knx-row" style="display:flex;align-items:center;font-size:12px;"></div>').appendTo(container);
+                    $('<div style="flex:2;padding:0 5px;">'+e.name+'</div>').appendTo(row);
+                    $('<div style="flex:1;padding:0 5px;">'+(typeLabels[e.type]||e.type)+inv+'</div>').appendTo(row);
+                    $('<div style="flex:1;padding:0 5px;">'+e.cmdAddr+'</div>').appendTo(row);
+                    $('<div style="flex:1;padding:0 5px;">'+(e.statusAddr||'-')+'</div>').appendTo(row);
+                    $('<div style="flex:1;padding:0 5px;">'+(ext||'-')+'</div>').appendTo(row);
+                    
+                    const btns = $('<div style="width:60px;text-align:right;"></div>').appendTo(row);
+                    $('<button class="red-ui-button red-ui-button-small e-edit" title="编辑"><i class="fa fa-pencil"></i></button>')
+                        .appendTo(btns)
+                        .on('click', function() { editKnxEntity(data, container); });
+                    
+                    container.find('.e-inv').on('change', function() {
+                        e.invert = $(this).is(':checked');
+                    });
+                },
+                sortable: true,
+                removable: true,
+                addButton: false,
+                height: 350
+            });
+
+            $('#map-list').css('min-height','300px').css('max-height','500px').editableList({
+                addItem: function(container, i, data) {
+                    const m = data;
+                    const row = $('<div class="map-row" style="display:flex;align-items:center;gap:5px;"></div>').appendTo(container);
+                    
+                    // KNX实体选择
+                    const selKnx = $('<select class="m-knx" style="flex:1;font-size:11px;"><option value="">--选择KNX--</option></select>').appendTo(row);
+                    function updateKnxOpts() {
+                        const currentVal = selKnx.val() || m.knxEntityId;
+                        selKnx.empty().append('<option value="">--选择KNX--</option>');
+                        const entities = [];
+                        $('#knx-list').editableList('items').each(function() {
+                            entities.push($(this).data('data'));
+                        });
+                        entities.forEach(e => {
+                            const inv = e.invert ? '↕' : '';
+                            $('<option value="'+e.id+'">'+e.name+'['+e.cmdAddr+']('+inv+(typeLabels[e.type]||'')+')</option>').appendTo(selKnx);
+                        });
+                        selKnx.val(currentVal);
+                    }
+                    updateKnxOpts();
+                    container.data('updateKnxOpts', updateKnxOpts);
+                    
+                    // HA实体选择 (使用 datalist 实现搜索)
+                    const listId = 'ha-list-' + Math.floor(Math.random() * 1000000);
+                    $('<input type="text" class="m-ha-input" placeholder="输入实体ID或名称搜索" value="'+(m.haEntityId||'')+'" list="'+listId+'" style="flex:1;font-size:11px;">').appendTo(row);
+                    const datalist = $('<datalist id="'+listId+'"></datalist>').appendTo(row);
+                    
+                    function updateHaOpts() {
+                        datalist.empty();
+                        haEntities.forEach(e => {
+                            $('<option value="'+e.entity_id+'">'+e.name+'</option>').appendTo(datalist);
+                        });
+                    }
+                    updateHaOpts();
+                    // 暴露更新方法
+                    container.data('updateHaOpts', updateHaOpts);
+
+                    // 绑定事件
+                    selKnx.on('change', function() {
+                        m.knxEntityId = $(this).val();
+                    });
+                    row.find('.m-ha-input').on('input change', function() {
+                        m.haEntityId = $(this).val();
+                    });
+                },
+                sortable: true,
+                removable: true,
+                height: 350
+            });
+
+            // 加载初始数据
+            try { 
+                const knxEntities = JSON.parse(node.knxEntities || '[]');
+                knxEntities.forEach(e => $('#knx-list').editableList('addItem', e));
+            } catch(e) {}
 
             function loadHaEntities() {
                 const sid = $('#node-input-haServer').val();
                 if (!sid) { 
                     haEntities = []; 
-                    renderMappings(); 
+                    refreshHaLists();
                     return; 
                 }
                 
@@ -37,7 +128,7 @@
                     .done(function(data) {
                         console.log('[KNX-HA Bridge] 收到响应:', data);
                         haEntities = data || [];
-                        renderMappings();
+                        refreshHaLists();
                         if (haEntities.length > 0) {
                             RED.notify('成功加载 ' + haEntities.length + ' 个HA实体', 'success');
                         } else {
@@ -47,11 +138,28 @@
                     .fail(function(err) {
                         console.error('[KNX-HA Bridge] 加载失败:', err);
                         haEntities = [];
-                        renderMappings();
+                        refreshHaLists();
                         RED.notify('HA服务器还未就绪，请稍后重试', 'warning');
                     });
             }
 
+            function refreshHaLists() {
+                 $('#map-list').editableList('items').each(function() {
+                     const updateFunc = $(this).data('updateHaOpts');
+                     if (updateFunc) updateFunc();
+                 });
+            }
+
+            // 刷新映射列表（主要用于初次加载）
+            function refreshMappings() {
+                if ($('#map-list').editableList('items').length === 0) {
+                    try {
+                        const mappings = JSON.parse(node.mappings || '[]');
+                        mappings.forEach(m => $('#map-list').editableList('addItem', m));
+                    } catch(e) {}
+                }
+            }
+
             $('#download-tpl-btn').on('click', function() {
                 const tpl = `# KNX实体导入模板 (Tab分隔)
 # 格式: 名称	类型	命令地址	状态地址	扩展1	扩展2	扩展3
@@ -81,32 +189,6 @@
                 a.download = 'knx-template.txt'; a.click();
             });
 
-            function renderKnxEntities() {
-                const c = $('#knx-list'); c.empty(); $('#knx-cnt').text(knxEntities.length);
-                if (!knxEntities.length) { c.html('<div class="tips">点击"导入"或"添加"管理KNX实体</div>'); return; }
-                let h = '<table class="tbl"><tr><th>名称</th><th>类型</th><th>命令</th><th>状态</th><th>扩展</th><th style="width:60px">操作</th></tr>';
-                knxEntities.forEach((e,i) => {
-                    const ext = [e.ext1,e.ext2,e.ext3].filter(x=>x).join(',');
-                    const inv = e.type==='cover' ? '<input type="checkbox" class="e-inv" title="位置反转"'+(e.invert?' checked':'')+'>' : '';
-                    h += '<tr data-ei="'+i+'"><td>'+e.name+'</td><td>'+(typeLabels[e.type]||e.type)+inv+'</td><td>'+e.cmdAddr+'</td><td>'+(e.statusAddr||'-')+'</td><td>'+(ext||'-')+'</td><td><button class="red-ui-button red-ui-button-small e-edit" title="编辑"><i class="fa fa-pencil"></i></button> <button class="red-ui-button red-ui-button-small e-del" title="删除"><i class="fa fa-times"></i></button></td></tr>';
-                });
-                c.html(h+'</table>');
-                $('.e-inv').off('change').on('change', function() {
-                    const ei = $(this).closest('tr').data('ei');
-                    knxEntities[ei].invert = $(this).is(':checked');
-                    saveKnxData();
-                });
-                $('.e-edit').off('click').on('click', function() {
-                    const ei = $(this).closest('tr').data('ei');
-                    editKnxEntity(ei);
-                });
-                $('.e-del').off('click').on('click', function() {
-                    const ei = $(this).closest('tr').data('ei');
-                    knxEntities.splice(ei, 1);
-                    renderKnxEntities(); renderMappings();
-                });
-            }
-            
             const typeFields = {
                 'switch': ['命令地址*','状态地址'],
                 'light_mono': ['开关地址*','状态地址','亮度地址'],
@@ -119,11 +201,16 @@
                 'floor_heating': ['开关地址*','温度地址','当前温度']
             };
             
-            let editingIndex = -1;
-            function showEntityPanel(index) {
-                const isEdit = index >= 0;
-                const e = isEdit ? knxEntities[index] : {name:'',type:'switch',cmdAddr:'',statusAddr:'',ext1:'',ext2:'',ext3:'',invert:false};
-                editingIndex = index;
+            // 编辑KNX实体
+            let currentEditContainer = null;
+            let currentEditData = null;
+
+            function showEntityPanel(data, container) {
+                const isEdit = !!data;
+                const e = isEdit ? data : {name:'',type:'switch',cmdAddr:'',statusAddr:'',ext1:'',ext2:'',ext3:'',invert:false};
+                currentEditContainer = container;
+                currentEditData = data;
+
                 const typeOpts = Object.keys(typeLabels).map(t => '<option value="'+t+'"'+(t===e.type?' selected':'')+'>'+typeLabels[t]+'</option>').join('');
                 const title = isEdit ? '编辑: '+e.name : '添加KNX实体';
                 const btnText = isEdit ? '保存' : '添加';
@@ -163,7 +250,8 @@
                     const name = $('#edit-name').val().trim();
                     const cmd = $('#edit-cmd').val().trim();
                     if (!name || !cmd) { RED.notify('请填写名称和命令地址', 'warning'); return; }
-                    const entity = {
+                    
+                    const newData = {
                         id: isEdit ? e.id : 'k'+Date.now()+Math.random().toString(36).substr(2,4),
                         name: name,
                         type: $('#edit-type').val(),
@@ -174,60 +262,35 @@
                         ext3: $('#edit-ext3').val().trim(),
                         invert: $('#edit-inv').is(':checked')
                     };
-                    if (isEdit) { knxEntities[editingIndex] = entity; }
-                    else { knxEntities.push(entity); }
+                    
+                    if (isEdit) {
+                        Object.assign(currentEditData, newData);
+                        const items = [];
+                        $('#knx-list').editableList('items').each(function() {
+                            items.push($(this).data('data'));
+                        });
+                        $('#knx-list').editableList('empty');
+                        items.forEach(item => $('#knx-list').editableList('addItem', item));
+                    } else {
+                        $('#knx-list').editableList('addItem', newData);
+                    }
+                    
+                    $('#map-list').editableList('items').each(function() {
+                        const updateFunc = $(this).data('updateKnxOpts');
+                        if (updateFunc) updateFunc();
+                    });
+
                     $('#edit-panel').hide().empty();
-                    renderKnxEntities(); renderMappings();
                     RED.notify(isEdit?'已更新':'已添加', 'success');
                 });
                 $('#cancel-edit').on('click', function() { $('#edit-panel').hide().empty(); });
             }
-            function editKnxEntity(index) { showEntityPanel(index); }
-
-            function renderMappings() {
-                const c = $('#map-list'); c.empty();
-                if (!mappings.length) { c.html('<div class="tips">点击"添加"创建映射</div>'); return; }
-                let h = '<table class="tbl"><tr><th style="width:24px">#</th><th style="width:45%">KNX实体</th><th style="width:45%">HA实体</th><th style="width:32px">删除</th></tr>';
-                mappings.forEach((m, i) => {
-                    h += '<tr data-i="'+i+'"><td>'+(i+1)+'</td>';
-                    h += '<td><select class="m-knx"><option value="">--选择KNX--</option>';
-                    knxEntities.forEach(e => {
-                        const inv = e.invert ? '↕' : '';
-                        h += '<option value="'+e.id+'"'+(e.id===m.knxEntityId?' selected':'')+'>'+e.name+'['+e.cmdAddr+']('+inv+(typeLabels[e.type]||'')+')</option>';
-                    });
-                    h += '</select></td>';
-                    h += '<td><input type="text" class="m-ha-input" placeholder="输入实体ID或名称搜索" value="'+(m.haEntityId||'')+'" list="ha-list-'+i+'" style="width:100%; font-size:11px">';
-                    h += '<datalist id="ha-list-'+i+'">';
-                    haEntities.forEach(e => {
-                        h += '<option value="'+e.entity_id+'">'+e.name+'</option>';
-                    });
-                    h += '</datalist></td>';
-                    h += '<td><button class="red-ui-button red-ui-button-small m-del" title="删除"><i class="fa fa-times"></i></button></td></tr>';
-                });
-                c.html(h+'</table>');
-                bindEvents();
-            }
-
-            function bindEvents() {
-                $('.m-knx').off('change').on('change', function() {
-                    const i = $(this).closest('tr').data('i');
-                    mappings[i].knxEntityId = $(this).val();
-                });
-                $('.m-ha-input').off('input change').on('input change', function() {
-                    const i = $(this).closest('tr').data('i');
-                    mappings[i].haEntityId = $(this).val();
-                });
-                $('.m-del').off('click').on('click', function() {
-                    mappings.splice($(this).closest('tr').data('i'), 1);
-                    renderMappings();
-                });
-            }
+            function editKnxEntity(data, container) { showEntityPanel(data, container); }
 
             $('#add-map-btn').on('click', function() {
-                mappings.push({ knxEntityId:'', haEntityId:'' });
-                renderMappings();
+                $('#map-list').editableList('addItem', { knxEntityId:'', haEntityId:'' });
             });
-            $('#clear-map-btn').on('click', function() { if(confirm('清空映射？')) { mappings=[]; renderMappings(); } });
+            $('#clear-map-btn').on('click', function() { if(confirm('清空映射？')) { $('#map-list').editableList('empty'); } });
 
             $('#import-btn').on('click', function() { $('#import-modal').show(); });
             $('#import-cancel').on('click', function() { $('#import-modal').hide(); });
@@ -241,21 +304,32 @@
                     const p = line.split(/\t+/);
                     if (p.length >= 2 && p[1] && /\d+\/\d+\/\d+/.test(p[2]||'')) {
                         const id = 'k' + Date.now() + Math.random().toString(36).substr(2,4);
-                        knxEntities.push({ id, name:p[0].trim(), type:p[1].trim(), cmdAddr:p[2].trim(), statusAddr:(p[3]||'').trim(), ext1:(p[4]||'').trim(), ext2:(p[5]||'').trim(), ext3:(p[6]||'').trim(), invert:false });
+                        const entity = { id, name:p[0].trim(), type:p[1].trim(), cmdAddr:p[2].trim(), statusAddr:(p[3]||'').trim(), ext1:(p[4]||'').trim(), ext2:(p[5]||'').trim(), ext3:(p[6]||'').trim(), invert:false };
+                        $('#knx-list').editableList('addItem', entity);
                         cnt++;
                     }
                 });
+                // 刷新映射列表中的KNX选项
+                $('#map-list').editableList('items').each(function() {
+                    const updateFunc = $(this).data('updateKnxOpts');
+                    if (updateFunc) updateFunc();
+                });
                 $('#import-modal').hide(); $('#import-input').val('');
-                renderKnxEntities(); renderMappings();
                 RED.notify('导入 '+cnt+' 个实体'+(cnt?'':'（需要有效组地址格式如1/2/3）'), cnt?'success':'warning');
             });
-            $('#add-knx-btn').on('click', function() { showEntityPanel(-1); });
-            $('#clear-knx-btn').on('click', function() { if(confirm('清空KNX实体？')) { knxEntities=[]; renderKnxEntities(); renderMappings(); } });
+            $('#add-knx-btn').on('click', function() { showEntityPanel(null, null); });
+            $('#clear-knx-btn').on('click', function() { if(confirm('清空KNX实体？')) { $('#knx-list').editableList('empty'); } });
 
-            function saveKnxData() { $('#knx-data').val(JSON.stringify(knxEntities)); }
+            function saveKnxData() { 
+                const entities = [];
+                $('#knx-list').editableList('items').each(function() {
+                    entities.push($(this).data('data'));
+                });
+                $('#knx-data').val(JSON.stringify(entities));
+            }
             
-            const origRender = renderKnxEntities;
-            renderKnxEntities = function() { origRender(); saveKnxData(); };
+            // 渲染后保存 (Deprecated in editableList mode, but kept for compatibility logic if any)
+            // renderKnxEntities = function() { origRender(); saveKnxData(); };
 
             $('#node-input-haServer').on('change', function() {
                 setTimeout(loadHaEntities, 2000);
@@ -269,7 +343,7 @@
             });
             
             setTimeout(function() { 
-                renderKnxEntities(); 
+                refreshMappings();
                 if ($('#node-input-haServer').val()) {
                     setTimeout(loadHaEntities, 2000);
                 }
@@ -277,12 +351,18 @@
         },
         oneditsave: function() {
             const maps = [];
-            $('#map-list tr[data-i]').each(function() {
-                const m = { knxEntityId: $(this).find('.m-knx').val(), haEntityId: $(this).find('.m-ha-input').val() };
+            $('#map-list').editableList('items').each(function() {
+                const m = $(this).data('data');
                 if (m.knxEntityId && m.haEntityId) maps.push(m);
             });
             this.mappings = JSON.stringify(maps);
-            this.knxEntities = $('#knx-data').val() || '[]';
+            
+            const entities = [];
+            $('#knx-list').editableList('items').each(function() {
+                entities.push($(this).data('data'));
+            });
+            $('#knx-data').val(JSON.stringify(entities));
+            this.knxEntities = $('#knx-data').val();
         }
     });
 </script>

package/package.json

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