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

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

@@ -0,0 +1,19 @@
+{
+    "coe-input": {
+        "label": {
+            "name": "Name",
+            "cmiconfig": "CMI Konfig",
+            "nodeNumber": "Knoten",
+            "outputNumber": "Eingang",
+            "dataType": "Datentyp",
+            "timeout": "Timeout (Min)"
+        },
+        "placeholder": {
+            "nodeNumber": "1-62, 0 = beliebig"
+        },
+        "status": {
+            "waiting": "wartet",
+            "waitingAny": "wartet (alle Knoten)"
+        }
+    }
+}

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

@@ -0,0 +1,10 @@
+<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>
+    <h3>Konfiguration</h3>
+    <ul>
+        <li>Optional: Filtere nur Pakete von einem bestimmten CAN-Knoten (0 = alle)</li>
+        <li>Filter Typ": "Filtere nach Datentyp: Alle, nur Analog oder nur Digital</li>
+        <li>Rohdaten einschließen": "Füge vollständige Rohdaten in msg.payload.raw hinzu</li>
+    </ul>
+</script>

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

@@ -0,0 +1,20 @@
+{
+    "coe-monitor": {
+        "label": {
+            "name": "Name",
+            "cmiconfig": "CMI Konfig",
+            "filterNodeNumber": "Filter Knoten",
+            "filterDataType": "Filter Typ",
+            "includeRaw": "Rohdaten einschließen",
+            "all": "Alle"
+        },
+        "placeholder": {
+            "filterNodeNumber": "0 = alle"
+        },
+        "status": {
+            "monitoring": "Lauscht...",
+            "idle": "Inaktiv",
+            "node": "Knoten"
+        }
+    }
+}

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

@@ -0,0 +1,14 @@
+<script type="text/html" data-help-name="coe-output">
+    <p>Sendet einzelne Werte an eine TA CMI via CoE.</p>
+    <h3>Konfiguration</h3>
+    <ul>
+        <li><b>Knoten:</b> CAN Knoten-Nummer (1-62)</li>
+        <li><b>Eingang:</b> Nummer des Netzwerkausgangs (Analog 1-32, Digital 1-16)</li>
+        <li><b>Datentyp:</b> Analog (numerisch) oder Digital (boolean)</li>
+        <li><b>Einheit:</b> Messeinheit (nur für analog)</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>
+</script>

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

@@ -0,0 +1,18 @@
+{
+    "coe-output": {
+        "label": {
+            "name": "Name",
+            "cmiconfig": "CMI Konfig",
+            "nodeNumber": "Knoten",
+            "outputNumber": "Ausgang",
+            "dataType": "Datentyp",
+            "unit": "Einheit"
+        },
+        "status": {
+            "noconfig": "Nicht konfiguriert",
+            "queued": "wartet",
+            "ready": "bereit",
+            "merged": "gesendet (Paket)"
+        }
+    }
+}

package/coe/locales/de/config.html

@@ -0,0 +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> 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>
+    </ul>
+    <p>Siehe Einstellungen > CAN im Menü des CMI</p>
+</script>

package/coe/locales/de/config.json

@@ -0,0 +1,10 @@
+{
+    "config": {
+        "label": {
+            "name": "Name",
+            "localip": "Lokale IP",
+            "address": "CMI Adresse",
+            "coeVersion": "CoE Version"
+        }
+    }
+}

package/coe/locales/en-US/coe-input.html

@@ -0,0 +1,10 @@
+<script type="text/html" data-help-name="coe-input">
+    <p>Receives values from a TA CMI via CoE (CAN over Ethernet).</p>
+    <h3>Configuration</h3>
+    <ul>
+        <li><b>Node:</b> CAN node number (1-62, 0 = receive from any node, not recommended for production)</li>
+        <li><b>Input:</b> Network input number (1-32)</li>
+        <li><b>Data Type:</b> Analog (1-32) or Digital (1-32)</li>
+        <li><b>Timeout:</b> CAN-Bus timeout value in Minutes</li>
+    </ul>
+</script>

