node-red-contrib-symi-mesh 1.8.3 → 1.8.5

package/lib/sync-utils.js

@@ -0,0 +1,398 @@
+/**
+ * Sync Utils - 通用同步工具类
+ * 版本: 1.8.5
+ * 
+ * 提供统一的防环路、状态缓存和同步队列管理功能
+ * 供 symi-ha-sync、symi-mqtt-sync、symi-rs485-sync 等节点共用
+ */
+
+// 默认超时配置
+const DEFAULT_TIMEOUT = 2000;      // 普通设备防环路超时
+const COVER_TIMEOUT = 40000;       // 窗帘防环路超时（增加至40s，针对无限位模块）
+const BRIGHTNESS_TIMEOUT = 800;    // 亮度防抖超时
+const CLEANUP_INTERVAL = 60000;    // 清理间隔
+const TIMESTAMP_EXPIRE = 60000;    // 时间戳过期时间
+
+// 三合一子实体映射配置
+const THREE_IN_ONE_SUB_ENTITIES = {
+    aircon: {
+        name: '空调',
+        hyqwType: 12,
+        haEntityType: 'climate',
+        properties: ['switch', 'temperature', 'mode', 'fanSpeed'],
+        meshAttrs: {
+            switch: 0x02,
+            temperature: 0x1B,
+            mode: 0x1D,
+            fanSpeed: 0x1C
+        }
+    },
+    fresh_air: {
+        name: '新风',
+        hyqwType: 36,
+        haEntityType: 'fan',
+        properties: ['switch', 'speed'],
+        meshAttrs: {
+            switch: 0x68,
+            speed: 0x6A
+        }
+    },
+    floor_heating: {
+        name: '地暖',
+        hyqwType: 16,
+        haEntityType: 'climate',
+        properties: ['switch', 'temperature'],
+        meshAttrs: {
+            switch: 0x6B,
+            temperature: 0x6C
+        }
+    }
+};
+
+/**
+ * 同步工具类 - 提供统一的防环路逻辑
+ */
+class SyncUtils {
+    constructor(options = {}) {
+        this.defaultTimeout = options.defaultTimeout || DEFAULT_TIMEOUT;
+        this.coverTimeout = options.coverTimeout || COVER_TIMEOUT;
+        this.brightnessTimeout = options.brightnessTimeout || BRIGHTNESS_TIMEOUT;
+        this.syncTimestamps = new Map();  // key -> { direction, timestamp }
+        this.cleanupInterval = null;
+        
+        // 启动定期清理
+        this.startCleanup();
+    }
+
+    /**
+     * 检查是否应该阻止同步（防环路）
+     * @param {string} direction - 'mesh-to-target' 或 'target-to-mesh'
+     * @param {string} key - 唯一标识符 (mac_channel_property)
+     * @param {number} timeout - 超时时间（毫秒），可选
+     * @returns {boolean} - true表示应该阻止
+     */
+    shouldPreventSync(direction, key, timeout) {
+        const now = Date.now();
+        const record = this.syncTimestamps.get(key);
+        
+        if (!record) return false;
+        
+        // 使用传入的timeout或默认值
+        const effectiveTimeout = timeout || this.defaultTimeout;
+        
+        // 检查反向同步是否在超时时间内
+        const oppositeDirection = direction === 'mesh-to-target' ? 'target-to-mesh' : 'mesh-to-target';
+        if (record.direction === oppositeDirection && (now - record.timestamp) < effectiveTimeout) {
+            return true;
+        }
+        
+        return false;
+    }
+
+    /**
+     * 记录同步时间
+     * @param {string} direction - 同步方向
+     * @param {string} key - 唯一标识符
+     */
+    recordSyncTime(direction, key) {
+        this.syncTimestamps.set(key, {
+            direction: direction,
+            timestamp: Date.now()
+        });
+    }
+
+    /**
+     * 清理过期的时间戳
+     * @param {number} expireMs - 过期时间（毫秒）
+     */
+    cleanupExpiredTimestamps(expireMs = TIMESTAMP_EXPIRE) {
+        const now = Date.now();
+        for (const [key, record] of this.syncTimestamps) {
+            if (now - record.timestamp > expireMs) {
+                this.syncTimestamps.delete(key);
+            }
+        }
+    }
+
+    /**
+     * 根据设备类型获取超时时间
+     * @param {string} deviceType - 设备类型
+     * @returns {number} - 超时时间（毫秒）
+     */
+    getTimeoutForDevice(deviceType) {
+        switch (deviceType) {
+            case 'cover':
+            case 'curtain':
+                return this.coverTimeout;
+            case 'light':
+            case 'brightness':
+                return this.brightnessTimeout;
+            default:
+                return this.defaultTimeout;
+        }
+    }
+
+    /**
+     * 启动定期清理
+     */
+    startCleanup() {
+        if (this.cleanupInterval) return;
+        this.cleanupInterval = setInterval(() => {
+            this.cleanupExpiredTimestamps();
+        }, CLEANUP_INTERVAL);
+    }
+
+    /**
+     * 销毁实例，清理资源
+     */
+    destroy() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
+        this.syncTimestamps.clear();
+    }
+}
+
+/**
+ * 状态缓存类 - 用于对比状态变化，避免重复同步
+ */
+class StateCache {
+    constructor(context, storageKey) {
+        this.context = context;
+        this.storageKey = storageKey || 'sync_state_cache';
+        this.cache = new Map();
+        this.loadFromContext();
+    }
+
+    /**
+     * 从Node-RED context加载缓存
+     */
+    loadFromContext() {
+        if (!this.context) return;
+        try {
+            const saved = this.context.get(this.storageKey) || {};
+            for (const [key, value] of Object.entries(saved)) {
+                this.cache.set(key, value);
+            }
+        } catch (e) {
+            // 静默处理
+        }
+    }
+
+    /**
+     * 保存缓存到Node-RED context
+     */
+    saveToContext() {
+        if (!this.context) return;
+        try {
+            const obj = Object.fromEntries(this.cache);
+            this.context.set(this.storageKey, obj);
+        } catch (e) {
+            // 静默处理
+        }
+    }
+
+    /**
+     * 检查状态是否有变化
+     * @param {string} key - 唯一标识符
+     * @param {any} newState - 新状态
+     * @returns {boolean} - true表示有变化
+     */
+    hasChanged(key, newState) {
+        const oldState = this.cache.get(key);
+        if (oldState === undefined) return true;
+        
+        // 深度比较
+        return JSON.stringify(oldState) !== JSON.stringify(newState);
+    }
+
+    /**
+     * 更新缓存
+     * @param {string} key - 唯一标识符
+     * @param {any} state - 状态值
+     */
+    update(key, state) {
+        this.cache.set(key, JSON.parse(JSON.stringify(state))); // 深拷贝
+        this.saveToContext();
+    }
+
+    /**
+     * 获取缓存的状态
+     * @param {string} key - 唯一标识符
+     * @returns {any} - 缓存的状态值
+     */
+    get(key) {
+        return this.cache.get(key);
+    }
+
+    /**
+     * 删除缓存项
+     * @param {string} key - 唯一标识符
+     */
+    remove(key) {
+        this.cache.delete(key);
+        this.saveToContext();
+    }
+
+    /**
+     * 清空缓存
+     */
+    clear() {
+        this.cache.clear();
+        this.saveToContext();
+    }
+}
+
+/**
+ * 同步队列类 - 管理同步命令的排队和执行
+ */
+class SyncQueue {
+    constructor(options = {}) {
+        this.maxSize = options.maxSize || 100;
+        this.processInterval = options.processInterval || 50;
+        this.queue = [];
+        this.processing = false;
+        this.logger = options.logger || console;
+        this.onProcess = options.onProcess || (() => {});
+        this.processTimer = null;
+    }
+
+    /**
+     * 添加命令到队列
+     * @param {object} command - 同步命令
+     * @returns {boolean} - 是否成功添加
+     */
+    add(command) {
+        // 队列满时移除最旧的命令
+        if (this.queue.length >= this.maxSize) {
+            const dropped = this.queue.shift();
+            if (this.logger && this.logger.warn) {
+                this.logger.warn(`[SyncQueue] 队列已满，丢弃旧命令: ${dropped.key || 'unknown'}`);
+            }
+        }
+        
+        // 去重：相同key的命令只保留最新的
+        if (command.key) {
+            const existingIndex = this.queue.findIndex(c => c.key === command.key);
+            if (existingIndex >= 0) {
+                this.queue[existingIndex] = command;
+                return true;
+            }
+        }
+        
+        command.timestamp = Date.now();
+        this.queue.push(command);
+        
+        // 如果没有在处理，启动处理
+        if (!this.processing) {
+            this.startProcessing();
+        }
+        
+        return true;
+    }
+
+    /**
+     * 开始处理队列
+     */
+    startProcessing() {
+        if (this.processing) return;
+        this.processing = true;
+        
+        const processNext = async () => {
+            if (this.queue.length === 0) {
+                this.processing = false;
+                return;
+            }
+            
+            const command = this.queue.shift();
+            
+            try {
+                await this.onProcess(command);
+            } catch (e) {
+                if (this.logger && this.logger.error) {
+                    this.logger.error(`[SyncQueue] 处理命令失败: ${e.message}`);
+                }
+            }
+            
+            // 继续处理下一个
+            this.processTimer = setTimeout(processNext, this.processInterval);
+        };
+        
+        processNext();
+    }
+
+    /**
+     * 获取队列深度
+     * @returns {number}
+     */
+    getDepth() {
+        return this.queue.length;
+    }
+
+    /**
+     * 清空队列
+     */
+    clear() {
+        this.queue = [];
+        if (this.processTimer) {
+            clearTimeout(this.processTimer);
+            this.processTimer = null;
+        }
+        this.processing = false;
+    }
+
+    /**
+     * 销毁队列
+     */
+    destroy() {
+        this.clear();
+        this.onProcess = null;
+        this.logger = null;
+    }
+}
+
+/**
+ * 获取三合一子实体配置
+ * @param {string} subType - 子实体类型 ('aircon', 'fresh_air', 'floor_heating')
+ * @returns {object|null} - 子实体配置
+ */
+function getThreeInOneSubEntity(subType) {
+    return THREE_IN_ONE_SUB_ENTITIES[subType] || null;
+}
+
+/**
+ * 获取所有三合一子实体类型
+ * @returns {string[]} - 子实体类型数组
+ */
+function getThreeInOneSubTypes() {
+    return Object.keys(THREE_IN_ONE_SUB_ENTITIES);
+}
+
+/**
+ * 根据HYQW设备类型获取对应的三合一子实体类型
+ * @param {number} hyqwType - HYQW设备类型
+ * @returns {string|null} - 子实体类型
+ */
+function getSubEntityByHyqwType(hyqwType) {
+    for (const [subType, config] of Object.entries(THREE_IN_ONE_SUB_ENTITIES)) {
+        if (config.hyqwType === hyqwType) {
+            return subType;
+        }
+    }
+    return null;
+}
+
+module.exports = {
+    SyncUtils,
+    StateCache,
+    SyncQueue,
+    THREE_IN_ONE_SUB_ENTITIES,
+    getThreeInOneSubEntity,
+    getThreeInOneSubTypes,
+    getSubEntityByHyqwType,
+    // 导出常量供外部使用
+    DEFAULT_TIMEOUT,
+    COVER_TIMEOUT,
+    BRIGHTNESS_TIMEOUT
+};

