cgse 2024.7.0__py3-none-any.whl → 2025.0.2__py3-none-any.whl

egse/gimbal/symetrie/gimbal.yaml

@@ -1,168 +0,0 @@
-BaseClass:
-    egse.gimbal.symmetrie.GimbalInterface
-
-ProxyClass:
-    egse.gimbal.symetrie.GimbalProxy
-
-ControlServerClass:
-    egse.gimbal.symetrie.GimbalControlServer
-
-ControlServer:
-    egse.gimbal.symetrie.gimbal_cs
-
-UserInterface:
-    egse.gimbal.symetrie.gimbal_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.
-    #                  GimbalInterface 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 GimbalProtocol class.
-    #                  The default (when no response is given) is 'handle_device_method'.
-
-    # Definition of the 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 Gimbal hardware controller is connected.
-
-    connect:
-        description:    Connect the Gimbal hardware controller
-
-    reconnect:
-        description:    Reconnect the Gimbal hardware controller.
-
-                        This command will force a disconnect and then try to re-connect to the controller.
-
-    disconnect:
-        description:    Disconnect from the gimbal controller.
-
-                        This command will be send to the Gimbal 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 Gimbal and the Controller.
-
-    reset:
-        description:    Completely resets the Gimbal 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 Gimbal.
-        cmd:            "&2 Q20=1"
-
-    is_homing_done:
-        description:    Check if Homing is done.
-
-    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_offsets:
-        description:    Change the definition of the offsets.
-        cmd:            "&2 Q80={grx} Q81={gry} Q20=21"
-
-    get_offsets:
-        description:    Retrieve the definition of the offsets.
-        cmd:            "&2 Q20=31"
-        query:          "&2 Q20 Q80,2,1"
-
-    get_general_state:
-        description:    Retreive general state information of the gimbal.
-
-    get_user_positions:
-        description:    Retreive the position of the object in the User Coordinate System.
-        cmd:            "&2 Q53,2,1"
-
-    get_machine_positions:
-        description:    Retreive the position of the gimbal in the Machine Coordinate System.
-        cmd:            "&2 Q47,2,1"
-
-    get_motor_temperatures:
-        description:    Retrieve the temperatures of the Gimbal motors.
-        cmd:            "&2 Q59,2,1"
-
-    get_actuator_length:
-        description:    Retreive the current length of the gimbal actuators.
-        cmd:            "&2 Q41,2,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.
-        cmd:            "&2 Q70=0 Q71={grx} Q72={gry} Q20=11"
-
-    move_relative:
-        description:    Move the object relative to its current object position and orientation.
-        cmd:            "&2 Q70=1 Q71={grx} Q72={gry} Q20=11"
-
-    check_absolute_movement:
-        description:    Check if the requested object movement is valid.
-        cmd:            "&2 Q70=0 Q71={grx} Q72={gry} Q20=10"
-
-    check_relative_movement:
-        description:    Check if the requested object movement is valid.
-        cmd:            "&2 Q70=0 Q71={grx} Q72={gry} Q20=11"
-
-    goto_zero_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 Gimbal
-                        machine limts (defined by the manufacturer), and the movement is
-                        performed in Machine coordinate system.
-
-    get_speed:
-        description:    Returns the rotation speed. the angular speed is expressed in degrees
-                        per second.
-
-    set_speed:
-        description:    Sets the speed of movements.
-        cmd:            "&2 Q81={sr} Q20=25"
-
-    get_debug_info:
-        description:    Returns debugging status information.

egse/gimbal/symetrie/gimbal_cs.py

