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

package/README.md

@@ -30,7 +30,7 @@ Node-RED的Modbus继电器控制节点，支持TCP/串口通信和MQTT集成。
 | 节点名称 | 功能描述 |
 | :--- | :--- |
 | **Modbus主站** | 核心调度中心，负责协议解析、多设备轮询和状态管理。 |
-| **从站开关** | 监听物理面板（Symi/Clowire）按键事件并联动继电器，支持LED同步。 |
+| **从站开关** | 监听物理面板（Symi/Clowire/LF拉斐）按键事件并联动继电器，支持LED同步。 |
 | **HomeKit网桥** | 一键将所有 Modbus 继电器接入 Apple HomeKit，支持自定义名称。 |
 | **控制看板** | 在 Node-RED 编辑器内直接控制和查看所有继电器的实时状态。 |
 | **Mesh透传** | 适配 Symi 蓝牙 Mesh 网关，支持窗帘、杜亚电机及各种子设备。 |
@@ -117,7 +117,7 @@ node-red-restart
 1. 拖拽 **从站开关** 节点到流程画布
 2. 选择刚创建的RS-485连接配置
 3. 配置开关面板信息：
-   - 面板品牌: `Symi` / `Clowire`（克伦威尔）
+   - 面板品牌: `Symi` / `Clowire`（克伦威尔）/ `LF`（拉斐）
    - 开关ID: 物理面板地址 (0-255)
    - 按钮编号: 按键编号 (1-8)
    - 按钮类型:
@@ -128,6 +128,41 @@ node-red-restart
    - 目标线圈编号: `0`
 5. 部署流程
 
+#### LF（拉斐）485 弱电开关
+
+- **串口**：9600 8N1，指令间隔 ≥50ms（由 `serial-port-config` 写入队列保证）
+- **面板地址**：1–42（出厂默认 2），开关 ID 填十进制地址
+- **按键上报**（主动发送 8 字节）：`[地址][03][00][02][绝对键值][按键掩码][CRC]`
+- **指示灯控制**：写寄存器 `0x1008` 一次写入完整 bitmask（变背光产品高字节 BIT8=1，节点自动处理）
+- **RCU 模式**：首次 LED 控制自动写 `0x1003=0x0006` 并保存 `0x100F`
+- **多键同步**：同面板 8 个从站开关节点共享状态，**只发一条** `0x1008` 帧（复用写入队列 / 200ms 防抖 / 面板级去重）
+
+**面板地址 1 · 变背光 · 单键亮（测试码）：**
+
+| 操作 | Hex |
+|------|-----|
+| 按键1亮 | `01 06 10 08 01 01 CC 98` |
+| 按键2亮 | `01 06 10 08 01 02 8C 99` |
+| 按键3亮 | `01 06 10 08 01 04 0C 9B` |
+| 按键4亮 | `01 06 10 08 01 08 0C 9E` |
+| 按键5亮 | `01 06 10 08 01 10 0C 94` |
+| 按键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 00 00 0C C8` |
+
+**单键灭（`0x1008` 写剩余 bitmask，非逐键单独灭指令）：**
+
+| 操作 | Hex |
+|------|-----|
+| 仅灭当前唯一亮键（全灭） | `01 06 10 08 00 00 0C C8` |
+| 灭键1、键2仍亮 | `01 06 10 08 01 02 8C 99` |
+| 灭键2、键1+3仍亮 | `01 06 10 08 01 05 CD 5B` |
+| 键1+3亮 | `01 06 10 08 01 05 CD 5B` |
+| 键1–4全亮 | `01 06 10 08 01 0F 4D 5C` |
+
+**修改面板地址**：广播 `FF 06 10 00 00 [新地址] [CRC]`，再向新地址发 `XX 06 10 0F 00 FE [CRC]` 保存。
+
 ### 6. 进阶功能配置
 
 #### HomeKit 接入
@@ -487,47 +522,28 @@ 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.27 (2026-07-09)
 
-#### v2.10.17 (2026-02-07)
+- **[LF485 开关]** 生产发布：拉斐 LF 485 弱电开关完整对接（主动收发、RCU 模式、变背光 BIT8、面板级 0x1008 单帧聚合）。
+- **[LF485 开关]** `sendLfPanelLedSync` 同面板 8 键只发一条指示灯帧；复用 `serial-port-config` 50ms 队列、200ms 防抖、粘包解析与全局缓存。
+- **[适配]** 从站开关 / 继电器输出 / Mesh 透传节点支持 LF 品牌；`lf-protocol.js` 单元测试覆盖 PDF 范例与用户抓包。
+- **[打包]** npm 包审计：不含 `doc/`、PDF、开发缓存；兼容 Node-RED ≥2.0、Node.js ≥14。
 
-- **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.20 (2026-06-30)
 
-#### v2.10.16 (2026-02-06)
-
-- **按键记忆**：同一帧内若同时上报位置与动作（如 position=100 + action=打开中），以位置为准到端点即按「已停止」记忆，避免被动作覆盖导致下次按键误判。
-- **开停关停 / 打开关闭**：状态记忆更稳，到顶/到底后再次按键必为关/开；开停关停模式下运动中点击会正确发送暂停(3)。
-- **场景按键**：场景模式下不再因 value=false 忽略一次按下，每次物理按键都会触发控制，解决「多按一次」才生效的问题。
-
-#### v2.10.15 (2026-02-05)
-
-- **Mesh 窗帘控制**：修复重启后实体消失、到头不记忆位置、再次点击误发暂停等问题；新增「打开/关闭」单键循环逻辑；「开-停-关-停」循环逻辑完整可用。
-- **配置界面**：控制逻辑选项正确保存与显示，选择「打开/关闭」后不再被覆盖为「循环」。
-- **Mesh 透传与杜亚**：与杜亚电机状态双向同步优化；窗帘到端点（0%/100%）状态正确同步到按键，点击时能正确执行开/关。
-- **稳定性**：实体持久化与存储校验增强，兼容更多固件版本的窗帘协议。
+- **[打包]** 修复 npm 发布包误含 `.codebase-memory/` 开发索引的问题，包体积约 158KB；规范 `.npmignore` / `.gitignore`，开发缓存目录不进入发布包。
+- **[工程]** 提取 `lib/lru-map.js`、`lib/slave-switch-cache.js`，全局 LRU 缓存与 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`）。
+- **[修复]** 修正 `isMeshFrame` 请求帧长度判定，与 `parseAllFrames` 保持一致。
+- **[Mesh 窗帘]** 按《蓝牙MESH网关（初级版）串口协议V1.0》修正 0x53 0x80 0x06 状态帧解析；窗帘动作/位置分离存储；开停关停与打开-关闭逻辑完善；Clowire 场景按键统一处理。
+- **[Mesh 透传]** 合并重复 close 监听；热路径日志降为 debug；杜亚电机状态双向同步优化；实体持久化增强。
 
