node-red-contrib-symi-modbus 2.10.16 → 2.10.19

package/README.md

@@ -117,9 +117,12 @@ node-red-restart
 1. 拖拽 **从站开关** 节点到流程画布
 2. 选择刚创建的RS-485连接配置
 3. 配置开关面板信息：
-   - 面板品牌: `Symi` (默认)
+   - 面板品牌: `Symi` / `Clowire`（克伦威尔）
    - 开关ID: 物理面板地址 (0-255)
    - 按钮编号: 按键编号 (1-8)
+   - 按钮类型:
+     - `开关按钮`：Symi 面板下，按下=开，释放=关（有独立开/关码），适合直接映射单个继电器
+     - `场景按钮`：**Clowire 推荐使用**，以及 Symi 场景键；每次按下都触发一次 Toggle，由指示灯和继电器状态共同决定“当前是开还是关”
 4. 配置映射到的继电器：
    - 目标从站地址: `10`
    - 目标线圈编号: `0`
@@ -142,7 +145,16 @@ node-red-restart
 1. 拖拽 **Mesh透传** 节点。
 2. 选择对应的 **RS-485配置节点**（连接到蓝牙 Mesh 网关）。
 3. 节点会自动发现网关下的子设备，选择目标窗帘或杜亚电机。
-4. 该节点支持百分比控制、动作反馈以及端点自动修正逻辑。
+4. 配置 **控制逻辑**（仅窗帘类型显示）：
+   - **循环 (开-停-关-停)**：单键依次 打开→暂停→关闭→暂停。
+   - **打开/关闭**：单键在 开/关 之间切换，到顶/到底后再次按键必为 关/开。
+5. 可选绑定 **按键触发**：
+   - 使用 `从站开关` 或 `继电器输出` 节点，面板品牌选择 Symi / Clowire，按钮类型选择 **场景按钮**，并与 Mesh 窗帘节点的 `switchId` / `buttonNumber` 保持一致
+   - Clowire 按键在内部统一按“场景模式”处理：每次物理按键都会触发一次事件，不会因为 `value=false` 被忽略
+6. **状态与按键记忆**：窗帘上报的位置（0%/100%）会更新节点内部状态；下次同一按键按下时，会根据“到顶/到底”正确执行 关/开 或 暂停，无需额外配置。
+   - 运动过程中（收到中间百分比，未到 0%/100%），再次按键一律发送 **暂停**，不会发生错误翻转
+   - 只有在电机真正上报到端点（Mesh 0x06 / 杜亚 0x04 的 0% / 100%）时，才会记为“开着/关着”，下一次按键才直接翻转为 关/开
+7. 支持杜亚 485 电机：勾选“启用解析”、填写电机地址（高位-低位），可同时控制 Mesh 窗帘与杜亚电机并双向同步位置。
 
 ## 核心特性说明
 
@@ -475,6 +487,29 @@ msg.payload = 1;      // 或 0
 
 ### 更新日志
 
