MTPPy2.0 0.1.5__py3-none-any.whl

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

@@ -0,0 +1,402 @@
+"""Implementation of AnaVlv."""
+
+__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 AnaVlv(ActiveElement):
+    # DataItem constant definitions
+    SAFE_POS = "SafePos"
+    SAFE_POS_EN = "SafePosEn"
+    SAFE_POS_ACT = "SafePosAct"
+    OPEN_AUT = "OpenAut"
+    CLOSE_AUT = "CloseAut"
+    OPEN_OP = "OpenOp"
+    CLOSE_OP = "CloseOp"
+    OPEN_ACT = "OpenAct"
+    CLOSE_ACT = "CloseAct"
+    POS_SCL_MIN = "PosSclMin"
+    POS_SCL_MAX = "PosSclMax"
+    POS_UNIT = "PosUnit"
+    POS_MIN = "PosMin"
+    POS_MAX = "PosMax"
+    POS_INT = "PosInt"
+    POS_MAN = "PosMan"
+    POS_RBK = "PosRbk"
+    POS_ = "Pos"
+    OPEN_FBK_CALC = "OpenFbkCalc"
+    OPEN_FBK = "OpenFbk"
+    CLOSE_FBK_CALC = "CloseFbkCalc"
+    CLOSE_FBK = "CloseFbk"
+    POS_FBK_CALC = "PosFbkCalc"
+    POS_FBK = "PosFbk"
+    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_EN: DataItem(
+            SAFE_POS_EN, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, None
+        ),
+        SAFE_POS_ACT: DataItem(
+            SAFE_POS_ACT, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, None
+        ),
+        OPEN_AUT: DataItem(
+            OPEN_AUT, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, None
+        ),
+        CLOSE_AUT: DataItem(
+            CLOSE_AUT, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, None
+        ),
+        OPEN_OP: DataItem(OPEN_OP, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, None),
+        CLOSE_OP: DataItem(
+            CLOSE_OP, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, None
+        ),
+        OPEN_ACT: DataItem(
+            OPEN_ACT, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, None
+        ),
+        CLOSE_ACT: DataItem(
+            CLOSE_ACT, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, None
+        ),
+        POS_SCL_MIN: DataItem(
+            POS_SCL_MIN, W3cXmlDataTypes.FLOAT, MTPAccess.ReadAccess, None
+        ),
+        POS_SCL_MAX: DataItem(
+            POS_SCL_MAX, W3cXmlDataTypes.FLOAT, MTPAccess.ReadAccess, None
+        ),
+        POS_UNIT: DataItem(POS_UNIT, W3cXmlDataTypes.SHORT, MTPAccess.ReadAccess, None),
+        POS_MIN: DataItem(POS_MIN, W3cXmlDataTypes.FLOAT, MTPAccess.ReadAccess, None),
+        POS_MAX: DataItem(POS_MAX, W3cXmlDataTypes.FLOAT, MTPAccess.ReadAccess, None),
+        POS_INT: DataItem(POS_INT, W3cXmlDataTypes.FLOAT, MTPAccess.ReadAccess, None),
+        POS_MAN: DataItem(
+            POS_MAN, W3cXmlDataTypes.FLOAT, MTPAccess.ReadWriteAccess, None
+        ),
+        POS_RBK: DataItem(POS_RBK, W3cXmlDataTypes.FLOAT, MTPAccess.ReadAccess, None),
+        POS_: DataItem(POS_, W3cXmlDataTypes.FLOAT, MTPAccess.ReadAccess, None),
+        OPEN_FBK_CALC: DataItem(
+            OPEN_FBK_CALC, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, None
+        ),
+        OPEN_FBK: DataItem(
+            OPEN_FBK, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, None
+        ),
+        CLOSE_FBK_CALC: DataItem(
+            CLOSE_FBK_CALC, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, None
+        ),
+        CLOSE_FBK: DataItem(
+            CLOSE_FBK, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, None
+        ),
+        POS_FBK_CALC: DataItem(
+            POS_FBK_CALC, W3cXmlDataTypes.BOOLEAN, MTPAccess.ReadAccess, None
+        ),
+        POS_FBK: DataItem(POS_FBK, W3cXmlDataTypes.FLOAT, 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
+
+    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,
+    ):
+        """
+        Analog Valve (AnaVlv).
+        """
+        super().__init__(tag_name, tag_description)
+        self.mtpObjectType = "MTPDataObjectSUCLib/DataAssembly/ActiveElement/AnaVlv"
+
+        self.op_mode = OperationMode()
+        self.src_mode = SourceMode()
+
+        # Initialize data items with dynamic values (using class-defined data items)
+        self[AnaVlv.SAFE_POS] = safe_pos
+        self[AnaVlv.SAFE_POS_EN] = safe_pos_en
+        self[AnaVlv.SAFE_POS_ACT] = False
+        self[AnaVlv.OPEN_AUT] = 0
+        self[AnaVlv.CLOSE_AUT] = 0
+        self[AnaVlv.OPEN_OP] = 0
+        self[AnaVlv.CLOSE_OP] = 0
+        self[AnaVlv.OPEN_ACT] = 0
+        self[AnaVlv.CLOSE_ACT] = 0
+        self[AnaVlv.POS_SCL_MIN] = pos_scl_min
+        self[AnaVlv.POS_SCL_MAX] = pos_scl_max
+        self[AnaVlv.POS_UNIT] = pos_unit
+        self[AnaVlv.POS_MIN] = pos_min
+        self[AnaVlv.POS_MAX] = pos_max
+        self[AnaVlv.POS_INT] = 0
+        self[AnaVlv.POS_MAN] = 0
+        self[AnaVlv.POS_RBK] = pos_min
+        self[AnaVlv.POS_] = pos_min
+        self[AnaVlv.OPEN_FBK_CALC] = open_fbk_calc
+        self[AnaVlv.OPEN_FBK] = False
+        self[AnaVlv.CLOSE_FBK_CALC] = close_fbk_calc
+        self[AnaVlv.CLOSE_FBK] = False
+        self[AnaVlv.POS_FBK_CALC] = pos_fbk_calc
+        self[AnaVlv.POS_FBK] = pos_min
+        self[AnaVlv.PERM_EN] = perm_en
+        self[AnaVlv.PERMIT_] = 0
+        self[AnaVlv.INTL_EN] = intl_en
+        self[AnaVlv.INTERLOCK] = 0
+        self[AnaVlv.PROT_EN] = prot_en
+        self[AnaVlv.PROTECT_] = 0
+        self[AnaVlv.RESET_OP] = 0
+        self[AnaVlv.RESET_AUT] = 0
+
+        # Set callbacks for writable items
+        self.get_item(AnaVlv.OPEN_OP).ext_wrt_cb = self.set_open_op
+        self.get_item(AnaVlv.CLOSE_OP).ext_wrt_cb = self.set_close_op
+        self.get_item(AnaVlv.POS_MAN).ext_wrt_cb = self.set_pos_man
+        self.get_item(AnaVlv.RESET_OP).ext_wrt_cb = self.set_reset_op
+
+    def _expect_save_pos(self):
+        if self._run_allowed():
+            self[AnaVlv.SAFE_POS_ACT] = False
+        else:
+            if self[AnaVlv.SAFE_POS_EN]:
+                self._go_save_pos()
+            else:  # hold position
+                logger.debug("Device has no safe position")
+            self[AnaVlv.SAFE_POS_ACT] = True
+
+    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[AnaVlv.POS_FBK_CALC]:
+            self[AnaVlv.POS_FBK] = safe_pos
+
+    def set_open_aut(self, value: bool):
+        logger.debug(f"OpenAut set to {value}")
+        if self.op_mode[OperationMode.STATE_AUT_ACT]:
+            if value and self._run_allowed():
+                self._run_open_vlv()
+
+    def set_close_aut(self, value: bool):
+        logger.debug(f"CloseAut set to {value}")
+        if self.op_mode[OperationMode.STATE_AUT_ACT]:
+            if value and self._run_allowed():
+                self._run_close_vlv()
+
+    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_vlv()
+
+    def set_open_op(self, value: bool):
+        logger.debug(f"OpenOp set to {value}")
+        if self.op_mode[OperationMode.STATE_OP_ACT]:
+            if value and self._run_allowed():
+                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[OperationMode.STATE_OP_ACT]:
+            if value and self._run_allowed():
+                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[OperationMode.STATE_OP_ACT] and value:
+            self._reset_vlv()
+            self[AnaVlv.RESET_OP] = False
+
+    def _run_allowed(self):
+        if self[AnaVlv.PERM_EN] and self[AnaVlv.PERMIT_] == 0:
+            logger.debug(f"Permission is not given")
+            return False
+        if self[AnaVlv.INTL_EN] and self[AnaVlv.INTERLOCK] == 0:
+            logger.debug(f"Interlock is active")
+            return False
+        if self[AnaVlv.PROT_EN] and self[AnaVlv.PROTECT_] == 0:
+            logger.debug(f"Protect is active")
+            return False
+        return True
+
+    def _run_open_vlv(self):
+        self[AnaVlv.OPEN_ACT] = True
+        if self[AnaVlv.OPEN_FBK_CALC]:
+            self[AnaVlv.OPEN_FBK] = True
+        self[AnaVlv.CLOSE_ACT] = False
+        if self[AnaVlv.CLOSE_FBK_CALC]:
+            self[AnaVlv.CLOSE_FBK] = False
+
+    def _run_close_vlv(self):
+        self[AnaVlv.OPEN_ACT] = False
+        if self[AnaVlv.OPEN_FBK_CALC]:
+            self[AnaVlv.OPEN_FBK] = False
+        self[AnaVlv.CLOSE_ACT] = True
+        if self[AnaVlv.CLOSE_FBK_CALC]:
+            self[AnaVlv.CLOSE_FBK] = True
+
+    def _reset_vlv(self):
+        if self[AnaVlv.PROT_EN] and self[AnaVlv.PROTECT_] == 0:
+            self[AnaVlv.PROTECT_] = True
+            self[AnaVlv.SAFE_POS_ACT] = False
+        self[AnaVlv.OPEN_ACT] = False
+        if self[AnaVlv.OPEN_FBK_CALC]:
+            self[AnaVlv.OPEN_FBK] = False
+        self[AnaVlv.CLOSE_ACT] = False
+        if self[AnaVlv.CLOSE_FBK_CALC]:
+            self[AnaVlv.CLOSE_FBK] = False
+
+    def set_pos_int(self, value: float):
+        logger.debug(f"PosInt set to {value}")
+        if self.src_mode[SourceMode.SRC_INT_ACT]:
+            self._set_pos(value)
+
+    def set_pos_man(self, value: float):
+        logger.debug(f"PosMan set to {value}")
+        if self.src_mode[SourceMode.SRC_MAN_ACT]:
+            self._set_pos(value)
+
+    def _correct_value(self, value: float):
+        if value > self[AnaVlv.POS_MAX]:
+            return self[AnaVlv.POS_MAX]
+        elif value < self[AnaVlv.POS_MIN]:
+            return self[AnaVlv.POS_MIN]
+        else:
+            return value
+
+    def valid_value(self, value: float):
+        return self[AnaVlv.POS_MIN] <= value <= self[AnaVlv.POS_MAX]
+
+    def _set_pos(self, value: float):
+        if not self._run_allowed():
+            logger.debug("No position change is allowed")
+            return
+
+        if self[AnaVlv.SAFE_POS_ACT] or (
+            self[AnaVlv.PERM_EN] and self[AnaVlv.PERMIT_] == 0
+        ):
+            logger.debug("manual or internal position specification inactive")
+            return
+
+        if self.valid_value(value):
+            if self[AnaVlv.CLOSE_ACT]:
+                value = self[AnaVlv.POS_MIN]
+
+            self[AnaVlv.POS_] = value
+            logger.debug(f"Pos set to {value}")
+            if self[AnaVlv.POS_FBK_CALC]:
+                self[AnaVlv.POS_FBK] = value
+        else:
+            logger.debug(f"Pos cannot be set to {value} (out of range)")
+
+    def set_pos_rbk(self, value: float):
+        corr_value = self._correct_value(value)
+        self[AnaVlv.POS_RBK] = corr_value
+        logger.debug(f"PosRbk set to {value}")
+
+    def set_pos_fbk(self, value: float):
+        if not self[AnaVlv.POS_FBK_CALC]:
+            corr_value = self._correct_value(value)
+            self[AnaVlv.POS_FBK] = corr_value
+            logger.debug(f"PosFbk set to {value}")
+
+    def set_open_fbk(self, value: bool):
+        if not self[AnaVlv.OPEN_FBK_CALC]:
+            self[AnaVlv.OPEN_FBK] = value
+            logger.debug(f"OpenFbk set to {value}")
+
+    def set_close_fbk(self, value: bool):
+        if not self[AnaVlv.CLOSE_FBK_CALC]:
+            self[AnaVlv.CLOSE_FBK] = value
+            logger.debug(f"CloseFbk set to {value}")
+
+    def set_permit(self, value: bool):
+        if not self[AnaVlv.PERM_EN]:
+            value = True
+        self[AnaVlv.PERMIT_] = value
+        logger.debug(f"Permit set to {value}")
+        self[AnaVlv.SAFE_POS_ACT] = (
+            False  # safety position should not be activated for permit mode
+        )
+
+    def set_interlock(self, value: bool):
+        if not self[AnaVlv.INTL_EN]:
+            value = True
+        self[AnaVlv.INTERLOCK] = value
+        logger.debug(f"Interlock set to {value}")
+        self._expect_save_pos()
+
+    def set_protect(self, value: bool):
+        if not self[AnaVlv.PROT_EN]:
+            value = True
+        if value:
+            self._reset_vlv()
+        self[AnaVlv.PROTECT_] = value
+        logger.debug(f"Protect set to {value}")
+        self._expect_save_pos()
+
+    def get_pos(self):
+        return self[AnaVlv.POS_]
+
+    def get_pos_rbk(self):
+        return self[AnaVlv.POS_RBK]
+
+    def get_pos_fbk(self):
+        return self[AnaVlv.POS_FBK]
+
+    def get_open_fbk(self):
+        return self[AnaVlv.OPEN_FBK]
+
+    def get_close_fbk(self):
+        return self[AnaVlv.CLOSE_FBK]