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

egse/collimator/fcul/ogse.yaml

@@ -1,14 +0,0 @@
-BaseClass:
-    egse.collimator.fcul.OGSEInterface
-
-ProxyClass:
-    egse.collimator.fcul.OGSEProxy
-
-ControlServerClass:
-    egse.collimator.fcul.ogse_cs.OGSEControlServer
-
-ControlServer:
-    egse.collimator.fcul.ogse_cs
-
-UserInterface:
-    egse.collimator.fcul.ogse_ui

egse/collimator/fcul/ogse_cs.py

@@ -1,154 +0,0 @@
-"""
-This module defines the control server for the OGSE.
-"""
-import logging
-import multiprocessing
-import sys
-
-multiprocessing.current_process().name = "ogse_cs"
-
-import click
-import invoke
-import zmq
-from prometheus_client import start_http_server
-
-from egse.collimator.fcul.ogse import OGSEProxy
-from egse.collimator.fcul.ogse_protocol import OGSEProtocol
-from egse.control import ControlServer
-from egse.control import is_control_server_active
-from egse.settings import Settings
-from egse.zmq_ser import connect_address
-
-# Use explicit name here otherwise the logger will probably be called __main__
-
-logger = logging.getLogger("egse.collimator.fcul.ogse_cs")
-
-CTRL_SETTINGS = Settings.load("OGSE Control Server")
-
-
-class OGSEControlServer(ControlServer):
-    def __init__(self):
-        super().__init__()
-
-        self.device_protocol = OGSEProtocol(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 "OGSE"
-
-    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 OGSE Simulator as the backend."
-)
-def start(simulator):
-    """
-    Starts the OGSE Control Server (ogse_cs). The ogse_cs is a device server which handles the
-    commanding of the OGSE at CSL.
-    """
-
-    if simulator:
-        Settings.set_simulation_mode(True)
-
-    try:
-        control_server = OGSEControlServer()
-        control_server.serve()
-    except KeyboardInterrupt:
-        print("Shutdown requested...exiting")
-    except SystemExit as exit_code:
-        print(f"System Exit with code {exit_code}.")
-        sys.exit(exit_code)
-    except (Exception, ) as exc:  # ignore: too broad exception clause
-        logger.error(f"Caught Exception: {exc}", exc_info=True)
-
-        # import traceback
-        # traceback.print_exc(file=sys.stdout)
-
-    return 0
-
-
-@cli.command()
-@click.option(
-    "--simulator", "--sim", is_flag=True, help="Start the OGSE Simulator as the backend."
-)
-def start_bg(simulator):
-    """Start the OGSE Control Server in the background."""
-    sim = "--simulator" if simulator else ""
-    invoke.run(f"ogse_cs start {sim}", disown=True)
-
-
-@cli.command()
-def stop():
-    """Send a 'quit_server' command to the OGSE Control Server."""
-    import rich
-
-    if is_control_server_active(connect_address(CTRL_SETTINGS.PROTOCOL,
-                                                CTRL_SETTINGS.HOSTNAME,
-                                                CTRL_SETTINGS.COMMANDING_PORT)):
-        with OGSEProxy() as ogse:
-            sp = ogse.get_service_proxy()
-            sp.quit_server()
-    else:
-        rich.print("[red]OGSE Control Server is not replying, check if the server is running.")
-
-
-@cli.command()
-def status():
-    """Print the status of the control server."""
-
-    from rich import print
-
-    print('OGSE Control Server:')
-
-    if is_control_server_active(connect_address(CTRL_SETTINGS.PROTOCOL,
-                                                CTRL_SETTINGS.HOSTNAME,
-                                                CTRL_SETTINGS.COMMANDING_PORT)):
-        print('  Status: [green]active')
-        with OGSEProxy() as ogse:
-            try:
-                print(f"  Version: {ogse.version()}")
-            except AttributeError:
-                print('  Version: [red]UNKNOWN')
-
-            print(f"  Hostname: {ogse.get_ip_address()}")
-            print(f"  Monitoring port: {ogse.get_monitoring_port()}")
-            print(f"  Commanding port: {ogse.get_commanding_port()}")
-            print(f"  Service port: {ogse.get_service_port()}")
-    else:
-        print('  Status: [red]not active')
-
-
-if __name__ == "__main__":
-
-    sys.exit(cli())

