node-red-contrib-symi-modbus 2.7.4 → 2.7.6

package/nodes/mesh-protocol.js

@@ -0,0 +1,286 @@
+// Symi蓝牙Mesh网关协议处理模块
+// 协议版本: V1.3.1
+// 支持TCP/IP和串口通信
+
+module.exports = function(RED) {
+    'use strict';
+
+    // 协议常量
+    const PROTOCOL = {
+        HEADER: 0x53,
+        // 操作码
+        OP_GET_DEVICE_LIST: 0x12,
+        OP_DEVICE_CONTROL: 0x30,
+        OP_QUERY_STATUS: 0x32,
+        OP_SCENE_CONTROL: 0x34,
+        OP_STATUS_EVENT: 0x80,
+        OP_DEVICE_LIST_RESPONSE: 0x92,
+        OP_CONTROL_RESPONSE: 0xB0,
+        OP_SCENE_RESPONSE: 0xB4,
+        // 消息类型
+        MSG_TYPE_SWITCH: 0x02,      // 开关状态（1-4路）
+        MSG_TYPE_DIMMER: 0x03,      // 调光状态
+        MSG_TYPE_RGB: 0x04,         // 五色调光
+        MSG_TYPE_CURTAIN: 0x05,     // 窗帘动作
+        MSG_TYPE_CURTAIN_POS: 0x06, // 窗帘位置
+        MSG_TYPE_THERMOSTAT: 0x07,  // 温控器
+        MSG_TYPE_SWITCH_6: 0x45,    // 6路开关状态
+        // 设备类型
+        DEVICE_TYPE_SWITCH: 0x01,
+        DEVICE_TYPE_DIMMER: 0x02,
+        DEVICE_TYPE_DUAL_COLOR: 0x04,
+        DEVICE_TYPE_CURTAIN: 0x05,
+        DEVICE_TYPE_CARD_POWER: 0x09,
+        DEVICE_TYPE_THERMOSTAT: 0x0A,
+        DEVICE_TYPE_PIR: 0x0C,
+        DEVICE_TYPE_RGB: 0x18,
+        DEVICE_TYPE_THERMOSTAT_3IN1: 0x94
+    };
+
+    // 计算异或校验和
+    function calculateChecksum(buffer) {
+        let checksum = 0;
+        for (let i = 0; i < buffer.length; i++) {
+            checksum ^= buffer[i];
+        }
+        return checksum;
+    }
+
+    // 构建获取设备列表请求帧
+    function buildGetDeviceListFrame() {
+        const buffer = Buffer.from([
+            PROTOCOL.HEADER,           // 0x53
+            PROTOCOL.OP_GET_DEVICE_LIST, // 0x12
+            0x00                       // Length = 0
+        ]);
+        const checksum = calculateChecksum(buffer);
+        return Buffer.concat([buffer, Buffer.from([checksum])]);
+    }
+
+    // 解析设备列表响应
+    function parseDeviceListResponse(frames) {
+        const devices = [];
+        
+        for (let i = 0; i < frames.length; i++) {
+            const frame = frames[i];
+            
+            // 验证帧头
+            if (frame[0] !== PROTOCOL.HEADER || frame[1] !== PROTOCOL.OP_DEVICE_LIST_RESPONSE) {
+                continue;
+            }
+            
+            const sequence = frame[2];
+            const length = frame[3];
+            
+            if (sequence === 0x00) {
+                // 第一帧：设备总数
+                const totalDevices = frame[4];
+                continue;
+            }
+            
+            // 解析设备数据
+            let offset = 4;
+            while (offset + 10 <= frame.length - 1) {
+                const shortAddr = frame[offset] | (frame[offset + 1] << 8); // 小端序
+                const deviceType = frame[offset + 2];
+                const mac = Buffer.from([
+                    frame[offset + 3],
+                    frame[offset + 4],
+                    frame[offset + 5],
+                    frame[offset + 6],
+                    frame[offset + 7],
+                    frame[offset + 8]
+                ]);
+                const buttons = frame[offset + 9];
+                
+                devices.push({
+                    shortAddr: shortAddr,
+                    type: deviceType,
+                    mac: mac.toString('hex').toUpperCase().match(/.{2}/g).join(':'),
+                    buttons: buttons
+                });
+                
+                offset += 10;
+            }
+        }
+        
+        return devices;
+    }
+
+    // 构建开关控制帧（带当前状态，保持其他路不变）
+    function buildSwitchControlFrame(shortAddr, buttonNumber, totalButtons, state, currentStates) {
+        let stateValue;
+
+        if (totalButtons === 1) {
+            // 单路开关
+            stateValue = state ? 0x02 : 0x01;
+            const buffer = Buffer.from([
+                PROTOCOL.HEADER,
+                PROTOCOL.OP_DEVICE_CONTROL,
+                0x05,  // Length
+                shortAddr & 0xFF,
+                (shortAddr >> 8) & 0xFF,
+                0x00,  // ACK = 0
+                0x05,  // 重传5次
+                PROTOCOL.MSG_TYPE_SWITCH,
+                stateValue
+            ]);
+            const checksum = calculateChecksum(buffer);
+            return Buffer.concat([buffer, Buffer.from([checksum])]);
+        } else if (totalButtons >= 2 && totalButtons <= 4) {
+            // 2-4路开关：使用当前状态构建完整状态值
+            if (currentStates && currentStates.length === totalButtons) {
+                stateValue = buildMultiSwitchState(currentStates, buttonNumber, state);
+            } else {
+                // 如果没有当前状态，只设置目标按钮，其他位设为00（保持不变）
+                const bitPos = (buttonNumber - 1) * 2;
+                stateValue = (state ? 0x02 : 0x01) << bitPos;
+            }
+
+            const buffer = Buffer.from([
+                PROTOCOL.HEADER,
+                PROTOCOL.OP_DEVICE_CONTROL,
+                0x05,  // Length
+                shortAddr & 0xFF,
+                (shortAddr >> 8) & 0xFF,
+                0x00,  // ACK = 0
+                0x05,  // 重传5次
+                PROTOCOL.MSG_TYPE_SWITCH,
+                stateValue
+            ]);
+            const checksum = calculateChecksum(buffer);
+            return Buffer.concat([buffer, Buffer.from([checksum])]);
+        } else if (totalButtons === 6) {
+            // 6路开关：2字节状态值（小端序）
+            let stateValue16;
+            if (currentStates && currentStates.length === totalButtons) {
+                stateValue16 = buildMultiSwitchState(currentStates, buttonNumber, state);
+            } else {
+                // 如果没有当前状态，只设置目标按钮，其他位设为00（保持不变）
+                const bitPos = (buttonNumber - 1) * 2;
+                stateValue16 = (state ? 0x02 : 0x01) << bitPos;
+            }
+
+            const buffer = Buffer.from([
+                PROTOCOL.HEADER,
+                PROTOCOL.OP_DEVICE_CONTROL,
+                0x06,  // Length
+                shortAddr & 0xFF,
+                (shortAddr >> 8) & 0xFF,
+                0x00,  // ACK = 0
+                0x05,  // 重传5次
+                PROTOCOL.MSG_TYPE_SWITCH,
+                stateValue16 & 0xFF,
+                (stateValue16 >> 8) & 0xFF
+            ]);
+            const checksum = calculateChecksum(buffer);
+            return Buffer.concat([buffer, Buffer.from([checksum])]);
+        }
+
+        return null;
+    }
+
+    // 解析状态事件帧
+    function parseStatusEvent(frame) {
+        // 验证帧头
+        if (frame[0] !== PROTOCOL.HEADER || frame[1] !== PROTOCOL.OP_STATUS_EVENT) {
+            return null;
+        }
+
+        const subOp = frame[2];
+        const length = frame[3];
+        const shortAddr = frame[4] | (frame[5] << 8); // 小端序
+        const msgType = frame[6];
+
+        const event = {
+            subOp: subOp,
+            shortAddr: shortAddr,
+            msgType: msgType
+        };
+
+        // 根据消息类型解析状态
+        if (msgType === PROTOCOL.MSG_TYPE_SWITCH) {
+            // 1-4路开关状态
+            const stateValue = frame[7];
+            event.states = parseMultiSwitchState(stateValue, 4);
+        } else if (msgType === PROTOCOL.MSG_TYPE_SWITCH_6) {
+            // 6路开关状态
+            const stateLow = frame[7];
+            const stateHigh = frame[8];
+            const stateValue = stateLow | (stateHigh << 8);
+            event.states = parseMultiSwitchState(stateValue, 6);
+        } else if (msgType === PROTOCOL.MSG_TYPE_DIMMER) {
+            // 调光灯状态
+            event.brightness = frame[7];
+            event.colorTemp = frame[8];
+        } else if (msgType === PROTOCOL.MSG_TYPE_CURTAIN) {
+            // 窗帘动作状态
+            event.action = frame[7]; // 0=停止, 1=打开中, 2=关闭中
+        } else if (msgType === PROTOCOL.MSG_TYPE_CURTAIN_POS) {
+            // 窗帘位置状态
+            event.position = frame[7]; // 0-100%
+        }
+
+        return event;
+    }
+
+    // 解析多路开关状态值
+    function parseMultiSwitchState(stateValue, totalButtons) {
+        const states = [];
+
+        for (let i = 0; i < totalButtons; i++) {
+            const bitPos = i * 2;
+            const bits = (stateValue >> bitPos) & 0x03;
+
+            if (bits === 0x01) {
+                states.push(false); // 关
+            } else if (bits === 0x02) {
+                states.push(true);  // 开
+            } else {
+                states.push(null);  // 保持不变或未知
+            }
+        }
+
+        return states;
+    }
+
+    // 构建多路开关状态值（用于控制时保持其他路不变）
+    function buildMultiSwitchState(currentStates, buttonNumber, newState) {
+        let stateValue = 0;
+
+        for (let i = 0; i < currentStates.length; i++) {
+            const bitPos = i * 2;
+            let bits;
+
+            if (i === buttonNumber - 1) {
+                // 要改变的按钮
+                bits = newState ? 0x02 : 0x01;
+            } else {
+                // 保持不变的按钮
+                if (currentStates[i] === true) {
+                    bits = 0x02;
+                } else if (currentStates[i] === false) {
+                    bits = 0x01;
+                } else {
+                    bits = 0x00; // 保持不变
+                }
+            }
+
+            stateValue |= (bits << bitPos);
+        }
+
+        return stateValue;
+    }
+
+    return {
+        PROTOCOL,
+        calculateChecksum,
+        buildGetDeviceListFrame,
+        parseDeviceListResponse,
+        buildSwitchControlFrame,
+        parseStatusEvent,
+        parseMultiSwitchState,
+        buildMultiSwitchState
+    };
+};
+

