symetrie-hexapod 0.17.3__py3-none-any.whl

egse/hexapod/symetrie/joran.py

@@ -0,0 +1,289 @@
+"""
+This module defines the device classes to be used to connect to and control the Hexapod JORAN from
+Symétrie.
+
+"""
+
+import logging
+import math
+import time
+
+from egse.hexapod.symetrie.alpha import AlphaPlusControllerInterface
+from egse.hexapod.symetrie.dynalpha import AlphaPlusTelnetInterface, decode_validation_error
+from egse.mixin import DynamicCommandMixin
+from egse.proxy import DynamicProxy
+from egse.settings import Settings
+from egse.system import Timer
+from egse.system import wait_until
+from egse.zmq_ser import connect_address
+
+logger = logging.getLogger(__name__)
+
+JORAN_SETTINGS = Settings.load("JORAN Controller")
+CTRL_SETTINGS = Settings.load("Hexapod JORAN Control Server")
+DEVICE_SETTINGS = Settings.load(filename="joran.yaml")
+
+
+class JoranInterface(AlphaPlusControllerInterface):
+    """
+    Interface definition for the JoranController, the JoranProxy, and the JoranSimulator.
+    """
+
+
+class JoranController(JoranInterface, DynamicCommandMixin):
+    def __init__(self):
+        self.hostname = {JORAN_SETTINGS.IP}
+        self.port = {JORAN_SETTINGS.PORT}
+        self.transport = self.hexapod = AlphaPlusTelnetInterface(self.hostname, self.port)
+
+        super.__init__()
+
+    def is_simulator(self):
+        return False
+
+    def is_connected(self):
+        return self.hexapod.is_connected()
+
+    def connect(self):
+        self.hexapod.connect()
+
+    def disconnect(self):
+        self.hexapod.disconnect()
+
+    def reconnect(self):
+        if self.is_connected():
+            self.disconnect()
+        self.connect()
+
+    def reset(self, wait=True):
+        raise NotImplementedError
+
+    # def sequence(self):
+    #     raise NotImplementedError
+
+    def set_virtual_homing(self, tx, ty, tz, rx, ry, rz):
+        raise NotImplementedError
+
+    def get_debug_info(self):
+        raise NotImplementedError
+
+    def jog(self, axis: int, inc: float) -> int:
+        raise NotImplementedError
+
+    def get_temperature(self):
+        raise NotImplementedError
+
+    def get_limits_state(self):
+        raise NotImplementedError
+
+    def machine_limit_enable(self, state):
+        raise NotImplementedError
+
+    def user_limit_set(self, *par):
+        raise NotImplementedError
+
+    def set_default(self):
+        raise NotImplementedError
+
+
+class JoranSimulator(JoranInterface):
+    """
+    HexapodSimulator simulates the Symétrie Hexapod JORAN. The class is heavily based on the
+    ReferenceFrames in the `egse.coordinates` package.
+
+    The simulator implements the same methods as the HexapodController class which acts on the
+    real hardware controller in either simulation mode or with a real Hexapod JORAN connected.
+
+    Therefore, the HexapodSimulator can be used instead of the Hexapod class in test harnesses
+    and when the hardware is not available.
+
+    This class simulates all the movements and status of the Hexapod.
+    """
+
+    def __init__(self):
+        super().__init__()
+
+        # Keep a record if the homing() command has been executed.
+
+        self.homing_done = False
+        self.control_loop = False
+        self._virtual_homing = False
+        self._virtual_homing_position = None
+
+    def is_simulator(self):
+        return True
+
+    def connect(self):
+        pass
+
+    def reconnect(self):
+        pass
+
+    def disconnect(self):
+        # TODO:
+        #   Should I keep state in this class to check if it has been disconnected?
+        #
+        # TODO:
+        #   What happens when I re-connect to this Simulator? Shall it be in Homing position or
+        #   do I have to keep state via a persistence mechanism?
+        pass
+
+    def is_connected(self):
+        return True
+
+    def clear_error(self):
+        return 0
+
+    def homing(self):
+        self.goto_zero_position()
+        self.homing_done = True
+        self._virtual_homing = False
+        self._virtual_homing_position = None
+        return 0
+
+    def is_homing_done(self):
+        return self.homing_done
+
+    def activate_control_loop(self):
+        self.control_loop = True
+        return self.control_loop
+
+    def deactivate_control_loop(self):
+        self.control_loop = False
+        return self.control_loop
+
+    pass
+
+
+class JoranProxy(DynamicProxy, JoranInterface):
+    """The JoranProxy class is used to connect to the control server and send commands to the
+    Hexapod JORAN remotely."""
+
+    def __init__(
+        self,
+        protocol=CTRL_SETTINGS.PROTOCOL,
+        hostname=CTRL_SETTINGS.HOSTNAME,
+        port=CTRL_SETTINGS.COMMANDING_PORT,
+    ):
+        """
+        Args:
+            protocol: the transport protocol [default is taken from settings file]
+            hostname: location of the control server (IP address) [default is taken from settings
+            file]
+            port: TCP port on which the control server is listening for commands [default is
+            taken from settings file]
+        """
+        super().__init__(connect_address(protocol, hostname, port))
+
+
+if __name__ == "__main__":
+    from rich import print as rp
+
+    joran = JoranController()
+    joran.connect()
+
+    with Timer("JoranController"):
+        rp(joran.info())
+        rp(joran.is_homing_done())
+        rp(joran.is_in_position())
+        rp(joran.activate_control_loop())
+        rp(joran.get_general_state())
+        rp(joran.get_actuator_state())
+        rp(joran.deactivate_control_loop())
+        rp(joran.get_general_state())
+        rp(joran.get_actuator_state())
+        rp(joran.stop())
+        rp(joran.get_limits_value(0))
+        rp(joran.get_limits_value(1))
+        rp(joran.check_absolute_movement(1, 1, 1, 1, 1, 1))
+        rp(joran.check_absolute_movement(51, 51, 51, 1, 1, 1))
+        rp(joran.get_speed())
+        rp(joran.set_speed(2.0, 1.0))
+        time.sleep(0.5)  # if we do not sleep, the get_speed() will get the old values
+        speed = joran.get_speed()
+
+        if not math.isclose(speed["vt"], 2.0):
+            rp(f"[red]{speed['vt']} != 2.0[/red]")
+        if not math.isclose(speed["vr"], 1.0):
+            rp(f"[red]{speed['vr']} != 1.0[/red]")
+
+        rp(joran.get_actuator_length())
+
+        # rp(joran.machine_limit_enable(0))
+        # rp(joran.machine_limit_enable(1))
+        # rp(joran.get_limits_state())
+        rp(joran.get_coordinates_systems())
+        rp(
+            joran.configure_coordinates_systems(
+                0.033000,
+                -0.238000,
+                230.205000,
+                0.003282,
+                0.005671,
+                0.013930,
+                0.000000,
+                0.000000,
+                0.000000,
+                0.000000,
+                0.000000,
+                0.000000,
+            )
+        )
+        rp(joran.get_coordinates_systems())
+        rp(joran.get_machine_positions())
+        rp(joran.get_user_positions())
+        rp(
+            joran.configure_coordinates_systems(
+                0.000000,
+                0.000000,
+                0.000000,
+                0.000000,
+                0.000000,
+                0.000000,
+                0.000000,
+                0.000000,
+                0.000000,
+                0.000000,
+                0.000000,
+                0.000000,
+            )
+        )
+        rp(joran.validate_position(1, 0, 0, 0, 0, 0, 0, 0))
+        rp(joran.validate_position(1, 0, 0, 0, 50, 0, 0, 0))
+
+        rp(joran.goto_zero_position())
+        rp(joran.is_in_position())
+        if wait_until(joran.is_in_position, interval=1, timeout=300):
+            rp("[red]Task joran.is_in_position() timed out after 30s.[/red]")
+        rp(joran.is_in_position())
+
+        rp(joran.get_machine_positions())
+        rp(joran.get_user_positions())
+
+        rp(joran.move_absolute(0, 0, 12, 0, 0, 10))
+
+        rp(joran.is_in_position())
+        if wait_until(joran.is_in_position, interval=1, timeout=300):
+            rp("[red]Task joran.is_in_position() timed out after 30s.[/red]")
+        rp(joran.is_in_position())
+
+        rp(joran.get_machine_positions())
+        rp(joran.get_user_positions())
+
+        rp(joran.move_absolute(0, 0, 0, 0, 0, 0))
+
+        rp(joran.is_in_position())
+        if wait_until(joran.is_in_position, interval=1, timeout=300):
+            rp("[red]Task joran.is_in_position() timed out after 30s.[/red]")
+        rp(joran.is_in_position())
+
+        rp(joran.get_machine_positions())
+        rp(joran.get_user_positions())
+
+        # joran.reset()
+        joran.disconnect()
+
+        rp(0, decode_validation_error(0))
+        rp(11, decode_validation_error(11))
+        rp(8, decode_validation_error(8))
+        rp(24, decode_validation_error(24))

