node-red-contrib-symi-modbus 2.10.27 → 2.10.29

package/README.md

@@ -34,7 +34,7 @@ Node-RED的Modbus继电器控制节点，支持TCP/串口通信和MQTT集成。
 | **HomeKit网桥** | 一键将所有 Modbus 继电器接入 Apple HomeKit，支持自定义名称。 |
 | **控制看板** | 在 Node-RED 编辑器内直接控制和查看所有继电器的实时状态。 |
 | **Mesh透传** | 适配 Symi 蓝牙 Mesh 网关，支持窗帘、杜亚电机及各种子设备。 |
-| **继电器输出** | 灵活的联动节点，支持按键触发、延时控制和多种动作逻辑。 |
+| **继电器输出** | 灵活的联动节点，支持按键触发、延时控制、多种动作逻辑，LF 品牌支持指示灯跟随与睡眠模式。 |
 | **Modbus调试** | 实时监控原始 485 总线报文，方便现场调试和协议分析。 |
 | **自定义协议** | 支持通过 JavaScript 编写自定义协议转换逻辑。 |
 | **配置节点** | 包含串口配置、MQTT配置和Modbus服务器配置。 |
@@ -134,8 +134,11 @@ node-red-restart
 - **面板地址**：1–42（出厂默认 2），开关 ID 填十进制地址
 - **按键上报**（主动发送 8 字节）：`[地址][03][00][02][绝对键值][按键掩码][CRC]`
 - **指示灯控制**：写寄存器 `0x1008` 一次写入完整 bitmask（变背光产品高字节 BIT8=1，节点自动处理）
+- **待机指示灯**：继电器全部关闭时默认下发 `0x0100`（仅 BIT8 背光），**不会**自动全灭；全灭 `0x0000` 仅用于显式熄灭
+- **继电器输出（LF）**：可选 **指示灯跟随状态**——勾选则按键灯与绑定线圈同步；不勾选则按键后瞬时亮灯，本按键关联的全部继电器动作完成后恢复待机背光
+- **睡眠模式（LF）**：继电器输出节点勾选 **睡眠模式** 后，该按键触发的继电器动作完成时面板全部指示灯熄灭（含背光）；任意面板按键按下后自动退出睡眠，恢复正常显示
 - **RCU 模式**：首次 LED 控制自动写 `0x1003=0x0006` 并保存 `0x100F`
-- **多键同步**：同面板 8 个从站开关节点共享状态，**只发一条** `0x1008` 帧（复用写入队列 / 200ms 防抖 / 面板级去重）
+- **多键同步**：同面板任意按键/继电器变化，经 `scheduleLfPanelLedSync` **面板级防抖** 后只发 **一条** `0x1008` 帧（非逐节点、非逐线圈各发一帧）
 
 **面板地址 1 · 变背光 · 单键亮（测试码）：**
 
@@ -149,6 +152,7 @@ node-red-restart
 | 按键6亮 | `01 06 10 08 01 20 0C 80` |
 | 按键7亮 | `01 06 10 08 01 40 0C A8` |
 | 按键8亮 | `01 06 10 08 01 80 0C F8` |
+| **待机指示灯** | `01 06 10 08 01 00 0D 58` |
 | **全灭** | `01 06 10 08 00 00 0C C8` |
 
 **单键灭（`0x1008` 写剩余 bitmask，非逐键单独灭指令）：**
@@ -522,12 +526,14 @@ msg.payload = 1;      // 或 0
 
 ### 更新日志
 
-#### v2.10.27 (2026-07-09)
+#### v2.10.29 (2026-07-09)
 
-- **[LF485 开关]** 生产发布：拉斐 LF 485 弱电开关完整对接（主动收发、RCU 模式、变背光 BIT8、面板级 0x1008 单帧聚合）。
-- **[LF485 开关]** `sendLfPanelLedSync` 同面板 8 键只发一条指示灯帧；复用 `serial-port-config` 50ms 队列、200ms 防抖、粘包解析与全局缓存。
+- **[LF485 开关]** 拉斐 LF 485 弱电开关完整对接：主动收发、RCU 模式自动启用、变背光 BIT8、面板级 `0x1008` 单帧聚合（同面板 8 键只发一条指示灯帧）。
+- **[LF485 睡眠模式]** 继电器输出节点新增 **睡眠模式** 勾选项（仅 LF 品牌）：勾选后该按键触发的继电器动作完成时，面板全部指示灯熄灭（`0x1008=0x0000`，含背光）；任意面板按键按下后自动退出睡眠，恢复正常显示。
+- **[LF485 指示灯跟随]** 继电器输出节点 LF 品牌新增 **指示灯跟随状态**（默认不跟随）：勾选=按键灯与绑定线圈同步；不勾选=瞬时亮灯，同按键全部继电器动作完成后回待机背光。
+- **[LF485 待机背光]** 继电器全关时默认 **待机背光**（`0x1008=0x0100`），不再误发全灭。
 - **[适配]** 从站开关 / 继电器输出 / Mesh 透传节点支持 LF 品牌；`lf-protocol.js` 单元测试覆盖 PDF 范例与用户抓包。
-- **[打包]** npm 包审计：不含 `doc/`、PDF、开发缓存；兼容 Node-RED ≥2.0、Node.js ≥14。
+- **[修复]** `RED.nodes.eachNode` 空指针崩溃防护；补全按键 7/8 从站开关节点；场景键不再误写 Modbus 线圈；移除未使用参数。
 
 #### v2.10.20 (2026-06-30)
 

package/lib/lf-led-registry.js

