node-red-contrib-symi-modbus 2.6.8 → 2.6.9

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 = 50; // 写入队列处理间隔（50ms，确保总线稳定，避免数据丢失）
+
         // 定期清理机制（每小时清理一次，防止内存泄漏）
         node.cleanupTimer = setInterval(() => {
             // 清理过期的错误日志记录
@@ -1157,33 +1162,78 @@ 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;
+
+            // 记录队列开始处理时间
+            const queueStartTime = Date.now();
+            const queueLength = node.writeQueue.length;
+
+            while (node.writeQueue.length > 0) {
+                const task = node.writeQueue.shift();
+
+                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);
+                    }
+                    // 写入失败不中断队列，继续处理下一个任务
+                    node.warn(`队列任务失败，继续处理下一个任务: ${err.message}`);
+                }
 
-            // 等待锁释放（最多等待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++;
+                // 等待一段时间再处理下一个任务（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;
+            // 队列处理完成，输出统计信息
+            const queueDuration = Date.now() - queueStartTime;
+            if (queueLength > 1) {
+                node.debug(`写入队列处理完成：${queueLength}个任务，耗时${queueDuration}ms`);
             }
-            
+
+            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;
 
@@ -1198,10 +1248,11 @@ module.exports = function(RED) {
                 node.lastWriteTime[slaveId] = Date.now();
 
                 // 更新本地状态
+                const oldValue = node.deviceStates[slaveId].coils[coil];
                 node.deviceStates[slaveId].coils[coil] = value;
 
                 node.log(`写入成功: 从站${slaveId} 线圈${coil} = ${value ? 'ON' : 'OFF'}`);
-                
+
                 // 发布到MQTT和触发事件
                 node.publishMqttState(slaveId, coil, value);
                 node.emit('stateUpdate', {
@@ -1209,11 +1260,22 @@ module.exports = function(RED) {
                     coil: coil,
                     value: value
                 });
-                
+
+                // 只在状态真正改变时广播状态变化事件（用于LED反馈）
+                // 避免重复广播导致LED反馈死循环
+                if (oldValue !== value) {
+                    RED.events.emit('modbus:coilStateChanged', {
+                        slave: slaveId,
+                        coil: coil,
+                        value: value,
+                        source: 'write'
+                    });
+                }
+
                 // 释放锁
                 node.modbusLock = false;
-                
-                // 延迟恢复轮询（给从站响应预留时间）
+
+                // 延迟恢复轮询（给从站响应预留时间，减少到20ms）
                 setTimeout(() => {
                     node.pausePolling = false;
                     const pauseDuration = Date.now() - pauseStartTime;
@@ -1221,74 +1283,103 @@ 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];
+                    const coilIndex = startCoil + i;
+                    const oldValue = node.deviceStates[slaveId].coils[coilIndex];
+                    const newValue = values[i];
+
+                    node.deviceStates[slaveId].coils[coilIndex] = newValue;
+
                     // 发布到MQTT和触发事件
-                    node.publishMqttState(slaveId, startCoil + i, values[i]);
+                    node.publishMqttState(slaveId, coilIndex, newValue);
                     node.emit('stateUpdate', {
                         slave: slaveId,
-                        coil: startCoil + i,
-                        value: values[i]
+                        coil: coilIndex,
+                        value: newValue
                     });
+
+                    // 只在状态真正改变时广播状态变化事件（用于LED反馈）
+                    if (oldValue !== newValue) {
+                        RED.events.emit('modbus:coilStateChanged', {
+                            slave: slaveId,
+                            coil: coilIndex,
+                            value: newValue,
+                            source: 'write'
+                        });
+                    }
                 }
-                
+
                 node.debug(`批量写入成功: 从站${slaveId} 起始线圈${startCoil} 共${values.length}个线圈`);
-                
+
                 // 释放锁
                 node.modbusLock = false;
-                
-                // 延迟恢复轮询（给从站响应预留时间）
+
+                // 延迟恢复轮询（给从站响应预留时间，减少到20ms）
                 setTimeout(() => {
                     node.pausePolling = false;
                     const pauseDuration = Date.now() - pauseStartTime;
@@ -1296,20 +1387,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();
+            });
+        };
         
         // 监听内部事件（从站开关节点发送的写入命令）
         // 这是免连线通信的核心机制
@@ -1326,18 +1435,10 @@ module.exports = function(RED) {
             node.log(`收到内部事件：从站${slave} 线圈${coil} = ${value ? 'ON' : 'OFF'}`);
 
             try {
-                // 执行写入操作
+                // 执行写入操作（writeSingleCoil内部已经会广播状态变化事件）
                 await node.writeSingleCoil(slave, coil, value);
 
-                // 写入成功后，广播状态变化事件（用于LED反馈）
-                RED.events.emit('modbus:coilStateChanged', {
-                    slave: slave,
-                    coil: coil,
-                    value: value,
-                    source: 'master'
-                });
-
-                node.log(`内部事件写入成功，已广播状态变化：从站${slave} 线圈${coil} = ${value ? 'ON' : 'OFF'}`);
+                node.log(`内部事件写入成功：从站${slave} 线圈${coil} = ${value ? 'ON' : 'OFF'}`);
             } catch (err) {
                 node.error(`内部事件写入失败: 从站${slave} 线圈${coil} - ${err.message}`);
             }

package/nodes/modbus-slave-switch.html

@@ -5,15 +5,20 @@
         defaults: {
             name: {value: "从站开关"},
             // RS-485连接配置（共享配置节点）
-            serialPortConfig: {value: "", type: "serial-port-config", required: true},
+            serialPortConfig: {value: "", type: "serial-port-config", required: false},
             // MQTT配置（可选）
             enableMqtt: {value: false},  // 默认不启用MQTT
             mqttServer: {value: "", type: "mqtt-server-config", required: false},
             // 开关面板配置
             switchBrand: {value: "symi"},  // 品牌选择
-            buttonType: {value: "switch"},  // 按钮类型：switch=开关模式，scene=场景模式
+            buttonType: {value: "switch"},  // 按钮类型：switch=开关模式，scene=场景模式，mesh=Mesh模式
             switchId: {value: 0, validate: RED.validators.number()},
             buttonNumber: {value: 1, validate: RED.validators.number()},
+            // Mesh模式配置
+            meshMacAddress: {value: ""},  // Mesh设备MAC地址
+            meshShortAddress: {value: 0},  // Mesh设备短地址
+            meshButtonNumber: {value: 1, validate: RED.validators.number()},  // Mesh按键编号（1-6）
+            meshTotalButtons: {value: 1, validate: RED.validators.number()},  // Mesh开关总路数（1-6）
             // 映射到继电器
             targetSlaveAddress: {value: 10, validate: RED.validators.number()},
             targetCoilNumber: {value: 1, validate: RED.validators.number()}  // 默认值改为1（显示为1路）
@@ -22,11 +27,21 @@
         outputs: 1,
         icon: "light.png",
         label: function() {
-            // 显示时直接使用用户输入的路数（1-32）
-            const coilDisplay = this.targetCoilNumber || 1;
-            return this.name || `开关${this.switchId}-按钮${this.buttonNumber} → 继电器${this.targetSlaveAddress}-${coilDisplay}路`;
+            if (this.buttonType === 'mesh') {
+                // Mesh模式显示
+                const mac = this.meshMacAddress || '未选择';
+                const btn = this.meshButtonNumber || 1;
+                const coilDisplay = this.targetCoilNumber || 1;
+                return this.name || `Mesh[${mac}]-按钮${btn} → 继电器${this.targetSlaveAddress}-${coilDisplay}路`;
+            } else {
+                // 开关模式和场景模式显示
+                const coilDisplay = this.targetCoilNumber || 1;
+                return this.name || `开关${this.switchId}-按钮${this.buttonNumber} → 继电器${this.targetSlaveAddress}-${coilDisplay}路`;
+            }
         },
         oneditprepare: function() {
+            const node = this;
+
             // MQTT开关控制显示/隐藏
             $("#node-input-enableMqtt").on("change", function() {
                 if ($(this).is(":checked")) {
@@ -35,9 +50,139 @@
                     $(".form-row-mqtt-slave").hide();
                 }
             });
-            
+
+            // 按钮类型切换控制显示/隐藏
+            $("#node-input-buttonType").on("change", function() {
+                const buttonType = $(this).val();
+                if (buttonType === 'mesh') {
+                    // Mesh模式：显示Mesh配置，隐藏RS-485配置
+                    $(".form-row-mesh").show();
+                    $(".form-row-rs485").hide();
+                    $("#btn-discover-mesh").show();
+                } else {
+                    // 开关/场景模式：显示RS-485配置，隐藏Mesh配置
+                    $(".form-row-mesh").hide();
+                    $(".form-row-rs485").show();
+                    $("#btn-discover-mesh").hide();
+                }
+            });
+
+            // Mesh设备发现按钮
+            $("#btn-discover-mesh").on("click", function() {
+                const serialPortConfig = $("#node-input-serialPortConfig").val();
+                if (!serialPortConfig) {
+                    RED.notify("请先选择RS-485连接配置", "warning");
+                    return;
+                }
+
+                // 禁用按钮，显示加载状态
+                $(this).prop("disabled", true).html('<i class="fa fa-spinner fa-spin"></i> 正在扫描...');
+
+                // 发送设备发现请求
+                $.ajax({
+                    url: "symi-mesh/discover",
+                    type: "POST",
+                    data: JSON.stringify({
+                        serialPortConfig: serialPortConfig
+                    }),
+                    contentType: "application/json",
+                    success: function(devices) {
+                        // 更新设备列表
+                        const select = $("#node-input-meshMacAddress");
+                        select.empty();
+                        select.append('<option value="">请选择Mesh开关</option>');
+
+                        devices.forEach(function(device) {
+                            if (device.type === 0x01 && device.buttons > 0) {
+                                // 只显示开关类型设备
+                                const mac = device.mac;
+                                const label = `${mac} (${device.buttons}路开关)`;
+                                select.append(`<option value="${mac}" data-short-addr="${device.shortAddr}" data-buttons="${device.buttons}">${label}</option>`);
+                            }
+                        });
+
+                        RED.notify(`发现 ${devices.length} 个Mesh设备`, "success");
+                        $("#btn-discover-mesh").prop("disabled", false).html('<i class="fa fa-search"></i> 扫描设备');
+                    },
+                    error: function(xhr, status, error) {
+                        RED.notify("设备发现失败: " + error, "error");
+                        $("#btn-discover-mesh").prop("disabled", false).html('<i class="fa fa-search"></i> 扫描设备');
+                    }
+                });
+            });
+
+            // Mesh设备选择变化时更新短地址和按钮数
+            $("#node-input-meshMacAddress").on("change", function() {
+                const selected = $(this).find("option:selected");
+                const shortAddr = selected.data("short-addr");
+                const buttons = selected.data("buttons");
+
+                if (shortAddr !== undefined) {
+                    $("#node-input-meshShortAddress").val(shortAddr);
+                    $("#node-input-meshTotalButtons").val(buttons);
+
+                    // 更新按钮编号选项
+                    const btnSelect = $("#node-input-meshButtonNumber");
+                    btnSelect.empty();
+                    for (let i = 1; i <= buttons; i++) {
+                        btnSelect.append(`<option value="${i}">按钮 ${i}</option>`);
+                    }
+                }
+            });
+
+            // 加载已保存的Mesh设备列表
+            function loadSavedMeshDevices() {
+                $.ajax({
+                    url: "symi-mesh/devices",
+                    type: "GET",
+                    success: function(devices) {
+                        if (devices && devices.length > 0) {
+                            const select = $("#node-input-meshMacAddress");
+                            select.empty();
+                            select.append('<option value="">请选择Mesh开关</option>');
+
+                            devices.forEach(function(device) {
+                                if (device.type === 0x01 && device.buttons > 0) {
+                                    const mac = device.mac;
+                                    const label = `${mac} (${device.buttons}路开关)`;
+                                    const option = $(`<option value="${mac}" data-short-addr="${device.shortAddr}" data-buttons="${device.buttons}">${label}</option>`);
+                                    select.append(option);
+
+                                    // 如果是当前配置的设备，选中它
+                                    if (mac === node.meshMacAddress) {
+                                        option.prop("selected", true);
+                                        $("#node-input-meshShortAddress").val(device.shortAddr);
+                                        $("#node-input-meshTotalButtons").val(device.buttons);
+
+                                        // 更新按钮编号选项
+                                        const btnSelect = $("#node-input-meshButtonNumber");
+                                        btnSelect.empty();
+                                        for (let i = 1; i <= device.buttons; i++) {
+                                            const btnOption = $(`<option value="${i}">按钮 ${i}</option>`);
+                                            if (i === node.meshButtonNumber) {
+                                                btnOption.prop("selected", true);
+                                            }
+                                            btnSelect.append(btnOption);
+                                        }
+                                    }
+                                }
+                            });
+                        }
+                    },
+                    error: function(xhr, status, error) {
+                        console.log("加载Mesh设备列表失败: " + error);
+                    }
+                });
+            }
+
             // 初始化显示状态
             $("#node-input-enableMqtt").trigger("change");
+            $("#node-input-buttonType").trigger("change");
+
+            // 如果是Mesh模式，加载已保存的设备列表
+            if (node.buttonType === 'mesh') {
+                loadSavedMeshDevices();
+            }
         }
     });
 </script>
@@ -119,16 +264,19 @@
     <div class="form-row">
         <label for="node-input-buttonType" style="width: 110px;"><i class="fa fa-cog"></i> 按钮类型</label>
         <select id="node-input-buttonType" style="width: 200px;">
-            <option value="switch">开关按钮</option>
-            <option value="scene">场景按钮</option>
+            <option value="switch">开关按钮（RS-485）</option>
+            <option value="scene">场景按钮（RS-485）</option>
+            <option value="mesh">Mesh开关（蓝牙Mesh）</option>
         </select>
         <div style="font-size: 11px; color: #888; margin-left: 110px; margin-top: 3px;">
-            <strong>开关按钮</strong>：灯光、插座等开关控制，有开/关状态<br>
-            <strong>场景按钮</strong>：场景触发、一键全开/全关等，只触发动作
+            <strong>开关按钮</strong>：RS-485开关，有开/关状态<br>
+            <strong>场景按钮</strong>：RS-485场景触发<br>
+            <strong>Mesh开关</strong>：蓝牙Mesh开关（1-6路）
         </div>
     </div>
 
-    <div class="form-row">
+    <!-- RS-485模式配置 -->
+    <div class="form-row form-row-rs485">
         <label for="node-input-switchId" style="width: 110px;"><i class="fa fa-id-card"></i> 开关ID</label>
         <input type="number" id="node-input-switchId" placeholder="0" min="0" max="255" style="width: 90px; padding: 5px 8px; border: 1px solid #ccc; border-radius: 4px; font-size: 13px;">
         <span style="margin-left: 10px; color: #666; font-size: 12px;">物理面板地址：<strong>0-255</strong></span>
@@ -137,7 +285,7 @@
         </div>
     </div>
 
-    <div class="form-row">
+    <div class="form-row form-row-rs485">
         <label for="node-input-buttonNumber" style="width: 110px;"><i class="fa fa-hand-pointer-o"></i> 按钮编号</label>
         <select id="node-input-buttonNumber" style="width: 150px;">
             <option value="1">按钮 1</option>
@@ -151,6 +299,42 @@
         </select>
         <span style="margin-left: 10px; font-size: 11px; color: #666; font-style: italic;">面板物理按键</span>
     </div>
+
+    <!-- Mesh模式配置 -->
+    <div class="form-row form-row-mesh" style="display: none;">
+        <button type="button" id="btn-discover-mesh" class="red-ui-button" style="margin-left: 110px;">
+            <i class="fa fa-search"></i> 扫描设备
+        </button>
+        <div style="font-size: 11px; color: #888; margin-left: 110px; margin-top: 5px;">
+            点击扫描按钮自动发现Mesh网关中的所有开关设备
+        </div>
+    </div>
+
+    <div class="form-row form-row-mesh" style="display: none;">
+        <label for="node-input-meshMacAddress" style="width: 110px;"><i class="fa fa-bluetooth"></i> Mesh设备</label>
+        <select id="node-input-meshMacAddress" style="width: 300px;">
+            <option value="">请选择Mesh开关</option>
+        </select>
+        <div style="font-size: 11px; color: #888; margin-left: 110px; margin-top: 3px;">
+            选择要控制的Mesh开关设备（MAC地址）
+        </div>
+    </div>
+
+    <div class="form-row form-row-mesh" style="display: none;">
+        <label for="node-input-meshButtonNumber" style="width: 110px;"><i class="fa fa-hand-pointer-o"></i> 按钮编号</label>
+        <select id="node-input-meshButtonNumber" style="width: 150px;">
+            <option value="1">按钮 1</option>
+            <option value="2">按钮 2</option>
+            <option value="3">按钮 3</option>
+            <option value="4">按钮 4</option>
+            <option value="5">按钮 5</option>
+            <option value="6">按钮 6</option>
+        </select>
+        <span style="margin-left: 10px; font-size: 11px; color: #666; font-style: italic;">Mesh开关按键（1-6路）</span>
+    </div>
+
+    <input type="hidden" id="node-input-meshShortAddress">
+    <input type="hidden" id="node-input-meshTotalButtons">
     
     <!-- 映射到继电器配置 -->
     <hr style="margin: 15px 0; border: 0; border-top: 2px solid #e0e0e0;">