package/nodes/modbus-dashboard.html

@@ -16,6 +16,7 @@
             var node = this;
             var stateCache = {}; // 缓存所有线圈状态
             var relayNamesCache = {}; // 缓存继电器名称
+            var pollInterval = null; // 轮询定时器（全局变量，用于清理）
 
             // 填充主站节点选择器
             var masterNodeSelect = $("#node-input-masterNode");
@@ -62,17 +63,27 @@
                     return;
                 }
 
-                var masterNode = RED.nodes.node(masterNodeId);
-                if (!masterNode || !masterNode.slaves || masterNode.slaves.length === 0) {
-                    container.html('<div style="padding: 40px; text-align: center; color: #999; font-size: 14px;">主站节点未配置从站</div>');
-                    return;
-                }
+                // 显示加载中
+                container.html('<div style="padding: 40px; text-align: center; color: #999; font-size: 14px;"><i class="fa fa-spinner fa-spin"></i> 加载中...</div>');
+
+                // 通过HTTP API获取主站节点的最新配置
+                $.ajax({
+                    url: '/modbus-dashboard/master-config/' + masterNodeId,
+                    method: 'GET',
+                    success: function(masterConfig) {
+                        if (!masterConfig || !masterConfig.slaves || masterConfig.slaves.length === 0) {
+                            container.html('<div style="padding: 40px; text-align: center; color: #999; font-size: 14px;">主站节点未配置从站</div>');
+                            return;
+                        }
+
+                        // 加载继电器名称
+                        loadRelayNames();
 
-                // 加载继电器名称
-                loadRelayNames();
+                        // 清空容器
+                        container.empty();
 
-                // 遍历所有从站
-                masterNode.slaves.forEach(function(slave) {
+                        // 遍历所有从站
+                        masterConfig.slaves.forEach(function(slave) {
                     var slaveSection = $('<div class="slave-section">');
                     
                     var slaveHeader = $(`
@@ -113,20 +124,25 @@
                     container.append(slaveSection);
                 });
 
-                // 绑定按钮点击事件
-                $(".btn-toggle").off("click").on("click", function() {
-                    var slaveAddr = parseInt($(this).data("slave"));
-                    var coil = parseInt($(this).data("coil"));
-                    var key = slaveAddr + "_" + coil;
-                    var currentState = stateCache[key] || false;
-                    var newState = !currentState;
-                    
-                    // 发送控制命令（通过HTTP API）
-                    sendControlCommand(slaveAddr, coil, newState);
-                    
-                    // 立即更新UI（乐观更新）
-                    stateCache[key] = newState;
-                    updateButtonState($(this), newState);
+                        // 绑定按钮点击事件
+                        $(".btn-toggle").off("click").on("click", function() {
+                            var slaveAddr = parseInt($(this).data("slave"));
+                            var coil = parseInt($(this).data("coil"));
+                            var key = slaveAddr + "_" + coil;
+                            var currentState = stateCache[key] || false;
+                            var newState = !currentState;
+
+                            // 发送控制命令（通过HTTP API）
+                            sendControlCommand(slaveAddr, coil, newState);
+
+                            // 立即更新UI（乐观更新）
+                            stateCache[key] = newState;
+                            updateButtonState($(this), newState);
+                        });
+                    },
+                    error: function(xhr, status, error) {
+                        container.html('<div style="padding: 40px; text-align: center; color: #f44336; font-size: 14px;"><i class="fa fa-exclamation-triangle"></i> 加载失败: ' + error + '</div>');
+                    }
                 });
             }
 
@@ -164,7 +180,6 @@
             }
 
             // 轮询状态更新（每500ms）
-            var pollInterval = null;
             function startPolling() {
                 if (pollInterval) {
                     clearInterval(pollInterval);
@@ -222,6 +237,15 @@
                 }
             });
 
+            // 添加刷新按钮
+            $("#btn-refresh-dashboard").on("click", function() {
+                stopPolling();
+                renderDashboard();
+                if (masterNodeSelect.val()) {
+                    startPolling();
+                }
+            });
+
             // 初始渲染
             renderDashboard();
             if (node.masterNode) {
@@ -232,6 +256,27 @@
             $("#node-dialog-cancel, #node-dialog-ok").on("click", function() {
                 stopPolling();
             });
+        },
+        oneditcancel: function() {
+            // 取消编辑时停止轮询，防止内存泄漏
+            if (pollInterval) {
+                clearInterval(pollInterval);
+                pollInterval = null;
+            }
+        },
+        oneditsave: function() {
+            // 保存时停止轮询，防止内存泄漏
+            if (pollInterval) {
+                clearInterval(pollInterval);
+                pollInterval = null;
+            }
+        },
+        oneditdelete: function() {
+            // 删除节点时停止轮询，防止内存泄漏
+            if (pollInterval) {
+                clearInterval(pollInterval);
+                pollInterval = null;
+            }
         }
     });
 </script>
@@ -244,10 +289,13 @@
 
     <div class="form-row">
         <label for="node-input-masterNode"><i class="fa fa-microchip"></i> 主站节点</label>
-        <select id="node-input-masterNode" style="width: 70%;">
+        <select id="node-input-masterNode" style="width: 55%;">
             <option value="">请选择主站节点</option>
         </select>
-        <div style="font-size: 11px; color: #999; margin-top: 5px;">选择要监控的Modbus主站节点</div>
+        <button type="button" id="btn-refresh-dashboard" class="red-ui-button" style="margin-left: 5px;">
+            <i class="fa fa-refresh"></i> 刷新
+        </button>
+        <div style="font-size: 11px; color: #999; margin-top: 5px;">选择要监控的Modbus主站节点，点击刷新按钮更新显示</div>
     </div>
 
     <div class="form-row" style="margin-top: 20px;">
@@ -255,7 +303,7 @@
             <i class="fa fa-dashboard"></i> 控制面板
         </label>
         <div id="dashboard-container" style="
-            max-height: 500px;
+            max-height: 700px;
             overflow-y: auto;
             border: 1px solid #ddd;
             border-radius: 4px;

package/nodes/modbus-dashboard.js

@@ -62,6 +62,23 @@ module.exports = function(RED) {
 
     RED.nodes.registerType("modbus-dashboard", ModbusDashboardNode);
 
+    // HTTP API：获取主站节点配置
+    RED.httpAdmin.get('/modbus-dashboard/master-config/:id', function(req, res) {
+        var masterNodeId = req.params.id;
+        var masterNode = RED.nodes.getNode(masterNodeId);
+
+        if (!masterNode) {
+            res.status(404).json({error: '主站节点不存在'});
+            return;
+        }
+
+        // 返回主站配置（包括最新的从站列表）
+        res.json({
+            slaves: masterNode.slaves || [],
+            relayNames: masterNode.relayNames || {}
+        });
+    });
+
     // HTTP API：获取状态
     RED.httpAdmin.get('/modbus-dashboard/state', function(req, res) {
         res.json({

package/nodes/modbus-master.js

@@ -1170,6 +1170,10 @@ module.exports = function(RED) {
 
             node.isProcessingWrite = true;
 
+            // 记录队列开始处理时间
+            const queueStartTime = Date.now();
+            const queueLength = node.writeQueue.length;
+
             while (node.writeQueue.length > 0) {
                 const task = node.writeQueue.shift();
 
@@ -1189,6 +1193,8 @@ module.exports = function(RED) {
                     if (task.reject) {
                         task.reject(err);
                     }
+                    // 写入失败不中断队列，继续处理下一个任务
+                    node.warn(`队列任务失败，继续处理下一个任务: ${err.message}`);
                 }
 
                 // 等待一段时间再处理下一个任务（20ms间隔，确保总线稳定）
@@ -1197,6 +1203,12 @@ module.exports = function(RED) {
                 }
             }
 
+            // 队列处理完成，输出统计信息
+            const queueDuration = Date.now() - queueStartTime;
+            if (queueLength > 1) {
+                node.debug(`写入队列处理完成：${queueLength}个任务，耗时${queueDuration}ms`);
+            }
+
             node.isProcessingWrite = false;
         };
 
@@ -1236,6 +1248,7 @@ 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'}`);
@@ -1248,6 +1261,17 @@ module.exports = function(RED) {
                     value: value
                 });
 
+                // 只在状态真正改变时广播状态变化事件（用于LED反馈）
+                // 避免重复广播导致LED反馈死循环
+                if (oldValue !== value) {
+                    RED.events.emit('modbus:coilStateChanged', {
+                        slave: slaveId,
+                        coil: coil,
+                        value: value,
+                        source: 'write'
+                    });
+                }
+
                 // 释放锁
                 node.modbusLock = false;
 
@@ -1325,14 +1349,29 @@ module.exports = function(RED) {
 
                 // 更新本地状态
                 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}个线圈`);
@@ -1396,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}`);
             }