MTPPy2.0 0.1.5__py3-none-any.whl

mtppy/part4/process_values/input_elements/ana_process_value_in.py

@@ -0,0 +1,160 @@
+"""Implementation of Analog Process Value Input.
+
+This module implements the AnaProcessValueIn class which represents an analog process value input
+element in accordance with the MTP 2.0 specification.
+"""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+from typing import ClassVar
+
+from mtppy.utils.logging import logger
+from mtppy.utils.data_item import DataItem
+from mtppy.part3.definitions.mtp_access import MTPAccess
+from mtppy.part5.definitions.w3c_xml_data_types import W3cXmlDataTypes
+from mtppy.part3.data_assembly_set.base_functions.oslevel import OSLevelBaseFunction
+from mtppy.part4.process_values.input_elements.input_element import InputElement
+
+
+class AnaProcessValueIn(InputElement):
+    """Analog Process Value Input (AnaProcessValueIn).
+
+    Implements an analog process value input element according to MTP 2.0 specification.
+    """
+
+    V_ = "V"
+    UNIT_CUR = "UnitCur"
+    SCL_MIN_CUR = "SclMinCur"
+    SCL_MAX_CUR = "SclMaxCur"
+    UNIT_EXT = "UnitExt"
+    SCL_MIN_EXT = "SclMinExt"
+    SCL_MAX_EXT = "SclMaxExt"
+    APPLY_EN = "ApplyEn"
+    APPLY_ = "Apply"
+
+    # Class-level data items dictionary
+    CLASS_DATA_ITEMS: ClassVar = {
+        V_: DataItem(V_, W3cXmlDataTypes.FLOAT, MTPAccess.ReadWriteAccess, 0),
+        UNIT_CUR: DataItem(UNIT_CUR, W3cXmlDataTypes.SHORT, MTPAccess.ReadAccess, 0),
+        SCL_MIN_CUR: DataItem(
+            SCL_MIN_CUR, W3cXmlDataTypes.FLOAT, MTPAccess.ReadAccess, 0
+        ),
+        SCL_MAX_CUR: DataItem(
+            SCL_MAX_CUR, W3cXmlDataTypes.FLOAT, MTPAccess.ReadAccess, 0
+        ),
+        UNIT_EXT: DataItem(
+            UNIT_EXT, W3cXmlDataTypes.SHORT, MTPAccess.ReadWriteAccess, 0, None
+        ),
+        SCL_MIN_EXT: DataItem(
+            SCL_MIN_EXT, W3cXmlDataTypes.FLOAT, MTPAccess.ReadWriteAccess, 0, None
+        ),
+        SCL_MAX_EXT: DataItem(
+            SCL_MAX_EXT, W3cXmlDataTypes.FLOAT, MTPAccess.ReadWriteAccess, 0, None
+        ),
+        APPLY_EN: DataItem(
+            APPLY_EN, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, False
+        ),
+        APPLY_: DataItem(
+            APPLY_, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadWriteAccess, False, None
+        ),
+    }
+
+    os_level: OSLevelBaseFunction
+
+    def __init__(
+        self,
+        tag_name: str,
+        tag_description: str,
+        v: float = 0,
+        scl_min_cur: float = 0,
+        scl_max_cur: float = 100,
+        unit_cur: int = 1998,
+        apply_en: bool = False,
+    ) -> None:
+        """Initialize the AnaProcessValueIn element.
+
+        Args:
+            tag_name: Name of the tag.
+            tag_description: Description of the tag.
+            v: Initial value for the V data item.
+            scl_min_cur: Current scale minimum value.
+            scl_max_cur: Current scale maximum value.
+            unit_cur: Current unit value.
+            apply_en: Apply enable flag.
+        """
+        super().__init__(tag_name, tag_description)
+        self.mtpObjectType = (
+            "MTPDataAssemblySUCLib/DataAssembly/InputElement/AnaProcessValueIn"
+        )
+
+        self.os_level = OSLevelBaseFunction()
+
+        # Set initial values for data items
+        self[self.V_] = v
+        self[self.UNIT_CUR] = unit_cur
+        self[self.SCL_MIN_CUR] = scl_min_cur
+        self[self.SCL_MAX_CUR] = scl_max_cur
+        self[self.UNIT_EXT] = 0
+        self[self.SCL_MIN_EXT] = 0
+        self[self.SCL_MAX_EXT] = 0
+        self[self.APPLY_EN] = apply_en
+
+        self.get_item(self.V_).ext_wrt_cb = self.set_v
+        self.get_item(self.UNIT_EXT).ext_wrt_cb = self._set_unit_ext
+        self.get_item(self.SCL_MIN_EXT).ext_wrt_cb = self._set_scl_min_ext
+        self.get_item(self.SCL_MAX_EXT).ext_wrt_cb = self._set_scl_max_ext
+        self.get_item(self.APPLY_).ext_wrt_cb = self.apply
+
+    def set_v(self, value: float) -> None:
+        """Set the V data item value.
+
+        Args:
+            value: The value to set for the V data item.
+        """
+        logger.debug(f"V set to {value}")
+        self[self.V_] = value
+
+    def _set_unit_ext(self, value: int) -> None:
+        """Set the UnitExt data item value.
+
+        Args:
+            value: The value to set for the UnitExt data item.
+        """
+        logger.debug(f"UnitExt set to {value}")
+        self[self.UNIT_EXT] = value
+
+    def _set_scl_min_ext(self, value: float) -> None:
+        """Set the SclMinExt data item value.
+
+        Args:
+            value: The value to set for the SclMinExt data item.
+        """
+        logger.debug("SclMinExt set to {value}")
+        self[self.SCL_MIN_EXT] = value
+
+    def _set_scl_max_ext(self, value: float) -> None:
+        """Set the SclMaxExt data item value.
+
+        Args:
+            value: The value to set for the SclMaxExt data item.
+        """
+        logger.debug(f"SclMaxExt set to {value}")
+        self[self.SCL_MAX_EXT] = value
+
+    def set_apply_en(self, value: bool) -> None:
+        """Set the ApplyEn data item value.
+
+        Args:
+            value: The boolean value to set for the ApplyEn data item.
+        """
+        self[self.APPLY_EN] = value
+
+    def apply(self) -> None:
+        """Apply the external values to current values."""
+        self[self.UNIT_CUR] = self[self.UNIT_EXT]
+        self[self.SCL_MIN_CUR] = self[self.SCL_MIN_EXT]
+        self[self.SCL_MAX_CUR] = self[self.SCL_MAX_EXT]
+        self[self.APPLY_] = False

