symetrie-hexapod 0.17.3__py3-none-any.whl

egse/hexapod/symetrie/puna.yaml

@@ -0,0 +1,193 @@
+BaseClass:
+    egse.hexapod.symmetrie.PunaInterface
+
+ProxyClass:
+    egse.hexapod.symetrie.PunaProxy
+
+ControlServerClass:
+    egse.hexapod.symetrie.PunaControlServer
+
+ControlServer:
+    egse.hexapod.symetrie.puna_cs
+
+UserInterface:
+    egse.hexapod.symetrie.puna_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 send 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.
+    #                  PunaInterface 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 PunaProtocol 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.
+
+
+    # Definition of the device commands
+
+    is_in_position:
+        description:    Returns True when the actuators are in position.
+
+    info:
+        description:    Retrieve basic information about the Hexapod and the Controller.
+
+    reset:
+        description:    Completely resets the Hexapod controller with the standard boot cycle.
+        cmd:            "$$$"
+
+    stop:
+        description:    Stop the current motion.
+        cmd:            "&2 Q20=2"
+
+    homing:
+        description:    Start the homing cycle for the Hexapod.
+        cmd:            "&2 Q20=1"
+
+    is_homing_done:
+        description:    Check if Homing is done.
+
+    set_virtual_homing:
+        description:    Starts the virtual homing cycle on the hexapod.
+
+                        This command uses the position given in parameters to initialize the hexapod position.
+                        No movements of the hexapod are performed during this homing cycle. Please note that the
+                        position specified in parameters must match the absolute position of the Object coordinate
+                        system in the User coordinate system (see description in the manual chapter 2 on coordinates
+                        systems). This position correspond to the answer of the command `get_user_positions()`.
+                        During this operation, it is important to have the same hexapod position as those defined
+                        during the record of the position. Otherwise, the system initialization will be incorrect.
+
+        cmd:            "&2 Q71={tx} Q72={ty} Q73={tz} Q74={rx} Q75={ry} Q76={rz} Q20=42"
+
+    clear_error:
+        description:    Clear all errors in the controller software.
+        cmd:            "&2 Q20=15"
+
+    activate_control_loop:
+        description:    Activates the control loop on motors.
+        cmd:            "&2 Q20=3"
+
+    deactivate_control_loop:
+        description:    Disables the control loop on the servo motors.
+        cmd:            "&2 Q20=4"
+
+    configure_coordinates_systems:
+        description:    Change the definition of the User Coordinate System and the Object Coordinate System.
+        cmd:            "&2 Q80={tx_u} Q81={ty_u} Q82={tz_u} Q83={rx_u} Q84={ry_u} Q85={rz_u} Q86={tx_o} Q87={ty_o} Q88={tz_o} Q89={rx_o} Q90={ry_o} Q91={rz_o} Q20=21"
+
+    get_coordinates_systems:
+        description:    Retrieve the definition of the User Coordinate System and the Object Coordinate System.
+        cmd:            "&2 Q20=31"
+        query:          "&2 Q20 Q80,12,1"
+
+    get_general_state:
+        description:    Retrieve general state information of the hexapod.
+
+    get_user_positions:
+        description:    Retrieve the position of the Object Coordinate System in the User Coordinate System.
+        cmd:            "&2 Q53,6,1"
+
+    get_machine_positions:
+        description:    Retrieve the position of the Platform Coordinate System in the Machine Coordinate System.
+        cmd:            "&2 Q47,6,1"
+
+    get_actuator_length:
+        description:    Retrieve the current length of the hexapod actuators.
+        cmd:            "&2 Q41,6,1"
+
+    get_actuator_state:
+        description:    Returns the general state of the actuators.
+
+    move_absolute:
+        description:    Move/define the Object Coordinate System position and orientation 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 at first (Tx, Ty, tZ)
+                        and then the rotation components (Rx, Ry, Rz).
+        cmd:            "&2 Q70=0 Q71={tx:.6f} Q72={ty:.6f} Q73={tz:.6f} Q74={rx:.6f} Q75={ry:.6f} Q76={rz:.6f} Q20=11"
+
+    move_relative_object:
+        description:    Move the object relative to its current object position and orientation.
+        cmd:            "&2 Q70=1 Q71={tx:.6f} Q72={ty:.6f} Q73={tz:.6f} Q74={rx:.6f} Q75={ry:.6f} Q76={rz:.6f} Q20=11"
+
+    move_relative_user:
+        description:    Move the object relative to its current object position and orientation.
+        cmd:            "&2 Q70=2 Q71={tx:.6f} Q72={ty:.6f} Q73={tz:.6f} Q74={rx:.6f} Q75={ry:.6f} Q76={rz:.6f} Q20=11"
+
+    check_absolute_movement:
+        description:    Check if the requested object movement is valid.
+        cmd:            "&2 Q70=0 Q71={tx} Q72={ty} Q73={tz} Q74={rx} Q75={ry} Q76={rz} Q20=10"
+
+    check_relative_object_movement:
+        description:    Check if the requested object movement is valid.
+        cmd:            "&2 Q70=1 Q71={tx} Q72={ty} Q73={tz} Q74={rx} Q75={ry} Q76={rz} Q20=10"
+
+    check_relative_user_movement:
+        description:    Check if the requested object movement is valid.
+        cmd:            "&2 Q70=2i Q71={tx} Q72={ty} Q73={tz} Q74={rx} Q75={ry} Q76={rz} Q20=10"
+
+    goto_zero_position:
+        cmd:            "&2 Q80=1 Q20=13"
+
+    goto_retracted_position:
+        cmd:            "&2 Q80=2 Q20=13"
+
+    goto_specific_position:
+        cmd:            "&2 Q80={pos} Q20=13"
+
+    perform_maintenance:
+        description:    Ask the controller to perform the maintenance cycle which consists to
+                        travel the full range on one axis. Full range corresponds to the Hexapod
+                        machine limts (defined by the manufacturer), and the movement is
+                        performed in Machine coordinate system.
+        cmd:            "{axis}"
+
+    get_speed:
+        description:    Returns the movement speed. Translation speed is expressed in mm per
+                        second, the angular speed is expressed in degrees per second.
+
+    set_speed:
+        description:    Sets the speed of movements.
+        cmd:            "&2 Q80={vt} Q81={vr} Q20=25"
+
+    get_debug_info:
+        description:    Returns debugging status information.

