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

package/coe/coe-monitor.js

@@ -8,11 +8,12 @@
 
 module.exports = function(RED) {
     'use strict';
-    const { getUnitInfo } = require('../lib/utils')
+    const { getUnitInfo, getDigitalStateKey } = require('../lib/utils')
 
     function CoEMonitorNode(config) {
         RED.nodes.createNode(this, config);
         const node = this;
+        node._ = RED._;
         
         node.cmiConfig = RED.nodes.getNode(config.cmiconfig);
 
@@ -31,22 +32,22 @@ module.exports = function(RED) {
         let packetCount = 0;
         let lastUpdate = Date.now();
 
-        const listener = (data) => { // Listener for incoming data
-            if (!data || !data.blocks || !Array.isArray(data.blocks)) {
+        const listener = (received) => { // Listener for incoming data
+            if (!received || !received.data || !Array.isArray(received.data)) {
                 node.warn('Received invalid data format');
                 return;
             }
 
-            for (let block of data.blocks) {
-                if (!block) continue;
+            for (let canNode of received.data) {
+                if (!canNode) continue;
 
                 if (node.filterNodeNumber !== null && // Filter by Node Number
                     node.filterNodeNumber !== 0 && 
-                    block.nodeNumber !== node.filterNodeNumber) {
+                    canNode.nodeNumber !== node.filterNodeNumber) {
                     continue;
                 }
                 
-                const isDigital = (block.blockNumber === 0 || block.blockNumber === 9); // Filter by Data Type
+                const isDigital = (canNode.dataType === 'digital'); // Filter by Data Type
                 const isAnalog = !isDigital;
                 
                 if (node.filterDataType === 'analog' && !isAnalog) continue;
@@ -58,48 +59,38 @@ module.exports = function(RED) {
                 // 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
+                        sourceIP: received.sourceIP,
+                        version: received.version,
+                        nodeNumber: canNode.nodeNumber,
+                        ...(canNode.blockNumber && { blockNumber: canNode.blockNumber}),
+                        dataType: canNode.dataType
                     },
-                    topic: `coe/monitor/${block.nodeNumber}/block/${block.blockNumber}`
+                    topic: `coe/monitor/${canNode.nodeNumber}/block/${canNode.dataType}`
                 };
                 
-                // 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],
+                // Additional Details for Digital/Analog Blocks
+                const valuesDetailed = {};
+
+                if (canNode.outputs) {
+                    Object.entries(canNode.outputs).forEach(([outputNumber, output]) => {
+                        const unitInfo = getUnitInfo(output.unit, lang);
+                        const translationKey = getDigitalStateKey(output.unit, output.value, "coe-monitor.status.");
+
+                        valuesDetailed[outputNumber] = {
+                            value: output.value,
+                            ...(isDigital && { state: node._(translationKey) }),
+                            unit: output.unit,
                             unitName: unitInfo.name,
-                            unitSymbol: unitInfo.symbol
+                            ...(isAnalog && { 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'
-                    }));
+                    msg.payload.values = valuesDetailed;
                 }
                 
                 // Raw Data
                 if (node.includeRaw) {
-                    msg.payload.raw = block;
+                    msg.payload.raw = { raw: received.rawBuffer ? received.rawBuffer.toString('hex').toUpperCase() : null}
                 }
                 
                 node.send(msg);
@@ -109,13 +100,13 @@ module.exports = function(RED) {
                 node.status({
                     fill: "green", 
                     shape: "dot", 
-                    text: RED._("coe-monitor.status.node") + ` ${block.nodeNumber} B${block.blockNumber}[${dataTypeLabel}] - ${packetCount} Pkts`
+                    text: node._("coe-monitor.status.node") + ` ${canNode.nodeNumber} ${dataTypeLabel} - ${packetCount} Pkts`
                 });
             }
         };
 
         node.cmiConfig.registerListener(listener);
-        node.status({fill: "grey", shape: "ring", text: "coe-monitor.status.monitoring"});
+        node.status({fill: "grey", shape: "ring", text: node._("coe-monitor.status.monitoring") + "..."});
 
         // Status Update Timer (shows last activity)
         const statusTimer = setInterval(() => {
@@ -124,7 +115,7 @@ module.exports = function(RED) {
                 node.status({
                     fill: "yellow", 
                     shape: "ring", 
-                    text: RED._("coe-monitor.status.idle") + ` ${secsSinceUpdate}s - ${packetCount} Pkts [v${coeVersion}]`
+                    text: node._("coe-monitor.status.monitoring") + ` ${secsSinceUpdate}s - ${packetCount} Pkt. [v${coeVersion}]`
                 });
             }
         }, 5000);

package/coe/coe-output.html

@@ -15,7 +15,10 @@
             nodeNumber: { value: 1, validate: RED.validators.number() },
             outputNumber: { value: 1, validate: RED.validators.number() },
             dataType: { value: "analog" },
-            unit: { value: 0, validate: RED.validators.number() }
+            unit: { value: 0, validate: RED.validators.number() },
+            minChange: { value: 1, validate: RED.validators.number() },
+            blockingTime: { value: 10, validate: RED.validators.number() },
+            maxInterval: { value: 5, validate: RED.validators.number() }
         },
         inputs: 1,
         outputs: 2,
@@ -33,37 +36,58 @@
             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(); 
+            function loadAndFilterUnits(dataType) {
+                const isDigital = dataType === 'analog' ? false : true;
 
-                    Object.keys(unitsData).forEach(function(key) {
-                        const unit = unitsData[key];
-                        selectElement.append(
-                            $('<option></option>')
-                                .attr('value', key)
-                                .text(unit.name)
-                        );
-                    });
+                $.getJSON('ta-cmi-coe/units/' + editorLanguage)
+                    .done(function(unitsData) {               
+                        const selectElement = $('#node-input-unit');
+                        selectElement.empty(); 
+                        let foundUnit = false;
+
+                        Object.keys(unitsData).forEach(function(key) {
+                            const unit = unitsData[key];
+                            
+                            if (unit.digital === isDigital) { 
+                                selectElement.append(
+                                    $('<option></option>')
+                                        .attr('value', key)
+                                        .text(unit.name)
+                                );
+                                if (Number(key) === Number(node.unit)) {
+                                    foundUnit = true;
+                                }
+                            }
+                        });
 
-                    // 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");
-                });
+                        if (!foundUnit) {
+                            node.unit = selectElement.find('option:first').attr('value') || 0;
+                        }
+
+                        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();
+            $("#node-input-dataType").change(function() { 
+                const selectedDataType = $(this).val();
+                loadAndFilterUnits(selectedDataType);
+
+                if (selectedDataType === "analog") {
+                    $("#minchange-row").show();
                 } else {
-                    $("#unit-row").hide();
+                    $("#minchange-row").hide();
                 }
             });
-            $("#node-input-dataType").change();
+            
+            $("#node-input-dataType").change(); 
+
+            $("#node-input-minChange").val(
+                parseFloat($("#node-input-minChange").val() || 0).toFixed(5)
+            );
         }
     });
 </script>
@@ -92,8 +116,23 @@
             <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>
+    <div class="form-row">
+        <label for="node-input-unit"><i class="fa fa-thermometer-full"></i> <span data-i18n="coe-output.label.unit"></span></label>
         <select id="node-input-unit"></select>
     </div>
+    <div class="form-row">
+        <span data-i18n="coe-output.label.sendConditions"></span>
+    </div>
+    <div class="form-row" id="minchange-row" style="display:none;">
+        <label for="node-input-minChange"><i class="fa fa-line-chart"></i> <span data-i18n="coe-output.label.minChange"></span></label>
+        <input type="number" id="node-input-minChange" placeholder="1" min="0" max="1000000" step="0.001">
+    </div>
+    <div class="form-row">
+        <label for="node-input-blockingTime"><i class="fa fa-clock-o"></i> <span data-i18n="coe-output.label.blockingTime"></span></label>
+        <input type="number" id="node-input-blockingTime" placeholder="10" min="1" max="999">
+    </div>
+    <div class="form-row">
+        <label for="node-input-maxInterval"><i class="fa fa-repeat"></i> <span data-i18n="coe-output.label.maxInterval"></span></label>
+        <input type="number" id="node-input-maxInterval" placeholder="5" min="1" max="60">
+    </div>
 </script>

package/coe/coe-output.js

@@ -14,6 +14,7 @@ module.exports = function(RED) {
     function CoEOutputNode(config) {
         RED.nodes.createNode(this, config);
         const node = this;
+        node._ = RED._;
         
         node.cmiConfig = RED.nodes.getNode(config.cmiconfig);
 
@@ -30,39 +31,173 @@ module.exports = function(RED) {
         node.dataType = config.dataType || 'analog';
         node.unit = parseInt(config.unit) || 0;
 
+        if (node.coeVersion === 2) {
+            node.queueKey = node.nodeNumber + '-' + node.dataType;
+        } else {
+            node.block = getBlockInfo(node.dataType, node.outputNumber);
+            node.queueKey = node.nodeNumber + '-' + node.block.number;
+        }
+        
+        // Filter configuration parameters
+        node.minChange = parseFloat(config.minChange) || 1;
+        node.blockingTime = parseFloat(config.blockingTime) || 10; // Seconds
+        node.maxInterval = parseFloat(config.maxInterval) || 5;  // Minutes
+        
+        // State tracking per output (not global!)
+        node.lastReceivedMsg = null;
+        node.lastReceivedValue = undefined;
+        node.lastReceivedUnit = null;
+        node.lastSentValue = undefined;
+        node.lastSentTime = 0;
+        node.lastInputTime = 0;
+        
+        node.intervalTimer = null;
+    
         node.on('input', function(msg) {
-            const blockInfo = getBlockInfo(node.dataType, node.outputNumber);
-            let values, units;
+            node.lastInputTime = Date.now();
+            const timeSinceLastSend = (node.lastInputTime - node.lastSentTime) / 1000; // Seconds
+            const isSupressed = checkSuppressCondition(node, timeSinceLastSend);
+            node.lastReceivedMsg = msg;
             
-            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;
+            // Prepare last received values
+            const payloadValue = parseFloat(msg.payload);
+            node.lastReceivedValue = isNaN(payloadValue) ? 0 : payloadValue;
+            node.lastReceivedUnit = (msg.coe && msg.coe.unit !== undefined) ? parseInt(msg.coe.unit) : node.unit;
+
+
+            // Filter based on sending conditions
+            if (isSupressed > 0) { 
+                if (isSupressed === 1) { // Suppressed due to blocking time
+                    setblockingTimer(timeSinceLastSend);
+                    }
+                return;
+                }
+
+            if (node.blockingTimer) {
+                clearTimeout(node.blockingTimer);
+                node.blockingTimer = null;
+            }
+
+            setIntervalTimer(); // Restart interval timer
+
+            queueAndSend(node);
+            node.lastSentValue = node.lastReceivedValue;
+            node.lastSentTime = Date.now();
+
+            node.status({ // Update to queued
+                fill: "yellow",
+                shape: "dot",
+                text: node._("coe-output.status.queued") + ` [v${node.coeVersion}]`
+            });
+        });
+        
+        node.on('close', function() { // Clear timers on shutdown
+            if (node.intervalTimer) {
+                clearTimeout(node.intervalTimer);
+                node.intervalTimer = null;
+            }
+            if (node.blockingTimer) {
+                clearTimeout(node.blockingTimer);
+                node.blockingTimer = null;
+            }
+        });
+        
+        node.status({fill:"grey", shape:"ring", text:node._("coe-output.status.ready") + ` [v${node.coeVersion}]`});
+
+        // Start the sending interval timer
+        function setIntervalTimer() {
+            if (node.intervalTimer) {
+                clearTimeout(node.intervalTimer);
+                node.intervalTimer = null;
+            } 
+
+            const checkInterval = node.maxInterval * 60 * 1000;
+            
+            node.intervalTimer = setTimeout(() => { // Interval elapsed, retransmit last value
+                const now = Date.now();
+                const timeSinceLastSend = (now - node.lastSentTime) / 1000 / 60;
                 
-                // Set unit for the specific output
-                units[blockInfo.position] = 
-                    (msg.coe && msg.coe.unit !== undefined) 
-                    ? parseInt(msg.coe.unit) 
-                    : node.unit;
+                queueAndSend(node);
+                node.lastSentValue = node.lastReceivedValue;
+                node.lastSentTime = Date.now();
+
+                if (node.lastReceivedValue !== undefined) {
+                    node.status({
+                        fill: "yellow",
+                        shape: "dot",
+                        text: node._("coe-output.status.retransmit") + ` (${timeSinceLastSend.toFixed(0)} Min) [v${node.coeVersion}]`
+                    });
+                }     
+                setTimeout(() => {
+                    node.status({fill: "grey", shape: "ring", text: node._("coe-output.status.ready") + ` [v${node.coeVersion}]`});
+                }, 5000);
                 
-            } else { // digital
-                values = new Array(16).fill(undefined);
-                values[blockInfo.position] = msg.payload ? 1 : 0;
-                units = null;
+                setIntervalTimer(); // Restart interval timer
+            }, checkInterval);
+
+        }
+        
+        function setblockingTimer(timeSinceLastSend) {
+            if (node.blockingTimer) {
+                clearTimeout(node.blockingTimer);
+                node.blockingTimer = null;
             }
+
+            const blockingTimeMs = (node.blockingTime - timeSinceLastSend) * 1000;
+
+            node.blockingTimer = setTimeout(() => {
+                if (node.lastReceivedValue !== undefined) {
+                    node.status({
+                        fill: "yellow",
+                        shape: "dot",
+                        text: node._("coe-output.status.queued") + ` [v${node.coeVersion}]`
+                    });
+
+                    queueAndSend(node);
+                    node.lastSentValue = node.lastReceivedValue;
+                    node.lastSentTime = Date.now();
+                    setIntervalTimer()
+                }
+            }, blockingTimeMs);
+        }
+    }
+    
+    // Checks if message should be suppressed based on sending conditions
+    function checkSuppressCondition(node, timeSinceLastSend) {
+        let isSuppressed = 0;
+        let blockReason = "";
+        
+        if (node.lastSentValue === undefined) { // First input
+            isSuppressed = 0;
+            blockReason = "Initial";
+        } else {
             
+            // Check blocking time
+            if (node.blockingTime > 0 && timeSinceLastSend < node.blockingTime) {
+                isSuppressed = 1;
+                blockReason = `⏱ ${timeSinceLastSend.toFixed(0)}/${node.blockingTime}s`;
+            }
+
+            // Check size of value change
+            if (node.dataType === 'analog') {
+                const delta = Math.abs(node.lastReceivedValue - node.lastSentValue);
+                if (node.minChange > 0 && delta < node.minChange) {
+                    isSuppressed = 2;
+                    blockReason = `Δ${delta.toFixed(2)} < ${node.minChange}`;
+                }
+            }
+        }
+        
+        if (isSuppressed > 0) { // Update status and state
             node.status({
                 fill: "yellow",
-                shape: "dot",
-                text: RED._("coe-output.status.queued") + `[v${node.coeVersion}]`
+                shape: "ring",
+                text: node._("coe-output.status.blocked") + `: ${blockReason} [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}]`});
+        }
+
+        return isSuppressed;
     }
+    
     RED.nodes.registerType("coe-output", CoEOutputNode);
 };

package/coe/config.js

@@ -9,7 +9,7 @@
 module.exports = function(RED) {
     "use strict";
     const dgram = require('dgram');
-    const { parseCoEPacket } = require('../lib/coe');
+    const { parsePacket } = require('../lib/protocol');
 
     // CoE Protocol Ports
     const COE_PORT1 = 5441; // CoE v1
@@ -19,7 +19,14 @@ module.exports = function(RED) {
         RED.nodes.createNode(this, config);
         const node = this;
     
-        node.lang = (RED.settings.lang.toLowerCase().startsWith("de")) ? "de" : "en";
+        let langSetting = (RED.settings.lang || "").toLowerCase();
+        switch (true) {
+        case langSetting.startsWith("de"):
+            node.lang = "de";
+            break;
+        default:
+            node.lang = "en";
+        }
 
         node.address = config.address || '192.168.0.100';
         node.coeVersion = parseInt(config.coeVersion) || 1;
@@ -36,11 +43,11 @@ module.exports = function(RED) {
             });
             
             node.socket.on('message', (msg, rinfo) => {
-                const blocks = parseCoEPacket(msg, node.coeVersion);
+                const data = parsePacket[node.coeVersion](msg);
                 
-                if (blocks && blocks.length > 0) {
-                    const data = { // Wrapper object for meta info
-                        blocks: blocks,
+                if (data && data.length > 0) {
+                    const received = { // Wrapper object for meta info
+                        data: data,
                         sourceIP: rinfo.address,
                         version: node.coeVersion,
                         timestamp: Date.now(),
@@ -49,7 +56,7 @@ module.exports = function(RED) {
 
                     node.listeners.forEach(listener => { // Notify all listeners
                         try {
-                            listener(data);
+                            listener(received);
                         } catch(err) {
                             node.error(`Listener error: ${err.message}`);
                         }

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

@@ -2,9 +2,9 @@
     <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>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>
+        <li><b>Timeout:</b> CAN-Bus Timeout (Wert in Minuten)</li>
     </ul>
 </script>

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

@@ -2,7 +2,7 @@
     "coe-input": {
         "label": {
             "name": "Name",
-            "cmiconfig": "CMI Konfig",
+            "cmiconfig": "CMI",
             "nodeNumber": "Knoten",
             "outputNumber": "Eingang",
             "dataType": "Datentyp",
@@ -13,7 +13,13 @@
         },
         "status": {
             "waiting": "wartet",
-            "waitingAny": "wartet (alle Knoten)"
+            "waitingAny": "wartet (alle Knoten)",
+            "open": "Offen",
+            "closed": "Geschlossen",
+            "on": "Ein",
+            "off": "Aus",
+            "yes": "Ja",
+            "no": "Nein"
         }
     }
 }

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

@@ -1,6 +1,5 @@
 <script type="text/html" data-help-name="coe-monitor">
-    <p>Empfängt und überwacht CoE (CAN over Ethernet) Pakete von allen Quellen.</p>
-    <p>Ideal für Debugging, Logging und Überwachung des gesamten CoE-Verkehrs.</p>
+    <p>Empfängt und überwacht CoE (CAN over Ethernet) Pakete von allen Quellen. Ideal für Debugging, Logging und Überwachung des gesamten CoE-Verkehrs.</p>
     <h3>Konfiguration</h3>
     <ul>
         <li>Optional: Filtere nur Pakete von einem bestimmten CAN-Knoten (0 = alle)</li>

package/coe/locales/de/coe-monitor.json

@@ -2,7 +2,7 @@
     "coe-monitor": {
         "label": {
             "name": "Name",
-            "cmiconfig": "CMI Konfig",
+            "cmiconfig": "CMI",
             "filterNodeNumber": "Filter Knoten",
             "filterDataType": "Filter Typ",
             "includeRaw": "Rohdaten einschließen",
@@ -12,9 +12,14 @@
             "filterNodeNumber": "0 = alle"
         },
         "status": {
-            "monitoring": "Lauscht...",
-            "idle": "Inaktiv",
-            "node": "Knoten"
+            "monitoring": "Lauscht",
+            "node": "Knoten",
+            "open": "Offen",
+            "closed": "Geschlossen",
+            "on": "Ein",
+            "off": "Aus",
+            "yes": "Ja",
+            "no": "Nein"
         }
     }
 }

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

@@ -7,8 +7,14 @@
         <li><b>Datentyp:</b> Analog (numerisch) oder Digital (boolean)</li>
         <li><b>Einheit:</b> Messeinheit (nur für analog)</li>
     </ul>
+    <h3>Sendebedingungen</h3>
+    <ul>
+        <li><b>bei Änderung >:</b> Erneut senden, wenn sich der aktuelle Wert um mehr als dieser Wert ändert (analoge Werte)</li>
+        <li><b>Blockierzeit:</b> Frühestens nach dieser Zeit erneut senden (Sekunden)</li>
+        <li><b>Intervallzeit:</b> Falls sich der Wert nicht ändert, nach diesem Intervall erneut senden (Minuten)</li>
+    </ul>
     <h3>Ausgänge</h3>
     <p><b>2 Ausgänge:</b> [0] Durchgeleitete Nachricht, [1] Debug-Info (Hex, Block-State, Units)</p>
-    <h3>Hinweise</h3>
-    <p>Werte werden 50ms gepuffert um die Nachrichtenfrequenz zu reduzieren</p>
+    <h3>Hinweis</h3>
+    <p>Werte werden 50 ms gepuffert um die Nachrichtenfrequenz zu reduzieren.</p>
 </script>

package/coe/locales/de/coe-output.json

@@ -2,17 +2,23 @@
     "coe-output": {
         "label": {
             "name": "Name",
-            "cmiconfig": "CMI Konfig",
+            "cmiconfig": "CMI",
             "nodeNumber": "Knoten",
             "outputNumber": "Ausgang",
             "dataType": "Datentyp",
-            "unit": "Einheit"
+            "unit": "Einheit",
+            "sendConditions": "Sendebedingungen:",
+            "minChange": "bei Änderung >",
+            "blockingTime": "Blockierzeit (Sek)",
+            "maxInterval": "Intervallzeit (Min)"
         },
         "status": {
             "noconfig": "Nicht konfiguriert",
-            "queued": "wartet",
-            "ready": "bereit",
-            "merged": "gesendet (Paket)"
+            "queued": "Wartet",
+            "ready": "Bereit",
+            "merged": "Gesendet",
+            "retransmit": "Erneut gesendet",
+            "blocked": "Blockiert"
         }
     }
 }

package/coe/locales/de/config.html

@@ -1,13 +1,13 @@
 <script type="text/html" data-help-name="cmiconfig">
     <p><strong>Konfiguration:</strong></p>
     <ul>
-        <li><b> Lokale IP:</b> IP Adressbereich in dem der UDP Port empfängt (Übliche Werte sind 0.0.0.0 oder 127.0.0.1)</li>
+        <li><b> IP-Bereich:</b> IP Adressbereich in dem der UDP Port empfängt (Übliche Werte sind 0.0.0.0 oder 127.0.0.1)</li>
         <li><b> Adresse:</b> Für das Senden von Nachrichten verwendete IP Adresse des TA C.M.I</li>
     </ul>
     <p><strong>CoE-Version:</strong></p>
     <ul>
-        <li><b>V1:</b> Standard-Einstellung. Wertebereich: ±32.767</li>
-        <li><b>V2:</b> Erweitert, benötigt CMI FW ≥v1.43.1. Wertebereich: ±2.147.483.647</li>
+        <li><b>Version 1:</b> Standard-Einstellung. Wertebereich: ± 32.767</li>
+        <li><b>Version 2:</b> Erweitert, benötigt CMI FW ≥ v1.43.1. Wertebereich: ± 2.147.483.647</li>
     </ul>
     <p>Siehe Einstellungen > CAN im Menü des CMI</p>
 </script>