node-red-contrib-ta-cmi-coe 1.0.0

package/coe/coe-input.js

@@ -0,0 +1,144 @@
+/**
+ * CoE Input Node
+ * 
+ * Copyright 2025 Florian Mayrhofer
+ * Licensed under the Apache License, Version 2.0
+ *
+ */ 
+
+module.exports = function(RED) {
+    'use strict';
+    const { getBlockInfo, getUnitInfo, mergeBlockData, createEmptyState } = require('../lib/utils');
+
+    // CoE Input Node (receiving values)
+    function CoEInputNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+        
+        node.cmiConfig = RED.nodes.getNode(config.cmiconfig);
+    
+        if (!node.cmiConfig) {
+            node.error("CMI Configuration missing");
+            return;
+        }
+        
+        node.cmiAddress = node.cmiConfig.address;
+        node.coeVersion = node.cmiConfig.coeVersion || 1;
+        node.lang = node.cmiConfig.lang;
+        node.nodeNumber = parseInt(config.nodeNumber) || 0;
+        node.outputNumber = parseInt(config.outputNumber) || 1;
+        node.dataType = config.dataType || 'analog';
+   
+        // State management for LKGVs (Last Known Good Values) per block
+        node.blockState = {};
+        
+        // Calculate block & position
+        const blockInfo = getBlockInfo(node.dataType, node.outputNumber);
+
+        // Set Timer for CoE timeout
+        const timeoutMs = (config.timeout || 20) * 60 * 1000; // Timeout in milliseconds
+        let timeoutTimer = null;
+        let currentNodeText = "";
+        
+        // Listener for incoming data
+        const listener = (data) => {
+            // Data is now: { blocks, sourceIP, version, timestamp }
+            if (!data || !data.blocks || !Array.isArray(data.blocks)) {
+                node.warn('Received invalid data format');
+                return;
+            }
+            
+            for (let incomingBlock of data.blocks) {
+                if (!incomingBlock) continue;
+                
+                const blockKey = `${incomingBlock.nodeNumber}-${incomingBlock.blockNumber}`;
+
+                // Filter Node number (if > 0)
+                if (node.nodeNumber > 0 && incomingBlock.nodeNumber !== node.nodeNumber) {
+                    continue;
+                }
+                
+                // Filter Block number
+                if (incomingBlock.blockNumber !== blockInfo.block) {
+                    continue;
+                }
+                
+                // Merge blocks
+                let currentState = node.blockState[blockKey];
+                if (!currentState) {
+                    currentState = createEmptyState(incomingBlock);
+                }
+                
+                const mergedBlock = mergeBlockData(currentState, incomingBlock);
+                node.blockState[blockKey] = mergedBlock;
+                
+                // Extract Values from merged block                
+                let value, unit; 
+                if (node.dataType === 'analog') {
+                    value = mergedBlock.values[blockInfo.position];
+                    unit = mergedBlock.units ? mergedBlock.units[blockInfo.position] : null;
+                } else {
+                    value = mergedBlock.values[blockInfo.position] ? true : false;
+                    unit = null;
+                }
+                
+                // Build message
+                const unitInfo = getUnitInfo(unit, node.lang);
+                const msg = {
+                    payload: value,
+                    topic: `coe/${node.nodeNumber || mergedBlock.nodeNumber}/${node.dataType}/${node.outputNumber}`,
+                    coe: {
+                        nodeNumber: mergedBlock.nodeNumber,
+                        blockNumber: mergedBlock.blockNumber,
+                        outputNumber: node.outputNumber,
+                        dataType: node.dataType,
+                        version: data.version,
+                        unit: unit,
+                        unitName: unitInfo.name,
+                        unitSymbol: unitInfo.symbol,
+                        sourceIP: data.sourceIP,
+                        timestamp: data.timestamp,
+                        raw: mergedBlock
+                    }
+                };
+                
+                if (value !== undefined) { // Send only, if value is defined in block
+                     node.send(msg);
+                }
+                
+                currentNodeText = `${value} ${unitInfo.symbol || ''} [v${node.coeVersion}]` // Caching last Node text
+
+                node.status({
+                    fill: "green", 
+                    shape: "dot", 
+                    text: currentNodeText
+                });
+                
+                resetTimeout();
+            }
+        };
+
+        node.cmiConfig.registerListener(listener);
+        
+        // Reset CoE Timeout
+        function resetTimeout() {
+            if (timeoutTimer) clearTimeout(timeoutTimer);
+            timeoutTimer = setTimeout(() => {
+                node.status({ fill: "red", shape: "dot", text: `${currentNodeText} (Timeout)` });
+            }, timeoutMs);
+        }
+        
+        // Status information, including if filtered
+        if (node.nodeNumber === 0) {
+            node.status({fill: "yellow", shape: "ring", text: "coe-input.status.waitingAny"});
+        } else {
+            node.status({fill: "grey", shape: "ring", text: "coe-input.status.waiting"});
+        }
+        
+        node.on('close', function() {
+            node.cmiConfig.unregisterListener(listener);
+        });
+    }
+    
+    RED.nodes.registerType("coe-input", CoEInputNode);
+};

