MTPPy2.0 0.1.5__py3-none-any.whl

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

@@ -0,0 +1,418 @@
+"""Test Suite for MonAnaDrv."""
+
+__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_ana_drv import MonAnaDrv
+
+
+def init_mon_ana_drv(
+    init_op_mode="off",
+    init_src_mode="int",
+    rev_fbk_calc=True,
+    fwd_fbk_calc=True,
+    rpm_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_dyn_ti=0.5,
+    mon_stat_ti=0.5,
+    rmp_ah_en=True,
+    rmp_al_en=True,
+    rpm_ah_lim=900,
+    rpm_al_lim=50,
+):
+    instance = MonAnaDrv(
+        "tag",
+        tag_description="",
+        rpm_min=-10,
+        rpm_max=1000,
+        rpm_scl_min=0,
+        rpm_scl_max=1000,
+        rev_fbk_calc=rev_fbk_calc,
+        fwd_fbk_calc=fwd_fbk_calc,
+        rpm_fbk_calc=rpm_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_dyn_ti=mon_dyn_ti,
+        mon_stat_ti=mon_stat_ti,
+        rpm_ah_en=rmp_ah_en,
+        rpm_al_en=rmp_al_en,
+        rpm_ah_lim=rpm_ah_lim,
+        rpm_al_lim=rpm_al_lim,
+    )
+    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_ana_drv = init_mon_ana_drv(
+            init_op_mode=op_mode,
+            init_src_mode=src_mode,
+            rmp_ah_en=False,
+            rmp_al_en=False,
+        )
+
+        mon_ana_drv.start_monitor()
+        try:
+            eval(f"mon_ana_drv.{set_command}({command})")
+            print(f"Scenario: mode {op_mode} {src_mode}, {set_command}")
+
+            # FwdFbk becomes to True without any control signals
+            mon_ana_drv["FwdFbk"] = True
+            time.sleep(0.6)
+
+            assert mon_ana_drv["MonStatErr"] == True
+            assert mon_ana_drv["SafePosAct"] == True
+            assert mon_ana_drv["FwdFbk"] == True  # safe position is clockwise rotation
+
+            # FwdFbk becomes to True without any control signals
+            mon_ana_drv["FwdFbk"] = False
+            time.sleep(0.6)
+
+            assert mon_ana_drv["MonStatErr"] == True
+            assert mon_ana_drv["SafePosAct"] == True
+            assert mon_ana_drv["FwdFbk"] == True  # safe position is clockwise rotation
+        finally:
+            mon_ana_drv.set_stop_monitor()
+            mon_ana_drv.monitor_static_thread.join()
+            mon_ana_drv.monitor_dynamic_thread.join()
+            mon_ana_drv.monitor_rpm_error_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_ana_drv = init_mon_ana_drv(
+            init_op_mode=op_mode,
+            init_src_mode=src_mode,
+            rmp_ah_en=False,
+            rmp_al_en=False,
+        )
+
+        mon_ana_drv.start_monitor()
+        try:
+            eval(f"mon_ana_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_ana_drv["FwdFbk"] = True
+            time.sleep(0.3)  # monitor time has not expired (0.5s)
+
+            assert mon_ana_drv["MonStatErr"] == False
+            assert mon_ana_drv["MonDynErr"] == False
+        finally:
+            mon_ana_drv.set_stop_monitor()
+            mon_ana_drv.monitor_static_thread.join()
+            mon_ana_drv.monitor_dynamic_thread.join()
+            mon_ana_drv.monitor_rpm_error_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_ana_drv = init_mon_ana_drv(
+        init_op_mode=op_mode, init_src_mode=src_mode, rmp_ah_en=False, rmp_al_en=False
+    )
+
+    mon_ana_drv.start_monitor()
+    try:
+        eval(f"mon_ana_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_ana_drv["FwdFbk"] = False
+        time.sleep(0.6)
+
+        assert mon_ana_drv["MonDynErr"] == True
+        assert mon_ana_drv["MonStatErr"] == False
+        assert mon_ana_drv["SafePosAct"] == True
+        assert mon_ana_drv["FwdFbk"] == True  # safe position is clockwise rotation
+
+        eval(f"mon_ana_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_ana_drv["FwdFbk"] = True
+        time.sleep(0.6)
+
+        assert mon_ana_drv["MonDynErr"] == True
+        assert mon_ana_drv["MonStatErr"] == False
+        assert mon_ana_drv["SafePosAct"] == True
+        assert mon_ana_drv["FwdFbk"] == True  # safe position is clockwise rotation
+    finally:
+        mon_ana_drv.set_stop_monitor()
+        mon_ana_drv.monitor_static_thread.join()
+        mon_ana_drv.monitor_dynamic_thread.join()
+        mon_ana_drv.monitor_rpm_error_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_ana_drv = init_mon_ana_drv(
+        init_op_mode=op_mode, init_src_mode=src_mode, rmp_ah_en=False, rmp_al_en=False
+    )
+
+    mon_ana_drv.start_monitor()
+    try:
+        eval(f"mon_ana_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_ana_drv["RevFbk"] = False
+        time.sleep(0.6)
+        assert mon_ana_drv["MonDynErr"] == True
+        assert mon_ana_drv["MonStatErr"] == False
+        assert mon_ana_drv["SafePosAct"] == True
+        assert mon_ana_drv["FwdFbk"] == True  # safe position is clockwise rotation
+
+        eval(f"mon_ana_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_ana_drv["FwdFbk"] = True
+        time.sleep(0.6)
+
+        assert mon_ana_drv["MonDynErr"] == True
+        assert mon_ana_drv["MonStatErr"] == False
+        assert mon_ana_drv["SafePosAct"] == True
+        assert mon_ana_drv["FwdFbk"] == True  # safe position is clockwise rotation
+
+    finally:
+        mon_ana_drv.set_stop_monitor()
+        mon_ana_drv.monitor_static_thread.join()
+        mon_ana_drv.monitor_dynamic_thread.join()
+        mon_ana_drv.monitor_rpm_error_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_ana_drv = init_mon_ana_drv(
+        init_op_mode=op_mode, init_src_mode=src_mode, rmp_ah_en=False, rmp_al_en=False
+    )
+
+    mon_ana_drv.start_monitor()
+    try:
+        # set valve to open
+        if op_mode == "op":
+            mon_ana_drv.set_fwd_op(True)
+        elif op_mode == "aut":
+            mon_ana_drv.set_fwd_aut(True)
+        time.sleep(0.6)
+
+        # reset valve
+        eval(f"mon_ana_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_ana_drv["FwdFbk"] = True
+        time.sleep(0.6)
+
+        assert mon_ana_drv["MonDynErr"] == True
+        assert mon_ana_drv["MonStatErr"] == False
+        assert mon_ana_drv["SafePosAct"] == True
+        assert mon_ana_drv["FwdFbk"] == True  # safe position is clockwise rotation
+    finally:
+        mon_ana_drv.set_stop_monitor()
+        mon_ana_drv.monitor_static_thread.join()
+        mon_ana_drv.monitor_dynamic_thread.join()
+        mon_ana_drv.monitor_rpm_error_thread.join()
+
+
+test_scenario_rpm = [
+    ("op", "int", "set_rpm_int", False),  # op shall not set rpm_int
+    ("aut", "int", "set_rpm_int", True),
+    ("op", "man", "set_rpm_man", True),
+    ("aut", "man", "set_rpm_man", False),  # aut shall not set rpm_man
+]
+
+
+@pytest.mark.parametrize(
+    "op_mode, src_mode, set_command, changes_expected", test_scenario_rpm
+)
+def test_rpm_error(op_mode, src_mode, set_command, changes_expected):
+    for command in [-500, 500, 700, 10000]:
+        mon_ana_drv = init_mon_ana_drv(
+            init_op_mode=op_mode,
+            init_src_mode=src_mode,
+            rpm_fbk_calc=True,
+            rmp_ah_en=False,
+            rmp_al_en=False,
+        )
+        mon_ana_drv.start_monitor()
+        try:
+            time.sleep(0.5)
+            eval(f"mon_ana_drv.{set_command}({command})")
+
+            print(
+                f"Scenario: mode {op_mode} {src_mode}, {set_command}, {command} changes expected: {changes_expected}"
+            )
+            mon_ana_drv["RpmFbk"] = 400
+            # RpmFbk is 400, it does not reach desired rpm (500 or 700)
+            time.sleep(0.5)
+            if changes_expected:
+                if -10 <= command <= 1000:
+                    if command == 500:
+                        assert mon_ana_drv["RpmErr"] == 100
+                    elif command == 700:
+                        assert mon_ana_drv["RpmErr"] == 300
+                else:
+                    assert mon_ana_drv["RpmErr"] == -410
+            else:
+                assert mon_ana_drv["RpmErr"] == -410
+
+            assert mon_ana_drv["SafePosAct"] == True
+            assert mon_ana_drv["FwdFbk"] == True  # safe position is clockwise rotation
+        finally:
+            mon_ana_drv.set_stop_monitor()
+            mon_ana_drv.monitor_static_thread.join()
+            mon_ana_drv.monitor_dynamic_thread.join()
+            mon_ana_drv.monitor_rpm_error_thread.join()
+
+
+@pytest.mark.parametrize(
+    "op_mode, src_mode, set_command, changes_expected", test_scenario_rpm
+)
+def test_rpm_high_limit_alarm(op_mode, src_mode, set_command, changes_expected):
+    for command in [901, 999, 10000]:  # high limit is 900
+        mon_ana_drv = init_mon_ana_drv(
+            init_op_mode=op_mode,
+            init_src_mode=src_mode,
+            rpm_fbk_calc=True,
+            rmp_ah_en=True,
+            rmp_al_en=False,
+        )
+        rpm = mon_ana_drv[MonAnaDrv.RPM_]
+        mon_ana_drv.start_monitor()
+        try:
+            time.sleep(0.5)
+            eval(f"mon_ana_drv.{set_command}({command})")
+            print(
+                f"Scenario: mode {op_mode} {src_mode}, {set_command}, {command} changes expected: {changes_expected}"
+            )
+            time.sleep(0.5)
+
+            if changes_expected:
+                if -10 <= command <= 1000:
+                    assert mon_ana_drv["RpmAHAct"] == True
+                else:
+                    assert mon_ana_drv["RpmAHAct"] == False
+            else:
+                assert mon_ana_drv[MonAnaDrv.RPM_] == rpm
+                assert mon_ana_drv["RpmAHAct"] == False
+        finally:
+            mon_ana_drv.set_stop_monitor()
+            mon_ana_drv.monitor_static_thread.join()
+            mon_ana_drv.monitor_dynamic_thread.join()
+            mon_ana_drv.monitor_rpm_error_thread.join()
+
+            mon_ana_drv.monitor_rpm_limit_high_thread.join()
+
+
+@pytest.mark.parametrize(
+    "op_mode, src_mode, set_command, changes_expected", test_scenario_rpm
+)
+def test_rpm_low_limit_alarm(op_mode, src_mode, set_command, changes_expected):
+    for command in [10, 40]:  # low limit is 50
+        mon_ana_drv = init_mon_ana_drv(
+            init_op_mode=op_mode,
+            init_src_mode=src_mode,
+            rpm_fbk_calc=True,
+            rmp_ah_en=False,
+            rmp_al_en=True,
+        )
+        mon_ana_drv.start_monitor()
+        try:
+            eval(f"mon_ana_drv.{set_command}({command})")
+            print(
+                f"Scenario: mode {op_mode} {src_mode}, {set_command}, {command} changes expected: {changes_expected}"
+            )
+            time.sleep(0.5)
+
+            assert mon_ana_drv["RpmALAct"] == True
+        finally:
+            mon_ana_drv.set_stop_monitor()
+            mon_ana_drv.monitor_static_thread.join()
+            mon_ana_drv.monitor_dynamic_thread.join()
+            mon_ana_drv.monitor_rpm_error_thread.join()
+
+            mon_ana_drv.monitor_rpm_limit_low_thread.join()
+
+
+if __name__ == "__main__":
+    # This allows running the tests directly if needed
+    pytest.main([__file__, "-v"])