+#### v2.10.19 (2026-06-30)
+
+- **[工程]** 提取 `lib/lru-map.js`、`lib/slave-switch-cache.js`，精简 `modbus-slave-switch` 全局缓存逻辑并限制 Mesh LED 定时器上限（5000）。
+- **[工程]** 新增 `lib/http-admin-utils.js`，14 个 HTTP Admin 路由统一权限校验（read/write）。
+- **[工程]** `modbus-master` 串口列表 API 复用 `lib/serial-utils`，消除重复实现。
+- **[测试]** 新增 `mesh-protocol`、`lightweight-protocol` 协议帧解析单元测试（`npm test`）。
+
+#### v2.10.18 (2026-06-30)
+
+- **[打包]** 修复 npm 发布包误含 `.codebase-memory/` 开发索引文件的问题，包体积从约 493KB 降至约 158KB，避免将本地知识图谱索引发布到 npm。
+- **[工程]** 在 `.npmignore` 与 `.gitignore` 中排除 `.codebase-memory/`，确保开发工具产物不会进入发布包或版本库。
+
+#### v2.10.17 (2026-02-07)
+
+- **Mesh 窗帘协议兼容性**：按照《蓝牙MESH网关（初级版）串口协议V1.0》修正 0x53 0x80 0x06 节点状态帧解析逻辑，明确区分事件类型 RESULT_EVENT_NODE_STATUS(0x06) 与 `VD_MSG_TYPE_CURT_RUN_STATUS(0x05)` / `VD_MSG_TYPE_CURT_RUN_PER_POS(0x06)`，不再误把 `subOp` 当成窗帘 msg_type 使用，严格从数据区解析 `[msg_type][param]`。
+- **窗帘状态与端点记忆**：窗帘动作(0x05) 与位置(0x06) 在内部状态中分离存储，位置只由真正的 0x06 位置帧（含杜亚485位置反馈）更新；仅当位置为 0%/100% 且确认为当前运动方向的目标端点时才标记到达端点并更新 `lastAction/lastDirection`，避免 0x05 帧或“打开中收到0% / 关闭中收到100%”被误判为端点。
+- **开停关停 / 打开-关闭 行为**：
+  - 引入 `isMoving` 统一表示“运动过程”，只要执行过开/关且未到端点(0%/100%)，物理按键再次点击必发送暂停(3)，不会直接翻转方向。
+  - 停在 0%/100% 后会进行“端点收敛”：端点上报后不会再多走一次暂停，下一次按键一定是「关着→打开 / 开着→关闭」，到顶/到底后再次点击必然反向（关/开）。
+  - 修正 cycle 模式下起点 0%/100% 刚起步时第二下按键误判为翻转的问题；到端点仅在 `isMoving=false && reachedEndpoint=true && endpointPosition=0/100` 时生效，并移除“>50% / <=50% 位置兜底”，中途暂停后的方向完全由 `lastDirection/lastAction` 决定，保证绝对的「开-停-关-停」节奏。
+- **Mesh 透传与日志**：合并重复 close 监听、Mesh 透传热路径日志改为 debug，减少生产环境刷屏；仍兼容 Mesh 动作反馈(0x05) 与位置反馈(0x06)，但不再因为偶发“停止/运动中”状态抖动误判为已停止，避免运动过程误触发开/关。
+- **Clowire 场景按键**：Clowire 面板按键在从站开关 / 继电器输出 / Mesh 透传中统一按“场景按钮”处理，每次物理按下都会触发一次事件；运动中的窗帘再次按下必然发送暂停，不会误翻转方向。
+
 #### v2.10.16 (2026-02-06)
 
 - **按键记忆**：同一帧内若同时上报位置与动作（如 position=100 + action=打开中），以位置为准到端点即按「已停止」记忆，避免被动作覆盖导致下次按键误判。

package/lib/http-admin-utils.js

@@ -0,0 +1,34 @@
+"use strict";
+
+/**
+ * Node-RED HTTP Admin 路由注册（统一权限校验）
+ */
+function needsPermission(RED, permission) {
+    if (RED.auth && typeof RED.auth.needsPermission === "function") {
+        return RED.auth.needsPermission(permission);
+    }
+    return function passThrough(req, res, next) {
+        if (typeof next === "function") {
+            next();
+        }
+    };
+}
+
+function registerGet(RED, path, permission, handler) {
+    RED.httpAdmin.get(path, needsPermission(RED, permission), handler);
+}
+
+function registerPost(RED, path, permission, handler) {
+    RED.httpAdmin.post(path, needsPermission(RED, permission), handler);
+}
+
+function registerDelete(RED, path, permission, handler) {
+    RED.httpAdmin.delete(path, needsPermission(RED, permission), handler);
+}
+
+module.exports = {
+    needsPermission,
+    registerGet,
+    registerPost,
+    registerDelete
+};

package/lib/lru-map.js

