MTPPy2.0 0.1.5__py3-none-any.whl

mtppy/part3/data_assembly_set/active_elements/pid/pid_ctrl.py

@@ -0,0 +1,333 @@
+"""Implementation of PidCtrl and PID Algorithm."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+from mtppy.utils.logging import logger
+import threading
+from typing import ClassVar
+
+from simple_pid import PID
+
+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.active_elements.active_element import ActiveElement
+from mtppy.part3.data_assembly_set.base_functions.operation_mode import OperationMode
+from mtppy.part3.data_assembly_set.base_functions.source_mode import SourceMode
+
+
+class PIDController:
+    def __init__(
+        self,
+        mv_init_value: float = 0,
+        kp: float = 100,
+        ki: float = 10,
+        kd: float = 1,
+        mv_min: float = 0,
+        mv_max: float = 100,
+        sample_time: float = 0.1,
+    ) -> None:
+        self.kp = kp
+        self.ki = ki
+        self.kd = kd
+        self.mv_min = mv_min
+        self.mv_max = mv_max
+        self.sp = 0
+        self.pv = 0
+        self.mv = mv_init_value
+        self.sample_time = sample_time
+
+        self.ctrl = PID(
+            Kp=self.kp,
+            Ki=self.ki,
+            Kd=self.kd,
+            output_limits=(mv_min, mv_max),
+            sample_time=sample_time,
+        )
+
+        self._stop_event = threading.Event()
+        self._thread = None
+
+    def set_limits(self, mv_min, mv_max):
+        self.ctrl.output_limits = (mv_min, mv_max)
+
+    def start(self):
+        logger.debug("Starting PID controller...")
+        self._stop_event.clear()
+        self._thread = threading.Thread(target=self.loop, daemon=True)
+        self.ctrl.setpoint = self.sp
+        self._thread.start()
+        logger.debug("Started")
+
+    def stop(self):
+        logger.debug("Stopping PID controller...")
+        self._stop_event.set()
+        if self._thread is not None:
+            self._thread.join(3.0)
+            if self._thread.is_alive():
+                logger.error("PID loop failed to stop within 3 secs")
+        self.ctrl.reset()
+        logger.debug("Stopped")
+
+    def set_sp(self, sp):
+        self.sp = sp
+        self.ctrl.setpoint = sp
+
+    def set_pv(self, pv):
+        self.pv = pv
+
+    def loop(self):
+        while not self._stop_event.wait(self.sample_time):
+            self.mv = self.ctrl(self.pv)
+
+    def get_mv(self):
+        return self.mv
+
+    def set_kp(self, kp):
+        self.ctrl.Kp = kp
+
+    def set_ki(self, ki):
+        self.ctrl.Ki = ki
+
+    def set_kd(self, kd):
+        self.ctrl.Kd = kd
+
+
+class PIDCtrl(ActiveElement):
+    # DataItem constant definitions
+    PV_: str = "PV"
+    PV_SCL_MIN: str = "PVSclMin"
+    PV_SCL_MAX: str = "PVSclMax"
+    PV_UNIT: str = "PVUnit"
+    SP_MAN = "SPMan"
+    SP_INT = "SPInt"
+    SP_SCL_MIN = "SPSclMin"
+    SP_SCL_MAX = "SPSclMax"
+    SP_UNIT = "SPUnit"
+    SP_INT_MIN = "SPIntMin"
+    SP_INT_MAX = "SPIntMax"
+    SP_MAN_MIN = "SPManMin"
+    SP_MAN_MAX = "SPManMax"
+    SP_ = "SP"
+    MV_MAN = "MVMan"
+    MV_ = "MV"
+    MV_MIN = "MVMin"
+    MV_MAX = "MVMax"
+    MV_UNIT = "MVUnit"
+    MV_SCL_MIN = "MVSclMin"
+    MV_SCL_MAX = "MVSclMax"
+    P_: str = "P"
+    TI_: str = "Ti"
+    TD_: str = "Td"
+
+    # Class-level data items dictionary
+    CLASS_DATA_ITEMS: ClassVar = {
+        PV_: DataItem(PV_, W3cXmlDataTypes.FLOAT, MTPAccess.ReadAccess, 0),
+        PV_SCL_MIN: DataItem(
+            PV_SCL_MIN, W3cXmlDataTypes.FLOAT, MTPAccess.ReadAccess, 0
+        ),
+        PV_SCL_MAX: DataItem(
+            PV_SCL_MAX, W3cXmlDataTypes.FLOAT, MTPAccess.ReadAccess, 0
+        ),
+        PV_UNIT: DataItem(PV_UNIT, W3cXmlDataTypes.SHORT, MTPAccess.ReadAccess, 0),
+        SP_MAN: DataItem(SP_MAN, W3cXmlDataTypes.FLOAT, MTPAccess.ReadWriteAccess, 0),
+        SP_INT: DataItem(SP_INT, W3cXmlDataTypes.FLOAT, MTPAccess.ReadAccess, 0),
+        SP_SCL_MIN: DataItem(
+            SP_SCL_MIN, W3cXmlDataTypes.FLOAT, MTPAccess.ReadAccess, 0
+        ),
+        SP_SCL_MAX: DataItem(
+            SP_SCL_MAX, W3cXmlDataTypes.FLOAT, MTPAccess.ReadAccess, 0
+        ),
+        SP_UNIT: DataItem(SP_UNIT, W3cXmlDataTypes.SHORT, MTPAccess.ReadAccess, 0),
+        SP_INT_MIN: DataItem(
+            SP_INT_MIN, W3cXmlDataTypes.FLOAT, MTPAccess.ReadAccess, 0
+        ),
+        SP_INT_MAX: DataItem(
+            SP_INT_MAX, W3cXmlDataTypes.FLOAT, MTPAccess.ReadAccess, 0
+        ),
+        SP_MAN_MIN: DataItem(
+            SP_MAN_MIN, W3cXmlDataTypes.FLOAT, MTPAccess.ReadAccess, 0
+        ),
+        SP_MAN_MAX: DataItem(
+            SP_MAN_MAX, W3cXmlDataTypes.FLOAT, MTPAccess.ReadAccess, 0
+        ),
+        SP_: DataItem(SP_, W3cXmlDataTypes.FLOAT, MTPAccess.ReadAccess, 0),
+        MV_MAN: DataItem(MV_MAN, W3cXmlDataTypes.FLOAT, MTPAccess.ReadWriteAccess, 0),
+        MV_: DataItem(MV_, W3cXmlDataTypes.FLOAT, MTPAccess.ReadAccess, 0),
+        MV_MIN: DataItem(MV_MIN, W3cXmlDataTypes.FLOAT, MTPAccess.ReadAccess, 0),
+        MV_MAX: DataItem(MV_MAX, W3cXmlDataTypes.FLOAT, MTPAccess.ReadAccess, 0),
+        MV_UNIT: DataItem(MV_UNIT, W3cXmlDataTypes.FLOAT, MTPAccess.ReadAccess, 0),
+        MV_SCL_MIN: DataItem(
+            MV_SCL_MIN, W3cXmlDataTypes.FLOAT, MTPAccess.ReadAccess, 0
+        ),
+        MV_SCL_MAX: DataItem(
+            MV_SCL_MAX, W3cXmlDataTypes.FLOAT, MTPAccess.ReadAccess, 0
+        ),
+        P_: DataItem(P_, W3cXmlDataTypes.FLOAT, MTPAccess.ReadWriteAccess, 0),
+        TI_: DataItem(TI_, W3cXmlDataTypes.FLOAT, MTPAccess.ReadWriteAccess, 0),
+        TD_: DataItem(TD_, W3cXmlDataTypes.FLOAT, MTPAccess.ReadWriteAccess, 0),
+    }
+
+    op_mode: OperationMode
+    src_mode: SourceMode
+    ctrl: PIDController
+    _mv_update_thread: threading.Thread
+    _stop_event: threading.Event
+
+    def __init__(
+        self,
+        tag_name: str,
+        tag_description: str = "",
+        pv_scl_min: float = 0,
+        pv_scl_max: float = 100,
+        pv_unit: float = 0,
+        sp_scl_min: float = 0,
+        sp_scl_max: float = 100,
+        sp_unit: float = 0,
+        sp_int_min: float = 0,
+        sp_int_max: float = 100,
+        sp_man_min: float = 0,
+        sp_man_max: float = 100,
+        mv_min: float = 0,
+        mv_max: float = 1000,
+        mv_unit: float = 0,
+        mv_scl_min: float = 0,
+        mv_scl_max: float = 100,
+        prop: float = 100,
+        ti: float = 10,
+        td: float = 1,
+    ):
+        super().__init__(tag_name, tag_description)
+        self.mtpObjectType = "MTPDataObjectSUCLib/DataAssembly/ActiveElement/PIDCtrl"
+
+        self.op_mode = OperationMode()
+        self.src_mode = SourceMode()
+
+        self.ctrl = PIDController(
+            mv_init_value=mv_min,
+            mv_min=mv_min,
+            mv_max=mv_max,
+            kp=prop,
+            ki=ti,
+            kd=td,
+            sample_time=0.1,
+        )
+
+        # Initialize data items with dynamic values (using class-defined data items)
+        self[PIDCtrl.PV_] = 0
+        self[PIDCtrl.PV_SCL_MIN] = pv_scl_min
+        self[PIDCtrl.PV_SCL_MAX] = pv_scl_max
+        self[PIDCtrl.PV_UNIT] = pv_unit
+        self[PIDCtrl.SP_MAN] = sp_man_min
+        self[PIDCtrl.SP_INT] = sp_int_min
+        self[PIDCtrl.SP_SCL_MIN] = sp_scl_min
+        self[PIDCtrl.SP_SCL_MAX] = sp_scl_max
+        self[PIDCtrl.SP_UNIT] = sp_unit
+        self[PIDCtrl.SP_INT_MIN] = sp_int_min
+        self[PIDCtrl.SP_INT_MAX] = sp_int_max
+        self[PIDCtrl.SP_MAN_MIN] = sp_man_min
+        self[PIDCtrl.SP_MAN_MAX] = sp_man_max
+        self[PIDCtrl.SP_] = sp_int_min
+        self[PIDCtrl.MV_MAN] = mv_min
+        self[PIDCtrl.MV_] = mv_min
+        self[PIDCtrl.MV_MIN] = mv_min
+        self[PIDCtrl.MV_MAX] = mv_max
+        self[PIDCtrl.MV_UNIT] = mv_unit
+        self[PIDCtrl.MV_SCL_MIN] = mv_scl_min
+        self[PIDCtrl.MV_SCL_MAX] = mv_scl_max
+        self[PIDCtrl.P_] = prop
+        self[PIDCtrl.TI_] = ti
+        self[PIDCtrl.TD_] = td
+
+        # Set callbacks for writable items
+        self.get_item(PIDCtrl.SP_MAN).ext_wrt_cb = self.set_sp_man
+        self.get_item(PIDCtrl.MV_MAN).ext_wrt_cb = self.set_mv_man
+        self.get_item(PIDCtrl.P_).ext_wrt_cb = self.set_p
+        self.get_item(PIDCtrl.TI_).ext_wrt_cb = self.set_ti
+        self.get_item(PIDCtrl.TD_).ext_wrt_cb = self.set_td
+
+        self.op_mode.add_enter_automatic_callback(self._start_aut_mv_update_loop)
+        self.op_mode.add_exit_automatic_callback(self._stop_aut_mv_update_loop)
+
+        self._mv_update_thread = None
+        self._stop_event = threading.Event()
+
+    def set_p(self, value):
+        self[PIDCtrl.P_] = value
+        self.ctrl.set_kp(value)
+
+    def set_ti(self, value):
+        self[PIDCtrl.TI_] = value
+        self.ctrl.set_ki(value)
+
+    def set_td(self, value):
+        self[PIDCtrl.TD_] = value
+        self.ctrl.set_kd(value)
+
+    @staticmethod
+    def _valid_value(value, v_min, v_max):
+        return v_min <= value <= v_max
+
+    def _set_sp(self, value, v_min, v_max):
+        if self._valid_value(value, v_min, v_max):
+            self[PIDCtrl.SP_] = value
+            self.ctrl.set_sp(value)
+            logger.debug(f"SP set to {value}")
+        else:
+            logger.debug(f"SP cannot be set to {value} (out of range)")
+
+    def set_sp_man(self, value):
+        logger.debug(f"SPMan set to {value}")
+        if self.src_mode["SrcManAct"] and self.op_mode["StateAutAct"]:
+            self._set_sp(value, self[PIDCtrl.SP_MAN_MIN], self[PIDCtrl.SP_MAN_MAX])
+
+    def set_sp_int(self, value):
+        logger.debug(f"SPInt set to {value}")
+        if self.src_mode["SrcIntAct"] and self.op_mode["StateAutAct"]:
+            self._set_sp(value, self[PIDCtrl.SP_INT_MIN], self[PIDCtrl.SP_INT_MAX])
+
+    def set_mv_man(self, value):
+        logger.debug(f"MVMan set to {value}")
+        if self.op_mode["StateOpAct"]:
+            self._set_mv(value, self[PIDCtrl.MV_MIN], self[PIDCtrl.MV_MAX])
+
+    def _set_mv(self, value, v_min, v_max):
+        if self._valid_value(value, v_min, v_max):
+            self[PIDCtrl.MV_] = value
+            logger.debug(f"MV set to {value}")
+        else:
+            logger.debug(f"MV cannot be set to {value} (out of range)")
+
+    def _update_mv_int_loop(self):
+        while not self._stop_event.wait(0.1):
+            if self.op_mode["StateAutAct"]:
+                value = self.ctrl.get_mv()
+                self._set_mv(value, self[PIDCtrl.MV_MIN], self[PIDCtrl.MV_MAX])
+
+    def _start_aut_mv_update_loop(self):
+        self.ctrl.start()
+        self._mv_update_thread = threading.Thread(
+            target=self._update_mv_int_loop, daemon=True
+        )
+        self._mv_update_thread.start()
+
+    def _stop_aut_mv_update_loop(self):
+        self.ctrl.stop()
+        self._stop_event.set()
+        if self._mv_update_thread is not None:
+            self._mv_update_thread.join(timeout=3.0)
+            if self._mv_update_thread.is_alive():
+                logger.error("PID update_mv loop failed to stop within 3 sec")
+
+    def set_pv(self, value):
+        self[PIDCtrl.PV_] = value
+        self.ctrl.set_pv(value)
+
+    def get_mv(self):
+        return self[PIDCtrl.MV_]
+
+    def get_sp(self):
+        return self[PIDCtrl.SP_]

mtppy/part3/data_assembly_set/active_elements/pid/pid_ctrl_test.py

@@ -0,0 +1,156 @@
+"""Test Suite for PIDCtrl."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+from time import sleep
+
+import pytest
+from mtppy.utils.testing import data_object_set_modes
+from mtppy.part3.data_assembly_set.active_elements.pid.pid_ctrl import PIDCtrl
+
+
+def init_pid_ctrl(init_op_mode: str = "off", init_src_mode: str = "int") -> PIDCtrl:
+    instance = PIDCtrl(
+        "tag",
+        tag_description="",
+        pv_scl_min=0,
+        pv_scl_max=100,
+        pv_unit=0,
+        sp_scl_min=0,
+        sp_scl_max=100,
+        sp_unit=0,
+        sp_int_min=-10,
+        sp_int_max=1000,
+        sp_man_min=-10,
+        sp_man_max=1000,
+        mv_min=-10,
+        mv_max=1000,
+        mv_unit=0,
+        mv_scl_min=0,
+        mv_scl_max=100,
+        #        p=1,
+        ti=10,
+        td=1,
+    )
+    data_object_set_modes(instance, init_op_mode, init_src_mode)
+    return instance
+
+
+test_scenario_sp = [
+    ("off", "int", "set_sp_man", False),
+    ("off", "man", "set_sp_man", False),
+    ("op", "int", "set_sp_man", False),
+    ("op", "man", "set_sp_man", False),
+    ("aut", "int", "set_sp_man", False),
+    ("aut", "man", "set_sp_man", True),
+    ("off", "int", "set_sp_int", False),
+    ("off", "man", "set_sp_int", False),
+    ("op", "int", "set_sp_int", False),
+    ("op", "man", "set_sp_int", False),
+    ("aut", "int", "set_sp_int", True),
+    ("aut", "man", "set_sp_int", False),
+]
+
+
+@pytest.mark.parametrize(
+    "op_mode, src_mode, set_command, changes_expected", test_scenario_sp
+)
+def test_set_sp(op_mode, src_mode, set_command, changes_expected):
+    for command in [-500, -10, 500, 1000, 10000]:
+        try:
+            pid_ctrl = init_pid_ctrl(init_op_mode=op_mode, init_src_mode=src_mode)
+            eval(f"pid_ctrl.{set_command}({command})")
+            print(
+                f"\nScenario: mode {op_mode} {src_mode}, {set_command}, changes expected: {changes_expected}"
+            )
+            if changes_expected:
+                if -10 <= command <= 1000:
+                    assert pid_ctrl.get_sp() == command
+                else:
+                    assert pid_ctrl.get_sp() == -10
+            else:
+                assert pid_ctrl.get_sp() == -10
+        finally:
+            pid_ctrl.op_mode._opmode_to_off()
+
+
+test_scenario_mv = [
+    ("off", "int", "set_mv_man", False),
+    ("off", "man", "set_mv_man", False),
+    ("op", "int", "set_mv_man", True),
+    ("op", "man", "set_mv_man", True),
+]
+
+
+@pytest.mark.parametrize(
+    "op_mode, src_mode, set_command, changes_expected", test_scenario_mv
+)
+def test_set_mv_man(op_mode, src_mode, set_command, changes_expected):
+    for command in [-500, -10, 500, 1000, 10000]:
+        try:
+            pid_ctrl = init_pid_ctrl(init_op_mode=op_mode, init_src_mode=src_mode)
+            eval(f"pid_ctrl.{set_command}({command})")
+            print(
+                f"Scenario: mode {op_mode} {src_mode}, {set_command}, changes expected: {changes_expected}"
+            )
+            if changes_expected:
+                if -10 <= command <= 1000:
+                    assert pid_ctrl.get_mv() == command
+                else:
+                    assert pid_ctrl.get_mv() == -10
+            else:
+                assert pid_ctrl.get_mv() == -10
+        finally:
+            pid_ctrl.op_mode._opmode_to_off()
+
+
+# Assumption - after initialization sp_int = sp_int_min = -10
+scenario_pid_cmds = [
+    # block 1: internal setpoint - ignored when outside bounds
+    ("aut", "int", "set_sp_int", -100, 0, "get_sp", -10),
+    ("aut", "int", "set_sp_int", -10, 0, "get_sp", -10),
+    ("aut", "int", "set_sp_int", 100, 0, "get_sp", 100),
+    ("aut", "int", "set_sp_int", 1000, 0, "get_sp", 1000),
+    ("aut", "int", "set_sp_int", 2000, 0, "get_sp", -10),
+    # block 2: internal setpoint - push to limits when inside bounds
+    ("aut", "int", "set_sp_int", -100, 1, "get_mv", 0),
+    ("aut", "int", "set_sp_int", -10, 1, "get_mv", -10),
+    ("aut", "int", "set_sp_int", 100, 1, "get_mv", 1000),
+    ("aut", "int", "set_sp_int", 1000, 1, "get_mv", 1000),
+    ("aut", "int", "set_sp_int", 2000, 1, "get_mv", 0),
+    # block 3: manual setpoint - set validation
+    ("aut", "man", "set_sp_man", -100, 0, "get_sp", -10),
+    ("aut", "man", "set_sp_man", -10, 0, "get_sp", -10),
+    ("aut", "man", "set_sp_man", 100, 0, "get_sp", 100),
+    ("aut", "man", "set_sp_man", 1000, 0, "get_sp", 1000),
+    ("aut", "man", "set_sp_man", 2000, 0, "get_sp", -10),
+    # block 4: manual setpoint - push to limits when inside bounds
+    ("aut", "man", "set_sp_man", -100, 1, "get_mv", 0),
+    ("aut", "man", "set_sp_man", -10, 1, "get_mv", -10),
+    ("aut", "man", "set_sp_man", 100, 1, "get_mv", 1000),
+    ("aut", "man", "set_sp_man", 1000, 1, "get_mv", 1000),
+    ("aut", "man", "set_sp_man", 2000, 1, "get_mv", 0),
+]
+
+
+@pytest.mark.parametrize(
+    "op_mode, src_mode, set_cmd, value, delay, get_cmd, expected", scenario_pid_cmds
+)
+def test_pid_cmds(op_mode, src_mode, set_cmd, value, delay, get_cmd, expected):
+    try:
+        pid_ctrl = init_pid_ctrl(init_op_mode=op_mode, init_src_mode=src_mode)
+        eval(f"pid_ctrl.{set_cmd}({value})")
+        sleep(delay)
+        assert pid_ctrl[PIDCtrl.SP_INT_MIN] == -10
+        assert pid_ctrl[PIDCtrl.SP_INT_MAX] == 1000
+        retval = eval(f"pid_ctrl.{get_cmd}()")
+        assert retval == expected
+    finally:
+        pid_ctrl.op_mode._opmode_to_off()
+
+
+if __name__ == "__main__":
+    # This allows running the tests directly if needed
+    pytest.main([__file__, "-v"])

mtppy/part3/data_assembly_set/active_elements/valves/__init__.py

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