-#### v2.10.14 (2026-02-03)
+#### 更早版本 (v2.10.14 ~ v2.10.17)
 
-- 多种 Modbus 协议支持（Telnet ASCII、RTU over TCP、TCP、串口）；智能轮询暂停，面板事件响应更及时。
-- Home Assistant MQTT Discovery 与实体唯一 ID；串口热插拔与 TCP 故障自动恢复。
-- 开关/场景按钮双模式，LED 反馈同步。
+- 多种 Modbus 协议（Telnet ASCII、RTU over TCP、TCP、串口）与智能轮询暂停。
+- Home Assistant MQTT Discovery、HomeKit 网桥、控制看板、Mesh 透传节点、继电器输出。
+- 按键记忆与端点收敛、场景按键每次按下均触发、LED 反馈同步、串口热插拔与 TCP 自动恢复。
 
 ## 许可证
 MIT License

package/nodes/lf-protocol.js

@@ -0,0 +1,285 @@
+/**
+ * LF485 通讯协议（拉斐 Laffey 智能酒店版）
+ * 参考：LF485通讯协议智能酒店版（轮询）V3.0
+ *
+ * 开关面板主动发送帧（8字节）：
+ * [地址][03][00][02][绝对键值][按键位掩码][CRC_L][CRC_H]
+ *
+ * 按键位掩码 BIT0~BIT7 对应按键 1~8
+ */
+
+module.exports = {
+    CMD_READ: 0x03,
+    CMD_WRITE: 0x06,
+
+    REG_PANEL_ADDR: 0x1000,
+    REG_PANEL_CONFIG: 0x1003,
+    REG_LED_CONTROL: 0x1008,
+    REG_BUTTON_VALUE: 0x100B,
+    REG_SAVE_CONFIG: 0x100F,
+
+    DEFAULT_PANEL_ADDR: 0x02,
+    ACTIVE_FRAME_LEN: 8,
+
+    // 0x1003 工作模式位定义（PDF V3.0）
+    CONFIG_DEMO_MODE: 0x0001,       // BIT0 演示模式（本地控制，非 RCU）
+    CONFIG_RCU_MODE: 0x0002,        // BIT1 RCU 模式（主机控制指示灯，必须开启）
+    CONFIG_ACTIVE_SEND: 0x0004,     // BIT2 按键主动发送
+    CONFIG_SENSOR_ENABLE: 0x0008,   // BIT3 感应使能
+    CONFIG_BACKLIGHT_DELAY: 0x0010, // BIT4 背光延时灭
+    CONFIG_RELEASE_SEND: 0x0020,    // BIT5 按键松开发送
+
+    // RCU + 主动发送（酒店/智能家居常用组合）
+    CONFIG_RCU_ACTIVE: 0x0006,
+
+    // 0x1008 变背光类产品需 BIT8 才允许 LED 显示
+    LED_BACKLIGHT_ENABLE: 0x0100,
+
+    /**
+     * Modbus CRC16（低字节在前）
+     */
+    calculateCRC16: function(buffer, len) {
+        let crc = 0xFFFF;
+        const end = len === undefined ? buffer.length : len;
+        for (let i = 0; i < end; i++) {
+            crc ^= buffer[i];
+            for (let j = 0; j < 8; j++) {
+                if (crc & 0x0001) {
+                    crc = (crc >> 1) ^ 0xA001;
+                } else {
+                    crc >>= 1;
+                }
+            }
+        }
+        return crc;
+    },
+
+    verifyCRC: function(buffer) {
+        if (!buffer || buffer.length < 3) {
+            return false;
+        }
+        const calc = this.calculateCRC16(buffer, buffer.length - 2);
+        const recv = buffer[buffer.length - 2] | (buffer[buffer.length - 1] << 8);
+        return calc === recv;
+    },
+
+    /**
+     * 绝对键值 = (面板地址 - 1) * 6 + 键编号
+     */
+    calcAbsoluteKey: function(panelAddr, buttonNumber) {
+        return ((panelAddr - 1) * 6) + buttonNumber;
+    },
+
+    /**
+     * 按键编号 -> 位掩码（1~8）
+     */
+    buttonToMask: function(buttonNumber) {
+        const n = parseInt(buttonNumber, 10);
+        if (n < 1 || n > 8) {
+            return 0;
+        }
+        return 1 << (n - 1);
+    },
+
+    /**
+     * 位掩码 -> 按键编号（仅支持单键按下）
+     */
+    maskToButton: function(mask) {
+        let m = mask & 0xFF;
+        if (m === 0 || (m & (m - 1)) !== 0) {
+            return null;
+        }
+        let bit = 0;
+        while (m > 1) {
+            m >>= 1;
+            bit++;
+        }
+        return bit + 1;
+    },
+
+    isLfActiveFrame: function(buffer) {
+        if (!buffer || buffer.length !== this.ACTIVE_FRAME_LEN) {
+            return false;
+        }
+        if (buffer[1] !== this.CMD_READ) {
+            return false;
+        }
+        if (buffer[2] !== 0x00 || buffer[3] !== 0x02) {
+            return false;
+        }
+        return this.verifyCRC(buffer);
+    },
+
+    /**
+     * 解析主动发送按键帧
+     */
+    parseActiveButtonFrame: function(buffer) {
+        if (!this.isLfActiveFrame(buffer)) {
+            return null;
+        }
+        const panelAddr = buffer[0];
+        const absKey = buffer[4];
+        const buttonMask = buffer[5];
+        const buttonNumber = this.maskToButton(buttonMask);
+        if (!buttonNumber) {
+            return null;
+        }
+        return {
+            panelAddr,
+            absKey,
+            buttonMask,
+            buttonNumber,
+            pressed: true,
+            type: "button"
+        };
+    },
+
+    parseAllFrames: function(buffer) {
+        const events = [];
+        if (!buffer || buffer.length < this.ACTIVE_FRAME_LEN) {
+            return events;
+        }
+        let offset = 0;
+        while (offset + this.ACTIVE_FRAME_LEN <= buffer.length) {
+            const slice = buffer.slice(offset, offset + this.ACTIVE_FRAME_LEN);
+            if (this.isLfActiveFrame(slice)) {
+                const event = this.parseActiveButtonFrame(slice);
+                if (event) {
+                    events.push(event);
+                }
+                offset += this.ACTIVE_FRAME_LEN;
+            } else {
+                offset++;
+            }
+        }
+        return events;
+    },
+
+    /**
+     * 写寄存器 0x1008 控制状态指示灯（RCU 模式）
+     * @param {number} panelAddr 面板地址 1-42
+     * @param {number} ledMask 指示灯位掩码 BIT0~BIT7 对应按键1~8
+     */
+    buildLedMaskCommand: function(panelAddr, ledMask) {
+        const buffer = Buffer.alloc(8);
+        buffer[0] = panelAddr & 0xFF;
+        buffer[1] = this.CMD_WRITE;
+        buffer[2] = 0x10;
+        buffer[3] = 0x08;
+        buffer[4] = (ledMask >> 8) & 0xFF;
+        buffer[5] = ledMask & 0xFF;
+        const crc = this.calculateCRC16(buffer, 6);
+        buffer[6] = crc & 0xFF;
+        buffer[7] = (crc >> 8) & 0xFF;
+        return buffer;
+    },
+
+    buildLedControlCommand: function(panelAddr, buttonNumber, state, useBacklight) {
+        const bit = this.buttonToMask(buttonNumber);
+        const buttonMask = state ? bit : 0;
+        return this.buildAggregatedLedMaskCommand(panelAddr, buttonMask, useBacklight);
+    },
+
+    buildTurnOffAllLedsCommand: function(panelAddr) {
+        return this.buildLedMaskCommand(panelAddr, 0x0000);
+    },
+
+    /**
+     * 聚合按键位掩码并应用变背光 BIT8（PDF：变背光产品 BIT8=1 才显示 LED）
+     * @param {number} buttonMask BIT0~7 按键状态
+     * @param {boolean} useBacklight 变背光面板（默认 true）
+     */
+    finalizeLedMask: function(buttonMask, useBacklight) {
+        let mask = buttonMask & 0xFF;
+        const backlight = useBacklight !== false;
+        if (backlight && mask !== 0) {
+            mask |= this.LED_BACKLIGHT_ENABLE;
+        }
+        return mask;
+    },
+
+    buildAggregatedLedMaskCommand: function(panelAddr, buttonMask, useBacklight) {
+        return this.buildLedMaskCommand(panelAddr, this.finalizeLedMask(buttonMask, useBacklight));
+    },
+
+    /**
+     * 清除单个按键位（0x1008 写完整掩码，灭某一键需写剩余键状态）
+     * @param {number} currentButtonMask 当前按键位 BIT0~7
+     * @param {number} buttonNumber 要熄灭的按键 1~8
+     */
+    clearButtonFromMask: function(currentButtonMask, buttonNumber) {
+        const bit = this.buttonToMask(buttonNumber);
+        return (currentButtonMask & 0xFF) & (~bit & 0xFF);
+    },
+
+    buildSingleButtonOffCommand: function(panelAddr, buttonNumber, currentButtonMask, useBacklight) {
+        const newMask = this.clearButtonFromMask(currentButtonMask || 0, buttonNumber);
+        return this.buildAggregatedLedMaskCommand(panelAddr, newMask, useBacklight);
+    },
+
+    /**
+     * 修改面板地址（写 0x1000），修改后需写 0x100F 保存
+     */
+    buildSetPanelAddressCommand: function(currentAddr, newAddr, useBroadcast) {
+        const addr = useBroadcast ? 0xFF : (currentAddr & 0xFF);
+        const buffer = Buffer.alloc(8);
+        buffer[0] = addr;
+        buffer[1] = this.CMD_WRITE;
+        buffer[2] = 0x10;
+        buffer[3] = 0x00;
+        buffer[4] = 0x00;
+        buffer[5] = newAddr & 0xFF;
+        const crc = this.calculateCRC16(buffer, 6);
+        buffer[6] = crc & 0xFF;
+        buffer[7] = (crc >> 8) & 0xFF;
+        return buffer;
+    },
+
+    /**
+     * 配置面板工作模式（0x1003）
+     * bit1=RCU模式 bit2=按键主动发送
+     */
+    buildSetPanelConfigCommand: function(panelAddr, configValue) {
+        const buffer = Buffer.alloc(8);
+        buffer[0] = panelAddr & 0xFF;
+        buffer[1] = this.CMD_WRITE;
+        buffer[2] = 0x10;
+        buffer[3] = 0x03;
+        buffer[4] = (configValue >> 8) & 0xFF;
+        buffer[5] = configValue & 0xFF;
+        const crc = this.calculateCRC16(buffer, 6);
+        buffer[6] = crc & 0xFF;
+        buffer[7] = (crc >> 8) & 0xFF;
+        return buffer;
+    },
+
+    buildSaveConfigCommand: function(panelAddr) {
+        const buffer = Buffer.alloc(8);
+        buffer[0] = panelAddr & 0xFF;
+        buffer[1] = this.CMD_WRITE;
+        buffer[2] = 0x10;
+        buffer[3] = 0x0F;
+        buffer[4] = 0x00;
+        buffer[5] = 0xFE;
+        const crc = this.calculateCRC16(buffer, 6);
+        buffer[6] = crc & 0xFF;
+        buffer[7] = (crc >> 8) & 0xFF;
+        return buffer;
+    },
+
+    /**
+     * 启用 RCU 模式 + 按键主动发送（PDF：BIT1=RCU 控制指示灯，BIT2=主动发送）
+     * 例：02 06 10 03 00 06 FD 3B
+     */
+    buildEnableRcuModeCommand: function(panelAddr) {
+        return this.buildSetPanelConfigCommand(panelAddr, this.CONFIG_RCU_ACTIVE);
+    },
+
+    /**
+     * 变背光类产品：按键1亮（需 BIT8=1 才显示 LED）
+     * 例：02 06 10 08 01 01 CC AB
+     */
+    buildLedControlCommandBacklight: function(panelAddr, buttonNumber, state) {
+        return this.buildLedControlCommand(panelAddr, buttonNumber, state, true);
+    }
+};

