cgse 2023.38.0__py3-none-any.whl → 2024.1.4__py3-none-any.whl

egse/lampcontrol/energetiq/lampEQ99.py

@@ -1,283 +0,0 @@
-"""
-This module defines the basic classes to access the Hamamatsu lamp connected to the
-EQ99 Manager controller that will be used in the IAS and INTA TVAC setup.
-"""
-import logging
-
-from egse.decorators import dynamic_interface
-from egse.device import DeviceInterface
-from egse.lampcontrol import LampError
-from egse.lampcontrol.energetiq.lampEQ99_devif import LampEQ99Error, LampEQ99USBInterface
-from egse.proxy import Proxy
-from egse.settings import Settings
-from egse.zmq_ser import connect_address
-
-LOGGER = logging.getLogger(__name__)
-CTRL_SETTINGS = Settings.load("Lamp EQ99 Control Server")
-DEVICE_SETTINGS = Settings.load(filename="eq99.yaml")
-
-
-class LampEQ99Interface(DeviceInterface):
-    """
-    Interface definition for the Lamp EQ-99 Manager Controller, Simulator and Proxy..
-    """
-    @dynamic_interface
-    def get_id(self, *args, **kwargs):
-        """
-        Send a command string to the device and wait for a response.
-
-        Returns:
-            a response from the device.
-        """
-        return NotImplemented
-
-    @dynamic_interface
-    def info(self) -> str:
-        """
-        Retrieve basic information about the Lamp controller.
-
-        Returns:
-            a multiline string with information about the device.
-        """
-        return NotImplemented
-
-    @dynamic_interface
-    def get_lamp_time(self):
-        """
-        Queries the lamp runtime
-
-        Returns:
-            The number of hours accumulated while the lamp was on. The value is in hours.
-        """
-        return NotImplemented
-
-    @dynamic_interface
-    def set_lamp_time(self):
-        """
-        Resets the lamp runtime to the new value in hours.
-
-        Args:
-            _time: int value in hours
-        """
-        return NotImplemented
-
-    @dynamic_interface
-    def get_lamp(self):
-        """
-        Queries the lamp output states
-
-        Returns:
-            Returns the output state. Will return true as soon as the turned on process has started, even if the lamp
-            has not yet turned on. To determine the lamp and laser state use get_lamp_state
-        """
-        return NotImplemented
-
-    @dynamic_interface
-    def set_lamp(self):
-        """
-        Turns the lamp output on or off
-        Args:
-            enable(bin)
-        """
-        return NotImplemented
-
-    @dynamic_interface
-    def get_lamp_status(self):
-        """
-        Queries LDLS condition register
-
-        Returns:
-            Returns the LDLS condition register. The condition register reflects the state of the instrument at the
-            time the condition register is read.
-
-            Bit     Value       Description
-            0       1           Interlock
-            1       2           Controller not detected
-            2       4           Controller fault
-            3       8           Lamp fault
-            4       16          Output on
-            5       32          Lamp on
-            6       64          Laser on
-            7       128         Laser stable
-            8       256         Shutter open
-
-        """
-        return NotImplemented
-
-    @dynamic_interface
-    def lamp_errors(self):
-        """
-        Queries for errors
-
-        Returns:
-            Returns a comma delimited list of error codes with a string description included.
-            If no error has occurred, a 0 is returned.
-        """
-        return NotImplemented
-
-    @dynamic_interface
-    def ldls_reset(self):
-        """
-        Resets the instrument to the factory default and the ouput is shut off. The unit remains in remote mode
-
-        """
-        return NotImplemented
-
-
-class LampEQ99Simulator(LampEQ99Interface):
-    """
-    The Lamp Simulator class.
-    """
-
-    def __init__(self):
-        self._connected = True
-        self.lamp_operation = False
-        self.lamp_time = 36
-        self.error_message = '0' # '0' means no error (lampEQ99 user manual p.21). Error message example (from lampEQ99 user manual p.22) : self.error_message = '201,"Out of range",124,"Data mismatch"'
-
-    def is_connected(self):
-        return self._connected
-
-    def is_simulator(self):
-        return True
-
-    def connect(self):
-        self._connected = True
-
-    def disconnect(self):
-        self._connected = False
-
-    def reconnect(self):
-        self._connected = True
-
-    def get_id(self):
-        pass
-
-    def ldls_reset(self):
-        pass
-
-    def get_lamp_time(self):
-        return self.lamp_time
-
-    def lamp_errors(self):
-        return f"Error Message: {self.error_message}"
-        
-    def set_lamp(self, _enable):
-        self.lamp_operation = _enable
-
-    def get_lamp(self):
-        return self.lamp_operation
-
-
-class LampEQ99Controller(LampEQ99Interface):
-    """The LampEQ99Controller allows controlling a Hamamatsu Lamp."""
-
-    def __init__(self):
-        """Initialize the EQ-99 Manager Controller interface."""
-
-        super().__init__()
-
-        LOGGER.debug("Initializing EQ99 Manager")
-
-        try:
-            self.lamp = LampEQ99USBInterface()
-            self.lamp.connect()
-        except LampEQ99Error as exc:
-            LOGGER.warning(f"LampError caught: Couldn't establish connection ({exc})")
-            raise LampError(
-                "Couldn't establish a connection with the Lamp EQ-99 controller."
-            ) from exc
-
-    def connect(self):
-        """Connects to the Lamp device.
-
-        Raises:
-            DeviceNotFoundError: when the Lamp device is not connected.
-        """
-        if not self.lamp.is_connected():
-            try:
-                self.lamp.connect()
-            except LampEQ99Error as exc:
-                LOGGER.warning(f"LampEQ99Error caught: Couldn't establish connection ({exc})")
-
-    def disconnect(self):
-        self.lamp.disconnect()
-
-    def reconnect(self):
-        if self.is_connected():
-            self.disconnect()
-        self.connect()
-
-    def is_connected(self):
-        """Check if the Lamp Controller is connected."""
-        return self.lamp.is_connected()
-
-    def is_simulator(self):
-        return False
-
-    def get_id(self):
-        self.lamp.write_message("*IDN?")
-        _id = self.lamp.read_message()
-        return _id
-
-    def ldls_reset(self):
-        self.lamp.write_message("*RST")
-
-    def lamp_errors(self):
-        self.lamp.write_message("ERRSTR?")
-        _errmsg = self.lamp.read_message()[:-1] # [:-1] is to remove the unwanted last character '\r'
-        return(f"Error Message: {_errmsg}")
-
-    def get_lamp_status(self):
-        "Query LDLS condition register"
-        self.lamp.write_message("LDLS:COND?")
-        _lamp = self.lamp.read_message()[:-1]
-        return(_lamp)
-
-    def set_lamp(self, _enable):
-        "Turns the ouput on/off"
-        self.lamp.write_message("LDLS:OUTput {}".format(str(_enable))) # _enable can be either bool or 0 or 1
-
-    def get_lamp(self):
-        """Query the lamp output state.
-        Will return true as soon as the turned on process has started, even if the lamp has not yet turned on.
-        To determine the lamp and laser state, use get_lamp_status function"""
-        self.lamp.write_message("LDLS:OUTput?")
-        _lamp = self.lamp.read_message() # _lamp is either '0\r' or '1\r' so _lamp is a str and not a bool
-        _lamp = bool(int(_lamp)) # now _lamp is a bool
-        return(_lamp)
-
-    def set_lamp_time(self, _time):
-        "Resets the Run time of the lifetime to the specified value (in hours). Useful to set to zero after Lamp replacement."
-        self.lamp.write_message("LDLS:LAMPTIME {}".format(int(_time)))
-
-    def get_lamp_time(self):
-        "Query the lamp runtime (in hours)."
-        self.lamp.write_message("LDLS:LAMPTIME?")
-        _lamp = self.lamp.read_message()[:-1]
-        return(_lamp)
-
-    def _beep(self):
-        "This is only used for debugging purposes"
-        self.lamp._beep()
-
-
-class LampEQ99Proxy(Proxy, LampEQ99Interface):
-    """The LampEQ99Proxy class is used to connect to the control server and send commands to
-     the Lamp device 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))

egse/lampcontrol/energetiq/lampEQ99_cs.py

@@ -1,128 +0,0 @@
-
-import click
-import logging
-import sys
-import zmq
-
-from egse.control import ControlServer
-from egse.settings import Settings
-from egse.lampcontrol.energetiq.lampEQ99 import LampEQ99Proxy
-from egse.lampcontrol.energetiq.lampEQ99_protocol import LampEQ99Protocol
-from prometheus_client import start_http_server
-
-
-logger = logging.getLogger(__name__)
-
-# Restrict the logging output for the following loggers.
-
-# Note that, in production, the logging level for the different loggers can be changed with a
-# service command `set_logging_level(logger_name, level)`.
-
-logger_levels = [
-    ("egse.protocol", logging.INFO),
-    ("egse.command", logging.INFO),
-    ("egse.settings", logging.INFO),
-]
-
-for name, level in logger_levels:
-    logger = logging.getLogger(name)
-    logger.setLevel(level)
-
-CTRL_SETTINGS = Settings.load("Lamp EQ99 Control Server")
-
-
-class LampControlServer(ControlServer):
-    """
-    LampControlServer - Command and monitor the Lamp EQ99 Controllers.
-    This class works as a command and monitoring server to control the Lamp Controller 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 Lamp controller.
-    * a PUB-SUP socket that serves as a monitoring server. It will send out Lamp status
-      information to all the connected clients every DELAY seconds.
-    """
-
-    def __init__(self):
-        super().__init__()
-
-        self.device_protocol = LampEQ99Protocol(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 "EQ99"
-
-    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 EQ99 Lamp Simulator as the backend.")
-def start(simulator):
-    """Start the EQ99 Lamp Control Server."""
-
-    if simulator:
-
-        Settings.set_simulation_mode(True)
-
-    try:
-
-        controller = LampControlServer()
-        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 EQ99 Lamp 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()
-def stop():
-    """Send a 'quit_server' command to the EQ99 Lamp Control Server."""
-
-    with LampEQ99Proxy() as proxy:
-
-        sp = proxy.get_service_proxy()
-        sp.quit_server()
-
-
-if __name__ == "__main__":
-
-    sys.exit(cli())

egse/lampcontrol/energetiq/lampEQ99_devif.py

@@ -1,158 +0,0 @@
-"""
-The device interface for the LDLS Lamp controller  that will be used at IAS and INTA for TVAC the PLATO Cameras.
-
-"""
-
-import datetime
-import logging
-import time
-
-import pylibftdi
-
-from egse.device import DeviceConnectionError
-from egse.command import ClientServerCommand
-from egse.exceptions import DeviceNotFoundError
-from egse.settings import Settings
-
-logger = logging.getLogger(__name__)
-
-ctrl_settings = Settings.load("Lamp EQ99 Controller")
-
-IDENTIFICATION_QUERY = "*IDN?"
-DEVICE_NAME = "Lamp EQ99"
-
-
-class LampEQ99Error(Exception):
-    """Base exception for all Lamp errors."""
-    pass
-
-class LampEQ99Command(ClientServerCommand):
-    def get_cmd_string(self, *args, **kwargs) -> str:
-        out = super().get_cmd_string(*args, **kwargs)
-        return out + "\n"
-
-class LampEQ99USBInterface:
-    def __init__(self):
-        "Init parameters"
-        "FTDI UART driver need to be installed: a CD is provided by the manufacturer"
-
-        self._lamp = None
-        self.baudrate = ctrl_settings.BAUDRATE
-        self.device_id = ctrl_settings.DEVICE_ID
-
-        self.is_connection_open = False
-
-    def connect(self):
-        "Low level interface to the FTDIUART"
-
-        # Sanity checks:
-        if self.is_connection_open:
-            logger.warning("Trying to connect to an already connected device")
-            return
-
-        try:
-            self._lamp = pylibftdi.Device(mode='t', device_id=self.device_id)
-
-        # EQ99 Manager uses full size USB Type B socket. Any USB 1.1 or 2.0 certified socked with the following config
-        # might be used (from manual)
-        # Baud rate = 38400
-            self._lamp.baudrate = self.baudrate
-        # 8 data bits, 1 stop bit, no parity
-            self._lamp.ftdi_fn.ftdi_set_line_property(8, 1, 0)
-
-            # Pre purge dwell 50 ms
-            time.sleep(50.0 / 1000)
-
-            # Purge the device
-            self._lamp.flush(pylibftdi.FLUSH_BOTH)
-
-            # Post purge dwell 50 ms
-            time.sleep(50.0 / 1000)
-
-        #Ensure to disable flow control. Failure to do so will prevent the instrument from sending data back to PC
-            self._lamp.ftdi_fn.ftdi_setflowctrl(0)
-
-        except (ValueError, Exception) as exc:
-            logger.warning(f"Could not open USB FTDI device: {exc}")
-            raise DeviceNotFoundError("Could not open USB FTDI device.") from exc
-
-        try:
-            logger.debug(f"Connecting tu UART device named: {self.device_id}")
-            self._lamp.open()
-        except OSError as exc:
-            raise DeviceConnectionError(DEVICE_NAME, f"OSError caught ({exc})") from exc
-
-        self.is_connection_open = True
-
-        response = self.get_id()
-
-        if self.device_id in response:
-            logger.info("Well connected to the EQ99 Manager")
-
-    def disconnect(self):
-        """
-        Disconnects from the device
-        Raises:
-            DeviceConnectionError when the connection has not been closed correctly
-
-        """
-        try:
-            if self.is_connection_open:
-                logger.debug(f"disconnecting from {self.device_id}")
-                self._lamp.close()
-            self.is_connection_open = False
-            logger.info("EQ99 Lamp Manager device has been disconnected")
-        except Exception as e_exc:
-            raise DeviceConnectionError(
-                DEVICE_NAME, f"Couldn't close the FTDI UART: {self.device_id}") from e_exc
-
-    def is_connected(self):
-        """Return True if the device is connected."""
-        if not self.is_connection_open:
-            return False
-        try:
-            self.write_message(IDENTIFICATION_QUERY)
-            time.sleep(0.1)
-            _id = self.read_message()
-            time.sleep(0.1)
-        except OSError:  # FIXME: Check which errors are actually thrown here
-            self.disconnect()
-            return False
-        return True
-
-    def get_response(self, cmd_string):
-        pass
-
-    def get_id(self):
-        self.write_message(IDENTIFICATION_QUERY)
-        _id = self.read_message()
-        return _id
-
-    def _beep(self):
-        self.write_message("BEEP")
-
-    def write_message(self, command: str):
-        """
-        Send a single command to the device controller without waiting for a response.
-
-        Args:
-            command: an order command for the controller.
-        """
-        command = command + "\r" + "\n"
-        self._lamp.write(command)
-
-    def read_message(self):
-        message = ""
-        t1 = datetime.datetime.now()
-        while True:
-            _byte = self._lamp.read(1)
-            time.sleep(0.001)
-            if (datetime.datetime.now()-t1).seconds > 2:
-                logging.warning("Device timeout")
-                break
-            if _byte == "\n":
-                break
-            else:
-                message += _byte
-
-        return message

egse/lampcontrol/energetiq/lampEQ99_encode_decode_errors.py

@@ -1,73 +0,0 @@
-from typing import List, Dict
-
-LAMP_ERRORS = {
-    0: ("No error", "No error was reported."),
-    3: ("Factory EE bad", "Error reading the factory data."),
-    4: ("User EE bad", "Error reading the user data, unit reset to factory defaults."),
-    5: ("User reset", "Unit reset to factory defaults (not an error, notification only)."),
-    6: ("User EE bad, no recovery", "Error reading the user data, could not be reset to factory defaults."),
-    10: ("Access denied", "Attempt to change protected settings without authorization."),
-    100: (
-    "General Error", "The error code is non-specific, and is generally used when no other error code is suitable."),
-    102: ("Message too long", "The message is too long to process (USB/Serial only)."),
-    123: ("Path not found", "The message used an invalid path command (USB/Serial only)."),
-    127: ("Change not allowed", "Attempt to change locked value."),
-    201: ("Data out of range",
-    "The message attempted to set a value that was outside the allowable range (USB/Serial only)."),
-    202: (
-    "Invalid data type", "When trying to parse the message, the data was in an invalid format (USB/Serial only)."),
-    303: ("Input buffer overflow", "Data was sent to the instrument faster than it could process."),
-    600: ("Interlock", "The interlock input is open."),
-    601: ("Lamp fault", "The controller is indicating a lamp fault. "
-                        "Consult the EQ-99 User’s Manual for more information."),
-    602: ("Controller fault", "The controller is indicating a controller fault. "
-                              "This is often caused by an open interlock condition. "
-                              "If that is not the case, consult the EQ-99 User’s Manual for more information."),
-    603: ("No controller", "The EQ-99 Power Supply Controller was not detected."),
-    998: ("Command not supported", "A command was recognized but not supported by the instrument."),
-    999: ("Non-specific error", "A non-specific error was encountered."),
-}
-LAMP_ERROR_CODES = list(LAMP_ERRORS.keys())
-
-
-def encode_lamp_errors(errors: List[int]) -> int:
-    """
-    Encodes the list of lamp error codes into a bitfield. The bitfield is constructed from the order of the keys
-    in the LAMP_ERRORS dictionary.
-
-    Note: when you need to add additional keys, add them at the end of the dictionary. This will guarantee proper
-    decoding of previously encoded lamp errors.
-
-    Args:
-        errors: a list of error codes as integers
-
-    Returns:
-        A integer representing the error codes as a bitfield.
-    """
-    encoded_errors = 0
-
-    for error in errors:
-        idx = LAMP_ERROR_CODES.index(error)
-        encoded_errors |= 2 ** idx
-
-    return encoded_errors
-
-
-def decode_lamp_errors(errors: int) -> Dict[int, str]:
-    """
-    Decodes the bitfield into the error codes and their messages.
-
-    Args:
-        errors: an integer as a bitfield of lamp errors (previously encoded with encode_lamp_errors)
-
-    Returns:
-        A dictionary of the lamp errors (key is error code, value is the description)
-    """
-    result = {}
-
-    for shift in range(len(LAMP_ERRORS)):
-        if (errors >> shift) & 1:
-            error_code = LAMP_ERROR_CODES[shift]
-            result[error_code] = ": ".join(LAMP_ERRORS[error_code])
-
-    return result