package/coe/locales/en-US/coe-input.json

@@ -0,0 +1,19 @@
+{
+    "coe-input": {
+        "label": {
+            "name": "Name",
+            "cmiconfig": "CMI Config",
+            "nodeNumber": "Node",
+            "outputNumber": "Input",
+            "dataType": "Data Type",
+            "timeout": "Timeout (Min)"
+        },
+        "placeholder": {
+            "nodeNumber": "1-62, 0 = any"
+        },
+        "status": {
+            "waiting": "waiting",
+            "waitingAny": "waiting (any node)"
+        }
+    }
+}

package/coe/locales/en-US/coe-monitor.html

@@ -0,0 +1,10 @@
+<script type="text/html" data-help-name="coe-monitor">
+    <p>Receives and monitors CoE (CAN over Ethernet) packets from all sources.</p>
+    <p>Ideal for debugging, logging, and monitoring total CoE traffic.</p>
+    <h3>Configuration</h3>
+    <ul>
+        <li>Optional: Filter packets from a specific CAN node only (0 = all)</li>
+        <li>Filter Type: Filter by data type: All, Analog only, or Digital only</li>
+        <li>Include Raw: Include complete raw data in msg.payload.raw</li>
+    </ul>
+</script>

package/coe/locales/en-US/coe-monitor.json

@@ -0,0 +1,20 @@
+{
+    "coe-monitor": {
+        "label": {
+            "name": "Name",
+            "cmiconfig": "CMI Config",
+            "filterNodeNumber": "Filter Node",
+            "filterDataType": "Filter Type",
+            "includeRaw": "Include Raw Data",
+            "all": "All"
+        },
+        "placeholder": {
+            "filterNodeNumber": "0 = all"
+        },
+        "status": {
+            "monitoring": "Monitoring...",
+            "idle": "Idle",
+            "node": "Node"
+        }
+    }
+}

package/coe/locales/en-US/coe-output.html

@@ -0,0 +1,14 @@
+<script type="text/html" data-help-name="coe-output">
+    <p>Sends single values to a TA CMI via CoE.</p>
+    <h3>Configuration</h3>
+    <ul>
+        <li><b>Node:</b> CAN node number (1-62)</li>
+        <li><b>Input:</b> Network output number (Analog 1-32, Digital 1-16)</li>
+        <li><b>Data Type:</b> Analog (numeric) or Digital (boolean)</li>
+        <li><b>Unit:</b> Measurement unit (analog only)</li>
+    </ul>
+    <h3>Outputs</h3>
+    <p><b>2 outputs:</b> [0] Message passthrough, [1] Debug info (Hex, Block-State, Units)</p>
+    <h3>Notes</h3>
+    <p>Values are buffered for 50ms to reduce message frequency.</p>
+</script>

package/coe/locales/en-US/coe-output.json

@@ -0,0 +1,18 @@
+{    
+    "coe-output": {
+        "label": {
+            "name": "Name",
+            "cmiconfig": "CMI Config",
+            "nodeNumber": "Node",
+            "outputNumber": "Output",
+            "dataType": "Data Type",
+            "unit": "Unit"
+        },
+        "status": {
+            "noconfig": "No config",
+            "queued": "queued",
+            "ready": "ready",
+            "merged": "sent (merged)"
+        }
+    }
+}

package/coe/locales/en-US/config.html

@@ -0,0 +1,13 @@
+<script type="text/html" data-help-name="cmiconfig">
+    <p><strong>Configuration:</strong></p>
+    <ul>
+        <li><b> Local IP:</b> IP Address range the UDP Port is listening on (Common values are 0.0.0.0 or 127.0.0.1)</li>
+        <li><b> Address:</b> IP Address of TA C.M.I used for sending CoE messages</li>
+    </ul>
+    <p><strong>CoE Version:</strong></p>
+    <ul>
+        <li><b>V1:</b> Default setting. Value range: ±32,767</li>
+        <li><b>V2:</b> Extended, requires CMI FW ≥v1.43.1. Value range: ±2,147,483,647</li>
+    </ul>
+    <p>See Settings > CAN in the CMI menu.</p>
+</script>