egse/hexapod/symetrie/puna_cs.py

@@ -0,0 +1,241 @@
+"""
+The Control Server that connects to the Hexapod PUNA Hardware Controller.
+
+Start the control server from the terminal as follows:
+
+    $ puna_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:
+
+    $ puna_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 multiprocessing
+import sys
+from typing import Annotated
+
+import rich
+import typer
+import zmq
+from prometheus_client import start_http_server
+
+from egse.control import ControlServer
+from egse.control import is_control_server_active
+from egse.hexapod.symetrie import ProxyFactory
+from egse.hexapod.symetrie import get_hexapod_controller_pars
+from egse.hexapod.symetrie import logger
+from egse.hexapod.symetrie.puna_protocol import PunaProtocol
+from egse.registry.client import RegistryClient
+from egse.services import ServiceProxy
+from egse.settings import Settings
+from egse.storage import store_housekeeping_information
+from egse.zmq_ser import connect_address
+
+CTRL_SETTINGS = Settings.load("Hexapod Control Server")
+
+
+class PunaControlServer(ControlServer):
+    """
+    PunaControlServer - Command and monitor the Hexapod PUNA hardware.
+
+    This class works as a command and monitoring server to control the Symétrie Hexapod PUNA.
+    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, device_id: str, simulator: bool = False):
+        super().__init__()
+
+        multiprocessing.current_process().name = "puna_cs"
+
+        self.logger = logger
+
+        self.device_id = device_id
+        self.device_protocol = PunaProtocol(self, device_id=device_id, simulator=simulator)
+
+        self.device_protocol.bind(self.dev_ctrl_cmd_sock)
+
+        self.poller.register(self.dev_ctrl_cmd_sock, zmq.POLLIN)
+
+        self.register_service(service_type=f"{device_id}")
+
+    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 "PUNA"
+
+    def is_storage_manager_active(self):
+        from egse.storage import is_storage_manager_active
+
+        return is_storage_manager_active()
+
+    def store_housekeeping_information(self, data):
+        """Send housekeeping information to the Storage manager."""
+
+        origin = self.get_storage_mnemonic()
+        store_housekeeping_information(origin, data)
+
+    def register_to_storage_manager(self):
+        from egse.storage import register_to_storage_manager
+        from egse.storage.persistence import TYPES
+
+        register_to_storage_manager(
+            origin=self.get_storage_mnemonic(),
+            persistence_class=TYPES["CSV"],
+            prep={
+                "column_names": list(self.device_protocol.get_housekeeping().keys()),
+                "mode": "a",
+            },
+        )
+
+    def unregister_from_storage_manager(self):
+        from egse.storage import unregister_from_storage_manager
+
+        unregister_from_storage_manager(origin=self.get_storage_mnemonic())
+
+    def before_serve(self):
+        start_http_server(CTRL_SETTINGS.METRICS_PORT)
+
+    def after_serve(self) -> None:
+        self.deregister_service()
+
+
+app = typer.Typer()
+
+
+@app.command()
+def start(
+    device_id: Annotated[str, typer.Argument(help="the device identifier, identifies the hardware controller")],
+    simulator: Annotated[
+        bool, typer.Option("--simulator", "--sim", help="start the hexapod PUNA Control Server in simulator mode")
+    ] = False,
+):
+    """
+    Start the Hexapod PUNA Control Server.
+    """
+
+    try:
+        controller = PunaControlServer(device_id, simulator)
+        controller.serve()
+
+    except KeyboardInterrupt:
+        print("Shutdown requested...exiting")
+
+    except SystemExit as exc:
+        exit_code = exc.code if hasattr(exc, "code") else 0
+        print(f"System Exit with code {exc.code}")
+        sys.exit(exit_code)
+
+    except Exception:
+        logger.exception("Cannot start the Hexapod Puna 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
+
+
+@app.command()
+def stop(device_id: str):
+    """Send a 'quit_server' command to the Hexapod Puna Control Server."""
+
+    with RegistryClient() as reg:
+        service = reg.discover_service(device_id)
+        rich.print("service = ", service)
+
+        if service:
+            proxy = ServiceProxy(protocol="tcp", hostname=service["host"], port=service["metadata"]["service_port"])
+            proxy.quit_server()
+        else:
+            *_, device_type, controller_type = get_hexapod_controller_pars(device_id)
+
+            factory = ProxyFactory()
+            try:
+                with factory.create(device_type, device_id=device_id) as proxy:
+                    sp = proxy.get_service_proxy()
+                    sp.quit_server()
+            except ConnectionError:
+                rich.print("[red]Couldn't connect to 'puna_cs', process probably not running. ")
+
+
+@app.command()
+def status(device_id: str):
+    """Request status information from the Control Server."""
+
+    *_, device_type, controller_type = get_hexapod_controller_pars(device_id)
+
+    with RegistryClient() as reg:
+        service = reg.discover_service(device_id)
+        # rich.print("service = ", service)
+
+        if service:
+            protocol = service.get("protocol", "tcp")
+            hostname = service["host"]
+            port = service["port"]
+            service_port = service["metadata"]["service_port"]
+            monitoring_port = service["metadata"]["monitoring_port"]
+            endpoint = connect_address(protocol, hostname, port)
+            # rich.print(f"{endpoint = }")
+        else:
+            rich.print(
+                f"[red]The PUNA CS '{device_id}' isn't registered as a service. I cannot contact the control "
+                f"server without the required info from the service registry.[/]"
+            )
+            rich.print("PUNA Hexapod: [red]not active")
+            return
+
+    factory = ProxyFactory()
+
+    if is_control_server_active(endpoint):
+        rich.print("PUNA Hexapod: [green]active")
+        with factory.create(device_type, device_id=device_id, protocol=protocol, hostname=hostname, port=port) as puna:
+            sim = puna.is_simulator()
+            connected = puna.is_connected()
+            ip = puna.get_ip_address()
+            rich.print(f"type: {controller_type}")
+            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}")
+            rich.print(f"service port: {service_port}")
+            rich.print(f"monitoring port: {monitoring_port}")
+    else:
+        rich.print("PUNA Hexapod: [red]not active")
+
+
+if __name__ == "__main__":
+    import logging
+
+    from egse.logger import set_all_logger_levels
+
+    set_all_logger_levels(logging.DEBUG)
+
+    sys.exit(app())

