node-red-contrib-symi-mesh 1.6.8 → 1.6.9

package/README.md

@@ -16,6 +16,7 @@
 - **三合一面板**：完整支持空调+新风+地暖三合一控制面板，自动识别
 - **RS485/Modbus集成**：支持第三方485设备双向同步，内置协议模板
 - **KNX集成**：支持与KNX系统双向同步
+- **KNX-HA集成**：支持KNX与Home Assistant实体直接双向同步
 - **云端同步**：从酒店云云平台自动获取设备名称和场景信息
 - **稳定可靠**：完善的错误处理和自动重连机制
 
@@ -179,6 +180,208 @@ node-red-restart
 
 每个功能独立同步，互不干扰。
 
+## KNX-HA双向同步
+
+本节点支持KNX与Home Assistant实体直接双向同步，实现KNX系统与HA的实时互联互通。
+
+### 功能特点
+
+- **直接实体同步**：通过HA events-state节点实时接收HA状态变化事件
+- **KNX实体导入**：支持Tab分隔格式导入KNX组地址配置，与KNX桥接节点100%一致
+- **HA实体加载**：从HA服务器节点自动加载所有支持的实体
+- **快速输入**：支持直接输入实体ID或名称搜索，带autocomplete提示，支持806+实体
+- **多设备类型**：开关、灯光、窗帘、空调、风扇
+- **双向同步**：自动处理KNX↔HA状态同步
+- **智能防抖**：调光300ms、窗帘500ms防抖，避免过程中频繁同步
+- **防死循环**：内置800ms防抖机制
+- **持久化保存**：映射配置自动保存，重启后保持
+- **宽屏界面**：对话框最小900px宽度，适配大屏幕
+
+### 配置步骤
+
+#### 1. 安装依赖节点
+
+```bash
+cd ~/.node-red
+npm install node-red-contrib-knx-ultimate
+npm install node-red-contrib-home-assistant-websocket
+```
+
+#### 2. 配置HA服务器
+
+1. 添加Home Assistant服务器配置节点（如果还没有）
+2. 输入HA的URL和访问令牌
+3. 测试连接确保成功
+
+#### 3. 添加KNX-HA桥接节点
+
+从"Symi Mesh"分类中拖入"KNX-HA桥接"节点
+
+#### 4. 选择HA服务器
+
+在节点配置中选择已配置的Home Assistant服务器节点
+
+#### 5. 导入KNX实体
+
+1. 点击"下载模板"获取导入格式示例
+2. 按照Tab分隔格式准备KNX组地址数据
+3. 点击"导入"按钮，粘贴数据
+4. 确认导入
+
+**导入格式示例**：
+```
+玄关射灯	switch	1/1/28	1/2/28
+客厅吊灯	light	1/1/10	1/2/10	1/3/10	1/4/10
+客厅布帘	cover	2/1/5	2/2/5	2/3/5
+主卧空调	climate	3/1/1	3/2/1	3/3/1	3/4/1	3/5/1
+```
+
+#### 6. 加载HA实体
+
+1. 选择HA服务器后，系统会自动加载实体（约2秒延迟）
+2. 如果未成功加载，点击"刷新"按钮重新加载
+3. 系统使用HA REST API直接获取实体列表
+
+#### 7. 配置映射
+
+1. 点击"添加"按钮
+2. 选择KNX实体
+3. 输入或选择HA实体（支持直接输入实体ID或输入名称快速搜索）
+4. 可以配置多个映射关系
+
+#### 8. 连接KNX节点
+
+```
+[knxUltimate-in] → [KNX-HA桥接] → [knxUltimate-out]
+```
+
+**knxUltimate-in配置**：
+- Listen to all GA：勾选
+- Telegram type：写入
+- Notify on write：勾选
+- Notify on response：勾选
+
+**knxUltimate-out配置**：
+- Listen to all GA：勾选（Universal Mode）
+- Output type：Write
+
+#### 9. 连接HA节点（实现HA→KNX同步）
+
+```
+[HA server-state-changed] → [KNX-HA桥接]
+```
+
+**HA server-state-changed配置**：
+- 节点类型：events: state changed
+- 实体ID：选择映射中的HA实体（或留空监听所有）
+- 输出属性：data（包含entity_id、new_state、old_state）
+
+**重要**：server-state-changed节点必须直接连接到KNX-HA桥接节点的输入，不要通过knxUltimate-in
+
+#### 10. 部署
+
+点击"部署"按钮，开始双向同步
+
+### 支持的设备类型
+
+| KNX设备类型 | HA实体类型 | 同步内容 | KNX地址字段 |
+|------------|-----------|----------|-------------|
+| 开关 | switch | 开/关状态 | 命令, 状态 |
+| 灯光 | light | 开关、亮度、色温 | 开关, 状态, 亮度, 色温 |
+| 窗帘 | cover | 开关、位置、停止 | 上下, 位置, 停止 |
+| 空调 | climate | 开关、温度、模式 | 开关, 温度, 模式, 风速, 当前温度 |
+| 风扇 | fan | 开关、风速 | 开关, 风速 |
+
+### 连接方式
+
+```
+[knxUltimate-in] → [KNX-HA桥接] → [knxUltimate-out]
+[server-state-changed] → [KNX-HA桥接] ↗
+```
+
+**说明**：
+- KNX→HA：knxUltimate-in → KNX-HA桥接，自动调用HA服务
+- HA→KNX：server-state-changed → KNX-HA桥接，桥接节点发送KNX命令到knxUltimate-out
+
+### 工作原理
+
+#### KNX → HA 同步
+
+1. KNX设备状态变化（如开关按下）
+2. knxUltimate-in节点接收GroupValue_Write
+3. KNX-HA桥接节点检测到变化
+4. 调用HA REST API服务（如switch.turn_on）
+5. HA实体状态更新
+
+#### HA → KNX 同步
+
+1. HA实体状态变化（如在HA界面操作）
+2. server-state-changed节点实时推送state_changed事件
+3. KNX-HA桥接节点接收HA事件
+4. 桥接节点发送KNX GroupValue_Write命令到knxUltimate-out
+5. KNX设备执行动作
+
+**防抖机制**：
+- 调光灯亮度：300ms防抖，只同步最终值
+- 窗帘位置：500ms防抖，避免移动过程中频繁同步
+- 开关控制：立即同步，无延迟
+
+### 注意事项
+
+1. **5秒初始化延迟**：部署后前5秒不同步，等待系统初始化
+2. **事件驱动**：HA→KNX通过events-state节点实时推送，无轮询开销
+3. **防死循环**：KNX/HA控制后800ms内，反向状态变化不会同步
+4. **智能防抖**：调光300ms、窗帘500ms防抖，只同步最终值
+5. **持久化配置**：所有映射配置自动保存，重启后保持
+6. **内存优化**：命令队列限制100条，自动清理过期缓存
+7. **宽屏界面**：对话框最小1000px，映射列表高度400px
+8. **快速输入**：支持直接输入实体ID或输入名称快速定位
+9. **断线恢复**：支持断电断网后自动重连
+
+### 故障排查
+
+**KNX→HA不工作**：
+1. 检查日志是否有`[KNX输入]`输出
+2. 确认knxUltimate-in节点已启用"Listen to all GA"
+3. 确认KNX组地址与映射中的地址一致
+4. 检查HA URL和Token是否正确
+5. 手动操作KNX设备，观察日志
+6. 查看调试输出端口的消息
+
+**HA→KNX不工作**：
+1. 检查日志是否有`[HA->KNX]`输出
+2. 确认HA实体ID与映射中的实体ID一致
+3. 确认HA服务器节点已连接并启用WebSocket
+4. 在HA中操作实体，观察日志
+5. 检查knxUltimate-out节点配置
+6. 确认knxUltimate-out已启用"Listen to all GA"（Universal Mode）
+
+**加载HA实体失败**：
+1. 检查HA服务器节点是否正确配置
+2. 确认HA服务器节点已连接
+3. 点击"刷新"按钮重新加载
+4. 检查是否安装了node-red-contrib-home-assistant-websocket
+5. 查看Node-RED日志中的详细错误信息
+
+### 使用场景
+
+**适合使用KNX-HA桥接的场景**：
+- HA中已有KNX集成，希望与其他系统整合
+- 需要KNX设备与HA中的Zigbee、WiFi等设备联动
+- 希望在HA中统一管理所有设备
+- 需要利用HA的自动化和场景功能
+- 已安装node-red-contrib-home-assistant-websocket，共享HA配置
+
+**与KNX直接集成的区别**：
+- KNX直接集成：HA作为KNX系统的一部分
+- KNX-HA桥接：KNX与HA作为两个独立系统，通过桥接互通
+
+**优势**：
+- 无需修改现有KNX配置
+- 可以选择性同步部分设备
+- 支持与HA中任意实体同步
+- 配置灵活，易于调整
+
 ## 协议说明
 
 ### 核心协议格式