package/coe/locales/en-US/config.json

@@ -0,0 +1,10 @@
+{
+    "config": {
+        "label": {
+            "name": "Name",
+            "localip": "Local IP",
+            "address": "CMI Address",
+            "coeVersion": "CoE Version"
+        }
+    }
+}

package/coe/units-config.js

@@ -0,0 +1,36 @@
+/**
+ * API Endpoint for Units
+ * 
+ * Copyright 2025 Florian Mayrhofer
+ * Licensed under the Apache License, Version 2.0
+ *
+ */ 
+
+module.exports = function(RED) {
+    
+    const UNITS = require ('../lib/units.js');
+
+    function UnitConfigNode(config) {
+        RED.nodes.createNode(this, config);
+    }
+    
+    RED.nodes.registerType("unit-config", UnitConfigNode);
+
+    RED.httpAdmin.get('/ta-cmi-coe/units/:lang?', function(req, res) {
+        const lang = req.params.lang && req.params.lang.toLowerCase().startsWith("de") ? "de" : "en";
+
+        const localizedUnits = {};
+
+        Object.keys(UNITS).forEach(key => {
+            const unit = UNITS[key];
+            localizedUnits[key] = {
+                name: lang === "de" ? unit.name_de : unit.name_en,
+                symb: lang === "de" ? unit.symb_de : unit.symb_en,
+                decimals: unit.decimals
+            };
+        });
+
+        res.json(localizedUnits);
+    });
+
+};

package/lib/coe-v2.js

