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

package/nodes/custom-protocol.js

@@ -0,0 +1,201 @@
+module.exports = function(RED) {
+    "use strict";
+
+    function CustomProtocolNode(config) {
+        RED.nodes.createNode(this, config);
+        var node = this;
+
+        // 配置
+        node.config = {
+            name: config.name || "自定义协议",
+            deviceType: config.deviceType || "switch",
+            serialConfig: config.serialConfig,
+            openCmd: config.openCmd || "",
+            closeCmd: config.closeCmd || "",
+            pauseCmd: config.pauseCmd || ""
+        };
+
+        // 窗帘模式的状态索引（0=打开, 1=关闭, 2=暂停）
+        node.curtainStateIndex = 0;
+
+        // 获取串口配置节点
+        var serialNode = RED.nodes.getNode(node.config.serialConfig);
+        if (!serialNode) {
+            node.error('未找到串口配置节点');
+            node.status({fill: "red", shape: "ring", text: "未配置串口"});
+            return;
+        }
+
+        // 16进制字符串转Buffer
+        function hexStringToBuffer(hexString) {
+            if (!hexString || hexString.trim() === '') {
+                return null;
+            }
+            
+            try {
+                // 移除空格和非16进制字符
+                var hex = hexString.replace(/\s+/g, '').replace(/[^0-9A-Fa-f]/g, '');
+                
+                // 确保是偶数长度
+                if (hex.length % 2 !== 0) {
+                    node.warn('16进制字符串长度必须为偶数: ' + hexString);
+                    return null;
+                }
+                
+                // 限制48字节
+                if (hex.length > 96) {
+                    hex = hex.substring(0, 96);
+                    node.warn('指令长度超过48字节，已截断');
+                }
+                
+                // 转换为Buffer
+                var buffer = Buffer.from(hex, 'hex');
+                return buffer;
+            } catch (err) {
+                node.error('16进制字符串转换失败: ' + err.message);
+                return null;
+            }
+        }
+
+        // 发送指令到串口
+        function sendCommand(buffer, cmdName) {
+            if (!buffer) {
+                node.warn('指令为空，跳过发送');
+                return;
+            }
+
+            // 输出消息（可连线到debug节点）
+            var msg = {
+                payload: buffer,
+                topic: 'custom-protocol',
+                command: cmdName
+            };
+            
+            node.send(msg);
+            node.status({fill: "green", shape: "dot", text: cmdName + " (" + buffer.length + "字节)"});
+            
+            // 3秒后清除状态
+            setTimeout(function() {
+                node.status({fill: "blue", shape: "ring", text: "就绪"});
+            }, 3000);
+        }
+
+        // 处理输入消息
+        node.on('input', function(msg) {
+            var value = msg.payload;
+            
+            // 只接受布尔值
+            if (typeof value !== 'boolean') {
+                node.warn('输入必须为true/false，当前类型: ' + typeof value);
+                return;
+            }
+
+            if (node.config.deviceType === 'curtain') {
+                // 窗帘模式：true/false交替触发，循环发送三个指令
+                var commands = [
+                    {name: '打开', hex: node.config.openCmd},
+                    {name: '关闭', hex: node.config.closeCmd},
+                    {name: '暂停', hex: node.config.pauseCmd}
+                ];
+                
+                // 获取当前指令
+                var currentCmd = commands[node.curtainStateIndex];
+                if (!currentCmd || !currentCmd.hex) {
+                    node.warn('窗帘模式缺少' + currentCmd.name + '指令配置');
+                    return;
+                }
+                
+                // 转换并发送
+                var buffer = hexStringToBuffer(currentCmd.hex);
+                if (buffer) {
+                    sendCommand(buffer, currentCmd.name);
+                    
+                    // 移动到下一个状态
+                    node.curtainStateIndex = (node.curtainStateIndex + 1) % 3;
+                }
+            } else {
+                // 开关/其他模式：true发送打开，false发送关闭
+                var cmdName = value ? '打开' : '关闭';
+                var hexString = value ? node.config.openCmd : node.config.closeCmd;
+                
+                if (!hexString) {
+                    node.warn(cmdName + '指令未配置');
+                    return;
+                }
+                
+                var buffer = hexStringToBuffer(hexString);
+                if (buffer) {
+                    sendCommand(buffer, cmdName);
+                }
+            }
+        });
+
+        // 初始状态
+        var typeNames = {
+            'switch': '开关',
+            'curtain': '窗帘',
+            'other': '其他'
+        };
+        var typeName = typeNames[node.config.deviceType] || '自定义';
+        node.status({fill: "blue", shape: "ring", text: typeName + "模式就绪"});
+
+        // 清理
+        node.on('close', function() {
+            node.status({});
+        });
+    }
+
+    RED.nodes.registerType("custom-protocol", CustomProtocolNode);
+
+    // HTTP API：测试发送指令
+    RED.httpAdmin.post('/custom-protocol/test', function(req, res) {
+        var serialConfigId = req.body.serialConfig;
+        var hexString = req.body.hexString;
+        var cmdName = req.body.cmdName;
+
+        if (!serialConfigId || !hexString) {
+            res.status(400).json({success: false, error: '参数错误'});
+            return;
+        }
+
+        // 获取串口配置节点
+        var serialNode = RED.nodes.getNode(serialConfigId);
+        if (!serialNode) {
+            res.status(404).json({success: false, error: '未找到串口配置节点'});
+            return;
+        }
+
+        try {
+            // 转换16进制字符串为Buffer
+            var hex = hexString.replace(/\s+/g, '').replace(/[^0-9A-Fa-f]/g, '');
+            if (hex.length % 2 !== 0) {
+                res.status(400).json({success: false, error: '16进制字符串长度必须为偶数'});
+                return;
+            }
+            if (hex.length > 96) {
+                hex = hex.substring(0, 96);
+            }
+            var buffer = Buffer.from(hex, 'hex');
+
+            // 发送到串口
+            if (serialNode.serialPort && serialNode.serialPort.isOpen) {
+                serialNode.serialPort.write(buffer, function(err) {
+                    if (err) {
+                        res.json({success: false, error: err.message});
+                    } else {
+                        res.json({
+                            success: true,
+                            message: cmdName + '指令已发送',
+                            bytes: buffer.length
+                        });
+                    }
+                });
+            } else {
+                res.status(503).json({success: false, error: '串口未打开'});
+            }
+        } catch (err) {
+            res.status(500).json({success: false, error: err.message});
+        }
+    });
+};
+