egse/collimator/fcul/ogse_devif.py

@@ -1,358 +0,0 @@
-"""
-The device interface for the RT-OGSE that will be used at CSL for alignment of the PLATO Cameras.
-
-"""
-import logging
-import socket
-import time
-
-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 format_datetime, Timer
-
-logger = logging.getLogger(__name__)
-
-READ_TIMEOUT = 10.0  # seconds
-WRITE_TIMEOUT = 1.0  # seconds
-CONNECT_TIMEOUT = 3.0  # seconds
-
-CTRL_SETTINGS = Settings.load("OGSE Controller")
-DEVICE_NAME = "OGSE"
-
-
-class OGSEError(Exception):
-    """Generic Error for the OGSE low-level classes."""
-
-    pass
-
-
-class OGSEEthernetInterface(DeviceConnectionInterface, DeviceTransport):
-    """Defines the low-level interface to the OGSE Controller."""
-
-    def __init__(self, hostname=None, port=None):
-        """
-        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.
-        """
-        super().__init__()
-        self.hostname = hostname or CTRL_SETTINGS.HOSTNAME
-        self.port = port or CTRL_SETTINGS.PORT
-        self.sock = None
-
-        self.is_connection_open = False
-
-    def connect(self):
-        """
-        Connect the OGSE device.
-
-        Raises:
-            DeviceConnectionError when the connection could not be established. Check the logging
-            messages for more detail.
-
-            DeviceTimeoutError: When the connection timed out.
-
-            ValueError: When hostname or port number are not provided.
-        """
-
-        # Sanity checks
-
-        if self.is_connection_open:
-            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)
-        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 CONNECT_TIMEOUT sec before connecting and reset to None
-        # (=blocking) after the connect. The reason for this is because when no
-        # device 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:
-            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 OGSE will respond with a message when connecting. We have to read this
-        # message from the buffer and can do some version checking if needed.
-
-        response = self.read()
-
-        # The expected response has the following format: b'This is PLATO RT-OGSE 2.1\n'
-
-        if b"PLATO RT-OGSE" in response:
-            version = response.rsplit(maxsplit=1)[-1]
-            logger.info(f"Connected to the PLATO RT-OGSE, {version=}")
-        else:
-            logger.warning(f"Unexpected response after connecting to the RT-OGSE. {response=}")
-
-    def disconnect(self):
-        """Disconnect from the Ethernet connection.
-
-        Raises:
-            DeviceConnectionError when the socket could not be closed.
-        """
-
-        try:
-            if self.is_connection_open:
-                logger.debug(f"Disconnecting from {self.hostname}")
-                self.sock.close()
-                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.
-        """
-
-        if not self.is_connection_open:
-            return False
-
-        return True
-
-    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 idx 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:
-            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):
-        """
-        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 send timed out, and a DeviceConnectionError if
-            there was a socket related error.
-        """
-        logger.debug(f"{command=}")
-
-        try:
-            self.sock.sendall(command.encode())
-        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 send timed out, and a DeviceConnectionError if
-            there was a socket related error.
-        """
-        # logger.debug(f"{command=}")
-
-        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_string = self.read()
-
-            return return_string
-
-        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__":
-
-    def send_command(cmd):
-        cmd = cmd.rstrip()
-        with Timer("OGSE Query"):
-            response = ogse.query(cmd + "\n")
-        print(f"{format_datetime()} Response for {cmd:>20s}: {response.rstrip()}")
-        return response
-
-    def wait_for_att():
-        while b'*' in ogse.query("level\n"):
-            time.sleep(1)
-
-
-    ogse = OGSEEthernetInterface()
-
-    print("-" * 10, end="")
-    print("Connecting to the device.")
-
-    ogse.connect()
-
-    print("-"*10, end='')
-    print("Requesting all info.")
-
-    send_command("get flags")
-    send_command("get interlock")
-    send_command("get power")
-    send_command("get lamp")
-    send_command("get laser")
-    send_command("get lamp-fault")
-    send_command("get controller-fault")
-    send_command("get psu")
-    send_command("get operate")
-    send_command("get XXX")
-
-    print("-"*10, end='')
-    print("Requesting lamp status.")
-
-    send_command("ldls status")
-
-    print("-"*10, end='')
-    print("Playing with attenuator commands")
-
-    send_command("att status")
-
-    send_command("level")
-    send_command("level 0.1")
-    wait_for_att()
-    send_command("level up")
-    wait_for_att()
-    send_command("level")
-    send_command("level up")
-    wait_for_att()
-    send_command("level")
-    send_command("level down")
-    wait_for_att()
-    send_command("level")
-    send_command("level down")
-    wait_for_att()
-    send_command("level")
-    send_command("level up")
-    wait_for_att()
-    send_command("level")
-    send_command("level 0.8")
-    wait_for_att()
-    send_command("level")
-
-    print("-"*10, end='')
-    print("Running through attenuation levels")
-
-    for a in range(1, 9):
-        for b in range(1, 9):
-            send_command(f"level {a} {b}")
-            wait_for_att()
-            send_command("level")
-
-    print("-"*10, end='')
-    print("Request info from Power Meter")
-
-    send_command("read")
-
-    print("-"*10, end='')
-    print("Request 10 power meter measurements")
-
-    for _ in range(10):
-        send_command("read")
-        time.sleep(1)
-
-    ogse.disconnect()

