MTPPy2.0 0.1.5__py3-none-any.whl

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

@@ -0,0 +1,469 @@
+"""Implementation of MonAnaDrv."""
+
+__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.drives.ana_drv import AnaDrv
+from mtppy.part3.data_assembly_set.base_functions.operation_mode import (
+    OperationMode as OM,
+)
+
+
+class MonAnaDrvValues:
+    def __init__(
+        self,
+        fwd_aut,
+        fwd_op,
+        rev_aut,
+        rev_op,
+        stop_aut,
+        stop_op,
+        reset_aut,
+        reset_op,
+        rpm,
+    ) -> None:
+        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.rpm = rpm
+        self.lock = threading.Lock()
+        self.stop_event_lock = threading.Event()
+
+
+class MonAnaDrv(AnaDrv):
+    MON_EN = "MonEn"
+    MON_SAFE_POS = "MonSafePos"
+    MON_STAT_ERR = "MonStatErr"
+    MON_DYN_ERR = "MonDynErr"
+    MON_STAT_TI = "MonStatTi"
+    MON_DYN_TI = "MonDynTi"
+    RPM_ERR = "RpmErr"
+    RPM_AH_EN = "RpmAHEn"
+    RPM_AL_EN = "RpmALEn"
+    RPM_AH_ACT = "RpmAHAct"
+    RPM_AL_ACT = "RpmALAct"
+    RPM_AH_LIM = "RpmAHLim"
+    RPM_AL_LIM = "RpmALLim"
+
+    CLASS_DATA_ITEMS: ClassVar = {
+        MON_EN: DataItem(
+            MON_EN,
+            W3cXmlDataTypes.BOOLEAN,
+            MTPAccess.ReadAccess,
+            True,
+        ),
+        MON_SAFE_POS: DataItem(
+            MON_SAFE_POS,
+            W3cXmlDataTypes.BOOLEAN,
+            MTPAccess.ReadAccess,
+            True,
+        ),
+        MON_STAT_ERR: DataItem(
+            MON_STAT_ERR,
+            W3cXmlDataTypes.BOOLEAN,
+            MTPAccess.ReadAccess,
+            False,
+        ),
+        MON_DYN_ERR: DataItem(
+            MON_DYN_ERR,
+            W3cXmlDataTypes.BOOLEAN,
+            MTPAccess.ReadAccess,
+            False,
+        ),
+        MON_STAT_TI: DataItem(
+            MON_STAT_TI,
+            W3cXmlDataTypes.FLOAT,
+            MTPAccess.ReadAccess,
+            1,
+        ),
+        MON_DYN_TI: DataItem(
+            MON_DYN_TI,
+            W3cXmlDataTypes.FLOAT,
+            MTPAccess.ReadAccess,
+            1,
+        ),
+        RPM_ERR: DataItem(
+            RPM_ERR,
+            W3cXmlDataTypes.FLOAT,
+            MTPAccess.ReadAccess,
+            0,
+        ),
+        RPM_AH_EN: DataItem(
+            RPM_AH_EN,
+            W3cXmlDataTypes.BOOLEAN,
+            MTPAccess.ReadAccess,
+            True,
+        ),
+        RPM_AL_EN: DataItem(
+            RPM_AL_EN,
+            W3cXmlDataTypes.BOOLEAN,
+            MTPAccess.ReadAccess,
+            True,
+        ),
+        RPM_AH_ACT: DataItem(
+            RPM_AH_ACT,
+            W3cXmlDataTypes.BOOLEAN,
+            MTPAccess.ReadAccess,
+            False,
+        ),
+        RPM_AL_ACT: DataItem(
+            RPM_AL_ACT,
+            W3cXmlDataTypes.BOOLEAN,
+            MTPAccess.ReadAccess,
+            False,
+        ),
+        RPM_AH_LIM: DataItem(
+            RPM_AH_LIM,
+            W3cXmlDataTypes.FLOAT,
+            MTPAccess.ReadAccess,
+            True,
+        ),
+        RPM_AL_LIM: DataItem(
+            RPM_AL_LIM,
+            W3cXmlDataTypes.FLOAT,
+            MTPAccess.ReadAccess,
+            True,
+        ),
+    }
+
+    monitored_values: MonAnaDrvValues
+    monitor_static_thread: threading.Thread
+    monitor_dynamic_thread: threading.Thread
+    monitor_rpm_error_thread: threading.Thread
+    monitor_rpm_limit_high_thread: threading.Thread
+    monitor_rpm_limit_low_thread: threading.Thread
+
+    def __init__(
+        self,
+        tag_name,
+        tag_description,
+        rpm_min=0,
+        rpm_max=1000,
+        rpm_scl_min=0,
+        rpm_scl_max=1000,
+        rpm_unit=0,
+        rev_fbk_calc=True,
+        fwd_fbk_calc=True,
+        rpm_fbk_calc=True,
+        safe_pos=0,
+        fwd_en=True,
+        rev_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,
+        rpm_ah_en=True,
+        rpm_al_en=True,
+        rpm_ah_lim=900,
+        rpm_al_lim=50,
+    ):
+        super().__init__(
+            tag_name,
+            tag_description,
+            rpm_min,
+            rpm_max,
+            rpm_scl_min,
+            rpm_scl_max,
+            rpm_unit,
+            rev_fbk_calc,
+            fwd_fbk_calc,
+            rpm_fbk_calc,
+            safe_pos,
+            fwd_en,
+            rev_en,
+            perm_en,
+            intl_en,
+            prot_en,
+        )
+        self.mtpObjectType = (
+            "MTPDataObjectSUCLib/DataAssembly/ActiveElement/AnaDrv/MonAnaDrv"
+        )
+
+        self[MonAnaDrv.MON_EN] = mon_en
+        self[MonAnaDrv.MON_SAFE_POS] = mon_safe_pos
+        self[MonAnaDrv.MON_STAT_TI] = mon_stat_ti
+        self[MonAnaDrv.MON_DYN_TI] = mon_dyn_ti
+        self[MonAnaDrv.RPM_AH_EN] = rpm_ah_en
+        self[MonAnaDrv.RPM_AL_EN] = rpm_al_en
+        self[MonAnaDrv.RPM_AH_LIM] = rpm_ah_lim
+        self[MonAnaDrv.RPM_AL_LIM] = rpm_al_lim
+
+        self.monitored_values = MonAnaDrvValues(
+            self[MonAnaDrv.FWD_AUT],
+            self[MonAnaDrv.FWD_OP],
+            self[MonAnaDrv.REV_AUT],
+            self[MonAnaDrv.REV_OP],
+            self[MonAnaDrv.STOP_AUT],
+            self[MonAnaDrv.STOP_OP],
+            self[MonAnaDrv.RESET_AUT],
+            self[MonAnaDrv.RESET_OP],
+            self[MonAnaDrv.RPM_],
+        )
+        self.monitor_static_thread = None
+        self.monitor_dynamic_thread = None
+        self.monitor_rpm_error_thread = None
+        self.monitor_rpm_limit_high_thread = None
+        self.monitor_rpm_limit_low_thread = None
+
+    def compare_states_control_signals(self, monitor_time):
+
+        self.monitored_values.lock.acquire()
+        fwd_ctrl1 = self[MonAnaDrv.FWD_FBK]
+        rev_ctrl1 = self[MonAnaDrv.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_ctrl2 = self[MonAnaDrv.FWD_FBK]
+        rev_ctrl2 = self[MonAnaDrv.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_ctrl1 == fwd_ctrl2, rev_ctrl1 == rev_ctrl2]
+        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[self.MON_STAT_TI]
+            )
+
+            if not (all(states)) and all(control_signals):
+                self[self.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[self.MON_DYN_TI]
+            )
+
+            if all(states) and not (all(control_signals)):
+                self[self.MON_DYN_ERR] = True
+                logger.debug("Dynamic error set to True")
+                self._handle_monitored_error()
+
+        logger.debug("dynamic monitoring stopped")
+
+    def monitor_rpm_error(self):
+        while not (self.monitored_values.stop_event_lock.is_set()):
+            rpm_error = self.monitored_values.rpm - self[MonAnaDrv.RPM_FBK]
+            if rpm_error:
+                self[MonAnaDrv.RPM_ERR] = rpm_error
+                logger.debug(f"Rpm error set to {rpm_error}")
+                self._handle_monitored_error()
+
+            sleep(0.01)
+        logger.debug("rpm monitoring stopped")
+
+    def monitor_rpm_high_limit(self):
+        while not (self.monitored_values.stop_event_lock.is_set()):
+            self.monitored_values.lock.acquire()
+            high_limit_alarm = self[MonAnaDrv.RPM_FBK] > self[MonAnaDrv.RPM_AH_LIM]
+            self.monitored_values.lock.release()
+            if high_limit_alarm:
+                self[MonAnaDrv.RPM_AH_ACT] = True
+                logger.debug("Rpm limit high set to True")
+            sleep(0.01)
+        logger.debug("rpm high limit monitoring stopped")
+
+    def monitor_rpm_low_limit(self):
+        while not (self.monitored_values.stop_event_lock.is_set()):
+            self.monitored_values.lock.acquire()
+            low_limit_alarm = self[MonAnaDrv.RPM_FBK] < self[MonAnaDrv.RPM_AL_LIM]
+            self.monitored_values.lock.release()
+            if low_limit_alarm:
+                self[MonAnaDrv.RPM_AL_ACT] = True
+                logger.debug("Rpm limit low set to True")
+            sleep(0.01)
+        logger.debug("rpm low limit monitoring stopped")
+
+    def _handle_monitored_error(self):
+        logger.debug("set valve to safety position")
+        self._go_save_pos()
+        self[MonAnaDrv.SAFE_POS_ACT] = True
+
+    def start_monitor(self):
+        if self[MonAnaDrv.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")
+
+            self.monitor_rpm_error_thread = threading.Thread(
+                target=self.monitor_rpm_error, daemon=True
+            )
+            self.monitor_rpm_error_thread.start()
+            logger.debug("rpm error monitoring start")
+
+        if self[MonAnaDrv.RPM_AH_EN]:
+            self.monitor_rpm_limit_high_thread = threading.Thread(
+                target=self.monitor_rpm_high_limit, daemon=True
+            )
+            self.monitor_rpm_limit_high_thread.start()
+            logger.debug("rpm high limit monitoring start")
+
+        if self[MonAnaDrv.RPM_AL_EN]:
+            self.monitor_rpm_limit_low_thread = threading.Thread(
+                target=self.monitor_rpm_low_limit, daemon=True
+            )
+            self.monitor_rpm_limit_low_thread.start()
+            logger.debug("rpm low limit monitoring start")
+
+    def set_fwd_op(self, value: bool):
+        logger.debug("FwdOp set to {value}")
+        if self.op_mode[OM.STATE_OP_ACT] and self[AnaDrv.FWD_EN]:
+            if value and self._run_allowed():
+                self._run_fwd_drv()
+                if self[MonAnaDrv.MON_EN]:
+                    self.monitored_values.lock.acquire()
+                    self.monitored_values.fwd_op = value
+                    self.monitored_values.lock.release()
+                self[MonAnaDrv.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[AnaDrv.REV_EN]:
+            if value and self._run_allowed():
+
+                if self[MonAnaDrv.MON_EN]:
+                    self.monitored_values.lock.acquire()
+                    self.monitored_values.rev_op = value
+                    self.monitored_values.lock.release()
+                self._run_rev_drv()
+                self[MonAnaDrv.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[MonAnaDrv.MON_EN]:
+                self.monitored_values.lock.acquire()
+                self.monitored_values.stop_op = value
+                self.monitored_values.lock.release()
+            self._stop_drv()
+            self[MonAnaDrv.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[MonAnaDrv.MON_EN]:
+                self.monitored_values.lock.acquire()
+                self.monitored_values.reset_op = value
+                self.monitored_values.lock.release()
+            self._reset_drv()
+            self[MonAnaDrv.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[AnaDrv.FWD_EN]:
+            if value and self._run_allowed():
+                if self[MonAnaDrv.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[AnaDrv.REV_EN]:
+            if value and self._run_allowed():
+                if self[MonAnaDrv.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[MonAnaDrv.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[MonAnaDrv.MON_EN]:
+                self.monitored_values.lock.acquire()
+                self.monitored_values.reset_aut = value
+                self.monitored_values.lock.release()
+            self._reset_drv()
+
+    def _set_rpm(self, value: float):
+        if self.valid_value(value):
+            self[MonAnaDrv.RPM_] = value
+            if self[MonAnaDrv.MON_EN]:
+                self.monitored_values.lock.acquire()
+                self.monitored_values.rpm = value
+                self.monitored_values.lock.release()
+            logger.debug(f"Rpm set to {value}")
+
+            if self[MonAnaDrv.RPM_FBK_CALC]:
+                if self[MonAnaDrv.MON_EN]:
+                    self.monitored_values.lock.acquire()
+                    self[MonAnaDrv.RPM_FBK] = value
+                    self.monitored_values.lock.release()
+                else:
+                    self[MonAnaDrv.RPM_FBK] = value
+
+        else:
+            logger.debug(f"Rpm cannot be set to {value} (out of range)")
+
+    def set_stop_monitor(self):
+        self.monitored_values.stop_event_lock.set()