@@ -0,0 +1,36 @@
+"use strict";
+
+/**
+ * 带大小限制的 LRU Map，用于全局缓存防内存泄漏
+ */
+class LRUMap extends Map {
+    constructor(maxSize, onEvict) {
+        super();
+        this.maxSize = maxSize;
+        this.onEvict = typeof onEvict === "function" ? onEvict : null;
+    }
+
+    set(key, value) {
+        if (this.has(key)) {
+            this.delete(key);
+        } else if (this.size >= this.maxSize) {
+            const firstKey = this.keys().next().value;
+            this.delete(firstKey);
+            if (this.onEvict) {
+                this.onEvict(firstKey);
+            }
+        }
+        return super.set(key, value);
+    }
+
+    get(key) {
+        const value = super.get(key);
+        if (value !== undefined) {
+            this.delete(key);
+            super.set(key, value);
+        }
+        return value;
+    }
+}
+
+module.exports = { LRUMap };

package/lib/slave-switch-cache.js

@@ -0,0 +1,88 @@
+"use strict";
+
+const { LRUMap } = require("./lru-map");
+
+const GLOBAL_CACHE_CONFIG = {
+    maxSize: 10000,
+    cleanupInterval: 600000,
+    expireTime: 3600000,
+    meshLedTimerMaxSize: 5000
+};
+
+/**
+ * 从站开关节点全局缓存（LRU + 定期清理）
+ */
+function createSlaveSwitchCaches(RED) {
+    const onEvict = (key) => {
+        if (RED && RED.log && RED.log.debug) {
+            RED.log.debug(`LRU缓存淘汰: 删除键 ${key}`);
+        }
+    };
+
+    const globalDebounceCache = new LRUMap(GLOBAL_CACHE_CONFIG.maxSize, onEvict);
+    const meshDeviceStates = new LRUMap(GLOBAL_CACHE_CONFIG.maxSize, onEvict);
+    const meshWirelessButtons = new LRUMap(GLOBAL_CACHE_CONFIG.maxSize, onEvict);
+    const globalButtonRelayStates = new LRUMap(GLOBAL_CACHE_CONFIG.maxSize, onEvict);
+    const meshLedDebounceTimers = new Map();
+
+    function getScopedKey(node, key) {
+        const configId = (node.serialPortConfig && node.serialPortConfig.id) || node.id || "global";
+        return `${configId}:${key}`;
+    }
+
+    let cleanupTimer = null;
+
+    function startGlobalDebounceCacheCleanup() {
+        if (cleanupTimer) {
+            return;
+        }
+        cleanupTimer = setInterval(() => {
+            const now = Date.now();
+            const expireThreshold = 60 * 1000;
+            let cleanedCount = 0;
+
+            for (const [key, timestamp] of globalDebounceCache.entries()) {
+                if (now - timestamp > expireThreshold) {
+                    globalDebounceCache.delete(key);
+                    cleanedCount++;
+                }
+            }
+
+            // Mesh LED 防抖定时器：清理已失效条目并限制最大数量
+            for (const [key, timerObj] of meshLedDebounceTimers.entries()) {
+                if (!timerObj || !timerObj.timer) {
+                    meshLedDebounceTimers.delete(key);
+                    cleanedCount++;
+                }
+            }
+            while (meshLedDebounceTimers.size > GLOBAL_CACHE_CONFIG.meshLedTimerMaxSize) {
+                const firstKey = meshLedDebounceTimers.keys().next().value;
+                const timerObj = meshLedDebounceTimers.get(firstKey);
+                if (timerObj && timerObj.timer) {
+                    clearTimeout(timerObj.timer);
+                }
+                meshLedDebounceTimers.delete(firstKey);
+                cleanedCount++;
+            }
+
+            if (cleanedCount > 0 && RED && RED.log && RED.log.debug) {
+                RED.log.debug(
+                    `全局缓存清理: 删除${cleanedCount}条记录，防抖${globalDebounceCache.size}条，LED定时器${meshLedDebounceTimers.size}条`
+                );
+            }
+        }, 10 * 60 * 1000);
+    }
+
+    return {
+        GLOBAL_CACHE_CONFIG,
+        globalDebounceCache,
+        meshDeviceStates,
+        meshWirelessButtons,
+        meshLedDebounceTimers,
+        globalButtonRelayStates,
+        getScopedKey,
+        startGlobalDebounceCacheCleanup
+    };
+}
+
+module.exports = { createSlaveSwitchCaches, GLOBAL_CACHE_CONFIG };