package/nodes/mesh-protocol.js

@@ -512,18 +512,31 @@ module.exports = function(_RED) {
      * @returns {boolean} 是否有效
      */
     function isMeshFrame(buffer) {
-        if (!buffer || buffer.length < 5) {return false;}
+        if (!buffer || buffer.length < 4) {return false;}
         if (buffer[0] !== PROTOCOL.HEADER) {return false;}
-        
-        const dataLen = buffer[3];
-        const totalLen = 4 + dataLen + 1;
-        
+
+        const opCode = buffer[1];
+        let dataLenIndex;
+        let overhead;
+
+        if (opCode >= 0x80) {
+            dataLenIndex = 3;
+            overhead = 5;
+        } else {
+            dataLenIndex = 2;
+            overhead = 4;
+        }
+
+        if (dataLenIndex >= buffer.length) {return false;}
+
+        const dataLen = buffer[dataLenIndex];
+        const totalLen = overhead + dataLen;
+
         if (buffer.length !== totalLen) {return false;}
-        
-        // 校验和验证
+
         const receivedChecksum = buffer[buffer.length - 1];
         const calculatedChecksum = calculateChecksum(buffer.slice(0, buffer.length - 1));
-        
+
         return receivedChecksum === calculatedChecksum;
     }
 

package/nodes/mesh-transparent-node.html

@@ -393,6 +393,7 @@
             <select id="node-input-switchBrand" style="width: 200px;">
                 <option value="symi">亖米（Symi）</option>
                 <option value="clowire">Clowire（克伦威尔）</option>
+                <option value="lf">LF（拉斐）</option>
             </select>
             <span style="margin-left: 10px; font-size: 11px; color: #666; font-style: italic;">支持1-8键开关</span>
         </div>

package/nodes/mesh-transparent-node.js

@@ -3,6 +3,7 @@ module.exports = function(RED) {
     const meshProtocol = require("./mesh-protocol")(RED);
     const protocol = require("./lightweight-protocol");
     const clowireProtocol = require("./clowire-protocol");
+    const lfProtocol = require("./lf-protocol");
     const dooyaProtocol = require("./dooya-protocol");
 
     function MeshTransparentNode(config) {
@@ -243,6 +244,8 @@ module.exports = function(RED) {
             let command = null;
             if (node.switchBrand === "clowire") {
                 command = clowireProtocol.buildLedControlCommand(node.switchId, node.buttonNumber, state);
+            } else if (node.switchBrand === "lf") {
+                command = lfProtocol.buildLedControlCommand(node.switchId, node.buttonNumber, state);
             } else {
                 // Symi: 使用 REPORT (0x04) 协议同步状态，不触发动作
                 const targetAddr = node.panelAddr || node.switchId || 1;

package/nodes/modbus-slave-switch.html

@@ -42,7 +42,12 @@
                 // 开关模式和场景模式显示
                 const coilDisplay = this.targetCoilNumber || 1;
                 const btnLabel = this.buttonNumber == 15 ? '背光灯' : `按钮${this.buttonNumber}`;
-                const brandLabel = this.switchBrand === 'clowire' ? 'Clowire' : '开关';
+                let brandLabel = '开关';
+                if (this.switchBrand === 'clowire') {
+                    brandLabel = 'Clowire';
+                } else if (this.switchBrand === 'lf') {
+                    brandLabel = 'LF';
+                }
                 return this.name || `${brandLabel}${this.switchId}-${btnLabel} → 继电器${this.targetSlaveAddress}-${coilDisplay}路`;
             }
         },
@@ -63,15 +68,38 @@
                 }
             });
 
