You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@plc4x.apache.org by hu...@apache.org on 2023/05/21 04:34:28 UTC

[plc4x] 03/03: feat(plc4py): Clean up debug info

This is an automated email from the ASF dual-hosted git repository.

hutcheb pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/plc4x.git

commit 67272f7a11d15c3543360da8cef8f6eb5dd4a846
Author: Ben Hutcheson <be...@gmail.com>
AuthorDate: Sun May 21 06:27:01 2023 +0200

    feat(plc4py): Clean up debug info
---
 .../python/PythonLanguageTemplateHelper.java       |   2 +-
 .../plc4py/protocols/modbus/readwrite/DataItem.py  | 354 ++++++++---------
 .../plc4py/protocols/modbus/readwrite/ModbusADU.py |   8 +-
 .../plc4py/protocols/modbus/readwrite/ModbusPDU.py |  78 ++--
 .../protocols/simulated/readwrite/DataItem.py      | 420 ++++++++++-----------
 5 files changed, 431 insertions(+), 431 deletions(-)

diff --git a/code-generation/language-python/src/main/java/org/apache/plc4x/language/python/PythonLanguageTemplateHelper.java b/code-generation/language-python/src/main/java/org/apache/plc4x/language/python/PythonLanguageTemplateHelper.java
index 9e946ad645..b8fe936846 100644
--- a/code-generation/language-python/src/main/java/org/apache/plc4x/language/python/PythonLanguageTemplateHelper.java
+++ b/code-generation/language-python/src/main/java/org/apache/plc4x/language/python/PythonLanguageTemplateHelper.java
@@ -1056,7 +1056,7 @@ public class PythonLanguageTemplateHelper extends BaseFreemarkerLanguageTemplate
         if ((parserArguments != null) && parserArguments.stream()
             .anyMatch(argument -> argument.getName().equals(variableLiteralName))) {
             tracer = tracer.dive("parser argument");
-            return tracer + variableLiteralName + "66" +
+            return tracer + variableLiteralName +
                 variableLiteral.getChild()
                     .map(child -> "." + camelCaseToSnakeCase(toVariableExpression(field, typeReference, child, parserArguments, serializerArguments, false, suppressPointerAccess, true)))
                     .orElse("");
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/DataItem.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/DataItem.py
index 84c761aa36..58f87c19d6 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/DataItem.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/DataItem.py
@@ -40,9 +40,9 @@ class DataItem:
         read_buffer: ReadBuffer, data_type: ModbusDataType, number_of_values: c_uint16
     ):
         if EvaluationHelper.equals(
-            data_type66, ModbusDataType.get_bool()
+            data_type, ModbusDataType.get_bool()
         ) and EvaluationHelper.equals(
-            number_of_values66, c_uint16(1)
+            number_of_values, c_uint16(1)
         ):  # BOOL
             # Reserved Field (Compartmentalized so the "reserved" variable can't leak)
             reserved: c_uint16 = read_buffer.readUnsignedInt("", 15)
@@ -59,27 +59,27 @@ class DataItem:
             value: c_bool = read_buffer.readBit("")
 
             return PlcBOOL(value)
-        if EvaluationHelper.equals(data_type66, ModbusDataType.get_bool()):  # List
+        if EvaluationHelper.equals(data_type, ModbusDataType.get_bool()):  # List
             # Array field (value)
             # Count array
-            if numberOfValues66 > Integer.MAX_VALUE:
+            if numberOfValues > Integer.MAX_VALUE:
                 raise ParseException(
                     "Array count of "
-                    + (numberOfValues66)
+                    + (numberOfValues)
                     + " exceeds the maximum allowed count of "
                     + Integer.MAX_VALUE
                 )
 
-            item_count: int = int(numberOfValues66)
+            item_count: int = int(numberOfValues)
             value: List[PlcValue] = []
             for cur_item in range(item_count):
                 value.append(PlcBOOL(c_bool(read_buffer.readBit(""))))
 
             return PlcList(value)
         if EvaluationHelper.equals(
-            data_type66, ModbusDataType.get_byte()
+            data_type, ModbusDataType.get_byte()
         ) and EvaluationHelper.equals(
-            number_of_values66, c_uint16(1)
+            number_of_values, c_uint16(1)
         ):  # BYTE
             # Reserved Field (Compartmentalized so the "reserved" variable can't leak)
             reserved: c_uint8 = read_buffer.readUnsignedShort("", 8)
@@ -96,42 +96,42 @@ class DataItem:
             value: c_uint8 = read_buffer.readUnsignedShort("", 8)
 
             return PlcBYTE(value)
-        if EvaluationHelper.equals(data_type66, ModbusDataType.get_byte()):  # List
+        if EvaluationHelper.equals(data_type, ModbusDataType.get_byte()):  # List
             # Array field (value)
             # Count array
-            if numberOfValues66 * c_int32(8) > Integer.MAX_VALUE:
+            if numberOfValues * c_int32(8) > Integer.MAX_VALUE:
                 raise ParseException(
                     "Array count of "
-                    + (numberOfValues66 * c_int32(8))
+                    + (numberOfValues * c_int32(8))
                     + " exceeds the maximum allowed count of "
                     + Integer.MAX_VALUE
                 )
 
-            item_count: int = int(numberOfValues66 * c_int32(8))
+            item_count: int = int(numberOfValues * c_int32(8))
             value: List[PlcValue] = []
             for cur_item in range(item_count):
                 value.append(PlcBOOL(c_bool(read_buffer.readBit(""))))
 
             return PlcList(value)
-        if EvaluationHelper.equals(data_type66, ModbusDataType.get_word()):  # WORD
+        if EvaluationHelper.equals(data_type, ModbusDataType.get_word()):  # WORD
             # Simple Field (value)
             value: c_uint16 = read_buffer.readUnsignedInt("", 16)
 
             return PlcWORD(value)
-        if EvaluationHelper.equals(data_type66, ModbusDataType.get_dword()):  # DWORD
+        if EvaluationHelper.equals(data_type, ModbusDataType.get_dword()):  # DWORD
             # Simple Field (value)
             value: c_uint32 = read_buffer.readUnsignedLong("", 32)
 
             return PlcDWORD(value)
-        if EvaluationHelper.equals(data_type66, ModbusDataType.get_lword()):  # LWORD
+        if EvaluationHelper.equals(data_type, ModbusDataType.get_lword()):  # LWORD
             # Simple Field (value)
             value: c_uint64 = read_buffer.readUnsignedBigInteger("", 64)
 
             return PlcLWORD(value)
         if EvaluationHelper.equals(
-            data_type66, ModbusDataType.get_sint()
+            data_type, ModbusDataType.get_sint()
         ) and EvaluationHelper.equals(
-            number_of_values66, c_uint16(1)
+            number_of_values, c_uint16(1)
         ):  # SINT
             # Reserved Field (Compartmentalized so the "reserved" variable can't leak)
             reserved: c_uint8 = read_buffer.readUnsignedShort("", 8)
@@ -148,105 +148,105 @@ class DataItem:
             value: c_int8 = read_buffer.readSignedByte("", 8)
 
             return PlcSINT(value)
-        if EvaluationHelper.equals(data_type66, ModbusDataType.get_sint()):  # List
+        if EvaluationHelper.equals(data_type, ModbusDataType.get_sint()):  # List
             # Array field (value)
             # Count array
-            if numberOfValues66 > Integer.MAX_VALUE:
+            if numberOfValues > Integer.MAX_VALUE:
                 raise ParseException(
                     "Array count of "
-                    + (numberOfValues66)
+                    + (numberOfValues)
                     + " exceeds the maximum allowed count of "
                     + Integer.MAX_VALUE
                 )
 
-            item_count: int = int(numberOfValues66)
+            item_count: int = int(numberOfValues)
             value: List[PlcValue] = []
             for cur_item in range(item_count):
                 value.append(PlcSINT(c_int8(read_buffer.readSignedByte("", 8))))
 
             return PlcList(value)
         if EvaluationHelper.equals(
-            data_type66, ModbusDataType.get_int()
+            data_type, ModbusDataType.get_int()
         ) and EvaluationHelper.equals(
-            number_of_values66, c_uint16(1)
+            number_of_values, c_uint16(1)
         ):  # INT
             # Simple Field (value)
             value: c_int16 = read_buffer.readShort("", 16)
 
             return PlcINT(value)
-        if EvaluationHelper.equals(data_type66, ModbusDataType.get_int()):  # List
+        if EvaluationHelper.equals(data_type, ModbusDataType.get_int()):  # List
             # Array field (value)
             # Count array
-            if numberOfValues66 > Integer.MAX_VALUE:
+            if numberOfValues > Integer.MAX_VALUE:
                 raise ParseException(
                     "Array count of "
-                    + (numberOfValues66)
+                    + (numberOfValues)
                     + " exceeds the maximum allowed count of "
                     + Integer.MAX_VALUE
                 )
 
-            item_count: int = int(numberOfValues66)
+            item_count: int = int(numberOfValues)
             value: List[PlcValue] = []
             for cur_item in range(item_count):
                 value.append(PlcINT(c_int16(read_buffer.readShort("", 16))))
 
             return PlcList(value)
         if EvaluationHelper.equals(
-            data_type66, ModbusDataType.get_dint()
+            data_type, ModbusDataType.get_dint()
         ) and EvaluationHelper.equals(
-            number_of_values66, c_uint16(1)
+            number_of_values, c_uint16(1)
         ):  # DINT
             # Simple Field (value)
             value: c_int32 = read_buffer.readInt("", 32)
 
             return PlcDINT(value)
-        if EvaluationHelper.equals(data_type66, ModbusDataType.get_dint()):  # List
+        if EvaluationHelper.equals(data_type, ModbusDataType.get_dint()):  # List
             # Array field (value)
             # Count array
-            if numberOfValues66 > Integer.MAX_VALUE:
+            if numberOfValues > Integer.MAX_VALUE:
                 raise ParseException(
                     "Array count of "
-                    + (numberOfValues66)
+                    + (numberOfValues)
                     + " exceeds the maximum allowed count of "
                     + Integer.MAX_VALUE
                 )
 
-            item_count: int = int(numberOfValues66)
+            item_count: int = int(numberOfValues)
             value: List[PlcValue] = []
             for cur_item in range(item_count):
                 value.append(PlcDINT(c_int32(read_buffer.readInt("", 32))))
 
             return PlcList(value)
         if EvaluationHelper.equals(
-            data_type66, ModbusDataType.get_lint()
+            data_type, ModbusDataType.get_lint()
         ) and EvaluationHelper.equals(
-            number_of_values66, c_uint16(1)
+            number_of_values, c_uint16(1)
         ):  # LINT
             # Simple Field (value)
             value: c_int64 = read_buffer.readLong("", 64)
 
             return PlcLINT(value)
-        if EvaluationHelper.equals(data_type66, ModbusDataType.get_lint()):  # List
+        if EvaluationHelper.equals(data_type, ModbusDataType.get_lint()):  # List
             # Array field (value)
             # Count array
-            if numberOfValues66 > Integer.MAX_VALUE:
+            if numberOfValues > Integer.MAX_VALUE:
                 raise ParseException(
                     "Array count of "
-                    + (numberOfValues66)
+                    + (numberOfValues)
                     + " exceeds the maximum allowed count of "
                     + Integer.MAX_VALUE
                 )
 
-            item_count: int = int(numberOfValues66)
+            item_count: int = int(numberOfValues)
             value: List[PlcValue] = []
             for cur_item in range(item_count):
                 value.append(PlcLINT(c_int64(read_buffer.readLong("", 64))))
 
             return PlcList(value)
         if EvaluationHelper.equals(
-            data_type66, ModbusDataType.get_usint()
+            data_type, ModbusDataType.get_usint()
         ) and EvaluationHelper.equals(
-            number_of_values66, c_uint16(1)
+            number_of_values, c_uint16(1)
         ):  # USINT
             # Reserved Field (Compartmentalized so the "reserved" variable can't leak)
             reserved: c_uint8 = read_buffer.readUnsignedShort("", 8)
@@ -263,96 +263,96 @@ class DataItem:
             value: c_uint8 = read_buffer.readUnsignedShort("", 8)
 
             return PlcUSINT(value)
-        if EvaluationHelper.equals(data_type66, ModbusDataType.get_usint()):  # List
+        if EvaluationHelper.equals(data_type, ModbusDataType.get_usint()):  # List
             # Array field (value)
             # Count array
-            if numberOfValues66 > Integer.MAX_VALUE:
+            if numberOfValues > Integer.MAX_VALUE:
                 raise ParseException(
                     "Array count of "
-                    + (numberOfValues66)
+                    + (numberOfValues)
                     + " exceeds the maximum allowed count of "
                     + Integer.MAX_VALUE
                 )
 
-            item_count: int = int(numberOfValues66)
+            item_count: int = int(numberOfValues)
             value: List[PlcValue] = []
             for cur_item in range(item_count):
                 value.append(PlcUINT(c_uint8(read_buffer.readUnsignedShort("", 8))))
 
             return PlcList(value)
         if EvaluationHelper.equals(
-            data_type66, ModbusDataType.get_uint()
+            data_type, ModbusDataType.get_uint()
         ) and EvaluationHelper.equals(
-            number_of_values66, c_uint16(1)
+            number_of_values, c_uint16(1)
         ):  # UINT
             # Simple Field (value)
             value: c_uint16 = read_buffer.readUnsignedInt("", 16)
 
             return PlcUINT(value)