@@ -1,183 +0,0 @@
-"""
-The Control Server that connects to the Gimbal Hardware Controller.
-
-Start the control server from the terminal as follows:
-
-    $ gimbal_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:
-
-    $ gimbal_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
-
-if __name__ != "__main__":
-    import multiprocessing
-    multiprocessing.current_process().name = "gimbal_cs"
-
-import sys
-
-import click
-import invoke
-import rich
-import zmq
-
-from egse.control import is_control_server_active
-from egse.zmq_ser import connect_address
-
-from prometheus_client import start_http_server
-
-from egse.control import ControlServer
-from egse.gimbal.symetrie.gimbal import GimbalProxy
-from egse.gimbal.symetrie.gimbal_protocol import GimbalProtocol
-from egse.settings import Settings
-
-logger = logging.getLogger(__name__)
-
-CTRL_SETTINGS = Settings.load("Gimbal Control Server")
-
-
-class GimbalControlServer(ControlServer):
-    """GimbalControlServer - Command and monitor the Gimbal hardware.
-
-    This class works as a command and monitoring server to control the Symétrie Gimbal.
-    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 GimbalController 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 Gimbal.
-
-    * a PUB-SUP socket that serves as a monitoring server. It will send out Gimbal status
-      information to all the connected clients every five seconds.
-
-    """
-
-    def __init__(self):
-        super().__init__()
-
-        self.device_protocol = GimbalProtocol(self)
-
-        self.logger.info(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 "GIMBAL"
-
-    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 Gimbal Simulator as the backend.")
-def start(simulator):
-    """Start the Gimbal Control Server."""
-
-    if simulator:
-
-        Settings.set_simulation_mode(True)
-
-    try:
-
-        controller = GimbalControlServer()
-        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 Gimbal 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 Gimbal Simulator as the backend.")
-def start_bg(simulator):
-    """Start the Gimbal Control Server in the background."""
-    sim = "--simulator" if simulator else ""
-    invoke.run(f"gimbal_cs start {sim}", disown=True)
-
-
-@cli.command()
-def stop():
-    """Send a 'quit_server' command to the Gimbal Control Server."""
-
-    try:
-        with GimbalProxy() as proxy:
-            sp = proxy.get_service_proxy()
-            sp.quit_server()
-    except ConnectionError:
-        rich.print("[red]Couldn't connect to 'gimbal_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(f"Gimbal: [green]active")
-        with GimbalProxy() as gimbal:
-            sim = gimbal.is_simulator()
-            connected = gimbal.is_connected()
-            ip = gimbal.get_ip_address()
-            rich.print(f"mode: {'simulator' if sim else 'device'}{' not' if not connected else ''} connected")
-            rich.print(f"hostname: {ip}")
-    else:
-        rich.print(f"Gimbal: [red]not active")
-
-
-if __name__ == "__main__":
-
-    logging.basicConfig(level=logging.DEBUG, format=Settings.LOG_FORMAT_FULL)
-
-    sys.exit(cli())

egse/gimbal/symetrie/gimbal_protocol.py

@@ -1,138 +0,0 @@
-import logging
-
-from egse.command import ClientServerCommand
-from egse.control import ControlServer
-from egse.device import DeviceConnectionState
-from egse.gimbal.symetrie.gimbal import GimbalController
-from egse.gimbal.symetrie.gimbal import GimbalInterface
-from egse.gimbal.symetrie.gimbal import GimbalSimulator
-from egse.hk import read_conversion_dict, convert_hk_names
-from egse.protocol import CommandProtocol
-from egse.settings import Settings
-from egse.setup import load_setup
-from egse.system import format_datetime
-from egse.zmq_ser import bind_address
-from egse.metrics import define_metrics
-
-logger = logging.getLogger(__name__)
-
-ctrl_settings = Settings.load("Gimbal Control Server")
-gimbal_settings = Settings.load(filename="gimbal.yaml")
-
-
-class GimbalCommand(ClientServerCommand):
-    pass
-
-
-class GimbalProtocol(CommandProtocol):
-    def __init__(self, control_server: ControlServer):
-        super().__init__()
-        self.control_server = control_server
-        setup = load_setup()
-
-        self.hk_conversion_table = read_conversion_dict(self.control_server.get_storage_mnemonic(), use_site=True,
-                                                        setup=setup)
-
-        if Settings.simulation_mode():
-            self.gimbal = GimbalSimulator()
-        else:
-            self.gimbal = GimbalController()
-            self.gimbal.add_observer(self)
-
-        try:
-            self.gimbal.connect()
-        except ConnectionError as exc:
-            logger.warning(
-                f"Couldn't establish a connection to the Gimbal, check the log messages.")
-
-        self.load_commands(gimbal_settings.Commands, GimbalCommand, GimbalInterface)
-        self.build_device_method_lookup_table(self.gimbal)
-
-        self.metrics = define_metrics(origin="GIMBAL", use_site=True, setup=setup)
-
-    def get_bind_address(self):
-        return bind_address(
-            self.control_server.get_communication_protocol(),
-            self.control_server.get_commanding_port(),
-        )
-
-    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.gimbal.get_machine_positions()
-        user_positions = self.gimbal.get_user_positions()
-        actuator_length = self.gimbal.get_actuator_length()
-
-        status.update({"mach": mach_positions, "user": user_positions, "alength": actuator_length})
-
-        return status
-
-    def get_housekeeping(self) -> dict:
-
-        metrics_dict = self.metrics
-
-        result = dict()
-        result["timestamp"] = format_datetime()
-
-        if self.state == DeviceConnectionState.DEVICE_NOT_CONNECTED and not Settings.simulation_mode():
-            return result
-
-        mach_positions = self.gimbal.get_machine_positions()
-        user_positions = self.gimbal.get_user_positions()
-        actuator_length = self.gimbal.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.gimbal.is_connected():
-                logger.warning("Gimbal disconnected.")
-                self.update_connection_state(DeviceConnectionState.DEVICE_NOT_CONNECTED)
-            return result
-
-        for idx, key in enumerate(
-            ["user_r_x", "user_r_y"]
-        ):
-            result[key] = user_positions[idx]
-
-        for idx, key in enumerate(
-            ["mach_r_x", "mach_r_y"]
-        ):
-            result[key] = mach_positions[idx]
-
-        for idx, key in enumerate(
-            ["alen_r_x", "alen_r_y"]
-        ):
-            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.gimbal.get_general_state()
-
-        result["Homing done"] = self.gimbal.is_homing_done()
-        result["In position"] = self.gimbal.is_in_position()
-        temperatures = self.gimbal.get_motor_temperatures()
-        result["Temp_X"] = temperatures[0]
-        result["Temp_Y"] = temperatures[1]
-        hk_dict = convert_hk_names(result, self.hk_conversion_table)
-
-        for hk_name in metrics_dict.keys():
-            metrics_dict[hk_name].set(hk_dict[hk_name])    
-            
-        return hk_dict
-    
-    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.gimbal.is_connected()