@@ -0,0 +1,364 @@
+"use strict";
+
+/**
+ * LF 面板指示灯聚合状态（从站开关 + 继电器输出共享）
+ *
+ * 设计原则：同一面板 (serialPortConfigId + switchId) 任意时刻只通过
+ * scheduleLfPanelLedSync 汇聚为 **一条** 0x1008 帧；禁止多路径各自立即发送。
+ *
+ * 待机：0x1008 = 0x0100（仅 BIT8 背光）
+ * 全灭：0x0000（仅显式熄灭场景）
+ */
+
+let syncCallback = null;
+const lfRelayOutputs = new Map();
+const lfMomentaryButtons = new Map();
+const lfPendingActions = new Map();
+const lfPanelSyncTimers = new Map();
+// 睡眠模式：面板级状态，激活时指示灯全灭（0x0000），任意按键退出
+const lfSleepModePanels = new Set();
+
+const BATCH_FALLBACK_MARGIN_MS = 3000;
+const PANEL_LED_DEBOUNCE_MS = 200;
+const PANEL_LED_DEDUPE_MS = 200;
+
+function getPanelKey(serialPortConfigId, switchId) {
+    return `${serialPortConfigId}:${parseInt(switchId, 10)}`;
+}
+
+/**
+ * 设置面板睡眠模式
+ * @param {string} serialPortConfigId 串口配置ID
+ * @param {number|string} switchId 面板地址
+ * @param {boolean} enabled true=进入睡眠（全灭），false=退出睡眠
+ */
+function setPanelSleepMode(serialPortConfigId, switchId, enabled) {
+    const panelKey = getPanelKey(serialPortConfigId, switchId);
+    if (enabled) {
+        lfSleepModePanels.add(panelKey);
+    } else {
+        lfSleepModePanels.delete(panelKey);
+    }
+}
+
+/**
+ * 查询面板是否处于睡眠模式
+ */
+function isPanelSleepMode(serialPortConfigId, switchId) {
+    return lfSleepModePanels.has(getPanelKey(serialPortConfigId, switchId));
+}
+
+/**
+ * 清除所有睡眠模式状态（节点卸载/重启时调用）
+ */
+function clearAllSleepMode() {
+    lfSleepModePanels.clear();
+}
+
+function getPendingKey(serialPortConfigId, switchId, buttonNumber) {
+    return `${getPanelKey(serialPortConfigId, switchId)}:${parseInt(buttonNumber, 10)}`;
+}
+
+function setLfLedSyncCallback(fn) {
+    syncCallback = fn;
+}
+
+function cancelPanelSyncTimer(panelKey) {
+    const timer = lfPanelSyncTimers.get(panelKey);
+    if (timer) {
+        clearTimeout(timer);
+        lfPanelSyncTimers.delete(panelKey);
+    }
+}
+
+/**
+ * 面板级 LED 调度：多次请求合并为一次 0x1008 发送
+ * @param {object} [options]
+ * @param {boolean} [options.immediate] 立即发送（仅按键瞬时亮灯等需要即时反馈的场景）
+ * @param {number} [options.debounceMs] 防抖毫秒，默认 200
+ */
+function scheduleLfPanelLedSync(serialPortConfigId, switchId, options) {
+    const opts = options || {};
+    const panelId = parseInt(switchId, 10);
+    const panelKey = getPanelKey(serialPortConfigId, panelId);
+
+    cancelPanelSyncTimer(panelKey);
+
+    if (opts.immediate === true) {
+        if (typeof syncCallback === "function") {
+            syncCallback(serialPortConfigId, panelId);
+        }
+        return;
+    }
+
+    const debounceMs = opts.debounceMs !== undefined ? opts.debounceMs : PANEL_LED_DEBOUNCE_MS;
+    const timer = setTimeout(() => {
+        lfPanelSyncTimers.delete(panelKey);
+        if (typeof syncCallback === "function") {
+            syncCallback(serialPortConfigId, panelId);
+        }
+    }, debounceMs);
+    lfPanelSyncTimers.set(panelKey, timer);
+}
+
+/** @deprecated 请使用 scheduleLfPanelLedSync；保留兼容入口 */
+function requestLfPanelLedSync(serialPortConfigId, switchId) {
+    scheduleLfPanelLedSync(serialPortConfigId, switchId, { debounceMs: PANEL_LED_DEBOUNCE_MS });
+}
+
+function registerLfRelayOutput(node) {
+    if (!node || node.switchBrand !== "lf" || node.buttonType === "input") {
+        return;
+    }
+    const configId = node.serialPortConfig || node.id || "global";
+    const key = getPanelKey(configId, node.switchId);
+    if (!lfRelayOutputs.has(key)) {
+        lfRelayOutputs.set(key, new Set());
+    }
+    lfRelayOutputs.get(key).add(node);
+}
+
+function unregisterLfRelayOutput(node) {
+    if (!node) {
+        return;
+    }
+    const configId = node.serialPortConfig || node.id || "global";
+    const key = getPanelKey(configId, node.switchId);
+    const set = lfRelayOutputs.get(key);
+    if (!set) {
+        return;
+    }
+    set.delete(node);
+    if (set.size === 0) {
+        lfRelayOutputs.delete(key);
+    }
+}
+
+function getRelayOutputsForButton(serialPortConfigId, switchId, buttonNumber) {
+    const key = getPanelKey(serialPortConfigId, switchId);
+    const set = lfRelayOutputs.get(key);
+    if (!set) {
+        return [];
+    }
+    const btn = parseInt(buttonNumber, 10);
+    return Array.from(set).filter((ro) => parseInt(ro.buttonNumber, 10) === btn);
+}
+
+function getMomentaryOutputs(serialPortConfigId, switchId, buttonNumber) {
+    return getRelayOutputsForButton(serialPortConfigId, switchId, buttonNumber)
+        .filter((ro) => ro.lfLedFollowState !== true);
+}
+
+function hasMomentaryRelayOutputs(serialPortConfigId, switchId, buttonNumber) {
+    return getMomentaryOutputs(serialPortConfigId, switchId, buttonNumber).length > 0;
+}
+
+function clearMomentary(serialPortConfigId, switchId, buttonNumber) {
+    const key = getPanelKey(serialPortConfigId, switchId);
+    const active = lfMomentaryButtons.get(key);
+    if (!active) {
+        return;
+    }
+    active.delete(parseInt(buttonNumber, 10));
+    if (active.size === 0) {
+        lfMomentaryButtons.delete(key);
+    }
+}
+
+function finishMomentaryBatch(serialPortConfigId, switchId, buttonNumber, pendingKey) {
+    const pending = lfPendingActions.get(pendingKey);
+    if (!pending) {
+        return;
+    }
+    if (pending.fallbackTimer) {
+        clearTimeout(pending.fallbackTimer);
+    }
+    lfPendingActions.delete(pendingKey);
+    clearMomentary(serialPortConfigId, switchId, buttonNumber);
+    // 批次结束：只调度一次聚合同步（含继电器状态稳定等待）
+    scheduleLfPanelLedSync(serialPortConfigId, switchId, { debounceMs: PANEL_LED_DEBOUNCE_MS });
+}
+
+/**
+ * 面板上是否有进行中的瞬时亮灯批次（继电器动作尚未全部完成）
+ */
+function hasActiveMomentaryBatch(serialPortConfigId, switchId) {
+    const prefix = `${getPanelKey(serialPortConfigId, switchId)}:`;
+    for (const [key, pending] of lfPendingActions.entries()) {
+        if (key.startsWith(prefix) && pending.completed < pending.expected) {
+            return true;
+        }
+    }
+    return false;
+}
+
+function isMomentaryBatchActive(serialPortConfigId, switchId, buttonNumber) {
+    const pendingKey = getPendingKey(serialPortConfigId, switchId, buttonNumber);
+    const pending = lfPendingActions.get(pendingKey);
+    return !!(pending && pending.completed < pending.expected);
+}
+
+/**
+ * 在 modbus:buttonPressed 派发之前调用
+ */
+function beginLfButtonActionBatch(serialPortConfigId, switchId, buttonNumber) {
+    const configId = serialPortConfigId;
+    const panelId = parseInt(switchId, 10);
+    const btn = parseInt(buttonNumber, 10);
+    const panelKey = getPanelKey(configId, panelId);
+    const pendingKey = getPendingKey(configId, panelId, btn);
+
+    const momentaryOutputs = getMomentaryOutputs(configId, panelId, btn);
+    if (momentaryOutputs.length === 0) {
+        return false;
+    }
+
+    if (lfPendingActions.has(pendingKey)) {
+        const old = lfPendingActions.get(pendingKey);
+        if (old && old.fallbackTimer) {
+            clearTimeout(old.fallbackTimer);
+        }
+    }
+
+    if (!lfMomentaryButtons.has(panelKey)) {
+        lfMomentaryButtons.set(panelKey, new Set());
+    }
+    lfMomentaryButtons.get(panelKey).add(btn);
+
+    const maxDelay = momentaryOutputs.reduce((max, ro) => Math.max(max, ro.delayMs || 0), 0);
+    const pending = {
+        expected: momentaryOutputs.length,
+        completed: 0,
+        maxDelay: maxDelay,
+        startedAt: Date.now()
+    };
+    pending.fallbackTimer = setTimeout(() => {
+        if (lfPendingActions.has(pendingKey)) {
+            finishMomentaryBatch(configId, panelId, btn, pendingKey);
+        }
+    }, maxDelay + BATCH_FALLBACK_MARGIN_MS);
+
+    lfPendingActions.set(pendingKey, pending);
+    return true;
+}
+
+function ensureLfButtonActionBatch(serialPortConfigId, switchId, buttonNumber) {
+    const pendingKey = getPendingKey(serialPortConfigId, switchId, buttonNumber);
+    if (lfPendingActions.has(pendingKey)) {
+        return true;
+    }
+    return beginLfButtonActionBatch(serialPortConfigId, switchId, buttonNumber);
+}
+
+function onLfRelayActionComplete(node) {
+    if (!node || node.switchBrand !== "lf" || node.lfLedFollowState === true) {
+        return;
+    }
+    const configId = node.serialPortConfig || node.id || "global";
+    const btn = parseInt(node.buttonNumber, 10);
+    const pendingKey = getPendingKey(configId, node.switchId, btn);
+    const pending = lfPendingActions.get(pendingKey);
+    if (!pending) {
+        return;
+    }
+
+    pending.completed += 1;
+    if (pending.completed < pending.expected) {
+        return;
+    }
+
+    finishMomentaryBatch(configId, node.switchId, btn, pendingKey);
+}
+
+function computeLfPanelLedMask(serialPortConfigId, switchId, lfProtocol, lfPanelNodes) {
+    // 睡眠模式优先：指示灯全灭（0x0000，连背光都灭），任意按键退出后自动恢复
+    if (lfSleepModePanels.has(getPanelKey(serialPortConfigId, switchId))) {
+        return 0;
+    }
+
+    let keyMask = 0;
+    const panelKey = getPanelKey(serialPortConfigId, switchId);
+
+    const collectFromSlave = function(n) {
+        if (!n || !n.config || n.config.switchBrand !== "lf") {
+            return;
+        }
+        if (parseInt(n.config.switchId, 10) !== parseInt(switchId, 10)) {
+            return;
+        }
+        if (!n.serialPortConfig || n.serialPortConfig.id !== serialPortConfigId) {
+            return;
+        }
+        if (n.config.syncLight === false) {
+            return;
+        }
+        if (n.config.buttonType === "scene") {
+            return;
+        }
+        if (n.currentState) {
+            keyMask |= lfProtocol.buttonToMask(n.config.buttonNumber);
+        }
+    };
+
+    const registered = lfPanelNodes.get(panelKey);
+    if (registered && registered.size > 0) {
+        registered.forEach(collectFromSlave);
+    }
+
+    const momentary = lfMomentaryButtons.get(panelKey);
+    if (momentary) {
+        momentary.forEach((btn) => {
+            keyMask |= lfProtocol.buttonToMask(btn);
+        });
+    }
+
+    const relaySet = lfRelayOutputs.get(panelKey);
+    if (relaySet) {
+        const followByButton = new Map();
+        relaySet.forEach((ro) => {
+            if (ro.lfLedFollowState !== true) {
+                return;
+            }
+            const btn = parseInt(ro.buttonNumber, 10);
+            const lit = ro.currentCoilState === true;
+            if (!followByButton.has(btn)) {
+                followByButton.set(btn, false);
+            }
+            if (lit) {
+                followByButton.set(btn, true);
+            }
+        });
+        followByButton.forEach((lit, btn) => {
+            if (lit) {
+                keyMask |= lfProtocol.buttonToMask(btn);
+            }
+        });
+    }
+
+    if (keyMask === 0) {
+        return lfProtocol.LED_STANDBY_MASK;
+    }
+    return lfProtocol.finalizeLedMask(keyMask, true);
+}
+
+module.exports = {
+    PANEL_LED_DEBOUNCE_MS,
+    PANEL_LED_DEDUPE_MS,
+    setLfLedSyncCallback,
+    scheduleLfPanelLedSync,
+    requestLfPanelLedSync,
+    registerLfRelayOutput,
+    unregisterLfRelayOutput,
+    beginLfButtonActionBatch,
+    ensureLfButtonActionBatch,
+    onLfRelayActionComplete,
+    hasActiveMomentaryBatch,
+    isMomentaryBatchActive,
+    hasMomentaryRelayOutputs,
+    getMomentaryOutputs,
+    computeLfPanelLedMask,
+    getPanelKey,
+    setPanelSleepMode,
+    isPanelSleepMode,
+    clearAllSleepMode
+};

