rtint 0.0.3__py3-none-any.whl

rtint/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.0.3'
+__version_tuple__ = version_tuple = (0, 0, 3)
+
+__commit_id__ = commit_id = None

rtint/rtint_acquisition.py

@@ -0,0 +1,327 @@
+# -*- coding: utf-8 -*-
+#
+# This file is part of the mechatronic project
+#
+# Copyright (c) Beamline Control Unit, ESRF
+# Distributed under the GNU LGPLv3. See LICENSE for more info.
+
+import gevent
+import random
+import string
+import numpy as np
+
+from resyst.client.acq import Acq, AcqState
+from resyst.common.acq_conf import AcqConf
+from tabulate import tabulate
+
+from rtint.rtint_utils import status_message
+
+RED = "\033[31m"
+GREEN = "\033[32m"
+RESET = "\033[0m"
+
+
+class RtintHdwAcquisition:
+    def __init__(self, tg):
+        self._tg = tg
+        self._system = tg._system
+        self._program = tg._program
+
+        self._acq: Acq | None = None
+
+    def __info__(self, debug=False):
+        if len(self._program.acqs) == 0:
+            return "\n    No Loaded acquisition"
+
+        lines = [["Name", "State", "Decimation", "Nbp", "Signals"]]
+        for acq in self._program.acqs:
+            lines.append(
+                [
+                    acq.conf.name,
+                    acq.status.state.name,
+                    acq.conf.decimation,
+                    f"{acq.conf.nbp:d}",
+                    acq.conf.signal_paths[0][len(self._program.name) + 1 :],
+                ]
+            )
+            for i in range(1, len(acq.conf.signal_paths)):
+                lines.append(
+                    [
+                        "",
+                        "",
+                        "",
+                        "",
+                        acq.conf.signal_paths[i][len(self._program.name) + 1 :],
+                    ]
+                )
+        return "\n" + tabulate(lines, headers="firstrow", tablefmt="grid", stralign="left")
+
+    def prepare(
+        self,
+        nsample,
+        counter_list,
+        decimation=1,
+        name=None,
+        filter_path="",
+        start_path="",
+        start_pre_samples=0,
+    ):
+        return self._create_acq(
+            counter_list,
+            nsample,
+            decimation=decimation,
+            name=name,
+            filter_path=filter_path,
+            start_path=start_path,
+            start_pre_samples=start_pre_samples,
+        )
+
+    def prepare_time(
+        self,
+        time,
+        counter_list,
+        decimation=1,
+        name=None,
+        filter_path="",
+        start_path="",
+        start_pre_samples=0,
+    ):
+        nbp = int(time / self._tg._Ts / decimation)
+        return self._create_acq(
+            counter_list,
+            nbp,
+            decimation=decimation,
+            name=name,
+            filter_path=filter_path,
+            start_path=start_path,
+            start_pre_samples=start_pre_samples,
+        )
+
+    def start(self, wait=False, silent=True, name=None):
+        """Use to start the acquisition (the real-time target will start sending data)"""
+        self._program.start_acqs([self._get_acq_from_name(name)])
+
+        if wait:
+            self._wait_finished(silent=silent)
+
+    def stop(self, name=None):
+        acq = self._get_acq_from_name(name)
+        if acq is not None:
+            acq.stop()
+
+    def get_data(self, name=None, display=False, debug=False):
+        """
+        Used to get all data of an acquistion.
+        It will wait for the acquisition to be finished (i.e. all data are received by the Resyst server).
+        The acquisition is then removed from the server.
+        """
+        acq = self._get_acq_from_name(name)
+        result = {
+            self._tg.counter._get_counter_from_full_path(signal_path).name: []
+            for signal_path in acq.conf.signal_paths
+        }
+        timestamp = []
+
+        with status_message(enable=display) as update:
+            while (self._is_running(name)) or (acq.nb_sample_to_read > 0):
+                if acq.nb_sample_to_read > 0:
+                    n_to_read = acq.nb_sample_to_read
+                    data_acq = acq.get_data(n_to_read)
+                    timestamp.append(data_acq["timestamp"])
+
+                    for signal_path in acq.conf.signal_paths:
+                        counter_name = (
+                            self._tg.counter._get_counter_from_full_path(
+                                signal_path
+                            ).name
+                        )
+                        val = data_acq[signal_path]
+                        result[counter_name].append(val)
+
+                    update(
+                        f"Waiting Acquisition to terminate ({np.sum([t.size for t in timestamp])}/{acq.conf.nbp})"
+                    )
+
+                gevent.sleep(0.2)
+
+        # concatenate the bunches for each signal (so result looks like the old get_data)
+        for k in list(result.keys()):
+            result[k] = np.concatenate(result[k], axis=0)
+
+        if debug:
+            if self._is_finished(name):
+                print(
+                    "Acquisition correctly acquired all the points."
+                )
+            else:
+                print(
+                    "Acquisition was not finished (not all points could be acquired by the Resyst server)."
+                )
+
+            # Check if no point is missing by looking at the Timestamp
+            timestamp = np.concatenate(timestamp, axis=0)
+            timestamp_nom_value = 1e6 * (
+                self._tg._Ts * acq.conf.decimation
+            )  # Expected timestamp increase in [us]
+            step_diff = np.rint(
+                np.diff(timestamp) / timestamp_nom_value
+            )  # Should always be equal to one
+
+            # Check if there are some missing points
+            if not np.all(step_diff == 1):
+                print(
+                    f"WARNING: There are {np.sum(step_diff - 1)} missing points (maximum {np.max(step_diff) - 1} consecutive missing points)"
+                )
+
+            # Check if correct number of points
+            if (
+                len(
+                    result[
+                        self._tg.counter._get_counter_from_full_path(
+                            acq.conf.signal_paths[0]
+                        ).name
+                    ]
+                )
+                != acq.conf.nbp
+            ):
+                print(
+                    f"WARNING: Incorect number of points: ({len(result[self._tg.counter._get_counter_from_full_path(acq.conf.signal_paths[0]).name])}/{acq.conf.nbp})"
+                )
+
+        # Delete the acquisition (after all data have been retrieved)
+        self._program.remove_acq(acq.conf.name)
+
+        return result
+
+    def get_available_data(self, name=None, max_nbp=None):
+        acq = self._get_acq_from_name(name)
+        result = {}
+
+        # If max_nbp is specified, get at most this number of points
+        # Otherwise, get all the available points
+        if max_nbp is not None:
+            n_to_read = min(max_nbp, acq.nb_sample_to_read)
+        else:
+            n_to_read = acq.nb_sample_to_read
+
+        data_acq = acq.get_data(n_to_read)
+
+        for signal_path in acq.conf.signal_paths:
+            counter_name = self._tg.counter._get_counter_from_full_path(
+                signal_path
+            ).name
+            val = data_acq[signal_path]
+            result[counter_name] = val
+
+        return result
+
+    def _create_acq(
+        self,
+        counters,
+        nbp,
+        decimation=1,
+        name=None,
+        filter_path="",
+        start_path="",
+        start_pre_samples=0,
+    ):
+        """
+        Register one Acquisition on the Resyst server
+        """
+        if name is None:
+            # Create random name if not specified
+            name = "".join(random.choices(string.ascii_uppercase, k=5))
+
+        if filter_path != "" and start_path != "":
+            print(
+                "WARNING: filter_path and start_path cannot be used at the same time"
+            )
+            return
+
+        if filter_path != "":  # Trigerred acquisition
+            name = "trig_" + name
+            if decimation > 1:
+                print(
+                    "WARNING: When filter_path is used, decimation should be equal to 1"
+                )
+        elif start_path != "":  # Start Condition : Monitoring
+            name = "moni_" + name
+        else:  # Normal Acquisition
+            name = "acq_" + name
+
+        # Force no pre-samples when not using a start trigger
+        if start_path == "":
+            start_pre_samples = 0
+
+        acq_conf = AcqConf(
+            name=name,
+            signal_paths=[counter._full_path for counter in counters],
+            nbp=nbp,
+            decimation=decimation,
+            filter_path=filter_path,
+            start_path=start_path,
+            start_pre_samples=start_pre_samples,
+        )
+
+        # Automatically add the acquisition
+        self._acq = self._program.add_acq(acq_conf)
+        return name
+
+    def _remove_acqs(self, acq_prefix_name=""):
+        """
+        Delete configured acquisition on the Resyst server.
+        If acq_prefix_name is not specified, all the acquisitons are removed.
+        """
+        for acq in self._tg._program.acqs:
+            if acq.conf.name.startswith(acq_prefix_name):
+                self._program.remove_acq(acq.conf.name)
+
+    def _remove_finished_acqs(self):
+        """
+        Used to remove all 'done' acquisitions.
+        """
+        for acq in self._tg._program.acqs:
+            if acq.is_done:
+                self._program.remove_acq(acq.conf.name)
+
+    def _get_acq_from_name(self, name=None):
+        """
+        Utility function to easily get the wanted acquisition (or the last loaded one if name is None)
+        """
+        if name is None:
+            return self._acq  # Get the last loaded Acquisition
+        else:
+            acq_dict = {acq.conf.name: acq for acq in self._program.acqs}
+            return acq_dict[name]
+
+    def _is_running(self, name=None):
+        """
+        Returns whether the acquisition is currently acquiring data or not.
+        """
+        acq = self._get_acq_from_name(name)
+        return acq.status.state == AcqState.RUNNING
+
+    def _is_stopped(self, name=None):
+        acq = self._get_acq_from_name(name)
+        return acq.status.state == AcqState.STOP
+
+    def _is_finished(self, name=None):
+        """
+        This means that the Resyst server has received all the wanted data.
+        It is possible that the acquisition is stopped, but because not all data
+        has been received, _is_finished is False.
+        """
+        return self._get_acq_from_name(name).is_done
+
+    def _wait_finished(self, silent=True, name=None):
+        """
+        Blocking function that only returns when the acquisition is no longer running.
+        Could be because it has been manually stopped or because all data has been stored by the server.
+        """
+        acq = self._get_acq_from_name(name)
+        with status_message(enable=not silent) as update:
+            while self._is_running(name):
+                update(
+                    f"Waiting Acquisition to terminate ({acq.nb_sample_to_read}/{acq.conf.nbp})"
+                )
+                gevent.sleep(0.2)

