cgse 0.17.2__tar.gz → 0.17.4__tar.gz

{cgse-0.17.2 → cgse-0.17.4}/CHANGELOG.md

@@ -8,6 +8,19 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ## [Unreleased]
 
+## [0.17.4] - 2026-01-27
+
+- Extracting HK from Ariel facility database
+- Re-shuffled hexapod settings
+- Cleaned up cgse-coordinates
+- Maintenance on cgse-core
+- Implementation of Digilent MEASURpoint DT8874
+
+
+## [0.17.3] - 2025-11-29
+
+In the previous release, uncommitted and untracked files were released by mistake. This release fixes this. Nothings has been changed with respect of release 0.17.2, except the removal of the uncommitted and untracked files.
+
 
 ## [0.17.2] - 2025-11-28
 
@@ -28,9 +41,9 @@ This release is mainly on maintenance and improvements to the `cgse-common` pack
 - Changed the return value of the different `get_version_*()` functions to return "0.0.0" when the version cannot 
   be determined. Previously, these functions returned None. [#215]
 - Improvements to `redirect_output_to_log()`: the file can be an absolute path, added a guard to overwrite [#217]
-- A warning message is now logged when you try to read the last few lines from a non-existing file 
+- A warning message is now logged when you try to read the last few lines from a non-existing file [#218]
 - InitializationError = InitialisationError, to be conform to the styling guide promoting the use of standard 
-  American English for code, comments  and docs 
+  American English for code, comments  and docs [#218]
 
 ### Added
 - Added a `from_string()` class method to Settings. This is mainly for testing and when you need to load 
@@ -197,7 +210,9 @@ This release is mainly on maintenance and improvements to the `cgse-common` pack
 - Renamed `cgse` subcommands `registry` →  `reg`, `notify` →  `not`.
 
 
-[Unreleased]: https://github.com/IvS-KULeuven/cgse/compare/v0.17.1...HEAD
+[Unreleased]: https://github.com/IvS-KULeuven/cgse/compare/v0.17.3...HEAD
+[0.17.3]: https://github.com/IvS-KULeuven/cgse/compare/v0.17.2...v0.17.3
+[0.17.2]: https://github.com/IvS-KULeuven/cgse/compare/v0.17.1...v0.17.2
 [0.17.1]: https://github.com/IvS-KULeuven/cgse/compare/v0.17.0...v0.17.1
 [0.17.0]: https://github.com/IvS-KULeuven/cgse/compare/v0.16.14...v0.17.0
 [0.16.14]: https://github.com/IvS-KULeuven/cgse/compare/v0.16.13...v0.16.14
@@ -216,6 +231,8 @@ This release is mainly on maintenance and improvements to the `cgse-common` pack
 [0.16.1]: https://github.com/IvS-KULeuven/cgse/compare/v0.16.0...v0.16.1
 [0.16.0]: https://github.com/IvS-KULeuven/cgse/compare/v0.15.1...v0.16.0
 
+[#219]: https://github.com/IvS-KULeuven/cgse/pull/219
+[#218]: https://github.com/IvS-KULeuven/cgse/pull/218
 [#217]: https://github.com/IvS-KULeuven/cgse/pull/217
 [#216]: https://github.com/IvS-KULeuven/cgse/pull/216
 [#215]: https://github.com/IvS-KULeuven/cgse/pull/215

{cgse-0.17.2 → cgse-0.17.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cgse
-Version: 0.17.2
+Version: 0.17.4
 Summary: Generic Common-EGSE: Commanding and monitoring lab equipment
 Author: IvS KU Leuven
 Maintainer-email: Rik Huygen <rik.huygen@kuleuven.be>, Sara Regibo <sara.regibo@kuleuven.be>

{cgse-0.17.2 → cgse-0.17.4/docs/admin_guide}/make-a-release.md

@@ -1,26 +1,65 @@
+## Making a release
 
-(also check the docs: [Building and publishing packages](https://ivs-kuleuven.github.io/cgse/dev_guide/uv/#building-and-publishing-all-packages))
+The first thing to do is to properly format your code changes, run:
 
-## Making a release
+```bash
+uvx ruff format
+```
+
+You should be on the branch with the developments that you want to push and merge the pull request on GitHub before making the release.
 
-- run `uvx ruff format`
 - commit all changes with a proper message
+- push changes to `origin`
+- create a pull request (possibly needs a review)
+- merge the pull request
+
+When all pull requests that should go into the release are merged, checkout main again and pull all the latest changes:
+
+```bash
+git checkout main
+git pull upstream main
+```
+
+Now, create the release branch: e.g. `release/v0.17.3`
+
+- `git checkout -b release/v0.17.3`
 - add all notable changes to the CHANGELOG file
   - fix the links in the headers if needed
   - add links to the different pull requests
   - commit the CHANGELOG file
 - bump the version number: `uv run bump.py [patch|minor|major]`
 - commit all `pyproject.toml` files after the version bump
-- push the changes to the dedicated branch (I use PyCharm for this)
+- push the changes to `origin`
 - create (and merge) a pull request, use the CHANGELOG as description
+
+In order to prevent publishing all remaining uncommitted changes and untracked files too, stash all changes and untracked files:
+
+```bash
+git stash push -u -m "All development work"
+```
+
+## Publish the new release
+
+(also check the docs: [Building and publishing packages](https://ivs-kuleuven.github.io/cgse/dev_guide/uv/#building-and-publishing-all-packages))
+
+Now, build and publish the packages:
+
 - remove the old distributions: `rm -r dist`
 - build the packages: `uv build --all-packages`
 - publish the packages to PyPI: `uv publish --token $UV_PUBLISH_TOKEN`
 
+Put back the changes and untracked files:
+
+```bash
+git checkout main
+git pull upstream main
+git stash pop
+```
 
 ## Tag the new release
 
 - create a tag for the commit of the bump: `git tag <version number> <commit hash>`, e.g. `git tag v0.16.0 559bbfc`
+    - you can find the commit hash with: `git log --oneline`
 - push the tag to upstream: `git push upstream <tag name>`, e.g. `git push upstream v0.16.0`
 
 

{cgse-0.17.2 → cgse-0.17.4}/libs/cgse-common/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cgse-common"
-version = "0.17.2"
+version = "0.17.4"
 description = "Software framework to support hardware testing"
 authors = [
     {name = "IvS KU Leuven"}

{cgse-0.17.2 → cgse-0.17.4}/libs/cgse-common/src/egse/hk.py

@@ -51,8 +51,8 @@ class TmDictionaryColumns(str, Enum):
     """  # noqa
 
     STORAGE_MNEMONIC = "Storage mnemonic"
-    CORRECT_HK_NAMES = "CAM EGSE mnemonic"
-    ORIGINAL_EGSE_HK_NAMES = "Original name in EGSE"
+    CORRECT_HK_NAMES = "CGSE mnemonic"
+    ORIGINAL_EGSE_HK_NAMES = "Original name in CGSE"
     SYNOPTICS_ORIGIN = f"Origin of synoptics at {get_site_id()}"
     TIMESTAMP_NAMES = "Name of corresponding timestamp"
     DESCRIPTION = "Description"

{cgse-0.17.2 → cgse-0.17.4}/libs/cgse-common/src/egse/log.py

@@ -131,6 +131,14 @@ for handler in root_logger.handlers:
         handler.addFilter(NonEGSEFilter())
         handler.addFilter(PackageFilter())
 
+try:
+    from textual.logging import TextualHandler
+
+    root_logger.addHandler(TextualHandler())
+except ImportError:
+    pass
+
+
 logger = egse_logger
 
 if __name__ == "__main__":

{cgse-0.17.2 → cgse-0.17.4}/libs/cgse-common/src/egse/socketdevice.py

@@ -17,6 +17,9 @@ from egse.device import DeviceTransport
 from egse.log import logger
 from egse.system import type_name
 
+SEPARATOR = b"\x03"
+SEPARATOR_STR = SEPARATOR.decode()
+
 
 class SocketDevice(DeviceConnectionInterface, DeviceTransport):
     """Base class that implements the socket interface."""
@@ -33,7 +36,7 @@ class SocketDevice(DeviceConnectionInterface, DeviceTransport):
         port: int,
         connect_timeout: float = 3.0,
         read_timeout: float | None = 1.0,
-        separator: str = b"\x03",
+        separator: bytes = SEPARATOR,
     ):
         super().__init__()
         self.is_connection_open = False
@@ -92,8 +95,6 @@ class SocketDevice(DeviceConnectionInterface, DeviceTransport):
             raise ConnectionError(f"{self.device_name}: socket address info error for {self.hostname}") from exc
         except socket.herror as exc:
             raise ConnectionError(f"{self.device_name}: socket host address error for {self.hostname}") from exc
-        except socket.timeout as exc:
-            raise TimeoutError(f"{self.device_name}: socket timeout error for {self.hostname}:{self.port}") from exc
         except OSError as exc:
             raise ConnectionError(f"{self.device_name}: OSError caught ({exc}).") from exc
 
@@ -269,7 +270,7 @@ class AsyncSocketDevice(AsyncDeviceInterface, AsyncDeviceTransport):
         port: int,
         connect_timeout: float = 3.0,
         read_timeout: float | None = 1.0,
-        separator: str = b"\x03",
+        separator: bytes = SEPARATOR,
     ):
         super().__init__()
         self.hostname = hostname

{cgse-0.17.2 → cgse-0.17.4}/libs/cgse-common/src/egse/system.py

@@ -2283,6 +2283,11 @@ def kebab_to_title(kebab_str: str) -> str:
     return kebab_str.replace("-", " ").title()
 
 
+def title_to_kebab(title_str: str) -> str:
+    """Convert Title Case (each word capitalized) to kebab-case"""
+    return title_str.replace(" ", "-").lower()
+
+
 def snake_to_title(snake_str: str) -> str:
     """Convert snake_case to Title Case (each word capitalized)"""
     return snake_str.replace("_", " ").title()

{cgse-0.17.2 → cgse-0.17.4}/libs/cgse-coordinates/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cgse-coordinates"
-version = "0.17.2"
+version = "0.17.4"
 description = "Reference Frames and Coordinate Transofrmations for CGSE"
 authors = [
     {name = "IvS KU Leuven"}
@@ -28,8 +28,8 @@ dependencies = [
 [project.entry-points."cgse.version"]
 cgse-coordinates = 'egse.version:get_version_installed'
 
-[project.entry-points."cgse.settings"]
-cgse-coordinates = "cgse_coordinates:settings.yaml"
+#[project.entry-points."cgse.settings"]
+#cgse-coordinates = "cgse_coordinates:settings.yaml"
 
 [tool.pytest.ini_options]
 pythonpath = "src"

cgse-0.17.4/libs/cgse-coordinates/src/egse/coordinates/__init__.py

@@ -0,0 +1,229 @@
+import ast
+import logging
+import re
+from typing import Dict
+from typing import List
+from typing import Optional
+from typing import Union
+
+import numpy as np
+from egse.setup import navdict
+
+logger = logging.getLogger(__name__)
+
+
+def dict_to_ref_model(model_def: Union[Dict, List]) -> navdict:
+    """Creates a reference frames model from a dictionary or list of reference frame definitions.
+
+    When a list is provided, the items in the list must be ReferenceFrames.
+
+    The reference frame definitions are usually read from a YAML file or returned by a Setup, but can also be just
+    ReferenceFrame objects.
+
+    ReferenceFrame definitions have the following format:
+
+    ```
+    ReferenceFrame://(<definition>)
+    ```
+    where `<definition>` has the following elements, separated by '` | `':
+    * a translation matrix
+    * a rotation matrix
+    * the name of the reference frame
+    * the name of the reference for this reference frame
+    * a dictionary of links
+
+    Args:
+        model_def (dict or list): Definition of the reference model.
+
+    Returns:
+        Dictionary representing the reference frames model.
+    """
+
+    ref_model = navdict()
+    ref_links = {}
+
+    from egse.coordinates.reference_frame import ReferenceFrame
+
+    def create_ref_frame(name, data) -> Union[ReferenceFrame, str]:
+        # This is a recursive function that creates a reference frame based on the given data.
+        # * When the data is already a ReferenceFrame, it just returns data
+        # * When data starts with the special string `ReferenceFrame//`, the data string is parsed
+        #   and a corresponding ReferenceFrame is returned
+        # * When there is no match, the data is returned unaltered.
+        #
+        # SIDE EFFECT:
+        # * In the process, the outer ref-model and ref_links are updated.
+
+        if isinstance(data, ReferenceFrame):
+            return data
+
+        match = re.match(r"ReferenceFrame//\((.*)\)$", data)
+        if not match:
+            return data
+
+        translation, rotation, name, ref_name, links = match[1].split(" | ")
+
+        # All links are processed later
+
+        ref_links[name] = ast.literal_eval(links)
+
+        if ref_name == name == "Master":
+            ref_model.add(ref_name, ReferenceFrame.create_master())
+            return ref_model["Master"]
+
+        if ref_name not in ref_model:
+            ref_model.add(ref_name, create_ref_frame(ref_name, model_def[ref_name]))
+
+        ref_frame = ReferenceFrame.from_translation_rotation(
+            deserialize_array(translation),
+            deserialize_array(rotation),
+            name=name,
+            reference_frame=ref_model[ref_name],
+        )
+
+        return ref_frame
+
+    # if the given model_def is a list, turn it into a dict
+
+    if isinstance(model_def, list):
+        model_def = {frame.name: frame for frame in model_def}
+
+    for key, value in model_def.items():
+        if key not in ref_model:
+            ref_model.add(key, create_ref_frame(key, value))
+
+    # Process all the links
+
+    for ref_name, link_names in ref_links.items():
+        ref = ref_model[ref_name]
+        for link_name in link_names:
+            if link_name not in ref.linked_to:
+                ref.add_link(ref_model[link_name])
+
+    return ref_model
+
+
+def ref_model_to_dict(ref_model) -> navdict:
+    """Creates a dictionary with reference frames definitions that define a reference model.
+
+    Args:
+        ref_model: A dictionary representing the reference frames model or a list of reference frames.
+
+    Returns:
+        Dictionary of reference frame definitions.
+    """
+
+    if isinstance(ref_model, dict):
+        ref_model = ref_model.values()
+
+    # take each key (which is a reference frame) and serialize it
+
+    model_def = {}
+
+    for ref in ref_model:
+        translation, rotation = ref.get_translation_rotation_vectors()
+        links = [ref.name for ref in ref.linked_to]
+        model_def[ref.name] = (
+            f"ReferenceFrame//("
+            f"{serialize_array(translation, precision=6)} | "
+            f"{serialize_array(rotation, precision=6)} | "
+            f"{ref.name} | "
+            f"{ref.reference_frame.name} | "
+            f"{links})"
+        )
+
+    return navdict(model_def)
+
+
+def serialize_array(arr: Union[np.ndarray, list], precision: int = 4) -> str:
+    """Returns a string representation of a numpy array.
+
+    >>> serialize_array([1,2,3])
+    '[1, 2, 3]'
+    >>> serialize_array([[1,2,3], [4,5,6]])
+    '[[1, 2, 3], [4, 5, 6]]'
+    >>> serialize_array([[1,2.2,3], [4.3,5,6]])
+    '[[1.0000, 2.2000, 3.0000], [4.3000, 5.0000, 6.0000]]'
+    >>> serialize_array([[1,2.2,3], [4.3,5,6]], precision=2)
+    '[[1.00, 2.20, 3.00], [4.30, 5.00, 6.00]]'
+
+    Args:
+        arr: One- or-two dimensional numpy array or list.
+        precision (int): number of digits of precision
+    Returns:
+        A string representing the input array.
+    """
+    if isinstance(arr, list):
+        arr = np.array(arr)
+    msg = np.array2string(
+        arr,
+        separator=", ",
+        suppress_small=True,
+        formatter={"float_kind": lambda x: f"{x:.{precision}f}"},
+    ).replace("\n", "")
+    return msg
+
+
+def deserialize_array(arr_str: str) -> Optional[np.ndarray]:
+    """Returns a numpy array from the given string.
+
+    The input string is interpreted as a one or two-dimensional array, with commas or spaces separating the columns,
+    and semicolons separating the rows.
+
+    >>> deserialize_array('1,2,3')
+    array([1, 2, 3])
+    >>> deserialize_array('1 2 3')
+    array([1, 2, 3])
+    >>> deserialize_array('1,2,3;4,5,6')
+    array([[1, 2, 3],
+           [4, 5, 6]])
+    >>> deserialize_array("[[1,2,3], [4,5,6]]")
+    array([[1, 2, 3],
+           [4, 5, 6]])
+
+    Args:
+        arr_str: String representation of a numpy array.
+
+    Returns:
+        One- or two-dimensional numpy array or `None` when input string cannot be parsed into a numpy array.
+    """
+
+    import re
+
+    arr_str = re.sub(r"\],\s*\[", "];[", arr_str)
+    try:
+        arr = np.array(_convert_from_string(arr_str))
+        return arr if ";" in arr_str else arr.flatten()
+    except ValueError as exc:
+        logger.error(f"Input string could not be parsed into a numpy array: {exc}")
+    return None
+
+
+def _convert_from_string(data: str) -> list[list]:
+    # This function was copied from:
+    #   https://github.com/numpy/numpy/blob/v1.19.0/numpy/matrixlib/defmatrix.py#L14
+    # We include the function here because the np.matrix class is deprecated and will be removed.
+    # This function is what we actually needed from np.matrix.
+
+    # This function can be replaced with np.fromstring()
+
+    for char in "[]":
+        data = data.replace(char, "")
+
+    rows = data.split(";")
+    new_data = []
+    count = 0
+    for row in rows:
+        trow = row.split(",")
+        new_row = []
+        for col in trow:
+            temp = col.split()
+            new_row.extend(map(ast.literal_eval, temp))
+        if count == 0:
+            n_cols = len(new_row)
+        elif len(new_row) != n_cols:
+            raise ValueError("Rows not the same size.")
+        count += 1
+        new_data.append(new_row)
+
+    return new_data

cgse-0.17.4/libs/cgse-coordinates/src/egse/coordinates/avoidance.py

@@ -0,0 +1,91 @@
+import numpy as np
+
+from egse.coordinates.point import Points
+from egse.coordinates.reference_frame import ReferenceFrame
+from egse.setup import Setup, load_setup
+
+
+def is_avoidance_ok(hexusr: ReferenceFrame, hexobj: ReferenceFrame, setup: Setup = None, verbose: bool = False):
+    """Checks whether the FPA is outside the avoidance volume around L6.
+
+    This function is used to verify that a requested movement of the PUNA hexapod will not cause the FPA to enter the
+    avoidance volume around L6.
+
+
+    Args:
+        hexusr (ReferenceFrame): User Reference Frame for the PUNA hexapod.  Its xy-plane corresponds to the maximum
+                                 height of FPA_SEN.  Its z-axis points away from the FPA.
+        hexobj (ReferenceFrame): Object Reference Frame for the PUNA hexapod.  Its xy-plane coincides with FPA_SEN. Its
+                                 z-axis points towards L6.
+        setup (Setup): Setup object containing the default reference frames.
+        verbose (bool): Indicates whether to print verbose output.
+
+    Returns:
+        True if the FPA is outside the avoidance volume around L6; False otherwise.
+    """
+
+    setup = setup or load_setup()
+
+    # A. HORIZONTAL AVOIDANCE
+    # Ensure that the centre of L6, materialised by HEX_USR (incl. z-direction security wrt TOU_L6) stays within a
+    # given radius of the origin of FPA_SEN
+
+    # Clearance = the tolerance in every horizontal direction (3 mm; PLATO-KUL-PL-ICD-0001 v1.2)
+    clearance_xy = setup.camera.fpa.avoidance.clearance_xy
+
+    # Projection of the origin of HEX_USR on the xy-plane of FPA_SEN
+    l6xy = hexusr.get_origin().express_in(hexobj)[:2]
+
+    # !! This is a verification of the current situation
+    # -> need to replace by a simulation of the forthcoming movement in the building block
+    horizontal_check = (l6xy[0] ** 2.0 + l6xy[1] ** 2.0) < clearance_xy * clearance_xy
+
+    # B. VERTICAL AVOIDANCE
+    # Ensure that the CCD never hits L6.
+    #   - The definition of HEX_USR includes a tolerance below L6 (1.65 mm).
+    #   - We include a tolerance above FPA_SEN here (0.3 mm).
+    #   - We define a collection of points to act at the vertices. of the avoidance volume above the FPA
+
+    # Clearance = vertical uncertainty on the CCD location (0.3 mm; PLATO-KUL-PL-ICD-0001 v1.2)
+    clearance_z = setup.camera.fpa.avoidance.clearance_z
+
+    # Vertices = Points representing the vertices of the avoidance volume above the FPA (60)
+    vertices_nb = setup.camera.fpa.avoidance.vertices_nb
+    # All vertices are on a circle of radius 'vertices_radius' (100 mm)
+    vertices_radius = setup.camera.fpa.avoidance.vertices_radius
+
+    angles = np.linspace(0, np.pi * 2, vertices_nb, endpoint=False)
+    vertices_x = np.cos(angles) * vertices_radius
+    vertices_y = np.sin(angles) * vertices_radius
+    vertices_z = np.ones_like(angles) * clearance_z
+
+    # The collection of points defining the avoidance volume around FPA_SEN
+
+    vert_obj = Points(
+        coordinates=np.array([vertices_x, vertices_y, vertices_z]), reference_frame=hexobj, name="vert_obj"
+    )
+
+    # Their coordinates in HEX_USR
+    # NB: vert_obj is a Points object, vert_usr is an array
+    vert_usr = vert_obj.express_in(hexusr)
+
+    # !! Same as above : this is verifying the current situation, not the one after a planned movement
+    # Verify that all vertices ("protecting" FPA_SEN) are below the x-y plane of HEX_USR ("protecting" L6)
+    vertical_check = np.all(vert_usr[2, :] < 0.0)
+
+    if verbose:
+        printdict = {True: "OK", False: "NOT OK"}
+        print(f"HORIZONTAL AVOIDANCE: {printdict[horizontal_check]}")
+        print(f" VERTICAL  AVOIDANCE: {printdict[vertical_check]}")
+
+    if verbose > 1:
+        print(f"Points Coordinates")
+        coobj = vert_obj.coordinates
+        for i in range(vertices_nb):
+            print(f"{i} OBJ {np.round(coobj[:3, i], 6)} --> USR {np.round(vert_usr[:3, i], 6)}")
+        vert_z = vert_usr[2, :]
+        vert_zi = np.where(vert_z == np.max(vert_z))
+        print(f"#vertices at max z : {len(vert_zi[0])}")
+        print(f"First one: vertex {vert_zi[0][0]} : {np.round(vert_usr[:3, vert_zi[0][0]], 6)}")
+
+    return horizontal_check and vertical_check

cgse-0.17.4/libs/cgse-coordinates/src/egse/coordinates/cslmodel.py

@@ -0,0 +1,118 @@
+"""
+A CSL reference frame model which has knowledge about the CSL Setup, and the PUNA Hexapod model.
+
+The CSL Reference Frame Model incorporates a Hexapod PUNA model which is represented by the
+Reference Frames HEXUSR, HEXOBJ, HEXMEC, and HEXPLT. A number of methods are defined here that
+assume these four reference frames exist in the model and behave like a proper hexapod simulator.
+Those methods start with the name `hexapod_`, e.g. `hexapod_goto_zero_position()`.
+
+"""
+
+import numpy as np
+from egse.coordinates.refmodel import ReferenceFrameModel
+
+HEXUSR = "hexusr"
+HEXMEC = "hexmec"
+HEXOBJ = "hexobj"
+HEXPLT = "hexplt"
+HEXOBUSR = "hexobusr"
+
+
+class CSLReferenceFrameModel(ReferenceFrameModel):
+    """
+    The CSL reference Frame Model is a specific reference model that adds convenience methods for manipulating the
+    Hexapod PUNA which is part of the overall CSL Setup.
+    """
+
+    _DEGREES_DEFAULT = ReferenceFrameModel._DEGREES_DEFAULT
+
+    def _create_obusr(self) -> None:
+        """Creates the Object User Reference Frame if it does not exist yet."""
+
+        if HEXOBUSR in self:
+            return
+
+        hexusr = self.get_frame(HEXUSR)
+        hexobj = self.get_frame(HEXOBJ)
+
+        transformation = hexusr.get_active_transformation_to(hexobj)
+
+        self.add_frame(HEXOBUSR, transformation=transformation, reference=HEXUSR)
+        self.add_link(HEXOBUSR, HEXOBJ)
+
+    def hexapod_move_absolute(self, translation: np.ndarray, rotation: np.ndarray, degrees: bool = _DEGREES_DEFAULT):
+        """Moves/defines the Object Coordinate System expressed in the invariant User Coordinate System.
+
+        The rotation centre coincides with the Object Coordinates System origin and the movements are controlled with
+        translation components first (Tx, Ty, tZ) and then the rotation components (Rx, Ry, Rz).
+
+        Args:
+            translation (np.ndarray): Translation vector.
+            rotation (np.ndarray): Rotation vector.
+            degrees (bool): Indicates whether the rotation angles are specified in degrees, rather than radians.
+        """
+
+        self.move_absolute_self(HEXOBUSR, translation, rotation, degrees=degrees)
+
+    def hexapod_move_relative_object(
+        self, translation: np.ndarray, rotation: np.ndarray, degrees: bool = _DEGREES_DEFAULT
+    ):
+        """Moves the object relative to its current position and orientation
+
+        The relative movement is expressed in the object coordinate system.
+
+        Args:
+            translation (np.ndarray): Translation vector.
+            rotation (np.ndarray): Rotation vector.
+            degrees (bool): Indicates whether the rotation angles are specified in degrees, rather than radians.
+        """
+
+        self.move_relative_self(HEXOBJ, translation, rotation, degrees=degrees)
+
+    def hexapod_move_relative_user(
+        self, translation: np.ndarray, rotation: np.ndarray, degrees: bool = _DEGREES_DEFAULT
+    ) -> None:
+        """Moves the object relative to its current object position and orientation.
+
+        The relative movement is expressed in the (invariant) user coordinate system.
+
+        Args:
+            translation (np.ndarray): Translation vector.
+            rotation (np.ndarray): Rotation vector.
+            degrees (bool): Indicates whether the rotation angles are specified in degrees, rather than radians.
+        """
+
+        self.move_relative_other_local(HEXOBJ, HEXUSR, translation, rotation, degrees=degrees)
+
+    def hexapod_configure_coordinates(
+        self,
+        usr_trans: np.ndarray,
+        usr_rot: np.ndarray,
+        obj_trans: np.ndarray,
+        obj_rot: np.ndarray,
+    ) -> None:
+        """Changes the definition of the User Coordinate System and the Object Coordinate System in the hexapod.
+
+        Args:
+            usr_trans (np.ndarray): Translation vector used to define the User Coordinate System relative to the Machine Coordinate System.
+            usr_rot (np.ndarray): Rotation vector used to define the User Coordinate System relative to the Machine Coordinate System.
+            obj_trans (np.ndarray): Translation vector used to define the Object Coordinate System relative to the Platform Coordinate System.
+            obj_rot (np.ndarray): Rotation vector used to define the Object Coordinate System relative to the Platoform Coordinate System.
+        """
+
+        self.remove_link(HEXUSR, HEXMEC)
+        self.remove_link(HEXOBJ, HEXPLT)
+        self.get_frame(HEXUSR).set_translation_rotation(usr_trans, usr_rot)
+        self.get_frame(HEXOBJ).set_translation_rotation(obj_trans, obj_rot)
+        self.add_link(HEXUSR, HEXMEC)
+        self.add_link(HEXOBJ, HEXPLT)
+
+    def hexapod_goto_zero_position(self) -> None:
+        """Instructs the hexapod to go to its zero position"""
+
+        self.move_absolute_self(HEXPLT, translation=np.array([0, 0, 0]), rotation=np.array([0, 0, 0]))
+
+    def hexapod_goto_retracted_position(self) -> None:
+        """Instructs the hexapod to go to its retracted position."""
+
+        self.move_absolute_self(HEXPLT, translation=np.array([0, 0, -20]), rotation=np.array([0, 0, 0]))