egse/hexapod/symetrie/joran.yaml

@@ -0,0 +1,62 @@
+BaseClass:
+    egse.hexapod.symetrie.alpha.AlphaPlusControllerInterface
+
+ProxyClass:
+    egse.hexapod.symetrie.joran.JoranProxy
+
+ControlServerClass:
+    egse.hexapod.symetrie.joran_cs.JoranControlServer
+
+ControlServer:
+    egse.hexapod.symetrie.joran_cs
+
+UserInterface:
+    egse.hexapod.symetrie.joran_ui
+
+Commands:
+
+    # Each of these groups is parsed and used on both the server and the client side.
+    #
+    # The group name (e.g. is_simulator) will be monkey patched in the Proxy class for the device
+    # or service.
+    #
+    # The other field are:
+    #   description:   Used by the doc_string method to generate a help string
+    #   cmd:           Command string that will eventually be sent to the hardware controller for
+    #                  the device. This cmd string is also used at the client side to parse and
+    #                  validate the arguments.
+    #   device_method: The name of the method to be called on the device class.
+    #                  These should all be defined by the interface class for the device, i.e.
+    #                  JoranInterface in this case.
+    #                  When the device_method is the same as the group name, it can be omitted.
+    #   response:      The name of the method to be called from the device protocol.
+    #                  This method should exist in the subclass of the CommandProtocol base class,
+    #                  i.e. in this case it will be the JoranProtocol class.
+    #                  The default (when no response is given) is 'handle_device_method'.
+
+    # Definition of the DeviceInterface
+
+    is_simulator:
+        description:    Ask if the connected class is a simulator instead of the real device Controller class.
+        returns:        bool | True if the far end is a simulator instead of the real hardware
+
+    is_connected:
+        description:    Check if the Hexapod hardware controller is connected.
+
+    connect:
+        description:    Connect the Hexapod hardware controller
+
+    reconnect:
+        description:    Reconnect the Hexapod hardware controller.
+
+                        This command will force a disconnect and then try to re-connect to the controller.
+
+    disconnect:
+        description:    Disconnect from the hexapod controller.
+
+                        This command will be send to the Hexapod Control Server which will then
+                        disconnect from the hardware controller.
+
+                        This command does not affect the ZeroMQ connection of the Proxy to the
+                        control server. Use the service command `disconnect_cs()` to disconnect
+                        from the control server.