package/coe/coe-monitor.html

@@ -0,0 +1,60 @@
+<!-- 
+    CoE Monitor Node
+
+    Copyright 2025 Florian Mayrhofer
+    Licensed under the Apache License, Version 2.0
+-->
+ 
+<script type="text/javascript">
+    RED.nodes.registerType('coe-monitor', {
+        category: 'TA CMI',
+        color: '#FFCC66',
+        defaults: {
+            name: { value: "" },
+            cmiconfig: { value: "", type: "cmiconfig", required: true },
+            filterNodeNumber: { value: 0, validate: RED.validators.number() },
+            filterDataType: { value: "all" },
+            includeRaw: { value: false }
+        },
+        inputs: 0,
+        outputs: 1,
+        icon: "feed.svg",
+        label: function() {
+            if (this.filterNodeNumber && this.filterNodeNumber > 0) {
+                return this.name || `CoE Monitor (Node ${this.filterNodeNumber})`;
+            }
+            return this.name || "CoE Monitor (All)";
+        },
+        labelStyle: function() {
+            return this.name ? "node_label_italic" : "";
+        }
+    });
+</script>
+
+<script type="text/html" data-template-name="coe-monitor">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> <span data-i18n="coe-monitor.label.name"></span></label>
+        <input type="text" id="node-input-name">
+    </div>
+    <div class="form-row">
+        <label for="node-input-cmiconfig"><i class="fa fa-cog"></i> <span data-i18n="coe-monitor.label.cmiconfig"></span></label>
+        <input type="text" id="node-input-cmiconfig">
+    </div>
+    <div class="form-row">
+        <label for="node-input-filterNodeNumber"><i class="fa fa-filter"></i> <span data-i18n="coe-monitor.label.filterNodeNumber"></span></label>
+        <input type="number" id="node-input-filterNodeNumber" placeholder="0" min="0" max="62">
+        <span id="monitor-filter-help" style="margin-left: 110px; font-size: 0.9em; color: #666;"></span>
+    </div>
+    <div class="form-row">
+        <label for="node-input-filterDataType"><i class="fa fa-filter"></i> <span data-i18n="coe-monitor.label.filterDataType"></span></label>
+        <select id="node-input-filterDataType">
+            <option value="" data-i18n="coe-monitor.label.all"></option>
+            <option value="analog">Analog</span></option>
+            <option value="digital">Digital</span></option>
+        </select>
+    </div>
+    <div class="form-row">
+        <label for="node-input-includeRaw"><i class="fa fa-database"></i> <span data-i18n="coe-monitor.label.includeRaw"></span></label>
+        <input type="checkbox" id="node-input-includeRaw" style="display: inline-block; width: auto;">
+    </div>
+</script>

package/coe/coe-monitor.js

