MTPPy2.0 0.1.5__py3-none-any.whl

mtppy/part4/automation_services/service_elements/parameter_elements/ana_serv_param.py

@@ -0,0 +1,108 @@
+"""Implementation of the AnaServ Parameters."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+from typing import ClassVar
+
+from mtppy.part5.definitions.w3c_xml_data_types import W3cXmlDataTypes
+from mtppy.part4.automation_services.service_elements.parameter_elements.parameter_element import (
+    ParameterElement,
+)
+from mtppy.part4.automation_services.service_elements.parameter_elements.common_serv_param import (
+    SERVICE_PARAM_BASE_DATA_ITEMS,
+    SERVICE_PARAM_NUMBER_DATA_ITEMS,
+    SERVICE_PARAM_SYNC_DATA_ITEMS,
+    CommonServParameter,
+)
+from mtppy.utils.logging import logger
+
+
+class AnaServParam(ParameterElement):
+    """Analog Service Parameter implementation.
+
+    This class implements analog service parameters for service elements,
+    inheriting from ParameterElement. It provides configurable boundaries (VMin, VMax)
+    along with scaling parameters (VSclMin, VSclMax) for e.g. display purposes.
+
+    """
+
+    CLASS_DATA_ITEMS: ClassVar = (
+        SERVICE_PARAM_BASE_DATA_ITEMS(W3cXmlDataTypes.FLOAT)
+        | SERVICE_PARAM_NUMBER_DATA_ITEMS(W3cXmlDataTypes.FLOAT)
+        | SERVICE_PARAM_SYNC_DATA_ITEMS
+    )
+
+    v_min: float
+    v_max: float
+    v_scl_min: float
+    v_scl_max: float
+    v_unit: int
+
+    def __init__(
+        self,
+        tag_name: str,
+        tag_description: str = "",
+        *,
+        v_min: float = 0,
+        v_max: float = 100,
+        v_scl_min: float = 0,
+        v_scl_max: float = 100,
+        v_unit: int = 0,
+    ) -> None:
+        """Initialize the Analog Service Parameter (AnaServParam).
+
+        Args:
+            tag_name: The name identifier for the parameter element
+            tag_description: A descriptive text for the parameter element
+            v_min: Minimum value for the analog parameter (enforced)
+            v_max: Maximum value for the analog parameter (enforced)
+            v_scl_min: Scaled minimum value for the analog parameter (informative)
+            v_scl_max: Scaled maximum value for the analog parameter (informative)
+            v_unit: Unit identifier for the analog parameter
+        """
+        super().__init__(tag_name, tag_description)
+        self.mtpObjectType = "MTPDataAssemblySUCLib/DataAssembly/ServiceElement/\
+            ParameterElement/AnaServParam"
+
+        self.v_min = v_min
+        self.v_max = v_max
+        self.v_scl_min = v_scl_min
+        self.v_scl_max = v_scl_max
+        self.v_unit = v_unit
+
+        # Initialize data items with dynamic values
+        self.get_item(CommonServParameter.V_OP).init_value = v_min
+        self.get_item(CommonServParameter.V_INT).init_value = v_min
+        self.get_item(CommonServParameter.V_EXT).init_value = v_min
+        self.get_item(CommonServParameter.V_REQ).init_value = v_min
+        self.get_item(CommonServParameter.V_UNIT).init_value = self.v_unit
+        self.get_item(CommonServParameter.V_SCL_MIN).init_value = self.v_scl_min
+        self.get_item(CommonServParameter.V_SCL_MAX).init_value = self.v_scl_max
+        self.get_item(CommonServParameter.V_MIN).init_value = self.v_min
+        self.get_item(CommonServParameter.V_MAX).init_value = self.v_max
+
+        self.get_item(CommonServParameter.V_OP).ext_wrt_cb = self.set_v_op
+        self.get_item(CommonServParameter.V_EXT).ext_wrt_cb = self.set_v_ext
+
+        self.get_item(CommonServParameter.V_INT).int_wrt_cb = self.set_v_int
+
+    def is_valid_value(self, value: float) -> bool:
+        """Check if a value is within the valid range for this parameter.
+
+        Logs information about the validation process and returns whether
+        the provided value is within the defined minimum and maximum bounds.
+
+        Args:
+            value: The value to validate
+
+        Returns:
+            bool: True if the value is within range, False otherwise
+        """
+        logger.info(f"AnaServ {value} in [{self.v_min},{self.v_max}]?")
+        if value < self.v_min or value > self.v_max:
+            logger.debug(f"{self.tag_name} invalid value, {value} (out of range)")
+            return False
+        return True

mtppy/part4/automation_services/service_elements/parameter_elements/ana_serv_param_test.py

@@ -0,0 +1,59 @@
+"""Test suite for AnaServParam."""
+
+import pytest
+
+from mtppy.part4.automation_services.service_elements.parameter_elements.ana_serv_param import (
+    AnaServParam,
+)
+from mtppy.part4.automation_services.service_elements.parameter_elements.common_serv_param import (
+    CommonServParameter as CSP,
+)
+
+
+def test_initialization_sets_numeric_metadata_and_values():
+    parameter = AnaServParam(
+        "Temperature",
+        "Temperature setpoint",
+        v_min=-10.5,
+        v_max=80.5,
+        v_scl_min=0,
+        v_scl_max=100,
+        v_unit=1001,
+    )
+
+    assert parameter.tag_name == "Temperature"
+    assert parameter.tag_description == "Temperature setpoint"
+    assert parameter.v_min == -10.5
+    assert parameter.v_max == 80.5
+    assert parameter.v_unit == 1001
+    assert parameter.get_item(CSP.V_MIN).init_value == -10.5
+    assert parameter.get_item(CSP.V_MAX).init_value == 80.5
+    assert parameter.get_item(CSP.V_UNIT).init_value == 1001
+    assert parameter.get_item(CSP.V_OP).init_value == -10.5
+    assert parameter.get_item(CSP.V_EXT).init_value == -10.5
+    assert parameter.get_item(CSP.V_INT).init_value == -10.5
+    assert parameter.get_item(CSP.V_REQ).init_value == -10.5
+
+
+@pytest.mark.parametrize("value", [-10.5, 0, 80.5])
+def test_valid_values_include_boundaries(value):
+    parameter = AnaServParam("Temperature", v_min=-10.5, v_max=80.5)
+
+    assert parameter.is_valid_value(value) is True
+
+
+@pytest.mark.parametrize("value", [-10.6, 80.6])
+def test_values_outside_range_are_invalid(value):
+    parameter = AnaServParam("Temperature", v_min=-10.5, v_max=80.5)
+
+    assert parameter.is_valid_value(value) is False
+
+
+def test_set_v_op_accepts_valid_value_and_rejects_invalid_value():
+    parameter = AnaServParam("Temperature", v_min=0, v_max=100)
+
+    parameter.set_v_op(42)
+    assert parameter[CSP.V_OP] == 42
+
+    parameter.set_v_op(101)
+    assert parameter[CSP.V_OP] == 42

mtppy/part4/automation_services/service_elements/parameter_elements/bin_serv_param.py

@@ -0,0 +1,70 @@
+"""Implementation of the Binary Service Parameters."""
+
+__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.part4.automation_services.service_elements.parameter_elements.parameter_element import (
+    ParameterElement,
+)
+from mtppy.part4.automation_services.service_elements.parameter_elements.common_serv_param import (
+    CommonServParameter,
+    SERVICE_PARAM_BASE_DATA_ITEMS,
+    SERVICE_PARAM_SYNC_DATA_ITEMS,
+)
+
+
+class BinServParam(ParameterElement):
+    V_STATE_0 = "VState0"
+    V_STATE_1 = "VState1"
+
+    CLASS_DATA_ITEMS: ClassVar = (
+        SERVICE_PARAM_BASE_DATA_ITEMS(W3cXmlDataTypes.BOOLEAN)
+        | {
+            V_STATE_0: DataItem(
+                V_STATE_0,
+                W3cXmlDataTypes.STRING,
+                MTPAccess.ReadAccess,
+                init_value=None,
+            ),
+            V_STATE_1: DataItem(
+                V_STATE_1,
+                W3cXmlDataTypes.STRING,
+                MTPAccess.ReadAccess,
+                init_value=None,
+            ),
+        }
+        | SERVICE_PARAM_SYNC_DATA_ITEMS
+    )
+
+    v_state_0: str
+    v_state_1: str
+
+    def __init__(
+        self,
+        tag_name: str,
+        tag_description: str = "",
+        v_state_0: str = "false",
+        v_state_1: str = "true",
+    ):
+        """
+        Binary Service Parameter (BinServParam).
+        """
+        super().__init__(tag_name, tag_description)
+        self.mtpObjectType = "MTPDataAssemblySUCLib/DataAssembly/ServiceElement/ParameterElement/BinServParam"
+
+        self.v_state_0 = v_state_0
+        self.v_state_1 = v_state_1
+
+        self.get_item(BinServParam.V_STATE_0).init_value = self.v_state_0
+        self.get_item(BinServParam.V_STATE_1).init_value = self.v_state_1
+
+        self.get_item(CommonServParameter.V_OP).ext_wrt_cb = self.set_v_op
+        self.get_item(CommonServParameter.V_EXT).ext_wrt_cb = self.set_v_ext

mtppy/part4/automation_services/service_elements/parameter_elements/bin_serv_param_test.py

@@ -0,0 +1,39 @@
+"""Test suite for BinServParam."""
+
+from mtppy.part4.automation_services.service_elements.parameter_elements.bin_serv_param import (
+    BinServParam,
+)
+from mtppy.part4.automation_services.service_elements.parameter_elements.common_serv_param import (
+    CommonServParameter as CSP,
+)
+
+
+def test_initialization_sets_state_labels():
+    parameter = BinServParam(
+        "PumpEnabled",
+        "Pump enabled state",
+        v_state_0="Disabled",
+        v_state_1="Enabled",
+    )
+
+    assert parameter.tag_name == "PumpEnabled"
+    assert parameter.tag_description == "Pump enabled state"
+    assert parameter.v_state_0 == "Disabled"
+    assert parameter.v_state_1 == "Enabled"
+    assert parameter.get_item(BinServParam.V_STATE_0).init_value == "Disabled"
+    assert parameter.get_item(BinServParam.V_STATE_1).init_value == "Enabled"
+
+
+def test_default_state_labels():
+    parameter = BinServParam("PumpEnabled")
+
+    assert parameter.get_item(BinServParam.V_STATE_0).init_value == "false"
+    assert parameter.get_item(BinServParam.V_STATE_1).init_value == "true"
+
+
+def test_set_v_op_updates_binary_value():
+    parameter = BinServParam("PumpEnabled")
+
+    parameter.set_v_op(True)
+
+    assert parameter[CSP.V_OP] is True

mtppy/part4/automation_services/service_elements/parameter_elements/common_serv_param.py

@@ -0,0 +1,111 @@
+"""Common Variables in service elements"""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+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
+
+
+class CommonServParameter:
+    V_OP = "VOp"
+    V_INT = "VInt"
+    V_EXT = "VExt"
+    V_REQ = "VReq"
+    V_OUT = "VOut"
+    V_FBK = "VFbk"
+    V_UNIT = "VUnit"
+    V_MIN = "VMin"
+    V_MAX = "VMax"
+    V_SCL_MIN = "VSclMin"
+    V_SCL_MAX = "VSclMax"
+    SYNC_ = "Sync"
+
+
+def SERVICE_PARAM_BASE_DATA_ITEMS(datatype: W3cXmlDataTypes):
+    return {
+        CommonServParameter.V_OP: DataItem(
+            CommonServParameter.V_OP,
+            datatype,
+            MTPAccess.ReadWriteAccess,
+            init_value=0,
+        ),
+        CommonServParameter.V_EXT: DataItem(
+            CommonServParameter.V_EXT,
+            datatype,
+            MTPAccess.ReadWriteAccess,
+            init_value=0,
+        ),
+        CommonServParameter.V_INT: DataItem(
+            CommonServParameter.V_INT,
+            datatype,
+            MTPAccess.ReadAccess,
+            init_value=0,
+        ),
+        CommonServParameter.V_REQ: DataItem(
+            CommonServParameter.V_REQ,
+            datatype,
+            MTPAccess.ReadAccess,
+            init_value=0,
+        ),
+        CommonServParameter.V_OUT: DataItem(
+            CommonServParameter.V_OUT,
+            datatype,
+            MTPAccess.ReadAccess,
+            init_value=0,
+        ),
+        CommonServParameter.V_FBK: DataItem(
+            CommonServParameter.V_FBK,
+            datatype,
+            MTPAccess.ReadAccess,
+            init_value=0,
+        ),
+    }
+
+
+def SERVICE_PARAM_NUMBER_DATA_ITEMS(datatype: W3cXmlDataTypes):
+    return {
+        CommonServParameter.V_UNIT: DataItem(
+            CommonServParameter.V_UNIT,
+            W3cXmlDataTypes.SHORT,
+            MTPAccess.ReadAccess,
+            init_value=0,
+        ),
+        CommonServParameter.V_MIN: DataItem(
+            CommonServParameter.V_MIN,
+            datatype,
+            MTPAccess.ReadAccess,
+            init_value=0,
+        ),
+        CommonServParameter.V_MAX: DataItem(
+            CommonServParameter.V_MAX,
+            datatype,
+            MTPAccess.ReadAccess,
+            init_value=0,
+        ),
+        CommonServParameter.V_SCL_MIN: DataItem(
+            CommonServParameter.V_SCL_MIN,
+            datatype,
+            MTPAccess.ReadAccess,
+            init_value=0,
+        ),
+        CommonServParameter.V_SCL_MAX: DataItem(
+            CommonServParameter.V_SCL_MAX,
+            datatype,
+            MTPAccess.ReadAccess,
+            init_value=9,
+        ),
+    }
+
+
+SERVICE_PARAM_SYNC_DATA_ITEMS = {
+    CommonServParameter.SYNC_: DataItem(
+        CommonServParameter.SYNC_,
+        W3cXmlDataTypes.BOOLEAN,
+        MTPAccess.ReadAccess,
+        init_value=False,
+    ),
+}

mtppy/part4/automation_services/service_elements/parameter_elements/dint_serv_param.py

@@ -0,0 +1,77 @@
+"""Implementation of the Integer Service Parameters."""
+
+__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.part5.definitions.w3c_xml_data_types import W3cXmlDataTypes
+from mtppy.part4.automation_services.service_elements.parameter_elements.parameter_element import (
+    ParameterElement,
+)
+from mtppy.part4.automation_services.service_elements.parameter_elements.common_serv_param import (
+    CommonServParameter,
+    SERVICE_PARAM_BASE_DATA_ITEMS,
+    SERVICE_PARAM_NUMBER_DATA_ITEMS,
+    SERVICE_PARAM_SYNC_DATA_ITEMS,
+)
+
+
+class DIntServParam(ParameterElement):
+    CLASS_DATA_ITEMS: ClassVar = (
+        SERVICE_PARAM_BASE_DATA_ITEMS(W3cXmlDataTypes.SHORT)
+        | SERVICE_PARAM_NUMBER_DATA_ITEMS(W3cXmlDataTypes.SHORT)
+        | SERVICE_PARAM_SYNC_DATA_ITEMS
+    )
+
+    v_min: int
+    v_max: int
+    v_scl_min: int
+    v_scl_max: int
+    v_unit: int
+
+    def __init__(
+        self,
+        tag_name: str,
+        tag_description: str = "",
+        v_op: int = 0,
+        v_min: int = 0,
+        v_max: int = 100,
+        v_scl_min: int = 0,
+        v_scl_max: int = 100,
+        v_unit: int = 0,
+    ):
+        """
+        Discrete Integer Service Parameter (DIntServParam).
+        """
+        super().__init__(tag_name, tag_description)
+        self.mtpObjectType = "MTPDataAssemblySUCLib/DataAssembly/ServiceElement/ParameterElement/DIntServParam"
+
+        self.v_min = v_min
+        self.v_max = v_max
+        self.v_scl_min = v_scl_min
+        self.v_scl_max = v_scl_max
+        self.v_unit = v_unit
+
+        self.get_item(CommonServParameter.V_OP).init_value = v_op
+        self.get_item(CommonServParameter.V_EXT).init_value = v_op
+        self.get_item(CommonServParameter.V_UNIT).init_value = self.v_unit
+        self.get_item(CommonServParameter.V_SCL_MIN).init_value = self.v_scl_min
+        self.get_item(CommonServParameter.V_SCL_MAX).init_value = self.v_scl_max
+        self.get_item(CommonServParameter.V_MIN).init_value = self.v_min
+        self.get_item(CommonServParameter.V_MAX).init_value = self.v_max
+
+        self.get_item(CommonServParameter.V_OP).ext_wrt_cb = self.set_v_op
+        self.get_item(CommonServParameter.V_EXT).ext_wrt_cb = self.set_v_ext
+
+    def is_valid_value(self, value):
+        if value < self.v_min or value > self.v_max:
+            logger.debug(
+                f"{self.tag_name} invalid value detected {value} (out of range)"
+            )
+            return False
+        else:
+            return True

mtppy/part4/automation_services/service_elements/parameter_elements/dint_serv_param_test.py

@@ -0,0 +1,58 @@
+"""Test suite for DIntServParam."""
+
+import pytest
+
+from mtppy.part4.automation_services.service_elements.parameter_elements.common_serv_param import (
+    CommonServParameter as CSP,
+)
+from mtppy.part4.automation_services.service_elements.parameter_elements.dint_serv_param import (
+    DIntServParam,
+)
+
+
+def test_initialization_sets_integer_metadata_and_values():
+    parameter = DIntServParam(
+        "BatchSize",
+        "Batch size",
+        v_op=5,
+        v_min=1,
+        v_max=20,
+        v_scl_min=0,
+        v_scl_max=20,
+        v_unit=1000,
+    )
+
+    assert parameter.tag_name == "BatchSize"
+    assert parameter.tag_description == "Batch size"
+    assert parameter.v_min == 1
+    assert parameter.v_max == 20
+    assert parameter.v_unit == 1000
+    assert parameter.get_item(CSP.V_OP).init_value == 5
+    assert parameter.get_item(CSP.V_EXT).init_value == 5
+    assert parameter.get_item(CSP.V_UNIT).init_value == 1000
+    assert parameter.get_item(CSP.V_MIN).init_value == 1
+    assert parameter.get_item(CSP.V_MAX).init_value == 20
+
+
+@pytest.mark.parametrize("value", [1, 10, 20])
+def test_valid_values_include_boundaries(value):
+    parameter = DIntServParam("BatchSize", v_min=1, v_max=20)
+
+    assert parameter.is_valid_value(value) is True
+
+
+@pytest.mark.parametrize("value", [0, 21])
+def test_values_outside_range_are_invalid(value):
+    parameter = DIntServParam("BatchSize", v_min=1, v_max=20)
+
+    assert parameter.is_valid_value(value) is False
+
+
+def test_set_v_op_accepts_valid_value_and_rejects_invalid_value():
+    parameter = DIntServParam("BatchSize", v_min=1, v_max=20)
+
+    parameter.set_v_op(12)
+    assert parameter[CSP.V_OP] == 12
+
+    parameter.set_v_op(21)
+    assert parameter[CSP.V_OP] == 12

mtppy/part4/automation_services/service_elements/parameter_elements/parameter_element.py

@@ -0,0 +1,175 @@
+"""Implementation of the ParameterElement."""
+
+__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.part3.data_assembly_set.data_assembly import DataAssembly
+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.automation_services.base_functions.service_operation_mode import (
+    ServiceOperationMode,
+)
+from mtppy.part4.automation_services.base_functions.service_source_mode import (
+    ServiceSourceMode,
+)
+from mtppy.part4.automation_services.service_elements.parameter_elements.common_serv_param import (
+    CommonServParameter as CSP,
+)
+
+
+class ParameterElement(DataAssembly):
+    APPLY_EN = "ApplyEn"
+    APPLY_EXT = "ApplyExt"
+    APPLY_OP = "ApplyOp"
+    APPLY_INT = "ApplyInt"
+    SYNC_ = "Sync"
+
+    CLASS_DATA_ITEMS: ClassVar = {
+        APPLY_EN: DataItem(
+            APPLY_EN,
+            W3cXmlDataTypes.BOOLEAN,
+            MTPAccess.ReadAccess,
+            init_value=True,
+        ),
+        APPLY_EXT: DataItem(
+            APPLY_EXT,
+            W3cXmlDataTypes.BOOLEAN,
+            MTPAccess.ReadWriteAccess,
+            init_value=False,
+        ),
+        APPLY_OP: DataItem(
+            APPLY_OP,
+            W3cXmlDataTypes.BOOLEAN,
+            MTPAccess.ReadWriteAccess,
+            init_value=False,
+        ),
+        APPLY_INT: DataItem(
+            APPLY_INT,
+            W3cXmlDataTypes.BOOLEAN,
+            MTPAccess.ReadAccess,
+            init_value=False,
+        ),
+        SYNC_: DataItem(
+            SYNC_,
+            W3cXmlDataTypes.BOOLEAN,
+            MTPAccess.ReadWriteAccess,
+            init_value=False,
+        ),
+    }
+
+    os_level: OSLevelBaseFunction
+    service_op_mode: ServiceOperationMode
+    service_src_mode: ServiceSourceMode
+
+    def __init__(self, tag_name: str, tag_description: str):
+        super().__init__(tag_name, tag_description)
+        self.mtpObjectType = (
+            "MTPDataAssemblySUCLib/DataAssembly/ServiceElement/ParameterElement"
+        )
+
+        self.os_level = OSLevelBaseFunction()
+        self.service_op_mode = ServiceOperationMode()
+        self.service_src_mode = ServiceSourceMode()
+
+        self.get_item(ParameterElement.APPLY_EN).ext_wrt_cb = self.apply_ext
+        self.get_item(ParameterElement.APPLY_OP).ext_wrt_cb = self.apply_op
+        self.get_item(ParameterElement.SYNC_).ext_wrt_cb = self.set_sync
+
+        self.get_item(ParameterElement.APPLY_INT).int_wrt_cb = self.apply_int
+        self.get_item(ParameterElement.APPLY_EXT).int_wrt_cb = self.apply_ext
+
+    def set_apply_en(self, value: bool):
+        self[ParameterElement.APPLY_EN] = value
+
+    def set_sync(self, value: bool):
+        self[ParameterElement.SYNC_] = value
+
+    def apply_op(self, value: bool):
+        if value and self.service_op_mode[ServiceOperationMode.STATE_OP_ACT]:
+            self.update_v_out()
+        self[ParameterElement.APPLY_OP] = False
+
+    def apply_ext(self, value: bool):
+        if (
+            value
+            and self.service_op_mode[ServiceOperationMode.STATE_AUT_ACT]
+            # TBD: check SRC_EXT_ACT, was SrcExt
+            and self.service_src_mode[ServiceSourceMode.SRC_EXT_ACT]
+        ):
+            self.update_v_out()
+        self[ParameterElement.APPLY_EXT] = False
+
+    def apply_int(self, value: bool):
+        if (
+            value
+            and self.service_op_mode[ServiceOperationMode.STATE_AUT_ACT]
+            # TBD: check SRC_INT_ACT, was SrcInt
+            and self.service_src_mode[ServiceSourceMode.SRC_INT_ACT]
+        ):
+            self.update_v_out()
+        self[ParameterElement.APPLY_INT] = False
+
+    def update_v_req(self):
+        if self.service_op_mode[ServiceOperationMode.STATE_OP_ACT]:
+            self[CSP.V_REQ] = self[CSP.V_OP]
+            logger.info(f"VReq set to VOp={self[CSP.V_OP]}")
+        elif (
+            self.service_op_mode[ServiceOperationMode.STATE_AUT_ACT]
+            # TBD: check SRC_INT_ACT, was SrcInt
+            and self.service_src_mode[ServiceSourceMode.SRC_INT_ACT]
+        ):
+            self[CSP.V_REQ] = self[CSP.V_INT]
+            logger.info(f"VReq set to VInt={self[CSP.V_INT]}")
+        elif (
+            self.service_op_mode[ServiceOperationMode.STATE_AUT_ACT]
+            # TBD: check SRC_EXT_ACT, was SrcExt
+            and self.service_src_mode[ServiceSourceMode.SRC_EXT_ACT]
+        ):
+            self[CSP.V_REQ] = self[CSP.V_EXT]
+            logger.info(f"VReq set to VExt={self[CSP.V_EXT]}")
+
+        # TBD: was self[CSP.V_REQ] = self[CSP.V_EXT ?
+        self[CSP.V_FBK] = self[CSP.V_REQ]
+
+    def set_v_fbk(self, value) -> None:
+        self[CSP.V_FBK] = value
+        logger.info(f"VFbk set to {value}")
+
+    def update_v_out(self) -> None:
+        self.update_v_req()
+        value = self[CSP.V_REQ]
+        self[CSP.V_OUT] = value
+        logger.mtp(f"VOut set to {value}")
+
+    def get_v_out(self) -> None:
+        return self[CSP.V_OUT]
+
+    def set_v_op(self, value) -> None:
+        if self.is_valid_value(value):
+            self[CSP.V_OP] = value
+            logger.mtp(f"VOp set to {self[CSP.V_OP]}")
+            self.update_v_req()
+
+    def set_v_int(self, value) -> None:
+        logger.debug(f"set_v_int: args={value}")
+        if self.is_valid_value(value):
+            self[CSP.V_INT] = value
+            logger.info(f"VInt set to {self[CSP.V_INT]}")
+            self.update_v_req()
+
+    def set_v_ext(self, value) -> None:
+        if self.is_valid_value(value):
+            self[CSP.V_EXT] = value
+            logger.info(f"VExt set to {self[CSP.V_EXT]}")
+            self.update_v_req()
+
+    def is_valid_value(self, value) -> bool:
+        logger.warning(f"is_valid_value of ParameterElement called!")
+        return True