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

egse/stages/huber/smc9300.yaml

@@ -1,63 +0,0 @@
-BaseClass:
-    egse.stages.huber.HuberSMC9300Interfcae
-
-ProxyClass:
-    egse.stages.huber.HuberSMC9300Proxy
-
-ControlServerClass:
-    egse.stages.huber.HuberSMC9300ControlServer
-
-ControlServer:
-    egse.stages.huber.smc9300_cs
-
-UserInterface:
-    egse.stages.huber.smc9300_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.
-    #                  HuberSMC9300Interface in this case.
-    #                  If device_method is not given, the command name (group name) will be used
-    #                  for the device_method.
-    #   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 HuberSMC9300Protocol class.
-    #                  If response is not given the method `handle_device_method()` will be called.
-
-    # 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 HUBER Stage Controller is connected.
-
-    connect:
-        description:    Connect the HUBER hardware controller.
-
-    reconnect:
-        description:    Reconnect the HUBER hardware controller.
-
-                        This command will force a disconnect and then try to re-connect to the controller.
-
-    disconnect:
-        description:    Disconnect from the Huber hardware controller.
-
-                        This command will be send to the Huber 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/stages/huber/smc9300_cs.py

@@ -1,178 +0,0 @@
-"""
-The HUBER SMC9300 control server connects to the HUBER Hardware Controller.
-
-Start the control server from the terminal as follows:
-
-    $ smc9300_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:
-
-    $ smc9300_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
-import multiprocessing
-
-import rich
-
-from egse.control import is_control_server_active
-from egse.zmq_ser import connect_address
-
-multiprocessing.current_process().name = "smc9300_cs"
-
-import sys
-
-import click
-import invoke
-import zmq
-from prometheus_client import start_http_server
-
-from egse.control import ControlServer
-from egse.settings import Settings
-from egse.stages.huber.smc9300 import HuberSMC9300Proxy
-from egse.stages.huber.smc9300_protocol import HuberSMC9300Protocol
-
-logger = logging.getLogger(__name__)
-
-CTRL_SETTINGS = Settings.load("Huber Control Server")
-
-
-class HuberSMC9300ControlServer(ControlServer):
-    """
-    HuberSMC9300ControlServer - Command and monitor the HUBER hardware stages.
-
-    This class works as a command and monitoring server to control the HUBER stages remotely.
-
-    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 Huber hardware controller.
-
-    * a PUB-SUP socket that serves as a monitoring server. It will send out HUBER status
-      information to all the connected clients every DELAY seconds.
-
-    """
-
-    def __init__(self):
-        super().__init__()
-
-        self.device_protocol = HuberSMC9300Protocol(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)
-
-        self.set_delay(CTRL_SETTINGS.ST_DELAY)
-        self.set_hk_delay(CTRL_SETTINGS.HK_DELAY)
-
-    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 "SMC9300"
-
-    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 Huber Stages Simulator as the backend."
-)
-def start(simulator):
-    """Start the Huber SMC9300 Stages Control Server."""
-
-    if simulator:
-
-        Settings.set_simulation_mode(True)
-
-    try:
-
-        controller = HuberSMC9300ControlServer()
-        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 Huber SMC9300 Stages Control Server")
-
-    return 0
-
-
-@cli.command()
-@click.option("--simulator", "--sim", is_flag=True,
-              help="Start the Huber SMC9300 Simulator as the backend.")
-def start_bg(simulator):
-    """Start the Huber SMC9300 Stages Control Server in the background."""
-    sim = "--simulator" if simulator else ""
-    invoke.run(f"smc9300_cs start {sim}", disown=True)
-
-
-@cli.command()
-def stop():
-    """Send a 'quit_server' command to the Huber SMC9300 Stages Control Server."""
-
-    with HuberSMC9300Proxy() as proxy:
-
-        sp = proxy.get_service_proxy()
-        sp.quit_server()
-
-@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"HUBER Stages: [green]active")
-        with HuberSMC9300Proxy() as stages:
-            sim = stages.is_simulator()
-            connected = stages.is_connected()
-            ip = stages.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"HUBER Stages: [red]not active")
-
-
-if __name__ == "__main__":
-
-    logging.basicConfig(level=logging.DEBUG, format=Settings.LOG_FORMAT_FULL)
-
-    sys.exit(cli())

egse/stages/huber/smc9300_devif.py

@@ -1,345 +0,0 @@
-"""
-HUBER Device Interface to the SMC 9300 motor controller.
-"""
-
-import logging
-import socket
-import threading
-import time
-
-from egse.command import ClientServerCommand
-from egse.device import DeviceConnectionError
-from egse.device import DeviceConnectionInterface
-from egse.device import DeviceTimeoutError
-from egse.device import DeviceTransport
-from egse.settings import Settings
-from egse.system import Timer
-from egse.system import format_datetime
-
-# Explicitly set the module name instead of __name__. When module is executed instead of imported
-# __name__ will result in __main__ and no logging to zmq will be done.
-
-MODULE_LOGGER = logging.getLogger("egse.stages.huber.smc9300_devif")
-
-READ_TIMEOUT = 10.0  # seconds
-WRITE_TIMEOUT = 1.0  # seconds
-CONNECT_TIMEOUT = 3.0  # seconds
-
-HUBER_SETTINGS = Settings.load("Huber Controller")
-DEVICE_NAME = "SMC9300"
-
-
-class HuberError(Exception):
-    pass
-
-
-class HuberSMC9300Command(ClientServerCommand):
-    def get_cmd_string(self, *args, **kwargs) -> str:
-        out = super().get_cmd_string(*args, **kwargs)
-        return out + "\r\n"
-
-
-class HuberSMC9300EthernetInterface(DeviceConnectionInterface, DeviceTransport):
-    """
-    Defines the low-level interface to the HUBER stages controller.
-
-    Args:
-        hostname (str): the IP address or fully qualified hostname of the OGSE hardware
-            controller. The default is defined in the ``settings.yaml`` configuration file.
-
-        port (int): the IP port number to connect to. The default is defined in the
-            `settings.yaml` configuration file.
-    """
-    def __init__(self, hostname: str = None, port: int = None):
-
-        super().__init__()
-
-        # Basic connection settings, loaded from the configuration YAML file
-
-        self.hostname = hostname or HUBER_SETTINGS.HOSTNAME
-        self.port = port or HUBER_SETTINGS.PORT
-        self.sock = None
-
-        # Access-to-the-connection semaphore. Use this to lock/unlock I/O access to the
-        # connection (whatever type it is) in child classes.
-
-        self.semaphore = threading.Semaphore()
-
-        self.is_connection_open = False
-
-        self._num_axes = HUBER_SETTINGS.NUMBER_OF_AXES
-
-    def connect(self):
-        """
-        Connects the TCP socket to the device controller.
-
-        Returns:
-            None.
-
-        Raises:
-            ValueError when hostname or port number are not initialized properly.
-
-            DeviceConnectionError on any socket error except timeouts.
-
-            DeviceTimeoutError on a socket timeout.
-        """
-        # Sanity checks
-
-        if self.is_connection_open:
-            MODULE_LOGGER.warning(
-                f"{DEVICE_NAME}: trying to connect to an already connected socket.")
-            return
-
-        if self.hostname in (None, ""):
-            raise ValueError(f"{DEVICE_NAME}: hostname is not initialized.")
-
-        if self.port in (None, 0):
-            raise ValueError(f"{DEVICE_NAME}: port number is not initialized.")
-
-        # Create a new socket instance
-
-        try:
-            self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-
-            # self.sock.setblocking(1)
-
-            # DON'T set a timeout on the socket, this will not result in the expected behavior.
-            #
-            # If the timeout is set, this will result in the following problem:
-            # DEBUG    234    huber.py  send_direct_command: Sent out to HUBER: 'goto1:0.0\r\n'
-            # DEBUG    284    huber.py  wait_until_axis_ready: Wait until axis 1 is ready...
-            # DEBUG    191    huber.py  get_response: Sent out to HUBER: '?s1\r\n'
-            # DEBUG    198    huber.py  get_response: Receiving data after cmd=''?s1\r\n''...
-            # WARNING  263    huber.py  wait_for_response: Socket timeout error from timed out
-            # DEBUG    200    huber.py  get_response: Received from HUBER: b'\r\n'
-            #
-
-            # self.sock.settimeout(3)
-
-        except socket.error as e_socket:
-            raise DeviceConnectionError(DEVICE_NAME, "Failed to create socket.") from e_socket
-
-        # Attempt to establish a connection to the remote host
-
-        # FIXME: Socket shall be closed on exception?
-
-        # We set a timeout of 3 sec before connecting and reset to None
-        # (=blocking) after the connect() method. The reason for this that when no
-        # HUBER SMC is available, e.g. during testing, the timeout will take about
-        # two minutes which is way too long. It needs to be evaluated if this
-        # approach is acceptable and not causing problems during production.
-
-        try:
-            MODULE_LOGGER.debug(
-                f'Connecting a socket to host "{self.hostname}" using port {self.port}')
-            self.sock.settimeout(CONNECT_TIMEOUT)
-            self.sock.connect((self.hostname, self.port))
-            self.sock.settimeout(None)
-        except ConnectionRefusedError as exc:
-            raise DeviceConnectionError(
-                DEVICE_NAME, f"Connection refused to {self.hostname}:{self.port}."
-            ) from exc
-        except TimeoutError as exc:
-            raise DeviceTimeoutError(
-                DEVICE_NAME, f"Connection to {self.hostname}:{self.port} timed out."
-            ) from exc
-        except socket.gaierror as exc:
-            raise DeviceConnectionError(
-                DEVICE_NAME, f"socket address info error for {self.hostname}"
-            ) from exc
-        except socket.herror as exc:
-            raise DeviceConnectionError(
-                DEVICE_NAME, f"socket host address error for {self.hostname}"
-            ) from exc
-        except socket.timeout as exc:
-            raise DeviceTimeoutError(
-                DEVICE_NAME, f"socket timeout error for {self.hostname}:{self.port}"
-            ) from exc
-        except OSError as exc:
-            raise DeviceConnectionError(DEVICE_NAME, f"OSError caught ({exc}).") from exc
-
-        self.is_connection_open = True
-
-        # The first thing to receive should be the 'smc 1.2.1093' string.
-
-        response = self.read()
-        MODULE_LOGGER.debug(f"After connection, we got '{response}' as a response.")
-
-    def disconnect(self):
-        """
-        Disconnect the Ethernet connection from the device controller.
-
-        Raises:
-             a DeviceConnectionError on failure.
-        """
-        try:
-            if self.is_connection_open:
-                MODULE_LOGGER.debug(f'Disconnecting from {self.hostname}')
-                self.semaphore.acquire()
-                self.sock.close()
-                self.semaphore.release()
-                self.is_connection_open = False
-        except Exception as e_exc:
-            raise DeviceConnectionError(
-                DEVICE_NAME, f"Could not close socket to {self.hostname}") from e_exc
-
-    def reconnect(self):
-
-        if self.is_connection_open:
-            self.disconnect()
-        self.connect()
-
-    def is_connected(self) -> bool:
-        """
-        Check if the device is connected.
-
-        Returns:
-             True is the device is connected, False otherwise.
-        """
-
-        return bool(self.is_connection_open)
-
-    def read(self) -> bytes:
-        """
-        Read a response from the device.
-
-        Returns:
-            A bytes object containing the response from the device. No processing is done
-            on the response.
-        Raises:
-            A DeviceTimeoutError when the read operation timed out.
-        """
-        idx, n_total = 0, 0
-        buf_size = 1024 * 10
-        response = bytes()
-
-        # Set a timeout of READ_TIMEOUT to the socket.recv
-
-        saved_timeout = self.sock.gettimeout()
-        self.sock.settimeout(READ_TIMEOUT)
-
-        try:
-            for _ in range(100):
-                # time.sleep(0.1)  # Give the device time to fill the buffer
-                data = self.sock.recv(buf_size)
-                n = len(data)
-                n_total += n
-                response += data
-                if n < buf_size:
-                    break
-        except socket.timeout as e_timeout:
-            MODULE_LOGGER.warning(f"Socket timeout error: {e_timeout}")
-            raise DeviceTimeoutError(DEVICE_NAME, "Socket timeout error") from e_timeout
-        finally:
-            self.sock.settimeout(saved_timeout)
-
-        # logger.debug(f"Total number of bytes received is {n_total}, idx={idx}")
-        # logger.debug(f"> {response[:80]=}")
-
-        return response
-
-    def write(self, command: str) -> None:
-        """
-        Send a command to the device.
-
-        No processing is done on the command string, except for the encoding into a bytes object.
-
-        Args:
-            command: the command string including terminators.
-
-        Raises:
-            A DeviceTimeoutError when the sendall() timed out, and a DeviceConnectionError if
-            there was a socket related error.
-        """
-
-        # MODULE_LOGGER.debug(f"{command.encode() = }")
-
-        try:
-            self.sock.sendall(command.encode())
-
-            # Give the SMC time to start a new command: see issue #1209
-            time.sleep(0.5)
-
-        except socket.timeout as e_timeout:
-            raise DeviceTimeoutError(DEVICE_NAME, "Socket timeout error") from e_timeout
-        except socket.error as e_socket:
-            # Interpret any socket-related error as an I/O error
-            raise DeviceConnectionError(DEVICE_NAME, "Socket communication error.") from e_socket
-
-    def trans(self, command: str) -> bytes:
-        """
-        Send a command to the device and wait for the response.
-
-        No processing is done on the command string, except for the encoding into a bytes object.
-
-        Args:
-            command: the command string including terminators.
-
-        Returns:
-            A bytes object containing the response from the device. No processing is done
-            on the response.
-
-        Raises:
-            A DeviceTimeoutError when the sendall() timed out, and a DeviceConnectionError if
-            there was a socket related error.
-        """
-        # MODULE_LOGGER.debug(f"{command.encode() = }")
-
-        try:
-            # Attempt to send the complete command
-
-            self.sock.sendall(command.encode())
-
-            # wait for, read and return the response (will be at most TBD chars)
-
-            return self.read()
-
-        except socket.timeout as e_timeout:
-            raise DeviceTimeoutError(DEVICE_NAME, "Socket timeout error") from e_timeout
-        except socket.error as e_socket:
-            # Interpret any socket-related error as an I/O error
-            raise DeviceConnectionError(DEVICE_NAME, "Socket communication error.") from e_socket
-
-
-if __name__ == "__main__":
-
-    from rich import print
-
-    def send_command(cmd):
-        cmd = cmd.rstrip()
-        with Timer(f"{DEVICE_NAME} Query"):
-            response = huber.query(cmd + "\r\n")
-        print(f"{format_datetime()} Response for {cmd:>20s}: {response}")
-        response = response.rstrip()
-        return response
-
-    huber = HuberSMC9300EthernetInterface()
-
-    print(f"{' ' :->10} Connecting to {DEVICE_NAME}..")
-
-    huber.connect()
-
-    print(f"{' ' :->10} Requesting info..")
-
-    send_command("?")
-    send_command("?v")
-    send_command("?s1")
-    send_command("?status1")
-    send_command("?status2")
-    send_command("?status3")
-    send_command("?err1")
-    send_command("?conf1")
-    send_command("?conf2")
-    send_command("?conf3")
-    send_command("?p1")
-    send_command("?e1")
-    send_command("?ec1")
-    send_command("?ip")
-    send_command("?pgm")  # command not yet available
-    send_command("?ffast1")
-    send_command("?ffast2")
-    send_command("?ffast3")
-
-    print(f"{' ' :->10} Closing connection..")
-
-    huber.disconnect()

egse/stages/huber/smc9300_protocol.py

@@ -1,113 +0,0 @@
-import logging
-import sys
-import time
-
-from egse.control import ControlServer
-from egse.device import DeviceConnectionState
-from egse.hk import convert_hk_names
-from egse.hk import read_conversion_dict
-from egse.metrics import define_metrics
-from egse.process import SubProcess
-from egse.protocol import DynamicCommandProtocol
-from egse.settings import Settings
-from egse.setup import load_setup
-from egse.stages.huber.smc9300 import HuberSMC9300Controller
-from egse.stages.huber.smc9300 import HuberSMC9300Interface
-from egse.system import format_datetime
-from egse.zmq_ser import bind_address
-
-HUBER_SETTINGS = Settings.load(filename="smc9300.yaml")
-STAGES_SETTINGS = Settings.load("Huber Controller")
-
-MODULE_LOGGER = logging.getLogger(__name__)
-
-
-class HuberSMC9300Protocol(DynamicCommandProtocol):
-    def __init__(self, control_server: ControlServer):
-        super().__init__(control_server)
-
-        self.huber_sim: SubProcess
-        self.huber = HuberSMC9300Interface
-        setup = load_setup()
-
-        storage_mnemonic = self.get_control_server().get_storage_mnemonic()
-
-        self.hk_conversion_table = read_conversion_dict(storage_mnemonic, use_site=True, setup=setup)
-
-        if Settings.simulation_mode():
-            # In simulation mode, we start the simulator process and have the control server
-            # connect to that process instead of the hardware.
-            self.huber_sim = SubProcess("SMC9300 Simulator",
-                                        [sys.executable, "-m", "egse.stages.huber.smc9300_sim", "start"])
-            self.huber_sim.execute(detach_from_parent=True)
-            time.sleep(2.0)  # Allow the simulator time to start up
-            self.huber = HuberSMC9300Controller(hostname="localhost")
-        else:
-            self.huber_sim = None
-            self.huber = HuberSMC9300Controller()
-
-        self.huber.add_observer(self)
-
-        try:
-            self.huber.connect()
-        except ConnectionError as exc:
-            MODULE_LOGGER.warning(
-                "Couldn't establish a connection to the HUBER Stages, check the log messages.")
-            MODULE_LOGGER.debug(f"{exc = }")
-
-        self.metrics = define_metrics(storage_mnemonic, use_site=True, setup=setup)
-
-    def quit(self):
-        if self.huber_sim is not None:
-            self.huber_sim.quit()
-
-    def get_bind_address(self):
-        return bind_address(
-            self.get_control_server().get_communication_protocol(),
-            self.get_control_server().get_commanding_port(),
-        )
-
-    def get_device(self):
-        return self.huber
-
-    # @timer()  # 20220621: takes about 50ms
-    def get_status(self):
-
-        status = super().get_status()
-
-        # Position of the stages:
-        #   - Commanded angle of the big rotation stage [degrees]
-        #   - Commanded angle of the small rotation stage [degrees]
-        #   - Commanded distance for the translation stage [mm]
-
-        status["big_rotation_stage_position"] = self.huber.get_current_position(STAGES_SETTINGS.BIG_ROTATION_STAGE)
-        status["small_rotation_stage_position"] = self.huber.get_current_position(STAGES_SETTINGS.SMALL_ROTATION_STAGE)
-        status["translation_stage_position"] = self.huber.get_current_position(STAGES_SETTINGS.TRANSLATION_STAGE)
-
-        return status
-
-    # @timer()  # 20220621: takes less than 200ms
-    def get_housekeeping(self) -> dict:
-
-        response = {"timestamp": format_datetime()}
-
-        if self.state == DeviceConnectionState.DEVICE_CONNECTED or Settings.simulation_mode():
-            response.update({
-                "axis 1 - cur_pos": self.huber.get_current_position(axis=1),
-                "axis 2 - cur_pos": self.huber.get_current_position(axis=2),
-                "axis 3 - cur_pos": self.huber.get_current_position(axis=3),
-                "axis 1 - enc_pos": self.huber.get_current_encoder_position(axis=1),
-                "axis 2 - enc_pos": self.huber.get_current_encoder_position(axis=2),
-                "axis 3 - enc_pos": self.huber.get_current_encoder_position(axis=3),
-                "axis 1 - enc_cnt": self.huber.get_current_encoder_counter_value(axis=1),
-                "axis 2 - enc_cnt": self.huber.get_current_encoder_counter_value(axis=2),
-                "axis 3 - enc_cnt": self.huber.get_current_encoder_counter_value(axis=3),
-            })
-
-        hk = convert_hk_names(response, self.hk_conversion_table)
-
-        for key, value in hk.items():
-            if key != "timestamp":
-                self.metrics[key].set(value)
-
-        return hk