node-red-contrib-symi-modbus 2.9.12 → 2.9.14

package/README.md

@@ -11,24 +11,22 @@ Node-RED的Modbus继电器控制节点，支持TCP/串口通信和MQTT集成，
 - **双模式运行**：
   - **本地模式**：纯串口/TCP通信，断网也能稳定运行，无需MQTT
   - **MQTT模式**：可选接入Home Assistant等第三方平台
-- **多协议支持**：
-  - Modbus RTU（串口直连RS485）
-  - Modbus TCP（标准Modbus TCP）
-  - Modbus RTU over TCP（TCP转RS485网关）
-  - Telnet ASCII（推荐用于TCP转RS485网关）
-- **Symi开关集成**：
-  - RS-485开关：自动识别并处理Symi私有协议按键事件
-  - 蓝牙Mesh开关：支持Symi蓝牙Mesh网关和1-6路Mesh开关
-  - 双向同步：开关面板与继电器状态实时同步
-  - 设备持久化：Mesh设备列表自动保存，重启无需重新扫描
-- **HomeKit网桥**：一键桥接到Apple HomeKit，支持Siri语音控制，自动同步主站配置，名称可自定义
-- **智能写入队列**：所有写入操作串行执行，支持HomeKit群控160个继电器同时动作，流畅无卡顿
-- **可视化控制看板**：实时显示和控制所有继电器状态，美观易用，适合现场调试和日常监控
-- **自定义协议转换**：支持非标准485协议设备，窗帘循环控制，配置界面可测试发送
-- **多设备轮询**：支持最多10台Modbus从站设备，每台32路继电器
-- **智能轮询机制**：从站上报时自动暂停轮询，优先处理数据，避免冲突
-- **稳定可靠**：完整的内存管理、错误处理、断线重连，适合7x24小时长期运行
-- **总线数据过滤**：自动忽略总线上的无关数据，只处理本节点相关的数据
+- **工业级稳定性**：
+  - **多主站隔离**：采用实例级隔离机制，支持无限个主站和从站节点共存，配置互不干扰
+  - **智能分包/粘包处理**：内置1KB环形缓冲区和协议分析器，完美处理RS-485总线的分包、粘包问题
+  - **内存安全**：严格的内存管理策略，长时间运行内存不泄露，自动清理过期缓存
+  - **死锁防护**：多级看门狗机制，自动检测并恢复控制死循环，确保生产环境不卡顿
+- **Symi/Clowire生态集成**：
+  - **多协议支持**：完美支持Symi和Clowire（克伦威尔）双品牌协议，自动识别
+  - **蓝牙Mesh深度集成**：支持Symi蓝牙Mesh网关V1.3.1协议，实现无线开关秒级响应
+  - **设备持久化**：Mesh设备列表自动保存到磁盘，断电/重启/断网后配置不丢失
+- **高级控制功能**：
+  - **门禁联动过滤**：继电器节点支持门禁ID过滤，实现精确的门禁联动控制（v2.9.12新增）
+  - **HomeKit网桥**：一键接入Apple HomeKit，支持Siri语音控制，状态实时同步
+  - **智能写入队列**：所有写入操作串行执行，支持HomeKit群控160个继电器同时动作
+- **可视化运维**：
+  - **控制看板**：实时显示所有继电器状态，支持手动控制
+  - **调试模式**：详细的通信日志，支持十六进制报文监控
 
 ## 快速开始
 
@@ -952,25 +950,31 @@ HomeKit网桥节点无需输入消息，自动同步主站配置和状态。
 
 ## 版本历史
 
-### 2.9.12
-- **Mesh 持久化优化**：Mesh 设备列表发现后自动保存到磁盘，网关离线或 Node-RED 重启后依然保留已配置的实体，无需重新扫描。
-- **门禁过滤功能**：在“继电器输出”节点中支持门禁 ID 过滤，支持“0=不过滤”模式，方便门禁联动场景。
-- **联动事件增强**：修复了从站开关节点未触发 `modbus:buttonPressed` 内部事件的问题，现在“继电器输出”节点可以完美绑定到 Symi/Clowire/Mesh 开关。
-- **稳定性提升**：优化了 Mesh 模式下的 LED 反馈逻辑和状态同步防抖。
+**v2.9.14 更新内容**：
+- **全协议指示灯同步优化**：重构了从站开关节点（modbus-slave-switch）的状态同步逻辑，将原有的 Mesh 模式高性能 LED 反馈机制扩展至所有协议（Symi、Clowire、RS-485），显著提升了群控场景下指示灯同步的准确率。
+- **非连续线圈配置支持**：优化了继电器控制逻辑，支持按键与非连续、跨从站线圈的灵活绑定，不再受限于线圈序号必须连续的物理约束。
+- **全局并发锁机制改进**：改进了全局 LED 反馈锁（Global Lock）机制，将锁定时间优化为 150ms，并引入了更精准的面板状态缓存（panelKey-based caching），有效解决了高频群控时个别按键指示灯同步失败的问题。
+- **稳定性与防抖增强**：统一了所有协议的指示灯同步防抖时间为 50ms，确保在继电器频繁动作时总线通信的有序与稳定。
 
