MTPPy2.0 0.1.5__py3-none-any.whl

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

@@ -0,0 +1,402 @@
+"""Implementation of MonAnaVlv."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+from typing import ClassVar
+
+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.ana_vlv import AnaVlv
+from mtppy.part3.data_assembly_set.base_functions.operation_mode import (
+    OperationMode as OM,
+)
+
+
+class MonAnaVlvValues:
+    def __init__(
+        self, open_aut, open_op, close_aut, close_op, reset_aut, reset_op, pos
+    ):
+        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.pos = pos
+        self.lock = threading.Lock()
+        self.stop_event_lock = threading.Event()
+
+
+class MonAnaVlv(AnaVlv):
+    # 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"
+    POS_REACHED_FBK = "PosReachedFbk"
+    POS_TOLERANCE = "PosTolerance"
+    MON_POS_TI = "MonPosTi"
+    MON_POS_ERR = "MonPosErr"
+
+    # 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
+        ),
+        POS_REACHED_FBK: DataItem(
+            POS_REACHED_FBK, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, None
+        ),
+        POS_TOLERANCE: DataItem(
+            POS_TOLERANCE, W3cXmlDataTypes.FLOAT, MTPAccess.ReadAccess, None
+        ),
+        MON_POS_TI: DataItem(
+            MON_POS_TI, W3cXmlDataTypes.FLOAT, MTPAccess.ReadAccess, None
+        ),
+        MON_POS_ERR: DataItem(
+            MON_POS_ERR, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, None
+        ),
+    }
+
+    monitored_values: MonAnaVlvValues
+    monitor_static_thread: threading.Thread
+    monitor_dynamic_thread: threading.Thread
+    monitor_pos_thread: threading.Thread
+
+    def __init__(
+        self,
+        tag_name,
+        tag_description="",
+        pos_min=0,
+        pos_max=100,
+        pos_scl_min=0,
+        pos_scl_max=100,
+        pos_unit=1342,
+        open_fbk_calc=True,
+        close_fbk_calc=True,
+        pos_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,
+        pos_tolerance=1,
+        mon_pos_ti=1,
+    ) -> None:
+        super().__init__(
+            tag_name,
+            tag_description,
+            pos_min,
+            pos_max,
+            pos_scl_min,
+            pos_scl_max,
+            pos_unit,
+            open_fbk_calc,
+            close_fbk_calc,
+            pos_fbk_calc,
+            safe_pos,
+            safe_pos_en,
+            perm_en,
+            intl_en,
+            prot_en,
+        )
+        self.mtpObjectType = (
+            "MTPDataObjectSUCLib/DataAssembly/ActiveElement/AnaVlv/MonAnaVlv"
+        )
+
+        # Initialize data items with dynamic values (using class-defined data items)
+        self[MonAnaVlv.MON_EN] = mon_en
+        self[MonAnaVlv.MON_SAFE_POS] = mon_safe_pos
+        self[MonAnaVlv.MON_STAT_ERR] = False
+        self[MonAnaVlv.MON_DYN_ERR] = False
+        self[MonAnaVlv.MON_STAT_TI] = mon_stat_ti
+        self[MonAnaVlv.MON_DYN_TI] = mon_dyn_ti
+        self[MonAnaVlv.POS_REACHED_FBK] = False
+        self[MonAnaVlv.POS_TOLERANCE] = pos_tolerance
+        self[MonAnaVlv.MON_POS_TI] = mon_pos_ti
+        self[MonAnaVlv.MON_POS_ERR] = False
+
+        self.monitored_values = MonAnaVlvValues(
+            self[MonAnaVlv.OPEN_AUT],
+            self[MonAnaVlv.OPEN_OP],
+            self[MonAnaVlv.CLOSE_AUT],
+            self[MonAnaVlv.CLOSE_OP],
+            self[MonAnaVlv.RESET_AUT],
+            self[MonAnaVlv.RESET_OP],
+            self[MonAnaVlv.POS_],
+        )
+        self.monitor_static_thread = None
+        self.monitor_dynamic_thread = None
+        self.monitor_pos_thread = None
+
+    def _go_save_pos(self):
+        if self[AnaVlv.SAFE_POS] == 1:
+            self._run_open_vlv()
+            safe_pos = self[AnaVlv.POS_MAX]
+        else:
+            self._run_close_vlv()
+            safe_pos = self[AnaVlv.POS_MIN]
+
+        self[AnaVlv.POS_] = safe_pos
+        logger.debug(f"Pos set to safe position {safe_pos}")
+        if self[MonAnaVlv.MON_EN]:
+            self.monitored_values.pos = safe_pos
+            self.monitor_pos_thread = threading.Thread(
+                target=self.monitor_position_reached, daemon=True
+            )
+            self.monitor_pos_thread.start()
+
+        if self[AnaVlv.POS_FBK_CALC]:
+            if self[MonAnaVlv.MON_EN]:
+                self.monitored_values.lock.acquire()
+                self[AnaVlv.POS_FBK] = safe_pos
+                self.monitored_values.lock.release()
+            else:
+                self[AnaVlv.POS_FBK] = safe_pos
+
+    def compare_states_control_signals(
+        self, monitor_time
+    ) -> tuple[list[bool], list[bool]]:
+        """
+        compare states of valve and control signals
+
+        Argument:
+            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[AnaVlv.OPEN_FBK]
+        close_fbk1 = self[AnaVlv.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[AnaVlv.OPEN_FBK]
+        close_fbk2 = self[AnaVlv.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[MonAnaVlv.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[MonAnaVlv.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[MonAnaVlv.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[MonAnaVlv.MON_DYN_ERR] = True
+                    logger.debug("Dynamic error set to True")
+                    self._handle_monitored_error()
+
+    def monitor_position_reached(self):
+        """
+        monitor position error
+        """
+        pos = self.monitored_values.pos
+        sleep(self[MonAnaVlv.MON_POS_TI])
+        pos_reached_fbk = (
+            abs(self[AnaVlv.POS_FBK] - pos) <= self[MonAnaVlv.POS_TOLERANCE]
+        )
+        self[MonAnaVlv.POS_REACHED_FBK] = pos_reached_fbk
+        if not pos_reached_fbk:
+            self[MonAnaVlv.MON_POS_ERR] = True
+            logger.debug("position error set to True")
+            self._handle_monitored_error()
+
+    def _handle_monitored_error(self):
+        if self[MonAnaVlv.MON_SAFE_POS]:
+            logger.debug("set valve to safety position")
+            if self[AnaVlv.SAFE_POS_EN]:
+                self._go_save_pos()
+            else:
+                logger.debug("Device has no safe position")
+            self[AnaVlv.SAFE_POS_ACT] = True
+
+    def start_monitor(self):
+        if self[MonAnaVlv.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_open_aut(self, value: bool):
+        logger.debug(f"OpenAut set to {value}")
+        if self.op_mode[OM.STATE_AUT_ACT]:
+            if value and self._run_allowed():
+                if self[MonAnaVlv.MON_EN]:
+                    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[OM.STATE_AUT_ACT]:
+            if value and self._run_allowed():
+                if self[MonAnaVlv.MON_EN]:
+                    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[OM.STATE_AUT_ACT] and value:
+            if self[MonAnaVlv.MON_EN]:
+                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[OM.STATE_OP_ACT]:
+            if value and self._run_allowed():
+                if self[MonAnaVlv.MON_EN]:
+                    self.monitored_values.lock.acquire()
+                    self.monitored_values.open_op = value
+                    self.monitored_values.lock.release()
+                self._run_open_vlv()
+                self[AnaVlv.OPEN_OP] = False
+
+    def set_close_op(self, value: bool):
+        logger.debug(f"CloseOp set to {value}")
+        if self.op_mode[OM.STATE_OP_ACT]:
+            if value and self._run_allowed():
+                if self[MonAnaVlv.MON_EN]:
+                    self.monitored_values.lock.acquire()
+                    self.monitored_values.close_op = value
+                    self.monitored_values.lock.release()
+                self._run_close_vlv()
+                self[AnaVlv.CLOSE_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[MonAnaVlv.MON_EN]:
+                self.monitored_values.lock.acquire()
+                self.monitored_values.reset_op = value
+                self.monitored_values.lock.release()
+            self._reset_vlv()
+            self[AnaVlv.RESET_OP] = False
+
+    def _set_pos(self, value: float):
+        if self.valid_value(value):
+            # if SafePosAct is inactive -> manual or internal position specification
+            if self[AnaVlv.OPEN_ACT] and not self[AnaVlv.SAFE_POS_ACT]:
+                value = value
+            elif self[AnaVlv.CLOSE_ACT] and not self[AnaVlv.SAFE_POS_ACT]:
+                value = self[AnaVlv.POS_MIN]
+
+            # if SafePosAct is active, safety setting for the position is accepted
+            elif self[AnaVlv.SAFE_POS_ACT] or (
+                self[AnaVlv.PERM_EN] and self[AnaVlv.PERMIT_] == 0
+            ):
+                logger.debug("manual or internal position specification inactive")
+                return
+
+            self[AnaVlv.POS_] = value
+            logger.debug(f"Pos set to {value}")
+
+            # start monitor_pos_thread to after pos has been changed
+            # if the position does not change, there is no need to check the desired position
+            if self[MonAnaVlv.MON_EN]:
+                self.monitored_values.pos = value
+                self.monitor_pos_thread = threading.Thread(
+                    target=self.monitor_position_reached
+                )
+                self.monitor_pos_thread.start()
+
+            if self[AnaVlv.POS_FBK_CALC]:
+                if self[MonAnaVlv.MON_EN]:
+                    self.monitored_values.lock.acquire()
+                    self[AnaVlv.POS_FBK] = value
+                    self.monitored_values.lock.release()
+                else:
+                    self[AnaVlv.POS_FBK] = value
+        else:
+            logger.debug(f"Pos cannot be set to {value} (out of range)")
+
+    def set_stop_monitor(self):
+        self.monitored_values.stop_event_lock.set()

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

@@ -0,0 +1,270 @@
+"""Test Suite for MonAnaVlv."""
+
+__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.valves.mon_ana_vlv import MonAnaVlv
+
+
+def init_mon_ana_vlv(
+    init_op_mode="off",
+    init_src_mode="int",
+    open_fbk_calc=True,
+    close_fbk_calc=True,
+    pos_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=True,
+    mon_stat_ti=1,
+    mon_dyn_ti=1,
+    pos_tolerance=1,
+    mon_pos_ti=1,
+):
+    mon_ana_vlv = MonAnaVlv(
+        "tag",
+        tag_description="",
+        pos_min=2,
+        pos_max=10,
+        pos_scl_min=0,
+        pos_scl_max=10,
+        pos_unit=0,
+        open_fbk_calc=open_fbk_calc,
+        close_fbk_calc=close_fbk_calc,
+        pos_fbk_calc=pos_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,
+        pos_tolerance=pos_tolerance,
+        mon_pos_ti=mon_pos_ti,
+    )
+    data_object_set_modes(mon_ana_vlv, init_op_mode, init_src_mode)
+    return mon_ana_vlv
+
+
+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_ana_vlv = init_mon_ana_vlv(init_op_mode=op_mode, init_src_mode=src_mode)
+        try:
+            mon_ana_vlv.start_monitor()
+            eval(f"mon_ana_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_ana_vlv["OpenFbk"] = True
+            time.sleep(1.1)  # monitor time has expired (> 1s)
+
+            assert mon_ana_vlv["MonStatErr"] == True
+            assert mon_ana_vlv["MonDynErr"] == False
+            assert mon_ana_vlv["SafePosAct"] == True
+            assert mon_ana_vlv["OpenFbk"] == True  # safe position of valve is open
+
+            time.sleep(0.5)
+
+            # after valve is set to safe position (open), the OpenFbk becomes to False --> another static error
+            mon_ana_vlv["OpenFbk"] = False
+            time.sleep(1.1)  # monitor time has expired (> 1s)
+
+            assert mon_ana_vlv["MonStatErr"] == True
+            assert mon_ana_vlv["MonDynErr"] == False
+            assert mon_ana_vlv["SafePosAct"] == True
+            assert mon_ana_vlv["OpenFbk"] == True  # safe position of valve is open
+        finally:
+            mon_ana_vlv.set_stop_monitor()
+            mon_ana_vlv.monitor_static_thread.join()
+            mon_ana_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 < 1s in this test),
+    there is no error"""
+
+    for command in [True, False]:
+        mon_ana_vlv = init_mon_ana_vlv(init_op_mode=op_mode, init_src_mode=src_mode)
+        try:
+            mon_ana_vlv.start_monitor()
+            eval(f"mon_ana_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_ana_vlv["OpenFbk"] = True
+            time.sleep(0.6)  # monitor time has not expired (1s)
+
+            assert mon_ana_vlv["MonStatErr"] == False
+            assert mon_ana_vlv["MonDynErr"] == False
+            assert mon_ana_vlv["SafePosAct"] == False
+        finally:
+            mon_ana_vlv.set_stop_monitor()
+            mon_ana_vlv.monitor_static_thread.join()
+            mon_ana_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_ana_vlv = init_mon_ana_vlv(init_op_mode=op_mode, init_src_mode=src_mode)
+    try:
+        mon_ana_vlv.start_monitor()
+        eval(f"mon_ana_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_ana_vlv["OpenFbk"] = False
+        time.sleep(1.1)  # monitor time has expired (> 1s)
+
+        assert mon_ana_vlv["MonDynErr"] == True
+        assert mon_ana_vlv["MonStatErr"] == False
+        assert mon_ana_vlv["SafePosAct"] == True
+        assert mon_ana_vlv["OpenFbk"] == True  # safe position of valve is open
+
+        eval(f"mon_ana_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_ana_vlv["OpenFbk"] = True
+        time.sleep(1.1)  # monitor time has expired (> 1s)
+
+        assert mon_ana_vlv["MonDynErr"] == True
+        assert mon_ana_vlv["MonStatErr"] == False
+        assert mon_ana_vlv["SafePosAct"] == True
+        assert mon_ana_vlv["OpenFbk"] == True  # safe position of valve is open
+    finally:
+        mon_ana_vlv.set_stop_monitor()
+        mon_ana_vlv.monitor_static_thread.join()
+        mon_ana_vlv.monitor_dynamic_thread.join()
+
+
+test_scenario_pos = [
+    ("op", "int", "set_pos_int"),
+    ("aut", "int", "set_pos_int"),
+    ("op", "man", "set_pos_man"),
+    ("aut", "man", "set_pos_man"),
+]
+
+
+@pytest.mark.parametrize("op_mode, src_mode, set_command", test_scenario_pos)
+def test_pos_open(op_mode, src_mode, set_command):
+    for pos_value in [-2, 4, 7, 10, 100]:  # pos min is 2, pos max is 10
+        mon_ana_vlv = init_mon_ana_vlv(
+            init_op_mode=op_mode, init_src_mode=src_mode, pos_fbk_calc=True
+        )
+        if op_mode == "op":
+            mon_ana_vlv.set_open_op(True)
+        elif op_mode == "aut":
+            mon_ana_vlv.set_open_aut(True)
+        eval(f"mon_ana_vlv.{set_command}({pos_value})")
+        print(
+            f"Scenario: modes=({op_mode},{src_mode}), cmd={set_command}, pos={pos_value}"
+        )
+        # position tolerance is 1, pos_fbk is 2.5 --> pos error
+        mon_ana_vlv["PosFbk"] = 7.5
+        time.sleep(1.5)  # time for monitoring pos error is 1s
+        if 2 <= pos_value < 6 or 8 < pos_value <= 10:  # out of the pos tolerance range
+            assert mon_ana_vlv["PosReachedFbk"] == False
+            assert mon_ana_vlv["MonPosErr"] == True
+            assert mon_ana_vlv["SafePosAct"] == True
+            assert mon_ana_vlv["OpenAct"] == True
+
+        elif 6 <= pos_value <= 8:  # within the pos tolerance range
+            assert mon_ana_vlv["PosReachedFbk"] == True
+            assert mon_ana_vlv["MonPosErr"] == False
+            assert mon_ana_vlv["SafePosAct"] == False
+
+        else:
+            assert mon_ana_vlv["PosReachedFbk"] == False
+            assert mon_ana_vlv["MonPosErr"] == False
+            assert mon_ana_vlv["SafePosAct"] == False
+
+
+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_ana_vlv = init_mon_ana_vlv(init_op_mode=op_mode, init_src_mode=src_mode)
+    try:
+        mon_ana_vlv.start_monitor()
+        # set valve to open
+        if op_mode == "op":
+            mon_ana_vlv.set_open_op(True)
+        elif op_mode == "aut":
+            mon_ana_vlv.set_open_aut(True)
+        time.sleep(1.1)
+
+        # reset valve
+        eval(f"mon_ana_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_ana_vlv["OpenFbk"] = True
+        time.sleep(1.1)
+
+        assert mon_ana_vlv["MonDynErr"] == True
+        assert mon_ana_vlv["MonStatErr"] == False
+        assert mon_ana_vlv["SafePosAct"] == True
+        assert mon_ana_vlv["OpenFbk"] == True  # safe position of valve is open
+    finally:
+        mon_ana_vlv.set_stop_monitor()
+        mon_ana_vlv.monitor_static_thread.join()
+        mon_ana_vlv.monitor_dynamic_thread.join()
+
+
+if __name__ == "__main__":
+    # This allows running the tests directly if needed
+    pytest.main([__file__, "-v"])