node-red-contrib-symi-modbus 2.6.7 → 2.7.0

package/README.md

@@ -17,6 +17,8 @@ Node-RED的Modbus继电器控制节点，支持TCP/串口通信和MQTT集成，
   - Modbus RTU over TCP（TCP转RS485网关）
   - Telnet ASCII（推荐用于TCP转RS485网关）
 - **Symi开关集成**：自动识别并处理Symi私有协议按键事件，实现开关面板与继电器的双向同步
+- **HomeKit网桥**：一键桥接到Apple HomeKit，支持Siri语音控制，自动同步主站配置，名称可自定义
+- **智能写入队列**：所有写入操作串行执行，支持HomeKit群控160个继电器同时动作，流畅无卡顿
 - **多设备轮询**：支持最多10台Modbus从站设备，每台32路继电器
 - **智能轮询机制**：从站上报时自动暂停轮询，优先处理数据，避免冲突
 - **稳定可靠**：完整的内存管理、错误处理、断线重连，适合7x24小时长期运行
@@ -146,6 +148,72 @@ node-red-restart
 5. **无需连线**：主站和从站通过内部事件自动通信，无需手动连线
 6. 部署流程
 
+### 6. 配置HomeKit网桥节点（可选）
+
+将Modbus继电器桥接到Apple HomeKit，实现Siri语音控制：
+
+**配置步骤**：
+
+1. **添加网桥节点**
+   - 拖拽 **HomeKit网桥** 节点到流程画布
+   - 双击节点打开配置界面
+
+2. **基础配置**
+   - 网桥名称: `Modbus继电器网桥`（在HomeKit中显示）
+   - 选择主站节点: 从下拉框选择已配置的主站
+   - 配对码: `031-45-154`（添加到HomeKit时使用）
+   - 端口: `51828`（保持默认）
+
+3. **配置继电器名称**（推荐）
+   - 选择主站后，下方会自动显示所有继电器
+   - 为每个继电器输入友好的中文名称
+   - 例如：`客厅灯`、`卧室灯`、`空调插座`等
+   - 配置后在HomeKit中直接显示，无需再修改
+
+4. **部署并添加到HomeKit**
+   - 点击"完成"并部署流程
+   - 打开iPhone/iPad的"家庭"App
+   - 点击右上角"+" → "添加配件"
+   - 选择"更多选项"
+   - 找到"Modbus继电器网桥"
+   - 输入配对码：`031-45-154`
+   - 完成配对
+
+**使用说明**：
+- 线圈0-15显示为开关，线圈16-31显示为插座
+- 支持Siri语音控制："嘿Siri，打开客厅灯"
+- 支持HomeKit自动化和场景
+- 配置会自动保存，重启后无需重新配对
+- **群控性能**：支持同时控制多个继电器（如创建编组），智能队列机制确保流畅无卡顿
+
+**群控说明**（客户友好模式）：
+
+本节点专为智能家居群控场景优化，支持以下高性能操作：
+
+1. **HomeKit编组群控**：
+   - 在HomeKit中创建房间或编组，可同时控制多个继电器
+   - 例如：创建"客厅"编组，包含10个灯光开关，一键全开/全关
+   - 智能队列机制确保所有继电器按序快速执行，无超时警告
+   - 10个继电器同时动作仅需约200ms（20ms间隔×10）
+
+2. **场景联动**：
+   - 支持HomeKit场景（如"回家模式"、"离家模式"）
+   - 场景可包含多个继电器动作，自动串行执行
+   - 前16个线圈（继电器）可同时动作，后16个线圈（场景）按需触发
+
+3. **性能保证**：
+   - 最大支持10台继电器（每台32路），共320个线圈
+   - 前160个线圈（10台×16路）可用于继电器控制，支持群控
+   - 后160个线圈（10台×16路）可用于场景触发，一般不会全部同时动作
+   - 智能写入队列确保所有操作串行执行，避免总线冲突
+   - 长期稳定运行，反复控制不会造成内存增加、卡顿或死机
+
+4. **技术细节**：
+   - 写入队列间隔：20ms（确保总线稳定）
+   - 轮询恢复时间：20ms（快速响应）
+   - 锁等待超时：100ms（快速检测异常）
+   - 队列自动处理，无需手动干预
+
 ## 核心特性说明
 
 ### Symi开关自动识别