-### 2.9.11
-- 增加对 Clowire (克伦威尔) 协议的支持。
-- 优化了 RS-485 拼包算法，解决工控机串口分包导致的数据解析失败。
+**v2.9.13 更新内容**：
+- **全量审计与生产环境验证**：确认多主站隔离、内存自动清理和防死锁机制稳定运行。
+- **文档规范化**：修复并补充了从站开关节点的内置帮助文档，增加 Mesh 和无线模式说明。
+- **发布质量保障**：完成严格的本地安装测试和 npm pack 验证。
+
+**v2.9.12 更新内容**：
+- **Mesh 持久化**：设备列表自动保存到磁盘，重启不丢失。
+- **RS-485 沾包处理**：重构拼包逻辑，引入循环缓冲区处理沾包、分包问题。
+- **门禁过滤**：继电器输出节点支持门禁 ID 过滤。
+- **事件联动**：修复 `modbus:buttonPressed` 事件，支持开关与继电器输出节点联动。
+
+**v2.9.11 更新内容**：
+- **Clowire 支持**：增加对克伦威尔协议的支持。
+- **拼包算法优化**：进一步解决工控机串口高频分包问题。
 
 **v2.9.10 更新内容**：
-- **日志系统优化 (解决日志占用问题)**：
-  - **彻底静默重连日志**：将 TCP/串口连接过程中的 `node.error` 降级为 `node.log` 或 `node.debug`，不再发送到 Node-RED 调试面板（Debug Tab），彻底解决重连期间日志刷屏问题。
-  - **智能过滤**：相同的连接错误在重试期间不再重复输出日志（每 10 分钟仅后台提醒一次）。
-  - **状态栏增强**：将具体错误信息（如“拒绝连接”、“串口不存在”）直接显示在节点状态文字中，无需查看日志即可掌握连接状况。
-- **多主站配置隔离修复**：
-  - 修复了多个Modbus主站节点在编辑时配置互相干扰的问题（通过Scoped Event Handler实现）
-  - 确保每个主站节点的从站列表配置完全独立，互不影响
-- **从站开关主站关联**：
+- **日志静默优化**：重连期间不再刷屏调试面板，错误信息显示在节点状态栏。
+- **多主站配置隔离**：修复多个主站节点配置互相干扰的问题。
+- **稳定性增强**：优化了内存管理和重连机制。
   - **新增关联主站功能**：从站开关节点新增"关联主站"配置项
   - **多主站支持**：支持选择特定的主站节点，解决多主站环境下相同从站地址冲突的问题
   - **智能过滤**：从站开关只响应关联主站的状态更新，避免误触发
@@ -1029,32 +1033,6 @@ HomeKit网桥节点无需输入消息，自动同步主站配置和状态。
   - 断电断网恢复后自动重连，正常工作
   - 无调试数据输出，适合生产环境长期运行
 
