rtint 0.0.3__py3-none-any.whl

rtint/rtint_parameter.py

@@ -0,0 +1,105 @@
+# This file is part of the mechatronic project
+#
+# Copyright (c) Beamline Control Unit, ESRF
+# Distributed under the GNU LGPLv3. See LICENSE for more info.
+
+"""
+REAL-TIME TARGET PARAMETERS
+"""
+
+import numpy as np
+from collections.abc import MutableSequence
+from treelib import Tree
+from tabulate import tabulate
+
+
+class RtintHdwParameterController:
+    def __init__(self, tg):
+        self._tg = tg
+        self._system = tg._system
+        self._program = tg._program
+        self._param_tree = self._program.tree.params
+
+        self._set_attr_root_params()
+        self._set_default_params()
+
+    def __info__(self, debug=False):
+        if self._root_params is None:
+            return "\n    No parameters in the model"
+        lines = [["Name", "Value"]]
+        for parameter in self._root_params:
+            lines.append([parameter, repr(getattr(self, parameter))])
+        return "\n" + tabulate(lines, headers="firstrow", tablefmt="grid", stralign="left")
+
+    # Used to automatically add "root parameters" as attributes for easy access/modification
+    def _set_attr_root_params(self):
+        for param_name in self._root_params:
+            setattr(self.__class__, param_name, RtintParam(self, param_name))
+
+    @property
+    def _root_params(self):
+        return [
+            param
+            for param in self._param_tree
+            if (self._program.name not in param and param[-1] != "_")
+        ]
+
+    # Set default params as defined in the YML file
+    def _set_default_params(self):
+        params_yml = self._tg._config.get("default_parameters")
+        if params_yml is None:
+            return
+
+        for param in params_yml:
+            try:
+                if isinstance(param["value"], MutableSequence):
+                    self.set(param["path"], np.array(param["value"]))
+                else:
+                    self.set(param["path"], param["value"])
+            except Exception:
+                print(
+                    f"Default parameter with path \"{param['path']}\" does not exist in the model"
+                )
+
+    @property
+    def _tree(self):
+        tree = Tree()
+        root = self._program.name
+        tree.create_node(root, root)
+
+        for path in self._param_tree:
+            parts = path.split("/")
+            parent = root
+            for i, p in enumerate(parts[1:], 1):  # start at index 1
+                node_id = "/".join(
+                    parts[: i + 1]
+                )  # build unique identifier up to this level
+                if not tree.contains(node_id):
+                    tree.create_node(p, node_id, parent=parent)
+                parent = node_id
+
+        return tree
+
+    def set(self, param_name, value):
+        # Automatically add "model_name" if necessary
+        if "/" in param_name:
+            param_name = self._program.name + "/" + param_name
+        self._param_tree[param_name].value = value
+
+    def get(self, param_name):
+        # Automatically add "model_name" if necessary
+        if "/" in param_name:
+            param_name = self._program.name + "/" + param_name
+        return self._param_tree[param_name].value
+
+
+class RtintParam:
+    def __init__(self, param_ctl, param_name):
+        self._param_ctl = param_ctl
+        self._name = param_name
+
+    def __get__(self, obj, objtype):
+        return self._param_ctl.get(self._name)
+
+    def __set__(self, obj, value):
+        self._param_ctl.set(self._name, value)

rtint/rtint_regul.py

