MTPPy2.0 0.1.5__py3-none-any.whl

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

@@ -0,0 +1,446 @@
+"""Implementation of AnaDrv."""
+
+__copyright__ = (
+    "Copyright (c) 2026 Dresden University of Technology, Process-to-Order Group"
+)
+__license__ = "MIT"
+from typing import ClassVar
+
+from mtppy.utils.logging import logger
+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.active_element import ActiveElement
+from mtppy.part3.data_assembly_set.base_functions.operation_mode import OperationMode
+from mtppy.part3.data_assembly_set.base_functions.source_mode import SourceMode
+
+
+class AnaDrv(ActiveElement):
+    # DataItem constant definitions
+    SAFE_POS = "SafePos"
+    SAFE_POS_ACT = "SafePosAct"
+    FWD_EN = "FwdEn"
+    REV_EN = "RevEn"
+    STOP_OP = "StopOp"
+    FWD_OP = "FwdOp"
+    REV_OP = "RevOp"
+    STOP_AUT = "StopAut"
+    FWD_AUT = "FwdAut"
+    REV_AUT = "RevAut"
+    FWD_CTRL = "FwdCtrl"
+    REV_CTRL = "RevCtrl"
+    RPM_SCL_MIN = "RpmSclMin"
+    RPM_SCL_MAX = "RpmSclMax"
+    RPM_UNIT = "RpmUnit"
+    RPM_MIN = "RpmMin"
+    RPM_MAX = "RpmMax"
+    RPM_INT = "RpmInt"
+    RPM_MAN = "RpmMan"
+    RPM_ = "Rpm"
+    RPM_RBK = "RpmRbk"
+    REV_FBK_CALC = "RevFbkCalc"
+    REV_FBK = "RevFbk"
+    FWD_FBK_CALC = "FwdFbkCalc"
+    FWD_FBK = "FwdFbk"
+    RPM_FBK_CALC = "RpmFbkCalc"
+    RPM_FBK = "RpmFbk"
+    TRIP_ = "Trip"
+    PERM_EN = "PermEn"
+    PERMIT_ = "Permit"
+    INTL_EN = "IntlEn"
+    INTERLOCK_ = "Interlock"
+    PROT_EN = "ProtEn"
+    PROTECT_ = "Protect"
+    RESET_OP = "ResetOp"
+    RESET_AUT = "ResetAut"
+
+    # Class-level data items dictionary
+    CLASS_DATA_ITEMS: ClassVar = {
+        SAFE_POS: DataItem(
+            SAFE_POS, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, None
+        ),
+        SAFE_POS_ACT: DataItem(
+            SAFE_POS_ACT, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, None
+        ),
+        FWD_EN: DataItem(FWD_EN, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, None),
+        REV_EN: DataItem(REV_EN, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, None),
+        STOP_OP: DataItem(
+            STOP_OP, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadWriteAccess, None
+        ),
+        FWD_OP: DataItem(
+            FWD_OP, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadWriteAccess, None
+        ),
+        REV_OP: DataItem(
+            REV_OP, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadWriteAccess, None
+        ),
+        STOP_AUT: DataItem(
+            STOP_AUT, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, None
+        ),
+        FWD_AUT: DataItem(FWD_AUT, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, None),
+        REV_AUT: DataItem(REV_AUT, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, None),
+        FWD_CTRL: DataItem(
+            FWD_CTRL, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, None
+        ),
+        REV_CTRL: DataItem(
+            REV_CTRL, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, None
+        ),
+        RPM_SCL_MIN: DataItem(
+            RPM_SCL_MIN, W3cXmlDataTypes.FLOAT, MTPAccess.ReadAccess, None
+        ),
+        RPM_SCL_MAX: DataItem(
+            RPM_SCL_MAX, W3cXmlDataTypes.FLOAT, MTPAccess.ReadAccess, None
+        ),
+        RPM_UNIT: DataItem(RPM_UNIT, W3cXmlDataTypes.SHORT, MTPAccess.ReadAccess, None),
+        RPM_MIN: DataItem(RPM_MIN, W3cXmlDataTypes.FLOAT, MTPAccess.ReadAccess, None),
+        RPM_MAX: DataItem(RPM_MAX, W3cXmlDataTypes.FLOAT, MTPAccess.ReadAccess, None),
+        RPM_INT: DataItem(RPM_INT, W3cXmlDataTypes.FLOAT, MTPAccess.ReadAccess, None),
+        RPM_MAN: DataItem(RPM_MAN, W3cXmlDataTypes.FLOAT, MTPAccess.ReadAccess, None),
+        RPM_: DataItem(RPM_, W3cXmlDataTypes.FLOAT, MTPAccess.ReadAccess, None),
+        RPM_RBK: DataItem(RPM_RBK, W3cXmlDataTypes.FLOAT, MTPAccess.ReadAccess, None),
+        REV_FBK_CALC: DataItem(
+            REV_FBK_CALC, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, None
+        ),
+        REV_FBK: DataItem(REV_FBK, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, None),
+        FWD_FBK_CALC: DataItem(
+            FWD_FBK_CALC, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, None
+        ),
+        FWD_FBK: DataItem(FWD_FBK, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, None),
+        RPM_FBK_CALC: DataItem(
+            RPM_FBK_CALC, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, None
+        ),
+        RPM_FBK: DataItem(RPM_FBK, W3cXmlDataTypes.FLOAT, MTPAccess.ReadAccess, None),
+        TRIP_: DataItem(TRIP_, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, None),
+        PERM_EN: DataItem(PERM_EN, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, None),
+        PERMIT_: DataItem(PERMIT_, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, None),
+        INTL_EN: DataItem(INTL_EN, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, None),
+        INTERLOCK_: DataItem(
+            INTERLOCK_, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, None
+        ),
+        PROT_EN: DataItem(PROT_EN, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, None),
+        PROTECT_: DataItem(
+            PROTECT_, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, None
+        ),
+        RESET_OP: DataItem(
+            RESET_OP, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadWriteAccess, None
+        ),
+        RESET_AUT: DataItem(
+            RESET_AUT, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, None
+        ),
+    }
+
+    op_mode: OperationMode
+    src_mode: SourceMode
+
+    rpm_min: float
+    rpm_max: float
+    rpm_scl_min: float
+    rpm_scl_max: float
+    rpm_unit: int
+    rev_fbk_calc: bool
+    fwd_fbk_calc: bool
+    rpm_fbk_calc: bool
+
+    safe_pos: int
+    fwd_en: bool
+    rev_en: bool
+    perm_en: bool
+    intl_en: bool
+    prot_en: bool
+
+    def __init__(
+        self,
+        tag_name: str,
+        tag_description: str = "",
+        rpm_min: float = 0,
+        rpm_max: float = 1000,
+        rpm_scl_min: float = 0,
+        rpm_scl_max: float = 1000,
+        rpm_unit: int = 0,
+        rev_fbk_calc: bool = True,
+        fwd_fbk_calc: bool = True,
+        rpm_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,
+    ):
+        """
+        Analog Drive (AnaDrv).
+        """
+        super().__init__(tag_name, tag_description)
+        self.mtpObjectType = "MTPDataObjectSUCLib/DataAssembly/ActiveElement/AnaDrv"
+
+        self.op_mode = OperationMode()
+        self.src_mode = SourceMode()
+
+        self.rpm_min = rpm_min
+        self.rpm_max = rpm_max
+        self.rpm_scl_min = rpm_scl_min
+        self.rpm_scl_max = rpm_scl_max
+        self.rpm_unit = rpm_unit
+        self.rev_fbk_calc = rev_fbk_calc
+        self.fwd_fbk_calc = fwd_fbk_calc
+        self.rpm_fbk_calc = rpm_fbk_calc
+
+        self.safe_pos = safe_pos
+        self.fwd_en = fwd_en
+        self.rev_en = rev_en
+        self.perm_en = perm_en
+        self.intl_en = intl_en
+        self.prot_en = prot_en
+
+        # Initialize data items with dynamic values (using class-defined data items)
+        self[AnaDrv.SAFE_POS] = safe_pos
+        self[AnaDrv.SAFE_POS_ACT] = True
+        self[AnaDrv.FWD_EN] = fwd_en
+        self[AnaDrv.REV_EN] = rev_en
+        self[AnaDrv.STOP_OP] = 0
+        self[AnaDrv.FWD_OP] = 0
+        self[AnaDrv.REV_OP] = 0
+        self[AnaDrv.STOP_AUT] = 0
+        self[AnaDrv.FWD_AUT] = 0
+        self[AnaDrv.REV_AUT] = 0
+        self[AnaDrv.FWD_CTRL] = 0
+        self[AnaDrv.REV_CTRL] = 0
+        self[AnaDrv.RPM_SCL_MIN] = self.rpm_scl_min
+        self[AnaDrv.RPM_SCL_MAX] = self.rpm_scl_max
+        self[AnaDrv.RPM_UNIT] = self.rpm_unit
+        self[AnaDrv.RPM_MIN] = self.rpm_min
+        self[AnaDrv.RPM_MAX] = self.rpm_max
+        self[AnaDrv.RPM_INT] = 0
+        self[AnaDrv.RPM_MAN] = 0
+        self[AnaDrv.RPM_] = rpm_min
+        self[AnaDrv.RPM_RBK] = rpm_min
+        self[AnaDrv.REV_FBK_CALC] = rev_fbk_calc
+        self[AnaDrv.REV_FBK] = False
+        self[AnaDrv.FWD_FBK_CALC] = fwd_fbk_calc
+        self[AnaDrv.FWD_FBK] = False
+        self[AnaDrv.RPM_FBK_CALC] = rpm_fbk_calc
+        self[AnaDrv.RPM_FBK] = rpm_min
+        self[AnaDrv.TRIP_] = True
+        self[AnaDrv.PERM_EN] = perm_en
+        self[AnaDrv.PERMIT_] = 0
+        self[AnaDrv.INTL_EN] = intl_en
+        self[AnaDrv.INTERLOCK_] = 0
+        self[AnaDrv.PROT_EN] = prot_en
+        self[AnaDrv.PROTECT_] = 0
+        self[AnaDrv.RESET_OP] = 0
+        self[AnaDrv.RESET_AUT] = 0
+
+        # Set callbacks for writable items
+        self.get_item(AnaDrv.STOP_OP).ext_wrt_cb = self.set_stop_op
+        self.get_item(AnaDrv.FWD_OP).ext_wrt_cb = self.set_fwd_op
+        self.get_item(AnaDrv.REV_OP).ext_wrt_cb = self.set_rev_op
+        self.get_item(AnaDrv.RPM_INT).ext_wrt_cb = self.set_rpm_int
+        self.get_item(AnaDrv.RPM_MAN).ext_wrt_cb = self.set_rpm_man
+        self.get_item(AnaDrv.RESET_OP).ext_wrt_cb = self.set_reset_op
+
+    def _expect_save_pos(self):
+        if self._run_allowed():
+            self[AnaDrv.SAFE_POS_ACT] = False
+        else:
+            self._go_save_pos()
+            self[AnaDrv.SAFE_POS_ACT] = True
+
+    def _go_save_pos(self):
+        if self[AnaDrv.SAFE_POS]:
+            self._run_fwd_drv()
+        else:
+            self._stop_drv()
+
+    def _run_allowed(self):
+        if self[AnaDrv.PERM_EN] and self[AnaDrv.PERMIT_] == 0:
+            logger.debug("Permission is not given")
+            return False
+        if self[AnaDrv.INTL_EN] and self[AnaDrv.INTERLOCK_] == 0:
+            logger.debug("Interlock is active")
+            return False
+        if self[AnaDrv.PROT_EN] and self[AnaDrv.PROTECT_] == 0:
+            logger.debug("Protect is active")
+            return False
+        if not self[AnaDrv.TRIP_]:
+            logger.debug("Drive protection triggered")
+            return False
+        return True
+
+    def set_fwd_op(self, value: bool):
+        logger.debug(f"FwdOp set to {value}")
+        if self.op_mode[OperationMode.STATE_OP_ACT] and self.fwd_en:
+            if value and self._run_allowed():
+                self._run_fwd_drv()
+                self[AnaDrv.FWD_OP] = False
+
+    def set_rev_op(self, value: bool):
+        logger.debug(f"RevOp set to {value}")
+        if self.op_mode[OperationMode.STATE_OP_ACT] and self.rev_en:
+            if value and self._run_allowed():
+                self._run_rev_drv()
+                self[AnaDrv.REV_OP] = False
+
+    def set_stop_op(self, value: bool):
+        logger.debug(f"StopOp set to {value}")
+        if self.op_mode[OperationMode.STATE_OP_ACT] and value:
+            self._stop_drv()
+            self[AnaDrv.STOP_OP] = False
+
+    def set_reset_op(self, value: bool):
+        logger.debug(f"ResetOp set to {value}")
+        if self.op_mode[OperationMode.STATE_OP_ACT] and value:
+            self._reset_drv()
+            self[AnaDrv.RESET_OP] = False
+
+    def set_fwd_aut(self, value: bool):
+        logger.debug(f"FwdAut set to {value}")
+        if self.op_mode[OperationMode.STATE_AUT_ACT] and self.fwd_en:
+            if value and self._run_allowed():
+                self._run_fwd_drv()
+
+    def set_rev_aut(self, value: bool):
+        logger.debug(f"RevAut set to {value}")
+        if self.op_mode[OperationMode.STATE_AUT_ACT] and self.rev_en:
+            if value and self._run_allowed():
+                self._run_rev_drv()
+
+    def set_stop_aut(self, value: bool):
+        logger.debug(f"StopAut set to {value}")
+        if self.op_mode[OperationMode.STATE_AUT_ACT] and value:
+            self._stop_drv()
+
+    def set_reset_aut(self, value: bool):
+        logger.debug(f"ResetAut set to {value}")
+        if self.op_mode[OperationMode.STATE_AUT_ACT] and value:
+            self._reset_drv()
+
+    def _run_fwd_drv(self) -> None:
+        """Run the driver forward."""
+        self[AnaDrv.FWD_CTRL] = True
+        if self[AnaDrv.FWD_FBK_CALC]:
+            self[AnaDrv.FWD_FBK] = True
+        self[AnaDrv.REV_CTRL] = False
+        if self[AnaDrv.REV_FBK_CALC]:
+            self[AnaDrv.REV_FBK] = False
+
+    def _run_rev_drv(self):
+        self[AnaDrv.FWD_CTRL] = False
+        if self[AnaDrv.FWD_FBK_CALC]:
+            self[AnaDrv.FWD_FBK] = False
+        self[AnaDrv.REV_CTRL] = True
+        if self[AnaDrv.REV_FBK_CALC]:
+            self[AnaDrv.REV_FBK] = True
+
+    def _stop_drv(self):
+        self[AnaDrv.FWD_CTRL] = False
+        if self[AnaDrv.FWD_FBK_CALC]:
+            self[AnaDrv.FWD_FBK] = False
+        self[AnaDrv.REV_CTRL] = False
+        if self[AnaDrv.REV_FBK_CALC]:
+            self[AnaDrv.REV_FBK] = False
+
+    def _reset_drv(self):
+        if self[AnaDrv.PROT_EN] and self[AnaDrv.PROTECT_] == 0:
+            self[AnaDrv.PROTECT_] = True
+            self[AnaDrv.SAFE_POS_ACT] = False
+        self._stop_drv()
+
+    def set_rpm_int(self, value: float):
+        logger.debug(f"RpmInt set to {value}")
+        if (
+            self.src_mode[SourceMode.SRC_INT_ACT]
+            and self.op_mode[OperationMode.STATE_AUT_ACT]
+        ):
+            self._set_rpm(value)
+
+    def set_rpm_man(self, value: float):
+        logger.debug(f"RpmIntMan set to {value}")
+
+        if self.op_mode[OperationMode.STATE_OP_ACT]:
+            self._set_rpm(value)
+
+    def valid_value(self, value: float):
+        if value < self.rpm_min or value > self.rpm_max:
+            return False
+        else:
+            return True
+
+    def _correct_value(self, value: float):
+        if value > self.rpm_max:
+            return self.rpm_max
+        elif value < self.rpm_min:
+            return self.rpm_min
+        else:
+            return value
+
+    def _set_rpm(self, value: float):
+        if self.valid_value(value):
+            self[AnaDrv.RPM_] = value
+            logger.debug(f"Rpm set to {value}")
+            if self[AnaDrv.RPM_FBK_CALC]:
+                self[AnaDrv.RPM_FBK] = value
+        else:
+            logger.debug(f"Rpm cannot be set to {value} (out of range)")
+
+    def set_rpm_rbk(self, value: float):
+        corr_value = self._correct_value(value)
+        self[AnaDrv.RPM_RBK] = corr_value
+        logger.debug(f"RpmRbk set to {corr_value}")
+
+    def set_rpm_fbk(self, value: float):
+        if not self[AnaDrv.RPM_FBK_CALC]:
+            corr_value = self._correct_value(value)
+            self[AnaDrv.RPM_FBK] = corr_value
+            logger.debug(f"RpmFbk set to {corr_value}")
+
+    def set_rev_fbk(self, value: bool):
+        if not self[AnaDrv.REV_FBK_CALC]:
+            self[AnaDrv.REV_FBK] = value
+            logger.debug(f"RevFbk set to {value}")
+
+    def set_fwd_fbk(self, value: bool):
+        if not self[AnaDrv.FWD_FBK_CALC]:
+            self[AnaDrv.FWD_FBK] = value
+            logger.debug(f"FwdFbk set to {value}")
+
+    def set_trip(self, value: bool):
+        self[AnaDrv.TRIP_] = value
+        logger.debug(f"Trip set to {value}")
+        self._expect_save_pos()
+
+    def set_permit(self, value: bool):
+        if not self[AnaDrv.PERM_EN]:
+            value = True
+        self[AnaDrv.PERMIT_] = value
+        logger.debug(f"Permit set to {value}")
+        self._expect_save_pos()
+
+    def set_interlock(self, value: bool):
+        if not self[AnaDrv.INTL_EN]:
+            value = True
+        self[AnaDrv.INTERLOCK_] = value
+        logger.debug(f"Interlock set to {value}")
+        self._expect_save_pos()
+
+    def set_protect(self, value: bool):
+        if not self[AnaDrv.PROT_EN]:
+            value = True
+        if value:
+            self._reset_drv()
+        self[AnaDrv.PROTECT_] = value
+        logger.debug(f"Protect set to {value}")
+        self._expect_save_pos()
+
+    def get_rpm(self):
+        return self[AnaDrv.RPM_]
+
+    def get_rpm_rbk(self):
+        return self[AnaDrv.RPM_RBK]
+
+    def get_rpm_fbk(self):
+        return self[AnaDrv.RPM_FBK]
+
+    def get_fwd_fbk(self):
+        return self[AnaDrv.FWD_FBK]
+
+    def get_rev_fbk(self):
+        return self[AnaDrv.REV_FBK]