rtint 0.0.3__py3-none-any.whl

rtint/rtint_hardware.py

@@ -0,0 +1,336 @@
+# This file is part of the mechatronic project
+#
+# Copyright (c) Beamline Control Unit, ESRF
+# Distributed under the GNU LGPLv3. See LICENSE for more info.
+
+"""
+Rtint Real Time Controller
+"""
+
+from rtint.rtint_parameter import (
+    RtintHdwParameterController,
+)
+from rtint.rtint_signal import RtintHdwSignalController
+from rtint.rtint_motor import RtintHdwMotorController
+from rtint.rtint_regul import RtintHdwRegulController
+from rtint.rtint_generator import (
+    RtintHdwGeneratorController,
+)
+from rtint.rtint_filter import RtintHdwFilterController
+from rtint.rtint_trigger import RtintHdwTriggerController
+from rtint.rtint_ethercat import (
+    RtintHdwEthercatController,
+)
+from rtint.rtint_lut import RtintHdwLutController
+from rtint.rtint_counter import RtintHdwCounterController
+from rtint.rtint_acquisition import RtintHdwAcquisition
+from rtint.rtint_utils import RtintUtils
+
+from rtint import _version
+
+from resyst.client.system import System
+from tabulate import tabulate
+
+RED = "\033[31m"
+GREEN = "\033[32m"
+RESET = "\033[0m"
+
+
+class RtintController:
+    def __init__(self, name, config):
+        # Set the real-time target name
+        self._name = name
+        self._config = config
+
+        # Connect to dance server
+        self._server = config.get("server", None)
+        self._port = config.get("port", None)
+
+        self._system = System.create(f"{self._server}:{self._port}")
+        self._system.timeout = 30
+        self._program = self._system.running_program
+
+        self._check_resyst_version(min_major=0, min_minor=18)
+
+        if self._program is not None:
+            self._load_objects()
+
+    def __info__(self):
+        if not self._is_app_running:
+            return "No app is running"
+
+        lines = []
+        lines.append(["Real-time target name", self._name])
+        lines.append(["Program Name", self._app_name])
+        lines.append(["", ""])
+        lines.append(["Cycle Time", f"{1e6 * self._Ts:.0f} us"])
+        lines.append(
+            [
+                "Max TET",
+                f"{1e6 * self._tet_max:.1f} us ({100 * self._tet_max / self._Ts:.1f}%)",
+            ]
+        )
+        lines.append(
+            ["Overloads", f"{self._overloads} (Max allowed: {self._max_overloads})"]
+        )
+        lines.append(["Execution Time", self._exec_time_string()])
+        lines.append(["", ""])
+        lines.append(["Resyst Client", self._system.version])
+        lines.append(["Resyst Server", self._system.server_version])
+        lines.append(["", ""])
+        lines.append(["RT Interface Version", self._version])
+        lines.append(["Library Git Version", self._lib_git_version])
+        lines.append(["Model Git Version", self._model_git_version])
+        return tabulate(lines, tablefmt="plain", stralign="left")
+
+    def _check_resyst_version(self, min_major=None, min_minor=None):
+        clt_major, clt_minor = self._parse_resyst_version(self._system.version)
+        srv_major, srv_minor = self._parse_resyst_version(self._system.server_version)
+
+        # Check that major and minor are the same
+        if (clt_major, clt_minor) != (srv_major, srv_minor):
+            raise ValueError(
+                f"Resyst version mismatch: client ({self._system.version}) vs server ({self._system.server_version})"
+            )
+
+        # Check minimum version if specified
+        if min_major is not None and min_minor is not None:
+            if (clt_major, clt_minor) < (min_major, min_minor):
+                raise ValueError(
+                    f"Resyst version ({self._system.version}) is lower than minimum required ({min_major}.{min_minor}.x)"
+                )
+
+    def _parse_resyst_version(self, version_str):
+        """Return (major, minor) as integers from a version string 'major.minor.revision'."""
+        major, minor, *_ = version_str.split(".")
+        return int(major), int(minor)
+
+    def _display_informations(self, debug=False):
+        sections = []
+
+        sections.append("Parameters")
+        sections.append(self.parameter.__info__(debug=debug))
+
+        sections.append("\n\nCounters")
+        sections.append(self.counter.__info__(debug=debug))
+
+        sections.append("\n\nFilters")
+        sections.append(self.filter.__info__(debug=debug))
+
+        sections.append("\n\nGenerators")
+        sections.append(self.generator.__info__(debug=debug))
+
+        sections.append("\n\nReguls")
+        sections.append(self.regul.__info__(debug=debug))
+
+        sections.append("\n\nMotors")
+        sections.append(self.motor.__info__(debug=debug))
+
+        sections.append("\n\nTriggers")
+        sections.append(self.trigger.__info__(debug=debug))
+
+        sections.append("\n\nEtherCAT")
+        sections.append(self.ethercat.__info__(debug=debug))
+
+        sections.append("\n\nLUT")
+        sections.append(self.lut.__info__(debug=debug))
+
+        sections.append("\n\nAcquisitions")
+        sections.append(self.acq.__info__(debug=debug))
+
+        print("\n".join(sections))
+
+    # Populate the tg_ctl object
+    def _load_objects(self):
+        self.parameter = RtintHdwParameterController(self)
+        self.signal = RtintHdwSignalController(self)
+
+        # Find the block were some informations are stored
+        tg_info_path = self._get_all_objects_from_key("bliss_speedgoat_info")
+        if len(tg_info_path) == 0:
+            print(
+                f"{RED}WARNING: The Simulink model does not have the 'Speedgoat Info' block{RESET}"
+            )
+            return
+        self._tg_info = tg_info_path[0]
+        self._Ts = self._cycle_time
+        self._Fs = 1 / self._Ts
+
+        self.counter = RtintHdwCounterController(self)
+        self.filter = RtintHdwFilterController(self)
+        self.generator = RtintHdwGeneratorController(self)
+        self.regul = RtintHdwRegulController(self)
+        self.motor = RtintHdwMotorController(self)
+        self.trigger = RtintHdwTriggerController(self)
+        self.ethercat = RtintHdwEthercatController(self)
+        self.lut = RtintHdwLutController(self)
+        self.acq = RtintHdwAcquisition(self)
+        self.utils = RtintUtils(self)
+
+    # Load model on real-time target and run
+    def _run_model(self, prg_name, force_load=False, force_run=False):
+        # First check if the program is available in the real-time target and or the PC Server
+        if prg_name not in self._program_stored_list:
+            if prg_name not in self._program_loaded_list:
+                raise RuntimeError(
+                    f"Program file {prg_name} not found on PC server nor on the real-time target"
+                )
+            else:
+                print(
+                    "Program is only present in the real-time target and not in the PC server."
+                )
+
+        if prg_name not in self._program_loaded_list and force_load is False:
+            raise RuntimeError(
+                f"Program file {prg_name} not loaded in the real-time target, use force_load=True"
+            )
+
+        # Cases to load the program
+        if prg_name not in self._program_loaded_list or force_load is True:
+            self._system.program_load(prg_name, overwrite=True)
+
+        # Now run the program
+        running_program = self._system.running_program
+        # If program is already running and force is False: do nothing
+        if (
+            running_program is None
+            or running_program.name != prg_name
+            or force_run is True
+        ):
+            default_timeout = self._system.timeout
+            self._system.timeout = 60
+            if running_program is not None:
+                self._system.program_stop()
+            self._system.program_run(prg_name)
+            self._program = self._system.running_program
+            self._system.timeout = default_timeout
+            self._load_objects()
+
+    @property
+    def _version(self):
+        return _version.version
+
+    @property
+    def _program_stored_list(self):
+        return [program.name for program in self._system.stored_programs]
+
+    @property
+    def _program_loaded_list(self):
+        return [program.name for program in self._system.loaded_programs]
+
+    @property
+    def _app_name(self):
+        return self._program.name
+
+    @property
+    def _is_app_running(self):
+        return self._system.running_program is not None
+
+    @property
+    def _tet(self):
+        return self.signal.get(f"{self._tg_info}/tet")
+
+    @property
+    def _tet_max(self):
+        return self.signal.get(f"{self._tg_info}/max_tet")
+
+    @property
+    def _cycle_time(self):
+        return self.signal.get(f"{self._tg_info}/Ts")
+
+    @property
+    def _exec_time(self):
+        return self._cycle_time * self.signal.get(
+            f"{self._tg_info}/exc_time"
+        )  # in [s]
+
+    @property
+    def _disk_space(self):
+        return 1e-9 * self.signal.get(
+            f"{self._tg_info}/Get disk space"
+        )  # in [Gb]
+
+    @property
+    def _memory_space(self):
+        return 1e-9 * self.signal.get(
+            f"{self._tg_info}/Get memory info"
+        )  # in [Gb]
+
+    def _exec_time_string(self):
+        seconds = int(self._exec_time)  # Ensure it's an integer
+        if seconds < 60:
+            return f"{seconds} second{'s' if seconds != 1 else ''}"
+        elif seconds < 3600:
+            minutes = seconds // 60
+            secs = seconds % 60
+            return f"{minutes} minute{'s' if minutes != 1 else ''}" + (
+                f" {secs} second{'s' if secs != 1 else ''}" if secs else ""
+            )
+        elif seconds < 86400:
+            hours = seconds // 3600
+            minutes = (seconds % 3600) // 60
+            return f"{hours} hour{'s' if hours != 1 else ''}" + (
+                f" {minutes} minute{'s' if minutes != 1 else ''}" if minutes else ""
+            )
+        else:
+            days = seconds // 86400
+            hours = (seconds % 86400) // 3600
+            return f"{days} day{'s' if days != 1 else ''}" + (
+                f" {hours} hour{'s' if hours != 1 else ''}" if hours else ""
+            )
+
+    def _autostart_enable(self):
+        self._system.autostart_program = self._program.name
+
+    def _autostart_disable(self):
+        self._system.autostart_program = None
+
+    def _autostart_status(self):
+        if self._system.autostart_program is None:
+            print("No autostart")
+        else:
+            print(f"Autostart program is {self._system.autostart_program.name}")
+
+    def _reset_max_tet(self):
+        self.parameter.set(
+            f"{self._tg_info}/reset_max_tet/Bias",
+            self.parameter.get(f"{self._tg_info}/reset_max_tet/Bias") + 1,
+        )
+
+    @property
+    def _is_overloaded(self):
+        return self._overloads >= self._max_overloads
+
+    @property
+    def _overloads(self):
+        return self.signal.get(
+            f"{self._tg_info}/Overload Options/Overload Options Core/o1"
+        )
+
+    @property
+    def _max_overloads(self):
+        return self.parameter.get(f"{self._tg_info}/max_overload/Value")
+
+    @property
+    def _model_git_version(self):
+        try:
+            version = self.parameter.get(f"{self._tg_info}/model_git_version")
+        except Exception:
+            version = ""  # By default if not specified in the model
+        return version
+
+    @property
+    def _lib_git_version(self):
+        try:
+            version = self.parameter.get(f"{self._tg_info}/lib_git_version")
+        except Exception:
+            version = ""  # By default if not specified in the model
+        return version
+
+    def _get_all_objects_from_key(self, name):
+        """Return identifiers of all parents whose child tag == name."""
+        return [
+            "/".join(param.split("/")[1:-2])
+            for param in self.parameter._param_tree
+            if name in param
+        ]