-        if EvaluationHelper.equals(data_type66, ModbusDataType.get_uint()):  # List
+        if EvaluationHelper.equals(data_type, ModbusDataType.get_uint()):  # List
             # Array field (value)
             # Count array
-            if numberOfValues66 > Integer.MAX_VALUE:
+            if numberOfValues > Integer.MAX_VALUE:
                 raise ParseException(
                     "Array count of "
-                    + (numberOfValues66)
+                    + (numberOfValues)
                     + " exceeds the maximum allowed count of "
                     + Integer.MAX_VALUE
                 )
 
-            item_count: int = int(numberOfValues66)
+            item_count: int = int(numberOfValues)
             value: List[PlcValue] = []
             for cur_item in range(item_count):
                 value.append(PlcUDINT(c_uint16(read_buffer.readUnsignedInt("", 16))))
 
             return PlcList(value)
         if EvaluationHelper.equals(
-            data_type66, ModbusDataType.get_udint()
+            data_type, ModbusDataType.get_udint()
         ) and EvaluationHelper.equals(
-            number_of_values66, c_uint16(1)
+            number_of_values, c_uint16(1)
         ):  # UDINT
             # Simple Field (value)
             value: c_uint32 = read_buffer.readUnsignedLong("", 32)
 
             return PlcUDINT(value)
-        if EvaluationHelper.equals(data_type66, ModbusDataType.get_udint()):  # List
+        if EvaluationHelper.equals(data_type, ModbusDataType.get_udint()):  # List
             # Array field (value)
             # Count array
-            if numberOfValues66 > Integer.MAX_VALUE:
+            if numberOfValues > Integer.MAX_VALUE:
                 raise ParseException(
                     "Array count of "
-                    + (numberOfValues66)
+                    + (numberOfValues)
                     + " exceeds the maximum allowed count of "
                     + Integer.MAX_VALUE
                 )
 
-            item_count: int = int(numberOfValues66)
+            item_count: int = int(numberOfValues)
             value: List[PlcValue] = []
             for cur_item in range(item_count):
                 value.append(PlcULINT(c_uint32(read_buffer.readUnsignedLong("", 32))))
 
             return PlcList(value)
         if EvaluationHelper.equals(
-            data_type66, ModbusDataType.get_ulint()
+            data_type, ModbusDataType.get_ulint()
         ) and EvaluationHelper.equals(
-            number_of_values66, c_uint16(1)
+            number_of_values, c_uint16(1)
         ):  # ULINT
             # Simple Field (value)
             value: c_uint64 = read_buffer.readUnsignedBigInteger("", 64)
 
             return PlcULINT(value)
-        if EvaluationHelper.equals(data_type66, ModbusDataType.get_ulint()):  # List
+        if EvaluationHelper.equals(data_type, ModbusDataType.get_ulint()):  # List
             # Array field (value)
             # Count array
-            if numberOfValues66 > Integer.MAX_VALUE:
+            if numberOfValues > Integer.MAX_VALUE:
                 raise ParseException(
                     "Array count of "
-                    + (numberOfValues66)
+                    + (numberOfValues)
                     + " exceeds the maximum allowed count of "
                     + Integer.MAX_VALUE
                 )
 
-            item_count: int = int(numberOfValues66)
+            item_count: int = int(numberOfValues)
             value: List[PlcValue] = []
             for cur_item in range(item_count):
                 value.append(
@@ -361,104 +361,104 @@ class DataItem:
 
             return PlcList(value)
         if EvaluationHelper.equals(
-            data_type66, ModbusDataType.get_real()
+            data_type, ModbusDataType.get_real()
         ) and EvaluationHelper.equals(
-            number_of_values66, c_uint16(1)
+            number_of_values, c_uint16(1)
         ):  # REAL
             # Simple Field (value)
             value: c_float = read_buffer.readFloat("", 32)
 
             return PlcREAL(value)
-        if EvaluationHelper.equals(data_type66, ModbusDataType.get_real()):  # List
+        if EvaluationHelper.equals(data_type, ModbusDataType.get_real()):  # List
             # Array field (value)
             # Count array
-            if numberOfValues66 > Integer.MAX_VALUE:
+            if numberOfValues > Integer.MAX_VALUE:
                 raise ParseException(
                     "Array count of "
-                    + (numberOfValues66)
+                    + (numberOfValues)
                     + " exceeds the maximum allowed count of "
                     + Integer.MAX_VALUE
                 )
 
-            item_count: int = int(numberOfValues66)
+            item_count: int = int(numberOfValues)
             value: List[PlcValue] = []
             for cur_item in range(item_count):
                 value.append(PlcREAL(c_float(read_buffer.readFloat("", 32))))
 
             return PlcList(value)
         if EvaluationHelper.equals(
-            data_type66, ModbusDataType.get_lreal()
+            data_type, ModbusDataType.get_lreal()
         ) and EvaluationHelper.equals(
-            number_of_values66, c_uint16(1)
+            number_of_values, c_uint16(1)
         ):  # LREAL
             # Simple Field (value)
             value: c_double = read_buffer.readDouble("", 64)
 
             return PlcLREAL(value)
-        if EvaluationHelper.equals(data_type66, ModbusDataType.get_lreal()):  # List
+        if EvaluationHelper.equals(data_type, ModbusDataType.get_lreal()):  # List
             # Array field (value)
             # Count array
-            if numberOfValues66 > Integer.MAX_VALUE:
+            if numberOfValues > Integer.MAX_VALUE:
                 raise ParseException(
                     "Array count of "
-                    + (numberOfValues66)
+                    + (numberOfValues)
                     + " exceeds the maximum allowed count of "
                     + Integer.MAX_VALUE
                 )
 
-            item_count: int = int(numberOfValues66)
+            item_count: int = int(numberOfValues)
             value: List[PlcValue] = []
             for cur_item in range(item_count):
                 value.append(PlcLREAL(c_double(read_buffer.readDouble("", 64))))
 
             return PlcList(value)
         if EvaluationHelper.equals(
-            data_type66, ModbusDataType.get_char()
+            data_type, ModbusDataType.get_char()
         ) and EvaluationHelper.equals(
-            number_of_values66, c_uint16(1)
+            number_of_values, c_uint16(1)
         ):  # CHAR
             # Simple Field (value)
             value: str = read_buffer.readString("", 8, "UTF-8")
 
             return PlcCHAR(value)
-        if EvaluationHelper.equals(data_type66, ModbusDataType.get_char()):  # List
+        if EvaluationHelper.equals(data_type, ModbusDataType.get_char()):  # List
             # Array field (value)
             # Count array
-            if numberOfValues66 > Integer.MAX_VALUE:
+            if numberOfValues > Integer.MAX_VALUE:
                 raise ParseException(
                     "Array count of "
-                    + (numberOfValues66)
+                    + (numberOfValues)
                     + " exceeds the maximum allowed count of "
                     + Integer.MAX_VALUE
                 )
 
-            item_count: int = int(numberOfValues66)
+            item_count: int = int(numberOfValues)
             value: List[PlcValue] = []
             for cur_item in range(item_count):
                 value.append(PlcSTRING(str(read_buffer.readString("", 8, "UTF-8"))))
 
             return PlcList(value)
         if EvaluationHelper.equals(
-            data_type66, ModbusDataType.get_wchar()
+            data_type, ModbusDataType.get_wchar()
         ) and EvaluationHelper.equals(
-            number_of_values66, c_uint16(1)
+            number_of_values, c_uint16(1)
         ):  # WCHAR
             # Simple Field (value)
             value: str = read_buffer.readString("", 16, "UTF-16")
 
             return PlcWCHAR(value)
-        if EvaluationHelper.equals(data_type66, ModbusDataType.get_wchar()):  # List
+        if EvaluationHelper.equals(data_type, ModbusDataType.get_wchar()):  # List
             # Array field (value)
             # Count array
-            if numberOfValues66 > Integer.MAX_VALUE:
+            if numberOfValues > Integer.MAX_VALUE:
                 raise ParseException(
                     "Array count of "
-                    + (numberOfValues66)
+                    + (numberOfValues)
                     + " exceeds the maximum allowed count of "
                     + Integer.MAX_VALUE
                 )
 
-            item_count: int = int(numberOfValues66)
+            item_count: int = int(numberOfValues)
             value: List[PlcValue] = []
             for cur_item in range(item_count):
                 value.append(PlcSTRING(str(read_buffer.readString("", 16, "UTF-16"))))
@@ -486,16 +486,16 @@ class DataItem:
         byteOrder: ByteOrder,
     ) -> None:
         if EvaluationHelper.equals(
-            dataType66, ModbusDataType.get_bool()
+            dataType, ModbusDataType.get_bool()
         ) and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+            numberOfValues, c_uint16(1)
         ):  # BOOL
             # Reserved Field
             writeBuffer.WriteUint16("cuint160x0000", 15, c_uint16(0x0000))
             # Simple Field (value)
             value: c_bool = _value.getC_bool()
             writeBuffer.WriteBit("value", (value))
-        if EvaluationHelper.equals(dataType66, ModbusDataType.get_bool()):  # List
+        if EvaluationHelper.equals(dataType, ModbusDataType.get_bool()):  # List
             values: PlcList = _value
 
             for val in values.getList():
@@ -503,45 +503,45 @@ class DataItem:
                 writeBuffer.WriteBit("value", (value))
 
         if EvaluationHelper.equals(
-            dataType66, ModbusDataType.get_byte()
+            dataType, ModbusDataType.get_byte()
         ) and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+            numberOfValues, c_uint16(1)
         ):  # BYTE
             # Reserved Field
             writeBuffer.WriteUint8("cuint80x00", 8, c_uint8(0x00))
             # Simple Field (value)
             value: c_uint8 = _value.getC_uint8()
             writeBuffer.WriteUint8("value", 8, (value))
-        if EvaluationHelper.equals(dataType66, ModbusDataType.get_byte()):  # List
+        if EvaluationHelper.equals(dataType, ModbusDataType.get_byte()):  # List
             values: PlcList = _value
 
             for val in values.getList():
                 value: c_bool = val.getC_bool()
                 writeBuffer.WriteBit("value", (value))
 
-        if EvaluationHelper.equals(dataType66, ModbusDataType.get_word()):  # WORD
+        if EvaluationHelper.equals(dataType, ModbusDataType.get_word()):  # WORD
             # Simple Field (value)
             value: c_uint16 = _value.getC_uint16()
             writeBuffer.WriteUint16("value", 16, (value))
-        if EvaluationHelper.equals(dataType66, ModbusDataType.get_dword()):  # DWORD
+        if EvaluationHelper.equals(dataType, ModbusDataType.get_dword()):  # DWORD
             # Simple Field (value)
             value: c_uint32 = _value.getC_uint32()
             writeBuffer.WriteUint32("value", 32, (value))
-        if EvaluationHelper.equals(dataType66, ModbusDataType.get_lword()):  # LWORD
+        if EvaluationHelper.equals(dataType, ModbusDataType.get_lword()):  # LWORD
             # Simple Field (value)
             value: c_uint64 = _value.getC_uint64()
             writeBuffer.WriteUint64("value", 64, (value))
         if EvaluationHelper.equals(
-            dataType66, ModbusDataType.get_sint()
+            dataType, ModbusDataType.get_sint()
         ) and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+            numberOfValues, c_uint16(1)
         ):  # SINT
             # Reserved Field
             writeBuffer.WriteUint8("cuint80x00", 8, c_uint8(0x00))
             # Simple Field (value)
             value: c_int8 = _value.getC_int8()
             writeBuffer.WriteInt8("value", 8, (value))
-        if EvaluationHelper.equals(dataType66, ModbusDataType.get_sint()):  # List
+        if EvaluationHelper.equals(dataType, ModbusDataType.get_sint()):  # List
             values: PlcList = _value
 
             for val in values.getList():
@@ -549,14 +549,14 @@ class DataItem:
                 writeBuffer.WriteInt8("value", 8, (value))
 
         if EvaluationHelper.equals(
-            dataType66, ModbusDataType.get_int()
+            dataType, ModbusDataType.get_int()
         ) and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+            numberOfValues, c_uint16(1)
         ):  # INT
             # Simple Field (value)
             value: c_int16 = _value.getC_int16()
             writeBuffer.WriteInt16("value", 16, (value))
-        if EvaluationHelper.equals(dataType66, ModbusDataType.get_int()):  # List
+        if EvaluationHelper.equals(dataType, ModbusDataType.get_int()):  # List
             values: PlcList = _value
 
             for val in values.getList():
@@ -564,14 +564,14 @@ class DataItem:
                 writeBuffer.WriteInt16("value", 16, (value))
 
         if EvaluationHelper.equals(
-            dataType66, ModbusDataType.get_dint()
+            dataType, ModbusDataType.get_dint()
         ) and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+            numberOfValues, c_uint16(1)
         ):  # DINT
             # Simple Field (value)
             value: c_int32 = _value.getC_int32()
             writeBuffer.WriteInt32("value", 32, (value))