@@ -0,0 +1,189 @@
+/**
+ * CoE V2 Protocol Support Module
+ * 
+ * Copyright 2025 Florian Mayrhofer
+ * Licensed under the Apache License, Version 2.0
+ *
+ */ 
+
+const { convertCoEToValue, convertValueToCoE } = require('./utils.js');
+
+// CoE V2 Parsing function
+function parseCoEV2Packet(buffer) {
+    if (buffer.length < 4) {
+        return null;
+    }
+    
+    // Parse header
+    const versionLow = buffer.readUInt8(0);
+    const versionHigh = buffer.readUInt8(1);
+    const messageLength = buffer.readUInt8(2);
+    const blockCount = buffer.readUInt8(3);
+    
+    if (versionLow !== 0x02 || versionHigh !== 0x00) { // Validate version
+        console.warn(`V2: Ungültige Version: ${versionLow}.${versionHigh}`);
+        return null;
+    }
+    
+    const expectedLength = 4 + (blockCount * 8);
+    if (buffer.length < expectedLength) {
+        console.warn(`V2: Packet incomplete. Expected: ${expectedLength}, Received: ${buffer.length}`);
+        return null;
+    }
+    
+    // Parse value blocks
+    const blocks = [];
+    for (let i = 0; i < blockCount; i++) {
+        const offset = 4 + (i * 8);
+        const canNode = buffer.readUInt8(offset);
+        const outputNumber = buffer.readUInt16LE(offset + 1);
+        const unitId = buffer.readUInt8(offset + 3);
+        const value = buffer.readInt32LE(offset + 4);
+        
+        blocks.push({
+            canNode: canNode,
+            outputNumber: outputNumber,
+            unitId: unitId,
+            value: value,
+            isDigital: outputNumber <= 254,
+            isAnalog: outputNumber > 254
+        });
+    }
+    
+    return {
+        version: 2,
+        messageLength: messageLength,
+        blockCount: blockCount,
+        blocks: blocks
+    };
+}
+
+// Create CoE V2 Packet
+function createCoEV2Packet(canNode, outputs) {
+    // Outputs: Array von {outputNumber, unitId, value}
+    // Max 16 value blocks
+    const blockCount = Math.min(outputs.length, 16);
+    const messageLength = 4 + (blockCount * 8);
+    
+    const buffer = Buffer.alloc(messageLength);
+    
+    // Write header
+    buffer.writeUInt8(0x02, 0);  // Version Low
+    buffer.writeUInt8(0x00, 1);  // Version High
+    buffer.writeUInt8(messageLength, 2);  // Message Length
+    buffer.writeUInt8(blockCount, 3);  // Block Count
+    
+    // Write value blocks
+    for (let i = 0; i < blockCount; i++) {
+        const offset = 4 + (i * 8);
+        const output = outputs[i];
+        
+        buffer.writeUInt8(canNode, offset);  // CAN Node
+        
+        // Output Number (Little Endian, 2 Bytes)
+        buffer.writeUInt8(output.outputNumber & 0xFF, offset + 1);
+        buffer.writeUInt8((output.outputNumber >> 8) & 0xFF, offset + 2);
+        
+        buffer.writeUInt8(output.unitId || 0, offset + 3);  // Unit ID
+        buffer.writeInt32LE(output.value, offset + 4);  // Value (Int32 LE)
+    }
+    
+    return buffer;
+}
+
+// Convert V2 Data into V1 (for compatibility)
+function convertV2ToLegacyFormat(v2Data) {
+    // Group Outputs by block
+    const blockMap = {};
+    
+    v2Data.blocks.forEach(block => {
+        const isDigital = block.outputNumber <= 254;
+        const actualOutput = isDigital ? block.outputNumber : (block.outputNumber - 255);
+        
+        // Determine block number and position
+        let blockNumber, position;
+        
+        if (isDigital) {
+            // Digital: Output 1-16 → Block 0, Output 17-32 → Block 9
+            if (actualOutput <= 16) {
+                blockNumber = 0;
+                position = actualOutput - 1;
+            } else {
+                blockNumber = 9;
+                position = actualOutput - 17;
+            }
+        } else {
+            // Analog: Output 1-4 → Block 1, 5-8 → Block 2, etc.
+            blockNumber = Math.floor((actualOutput - 1) / 4) + 1;
+            position = (actualOutput - 1) % 4;
+        }
+        
+        const key = `${block.canNode}-${blockNumber}`;
+        
+        if (!blockMap[key]) {
+            blockMap[key] = {
+                nodeNumber: block.canNode,
+                blockNumber: blockNumber,
+                dataType: isDigital ? 'digital' : 'analog',
+                values: isDigital ? new Array(16).fill(undefined) : new Array(4).fill(undefined),
+                units: isDigital ? null : new Array(4).fill(undefined)
+            };
+        }
+        
+        // Convert value & insert (V2 uses other decimals)
+        const convertedValue = convertCoEToValue(block.value, block.unitId, 2);
+        blockMap[key].values[position] = isDigital ? (block.value ? 1 : 0) : convertedValue;
+        
+        if (!isDigital && blockMap[key].units) {
+            blockMap[key].units[position] = block.unitId;
+        }
+    });
+    
+    return Object.values(blockMap);
+}
+
+// Convert V1 Format to V2 Outputs
+function convertLegacyToV2Format(nodeNumber, blockNumber, values, units, dataType) {
+    const outputs = [];
+    
+    if (dataType === 'digital') {
+        // Digital: 16 Bits
+        const baseOutput = blockNumber === 0 ? 1 : 17;
+        for (let i = 0; i < values.length; i++) {
+            if (values[i] !== undefined) {
+                outputs.push({
+                    outputNumber: baseOutput + i,
+                    unitId: 0,
+                    value: values[i] ? 1 : 0
+                });
+            }
+        }
+    } else {
+        // Analog: 4 Values
+        const baseOutput = (blockNumber - 1) * 4 + 1;
+        for (let i = 0; i < 4; i++) {
+            if (values[i] !== undefined) {
+                const unitId = units ? units[i] : 0;
+                const rawValue = convertValueToCoE(values[i], unitId, 2); // V2 uses other decimals
+                
+                // Output > 255 = analog
+                const outputNumber = baseOutput + i + 255;
+                
+                outputs.push({
+                    outputNumber: outputNumber,
+                    unitId: unitId,
+                    value: rawValue
+                });
+            }
+        }
+    }
+    
+    return outputs;
+}
+
+module.exports = {
+    parseCoEV2Packet,
+    createCoEV2Packet,
+    convertV2ToLegacyFormat,
+    convertLegacyToV2Format
+};

