node-red-contrib-symi-mesh 1.7.3 → 1.7.5

package/README.md

@@ -1291,6 +1291,8 @@ A: 每个房间部署一个云端同步节点，配置对应的酒店ID和房间
 | **Symi RS485 Bridge** | RS485设备双向同步 | [RS485/Modbus双向同步](#rs485modbus双向同步) |
 | **Symi KNX Bridge** | KNX系统双向同步 | [KNX双向同步](#knx双向同步) |
 | **Symi KNX-HA Bridge** | KNX与HA实体双向同步 | [KNX-HA双向同步](#knx-ha双向同步) |
+| **Symi MQTT Sync** | 第三方MQTT品牌设备同步 | v1.7.3新增 |
+| **Symi MQTT Brand** | 品牌MQTT配置节点 | v1.7.3新增 |
 | **RS485 Debug** | RS485总线数据抓包调试 | [RS485调试节点](#rs485调试节点) |
 | **Symi RS485 Sync** | 两种RS485协议双向同步 | [RS485协议同步](#rs485协议同步) |
 
@@ -1314,12 +1316,15 @@ node-red-contrib-symi-mesh/
 │   ├── symi-485-bridge.js/html # RS485桥接节点
 │   ├── symi-485-config.js/html # RS485配置节点
 │   ├── symi-knx-bridge.js/html # KNX桥接节点
+│   ├── symi-knx-ha-bridge.js/html # KNX-HA桥接节点
 │   ├── symi-rs485-sync.js/html # RS485协议同步节点
+│   ├── symi-mqtt-sync.js/html # MQTT品牌同步节点
+│   ├── symi-mqtt-brand.js/html # 品牌MQTT配置节点
 │   └── rs485-debug.js/html   # RS485调试节点
 ├── examples/
 │   ├── basic-example.json    # 基础示例
-│   ├── knx-sync-example.json # KNX Function节点示例
-│   └── knx-bridge-example.json # KNX桥接节点示例
+│   ├── knx-sync-example.json # KNX桥接节点示例
+│   └── rs485-sync-example.json # RS485协议同步示例
 ├── LICENSE
 ├── README.md
 └── package.json
@@ -1457,6 +1462,37 @@ node-red-contrib-symi-mesh/
 
 ## 更新日志
 
+### v1.7.5 (2025-12-24)
+- **API路径兼容性修复**：修复HassOS环境下节点配置界面无法加载设备列表的问题
+  - **根本原因**：HassOS Node-RED使用nginx反向代理，绝对路径`/api`会被拦截，需使用相对路径`api`
+  - **修复范围**：所有节点HTML中的`$.getJSON()`调用统一使用相对路径
+  - **开发规范**：后续开发节点时，所有前端API调用必须使用相对路径，不带前导斜杠
+- **KNX Bridge双向同步修复**：修复Mesh控制KNX开关不工作的问题
+  - **根本原因**：knxUltimate节点当`setTopicType: "str"`时使用`msg.topic`作为目标地址，而非`msg.destination`
+  - **修复方案**：发送消息同时包含`topic`和`destination`字段，确保兼容所有knxUltimate配置
+  - **消息格式**：`{ topic, destination, payload, dpt, event }`
+  - **防死循环**：不包含`knx`对象，避免触发knxUltimate的循环引用保护机制
+- **用户体验优化**：
+  - 设备列表加载时显示"加载中..."提示
+  - API调用失败时显示"加载失败，请重试"提示
+
+### v1.7.4 (2025-12-24)
+- **串口配置完善**：完整的串口参数配置，解决HassOS环境串口锁定问题
+  - **完整参数**：波特率、数据位(7/8)、停止位(1/2)、校验位(None/Even/Odd)
+  - **串口解锁**：添加`lock: false`参数，避免HassOS环境下"Cannot lock port"错误
+  - **配置持久化**：所有串口参数自动保存，重启后保持
+  - **统一界面**：symi-gateway和symi-485-config使用相同的串口配置界面
+- **串口兼容性修复**：兼容serialport v9和v10+，确保HassOS环境正常使用串口
+  - `serial-client.js`：动态检测serialport版本
+  - `symi-485-config.js`：兼容v9/v10+ API
+  - `symi-485-bridge.js`：兼容v9/v10+ API
+- **KNX Bridge窗帘/调光同步优化**：重新设计步进设备同步逻辑，解决双向控制时乱动问题
+  - **控制锁定机制**：谁先发起控制谁锁定，3秒内忽略另一方的反馈
+  - **窗帘设备**：Mesh控制→锁定→忽略KNX反馈；KNX控制→锁定→忽略Mesh反馈
+  - **调光设备**：同样应用控制锁定机制，避免亮度调节过程中的反馈干扰
+  - **停止解锁**：窗帘stopped动作会解除锁定，允许下一次控制
+  - **位置/亮度同步**：只同步最终值，不同步过程中的步进状态
+
 ### v1.7.3 (2025-12-24)
 - **MQTT同步节点**：新增`symi-mqtt-sync`节点实现第三方MQTT品牌设备与Mesh设备双向同步
   - **双MQTT配置节点架构**：
@@ -1563,36 +1599,6 @@ 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修复
-
-
 ## 许可证
 
 MIT License
@@ -1604,7 +1610,7 @@ Copyright (c) 2025 SYMI 亖米
 ## 关于
 
 **作者**: SYMI 亖米
-**版本**: 1.7.3
+**版本**: 1.7.5
 **协议**: 蓝牙MESH网关（初级版）串口协议V1.0
 **最后更新**: 2025-12-24
 **仓库**: https://github.com/symi-daguo/node-red-contrib-symi-mesh

package/examples/knx-sync-example.json

@@ -80,12 +80,12 @@
         "notifyreadrequest": false,
         "notifyresponse": false,
         "notifywrite": true,
-        "name": "Universal KNX",
+        "name": "Universal KNX Output",
         "outputtype": "write",
         "outputRBE": "false",
         "inputRBE": "false",
         "passthrough": "no",
-        "listenallga": true,
+        "listenallga": false,
         "buttonEnabled": false,
         "x": 620,
         "y": 120,

package/lib/serial-client.js

@@ -6,10 +6,13 @@ const EventEmitter = require('events');
 const { ProtocolHandler } = require('./protocol');
 
 class SerialClient extends EventEmitter {
-    constructor(portPath, baudRate = 115200, logger = console) {
+    constructor(portPath, baudRate = 115200, logger = console, options = {}) {
         super();
         this.portPath = portPath;
         this.baudRate = baudRate;
+        this.dataBits = options.dataBits || 8;
+        this.stopBits = options.stopBits || 1;
+        this.parity = options.parity || 'none';
         this.logger = logger;
         this.port = null;
         this.protocolHandler = new ProtocolHandler();
@@ -59,15 +62,23 @@ class SerialClient extends EventEmitter {
             }
 
             if (!this.SerialPort) {
-                this.SerialPort = require('serialport').SerialPort;
+                // 兼容serialport v9和v10+
+                try {
+                    // v10+ API
+                    this.SerialPort = require('serialport').SerialPort;
+                } catch (e) {
+                    // v9 API
+                    this.SerialPort = require('serialport');
+                }
             }
 
             this.port = new this.SerialPort({
                 path: this.portPath,
                 baudRate: this.baudRate,
-                dataBits: 8,
-                stopBits: 1,
-                parity: 'none'
+                dataBits: this.dataBits,
+                stopBits: this.stopBits,
+                parity: this.parity,
+                lock: false  // 不锁定串口，避免HassOS环境下的锁定问题
             });
 
             return new Promise((resolve, reject) => {

package/nodes/rs485-debug.html

@@ -34,7 +34,7 @@
             
             function loadHistory() {
                 if (!node.id) return;
-                $.getJSON('/rs485-debug/history/' + node.id, function(messages) {
+                $.getJSON('rs485-debug/history/' + node.id, function(messages) {
                     var container = $('#debug-history');
                     
                     if (messages.length === 0) {

package/nodes/symi-485-bridge.html

@@ -43,7 +43,7 @@
                     if (callback) callback(); 
                     return; 
                 }
-                $.getJSON('/symi-rs485-bridge/mesh-devices/' + gatewayId)
+                $.getJSON('symi-rs485-bridge/mesh-devices/' + gatewayId)
                     .done(function(devices) {
                         meshDevices = devices || [];
                         console.log('[RS485 Bridge] 加载Mesh设备:', meshDevices.length);
@@ -56,7 +56,7 @@
             }
 
             // 加载协议模板
-            $.getJSON('/symi-rs485-bridge/protocols', function(data) {
+            $.getJSON('symi-rs485-bridge/protocols', function(data) {
                 protocolData = data || { brands: {} };
                 // 延迟加载设备，确保gateway选择框已初始化
                 setTimeout(function() {

package/nodes/symi-485-bridge.js

@@ -4,7 +4,13 @@
  * 事件驱动架构，命令队列顺序处理
  */
 
-const { SerialPort } = require('serialport');
+// 兼容serialport v9和v10+
+let SerialPort;
+try {
+    SerialPort = require('serialport').SerialPort;
+} catch (e) {
+    SerialPort = require('serialport');
+}
 
 module.exports = function(RED) {
     

package/nodes/symi-485-config.html

@@ -8,6 +8,8 @@
             port: { value: 502 },
             serialPort: { value: '' },
             baudRate: { value: 9600 },
+            dataBits: { value: 8 },
+            stopBits: { value: 1 },
             parity: { value: 'none' }
         },
         label: function() {
@@ -36,7 +38,7 @@
                 $btn.prop('disabled', true);
                 $select.empty().append('<option value="">搜索中...</option>').show();
                 
-                $.getJSON('/symi-gateway/serial-ports', function(ports) {
+                $.getJSON('symi-gateway/serial-ports', function(ports) {
                     $select.empty();
                     if (ports && ports.length > 0) {
                         $select.append('<option value="">-- 选择串口 --</option>');
@@ -108,6 +110,22 @@
             </select>
         </div>
         
+        <div class="form-row">
+            <label for="node-config-input-dataBits"><i class="fa fa-bars"></i> 数据位</label>
+            <select id="node-config-input-dataBits">
+                <option value="7">7</option>
+                <option value="8">8</option>
+            </select>
+        </div>
+        
+        <div class="form-row">
+            <label for="node-config-input-stopBits"><i class="fa fa-stop"></i> 停止位</label>
+            <select id="node-config-input-stopBits">
+                <option value="1">1</option>
+                <option value="2">2</option>
+            </select>
+        </div>
+        
         <div class="form-row">
             <label for="node-config-input-parity"><i class="fa fa-check-square"></i> 校验位</label>
             <select id="node-config-input-parity">

package/nodes/symi-485-config.js

@@ -3,7 +3,13 @@
  * 使用与Mesh网关相同的技术栈（SerialPort/net）
  */
 
-const { SerialPort } = require('serialport');
+// 兼容serialport v9和v10+
+let SerialPort;
+try {
+    SerialPort = require('serialport').SerialPort;
+} catch (e) {
+    SerialPort = require('serialport');
+}
 const net = require('net');
 
 // 全局禁用 Happy Eyeballs 算法，防止 AggregateError 导致 Node-RED 崩溃
@@ -50,6 +56,8 @@ module.exports = function(RED) {
         node.port = parseInt(config.port) || 502;
         node.serialPort = config.serialPort || '';
         node.baudRate = parseInt(config.baudRate) || 9600;
+        node.dataBits = parseInt(config.dataBits) || 8;
+        node.stopBits = parseInt(config.stopBits) || 1;
         node.parity = config.parity || 'none';
 
         // 连接状态
@@ -93,10 +101,11 @@ module.exports = function(RED) {
                     node.client = new SerialPort({
                         path: node.serialPort,
                         baudRate: node.baudRate,
-                        dataBits: 8,
-                        stopBits: 1,
+                        dataBits: node.dataBits,
+                        stopBits: node.stopBits,
                         parity: node.parity,
-                        autoOpen: false
+                        autoOpen: false,
+                        lock: false  // 不锁定串口，避免HassOS环境下的锁定问题
                     });
 
                     node.client.on('open', () => {

package/nodes/symi-device.html

@@ -60,6 +60,7 @@
             
             var loadDevices = function(gatewayId) {
                 if (!gatewayId) {
+                    console.log('[symi-device] 网关ID为空，跳过加载');
                     return;
                 }
                 
@@ -67,11 +68,16 @@
                 var currentValue = deviceSelect.val();
                 
                 deviceSelect.empty();
-                deviceSelect.append('<option value="">-- 选择设备 --</option>');
+                deviceSelect.append('<option value="">加载中...</option>');
                 
-                $.getJSON('/symi-gateway/devices/' + gatewayId)
+                var apiUrl = 'symi-gateway/devices/' + gatewayId;
+                console.log('[symi-device] 加载设备列表, API:', apiUrl);
+                
+                $.getJSON(apiUrl)
                     .done(function(devices) {
-                        console.log('加载设备列表:', devices.length, '个设备');
+                        console.log('[symi-device] 加载成功:', devices ? devices.length : 0, '个设备');
+                        deviceSelect.empty();
+                        deviceSelect.append('<option value="">-- 选择设备 --</option>');
                         if (devices && devices.length > 0) {
                             devices.forEach(function(device) {
                                 var label = device.name + ' (' + device.mac + ')';
@@ -99,8 +105,10 @@
                         
                         deviceSelect.trigger('change');
                     })
-                    .fail(function(err) {
-                        console.log('加载设备失败:', err);
+                    .fail(function(xhr, status, err) {
+                        console.log('[symi-device] 加载设备失败:', status, err, xhr.responseText);
+                        deviceSelect.empty();
+                        deviceSelect.append('<option value="">加载失败，请重试</option>');
                     });
             };
             

package/nodes/symi-gateway.html

@@ -7,7 +7,10 @@
             host: { value: '' },
             port: { value: 4196 },
             serialPort: { value: '' },
-            baudRate: { value: 115200 }
+            baudRate: { value: 115200 },
+            dataBits: { value: 8 },
+            stopBits: { value: 1 },
+            parity: { value: 'none' }
         },
         label: function() {
             return this.name || (this.connectionType === 'tcp'
@@ -34,7 +37,7 @@
                 $btn.prop('disabled', true).text('搜索中...');
                 $select.empty().append('<option value="">搜索中...</option>');
                 
-                $.getJSON('/symi-gateway/serial-ports', function(ports) {
+                $.getJSON('symi-gateway/serial-ports', function(ports) {
                     $select.empty();
                     if (ports && ports.length > 0) {
                         $select.append('<option value="">-- 选择串口 --</option>');
@@ -107,7 +110,38 @@
     
     <div class="form-row serial-config">
         <label for="node-config-input-baudRate"><i class="fa fa-tachometer"></i> 波特率</label>
-        <input type="number" id="node-config-input-baudRate" placeholder="115200">
+        <select id="node-config-input-baudRate">
+            <option value="9600">9600</option>
+            <option value="19200">19200</option>
+            <option value="38400">38400</option>
+            <option value="57600">57600</option>
+            <option value="115200">115200</option>
+        </select>
+    </div>
+    
+    <div class="form-row serial-config">
+        <label for="node-config-input-dataBits"><i class="fa fa-bars"></i> 数据位</label>
+        <select id="node-config-input-dataBits">
+            <option value="7">7</option>
+            <option value="8">8</option>
+        </select>
+    </div>
+    
+    <div class="form-row serial-config">
+        <label for="node-config-input-stopBits"><i class="fa fa-stop"></i> 停止位</label>
+        <select id="node-config-input-stopBits">
+            <option value="1">1</option>
+            <option value="2">2</option>
+        </select>
+    </div>
+    
+    <div class="form-row serial-config">
+        <label for="node-config-input-parity"><i class="fa fa-check-square"></i> 校验位</label>
+        <select id="node-config-input-parity">
+            <option value="none">无 (None)</option>
+            <option value="even">偶校验 (Even)</option>
+            <option value="odd">奇校验 (Odd)</option>
+        </select>
     </div>
 </script>
 

package/nodes/symi-gateway.js

@@ -45,6 +45,9 @@ module.exports = function(RED) {
         this.port = parseInt(config.port) || 4196;
         this.serialPort = config.serialPort;
         this.baudRate = parseInt(config.baudRate) || 115200;
+        this.dataBits = parseInt(config.dataBits) || 8;
+        this.stopBits = parseInt(config.stopBits) || 1;
+        this.parity = config.parity || 'none';
 
         this.client = null;
         this.deviceManager = new DeviceManager(this.context(), this, this.id);
@@ -83,7 +86,11 @@ module.exports = function(RED) {
             if (this.connectionType === 'tcp') {
                 this.client = new TCPClient(this.host, this.port, this);
             } else {
-                this.client = new SerialClient(this.serialPort, this.baudRate, this);
+                this.client = new SerialClient(this.serialPort, this.baudRate, this, {
+                    dataBits: this.dataBits,
+                    stopBits: this.stopBits,
+                    parity: this.parity
+                });
             }
             
             this.client.on('connected', () => {

package/nodes/symi-knx-bridge.js

@@ -149,11 +149,17 @@ module.exports = function(RED) {
         node.knxStateCache = {};        // KNX设备状态缓存
         node.lastMeshToKnx = {};        // 记录Mesh->KNX发送时间，防止回环
         node.lastKnxToMesh = {};        // 记录KNX->Mesh发送时间，防止回环
+        node.lastKnxAddrSent = {};      // 记录发送到KNX地址的时间，防止自己发的命令又被处理
         
         // 防死循环参数
         const LOOP_PREVENTION_MS = 800;   // 800ms内不处理反向同步，防止回环
         const DEBOUNCE_MS = 100;          // 100ms防抖
         const MAX_QUEUE_SIZE = 100;       // 最大队列大小
+        const COVER_CONTROL_LOCK_MS = 3000;  // 窗帘/调光控制锁定3秒（只忽略过程反馈，不长期锁定）
+        
+        // 控制锁定状态：谁先动作，锁定期间忽略另一方的反馈
+        // { deviceKey: { controller: 'mesh'|'knx', lockUntil: timestamp } }
+        node.controlLock = {};
         
         // 初始化标记
         node.initializing = true;
@@ -292,10 +298,15 @@ module.exports = function(RED) {
             for (const mapping of matchedMappings) {
                 const loopKey = `${mac}_${mapping.meshChannel}`;
                 
-                // 防死循环检查
-                if (node.shouldPreventSync('mesh-to-knx', loopKey)) {
-                    node.log(`[Mesh->KNX] 跳过(防死循环): ${loopKey}`);
-                    continue;
+                // 窗帘设备需要单独处理防死循环（动作和位置分开检查）
+                if (mapping.deviceType === 'cover') {
+                    // 窗帘的防死循环在内部单独处理，这里不跳过
+                } else {
+                    // 其他设备统一防死循环检查
+                    if (node.shouldPreventSync('mesh-to-knx', loopKey)) {
+                        node.log(`[Mesh->KNX] 跳过(防死循环): ${loopKey}`);
+                        continue;
+                    }
                 }
                 
                 // 开关设备
@@ -312,8 +323,23 @@ module.exports = function(RED) {
                         });
                     }
                 }
-                // 调光灯设备（单色、双色、RGB、RGBCW）
+                // 调光灯设备（单色、双色、RGB、RGBCW）- 简化逻辑：谁动谁跟，忽略过程反馈
                 else if (mapping.deviceType.startsWith('light_')) {
+                    if (!eventData.isUserControl) continue;
+                    
+                    const deviceKey = `${macNormalized}_light`;
+                    const now = Date.now();
+                    const lock = node.controlLock[deviceKey];
+                    
+                    // 如果KNX正在控制中，忽略Mesh的反馈
+                    if (lock && lock.controller === 'knx' && now < lock.lockUntil) {
+                        node.debug(`[Mesh->KNX] 调光灯跳过(KNX控制中): ${deviceKey}`);
+                        continue;
+                    }
+                    
+                    // Mesh发起控制，锁定20秒
+                    node.controlLock[deviceKey] = { controller: 'mesh', lockUntil: now + COVER_CONTROL_LOCK_MS };
+                    
                     // 开关状态
                     if (changed.switch !== undefined) {
                         node.log(`[Mesh->KNX] 调光灯开关: ${mapping.name || eventData.device.name} = ${changed.switch}`);
@@ -325,8 +351,8 @@ module.exports = function(RED) {
                             key: loopKey
                         });
                     }
-                    // 亮度
-                    if (changed.brightness !== undefined) {
+                    // 亮度（只在没有开关变化时同步，避免重复）
+                    if (changed.brightness !== undefined && changed.switch === undefined) {
                         node.log(`[Mesh->KNX] 调光灯亮度: ${mapping.name || eventData.device.name} = ${changed.brightness}%`);
                         node.queueCommand({
                             direction: 'mesh-to-knx',
@@ -348,29 +374,50 @@ module.exports = function(RED) {
                         });
                     }
                 }
-                // 窗帘设备
+                // 窗帘设备 - 简化逻辑：谁动谁跟，忽略过程反馈
                 else if (mapping.deviceType === 'cover') {
                     if (!eventData.isUserControl) continue;
                     
-                    if (changed.curtainAction !== undefined || changed.curtainStatus !== undefined) {
-                        const action = changed.curtainAction || state.curtainAction;
+                    const deviceKey = macNormalized;
+                    const now = Date.now();
+                    const lock = node.controlLock[deviceKey];
+                    
+                    // 如果KNX正在控制中，忽略Mesh的反馈（避免回环）
+                    if (lock && lock.controller === 'knx' && now < lock.lockUntil) {
+                        node.debug(`[Mesh->KNX] 窗帘跳过(KNX控制中): ${deviceKey}`);
+                        continue;
+                    }
+                    
+                    // Mesh发起控制，锁定20秒
+                    node.controlLock[deviceKey] = { controller: 'mesh', lockUntil: now + COVER_CONTROL_LOCK_MS };
+                    
+                    // 处理动作（打开/关闭/停止）
+                    if (changed.curtainAction !== undefined) {
+                        const action = changed.curtainAction;
                         node.log(`[Mesh->KNX] 窗帘动作: ${mapping.name || eventData.device.name} action=${action}`);
                         node.queueCommand({
                             direction: 'mesh-to-knx',
                             mapping: mapping,
                             type: 'cover_action',
                             value: action,
-                            key: loopKey
+                            key: `${loopKey}_action`
                         });
+                        
+                        // 停止时解除锁定
+                        if (action === 'stopped') {
+                            delete node.controlLock[deviceKey];
+                        }
                     }
-                    if (changed.curtainPosition !== undefined) {
+                    
+                    // 处理位置变化（只在没有动作变化时同步位置）
+                    if (changed.curtainPosition !== undefined && changed.curtainAction === undefined) {
                         node.log(`[Mesh->KNX] 窗帘位置: ${mapping.name || eventData.device.name} pos=${changed.curtainPosition}%`);
                         node.queueCommand({
                             direction: 'mesh-to-knx',
                             mapping: mapping,
                             type: 'cover_position',
                             value: changed.curtainPosition,
-                            key: loopKey
+                            key: `${loopKey}_position`
                         });
                     }
                 }
@@ -709,10 +756,17 @@ module.exports = function(RED) {
             }
             
             if (knxMsg) {
-                // knxUltimate官方格式: https://supergiovane.github.io/node-red-contrib-knx-ultimate/wiki/Device
-                // 必须包含: destination, payload, dpt, event
+                // 记录发送到的KNX地址和时间，防止自己发的命令又被处理
+                const destAddr = knxMsg.knx.destination;
+                node.lastKnxAddrSent[destAddr] = Date.now();
+                
+                // knxUltimate输入格式：topic + destination + payload + dpt + event
+                // topic: 当setTopicType=str时，knxUltimate使用msg.topic作为目标地址
+                // destination: 官方备用字段
+                // 注意：不能包含knx对象，否则会触发knxUltimate的循环引用保护
                 const sendMsg = {
-                    destination: knxMsg.knx.destination,
+                    topic: destAddr,
+                    destination: destAddr,
                     payload: knxMsg.payload,
                     dpt: knxMsg.dpt || knxMsg.knx.dpt,
                     event: "GroupValue_Write"
@@ -733,7 +787,7 @@ module.exports = function(RED) {
                     timestamp: new Date().toISOString()
                 };
                 
-                node.log(`[Mesh->KNX] 发送: destination=${sendMsg.destination}, payload=${sendMsg.payload}, dpt=${sendMsg.dpt}, event=${sendMsg.event}`);
+                node.log(`[Mesh->KNX] 发送: topic=${sendMsg.topic}, payload=${sendMsg.payload}, dpt=${sendMsg.dpt}`);
                 
                 // 同时发送到两个输出端口（一次send调用）
                 node.send([sendMsg, debugMsg]);
@@ -897,6 +951,14 @@ module.exports = function(RED) {
                 return;
             }
             
+            // 检查是否是我们自己发出去的命令（防止自己发的命令被监听后又处理）
+            const lastSentTime = node.lastKnxAddrSent[groupAddr] || 0;
+            if (Date.now() - lastSentTime < LOOP_PREVENTION_MS) {
+                node.debug(`[KNX输入] 跳过(自己发的): ${groupAddr}`);
+                done && done();
+                return;
+            }
+            
             // 查找映射
             const mapping = node.findKnxMapping(groupAddr);
             if (!mapping) {
@@ -909,7 +971,7 @@ module.exports = function(RED) {
             const addrFunc = node.getKnxAddrFunction(mapping, groupAddr);
             const loopKey = `${mapping.meshMac}_${mapping.meshChannel}`;
             
-            // 防死循环检查
+            // 防死循环检查（基于设备的双向同步防护）
             if (node.shouldPreventSync('knx-to-mesh', loopKey)) {
                 node.debug(`[KNX->Mesh] 跳过同步(防死循环): ${loopKey}, addr=${groupAddr}`);
                 done && done();
@@ -933,35 +995,55 @@ module.exports = function(RED) {
                     });
                 }
             }
-            // 窗帘设备
+            // 窗帘设备 - 简化逻辑：谁动谁跟，KNX可抢占控制权
             else if (mapping.deviceType === 'cover') {
+                const deviceKey = (mapping.meshMac || '').toLowerCase().replace(/:/g, '');
+                const now = Date.now();
+                
+                // KNX主动发起控制，直接抢占锁定（用户操作优先）
+                node.controlLock[deviceKey] = { controller: 'knx', lockUntil: now + COVER_CONTROL_LOCK_MS };
+                
                 if (addrFunc === 'cmd') {
                     // 上下命令: 0=上(开), 1=下(关)
                     const action = (value === 0 || value === false) ? 'open' : 'close';
+                    node.log(`[KNX->Mesh] 窗帘动作: ${action}`);
                     node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'cover_action', value: action, key: loopKey, sourceAddr: groupAddr });
                 }
                 else if (addrFunc === 'stop') {
+                    node.log(`[KNX->Mesh] 窗帘停止`);
                     node.queueCommand({ direction: 'knx-to-mesh', mapping, type: 'cover_action', value: 'stop', key: loopKey, sourceAddr: groupAddr });
+                    // 停止时解除锁定
+                    delete node.controlLock[deviceKey];
                 }
                 else if (addrFunc === 'position' || addrFunc === 'status') {
                     const pos = mapping.invertPosition ? (100 - (parseInt(value) || 0)) : (parseInt(value) || 0);
+                    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();
+                
+                // KNX主动发起控制，直接抢占锁定（用户操作优先）
+                node.controlLock[deviceKey] = { controller: 'knx', lockUntil: now + COVER_CONTROL_LOCK_MS };
+                
                 if (addrFunc === 'cmd' || addrFunc === 'status') {
                     // 开关
                     const sw = (value === 1 || value === true);
+                    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);
+                    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 });
                 }
             }

package/nodes/symi-mqtt-sync.html

@@ -59,7 +59,7 @@
                     if (callback) callback();
                     return;
                 }
-                $.getJSON('/symi-gateway/devices/' + gatewayId, function(devices) {
+                $.getJSON('symi-gateway/devices/' + gatewayId, function(devices) {
                     meshDevices = devices || [];
                     if (callback) callback();
                 }).fail(function() {
@@ -76,7 +76,7 @@
                     if (callback) callback();
                     return;
                 }
-                $.getJSON('/symi-mqtt-brand/devices/' + brandConfigId, function(devices) {
+                $.getJSON('symi-mqtt-brand/devices/' + brandConfigId, function(devices) {
                     brandDevices = devices || [];
                     if (callback) callback();
                 }).fail(function() {

package/package.json

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