mtppy/part4/process_values/input_elements/bin_process_value_in.py

@@ -0,0 +1,83 @@
+"""Implements Binary Process Value Input.
+
+This module implements the BinProcessValueIn class which represents a binary process value input
+element in accordance with the MTP 2.0 specification.
+"""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+from typing import ClassVar
+
+from mtppy.utils.logging import logger
+from mtppy.utils.data_item import DataItem
+from mtppy.part3.definitions.mtp_access import MTPAccess
+from mtppy.part5.definitions.w3c_xml_data_types import W3cXmlDataTypes
+from mtppy.part3.data_assembly_set.base_functions.oslevel import OSLevelBaseFunction
+from mtppy.part4.process_values.input_elements.input_element import InputElement
+
+
+class BinProcessValueIn(InputElement):
+    """Binary Process Value Input (BinProcessValueIn).
+
+    Implements a binary process value input element according to MTP 2.0 specification.
+    """
+
+    V_ = "V"
+    V_STATE_0 = "VState0"
+    V_STATE_1 = "VState1"
+
+    # Class-level data items dictionary
+    CLASS_DATA_ITEMS: ClassVar = {
+        V_: DataItem(V_, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadWriteAccess, False),
+        V_STATE_0: DataItem(
+            V_STATE_0, W3cXmlDataTypes.STRING, MTPAccess.ReadAccess, ""
+        ),
+        V_STATE_1: DataItem(
+            V_STATE_1, W3cXmlDataTypes.STRING, MTPAccess.ReadAccess, ""
+        ),
+    }
+
+    os_level: OSLevelBaseFunction
+
+    def __init__(
+        self,
+        tag_name: str,
+        tag_description: str,
+        v: bool = False,
+        v_state_0: str = "False",
+        v_state_1: str = "True",
+    ) -> None:
+        """Initialize the BinProcessValueIn element.
+
+        Args:
+            tag_name: Name of the tag.
+            tag_description: Description of the tag.
+            v: Initial value for the V data item.
+            v_state_0: Value for VState0 data item.
+            v_state_1: Value for VState1 data item.
+        """
+        super().__init__(tag_name, tag_description)
+        self.mtpObjectType = (
+            "MTPDataAssemblySUCLib/DataAssembly/InputElement/BinProcessValueIn"
+        )
+
+        self.os_level = OSLevelBaseFunction()
+
+        # Set initial values for data items
+        self[self.V_] = v
+        self[self.V_STATE_0] = v_state_0
+        self[self.V_STATE_1] = v_state_1
+
+        self.get_item(self.V_).ext_wrt_cb = self.set_v
+
+    def set_v(self, value: bool) -> None:
+        """Set the V data item value.
+
+        Args:
+            value: The boolean value to set for the V data item.
+        """
+        logger.debug(f"V set to {value}")
+        self[self.V_] = value