@@ -0,0 +1,310 @@
+# This file is part of the mechatronic project
+#
+# Copyright (c) Beamline Control Unit, ESRF
+# Distributed under the GNU LGPLv3. See LICENSE for more info.
+
+"""
+REAL-TIME TARGET REGULATOR
+"""
+
+import numpy as np
+import enum
+from tabulate import tabulate
+
+RED = "\033[31m"
+GREEN = "\033[32m"
+RESET = "\033[0m"
+
+
+class RegulState(enum.IntEnum):
+    Off = 0
+    On = 1
+
+
+class RegulError(enum.IntEnum):
+    NoError = 0
+    MinInput = 1
+    MaxInput = 2
+    MinOutput = 3
+    MaxOutput = 4
+    ExtError = 5
+
+
+class RtintHdwRegulController:
+    def __init__(self, tg):
+        self._tg = tg
+        self._reguls: dict[str, RtintHdwRegul] | None = None
+        self._load()
+
+    def __info__(self, debug=False):
+        if self._reguls is None:
+            return "\n    No Regulator in the model"
+
+        if debug:
+            lines = [["Name", "Path", "Wanted", "State", "Error", "Input", "Output"]]
+        else:
+            lines = [["Name", "Wanted", "State"]]
+
+        for _regul in self._reguls.values():
+            if debug:
+                lines.append(
+                    [
+                        _regul._name,
+                        _regul._unique_name,
+                        _regul.wanted,
+                        _regul.ctrl_status.name,
+                        _regul.ctrl_error.name,
+                        _regul.error_signal,
+                        _regul.command_signal,
+                    ]
+                )
+            else:
+                lines.append([_regul._name, _regul.wanted, _regul.ctrl_status.name])
+        return "\n" + tabulate(lines, headers="firstrow", tablefmt="grid", stralign="left")
+
+    def _load(self):
+        reguls = self._tg._get_all_objects_from_key("bliss_regulator")
+        if len(reguls) > 0:
+            self._reguls = {}
+            for regul in reguls:
+                tg_regul = RtintHdwRegul(self._tg, regul)
+
+                if hasattr(self, tg_regul._name):
+                    print(
+                        f"{RED}WARNING: Regulator '{tg_regul._name}' already exists{RESET}"
+                    )
+                    return
+                else:
+                    setattr(self, tg_regul._name, tg_regul)
+                    self._reguls[tg_regul._name] = tg_regul
+
+
+class RtintHdwRegul:
+    def __init__(self, tg, unique_name):
+        self._tg = tg
+        self._unique_name = unique_name
+
+    def __info__(self):
+        lines = []
+        lines.append(["Name", self._name])
+        wanted_str = f"{GREEN}True{RESET}" if self.wanted else f"{RED}False{RESET}"
+        lines.append(["Wanted", wanted_str])
+        if self.ctrl_status == 0:
+            lines.append(["State", f"{RED}{self.ctrl_status.name}{RESET}"])
+            lines.append(["Error", f"{RED}{self.ctrl_error.name}{RESET}"])
+            if self.ctrl_error != 0:
+                lines.append(
+                    [
+                        "  Output at error",
+                        "["
+                        + ", ".join(f"{x:.2g}" for x in np.ravel(self.command_fault))
+                        + "]",
+                    ]
+                )
+                lines.append(
+                    [
+                        "  Intput at error",
+                        "["
+                        + ", ".join(f"{x:.2g}" for x in np.ravel(self.error_fault))
+                        + "]",
+                    ]
+                )
+        else:
+            lines.append(["State", f"{GREEN}{self.ctrl_status.name}{RESET}"])
+        lines.append(["", ""])
+        lines.append(
+            [
+                "Current Error",
+                "[" + ", ".join(f"{x:.2g}" for x in np.ravel(self.error_signal)) + "]",
+            ]
+        )
+        lines.append(
+            [
+                "Current Command",
+                "["
+                + ", ".join(f"{x:.2g}" for x in np.ravel(self.command_signal))
+                + "]",
+            ]
+        )
+        lines.append(["", ""])
+        lines.append(
+            [
+                "Error Limits",
+                "["
+                + ", ".join(
+                    f"{x:.2g}" for x in [self.error_lower_limit, self.error_upper_limit]
+                )
+                + "]",
+            ]
+        )
+        lines.append(
+            [
+                "Command Limits",
+                "["
+                + ", ".join(
+                    f"{x:.2g}"
+                    for x in [self.command_lower_limit, self.command_upper_limit]
+                )
+                + "]",
+            ]
+        )
+        return tabulate(lines, tablefmt="plain", stralign="right")
+
+    def _tree(self):
+        print("Parameters:")
+        self._tg.parameter._tree.subtree(
+            self._tg._program.name + "/" + self._unique_name
+        ).show()
+        print("Signals:")
+        self._tg.signal._tree.subtree(
+            self._tg._program.name + "/" + self._unique_name
+        ).show()
+
+    @property
+    def _name(self):
+        return self._tg.parameter.get(
+            f"{self._unique_name}/bliss_regulator/String"
+        )
+
+    @property
+    def error_lower_limit(self):
+        """Minimum allowed input (usually control error)"""
+        return self._tg.parameter.get(f"{self._unique_name}/error_lower_limit")
+
+    @error_lower_limit.setter
+    def error_lower_limit(self, value):
+        if value < self.error_upper_limit:
+            self._tg.parameter.set(
+                f"{self._unique_name}/error_lower_limit", value
+            )
+        else:
+            raise ValueError(
+                f"error_lower_limit {value} must be < {self.error_upper_limit}"
+            )
+
+    @property
+    def error_upper_limit(self):
+        """Maximum allowed input (usually control error)"""
+        return self._tg.parameter.get(f"{self._unique_name}/error_upper_limit")
+
+    @error_upper_limit.setter
+    def error_upper_limit(self, value):
+        if value > self.error_lower_limit:
+            self._tg.parameter.set(
+                f"{self._unique_name}/error_upper_limit", value
+            )
+        else:
+            raise ValueError(
+                f"error_upper_limit {value} must be > {self.error_lower_limit}"
+            )
+
+    @property
+    def command_lower_limit(self):
+        """Mimum allowed output (usually control command signal)"""
+        return self._tg.parameter.get(f"{self._unique_name}/command_lower_limit")
+
+    @command_lower_limit.setter
+    def command_lower_limit(self, value):
+        if value < self.command_upper_limit:
+            self._tg.parameter.set(
+                f"{self._unique_name}/command_lower_limit", value
+            )
+        else:
+            raise ValueError(
+                f"command_lower_limit {value} must be < {self.command_upper_limit}"
+            )
+
+    @property
+    def command_upper_limit(self):
+        """Maximum allowed output (usually control command signal)"""
+        return self._tg.parameter.get(f"{self._unique_name}/command_upper_limit")
+
+    @command_upper_limit.setter
+    def command_upper_limit(self, value):
+        if value > self.command_lower_limit:
+            self._tg.parameter.set(
+                f"{self._unique_name}/command_upper_limit", value
+            )
+        else:
+            raise ValueError(
+                f"command_upper_limit {value} must be > {self.command_lower_limit}"
+            )
+
+    @property
+    def error_fault(self):
+        """Stored input (usually error signal) when the regul was last turned OFF."""
+        return self._tg.signal.get(f"{self._unique_name}/error_fault")
+
+    @property
+    def command_fault(self):
+        """Stored command signal when the regul was last turned OFF."""
+        return self._tg.signal.get(f"{self._unique_name}/command_fault")
+
+    @property
+    def wanted(self):
+        """Is the regul is wanted?"""
+        return bool(int(self._tg.signal.get(f"{self._unique_name}/ctrl_wanted")))
+
+    def on(self):
+        """Turn the regul ON"""
+        self.reset_error()
+        self._tg.parameter.set(f"{self._unique_name}/wanted/Value", 1)
+
+    def off(self):
+        """Turn the regul OFF"""
+        self._tg.parameter.set(f"{self._unique_name}/wanted/Value", 0)
+
+    def reset_error(self):
+        """If the regul was OFF due to too large input or output, reset the error to be
+        able to turn it ON again."""
+        reset_error = int(
+            self._tg.parameter.get(f"{self._unique_name}/reset_error/Bias")
+        )
+        self._tg.parameter.set(
+            f"{self._unique_name}/reset_error/Bias", reset_error + 1
+        )
+
+    @property
+    def fault_time(self):
+        """IF the regul goes from ON to OFF, time it takes to put the command signal at zero."""
+        return self._tg.parameter.get(f"{self._unique_name}/fault_time")
+
+    @fault_time.setter
+    def fault_time(self, value):
+        if value <= 0:
+            raise ValueError("fault_time must be positive")
+        self._tg.parameter.set(f"{self._unique_name}/fault_time", value)
+
+    @property
+    def fault_output(self):
+        """IF the regul goes from ON to OFF, the output signal will be fault_output."""
+        return self._tg.parameter.get(f"{self._unique_name}/fault_output")
+
+    @fault_output.setter
+    def fault_output(self, value):
+        self._tg.parameter.set(f"{self._unique_name}/fault_output", value)
+
+    @property
+    def ctrl_error(self):
+        """It regul is OFF due to some error, display this error."""
+        # 0:no_error 1:min_input_reached 2:max_input_reached 3:min_output_reached 4:max_output_reached 5:ext_error
+        return RegulError(
+            int(self._tg.signal.get(f"{self._unique_name}/ctrl_error"))
+        )
+
+    @property
+    def ctrl_status(self):
+        # 0:off 1:on
+        return RegulState(
+            int(self._tg.signal.get(f"{self._unique_name}/ctrl_status"))
+        )
+
+    @property
+    def error_signal(self):
+        """Regul input, usually error signal."""
+        return self._tg.signal.get(f"{self._unique_name}/error_signal")
+
+    @property
+    def command_signal(self):
+        """Regul output, usually command signal."""
+        return self._tg.signal.get(f"{self._unique_name}/command_signal")