rtint/rtint_counter.py

@@ -0,0 +1,202 @@
+# 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 COUNTERS
+"""
+
+import re
+from tabulate import tabulate
+
+RED = "\033[31m"
+GREEN = "\033[32m"
+RESET = "\033[0m"
+
+
+class RtintHdwCounterController:
+    def __init__(self, tg):
+        self._tg = tg
+        self._counters: dict[str, RtintHdwCounter] | None = None
+        self._load()
+
+    def __info__(self, debug=False):
+        """Display list of all counters"""
+        if self._counters is None:
+            return "\n    No Counter in the model"
+
+        if debug:
+            lines = [["Name", "Signal Path", "Value", "Unit", "Description"]]
+        else:
+            lines = [["Name", "Value", "Unit", "Description"]]
+        for counter in self._counters.values():
+            if debug:
+                lines.append(
+                    [
+                        counter.name,
+                        counter.path,
+                        counter._formated_value,
+                        counter.unit,
+                        counter.description,
+                    ]
+                )
+            else:
+                lines.append(
+                    [
+                        counter.name,
+                        counter._formated_value,
+                        counter.unit,
+                        counter.description,
+                    ]
+                )
+        return "\n" + tabulate(lines, headers="firstrow", tablefmt="grid", stralign="left")
+
+    def _load(self):
+        self._counters = {}
+        # Add custom counters defined in the YML file
+        counters_yml = self._tg._config.get("counters")
+        if counters_yml is not None:
+            for counter in counters_yml:
+                # Set defaults if not set in the YML file
+                counter.setdefault("description", None)
+                counter.setdefault("unit", None)
+                self._add_counter(
+                    counter["name"],
+                    counter["path"],
+                    description=counter["description"],
+                    unit=counter["unit"],
+                )
+        # Add counters defined in the Simulink file
+        pattern = re.compile(r"^(?P<name>.+?)_counter_$")
+
+        for signal_name, signal_obj in self._tg._program.tree.signals.items():
+            match = pattern.match(signal_obj.variable_name)
+            if not match:
+                continue
+
+            name = match.group("name")
+
+            counter_info = self._parse_signal_description(signal_obj.description)
+
+            # Unit corresponding to the counter
+            if "unit" in counter_info:
+                # Format unit because of forbiden characters in Simulink
+                unit = counter_info["unit"]
+                unit = unit.replace("_per_", "/")
+                unit = unit.replace("2", "^2")
+                unit = unit.replace("3", "^3")
+            else:
+                unit = None
+
+            # Description corresponding to the counter
+            if "description" in counter_info:
+                description = counter_info["description"]
+            else:
+                description = None
+
+            # Used to specify the display "format" of the counter
+            if "format_spec" in counter_info:
+                format_spec = counter_info["format_spec"]
+            else:
+                format_spec = None
+
+            self._add_counter(
+                name,
+                signal_obj.path[len(self._tg._program.name) + 1 :],
+                unit=unit,
+                description=description,
+                format_spec=format_spec,
+            )
+
+    def _parse_signal_description(self, desc_str: str) -> dict:
+        """
+        Parse a multiline description string containing lines like:
+          _desc: ...
+          _unit: ...
+          _disp: ...
+        Returns a dict without the leading underscores.
+        """
+        result = {}
+        for line in desc_str.splitlines():
+            line = line.strip()
+            if not line or ":" not in line:
+                continue
+
+            key, value = line.split(":", 1)
+            key = key.strip().lstrip("_")  # remove leading underscore
+            value = value.strip()
+
+            result[key] = value
+
+        return result
+
+    def _add_counter(
+        self, name, path, description=None, unit=None, format_spec=None, force=False
+    ):
+        # Verify signal path exists
+        try:
+            self._tg.signal.get(path)
+        except KeyError:
+            print(f"{RED}WARNING: Counter '{name}' has not a valid path{RESET}")
+            return
+        if force is False and name in self._counters:
+            print(
+                f"{RED}WARNING: Counter '{name}' already exists, use force=True to override{RESET}"
+            )
+            return
+        tg_counter = RtintHdwCounter(
+            self._tg,
+            name,
+            path,
+            description=description,
+            unit=unit,
+            format_spec=format_spec,
+        )
+        setattr(self, name, tg_counter)
+        self._counters[name] = tg_counter
+
+    def _get_counter_from_full_path(self, full_path):
+        for counter in self._counters.values():
+            if counter._full_path == full_path:
+                return counter
+        raise KeyError(f"No counter with full_path={full_path}")
+
+
+class RtintHdwCounter:
+    """Real-time target counter - Has name, description, unit and value"""
+
+    def __init__(
+        self, tg, name, path, description=None, unit=None, format_spec=None
+    ):
+        self._tg = tg
+        self.name = name
+        self.path = path
+        self.description = description
+        self.unit = unit
+        self.format_spec = format_spec
+
+    def __info__(self):
+        lines = []
+        lines.append(["Name", self.name])
+        lines.append(["Description", self.description])
+        lines.append(["Unit", self.unit])
+        lines.append(["Path", self.path])
+        lines.append(["", ""])
+        lines.append(["Counter Value", self._formated_value])
+        return tabulate(lines, tablefmt="plain", stralign="right")
+
+    @property
+    def _full_path(self):
+        return f"{self._tg._program.name}/{self.path}"
+
+    @property
+    def value(self):
+        return self._tg.signal.get(self.path)
+
+    @property
+    def _formated_value(self):
+        if self.format_spec is None:
+            return repr(self.value)
+        else:
+            return f"{self.value:{self.format_spec}}"

rtint/rtint_ethercat.py

@@ -0,0 +1,127 @@
+# -*- coding: utf-8 -*-
+#
+# This file is part of the mechatronic project
+#
+# Copyright (c) Beamline Control Unit, ESRF
+# Distributed under the GNU LGPLv3. See LICENSE for more info.
+
+import enum
+import gevent
+import time
+from tabulate import tabulate
+
+from rtint.rtint_utils import status_message
+
+RED = "\033[31m"
+GREEN = "\033[32m"
+RESET = "\033[0m"
+
+"""
+REAL-TIME TARGET EtherCAT
+"""
+
+
+class EthercatState(enum.IntEnum):
+    INIT = 1
+    PREOP = 2
+    SAFEOP = 4
+    OP = 8
+
+
+class RtintHdwEthercatController:
+    def __init__(self, tg):
+        self._tg = tg
+        self._ethercats: dict[str, RtintHdwEthercat] | None = None
+        self._load()
+
+    def __info__(self, debug=False):
+        if self._ethercats is None:
+            return "\n    No EtherCAT network in the model"
+
+        if debug:
+            lines = [["Name", "Path", "State"]]
+        else:
+            lines = [["Name", "State"]]
+
+        for _ethercat in self._ethercats.values():
+            if debug:
+                lines.append(
+                    [
+                        _ethercat._name,
+                        _ethercat._unique_name,
+                        EthercatState(_ethercat.state).name,
+                    ]
+                )
+            else:
+                lines.append([_ethercat._name, EthercatState(_ethercat.state).name])
+        return "\n" + tabulate(lines, headers="firstrow", tablefmt="grid", stralign="left")
+
+    def _load(self):
+        ethercats = self._tg._get_all_objects_from_key("bliss_ethercat")
+        if len(ethercats) > 0:
+            self._ethercats = {}
+            for ethercat in ethercats:
+                tg_ethercat = RtintHdwEthercat(self._tg, ethercat)
+
+                if hasattr(self, tg_ethercat._name):
+                    print(
+                        f"{RED}WARNING: ethercat '{tg_ethercat._name}' already exists{RESET}"
+                    )
+                    return
+                else:
+                    setattr(self, tg_ethercat._name, tg_ethercat)
+                    self._ethercats[tg_ethercat._name] = tg_ethercat
+
+
+class RtintHdwEthercat:
+    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", EthercatState(self.state).name])
+        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_ethercat/String"
+        )
+
+    @property
+    def state(self):
+        return self._tg.signal.get(f"{self._unique_name}/MasterState")
+
+    def set_state(self, state, wait=False, display=False, timeout=10):
+        self._tg.parameter.set(f"{self._unique_name}/wanted_state/Value", state)
+        self._tg.parameter.set(
+            f"{self._unique_name}/state_trigger/Bias",
+            self._tg.parameter.get(f"{self._unique_name}/state_trigger/Bias")
+            + 1,
+        )
+
+        if wait is True:
+            start_time = time.time()  # Here we suppose the acquisition has just started
+            with status_message(enable=display) as update:
+                while self.state != state:
+                    if display is True:
+                        update(f"Current State: {EthercatState(self.state).name}")
+                    gevent.sleep(0.2)
+                    if time.time() - start_time > timeout:
+                        raise TimeoutError("Timeout while changing the EtherCAT State")
+                if display is True:
+                    update(f"Current State: {EthercatState(self.state).name}")