MTPPy2.0 0.1.5__py3-none-any.whl

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

@@ -0,0 +1,365 @@
+"""Implementation of BinDrv.
+
+This module implements the BinDrv class which represents a binary drive
+element in accordance with the MTP 2.0 specification.
+"""
+
+__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 BinDrv(ActiveElement):
+    """Binary Drive (BinDrv).
+
+    Implements a binary drive element according to MTP 2.0 specification.
+    """
+
+    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"
+    REV_FBK_CALC = "RevFbkCalc"
+    REV_FBK = "RevFbk"
+    FWD_FBK_CALC = "FwdFbkCalc"
+    FWD_FBK = "FwdFbk"
+    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, 0),
+        SAFE_POS_ACT: DataItem(
+            SAFE_POS_ACT, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, False
+        ),
+        FWD_EN: DataItem(FWD_EN, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, True),
+        REV_EN: DataItem(REV_EN, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, False),
+        STOP_OP: DataItem(
+            STOP_OP, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadWriteAccess, 0
+        ),
+        FWD_OP: DataItem(FWD_OP, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadWriteAccess, 0),
+        REV_OP: DataItem(REV_OP, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadWriteAccess, 0),
+        STOP_AUT: DataItem(STOP_AUT, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, 0),
+        FWD_AUT: DataItem(FWD_AUT, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, 0),
+        REV_AUT: DataItem(REV_AUT, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, 0),
+        FWD_CTRL: DataItem(FWD_CTRL, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, 0),
+        REV_CTRL: DataItem(REV_CTRL, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, 0),
+        REV_FBK_CALC: DataItem(
+            REV_FBK_CALC, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, True
+        ),
+        REV_FBK: DataItem(
+            REV_FBK, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, False
+        ),
+        FWD_FBK_CALC: DataItem(
+            FWD_FBK_CALC, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, True
+        ),
+        FWD_FBK: DataItem(
+            FWD_FBK, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, False
+        ),
+        TRIP_: DataItem(TRIP_, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, True),
+        PERM_EN: DataItem(
+            PERM_EN, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, False
+        ),
+        PERMIT_: DataItem(PERMIT_, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, 0),
+        INTL_EN: DataItem(
+            INTL_EN, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, False
+        ),
+        INTERLOCK_: DataItem(
+            INTERLOCK_, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, 0
+        ),
+        PROT_EN: DataItem(
+            PROT_EN, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, False
+        ),
+        PROTECT_: DataItem(PROTECT_, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, 0),
+        RESET_OP: DataItem(
+            RESET_OP, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadWriteAccess, 0
+        ),
+        RESET_AUT: DataItem(
+            RESET_AUT, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, 0
+        ),
+    }
+
+    op_mode: OperationMode
+    src_mode: SourceMode
+
+    rev_fbk_calc: bool
+    fwd_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 = "",
+        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,
+    ) -> None:
+        """Initialize the BinDrv element.
+
+        Args:
+            tag_name: Name of the tag.
+            tag_description: Description of the tag.
+            rev_fbk_calc: Reverse feedback calculation flag.
+            fwd_fbk_calc: Forward feedback calculation flag.
+            safe_pos: Safe position value.
+            fwd_en: Forward enable flag.
+            rev_en: Reverse enable flag.
+            perm_en: Permission enable flag.
+            intl_en: Interlock enable flag.
+            prot_en: Protection enable flag.
+        """
+        super().__init__(tag_name, tag_description)
+        self.mtpObjectType = "MTPDataObjectSUCLib/DataAssembly/ActiveElement/BinDrv"
+
+        self.op_mode = OperationMode()
+        self.src_mode = SourceMode()
+
+        self.rev_fbk_calc = rev_fbk_calc
+        self.fwd_fbk_calc = fwd_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
+
+        # Set initial values for data items
+        self[BinDrv.SAFE_POS] = safe_pos
+        self[BinDrv.SAFE_POS_ACT] = True
+        self[BinDrv.FWD_EN] = fwd_en
+        self[BinDrv.REV_EN] = rev_en
+        self[BinDrv.STOP_AUT] = 0
+        self[BinDrv.FWD_AUT] = 0
+        self[BinDrv.REV_AUT] = 0
+        self[BinDrv.FWD_CTRL] = 0
+        self[BinDrv.REV_CTRL] = 0
+        self[BinDrv.REV_FBK_CALC] = rev_fbk_calc
+        self[BinDrv.REV_FBK] = False
+        self[BinDrv.FWD_FBK_CALC] = fwd_fbk_calc
+        self[BinDrv.FWD_FBK] = False
+        self[BinDrv.TRIP_] = True
+        self[BinDrv.PERM_EN] = perm_en
+        self[BinDrv.PERMIT_] = 0
+        self[BinDrv.INTL_EN] = intl_en
+        self[BinDrv.INTERLOCK_] = 0
+        self[BinDrv.PROT_EN] = prot_en
+        self[BinDrv.PROTECT_] = 0
+        self[BinDrv.RESET_OP] = 0
+        self[BinDrv.RESET_AUT] = 0
+
+        # Setup callbacks after initialization
+        self.get_item(BinDrv.STOP_OP).ext_wrt_cb = self.set_stop_op
+        self.get_item(BinDrv.FWD_OP).ext_wrt_cb = self.set_fwd_op
+        self.get_item(BinDrv.REV_OP).ext_wrt_cb = self.set_rev_op
+        self.get_item(BinDrv.RESET_OP).ext_wrt_cb = self.set_reset_op
+
+    def _expect_save_pos(self) -> None:
+        """Check if safe position is expected and update accordingly."""
+        if self._run_allowed():
+            self[BinDrv.SAFE_POS_ACT] = False
+        else:
+            self._go_safe_pos()
+            self[BinDrv.SAFE_POS_ACT] = True
+
+    def _go_safe_pos(self) -> None:
+        """Move to safe position."""
+        if self[BinDrv.SAFE_POS]:
+            self._run_fwd_drv()
+        else:
+            self._stop_drv()
+
+    def _run_allowed(self) -> bool:
+        """Check if driving is allowed."""
+        if self[BinDrv.PERM_EN] and self[BinDrv.PERMIT_] == 0:
+            logger.debug("Permission is not given")
+            return False
+        if self[BinDrv.INTL_EN] and self[BinDrv.INTERLOCK_] == 0:
+            logger.debug("Interlock is active")
+            return False
+        if self[BinDrv.PROT_EN] and self[BinDrv.PROTECT_] == 0:
+            logger.debug("Protect is active")
+            return False
+        if not self[BinDrv.TRIP_]:
+            logger.debug("Drive protection triggered")
+            return False
+        return True
+
+    def set_fwd_op(self, value: bool) -> None:
+        """Set forward operation command."""
+        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[BinDrv.FWD_OP] = False
+
+    def set_rev_op(self, value: bool) -> None:
+        """Set reverse operation command."""
+        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[BinDrv.REV_OP] = False
+
+    def set_stop_op(self, value: bool) -> None:
+        """Set stop operation command."""
+        logger.debug(f"StopOp set to {value}")
+        if self.op_mode[OperationMode.STATE_OP_ACT] and value:
+            self._stop_drv()
+            self[BinDrv.STOP_OP] = False
+
+    def set_reset_op(self, value: bool) -> None:
+        """Set reset operation command."""
+        logger.debug(f"ResetOp set to {value}")
+        if self.op_mode[OperationMode.STATE_OP_ACT] and value:
+            self._reset_drv()
+            self[BinDrv.RESET_OP] = False
+
+    def set_fwd_aut(self, value: bool) -> None:
+        """Set forward automatic command."""
+        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) -> None:
+        """Set reverse automatic command."""
+        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) -> None:
+        """Set stop automatic command."""
+        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) -> None:
+        """Set reset automatic command."""
+        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[BinDrv.FWD_CTRL] = True
+        if self[BinDrv.FWD_FBK_CALC]:
+            self[BinDrv.FWD_FBK] = True
+        self[BinDrv.REV_CTRL] = False
+        if self[BinDrv.REV_FBK_CALC]:
+            self[BinDrv.REV_FBK] = False
+
+    def _run_rev_drv(self) -> None:
+        """Run the driver in reverse."""
+        self[BinDrv.FWD_CTRL] = False
+        if self[BinDrv.FWD_FBK_CALC]:
+            self[BinDrv.FWD_FBK] = False
+        self[BinDrv.REV_CTRL] = True
+        if self[BinDrv.REV_FBK_CALC]:
+            self[BinDrv.REV_FBK] = True
+
+    def _stop_drv(self) -> None:
+        """Stop the driver."""
+        self[BinDrv.FWD_CTRL] = False
+        if self[BinDrv.FWD_FBK_CALC]:
+            self[BinDrv.FWD_FBK] = False
+        self[BinDrv.REV_CTRL] = False
+        if self[BinDrv.REV_FBK_CALC]:
+            self[BinDrv.REV_FBK] = False
+
+    def _reset_drv(self) -> None:
+        """Reset the driver."""
+        if self[BinDrv.PROT_EN] and self[BinDrv.PROTECT_] == 0:
+            self[BinDrv.PROTECT_] = True
+            self[BinDrv.SAFE_POS_ACT] = False
+        self._stop_drv()
+
+    def set_rev_fbk(self, value: bool) -> None:
+        """Set reverse feedback."""
+        if not self[BinDrv.REV_FBK_CALC]:
+            self[BinDrv.REV_FBK] = value
+            logger.debug(f"RevFbk set to {value}")
+
+    def set_fwd_fbk(self, value: bool) -> None:
+        """Set forward feedback."""
+        if not self[BinDrv.FWD_FBK_CALC]:
+            self[BinDrv.FWD_FBK] = value
+            logger.debug(f"FwdFbk set to {value}")
+
+    def set_trip(self, value: bool) -> None:
+        """Set trip status."""
+        self[BinDrv.TRIP_] = value
+        logger.debug(f"Trip set to {value}")
+        self._expect_save_pos()
+
+    def set_permit(self, value: bool) -> None:
+        """Set permit status."""
+        if not self[BinDrv.PERM_EN]:
+            value = True
+        self[BinDrv.PERMIT_] = value
+        logger.debug(f"Permit set to {value}")
+        self._expect_save_pos()
+        # self[self.SAFE_POS_ACT] = False
+
+    def set_interlock(self, value: bool) -> None:
+        """Set interlock status."""
+        if not self[BinDrv.INTL_EN]:
+            value = True
+        self[BinDrv.INTERLOCK_] = value
+        logger.debug(f"Interlock set to {value}")
+        self._expect_save_pos()
+
+    def set_protect(self, value: bool) -> None:
+        """Set protection status."""
+        if not self[BinDrv.PROT_EN]:
+            value = True
+        if value:
+            self._reset_drv()
+        self[BinDrv.PROTECT_] = value
+        logger.debug(f"Protect set to {value}")
+        self._expect_save_pos()
+
+    def get_fwd_fbk(self) -> bool:
+        """Get forward feedback status."""
+        return self[BinDrv.FWD_FBK]
+
+    def get_rev_fbk(self) -> bool:
+        """Get reverse feedback status."""
+        return self[BinDrv.REV_FBK]