@@ -0,0 +1,138 @@
+/**
+ * CoE Monitor Node (Receives all CoE packets)
+ * 
+ * Copyright 2025 Florian Mayrhofer
+ * Licensed under the Apache License, Version 2.0
+ *
+ */ 
+
+module.exports = function(RED) {
+    'use strict';
+    const { getUnitInfo } = require('../lib/utils')
+
+    function CoEMonitorNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+        
+        node.cmiConfig = RED.nodes.getNode(config.cmiconfig);
+
+        const lang = node.cmiConfig.lang;
+        const coeVersion = node.cmiConfig.coeVersion || 1;
+        
+        if (!node.cmiConfig) {
+            node.error("CMI Configuration missing");
+            return;
+        }
+        
+        node.filterNodeNumber = config.filterNodeNumber ? parseInt(config.filterNodeNumber) : null;
+        node.filterDataType = config.filterDataType || 'all';
+        node.includeRaw = config.includeRaw || false;
+
+        let packetCount = 0;
+        let lastUpdate = Date.now();
+
+        const listener = (data) => { // Listener for incoming data
+            if (!data || !data.blocks || !Array.isArray(data.blocks)) {
+                node.warn('Received invalid data format');
+                return;
+            }
+
+            for (let block of data.blocks) {
+                if (!block) continue;
+
+                if (node.filterNodeNumber !== null && // Filter by Node Number
+                    node.filterNodeNumber !== 0 && 
+                    block.nodeNumber !== node.filterNodeNumber) {
+                    continue;
+                }
+                
+                const isDigital = (block.blockNumber === 0 || block.blockNumber === 9); // Filter by Data Type
+                const isAnalog = !isDigital;
+                
+                if (node.filterDataType === 'analog' && !isAnalog) continue;
+                if (node.filterDataType === 'digital' && !isDigital) continue;
+                
+                packetCount++;
+                lastUpdate = Date.now();
+                
+                // Build message
+                const msg = {
+                    payload: {
+                        nodeNumber: block.nodeNumber,
+                        blockNumber: block.blockNumber,
+                        dataType: isDigital ? 'digital' : 'analog',
+                        values: block.values,
+                        units: block.units,
+                        sourceIP: data.sourceIP,
+                        version: data.version,
+                        timestamp: new Date().toISOString(),
+                        rawBuffer: data.rawBuffer ? data.rawBuffer.toString('hex').toUpperCase() : null
+                    },
+                    topic: `coe/monitor/${block.nodeNumber}/block/${block.blockNumber}`
+                };
+                
+                // Additional Details for Analog Blocks
+                if (isAnalog && block.units) {
+                    msg.payload.valuesDetailed = block.values.map((value, idx) => {
+                        const unitInfo = getUnitInfo(block.units[idx], lang);
+                        RED.log.debug(`Unit Info for unit ${block.units[idx]}: ${JSON.stringify(unitInfo)} + version: ${coeVersion} + key: ${unitInfo.key} + symbol: ${unitInfo.symbol}`);
+                        const outputNumber = (block.blockNumber - 1) * 4 + idx + 1;
+                        return {
+                            outputNumber: outputNumber,
+                            value: value,
+                            unit: block.units[idx],
+                            unitName: unitInfo.name,
+                            unitSymbol: unitInfo.symbol
+                        };
+                    });
+                }
+                
+                // Additional Details for Digital Blocks
+                if (isDigital) {
+                    const baseOutput = block.blockNumber === 0 ? 1 : 17;
+                    msg.payload.valuesDetailed = block.values.map((value, idx) => ({
+                        outputNumber: baseOutput + idx,
+                        value: value === 1,
+                        state: value === 1 ? 'ON' : 'OFF'
+                    }));
+                }
+                
+                // Raw Data
+                if (node.includeRaw) {
+                    msg.payload.raw = block;
+                }
+                
+                node.send(msg);
+
+                // Status Update
+                const dataTypeLabel = isDigital ? 'D' : 'A';
+                node.status({
+                    fill: "green", 
+                    shape: "dot", 
+                    text: RED._("coe-monitor.status.node") + ` ${block.nodeNumber} B${block.blockNumber}[${dataTypeLabel}] - ${packetCount} Pkts`
+                });
+            }
+        };
+
+        node.cmiConfig.registerListener(listener);
+        node.status({fill: "grey", shape: "ring", text: "coe-monitor.status.monitoring"});
+
+        // Status Update Timer (shows last activity)
+        const statusTimer = setInterval(() => {
+            const secsSinceUpdate = Math.floor((Date.now() - lastUpdate) / 1000);
+            if (secsSinceUpdate > 10) {
+                node.status({
+                    fill: "yellow", 
+                    shape: "ring", 
+                    text: RED._("coe-monitor.status.idle") + ` ${secsSinceUpdate}s - ${packetCount} Pkts [v${coeVersion}]`
+                });
+            }
+        }, 5000);
+
+        node.on('close', function() {
+            clearInterval(statusTimer);
+            node.cmiConfig.unregisterListener(listener);
+        });
+    }
+    RED.nodes.registerType("coe-monitor", CoEMonitorNode);
+};