mtppy/part4/process_values/input_elements/dint_process_value_in.py

@@ -0,0 +1,159 @@
+"""Implementation of DIntProcessValueIn
+
+This module implements the DIntProcessValueIn class which represents a discrete integer
+process value input element in accordance with the MTP 2.0 specification.
+"""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+from typing import ClassVar
+
+from mtppy.utils.logging import logger
+from mtppy.utils.data_item import DataItem
+from mtppy.part3.definitions.mtp_access import MTPAccess
+from mtppy.part5.definitions.w3c_xml_data_types import W3cXmlDataTypes
+from mtppy.part3.data_assembly_set.base_functions.oslevel import OSLevelBaseFunction
+from mtppy.part4.process_values.input_elements.input_element import InputElement
+
+
+class DIntProcessValueIn(InputElement):
+    """Discrete Integer Process Value Input (DIntProcessValueIn)."""
+
+    V_ = "V"
+    UNIT_CUR = "UnitCur"
+    SCL_MIN_CUR = "SclMinCur"
+    SCL_MAX_CUR = "SclMaxCur"
+    UNIT_EXT = "UnitExt"
+    SCL_MIN_EXT = "SclMinExt"
+    SCL_MAX_EXT = "SclMaxExt"
+    APPLY_EN = "ApplyEn"
+    APPLY_ = "Apply"
+
+    # Class-level data items dictionary
+    CLASS_DATA_ITEMS: ClassVar = {
+        V_: DataItem(V_, W3cXmlDataTypes.SHORT, MTPAccess.ReadWriteAccess, 0),
+        UNIT_CUR: DataItem(UNIT_CUR, W3cXmlDataTypes.SHORT, MTPAccess.ReadAccess, 0),
+        SCL_MIN_CUR: DataItem(
+            SCL_MIN_CUR, W3cXmlDataTypes.SHORT, MTPAccess.ReadAccess, 0
+        ),
+        SCL_MAX_CUR: DataItem(
+            SCL_MAX_CUR, W3cXmlDataTypes.SHORT, MTPAccess.ReadAccess, 0
+        ),
+        UNIT_EXT: DataItem(
+            UNIT_EXT, W3cXmlDataTypes.SHORT, MTPAccess.ReadWriteAccess, 0
+        ),
+        SCL_MIN_EXT: DataItem(
+            SCL_MIN_EXT, W3cXmlDataTypes.SHORT, MTPAccess.ReadWriteAccess, 0
+        ),
+        SCL_MAX_EXT: DataItem(
+            SCL_MAX_EXT, W3cXmlDataTypes.SHORT, MTPAccess.ReadWriteAccess, 0
+        ),
+        APPLY_EN: DataItem(
+            APPLY_EN, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, False
+        ),
+        APPLY_: DataItem(
+            APPLY_, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadWriteAccess, False
+        ),
+    }
+
+    os_level: OSLevelBaseFunction
+
+    def __init__(
+        self,
+        tag_name: str,
+        tag_description: str,
+        v: int = 0,
+        scl_min_cur: int = 0,
+        scl_max_cur: int = 100,
+        unit_cur: int = 1998,
+        apply_en: bool = False,
+    ) -> None:
+        """Initialize the DIntProcessValueIn element.
+
+        Args:
+            tag_name: Name of the tag.
+            tag_description: Description of the tag.
+            v: Initial value for the V data item.
+            scl_min_cur: Current scale minimum value.
+            scl_max_cur: Current scale maximum value.
+            unit_cur: Current unit value.
+            apply_en: Apply enable flag.
+        """
+        super().__init__(tag_name, tag_description)
+        self.mtpObjectType = (
+            "MTPDataAssemblySUCLib/DataAssembly/InputElement/DIntProcessValueIn"
+        )
+
+        self.os_level = OSLevelBaseFunction()
+
+        # Set initial values for data items
+        self[self.V_] = v
+        self[self.UNIT_CUR] = unit_cur
+        self[self.SCL_MIN_CUR] = scl_min_cur
+        self[self.SCL_MAX_CUR] = scl_max_cur
+        self[self.UNIT_EXT] = 0
+        self[self.SCL_MIN_EXT] = 0
+        self[self.SCL_MAX_EXT] = 0
+        self[self.APPLY_EN] = apply_en
+        self[self.APPLY_] = False
+
+        # Setup callbacks
+        self.get_item(self.V_).ext_wrt_cb = self.set_v
+        self.get_item(self.UNIT_EXT).ext_wrt_cb = self.set_unit_ext
+        self.get_item(self.SCL_MIN_EXT).ext_wrt_cb = self.set_scl_min_ext
+        self.get_item(self.SCL_MAX_EXT).ext_wrt_cb = self.set_scl_max_ext
+        self.get_item(self.APPLY_).ext_wrt_cb = self.apply
+
+    def set_v(self, value: int) -> None:
+        """Set the V data item value.
+
+        Args:
+            value: The value to set for the V data item.
+        """
+        logger.debug(f"V set to {value}")
+        self[self.V_] = value
+
+    def set_unit_ext(self, value: int) -> None:
+        """Set the UnitExt data item value.
+
+        Args:
+            value: The value to set for the UnitExt data item.
+        """
+        logger.debug(f"UnitExt set to {value}")
+        self[self.UNIT_EXT] = value
+
+    def set_scl_min_ext(self, value: int) -> None:
+        """Set the SclMinExt data item value.
+
+        Args:
+            value: The value to set for the SclMinExt data item.
+        """
+        logger.debug(f"SclMinExt set to {value}")
+        self[self.SCL_MIN_EXT] = value
+
+    def set_scl_max_ext(self, value: int) -> None:
+        """Set the SclMaxExt data item value.
+
+        Args:
+            value: The value to set for the SclMaxExt data item.
+        """
+        logger.debug(f"SclMaxExt set to {value}")
+        self[self.SCL_MAX_EXT] = value
+
+    def set_apply_en(self, value: bool) -> None:
+        """Set the ApplyEn data item value.
+
+        Args:
+            value: The boolean value to set for the ApplyEn data item.
+        """
+        self[self.APPLY_EN] = value
+
+    def apply(self) -> None:
+        """Apply the external values to current values."""
+        self[self.UNIT_CUR] = self[self.UNIT_EXT]
+        self[self.SCL_MIN_CUR] = self[self.SCL_MIN_EXT]
+        self[self.SCL_MAX_CUR] = self[self.SCL_MAX_EXT]
+        self[self.APPLY_] = False