egse/hexapod/symetrie/puna_protocol.py

@@ -0,0 +1,126 @@
+from pathlib import Path
+
+from egse.command import ClientServerCommand
+from egse.control import ControlServer
+from egse.device import DeviceConnectionState
+from egse.hexapod.symetrie import ControllerFactory
+from egse.hexapod.symetrie import get_hexapod_controller_pars
+from egse.hexapod.symetrie import logger
+from egse.hexapod.symetrie.puna import PunaInterface
+from egse.hexapod.symetrie.puna import PunaSimulator
+
+# from egse.hk import read_conversion_dict, convert_hk_names
+from egse.protocol import CommandProtocol
+from egse.settings import Settings
+from egse.system import format_datetime
+from egse.zmq_ser import bind_address
+
+_HERE = Path(__file__).parent
+
+DEVICE_SETTINGS = Settings.load(filename="puna.yaml", location=_HERE)
+
+
+class PunaCommand(ClientServerCommand):
+    pass
+
+
+class PunaProtocol(CommandProtocol):
+    def __init__(self, control_server: ControlServer, device_id: str, simulator: bool = False):
+        super().__init__(control_server)
+        self.simulator = simulator
+        self.device_id = device_id
+
+        # FIXME: HK needs to be working
+        # self.hk_conversion_table = read_conversion_dict(self.control_server.get_storage_mnemonic(), use_site=True)
+
+        if self.simulator:
+            self.hexapod = PunaSimulator()
+        else:
+            *_, device_type, controller_type = get_hexapod_controller_pars(device_id)
+
+            factory = ControllerFactory()
+            self.hexapod = factory.create(device_type, device_id=device_id)
+            self.hexapod.add_observer(self)
+
+        try:
+            self.hexapod.connect()
+        except ConnectionError:
+            logger.warning("Couldn't establish a connection to the PUNA Hexapod, check the log messages.")
+
+        self.load_commands(DEVICE_SETTINGS.Commands, PunaCommand, PunaInterface)
+        self.build_device_method_lookup_table(self.hexapod)
+
+        # self.metrics = define_metrics("PUNA")
+
+    def get_bind_address(self):
+        return bind_address(
+            self.control_server.get_communication_protocol(),
+            self.control_server.get_commanding_port(),
+        )
+
+    def get_device(self):
+        return self.hexapod
+
+    def get_status(self):
+        status = super().get_status()
+
+        if self.state == DeviceConnectionState.DEVICE_NOT_CONNECTED and not self.simulator:
+            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 self.simulator:
+            return result
+
+        mach_positions = self.hexapod.get_machine_positions()
+        user_positions = self.hexapod.get_user_positions()
+        actuator_length = self.hexapod.get_actuator_length()
+
+        # The result of the previous calls might be None when e.g. the connection
+        # to the device gets lost.
+
+        if mach_positions is None or user_positions is None or actuator_length is None:
+            if not self.hexapod.is_connected():
+                logger.warning("Hexapod PUNA disconnected.")
+                self.update_connection_state(DeviceConnectionState.DEVICE_NOT_CONNECTED)
+            return result
+
+        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]
+
+        # 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()
+
+        return result  # convert_hk_names(result, self.hk_conversion_table)
+
+    def is_device_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()