package/lib/coe.js

@@ -0,0 +1,109 @@
+/**
+ * CoE Protocol Parsing and Creation Module
+ * 
+ * Copyright 2025 Florian Mayrhofer
+ * Licensed under the Apache License, Version 2.0
+ *
+ */ 
+
+const { parseCoEV2Packet, createCoEV2Packet, convertV2ToLegacyFormat, convertLegacyToV2Format } = require('./coe-v2');
+const { convertCoEToValue, convertValueToCoE } = require('./utils');
+
+// Parse CoE packet from buffer
+function parseCoEPacket(buffer, version) {
+
+    // If V2 Protokoll is used
+    if (version === 2) {
+        const v2Data = parseCoEV2Packet(buffer);
+        if (!v2Data) {
+            console.warn('V2: Unable to parse packet.');
+            return null;
+        }
+        
+        // Convert to legacy format for further processing
+        const legacyBlocks = convertV2ToLegacyFormat(v2Data);
+            
+        // Return all blocks (can be multiple)
+        return legacyBlocks;
+    }
+    
+    const nodeNumber = buffer.readUInt8(0);
+    const blockNumber = buffer.readUInt8(1);
+    
+    let values = [];
+    let units = [];
+    
+    if (blockNumber === 0 || blockNumber === 9) {
+        // digital
+        const bitField = buffer.readUInt16LE(2);
+        const unitId = buffer.readUInt8(11); // Block-wise unit id → byte 11
+        for (let i = 0; i < 16; i++) {
+            values.push((bitField >> i) & 1);
+            units.push(unitId);
+        }
+    } else {
+        // analog V1
+        for (let i = 0; i < 4; i++) {
+            const value = buffer.readInt16LE(2 + i * 2);
+            const unitId = buffer.readUInt8(10 + i);
+            
+            const convertedValue = convertCoEToValue(value, unitId, 1); // V1 decimals
+            values.push(convertedValue);
+            units.push(unitId);
+        }
+    }
+    
+    return [{
+        nodeNumber: nodeNumber,
+        blockNumber: blockNumber,
+        values: values,
+        units: units
+    }];
+}
+
+// Create CoE Packet from values
+function createCoEPacket(nodeNumber, blockNumber, values, units, dataType, version) {
+    // If V2 Protokoll is used
+    if (version === 2) {
+        const outputs = convertLegacyToV2Format(nodeNumber, blockNumber, values, units, dataType);
+        return createCoEV2Packet(nodeNumber, outputs);
+    }
+    
+    let buffer;
+    
+    if (dataType === 'digital') {
+        buffer = Buffer.alloc(14);
+        buffer.writeUInt8(nodeNumber, 0);
+        buffer.writeUInt8(blockNumber, 1);
+        
+        let bitField = 0;
+        for (let i = 0; i < 16; i++) {
+            if (values[i]) {
+                bitField |= (1 << i);
+            }
+        }
+        buffer.writeUInt16LE(bitField, 2);
+        buffer.fill(0, 4, buffer.length);
+        
+    } else { // analog
+        buffer = Buffer.alloc(14);
+        buffer.writeUInt8(nodeNumber, 0);
+        buffer.writeUInt8(blockNumber, 1);
+        
+        for (let i = 0; i < 4; i++) {
+            const unitId = units ? units[i] : 0;
+            const rawValue = convertValueToCoE(values[i], unitId, 1); // V1 Decimal places
+            
+            if (rawValue > 32767 || rawValue < -32768) {
+                console.warn(`Value ${values[i]} exceeds V1 limits. Consider using V2.`);
+            }
+            
+            buffer.writeInt16LE(Math.max(-32768, Math.min(32767, rawValue)), 2 + i * 2);
+            buffer.writeUInt8(unitId, 10 + i);
+        }
+    }
+    
+    return buffer;
+}
+
+module.exports = { parseCoEPacket, createCoEPacket};