egse/collimator/fcul/ogse_protocol.py

@@ -1,132 +0,0 @@
-import logging
-
-import sys
-import time
-
-from egse.collimator.fcul.ogse import OGSEController
-from egse.collimator.fcul.ogse import OGSEInterface
-from egse.control import ControlServer
-from egse.control import Failure
-from egse.device import DeviceConnectionError
-from egse.device import DeviceTimeoutError
-from egse.metrics import define_metrics
-from egse.metrics import update_metrics
-from egse.process import SubProcess
-from egse.protocol import DynamicCommandProtocol
-from egse.settings import Settings
-from egse.setup import load_setup
-from egse.synoptics import SynopticsManagerProxy
-from egse.system import format_datetime
-
-DEVICE_SETTINGS = Settings.load(filename="ogse.yaml")
-SITE = Settings.load("SITE")
-
-MODULE_LOGGER = logging.getLogger(__name__)
-
-
-class OGSEProtocol(DynamicCommandProtocol):
-    def __init__(self, control_server: ControlServer):
-        super().__init__(control_server)
-
-        setup = load_setup()
-
-        self.ogse_sim: SubProcess
-        self.device = OGSEInterface
-
-        self.fwc_calibration = setup.gse.ogse.calibration.fwc_calibration
-
-        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.ogse_sim = SubProcess("OGSE Simulator",
-                                       [sys.executable, "-m", "egse.collimator.fcul.ogse_sim", "start"])
-            self.ogse_sim.execute(detach_from_parent=True)
-            time.sleep(2.0)  # Allow the simulator time to start up
-            self.device = OGSEController(hostname="localhost")
-        else:
-            self.ogse_sim = None
-            self.device = OGSEController()
-
-        self.device.add_observer(self)
-
-        try:
-            self.device.connect()
-        except DeviceConnectionError as exc:
-            MODULE_LOGGER.warning(
-                "Couldn't establish a connection to the OGSE, check the log messages.")
-            MODULE_LOGGER.debug(f"{exc = }")
-        except ValueError as exc:
-            MODULE_LOGGER.warning(exc)
-        except DeviceTimeoutError as exc:
-            MODULE_LOGGER.warning(exc)
-
-        self.synoptics = SynopticsManagerProxy()
-        self.metrics = define_metrics(origin="OGSE", dashboard="GOGSE_MON", use_site=True, setup=setup)
-
-    def quit(self):
-        if self.synoptics is not None:
-            MODULE_LOGGER.info("Disconnecting from Synoptics Manager...")
-            self.synoptics.disconnect_cs()
-
-        if self.ogse_sim is not None:
-            MODULE_LOGGER.info("Terminating the OGSE Simulator...")
-            self.ogse_sim.quit()
-
-    def get_device(self):
-        return self.device
-
-    def get_status(self):
-        return super().get_status()
-
-    def get_housekeeping(self) -> dict:
-
-        hk = {"timestamp": format_datetime()}
-
-        ogse_status = self.device.status()
-
-        if isinstance(ogse_status, Failure):
-            MODULE_LOGGER.info(
-                "Failure detected while requesting the status of the OGSE. "
-                "No housekeeping generated. Check the log file for more information on the cause."
-            )
-            MODULE_LOGGER.error(f"Failure: {ogse_status}", exc_info=False)
-            return hk
-
-        ogse_laser = self.device.get_laser()
-
-        hk[f"G{SITE.ID}_OGSE_LDLS_LAMP"] = ogse_status["lamp"] == "ON"
-        hk[f"G{SITE.ID}_OGSE_LDLS_LASER"] = ogse_laser == "laser: ON"
-        hk[f"G{SITE.ID}_OGSE_PM_CH1_PWR"] = ogse_status["power1"]
-        hk[f"G{SITE.ID}_OGSE_PM_CH2_PWR"] = ogse_status["power2"]
-        hk[f"G{SITE.ID}_OGSE_REL_INTENSITY"] = ogse_status["att_factor"]
-        hk[f"G{SITE.ID}_OGSE_FWC_FRACTION"] = ogse_status["att_factor"] / self.fwc_calibration
-
-        # Send the HK acquired so far to the Synoptics Manager
-
-        hk_for_synoptics = hk.copy()
-
-        # The GOGSE_SHUTTER_OPEN parameter is not in the CSL OGSE HK but is included in the synoptics
-
-        if "CSL" in SITE.ID:
-            hk_for_synoptics[f"G{SITE.ID}_OGSE_SHUTTER_OPEN"] = True
-
-        self.synoptics.store_th_synoptics(hk_for_synoptics)
-
-        hk[f"G{SITE.ID}_OGSE_LDLS_INTERLOCK"] = ogse_status["interlock"] == "ON"
-        hk[f"G{SITE.ID}_OGSE_LDLS_POWER"] = ogse_status["power"] == "ON"
-        hk[f"G{SITE.ID}_OGSE_LDLS_PSU"] = ogse_status["psu"] == "ON"
-        hk[f"G{SITE.ID}_OGSE_PM_CH1_TEMP"] = ogse_status["temp1"]
-        hk[f"G{SITE.ID}_OGSE_PM_CH2_TEMP"] = ogse_status["temp2"]
-        hk[f"G{SITE.ID}_OGSE_LDLS_LAMP_FAULT"] = self.device.get_lamp_fault() == "lamp-fault: NO-ERROR"
-        hk[f"G{SITE.ID}_OGSE_LDLS_CTRL_FAULT"] = self.device.get_controller_fault() == "controller-fault: NO-ERROR"
-        hk[f"G{SITE.ID}_OGSE_LDLS_OPERATE"] = self.device.get_operate() == "operate: ON"
-        hk[f"G{SITE.ID}_OGSE_FW_MOVING"] = ogse_status["att_moving"]
-
-        pm_status = self.device.pm_status()
-
-        hk[f"G{SITE.ID}_OGSE_PM_CH1_STATUS"] = pm_status["pm1"] == "OK"
-        hk[f"G{SITE.ID}_OGSE_PM_CH2_STATUS"] = pm_status["pm2"] == "OK"
-
-        update_metrics(self.metrics, {name: hk[name] for name in hk if name in self.metrics})
-
-        return hk