MTPPy2.0 0.1.5__py3-none-any.whl

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

@@ -0,0 +1,286 @@
+"""Implementation of MonBinVlv."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+from typing import ClassVar, SupportsFloat, SupportsIndex
+
+from mtppy.utils.logging import logger
+import threading
+from time import sleep
+
+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.valves.bin_vlv import BinVlv
+
+
+class MonBinVlvValues:
+    def __init__(self, open_aut, open_op, close_aut, close_op, reset_aut, reset_op):
+        self.open_aut = open_aut
+        self.open_op = open_op
+        self.close_aut = close_aut
+        self.close_op = close_op
+        self.reset_aut = reset_aut
+        self.reset_op = reset_op
+        self.lock = threading.Lock()
+        self.stop_event_lock = threading.Event()
+
+
+class MonBinVlv(BinVlv):
+    # DataItem constant definitions
+    MON_EN = "MonEn"
+    MON_SAFE_POS = "MonSafePos"
+    MON_STAT_ERR = "MonStatErr"
+    MON_DYN_ERR = "MonDynErr"
+    MON_STAT_TI = "MonStatTi"
+    MON_DYN_TI = "MonDynTi"
+
+    # Class-level data items dictionary
+    CLASS_DATA_ITEMS: ClassVar = {
+        MON_EN: DataItem(MON_EN, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, None),
+        MON_SAFE_POS: DataItem(
+            MON_SAFE_POS, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, None
+        ),
+        MON_STAT_ERR: DataItem(
+            MON_STAT_ERR, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, None
+        ),
+        MON_DYN_ERR: DataItem(
+            MON_DYN_ERR, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, None
+        ),
+        MON_STAT_TI: DataItem(
+            MON_STAT_TI, W3cXmlDataTypes.FLOAT, MTPAccess.ReadAccess, None
+        ),
+        MON_DYN_TI: DataItem(
+            MON_DYN_TI, W3cXmlDataTypes.FLOAT, MTPAccess.ReadAccess, None
+        ),
+    }
+
+    monitored_values: MonBinVlvValues
+    monitor_static_thread = threading.Thread
+    monitor_dynamic_thread = threading.Thread
+
+    def __init__(
+        self,
+        tag_name,
+        tag_description="",
+        open_fbk_calc=True,
+        close_fbk_calc=True,
+        safe_pos=0,
+        safe_pos_en=False,
+        perm_en=False,
+        intl_en=False,
+        prot_en=False,
+        mon_en=True,
+        mon_safe_pos=True,
+        mon_stat_ti=1,
+        mon_dyn_ti=1,
+    ):
+        super().__init__(
+            tag_name,
+            tag_description,
+            open_fbk_calc,
+            close_fbk_calc,
+            safe_pos,
+            safe_pos_en,
+            perm_en,
+            intl_en,
+            prot_en,
+        )
+        self.mtpObjectType = (
+            "MTPDataObjectSUCLib/DataAssembly/ActiveElement/BinVlv/MonBinVlv"
+        )
+
+        # Initialize data items with dynamic values (using class-defined data items)
+        self[MonBinVlv.MON_EN] = mon_en
+        self[MonBinVlv.MON_SAFE_POS] = mon_safe_pos
+        self[MonBinVlv.MON_STAT_ERR] = False
+        self[MonBinVlv.MON_DYN_ERR] = False
+        self[MonBinVlv.MON_STAT_TI] = mon_stat_ti
+        self[MonBinVlv.MON_DYN_TI] = mon_dyn_ti
+
+        self.monitored_values = MonBinVlvValues(
+            self[BinVlv.OPEN_AUT],
+            self[BinVlv.OPEN_OP],
+            self[BinVlv.CLOSE_AUT],
+            self[BinVlv.CLOSE_OP],
+            self[BinVlv.RESET_AUT],
+            self[BinVlv.RESET_OP],
+        )
+        self.monitor_static_thread = None
+        self.monitor_dynamic_thread = None
+
+    def compare_states_control_signals(
+        self,
+        monitor_time: SupportsFloat | SupportsIndex,
+    ) -> tuple[list[bool], list[bool]]:
+        """
+        compare states of valve and control signals
+
+        Arguments:
+            monitor_time: MonStatTi or MonDynTi times
+
+        Returns:
+            results of states and control signals comparisons (a list including True or False)
+        """
+        self.monitored_values.lock.acquire()
+        open_fbk1 = self[BinVlv.OPEN_FBK]
+        close_fbk1 = self[BinVlv.CLOSE_FBK]
+        open_op1 = self.monitored_values.open_op
+        open_aut1 = self.monitored_values.open_aut
+        close_op1 = self.monitored_values.close_op
+        close_aut1 = self.monitored_values.close_aut
+        reset_op1 = self.monitored_values.reset_op
+        reset_aut1 = self.monitored_values.reset_aut
+        self.monitored_values.lock.release()
+
+        sleep(monitor_time)
+
+        self.monitored_values.lock.acquire()
+        open_fbk2 = self[BinVlv.OPEN_FBK]
+        close_fbk2 = self[BinVlv.CLOSE_FBK]
+        open_op2 = self.monitored_values.open_op
+        open_aut2 = self.monitored_values.open_aut
+        close_op2 = self.monitored_values.close_op
+        close_aut2 = self.monitored_values.close_aut
+        reset_op2 = self.monitored_values.reset_op
+        reset_aut2 = self.monitored_values.reset_aut
+        self.monitored_values.lock.release()
+
+        control_signals_comparison = [
+            open_op1 == open_op2,
+            open_aut1 == open_aut2,
+            close_op1 == close_op2,
+            close_aut1 == close_aut2,
+            reset_op1 == reset_op2,
+            reset_aut1 == reset_aut2,
+        ]
+        state_comparison = [open_fbk1 == open_fbk2, close_fbk1 == close_fbk2]
+        return state_comparison, control_signals_comparison
+
+    def monitor_static_error(self):
+        """
+        monitor static error
+        """
+        while True:
+            if self.monitored_values.stop_event_lock.is_set():
+                logger.debug("static monitoring stopped")
+                break
+            states, control_signals = self.compare_states_control_signals(
+                self[MonBinVlv.MON_STAT_TI]
+            )
+
+            if not all(states):  # if the states of valve changed
+                if all(control_signals):  # but the control signals did not change
+                    self[MonBinVlv.MON_STAT_ERR] = True
+                    logger.debug("Static error set to True")
+                    self._handle_monitored_error()
+
+    def monitor_dynamic_error(self):
+        """
+        monitor dynamic error
+        """
+        while True:
+            if self.monitored_values.stop_event_lock.is_set():
+                logger.debug("dynamic monitoring stopped")
+                break
+            states, control_signals = self.compare_states_control_signals(
+                self[MonBinVlv.MON_DYN_TI]
+            )
+
+            if all(states):  # if the states of valve did not change
+                if not all(control_signals):  # but a control command is executed
+                    self[MonBinVlv.MON_DYN_ERR] = True
+                    logger.debug("Dynamic error set to True")
+                    self._handle_monitored_error()
+
+    def _handle_monitored_error(self):
+        if self[MonBinVlv.MON_SAFE_POS]:
+            logger.debug("set valve to safety position")
+            if self[BinVlv.SAFE_POS_EN]:
+                self._go_safe_pos()
+            else:
+                logger.debug("Device has no safe position")
+            self[BinVlv.SAFE_POS_ACT] = True
+
+    def start_monitor(self):
+        """
+        start static and dynamic error monitoring thread
+        """
+        if self["MonEn"]:
+            self.monitor_static_thread = threading.Thread(
+                target=self.monitor_static_error, daemon=True
+            )
+            self.monitor_static_thread.start()
+            logger.debug("static monitoring start")
+            self.monitor_dynamic_thread = threading.Thread(
+                target=self.monitor_dynamic_error, daemon=True
+            )
+            self.monitor_dynamic_thread.start()
+            logger.debug("dynamic monitoring start")
+
+    def set_open_aut(self, value: bool):
+        logger.debug(f"OpenAut set to {value}")
+        if self.op_mode["StateAutAct"]:
+            if value and self._run_allowed():
+                if self["MonEn"]:
+                    self.monitored_values.lock.acquire()
+                    self.monitored_values.open_aut = value
+                    self.monitored_values.lock.release()
+                self._run_open_vlv()
+
+    def set_close_aut(self, value: bool):
+        if self.op_mode["StateAutAct"]:
+            if value and self._run_allowed():
+                if self["MonEn"]:
+                    self.monitored_values.lock.acquire()
+                    self.monitored_values.close_aut = value
+                    self.monitored_values.lock.release()
+                logger.debug(f"CloseAut set to {value}")
+                self._run_close_vlv()
+
+    def set_reset_aut(self, value: bool):
+        logger.debug(f"ResetAut set to {value}")
+        if self.op_mode["StateAutAct"] and value:
+            if self["MonEn"]:
+                self.monitored_values.lock.acquire()
+                self.monitored_values.reset_aut = value
+                self.monitored_values.lock.release()
+            self._reset_vlv()
+
+    def set_open_op(self, value: bool):
+        logger.debug(f"OpenOp set to {value}")
+        if self.op_mode["StateOpAct"]:
+            if value and self._run_allowed():
+                if self["MonEn"]:
+                    self.monitored_values.lock.acquire()
+                    self.monitored_values.open_op = value
+                    self.monitored_values.lock.release()
+                self._run_open_vlv()
+                self["OpenOp"] = False
+
+    def set_close_op(self, value: bool):
+        logger.debug(f"CloseOp set to {value}")
+        if self.op_mode["StateOpAct"]:
+            if value and self._run_allowed():
+                if self["MonEn"]:
+                    self.monitored_values.lock.acquire()
+                    self.monitored_values.close_op = value
+                    self.monitored_values.lock.release()
+                self._run_close_vlv()
+                self["CloseOp"] = False
+
+    def set_reset_op(self, value: bool):
+        logger.debug(f"ResetOp set to {value}")
+        if self.op_mode["StateOpAct"] and value:
+            if self["MonEn"]:
+                self.monitored_values.lock.acquire()
+                self.monitored_values.reset_op = value
+                self.monitored_values.lock.release()
+            self._reset_vlv()
+            self["ResetOp"] = False
+
+    def set_stop_monitor(self):
+        self.monitored_values.stop_event_lock.set()

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

@@ -0,0 +1,224 @@
+"""Test Suite for MonBinValve."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+import pytest
+import time
+
+from mtppy.part3.data_assembly_set.active_elements.valves.bin_vlv import BinVlv
+from mtppy.part3.data_assembly_set.active_elements.valves.mon_bin_vlv import MonBinVlv
+from mtppy.utils.testing import data_object_set_modes
+
+
+def init_mon_bin_vlv(
+    init_op_mode="off",
+    init_src_mode="int",
+    open_fbk_calc=True,
+    close_fbk_calc=True,
+    safe_pos=1,
+    safe_pos_en=True,
+    perm_en=False,
+    intl_en=False,
+    prot_en=False,
+    mon_en=True,
+    mon_safe_pos=1,
+    mon_stat_ti=0.5,
+    mon_dyn_ti=0.4,
+):
+    instance = MonBinVlv(
+        "tag",
+        tag_description="",
+        open_fbk_calc=open_fbk_calc,
+        close_fbk_calc=close_fbk_calc,
+        safe_pos=safe_pos,
+        safe_pos_en=safe_pos_en,
+        perm_en=perm_en,
+        intl_en=intl_en,
+        prot_en=prot_en,
+        mon_en=mon_en,
+        mon_safe_pos=mon_safe_pos,
+        mon_stat_ti=mon_stat_ti,
+        mon_dyn_ti=mon_dyn_ti,
+    )
+    data_object_set_modes(instance, init_op_mode, init_src_mode)
+    return instance
+
+
+test_scenario_no_control_signals = [
+    ("off", "int", "set_open_op"),
+    ("off", "man", "set_open_op"),
+    ("aut", "int", "set_open_op"),
+    ("aut", "man", "set_open_op"),
+    ("off", "int", "set_open_aut"),
+    ("off", "man", "set_open_aut"),
+    ("op", "int", "set_open_aut"),
+    ("op", "man", "set_open_aut"),
+    ("off", "int", "set_close_op"),
+    ("off", "man", "set_close_op"),
+    ("aut", "int", "set_close_op"),
+    ("aut", "man", "set_close_op"),
+    ("off", "int", "set_close_aut"),
+    ("off", "man", "set_close_aut"),
+    ("op", "int", "set_close_aut"),
+    ("op", "man", "set_close_aut"),
+]
+
+
+@pytest.mark.parametrize(
+    "op_mode, src_mode, set_command", test_scenario_no_control_signals
+)
+def test_static_error(op_mode, src_mode, set_command):
+    for command in [True, False]:
+        mon_bin_vlv = init_mon_bin_vlv(init_op_mode=op_mode, init_src_mode=src_mode)
+        try:
+            mon_bin_vlv.start_monitor()
+            eval(f"mon_bin_vlv.{set_command}({command})")
+            print(f"Scenario: mode {op_mode} {src_mode}, {set_command}")
+
+            # mimic an error situation: OpenFbk changes to True without any change in control signal
+            mon_bin_vlv[BinVlv.OPEN_FBK] = True
+            time.sleep(mon_bin_vlv[MonBinVlv.MON_STAT_TI] * 2)
+
+            assert mon_bin_vlv[MonBinVlv.MON_STAT_ERR] == True
+            assert mon_bin_vlv[MonBinVlv.MON_DYN_ERR] == False
+            assert mon_bin_vlv[BinVlv.SAFE_POS_ACT] == True
+            assert (
+                mon_bin_vlv[BinVlv.OPEN_FBK] == True
+            )  # safe position of valve is open
+
+            time.sleep(mon_bin_vlv[MonBinVlv.MON_STAT_TI])
+
+            # after valve is set to safe position (open), the OpenFbk becomes to False --> another static error
+            mon_bin_vlv[BinVlv.OPEN_FBK] = False
+            time.sleep(mon_bin_vlv[MonBinVlv.MON_STAT_TI] * 1.5)
+
+            assert mon_bin_vlv[MonBinVlv.MON_STAT_ERR] == True
+            assert mon_bin_vlv[MonBinVlv.MON_DYN_ERR] == False
+            assert mon_bin_vlv[BinVlv.SAFE_POS_ACT] == True
+            assert (
+                mon_bin_vlv[BinVlv.OPEN_FBK] == True
+            )  # safe position of valve is open
+        finally:
+            mon_bin_vlv.set_stop_monitor()
+            mon_bin_vlv.monitor_static_thread.join()
+            mon_bin_vlv.monitor_dynamic_thread.join()
+
+
+@pytest.mark.parametrize(
+    "op_mode, src_mode, set_command", test_scenario_no_control_signals
+)
+def test_static_error_within_monitor_time(op_mode, src_mode, set_command):
+    """If the required state is set on the interface before the time has expired (wait tme < 0.5s in this test),
+    there is no error"""
+
+    for command in [True, False]:
+        mon_bin_vlv = init_mon_bin_vlv(init_op_mode=op_mode, init_src_mode=src_mode)
+        try:
+            mon_bin_vlv.start_monitor()
+            eval(f"mon_bin_vlv.{set_command}({command})")
+            print(f"Scenario: mode {op_mode} {src_mode}, {set_command}")
+
+            # mimic an error situation: OpenFbk changes to True without any change in control signal
+            mon_bin_vlv[BinVlv.OPEN_FBK] = True
+            time.sleep(
+                mon_bin_vlv[MonBinVlv.MON_STAT_TI] * 0.5
+            )  # monitor time has not expired (0.5s)
+
+            assert mon_bin_vlv[MonBinVlv.MON_STAT_ERR] == False
+            assert mon_bin_vlv[MonBinVlv.MON_DYN_ERR] == False
+            assert mon_bin_vlv[BinVlv.SAFE_POS_ACT] == False
+        finally:
+            mon_bin_vlv.set_stop_monitor()
+            mon_bin_vlv.monitor_static_thread.join()
+            mon_bin_vlv.monitor_dynamic_thread.join()
+
+
+test_scenario_control_signals = [
+    ("op", "int", "set_open_op", "set_close_op"),
+    ("op", "man", "set_open_op", "set_close_op"),
+    ("aut", "int", "set_open_aut", "set_close_aut"),
+    ("aut", "man", "set_open_aut", "set_close_aut"),
+]
+
+
+@pytest.mark.parametrize(
+    "op_mode, src_mode, open_command, close_command", test_scenario_control_signals
+)
+def test_dynamic_error_open_close(op_mode, src_mode, open_command, close_command):
+    mon_bin_vlv = init_mon_bin_vlv(init_op_mode=op_mode, init_src_mode=src_mode)
+    try:
+        mon_bin_vlv.start_monitor()
+        eval(f"mon_bin_vlv.{open_command}(True)")
+        print(f"Scenario: mode {op_mode} {src_mode}, {open_command}")
+
+        # mimic an error situation: OpenFbk does not change to True after control signal has changed to open
+        mon_bin_vlv[BinVlv.OPEN_FBK] = False
+        time.sleep(mon_bin_vlv[MonBinVlv.MON_DYN_TI] * 2)
+
+        assert mon_bin_vlv[MonBinVlv.MON_DYN_ERR] == True
+        assert mon_bin_vlv[MonBinVlv.MON_STAT_ERR] == False
+        assert mon_bin_vlv[BinVlv.SAFE_POS_ACT] == True
+        assert mon_bin_vlv[BinVlv.OPEN_FBK] == True  # safe position of valve is open
+
+        eval(f"mon_bin_vlv.{close_command}(True)")
+        print(f"Scenario: mode {op_mode} {src_mode}, {close_command}")
+
+        # mimic an error situation: OpenFbk does not change to False after control signal has changed to close
+        mon_bin_vlv[BinVlv.OPEN_FBK] = True
+        time.sleep(mon_bin_vlv[MonBinVlv.MON_DYN_TI] * 2)
+
+        assert mon_bin_vlv["MonDynErr"] == True
+        assert mon_bin_vlv["MonStatErr"] == False
+        assert mon_bin_vlv["SafePosAct"] == True
+        assert mon_bin_vlv["OpenFbk"] == True  # safe position of valve is open
+    finally:
+        mon_bin_vlv.set_stop_monitor()
+        mon_bin_vlv.monitor_static_thread.join()
+        mon_bin_vlv.monitor_dynamic_thread.join()
+
+
+test_scenario_control_signals_reset = [
+    ("op", "int", "set_reset_op"),
+    ("op", "man", "set_reset_op"),
+    ("aut", "int", "set_reset_aut"),
+    ("aut", "man", "set_reset_aut"),
+]
+
+
+@pytest.mark.parametrize(
+    "op_mode, src_mode, set_command", test_scenario_control_signals_reset
+)
+def test_dynamic_error_reset(op_mode, src_mode, set_command):
+    mon_bin_vlv = init_mon_bin_vlv(init_op_mode=op_mode, init_src_mode=src_mode)
+    try:
+        mon_bin_vlv.start_monitor()
+        # set valve to open
+        if op_mode == "op":
+            mon_bin_vlv.set_open_op(True)
+        elif op_mode == "aut":
+            mon_bin_vlv.set_open_aut(True)
+        time.sleep(mon_bin_vlv[MonBinVlv.MON_DYN_TI] * 1)
+
+        # reset valve
+        eval(f"mon_bin_vlv.{set_command}(True)")
+        print(f"Scenario: mode {op_mode} {src_mode}, {set_command}")
+
+        # mimic an error situation: OpenFbk does not change to False after reset changes to True
+        mon_bin_vlv[BinVlv.OPEN_FBK] = True
+        time.sleep(mon_bin_vlv[MonBinVlv.MON_DYN_TI] * 3)
+
+        assert mon_bin_vlv[MonBinVlv.MON_DYN_ERR] == True
+        assert mon_bin_vlv[MonBinVlv.MON_STAT_ERR] == False
+        assert mon_bin_vlv[BinVlv.SAFE_POS_ACT] == True
+        assert mon_bin_vlv[BinVlv.OPEN_FBK] == True  # safe position of valve is open
+    finally:
+        mon_bin_vlv.set_stop_monitor()
+        mon_bin_vlv.monitor_static_thread.join()
+        mon_bin_vlv.monitor_dynamic_thread.join()
+
+
+if __name__ == "__main__":
+    # This allows running the tests directly if needed
+    pytest.main([__file__, "-v"])

mtppy/part3/data_assembly_set/base_functions/__init__.py

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