mtppy/part4/process_values/input_elements/input_element.py

@@ -0,0 +1,40 @@
+"""Base Class for Input Elements."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+from mtppy.part3.data_assembly_set.data_assembly import DataAssembly
+from mtppy.part3.data_assembly_set.base_functions.wqc import WQCBaseFunction
+from mtppy.part4.process_values.base_functions.vqc import VQCBaseFunction
+
+
+class InputElement(DataAssembly):
+    """Base class for input elements in the process value framework.
+
+    Input elements provide data input capabilities with integrated quality control
+    through WQC (Write Quality Control) and VQC (Validation Quality Control) functions.
+    They inherit from DataAssembly and serve as the foundation for various input
+    element types in the system.
+
+    Attributes:
+        wqc: Write Quality Control function instance for managing write operations
+        vqc: Validation Quality Control function instance for validating data
+    """
+
+    wqc: WQCBaseFunction
+    vqc: VQCBaseFunction
+
+    def __init__(self, tag_name: str, tag_description: str):
+        """Initialize an InputElement instance.
+
+        Args:
+            tag_name: The name identifier for the input element
+            tag_description: A descriptive text for the input element
+        """
+        super().__init__(tag_name, tag_description)
+        self.mtpObjectType = "MTPDataAssemblySUCLib/DataAssembly/InputElement"
+
+        self.wqc = WQCBaseFunction()
+        self.vqc = VQCBaseFunction()

mtppy/part4/process_values/input_elements/string_process_value_in.py

@@ -0,0 +1,45 @@
+"""Implementation of String Process Value Input.
+
+This module implements the StringProcessValueIn class which represents an analog process value input
+element in accordance with the MTP 2.0 specification.
+"""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+from typing import ClassVar
+
+from mtppy.utils.logging import logger
+from mtppy.utils.data_item import DataItem
+from mtppy.part3.definitions.mtp_access import MTPAccess
+from mtppy.part5.definitions.w3c_xml_data_types import W3cXmlDataTypes
+from mtppy.part3.data_assembly_set.base_functions.oslevel import OSLevelBaseFunction
+from mtppy.part4.process_values.input_elements.input_element import InputElement
+
+
+class StringProcessValueIn(InputElement):
+    V_ = "V"
+
+    # Class-level data items dictionary
+    CLASS_DATA_ITEMS: ClassVar = {
+        V_: DataItem(V_, W3cXmlDataTypes.STRING, MTPAccess.ReadWriteAccess, "")
+    }
+
+    os_level: OSLevelBaseFunction
+
+    def __init__(self, tag_name: str, tag_description: str, v: str = ""):
+        super().__init__(tag_name, tag_description)
+        self.mtpObjectType = (
+            "MTPDataAssemblySUCLib/DataAssembly/InputElement/StringProcessValueIn"
+        )
+
+        self.os_level = OSLevelBaseFunction()
+
+        self[self.V_] = v
+        self.get_item(self.V_).ext_wrt_cb = self.set_v
+
+    def set_v(self, value):
+        logger.debug(f"V set to {value}")
+        self[self.V_] = value

mtppy/part5/__init__.py

@@ -0,0 +1,4 @@
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"

mtppy/part5/communication_object.py

@@ -0,0 +1,99 @@
+"""Communication objects encapsulate value updates for external protocols."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+from opcua import ua
+from opcua.common.node import Node as OPCUA_Node
+
+import utils.type_conversion as tc
+
+
+class CommunicationObject(ABC):
+    """Base class for protocol-specific communication objects.
+
+    A communication object binds a protocol-specific node to a callback that a
+    DataItem can use to publish value changes.
+
+    Attributes:
+        write_value_callback: Public callback that delegates to the concrete
+            protocol-specific write implementation.
+    """
+
+    def __init__(self, node_obj: Any, node_id: str) -> None:
+        """Initialize a communication object.
+
+        Args:
+            node_obj: Protocol-specific node or client object used to write
+                values.
+            node_id: Identifier of the associated node or register. Its
+                interpretation is defined by the concrete subclass.
+        """
+        self._node_obj = node_obj
+        self._node_id = node_id
+        self.write_value_callback = self._set_value
+
+    @abstractmethod
+    def _set_value(self, value: tc.ANY_TYPE) -> None:
+        """Write a value using the protocol-specific implementation.
+
+        Args:
+            value: Value to write to the associated external node.
+        """
+
+
+class OPCUACommunicationObject(CommunicationObject):
+    """Write DataItem values to an OPC UA node.
+
+    Values are wrapped in an ``opcua.ua.Variant`` before being passed to the
+    node's ``set_value`` method.
+    """
+
+    def __init__(self, opcua_node_obj: OPCUA_Node, node_id: str) -> None:
+        """Initialize an OPC UA communication object.
+
+        Args:
+            opcua_node_obj: OPC UA node that receives written values.
+            node_id: OPC UA node identifier retained for diagnostics and model
+                generation.
+        """
+        super().__init__(opcua_node_obj, node_id)
+
+    def _set_value(self, value: tc.ANY_TYPE) -> None:
+        """Set a value on the OPC UA node.
+
+        Args:
+            value: Value to wrap in an OPC UA Variant and write to the node.
+        """
+        self._node_obj.set_value(ua.Variant(value))
+
+
+class MODBUSCommunicationObject(CommunicationObject):
+    """Write DataItem values to a Modbus holding register.
+
+    The ``node_obj`` is expected to be a pymodbus client exposing
+    ``write_register``. The string ``node_id`` is converted to an integer
+    register address for each write.
+    """
+
+    def __init__(self, modbus_client: Any, node_id: str) -> None:
+        """Initialize a Modbus communication object.
+
+        Args:
+            modbus_client: Pymodbus client used to write the register.
+            node_id: Register address represented as a string.
+        """
+        super().__init__(modbus_client, node_id)
+
+    def _set_value(self, value: tc.ANY_TYPE) -> None:
+        """Write a value to the configured Modbus holding register.
+
+        Args:
+            value: Integer-compatible value accepted by pymodbus.
+        """
+        self._node_obj.write_register(address=int(self._node_id), value=value)