-        if EvaluationHelper.equals(dataType66, ModbusDataType.get_dint()):  # List
+        if EvaluationHelper.equals(dataType, ModbusDataType.get_dint()):  # List
             values: PlcList = _value
 
             for val in values.getList():
@@ -579,14 +579,14 @@ class DataItem:
                 writeBuffer.WriteInt32("value", 32, (value))
 
         if EvaluationHelper.equals(
-            dataType66, ModbusDataType.get_lint()
+            dataType, ModbusDataType.get_lint()
         ) and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+            numberOfValues, c_uint16(1)
         ):  # LINT
             # Simple Field (value)
             value: c_int64 = _value.getC_int64()
             writeBuffer.WriteInt64("value", 64, (value))
-        if EvaluationHelper.equals(dataType66, ModbusDataType.get_lint()):  # List
+        if EvaluationHelper.equals(dataType, ModbusDataType.get_lint()):  # List
             values: PlcList = _value
 
             for val in values.getList():
@@ -594,16 +594,16 @@ class DataItem:
                 writeBuffer.WriteInt64("value", 64, (value))
 
         if EvaluationHelper.equals(
-            dataType66, ModbusDataType.get_usint()
+            dataType, ModbusDataType.get_usint()
         ) and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+            numberOfValues, c_uint16(1)
         ):  # USINT
             # Reserved Field
             writeBuffer.WriteUint8("cuint80x00", 8, c_uint8(0x00))
             # Simple Field (value)
             value: c_uint8 = _value.getC_uint8()
             writeBuffer.WriteUint8("value", 8, (value))
-        if EvaluationHelper.equals(dataType66, ModbusDataType.get_usint()):  # List
+        if EvaluationHelper.equals(dataType, ModbusDataType.get_usint()):  # List
             values: PlcList = _value
 
             for val in values.getList():
@@ -611,14 +611,14 @@ class DataItem:
                 writeBuffer.WriteUint8("value", 8, (value))
 
         if EvaluationHelper.equals(
-            dataType66, ModbusDataType.get_uint()
+            dataType, ModbusDataType.get_uint()
         ) and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+            numberOfValues, c_uint16(1)
         ):  # UINT
             # Simple Field (value)
             value: c_uint16 = _value.getC_uint16()
             writeBuffer.WriteUint16("value", 16, (value))
-        if EvaluationHelper.equals(dataType66, ModbusDataType.get_uint()):  # List
+        if EvaluationHelper.equals(dataType, ModbusDataType.get_uint()):  # List
             values: PlcList = _value
 
             for val in values.getList():
@@ -626,14 +626,14 @@ class DataItem:
                 writeBuffer.WriteUint16("value", 16, (value))
 
         if EvaluationHelper.equals(
-            dataType66, ModbusDataType.get_udint()
+            dataType, ModbusDataType.get_udint()
         ) and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+            numberOfValues, c_uint16(1)
         ):  # UDINT
             # Simple Field (value)
             value: c_uint32 = _value.getC_uint32()
             writeBuffer.WriteUint32("value", 32, (value))
-        if EvaluationHelper.equals(dataType66, ModbusDataType.get_udint()):  # List
+        if EvaluationHelper.equals(dataType, ModbusDataType.get_udint()):  # List
             values: PlcList = _value
 
             for val in values.getList():
@@ -641,14 +641,14 @@ class DataItem:
                 writeBuffer.WriteUint32("value", 32, (value))
 
         if EvaluationHelper.equals(
-            dataType66, ModbusDataType.get_ulint()
+            dataType, ModbusDataType.get_ulint()
         ) and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+            numberOfValues, c_uint16(1)
         ):  # ULINT
             # Simple Field (value)
             value: c_uint64 = _value.getC_uint64()
             writeBuffer.WriteUint64("value", 64, (value))
-        if EvaluationHelper.equals(dataType66, ModbusDataType.get_ulint()):  # List
+        if EvaluationHelper.equals(dataType, ModbusDataType.get_ulint()):  # List
             values: PlcList = _value
 
             for val in values.getList():
@@ -656,14 +656,14 @@ class DataItem:
                 writeBuffer.WriteUint64("value", 64, (value))
 
         if EvaluationHelper.equals(
-            dataType66, ModbusDataType.get_real()
+            dataType, ModbusDataType.get_real()
         ) and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+            numberOfValues, c_uint16(1)
         ):  # REAL
             # Simple Field (value)
             value: c_float = _value.getC_float()
             writeBuffer.WriteFloat32("value", 32, (value))
-        if EvaluationHelper.equals(dataType66, ModbusDataType.get_real()):  # List
+        if EvaluationHelper.equals(dataType, ModbusDataType.get_real()):  # List
             values: PlcList = _value
 
             for val in values.getList():
@@ -671,14 +671,14 @@ class DataItem:
                 writeBuffer.WriteFloat32("value", 32, (value))
 
         if EvaluationHelper.equals(
-            dataType66, ModbusDataType.get_lreal()
+            dataType, ModbusDataType.get_lreal()
         ) and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+            numberOfValues, c_uint16(1)
         ):  # LREAL
             # Simple Field (value)
             value: c_double = _value.getC_double()
             writeBuffer.WriteFloat64("value", 64, (value))
-        if EvaluationHelper.equals(dataType66, ModbusDataType.get_lreal()):  # List
+        if EvaluationHelper.equals(dataType, ModbusDataType.get_lreal()):  # List
             values: PlcList = _value
 
             for val in values.getList():
@@ -686,14 +686,14 @@ class DataItem:
                 writeBuffer.WriteFloat64("value", 64, (value))
 
         if EvaluationHelper.equals(
-            dataType66, ModbusDataType.get_char()
+            dataType, ModbusDataType.get_char()
         ) and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+            numberOfValues, c_uint16(1)
         ):  # CHAR
             # Simple Field (value)
             value: str = _value.getStr()
             writeBuffer.WriteString("value", uint32(8), "UTF-8", (value))
-        if EvaluationHelper.equals(dataType66, ModbusDataType.get_char()):  # List
+        if EvaluationHelper.equals(dataType, ModbusDataType.get_char()):  # List
             values: PlcList = _value
 
             for val in values.getList():
@@ -701,14 +701,14 @@ class DataItem:
                 writeBuffer.WriteString("value", uint32(8), "UTF-8", (value))
 
         if EvaluationHelper.equals(
-            dataType66, ModbusDataType.get_wchar()
+            dataType, ModbusDataType.get_wchar()
         ) and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+            numberOfValues, c_uint16(1)
         ):  # WCHAR
             # Simple Field (value)
             value: str = _value.getStr()
             writeBuffer.WriteString("value", uint32(16), "UTF-16", (value))
-        if EvaluationHelper.equals(dataType66, ModbusDataType.get_wchar()):  # List
+        if EvaluationHelper.equals(dataType, ModbusDataType.get_wchar()):  # List
             values: PlcList = _value
 
             for val in values.getList():
@@ -729,160 +729,160 @@ class DataItem:
     ) -> int:
         sizeInBits: int = 0
         if EvaluationHelper.equals(
-            dataType66, ModbusDataType.get_bool()
+            dataType, ModbusDataType.get_bool()
         ) and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+            numberOfValues, c_uint16(1)
         ):  # BOOL
             # Reserved Field
             sizeInBits += 15
             # Simple Field (value)
             sizeInBits += 1
-        if EvaluationHelper.equals(dataType66, ModbusDataType.get_bool()):  # List
+        if EvaluationHelper.equals(dataType, ModbusDataType.get_bool()):  # List
             values: PlcList = _value
             sizeInBits += values.getList().size() * 1
         if EvaluationHelper.equals(
-            dataType66, ModbusDataType.get_byte()
+            dataType, ModbusDataType.get_byte()
         ) and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+            numberOfValues, c_uint16(1)
         ):  # BYTE
             # Reserved Field
             sizeInBits += 8
             # Simple Field (value)
             sizeInBits += 8
-        if EvaluationHelper.equals(dataType66, ModbusDataType.get_byte()):  # List
+        if EvaluationHelper.equals(dataType, ModbusDataType.get_byte()):  # List
             values: PlcList = _value
             sizeInBits += values.getList().size() * 1
-        if EvaluationHelper.equals(dataType66, ModbusDataType.get_word()):  # WORD
+        if EvaluationHelper.equals(dataType, ModbusDataType.get_word()):  # WORD
             # Simple Field (value)
             sizeInBits += 16
-        if EvaluationHelper.equals(dataType66, ModbusDataType.get_dword()):  # DWORD
+        if EvaluationHelper.equals(dataType, ModbusDataType.get_dword()):  # DWORD
             # Simple Field (value)
             sizeInBits += 32
-        if EvaluationHelper.equals(dataType66, ModbusDataType.get_lword()):  # LWORD
+        if EvaluationHelper.equals(dataType, ModbusDataType.get_lword()):  # LWORD
             # Simple Field (value)
             sizeInBits += 64
         if EvaluationHelper.equals(
-            dataType66, ModbusDataType.get_sint()
+            dataType, ModbusDataType.get_sint()
         ) and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+            numberOfValues, c_uint16(1)
         ):  # SINT
             # Reserved Field
             sizeInBits += 8
             # Simple Field (value)
             sizeInBits += 8
-        if EvaluationHelper.equals(dataType66, ModbusDataType.get_sint()):  # List
+        if EvaluationHelper.equals(dataType, ModbusDataType.get_sint()):  # List
             values: PlcList = _value
             sizeInBits += values.getList().size() * 8
         if EvaluationHelper.equals(
-            dataType66, ModbusDataType.get_int()
+            dataType, ModbusDataType.get_int()
         ) and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+            numberOfValues, c_uint16(1)
         ):  # INT
             # Simple Field (value)
             sizeInBits += 16
-        if EvaluationHelper.equals(dataType66, ModbusDataType.get_int()):  # List
+        if EvaluationHelper.equals(dataType, ModbusDataType.get_int()):  # List
             values: PlcList = _value
             sizeInBits += values.getList().size() * 16
         if EvaluationHelper.equals(
-            dataType66, ModbusDataType.get_dint()
+            dataType, ModbusDataType.get_dint()
         ) and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+            numberOfValues, c_uint16(1)
         ):  # DINT
             # Simple Field (value)
             sizeInBits += 32
-        if EvaluationHelper.equals(dataType66, ModbusDataType.get_dint()):  # List
+        if EvaluationHelper.equals(dataType, ModbusDataType.get_dint()):  # List
             values: PlcList = _value
             sizeInBits += values.getList().size() * 32
         if EvaluationHelper.equals(
-            dataType66, ModbusDataType.get_lint()
+            dataType, ModbusDataType.get_lint()
         ) and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+            numberOfValues, c_uint16(1)
         ):  # LINT
             # Simple Field (value)
             sizeInBits += 64
-        if EvaluationHelper.equals(dataType66, ModbusDataType.get_lint()):  # List
+        if EvaluationHelper.equals(dataType, ModbusDataType.get_lint()):  # List
             values: PlcList = _value
             sizeInBits += values.getList().size() * 64
         if EvaluationHelper.equals(
-            dataType66, ModbusDataType.get_usint()
+            dataType, ModbusDataType.get_usint()
         ) and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+            numberOfValues, c_uint16(1)
         ):  # USINT
             # Reserved Field
             sizeInBits += 8
             # Simple Field (value)
             sizeInBits += 8
-        if EvaluationHelper.equals(dataType66, ModbusDataType.get_usint()):  # List
+        if EvaluationHelper.equals(dataType, ModbusDataType.get_usint()):  # List
             values: PlcList = _value
             sizeInBits += values.getList().size() * 8
         if EvaluationHelper.equals(
-            dataType66, ModbusDataType.get_uint()
+            dataType, ModbusDataType.get_uint()
         ) and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+            numberOfValues, c_uint16(1)
         ):  # UINT
             # Simple Field (value)
             sizeInBits += 16
-        if EvaluationHelper.equals(dataType66, ModbusDataType.get_uint()):  # List
+        if EvaluationHelper.equals(dataType, ModbusDataType.get_uint()):  # List
             values: PlcList = _value
             sizeInBits += values.getList().size() * 16
         if EvaluationHelper.equals(
-            dataType66, ModbusDataType.get_udint()
+            dataType, ModbusDataType.get_udint()
         ) and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+            numberOfValues, c_uint16(1)
         ):  # UDINT
             # Simple Field (value)
             sizeInBits += 32
-        if EvaluationHelper.equals(dataType66, ModbusDataType.get_udint()):  # List
+        if EvaluationHelper.equals(dataType, ModbusDataType.get_udint()):  # List
             values: PlcList = _value
             sizeInBits += values.getList().size() * 32
         if EvaluationHelper.equals(
-            dataType66, ModbusDataType.get_ulint()
+            dataType, ModbusDataType.get_ulint()
         ) and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+            numberOfValues, c_uint16(1)
         ):  # ULINT
             # Simple Field (value)
             sizeInBits += 64
-        if EvaluationHelper.equals(dataType66, ModbusDataType.get_ulint()):  # List
+        if EvaluationHelper.equals(dataType, ModbusDataType.get_ulint()):  # List
             values: PlcList = _value
             sizeInBits += values.getList().size() * 64
         if EvaluationHelper.equals(
-            dataType66, ModbusDataType.get_real()
+            dataType, ModbusDataType.get_real()
         ) and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+            numberOfValues, c_uint16(1)
         ):  # REAL
             # Simple Field (value)
             sizeInBits += 32
