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

package/lib/old.js

@@ -0,0 +1,133 @@
+/**
+ * CoE V2 Protocol Support Module
+ * 
+ * Copyright 2025 Florian Mayrhofer
+ * Licensed under the Apache License, Version 2.0
+ *
+ */ 
+
+// Convert V2 Data into Uniform format
+function convertV2ToUniformFormat(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.nodeNumber}-${blockNumber}`;
+        
+        if (!blockMap[key]) {
+            blockMap[key] = {
+                nodeNumber: block.nodeNumber,
+                blockNumber: blockNumber,
+                dataType: isDigital ? 'digital' : 'analog',
+                values: isDigital ? new Array(16).fill(undefined) : new Array(4).fill(undefined),
+                units: isDigital ? new Array(16).fill(undefined) : new Array(4).fill(undefined)
+            };
+        }
+        
+        // Convert value & insert (V2 uses other decimals)
+        const convertedValue = convertRawToValue(block.value, block.unitId, 2);
+        blockMap[key].values[position] = isDigital ? (block.value ? 1 : 0) : convertedValue;
+        
+        if (blockMap[key].units) {
+            blockMap[key].units[position] = block.unitId;
+        }
+    });
+    return Object.values(blockMap);
+}
+
+// Create CoE V2 Packet
+function createPacket(nodeNumber, dataType, outputs) {
+    // outputState: Array von {outputNumber, unit, value}
+    // Max 16 value blocks
+    const outputState = convertUniformToV2Format(dataType, outputs);
+    
+    const blockCount = Math.min(outputState.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 = outputState[i];
+        
+        buffer.writeUInt8(nodeNumber, offset);
+        
+        // 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 Uniform format to V2 outputs
+// function convertUniformToV2Format(blockNumber, values, units, dataType) {
+function convertUniformToV2Format(dataType, outputs) {
+    let outputState = [];
+    
+    if (dataType === 'digital') {
+        // Digital: 16 Bits
+        const baseOutput = blockNumber === 0 ? 1 : 17;
+        for (let i = 0; i < values.length; i++) {
+            if (values[i] !== undefined) {
+                const unitId = units && units[i] !== undefined ? units[i] : 0;
+
+                outputState.push({
+                    outputNumber: baseOutput + i,
+                    unitId: unitId,
+                    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 = convertValueToRaw(values[i], unitId, 2); // V2 uses other decimals
+                
+                // Output > 255 = analog
+                const outputNumber = baseOutput + i + 255;
+                
+                outputState.push({
+                    outputNumber: outputNumber,
+                    unitId: unitId,
+                    value: rawValue
+                });
+            }
+        }
+    }
+    
+    return outputState;
+}

package/lib/protocol.js

@@ -0,0 +1,19 @@
+/**
+ * CoE Protocol Parsing and Creation Module
+ * 
+ * Copyright 2025 Florian Mayrhofer
+ * Licensed under the Apache License, Version 2.0
+ *
+ */ 
+
+module.exports = {
+    // Parsing functions for CoE V1 and V2
+    createPacket: {
+        1: require('./coe-v1.js').createPacket,
+        2: require('./coe-v2.js').createPacket
+    },
+    parsePacket: {
+        1: require('./coe-v1.js').parsePacket,
+        2: require('./coe-v2.js').parsePacket
+    }
+};

package/lib/queueing.js

@@ -6,115 +6,69 @@
  *
  */ 
 
-const { createCoEPacket } = require('../lib/coe');
+const { createPacket } = require('./protocol');
 
-const blockStateCache = {};
-const blockUnitsCache = {}; // Cache for units per block
-const blockQueues = {};
 const blockTimers = {};
 const DEBOUNCE_DELAY = 50; // ms (Time slot for message collection)
+const outputStateCache = {};
+const queuedState = {};
 
-// Returns a copy of the current block state (values) for the given block
-function getBlockState(nodeNumber, blockNumber, dataType) {
-    const key = `${nodeNumber}-${blockNumber}-${dataType}`;
-    if (!blockStateCache[key]) {
-        if (dataType === 'analog') {
-            blockStateCache[key] = [0, 0, 0, 0];
-        } else {
-            blockStateCache[key] = new Array(16).fill(0);
-        }
-    }
-    // Return a copy to avoid accidental external mutation
-    return Array.isArray(blockStateCache[key]) ? [...blockStateCache[key]] : blockStateCache[key];
-}
-
-// Sets the current block state (values) for the given block
-function setBlockState(nodeNumber, blockNumber, dataType, values) {
-    const key = `${nodeNumber}-${blockNumber}-${dataType}`;
-    blockStateCache[key] = [...values];
+// Persist output state for a specific block
+function setOutputState(queueKey, output) {
+    outputStateCache[queueKey] = {
+        ...outputStateCache[queueKey],
+        outputs: output
+    };  
 }
 
-// Returns a copy of the current block units for the given block (analog only)
-function getBlockUnits(nodeNumber, blockNumber, dataType) {
-    const key = `${nodeNumber}-${blockNumber}-${dataType}`;
-    if (!blockUnitsCache[key]) {
-        // Only analog blocks have units
-        if (dataType === 'analog') {
-            blockUnitsCache[key] = [0, 0, 0, 0];
-        } else {
-            blockUnitsCache[key] = null;
+// Return a copy of the current message state
+function getOutputState(node, queueKey) {
+    if (!outputStateCache[queueKey]) {
+        outputStateCache[queueKey] = {
+            nodeNumber: node.nodeNumber,
+            dataType: node.dataType,
+            outputs: {}
         }
     }
-    return blockUnitsCache[key] ? [...blockUnitsCache[key]] : null;
+    return { ...outputStateCache[queueKey] };
 }
 
-// Sets the current block units for the given block (analog only)
-function setBlockUnits(nodeNumber, blockNumber, dataType, units) {
-    const key = `${nodeNumber}-${blockNumber}-${dataType}`;
-    if (dataType === 'analog') {
-        blockUnitsCache[key] = units ? [...units] : [0,0,0,0];
-    } else {
-        blockUnitsCache[key] = null;
-    }
-}
-
-// Generates a unique key for the queue based on node, block, and data type
-function getQueueKey(nodeNumber, blockNumber, dataType) {
-    return `${nodeNumber}-${blockNumber}-${dataType}`;
-}
 
 // Queues and debounces messages for a specific block
-function queueAndSend(node, translate, nodeNumber, blockNumber, values, units, dataType, version, cmiConfig, cmiAddress, origMsg) {
-    const queueKey = getQueueKey(nodeNumber, blockNumber, dataType);
+function queueAndSend(node) {
+    const valueState = {output: node.outputNumber, value: node.lastReceivedValue, unit: node.lastReceivedUnit};
+    const origMsg = node.lastReceivedMsg;
+    const queueKey = node.queueKey;
+    const coeVersion = node.coeVersion;
+    const cmiConfig = node.cmiConfig;
+    const cmiAddress = node.cmiAddress;
 
     // New queueing logic
-    let baseValues;
-    let baseUnits;
+    let initialOutputState;
+    let participatingNodes = new Set();
 
-    if (blockQueues[queueKey]) {
-        baseValues = [...blockQueues[queueKey].values];
-        baseUnits = blockQueues[queueKey].units ? [...blockQueues[queueKey].units] : null;
+    if (queuedState[queueKey]) {
+        participatingNodes = queuedState[queueKey].participating.add(node);
     } else {
-        baseValues = getBlockState(nodeNumber, blockNumber, dataType);
-        baseUnits = (dataType === 'analog') ? getBlockUnits(nodeNumber, blockNumber, dataType) : null;
+        queuedState[queueKey] = {
+            timestamp: Date.now(),
+            participating: participatingNodes.add(node),
+            origMsg: origMsg || null
+        }
     }
 
+    initialOutputState = getOutputState(node, queueKey).outputs;
+
     // Merge incoming values/units with existing block state
-    let mergedValues = baseValues;
-    let mergedUnits = baseUnits;
-    
-    if (dataType === 'analog') {
-        for (let i = 0; i < 4; i++) {
-            if (values[i] !== undefined && values[i] !== null) {
-                mergedValues[i] = values[i];
-            }
-            if (units && units[i] !== undefined) {
-                mergedUnits[i] = units[i];
-            }
-        }
-    } else {
-        for (let i = 0; i < 16; i++) {
-            if (values[i] !== undefined) {
-                mergedValues[i] = values[i];
-            }
-        }
+    let mergedOutputState = initialOutputState;
+
+    if (valueState.output !== undefined && valueState.output !== null) {
+        mergedOutputState[valueState.output] = { 
+            value: valueState.value, 
+            unit: valueState.unit 
+        };
     }
 
-    if (!blockQueues[queueKey]) { // Create queue, if none
-            blockQueues[queueKey] = {
-                values: mergedValues,
-                units: mergedUnits,
-                node: node,
-                timestamp: Date.now(),
-                origMsg: origMsg || null
-            };
-        } else { // Overwrite state, if queue exists
-            const q = blockQueues[queueKey];
-            q.values = mergedValues;
-            q.units = mergedUnits;
-            q.origMsg = origMsg || q.origMsg;
-        }
-        
     // Delete existing timer if any
     if (blockTimers[queueKey]) {
         clearTimeout(blockTimers[queueKey]);
@@ -122,67 +76,68 @@ function queueAndSend(node, translate, nodeNumber, blockNumber, values, units, d
 
     // Start a new timer to send the queued message after the debounce delay
     blockTimers[queueKey] = setTimeout(() => {
-        const queued = blockQueues[queueKey];
-        if (queued) {
-            const packet = createCoEPacket(
+        const nodeNumber = outputStateCache[queueKey].nodeNumber;
+        const dataType = outputStateCache[queueKey].dataType;
+        const queued = mergedOutputState;
+        if (outputStateCache[queueKey]) {
+            const packet = createPacket[coeVersion](
                 nodeNumber,
-                blockNumber,
-                queued.values,
-                queued.units,
                 dataType,
-                version
+                queued
             );
             
-            // Persist both values and units for the block
-            setBlockState(nodeNumber, blockNumber, dataType, queued.values);
-            if (dataType === 'analog') {
-                setBlockUnits(nodeNumber, blockNumber, dataType, queued.units);
-            }
+            // Persist the merged output state for the queue
+            setOutputState(queueKey, queued);
+
+            cmiConfig.send(cmiAddress, packet);
+
+            const now = Date.now();
+            const mergedText = node._("coe-output.status.merged");
+            const readyText = node._("coe-output.status.ready");
+
+            queuedState[queueKey].participating.forEach(participatingNode => {
+                const outputNumber = participatingNode.outputNumber;
+
+                // Guard against missing sparse entries
+                participatingNode.lastSentValue = (queued[outputNumber] && queued[outputNumber].value !== undefined) ? queued[outputNumber].value : undefined;
+                participatingNode.lastSentTime = now;
             
-            // Send debug output on the node outputs: [original msg, debug info]
-            try {
-                const debugPayload = {
-                    debug: {
-                        hex: packet.toString('hex').toUpperCase(),
-                        node: nodeNumber,
-                        block: blockNumber,
-                        dataType: dataType,
-                        version: version,
-                        blockState: queued.values,
-                        units: queued.units
-                    }
-                };
-                // If node has outputs, send original msg on first output and debug on second
-                queued.node.send([queued.origMsg || null, { payload: debugPayload }]);
-            } catch (err) {
-                // Do not break sending on debug failure
-                queued.node.warn(`Failed to send debug msg: ${err.message}`);
-            }
-                const mergedText = translate("coe-output.status.merged");
-                const readyText = translate("coe-output.status.ready");
-
-                cmiConfig.send(cmiAddress, packet);
-                
-                queued.node.status({
+                participatingNode.status({
                     fill: "green",
                     shape: "dot",
-                    text: `${mergedText} [${version}]`
+                    text: `${mergedText} [v${coeVersion}]`
                 });
-                
                 setTimeout(() => {
-                    queued.node.status({fill: "grey", shape: "ring", text: `${readyText} [v${version}]`});
-                }, 2000);
+                    participatingNode.status({fill: "grey", shape: "ring", text: `${readyText} [v${coeVersion}]`});
+                }, 5000);
+
+                // Send debug output on the node outputs: [original msg, debug info]
+                try {
+                    const debugPayload = {
+                        debug: {
+                            node: nodeNumber,
+                            dataType: dataType,
+                            output: outputNumber,
+                            value: queued[outputNumber] ? queued[outputNumber].value : undefined,
+                            unit: queued[outputNumber] ? queued[outputNumber].unit : undefined
+                            // raw: packet.toString('hex').toUpperCase()
+                        }
+                    };
+                    // If node has outputs, send original msg on first output and debug on second
+                    participatingNode.send([queuedState[queueKey].origMsg || null, { payload: debugPayload }]);
+                } catch (err) {
+                    // Do not break sending on debug failure
+                    participatingNode.warn(`Failed to send debug msg: ${err.message}`);
+                }
+
+            });
                 
-                delete blockQueues[queueKey];
-                delete blockTimers[queueKey];
-            }
-        }, DEBOUNCE_DELAY);
+            delete queuedState[queueKey];
+            delete blockTimers[queueKey];
+        }
+    }, DEBOUNCE_DELAY);
 }
 
 module.exports = {
-    getBlockState,
-    setBlockState,
-    getBlockUnits,
-    setBlockUnits,
     queueAndSend
 };

package/lib/units.js

@@ -33,7 +33,7 @@ const UNITS = {
 22: { name_de: 'Durchfluss l/min', symb_de: 'l/min',name_en: 'Flow rate l/min', symb_en: 'l/min', decimals: 0 },
 23: { name_de: 'Druck bar', symb_de: 'bar',name_en: 'Pressure bar', symb_en: 'bar', decimals: 2 },
 24: { name_de: 'Arbeitszahl', symb_de: '',name_en: 'COP', symb_en: '', decimals: 2 },
-25: { name_de: 'Länge km', symb_de: 'km',name_en: 'Length km', symb_en: 'km', decimals: 0 },
+25: { name_de: 'Länge km', symb_de: 'km',name_en: 'Length km', symb_en: 'km', decimals: 0},
 26: { name_de: 'Länge m', symb_de: 'm',name_en: 'Length m', symb_en: 'm', decimals: 1 },
 27: { name_de: 'Länge mm', symb_de: 'mm',name_en: 'Length mm', symb_en: 'mm', decimals: 1 },
 28: { name_de: 'Kubikmeter', symb_de: 'm³',name_en: 'Cubic meters', symb_en: 'm³', decimals: 0 },
@@ -45,8 +45,8 @@ const UNITS = {
 40: { name_de: 'Geschwindigkeit mm/min', symb_de: 'mm/min',name_en: 'Speed mm/min', symb_en: 'mm/min', decimals: 0 },
 41: { name_de: 'Geschwindigkeit mm/h', symb_de: 'mm/h',name_en: 'Speed mm/h', symb_en: 'mm/h', decimals: 0 },
 42: { name_de: 'Geschwindigkeit mm/d', symb_de: 'mm/d',name_en: 'Speed mm/d', symb_en: 'mm/d', decimals: 0 },
-43: { name_de: 'Digital (aus/ein)', symb_de: 'Aus/Ein',name_en: 'Digital (off/on)', symb_en: 'Off/On', decimals: 0 },
-44: { name_de: 'Digital (nein/ja)', symb_de: 'Nein/Ja',name_en: 'Digital (no/yes)', symb_en: 'No/Yes', decimals: 0 },
+43: { name_de: 'Ein/Aus', symb_de: 'Aus/Ein',name_en: 'On/Off', symb_en: 'Off/On', decimals: 0, digital: true },
+44: { name_de: 'Ja/Nein', symb_de: 'Nein/Ja',name_en: 'Yes/No', symb_en: 'No/Yes', decimals: 0, digital: true },
 46: { name_de: 'RAS', symb_de: '°C',name_en: 'RAS', symb_en: '°C', decimals: 1 },
 50: { name_de: 'Euro', symb_de: '€',name_en: 'Euro', symb_en: '€', decimals: 2 },
 51: { name_de: 'Dollar', symb_de: '$',name_en: 'Dollar', symb_en: '$', decimals: 2 },
@@ -62,17 +62,17 @@ const UNITS = {
 65: { name_de: 'Druck mbar', symb_de: 'mbar',name_en: 'Pressure mbar', symb_en: 'mbar', decimals: 1 },
 66: { name_de: 'Druck Pa', symb_de: 'Pa',name_en: 'Pressure Pa', symb_en: 'Pa', decimals: 0 },
 67: { name_de: 'CO2-Gehalt ppm', symb_de: 'ppm',name_en: 'CO2 content ppm', symb_en: 'ppm', decimals: 0 },
-68: { name_de: '', symb_de: '',name_en: '', symb_en: '', decimals: 0 },
 69: { name_de: 'Leistung W', symb_de: 'W',name_en: 'Power W', symb_en: 'W', decimals: 0 },
 70: { name_de: 'Gewicht t', symb_de: 't',name_en: 'Weight t', symb_en: 't', decimals: 2 },
-71: { name_de: 'Gewicht kg', symb_de: 'kg',name_en: 'Weight kg', symb_en: 'kg', decimals: 1 },
+71: { name_de: 'Gewicht kg', symb_de: 'kg',name_en: 'Weight kg', symb_en: 'kg', decimals: 1},
 72: { name_de: 'Gewicht g', symb_de: 'g',name_en: 'Weight g', symb_en: 'g', decimals: 1 },
 73: { name_de: 'Länge cm', symb_de: 'cm',name_en: 'Length cm', symb_en: 'cm', decimals: 1 },
 74: { name_de: 'Temperatur K', symb_de: 'K',name_en: 'Temperature K', symb_en: 'K', decimals: 0 },
 75: { name_de: 'Lichtstärke', symb_de: 'lx',name_en: 'Light intensity', symb_en: 'lx', decimals: 1 },
 76: { name_de: 'Radonkonzentration', symb_de: 'Bq/m³',name_en: 'Radon concentration', symb_en: 'Bq/m³', decimals: 0 },
 77: { name_de: 'Preis ct/kWh', symb_de: 'ct/kWh',name_en: 'Price ct/kWh', symb_en: 'ct/kWh', decimals: 3 },
-78: { name_de: 'Digital (geschl./offen)', symb_de: 'Geschlossen/Offen',name_en: 'Digital (closed/open)', symb_en: 'Closed/Open', decimals: 0 }
+78: { name_de: 'Offen/Geschlossen', symb_de: 'Geschlossen/Offen',name_en: 'Open/Closed', symb_en: 'Closed/Open', decimals: 0, digital: true },
+79: { name_de: 'Konzentration ppb', symb_de: 'ppb',name_en: 'Concentration ppb', symb_en: 'ppb', decimals: 0 }
 };
 
-module.exports = UNITS;
+module.exports = UNITS ;

package/lib/utils.js

@@ -9,13 +9,13 @@
 const UNITS = require ('./units.js');
 
 // Utilities for unit conversion
-function convertCoEToValue(rawValue, unitId, protocolVersion) {
-    const unitDecimals = getUnitDecimals(unitId, protocolVersion);
+function convertRawToValue(rawValue, unitId, coeVersion) {
+    const unitDecimals = getUnitDecimals(unitId, coeVersion);
     return rawValue / Math.pow(10, unitDecimals);
 }
 
-function convertValueToCoE(value, unitId, protocolVersion) {
-    const unitDecimals = getUnitDecimals(unitId, protocolVersion);
+function convertValueToRaw(value, unitId, coeVersion) {
+    const unitDecimals = getUnitDecimals(unitId, coeVersion);
     return Math.round(value * Math.pow(10, unitDecimals));
 }
 
@@ -25,11 +25,11 @@ function getUnitInfo(unitId, langCode) {
     const idKey = String(unitId);
 
     // Use UNITS from units.js as base
-    if (UNITS && UNITS[idKey]) { 
+    if (UNITS && UNITS[idKey]) {
         const unit = UNITS[idKey];
         return {
             name: useGerman ? unit.name_de : unit.name_en,
-            symbol: useGerman ? unit.symb_de : unit.symb_en
+            symbol: unit.digital ? '' : (useGerman ? unit.symb_de : unit.symb_en) // No symbol for digital types
         };
     } else {
         return {
@@ -39,6 +39,19 @@ function getUnitInfo(unitId, langCode) {
     }
 }
 
+// Generate digital state key based on unit and value
+function getDigitalStateKey(unit, value, prefix = "coe.status.") {
+    const states = {
+        43: value ? "on" : "off",
+        44: value ? "yes" : "no",
+        78: value ? "open" : "closed",
+        default: value ? "on" : "off"
+    };
+
+    const state = states[unit] || states.default;
+    return `${prefix}${state}`;
+}
+
 // Retrieve unit decimals from unit list
 function getUnitDecimals(unitId, protocolVersion) {
     let unitDecimals;
@@ -74,90 +87,82 @@ function getUnitLanguage(lang) {
 
 // Translate output number to block position (CoE V1)
 function getBlockInfo(dataType, outputNumber) {
+    let blockNumber, position, dType;
     outputNumber = parseInt(outputNumber);
-    if (isNaN(outputNumber) || outputNumber < 1) {
-        // Default to block 1 position 0
-        return { block: 1, position: 0 };
-    }
 
-    if (dataType === 'analog') {
-        // Analog: Outputs 1..32 → Blocks 1..8 (4 Outputs each)
-        const block = Math.floor((outputNumber - 1) / 4) + 1; // 1..8
-        const position = (outputNumber - 1) % 4; // 0..3
-        return { block: block, position: position };
+    if (isNaN(outputNumber) || outputNumber < 1) { // Default to block 1 position 0
+        blockNumber = 1;
+        position = 0;
+        dType = 'a';
     } else {
-        // Digital: Outputs 1..16 → Block 0, 17..32 → Block 9
-        if (outputNumber <= 16) {
-            return { block: 0, position: outputNumber - 1 }; // 0..15
+        if (dataType === 'analog') {
+            // Analog: Outputs 1..32 → Blocks 1..8 (4 Outputs each)
+            blockNumber = Math.floor((outputNumber - 1) / 4) + 1; // 1..8
+            position = (outputNumber - 1) % 4; // 0..3
+            dType = 'a';
         } else {
-            return { block: 9, position: outputNumber - 17 }; // 0..15
-        }
-    }
-}
-
-// Merge incoming (V2) block data with LKGV (Last Known Good Values)
-function mergeBlockData(currentState, newBlock) {
-    const isDigital = newBlock.dataType === 'digital' || newBlock.blockNumber === 0 || newBlock.blockNumber === 9;
-    const numValues = isDigital ? 16 : 4;
-    
-    const updatedBlock = { // Initialize the updated block (copy)
-        ...currentState,
-        values: new Array(numValues).fill(undefined),
-        units: isDigital ? null : new Array(numValues).fill(undefined)
-    };
-
-    const oldValues = currentState.values || [];
-    const oldUnits = currentState.units || [];
-
-    for (let i = 0; i < numValues; i++) { // Copy the old LKGV (Last Known Good Values)
-        if (oldValues[i] !== undefined) {
-                updatedBlock.values[i] = oldValues[i];
-        }
-    }
-
-    if (!isDigital && updatedBlock.units && oldUnits) { // Copy old units
-        for (let i = 0; i < 4; i++) {
-            if (oldUnits[i] !== undefined) {
-                updatedBlock.units[i] = oldUnits[i];
+            dType = 'd';
+            // Digital: Outputs 1..16 → Block 0, 17..32 → Block 9
+            if (outputNumber <= 16) {
+                blockNumber = 0;
+                position = outputNumber - 1; // 0..1
+            } else {
+                blockNumber = 9;
+                position = outputNumber - 17; // 0..15
             }
         }
     }
+    return { number: blockNumber, position: position};
+}
 
-    for (let i = 0; i < numValues; i++) { // Merge with the new (sparse V2) values
-        if (newBlock.values && newBlock.values[i] !== undefined) {
-            updatedBlock.values[i] = newBlock.values[i];
-        }
+// Translate block number to output arrays (CoE V1)
+function getOutputsfromBlock(blockNumber, dataType) { 
+    let start, length;
+    if (dataType === 'analog') {
+        length = 4;
+        start = ((blockNumber - 1) * 4) + 1;
     }
-
-    if (!isDigital && updatedBlock.units && newBlock.units) { // Merge the new units (only analog)
-        for (let i = 0; i < 4; i++) {
-            if (newBlock.units[i] !== undefined) {
-                updatedBlock.units[i] = newBlock.units[i];
-            }
+    else { // digital
+        length = 16;
+        if (blockNumber === 0) {
+            start = 1;
+        } else { // block 9
+            start = 17;
         }
     }
+    return Array.from({ length }, (_, i) => start + i); 
+}
 
-    return updatedBlock;
+// Merge incoming (V2) node data with LKGV (Last Known Good Values)
+function mergeNodeData(currentState, newNode) {
+    return { 
+        ...currentState, 
+        ...newNode, 
+        outputs: { 
+            ...currentState.outputs, 
+            ...newNode.outputs 
+        } 
+    }; 
 }
 
 // Create empty block state (incoming block)
 function createEmptyState(incomingBlock) {
-    const isDigital = incomingBlock.dataType === 'digital' || incomingBlock.blockNumber === 0 || incomingBlock.blockNumber === 9;
-    const numValues = isDigital ? 16 : 4;
+    const isDigital = incomingBlock.dataType === 'digital';
+
     return {
         nodeNumber: incomingBlock.nodeNumber,
-        blockNumber: incomingBlock.blockNumber,
         dataType: isDigital ? 'digital' : 'analog',
-        values: new Array(numValues).fill(undefined),
-        units: isDigital ? null : new Array(numValues).fill(undefined),
+        outputs: {}
     };
 }
 
 module.exports = {
-    convertCoEToValue,
-    convertValueToCoE,
+    convertRawToValue,
+    convertValueToRaw,
     getUnitInfo,
+    getDigitalStateKey,
     getBlockInfo,
-    mergeBlockData,
+    getOutputsfromBlock,
+    mergeNodeData,
     createEmptyState
 };