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

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,23 @@ node-red-contrib-symi-mesh/
 
 ## 更新日志
 
+### 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配置节点架构**：
@@ -1580,19 +1602,6 @@ node-red-contrib-symi-mesh/
   - 连接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 +1613,7 @@ Copyright (c) 2025 SYMI 亖米
 ## 关于
 
 **作者**: SYMI 亖米
-**版本**: 1.7.3
+**版本**: 1.7.4
 **协议**: 蓝牙MESH网关（初级版）串口协议V1.0
 **最后更新**: 2025-12-24
 **仓库**: https://github.com/symi-daguo/node-red-contrib-symi-mesh

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/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() {
@@ -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-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'
@@ -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,14 @@ module.exports = function(RED) {
             }
             
             if (knxMsg) {
+                // 记录发送到的KNX地址和时间，防止自己发的命令又被处理
+                const destAddr = knxMsg.knx.destination;
+                node.lastKnxAddrSent[destAddr] = Date.now();
+                
                 // knxUltimate官方格式: https://supergiovane.github.io/node-red-contrib-knx-ultimate/wiki/Device
                 // 必须包含: destination, payload, dpt, event
                 const sendMsg = {
-                    destination: knxMsg.knx.destination,
+                    destination: destAddr,
                     payload: knxMsg.payload,
                     dpt: knxMsg.dpt || knxMsg.knx.dpt,
                     event: "GroupValue_Write"
@@ -897,6 +948,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 +968,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 +992,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/package.json

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