package/coe/coe-output.html

@@ -0,0 +1,99 @@
+<!-- 
+    CoE Output Node
+
+    Copyright 2025 Florian Mayrhofer
+    Licensed under the Apache License, Version 2.0
+-->
+ 
+<script type="text/javascript">
+    RED.nodes.registerType('coe-output', {
+        category: 'TA CMI',
+        color: '#C0DEED',
+        defaults: {
+            name: { value: "" },
+            cmiconfig: { value: "", type: "cmiconfig", required: true },
+            nodeNumber: { value: 1, validate: RED.validators.number() },
+            outputNumber: { value: 1, validate: RED.validators.number() },
+            dataType: { value: "analog" },
+            unit: { value: 0, validate: RED.validators.number() }
+        },
+        inputs: 1,
+        outputs: 2,
+        icon: "serial.svg",
+        outputLabels: ["message", "debug"],
+        label: function() {
+            const type = this.dataType === 'analog' ? 'A' : 'D';
+            return this.name || `CoE Out (${type}${this.outputNumber})`;
+        },
+        labelStyle: function() {
+            return this.name ? "node_label_italic" : "";
+        },
+        oneditprepare: function() {
+            const node = this;
+            const langString = RED.i18n.detectLanguage() || 'en';
+            const editorLanguage = (langString.toLowerCase().startsWith("de")) ? "de" : "en";
+
+            // Populate unit dropdown
+            $.getJSON('ta-cmi-coe/units/' + editorLanguage)
+                .done(function(unitsData) {               
+                    const selectElement = $('#node-input-unit');
+                    selectElement.empty(); 
+
+                    Object.keys(unitsData).forEach(function(key) {
+                        const unit = unitsData[key];
+                        selectElement.append(
+                            $('<option></option>')
+                                .attr('value', key)
+                                .text(unit.name)
+                        );
+                    });
+
+                    // Set existing value
+                    selectElement.val(node.unit);
+                })
+                .fail(function(jqXHR, textStatus, errorThrown) {
+                    console.error("Error loading unit list:", errorThrown);
+                    RED.notify("Error loading unit list from unit-config.js.", "error");
+                });
+            
+            $("#node-input-dataType").change(function() {
+                if ($(this).val() === "analog") {
+                    $("#unit-row").show();
+                } else {
+                    $("#unit-row").hide();
+                }
+            });
+            $("#node-input-dataType").change();
+        }
+    });
+</script>
+
+<script type="text/html" data-template-name="coe-output">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> <span data-i18n="coe-output.label.name"></span></label>
+        <input type="text" id="node-input-name">
+    </div>
+    <div class="form-row">
+        <label for="node-input-cmiconfig"><i class="fa fa-cog"></i> <span data-i18n="coe-output.label.cmiconfig"></span></label>
+        <input type="text" id="node-input-cmiconfig">
+    </div>
+    <div class="form-row">
+        <label for="node-input-nodeNumber"><i class="fa fa-sitemap"></i> <span data-i18n="coe-output.label.nodeNumber"></span></label>
+        <input type="number" id="node-input-nodeNumber" placeholder="1" min="1" max="62">
+    </div>
+    <div class="form-row">
+        <label for="node-input-outputNumber"><i class="fa fa-arrow-up"></i> <span data-i18n="coe-output.label.outputNumber"></span></label>
+        <input type="number" id="node-input-outputNumber" placeholder="1" min="1" max="32">
+    </div>
+    <div class="form-row">
+        <label for="node-input-dataType"><i class="fa fa-list"></i> <span data-i18n="coe-output.label.dataType"></span></label>
+        <select id="node-input-dataType">
+            <option value="analog">Analog</span></option>
+            <option value="digital">Digital</span></option>
+        </select>
+    </div>
+    <div class="form-row" id="unit-row" style="display:none;">
+        <label for="node-input-unit"><i class="fa fa-ruler"></i> <span data-i18n="coe-output.label.unit"></span></label>
+        <select id="node-input-unit"></select>
+    </div>
+</script>

package/coe/coe-output.js