+            function updateBrandUi() {
+                const brand = $("#node-input-switchBrand").val();
+                const backlightOpt = $("#node-input-buttonNumber option[value='15']");
+                if (brand === 'lf') {
+                    $("#node-input-switchId").attr("min", 1).attr("max", 42);
+                    $("#lf-brand-hint").show();
+                    backlightOpt.hide();
+                    if ($("#node-input-buttonNumber").val() === '15') {
+                        $("#node-input-buttonNumber").val(1);
+                        $("#backlight-hint").hide();
+                    }
+                } else {
+                    $("#node-input-switchId").attr("min", 0).attr("max", 255);
+                    $("#lf-brand-hint").hide();
+                    backlightOpt.show();
+                }
+            }
+
             // 品牌切换控制
             $("#node-input-switchBrand").on("change", function() {
                 const brand = $(this).val();
                 if (brand === 'clowire') {
-                    // Clowire默认地址是2
                     if ($("#node-input-switchId").val() === '0') {
                         $("#node-input-switchId").val(2);
                     }
+                } else if (brand === 'lf') {
+                    const sid = $("#node-input-switchId").val();
+                    if (sid === '0' || sid === '2' || sid === '') {
+                        $("#node-input-switchId").val(1);
+                    }
                 }
+                updateBrandUi();
             });
 
             // 按钮类型切换控制显示/隐藏