package/nodes/rs485-debug.html

@@ -22,10 +22,11 @@
             var autoRefreshInterval = null;
             var autoRefreshEnabled = true;
             
-            // 设置编辑面板更宽
+            // 设置编辑面板更宽更高
             var panel = $('#dialog-form').parent();
-            if (panel.length && panel.width() < 700) {
-                panel.css('width', '800px');
+            if (panel.length) {
+                if (panel.width() < 1000) panel.css('width', '1000px');
+                if (panel.height() < 1000) panel.css('min-height', '1000px');
             }
             
             // 加载历史消息 - 显示全部100条（增量更新避免闪烁）

package/nodes/symi-485-bridge.html

@@ -30,10 +30,11 @@
             var mappings = [];
             var cachedMeshDevices = [];
             
-            // 设置编辑面板更宽
+            // 设置编辑面板更宽更高
             var panel = $('#dialog-form').parent();
-            if (panel.length && panel.width() < 920) {
-                panel.css('width', '900px');
+            if (panel.length) {
+                if (panel.width() < 1000) panel.css('width', '1000px');
+                if (panel.height() < 1000) panel.css('min-height', '1000px');
             }
             
             try { mappings = JSON.parse(node.mappings || '[]'); } catch(e) { mappings = []; }

package/nodes/symi-485-bridge.js

@@ -2,6 +2,11 @@
  * Symi RS485 Bridge Node - Mesh与RS485设备双向同步桥接
  * 使用配置节点管理RS485连接（与Mesh网关相同的配置方式）
  * 事件驱动架构，命令队列顺序处理
+ * 
+ * 版本: 1.8.5
+ * 
+ * v1.8.5 更新:
+ * - 使用通用 SyncUtils 类统一防环路逻辑
  */
 
 // 兼容serialport v9和v10+
@@ -12,6 +17,8 @@ try {
     SerialPort = require('serialport');
 }
 
+const { SyncUtils, COVER_TIMEOUT, BRIGHTNESS_TIMEOUT, DEFAULT_TIMEOUT } = require('../lib/sync-utils');
+
 module.exports = function(RED) {
     
     // 协议模板定义 - 按品牌/小区组织，不含房间名，只有设备类型标准模板
@@ -966,6 +973,13 @@ module.exports = function(RED) {
         node.syncLock = false;
         node.lastSyncTime = {};
         node.pendingVerify = false;
+        
+        // 初始化通用同步工具类
+        node.syncUtils = new SyncUtils({
+            defaultTimeout: DEFAULT_TIMEOUT,
+            coverTimeout: COVER_TIMEOUT,
+            brightnessTimeout: BRIGHTNESS_TIMEOUT
+        });
 
         // RS485连接信息
         const rs485Info = node.rs485Config.connectionType === 'tcp' 
@@ -1051,6 +1065,19 @@ module.exports = function(RED) {
             node.log('[RS485 Bridge] 初始化完成，开始同步');
         }, 5000);  // 5秒初始化延迟
 
+        // 检查是否应该阻止同步（防死循环）- 使用通用 SyncUtils
+        node.shouldPreventSync = function(direction, key) {
+            // 转换方向名称以匹配 SyncUtils 的格式
+            const syncDirection = direction === 'mesh-to-rs485' ? 'mesh-to-target' : 'target-to-mesh';
+            return node.syncUtils.shouldPreventSync(syncDirection, key);
+        };
+
+        // 记录同步时间（用于防死循环）- 使用通用 SyncUtils
+        node.recordSyncTime = function(direction, key) {
+            const syncDirection = direction === 'mesh-to-rs485' ? 'mesh-to-target' : 'target-to-mesh';
+            node.syncUtils.recordSyncTime(syncDirection, key);
+        };
+
         // Mesh设备状态变化处理(事件驱动)
         const handleMeshStateChange = (eventData) => {
             // 只检查initializing，不检查syncLock以避免丢失事件
@@ -3077,6 +3104,11 @@ module.exports = function(RED) {
                 node.rs485Config.deregister(node);
             }
             
+            // 销毁 SyncUtils 实例，清理资源
+            if (node.syncUtils) {
+                node.syncUtils.destroy();
+            }
+            
             // 清理缓存和队列，防止内存泄漏
             node.stateCache = {};
             node.commandQueue = [];

package/nodes/symi-485-config.html

@@ -20,6 +20,13 @@
         oneditprepare: function() {
             var node = this;
             
+            // 设置编辑面板更宽更高
+            var panel = $('#dialog-form').parent();
+            if (panel.length) {
+                if (panel.width() < 1000) panel.css('width', '1000px');
+                if (panel.height() < 1000) panel.css('min-height', '1000px');
+            }
+            
             // 连接类型切换
             $('#node-config-input-connectionType').on('change', function() {
                 if ($(this).val() === 'tcp') {

package/nodes/symi-cloud-sync.html

@@ -29,6 +29,13 @@
         oneditprepare: function() {
             const node = this;
 
+            // 设置编辑面板更宽更高
+            var panel = $('#dialog-form').parent();
+            if (panel.length) {
+                if (panel.width() < 1000) panel.css('width', '1000px');
+                if (panel.height() < 1000) panel.css('min-height', '1000px');
+            }
+
             $('#node-input-autoSync').prop('checked', node.autoSync !== false);
 
             // 初始化已保存的酒店和房间信息

package/nodes/symi-device.html

@@ -31,6 +31,13 @@
         oneditprepare: function() {
             var node = this;
             node._deviceCache = {};
+
+            // 设置编辑面板更宽更高
+            var panel = $('#dialog-form').parent();
+            if (panel.length) {
+                if (panel.width() < 1000) panel.css('width', '1000px');
+                if (panel.height() < 1000) panel.css('min-height', '1000px');
+            }
             
             var updateChannelSelector = function(channels) {
                 if (channels > 1) {

package/nodes/symi-gateway.html

@@ -20,6 +20,13 @@
         oneditprepare: function() {
             var node = this;
             
+            // 设置编辑面板更宽更高
+            var panel = $('#dialog-form').parent();
+            if (panel.length) {
+                if (panel.width() < 1000) panel.css('width', '1000px');
+                if (panel.height() < 1000) panel.css('min-height', '1000px');
+            }
+            
             $('#node-config-input-connectionType').on('change', function() {
                 if ($(this).val() === 'tcp') {
                     $('.tcp-config').show();

package/nodes/symi-ha-sync.html

@@ -35,8 +35,8 @@
             // 设置编辑面板更宽更高
             var panel = $('#dialog-form').parent();
             if (panel.length) {
-                if (panel.width() < 920) panel.css('width', '900px');
-                if (panel.height() < 700) panel.css('min-height', '700px');
+                if (panel.width() < 1000) panel.css('width', '1000px');
+                if (panel.height() < 1000) panel.css('min-height', '1000px');
             }
 
             try { mappings = JSON.parse(node.mappings || '[]'); } catch(e) { mappings = []; }
@@ -202,7 +202,7 @@
                     });
                 } else {
                     // 多路开关
-                    var channels = parseInt(device ? (device.channels || 1) : (savedChannels || 1)) || 1;
+                    var channels = device ? (device.channels || 1) : (savedChannels || 1);
                     for (var i = 1; i <= channels; i++) {
                         var sel = (i == selectedKey) ? ' selected' : '';
                         html += '<option value="' + i + '"' + sel + '>按键' + i + '</option>';
@@ -477,44 +477,11 @@
     <h3>功能特性</h3>
     <ul>
         <li><strong>完美双向同步</strong>：Symi↔HA实时状态同步</li>
-        <li><strong>多设备类型支持</strong>：开关、调光灯、窗帘、温控器/空调、新风、地暖</li>
+        <li><strong>多设备类型支持</strong>：开关、调光灯、窗帘、温控器/空调</li>
         <li><strong>智能按键选择</strong>：只有多路开关才显示按键选择</li>
         <li><strong>配置持久化</strong>：设备列表和映射配置持久保存</li>
         <li><strong>防死循环</strong>：内置2秒防抖机制</li>
-        <li><strong>智能防抖</strong>：窗帘/调光灯只同步最终位置，过程状态不同步</li>
-    </ul>
-
-    <h3>⚠️ 双向同步连接方式（重要）</h3>
-    <p>要实现 HA→Symi 方向同步，必须连接 HA 事件节点到本节点输入端：</p>
-    
-    <h4>方式1：使用 server-events 节点（推荐）</h4>
-    <pre>
-[server-events] → [symi-ha-sync]
-    (事件类型: state_changed)
-    </pre>
-    <p><strong>配置步骤：</strong></p>
-    <ol>
-        <li>添加 <code>events: all</code> 节点（Home Assistant 分类下）</li>
-        <li>事件类型(Event Type)填写: <code>state_changed</code></li>
-        <li>将输出连接到 symi-ha-sync 节点的输入端</li>
-    </ol>
-    
-    <h4>方式2：使用 server-state-changed 节点</h4>
-    <pre>
-[server-state-changed] → [symi-ha-sync]
-    </pre>
-    <p><strong>配置步骤：</strong></p>
-    <ol>
-        <li>添加 <code>events: state</code> 节点</li>
-        <li>实体ID可留空（监听所有实体）或指定特定实体</li>
-        <li>将输出连接到 symi-ha-sync 节点的输入端</li>
-    </ol>
-
-    <h3>状态指示</h3>
-    <ul>
-        <li><strong>蓝色 "Mesh→HA"</strong>：仅 Mesh 到 HA 方向工作（未连接 HA 事件节点）</li>
-        <li><strong>绿色 "双向同步"</strong>：双向同步正常工作</li>
-        <li><strong>红色</strong>：配置错误</li>
+        <li><strong>智能防抖</strong>：窗帘/调光灯只同步最终位置</li>
     </ul>
 
     <h3>支持的设备类型</h3>
@@ -523,15 +490,6 @@
         <li><strong>调光灯</strong>：开关 + 亮度 (0-100)</li>
         <li><strong>窗帘</strong>：开/关/停 + 位置 (0-100%)</li>
         <li><strong>温控器/空调</strong>：开关 + 温度 + 模式 + 风速</li>
-        <li><strong>三合一面板</strong>：空调 + 新风 + 地暖，分别配置</li>
-    </ul>
-
-    <h3>三合一面板配置</h3>
-    <p>三合一面板需要分别为每个子设备创建映射：</p>
-    <ul>
-        <li><strong>空调</strong>：选择子设备"空调"，映射到 climate 实体</li>
-        <li><strong>新风</strong>：选择子设备"新风"，映射到 fan 实体</li>
-        <li><strong>地暖</strong>：选择子设备"地暖"，映射到 climate 实体</li>
     </ul>
 
     <h3>离线设备显示</h3>