-**v2.9.6 更新内容**：
-- **重要修复**：485开关场景按钮的CRC校验兼容性问题
-  - 修复不同按键编号的场景按钮因CRC校验值不同而被错误拒绝的问题
-  - 问题根因：不同按键编号（如按钮3、按钮4）会产生不同的CRC校验值，严格校验导致某些厂家的485开关帧被丢弃
-  - 解决方案：对于按键事件帧（SET/REPORT类型），采用宽松的CRC校验策略
-  - 宽松策略：如果CRC不匹配，但帧头、帧尾、数据长度都正确，仍然解析该帧
-  - 现在1-8路所有按键的场景按钮都能正常解析处理，兼容不同厂家的485开关
-  - 测试通过：按钮1-8全部测试通过，包括错误CRC的宽松模式测试
-
-**v2.9.5 更新内容**：
-- **重要修复**：重启Node-RED时设备自动动作问题
-  - 修复重启后继电器会自动动作一次的bug
-  - 问题根因：首次轮询（source='init'）时modbus-slave-switch向下游发送状态消息，触发下游节点执行控制命令
-  - 解决方案：首次轮询时只同步内部状态和LED反馈，不发送消息到下游节点
-  - 现在重启Node-RED不会导致任何继电器动作，只会同步指示灯状态
-
-**v2.9.4 更新内容**：
-- **重要修复**：场景按钮LED反馈不同步问题
-  - 修复场景按钮按下后背光灯不跟随继电器状态变化的bug
-  - 问题根因：场景模式下currentState提前更新，导致后续状态变化事件被认为"未变化"而跳过LED反馈
-  - 解决方案：场景按钮触发时立即发送LED反馈，不等待状态变化事件
-- **新功能**：按键背光灯选项
-  - 在按钮编号下拉框中新增"按键背光灯"选项（通道0x0F）
-  - 用于红外感应触发背光灯的联动控制
-  - 未选择此选项时，红外感应帧会被正确忽略，避免误触发
-
 **核心特性**：
 - 支持Modbus RTU/TCP协议，兼容标准Modbus设备和TCP转RS485网关
 - 支持Symi RS-485开关和蓝牙Mesh开关，实现双向状态同步

package/nodes/modbus-master.html