-        if EvaluationHelper.equals(dataType66, ModbusDataType.get_real()):  # List
+        if EvaluationHelper.equals(dataType, ModbusDataType.get_real()):  # List
             values: PlcList = _value
             sizeInBits += values.getList().size() * 32
         if EvaluationHelper.equals(
-            dataType66, ModbusDataType.get_lreal()
+            dataType, ModbusDataType.get_lreal()
         ) and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+            numberOfValues, c_uint16(1)
         ):  # LREAL
             # Simple Field (value)
             sizeInBits += 64
-        if EvaluationHelper.equals(dataType66, ModbusDataType.get_lreal()):  # List
+        if EvaluationHelper.equals(dataType, ModbusDataType.get_lreal()):  # List
             values: PlcList = _value
             sizeInBits += values.getList().size() * 64
         if EvaluationHelper.equals(
-            dataType66, ModbusDataType.get_char()
+            dataType, ModbusDataType.get_char()
         ) and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+            numberOfValues, c_uint16(1)
         ):  # CHAR
             # Simple Field (value)
             sizeInBits += 8
-        if EvaluationHelper.equals(dataType66, ModbusDataType.get_char()):  # List
+        if EvaluationHelper.equals(dataType, ModbusDataType.get_char()):  # List
             values: PlcList = _value
             sizeInBits += values.getList().size() * 8
         if EvaluationHelper.equals(
-            dataType66, ModbusDataType.get_wchar()
+            dataType, ModbusDataType.get_wchar()
         ) and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+            numberOfValues, c_uint16(1)
         ):  # WCHAR
             # Simple Field (value)
             sizeInBits += 16
-        if EvaluationHelper.equals(dataType66, ModbusDataType.get_wchar()):  # List
+        if EvaluationHelper.equals(dataType, ModbusDataType.get_wchar()):  # List
             values: PlcList = _value
             sizeInBits += values.getList().size() * 16
         return sizeInBits
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusADU.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusADU.py
index 9ba726b3a1..011ff418c5 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusADU.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusADU.py
@@ -106,11 +106,11 @@ class ModbusADU(ABC, PlcMessage):
 
         # Switch Field (Depending on the discriminator values, passes the instantiation to a sub-type)
         builder: ModbusADUBuilder = None
-        if EvaluationHelper.equals(driverType66, DriverType.get_modbu_s__tcp()):
+        if EvaluationHelper.equals(driverType, DriverType.get_modbu_s__tcp()):
             builder = ModbusTcpADU.staticParseBuilder(read_buffer, driverType, response)
-        if EvaluationHelper.equals(driverType66, DriverType.get_modbu_s__rtu()):
+        if EvaluationHelper.equals(driverType, DriverType.get_modbu_s__rtu()):
             builder = ModbusRtuADU.staticParseBuilder(read_buffer, driverType, response)
-        if EvaluationHelper.equals(driverType66, DriverType.get_modbu_s__ascii()):
+        if EvaluationHelper.equals(driverType, DriverType.get_modbu_s__ascii()):
             builder = ModbusAsciiADU.staticParseBuilder(
                 read_buffer, driverType, response
             )
@@ -119,7 +119,7 @@ class ModbusADU(ABC, PlcMessage):
                 "Unsupported case for discriminated type"
                 + " parameters ["
                 + "driverType="