@@ -0,0 +1,68 @@
+/**
+ * CoE Output Node (Sending of values)
+ * 
+ * Copyright 2025 Florian Mayrhofer
+ * Licensed under the Apache License, Version 2.0
+ *
+ */ 
+
+module.exports = function(RED) {
+    'use strict';
+    const { getBlockInfo } = require('../lib/utils')
+    const { queueAndSend } = require('../lib/queueing');
+
+    function CoEOutputNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+        
+        node.cmiConfig = RED.nodes.getNode(config.cmiconfig);
+
+        if (!node.cmiConfig) {
+            node.error("CoE Configuration missing or invalid.");
+            node.status({fill:"red", shape:"ring", text:"coe-output.status.noconfig"});
+            return;
+        }
+
+        node.cmiAddress = node.cmiConfig.address;
+        node.coeVersion = node.cmiConfig.coeVersion || 1;
+        node.nodeNumber = parseInt(config.nodeNumber) || 1;
+        node.outputNumber = parseInt(config.outputNumber) || 1;
+        node.dataType = config.dataType || 'analog';
+        node.unit = parseInt(config.unit) || 0;
+
+        node.on('input', function(msg) {
+            const blockInfo = getBlockInfo(node.dataType, node.outputNumber);
+            let values, units;
+            
+            if (node.dataType === 'analog') {
+                values = [undefined, undefined, undefined, undefined];
+                units  = [undefined, undefined, undefined, undefined];
+                
+                const payloadValue = parseFloat(msg.payload);
+                values[blockInfo.position] = isNaN(payloadValue) ? 0 : payloadValue;
+                
+                // Set unit for the specific output
+                units[blockInfo.position] = 
+                    (msg.coe && msg.coe.unit !== undefined) 
+                    ? parseInt(msg.coe.unit) 
+                    : node.unit;
+                
+            } else { // digital
+                values = new Array(16).fill(undefined);
+                values[blockInfo.position] = msg.payload ? 1 : 0;
+                units = null;
+            }
+            
+            node.status({
+                fill: "yellow",
+                shape: "dot",
+                text: RED._("coe-output.status.queued") + `[v${node.coeVersion}]`
+            });
+            
+            queueAndSend(node, RED._, node.nodeNumber, blockInfo.block, values, units, node.dataType, node.coeVersion, node.cmiConfig, node.cmiAddress, msg);
+        });
+        
+        node.status({fill:"grey", shape:"ring", text:RED._("coe-output.status.ready") + ` [v${node.coeVersion}]`});
+    }
+    RED.nodes.registerType("coe-output", CoEOutputNode);
+};

package/coe/config.html

@@ -0,0 +1,52 @@
+<!-- 
+    CMI Configuration Node
+
+    Copyright 2025 Florian Mayrhofer
+    Licensed under the Apache License, Version 2.0
+-->
+ 
+<script type="text/javascript">
+    RED.nodes.registerType('cmiconfig', {
+        category: 'config',
+        defaults: {
+            name:      { value: "" },
+            localip:   { value: "0.0.0.0" },
+            address:   { value: "192.168.0.100" },
+            coeVersion:{ value: 1 }
+        },
+        label: function() {
+            const version = this.coeVersion || 1;
+            return this.name || `Address (${this.address || "192.168.0.100"}), CMI Config (${version})`;
+        }
+    });
+</script>
+
+<script type="text/html" data-template-name="cmiconfig">
+    <div class="form-row">
+        <label for="node-config-input-name"><i class="fa fa-tag"></i> 
+            <span data-i18n="config.label.name"></span>
+        </label>
+        <input type="text" id="node-config-input-name">
+    </div>
+    <div class="form-row">
+        <label for="node-config-input-localip"><i class="fa fa-wifi"></i> 
+            <span data-i18n="config.label.localip"></span>
+        </label>
+        <input type="text" id="node-config-input-localip" placeholder="0.0.0.0">
+    </div>
+    <div class="form-row">
+        <label for="node-config-input-address"><i class="fa fa-globe"></i> 
+            <span data-i18n="config.label.address"></span>
+        </label>
+        <input type="text" id="node-config-input-address" placeholder="192.168.1.100">
+    </div>
+    <div class="form-row">
+        <label for="node-config-input-coeVersion"><i class="fa fa-cog"></i> 
+            <span data-i18n="config.label.coeVersion"></span>
+        </label>
+        <select id="node-config-input-coeVersion">
+            <option value="1">V1</option>
+            <option value="2">V2</option>
+        </select>
+    </div>
+</script>

