MTPPy2.0 0.1.5__py3-none-any.whl

mtppy/part3/data_assembly_set/active_elements/drives/mon_bin_drv.py

@@ -0,0 +1,295 @@
+"""Implementation of MonBinDrv."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+
+from typing import ClassVar
+
+from mtppy.part3.data_assembly_set.active_elements.drives.bin_drv import BinDrv
+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.base_functions.operation_mode import (
+    OperationMode as OM,
+)
+
+
+class MonBinDrvValues:
+    def __init__(
+        self, fwd_aut, fwd_op, rev_aut, rev_op, stop_aut, stop_op, reset_aut, reset_op
+    ):
+        self.fwd_aut = fwd_aut
+        self.fwd_op = fwd_op
+        self.rev_aut = rev_aut
+        self.rev_op = rev_op
+        self.stop_aut = stop_aut
+        self.stop_op = stop_op
+        self.reset_aut = reset_aut
+        self.reset_op = reset_op
+        self.lock = threading.Lock()
+        self.stop_event_lock = threading.Event()
+
+
+class MonBinDrv(BinDrv):
+    # 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: MonBinDrvValues
+    monitor_static_thread: threading.Thread
+    monitor_dynamic_thread: threading.Thread
+
+    def __init__(
+        self,
+        tag_name: str,
+        tag_description: str = "",
+        rev_fbk_calc: bool = True,
+        fwd_fbk_calc: bool = True,
+        safe_pos: int = 0,
+        fwd_en: bool = True,
+        rev_en: bool = False,
+        perm_en: bool = False,
+        intl_en: bool = False,
+        prot_en: bool = False,
+        mon_en: bool = True,
+        mon_safe_pos: bool = True,
+        mon_stat_ti: float = 1,
+        mon_dyn_ti: float = 1,
+    ) -> None:
+        super().__init__(
+            tag_name,
+            tag_description,
+            rev_fbk_calc,
+            fwd_fbk_calc,
+            safe_pos,
+            fwd_en,
+            rev_en,
+            perm_en,
+            intl_en,
+            prot_en,
+        )
+        self.mtpObjectType = (
+            "MTPDataObjectSUCLib/DataAssembly/ActiveElement/BinDrv/MonBinDrv"
+        )
+
+        # Initialize data items with dynamic values (using class-defined data items)
+        self[MonBinDrv.MON_EN] = mon_en
+        self[MonBinDrv.MON_SAFE_POS] = mon_safe_pos
+        self[MonBinDrv.MON_STAT_ERR] = False
+        self[MonBinDrv.MON_DYN_ERR] = False
+        self[MonBinDrv.MON_STAT_TI] = mon_stat_ti
+        self[MonBinDrv.MON_DYN_TI] = mon_dyn_ti
+
+        self.monitored_values = MonBinDrvValues(
+            self[BinDrv.FWD_AUT],
+            self[BinDrv.FWD_OP],
+            self[BinDrv.REV_AUT],
+            self[BinDrv.REV_OP],
+            self[BinDrv.STOP_AUT],
+            self[BinDrv.STOP_OP],
+            self[BinDrv.RESET_AUT],
+            self[BinDrv.RESET_OP],
+        )
+        self.monitor_static_thread = None
+        self.monitor_dynamic_thread = None
+
+    def compare_states_control_signals(self, monitor_time):
+
+        self.monitored_values.lock.acquire()
+        fwd_fbk1 = self[BinDrv.FWD_FBK]
+        rev_fbk1 = self[BinDrv.REV_FBK]
+        fwd_op1 = self.monitored_values.fwd_op
+        fwd_aut1 = self.monitored_values.fwd_aut
+        rev_op1 = self.monitored_values.rev_op
+        rev_aut1 = self.monitored_values.rev_aut
+        stop_op1 = self.monitored_values.stop_op
+        stop_aut1 = self.monitored_values.stop_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()
+        fwd_fbk2 = self[BinDrv.FWD_FBK]
+        rev_fbk2 = self[BinDrv.REV_FBK]
+        fwd_op2 = self.monitored_values.fwd_op
+        fwd_aut2 = self.monitored_values.fwd_aut
+        rev_op2 = self.monitored_values.rev_op
+        rev_aut2 = self.monitored_values.rev_aut
+        stop_op2 = self.monitored_values.stop_op
+        stop_aut2 = self.monitored_values.stop_aut
+        reset_op2 = self.monitored_values.reset_op
+        reset_aut2 = self.monitored_values.reset_aut
+        self.monitored_values.lock.release()
+
+        control_signals_comparison = [
+            fwd_op1 == fwd_op2,
+            fwd_aut1 == fwd_aut2,
+            rev_op1 == rev_op2,
+            rev_aut1 == rev_aut2,
+            stop_op1 == stop_op2,
+            stop_aut1 == stop_aut2,
+            reset_op1 == reset_op2,
+            reset_aut1 == reset_aut2,
+        ]
+        state_comparison = [fwd_fbk1 == fwd_fbk2, rev_fbk1 == rev_fbk2]
+        return state_comparison, control_signals_comparison
+
+    def monitor_static_error(self):
+        while not (self.monitored_values.stop_event_lock.is_set()):
+            states, control_signals = self.compare_states_control_signals(
+                self[MonBinDrv.MON_STAT_TI]
+            )
+
+            if not (all(states)) and all(control_signals):
+                self[MonBinDrv.MON_STAT_ERR] = True
+                logger.debug("Static error set to True")
+                self._handle_monitored_error()
+
+        logger.debug("static monitoring stopped")
+
+    def monitor_dynamic_error(self):
+        while not (self.monitored_values.stop_event_lock.is_set()):
+            states, control_signals = self.compare_states_control_signals(
+                self[MonBinDrv.MON_DYN_TI]
+            )
+
+            if all(states) and not (all(control_signals)):
+                self[MonBinDrv.MON_DYN_ERR] = True
+                logger.debug("Dynamic error set to True")
+                self._handle_monitored_error()
+
+        logger.debug("dynamic monitoring stopped")
+
+    def _handle_monitored_error(self):
+        logger.debug("set valve to safety position")
+        self._go_safe_pos()
+        self[BinDrv.SAFE_POS_ACT] = True
+
+    def start_monitor(self):
+        if self[MonBinDrv.MON_EN]:
+            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_fwd_op(self, value: bool):
+        logger.debug(f"FwdOp set to {value}")
+        if self.op_mode[OM.STATE_OP_ACT] and self[BinDrv.FWD_EN]:
+            if value and self._run_allowed():
+                self._run_fwd_drv()
+                if self[MonBinDrv.MON_EN]:
+                    self.monitored_values.lock.acquire()
+                    self.monitored_values.fwd_op = value
+                    self.monitored_values.lock.release()
+                self[BinDrv.FWD_OP] = False
+
+    def set_rev_op(self, value: bool):
+        logger.debug(f"RevOp set to {value}")
+        if self.op_mode[OM.STATE_OP_ACT] and self[BinDrv.REV_EN]:
+            if value and self._run_allowed():
+
+                if self[MonBinDrv.MON_EN]:
+                    self.monitored_values.lock.acquire()
+                    self.monitored_values.rev_op = value
+                    self.monitored_values.lock.release()
+                self._run_rev_drv()
+                self[BinDrv.REV_OP] = False
+
+    def set_stop_op(self, value: bool):
+        logger.debug(f"StopOp set to {value}")
+        if self.op_mode[OM.STATE_OP_ACT] and value:
+            if self[MonBinDrv.MON_EN]:
+                self.monitored_values.lock.acquire()
+                self.monitored_values.stop_op = value
+                self.monitored_values.lock.release()
+            self._stop_drv()
+            self[BinDrv.STOP_OP] = False
+
+    def set_reset_op(self, value: bool):
+        logger.debug(f"ResetOp set to {value}")
+        if self.op_mode[OM.STATE_OP_ACT] and value:
+            if self[MonBinDrv.MON_EN]:
+                self.monitored_values.lock.acquire()
+                self.monitored_values.reset_op = value
+                self.monitored_values.lock.release()
+            self._reset_drv()
+            self[BinDrv.RESET_OP] = False
+
+    def set_fwd_aut(self, value: bool):
+        logger.debug(f"FwdAut set to {value}")
+        if self.op_mode[OM.STATE_AUT_ACT] and self[BinDrv.FWD_EN]:
+            if value and self._run_allowed():
+                if self[MonBinDrv.MON_EN]:
+                    self.monitored_values.lock.acquire()
+                    self.monitored_values.fwd_aut = value
+                    self.monitored_values.lock.release()
+                self._run_fwd_drv()
+
+    def set_rev_aut(self, value: bool):
+        logger.debug(f"RevAut set to {value}")
+        if self.op_mode[OM.STATE_AUT_ACT] and self[BinDrv.REV_EN]:
+            if value and self._run_allowed():
+                if self[MonBinDrv.MON_EN]:
+                    self.monitored_values.lock.acquire()
+                    self.monitored_values.rev_aut = value
+                    self.monitored_values.lock.release()
+                self._run_rev_drv()
+
+    def set_stop_aut(self, value: bool):
+        logger.debug(f"StopAut set to {value}")
+        if self.op_mode[OM.STATE_AUT_ACT] and value:
+            if self[MonBinDrv.MON_EN]:
+                self.monitored_values.lock.acquire()
+                self.monitored_values.stop_aut = value
+                self.monitored_values.lock.release()
+            self._stop_drv()
+
+    def set_reset_aut(self, value: bool):
+        logger.debug(f"ResetAut set to {value}")
+        if self.op_mode[OM.STATE_AUT_ACT] and value:
+            if self[MonBinDrv.MON_EN]:
+                self.monitored_values.lock.acquire()
+                self.monitored_values.reset_aut = value
+                self.monitored_values.lock.release()
+            self._reset_drv()
+
+    def set_stop_monitor(self):
+        self.monitored_values.stop_event_lock.set()

mtppy/part3/data_assembly_set/active_elements/drives/mon_bin_drv_test.py

@@ -0,0 +1,265 @@
+"""Test Suite for MonBinDrv."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+import pytest
+import time
+
+from mtppy.utils.testing import data_object_set_modes
+from mtppy.part3.data_assembly_set.active_elements.drives.mon_bin_drv import MonBinDrv
+
+
+def init_mon_bin_drv(
+    init_op_mode="off",
+    init_src_mode="int",
+    rev_fbk_calc=True,
+    fwd_fbk_calc=True,
+    safe_pos=1,
+    fwd_en=True,
+    rev_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.5,
+) -> MonBinDrv:
+    instance = MonBinDrv(
+        "tag",
+        tag_description="",
+        rev_fbk_calc=rev_fbk_calc,
+        fwd_fbk_calc=fwd_fbk_calc,
+        safe_pos=safe_pos,
+        fwd_en=fwd_en,
+        rev_en=rev_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_fwd_op"),
+    ("off", "man", "set_fwd_op"),
+    ("aut", "int", "set_fwd_op"),
+    ("aut", "man", "set_fwd_op"),
+    ("off", "int", "set_fwd_aut"),
+    ("off", "man", "set_fwd_aut"),
+    ("op", "int", "set_fwd_aut"),
+    ("op", "man", "set_fwd_aut"),
+    ("off", "int", "set_rev_op"),
+    ("off", "man", "set_rev_op"),
+    ("aut", "int", "set_rev_op"),
+    ("aut", "man", "set_rev_op"),
+    ("off", "int", "set_rev_aut"),
+    ("off", "man", "set_rev_aut"),
+    ("op", "int", "set_rev_aut"),
+    ("op", "man", "set_rev_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_drv = init_mon_bin_drv(init_op_mode=op_mode, init_src_mode=src_mode)
+
+        mon_bin_drv.start_monitor()
+        try:
+            eval(f"mon_bin_drv.{set_command}({command})")
+            print(f"Scenario: mode {op_mode} {src_mode}, {set_command}")
+
+            mon_bin_drv["FwdFbk"] = True  # FwdFbk becomes True w/o control signals
+            time.sleep(0.6)
+
+            assert mon_bin_drv["MonStatErr"] == True
+            assert mon_bin_drv["SafePosAct"] == True
+            assert mon_bin_drv["FwdFbk"] == True  # safe position is clockwise rotation
+
+            mon_bin_drv["FwdFbk"] = (
+                False  # FwdFbk becomes to False w/o  control signals
+            )
+
+            time.sleep(0.6)
+
+            assert mon_bin_drv["MonStatErr"] == True
+            assert mon_bin_drv["SafePosAct"] == True
+            assert mon_bin_drv["FwdFbk"] == True  # safe position is clockwise rotation
+        finally:
+            mon_bin_drv.set_stop_monitor()
+            mon_bin_drv.monitor_static_thread.join()
+            mon_bin_drv.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_drv = init_mon_bin_drv(init_op_mode=op_mode, init_src_mode=src_mode)
+
+        mon_bin_drv.start_monitor()
+        try:
+            eval(f"mon_bin_drv.{set_command}({command})")
+            print(f"Scenario: mode {op_mode} {src_mode}, {set_command}")
+
+            # mimic an error situation: FwdFbk changes to True without any change in control signal
+            mon_bin_drv["FwdFbk"] = True
+            time.sleep(0.3)  # monitor time has not expired (0.5s)
+
+            assert mon_bin_drv["MonStatErr"] == False
+            assert mon_bin_drv["MonDynErr"] == False
+            # assert mon_bin_drv["SafePosAct"] == False
+
+        finally:
+            mon_bin_drv.set_stop_monitor()
+            mon_bin_drv.monitor_static_thread.join()
+            mon_bin_drv.monitor_dynamic_thread.join()
+
+
+test_scenario_control_signals_fwd = [
+    ("op", "int", "set_fwd_op", "set_stop_op"),
+    ("op", "man", "set_fwd_op", "set_stop_op"),
+    ("aut", "int", "set_fwd_aut", "set_stop_aut"),
+    ("aut", "man", "set_fwd_aut", "set_stop_aut"),
+]
+
+
+@pytest.mark.parametrize(
+    "op_mode, src_mode, fwd_command, stop_command", test_scenario_control_signals_fwd
+)
+def test_dynamic_error_fwd_stop(op_mode, src_mode, fwd_command, stop_command):
+    mon_bin_drv = init_mon_bin_drv(init_op_mode=op_mode, init_src_mode=src_mode)
+
+    mon_bin_drv.start_monitor()
+    try:
+        eval(f"mon_bin_drv.{fwd_command}(True)")
+        print(f"Scenario: mode {op_mode} {src_mode}, {fwd_command}")
+
+        # FwdFbk does not change to True after control signal has changed to clockwise rotation
+        mon_bin_drv["FwdFbk"] = False
+        time.sleep(0.6)
+
+        assert mon_bin_drv["MonDynErr"] == True
+        assert mon_bin_drv["MonStatErr"] == False
+        assert mon_bin_drv["SafePosAct"] == True
+        assert mon_bin_drv["FwdFbk"] == True  # safe position is clockwise rotation
+
+        eval(f"mon_bin_drv.{stop_command}(True)")
+        print(f"Scenario: mode {op_mode} {src_mode}, {stop_command}")
+
+        # FwdFbk does not change to False after control signal has changed to stop
+        mon_bin_drv["FwdFbk"] = True
+        time.sleep(0.6)
+
+        assert mon_bin_drv["MonDynErr"] == True
+        assert mon_bin_drv["MonStatErr"] == False
+        assert mon_bin_drv["SafePosAct"] == True
+        assert mon_bin_drv["FwdFbk"] == True  # safe position is clockwise rotation
+    finally:
+        mon_bin_drv.set_stop_monitor()
+        mon_bin_drv.monitor_static_thread.join()
+        mon_bin_drv.monitor_dynamic_thread.join()
+
+
+test_scenario_control_signals_rev = [
+    ("op", "int", "set_rev_op", "set_stop_op"),
+    ("op", "man", "set_rev_op", "set_stop_op"),
+    ("aut", "int", "set_rev_aut", "set_stop_aut"),
+    ("aut", "man", "set_rev_aut", "set_stop_aut"),
+]
+
+
+@pytest.mark.parametrize(
+    "op_mode, src_mode, rev_command, stop_command", test_scenario_control_signals_rev
+)
+def test_dynamic_error_rev_stop(op_mode, src_mode, rev_command, stop_command):
+    mon_bin_drv = init_mon_bin_drv(init_op_mode=op_mode, init_src_mode=src_mode)
+
+    mon_bin_drv.start_monitor()
+    try:
+        eval(f"mon_bin_drv.{rev_command}(True)")
+        print(f"Scenario: mode {op_mode} {src_mode}, {rev_command}")
+
+        # RevFbk does not change to True after control signal has changed to anti-clockwise rotation
+        mon_bin_drv["RevFbk"] = False
+        time.sleep(0.6)
+        assert mon_bin_drv["MonDynErr"] == True
+        assert mon_bin_drv["MonStatErr"] == False
+        assert mon_bin_drv["SafePosAct"] == True
+        assert mon_bin_drv["FwdFbk"] == True  # safe position is clockwise rotation
+
+        eval(f"mon_bin_drv.{stop_command}(True)")
+        print(f"Scenario: mode {op_mode} {src_mode}, {stop_command}")
+
+        # FwdFbk does not change to False after control signal has changed to stop
+        mon_bin_drv["FwdFbk"] = True
+        time.sleep(0.6)
+
+        assert mon_bin_drv["MonDynErr"] == True
+        assert mon_bin_drv["MonStatErr"] == False
+        assert mon_bin_drv["SafePosAct"] == True
+        assert mon_bin_drv["FwdFbk"] == True  # safe position is clockwise rotation
+    finally:
+        mon_bin_drv.set_stop_monitor()
+        mon_bin_drv.monitor_static_thread.join()
+        mon_bin_drv.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_drv = init_mon_bin_drv(init_op_mode=op_mode, init_src_mode=src_mode)
+
+    mon_bin_drv.start_monitor()
+    try:
+        # set valve to open
+        if op_mode == "op":
+            mon_bin_drv.set_fwd_op(True)
+        elif op_mode == "aut":
+            mon_bin_drv.set_fwd_aut(True)
+        time.sleep(0.6)
+
+        # reset valve
+        eval(f"mon_bin_drv.{set_command}(True)")
+        print(f"Scenario: mode {op_mode} {src_mode}, {set_command}")
+
+        # mimic an error situation: FwdFbk does not change to False after reset changes to True
+        mon_bin_drv["FwdFbk"] = True
+        time.sleep(0.6)
+
+        assert mon_bin_drv["MonDynErr"] == True
+        assert mon_bin_drv["MonStatErr"] == False
+        assert mon_bin_drv["SafePosAct"] == True
+        assert mon_bin_drv["FwdFbk"] == True  # safe position of valve is open
+    finally:
+        mon_bin_drv.set_stop_monitor()
+        mon_bin_drv.monitor_static_thread.join()
+        mon_bin_drv.monitor_dynamic_thread.join()
+
+
+if __name__ == "__main__":
+    # This allows running the tests directly if needed
+    pytest.main([__file__, "-v"])

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

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