egse/hexapod/symetrie/joran_cs.py

@@ -0,0 +1,179 @@
+"""
+The Control Server that connects to the Hexapod JORAN Hardware Controller.
+
+Start the control server from the terminal as follows:
+
+    $ joran_cs start-bg
+
+or when you don't have the device available, start the control server in simulator mode. That
+will make the control server connect to a device software simulator:
+
+    $ joran_cs start --sim
+
+Please note that software simulators are intended for simple test purposes and will not simulate
+all device behavior correctly, e.g. timing, error conditions, etc.
+
+"""
+
+import logging
+
+from egse.process import SubProcess
+
+if __name__ != "__main__":
+    import multiprocessing
+
+    multiprocessing.current_process().name = "joran_cs"
+
+import sys
+
+import click
+import rich
+import zmq
+
+from egse.control import ControlServer
+from egse.control import is_control_server_active
+from egse.hexapod.symetrie.joran import JoranProxy
+from egse.hexapod.symetrie.joran_protocol import JoranProtocol
+from egse.settings import Settings
+from egse.zmq_ser import connect_address
+from prometheus_client import start_http_server
+
+logger = logging.getLogger(__name__)
+
+CTRL_SETTINGS = Settings.load("Hexapod JORAN Control Server")
+
+
+class JoranControlServer(ControlServer):
+    """JoranControlServer - Command and monitor the Hexapod JORAN hardware.
+
+    This class works as a command and monitoring server to control the Symétrie Hexapod JORAN.
+    This control server shall be used as the single point access for controlling the hardware
+    device. Monitoring access should be done preferably through this control server also,
+    but can be done with a direct connection through the PunaController if needed.
+
+    The sever binds to the following ZeroMQ sockets:
+
+    * a REQ-REP socket that can be used as a command server. Any client can connect and
+      send a command to the Hexapod.
+
+    * a PUB-SUP socket that serves as a monitoring server. It will send out Hexapod status
+      information to all the connected clients every five seconds.
+
+    """
+
+    def __init__(self):
+        super().__init__()
+
+        self.device_protocol = JoranProtocol(self)
+
+        self.logger.debug(f"Binding ZeroMQ socket to {self.device_protocol.get_bind_address()}")
+
+        self.device_protocol.bind(self.dev_ctrl_cmd_sock)
+
+        self.poller.register(self.dev_ctrl_cmd_sock, zmq.POLLIN)
+
+    def get_communication_protocol(self):
+        return CTRL_SETTINGS.PROTOCOL
+
+    def get_commanding_port(self):
+        return CTRL_SETTINGS.COMMANDING_PORT
+
+    def get_service_port(self):
+        return CTRL_SETTINGS.SERVICE_PORT
+
+    def get_monitoring_port(self):
+        return CTRL_SETTINGS.MONITORING_PORT
+
+    def get_storage_mnemonic(self):
+        try:
+            return CTRL_SETTINGS.STORAGE_MNEMONIC
+        except AttributeError:
+            return "JORAN"
+
+    def before_serve(self):
+        start_http_server(CTRL_SETTINGS.METRICS_PORT)
+
+
+@click.group()
+def cli():
+    pass
+
+
+@cli.command()
+@click.option("--simulator", "--sim", is_flag=True, help="Start the Hexapod Joran Simulator as the backend.")
+def start(simulator):
+    """Start the Hexapod Joran Control Server."""
+
+    if simulator:
+        Settings.set_simulation_mode(True)
+
+    try:
+        controller = JoranControlServer()
+        controller.serve()
+
+    except KeyboardInterrupt:
+        print("Shutdown requested...exiting")
+
+    except SystemExit as exit_code:
+        print("System Exit with code {}.".format(exit_code))
+        sys.exit(exit_code)
+
+    except Exception:
+        logger.exception("Cannot start the Hexapod Joran Control Server")
+
+        # The above line does exactly the same as the traceback, but on the logger
+        # import traceback
+        # traceback.print_exc(file=sys.stdout)
+
+    return 0
+
+
+@cli.command()
+@click.option("--simulator", "--sim", is_flag=True, help="Start the Hexapod Joran Simulator as the backend.")
+def start_bg(simulator):
+    """Start the JORAN Control Server in the background."""
+    sim = "--simulator" if simulator else ""
+    proc = SubProcess("joran_cs", ["joran_cs", "start", sim])
+    proc.execute()
+
+
+@cli.command()
+def stop():
+    """Send a 'quit_server' command to the Hexapod Joran Control Server."""
+
+    try:
+        with JoranProxy() as proxy:
+            sp = proxy.get_service_proxy()
+            sp.quit_server()
+    except ConnectionError:
+        rich.print("[red]Couldn't connect to 'joran_cs', process probably not running. ")
+
+
+@cli.command()
+def status():
+    """Request status information from the Control Server."""
+
+    protocol = CTRL_SETTINGS.PROTOCOL
+    hostname = CTRL_SETTINGS.HOSTNAME
+    port = CTRL_SETTINGS.COMMANDING_PORT
+
+    endpoint = connect_address(protocol, hostname, port)
+
+    if is_control_server_active(endpoint):
+        rich.print("JORAN Hexapod: [green]active")
+        with JoranProxy() as joran:
+            sim = joran.is_simulator()
+            connected = joran.is_connected()
+            ip = joran.get_ip_address()
+            rich.print(f"type: ALPHA+")
+            rich.print(f"mode: {'simulator' if sim else 'device'}{'' if connected else ' not'} connected")
+            rich.print(f"hostname: {ip}")
+            rich.print(f"commanding port: {port}")
+    else:
+        rich.print("JORAN Hexapod: [red]not active")
+
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.DEBUG, format=Settings.LOG_FORMAT_FULL)
+
+    sys.exit(cli())

