symetrie-hexapod 2023.1.0__py3-none-any.whl

egse/hexapod/symetrie/hexapod_ui.py

@@ -0,0 +1,1509 @@
+import logging
+from typing import Dict
+from typing import List
+from typing import Optional
+from typing import Union
+
+from PyQt5.QtCore import QEvent
+from PyQt5.QtCore import QSize
+from PyQt5.QtCore import QTimer
+from PyQt5.QtCore import Qt
+from PyQt5.QtGui import QIcon
+from PyQt5.QtGui import QPixmap
+from PyQt5.QtWidgets import QAction
+from PyQt5.QtWidgets import QComboBox
+from PyQt5.QtWidgets import QFrame
+from PyQt5.QtWidgets import QGroupBox
+from PyQt5.QtWidgets import QHBoxLayout
+from PyQt5.QtWidgets import QLabel
+from PyQt5.QtWidgets import QLineEdit
+from PyQt5.QtWidgets import QMainWindow
+from PyQt5.QtWidgets import QPushButton
+from PyQt5.QtWidgets import QSizePolicy
+from PyQt5.QtWidgets import QTabWidget
+from PyQt5.QtWidgets import QVBoxLayout
+from PyQt5.QtWidgets import QWidget
+
+from egse.decorators import deprecate
+from egse.gui import show_warning_message
+from egse.gui.buttons import ToggleButton
+from egse.gui.buttons import TouchButton
+from egse.gui.led import LED
+from egse.gui.led import ShapeEnum
+from egse.observer import Observable
+from egse.observer import Observer
+from egse.resource import get_resource
+from egse.state import UnknownStateError
+
+MODULE_LOGGER = logging.getLogger(__name__)
+
+
+class VLine(QFrame):
+    """Presents a simple Vertical Bar that can be used in e.g. the status bar."""
+
+    def __init__(self):
+        super().__init__()
+        self.setFrameShape(self.VLine | self.Sunken)
+
+
+class Container(QWidget):
+    """
+    An empty container that is used currently as a place-holder for a QWidget that is to be
+    implemented.
+    """
+
+    def __init__(self, text):
+        super().__init__()
+
+        self.hbox = QHBoxLayout()
+        self.hbox.setSpacing(0)
+        self.hbox.setContentsMargins(0, 0, 0, 0)
+        self.setLayout(self.hbox)
+
+        self.button = QPushButton(text)
+        self.hbox.addWidget(self.button)
+
+
+class ValidationIcon(QWidget):
+    """
+    This Icon is used
+    """
+
+    def __init__(self):
+        super().__init__()
+
+        self._valid = QPixmap(str(get_resource(":/icons/valid.png")))
+        self._invalid = QPixmap(str(get_resource(":/icons/invalid.png")))
+        self._disabled = QPixmap(str(get_resource(":/icons/unvalid.png")))
+
+        self._label = QLabel()
+
+        self.disable()
+
+        hbox = QHBoxLayout()
+        hbox.setSpacing(0)
+        hbox.setContentsMargins(0, 0, 0, 0)
+        hbox.addWidget(self._label)
+
+        self.setLayout(hbox)
+
+    def eventFilter(self, source, event):
+        if event.type() == QEvent.FocusOut:
+            self.disable()
+        return True
+
+    def validate(self):
+        self._label.setPixmap(self._valid)
+
+    def invalidate(self):
+        self._label.setPixmap(self._invalid)
+
+    def disable(self):
+        self._label.setPixmap(self._disabled)
+        self._label.setToolTip("No validation was performed.")
+
+    def setToolTip(self, message: str) -> None:
+        self._label.setToolTip(message)
+
+
+class Positioning(QWidget):
+    """
+    The Positioning widget which allows to manually command the Hexapod to a certain position,
+    absolute or relative.
+    """
+
+    def __init__(self, view, observable):
+        super().__init__()
+        self.observable = observable
+        self.view = view
+
+        # initialize instance variables used by this class
+
+        self.manual_mode: QGroupBox = None
+        self.manual_mode_positions_widget: QFrame = None
+        self.manual_mode_positions: List = None
+
+        self.combo_absolute_relative: QComboBox = None
+
+        self.validate_label = None
+
+        self.specific_positions: QGroupBox = None
+        self.specific_positions_widget: QFrame = None
+
+        self.init_gui()
+
+    def init_gui(self):
+        """Initialize the main user interface for this component."""
+
+        # Setup the Manual Mode GroupBox widget
+
+        hbox = QHBoxLayout()
+
+        self.manual_mode = QGroupBox("Manual Mode")
+        self.manual_mode.setLayout(hbox)
+        self.manual_mode.setObjectName("ManualModeGroupBox")
+
+        self.manual_mode_positions_widget = self.create_manual_mode_position_widget()
+
+        hbox.addWidget(self.manual_mode_positions_widget)
+
+        # Setup the Specific Positions GroupBox widget
+
+        hbox = QHBoxLayout()
+
+        self.specific_positions = QGroupBox("Specific Positions")
+        self.specific_positions.setLayout(hbox)
+        self.manual_mode.setObjectName("SpecificPositionsGroupBox")
+
+        self.specific_positions_widget = self.create_specific_positions_widget()
+
+        hbox.addWidget(self.specific_positions_widget)
+
+        # Finally, within the Positions widget, a VBoxLayout holds the manual mode and the
+        # specific positions widgets.
+
+        vbox = QVBoxLayout()
+
+        vbox.addWidget(self.manual_mode)
+        vbox.addWidget(self.specific_positions)
+
+        self.setLayout(vbox)
+
+    def create_specific_positions_widget(self):
+        hbox = QHBoxLayout()
+
+        self.combo_specific_position = QComboBox()
+        self.combo_specific_position.addItems(["Position ZERO", "Position RETRACTED"])
+        self.combo_specific_position.setMinimumContentsLength(18)
+        self.combo_specific_position.adjustSize()
+
+        self.move_to_button = QPushButton("Move To")
+        self.move_to_button.setToolTip(
+            "Move to the specific position that is selected in the combobox."
+            "<ul>"
+            "<li><strong>ZERO</strong> moves Tx, Ty, Tz, Rx, Ry, Rz to position 0.0"
+            "<li><strong>RETRACTED</strong> moves the hexapod into its smallest height (useful for "
+            "loading or storage)"
+            "</ul>"
+        )
+        self.move_to_button.clicked.connect(self.handle_move_to_specific_position)
+
+        hbox.addWidget(self.combo_specific_position)
+        hbox.addWidget(self.move_to_button)
+
+        frame = QFrame()
+        frame.setObjectName("SpecificPositions")
+        frame.setLayout(hbox)
+
+        return frame
+
+    def create_manual_mode_position_widget(self) -> QFrame:
+        """Creates the internal frame for the manual mode box."""
+
+        vbox = QVBoxLayout()
+
+        self.manual_mode_positions = [
+            [QLabel("X"), QLineEdit(), QLabel("mm")],
+            [QLabel("Y"), QLineEdit(), QLabel("mm")],
+            [QLabel("Z"), QLineEdit(), QLabel("mm")],
+            [QLabel("Rx"), QLineEdit(), QLabel("deg")],
+            [QLabel("Ry"), QLineEdit(), QLabel("deg")],
+            [QLabel("Rz"), QLineEdit(), QLabel("deg")],
+        ]
+
+        for mm_pos in self.manual_mode_positions:
+            hbox = QHBoxLayout()
+            hbox.addWidget(mm_pos[0])
+            hbox.addWidget(mm_pos[1])
+            hbox.addWidget(mm_pos[2])
+            mm_pos[0].setMinimumWidth(20)
+            mm_pos[1].setText("0.0000")
+            mm_pos[1].setStyleSheet("QLabel { background-color : LightGray; }")
+            mm_pos[1].setAlignment(Qt.AlignRight | Qt.AlignVCenter)
+            mm_pos[1].setMinimumWidth(50)
+            vbox.addLayout(hbox)
+
+        # Add the two buttons, (1) Copy, and (2) Clear
+
+        hbox = QHBoxLayout()
+
+        copy_button = QPushButton("Copy")
+        copy_button.setToolTip("Copy the positions from Object [in User].")
+        copy_button.clicked.connect(self.handle_copy_positions)
+
+        clear_button = QPushButton("Clear")
+        clear_button.setToolTip("Clear the input fields.")
+        clear_button.clicked.connect(self.handle_clear_inputs)
+
+        hbox.addWidget(copy_button)
+        hbox.addStretch()
+        hbox.addWidget(clear_button)
+
+        vbox.addLayout(hbox)
+
+        # Make sure the hboxes defined above stay nicely together when vertically resizing the
+        # Frame.
+
+        vbox.addStretch()
+
+        # Add the QComboBox to select either absolute or relative movement
+
+        hbox = QHBoxLayout()
+
+        self.combo_absolute_relative = QComboBox()
+        self.combo_absolute_relative.addItems(["Absolute", "Relative object", "Relative user"])
+        self.combo_absolute_relative.setMinimumContentsLength(15)
+        self.combo_absolute_relative.adjustSize()
+
+        self.move_button = QPushButton("Move")
+        self.move_button.setToolTip(
+            "When you press this button, the Hexapod will start moving \n"
+            "to the position you have given in manual mode above.\n"
+            "Depending on the control setting, the movement will be absolute or relative."
+        )
+        self.move_button.clicked.connect(self.handle_movement)
+
+        hbox.addWidget(self.combo_absolute_relative)
+        hbox.addWidget(self.move_button)
+
+        vbox.addLayout(hbox)
+
+        # Add the two buttons, (1) Move, and (2) Validate Movement.
+
+        hbox = QHBoxLayout()
+
+        self.validate_button = QPushButton("Validate Movement...")
+        self.validate_button.setToolTip(
+            "When you press this button, the Hexapod controller will validate the input position "
+            "in manual mode.\n"
+            "Depending on the control setting, the movement will be absolute or relative."
+        )
+        self.validate_button.clicked.connect(self.handle_validate)
+
+        self.validate_label = ValidationIcon()
+        self.validate_label.installEventFilter(self.validate_label)
+
+        hbox.addWidget(self.validate_label)
+        hbox.addWidget(self.validate_button)
+
+        vbox.addLayout(hbox)
+
+        frame = QFrame()
+        frame.setObjectName("ManualPositions")
+        frame.setLayout(vbox)
+
+        return frame
+
+    def disable_movement(self):
+        self.move_button.setDisabled(True)
+        self.move_to_button.setDisabled(True)
+        self.validate_button.setDisabled(True)
+
+    def enable_movement(self):
+        self.move_button.setEnabled(True)
+        self.move_to_button.setEnabled(True)
+        self.validate_button.setEnabled(True)
+
+    def set_position_validation_icon(self, error_codes, tooltip: str = None):
+
+        if error_codes:
+            self.validate_label.setFocus()
+            self.validate_label.invalidate()
+            self.validate_label.setToolTip(format_tooltip(tooltip or error_codes))
+        else:
+            self.validate_label.setFocus()
+            self.validate_label.validate()
+            self.validate_label.setToolTip("Movement command is valid.")
+
+    def get_manual_inputs(self):
+        """Returns the input positions as a list of floats."""
+        try:
+            pos = [
+                float(mm_pos[1].text().replace(",", ".")) for mm_pos in self.manual_mode_positions
+            ]
+        except ValueError as exc:
+            MODULE_LOGGER.error(f"Incorrect manual position input given: {exc}")
+
+            description = "Input errors in manual positions"
+            info_text = (
+                "Some of the values that you have filled into the manual position fields are "
+                "invalid. The fields can only contain floating point numbers, both '.' and ',"
+                "' are allowed."
+            )
+            show_warning_message(description, info_text)
+
+            return None
+
+        return pos
+
+    def handle_move_to_specific_position(self):
+
+        # Check which movement was requested
+
+        selected_text = self.combo_specific_position.currentText()
+        if "ZERO" in selected_text:
+            action = "goto_zero_position"
+            value = 1
+        if "RETRACTED" in selected_text:
+            action = "goto_retracted_position"
+            value = 2
+
+        self.observable.actionObservers({action: value})
+
+    def handle_movement(self):
+        # Read out the values in manual mode into an array of floats
+        # Users may use comma or point as a decimal delimiter
+
+        pos = self.get_manual_inputs()
+        if pos is None:
+            return
+
+        # Check which movement was requested
+
+        selected_text = self.combo_absolute_relative.currentText()
+        if selected_text == "Absolute":
+            movement = "move_absolute"
+        elif selected_text == "Relative object":
+            movement = "move_relative_object"
+        elif selected_text == "Relative user":
+            movement = "move_relative_user"
+
+        self.observable.actionObservers({movement: pos})
+
+    def handle_validate(self):
+        pos = self.get_manual_inputs()
+        if pos is None:
+            return
+
+        # Check which movement was requested
+
+        selected_text = self.combo_absolute_relative.currentText()
+        if selected_text == "Absolute":
+            validation = "check_absolute_movement"
+        elif selected_text == "Relative object":
+            validation = "check_relative_object_movement"
+        elif selected_text == "Relative user":
+            validation = "check_relative_user_movement"
+
+        self.observable.actionObservers({validation: pos})
+
+    def handle_copy_positions(self):
+        for pos, mm_pos in zip(self.view.user_positions, self.manual_mode_positions):
+            mm_pos[1].setText(pos[1].text())
+
+        self.validate_label.disable()
+        self.manual_mode_positions_widget.repaint()
+
+    def handle_clear_inputs(self):
+        for mm_pos in self.manual_mode_positions:
+            mm_pos[1].setText("0.0000")
+
+        self.validate_label.disable()
+        self.manual_mode_positions_widget.repaint()
+
+
+class SpeedSettings(QWidget):
+
+    def __init__(self, view, observable):
+        super().__init__()
+        self.observable = observable
+        self.view = view
+
+        self.set_speed_widget: Optional[QGroupBox] = None
+        self.set_speed_widget = self.create_set_speed_widget()
+
+        vbox = QVBoxLayout()
+
+        hbox = QHBoxLayout()
+        hbox.addWidget(self.set_speed_widget)
+        hbox.addStretch()
+
+        # Add the Fetch and Apply for the Speed to the HBOX here
+
+        vbox_speed = QVBoxLayout()
+
+        fetch_button = QPushButton("Fetch")
+        fetch_button.setToolTip("Fetch speed settings from the Controller.")
+        fetch_button.clicked.connect(self.handle_fetch_speed_settings)
+
+        apply_button = QPushButton("Apply")
+        apply_button.setToolTip("Apply BOTH speed settings to the Controller.")
+        apply_button.clicked.connect(self.handle_apply_speed_settings)
+
+        vbox_speed.addWidget(fetch_button)
+        vbox_speed.addWidget(apply_button)
+
+        hbox.addLayout(vbox_speed)
+
+        vbox.addLayout(hbox)
+
+        self.setLayout(vbox)
+
+    def create_set_speed_widget(self):
+        """Creates the widget for the user set/get speed box."""
+
+        vbox = QVBoxLayout()
+
+        self.user_set_speed = [
+            [QLabel("Translation Speed (vt): "), QLineEdit(), QLabel("mm/s")],
+            [QLabel("Rotation Speed (vr): "), QLineEdit(), QLabel("°/s")]]
+
+        for speed in self.user_set_speed:
+            hbox = QHBoxLayout()
+            hbox.addWidget(speed[0])
+            hbox.addWidget(speed[1])
+            hbox.setSpacing(0)
+            hbox.addWidget(speed[2])
+            speed[0].setMinimumWidth(150)
+            speed[1].setText("0.0000")
+            speed[1].setStyleSheet("QLabel { background-color : LightGray; }")
+            speed[1].setAlignment(Qt.AlignRight | Qt.AlignVCenter)
+            speed[1].setFixedWidth(100)
+            vbox.addLayout(hbox)
+
+        gbox_set_speed = QGroupBox("Set Speed parameters", self)
+        gbox_set_speed.setLayout(vbox)
+
+        return gbox_set_speed
+
+    def get_speed_settings_input(self):
+
+        tr_speed = float(self.user_set_speed[0][1].text())
+        rot_speed = float(self.user_set_speed[1][1].text())
+
+        return tr_speed, rot_speed
+
+    def set_speed(self, vt, vr):
+        self.user_set_speed[0][1].setText(str(vt))
+        self.user_set_speed[1][1].setText(str(vr))
+        self.set_speed_widget.repaint()
+
+    def handle_apply_speed_settings(self):
+
+        # Read out the values in the speed settings group
+
+        translation_speed, rotation_speed = self.get_speed_settings_input()
+
+        self.observable.actionObservers({"set_speed": (translation_speed, rotation_speed)})
+
+    def handle_fetch_speed_settings(self):
+
+        self.observable.actionObservers({"fetch_speed": True})
+
+
+class CoordinateSystems(QWidget):
+    """This Widget allow to set the User and Object coordinate systems."""
+
+    def __init__(self, view, observable):
+        super().__init__()
+        self.observable = observable
+        self.view = view
+
+        # initialize instance variables used by this class
+
+        self.user_coordinates_system_widget: QGroupBox = None
+        self.user_coordinates_system: List = None
+
+        self.object_coordinates_system_widget: QGroupBox = None
+        self.object_coordinates_system: List = None
+
+        self.init_gui()
+
+    def init_gui(self):
+        """Initialize the main interface for this component."""
+
+        vbox = QVBoxLayout()
+
+        self.user_coordinates_system_widget = self.create_user_coordinates_system_widget()
+        self.object_coordinates_system_widget = self.create_object_coordinates_system_widget()
+
+        # The double arrow buttons are used to copy parameters from user to object coordinate
+        # system or vice versa.
+
+        copy_right_icon = QIcon(str(get_resource(":/icons/double-right-arrow.svg")))
+        copy_right_button = QPushButton()
+        copy_right_button.setIcon(copy_right_icon)
+        copy_right_button.setToolTip("Copy User coordinates to Object coordinates")
+        copy_right_button.clicked.connect(self.on_copy_right)
+
+        copy_left_icon = QIcon(str(get_resource(":/icons/double-left-arrow.svg")))
+        copy_left_button = QPushButton()
+        copy_left_button.setIcon(copy_left_icon)
+        copy_left_button.setToolTip("Copy Object coordinates to User coordinates")
+        copy_left_button.clicked.connect(self.on_copy_left)
+
+        vbox_icons = QVBoxLayout()
+        vbox_icons.addStretch()
+        vbox_icons.addWidget(copy_left_button)
+        vbox_icons.addWidget(copy_right_button)
+        vbox_icons.addStretch()
+
+        hbox = QHBoxLayout()
+
+        hbox.addWidget(self.user_coordinates_system_widget)
+        hbox.addLayout(vbox_icons)
+        hbox.addWidget(self.object_coordinates_system_widget)
+
+        vbox.addLayout(hbox)
+
+        apply_button = QPushButton("Apply")
+        apply_button.setToolTip("Apply the Coordinates Systems to the Controller.")
+        apply_button.clicked.connect(self.handle_apply_coordinates_systems)
+
+        fetch_button = QPushButton("Fetch")
+        fetch_button.setToolTip("Fetch the Coordinates Systems from the Controller.")
+        fetch_button.clicked.connect(self.handle_fetch_coordinates_systems)
+
+        hbox = QHBoxLayout()
+        hbox.addWidget(fetch_button)
+        hbox.addStretch()
+        hbox.addWidget(apply_button)
+        vbox.addLayout(hbox)
+
+        vbox.addStretch(1)
+
+        self.setLayout(vbox)
+
+    def set_coordinates_systems(self, user_cs, object_cs):
+        for usr, value in zip(self.user_coordinates_system, user_cs):
+            usr[1].setText(str(value))
+        for obj, value in zip(self.object_coordinates_system, object_cs):
+            obj[1].setText(str(value))
+        self.object_coordinates_system_widget.repaint()
+        self.user_coordinates_system_widget.repaint()
+
+    def create_user_coordinates_system_widget(self) -> QWidget:
+        """Creates the widget for the user coordinates system box."""
+
+        vbox = QVBoxLayout()
+
+        self.user_coordinates_system = [
+            [QLabel("X"), QLineEdit(), QLabel("mm")],
+            [QLabel("Y"), QLineEdit(), QLabel("mm")],
+            [QLabel("Z"), QLineEdit(), QLabel("mm")],
+            [QLabel("Rx"), QLineEdit(), QLabel("deg")],
+            [QLabel("Ry"), QLineEdit(), QLabel("deg")],
+            [QLabel("Rz"), QLineEdit(), QLabel("deg")],
+        ]
+
+        for mm_pos in self.user_coordinates_system:
+            hbox = QHBoxLayout()
+            hbox.addWidget(mm_pos[0])
+            hbox.addWidget(mm_pos[1])
+            hbox.addWidget(mm_pos[2])
+            mm_pos[0].setMinimumWidth(20)
+            mm_pos[1].setText("0.0000")
+            mm_pos[1].setStyleSheet("QLabel { background-color : LightGray; }")
+            mm_pos[1].setAlignment(Qt.AlignRight | Qt.AlignVCenter)
+            mm_pos[1].setMinimumWidth(50)
+            vbox.addLayout(hbox)
+
+        # Make sure the hboxes defined above stay nicely together when vertically resizing the
+        # Frame.
+
+        # vbox.addStretch()
+
+        gbox_user_coordinates_system = QGroupBox("User Coordinate System", self)
+        gbox_user_coordinates_system.setLayout(vbox)
+        gbox_user_coordinates_system.setToolTip("The User Coordinate System.")
+
+        return gbox_user_coordinates_system
+
+    def create_object_coordinates_system_widget(self) -> QWidget:
+        """Creates the widget for the object coordinates system box."""
+
+        vbox = QVBoxLayout()
+
+        self.object_coordinates_system = [
+            [QLabel("X"), QLineEdit(), QLabel("mm")],
+            [QLabel("Y"), QLineEdit(), QLabel("mm")],
+            [QLabel("Z"), QLineEdit(), QLabel("mm")],
+            [QLabel("Rx"), QLineEdit(), QLabel("deg")],
+            [QLabel("Ry"), QLineEdit(), QLabel("deg")],
+            [QLabel("Rz"), QLineEdit(), QLabel("deg")],
+        ]
+
+        for mm_pos in self.object_coordinates_system:
+            hbox = QHBoxLayout()
+            hbox.addWidget(mm_pos[0])
+            hbox.addWidget(mm_pos[1])
+            hbox.addWidget(mm_pos[2])
+            mm_pos[0].setMinimumWidth(20)
+            mm_pos[1].setText("0.0000")
+            mm_pos[1].setStyleSheet("QLabel { background-color : LightGray; }")
+            mm_pos[1].setAlignment(Qt.AlignRight | Qt.AlignVCenter)
+            mm_pos[1].setMinimumWidth(50)
+            vbox.addLayout(hbox)
+
+        # Make sure the hboxes defined above stay nicely together when vertically resizing the
+        # Frame.
+
+        # vbox.addStretch()
+
+        gbox_object_coordinates_system = QGroupBox("Object Coordinate System", self)
+        gbox_object_coordinates_system.setLayout(vbox)
+        gbox_object_coordinates_system.setToolTip("The Object Coordinate System.")
+
+        return gbox_object_coordinates_system
+
+    def on_copy_right(self, icon):
+        for usr, obj in zip(self.user_coordinates_system, self.object_coordinates_system):
+            obj[1].setText(usr[1].text())
+        self.object_coordinates_system_widget.repaint()
+
+    def on_copy_left(self, icon):
+        for usr, obj in zip(self.user_coordinates_system, self.object_coordinates_system):
+            usr[1].setText(obj[1].text())
+        self.user_coordinates_system_widget.repaint()
+
+    def get_coordinates_systems_inputs(self):
+        """Returns the values from the user and object coordinates systems as a tuple of two
+        lists of floats.
+
+        Returns:
+            A tuple containing two lists of floats, the first list for the user coordinates
+            system, the second list for the object coordinates system.
+        """
+        try:
+            user_cs = [
+                float(pos[1].text().replace(",", ".")) for pos in self.user_coordinates_system
+            ]
+            object_cs = [
+                float(pos[1].text().replace(",", ".")) for pos in self.object_coordinates_system
+            ]
+        except ValueError as exc:
+            MODULE_LOGGER.error(
+                f"Incorrect manual input given for user or object coordinates " f"system: {exc}"
+            )
+
+            description = "Input errors for coordinates systems"
+            info_text = (
+                "Some of the values that you have filled into the fields for the coordinates "
+                "systems are invalid. The fields can only contain floating point numbers,  "
+                "both '.' and ',' are allowed."
+            )
+            show_warning_message(description, info_text)
+
+            return None, None
+
+        return user_cs, object_cs
+
+    def handle_apply_coordinates_systems(self):
+
+        # Read out the values in manual mode into an array of floats
+        # Users may use comma or point as a decimal delimiter
+
+        user_cs, object_cs = self.get_coordinates_systems_inputs()
+        if user_cs is None:
+            return
+
+        self.observable.actionObservers({"configure_coordinates_systems": (user_cs, object_cs)})
+
+    def handle_fetch_coordinates_systems(self):
+
+        self.observable.actionObservers({"fetch_coordinates_systems": True})
+
+
+class ActuatorStates(QWidget):
+    """This Widget allows to view the state of all six actuators."""
+    def __init__(self, labels: List[str] = None):
+        super().__init__()
+
+        # initialize instance variables used by this class
+
+        self.status_labels = labels
+        self.leds: List[List] = []
+
+        vbox = QVBoxLayout()
+        vbox.addWidget(QLabel("Actuator States"))
+        vbox.setAlignment(Qt.AlignTop | Qt.AlignLeft)
+
+        self.create_states_widget = self.create_states()
+        vbox.addWidget(self.create_states_widget)
+        self.setLayout(vbox)
+
+    def create_states(self):
+        vbox = QVBoxLayout()
+
+        hbox = QHBoxLayout()
+        hbox.addWidget(QLabel(""))
+
+        for actuator_index in range(1, 7):
+
+            actuator_number = QLabel(str(actuator_index))
+            actuator_number.setAlignment(Qt.AlignHCenter)
+            actuator_number.setMinimumSize(20, 20)
+            actuator_number.setMaximumSize(20, 20)
+            # LED(self, size=QSize(20, 20), shape=ShapeEnum.SQUARE)
+            hbox.addWidget(actuator_number)
+            hbox.setSpacing(2)
+        vbox.addLayout(hbox)
+
+        for state in self.status_labels:
+            hbox = QHBoxLayout()
+            hbox.addWidget(QLabel(state))
+            actuator_leds = [
+                LED(self, size=QSize(20, 20), shape=ShapeEnum.SQUARE)
+                for _ in range(6)
+            ]
+            for led in actuator_leds:
+                hbox.addWidget(led)
+                hbox.setSpacing(2)
+            self.leds.append(actuator_leds)
+            vbox.addLayout(hbox)
+
+        create_states = QGroupBox()
+        create_states.setLayout(vbox)
+
+        return create_states
+
+    def set_states(self, states: List):
+
+        # States is a List of Lists, each inside list contains a dict with the states and
+        # another list with the states.
+
+        # zip(*states) will transpose the states
+
+        for leds, new_states in zip(self.leds, zip(*states)):
+            for led, state in zip(leds, new_states):
+                led.set_color(state)
+
+    def reset_states(self):
+        pass
+
+
+def format_tooltip(value: Union[str, Dict, List] = None) -> str:
+    if value is None:
+        return ""
+
+    from rich.console import Console
+
+    console = Console(width=60, force_terminal=False, force_jupyter=False)
+    with console.capture() as capture:
+        console.print(value)
+
+    return capture.get()
+
+
+class HexapodUIModel:
+    def __init__(self, connection_type: str, device):
+        self._connection_type = connection_type
+        self._device = device
+
+    @property
+    def connection_type(self):
+        return self._connection_type
+
+    @property
+    def device(self):
+        return self._device
+
+    def is_simulator(self):
+        return self.device.is_simulator()
+
+    def is_cs_connected(self):
+        return self.device.is_cs_connected() if self.connection_type == "proxy" else False
+
+    def is_device_connected(self):
+        return self.device.is_connected()
+
+    @deprecate(alternative="reconnect_device")
+    def reconnect(self):
+        self.reconnect_device()
+
+    def reconnect_device(self):
+        self.device.reconnect()
+        return self.device.is_connected()
+
+    def reconnect_cs(self):
+        self.device.reconnect_cs()
+        return self.device.is_cs_connected()
+
+    def disconnect(self):
+        self.device.disconnect()
+
+    def disconnect_cs(self):
+        self.device.disconnect_cs()
+
+    def has_commands(self):
+        if self.connection_type == "proxy":
+            return self.device.has_commands()
+        return True
+
+    def load_commands(self):
+        if self.connection_type == "proxy":
+            self.device.load_commands()
+
+    def get_states(self):
+        try:
+            _, states = self.device.get_general_state()
+        except TypeError:
+            states = None
+        return states
+
+    def configure_coordinates_systems(self, user_cs, object_cs):
+        return self.device.configure_coordinates_systems(*user_cs, *object_cs)
+
+    def get_coordinates_systems(self):
+        response = self.device.get_coordinates_systems()
+        user_cs = response[:6]
+        object_cs = response[6:]
+        return user_cs, object_cs
+
+    def get_user_positions(self):
+        return self.device.get_user_positions()
+
+    def get_machine_positions(self):
+        return self.device.get_machine_positions()
+
+    def get_actuator_length(self):
+        return self.device.get_actuator_length()
+
+    def get_actuator_states(self):
+        states = self.device.get_actuator_state()
+        states = [x[1] for x in states]
+        return states
+
+    def get_speed(self):
+        raise NotImplementedError
+
+    def activate_control_loop(self):
+        self.device.activate_control_loop()
+
+    def deactivate_control_loop(self):
+        self.device.deactivate_control_loop()
+
+    def check_absolute_movement(self, pos):
+        rc, rc_dict = self.device.check_absolute_movement(*pos)
+        MODULE_LOGGER.debug(rc)
+        MODULE_LOGGER.debug(rc_dict)
+        return rc_dict
+
+    def check_relative_object_movement(self, pos):
+        rc, rc_dict = self.device.check_relative_object_movement(*pos)
+        MODULE_LOGGER.debug(rc)
+        MODULE_LOGGER.debug(rc_dict)
+        return rc_dict
+
+    def check_relative_user_movement(self, pos):
+        rc, rc_dict = self.device.check_relative_user_movement(*pos)
+        MODULE_LOGGER.debug(rc)
+        MODULE_LOGGER.debug(rc_dict)
+        return rc_dict
+
+    def move_absolute(self, pos):
+        self.device.move_absolute(*pos)
+
+    def move_relative_object(self, pos):
+        self.device.move_relative_object(*pos)
+
+    def move_relative_user(self, pos):
+        self.device.move_relative_user(*pos)
+
+    def goto_zero_position(self):
+        self.device.goto_zero_position()
+
+    def goto_retracted_position(self):
+        self.device.goto_retracted_position()
+
+    def set_speed(self, tr_speed, rot_speed):
+        self.device.set_speed(tr_speed, rot_speed)
+
+    def homing(self):
+        self.device.homing()
+
+    def clear_error(self):
+        self.device.clear_error()
+
+    def reset(self):
+        self.device.reset()
+
+    def stop(self):
+        self.device.stop()
+
+
+class HexapodUIController(Observer):
+    def __init__(self, model: HexapodUIModel, view):
+        self._model = model
+        self._view = view
+        self._view.addObserver(self)
+
+        self.states_capture_timer = None
+        self.timer_interval = 200
+        self.create_timer()
+
+        try:
+            if self.model.is_device_connected():
+                mode = self.model.connection_type.capitalize()
+                if self.model.is_simulator():
+                    mode = f"{mode} [Simulator]"
+                self.view.update_status_bar(mode=mode)
+
+                self.view.check_device_action()
+            else:
+                self.view.uncheck_device_action()
+
+            if self.model.is_cs_connected():
+                self.view.check_cs_action()
+            else:
+                self.view.uncheck_cs_action()
+
+            MODULE_LOGGER.info(f"{self.model.is_device_connected()=}, {self.model.is_cs_connected()=}")
+
+            if model.connection_type in ["direct", "simulator"]:
+                view.disable_cs_action()
+
+            if self.has_connection():
+                self.view.set_connection_state("connected")
+                self.start_timer()
+            else:
+                self.view.set_connection_state("disconnected")
+                self.stop_timer()
+        except NotImplementedError:
+            MODULE_LOGGER.warning(
+                "There was no connection to the control server during startup, "
+                "GUI starts in disconnected mode."
+            )
+            self.view.uncheck_cs_action()
+            self.view.uncheck_device_action()
+            self.view.set_connection_state("disconnected")
+
+    def has_connection(self):
+        """
+        Returns True if the controller has a connection to the device. This takes into account
+        that the control server might be disabled when the controller is directly connected to
+        the device or to a simulator.
+        """
+        if self.view.is_cs_action_enabled():
+            return bool(self.model.is_device_connected() and self.model.is_cs_connected())
+        else:
+            return bool(self.model.is_device_connected())
+
+    @property
+    def model(self):
+        return self._model
+
+    @property
+    def view(self):
+        return self._view
+
+    def create_timer(self):
+        """Create a Timer that will update the States every second."""
+
+        self.states_capture_timer = QTimer()
+        # This is only needed when the Timer needs to run in another Thread
+        # self.states_capture_timer.moveToThread(self)
+        self.states_capture_timer.timeout.connect(self.update_values)
+        self.states_capture_timer.setInterval(self.timer_interval)
+
+    def start_timer(self):
+        self.states_capture_timer.start()
+
+    def stop_timer(self):
+        self.states_capture_timer.stop()
+
+    def update_values(self):
+        """Updates the common view widgets."""
+
+        if not self.has_connection():
+            self.view.set_connection_state("disconnected")
+            self.stop_timer()
+
+            if not self.model.is_device_connected(): self.view.disable_device_action()
+            if not self.model.is_cs_connected(): self.view.uncheck_cs_action()
+
+            return
+
+        states = self.model.get_states()
+
+        if states:
+            self.view.updateStates(states)
+
+        actuator_states = self.model.get_actuator_states()
+        self.view.update_actuator_states(actuator_states)
+
+        upos = self.model.get_user_positions()
+        mpos = self.model.get_machine_positions()
+        alen = self.model.get_actuator_length()
+
+        # the updatePositions() checks for None, no need to do that here
+
+        self.view.updatePositions(upos, mpos, alen)
+
+    def update(self, changed_object):
+
+        text = changed_object.text()
+
+        if text == "STOP":
+            self.model.stop()
+
+        if text == "INFO":
+            self.help_window.show()
+
+        if text == "DEVICE-CONNECT":
+            print(f"Pressed {text}")
+
+            if changed_object.is_selected():
+                MODULE_LOGGER.debug("Reconnecting the Hexapod model.")
+                if self.model.reconnect_device():
+                    self.view.set_connection_state("connected")
+                    if not self.model.has_commands():
+                        self.model.load_commands()
+                    self.start_timer()
+                else:
+                    self.view.device_connection.set_selected(False)
+            else:
+                MODULE_LOGGER.debug("Disconnecting the Hexapod model.")
+                self.stop_timer()
+                self.model.disconnect()
+                self.view.set_connection_state("disconnected")
+            return
+
+        if text == "CS-CONNECT":
+            if changed_object.is_selected():
+                MODULE_LOGGER.debug("Reconnecting the Hexapod Control Server.")
+                self.model.reconnect_cs()
+                if not self.model.has_commands():
+                    self.model.load_commands()
+                self.start_timer()
+                if self.model.is_device_connected() and self.model.is_cs_connected():
+                    self.view.set_connection_state("connected")
+                    self.view.device_connection.enable()
+            else:
+                MODULE_LOGGER.debug("Disconnecting the Hexapod Control Server.")
+                self.stop_timer()
+                self.model.disconnect_cs()
+                self.view.device_connection.disable()
+                self.view.set_connection_state("disconnected")
+
+        if text == "CONTROL":
+            if changed_object.is_selected():
+                self.model.activate_control_loop()
+            else:
+                self.model.deactivate_control_loop()
+
+        if text == "HOMING":
+            self.model.homing()
+
+        if text == "CLEAR-ERRORS":
+            self.model.clear_error()
+
+        if text == "Reset":
+            # FIXME: This causes a problem in the GUI EventLoop as the reset waits for 30 seconds
+            #        before it finishes. This will hang the EventLoop for 30 seconds with a spinning
+            #        wheel. Do we need to run the hexapod commands (or some) in a separate thread?
+            #        Other commands like move to position will also take some time and cause the GUI
+            #        to apear hanging...
+            #
+            #        It is known that time.sleep() should not be used in GUI applications.
+            #        Use QTimer.singleShot() instead.
+
+            self.model.reset()
+
+    def do(self, actions):
+
+        for action, value in actions.items():
+            MODULE_LOGGER.debug(f"do {action} with {value}")
+            if action == "move_absolute":
+                self.model.move_absolute(value)
+                self.view.update_status_bar(message=f"command: {action}{value}")
+            elif action == "move_relative_object":
+                self.model.move_relative_object(value)
+                self.view.update_status_bar(message=f"command: {action}{value}")
+            elif action == "move_relative_user":
+                self.model.move_relative_user(value)
+                self.view.update_status_bar(message=f"command: {action}{value}")
+            elif action == "check_absolute_movement":
+                rc_dict = self.model.check_absolute_movement(value)
+                self.view.update_status_bar(message=f"command: {action}{value}")
+                self.view.positioning.set_position_validation_icon(rc_dict)
+            elif action == "check_relative_object_movement":
+                rc_dict = self.model.check_relative_object_movement(value)
+                self.view.update_status_bar(message=f"command: {action}{value}")
+                self.view.positioning.set_position_validation_icon(rc_dict)
+            elif action == "check_relative_user_movement":
+                rc_dict = self.model.check_relative_user_movement(value)
+                self.view.update_status_bar(message=f"command: {action}{value}")
+                self.view.positioning.set_position_validation_icon(rc_dict)
+            elif action == "set_speed":
+                tr_speed, rot_speed = value
+                MODULE_LOGGER.info(f"Set speed: {tr_speed=}, {rot_speed=}")
+                self.model.set_speed(tr_speed, rot_speed)
+            elif action == "fetch_speed":
+                tr_speed, rot_speed = self.model.get_speed()
+                self.view.set_speed(tr_speed, rot_speed)
+            elif action == "goto_zero_position":
+                self.model.goto_zero_position()
+            elif action == "goto_retracted_position":
+                self.model.goto_retracted_position()
+            elif action == "configure_coordinates_systems":
+                self.model.configure_coordinates_systems(*value)
+            elif action == "fetch_coordinates_systems":
+                user_cs, object_cs = self.model.get_coordinates_systems()
+                self.view.set_coordinates_systems(user_cs, object_cs)
+            else:
+                MODULE_LOGGER.warning(f"Unknown action {action}")
+
+
+class HexapodUIView(QMainWindow, Observable):
+    def __init__(self):
+        super().__init__()
+
+        self.setGeometry(300, 300, 300, 200)
+
+        self.mode_label = QLabel("")
+        self.user_positions = None
+
+        # Widget for Manual Positioning, Configuration TAB
+
+        self.positioning = None
+        self.configuration = None
+
+        self.coordinate_systems: CoordinateSystems = None
+        self.speed_settings = None
+
+        # Widget for the Advanced TAB
+
+        self.actuator_states = None
+
+        # Widget fot the temperature log TAB
+
+        self.temperature_log = None
+
+    def onClick(self, icon: Union[QIcon, bool]):
+
+        sender = self.sender()
+
+        MODULE_LOGGER.log(0, f"type(sender) = {type(sender)}")
+        MODULE_LOGGER.log(0, f"sender.text() = {sender.text()}")
+        MODULE_LOGGER.log(0, f"sender.isCheckable() = {sender.isCheckable()}")
+        MODULE_LOGGER.log(0, f"sender.isChecked() = {sender.isChecked()}")
+        MODULE_LOGGER.log(0, f"type(icon) = {type(icon)}")
+
+        # This will trigger the update() method on all the observers
+
+        self.notifyObservers(sender)
+
+    def createStatusBar(self):
+
+        self.statusBar().setStyleSheet("border: 0; background-color: #FFF8DC;")
+        self.statusBar().setStyleSheet("QStatusBar::item {border: none;}")
+        self.statusBar().addPermanentWidget(VLine())
+        self.statusBar().addPermanentWidget(self.mode_label)
+
+    def createToolbar(self):
+
+        # The Switch On/OFF is in this case used for the Control ON/OFF action.
+
+        self.control = ToggleButton(
+            name="CONTROL",
+            status_tip="enable-disable the control loop on the servo motors",
+            selected=get_resource(":/icons/switch-on.svg"),
+            not_selected=get_resource(":/icons/switch-off.svg"),
+            disabled=get_resource(":/icons/switch-disabled.svg")
+        )
+        self.control.clicked.connect(self.onClick)
+
+        # The Home action is used to command the Homing to the Hexapod.
+
+        self.homing = TouchButton(
+            name="HOMING",
+            status_tip="perform a homing operation",
+            selected=get_resource(":/icons/home.svg"),
+            disabled=get_resource(":/icons/home-disabled.svg"),
+        )
+        self.homing.clicked.connect(self.onClick)
+
+        # The Clear action is used to command the ClearErrors to the Hexapod.
+
+        self.clear_errors = TouchButton(
+            name="CLEAR-ERRORS",
+            status_tip="clear the error list on the controller",
+            selected=get_resource(":/icons/erase.svg"),
+            disabled=get_resource(":/icons/erase-disabled.svg"),
+        )
+        self.clear_errors.clicked.connect(self.onClick)
+
+        # The Reconnect action is used to reconnect to the control server
+
+        self.cs_connection = ToggleButton(
+            name="CS-CONNECT",
+            status_tip="connect-disconnect hexapod control server.",
+            selected=get_resource(":/icons/cs-connected.svg"),
+            not_selected=get_resource(":/icons/cs-not-connected.svg"),
+            disabled=get_resource(":/icons/cs-connected-disabled.svg")
+        )
+        self.cs_connection.clicked.connect(self.onClick)
+
+        # The Reconnect action is used to reconnect the device
+
+        self.device_connection = ToggleButton(
+            name="DEVICE-CONNECT",
+            status_tip="connect-disconnect the hexapod controller",
+            selected=get_resource(":/icons/plugged.svg"),
+            not_selected=get_resource(":/icons/unplugged.svg"),
+            disabled=get_resource(":/icons/plugged-disabled.svg")
+        )
+        self.device_connection.clicked.connect(self.onClick)
+
+
+        # The STOP button is used to immediately stop the current motion
+
+        stop_button = QIcon(str(get_resource(":/icons/stop.svg")))
+
+        self.stop_action = QAction(stop_button, "STOP", self)
+        self.stop_action.setToolTip("STOP Movement")
+        self.stop_action.triggered.connect(self.onClick)
+
+        # The HELP button is used to show the on-line help in a browser window
+
+        help_button = QIcon(str(get_resource(":/icons/info.svg")))
+
+        self.help_action = QAction(help_button, "INFO", self)
+        self.help_action.setToolTip("Browse the on-line documentation")
+        self.help_action.triggered.connect(self.onClick)
+
+        # spacer widget to help with aligning STOP button to the right
+
+        spacer = QWidget()
+        spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
+
+        self.toolbar = self.addToolBar("MainToolbar")
+        self.toolbar.addWidget(self.control)
+        self.toolbar.addWidget(self.homing)
+        self.toolbar.addWidget(self.clear_errors)
+        self.toolbar.addWidget(self.device_connection)
+        self.toolbar.addWidget(self.cs_connection)
+        self.toolbar.addWidget(spacer)
+        self.toolbar.addAction(self.stop_action)
+        self.toolbar.addAction(self.help_action)
+
+        return self.toolbar
+
+    def createUserPositionWidget(self):
+
+        vbox_labels = QVBoxLayout()
+        vbox_values = QVBoxLayout()
+        vbox_units = QVBoxLayout()
+        hbox = QHBoxLayout()
+
+        self.user_positions = [
+            [QLabel("X"), QLabel(), QLabel("mm")],
+            [QLabel("Y"), QLabel(), QLabel("mm")],
+            [QLabel("Z"), QLabel(), QLabel("mm")],
+            [QLabel("Rx"), QLabel(), QLabel("deg")],
+            [QLabel("Ry"), QLabel(), QLabel("deg")],
+            [QLabel("Rz"), QLabel(), QLabel("deg")],
+        ]
+
+        for upos in self.user_positions:
+            vbox_labels.addWidget(upos[0])
+            vbox_values.addWidget(upos[1])
+            upos[1].setStyleSheet("QLabel { background-color : LightGrey; }")
+            upos[1].setAlignment(Qt.AlignRight | Qt.AlignVCenter)
+            upos[1].setMinimumWidth(80)
+            vbox_units.addWidget(upos[2])
+
+        # Make sure the labels stay nicely together when vertically resizing the Frame.
+        vbox_labels.addStretch(1)
+        vbox_values.addStretch(1)
+        vbox_units.addStretch(1)
+
+        hbox.addLayout(vbox_labels)
+        hbox.addLayout(vbox_values)
+        hbox.addLayout(vbox_units)
+
+        # Make sure the leds and labels stay nicely together when horizontally resizing the Frame.
+        hbox.addStretch(1)
+
+        gbox_positions = QGroupBox("Object [in User]", self)
+        gbox_positions.setLayout(hbox)
+        gbox_positions.setToolTip(
+            "The position of the Object Coordinate System in the User Coordinate System."
+        )
+
+        return gbox_positions
+
+    def createMachinePositionWidget(self):
+
+        vbox_labels = QVBoxLayout()
+        vbox_values = QVBoxLayout()
+        vbox_units = QVBoxLayout()
+        hbox = QHBoxLayout()
+
+        self.mach_positions = [
+            [QLabel("X"), QLabel(), QLabel("mm")],
+            [QLabel("Y"), QLabel(), QLabel("mm")],
+            [QLabel("Z"), QLabel(), QLabel("mm")],
+            [QLabel("Rx"), QLabel(), QLabel("deg")],
+            [QLabel("Ry"), QLabel(), QLabel("deg")],
+            [QLabel("Rz"), QLabel(), QLabel("deg")],
+        ]
+
+        for mpos in self.mach_positions:
+            vbox_labels.addWidget(mpos[0])
+            vbox_values.addWidget(mpos[1])
+            mpos[1].setStyleSheet("QLabel { background-color : LightGrey; }")
+            mpos[1].setAlignment(Qt.AlignRight | Qt.AlignVCenter)
+            mpos[1].setMinimumWidth(80)
+            vbox_units.addWidget(mpos[2])
+
+        # Make sure the labels stay nicely together when vertically resizing the Frame.
+        vbox_labels.addStretch(1)
+        vbox_values.addStretch(1)
+        vbox_units.addStretch(1)
+
+        hbox.addLayout(vbox_labels)
+        hbox.addLayout(vbox_values)
+        hbox.addLayout(vbox_units)
+
+        # Make sure the leds and labels stay nicely together when horizontally resizing the Frame.
+        hbox.addStretch(1)
+
+        gbox_positions = QGroupBox("Platform [in Machine]", self)
+        gbox_positions.setLayout(hbox)
+        gbox_positions.setToolTip(
+            "The position of the Platform Coordinate System in the Machine Coordinate System."
+        )
+
+        return gbox_positions
+
+    def createActuatorLengthWidget(self):
+
+        vbox_labels = QVBoxLayout()
+        vbox_values = QVBoxLayout()
+        vbox_units = QVBoxLayout()
+        hbox = QHBoxLayout()
+
+        self.actuator_lengths = [
+            [QLabel("L1"), QLabel(), QLabel("mm")],
+            [QLabel("L2"), QLabel(), QLabel("mm")],
+            [QLabel("L3"), QLabel(), QLabel("mm")],
+            [QLabel("L4"), QLabel(), QLabel("mm")],
+            [QLabel("L5"), QLabel(), QLabel("mm")],
+            [QLabel("L6"), QLabel(), QLabel("mm")],
+        ]
+
+        for alength in self.actuator_lengths:
+            vbox_labels.addWidget(alength[0])
+            vbox_values.addWidget(alength[1])
+            alength[1].setStyleSheet("QLabel { background-color : LightGrey; }")
+            alength[1].setAlignment(Qt.AlignRight | Qt.AlignVCenter)
+            alength[1].setMinimumWidth(80)
+            vbox_units.addWidget(alength[2])
+
+        # Make sure the labels stay nicely together when vertically resizing the Frame.
+        vbox_labels.addStretch(1)
+        vbox_values.addStretch(1)
+        vbox_units.addStretch(1)
+
+        hbox.addLayout(vbox_labels)
+        hbox.addLayout(vbox_values)
+        hbox.addLayout(vbox_units)
+
+        # Make sure the leds and labels stay nicely together when horizontally resizing the Frame.
+        hbox.addStretch(1)
+
+        gbox_lengths = QGroupBox("Actuator Length", self)
+        gbox_lengths.setLayout(hbox)
+
+        return gbox_lengths
+
+    def create_tabbed_widget(self):
+
+        self.tabs = QTabWidget()
+        self.tabs.setTabsClosable(False)
+        self.tabs.setMovable(False)
+        self.tabs.setDocumentMode(True)
+        self.tabs.setElideMode(Qt.ElideRight)
+        self.tabs.setUsesScrollButtons(True)
+
+        self.positioning = Positioning(self, self)
+        self.tabs.addTab(self.positioning, "Positions")
+        self.coordinate_systems = CoordinateSystems(self, self)
+        self.speed_settings = SpeedSettings(self, self)
+        self.configuration = QWidget()
+        vbox = QVBoxLayout()
+        vbox.setSpacing(0)
+        vbox.addWidget(self.coordinate_systems)
+        vbox.addWidget(self.speed_settings)
+        self.configuration.setLayout(vbox)
+        self.tabs.addTab(self.configuration, "Configuration")
+        self.tabs.currentChanged.connect(self.reload_settings_for_tab)
+
+        # Actuator states are initialised in the sub-class because the states are different
+        # for the Alpha and Aplha+ controllers
+
+        self.tabs.addTab(self.actuator_states, "Advanced State")
+
+        self.tabs.addTab(self.temperature_log, "Temperature Log")
+
+        return self.tabs
+
+    def reload_settings_for_tab(self, tab_idx):
+        MODULE_LOGGER.info(f"Reload for tab: {tab_idx}")
+        if self.configuration is self.tabs.widget(tab_idx):
+            self.coordinate_systems.handle_fetch_coordinates_systems()
+            self.speed_settings.handle_fetch_speed_settings()
+
+    def set_coordinates_systems(self, user_cs, object_cs):
+        self.coordinate_systems.set_coordinates_systems(user_cs, object_cs)
+
+    def set_speed(self, vt, vr):
+        self.speed_settings.set_speed(vt, vr)
+
+    def is_cs_action_enabled(self):
+        return self.cs_connection.isEnabled()
+
+    def disable_cs_action(self):
+        self.cs_connection.disable()
+
+    def enable_cs_action(self):
+        self.cs_connection.enable()
+
+    def check_cs_action(self):
+        self.cs_connection.set_selected()
+
+    def uncheck_cs_action(self):
+        self.cs_connection.set_selected(False)
+
+    def disable_device_action(self):
+        self.device_connection.disable()
+
+    def enable_device_action(self):
+        self.device_connection.enabled()
+
+    def check_device_action(self):
+        self.device_connection.set_selected()
+
+    def uncheck_device_action(self):
+        self.device_connection.set_selected(False)
+
+    def set_connection_state(self, state):
+        # enable or disable all actions that involve a device or cs connection
+        # don't change the action buttons for the device nor the cs, that is handled
+        # in the caller because it might be a device connection loss that causes this state
+        # or a control server, or both...
+
+        MODULE_LOGGER.info(f"{state=}")
+
+        if state == "connected":
+            self.control.enable()
+            self.homing.enable()
+            self.clear_errors.enable()
+            self.positioning.enable_movement()
+        elif state == "disconnected":
+            self.control.disable()
+            self.homing.disable()
+            self.clear_errors.disable()
+            self.positioning.disable_movement()
+        else:
+            raise UnknownStateError(
+                f"Unknown State ({state}), expected 'connected' or 'disconnected'."
+            )
+
+    def update_actuator_states(self, states):
+        if states is None:
+            return
+
+        self.actuator_states.set_states(states)