-                + driverType66
+                + driverType
                 + "]"
             )
 
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDU.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDU.py
index cf08d93b09..b9feaedb58 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDU.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDU.py
@@ -125,7 +125,7 @@ class ModbusPDU(ABC, PlcMessage):
         if (
             EvaluationHelper.equals(errorFlag, c_bool(False))
             and EvaluationHelper.equals(functionFlag, c_uint8(0x02))
-            and EvaluationHelper.equals(response66, c_bool(False))
+            and EvaluationHelper.equals(response, c_bool(False))
         ):
             builder = ModbusPDUReadDiscreteInputsRequest.staticParseBuilder(
                 read_buffer, response
@@ -133,7 +133,7 @@ class ModbusPDU(ABC, PlcMessage):
         if (
             EvaluationHelper.equals(errorFlag, c_bool(False))
             and EvaluationHelper.equals(functionFlag, c_uint8(0x02))
-            and EvaluationHelper.equals(response66, c_bool(True))
+            and EvaluationHelper.equals(response, c_bool(True))
         ):
             builder = ModbusPDUReadDiscreteInputsResponse.staticParseBuilder(
                 read_buffer, response
@@ -141,7 +141,7 @@ class ModbusPDU(ABC, PlcMessage):
         if (
             EvaluationHelper.equals(errorFlag, c_bool(False))
             and EvaluationHelper.equals(functionFlag, c_uint8(0x01))
-            and EvaluationHelper.equals(response66, c_bool(False))
+            and EvaluationHelper.equals(response, c_bool(False))
         ):
             builder = ModbusPDUReadCoilsRequest.staticParseBuilder(
                 read_buffer, response
@@ -149,7 +149,7 @@ class ModbusPDU(ABC, PlcMessage):
         if (
             EvaluationHelper.equals(errorFlag, c_bool(False))
             and EvaluationHelper.equals(functionFlag, c_uint8(0x01))
-            and EvaluationHelper.equals(response66, c_bool(True))
+            and EvaluationHelper.equals(response, c_bool(True))
         ):
             builder = ModbusPDUReadCoilsResponse.staticParseBuilder(
                 read_buffer, response
@@ -157,7 +157,7 @@ class ModbusPDU(ABC, PlcMessage):
         if (
             EvaluationHelper.equals(errorFlag, c_bool(False))
             and EvaluationHelper.equals(functionFlag, c_uint8(0x05))
-            and EvaluationHelper.equals(response66, c_bool(False))
+            and EvaluationHelper.equals(response, c_bool(False))
         ):
             builder = ModbusPDUWriteSingleCoilRequest.staticParseBuilder(
                 read_buffer, response
@@ -165,7 +165,7 @@ class ModbusPDU(ABC, PlcMessage):
         if (
             EvaluationHelper.equals(errorFlag, c_bool(False))
             and EvaluationHelper.equals(functionFlag, c_uint8(0x05))
-            and EvaluationHelper.equals(response66, c_bool(True))
+            and EvaluationHelper.equals(response, c_bool(True))
         ):
             builder = ModbusPDUWriteSingleCoilResponse.staticParseBuilder(
                 read_buffer, response
@@ -173,7 +173,7 @@ class ModbusPDU(ABC, PlcMessage):
         if (
             EvaluationHelper.equals(errorFlag, c_bool(False))
             and EvaluationHelper.equals(functionFlag, c_uint8(0x0F))
-            and EvaluationHelper.equals(response66, c_bool(False))
+            and EvaluationHelper.equals(response, c_bool(False))
         ):
             builder = ModbusPDUWriteMultipleCoilsRequest.staticParseBuilder(
                 read_buffer, response
@@ -181,7 +181,7 @@ class ModbusPDU(ABC, PlcMessage):
         if (
             EvaluationHelper.equals(errorFlag, c_bool(False))
             and EvaluationHelper.equals(functionFlag, c_uint8(0x0F))
-            and EvaluationHelper.equals(response66, c_bool(True))
+            and EvaluationHelper.equals(response, c_bool(True))
         ):
             builder = ModbusPDUWriteMultipleCoilsResponse.staticParseBuilder(
                 read_buffer, response
@@ -189,7 +189,7 @@ class ModbusPDU(ABC, PlcMessage):
         if (
             EvaluationHelper.equals(errorFlag, c_bool(False))
             and EvaluationHelper.equals(functionFlag, c_uint8(0x04))
-            and EvaluationHelper.equals(response66, c_bool(False))
+            and EvaluationHelper.equals(response, c_bool(False))
         ):
             builder = ModbusPDUReadInputRegistersRequest.staticParseBuilder(
                 read_buffer, response
@@ -197,7 +197,7 @@ class ModbusPDU(ABC, PlcMessage):
         if (
             EvaluationHelper.equals(errorFlag, c_bool(False))
             and EvaluationHelper.equals(functionFlag, c_uint8(0x04))
-            and EvaluationHelper.equals(response66, c_bool(True))
+            and EvaluationHelper.equals(response, c_bool(True))
         ):
             builder = ModbusPDUReadInputRegistersResponse.staticParseBuilder(
                 read_buffer, response
@@ -205,7 +205,7 @@ class ModbusPDU(ABC, PlcMessage):
         if (
             EvaluationHelper.equals(errorFlag, c_bool(False))
             and EvaluationHelper.equals(functionFlag, c_uint8(0x03))
-            and EvaluationHelper.equals(response66, c_bool(False))
+            and EvaluationHelper.equals(response, c_bool(False))
         ):
             builder = ModbusPDUReadHoldingRegistersRequest.staticParseBuilder(
                 read_buffer, response
@@ -213,7 +213,7 @@ class ModbusPDU(ABC, PlcMessage):
         if (
             EvaluationHelper.equals(errorFlag, c_bool(False))
             and EvaluationHelper.equals(functionFlag, c_uint8(0x03))
-            and EvaluationHelper.equals(response66, c_bool(True))
+            and EvaluationHelper.equals(response, c_bool(True))
         ):
             builder = ModbusPDUReadHoldingRegistersResponse.staticParseBuilder(
                 read_buffer, response
@@ -221,7 +221,7 @@ class ModbusPDU(ABC, PlcMessage):
         if (
             EvaluationHelper.equals(errorFlag, c_bool(False))
             and EvaluationHelper.equals(functionFlag, c_uint8(0x06))
-            and EvaluationHelper.equals(response66, c_bool(False))
+            and EvaluationHelper.equals(response, c_bool(False))
         ):
             builder = ModbusPDUWriteSingleRegisterRequest.staticParseBuilder(
                 read_buffer, response
@@ -229,7 +229,7 @@ class ModbusPDU(ABC, PlcMessage):
         if (
             EvaluationHelper.equals(errorFlag, c_bool(False))
             and EvaluationHelper.equals(functionFlag, c_uint8(0x06))
-            and EvaluationHelper.equals(response66, c_bool(True))
+            and EvaluationHelper.equals(response, c_bool(True))
         ):
             builder = ModbusPDUWriteSingleRegisterResponse.staticParseBuilder(
                 read_buffer, response
@@ -237,7 +237,7 @@ class ModbusPDU(ABC, PlcMessage):
         if (
             EvaluationHelper.equals(errorFlag, c_bool(False))
             and EvaluationHelper.equals(functionFlag, c_uint8(0x10))
-            and EvaluationHelper.equals(response66, c_bool(False))
+            and EvaluationHelper.equals(response, c_bool(False))
         ):
             builder = ModbusPDUWriteMultipleHoldingRegistersRequest.staticParseBuilder(
                 read_buffer, response
@@ -245,7 +245,7 @@ class ModbusPDU(ABC, PlcMessage):
         if (
             EvaluationHelper.equals(errorFlag, c_bool(False))
             and EvaluationHelper.equals(functionFlag, c_uint8(0x10))
-            and EvaluationHelper.equals(response66, c_bool(True))
+            and EvaluationHelper.equals(response, c_bool(True))
         ):
             builder = ModbusPDUWriteMultipleHoldingRegistersResponse.staticParseBuilder(
                 read_buffer, response
@@ -253,7 +253,7 @@ class ModbusPDU(ABC, PlcMessage):
         if (
             EvaluationHelper.equals(errorFlag, c_bool(False))
             and EvaluationHelper.equals(functionFlag, c_uint8(0x17))
-            and EvaluationHelper.equals(response66, c_bool(False))
+            and EvaluationHelper.equals(response, c_bool(False))
         ):
             builder = (
                 ModbusPDUReadWriteMultipleHoldingRegistersRequest.staticParseBuilder(
@@ -263,7 +263,7 @@ class ModbusPDU(ABC, PlcMessage):
         if (
             EvaluationHelper.equals(errorFlag, c_bool(False))
             and EvaluationHelper.equals(functionFlag, c_uint8(0x17))
-            and EvaluationHelper.equals(response66, c_bool(True))
+            and EvaluationHelper.equals(response, c_bool(True))
         ):
             builder = (
                 ModbusPDUReadWriteMultipleHoldingRegistersResponse.staticParseBuilder(
@@ -273,7 +273,7 @@ class ModbusPDU(ABC, PlcMessage):
         if (
             EvaluationHelper.equals(errorFlag, c_bool(False))
             and EvaluationHelper.equals(functionFlag, c_uint8(0x16))
-            and EvaluationHelper.equals(response66, c_bool(False))
+            and EvaluationHelper.equals(response, c_bool(False))
         ):
             builder = ModbusPDUMaskWriteHoldingRegisterRequest.staticParseBuilder(
                 read_buffer, response
@@ -281,7 +281,7 @@ class ModbusPDU(ABC, PlcMessage):
         if (
             EvaluationHelper.equals(errorFlag, c_bool(False))
             and EvaluationHelper.equals(functionFlag, c_uint8(0x16))
-            and EvaluationHelper.equals(response66, c_bool(True))
+            and EvaluationHelper.equals(response, c_bool(True))
         ):
             builder = ModbusPDUMaskWriteHoldingRegisterResponse.staticParseBuilder(
                 read_buffer, response
@@ -289,7 +289,7 @@ class ModbusPDU(ABC, PlcMessage):
         if (
             EvaluationHelper.equals(errorFlag, c_bool(False))
             and EvaluationHelper.equals(functionFlag, c_uint8(0x18))
-            and EvaluationHelper.equals(response66, c_bool(False))
+            and EvaluationHelper.equals(response, c_bool(False))
         ):
             builder = ModbusPDUReadFifoQueueRequest.staticParseBuilder(
                 read_buffer, response
@@ -297,7 +297,7 @@ class ModbusPDU(ABC, PlcMessage):
         if (
             EvaluationHelper.equals(errorFlag, c_bool(False))
             and EvaluationHelper.equals(functionFlag, c_uint8(0x18))
-            and EvaluationHelper.equals(response66, c_bool(True))
+            and EvaluationHelper.equals(response, c_bool(True))
         ):
             builder = ModbusPDUReadFifoQueueResponse.staticParseBuilder(
                 read_buffer, response
@@ -305,7 +305,7 @@ class ModbusPDU(ABC, PlcMessage):
         if (
             EvaluationHelper.equals(errorFlag, c_bool(False))
             and EvaluationHelper.equals(functionFlag, c_uint8(0x14))
-            and EvaluationHelper.equals(response66, c_bool(False))
+            and EvaluationHelper.equals(response, c_bool(False))
         ):
             builder = ModbusPDUReadFileRecordRequest.staticParseBuilder(
                 read_buffer, response
@@ -313,7 +313,7 @@ class ModbusPDU(ABC, PlcMessage):
         if (
             EvaluationHelper.equals(errorFlag, c_bool(False))
             and EvaluationHelper.equals(functionFlag, c_uint8(0x14))
-            and EvaluationHelper.equals(response66, c_bool(True))
+            and EvaluationHelper.equals(response, c_bool(True))
         ):
             builder = ModbusPDUReadFileRecordResponse.staticParseBuilder(
                 read_buffer, response
@@ -321,7 +321,7 @@ class ModbusPDU(ABC, PlcMessage):
         if (
             EvaluationHelper.equals(errorFlag, c_bool(False))
             and EvaluationHelper.equals(functionFlag, c_uint8(0x15))
-            and EvaluationHelper.equals(response66, c_bool(False))
+            and EvaluationHelper.equals(response, c_bool(False))
         ):
             builder = ModbusPDUWriteFileRecordRequest.staticParseBuilder(
                 read_buffer, response
@@ -329,7 +329,7 @@ class ModbusPDU(ABC, PlcMessage):
         if (
             EvaluationHelper.equals(errorFlag, c_bool(False))
             and EvaluationHelper.equals(functionFlag, c_uint8(0x15))
-            and EvaluationHelper.equals(response66, c_bool(True))
+            and EvaluationHelper.equals(response, c_bool(True))
         ):
             builder = ModbusPDUWriteFileRecordResponse.staticParseBuilder(
                 read_buffer, response
@@ -337,7 +337,7 @@ class ModbusPDU(ABC, PlcMessage):
         if (
             EvaluationHelper.equals(errorFlag, c_bool(False))
             and EvaluationHelper.equals(functionFlag, c_uint8(0x07))
-            and EvaluationHelper.equals(response66, c_bool(False))
+            and EvaluationHelper.equals(response, c_bool(False))
         ):
             builder = ModbusPDUReadExceptionStatusRequest.staticParseBuilder(
                 read_buffer, response
@@ -345,7 +345,7 @@ class ModbusPDU(ABC, PlcMessage):
         if (
             EvaluationHelper.equals(errorFlag, c_bool(False))
             and EvaluationHelper.equals(functionFlag, c_uint8(0x07))
-            and EvaluationHelper.equals(response66, c_bool(True))
+            and EvaluationHelper.equals(response, c_bool(True))
         ):
             builder = ModbusPDUReadExceptionStatusResponse.staticParseBuilder(
                 read_buffer, response
@@ -353,7 +353,7 @@ class ModbusPDU(ABC, PlcMessage):
         if (
             EvaluationHelper.equals(errorFlag, c_bool(False))
             and EvaluationHelper.equals(functionFlag, c_uint8(0x08))
-            and EvaluationHelper.equals(response66, c_bool(False))
+            and EvaluationHelper.equals(response, c_bool(False))
         ):
             builder = ModbusPDUDiagnosticRequest.staticParseBuilder(
                 read_buffer, response
@@ -361,7 +361,7 @@ class ModbusPDU(ABC, PlcMessage):
         if (
             EvaluationHelper.equals(errorFlag, c_bool(False))
             and EvaluationHelper.equals(functionFlag, c_uint8(0x08))
-            and EvaluationHelper.equals(response66, c_bool(True))
+            and EvaluationHelper.equals(response, c_bool(True))
         ):
             builder = ModbusPDUDiagnosticResponse.staticParseBuilder(
                 read_buffer, response
@@ -369,7 +369,7 @@ class ModbusPDU(ABC, PlcMessage):
         if (
             EvaluationHelper.equals(errorFlag, c_bool(False))
             and EvaluationHelper.equals(functionFlag, c_uint8(0x0B))
-            and EvaluationHelper.equals(response66, c_bool(False))
+            and EvaluationHelper.equals(response, c_bool(False))
         ):
             builder = ModbusPDUGetComEventCounterRequest.staticParseBuilder(
                 read_buffer, response
@@ -377,7 +377,7 @@ class ModbusPDU(ABC, PlcMessage):
         if (
             EvaluationHelper.equals(errorFlag, c_bool(False))
             and EvaluationHelper.equals(functionFlag, c_uint8(0x0B))
-            and EvaluationHelper.equals(response66, c_bool(True))
+            and EvaluationHelper.equals(response, c_bool(True))
         ):
             builder = ModbusPDUGetComEventCounterResponse.staticParseBuilder(
                 read_buffer, response
@@ -385,7 +385,7 @@ class ModbusPDU(ABC, PlcMessage):
         if (
             EvaluationHelper.equals(errorFlag, c_bool(False))
             and EvaluationHelper.equals(functionFlag, c_uint8(0x0C))
-            and EvaluationHelper.equals(response66, c_bool(False))
+            and EvaluationHelper.equals(response, c_bool(False))
         ):
             builder = ModbusPDUGetComEventLogRequest.staticParseBuilder(
                 read_buffer, response
@@ -393,7 +393,7 @@ class ModbusPDU(ABC, PlcMessage):
         if (
             EvaluationHelper.equals(errorFlag, c_bool(False))
             and EvaluationHelper.equals(functionFlag, c_uint8(0x0C))
-            and EvaluationHelper.equals(response66, c_bool(True))
+            and EvaluationHelper.equals(response, c_bool(True))
         ):
             builder = ModbusPDUGetComEventLogResponse.staticParseBuilder(
                 read_buffer, response
@@ -401,7 +401,7 @@ class ModbusPDU(ABC, PlcMessage):
         if (
             EvaluationHelper.equals(errorFlag, c_bool(False))
             and EvaluationHelper.equals(functionFlag, c_uint8(0x11))
-            and EvaluationHelper.equals(response66, c_bool(False))
+            and EvaluationHelper.equals(response, c_bool(False))
         ):
             builder = ModbusPDUReportServerIdRequest.staticParseBuilder(
                 read_buffer, response
@@ -409,7 +409,7 @@ class ModbusPDU(ABC, PlcMessage):
         if (
             EvaluationHelper.equals(errorFlag, c_bool(False))
             and EvaluationHelper.equals(functionFlag, c_uint8(0x11))
-            and EvaluationHelper.equals(response66, c_bool(True))
+            and EvaluationHelper.equals(response, c_bool(True))
         ):
             builder = ModbusPDUReportServerIdResponse.staticParseBuilder(
                 read_buffer, response
@@ -417,7 +417,7 @@ class ModbusPDU(ABC, PlcMessage):
         if (
             EvaluationHelper.equals(errorFlag, c_bool(False))
             and EvaluationHelper.equals(functionFlag, c_uint8(0x2B))
-            and EvaluationHelper.equals(response66, c_bool(False))
+            and EvaluationHelper.equals(response, c_bool(False))
         ):
             builder = ModbusPDUReadDeviceIdentificationRequest.staticParseBuilder(
                 read_buffer, response
@@ -425,7 +425,7 @@ class ModbusPDU(ABC, PlcMessage):
         if (
             EvaluationHelper.equals(errorFlag, c_bool(False))
             and EvaluationHelper.equals(functionFlag, c_uint8(0x2B))
-            and EvaluationHelper.equals(response66, c_bool(True))
+            and EvaluationHelper.equals(response, c_bool(True))
         ):
             builder = ModbusPDUReadDeviceIdentificationResponse.staticParseBuilder(
                 read_buffer, response
@@ -441,7 +441,7 @@ class ModbusPDU(ABC, PlcMessage):
                 + functionFlag
                 + " "
                 + "response="
-                + response66
+                + response
                 + "]"
             )
 
diff --git a/sandbox/plc4py/plc4py/protocols/simulated/readwrite/DataItem.py b/sandbox/plc4py/plc4py/protocols/simulated/readwrite/DataItem.py
index 3c7ea1cf8e..e64f50970e 100644
--- a/sandbox/plc4py/plc4py/protocols/simulated/readwrite/DataItem.py
+++ b/sandbox/plc4py/plc4py/protocols/simulated/readwrite/DataItem.py
@@ -38,121 +38,121 @@ class DataItem:
     def static_parse(
         read_buffer: ReadBuffer, data_type: str, number_of_values: c_uint16
     ):
-        if EvaluationHelper.equals(data_type66, "_bool") and EvaluationHelper.equals(
-            number_of_values66, c_uint16(1)
+        if EvaluationHelper.equals(data_type, "_bool") and EvaluationHelper.equals(
+            number_of_values, c_uint16(1)
         ):  # BOOL
             # Simple Field (value)
             value: c_bool = read_buffer.readBit("")
 
             return PlcBOOL(value)
-        if EvaluationHelper.equals(data_type66, "_bool"):  # List
+        if EvaluationHelper.equals(data_type, "_bool"):  # List
             # Array field (value)
             # Count array
-            if numberOfValues66 > Integer.MAX_VALUE:
+            if numberOfValues > Integer.MAX_VALUE:
                 raise ParseException(
                     "Array count of "
-                    + (numberOfValues66)
+                    + (numberOfValues)
                     + " exceeds the maximum allowed count of "
                     + Integer.MAX_VALUE
                 )
 
-            item_count: int = int(numberOfValues66)
+            item_count: int = int(numberOfValues)
             value: List[PlcValue] = []
             for cur_item in range(item_count):
                 value.append(PlcBOOL(c_bool(read_buffer.readBit(""))))
 
             return PlcList(value)
-        if EvaluationHelper.equals(data_type66, "_byte") and EvaluationHelper.equals(
-            number_of_values66, c_uint16(1)
+        if EvaluationHelper.equals(data_type, "_byte") and EvaluationHelper.equals(
+            number_of_values, c_uint16(1)
         ):  # BYTE
             # Simple Field (value)
             value: c_uint8 = read_buffer.readUnsignedShort("", 8)
 
             return PlcBYTE(value)
-        if EvaluationHelper.equals(data_type66, "_byte"):  # List
+        if EvaluationHelper.equals(data_type, "_byte"):  # List
             # Array field (value)
             # Count array
-            if numberOfValues66 > Integer.MAX_VALUE:
+            if numberOfValues > Integer.MAX_VALUE:
                 raise ParseException(
                     "Array count of "
-                    + (numberOfValues66)
+                    + (numberOfValues)
                     + " exceeds the maximum allowed count of "
                     + Integer.MAX_VALUE
                 )
 
-            item_count: int = int(numberOfValues66)
+            item_count: int = int(numberOfValues)
             value: List[PlcValue] = []
             for cur_item in range(item_count):
                 value.append(PlcUINT(c_uint8(read_buffer.readUnsignedShort("", 8))))
 
             return PlcList(value)
-        if EvaluationHelper.equals(data_type66, "_word") and EvaluationHelper.equals(
-            number_of_values66, c_uint16(1)
+        if EvaluationHelper.equals(data_type, "_word") and EvaluationHelper.equals(
+            number_of_values, c_uint16(1)
         ):  # WORD
             # Simple Field (value)
             value: c_uint16 = read_buffer.readUnsignedInt("", 16)
 
             return PlcWORD(value)
-        if EvaluationHelper.equals(data_type66, "_word"):  # List
+        if EvaluationHelper.equals(data_type, "_word"):  # List
             # Array field (value)
             # Count array
-            if numberOfValues66 > Integer.MAX_VALUE:
+            if numberOfValues > Integer.MAX_VALUE:
                 raise ParseException(
                     "Array count of "
-                    + (numberOfValues66)
+                    + (numberOfValues)
                     + " exceeds the maximum allowed count of "
                     + Integer.MAX_VALUE
                 )
 
-            item_count: int = int(numberOfValues66)
+            item_count: int = int(numberOfValues)
             value: List[PlcValue] = []
             for cur_item in range(item_count):
                 value.append(PlcUDINT(c_uint16(read_buffer.readUnsignedInt("", 16))))
 
             return PlcList(value)
-        if EvaluationHelper.equals(data_type66, "_dword") and EvaluationHelper.equals(
-            number_of_values66, c_uint16(1)
+        if EvaluationHelper.equals(data_type, "_dword") and EvaluationHelper.equals(
+            number_of_values, c_uint16(1)
         ):  # DWORD
             # Simple Field (value)
             value: c_uint32 = read_buffer.readUnsignedLong("", 32)
 
             return PlcDWORD(value)
-        if EvaluationHelper.equals(data_type66, "_dword"):  # List
+        if EvaluationHelper.equals(data_type, "_dword"):  # List
             # Array field (value)
             # Count array
-            if numberOfValues66 > Integer.MAX_VALUE:
+            if numberOfValues > Integer.MAX_VALUE:
                 raise ParseException(
                     "Array count of "
-                    + (numberOfValues66)
+                    + (numberOfValues)
                     + " exceeds the maximum allowed count of "
                     + Integer.MAX_VALUE
                 )
 
-            item_count: int = int(numberOfValues66)
+            item_count: int = int(numberOfValues)
             value: List[PlcValue] = []
             for cur_item in range(item_count):
                 value.append(PlcULINT(c_uint32(read_buffer.readUnsignedLong("", 32))))
 
             return PlcList(value)
-        if EvaluationHelper.equals(data_type66, "_lword") and EvaluationHelper.equals(
-            number_of_values66, c_uint16(1)
+        if EvaluationHelper.equals(data_type, "_lword") and EvaluationHelper.equals(
+            number_of_values, c_uint16(1)
         ):  # LWORD
             # Simple Field (value)
             value: c_uint64 = read_buffer.readUnsignedBigInteger("", 64)
 
             return PlcLWORD(value)
-        if EvaluationHelper.equals(data_type66, "_lword"):  # List
+        if EvaluationHelper.equals(data_type, "_lword"):  # List
             # Array field (value)
             # Count array
-            if numberOfValues66 > Integer.MAX_VALUE:
+            if numberOfValues > Integer.MAX_VALUE:
                 raise ParseException(
                     "Array count of "
-                    + (numberOfValues66)
+                    + (numberOfValues)
                     + " exceeds the maximum allowed count of "
                     + Integer.MAX_VALUE
                 )
 
-            item_count: int = int(numberOfValues66)
+            item_count: int = int(numberOfValues)
             value: List[PlcValue] = []
             for cur_item in range(item_count):
                 value.append(
@@ -160,193 +160,193 @@ class DataItem:
                 )
 
             return PlcList(value)
-        if EvaluationHelper.equals(data_type66, "_sint") and EvaluationHelper.equals(
-            number_of_values66, c_uint16(1)
+        if EvaluationHelper.equals(data_type, "_sint") and EvaluationHelper.equals(
+            number_of_values, c_uint16(1)
         ):  # SINT
             # Simple Field (value)
             value: c_int8 = read_buffer.readSignedByte("", 8)
 
             return PlcSINT(value)
-        if EvaluationHelper.equals(data_type66, "_sint"):  # List
+        if EvaluationHelper.equals(data_type, "_sint"):  # List
             # Array field (value)
             # Count array
-            if numberOfValues66 > Integer.MAX_VALUE:
+            if numberOfValues > Integer.MAX_VALUE:
                 raise ParseException(
                     "Array count of "
-                    + (numberOfValues66)
+                    + (numberOfValues)
                     + " exceeds the maximum allowed count of "
                     + Integer.MAX_VALUE
                 )
 
-            item_count: int = int(numberOfValues66)
+            item_count: int = int(numberOfValues)
             value: List[PlcValue] = []
             for cur_item in range(item_count):
                 value.append(PlcSINT(c_int8(read_buffer.readSignedByte("", 8))))
 
             return PlcList(value)
-        if EvaluationHelper.equals(data_type66, "_int") and EvaluationHelper.equals(
-            number_of_values66, c_uint16(1)
+        if EvaluationHelper.equals(data_type, "_int") and EvaluationHelper.equals(
+            number_of_values, c_uint16(1)
         ):  # INT
             # Simple Field (value)
             value: c_int16 = read_buffer.readShort("", 16)
 
             return PlcINT(value)
-        if EvaluationHelper.equals(data_type66, "_int"):  # List
+        if EvaluationHelper.equals(data_type, "_int"):  # List
             # Array field (value)
             # Count array
-            if numberOfValues66 > Integer.MAX_VALUE:
+            if numberOfValues > Integer.MAX_VALUE:
                 raise ParseException(
                     "Array count of "
-                    + (numberOfValues66)
+                    + (numberOfValues)
                     + " exceeds the maximum allowed count of "
                     + Integer.MAX_VALUE
                 )
 
-            item_count: int = int(numberOfValues66)
+            item_count: int = int(numberOfValues)
             value: List[PlcValue] = []
             for cur_item in range(item_count):
                 value.append(PlcINT(c_int16(read_buffer.readShort("", 16))))
 
             return PlcList(value)
-        if EvaluationHelper.equals(data_type66, "_dint") and EvaluationHelper.equals(
-            number_of_values66, c_uint16(1)
+        if EvaluationHelper.equals(data_type, "_dint") and EvaluationHelper.equals(
+            number_of_values, c_uint16(1)
         ):  # DINT
             # Simple Field (value)
             value: c_int32 = read_buffer.readInt("", 32)
 
             return PlcDINT(value)
-        if EvaluationHelper.equals(data_type66, "_dint"):  # List
+        if EvaluationHelper.equals(data_type, "_dint"):  # List
             # Array field (value)
             # Count array
-            if numberOfValues66 > Integer.MAX_VALUE:
+            if numberOfValues > Integer.MAX_VALUE:
                 raise ParseException(
                     "Array count of "
-                    + (numberOfValues66)
+                    + (numberOfValues)
                     + " exceeds the maximum allowed count of "
                     + Integer.MAX_VALUE
                 )
 
-            item_count: int = int(numberOfValues66)
+            item_count: int = int(numberOfValues)
             value: List[PlcValue] = []
             for cur_item in range(item_count):
                 value.append(PlcDINT(c_int32(read_buffer.readInt("", 32))))
 
             return PlcList(value)
-        if EvaluationHelper.equals(data_type66, "_lint") and EvaluationHelper.equals(
-            number_of_values66, c_uint16(1)
+        if EvaluationHelper.equals(data_type, "_lint") and EvaluationHelper.equals(
+            number_of_values, c_uint16(1)
         ):  # LINT
             # Simple Field (value)
             value: c_int64 = read_buffer.readLong("", 64)
 
             return PlcLINT(value)
-        if EvaluationHelper.equals(data_type66, "_lint"):  # List
+        if EvaluationHelper.equals(data_type, "_lint"):  # List
             # Array field (value)
             # Count array
-            if numberOfValues66 > Integer.MAX_VALUE:
+            if numberOfValues > Integer.MAX_VALUE:
                 raise ParseException(
                     "Array count of "
-                    + (numberOfValues66)
+                    + (numberOfValues)
                     + " exceeds the maximum allowed count of "
                     + Integer.MAX_VALUE
                 )
 
-            item_count: int = int(numberOfValues66)
+            item_count: int = int(numberOfValues)
             value: List[PlcValue] = []
             for cur_item in range(item_count):
                 value.append(PlcLINT(c_int64(read_buffer.readLong("", 64))))
 
             return PlcList(value)
-        if EvaluationHelper.equals(data_type66, "_usint") and EvaluationHelper.equals(
-            number_of_values66, c_uint16(1)
+        if EvaluationHelper.equals(data_type, "_usint") and EvaluationHelper.equals(
+            number_of_values, c_uint16(1)
         ):  # USINT
             # Simple Field (value)
             value: c_uint8 = read_buffer.readUnsignedShort("", 8)
 
             return PlcUSINT(value)
-        if EvaluationHelper.equals(data_type66, "_usint"):  # List
+        if EvaluationHelper.equals(data_type, "_usint"):  # List
             # Array field (value)
             # Count array
-            if numberOfValues66 > Integer.MAX_VALUE:
+            if numberOfValues > Integer.MAX_VALUE:
                 raise ParseException(
                     "Array count of "
-                    + (numberOfValues66)
+                    + (numberOfValues)
                     + " exceeds the maximum allowed count of "
                     + Integer.MAX_VALUE
                 )
 
-            item_count: int = int(numberOfValues66)
+            item_count: int = int(numberOfValues)
             value: List[PlcValue] = []
             for cur_item in range(item_count):
                 value.append(PlcUINT(c_uint8(read_buffer.readUnsignedShort("", 8))))
 
             return PlcList(value)
-        if EvaluationHelper.equals(data_type66, "_uint") and EvaluationHelper.equals(
-            number_of_values66, c_uint16(1)
+        if EvaluationHelper.equals(data_type, "_uint") and EvaluationHelper.equals(
+            number_of_values, c_uint16(1)
         ):  # UINT
             # Simple Field (value)
             value: c_uint16 = read_buffer.readUnsignedInt("", 16)
 
             return PlcUINT(value)
-        if EvaluationHelper.equals(data_type66, "_uint"):  # List
+        if EvaluationHelper.equals(data_type, "_uint"):  # List
             # Array field (value)
             # Count array
-            if numberOfValues66 > Integer.MAX_VALUE:
+            if numberOfValues > Integer.MAX_VALUE:
                 raise ParseException(
                     "Array count of "
-                    + (numberOfValues66)
+                    + (numberOfValues)
                     + " exceeds the maximum allowed count of "
                     + Integer.MAX_VALUE
                 )
 
-            item_count: int = int(numberOfValues66)
+            item_count: int = int(numberOfValues)
             value: List[PlcValue] = []
             for cur_item in range(item_count):
                 value.append(PlcUDINT(c_uint16(read_buffer.readUnsignedInt("", 16))))
 
             return PlcList(value)
-        if EvaluationHelper.equals(data_type66, "_udint") and EvaluationHelper.equals(
-            number_of_values66, c_uint16(1)
+        if EvaluationHelper.equals(data_type, "_udint") and EvaluationHelper.equals(
+            number_of_values, c_uint16(1)
         ):  # UDINT
             # Simple Field (value)
             value: c_uint32 = read_buffer.readUnsignedLong("", 32)
 
             return PlcUDINT(value)
-        if EvaluationHelper.equals(data_type66, "_udint"):  # List
+        if EvaluationHelper.equals(data_type, "_udint"):  # List
             # Array field (value)
             # Count array
-            if numberOfValues66 > Integer.MAX_VALUE:
+            if numberOfValues > Integer.MAX_VALUE:
                 raise ParseException(
                     "Array count of "
-                    + (numberOfValues66)
+                    + (numberOfValues)
                     + " exceeds the maximum allowed count of "
                     + Integer.MAX_VALUE
                 )
 
-            item_count: int = int(numberOfValues66)
+            item_count: int = int(numberOfValues)
             value: List[PlcValue] = []
             for cur_item in range(item_count):
                 value.append(PlcULINT(c_uint32(read_buffer.readUnsignedLong("", 32))))
 
             return PlcList(value)
-        if EvaluationHelper.equals(data_type66, "_ulint") and EvaluationHelper.equals(
-            number_of_values66, c_uint16(1)
+        if EvaluationHelper.equals(data_type, "_ulint") and EvaluationHelper.equals(
+            number_of_values, c_uint16(1)
         ):  # ULINT
             # Simple Field (value)
             value: c_uint64 = read_buffer.readUnsignedBigInteger("", 64)
 
             return PlcULINT(value)
-        if EvaluationHelper.equals(data_type66, "_ulint"):  # List
+        if EvaluationHelper.equals(data_type, "_ulint"):  # List
             # Array field (value)
             # Count array
-            if numberOfValues66 > Integer.MAX_VALUE:
+            if numberOfValues > Integer.MAX_VALUE:
                 raise ParseException(
                     "Array count of "
-                    + (numberOfValues66)
+                    + (numberOfValues)
                     + " exceeds the maximum allowed count of "
                     + Integer.MAX_VALUE
                 )
 
-            item_count: int = int(numberOfValues66)
+            item_count: int = int(numberOfValues)
             value: List[PlcValue] = []
             for cur_item in range(item_count):
                 value.append(
@@ -354,108 +354,108 @@ class DataItem:
                 )
 
             return PlcList(value)
-        if EvaluationHelper.equals(data_type66, "_real") and EvaluationHelper.equals(
-            number_of_values66, c_uint16(1)
+        if EvaluationHelper.equals(data_type, "_real") and EvaluationHelper.equals(
+            number_of_values, c_uint16(1)
         ):  # REAL
             # Simple Field (value)
             value: c_float = read_buffer.readFloat("", 32)
 
             return PlcREAL(value)
-        if EvaluationHelper.equals(data_type66, "_real"):  # List
+        if EvaluationHelper.equals(data_type, "_real"):  # List
             # Array field (value)
             # Count array
-            if numberOfValues66 > Integer.MAX_VALUE:
+            if numberOfValues > Integer.MAX_VALUE:
                 raise ParseException(
                     "Array count of "
-                    + (numberOfValues66)
+                    + (numberOfValues)
                     + " exceeds the maximum allowed count of "
                     + Integer.MAX_VALUE
                 )
 
-            item_count: int = int(numberOfValues66)
+            item_count: int = int(numberOfValues)
             value: List[PlcValue] = []
             for cur_item in range(item_count):
                 value.append(PlcREAL(c_float(read_buffer.readFloat("", 32))))
 
             return PlcList(value)
-        if EvaluationHelper.equals(data_type66, "_lreal") and EvaluationHelper.equals(
-            number_of_values66, c_uint16(1)
+        if EvaluationHelper.equals(data_type, "_lreal") and EvaluationHelper.equals(
+            number_of_values, c_uint16(1)
         ):  # LREAL
             # Simple Field (value)
             value: c_double = read_buffer.readDouble("", 64)
 
             return PlcLREAL(value)
-        if EvaluationHelper.equals(data_type66, "_lreal"):  # List
+        if EvaluationHelper.equals(data_type, "_lreal"):  # List
             # Array field (value)
             # Count array
-            if numberOfValues66 > Integer.MAX_VALUE:
+            if numberOfValues > Integer.MAX_VALUE:
                 raise ParseException(
                     "Array count of "
-                    + (numberOfValues66)
+                    + (numberOfValues)
                     + " exceeds the maximum allowed count of "
                     + Integer.MAX_VALUE
                 )
 
-            item_count: int = int(numberOfValues66)
+            item_count: int = int(numberOfValues)
             value: List[PlcValue] = []
             for cur_item in range(item_count):
                 value.append(PlcLREAL(c_double(read_buffer.readDouble("", 64))))
 
             return PlcList(value)
-        if EvaluationHelper.equals(data_type66, "_char") and EvaluationHelper.equals(
-            number_of_values66, c_uint16(1)
+        if EvaluationHelper.equals(data_type, "_char") and EvaluationHelper.equals(
+            number_of_values, c_uint16(1)
         ):  # CHAR
             # Simple Field (value)
             value: str = read_buffer.readString("", 8, "UTF-8")
 
             return PlcCHAR(value)
-        if EvaluationHelper.equals(data_type66, "_char"):  # List
+        if EvaluationHelper.equals(data_type, "_char"):  # List
             # Array field (value)
             # Count array
-            if numberOfValues66 > Integer.MAX_VALUE:
+            if numberOfValues > Integer.MAX_VALUE:
                 raise ParseException(
                     "Array count of "
-                    + (numberOfValues66)
+                    + (numberOfValues)
                     + " exceeds the maximum allowed count of "
                     + Integer.MAX_VALUE
                 )
 
-            item_count: int = int(numberOfValues66)
+            item_count: int = int(numberOfValues)
             value: List[PlcValue] = []
             for cur_item in range(item_count):
                 value.append(PlcSTRING(str(read_buffer.readString("", 8, "UTF-8"))))
 
             return PlcList(value)
-        if EvaluationHelper.equals(data_type66, "_wchar") and EvaluationHelper.equals(
-            number_of_values66, c_uint16(1)
+        if EvaluationHelper.equals(data_type, "_wchar") and EvaluationHelper.equals(
+            number_of_values, c_uint16(1)
         ):  # WCHAR
             # Simple Field (value)
             value: str = read_buffer.readString("", 16, "UTF-16")
 
             return PlcWCHAR(value)
-        if EvaluationHelper.equals(data_type66, "_wchar"):  # List
+        if EvaluationHelper.equals(data_type, "_wchar"):  # List
             # Array field (value)
             # Count array
-            if numberOfValues66 > Integer.MAX_VALUE:
+            if numberOfValues > Integer.MAX_VALUE:
                 raise ParseException(
                     "Array count of "
-                    + (numberOfValues66)
+                    + (numberOfValues)
                     + " exceeds the maximum allowed count of "
                     + Integer.MAX_VALUE
                 )
 
-            item_count: int = int(numberOfValues66)
+            item_count: int = int(numberOfValues)
             value: List[PlcValue] = []
             for cur_item in range(item_count):
                 value.append(PlcSTRING(str(read_buffer.readString("", 16, "UTF-16"))))
 
             return PlcList(value)
-        if EvaluationHelper.equals(data_type66, "_string"):  # STRING
+        if EvaluationHelper.equals(data_type, "_string"):  # STRING
             # Simple Field (value)
             value: str = read_buffer.readString("", 255, "UTF-8")
 
             return PlcSTRING(value)
-        if EvaluationHelper.equals(data_type66, "_wstring"):  # STRING
+        if EvaluationHelper.equals(data_type, "_wstring"):  # STRING
             # Simple Field (value)
             value: str = read_buffer.readString("", 255, "UTF-16")
 
@@ -481,232 +481,232 @@ class DataItem:
         numberOfValues: c_uint16,
         byteOrder: ByteOrder,
     ) -> None:
-        if EvaluationHelper.equals(dataType66, "BOOL") and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+        if EvaluationHelper.equals(dataType, "BOOL") and EvaluationHelper.equals(
+            numberOfValues, c_uint16(1)
         ):  # BOOL
             # Simple Field (value)
             value: c_bool = _value.getC_bool()
             writeBuffer.WriteBit("value", (value))
-        if EvaluationHelper.equals(dataType66, "BOOL"):  # List
+        if EvaluationHelper.equals(dataType, "BOOL"):  # List
             values: PlcList = _value
 
             for val in values.getList():
                 value: c_bool = val.getC_bool()
                 writeBuffer.WriteBit("value", (value))
 
-        if EvaluationHelper.equals(dataType66, "BYTE") and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+        if EvaluationHelper.equals(dataType, "BYTE") and EvaluationHelper.equals(
+            numberOfValues, c_uint16(1)
         ):  # BYTE
             # Simple Field (value)
             value: c_uint8 = _value.getC_uint8()
             writeBuffer.WriteUint8("value", 8, (value))
-        if EvaluationHelper.equals(dataType66, "BYTE"):  # List
+        if EvaluationHelper.equals(dataType, "BYTE"):  # List
             values: PlcList = _value
 
             for val in values.getList():
                 value: c_uint8 = val.getC_uint8()
                 writeBuffer.WriteUint8("value", 8, (value))
 
-        if EvaluationHelper.equals(dataType66, "WORD") and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+        if EvaluationHelper.equals(dataType, "WORD") and EvaluationHelper.equals(
+            numberOfValues, c_uint16(1)
         ):  # WORD
             # Simple Field (value)
             value: c_uint16 = _value.getC_uint16()
             writeBuffer.WriteUint16("value", 16, (value))
-        if EvaluationHelper.equals(dataType66, "WORD"):  # List
+        if EvaluationHelper.equals(dataType, "WORD"):  # List
             values: PlcList = _value
 
             for val in values.getList():
                 value: c_uint16 = val.getC_uint16()
                 writeBuffer.WriteUint16("value", 16, (value))
 
-        if EvaluationHelper.equals(dataType66, "DWORD") and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+        if EvaluationHelper.equals(dataType, "DWORD") and EvaluationHelper.equals(
+            numberOfValues, c_uint16(1)
         ):  # DWORD
             # Simple Field (value)
             value: c_uint32 = _value.getC_uint32()
             writeBuffer.WriteUint32("value", 32, (value))
-        if EvaluationHelper.equals(dataType66, "DWORD"):  # List
+        if EvaluationHelper.equals(dataType, "DWORD"):  # List
             values: PlcList = _value
 
             for val in values.getList():
                 value: c_uint32 = val.getC_uint32()
                 writeBuffer.WriteUint32("value", 32, (value))
 
-        if EvaluationHelper.equals(dataType66, "LWORD") and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+        if EvaluationHelper.equals(dataType, "LWORD") and EvaluationHelper.equals(
+            numberOfValues, c_uint16(1)
         ):  # LWORD
             # Simple Field (value)
             value: c_uint64 = _value.getC_uint64()
             writeBuffer.WriteUint64("value", 64, (value))
-        if EvaluationHelper.equals(dataType66, "LWORD"):  # List
+        if EvaluationHelper.equals(dataType, "LWORD"):  # List
             values: PlcList = _value
 
             for val in values.getList():
                 value: c_uint64 = val.getC_uint64()
                 writeBuffer.WriteUint64("value", 64, (value))
 
-        if EvaluationHelper.equals(dataType66, "SINT") and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+        if EvaluationHelper.equals(dataType, "SINT") and EvaluationHelper.equals(
+            numberOfValues, c_uint16(1)
         ):  # SINT
             # Simple Field (value)
             value: c_int8 = _value.getC_int8()
             writeBuffer.WriteInt8("value", 8, (value))
-        if EvaluationHelper.equals(dataType66, "SINT"):  # List
+        if EvaluationHelper.equals(dataType, "SINT"):  # List
             values: PlcList = _value
 
             for val in values.getList():
                 value: c_int8 = val.getC_int8()
                 writeBuffer.WriteInt8("value", 8, (value))
 
-        if EvaluationHelper.equals(dataType66, "INT") and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+        if EvaluationHelper.equals(dataType, "INT") and EvaluationHelper.equals(
+            numberOfValues, c_uint16(1)
         ):  # INT
             # Simple Field (value)
             value: c_int16 = _value.getC_int16()
             writeBuffer.WriteInt16("value", 16, (value))
-        if EvaluationHelper.equals(dataType66, "INT"):  # List
+        if EvaluationHelper.equals(dataType, "INT"):  # List
             values: PlcList = _value
 
             for val in values.getList():
                 value: c_int16 = val.getC_int16()
                 writeBuffer.WriteInt16("value", 16, (value))
 
-        if EvaluationHelper.equals(dataType66, "DINT") and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+        if EvaluationHelper.equals(dataType, "DINT") and EvaluationHelper.equals(
+            numberOfValues, c_uint16(1)
         ):  # DINT
             # Simple Field (value)
             value: c_int32 = _value.getC_int32()
             writeBuffer.WriteInt32("value", 32, (value))
-        if EvaluationHelper.equals(dataType66, "DINT"):  # List
+        if EvaluationHelper.equals(dataType, "DINT"):  # List
             values: PlcList = _value
 
             for val in values.getList():
                 value: c_int32 = val.getC_int32()
                 writeBuffer.WriteInt32("value", 32, (value))
 
-        if EvaluationHelper.equals(dataType66, "LINT") and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+        if EvaluationHelper.equals(dataType, "LINT") and EvaluationHelper.equals(
+            numberOfValues, c_uint16(1)
         ):  # LINT
             # Simple Field (value)
             value: c_int64 = _value.getC_int64()
             writeBuffer.WriteInt64("value", 64, (value))
-        if EvaluationHelper.equals(dataType66, "LINT"):  # List
+        if EvaluationHelper.equals(dataType, "LINT"):  # List
             values: PlcList = _value
 
             for val in values.getList():
                 value: c_int64 = val.getC_int64()
                 writeBuffer.WriteInt64("value", 64, (value))
 
-        if EvaluationHelper.equals(dataType66, "USINT") and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+        if EvaluationHelper.equals(dataType, "USINT") and EvaluationHelper.equals(
+            numberOfValues, c_uint16(1)
         ):  # USINT
             # Simple Field (value)
             value: c_uint8 = _value.getC_uint8()
             writeBuffer.WriteUint8("value", 8, (value))
-        if EvaluationHelper.equals(dataType66, "USINT"):  # List
+        if EvaluationHelper.equals(dataType, "USINT"):  # List
             values: PlcList = _value
 
             for val in values.getList():
                 value: c_uint8 = val.getC_uint8()
                 writeBuffer.WriteUint8("value", 8, (value))
 
-        if EvaluationHelper.equals(dataType66, "UINT") and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+        if EvaluationHelper.equals(dataType, "UINT") and EvaluationHelper.equals(
+            numberOfValues, c_uint16(1)
         ):  # UINT
             # Simple Field (value)
             value: c_uint16 = _value.getC_uint16()
             writeBuffer.WriteUint16("value", 16, (value))
-        if EvaluationHelper.equals(dataType66, "UINT"):  # List
+        if EvaluationHelper.equals(dataType, "UINT"):  # List
             values: PlcList = _value
 
             for val in values.getList():
                 value: c_uint16 = val.getC_uint16()
                 writeBuffer.WriteUint16("value", 16, (value))
 
-        if EvaluationHelper.equals(dataType66, "UDINT") and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+        if EvaluationHelper.equals(dataType, "UDINT") and EvaluationHelper.equals(
+            numberOfValues, c_uint16(1)
         ):  # UDINT
             # Simple Field (value)
             value: c_uint32 = _value.getC_uint32()
             writeBuffer.WriteUint32("value", 32, (value))
-        if EvaluationHelper.equals(dataType66, "UDINT"):  # List
+        if EvaluationHelper.equals(dataType, "UDINT"):  # List
             values: PlcList = _value
 
             for val in values.getList():
                 value: c_uint32 = val.getC_uint32()
                 writeBuffer.WriteUint32("value", 32, (value))
 
-        if EvaluationHelper.equals(dataType66, "ULINT") and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+        if EvaluationHelper.equals(dataType, "ULINT") and EvaluationHelper.equals(
+            numberOfValues, c_uint16(1)
         ):  # ULINT
             # Simple Field (value)
             value: c_uint64 = _value.getC_uint64()
             writeBuffer.WriteUint64("value", 64, (value))
-        if EvaluationHelper.equals(dataType66, "ULINT"):  # List
+        if EvaluationHelper.equals(dataType, "ULINT"):  # List
             values: PlcList = _value
 
             for val in values.getList():
                 value: c_uint64 = val.getC_uint64()
                 writeBuffer.WriteUint64("value", 64, (value))
 
-        if EvaluationHelper.equals(dataType66, "REAL") and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+        if EvaluationHelper.equals(dataType, "REAL") and EvaluationHelper.equals(
+            numberOfValues, c_uint16(1)
         ):  # REAL
             # Simple Field (value)
             value: c_float = _value.getC_float()
             writeBuffer.WriteFloat32("value", 32, (value))
-        if EvaluationHelper.equals(dataType66, "REAL"):  # List
+        if EvaluationHelper.equals(dataType, "REAL"):  # List
             values: PlcList = _value
 
             for val in values.getList():
                 value: c_float = val.getC_float()
                 writeBuffer.WriteFloat32("value", 32, (value))
 
-        if EvaluationHelper.equals(dataType66, "LREAL") and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+        if EvaluationHelper.equals(dataType, "LREAL") and EvaluationHelper.equals(
+            numberOfValues, c_uint16(1)
         ):  # LREAL
             # Simple Field (value)
             value: c_double = _value.getC_double()
             writeBuffer.WriteFloat64("value", 64, (value))
-        if EvaluationHelper.equals(dataType66, "LREAL"):  # List
+        if EvaluationHelper.equals(dataType, "LREAL"):  # List
             values: PlcList = _value
 
             for val in values.getList():
                 value: c_double = val.getC_double()
                 writeBuffer.WriteFloat64("value", 64, (value))
 
-        if EvaluationHelper.equals(dataType66, "CHAR") and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+        if EvaluationHelper.equals(dataType, "CHAR") and EvaluationHelper.equals(
+            numberOfValues, c_uint16(1)
         ):  # CHAR
             # Simple Field (value)
             value: str = _value.getStr()
             writeBuffer.WriteString("value", uint32(8), "UTF-8", (value))
-        if EvaluationHelper.equals(dataType66, "CHAR"):  # List
+        if EvaluationHelper.equals(dataType, "CHAR"):  # List
             values: PlcList = _value
 
             for val in values.getList():
                 value: str = val.getStr()
                 writeBuffer.WriteString("value", uint32(8), "UTF-8", (value))
 
-        if EvaluationHelper.equals(dataType66, "WCHAR") and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+        if EvaluationHelper.equals(dataType, "WCHAR") and EvaluationHelper.equals(
+            numberOfValues, c_uint16(1)
         ):  # WCHAR
             # Simple Field (value)
             value: str = _value.getStr()
             writeBuffer.WriteString("value", uint32(16), "UTF-16", (value))
-        if EvaluationHelper.equals(dataType66, "WCHAR"):  # List
+        if EvaluationHelper.equals(dataType, "WCHAR"):  # List
             values: PlcList = _value
 
             for val in values.getList():
                 value: str = val.getStr()
                 writeBuffer.WriteString("value", uint32(16), "UTF-16", (value))
 
-        if EvaluationHelper.equals(dataType66, "STRING"):  # STRING
+        if EvaluationHelper.equals(dataType, "STRING"):  # STRING
             # Simple Field (value)
             value: str = _value.getStr()
             writeBuffer.WriteString("value", uint32(255), "UTF-8", (value))
-        if EvaluationHelper.equals(dataType66, "WSTRING"):  # STRING
+        if EvaluationHelper.equals(dataType, "WSTRING"):  # STRING
             # Simple Field (value)
             value: str = _value.getStr()
             writeBuffer.WriteString("value", uint32(255), "UTF-16", (value))
@@ -724,146 +724,146 @@ class DataItem:
         _value: PlcValue, dataType: str, numberOfValues: c_uint16
     ) -> int:
         sizeInBits: int = 0
-        if EvaluationHelper.equals(dataType66, "BOOL") and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+        if EvaluationHelper.equals(dataType, "BOOL") and EvaluationHelper.equals(
+            numberOfValues, c_uint16(1)
         ):  # BOOL
             # Simple Field (value)
             sizeInBits += 1
-        if EvaluationHelper.equals(dataType66, "BOOL"):  # List
+        if EvaluationHelper.equals(dataType, "BOOL"):  # List
             values: PlcList = _value
             sizeInBits += values.getList().size() * 1
-        if EvaluationHelper.equals(dataType66, "BYTE") and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+        if EvaluationHelper.equals(dataType, "BYTE") and EvaluationHelper.equals(
+            numberOfValues, c_uint16(1)
         ):  # BYTE
             # Simple Field (value)
             sizeInBits += 8
-        if EvaluationHelper.equals(dataType66, "BYTE"):  # List
+        if EvaluationHelper.equals(dataType, "BYTE"):  # List
             values: PlcList = _value
             sizeInBits += values.getList().size() * 8
-        if EvaluationHelper.equals(dataType66, "WORD") and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+        if EvaluationHelper.equals(dataType, "WORD") and EvaluationHelper.equals(
+            numberOfValues, c_uint16(1)
         ):  # WORD
             # Simple Field (value)
             sizeInBits += 16
-        if EvaluationHelper.equals(dataType66, "WORD"):  # List
+        if EvaluationHelper.equals(dataType, "WORD"):  # List
             values: PlcList = _value
             sizeInBits += values.getList().size() * 16
-        if EvaluationHelper.equals(dataType66, "DWORD") and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+        if EvaluationHelper.equals(dataType, "DWORD") and EvaluationHelper.equals(
+            numberOfValues, c_uint16(1)
         ):  # DWORD
             # Simple Field (value)
             sizeInBits += 32
-        if EvaluationHelper.equals(dataType66, "DWORD"):  # List
+        if EvaluationHelper.equals(dataType, "DWORD"):  # List
             values: PlcList = _value
             sizeInBits += values.getList().size() * 32
-        if EvaluationHelper.equals(dataType66, "LWORD") and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+        if EvaluationHelper.equals(dataType, "LWORD") and EvaluationHelper.equals(
+            numberOfValues, c_uint16(1)
         ):  # LWORD
             # Simple Field (value)
             sizeInBits += 64
-        if EvaluationHelper.equals(dataType66, "LWORD"):  # List
+        if EvaluationHelper.equals(dataType, "LWORD"):  # List
             values: PlcList = _value
             sizeInBits += values.getList().size() * 64
-        if EvaluationHelper.equals(dataType66, "SINT") and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+        if EvaluationHelper.equals(dataType, "SINT") and EvaluationHelper.equals(
+            numberOfValues, c_uint16(1)
         ):  # SINT
             # Simple Field (value)
             sizeInBits += 8
-        if EvaluationHelper.equals(dataType66, "SINT"):  # List
+        if EvaluationHelper.equals(dataType, "SINT"):  # List
             values: PlcList = _value
             sizeInBits += values.getList().size() * 8
-        if EvaluationHelper.equals(dataType66, "INT") and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+        if EvaluationHelper.equals(dataType, "INT") and EvaluationHelper.equals(
+            numberOfValues, c_uint16(1)
         ):  # INT
             # Simple Field (value)
             sizeInBits += 16
-        if EvaluationHelper.equals(dataType66, "INT"):  # List
+        if EvaluationHelper.equals(dataType, "INT"):  # List
             values: PlcList = _value
             sizeInBits += values.getList().size() * 16
-        if EvaluationHelper.equals(dataType66, "DINT") and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+        if EvaluationHelper.equals(dataType, "DINT") and EvaluationHelper.equals(
+            numberOfValues, c_uint16(1)
         ):  # DINT
             # Simple Field (value)
             sizeInBits += 32
-        if EvaluationHelper.equals(dataType66, "DINT"):  # List
+        if EvaluationHelper.equals(dataType, "DINT"):  # List
             values: PlcList = _value
             sizeInBits += values.getList().size() * 32
-        if EvaluationHelper.equals(dataType66, "LINT") and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+        if EvaluationHelper.equals(dataType, "LINT") and EvaluationHelper.equals(
+            numberOfValues, c_uint16(1)
         ):  # LINT
             # Simple Field (value)
             sizeInBits += 64
-        if EvaluationHelper.equals(dataType66, "LINT"):  # List
+        if EvaluationHelper.equals(dataType, "LINT"):  # List
             values: PlcList = _value
             sizeInBits += values.getList().size() * 64
-        if EvaluationHelper.equals(dataType66, "USINT") and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+        if EvaluationHelper.equals(dataType, "USINT") and EvaluationHelper.equals(
+            numberOfValues, c_uint16(1)
         ):  # USINT
             # Simple Field (value)
             sizeInBits += 8
-        if EvaluationHelper.equals(dataType66, "USINT"):  # List
+        if EvaluationHelper.equals(dataType, "USINT"):  # List
             values: PlcList = _value
             sizeInBits += values.getList().size() * 8
-        if EvaluationHelper.equals(dataType66, "UINT") and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+        if EvaluationHelper.equals(dataType, "UINT") and EvaluationHelper.equals(
+            numberOfValues, c_uint16(1)
         ):  # UINT
             # Simple Field (value)
             sizeInBits += 16
-        if EvaluationHelper.equals(dataType66, "UINT"):  # List
+        if EvaluationHelper.equals(dataType, "UINT"):  # List
             values: PlcList = _value
             sizeInBits += values.getList().size() * 16
-        if EvaluationHelper.equals(dataType66, "UDINT") and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+        if EvaluationHelper.equals(dataType, "UDINT") and EvaluationHelper.equals(
+            numberOfValues, c_uint16(1)
         ):  # UDINT
             # Simple Field (value)
             sizeInBits += 32
-        if EvaluationHelper.equals(dataType66, "UDINT"):  # List
+        if EvaluationHelper.equals(dataType, "UDINT"):  # List
             values: PlcList = _value
             sizeInBits += values.getList().size() * 32
-        if EvaluationHelper.equals(dataType66, "ULINT") and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+        if EvaluationHelper.equals(dataType, "ULINT") and EvaluationHelper.equals(
+            numberOfValues, c_uint16(1)
         ):  # ULINT
             # Simple Field (value)
             sizeInBits += 64
-        if EvaluationHelper.equals(dataType66, "ULINT"):  # List
+        if EvaluationHelper.equals(dataType, "ULINT"):  # List
             values: PlcList = _value
             sizeInBits += values.getList().size() * 64
-        if EvaluationHelper.equals(dataType66, "REAL") and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+        if EvaluationHelper.equals(dataType, "REAL") and EvaluationHelper.equals(
+            numberOfValues, c_uint16(1)
         ):  # REAL
             # Simple Field (value)
             sizeInBits += 32
-        if EvaluationHelper.equals(dataType66, "REAL"):  # List
+        if EvaluationHelper.equals(dataType, "REAL"):  # List
             values: PlcList = _value
             sizeInBits += values.getList().size() * 32
-        if EvaluationHelper.equals(dataType66, "LREAL") and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+        if EvaluationHelper.equals(dataType, "LREAL") and EvaluationHelper.equals(
+            numberOfValues, c_uint16(1)
         ):  # LREAL
             # Simple Field (value)
             sizeInBits += 64
-        if EvaluationHelper.equals(dataType66, "LREAL"):  # List
+        if EvaluationHelper.equals(dataType, "LREAL"):  # List
             values: PlcList = _value
             sizeInBits += values.getList().size() * 64
-        if EvaluationHelper.equals(dataType66, "CHAR") and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+        if EvaluationHelper.equals(dataType, "CHAR") and EvaluationHelper.equals(
+            numberOfValues, c_uint16(1)
         ):  # CHAR
             # Simple Field (value)
             sizeInBits += 8
-        if EvaluationHelper.equals(dataType66, "CHAR"):  # List
+        if EvaluationHelper.equals(dataType, "CHAR"):  # List
             values: PlcList = _value
             sizeInBits += values.getList().size() * 8
-        if EvaluationHelper.equals(dataType66, "WCHAR") and EvaluationHelper.equals(
-            numberOfValues66, c_uint16(1)
+        if EvaluationHelper.equals(dataType, "WCHAR") and EvaluationHelper.equals(
+            numberOfValues, c_uint16(1)
         ):  # WCHAR
             # Simple Field (value)
             sizeInBits += 16
-        if EvaluationHelper.equals(dataType66, "WCHAR"):  # List
+        if EvaluationHelper.equals(dataType, "WCHAR"):  # List
             values: PlcList = _value
             sizeInBits += values.getList().size() * 16
-        if EvaluationHelper.equals(dataType66, "STRING"):  # STRING
+        if EvaluationHelper.equals(dataType, "STRING"):  # STRING
             # Simple Field (value)
             sizeInBits += 255
-        if EvaluationHelper.equals(dataType66, "WSTRING"):  # STRING
+        if EvaluationHelper.equals(dataType, "WSTRING"):  # STRING
             # Simple Field (value)
             sizeInBits += 255
         return sizeInBits