package/nodes/modbus-dashboard.html

@@ -0,0 +1,396 @@
+<script type="text/javascript">
+    RED.nodes.registerType('modbus-dashboard', {
+        category: 'SYMI-MODBUS',
+        color: '#4CAF50',
+        defaults: {
+            name: {value: "Modbus控制看板"},
+            masterNode: {value: "", required: true}
+        },
+        inputs: 0,
+        outputs: 0,
+        icon: "font-awesome/fa-dashboard",
+        label: function() {
+            return this.name || "Modbus控制看板";
+        },
+        oneditprepare: function() {
+            var node = this;
+            var stateCache = {}; // 缓存所有线圈状态
+            var relayNamesCache = {}; // 缓存继电器名称
+
+            // 填充主站节点选择器
+            var masterNodeSelect = $("#node-input-masterNode");
+            masterNodeSelect.empty();
+            masterNodeSelect.append('<option value="">请选择主站节点</option>');
+
+            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>`);
+                }
+            });
+
+            // 加载HomeKit网桥的名称配置
+            function loadRelayNames() {
+                RED.nodes.eachNode(function(n) {
+                    if (n.type === "homekit-bridge" && n.masterNode === node.masterNode) {
+                        if (n.relayNames) {
+                            relayNamesCache = Object.assign({}, n.relayNames);
+                        }
+                    }
+                });
+            }
+
+            // 获取继电器名称
+            function getRelayName(slaveAddr, coil) {
+                var key = slaveAddr + "_" + coil;
+                if (relayNamesCache[key]) {
+                    return relayNamesCache[key];
+                }
+                var relayType = coil < 16 ? "开关" : "插座";
+                return `${relayType}${coil + 1}`;
+            }
+
+            // 渲染控制面板
+            function renderDashboard() {
+                var masterNodeId = $("#node-input-masterNode").val();
+                var container = $("#dashboard-container");
+                container.empty();
+
+                if (!masterNodeId) {
+                    container.html('<div style="padding: 40px; text-align: center; color: #999; font-size: 14px;">请先选择主站节点</div>');
+                    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;
+                }
+
+                // 加载继电器名称
+                loadRelayNames();
+
+                // 遍历所有从站
+                masterNode.slaves.forEach(function(slave) {
+                    var slaveSection = $('<div class="slave-section">');
+                    
+                    var slaveHeader = $(`
+                        <div class="slave-header">
+                            <span class="slave-title">从站 ${slave.address}</span>
+                            <span class="slave-info">线圈 ${slave.coilStart}-${slave.coilEnd}</span>
+                        </div>
+                    `);
+                    
+                    var coilGrid = $('<div class="coil-grid">');
+                    
+                    for (var coil = slave.coilStart; coil <= slave.coilEnd; coil++) {
+                        var key = slave.address + "_" + coil;
+                        var relayName = getRelayName(slave.address, coil);
+                        var currentState = stateCache[key] || false;
+                        var stateClass = currentState ? 'state-on' : 'state-off';
+                        var stateText = currentState ? 'ON' : 'OFF';
+                        
+                        var coilItem = $(`
+                            <div class="coil-item">
+                                <div class="coil-header">
+                                    <span class="coil-name" title="${relayName}">${relayName}</span>
+                                    <span class="coil-number">线圈${coil}</span>
+                                </div>
+                                <div class="coil-control">
+                                    <button class="btn-toggle ${stateClass}" data-slave="${slave.address}" data-coil="${coil}">
+                                        <span class="state-text">${stateText}</span>
+                                    </button>
+                                </div>
+                            </div>
+                        `);
+                        
+                        coilGrid.append(coilItem);
+                    }
+                    
+                    slaveSection.append(slaveHeader);
+                    slaveSection.append(coilGrid);
+                    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);
+                });
+            }
+
+            // 更新按钮状态
+            function updateButtonState(button, state) {
+                if (state) {
+                    button.removeClass('state-off').addClass('state-on');
+                    button.find('.state-text').text('ON');
+                } else {
+                    button.removeClass('state-on').addClass('state-off');
+                    button.find('.state-text').text('OFF');
+                }
+            }
+
+            // 发送控制命令
+            function sendControlCommand(slaveAddr, coil, value) {
+                // 通过Node-RED的admin API发送注入命令
+                $.ajax({
+                    url: '/modbus-dashboard/control',
+                    method: 'POST',
+                    contentType: 'application/json',
+                    data: JSON.stringify({
+                        slave: slaveAddr,
+                        coil: coil,
+                        value: value
+                    }),
+                    success: function() {
+                        console.log(`控制命令已发送: 从站${slaveAddr} 线圈${coil} = ${value ? 'ON' : 'OFF'}`);
+                    },
+                    error: function(err) {
+                        console.error('控制命令发送失败:', err);
+                        RED.notify('控制命令发送失败', 'error');
+                    }
+                });
+            }
+
+            // 轮询状态更新（每500ms）
+            var pollInterval = null;
+            function startPolling() {
+                if (pollInterval) {
+                    clearInterval(pollInterval);
+                }
+                
+                pollInterval = setInterval(function() {
+                    var masterNodeId = $("#node-input-masterNode").val();
+                    if (!masterNodeId) return;
+                    
+                    $.ajax({
+                        url: '/modbus-dashboard/state',
+                        method: 'GET',
+                        success: function(data) {
+                            if (data && data.states) {
+                                // 更新状态缓存
+                                Object.keys(data.states).forEach(function(key) {
+                                    var oldState = stateCache[key];
+                                    var newState = data.states[key];
+                                    stateCache[key] = newState;
+                                    
+                                    // 如果状态变化，更新UI
+                                    if (oldState !== newState) {
+                                        var parts = key.split('_');
+                                        var slaveAddr = parts[0];
+                                        var coil = parts[1];
+                                        var button = $(`.btn-toggle[data-slave="${slaveAddr}"][data-coil="${coil}"]`);
+                                        if (button.length > 0) {
+                                            updateButtonState(button, newState);
+                                        }
+                                    }
+                                });
+                            }
+                        },
+                        error: function(err) {
+                            console.error('状态轮询失败:', err);
+                        }
+                    });
+                }, 500);
+            }
+
+            // 停止轮询
+            function stopPolling() {
+                if (pollInterval) {
+                    clearInterval(pollInterval);
+                    pollInterval = null;
+                }
+            }
+
+            // 监听主站节点选择变化
+            masterNodeSelect.on("change", function() {
+                renderDashboard();
+                stopPolling();
+                if ($(this).val()) {
+                    startPolling();
+                }
+            });
+
+            // 初始渲染
+            renderDashboard();
+            if (node.masterNode) {
+                startPolling();
+            }
+
+            // 对话框关闭时停止轮询
+            $("#node-dialog-cancel, #node-dialog-ok").on("click", function() {
+                stopPolling();
+            });
+        }
+    });
+</script>
+
+<script type="text/html" data-template-name="modbus-dashboard">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> 节点名称</label>
+        <input type="text" id="node-input-name" placeholder="Modbus控制看板">
+    </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>
+
+    <div class="form-row" style="margin-top: 20px;">
+        <label style="width: 100%; font-weight: bold; margin-bottom: 10px;">
+            <i class="fa fa-dashboard"></i> 控制面板
+        </label>
+        <div id="dashboard-container" style="
+            max-height: 500px;
+            overflow-y: auto;
+            border: 1px solid #ddd;
+            border-radius: 4px;
+            background: #fafafa;
+            padding: 10px;
+        "></div>
+    </div>
+
+    <style>
+        .slave-section {
+            margin-bottom: 20px;
+            background: white;
+            border-radius: 8px;
+            padding: 15px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        }
+        
+        .slave-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 15px;
+            padding-bottom: 10px;
+            border-bottom: 2px solid #4CAF50;
+        }
+        
+        .slave-title {
+            font-weight: bold;
+            font-size: 16px;
+            color: #333;
+        }
+        
+        .slave-info {
+            font-size: 12px;
+            color: #666;
+        }
+        
+        .coil-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));
+            gap: 10px;
+        }
+        
+        .coil-item {
+            background: #f9f9f9;
+            border: 1px solid #e0e0e0;
+            border-radius: 6px;
+            padding: 10px;
+        }
+        
+        .coil-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 8px;
+        }
+        
+        .coil-name {
+            font-weight: 500;
+            font-size: 13px;
+            color: #333;
+            overflow: hidden;
+            text-overflow: ellipsis;
+            white-space: nowrap;
+            max-width: 120px;
+        }
+        
+        .coil-number {
+            font-size: 11px;
+            color: #999;
+        }
+        
+        .coil-control {
+            display: flex;
+            justify-content: center;
+        }
+        
+        .btn-toggle {
+            width: 100%;
+            padding: 8px 16px;
+            border: none;
+            border-radius: 4px;
+            font-weight: bold;
+            font-size: 13px;
+            cursor: pointer;
+            transition: all 0.2s;
+        }
+        
+        .btn-toggle.state-on {
+            background: #4CAF50;
+            color: white;
+        }
+        
+        .btn-toggle.state-on:hover {
+            background: #45a049;
+        }
+        
+        .btn-toggle.state-off {
+            background: #f44336;
+            color: white;
+        }
+        
+        .btn-toggle.state-off:hover {
+            background: #da190b;
+        }
+    </style>
+</script>
+
+<script type="text/html" data-help-name="modbus-dashboard">
+    <p>Modbus控制看板节点，提供可视化界面显示和控制所有从站的继电器状态。</p>
+    
+    <h3>功能特性</h3>
+    <ul>
+        <li>实时显示所有从站和线圈的状态</li>
+        <li>支持直接点击按钮控制继电器开关</li>
+        <li>自动同步HomeKit网桥配置的继电器名称</li>
+        <li>美观的网格布局，按从站分组显示</li>
+        <li>状态实时更新（500ms轮询）</li>
+        <li>零额外开销，不参与实际Modbus通信</li>
+    </ul>
+    
+    <h3>使用步骤</h3>
+    <ol>
+        <li>选择已配置的Modbus主站节点</li>
+        <li>在配置界面中查看所有继电器状态</li>
+        <li>点击按钮即可控制继电器开关</li>
+        <li>部署流程后，节点会显示监控状态</li>
+    </ol>
+    
+    <h3>注意事项</h3>
+    <ul>
+        <li>确保主站节点已正确配置并运行</li>
+        <li>控制看板只在配置界面打开时才轮询状态</li>
+        <li>继电器名称与HomeKit网桥共享，修改需在HomeKit网桥节点中进行</li>
+        <li>本节点不参与实际Modbus通信，不会增加主站负担</li>
+    </ul>
+</script>
+

package/nodes/modbus-dashboard.js

@@ -0,0 +1,98 @@
+module.exports = function(RED) {
+    "use strict";
+
+    // 全局状态缓存（所有dashboard节点共享）
+    var globalStateCache = {};
+
+    function ModbusDashboardNode(config) {
+        RED.nodes.createNode(this, config);
+        var node = this;
+
+        // 配置
+        node.config = {
+            name: config.name || "Modbus控制看板",
+            masterNode: config.masterNode
+        };
+
+        // 获取主站节点
+        var masterNode = RED.nodes.getNode(node.config.masterNode);
+        if (!masterNode) {
+            node.error('未找到主站节点');
+            node.status({fill: "red", shape: "ring", text: "未配置主站"});
+            return;
+        }
+
+        // 监听主站状态更新事件
+        node.stateUpdateHandler = function(data) {
+            if (!data || typeof data !== 'object') {
+                return;
+            }
+
+            var key = data.slave + "_" + data.coil;
+            globalStateCache[key] = data.value;
+        };
+
+        // 注册事件监听器
+        masterNode.on('stateUpdate', node.stateUpdateHandler);
+
+        // 初始化状态缓存（从主站获取当前状态）
+        if (masterNode.deviceStates) {
+            Object.keys(masterNode.deviceStates).forEach(function(slaveId) {
+                var deviceState = masterNode.deviceStates[slaveId];
+                if (deviceState && deviceState.coils) {
+                    deviceState.coils.forEach(function(value, coil) {
+                        var key = slaveId + "_" + coil;
+                        globalStateCache[key] = value;
+                    });
+                }
+            });
+        }
+
+        // 更新节点状态
+        node.status({fill: "green", shape: "dot", text: "监控中"});
+
+        // 清理
+        node.on('close', function() {
+            if (masterNode && node.stateUpdateHandler) {
+                masterNode.removeListener('stateUpdate', node.stateUpdateHandler);
+            }
+            node.status({});
+        });
+    }
+
+    RED.nodes.registerType("modbus-dashboard", ModbusDashboardNode);
+
+    // HTTP API：获取状态
+    RED.httpAdmin.get('/modbus-dashboard/state', function(req, res) {
+        res.json({
+            states: globalStateCache
+        });
+    });
+
+    // HTTP API：发送控制命令
+    RED.httpAdmin.post('/modbus-dashboard/control', function(req, res) {
+        var slave = parseInt(req.body.slave);
+        var coil = parseInt(req.body.coil);
+        var value = Boolean(req.body.value);
+
+        if (isNaN(slave) || isNaN(coil)) {
+            res.status(400).json({error: '参数错误'});
+            return;
+        }
+
+        // 发送内部事件（通过免连线通信机制）
+        RED.events.emit('modbus:writeCoil', {
+            slave: slave,
+            coil: coil,
+            value: value,
+            source: 'dashboard'
+        });
+
+        // 立即更新缓存（乐观更新）
+        var key = slave + "_" + coil;
+        globalStateCache[key] = value;
+
+        res.json({success: true});
+    });
+};
+