egse/hexapod/symetrie/joran_protocol.py

@@ -0,0 +1,117 @@
+import logging
+
+from egse.command import ClientServerCommand
+from egse.control import ControlServer
+from egse.device import DeviceConnectionState
+from egse.hexapod.symetrie.joran import JoranController
+from egse.hexapod.symetrie.joran import JoranInterface
+from egse.hexapod.symetrie.joran import JoranSimulator
+from egse.hk import read_conversion_dict, convert_hk_names
+from egse.metrics import define_metrics
+from egse.protocol import CommandProtocol
+from egse.settings import Settings
+from egse.system import format_datetime
+from egse.zmq_ser import bind_address
+
+logger = logging.getLogger(__name__)
+
+ctrl_settings = Settings.load("Hexapod JORAN Control Server")
+joran_settings = Settings.load(filename="joran.yaml")
+
+
+class JoranCommand(ClientServerCommand):
+    pass
+
+
+class JoranProtocol(CommandProtocol):
+    def __init__(self, control_server: ControlServer):
+        super().__init__(control_server)
+
+        self.hk_conversion_table = read_conversion_dict(self.control_server.get_storage_mnemonic(), use_site=True)
+
+        if Settings.simulation_mode():
+            self.hexapod = JoranSimulator()
+        else:
+            self.hexapod = JoranController()
+
+        self.hexapod.connect()
+
+        self.load_commands(joran_settings.Commands, JoranCommand, JoranInterface)
+
+        self.build_device_method_lookup_table(self.hexapod)
+
+        self.metrics = define_metrics("JORAN")
+
+    def get_bind_address(self):
+        return bind_address(
+            self.control_server.get_communication_protocol(),
+            self.control_server.get_commanding_port(),
+        )
+
+    def get_device(self):
+        self.hexapod
+
+    def get_status(self):
+        status = super().get_status()
+
+        if self.state == DeviceConnectionState.DEVICE_NOT_CONNECTED and not Settings.simulation_mode():
+            return status
+
+        mach_positions = self.hexapod.get_machine_positions()
+        user_positions = self.hexapod.get_user_positions()
+        actuator_length = self.hexapod.get_actuator_length()
+
+        status.update({"mach": mach_positions, "user": user_positions, "alength": actuator_length})
+
+        return status
+
+    def get_housekeeping(self) -> dict:
+        result = dict()
+        result["timestamp"] = format_datetime()
+
+        if self.state == DeviceConnectionState.DEVICE_NOT_CONNECTED and not Settings.simulation_mode():
+            return result
+
+        mach_positions = self.hexapod.get_machine_positions()
+        user_positions = self.hexapod.get_user_positions()
+        actuator_length = self.hexapod.get_actuator_length()
+        actuator_temperature = self.hexapod.get_temperature()
+
+        for idx, key in enumerate(["user_t_x", "user_t_y", "user_t_z", "user_r_x", "user_r_y", "user_r_z"]):
+            result[key] = user_positions[idx]
+
+        for idx, key in enumerate(["mach_t_x", "mach_t_y", "mach_t_z", "mach_r_x", "mach_r_y", "mach_r_z"]):
+            result[key] = mach_positions[idx]
+
+        for idx, key in enumerate(["alen_t_x", "alen_t_y", "alen_t_z", "alen_r_x", "alen_r_y", "alen_r_z"]):
+            result[key] = actuator_length[idx]
+
+        for idx, key in enumerate(["atemp_1", "atemp_2", "atemp_3", "atemp_4", "atemp_5", "atemp_6"]):
+            result[key] = actuator_temperature[idx]
+
+        # # TODO:
+        # #   the get_general_state() method should be refactored as to return a dict instead of a
+        # #   list. Also, we might want to rethink the usefulness of returning the tuple,
+        # #   it the first return value ever used?
+
+        _, _ = self.hexapod.get_general_state()
+
+        result["Homing done"] = self.hexapod.is_homing_done()
+        result["In position"] = self.hexapod.is_in_position()
+
+        hk_dict = convert_hk_names(result, self.hk_conversion_table)
+
+        for key, value in hk_dict.items():
+            if key != "timestamp":
+                self.metrics[key].set(value)
+
+        return hk_dict
+
+    def is_connected(self):
+        # FIXME(rik): There must be another way to check if the socket is still alive...
+        #             This will send way too many VERSION requests to the controllers.
+        #             According to SO [https://stackoverflow.com/a/15175067] the best way
+        #             to check for a connection drop / close is to handle the exceptions
+        #             properly.... so, no polling for connections by sending it a simple
+        #             command.
+        return self.hexapod.is_connected()