rtint/rtint_lut.py

@@ -0,0 +1,143 @@
+# 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 Lookup Tables
+"""
+
+import numpy as np
+from tabulate import tabulate
+
+RED = "\033[31m"
+GREEN = "\033[32m"
+RESET = "\033[0m"
+
+
+class RtintHdwLutController:
+    def __init__(self, tg):
+        self._tg = tg
+        self._luts: dict[str, RtintHdwLut] | None = None
+        self._load()
+
+    def __info__(self, debug=False):
+        if self._luts is None:
+            return "\n    No LUT in the model"
+
+        if debug:
+            lines = [["Name", "Path", "Enabled"]]
+        else:
+            lines = [["Name", "Enabled"]]
+        for _lut in self._luts.values():
+            if debug:
+                lines.append(
+                    [
+                        _lut._name,
+                        _lut._unique_name,
+                        f"{GREEN}True{RESET}" if _lut.enabled else f"{RED}False{RESET}",
+                    ]
+                )
+            else:
+                lines.append(
+                    [_lut._name, f"{GREEN}True{RESET}" if _lut.enabled else f"{RED}False{RESET}"]
+                )
+        return "\n" + tabulate(lines, headers="firstrow", tablefmt="grid", stralign="left")
+
+    def _load(self, force=False):
+        luts = self._tg._get_all_objects_from_key("bliss_lut")
+        if len(luts) > 0:
+            self._luts = {}
+            for _lut in luts:
+                tg_lut = RtintHdwLut(self._tg, _lut)
+
+                if hasattr(self, tg_lut._name):
+                    print(f"{RED}WARNING: LUT '{tg_lut._name}' already exists{RESET}")
+                    return
+                else:
+                    setattr(self, tg_lut._name, tg_lut)
+                    self._luts[tg_lut._name] = tg_lut
+
+
+class RtintHdwLut:
+    def __init__(self, tg, unique_name):
+        self._tg = tg
+        self._unique_name = unique_name
+
+    def __info__(self):
+        lines = []
+        lines.append(["", ""])
+        lines.append(["Name", self._name])
+        lines.append(["Unique Name", self._unique_name])
+        enabled_str = f"{GREEN}True{RESET}" if self.enabled else f"{RED}False{RESET}"
+        lines.append(["Enabled", enabled_str])
+        y_raw = self.y_raw
+        lines.append(
+            ["X raw", f"[{y_raw[0]}, {y_raw[1]}, ..., {y_raw[-2]}, {y_raw[-1]}]"]
+        )
+        x_raw = self.x_raw
+        lines.append(
+            ["Y raw", f"[{x_raw[0]}, {x_raw[1]}, ..., {x_raw[-2]}, {x_raw[-1]}]"]
+        )
+        lines.append(["", ""])
+        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_lut/String")
+
+    def enable(self):
+        self._tg.parameter.set(f"{self._unique_name}/enable/Value", 1)
+
+    def disable(self):
+        self._tg.parameter.set(f"{self._unique_name}/enable/Value", 0)
+
+    @property
+    def length(self):
+        return len(self.x_raw)
+
+    @property
+    def enabled(self):
+        return bool(self._tg.parameter.get(f"{self._unique_name}/enable/Value"))
+
+    @property
+    def y_raw(self):
+        return np.squeeze(self._tg.parameter.get(f"{self._unique_name}/y_raw"))
+
+    @y_raw.setter
+    def y_raw(self, value):
+        self._tg.parameter.set(f"{self._unique_name}/y_raw", value)
+
+    @property
+    def x_raw(self):
+        return np.squeeze(self._tg.parameter.get(f"{self._unique_name}/x_raw"))
+
+    @x_raw.setter
+    def x_raw(self, value):
+        self._tg.parameter.set(f"{self._unique_name}/x_raw", value)
+
+    @property
+    def y_input(self):
+        return self._tg.signal.get(f"{self._unique_name}/y_input")
+
+    @property
+    def y_output(self):
+        return self._tg.signal.get(f"{self._unique_name}/y_output")
+
+    @property
+    def x_data(self):
+        return self._tg.signal.get(f"{self._unique_name}/x_data")
+
+    @property
+    def y_data(self):
+        return self._tg.signal.get(f"{self._unique_name}/y_data")

rtint/rtint_motor.py

@@ -0,0 +1,191 @@
+# 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 MOTORS
+"""
+
+import enum
+from tabulate import tabulate
+
+RED = "\033[31m"
+GREEN = "\033[32m"
+RESET = "\033[0m"
+
+
+class MotorState(enum.IntEnum):
+    Ready = 0
+    Moving = 1
+    LimitNeg = 2
+    LimitPos = 3
+    Stopped = 4
+    Error = 5
+
+
+class RtintHdwMotorController:
+    def __init__(self, tg):
+        self._tg = tg
+        self._motors: dict[str, RtintHdwMotor] | None = None
+        self._load()
+
+    def __info__(self, debug=False):
+        if self._motors is None:
+            return "\n    No Motor in the model"
+
+        if debug:
+            lines = [
+                ["Name", "Path", "State", "Position", "Limits", "Velocity", "Acc. Time"]
+            ]
+        else:
+            lines = [["Name", "State", "Position"]]
+        for motor in self._motors.values():
+            if debug:
+                lines.append(
+                    [
+                        motor._name,
+                        motor._unique_name,
+                        motor.state.name,
+                        motor.position,
+                        (motor.limit_pos, motor.limit_neg),
+                        motor.velocity,
+                        motor.acc_time,
+                    ]
+                )
+            else:
+                lines.append([motor._name, motor.state.name, motor.position])
+        return "\n" + tabulate(lines, headers="firstrow", tablefmt="grid", stralign="left")
+
+    def _load(self):
+        motors = self._tg._get_all_objects_from_key("bliss_motor")
+        if len(motors) > 0:
+            self._motors = {}
+            for motor in motors:
+                tg_motor = RtintHdwMotor(self._tg, motor)
+
+                if hasattr(self, tg_motor._name):
+                    print(f"{RED}WARNING: Motor '{tg_motor._name}' already exists{RESET}")
+                    return
+                else:
+                    setattr(self, tg_motor._name, tg_motor)
+                    self._motors[tg_motor._name] = tg_motor
+
+
+class RtintHdwMotor:
+    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(["State", self.state.name])
+        lines.append(["Position", self.position])
+        lines.append(["", ""])
+        lines.append(["Velocity", self.velocity])
+        lines.append(["Acc. Time", self.acc_time])
+        lines.append(["Limit Neg.", self.limit_neg])
+        lines.append(["Limit Pos.", self.limit_pos])
+        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_motor/String")
+
+    def start(self):
+        val = self._tg.parameter.get(f"{self._unique_name}/start_trigger/Bias")
+        self._tg.parameter.set(
+            f"{self._unique_name}/start_trigger/Bias", val + 1
+        )
+
+    def stop(self):
+        val = self._tg.parameter.get(f"{self._unique_name}/stop_trigger/Bias")
+        self._tg.parameter.set(f"{self._unique_name}/stop_trigger/Bias", val + 1)
+
+    @property
+    def acc_time(self):
+        return float(self._tg.parameter.get(f"{self._unique_name}/acc_time"))
+
+    @acc_time.setter
+    def acc_time(self, acc_time):
+        self._tg.parameter.set(f"{self._unique_name}/acc_time", acc_time)
+
+    @property
+    def limit_neg(self):
+        return float(self._tg.parameter.get(f"{self._unique_name}/limit_neg"))
+
+    @limit_neg.setter
+    def limit_neg(self, limit_neg):
+        self._tg.parameter.set(f"{self._unique_name}/limit_neg", limit_neg)
+
+    @property
+    def limit_pos(self):
+        return float(self._tg.parameter.get(f"{self._unique_name}/limit_pos"))
+
+    @limit_pos.setter
+    def limit_pos(self, limit_pos):
+        self._tg.parameter.set(f"{self._unique_name}/limit_pos", limit_pos)
+
+    @property
+    def setpoint(self):
+        return float(self._tg.signal.get(f"{self._unique_name}/motor_setpoint"))
+
+    @setpoint.setter
+    def setpoint(self, setpoint):
+        if (
+            self._tg.parameter.get(
+                f"{self._unique_name}/select_setpoint/tracking_mode/Value"
+            )
+            != 0
+        ):
+            raise RuntimeError("Motor is in tracking mode")
+
+        self._tg.parameter.set(f"{self._unique_name}/setpoint", setpoint)
+
+    @property
+    def velocity(self):
+        return float(self._tg.parameter.get(f"{self._unique_name}/velocity"))
+
+    @velocity.setter
+    def velocity(self, velocity):
+        self._tg.parameter.set(f"{self._unique_name}/velocity", velocity)
+
+    @property
+    def position(self):
+        return float(self._tg.signal.get(f"{self._unique_name}/motor_position"))
+
+    @property
+    def state(self):
+        return MotorState(
+            int(self._tg.signal.get(f"{self._unique_name}/motor_state"))
+        )
+
+    @property
+    def position_encoder(self):
+        if self._tg.signal._tree.contains(f"{self._unique_name}/encoder_value"):
+            return float(
+                self._tg.signal.get(f"{self._unique_name}/encoder_value")
+            )
+
+    @property
+    def position_error(self):
+        if self._tg.signal._tree.contains(f"{self._unique_name}/error_value"):
+            return float(self._tg.signal.get(f"{self._unique_name}/error_value"))
+
+    def _activate_tracking(self, tracking_enable):
+        self._tg.parameter.set(
+            f"{self._unique_name}/select_setpoint/tracking_mode/Value", tracking_enable
+        )