package/nodes/custom-protocol.js

@@ -1,5 +1,6 @@
 module.exports = function(RED) {
     "use strict";
+    const httpAdmin = require("../lib/http-admin-utils");
 
     function CustomProtocolNode(config) {
         RED.nodes.createNode(this, config);
@@ -173,7 +174,7 @@ module.exports = function(RED) {
     RED.nodes.registerType("custom-protocol", CustomProtocolNode);
 
     // HTTP API：测试发送指令
-    RED.httpAdmin.post("/custom-protocol/test", function(req, res) {
+    httpAdmin.registerPost(RED, "/custom-protocol/test", "custom-protocol.write", function(req, res) {
         var serialConfigId = req.body.serialConfig;
         var hexString = req.body.hexString;
         var cmdName = req.body.cmdName;

package/nodes/homekit-bridge.js

@@ -1,6 +1,7 @@
 module.exports = function(RED) {
     "use strict";
     const { ensureRedEventsMaxListeners } = require("../lib/red-events-utils");
+    const httpAdmin = require("../lib/http-admin-utils");
     ensureRedEventsMaxListeners(RED);
     const hap = require("hap-nodejs");
     const storage = require("node-persist");
@@ -335,7 +336,7 @@ module.exports = function(RED) {
     RED.nodes.registerType("homekit-bridge", HomekitBridgeNode);
 
     // HTTP API：获取主站节点配置
-    RED.httpAdmin.get("/homekit-bridge/master-config/:id", function(req, res) {
+    httpAdmin.registerGet(RED, "/homekit-bridge/master-config/:id", "homekit-bridge.read", function(req, res) {
         var masterNodeId = req.params.id;
         var masterNode = RED.nodes.getNode(masterNodeId);
 

package/nodes/mesh-protocol.js

@@ -284,37 +284,6 @@ module.exports = function(_RED) {
                 mac: null
             };
 
-            // 逻辑修正：如果 subOp 是窗帘相关类型 (0x05/0x06)，处理两种帧格式
-            // 1. 标准帧 (Len=4): Addr(2) + Type(1) + Value(1) → 电机到头会上报 06 64(100%) 或 06 00(0%)，用于开/关记忆
-            // 2. 紧凑帧 (Len=3): Addr(2) + Value(1) (部分旧固件或特定场景)
-            if ((subOp === PROTOCOL.MSG_TYPE_CURTAIN || subOp === PROTOCOL.MSG_TYPE_CURTAIN_POS)) {
-                const dataLen = frame[3];
-                
-                // 标准帧: 53 80 06 04 [AddrL] [AddrH] [Type] [Value] — Type=0x06 时 Value 即位置 0–100（06 00=0%，06 64=100%）
-                if (dataLen === 4 && frame.length >= 8) {
-                    event.msgType = subOp;
-                    event.deviceType = frame[6]; // 0x05=动作帧 / 0x06=位置帧（收到位置帧后 entity.type 会为 6，透传节点需按窗帘处理）
-                    if (subOp === PROTOCOL.MSG_TYPE_CURTAIN) {
-                        event.action = frame[7];
-                    } else {
-                        event.position = frame[7]; // 精准：06 64=100%，06 00=0%
-                    }
-                    return event;
-                }
-                
-                // 紧凑帧: 53 80 06 03 [AddrL] [AddrH] [Value]
-                if (dataLen === 3 && frame.length >= 7) {
-                    event.msgType = subOp;
-                    event.deviceType = PROTOCOL.DEVICE_TYPE_CURTAIN; // 隐式推断
-                    if (subOp === PROTOCOL.MSG_TYPE_CURTAIN) {
-                        event.action = frame[6];
-                    } else {
-                        event.position = frame[6];
-                    }
-                    return event;
-                }
-            }
-
             // 解析数据部分（从第6字节开始）
             let offset = 6;
             while (offset < frame.length - 1) {  // 最后一字节是校验