@@ -578,6 +646,40 @@ msg.payload = "ON";   // 或 "OFF"
 msg.payload = 1;      // 或 0
 ```
 
+### HomeKit网桥节点
+
+HomeKit网桥节点无需输入消息，自动同步主站配置和状态。
+
+**配置参数**：
+- **主站节点**：选择要桥接的Modbus主站节点（必填）
+- **网桥名称**：在HomeKit中显示的网桥名称（默认：Modbus继电器网桥）
+- **MAC地址**：HomeKit网桥的唯一标识符（自动生成，无需修改）
+- **配对码**：HomeKit配对时使用的PIN码（格式：XXX-XX-XXX，默认：031-45-154）
+- **端口**：HomeKit网桥监听端口（默认：51828）
+- **继电器名称配置**：为每个继电器配置友好的中文名称（可选）
+
+**自动同步规则**：
+- 自动读取主站节点配置的所有从站和线圈
+- 线圈0-15（1-16路）：创建为开关（Switch）配件
+- 线圈16-31（17-32路）：创建为插座（Outlet）配件
+- 监听主站的状态变化事件，实时同步到HomeKit
+- 接收HomeKit控制命令，发送到主站执行
+
+**使用示例**：
+1. 在Node-RED中配置好主站节点和从站
+2. 添加HomeKit网桥节点，选择主站节点
+3. 为每个继电器配置友好的名称（例如：客厅灯、卧室灯）
+4. 部署流程
+5. 在iPhone的"家庭"App中添加配件，输入配对码
+6. 完成配对后，即可在HomeKit中控制继电器，支持Siri语音控制
+
+**注意事项**：
+- 确保主站节点已正确配置并运行
+- 配对码格式必须为XXX-XX-XXX（8位数字）
+- 端口不能与其他服务冲突（默认51828）
+- 配置信息持久化存储在~/.node-red/homekit-persist目录
+- 重启Node-RED后自动恢复配对状态，无需重新配对
+
 ## 输出消息格式
 
 ### 主站节点
@@ -638,28 +740,46 @@ msg.payload = 1;      // 或 0
 
 ## 项目信息
 
-**版本**: v2.6.7
+**版本**: v2.7.0
 
 **核心功能**：
 - 支持多种Modbus协议（Telnet ASCII、RTU over TCP、Modbus TCP、Modbus RTU串口）
 - 多设备轮询（最多10台从站，每台32路继电器，轮询间隔100-10000ms可调）
-- Symi私有协议自动识别（支持两种485开关控制方式）
-- 智能轮询暂停机制（从站上报时自动暂停，处理完成后恢复）
 - 🔥 **双模式支持**（本地模式和MQTT模式可选切换，断网也能稳定运行）
-- 🔥 **免连线通信**（主站和从站通过内部事件通信，无需连线，支持本地模式和MQTT模式）
-- MQTT集成（可选启用，Home Assistant自动发现，实体唯一性保证，QoS=0高性能发布）
-- 物理开关面板双向同步（亖米协议支持，LED反馈同步，支持开关模式和场景模式）
-- 共享连接架构（多个从站开关节点共享同一个串口/TCP连接，支持500+节点）
-- 长期稳定运行（内存管理、智能重连、错误日志限流、异步MQTT发布、TCP永久连接）
-
-**技术栈**：
-- modbus-serial: ^8.0.23（内部封装serialport，支持TCP和串口）
-- serialport: ^12.0.0（原生串口通信）
-- mqtt: ^5.14.1（最新稳定版，可选依赖）
+- 🔥 **免连线通信**（主站和从站通过内部事件通信，无需连线）
+- 🔥 **HomeKit网桥**（一键桥接到Apple HomeKit，支持Siri语音控制）
+- 🔥 **智能写入队列**（所有写入操作串行执行，避免锁竞争，支持HomeKit群控）
+- MQTT集成（可选启用，Home Assistant自动发现）
+- 物理开关面板双向同步（支持开关模式和场景模式）
+- 长期稳定运行（内存管理、智能重连、异步处理）
+
+**技术要求**：
 - Node.js: >=14.0.0
 - Node-RED: >=2.0.0
 
-**最新更新（v2.6.7）**：
+**最新更新（v2.7.0）**：
+- **🔥 智能写入队列机制**：
+  - 所有写入操作（HomeKit、MQTT、内部事件）统一进入队列串行执行
+  - 彻底解决HomeKit群控时的锁竞争问题，不再出现"写入线圈等待超时"警告
+  - 写入间隔优化到20ms，确保快速响应（10个继电器同时动作仅需200ms）
+  - 队列自动处理，无需手动干预，确保总线稳定性
+  - 支持最多160个继电器（10台从站×16路）同时群控，流畅无卡顿
+- **性能优化**：
+  - 轮询恢复时间从100ms优化到20ms，提升响应速度5倍
+  - 锁等待超时从1000ms降低到100ms，快速检测异常
+  - 内存占用更低，CPU占用更少，适合长期运行
+
+**v2.6.8更新**：
+- **🔥 新增HomeKit网桥节点**：
+  - 一键桥接Modbus继电器到Apple HomeKit
+  - 自动同步主站配置的所有从站和继电器
+  - 支持在Node-RED中配置继电器友好名称
+  - 双向同步：HomeKit控制继电器，继电器状态实时同步到HomeKit
+  - 支持Siri语音控制和HomeKit自动化场景
+  - 持久化存储配对信息，重启后自动恢复
+  - 线圈0-15显示为开关，线圈16-31显示为插座（避免误触发）
+
+**v2.6.7更新**：
 - **🔥 修复LED反馈功能**：
   - 主站轮询检测到状态变化时自动广播事件
   - 从站开关节点监听状态变化并发送LED反馈到物理面板
@@ -986,7 +1106,7 @@ msg.payload = 1;      // 或 0
 
 ## 项目信息
 
-**版本**: v2.6.7
+**版本**: v2.7.0
 
 **核心功能**：
 - 支持多种Modbus协议（Telnet ASCII、RTU over TCP、Modbus TCP、Modbus RTU串口）
@@ -995,6 +1115,8 @@ msg.payload = 1;      // 或 0
 - 智能轮询暂停机制（从站上报时自动暂停，处理完成后恢复）
 - 🔥 **双模式支持**（本地模式和MQTT模式可选切换，断网也能稳定运行）
 - 🔥 **免连线通信**（主站和从站通过内部事件通信，无需连线，支持本地模式和MQTT模式）
+- 🔥 **HomeKit网桥**（一键桥接到Apple HomeKit，支持Siri语音控制，名称可自定义）
+- 🔥 **智能写入队列**（所有写入操作串行执行，避免锁竞争，支持HomeKit群控）
 - MQTT集成（可选启用，Home Assistant自动发现，实体唯一性保证，QoS=0高性能发布）
 - 物理开关面板双向同步（亖米协议支持，LED反馈同步，支持开关模式和场景模式）
 - 共享连接架构（多个从站开关节点共享同一个串口/TCP连接，支持500+节点）
@@ -1004,5 +1126,7 @@ msg.payload = 1;      // 或 0
 - modbus-serial: ^8.0.23（内部封装serialport，支持TCP和串口）
 - serialport: ^12.0.0（原生串口通信）
 - mqtt: ^5.14.1（最新稳定版，可选依赖）
+- hap-nodejs: ^1.2.0（HomeKit桥接）
+- node-persist: ^4.0.4（持久化存储）
 - Node.js: >=14.0.0
 - Node-RED: >=2.0.0

package/nodes/homekit-bridge.html

@@ -0,0 +1,251 @@
+<script type="text/javascript">
+    RED.nodes.registerType('homekit-bridge', {
+        category: 'SYMI-MODBUS',
+        color: '#FF9800',
+        defaults: {
+            name: {value: "HomeKit网桥"},
+            bridgeName: {value: "Modbus继电器网桥"},
+            username: {value: ""},  // 自动生成MAC地址
+            pincode: {value: "031-45-154"},
+            port: {value: 51828},
+            masterNode: {value: "", required: true},
+            // 继电器名称配置（持久化）
+            relayNames: {value: {}}  // 格式: {"10_0": "客厅灯", "10_1": "卧室灯", ...}
+        },
+        inputs: 0,
+        outputs: 0,
+        icon: "home.png",
+        label: function() {
+            return this.name || "HomeKit网桥";
+        },
+        oneditprepare: function() {
+            var node = this;
+
+            // 填充主站节点选择器
+            var masterNodeSelect = $("#node-input-masterNode");
+            masterNodeSelect.empty();
+            masterNodeSelect.append('<option value="">请选择主站节点</option>');
+
+            // 查找所有modbus-master节点
+            RED.nodes.eachNode(function(n) {
+                if (n.type === "modbus-master") {
+                    var label = n.name || `主站 ${n.id.substring(0, 8)}`;
+                    var selected = (n.id === node.masterNode) ? ' selected' : '';
+                    masterNodeSelect.append(`<option value="${n.id}"${selected}>${label}</option>`);
+                }
+            });
+
+            // 自动生成MAC地址（如果未设置）
+            if (!node.username || node.username === "") {
+                node.username = generateMacAddress();
+                $("#node-input-username").val(node.username);
+            }
+
+            // 初始化继电器名称配置
+            if (!node.relayNames) {
+                node.relayNames = {};
+            }
+
+            // 监听主站节点选择变化
+            masterNodeSelect.on("change", function() {
+                renderRelayNameConfig();
+            });
+
+            // 初始渲染
+            renderRelayNameConfig();
+            
+            // 生成MAC地址函数
+            function generateMacAddress() {
+                var mac = [];
+                for (var i = 0; i < 6; i++) {
+                    var byte = Math.floor(Math.random() * 256).toString(16).toUpperCase();
+                    mac.push(byte.length === 1 ? "0" + byte : byte);
+                }
+                return mac.join(":");
+            }
+            
+            // 渲染继电器名称配置
+            function renderRelayNameConfig() {
+                var masterNodeId = $("#node-input-masterNode").val();
+                var container = $("#relay-names-container");
+                container.empty();
+                
+                if (!masterNodeId) {
+                    container.html('<div style="padding: 20px; text-align: center; color: #999;">请先选择主站节点</div>');
+                    return;
+                }
+                
+                // 获取主站节点配置
+                var masterNode = RED.nodes.node(masterNodeId);
+                if (!masterNode || !masterNode.slaves || masterNode.slaves.length === 0) {
+                    container.html('<div style="padding: 20px; text-align: center; color: #999;">主站节点未配置从站</div>');
+                    return;
+                }
+                
+                // 遍历所有从站和线圈
+                masterNode.slaves.forEach(function(slave) {
+                    var slaveSection = $('<div class="slave-section" style="margin-bottom: 20px; padding: 15px; border: 1px solid #e0e0e0; border-radius: 8px; background: #f9f9f9;">');
+                    
+                    slaveSection.html(`
+                        <div style="font-weight: bold; font-size: 14px; margin-bottom: 10px; color: #333;">
+                            从站 ${slave.address} (线圈 ${slave.coilStart}-${slave.coilEnd})
+                        </div>
+                    `);
+                    
+                    var relayGrid = $('<div style="display: grid; grid-template-columns: repeat(2, 1fr); gap: 10px;">');
+                    
+                    for (var coil = slave.coilStart; coil <= slave.coilEnd; coil++) {
+                        var key = slave.address + "_" + coil;
+                        var currentName = node.relayNames[key] || getDefaultRelayName(slave.address, coil);
+                        var relayType = coil < 16 ? "开关" : "插座";
+                        
+                        var relayRow = $(`
+                            <div style="display: flex; align-items: center; gap: 8px; padding: 8px; background: white; border-radius: 4px;">
+                                <span style="min-width: 80px; font-size: 12px; color: #666;">线圈${coil} (${relayType}):</span>
+                                <input type="text" class="relay-name-input" data-key="${key}" value="${currentName}" 
+                                    style="flex: 1; padding: 5px 8px; border: 1px solid #ccc; border-radius: 4px; font-size: 13px;"
+                                    placeholder="输入名称...">
+                            </div>
+                        `);
+                        
+                        relayGrid.append(relayRow);
+                    }
+                    
+                    slaveSection.append(relayGrid);
+                    container.append(slaveSection);
+                });
+                
+                // 绑定输入事件
+                $(".relay-name-input").on("input", function() {
+                    var key = $(this).data("key");
+                    var value = $(this).val().trim();
+                    if (value) {
+                        node.relayNames[key] = value;
+                    } else {
+                        delete node.relayNames[key];
+                    }
+                });
+            }
+            
+            // 获取默认继电器名称
+            function getDefaultRelayName(slaveAddr, coil) {
+                var type = coil < 16 ? "开关" : "场景";
+                return `从站${slaveAddr}_${type}${coil + 1}`;
+            }
+        },
+        oneditsave: function() {
+            // 保存时确保relayNames已更新
+            // 已在input事件中实时更新，无需额外处理
+        }
+    });
+</script>
+
+<script type="text/html" data-template-name="homekit-bridge">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> 节点名称</label>
+        <input type="text" id="node-input-name" placeholder="HomeKit网桥">
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-masterNode"><i class="fa fa-microchip"></i> 主站节点</label>
+        <select id="node-input-masterNode" style="width: 70%;">
+            <option value="">请选择主站节点</option>
+        </select>
+        <div style="font-size: 11px; color: #999; margin-top: 5px;">选择要桥接的Modbus主站节点</div>
+    </div>
+
+    <hr style="margin: 20px 0; border: none; border-top: 1px solid #e0e0e0;">
+
+    <div class="form-row">
+        <label for="node-input-bridgeName"><i class="fa fa-home"></i> 网桥名称</label>
+        <input type="text" id="node-input-bridgeName" placeholder="Modbus继电器网桥">
+        <div style="font-size: 11px; color: #999; margin-top: 5px;">在HomeKit中显示的网桥名称</div>
+    </div>
+    
+    <div class="form-row">
+        <label for="node-input-username"><i class="fa fa-barcode"></i> MAC地址</label>
+        <input type="text" id="node-input-username" placeholder="自动生成" readonly>
+        <div style="font-size: 11px; color: #999; margin-top: 5px;">HomeKit网桥的唯一标识符（自动生成）</div>
+    </div>
+    
+    <div class="form-row">
+        <label for="node-input-pincode"><i class="fa fa-key"></i> 配对码</label>
+        <input type="text" id="node-input-pincode" placeholder="031-45-154">
+        <div style="font-size: 11px; color: #999; margin-top: 5px;">HomeKit配对时使用的PIN码（格式：XXX-XX-XXX）</div>
+    </div>
+    
+    <div class="form-row">
+        <label for="node-input-port"><i class="fa fa-plug"></i> 端口</label>
+        <input type="number" id="node-input-port" placeholder="51828" min="1024" max="65535">
+        <div style="font-size: 11px; color: #999; margin-top: 5px;">HomeKit网桥监听端口（默认：51828）</div>
+    </div>
+    
+    <hr style="margin: 20px 0; border: none; border-top: 1px solid #e0e0e0;">
+    
+    <div class="form-row">
+        <label style="width: 100%; margin-bottom: 10px;">
+            <i class="fa fa-list"></i> 继电器名称配置
+        </label>
+        <div id="relay-names-container" style="width: 100%; max-height: 400px; overflow-y: auto; border: 1px solid #e0e0e0; border-radius: 4px; padding: 10px; background: white;">
+            <div style="padding: 20px; text-align: center; color: #999;">请先选择主站节点</div>
+        </div>
+        <div style="font-size: 11px; color: #999; margin-top: 5px;">
+            配置每个继电器在HomeKit中显示的名称<br>
+            线圈0-15显示为开关，线圈16-31显示为插座（避免误触发场景）
+        </div>
+    </div>
+</script>
+
+<script type="text/html" data-help-name="homekit-bridge">
+    <p>HomeKit网桥节点，将Modbus继电器桥接到Apple HomeKit。</p>
+    
+    <h3>功能特性</h3>
+    <ul>
+        <li>自动同步主站节点配置的所有从站和继电器</li>
+        <li>线圈0-15显示为开关（Switch），线圈16-31显示为插座（Outlet）</li>
+        <li>支持在Node-RED中配置每个继电器的名称，无需在HomeKit中修改</li>
+        <li>双向同步：HomeKit控制继电器，继电器状态同步到HomeKit</li>
+        <li>持久化存储配置和配对信息，重启后自动恢复</li>
+    </ul>
+    
+    <h3>配置说明</h3>
+    <dl class="message-properties">
+        <dt>主站节点 <span class="property-type">必填</span></dt>
+        <dd>选择要桥接的Modbus主站节点</dd>
+        
+        <dt>网桥名称 <span class="property-type">可选</span></dt>
+        <dd>在HomeKit中显示的网桥名称（默认：Modbus继电器网桥）</dd>
+        
+        <dt>MAC地址 <span class="property-type">自动生成</span></dt>
+        <dd>HomeKit网桥的唯一标识符，自动生成，无需修改</dd>
+        
+        <dt>配对码 <span class="property-type">必填</span></dt>
+        <dd>HomeKit配对时使用的PIN码（格式：XXX-XX-XXX，默认：031-45-154）</dd>
+        
+        <dt>端口 <span class="property-type">可选</span></dt>
+        <dd>HomeKit网桥监听端口（默认：51828）</dd>
+        
+        <dt>继电器名称配置 <span class="property-type">可选</span></dt>
+        <dd>配置每个继电器在HomeKit中显示的名称，支持中文</dd>
+    </dl>
+    
+    <h3>使用步骤</h3>
+    <ol>
+        <li>选择已配置的Modbus主站节点</li>
+        <li>配置网桥名称和配对码</li>
+        <li>为每个继电器配置友好的名称（可选）</li>
+        <li>部署流程</li>
+        <li>在iPhone/iPad的"家庭"App中添加配件，输入配对码</li>
+        <li>完成配对后，即可在HomeKit中控制继电器</li>
+    </ol>
+    
+    <h3>注意事项</h3>
+    <ul>
+        <li>确保主站节点已正确配置并运行</li>
+        <li>配对码格式必须为XXX-XX-XXX（8位数字）</li>
+        <li>端口不能与其他服务冲突</li>
+        <li>线圈16-31使用插座类型，避免在HomeKit中误触发所有开关</li>
+        <li>配置信息持久化存储在~/.node-red/homekit-persist目录</li>
+    </ul>
+</script>
+

package/nodes/homekit-bridge.js

@@ -0,0 +1,328 @@
+module.exports = function(RED) {
+    "use strict";
+    const hap = require('hap-nodejs');
+    const storage = require('node-persist');
+    const path = require('path');
+    const os = require('os');
+
+    function HomekitBridgeNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        // 配置参数
+        node.config = {
+            name: config.name || "HomeKit网桥",
+            bridgeName: config.bridgeName || "Modbus继电器网桥",
+            username: config.username,
+            pincode: config.pincode || "031-45-154",
+            port: parseInt(config.port) || 51828,
+            masterNodeId: config.masterNode,
+            relayNames: config.relayNames || {}
+        };
+
+        // 运行时状态
+        node.bridge = null;
+        node.accessories = {};
+        node.stateChangeListener = null;
+        node.masterNode = null;
+        node.isInitialized = false;
+
+        // 初始化持久化存储
+        const persistDir = path.join(RED.settings.userDir || os.homedir() + '/.node-red', 'homekit-persist');
+
+        // 初始化函数
+        async function initialize() {
+            try {
+                // 初始化存储
+                await storage.init({
+                    dir: persistDir,
+                    stringify: JSON.stringify,
+                    parse: JSON.parse,
+                    encoding: 'utf8',
+                    logging: false,
+                    ttl: false,
+                    expiredInterval: 2 * 60 * 1000,
+                    forgiveParseErrors: true
+                });
+
+                node.log(`持久化存储初始化成功: ${persistDir}`);
+
+                // 保存继电器名称配置到持久化存储
+                await storage.setItem('relayNames', node.config.relayNames);
+                node.log(`继电器名称配置已保存: ${Object.keys(node.config.relayNames).length} 个`);
+
+                // 获取主站节点
+                node.masterNode = RED.nodes.getNode(node.config.masterNodeId);
+                if (!node.masterNode) {
+                    node.error("未找到主站节点");
+                    node.status({fill: "red", shape: "dot", text: "主站节点未找到"});
+                    return;
+                }
+
+                // 从主站节点的 config.slaves 获取从站配置
+                const slaves = node.masterNode.config ? node.masterNode.config.slaves : null;
+                if (!slaves || slaves.length === 0) {
+                    node.error("主站节点未配置从站");
+                    node.status({fill: "red", shape: "dot", text: "主站未配置从站"});
+                    return;
+                }
+
+                node.log(`找到主站节点，从站数量: ${slaves.length}`);
+
+                // 创建HomeKit网桥
+                await createBridge();
+
+                // 注册状态变化监听器
+                registerStateChangeListener();
+
+                node.isInitialized = true;
+                node.status({fill: "green", shape: "dot", text: "运行中"});
+                node.log(`HomeKit网桥已启动: ${node.config.bridgeName}`);
+                node.log(`配对码: ${node.config.pincode}`);
+                node.log(`端口: ${node.config.port}`);
+
+            } catch (err) {
+                node.error(`初始化失败: ${err.message}`);
+                node.status({fill: "red", shape: "dot", text: "初始化失败"});
+            }
+        }
+        
+        // 创建HomeKit网桥
+        async function createBridge() {
+            // 创建网桥配件
+            const uuid = hap.uuid.generate('homebridge:modbus-bridge:' + node.config.username);
+            node.bridge = new hap.Bridge(node.config.bridgeName, uuid);
+
+            // 配置网桥信息
+            node.bridge.getService(hap.Service.AccessoryInformation)
+                .setCharacteristic(hap.Characteristic.Manufacturer, "SYMI")
+                .setCharacteristic(hap.Characteristic.Model, "Modbus Relay Bridge")
+                .setCharacteristic(hap.Characteristic.SerialNumber, node.config.username)
+                .setCharacteristic(hap.Characteristic.FirmwareRevision, "2.6.8");
+
+            // 遍历所有从站和线圈，创建配件
+            let accessoryCount = 0;
+            const slaves = node.masterNode.config ? node.masterNode.config.slaves : [];
+            slaves.forEach(function(slave) {
+                for (let coil = slave.coilStart; coil <= slave.coilEnd; coil++) {
+                    const key = `${slave.address}_${coil}`;
+                    const accessory = createAccessory(slave.address, coil);
+                    if (accessory) {
+                        node.bridge.addBridgedAccessory(accessory);
+                        node.accessories[key] = accessory;
+                        accessoryCount++;
+                    }
+                }
+            });
+
+            node.log(`已创建 ${accessoryCount} 个HomeKit配件`);
+
+            // 发布网桥
+            node.bridge.publish({
+                username: node.config.username,
+                pincode: node.config.pincode,
+                port: node.config.port,
+                category: hap.Categories.BRIDGE
+            });
+
+            // 部署后自动更新所有配件名称（确保使用最新配置）
+            setTimeout(() => {
+                updateAllAccessoryNames();
+            }, 1000);
+        }
+        
+        // 创建单个配件
+        function createAccessory(slaveAddr, coil) {
+            const key = `${slaveAddr}_${coil}`;
+            const name = node.config.relayNames[key] || getDefaultRelayName(slaveAddr, coil);
+            const uuid = hap.uuid.generate(`homebridge:modbus-relay:${slaveAddr}:${coil}`);
+
+            // 线圈0-15使用开关，线圈16-31使用插座（避免误触发）
+            const isSwitch = coil < 16;
+            const accessory = new hap.Accessory(name, uuid);
+
+            // 保存关键信息到配件对象（用于后续更新名称）
+            accessory._slaveAddr = slaveAddr;
+            accessory._coil = coil;
+            accessory._isSwitch = isSwitch;
+
+            // 配置配件信息
+            accessory.getService(hap.Service.AccessoryInformation)
+                .setCharacteristic(hap.Characteristic.Manufacturer, "SYMI")
+                .setCharacteristic(hap.Characteristic.Model, isSwitch ? "Modbus Switch" : "Modbus Outlet")
+                .setCharacteristic(hap.Characteristic.SerialNumber, `${slaveAddr}-${coil}`)
+                .setCharacteristic(hap.Characteristic.FirmwareRevision, "2.6.8");
+
+            // 添加服务（开关或插座）
+            const service = isSwitch
+                ? accessory.addService(hap.Service.Switch, name)
+                : accessory.addService(hap.Service.Outlet, name);
+
+            // 配置On特性
+            service.getCharacteristic(hap.Characteristic.On)
+                .on('get', (callback) => {
+                    // 从主站获取当前状态
+                    const state = getRelayState(slaveAddr, coil);
+                    callback(null, state);
+                })
+                .on('set', (value, callback) => {
+                    // 发送控制命令到主站
+                    setRelayState(slaveAddr, coil, value);
+                    callback(null);
+                });
+
+            // 如果是插座，配置InUse特性（始终为true）
+            if (!isSwitch) {
+                service.getCharacteristic(hap.Characteristic.OutletInUse)
+                    .on('get', (callback) => {
+                        callback(null, true);
+                    });
+            }
+
+            return accessory;
+        }
+
+        // 更新配件名称（重新部署时调用）
+        function updateAccessoryName(accessory, newName) {
+            try {
+                const isSwitch = accessory._isSwitch;
+                const service = isSwitch
+                    ? accessory.getService(hap.Service.Switch)
+                    : accessory.getService(hap.Service.Outlet);
+
+                if (service) {
+                    // 更新服务名称
+                    service.setCharacteristic(hap.Characteristic.Name, newName);
+                    // 更新配件显示名称
+                    accessory.displayName = newName;
+                    node.log(`配件名称已更新: ${accessory._slaveAddr}_${accessory._coil} -> ${newName}`);
+                }
+            } catch (err) {
+                node.error(`更新配件名称失败: ${err.message}`);
+            }
+        }
+
+        // 获取默认继电器名称
+        function getDefaultRelayName(slaveAddr, coil) {
+            const type = coil < 16 ? "开关" : "场景";
+            return `从站${slaveAddr}_${type}${coil + 1}`;
+        }
+
+        // 获取继电器状态（修复：使用 deviceStates 而不是 coilStates）
+        function getRelayState(slaveAddr, coil) {
+            if (!node.masterNode || !node.masterNode.deviceStates) {
+                return false;
+            }
+            const deviceState = node.masterNode.deviceStates[slaveAddr];
+            if (!deviceState || !deviceState.coils) {
+                return false;
+            }
+            return deviceState.coils[coil] || false;
+        }
+        
+        // 设置继电器状态
+        function setRelayState(slaveAddr, coil, value) {
+            // 发送内部事件到主站
+            RED.events.emit('modbus:writeCoil', {
+                slave: slaveAddr,
+                coil: coil,
+                value: value,
+                source: 'homekit'
+            });
+            
+            node.log(`HomeKit控制: 从站${slaveAddr} 线圈${coil} = ${value ? 'ON' : 'OFF'}`);
+        }
+        
+        // 注册状态变化监听器
+        function registerStateChangeListener() {
+            node.stateChangeListener = function(data) {
+                try {
+                    const slave = parseInt(data.slave);
+                    const coil = parseInt(data.coil);
+                    const value = Boolean(data.value);
+                    const key = `${slave}_${coil}`;
+                    
+                    // 查找对应的配件
+                    const accessory = node.accessories[key];
+                    if (!accessory) {
+                        return;
+                    }
+                    
+                    // 更新HomeKit状态
+                    const isSwitch = coil < 16;
+                    const service = isSwitch 
+                        ? accessory.getService(hap.Service.Switch)
+                        : accessory.getService(hap.Service.Outlet);
+                    
+                    if (service) {
+                        service.getCharacteristic(hap.Characteristic.On).updateValue(value);
+                        node.log(`状态同步到HomeKit: 从站${slave} 线圈${coil} = ${value ? 'ON' : 'OFF'}`);
+                    }
+                } catch (err) {
+                    node.error(`状态变化监听器错误: ${err.message}`);
+                }
+            };
+            
+            RED.events.on('modbus:coilStateChanged', node.stateChangeListener);
+            node.log("已注册状态变化监听器（用于HomeKit同步）");
+        }
+        
+        // 监听配置更新（重新部署时）
+        node.on('input', function(msg) {
+            // 检查是否是配置更新消息
+            if (msg.topic === 'updateNames' && node.isInitialized) {
+                updateAllAccessoryNames();
+            }
+        });
+
+        // 更新所有配件名称
+        function updateAllAccessoryNames() {
+            try {
+                let updateCount = 0;
+                Object.keys(node.accessories).forEach(key => {
+                    const accessory = node.accessories[key];
+                    const newName = node.config.relayNames[key] || getDefaultRelayName(accessory._slaveAddr, accessory._coil);
+                    updateAccessoryName(accessory, newName);
+                    updateCount++;
+                });
+                node.log(`已更新 ${updateCount} 个配件名称`);
+            } catch (err) {
+                node.error(`批量更新配件名称失败: ${err.message}`);
+            }
+        }
+
+        // 节点关闭时清理
+        node.on('close', function(done) {
+            node.log("正在停止HomeKit网桥...");
+
+            // 移除状态变化监听器
+            if (node.stateChangeListener) {
+                RED.events.removeListener('modbus:coilStateChanged', node.stateChangeListener);
+                node.log("状态变化监听器已移除");
+            }
+
+            // 停止网桥
+            if (node.bridge) {
+                try {
+                    node.bridge.unpublish();
+                    node.log("HomeKit网桥已停止");
+                } catch (err) {
+                    node.warn(`停止网桥时出错: ${err.message}`);
+                }
+            }
+
+            // 清理资源
+            node.accessories = {};
+            node.bridge = null;
+            node.isInitialized = false;
+
+            done();
+        });
+
+        // 启动初始化
+        initialize();
+    }
+
+    RED.nodes.registerType("homekit-bridge", HomekitBridgeNode);
+};
+

package/nodes/modbus-master.js

@@ -147,6 +147,11 @@ module.exports = function(RED) {
         node.pollingPausedCount = 0; // 暂停轮询计数器
         node._discoveryPublished = false; // Discovery发布标志（避免重复）
 
+        // 写入队列机制（确保所有写入操作串行执行，避免锁竞争）
+        node.writeQueue = []; // 写入队列
+        node.isProcessingWrite = false; // 是否正在处理写入队列
+        node.writeQueueInterval = 20; // 写入队列处理间隔（20ms，确保快速响应）
+
         // 定期清理机制（每小时清理一次，防止内存泄漏）
         node.cleanupTimer = setInterval(() => {
             // 清理过期的错误日志记录
@@ -805,7 +810,7 @@ module.exports = function(RED) {
                 }
 
                 if (!node.isConnected) {
-                    node.warn('轮询已停止（Modbus未连接）');
+                    node.log('轮询已停止（Modbus未连接）');
                     return;
                 }
 
@@ -817,7 +822,7 @@ module.exports = function(RED) {
                 // 获取当前从站配置（在轮询前获取，确保使用正确的间隔）
                 const currentSlave = node.config.slaves[node.currentSlaveIndex];
                 if (!currentSlave) {
-                    node.warn(`从站索引${node.currentSlaveIndex}无效，重置为0`);
+                    node.log(`从站索引${node.currentSlaveIndex}无效，重置为0`);
                     node.currentSlaveIndex = 0;
                     // 继续轮询，不要中断
                     node.pollTimer = setTimeout(pollLoop, 200);
@@ -829,8 +834,8 @@ module.exports = function(RED) {
                 try {
                     await node.pollNextSlave();
                 } catch (err) {
-                    // 捕获所有异常，防止轮询中断（降级为warn，避免日志刷屏）
-                    node.warn(`轮询异常（已忽略，继续轮询）: ${err.message}`);
+                    // 捕获所有异常，防止轮询中断（只记录到日志文件，不输出到调试窗口）
+                    node.log(`轮询异常（已忽略，继续轮询）: ${err.message}`);
                 }
 
                 // 移动到下一个从站
@@ -877,7 +882,7 @@ module.exports = function(RED) {
             // 获取当前从站配置
             const slave = node.config.slaves[node.currentSlaveIndex];
             if (!slave) {
-                node.warn(`从站索引${node.currentSlaveIndex}无效，重置为0`);
+                node.log(`从站索引${node.currentSlaveIndex}无效，重置为0`);
                 node.currentSlaveIndex = 0;
                 return;
             }
@@ -993,7 +998,7 @@ module.exports = function(RED) {
 
                 // 确保deviceState存在（防止未定义错误）
                 if (!node.deviceStates[slaveId]) {
-                    node.warn(`从站${slaveId}状态未初始化，跳过错误记录`);
+                    node.log(`从站${slaveId}状态未初始化，跳过错误记录`);
                     return;
                 }
 
@@ -1016,15 +1021,15 @@ module.exports = function(RED) {
                     // 增加超时计数（仅用于统计，不影响轮询）
                     node.deviceStates[slaveId].timeoutCount++;
 
-                    // 只记录日志，不再临时忽略从站（确保轮询永不停止）
+                    // 只记录日志到文件，不输出到调试窗口（避免日志刷屏）
                     if (shouldLog) {
-                        node.warn(`从站${slaveId}轮询超时: ${err.message} (线圈${slave.coilStart}-${slave.coilEnd}) [连续超时${node.deviceStates[slaveId].timeoutCount}次]`);
+                        node.log(`从站${slaveId}轮询超时: ${err.message} (线圈${slave.coilStart}-${slave.coilEnd}) [连续超时${node.deviceStates[slaveId].timeoutCount}次]`);
                         node.lastErrorLog[slaveId] = now;
                     }
                 } else {
-                    // 非超时错误（如CRC错误、总线干扰），记录日志但不累积计数
+                    // 非超时错误（如CRC错误、总线干扰），记录日志到文件，不输出到调试窗口
                     if (shouldLog) {
-                        node.warn(`从站${slaveId}轮询失败: ${err.message} (线圈${slave.coilStart}-${slave.coilEnd})`);
+                        node.log(`从站${slaveId}轮询失败: ${err.message} (线圈${slave.coilStart}-${slave.coilEnd})`);
                         node.lastErrorLog[slaveId] = now;
                     }
                 }
@@ -1157,33 +1162,66 @@ module.exports = function(RED) {
             }
         };
 
-        // 写单个线圈（带互斥锁和轮询暂停）
-        node.writeSingleCoil = async function(slaveId, coil, value) {
-            if (!node.isConnected) {
-                node.warn('Modbus未连接');
+        // 写入队列处理函数（串行执行所有写入操作）
+        node.processWriteQueue = async function() {
+            if (node.isProcessingWrite || node.writeQueue.length === 0) {
                 return;
             }
 
-            // 暂停轮询（写操作优先）
-            node.pausePolling = true;
-            const pauseStartTime = Date.now();
+            node.isProcessingWrite = true;
+
+            while (node.writeQueue.length > 0) {
+                const task = node.writeQueue.shift();
 
-            // 等待锁释放（最多等待1000ms，减少超时时间）
-            const maxWait = 1000;
-            const startWait = Date.now();
-            let waitCount = 0;
-            while (node.modbusLock && (Date.now() - startWait) < maxWait) {
-                await new Promise(resolve => setTimeout(resolve, 10));
-                waitCount++;
+                try {
+                    if (task.type === 'single') {
+                        await node._writeSingleCoilInternal(task.slaveId, task.coil, task.value);
+                    } else if (task.type === 'multiple') {
+                        await node._writeMultipleCoilsInternal(task.slaveId, task.startCoil, task.values);
+                    }
+
+                    // 写入成功，调用回调
+                    if (task.resolve) {
+                        task.resolve();
+                    }
+                } catch (err) {
+                    // 写入失败，调用错误回调
+                    if (task.reject) {
+                        task.reject(err);
+                    }
+                }
+
+                // 等待一段时间再处理下一个任务（20ms间隔，确保总线稳定）
+                if (node.writeQueue.length > 0) {
+                    await new Promise(resolve => setTimeout(resolve, node.writeQueueInterval));
+                }
             }
 
-            if (node.modbusLock) {
-                // 强制释放锁（避免死锁）
-                node.warn(`写入线圈等待超时(${waitCount * 10}ms)，强制释放锁: 从站${slaveId} 线圈${coil}`);
-                node.modbusLock = false;
+            node.isProcessingWrite = false;
+        };
+
+        // 写单个线圈（内部实现，不经过队列）
+        node._writeSingleCoilInternal = async function(slaveId, coil, value) {
+            if (!node.isConnected) {
+                throw new Error('Modbus未连接');
             }
-            
+
+            // 暂停轮询（写操作优先）
+            node.pausePolling = true;
+            const pauseStartTime = Date.now();
+
             try {
+                // 等待锁释放（最多等待100ms，因为有队列机制，不需要等太久）
+                const maxWait = 100;
+                const startWait = Date.now();
+                while (node.modbusLock && (Date.now() - startWait) < maxWait) {
+                    await new Promise(resolve => setTimeout(resolve, 10));
+                }
+
+                if (node.modbusLock) {
+                    throw new Error(`写入线圈等待锁超时: 从站${slaveId} 线圈${coil}`);
+                }
+
                 // 设置锁
                 node.modbusLock = true;
 
@@ -1201,7 +1239,7 @@ module.exports = function(RED) {
                 node.deviceStates[slaveId].coils[coil] = value;
 
                 node.log(`写入成功: 从站${slaveId} 线圈${coil} = ${value ? 'ON' : 'OFF'}`);
-                
+
                 // 发布到MQTT和触发事件
                 node.publishMqttState(slaveId, coil, value);
                 node.emit('stateUpdate', {
@@ -1209,11 +1247,11 @@ module.exports = function(RED) {
                     coil: coil,
                     value: value
                 });
-                
+
                 // 释放锁
                 node.modbusLock = false;
-                
-                // 延迟恢复轮询（给从站响应预留时间）
+
+                // 延迟恢复轮询（给从站响应预留时间，减少到20ms）
                 setTimeout(() => {
                     node.pausePolling = false;
                     const pauseDuration = Date.now() - pauseStartTime;
@@ -1221,56 +1259,70 @@ module.exports = function(RED) {
                         node.debug(`轮询暂停 ${pauseDuration}ms，跳过 ${node.pollingPausedCount} 次轮询`);
                         node.pollingPausedCount = 0;
                     }
-                }, 100);
-                
+                }, 20);
+
             } catch (err) {
                 // 释放锁
                 node.modbusLock = false;
-                
+
                 // 恢复轮询
                 node.pausePolling = false;
                 node.pollingPausedCount = 0;
-                
+
                 node.error(`写入线圈失败: 从站${slaveId} 线圈${coil} - ${err.message}`);
-                throw err;  // 抛出错误，让调用者知道失败
+                throw err;
             }
         };
+
+        // 写单个线圈（公共接口，通过队列执行）
+        node.writeSingleCoil = function(slaveId, coil, value) {
+            return new Promise((resolve, reject) => {
+                // 添加到队列
+                node.writeQueue.push({
+                    type: 'single',
+                    slaveId: slaveId,
+                    coil: coil,
+                    value: value,
+                    resolve: resolve,
+                    reject: reject
+                });
+
+                // 触发队列处理
+                node.processWriteQueue();
+            });
+        };
         
-        // 批量写入多个线圈（带互斥锁和轮询暂停）
-        node.writeMultipleCoils = async function(slaveId, startCoil, values) {
+        // 批量写入多个线圈（内部实现，不经过队列）
+        node._writeMultipleCoilsInternal = async function(slaveId, startCoil, values) {
             if (!node.isConnected) {
-                node.warn('Modbus未连接');
-                return;
+                throw new Error('Modbus未连接');
             }
-            
+
             // 暂停轮询（从站上报优先处理）
             node.pausePolling = true;
             const pauseStartTime = Date.now();
-            
-            // 等待锁释放（最多等待500ms）
-            const maxWait = 500;
-            const startWait = Date.now();
-            while (node.modbusLock && (Date.now() - startWait) < maxWait) {
-                await new Promise(resolve => setTimeout(resolve, 10));
-            }
-            
-            if (node.modbusLock) {
-                node.error(`批量写入线圈超时: 从站${slaveId} 起始线圈${startCoil} (等待锁释放超时)`);
-                // 恢复轮询
-                node.pausePolling = false;
-                return;
-            }
-            
+
             try {
+                // 等待锁释放（最多等待100ms）
+                const maxWait = 100;
+                const startWait = Date.now();
+                while (node.modbusLock && (Date.now() - startWait) < maxWait) {
+                    await new Promise(resolve => setTimeout(resolve, 10));
+                }
+
+                if (node.modbusLock) {
+                    throw new Error(`批量写入线圈等待锁超时: 从站${slaveId} 起始线圈${startCoil}`);
+                }
+
                 // 设置锁
                 node.modbusLock = true;
-                
+
                 node.client.setID(slaveId);
                 await node.client.writeCoils(startCoil, values);
-                
+
                 // 记录写入时间（用于暂停轮询）
                 node.lastWriteTime[slaveId] = Date.now();
-                
+
                 // 更新本地状态
                 for (let i = 0; i < values.length; i++) {
                     node.deviceStates[slaveId].coils[startCoil + i] = values[i];
@@ -1282,13 +1334,13 @@ module.exports = function(RED) {
                         value: values[i]
                     });
                 }
-                
+
                 node.debug(`批量写入成功: 从站${slaveId} 起始线圈${startCoil} 共${values.length}个线圈`);
-                
+
                 // 释放锁
                 node.modbusLock = false;
-                
-                // 延迟恢复轮询（给从站响应预留时间）
+
+                // 延迟恢复轮询（给从站响应预留时间，减少到20ms）
                 setTimeout(() => {
                     node.pausePolling = false;
                     const pauseDuration = Date.now() - pauseStartTime;
@@ -1296,20 +1348,38 @@ module.exports = function(RED) {
                         node.debug(`轮询暂停 ${pauseDuration}ms，跳过 ${node.pollingPausedCount} 次轮询`);
                         node.pollingPausedCount = 0;
                     }
-                }, 100);
-                
+                }, 20);
+
             } catch (err) {
                 // 释放锁
                 node.modbusLock = false;
-                
+
                 // 恢复轮询
                 node.pausePolling = false;
                 node.pollingPausedCount = 0;
-                
+
                 node.error(`批量写入线圈失败: 从站${slaveId} 起始线圈${startCoil} - ${err.message}`);
-                throw err; // 抛出错误，让调用者知道失败
+                throw err;
             }
         };
+
+        // 批量写入多个线圈（公共接口，通过队列执行）
+        node.writeMultipleCoils = function(slaveId, startCoil, values) {
+            return new Promise((resolve, reject) => {
+                // 添加到队列
+                node.writeQueue.push({
+                    type: 'multiple',
+                    slaveId: slaveId,
+                    startCoil: startCoil,
+                    values: values,
+                    resolve: resolve,
+                    reject: reject
+                });
+
+                // 触发队列处理
+                node.processWriteQueue();
+            });
+        };
         
         // 监听内部事件（从站开关节点发送的写入命令）
         // 这是免连线通信的核心机制

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "node-red-contrib-symi-modbus",
-  "version": "2.6.7",
-  "description": "Node-RED Modbus节点，支持TCP/串口通信、串口自动搜索、多设备轮询、可选MQTT集成（支持纯本地模式和MQTT模式）、Home Assistant自动发现和物理开关面板双向同步，工控机长期稳定运行",
+  "version": "2.7.0",
+  "description": "Node-RED Modbus节点，支持TCP/串口通信、串口自动搜索、多设备轮询、可选MQTT集成（支持纯本地模式和MQTT模式）、Home Assistant自动发现、HomeKit网桥和物理开关面板双向同步，工控机长期稳定运行",
   "main": "nodes/modbus-master.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
@@ -37,12 +37,15 @@
       "modbus-server-config": "nodes/modbus-server-config.js",
       "mqtt-server-config": "nodes/mqtt-server-config.js",
       "serial-port-config": "nodes/serial-port-config.js",
-      "modbus-debug": "nodes/modbus-debug.js"
+      "modbus-debug": "nodes/modbus-debug.js",
+      "homekit-bridge": "nodes/homekit-bridge.js"
     }
   },
   "dependencies": {
+    "hap-nodejs": "^1.2.0",
     "modbus-serial": "^8.0.23",
     "mqtt": "^5.14.1",
+    "node-persist": "^4.0.4",
     "serialport": "^12.0.0"
   },
   "repository": {