rtint/rtint_signal.py

@@ -0,0 +1,42 @@
+# This file is part of the mechatronic project
+#
+# Copyright (c) Beamline Control Unit, ESRF
+# Distributed under the GNU LGPLv3. See LICENSE for more info.
+
+from treelib import Tree
+
+"""
+SIGNALS
+"""
+
+
+class RtintHdwSignalController:
+    def __init__(self, tg):
+        self._tg = tg
+        self._system = tg._system
+        self._program = tg._program
+        self._signal_tree = tg._program.tree.signals
+
+    def __info__(self):
+        self._tree.show()
+        return ""
+
+    @property
+    def _tree(self):
+        tree = Tree()
+        root = self._program.name
+        tree.create_node(root, root)
+
+        for path in self._signal_tree:
+            parts = path.split("/")
+            parent = root
+            for p in parts[1:]:
+                node_id = "/".join(parts[: parts.index(p) + 1])  # unique identifier
+                if not tree.contains(node_id):
+                    tree.create_node(p, node_id, parent=parent)
+                parent = node_id
+
+        return tree
+
+    def get(self, signal_path):
+        return self._signal_tree[self._program.name + "/" + signal_path].value

rtint/rtint_trigger.py

@@ -0,0 +1,107 @@
+# This file is part of the mechatronic project
+#
+# Copyright (c) Beamline Control Unit, ESRF
+# Distributed under the GNU LGPLv3. See LICENSE for more info.
+
+from tabulate import tabulate
+
+RED = "\033[31m"
+GREEN = "\033[32m"
+RESET = "\033[0m"
+
+
+"""
+REAL-TIME TARGET triggers
+"""
+
+
+class RtintHdwTriggerController:
+    def __init__(self, tg):
+        self._tg = tg
+        self._triggers: dict[str, RtintHdwTrigger] | None = None
+        self._load()
+
+    def __info__(self, debug=False):
+        if self._triggers is None:
+            return "\n    No trigger in the model"
+
+        if debug:
+            lines = [["Name", "Path", "Trigger Number"]]
+        else:
+            lines = [["Name"]]
+
+        for _trigger in self._triggers.values():
+            if debug:
+                lines.append(
+                    [_trigger._name, _trigger._unique_name, _trigger.trig_number]
+                )
+            else:
+                lines.append([_trigger._name])
+        return "\n" + tabulate(lines, headers="firstrow", tablefmt="grid", stralign="left")
+
+    def _load(self):
+        triggers = self._tg._get_all_objects_from_key("bliss_trigger")
+        if len(triggers) > 0:
+            self._triggers = {}
+            for trigger in triggers:
+                tg_trigger = RtintHdwTrigger(self._tg, trigger)
+
+                if hasattr(self, tg_trigger._name):
+                    print(
+                        f"{RED}WARNING: Trigger '{tg_trigger._name}' already exists{RESET}"
+                    )
+                    return
+                else:
+                    setattr(self, tg_trigger._name, tg_trigger)
+                    self._triggers[tg_trigger._name] = tg_trigger
+
+
+class RtintHdwTrigger:
+    def __init__(self, tg, unique_name):
+        self._tg = tg
+        self._unique_name = unique_name
+
+    def __info__(self):
+        lines = []
+        lines.append(["Name", self._name])
+        lines.append(["Unique Name", self._unique_name])
+        lines.append(["", ""])
+        lines.append(["Number of trigs", self.trig_number])
+        return tabulate(lines, tablefmt="plain", stralign="right")
+
+    def _tree(self):
+        print("Parameters:")
+        self._tg.parameter._tree.subtree(
+            self._tg._program.name + "/" + self._unique_name
+        ).show()
+        print("Signals:")
+        self._tg.signal._tree.subtree(
+            self._tg._program.name + "/" + self._unique_name
+        ).show()
+
+    @property
+    def _name(self):
+        return self._tg.parameter.get(
+            f"{self._unique_name}/bliss_trigger/String"
+        )
+
+    @property
+    def trig_number(self):
+        return int(self._tg.signal.get(f"{self._unique_name}/trig_number"))
+
+    def reset_trig_number(self):
+        self._tg.parameter.set(f"{self._unique_name}/start_trigger/Bias", 0)
+        reset_trigger = int(
+            self._tg.parameter.get(f"{self._unique_name}/reset_trig_number/Bias")
+        )
+        self._tg.parameter.set(
+            f"{self._unique_name}/reset_trig_number/Bias", reset_trigger + 1
+        )
+
+    def trig(self):
+        bias = int(
+            self._tg.parameter.get(f"{self._unique_name}/start_trigger/Bias")
+        )
+        self._tg.parameter.set(
+            f"{self._unique_name}/start_trigger/Bias", bias + 1
+        )