@@ -4,7 +4,7 @@
         color: '#3FADB5',
         paletteLabel: "主站",
         defaults: {
-            name: {value: "Modbus主站"},
+            name: {value: "Modbus主站", required: true},
             modbusServer: {value: "", type: "modbus-server-config", required: true},
             // 从站配置列表（数组）
             slaves: {value: [{

package/nodes/modbus-slave-switch.html

@@ -25,7 +25,7 @@
             // 映射到继电器
             targetSlaveAddress: {value: 10, validate: RED.validators.number()},
             targetCoilNumber: {value: 1, validate: RED.validators.number()},  // 默认值改为1（显示为1路）
-            modbusMaster: {value: ""}  // 关联的主站节点
+            modbusMaster: {value: "", required: true}  // 关联的主站节点
         },
         inputs: 1,
         outputs: 1,
@@ -448,12 +448,25 @@
     <p>Modbus从站开关节点，将物理开关面板的按钮映射到Modbus继电器设备，通过MQTT实现控制。</p>
     
     <h3>工作原理</h3>
-    <p>本节点实现物理开关面板（RS-485）到Modbus继电器的映射：</p>
+    <p>本节点实现物理开关面板（RS-485或蓝牙Mesh）到Modbus继电器的映射：</p>
     <ul>
-        <li><strong>物理面板</strong>：开关ID（0-255）+ 按钮编号（1-8）</li>
+        <li><strong>物理面板(RS-485)</strong>：开关ID（0-255）+ 按钮编号（1-8）</li>
+        <li><strong>Mesh开关(蓝牙)</strong>：MAC地址 + 按钮编号（1-6）</li>
         <li><strong>映射到</strong>：Modbus从站地址（10-19）+ 线圈编号（0-31）</li>
         <li><strong>通过MQTT</strong>：内置MQTT客户端，无需连线到主站节点</li>
     </ul>
+
+    <h3>模式选择</h3>
+    <dl class="message-properties">
+        <dt>按钮类型<span class="property-type">select</span></dt>
+        <dd>
+            <ul>
+                <li><strong>开关按钮</strong>：RS-485有线开关，带状态反馈</li>
+                <li><strong>场景按钮</strong>：RS-485场景面板，无状态反馈</li>
+                <li><strong>Mesh开关</strong>：蓝牙Mesh无线开关，支持设备发现</li>
+            </ul>
+        </dd>
+    </dl>
     
     <h3>MQTT配置</h3>
     <dl class="message-properties">

package/nodes/modbus-slave-switch.js

@@ -571,12 +571,9 @@ module.exports = function(RED) {
             if (node.serialPortConfig) {
                 // 定义数据监听器函数（静默处理，只在匹配时输出日志）
                 node.serialDataListener = (data) => {
-                    // 根据开关类型调用不同的处理函数
-                    if (node.config.buttonType === 'mesh') {
-                        node.handleMeshData(data);
-                    } else {
-                        node.handleRs485Data(data);
-                    }
+                    // 所有品牌/协议统一使用 handleRs485Data 进行拼包解析
+                    // 内部会根据 buttonType/switchBrand 自动选择解析算法，解决沾包分包问题
+                    node.handleRs485Data(data);
                 };
 
                 // 注册到共享连接配置
@@ -612,171 +609,111 @@ module.exports = function(RED) {
                     node.debug(`收到首次轮询状态同步：从站${slave} 线圈${coil} = ${value ? 'ON' : 'OFF'}`);
                 }
 
-                // Mesh模式：监听所有绑定到同一个面板的线圈，更新全局状态缓存
-                if (node.config.buttonType === 'mesh' && slave === node.config.targetSlaveAddress) {
-                    const meshAddr = node.config.meshShortAddress;
-                    if (!meshDeviceStates.has(meshAddr)) {
-                        // 初始化状态数组（全部设为null，表示未知状态）
-                        meshDeviceStates.set(meshAddr, new Array(node.config.meshTotalButtons).fill(null));
+                // 核心变量准备
+                const isMesh = (node.config.buttonType === 'mesh');
+                const panelKey = isMesh ? node.config.meshShortAddress : node.config.switchId;
+                const isButtonPress = (triggerSource === 'button-press' || triggerSource === 'scene-trigger');
+                const isInit = (triggerSource === 'init' || data.source === 'init');
+                const isRelayControl = !isButtonPress && !isInit;
+
+                // 更新全局状态缓存（用于所有协议的LED反馈优化）
+                if (panelKey) {
+                    if (!meshDeviceStates.has(panelKey)) {
+                        const totalButtons = isMesh ? node.config.meshTotalButtons : 8; // 非Mesh默认支持8路
+                        meshDeviceStates.set(panelKey, new Array(totalButtons).fill(null));
+                    }
+                    const states = meshDeviceStates.get(panelKey);
+                    
+                    // 计算按键索引
+                    let buttonIndex = -1;
+                    if (isMesh) {
+                        const baseCoil = node.config.targetCoilNumber - (node.config.meshButtonNumber - 1);
+                        buttonIndex = coil - baseCoil;
+                    } else if (slave === node.config.targetSlaveAddress) {
+                        // RS-485模式：假设线圈是连续的，或者通过targetCoilNumber定位
+                        // 这里我们优先处理当前节点绑定的按键
+                        if (coil === node.config.targetCoilNumber) {
+                            buttonIndex = node.config.buttonNumber - 1;
+                        }
                     }
 
-                    // 计算线圈对应的按钮编号（线圈0→按钮1，线圈1→按钮2，...）
-                    const baseCoil = node.config.targetCoilNumber - (node.config.meshButtonNumber - 1);
-                    const buttonIndex = coil - baseCoil;
-
-                    // 检查是否是同一个面板的线圈（线圈范围：baseCoil ~ baseCoil+totalButtons-1）
-                    if (buttonIndex >= 0 && buttonIndex < node.config.meshTotalButtons) {
-                        // 更新全局状态缓存
-                        const states = meshDeviceStates.get(meshAddr);
+                    if (buttonIndex >= 0 && buttonIndex < states.length) {
                         const oldValue = states[buttonIndex];
                         states[buttonIndex] = value;
                         const stateChanged = (oldValue !== value);
 
-                        // 核心修复：区分按键触发和继电器直接控制
-                        const isButtonPress = (triggerSource === 'button-press');
-                        const isInit = (triggerSource === 'init' || data.source === 'init');
-                        const isRelayControl = !isButtonPress && !isInit;
-
-                        // 继电器控制：所有同一面板的线圈变化都会重置定时器（只有按钮1节点负责）
-                        if (isRelayControl && stateChanged && node.config.meshButtonNumber === 1) {
+                        // 继电器控制：面板关联的任何线圈变化都会触发LED同步
+                        if (isRelayControl && stateChanged) {
                             const now = Date.now();
-
-                            // 获取或创建定时器对象
-                            let timerObj = meshLedDebounceTimers.get(meshAddr);
+                            let timerObj = meshLedDebounceTimers.get(panelKey);
 
                             if (!timerObj) {
-                                // 首次变化：创建新的定时器对象
                                 timerObj = {
                                     timer: null,
                                     nodeId: node.id,
                                     serialPortConfig: node.serialPortConfig,
-                                    firstChangeTime: now,  // 记录第一次变化的时间
-                                    changeCount: 0  // 记录变化次数
+                                    firstChangeTime: now,
+                                    changeCount: 0
                                 };
-                                meshLedDebounceTimers.set(meshAddr, timerObj);
+                                meshLedDebounceTimers.set(panelKey, timerObj);
                             }
 
-                            // 增加变化计数
                             timerObj.changeCount++;
+                            if (timerObj.timer) clearTimeout(timerObj.timer);
 
-                            // 清除之前的定时器
-                            if (timerObj.timer) {
-                                clearTimeout(timerObj.timer);
-                            }
-
-                            // 设置新的定时器：100ms内如果没有新的状态变化，才发送LED反馈
                             const capturedNode = node;
                             timerObj.timer = setTimeout(() => {
-                                // 检查是否是当前节点设置的定时器
-                                const currentTimerObj = meshLedDebounceTimers.get(meshAddr);
-                                if (currentTimerObj && currentTimerObj.nodeId === capturedNode.id) {
-                                    meshLedDebounceTimers.delete(meshAddr);
-                                    const currentStates = meshDeviceStates.get(meshAddr);
-
-                                    // 计算全局锁定时间：100ms（足够发送LED反馈，但不影响下一次按键）
-                                    const lockDuration = 100;
-                                    meshLedFeedbackGlobalLock = Date.now() + lockDuration;
-
-                                    // 发送LED反馈到物理开关面板（使用最新的完整状态）
-                                    const button1State = currentStates[0];  // 按钮1的状态
-                                    capturedNode.sendCommandToPanel(button1State);
+                                const currentTimerObj = meshLedDebounceTimers.get(panelKey);
+                                if (currentTimerObj) {
+                                    meshLedDebounceTimers.delete(panelKey);
+                                    
+                                    // 设置全局锁定：100ms内忽略面板状态上报
+                                    // 改进：使用更精准的锁定时间，并增加序列号或时间戳校验
+                                    meshLedFeedbackGlobalLock = Date.now() + 150; 
+
+                                    capturedNode.debug(`[LED反馈] 面板${panelKey} 继电器触发同步`);
+                                    capturedNode.sendCommandToPanel(capturedNode.currentState);
                                 }
-                            }, 100);
-                        }
-
-                        // 只有当前节点绑定的线圈变化时，才更新节点状态并触发按键LED反馈
-                        if (coil === node.config.targetCoilNumber) {
-                            // 更新当前节点状态
-                            node.currentState = value;
-                            node.lastStateChange.timestamp = Date.now();
-                            node.lastStateChange.value = value;
-
-                            if (stateChanged) {
-                                if (isButtonPress) {
-                                    // 按键触发：立即发送整个面板LED状态（快速响应）
-                                    node.debug(`[LED反馈] Mesh${meshAddr} 按钮${node.config.meshButtonNumber}: 按键触发，立即发送整个面板LED状态`);
-
-                                    // 设置全局锁定：100ms内忽略所有Mesh面板的状态上报（缩短锁定时间，避免影响下一次按键）
-                                    meshLedFeedbackGlobalLock = Date.now() + 100;
-
-                                    // 立即发送LED反馈（整个面板）
-                                    node.sendCommandToPanel(value);
-                                } else if (isInit) {
-                                    // 首次轮询：发送LED反馈（同步初始状态）
-                                    // 使用防抖机制，避免重复发送
-                                    if (!meshLedDebounceTimers.has(meshAddr)) {
-                                        const capturedNode = node;
-                                        const timer = setTimeout(() => {
-                                            const timerObj = meshLedDebounceTimers.get(meshAddr);
-                                            if (timerObj && timerObj.nodeId === capturedNode.id) {
-                                                meshLedDebounceTimers.delete(meshAddr);
-                                                const currentStates = meshDeviceStates.get(meshAddr);
-                                                capturedNode.debug(`[LED反馈] Mesh${meshAddr} 首次轮询，发送整个面板LED状态: ${JSON.stringify(currentStates)}`);
-
-                                                // 设置全局锁定：100ms内忽略所有Mesh面板的状态上报
-                                                meshLedFeedbackGlobalLock = Date.now() + 100;
-
-                                                capturedNode.sendCommandToPanel(value);
-                                            }
-                                        }, 200);  // 200ms防抖时间，等待所有初始状态收集完毕
-
-                                        meshLedDebounceTimers.set(meshAddr, {
-                                            timer: timer,
-                                            nodeId: node.id,
-                                            serialPortConfig: node.serialPortConfig
-                                        });
-
-                                        node.debug(`[LED防抖] Mesh${meshAddr} 按钮${node.config.meshButtonNumber}: 首次轮询，设置防抖定时器(200ms)`);
-                                    }
-                                }
-                            }
-
-                            // 更新节点状态显示
-                            node.updateStatus();
-
-                            // 输出状态消息（立即输出，不等待防抖）
-                            node.send({
-                                payload: value,
-                                topic: `switch_${node.config.switchId}_btn${node.config.buttonNumber}`,
-                                switchId: node.config.switchId,
-                                button: node.config.buttonNumber,
-                                targetSlave: node.config.targetSlaveAddress,
-                                targetCoil: node.config.targetCoilNumber
-                            });
+                            }, 50); // 50ms防抖
                         }
                     }
-                } else if (slave === node.config.targetSlaveAddress && coil === node.config.targetCoilNumber) {
-                    // RS-485模式或非Mesh模式：只处理自己绑定的线圈
-                    // 检查状态是否真正变化
-                    const stateChanged = (node.currentState !== value);
-                    
-                    // 区分触发源
-                    const isButtonPress = (triggerSource === 'button-press' || triggerSource === 'scene-trigger');
-                    const isInit = (data.source === 'init');  // 首次轮询
-                    const isPolling = (data.source === 'polling');  // 轮询变化
+                }
 
-                    // 更新当前状态
+                // 只有当前节点绑定的线圈变化时，才更新节点状态并处理后续逻辑
+                if (slave === node.config.targetSlaveAddress && coil === node.config.targetCoilNumber) {
+                    const stateChanged = (node.currentState !== value);
                     node.currentState = value;
                     node.lastStateChange.timestamp = Date.now();
                     node.lastStateChange.value = value;
 
-                    if (stateChanged && !isButtonPress) {
-                        // RS-485模式：状态变化且非按键触发时发送LED反馈
-                        // 按键触发的LED反馈已在handleRs485Data中发送，避免重复
-                        node.sendCommandToPanel(value);
+                    if (stateChanged) {
+                        if (isButtonPress) {
+                            // 按键触发：立即同步（高优先级）
+                            meshLedFeedbackGlobalLock = Date.now() + 150;
+                            node.sendCommandToPanel(value);
+                        } else if (isInit) {
+                            // 首次轮询：防抖同步
+                            if (panelKey && !meshLedDebounceTimers.has(panelKey)) {
+                                const capturedNode = node;
+                                const timer = setTimeout(() => {
+                                    if (meshLedDebounceTimers.has(panelKey)) {
+                                        meshLedDebounceTimers.delete(panelKey);
+                                        meshLedFeedbackGlobalLock = Date.now() + 150;
+                                        capturedNode.sendCommandToPanel(value);
+                                    }
+                                }, 200);
+                                meshLedDebounceTimers.set(panelKey, { timer, nodeId: node.id });
+                            }
+                        }
                     }
 
-                    // 更新节点状态显示
                     node.updateStatus();
 
-                    // 首次轮询时只同步内部状态和LED反馈，不发送消息到下游
-                    // 避免重启Node-RED时触发下游节点导致继电器动作
                     if (isInit) {
                         node.debug(`首次轮询状态同步：从站${slave} 线圈${coil} = ${value ? 'ON' : 'OFF'}（不发送到下游）`);
                         return;
                     }
 
-                    // 输出状态消息（仅在非首次轮询时发送）
                     node.send({
                         payload: value,
                         topic: `switch_${node.config.switchId}_btn${node.config.buttonNumber}`,
@@ -784,7 +721,7 @@ module.exports = function(RED) {
                         button: node.config.buttonNumber,
                         targetSlave: node.config.targetSlaveAddress,
                         targetCoil: node.config.targetCoilNumber,
-                        source: isPolling ? 'polling' : triggerSource  // 传递触发源
+                        source: (data.source === 'polling') ? 'polling' : triggerSource
                     });
                 }
             };

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "node-red-contrib-symi-modbus",
-  "version": "2.9.12",
+  "version": "2.9.14",
   "description": "Node-RED Modbus节点，支持TCP/串口通信、多主站独立运行、串口自动搜索、多设备轮询、可选MQTT集成（支持纯本地模式和MQTT模式）、Home Assistant自动发现、HomeKit网桥、可视化控制看板、自定义协议转换和物理开关面板双向同步（支持亖米/Clowire品牌），工控机长期稳定运行",
   "main": "nodes/modbus-master.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "lint": "echo \"No linting configured\"",
+    "test": "echo \"No tests configured\""
   },
   "keywords": [
     "node-red",