@@ -212,6 +240,7 @@
             // 初始化显示状态
             $("#node-input-enableMqtt").trigger("change");
             $("#node-input-buttonType").trigger("change");
+            updateBrandUi();
 
             // 始终加载已保存的Mesh设备列表（无论当前是什么模式）
             // 这样切换到Mesh模式时，列表已经加载好了
@@ -321,10 +350,14 @@
         <select id="node-input-switchBrand" style="width: 200px;">
             <option value="symi">亖米（Symi）</option>
             <option value="clowire">Clowire（克伦威尔）</option>
+            <option value="lf">LF（拉斐）</option>
         </select>
         <span style="margin-left: 10px; font-size: 11px; color: #666; font-style: italic;">支持1-8键开关</span>
     </div>
 
+    <div id="lf-brand-hint" style="display: none; font-size: 11px; color: #888; margin: -8px 0 8px 110px;">
+        LF485：9600 8N1，地址 1-42；RCU 模式 + 变背光 BIT8 自动控制 0x1008 指示灯
+    </div>
 
 
     <div class="form-row" style="display: flex; align-items: center;">

package/nodes/modbus-slave-switch.js

@@ -3,6 +3,7 @@ module.exports = function(RED) {
     const mqtt = require("mqtt");
     const protocol = require("./lightweight-protocol");
     const clowireProtocol = require("./clowire-protocol");
+    const lfProtocol = require("./lf-protocol");
     const meshProtocol = require("./mesh-protocol")(RED);
     const mqttHelper = require("./mqtt-helper");
     const storage = require("node-persist");
@@ -23,6 +24,143 @@ module.exports = function(RED) {
     } = createSlaveSwitchCaches(RED);
 
     startGlobalDebounceCacheCleanup();
+
+    // LF 面板指示灯聚合掩码（同一485总线上多节点共享）
+    const lfPanelLedMask = new Map();
+    // LF 面板上次已下发的 0x1008 掩码（每面板一条，避免多节点重复发送）
+    const lfPanelLastSentMask = new Map();
+    // LF 面板 RCU 模式已配置标记（PDF：0x1003 BIT1=1 才能由主机控制 0x1008 指示灯）
+    const lfRcuConfiguredPanels = new Set();
+
+    function ensureLfRcuMode(node, panelId) {
+        if (!node.serialPortConfig || typeof node.serialPortConfig.write !== "function") {
+            return;
+        }
+        const configId = node.serialPortConfig.id || node.id;
+        const rcuKey = `${configId}:${panelId}`;
+        if (lfRcuConfiguredPanels.has(rcuKey)) {
+            return;
+        }
+        lfRcuConfiguredPanels.add(rcuKey);
+
+        const cfgCmd = lfProtocol.buildEnableRcuModeCommand(panelId);
+        const saveCmd = lfProtocol.buildSaveConfigCommand(panelId);
+        node.log(`[LF RCU] 面板${panelId} 自动启用 RCU 模式(0x1003=0x0006) 并保存，之后主机可控制 0x1008 指示灯`);
+
+        node.serialPortConfig.write(cfgCmd, (err) => {
+            if (err) {
+                node.log(`[LF RCU] 写入 0x1003 失败: ${err.message}`);
+            }
+        }, 4, panelId);
+        node.serialPortConfig.write(saveCmd, (err) => {
+            if (err) {
+                node.log(`[LF RCU] 写入 0x100F 保存失败: ${err.message}`);
+            }
+        }, 4, panelId);
+    }
+
+    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 lfProtocol.finalizeLedMask(mask, true);
+    }
+
+    function updateLfRelayStateCache(node, state) {
+        const relayStateKey = getScopedKey(node, `relay-state-${node.config.targetSlaveAddress}-${node.config.targetCoilNumber}`);
+        if (!globalButtonRelayStates.has(relayStateKey)) {
+            globalButtonRelayStates.set(relayStateKey, new Map());
+        }
+        globalButtonRelayStates.get(relayStateKey).set(node.id, state);
+    }
+
+    /**
+     * 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指示灯反馈");
+            }
+            return false;
+        }
+
+        const panelId = parseInt(callerNode.config.switchId, 10);
+        const configId = callerNode.serialPortConfig.id || callerNode.id;
+        const ledKey = `${configId}:${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 command = mask === 0
+            ? lfProtocol.buildTurnOffAllLedsCommand(panelId)
+            : lfProtocol.buildLedMaskCommand(panelId, 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;
+        });
+
+        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}]`);
+
+        callerNode.serialPortConfig.write(command, (err) => {
+            if (err) {
+                callerNode.log(`LF LED反馈失败: ${err.message}`);
+            }
+        }, 3, panelId);
+        return true;
+    }
     // 初始化Mesh设备持久化存储
     const meshPersistDir = path.join(RED.settings.userDir || os.homedir() + "/.node-red", "mesh-devices-persist");
     
@@ -313,7 +451,7 @@ module.exports = function(RED) {
             mqttPassword: node.mqttServerConfig ? (node.mqttServerConfig.credentials ? node.mqttServerConfig.credentials.password : "") : "",
             mqttBaseTopic: node.mqttServerConfig ? node.mqttServerConfig.baseTopic : "modbus/relay",
             // 开关面板配置
-            switchBrand: config.switchBrand || "symi",         // 面板品牌（默认Symi，支持clowire）
+            switchBrand: config.switchBrand || "symi",         // 面板品牌（symi/clowire/lf）
             buttonType: config.buttonType || "switch",         // 按钮类型：switch=开关模式，scene=场景模式，mesh=Mesh模式
             syncLight: config.syncLight !== false,             // 指示灯同步：默认开启
             switchId: parseInt(config.switchId) || 0,           // 开关ID（0-255，物理面板地址）
@@ -794,12 +932,16 @@ module.exports = function(RED) {
                                             representativeNode.debug(`检查面板按键状态时出错: ${err.message}`);
                                         }
 
-                                        // Clowire/Symi 协议优化：如果该面板所有已知的按键状态都为 OFF，则发送一条“全关”指令
+                                        // LF：聚合同面板全部按键，只发一条 0x1008
+                                        if (representativeNode.config.switchBrand === "lf") {
+                                            sendLfPanelLedSync(representativeNode, false);
+                                            return;
+                                        }
+
+                                        // Clowire/Symi 协议优化：如果该面板所有按键都为 OFF，则发送一条“全关”指令
                                         let useGlobalOff = false;
                                         if (!anyOn) {
                                             if (representativeNode.config.switchBrand === "clowire") {
-                                                // v2.10.7 回退：Clowire 全关指令 (0x1020=0x0002) 在部分面板上无法同步指示灯状态
-                                                // 暂时禁用该优化，改回逐个发送关闭指令
                                                 useGlobalOff = false;
                                             } else if (representativeNode.config.switchBrand === "symi") {
                                                 useGlobalOff = false;
@@ -944,6 +1086,17 @@ module.exports = function(RED) {
                             }
                         }
                     }
+                } else if (node.config.switchBrand === "lf") {
+                    // LF485 拉斐面板：固定8字节主动发送帧
+                    while (node.rs485Buffer.length >= lfProtocol.ACTIVE_FRAME_LEN) {
+                        const slice = node.rs485Buffer.slice(0, lfProtocol.ACTIVE_FRAME_LEN);
+                        if (lfProtocol.isLfActiveFrame(slice)) {
+                            node.handleLfData(slice);
+                            node.rs485Buffer = node.rs485Buffer.slice(lfProtocol.ACTIVE_FRAME_LEN);
+                        } else {
+                            node.rs485Buffer = node.rs485Buffer.slice(1);
+                        }
+                    }
                 } else if (node.config.switchBrand === "clowire") {
                     // Clowire 协议拼包逻辑 (克伦威尔)
                     while (node.rs485Buffer.length >= 9) {
@@ -1439,6 +1592,80 @@ module.exports = function(RED) {
             }
         };
 
+        // 处理LF485拉斐面板协议数据
+        node.handleLfData = function(data) {
+            try {
+                const frames = Buffer.isBuffer(data) ? [data] : [data];
+                for (const frame of frames) {
+                    const event = lfProtocol.parseActiveButtonFrame(frame);
+                    if (!event) {
+                        continue;
+                    }
+                    if (event.panelAddr !== parseInt(node.config.switchId, 10)) {
+                        continue;
+                    }
+                    if (event.buttonNumber !== parseInt(node.config.buttonNumber, 10)) {
+                        continue;
+                    }
+
+                    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 lastCommandTime = globalDebounceCache.get(commandDebounceKey) || 0;
+                    if (now - lastCommandTime < 500) {
+                        return;
+                    }
+                    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} 按下`);
+
+                    node.currentState = !node.currentState;
+
+                    updateLfRelayStateCache(node, node.currentState);
+
+                    RED.events.emit("modbus:buttonPressed", {
+                        switchId: node.config.switchId,
+                        button: node.config.buttonNumber,
+                        value: node.currentState,
+                        brand: "lf",
+                        type: "scene",
+                        serialPortConfigId: node.serialPortConfig ? node.serialPortConfig.id : null
+                    });
+
+                    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}`,
+                        switchId: node.config.switchId,
+                        button: node.config.buttonNumber,
+                        brand: "lf",
+                        targetSlave: node.config.targetSlaveAddress,
+                        targetCoil: node.config.targetCoilNumber
+                    });
+                }
+            } catch (err) {
+                node.log(`处理LF协议数据失败: ${err.message}`);
+            }
+        };
+
         // 处理Clowire协议数据
         node.handleClowireData = function(data) {
             try {
@@ -1997,6 +2224,9 @@ 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);
+                return;
             } else {
                 // RS-485模式：使用轻量级协议
                 // 修正：设备地址应为面板地址 (switchId)
@@ -2479,6 +2709,15 @@ module.exports = function(RED) {
                 node.sendMqttCommand(value);
             }
 
+            // 本地输入同步面板指示灯（无需 Modbus 主站在线）
+            if (node.config.syncLight && node.config.buttonType !== "mesh") {
+                if (node.config.switchBrand === "lf") {
+                    sendLfPanelLedSync(node, false);
+                } else {
+                    node.sendCommandToPanel(value, false);
+                }
+            }
+
             // 更新状态显示
             node.updateStatus();
         });

package/nodes/relay-output.html

@@ -182,6 +182,7 @@
         <select id="node-input-switchBrand" style="width: 200px;">
             <option value="symi">亖米（Symi）</option>
             <option value="clowire">Clowire（克伦威尔）</option>
+            <option value="lf">LF（拉斐）</option>
         </select>
         <span style="margin-left: 10px; font-size: 11px; color: #666; font-style: italic;">支持1-8键开关</span>
     </div>

package/nodes/relay-output.js

@@ -98,11 +98,11 @@ module.exports = function(RED) {
 
                 // 获取触发值
                 const triggerValue = data.value !== undefined ? data.value : data.payload;
-                const isClowire = msgBrand === "clowire";
+                const isToggleBrand = msgBrand === "clowire" || msgBrand === "lf";
 
                 // 忽略释放信号
-                // 注意：Clowire 协议上报的是“切换状态”，false 也是一次有效按键事件，不能当作释放信号丢弃
-                if (node.ignoreRelease && !triggerValue && !isClowire) {
+                // Clowire/LF 协议上报的是“切换状态”，false 也是一次有效按键事件
+                if (node.ignoreRelease && !triggerValue && !isToggleBrand) {
                     return;
                 }
 

package/package.json

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