@@ -853,6 +1056,7 @@ A: 每个房间部署一个云端同步节点，配置对应的酒店ID和房间
 | **Symi Cloud Sync** | 云端同步设备名称和场景 | [云端数据同步](#云端数据同步) |
 | **Symi RS485 Bridge** | RS485设备双向同步 | [RS485/Modbus双向同步](#rs485modbus双向同步) |
 | **Symi KNX Bridge** | KNX系统双向同步 | [KNX双向同步](#knx双向同步) |
+| **Symi KNX-HA Bridge** | KNX与HA实体双向同步 | [KNX-HA双向同步](#knx-ha双向同步) |
 | **RS485 Debug** | RS485总线数据抓包调试 | [RS485调试节点](#rs485调试节点) |
 
 ## 开发者信息
@@ -1017,6 +1221,35 @@ node-red-contrib-symi-mesh/
 
 ## 更新日志
 
+### v1.6.9 (2025-12-20)
+- **KNX-HA双向同步**：新增`symi-knx-ha-bridge`节点
+  - 直接连接KNX与HA实体，实现双向同步
+  - 支持Tab分隔格式导入KNX组地址配置（与KNX桥接节点100%一致）
+  - 使用共享HA服务器节点，通过REST API自动加载HA实体列表
+  - 支持开关、灯光、窗帘、空调、风扇等设备类型
+  - 完整双向同步：KNX↔HA实时状态同步
+  - 事件驱动架构，通过HA events-state节点实时接收事件
+  - 智能防抖：调光300ms、窗帘500ms，只同步最终值
+  - 内置防死循环机制（800ms防抖）
+  - 快速输入框：支持输入实体ID或名称搜索，自动提示806+实体
+  - 手动刷新按钮，随时重新加载HA实体
+  - 宽屏界面：对话框最小1000px宽度
+  - 持久化配置保存，内存优化
+  - 连接knxUltimate节点，无缝集成
+  - 适用于已有KNX系统与HA整合的场景
+
+### v1.6.8 (2025-12-15)
+- **KNX双向同步修复**：彻底修复米家/面板操作KNX不同步的问题
+  - 修复0x45消息类型处理：米家/面板操作发送msgType=0x45，不再限制channels>=6
+  - 支持1-4路开关2字节参数解析（米家/面板场景触发格式）
+  - 场景执行通知(0x11)后自动查询设备状态
+- **syncLock阻塞修复**：移除handleMeshStateChange中syncLock检查
+  - 避免队列处理期间丢失状态变化事件
+  - 改用per-device时间戳防回环机制
+- **processQueue健壮性**：添加try/finally确保processing标志正确重置
+- **防死循环参数调整**：LOOP_PREVENTION_MS调整为800ms
+- **同时修复RS485桥接**：应用相同syncLock修复
+
 ### v1.6.7 (2025-12-10)
 - **KNX双向同步完善**：`symi-knx-bridge`节点全面升级
   - **knxUltimate消息格式**：符合官方规范，使用`destination`+`payload`+`dpt`+`event`
@@ -1036,18 +1269,6 @@ node-red-contrib-symi-mesh/
   - 多设备类型：开关、调光灯、窗帘、空调、新风、地暖
   - 智能通道选择：根据Mesh设备实际路数显示可选通道
 
-### v1.6.8 (2025-12-15)
-- **KNX双向同步修复**：彻底修复米家/面板操作KNX不同步的问题
-  - 修复0x45消息类型处理：米家/面板操作发送msgType=0x45，不再限制channels>=6
-  - 支持1-4路开关2字节参数解析（米家/面板场景触发格式）
-  - 场景执行通知(0x11)后自动查询设备状态
-- **syncLock阻塞修复**：移除handleMeshStateChange中syncLock检查
-  - 避免队列处理期间丢失状态变化事件
-  - 改用per-device时间戳防回环机制
-- **processQueue健壮性**：添加try/finally确保processing标志正确重置
-- **防死循环参数调整**：LOOP_PREVENTION_MS调整为800ms
-- **同时修复RS485桥接**：应用相同syncLock修复
-
 ### v1.6.6 (2025-12-09)
 - **三合一面板完整双向同步**：支持空调+新风+地暖独立RS485映射
   - 三合一0x94协议完整解析：空调(开关/模式/风速/温度)、地暖(开关/温度)、新风(开关/风速)
@@ -1076,23 +1297,6 @@ node-red-contrib-symi-mesh/
 - **内存安全**：命令队列限制100条，节点关闭时清理所有缓存
 - **文档更新**：添加三合一面板RS485配置说明和协议对照表
 
-### v1.6.5 (2025-12-06)
-- **杜亚窗帘协议**：原生支持杜亚窗帘协议(A6B6)，2字节地址，自动CRC16计算
-  - 帧格式：55 [地址高] [地址低] 03 [动作/位置] [CRC16低] [CRC16高]
-  - 支持打开(01)、关闭(02)、暂停(03)、百分比(04+位置)
-- **窗帘控制智能判断**：根据当前位置判断方向
-  - 位置>=50% + curtainStatus变化 → 发关闭码
-  - 位置<50% + curtainStatus变化 → 发打开码
-  - 暂停(curtainStatus=3)最高优先级
-- **窗帘百分比模式修复**：修复百分比控制后开/关命令失效的问题
-  - 百分比控制时进入百分比模式（inPosMode）
-  - 窗帘到位（curtainStatus=0）后自动退出百分比模式
-  - 退出后开/关命令可正常发送
-- **发码防抖**：500ms内不重复发相同码，避免Mesh状态混乱
-- **设备类型过滤**：映射只响应对应类型的状态变化
-- **RS485调试增强**：新增协议测试发送功能
-- **初始化延迟**：20秒，避免部署时误发命令
-
 ## 许可证
 
 MIT License
@@ -1104,8 +1308,8 @@ Copyright (c) 2025 SYMI 亖米
 ## 关于
 
 **作者**: SYMI 亖米
-**版本**: 1.6.8
+**版本**: 1.6.9
 **协议**: 蓝牙MESH网关（初级版）串口协议V1.0
-**最后更新**: 2025-12-15
+**最后更新**: 2025-12-20
 **仓库**: https://github.com/symi-daguo/node-red-contrib-symi-mesh
 **npm包**: https://www.npmjs.com/package/node-red-contrib-symi-mesh

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

@@ -0,0 +1,370 @@
+<script type="text/javascript">
+    RED.nodes.registerType('symi-knx-ha-bridge', {
+        category: 'Symi Mesh',
+        color: '#41BDF5',
+        defaults: {
+            name: { value: '' },
+            haServer: { value: '', type: 'server' },
+            mappings: { value: '[]' },
+            knxEntities: { value: '[]' }
+        },
+        inputs: 1,
+        outputs: 2,
+        outputLabels: ['KNX输出', '调试信息'],
+        icon: 'bridge.svg',
+        label: function() { return this.name || 'KNX-HA桥接'; },
+        paletteLabel: 'KNX-HA桥接',
+        oneditprepare: function() {
+            const node = this;
+            let mappings = [], haEntities = [], knxEntities = [];
+            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 = []; }
+
+            function loadHaEntities() {
+                const sid = $('#node-input-haServer').val();
+                if (!sid) { 
+                    haEntities = []; 
+                    renderMappings(); 
+                    return; 
+                }
+                
+                console.log('[KNX-HA Bridge] 开始加载HA实体，服务器ID:', sid);
+                
+                $.getJSON('symi-knx-ha-bridge/ha-entities/' + sid)
+                    .done(function(data) {
+                        console.log('[KNX-HA Bridge] 收到响应:', data);
+                        haEntities = data || [];
+                        renderMappings();
+                        if (haEntities.length > 0) {
+                            RED.notify('成功加载 ' + haEntities.length + ' 个HA实体', 'success');
+                        } else {
+                            RED.notify('HA服务器还未就绪，请稍后重试', 'warning');
+                        }
+                    })
+                    .fail(function(err) {
+                        console.error('[KNX-HA Bridge] 加载失败:', err);
+                        haEntities = [];
+                        renderMappings();
+                        RED.notify('HA服务器还未就绪，请稍后重试', 'warning');
+                    });
+            }
+
+            $('#download-tpl-btn').on('click', function() {
+                const tpl = `# KNX实体导入模板 (Tab分隔)
+# 格式: 名称	类型	命令地址	状态地址	扩展1	扩展2	扩展3
+# 类型: switch, light_mono, light_cct, light_rgb, light_rgbcw, cover, climate, fresh_air, floor_heating
+#
+# 开关 (命令, 状态)
+玄关射灯	switch	1/1/28	1/2/28
+客厅射灯	switch	1/1/25	1/2/25
+# 单色调光 (开关, 状态, 亮度)
+卧室筒灯	light_mono	1/1/1	1/2/1	1/3/1
+# 双色调光 (开关, 状态, 亮度, 色温)
+客厅吊灯	light_cct	1/1/10	1/2/10	1/3/10	1/4/10
+# RGB (开关, 状态, 亮度, RGB)
+氛围灯	light_rgb	1/1/20	1/2/20	1/3/20	1/5/20
+# RGBCW (开关, 状态, 亮度, 色温, RGB)
+主灯	light_rgbcw	1/1/30	1/2/30	1/3/30	1/4/30	1/5/30
+# 窗帘 (上下, 位置, 停止)
+客厅布帘	cover	2/1/5	2/2/5	2/3/5
+# 空调 (开关, 温度, 模式, 风速, 当前温度)
+主卧空调	climate	3/1/1	3/2/1	3/3/1	3/4/1	3/5/1
+# 新风 (开关, 风速)
+全屋新风	fresh_air	4/1/1	4/2/1
+# 地暖 (开关, 温度, 当前温度)
+客厅地暖	floor_heating	5/1/1	5/2/1	5/3/1`;
+                const blob = new Blob([tpl], {type:'text/plain;charset=utf-8'});
+                const a = document.createElement('a'); a.href = URL.createObjectURL(blob);
+                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': ['开关地址*','状态地址','亮度地址'],
+                'light_cct': ['开关地址*','状态地址','亮度地址','色温地址'],
+                'light_rgb': ['开关地址*','状态地址','亮度地址','RGB地址'],
+                'light_rgbcw': ['开关地址*','状态地址','亮度地址','色温地址','RGB地址'],
+                'cover': ['上下地址*','位置地址','停止地址'],
+                'climate': ['开关地址*','温度地址','模式地址','风速地址','当前温度'],
+                'fresh_air': ['开关地址*','风速地址'],
+                '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;
+                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 ? '保存' : '添加';
+                $('#edit-panel').html(
+                    '<div class="edit-form"><h4>'+title+'</h4>'+
+                    '<div class="form-row"><label>名称*</label><input type="text" id="edit-name" value="'+(e.name||'')+'" placeholder="如: 客厅灯"></div>'+
+                    '<div class="form-row"><label>类型</label><select id="edit-type">'+typeOpts+'</select></div>'+
+                    '<div class="form-row" id="row-cmd"><label id="lbl-cmd">命令地址*</label><input type="text" id="edit-cmd" value="'+(e.cmdAddr||'')+'"></div>'+
+                    '<div class="form-row" id="row-status"><label id="lbl-status">状态地址</label><input type="text" id="edit-status" value="'+(e.statusAddr||'')+'"></div>'+
+                    '<div class="form-row" id="row-ext1"><label id="lbl-ext1">扩展1</label><input type="text" id="edit-ext1" value="'+(e.ext1||'')+'"></div>'+
+                    '<div class="form-row" id="row-ext2"><label id="lbl-ext2">扩展2</label><input type="text" id="edit-ext2" value="'+(e.ext2||'')+'"></div>'+
+                    '<div class="form-row" id="row-ext3"><label id="lbl-ext3">扩展3</label><input type="text" id="edit-ext3" value="'+(e.ext3||'')+'"></div>'+
+                    '<div class="form-row" id="row-inv" style="display:none"><label>位置反转</label><input type="checkbox" id="edit-inv"'+(e.invert?' checked':'')+'></div>'+
+                    '<div class="form-row"><button id="save-edit" class="red-ui-button red-ui-button-small">'+btnText+'</button> <button id="cancel-edit" class="red-ui-button red-ui-button-small">取消</button></div>'+
+                    '</div>'
+                ).show();
+                
+                function updateFieldLabels() {
+                    const type = $('#edit-type').val();
+                    const fields = typeFields[type] || ['命令地址*','状态地址'];
+                    const rows = ['row-cmd','row-status','row-ext1','row-ext2','row-ext3'];
+                    const labels = ['lbl-cmd','lbl-status','lbl-ext1','lbl-ext2','lbl-ext3'];
+                    rows.forEach((row,i) => {
+                        if (i < fields.length) {
+                            $('#'+row).show();
+                            $('#'+labels[i]).text(fields[i]);
+                        } else {
+                            $('#'+row).hide();
+                        }
+                    });
+                    $('#row-inv').toggle(type === 'cover');
+                }
+                updateFieldLabels();
+                $('#edit-type').on('change', updateFieldLabels);
+                
+                $('#save-edit').on('click', function() {
+                    const name = $('#edit-name').val().trim();
+                    const cmd = $('#edit-cmd').val().trim();
+                    if (!name || !cmd) { RED.notify('请填写名称和命令地址', 'warning'); return; }
+                    const entity = {
+                        id: isEdit ? e.id : 'k'+Date.now()+Math.random().toString(36).substr(2,4),
+                        name: name,
+                        type: $('#edit-type').val(),
+                        cmdAddr: cmd,
+                        statusAddr: $('#edit-status').val().trim(),
+                        ext1: $('#edit-ext1').val().trim(),
+                        ext2: $('#edit-ext2').val().trim(),
+                        ext3: $('#edit-ext3').val().trim(),
+                        invert: $('#edit-inv').is(':checked')
+                    };
+                    if (isEdit) { knxEntities[editingIndex] = entity; }
+                    else { knxEntities.push(entity); }
+                    $('#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();
+                });
+            }
+
+            $('#add-map-btn').on('click', function() {
+                mappings.push({ knxEntityId:'', haEntityId:'' });
+                renderMappings();
+            });
+            $('#clear-map-btn').on('click', function() { if(confirm('清空映射？')) { mappings=[]; renderMappings(); } });
+
+            $('#import-btn').on('click', function() { $('#import-modal').show(); });
+            $('#import-cancel').on('click', function() { $('#import-modal').hide(); });
+            $('#import-confirm').on('click', function() {
+                const text = $('#import-input').val().trim();
+                if (!text) { $('#import-modal').hide(); return; }
+                let cnt = 0;
+                text.split('\n').forEach(line => {
+                    line = line.trim();
+                    if (!line || line.startsWith('#')) return;
+                    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 });
+                        cnt++;
+                    }
+                });
+                $('#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(); } });
+
+            function saveKnxData() { $('#knx-data').val(JSON.stringify(knxEntities)); }
+            
+            const origRender = renderKnxEntities;
+            renderKnxEntities = function() { origRender(); saveKnxData(); };
+
+            $('#node-input-haServer').on('change', function() {
+                setTimeout(loadHaEntities, 2000);
+            });
+            $('#reload-ha-btn').on('click', function() {
+                $(this).prop('disabled', true).text('加载中...');
+                setTimeout(function() {
+                    loadHaEntities();
+                    $('#reload-ha-btn').prop('disabled', false).text('刷新');
+                }, 100);
+            });
+            
+            setTimeout(function() { 
+                renderKnxEntities(); 
+                if ($('#node-input-haServer').val()) {
+                    setTimeout(loadHaEntities, 2000);
+                }
+            }, 100);
+        },
+        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() };
+                if (m.knxEntityId && m.haEntityId) maps.push(m);
+            });
+            this.mappings = JSON.stringify(maps);
+            this.knxEntities = $('#knx-data').val() || '[]';
+        }
+    });
+</script>
+
+<script type="text/html" data-template-name="symi-knx-ha-bridge">
+    <style>
+        #dialog-form { min-width: 1000px; }
+        .tbl { width:100%; border-collapse:collapse; font-size:11px; }
+        .tbl th, .tbl td { padding:3px 5px; border:1px solid #ddd; }
+        .tbl th { background:#f0f0f0; }
+        .tbl select { width:100%; font-size:11px; padding:2px; }
+        .tbl input[type="checkbox"] { margin:0; }
+        #knx-list { max-height:180px; overflow-y:auto; border:1px solid #ccc; margin:5px 0; padding:3px; }
+        #map-list { max-height:400px; overflow-y:auto; border:1px solid #ccc; margin:5px 0; padding:3px; }
+        .tips { color:#666; padding:8px; text-align:center; font-size:12px; }
+        .sec { display:flex; justify-content:space-between; align-items:center; margin:10px 0 4px; padding-bottom:4px; border-bottom:1px solid #ddd; }
+        .sec b { font-size:12px; }
+        .btns button { margin-left:4px; }
+        .modal-overlay { display:none; position:fixed; top:0; left:0; right:0; bottom:0; background:rgba(0,0,0,0.5); z-index:99999; }
+        .modal-box { position:fixed; top:50%; left:50%; transform:translate(-50%,-50%); background:#fff; padding:15px; border-radius:5px; box-shadow:0 4px 20px rgba(0,0,0,0.3); z-index:100000; }
+        #import-modal .modal-box { width:650px; }
+        #import-input { width:100%; height:160px; font-family:monospace; font-size:10px; }
+        .modal-box h4 { margin:0 0 10px; }
+        .modal-box .mbtns { text-align:right; margin-top:10px; }
+        .info { background:#f8f8e8; border:1px solid #e0e0c0; padding:5px 8px; margin:6px 0; font-size:11px; border-radius:3px; }
+        .edit-form h4 { margin:0 0 10px; color:#333; }
+        .edit-form .form-row { margin-bottom:8px; display:flex; align-items:center; }
+        .edit-form .form-row label { width:70px; font-size:12px; }
+        .edit-form .form-row input, .edit-form .form-row select { flex:1; padding:4px; font-size:12px; }
+        datalist { max-height: 300px !important; }
+        input[list]::-webkit-calendar-picker-indicator { display: block; }
+    </style>
+
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> 名称</label>
+        <input type="text" id="node-input-name" placeholder="KNX-HA桥接">
+    </div>
+    <div class="form-row">
+        <label for="node-input-haServer"><i class="fa fa-home"></i> HA服务器</label>
+        <input type="text" id="node-input-haServer" style="width:calc(100% - 180px)">
+        <button type="button" id="reload-ha-btn" class="red-ui-button red-ui-button-small" style="margin-left:5px">刷新</button>
+    </div>
+
+    <div class="info"><b>连接:</b> <code>[knxUltimate-in] → [KNX-HA桥接] → [knxUltimate-out]</code></div>
+
+    <div class="sec">
+        <b><i class="fa fa-database"></i> KNX实体库 (<span id="knx-cnt">0</span>)</b>
+        <span class="btns">
+            <button type="button" class="red-ui-button red-ui-button-small" id="download-tpl-btn"><i class="fa fa-download"></i> 模板</button>
+            <button type="button" class="red-ui-button red-ui-button-small" id="import-btn"><i class="fa fa-upload"></i> 导入</button>
+            <button type="button" class="red-ui-button red-ui-button-small" id="add-knx-btn"><i class="fa fa-plus"></i> 添加</button>
+            <button type="button" class="red-ui-button red-ui-button-small" id="clear-knx-btn"><i class="fa fa-trash"></i></button>
+        </span>
+    </div>
+    <div id="knx-list"><div class="tips">点击"导入"或"添加"管理KNX实体</div></div>
+    <div id="edit-panel" style="display:none;background:#fffde7;border:1px solid #ffc107;padding:10px;margin:5px 0;border-radius:4px;"></div>
+    <input type="hidden" id="knx-data">
+
+    <div class="sec">
+        <b><i class="fa fa-exchange"></i> 实体映射</b>
+        <span class="btns">
+            <button type="button" class="red-ui-button red-ui-button-small" id="add-map-btn"><i class="fa fa-plus"></i> 添加</button>
+            <button type="button" class="red-ui-button red-ui-button-small" id="clear-map-btn"><i class="fa fa-trash"></i> 清空</button>
+        </span>
+    </div>
+    <div id="map-list"><div class="tips">添加KNX↔HA映射</div></div>
+
+    <div id="import-modal" class="modal-overlay">
+        <div class="modal-box">
+            <h4>导入KNX实体</h4>
+            <p style="font-size:11px;margin:0 0 8px">Tab分隔: <code>名称  类型  命令地址  状态地址  扩展...</code>（无效行自动忽略）</p>
+            <textarea id="import-input" placeholder="玄关射灯	switch	1/1/28	1/2/28
+客厅吊灯	light_cct	1/1/10	1/2/10	1/3/10	1/4/10
+客厅布帘	cover	2/1/5	2/2/5	2/3/5"></textarea>
+            <div class="mbtns">
+                <button type="button" class="red-ui-button" id="import-cancel">取消</button>
+                <button type="button" class="red-ui-button red-ui-button-primary" id="import-confirm">导入</button>
+            </div>
+        </div>
+    </div>
+
+</script>
+
+<script type="text/html" data-help-name="symi-knx-ha-bridge">
+    <p>KNX与Home Assistant实体双向同步桥接</p>
+</script>

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

@@ -0,0 +1,524 @@
+/**
+ * Symi KNX-HA Bridge Node - KNX与Home Assistant实体双向同步桥接
+ * 版本: 1.6.9
+ */
+
+module.exports = function(RED) {
+    
+    function SymiKNXHABridgeNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        node.name = config.name || 'KNX-HA Bridge';
+        node.haServer = RED.nodes.getNode(config.haServer);
+        
+        let knxEntities = [];
+        try {
+            knxEntities = JSON.parse(config.knxEntities || '[]');
+        } catch (e) {
+            node.error('KNX实体配置解析失败: ' + e.message);
+        }
+
+        try {
+            const rawMappings = JSON.parse(config.mappings || '[]');
+            node.mappings = rawMappings.map(m => {
+                const knxEntity = knxEntities.find(e => e.id === m.knxEntityId) || {};
+                
+                return {
+                    knxEntityId: m.knxEntityId,
+                    haEntityId: m.haEntityId,
+                    knxName: knxEntity.name || '',
+                    knxType: knxEntity.type || 'switch',
+                    knxAddrCmd: knxEntity.cmdAddr || '',
+                    knxAddrStatus: knxEntity.statusAddr || '',
+                    knxAddrExt1: knxEntity.ext1 || '',
+                    knxAddrExt2: knxEntity.ext2 || '',
+                    knxAddrExt3: knxEntity.ext3 || '',
+                    invertPosition: knxEntity.invert || false,
+                    allKnxAddrs: [
+                        knxEntity.cmdAddr,
+                        knxEntity.statusAddr,
+                        knxEntity.ext1,
+                        knxEntity.ext2,
+                        knxEntity.ext3
+                    ].filter(addr => addr && addr.length > 0)
+                };
+            }).filter(m => m.knxEntityId && m.haEntityId);
+            
+            if (node.mappings.length > 0) {
+                node.mappings.forEach((m, i) => {
+                    node.log(`[映射${i+1}] KNX ${m.knxName}[${m.knxAddrCmd}] <-> HA ${m.haEntityId}`);
+                });
+            }
+        } catch (e) {
+            node.mappings = [];
+            node.error('映射配置解析失败: ' + e.message);
+        }
+
+        node.commandQueue = [];
+        node.processing = false;
+        node.knxStateCache = {};
+        node.haStateCache = {};
+        node.lastKnxToHa = {};
+        node.lastHaToKnx = {};
+        node.dimmingTimers = {};
+        node.coverTimers = {};
+        
+        const LOOP_PREVENTION_MS = 800;
+        const DEBOUNCE_MS = 100;
+        const MAX_QUEUE_SIZE = 100;
+        const DIMMING_DEBOUNCE_MS = 300;
+        const COVER_DEBOUNCE_MS = 500;
+        
+        node.initializing = true;
+        node.initTimer = setTimeout(() => {
+            node.initializing = false;
+            node.log('[KNX-HA Bridge] 初始化完成，开始同步');
+        }, 5000);
+
+        node.log(`[KNX-HA Bridge] haServer: ${!!node.haServer}, credentials: ${!!node.haServer?.credentials}`);
+        
+        if (node.mappings.length === 0) {
+            node.status({ fill: 'grey', shape: 'ring', text: '未配置映射' });
+        } else {
+            node.status({ fill: 'green', shape: 'dot', text: `${node.mappings.length}个映射已激活` });
+        }
+
+        node.findKnxMapping = function(groupAddr) {
+            return node.mappings.find(m => m.allKnxAddrs.includes(groupAddr));
+        };
+
+        node.findHaMapping = function(entityId) {
+            return node.mappings.find(m => m.haEntityId === entityId);
+        };
+
+        node.getKnxAddrFunction = function(mapping, groupAddr) {
+            if (groupAddr === mapping.knxAddrCmd) return 'cmd';
+            if (groupAddr === mapping.knxAddrStatus) return 'status';
+            if (groupAddr === mapping.knxAddrExt1) return 'ext1';
+            if (groupAddr === mapping.knxAddrExt2) return 'ext2';
+            if (groupAddr === mapping.knxAddrExt3) return 'ext3';
+            return 'unknown';
+        };
+
+        node.shouldPreventSync = function(direction, key) {
+            const now = Date.now();
+            if (direction === 'knx-to-ha') {
+                const lastHaTime = node.lastHaToKnx[key] || 0;
+                return (now - lastHaTime) < LOOP_PREVENTION_MS;
+            } else {
+                const lastKnxTime = node.lastKnxToHa[key] || 0;
+                return (now - lastKnxTime) < LOOP_PREVENTION_MS;
+            }
+        };
+
+        node.recordSyncTime = function(direction, key) {
+            const now = Date.now();
+            if (direction === 'knx-to-ha') {
+                node.lastKnxToHa[key] = now;
+            } else {
+                node.lastHaToKnx[key] = now;
+            }
+        };
+
+        node.sleep = function(ms) {
+            return new Promise(resolve => setTimeout(resolve, ms));
+        };
+
+        // 输入处理：支持KNX和HA两种消息
+        node.on('input', function(msg) {
+            if (node.initializing) return;
+            
+            // 处理来自HA server-state-changed节点的消息
+            if (msg.data && msg.data.entity_id && msg.data.new_state && msg.data.old_state) {
+                const entityId = msg.data.entity_id;
+                const mapping = node.findHaMapping(entityId);
+                
+                if (!mapping) {
+                    node.debug(`[HA输入] 实体 ${entityId} 无映射配置`);
+                    return;
+                }
+                
+                const loopKey = `${mapping.knxEntityId}_${mapping.haEntityId}`;
+                
+                if (node.shouldPreventSync('ha-to-knx', loopKey)) {
+                    node.debug(`[HA->KNX] 跳过(防死循环): ${entityId}`);
+                    return;
+                }
+                
+                const newState = msg.data.new_state;
+                const oldState = msg.data.old_state;
+                
+                if (oldState.state === newState.state) return;
+                
+                node.log(`[HA->KNX] ${entityId} 状态变化: ${oldState.state} -> ${newState.state}`);
+                
+                const domain = entityId.split('.')[0];
+                node.queueCommand({
+                    direction: 'ha-to-knx',
+                    mapping: mapping,
+                    type: domain === 'switch' ? 'switch' : 'light_switch',
+                    value: newState.state === 'on',
+                    key: loopKey
+                });
+                return;
+            }
+            
+            // 处理来自KNX的消息
+            if (!msg.knx || !msg.knx.destination) {
+                return;
+            }
+            
+            const groupAddr = msg.knx.destination;
+            const mapping = node.findKnxMapping(groupAddr);
+            
+            if (!mapping) {
+                node.debug(`[KNX输入] 组地址 ${groupAddr} 无映射配置`);
+                return;
+            }
+            
+            const loopKey = `${mapping.knxEntityId}_${mapping.haEntityId}`;
+            
+            if (node.shouldPreventSync('knx-to-ha', loopKey)) {
+                node.log(`[KNX->HA] 跳过(防死循环): ${groupAddr}`);
+                return;
+            }
+            
+            node.log(`[KNX输入] ${groupAddr} = ${msg.payload}, 映射到 ${mapping.haEntityId}`);
+            
+            const addrFunc = node.getKnxAddrFunction(mapping, groupAddr);
+            const knxType = mapping.knxType;
+            
+            if (knxType === 'switch') {
+                if (addrFunc === 'cmd' || addrFunc === 'status') {
+                    node.queueCommand({
+                        direction: 'knx-to-ha',
+                        mapping: mapping,
+                        type: 'switch',
+                        value: msg.payload === true || msg.payload === 1,
+                        key: loopKey
+                    });
+                }
+            }
+            else if (knxType.startsWith('light_')) {
+                if (addrFunc === 'cmd') {
+                    node.queueCommand({
+                        direction: 'knx-to-ha',
+                        mapping: mapping,
+                        type: 'light_switch',
+                        value: msg.payload === true || msg.payload === 1,
+                        key: loopKey
+                    });
+                } else if (addrFunc === 'ext1') {
+                    const timerKey = `${mapping.haEntityId}_brightness`;
+                    if (node.dimmingTimers[timerKey]) {
+                        clearTimeout(node.dimmingTimers[timerKey]);
+                    }
+                    node.dimmingTimers[timerKey] = setTimeout(() => {
+                        node.queueCommand({
+                            direction: 'knx-to-ha',
+                            mapping: mapping,
+                            type: 'light_brightness',
+                            value: Math.round(msg.payload * 100 / 255),
+                            key: loopKey
+                        });
+                        delete node.dimmingTimers[timerKey];
+                    }, DIMMING_DEBOUNCE_MS);
+                }
+            }
+            else if (knxType === 'cover') {
+                if (addrFunc === 'cmd') {
+                    node.queueCommand({
+                        direction: 'knx-to-ha',
+                        mapping: mapping,
+                        type: 'cover_action',
+                        value: msg.payload ? 'closing' : 'opening',
+                        key: loopKey
+                    });
+                } else if (addrFunc === 'status') {
+                    const timerKey = `${mapping.haEntityId}_position`;
+                    if (node.coverTimers[timerKey]) {
+                        clearTimeout(node.coverTimers[timerKey]);
+                    }
+                    node.coverTimers[timerKey] = setTimeout(() => {
+                        const pos = mapping.invertPosition ? (100 - msg.payload) : msg.payload;
+                        node.queueCommand({
+                            direction: 'knx-to-ha',
+                            mapping: mapping,
+                            type: 'cover_position',
+                            value: pos,
+                            key: loopKey
+                        });
+                        delete node.coverTimers[timerKey];
+                    }, COVER_DEBOUNCE_MS);
+                }
+            }
+            else if (knxType === 'climate') {
+                if (addrFunc === 'cmd') {
+                    node.queueCommand({
+                        direction: 'knx-to-ha',
+                        mapping: mapping,
+                        type: 'climate_switch',
+                        value: msg.payload === true || msg.payload === 1,
+                        key: loopKey
+                    });
+                }
+            }
+        });
+
+        node.queueCommand = function(cmd) {
+            if (node.commandQueue.length >= MAX_QUEUE_SIZE) {
+                node.commandQueue.shift();
+            }
+            
+            const existing = node.commandQueue.find(c =>
+                c.direction === cmd.direction &&
+                c.mapping.knxEntityId === cmd.mapping.knxEntityId &&
+                c.type === cmd.type &&
+                Date.now() - (c.timestamp || 0) < DEBOUNCE_MS
+            );
+            
+            if (existing) {
+                existing.value = cmd.value;
+                return;
+            }
+            
+            cmd.timestamp = Date.now();
+            node.commandQueue.push(cmd);
+            node.processQueue();
+        };
+
+        node.processQueue = async function() {
+            if (node.processing || node.commandQueue.length === 0) return;
+            
+            node.processing = true;
+            
+            try {
+                while (node.commandQueue.length > 0) {
+                    const cmd = node.commandQueue.shift();
+                    try {
+                        if (cmd.direction === 'knx-to-ha') {
+                            await node.syncKnxToHa(cmd);
+                        } else if (cmd.direction === 'ha-to-knx') {
+                            await node.syncHaToKnx(cmd);
+                        }
+                        await node.sleep(50);
+                    } catch (err) {
+                        node.error(`同步失败: ${err.message}`);
+                    }
+                }
+            } finally {
+                node.processing = false;
+            }
+        };
+
+        // KNX -> HA 同步
+        node.syncKnxToHa = async function(cmd) {
+            const { mapping, type, value, key } = cmd;
+            node.recordSyncTime('knx-to-ha', key);
+            
+            if (!node.haServer || !node.haServer.credentials) {
+                node.warn('[KNX->HA] HA服务器未配置');
+                return;
+            }
+            
+            try {
+                const axios = require('axios');
+                const baseURL = node.haServer.credentials.host || 'http://localhost:8123';
+                const token = node.haServer.credentials.access_token;
+                
+                if (!token) {
+                    node.warn('[KNX->HA] HA访问令牌未配置');
+                    return;
+                }
+                
+                const domain = mapping.haEntityId.split('.')[0];
+                let service = '';
+                let serviceData = { entity_id: mapping.haEntityId };
+                
+                if (type === 'switch') {
+                    service = value ? 'turn_on' : 'turn_off';
+                }
+                else if (type === 'light_switch') {
+                    service = value ? 'turn_on' : 'turn_off';
+                }
+                else if (type === 'light_brightness') {
+                    service = 'turn_on';
+                    serviceData.brightness = Math.round(value * 255 / 100);
+                }
+                else if (type === 'cover_action') {
+                    service = value === 'opening' ? 'open_cover' : 'close_cover';
+                }
+                else if (type === 'cover_position') {
+                    service = 'set_cover_position';
+                    serviceData.position = value;
+                }
+                else if (type === 'climate_switch') {
+                    service = value ? 'turn_on' : 'turn_off';
+                }
+                
+                if (service) {
+                    await axios.post(`${baseURL}/api/services/${domain}/${service}`, serviceData, {
+                        headers: {
+                            'Authorization': `Bearer ${token}`,
+                            'Content-Type': 'application/json'
+                        },
+                        timeout: 5000
+                    });
+                    
+                    node.log(`[KNX->HA] ${mapping.haEntityId} ${service}`);
+                    
+                    node.send([null, { 
+                        payload: { 
+                            type: 'knx-to-ha', 
+                            entity: mapping.haEntityId,
+                            service: service
+                        } 
+                    }]);
+                }
+            } catch (err) {
+                node.error(`[KNX->HA] 调用HA服务失败: ${err.message}`);
+            }
+        };
+
+
+        // HA -> KNX 同步
+        node.syncHaToKnx = async function(cmd) {
+            const { mapping, type, value, key } = cmd;
+            node.recordSyncTime('ha-to-knx', key);
+            
+            let knxMsg = null;
+            
+            if (type === 'switch') {
+                knxMsg = {
+                    destination: mapping.knxAddrCmd,
+                    payload: value,
+                    dpt: '1.001',
+                    event: "GroupValue_Write"
+                };
+            }
+            else if (type === 'light_switch') {
+                knxMsg = {
+                    destination: mapping.knxAddrCmd,
+                    payload: value,
+                    dpt: '1.001',
+                    event: "GroupValue_Write"
+                };
+            }
+            else if (type === 'light_brightness') {
+                knxMsg = {
+                    destination: mapping.knxAddrExt1 || mapping.knxAddrStatus,
+                    payload: Math.round(value * 255 / 100),
+                    dpt: '5.001',
+                    event: "GroupValue_Write"
+                };
+            }
+            else if (type === 'cover_action') {
+                knxMsg = {
+                    destination: mapping.knxAddrCmd,
+                    payload: value === 'closing',
+                    dpt: '1.008',
+                    event: "GroupValue_Write"
+                };
+            }
+            else if (type === 'cover_position') {
+                const pos = mapping.invertPosition ? (100 - value) : value;
+                knxMsg = {
+                    destination: mapping.knxAddrStatus || mapping.knxAddrExt1,
+                    payload: pos,
+                    dpt: '5.001',
+                    event: "GroupValue_Write"
+                };
+            }
+            
+            if (knxMsg) {
+                node.log(`[HA->KNX] ${knxMsg.destination} = ${value}`);
+                node.send([knxMsg, null]);
+            }
+        };
+
+        node.on('close', function(done) {
+            if (node.initTimer) clearTimeout(node.initTimer);
+            
+            // 清理HA事件监听
+            if (node.haEventHandlers) {
+                node.haEventHandlers.forEach(({ eventName, handler, ha }) => {
+                    if (ha && ha.eventBus) {
+                        ha.eventBus.removeListener(eventName, handler);
+                    }
+                });
+                node.haEventHandlers = [];
+            }
+            
+            Object.values(node.dimmingTimers).forEach(timer => clearTimeout(timer));
+            Object.values(node.coverTimers).forEach(timer => clearTimeout(timer));
+            
+            node.commandQueue = [];
+            node.knxStateCache = {};
+            node.haStateCache = {};
+            node.lastKnxToHa = {};
+            node.lastHaToKnx = {};
+            node.dimmingTimers = {};
+            node.coverTimers = {};
+            
+            done();
+        });
+    }
+
+    RED.nodes.registerType('symi-knx-ha-bridge', SymiKNXHABridgeNode);
+
+    // HTTP API: 加载HA实体 - 直接使用HA REST API
+    RED.httpAdmin.get('/symi-knx-ha-bridge/ha-entities/:id', async function(req, res) {
+        try {
+            const serverNode = RED.nodes.getNode(req.params.id);
+            
+            if (!serverNode || !serverNode.credentials) {
+                return res.json([]);
+            }
+            
+            const axios = require('axios');
+            const baseURL = serverNode.credentials.host || 'http://localhost:8123';
+            const token = serverNode.credentials.access_token;
+            
+            RED.log.info('[KNX-HA Bridge] baseURL: ' + baseURL);
+            RED.log.info('[KNX-HA Bridge] token length: ' + (token ? token.length : 0));
+            
+            if (!token) {
+                RED.log.warn('[KNX-HA Bridge] HA访问令牌未配置');
+                return res.json([]);
+            }
+            
+            RED.log.info('[KNX-HA Bridge] 使用REST API加载HA实体: ' + baseURL);
+            
+            const response = await axios.get(`${baseURL}/api/states`, {
+                headers: {
+                    'Authorization': `Bearer ${token}`,
+                    'Content-Type': 'application/json'
+                },
+                timeout: 10000
+            });
+            
+            const entities = [];
+            if (response.data && Array.isArray(response.data)) {
+                response.data.forEach(state => {
+                    if (!state || !state.entity_id) return;
+                    
+                    const domain = state.entity_id.split('.')[0];
+                    if (['switch', 'light', 'cover', 'climate', 'fan'].includes(domain)) {
+                        entities.push({
+                            entity_id: state.entity_id,
+                            name: (state.attributes && state.attributes.friendly_name) || state.entity_id,
+                            type: domain
+                        });
+                    }
+                });
+            }
+            
+            RED.log.info('[KNX-HA Bridge] 成功加载 ' + entities.length + ' 个HA实体');
+            res.json(entities);
+        } catch (err) {
+            RED.log.error('[KNX-HA Bridge] 加载HA实体失败: ' + err.message);
+            res.json([]);
+        }
+    });
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-symi-mesh",
-  "version": "1.6.8",
+  "version": "1.6.9",
   "description": "Node-RED节点集合，用于通过TCP/串口连接Symi蓝牙Mesh网关，支持Home Assistant MQTT Discovery自动发现和云端数据同步",
   "main": "nodes/symi-gateway.js",
   "scripts": {
@@ -35,7 +35,8 @@
       "symi-485-config": "nodes/symi-485-config.js",
       "symi-rs485-bridge": "nodes/symi-485-bridge.js",
       "rs485-debug": "nodes/rs485-debug.js",
-      "symi-knx-bridge": "nodes/symi-knx-bridge.js"
+      "symi-knx-bridge": "nodes/symi-knx-bridge.js",
+      "symi-knx-ha-bridge": "nodes/symi-knx-ha-bridge.js"
     }
   },
   "dependencies": {