mtppy/part5/communication_object_test.py

@@ -0,0 +1,59 @@
+"""Test suite for the OPC UA communication object."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+from unittest.mock import Mock
+from typing import Any
+
+from opcua import ua
+
+from mtppy.part5.communication_object import (
+    CommunicationObject,
+    MODBUSCommunicationObject,
+    OPCUACommunicationObject,
+)
+
+
+class TestCommunicationObject(CommunicationObject):
+    def _set_value(self, value: Any) -> None:
+        self.written_value = value
+
+
+def test_initializes_with_node_and_node_id() -> None:
+    node = Mock()
+
+    communication_object = OPCUACommunicationObject(node, "ns=2;s=Test")
+
+    assert callable(communication_object.write_value_callback)
+
+
+def test_base_callback_delegates_to_protocol_specific_writer() -> None:
+    communication_object = TestCommunicationObject(Mock(), "test")
+
+    communication_object.write_value_callback("value")
+
+    assert communication_object.written_value == "value"
+
+
+def test_write_value_callback_sets_variant_on_node() -> None:
+    node = Mock()
+    communication_object = OPCUACommunicationObject(node, "ns=2;s=Test")
+
+    communication_object.write_value_callback(42)
+
+    node.set_value.assert_called_once()
+    value = node.set_value.call_args.args[0]
+    assert isinstance(value, ua.Variant)
+    assert getattr(value, "Value") == 42
+
+
+def test_modbus_write_value_callback_writes_to_register() -> None:
+    client = Mock()
+    communication_object = MODBUSCommunicationObject(client, "42")
+
+    communication_object.write_value_callback(7)
+
+    client.write_register.assert_called_once_with(address=42, value=7)

mtppy/part5/definitions/__init__.py

@@ -0,0 +1,4 @@
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"

mtppy/part5/definitions/iec61131_data_types.py

@@ -0,0 +1,31 @@
+"""Implementation of IEC-61131 Data Types."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+from enum import Enum
+
+
+class IEC61131DataTypes(Enum):
+    BOOL = ("BOOL",)
+    BYTE = ("BYTE",)
+    WORD = ("WORD",)
+    DWORD = ("DWORD",)
+    LWORD = ("LWORD",)
+    SINT = ("SINT",)
+    INT = ("INT",)
+    DINT = ("DINT",)
+    LINT = ("LINT",)
+    USINT = ("USINT",)
+    UINT = ("UINT",)
+    UDINT = ("UDINT",)
+    ULINT = ("ULINT",)
+    REAL = ("REAL",)
+    LREAL = ("LREAL",)
+    STRING = ("STRING",)
+    WSTRING = ("WSTRING",)
+    DATE = ("DATE",)
+    TIME_OF_DAY = ("TIME_OF_DAY",)
+    DATE_AND_TIME = "DATE_AND_TIME"