package/coe/config.js

@@ -0,0 +1,101 @@
+/**
+ * CMI Configuration Node & Shared UDP socket
+ * 
+ * Copyright 2025 Florian Mayrhofer
+ * Licensed under the Apache License, Version 2.0
+ *
+ */ 
+
+module.exports = function(RED) {
+    "use strict";
+    const dgram = require('dgram');
+    const { parseCoEPacket } = require('../lib/coe');
+
+    // CoE Protocol Ports
+    const COE_PORT1 = 5441; // CoE v1
+    const COE_PORT2 = 5442; // CoE v2
+
+    function CMIConfigNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+    
+        node.lang = (RED.settings.lang.toLowerCase().startsWith("de")) ? "de" : "en";
+
+        node.address = config.address || '192.168.0.100';
+        node.coeVersion = parseInt(config.coeVersion) || 1;
+        node.port = (node.coeVersion === 2) ? COE_PORT2 : COE_PORT1;
+        node.localAddress = config.localip || '0.0.0.0';
+        node.socket = null;
+        node.listeners = [];
+
+        // Add UDP Socket
+        try {
+            node.socket = dgram.createSocket({
+                type: 'udp4',
+                reuseAddr: true  // Enable Socket Reuse
+            });
+            
+            node.socket.on('message', (msg, rinfo) => {
+                const blocks = parseCoEPacket(msg, node.coeVersion);
+                
+                if (blocks && blocks.length > 0) {
+                    const data = { // Wrapper object for meta info
+                        blocks: blocks,
+                        sourceIP: rinfo.address,
+                        version: node.coeVersion,
+                        timestamp: Date.now(),
+                        rawBuffer: msg
+                    };
+
+                    node.listeners.forEach(listener => { // Notify all listeners
+                        try {
+                            listener(data);
+                        } catch(err) {
+                            node.error(`Listener error: ${err.message}`);
+                        }
+                    });
+                }
+            });
+
+            node.socket.on('error', (err) => {
+                node.error(`UDP Socket Error: ${err.message}`);
+            });
+
+            node.socket.bind(node.port, node.localAddress, () => {
+                node.log(`CoE UDP Socket is listening on ${node.localAddress}:${node.port} (CoE V${node.coeVersion})`);
+            });
+
+        } catch(err) {
+            node.error(`Failed to create UDP socket: ${err.message}`);
+        }
+
+        node.registerListener = function(callback) { // Add listener
+            node.listeners.push(callback);
+        };
+
+        node.unregisterListener = function(callback) { // Remove listener
+            const index = node.listeners.indexOf(callback);
+            if (index > -1) {
+                node.listeners.splice(index, 1);
+            }
+        };
+
+        node.send = function(host, packet) { // Send data
+            if (node.socket) {
+                node.socket.send(packet, 0, packet.length, node.port, host, (err) => {
+                    if (err) {
+                        node.error(`Failed to send: ${err.message}`);
+                    }
+                });
+            }
+        };
+
+        node.on('close', function() { // Cleanup on node shutdown
+            if (node.socket) {
+                node.socket.close();
+            }
+        });
+    }
+    RED.nodes.registerType("cmiconfig", CMIConfigNode);
+
+};

package/coe/locales/de/coe-input.html

@@ -0,0 +1,10 @@
+<script type="text/html" data-help-name="coe-input">
+    <p>Empfängt Werte von einer TA CMI via CoE (CAN over Ethernet).</p>
+    <h3>Konfiguration</h3>
+    <ul>
+        <li><b>Knoten:</b> CAN Knoten-Nummer (1-62, 0 = von beliebigem Knoten empfangen, nicht empfohlen in Produktivbetrieb)</li>
+        <li><b>Eingang:</b> Nummer des Netzwerkeingangs (1-32)</li>
+        <li><b>Datentyp:</b> Analog (1-32) oder Digital (1-32)</li>
+        <li><b>Timeout:</b> CAN-Bus Timeout-Wert in Minuten</li>
+    </ul>
+</script>