package/nodes/lf-protocol.js

@@ -34,6 +34,8 @@ module.exports = {
 
     // 0x1008 变背光类产品需 BIT8 才允许 LED 显示
     LED_BACKLIGHT_ENABLE: 0x0100,
+    // 待机指示灯：仅背光 BIT8，继电器全关时的默认外观（非全灭）
+    LED_STANDBY_MASK: 0x0100,
 
     /**
      * Modbus CRC16（低字节在前）
@@ -184,6 +186,14 @@ module.exports = {
         return this.buildLedMaskCommand(panelAddr, 0x0000);
     },
 
+    /**
+     * 待机指示灯（继电器全关默认态）：仅 BIT8 背光，按键位全 0
+     * 例：01 06 10 08 01 00 0D 58
+     */
+    buildStandbyLedCommand: function(panelAddr) {
+        return this.buildLedMaskCommand(panelAddr, this.LED_STANDBY_MASK);
+    },
+
     /**
      * 聚合按键位掩码并应用变背光 BIT8（PDF：变背光产品 BIT8=1 才显示 LED）
      * @param {number} buttonMask BIT0~7 按键状态

package/nodes/modbus-slave-switch.js

@@ -12,6 +12,7 @@ module.exports = function(RED) {
     const serialUtils = require("../lib/serial-utils");
     const httpAdmin = require("../lib/http-admin-utils");
     const { createSlaveSwitchCaches } = require("../lib/slave-switch-cache");
+    const lfLedRegistry = require("../lib/lf-led-registry");
 
     const {
         globalDebounceCache,
@@ -31,6 +32,54 @@ module.exports = function(RED) {
     const lfPanelLastSentMask = new Map();
     // LF 面板 RCU 模式已配置标记（PDF：0x1003 BIT1=1 才能由主机控制 0x1008 指示灯）
     const lfRcuConfiguredPanels = new Set();
+    // LF 面板运行时节点注册表（避免 RED.nodes.eachNode 找不到带 currentState 的实例）
+    const lfPanelNodes = new Map();
+
+    function getLfPanelKey(serialPortConfigId, switchId) {
+        return `${serialPortConfigId}:${parseInt(switchId, 10)}`;
+    }
+
+    function registerLfPanelNode(node) {
+        if (!node || !node.config || node.config.switchBrand !== "lf") {
+            return;
+        }
+        const configId = (node.serialPortConfig && node.serialPortConfig.id) || node.id;
+        const key = getLfPanelKey(configId, node.config.switchId);
+        if (!lfPanelNodes.has(key)) {
+            lfPanelNodes.set(key, new Set());
+        }
+        lfPanelNodes.get(key).add(node);
+    }
+
+    function unregisterLfPanelNode(node) {
+        if (!node || !node.config || node.config.switchBrand !== "lf") {
+            return;
+        }
+        const configId = (node.serialPortConfig && node.serialPortConfig.id) || node.id;
+        const key = getLfPanelKey(configId, node.config.switchId);
+        const nodes = lfPanelNodes.get(key);
+        if (!nodes) {
+            return;
+        }
+        nodes.delete(node);
+        if (nodes.size === 0) {
+            lfPanelNodes.delete(key);
+        }
+    }
+
+    function isLfSerialReady(serialPortConfig) {
+        if (!serialPortConfig) {
+            return false;
+        }
+        const conn = serialPortConfig.connection;
+        if (!conn) {
+            return false;
+        }
+        if (serialPortConfig.connectionType === "tcp") {
+            return !conn.destroyed;
+        }
+        return conn.isOpen === true;
+    }
 
     function ensureLfRcuMode(node, panelId) {
         if (!node.serialPortConfig || typeof node.serialPortConfig.write !== "function") {
@@ -60,30 +109,35 @@ module.exports = function(RED) {
     }
 
     function computeLfPanelLedMask(serialPortConfigId, switchId) {
-        let mask = 0;
-        RED.nodes.eachNode(function(n) {
-            if (n.type !== "modbus-slave-switch") {
-                return;
-            }
-            if (n.config.switchBrand !== "lf") {
-                return;
-            }
-            if (parseInt(n.config.switchId, 10) !== parseInt(switchId, 10)) {
-                return;
-            }
-            if (!n.serialPortConfig || n.serialPortConfig.id !== serialPortConfigId) {
-                return;
-            }
-            if (n.config.syncLight === false) {
-                return;
-            }
-            if (n.currentState) {
-                mask |= lfProtocol.buttonToMask(n.config.buttonNumber);
+        return lfLedRegistry.computeLfPanelLedMask(
+            serialPortConfigId,
+            switchId,
+            lfProtocol,
+            lfPanelNodes
+        );
+    }
+
+    function findLfPanelRepresentativeNode(serialPortConfigId, switchId) {
+        const panelKey = getLfPanelKey(serialPortConfigId, switchId);
+        const registered = lfPanelNodes.get(panelKey);
+        if (!registered || registered.size === 0) {
+            return null;
+        }
+        for (const n of registered) {
+            if (n && n.serialPortConfig && isLfSerialReady(n.serialPortConfig)) {
+                return n;
             }
-        });
-        return lfProtocol.finalizeLedMask(mask, true);
+        }
+        return null;
     }
 
+    lfLedRegistry.setLfLedSyncCallback(function(serialPortConfigId, switchId) {
+        const rep = findLfPanelRepresentativeNode(serialPortConfigId, switchId);
+        if (rep) {
+            sendLfPanelLedSync(rep);
+        }
+    });
+
     function updateLfRelayStateCache(node, state) {
         const relayStateKey = getScopedKey(node, `relay-state-${node.config.targetSlaveAddress}-${node.config.targetCoilNumber}`);
         if (!globalButtonRelayStates.has(relayStateKey)) {
@@ -95,71 +149,77 @@ module.exports = function(RED) {
     /**
      * LF 面板 LED 同步：聚合同面板全部按键状态，只发一条 0x1008 写寄存器帧
      */
-    function sendLfPanelLedSync(callerNode, isTriggerSource) {
-        if (!callerNode || !callerNode.config || callerNode.config.switchBrand !== "lf") {
-            return false;
-        }
-        if (callerNode.config.syncLight === false) {
-            return false;
-        }
-        if (!callerNode.serialPortConfig || !callerNode.serialPortConfig.connection) {
-            if (!callerNode.isInitializing && !callerNode.isClosing) {
-                callerNode.log("RS-485连接未建立，无法发送LF指示灯反馈");
+    function sendLfPanelLedSync(callerNode) {
+        try {
+            if (!callerNode || !callerNode.config || callerNode.config.switchBrand !== "lf") {
+                return false;
+            }
+            if (!isLfSerialReady(callerNode.serialPortConfig)) {
+                if (!callerNode.isInitializing && !callerNode.isClosing) {
+                    callerNode.log("RS-485连接未建立，无法发送LF指示灯反馈");
+                }
+                return false;
             }
-            return false;
-        }
 
-        const panelId = parseInt(callerNode.config.switchId, 10);
-        const configId = callerNode.serialPortConfig.id || callerNode.id;
-        const ledKey = `${configId}:${panelId}`;
+            const panelId = parseInt(callerNode.config.switchId, 10);
+            const configId = callerNode.serialPortConfig.id || callerNode.id;
+            const ledKey = `${configId}:${panelId}`;
 
-        ensureLfRcuMode(callerNode, panelId);
+            ensureLfRcuMode(callerNode, panelId);
 
-        const mask = computeLfPanelLedMask(configId, panelId);
-        const now = Date.now();
-        const lastSent = lfPanelLastSentMask.get(ledKey);
-        if (!isTriggerSource && lastSent && lastSent.mask === mask && (now - lastSent.timestamp) < 50) {
-            callerNode.debug(`[LF LED] 跳过重复 面板${panelId} 掩码=0x${mask.toString(16).padStart(4, "0")}`);
-            return false;
-        }
+            const mask = computeLfPanelLedMask(configId, panelId);
+            const now = Date.now();
+            const lastSent = lfPanelLastSentMask.get(ledKey);
+            if (lastSent && lastSent.mask === mask && (now - lastSent.timestamp) < lfLedRegistry.PANEL_LED_DEDUPE_MS) {
+                callerNode.debug(`[LF LED] 跳过重复 面板${panelId} 掩码=0x${mask.toString(16).padStart(4, "0")}`);
+                return false;
+            }
 
-        const command = mask === 0
-            ? lfProtocol.buildTurnOffAllLedsCommand(panelId)
-            : lfProtocol.buildLedMaskCommand(panelId, mask);
+            const command = mask === lfProtocol.LED_STANDBY_MASK
+                ? lfProtocol.buildStandbyLedCommand(panelId)
+                : (mask === 0
+                    ? lfProtocol.buildTurnOffAllLedsCommand(panelId)
+                    : lfProtocol.buildLedMaskCommand(panelId, mask));
 
-        lfPanelLastSentMask.set(ledKey, { mask, timestamp: now });
-        lfPanelLedMask.set(ledKey, mask);
+            lfPanelLastSentMask.set(ledKey, { mask, timestamp: now });
+            lfPanelLedMask.set(ledKey, mask);
 
-        RED.nodes.eachNode(function(n) {
-            if (n.type !== "modbus-slave-switch") {
-                return;
-            }
-            if (n.config.switchBrand !== "lf") {
-                return;
-            }
-            if (parseInt(n.config.switchId, 10) !== panelId) {
-                return;
-            }
-            if (!n.serialPortConfig || n.serialPortConfig.id !== configId) {
-                return;
-            }
-            n.lastSentLedState.value = n.currentState;
-            n.lastSentLedState.timestamp = now;
-        });
+            RED.nodes.eachNode(function(n) {
+                if (!n || !n.config || n.type !== "modbus-slave-switch") {
+                    return;
+                }
+                if (n.config.switchBrand !== "lf") {
+                    return;
+                }
+                if (parseInt(n.config.switchId, 10) !== panelId) {
+                    return;
+                }
+                if (!n.serialPortConfig || n.serialPortConfig.id !== configId) {
+                    return;
+                }
+                n.lastSentLedState.value = n.currentState;
+                n.lastSentLedState.timestamp = now;
+            });
 
-        if (typeof callerNode.serialPortConfig.setFeedbackLock === "function") {
-            callerNode.serialPortConfig.setFeedbackLock(150);
-        }
+            if (typeof callerNode.serialPortConfig.setFeedbackLock === "function") {
+                callerNode.serialPortConfig.setFeedbackLock(150);
+            }
 
-        const hexStr = command.toString("hex").toUpperCase().match(/.{1,2}/g).join(" ");
-        callerNode.debug(`[LF LED] 面板${panelId} 聚合掩码=0x${mask.toString(16).padStart(4, "0")} 单帧=[${hexStr}]`);
+            const hexStr = command.toString("hex").toUpperCase().match(/.{1,2}/g).join(" ");
+            callerNode.log(`[LF LED] 面板${panelId} 聚合掩码=0x${mask.toString(16).padStart(4, "0")} 帧=[${hexStr}]`);
 
-        callerNode.serialPortConfig.write(command, (err) => {
-            if (err) {
-                callerNode.log(`LF LED反馈失败: ${err.message}`);
+            callerNode.serialPortConfig.write(command, (err) => {
+                if (err) {
+                    callerNode.log(`LF LED反馈失败: ${err.message}`);
+                }
+            }, 3, panelId);
+            return true;
+        } catch (err) {
+            if (callerNode && typeof callerNode.log === "function") {
+                callerNode.log(`[LF LED] 同步异常: ${err.message}`);
             }
-        }, 3, panelId);
-        return true;
+            return false;
+        }
     }
     // 初始化Mesh设备持久化存储
     const meshPersistDir = path.join(RED.settings.userDir || os.homedir() + "/.node-red", "mesh-devices-persist");
@@ -722,6 +782,7 @@ module.exports = function(RED) {
                         !isInit &&
                         (
                             stateChanged ||
+                            (node.config.switchBrand === "lf" && isButtonPress) ||
                             (
                                 isRelayControl &&
                                 (
@@ -749,6 +810,22 @@ module.exports = function(RED) {
                     }
                     
                     if (shouldSyncLed) {
+                        // LF：统一走面板级调度，批次进行中抑制继电器侧中间帧
+                        if (node.config.switchBrand === "lf") {
+                            const configId = node.serialPortConfig ? node.serialPortConfig.id : null;
+                            const panelId = node.config.switchId;
+                            if (isRelayControl && configId && lfLedRegistry.hasActiveMomentaryBatch(configId, panelId)) {
+                                node.debug(`[LF LED] 批次进行中，跳过继电器中间同步 面板${panelId}`);
+                                return;
+                            }
+                            if (configId) {
+                                lfLedRegistry.scheduleLfPanelLedSync(configId, panelId, {
+                                    debounceMs: lfLedRegistry.PANEL_LED_DEBOUNCE_MS
+                                });
+                            }
+                            return;
+                        }
+
                         node.debug(`[主站状态变化] 准备同步LED: 从站=${slave} 线圈=${coil} 值=${value ? "ON" : "OFF"} 触发源=${triggerSource}`);
                         // 核心逻辑：状态发生变化时，启动 LED 同步防抖队列
                         // 防抖机制（200ms）确保在全开/全关等批量场景下，能够收集完整状态并平滑同步
@@ -934,7 +1011,7 @@ module.exports = function(RED) {
 
                                         // LF：聚合同面板全部按键，只发一条 0x1008
                                         if (representativeNode.config.switchBrand === "lf") {
-                                            sendLfPanelLedSync(representativeNode, false);
+                                            sendLfPanelLedSync(representativeNode);
                                             return;
                                         }
 
@@ -1609,8 +1686,16 @@ module.exports = function(RED) {
                     }
 
                     const commandDebounceKey = getScopedKey(node, `lf-cmd-${node.config.switchId}-${node.config.buttonNumber}-${node.config.targetSlaveAddress}-${node.config.targetCoilNumber}`);
-                    const ledDebounceKey = getScopedKey(node, `lf-panel-led-${node.config.switchId}`);
                     const now = Date.now();
+                    const isSceneMode = node.config.buttonType === "scene";
+                    const configId = node.serialPortConfig ? node.serialPortConfig.id : null;
+                    const isSceneKey = isSceneMode || (
+                        configId && lfLedRegistry.hasMomentaryRelayOutputs(
+                            configId,
+                            node.config.switchId,
+                            node.config.buttonNumber
+                        )
+                    );
 
                     const lastCommandTime = globalDebounceCache.get(commandDebounceKey) || 0;
                     if (now - lastCommandTime < 500) {
@@ -1618,39 +1703,50 @@ module.exports = function(RED) {
                     }
                     globalDebounceCache.set(commandDebounceKey, now);
 
-                    const lastLedTime = globalDebounceCache.get(ledDebounceKey) || 0;
-                    const shouldSendLed = (now - lastLedTime >= 300);
-                    if (shouldSendLed) {
-                        globalDebounceCache.set(ledDebounceKey, now);
-                    }
-
                     if (node.serialPortConfig && typeof node.serialPortConfig.setTriggerSource === "function") {
                         node.serialPortConfig.setTriggerSource(node.config.switchId);
                     }
 
-                    node.debug(`[LF按键] 面板${node.config.switchId} 按键${node.config.buttonNumber} 按下`);
+                    // 退出睡眠模式：任意按键触发即退出，恢复正常显示
+                    if (configId && lfLedRegistry.isPanelSleepMode(configId, node.config.switchId)) {
+                        lfLedRegistry.setPanelSleepMode(configId, node.config.switchId, false);
+                        node.log(`[LF 睡眠] 面板${node.config.switchId} 退出睡眠模式（按键${node.config.buttonNumber}触发）`);
+                        lfLedRegistry.scheduleLfPanelLedSync(configId, node.config.switchId, {
+                            debounceMs: lfLedRegistry.PANEL_LED_DEBOUNCE_MS
+                        });
+                    }
+
+                    node.debug(`[LF按键] 面板${node.config.switchId} 按键${node.config.buttonNumber} 按下 mode=${isSceneKey ? "scene" : "switch"}`);
 
-                    node.currentState = !node.currentState;
+                    if (!isSceneKey) {
+                        node.currentState = !node.currentState;
+                        updateLfRelayStateCache(node, node.currentState);
+                        node.sendMqttCommand(node.currentState);
+                        if (configId) {
+                            lfLedRegistry.scheduleLfPanelLedSync(configId, node.config.switchId, {
+                                debounceMs: lfLedRegistry.PANEL_LED_DEBOUNCE_MS
+                            });
+                        }
+                    }
 
-                    updateLfRelayStateCache(node, node.currentState);
+                    if (isSceneKey && configId) {
+                        lfLedRegistry.beginLfButtonActionBatch(
+                            configId,
+                            node.config.switchId,
+                            node.config.buttonNumber
+                        );
+                    }
 
                     RED.events.emit("modbus:buttonPressed", {
                         switchId: node.config.switchId,
                         button: node.config.buttonNumber,
-                        value: node.currentState,
+                        value: isSceneKey ? true : node.currentState,
                         brand: "lf",
-                        type: "scene",
-                        serialPortConfigId: node.serialPortConfig ? node.serialPortConfig.id : null
+                        type: "button",
+                        isSceneMode: false,
+                        serialPortConfigId: configId
                     });
 
-                    node.sendMqttCommand(node.currentState);
-
-                    if (shouldSendLed) {
-                        setTimeout(() => {
-                            sendLfPanelLedSync(node, true);
-                        }, 200);
-                    }
-
                     node.send({
                         payload: node.currentState,
                         topic: `lf_switch_${node.config.switchId}_btn${node.config.buttonNumber}`,
@@ -2225,7 +2321,13 @@ module.exports = function(RED) {
                 const hexStr = command.toString("hex").toUpperCase().match(/.{1,2}/g).join(" ");
                 node.debug(`[Clowire LED] 控制帧已构建：[${hexStr}]`);
             } else if (node.config.switchBrand === "lf") {
-                sendLfPanelLedSync(node, isTriggerSource);
+                const configId = node.serialPortConfig ? node.serialPortConfig.id : null;
+                if (configId) {
+                    lfLedRegistry.scheduleLfPanelLedSync(configId, node.config.switchId, {
+                        immediate: isTriggerSource === true,
+                        debounceMs: lfLedRegistry.PANEL_LED_DEBOUNCE_MS
+                    });
+                }
                 return;
             } else {
                 // RS-485模式：使用轻量级协议
@@ -2712,7 +2814,12 @@ module.exports = function(RED) {
             // 本地输入同步面板指示灯（无需 Modbus 主站在线）
             if (node.config.syncLight && node.config.buttonType !== "mesh") {
                 if (node.config.switchBrand === "lf") {
-                    sendLfPanelLedSync(node, false);
+                    const configId = node.serialPortConfig ? node.serialPortConfig.id : null;
+                    if (configId) {
+                        lfLedRegistry.scheduleLfPanelLedSync(configId, node.config.switchId, {
+                            debounceMs: lfLedRegistry.PANEL_LED_DEBOUNCE_MS
+                        });
+                    }
                 } else {
                     node.sendCommandToPanel(value, false);
                 }
@@ -2726,6 +2833,10 @@ module.exports = function(RED) {
         node.on("close", function(done) {
             node.isClosing = true;
 
+            if (node.config && node.config.switchBrand === "lf") {
+                unregisterLfPanelNode(node);
+            }
+
             // 清除重连定时器
             if (node.reconnectTimer) {
                 clearTimeout(node.reconnectTimer);
@@ -2829,6 +2940,10 @@ module.exports = function(RED) {
             node.log(`[无线模式] 注册按键：设备${meshAddr} 按键${node.config.meshButtonNumber}`);
         }
 
+        if (node.config.switchBrand === "lf") {
+            registerLfPanelNode(node);
+        }
+
         node.updateStatus();
         node.connectRs485();  // 连接RS-485总线
         node.connectMqtt();   // 连接MQTT

package/nodes/relay-output.html

@@ -24,7 +24,9 @@
             // 门禁ID过滤（可选）
             filterDeviceId: { value: 0, validate: RED.validators.number() },
             // 跨网关控制
-            ignoreGatewayId: { value: false }
+            ignoreGatewayId: { value: false },
+            lfLedFollowState: { value: false },
+            lfSleepMode: { value: false }
         },
         inputs: 1,
         outputs: 1,
@@ -87,8 +89,21 @@
                 } else {
                     $(".form-row-switch").show();
                 }
+                updateLfLedFollowVisibility();
             }).trigger("change");
 
+            function updateLfLedFollowVisibility() {
+                const isLf = $("#node-input-switchBrand").val() === "lf";
+                const isInput = $("#node-input-buttonType").val() === "input";
+                if (isLf && !isInput) {
+                    $(".form-row-lf-led-follow").show();
+                } else {
+                    $(".form-row-lf-led-follow").hide();
+                }
+            }
+
+            $("#node-input-switchBrand").on("change", updateLfLedFollowVisibility).trigger("change");
+
             // 按钮编号切换时显示/隐藏背光灯提示
             $("#node-input-buttonNumber").on("change", function() {
                 const buttonNumber = $(this).val();
@@ -147,19 +162,13 @@
         <label style="width: 100%; margin-bottom: 8px;">
             <i class="fa fa-plug" style="color: #ff9800;"></i>
             <span style="font-size: 14px; font-weight: 600; color: #333;">RS-485连接配置</span>
+            <span style="font-size: 11px; color: #999; margin-left: 10px;">多个节点可共享同一配置，无需连线到主站</span>
         </label>
-        <div style="font-size: 11px; color: #555; padding: 10px 12px; background: linear-gradient(135deg, #fff3cd 0%, #fffbe6 100%); border-left: 4px solid #ffc107; border-radius: 4px; box-shadow: 0 1px 3px rgba(0,0,0,0.08);">
-            <strong>说明：</strong>多个继电器输出节点可以共享同一个RS-485连接配置（支持TCP网关或串口）<br>
-            <strong>提示：</strong>此配置用于监听开关按键事件，无需连线到主站节点
-        </div>
     </div>
 
     <div class="form-row">
         <label for="node-input-serialPortConfig" style="width: 110px;"><i class="fa fa-server"></i> 连接配置</label>
         <input type="text" id="node-input-serialPortConfig" placeholder="选择或添加RS-485连接配置" style="width: calc(70% - 110px);">
-        <div style="font-size: 11px; color: #888; margin-left: 110px; margin-top: 3px;">
-            选择已配置的RS-485连接（支持多个节点共享）
-        </div>
     </div>
 
     <div class="form-row">
@@ -172,11 +181,11 @@
     <hr style="margin: 15px 0; border: 0; border-top: 2px solid #e0e0e0;">
     <div class="form-row">
         <label style="width: 100%; margin-bottom: 8px;">
-            <i class="fa fa-hand-pointer-o" style="color: #3f51b5;"></i> 
+            <i class="fa fa-hand-pointer-o" style="color: #3f51b5;"></i>
             <span style="font-size: 14px; font-weight: 600; color: #333;">按键触发配置</span>
         </label>
     </div>
-    
+
     <div class="form-row">
         <label for="node-input-switchBrand" style="width: 110px;"><i class="fa fa-trademark"></i> 面板品牌</label>
         <select id="node-input-switchBrand" style="width: 200px;">
@@ -194,10 +203,17 @@
             <option value="scene">场景按钮（RS-485）</option>
             <option value="input">输入端触发（外部设备）</option>
         </select>
-        <div style="font-size: 11px; color: #888; margin-left: 110px; margin-top: 3px;">
-            <strong>开关按钮</strong>：RS-485开关，有开/关状态<br>
-            <strong>场景按钮</strong>：RS-485场景触发<br>
-            <strong>输入端触发</strong>：海康门禁等外部设备
+        <span class="form-row-lf-led-follow" style="margin-left: 16px; white-space: nowrap;">
+            <input type="checkbox" id="node-input-lfLedFollowState" style="width: auto; vertical-align: middle;">
+            <label for="node-input-lfLedFollowState" style="width: auto; margin-left: 4px; font-weight: normal;">指示灯跟随状态</label>
+        </span>
+        <span class="form-row-lf-led-follow" style="margin-left: 16px; white-space: nowrap;">
+            <input type="checkbox" id="node-input-lfSleepMode" style="width: auto; vertical-align: middle;">
+            <label for="node-input-lfSleepMode" style="width: auto; margin-left: 4px; font-weight: normal;">睡眠模式</label>
+        </span>
+        <div class="form-row-lf-led-follow" style="font-size: 11px; color: #888; margin-left: 110px; margin-top: 3px;">
+            <strong>指示灯跟随</strong>：按键灯与绑定线圈同步；不勾选则瞬时亮灯，继电器动作完成后回待机背光。
+            <strong>睡眠模式</strong>：继电器动作后面板指示灯全灭，任意按键退出。
         </div>
     </div>
 
@@ -205,9 +221,6 @@
         <label for="node-input-switchId" style="width: 110px;"><i class="fa fa-id-card"></i> 开关ID</label>
         <input type="number" id="node-input-switchId" placeholder="0" min="0" max="255" style="width: 90px; padding: 5px 8px; border: 1px solid #ccc; border-radius: 4px; font-size: 13px;">
         <span style="margin-left: 10px; color: #666; font-size: 12px;">物理面板地址：<strong>0-255</strong></span>
-        <div style="font-size: 11px; color: #888; margin-left: 110px; margin-top: 3px;">
-            RS-485总线上的设备地址标识
-        </div>
     </div>
 
     <div class="form-row form-row-switch">
@@ -239,43 +252,35 @@
     <hr style="margin: 15px 0; border: 0; border-top: 2px solid #e0e0e0;">
     <div class="form-row">
         <label style="width: 100%; margin-bottom: 8px;">
-            <i class="fa fa-arrow-right" style="color: #4caf50;"></i> 
+            <i class="fa fa-arrow-right" style="color: #4caf50;"></i>
             <span style="font-size: 14px; font-weight: 600; color: #333;">目标继电器配置</span>
         </label>
     </div>
-    
+
     <div class="form-row">
         <label for="node-input-masterNode" style="width: 110px;"><i class="fa fa-microchip"></i> 主站节点</label>
         <select id="node-input-masterNode" style="width: calc(70% - 110px);">
             <option value="">请选择主站节点</option>
         </select>
-        <div style="font-size: 11px; color: #888; margin-left: 110px; margin-top: 3px;">
-            选择要控制的目标Modbus主站节点
-        </div>
     </div>
-    
+
     <div class="form-row">
         <label for="node-input-slaveAddress" style="width: 110px;"><i class="fa fa-map-marker"></i> 从站地址</label>
         <input type="number" id="node-input-slaveAddress" placeholder="10" min="1" max="247" style="width: 90px; padding: 5px 8px; border: 1px solid #ccc; border-radius: 4px; font-size: 13px;">
         <span style="margin-left: 10px; color: #666; font-size: 12px;">Modbus继电器：<strong>10-19</strong></span>
-        <div style="font-size: 11px; color: #888; margin-left: 110px; margin-top: 3px;">
-            主站节点中配置的从站设备地址
-        </div>
     </div>
-    
+
     <div class="form-row">
         <label for="node-input-coilNumber" style="width: 110px;"><i class="fa fa-plug"></i> 继电器路数</label>
         <input type="number" id="node-input-coilNumber" placeholder="1" min="1" max="32" style="width: 90px; padding: 5px 8px; border: 1px solid #ccc; border-radius: 4px; font-size: 13px;">
-        <div style="font-size: 11px; color: #888; margin-left: 110px; margin-top: 3px;">
-            继电器1-32路，对应线圈0-31，只需填写正确的继电器通道即可
-        </div>
+        <span style="margin-left: 10px; color: #666; font-size: 12px;">1-32路，对应线圈0-31</span>
     </div>
 
     <!-- 动作配置 -->
     <hr style="margin: 15px 0; border: 0; border-top: 2px solid #e0e0e0;">
     <div class="form-row">
         <label style="width: 100%; margin-bottom: 8px;">
-            <i class="fa fa-bolt" style="color: #ff5722;"></i> 
+            <i class="fa fa-bolt" style="color: #ff5722;"></i>
             <span style="font-size: 14px; font-weight: 600; color: #333;">动作配置</span>
         </label>
     </div>
@@ -295,16 +300,13 @@
         <input type="number" id="node-input-delayMs" min="0" max="60000" style="width: 120px; padding: 5px 8px; border: 1px solid #ccc; border-radius: 4px; font-size: 13px;">
         <span style="margin-left: 5px;">ms</span>
         <span id="delay-hint" style="margin-left: 10px; color: #f57c00; font-size: 11px;"></span>
-        <div style="font-size: 11px; color: #888; margin-left: 110px; margin-top: 3px;">
-            执行延时（0-60000毫秒），用于实现级联开灯效果
-        </div>
     </div>
 
     <div class="form-row">
         <input type="checkbox" id="node-input-ignoreRelease" style="width: auto; margin-left: 110px;">
         <label for="node-input-ignoreRelease" style="width: auto;">忽略释放信号（只响应按下）</label>
     </div>
-    
+
     <!-- 配置摘要 -->
     <div class="form-row" style="margin-top: 20px; padding: 14px; background: linear-gradient(135deg, #e8f5e9 0%, #f1f8f4 100%); border-left: 4px solid #4caf50; border-radius: 6px; box-shadow: 0 2px 4px rgba(0,0,0,0.08);">
         <div style="font-size: 12px; color: #333; line-height: 1.8;">
@@ -313,9 +315,6 @@
             </div>
             <div id="config-summary" style="background: white; padding: 8px; border-radius: 4px; border: 1px solid #c8e6c9; font-size: 12px; color: #555;">
             </div>
-            <div style="margin-top: 10px; font-size: 11px; color: #666;">
-                <strong>工作原理：</strong>监听按键事件，通过内部事件发送控制命令到主站，<strong>无需连线</strong>
-            </div>
         </div>
     </div>
     </div>
@@ -334,7 +333,7 @@
     <h3>按键触发配置</h3>
     <dl class="message-properties">
         <dt>面板品牌 <span class="property-type">string</span></dt>
-        <dd>开关面板品牌，目前支持亖米（Symi）和 Clowire（克伦威尔）</dd>
+        <dd>开关面板品牌，支持亖米（Symi）、Clowire（克伦威尔）、LF（拉斐）</dd>
 
         <dt>按钮类型 <span class="property-type">string</span></dt>
         <dd>开关按钮/场景按钮/输入端触发</dd>
@@ -368,6 +367,12 @@
 
         <dt>忽略释放信号 <span class="property-type">boolean</span></dt>
         <dd>勾选后，只响应按下信号，忽略释放信号</dd>
+
+        <dt>指示灯跟随状态 <span class="property-type">boolean</span></dt>
+        <dd>仅 LF 品牌：勾选后按键指示灯与绑定的继电器线圈状态同步；不勾选则按键后瞬时亮灯，全部关联继电器动作完成后恢复待机背光</dd>
+
+        <dt>睡眠模式 <span class="property-type">boolean</span></dt>
+        <dd>仅 LF 品牌：勾选后本按键触发的继电器动作完成时，该面板全部指示灯熄灭（含背光）；任意面板按键按下后自动退出睡眠，恢复正常显示</dd>
     </dl>
 
     <h3>使用场景</h3>
@@ -383,6 +388,13 @@
     <p><b>场景3：海康门禁触发（使用输入端）</b></p>
     <pre>海康门禁事件 → 继电器输出(按钮类型=输入端触发 目标从站10 1路)</pre>
 
+    <p><b>场景4：睡眠模式（LF 品牌）</b></p>
+    <p>将某个按键（如按键8）配置为全关场景并勾选 <b>睡眠模式</b>，按下后关闭全部继电器并熄灭面板所有指示灯（含背光）；任意面板按键按下后自动退出睡眠，恢复正常显示。</p>
+    <pre>开关ID=1 按钮=8 LF品牌 睡眠模式 → 从站10 1路 关闭
+                                  → 从站10 2路 关闭
+                                  → 从站10 3路 关闭
+                                  → 从站10 4路 关闭</pre>
+
     <h3>工作原理</h3>
     <p>节点监听 <code>modbus:buttonPressed</code> 事件（按键触发），
     通过 <code>modbus:writeCoil</code> 事件发送控制命令到主站。</p>

package/nodes/relay-output.js

@@ -8,6 +8,7 @@
 module.exports = function(RED) {
     "use strict";
     const { ensureRedEventsMaxListeners } = require("../lib/red-events-utils");
+    const lfLedRegistry = require("../lib/lf-led-registry");
     ensureRedEventsMaxListeners(RED);
 
     function RelayOutputNode(config) {
@@ -35,6 +36,10 @@ module.exports = function(RED) {
         node.delayMs = parseInt(config.delayMs) || 0;
         node.ignoreRelease = config.ignoreRelease !== false;  // 默认忽略释放信号
         node.ignoreGatewayId = config.ignoreGatewayId === true; // 是否忽略网关ID校验
+        // LF：指示灯是否跟随绑定的继电器线圈状态（默认不跟随=瞬时亮灯，全部继电器完成后回待机）
+        node.lfLedFollowState = config.lfLedFollowState === true;
+        // LF：睡眠模式（触发后该面板指示灯全灭，任意按键退出）
+        node.lfSleepMode = config.lfSleepMode === true;
 
         // 节点状态
         node.isClosing = false;
@@ -48,10 +53,11 @@ module.exports = function(RED) {
         node.initTimer = setTimeout(() => {
             node.initialized = true;
             const btnLabel = node.buttonNumber === 15 ? "背光灯" : `按键${node.buttonNumber}`;
-            const triggerInfo = node.buttonType === "input" 
-                ? "← 输入端" 
+            const triggerInfo = node.buttonType === "input"
+                ? "← 输入端"
                 : `← 开关${node.switchId}-${btnLabel}`;
-            node.status({ fill: "blue", shape: "ring", text: `就绪 ${triggerInfo} → 从站${node.slaveAddress}-${node.coilNumber}路` });
+            const sleepHint = (node.switchBrand === "lf" && node.lfSleepMode) ? " [睡眠]" : "";
+            node.status({ fill: "blue", shape: "ring", text: `就绪 ${triggerInfo} → 从站${node.slaveAddress}-${node.coilNumber}路${sleepHint}` });
         }, 2000);
 
         // 更新状态显示
@@ -106,7 +112,7 @@ module.exports = function(RED) {
                     return;
                 }
 
-                // 执行控制
+                // 场景键批次由从站开关在派发事件前统一登记，relay-output 只负责写线圈
                 const btnLabel = msgButtonNumber === 15 ? "背光灯" : `按键${msgButtonNumber}`;
                 const triggerSource = (data.type === "scene" || data.isSceneMode) ? "scene-trigger" : "button-press";
                 node.executeControl(triggerValue, `开关${msgSwitchId}-${btnLabel}`, triggerSource);
@@ -114,7 +120,14 @@ module.exports = function(RED) {
 
             RED.events.on("modbus:buttonPressed", node.stateChangeListener);
             const btnLabel = node.buttonNumber === 15 ? "背光灯" : `按键${node.buttonNumber}`;
-            node.log(`绑定触发源: 开关${node.switchId} ${btnLabel}`);
+            const lfLedHint = (node.switchBrand === "lf")
+                ? (node.lfLedFollowState ? " LED跟随" : " LED瞬时") + (node.lfSleepMode ? " 睡眠模式" : "")
+                : "";
+            node.log(`绑定触发源: 开关${node.switchId} ${btnLabel}${lfLedHint}`);
+        }
+
+        if (node.switchBrand === "lf" && node.buttonType !== "input") {
+            lfLedRegistry.registerLfRelayOutput(node);
         }
 
         // 监听目标线圈状态变化（用于状态同步和实现 Toggle 逻辑）
@@ -132,6 +145,14 @@ module.exports = function(RED) {
                     const actionText = node.currentCoilState ? "ON" : "OFF";
                     node.updateStatus(`同步状态: ${actionText} ← 从站${node.slaveAddress}`, node.currentCoilState ? "green" : "grey");
                 }
+
+                if (node.switchBrand === "lf" && node.lfLedFollowState && node.serialPortConfig) {
+                    if (!lfLedRegistry.hasActiveMomentaryBatch(node.serialPortConfig, node.switchId)) {
+                        lfLedRegistry.scheduleLfPanelLedSync(node.serialPortConfig, node.switchId, {
+                            debounceMs: lfLedRegistry.PANEL_LED_DEBOUNCE_MS
+                        });
+                    }
+                }
             }
         };
         RED.events.on("modbus:coilStateChanged", node.coilStateListener);
@@ -171,6 +192,19 @@ module.exports = function(RED) {
             const sourceText = source ? ` (${source})` : "";
             node.updateStatus(`${actionText} → 从站${node.slaveAddress}线圈${node.coilNumber}${sourceText}`, value ? "green" : "grey");
             node.debug(`[联动执行] 触发写入: 从站=${node.slaveAddress}, 线圈=${node.coilNumber}, 值=${value}, 目标主站=${targetMasterId || "广播"}${sourceText}`);
+
+            if (node.switchBrand === "lf" && node.lfLedFollowState !== true) {
+                lfLedRegistry.onLfRelayActionComplete(node);
+            }
+
+            // LF 睡眠模式：本节点配置了睡眠模式，指令发送后激活该面板睡眠（指示灯全灭）
+            if (node.switchBrand === "lf" && node.lfSleepMode && node.serialPortConfig) {
+                lfLedRegistry.setPanelSleepMode(node.serialPortConfig, node.switchId, true);
+                lfLedRegistry.scheduleLfPanelLedSync(node.serialPortConfig, node.switchId, {
+                    debounceMs: lfLedRegistry.PANEL_LED_DEBOUNCE_MS
+                });
+                node.log(`[LF 睡眠] 面板${node.switchId} 进入睡眠模式（按键${node.buttonNumber}触发，指示灯全灭）`);
+            }
         };
 
         // 执行控制逻辑
@@ -316,6 +350,10 @@ module.exports = function(RED) {
                 node.coilStateListener = null;
             }
 
+            if (node.switchBrand === "lf") {
+                lfLedRegistry.unregisterLfRelayOutput(node);
+            }
+
             if (removed) {
                 // 节点被删除时的额外清理（如果有）
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-symi-modbus",
-  "version": "2.10.27",
+  "version": "2.10.29",
   "description": "Node-RED Modbus节点，支持TCP/串口通信、多主站独立运行、串口自动搜索、多设备轮询、可选MQTT集成（支持纯本地模式和MQTT模式）、Home Assistant自动发现、HomeKit网桥、可视化控制看板、自定义协议转换和物理开关面板双向同步（支持Symi/Clowire/LF拉斐品牌），工控机长期稳定运行",
   "main": "nodes/modbus-master.js",
   "scripts": {