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

egse/tempcontrol/keithley/daq6510.yaml

@@ -1,105 +0,0 @@
-BaseClass:
-    egse.tempcontrol.keithley.daq6510.DAQ6510Interface
-
-ProxyClass:
-    egse.tempcontrol.keithley.daq6510.DAQ6510Proxy
-
-ControlServerClass:
-    egse.tempcontrol.keithley.daq6510_cs.DAQ6510ControlServer
-
-ControlServer:
-    egse.tempcontrol.keithley.daq6510_cs
-
-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 after the arguments have been filled.
-    #   device_method: The name of the method to be called on the device class.
-    #                  These should all be defined by the base class for the device, i.e. KeithleyBase.
-    #   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 KeithleyProtocol class.
-
-    # Definition of the the DeviceInterface
-
-    disconnect:
-        description  : Disconnect from the Keithley controller. This command will be send to the
-                       Keithley Control Server which will then disconnect from the hardware controller.
-                       This command doesn't affect the ZeroMQ connection of this Proxy to the
-                       control server. Use the service command ``disconnect()`` to disconnect
-                       from the control server.
-
-    connect:
-        description:    Connect the Keithley hardware controller
-
-    reconnect:
-        description:    Reconnect the Keithley hardware controller.
-
-                        This command will force a disconnect and then try to re-connect to the controller.
-
-    is_simulator:
-        description:   Ask if the control server is a simulator instead of the real KeithleyController class.
-        returns:       bool | True if the far end is a simulator instead of the real hardware
-
-    is_connected:
-        description:   Check if the Keithley Hardware Controller is connected.
-
-
-    # Definition of the device commands
-
-    info:
-        description:   Retrieve basic information about the Keithley and the Controller.
-
-    reset:
-        description:   Resets the device. This returns the instrument to default settings, and cancels all
-                       pending commands.
-
-    send_command:
-        description:   Sends a SCPI command to the device
-        cmd:           '{command} {response}'
-
-    set_time:
-        description:   Set the absolute date and time of the device.
-        cmd:           '{year} {month} {day} {hour} {minute} {second}'
-
-    get_time:
-        description:   Get the time and time of the device.
-        
-    read_buffer:
-        description:   Reads specific data elements (measurements) from the given buffer.
-
-    get_buffer_count:
-        description:   The number of readings in the specified reading buffer.
-
-    get_buffer_capacity:
-        description:   The total number of readings that the buffer can store.
-
-    delete_buffer:
-        description:   Deletes the given buffer.
-
-    clear_buffer:
-        description:   Clears all readings and statistics from the specified buffer.
-
-    create_buffer:
-        description:   Creates a Reading Buffer with the given name.
-
-    configure_sensors:
-        description:   Allows to configure the different sensors in the `channel_list`. Each sensor
-                       in the list will be configured according to the settings given in the
-                       `sense` dictionary.
-        cmd:           '{channel_list} {sense}'
-
-    setup_measurements:
-        description:   Setup the measurements for the given channel list.
-        cmd:           '{channel_list}'
-
-    perform_measurement:
-        description:   Perform the actual measurements. This function will wait until all
-                       measurements have completed, so be careful with the arguments `count` and
-                       `interval` as they will multiply into the number of seconds that you will
-                       have to wait for the response.
-        cmd:           '{channel_list} {count} {interval}'

egse/tempcontrol/keithley/daq6510_cs.py

@@ -1,163 +0,0 @@
-import logging
-
-from prometheus_client import start_http_server
-
-import multiprocessing
-multiprocessing.current_process().name = "daq6510_cs"
-
-import sys
-
-import click
-import invoke
-import rich
-import zmq
-
-from egse.control import ControlServer
-from egse.control import is_control_server_active
-from egse.settings import Settings
-from egse.tempcontrol.keithley.daq6510 import DAQ6510Proxy
-from egse.tempcontrol.keithley.daq6510_protocol import DAQ6510Protocol
-from egse.zmq_ser import connect_address
-
-logger = logging.getLogger(__name__)
-
-CTRL_SETTINGS = Settings.load("Keithley Control Server")
-
-
-def is_daq6510_cs_active(timeout: float = 0.5):
-    """Check if the DAQ6510 Control Server is running.
-
-    Args:
-        timeout (float): timeout when waiting for a reply [seconds, default=0.5]
-    Returns:
-        True if the control server is running and replied with the expected answer.
-    """
-
-    endpoint = connect_address(
-        CTRL_SETTINGS.PROTOCOL, CTRL_SETTINGS.HOSTNAME, CTRL_SETTINGS.COMMANDING_PORT
-    )
-
-    return is_control_server_active(endpoint, timeout)
-
-
-class DAQ6510ControlServer(ControlServer):
-    """
-    Keithley DAQ6510ControlServer - Command and monitor the Keithley Data Acquisition System.
-
-    This class works as a command and monitoring server to control the DAQ6510 Controller.
-
-    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 DAQ6510 controller.
-
-    * a PUB-SUP socket that serves as a monitoring server. It will send out DAQ6510 status
-      information to all the connected clients every DELAY seconds.
-
-    """
-
-    def __init__(self):
-        super().__init__()
-
-        self.device_protocol = DAQ6510Protocol(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 "DAQ6510"
-
-    def before_serve(self):
-        start_http_server(CTRL_SETTINGS.METRICS_PORT)
-
-
-@click.group()
-def cli():
-    pass
-
-
-@cli.command()
-def start():
-    """Starts the Keithley DAQ6510 Control Server."""
-
-    try:
-        control_server = DAQ6510ControlServer()
-        control_server.serve()
-    except KeyboardInterrupt:
-        logger.debug("Shutdown requested...exiting")
-    except SystemExit as exit_code:
-        logger.debug("System Exit with code {}.".format(exit_code))
-        sys.exit(exit_code)
-    except Exception:
-        msg = "Cannot start the DAQ6510 Control Server"
-        logger.exception(msg)
-        rich.print(f"[red]{msg}.")
-
-    return 0
-
-
-@cli.command()
-def start_bg():
-    """Start the DAQ6510 Control Server in the background."""
-    invoke.run("daq6510_cs start", disown=True)
-
-
-@cli.command()
-def stop():
-    """Send a 'quit_server' command to the Keithley DAQ6510 control server."""
-
-    try:
-        with DAQ6510Proxy() as daq:
-            sp = daq.get_service_proxy()
-            sp.quit_server()
-    except ConnectionError as exc:
-        msg = "Cannot stop the DAQ6510 Control Server"
-        logger.exception(msg)
-        rich.print(f"[red]{msg}, could not send the Quit command. [black]Check log messages.")
-
-
-@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"DAQ6510 CS: [green]active")
-        with DAQ6510Proxy() as daq6510:
-            sim = daq6510.is_simulator()
-            connected = daq6510.is_connected()
-            ip = daq6510.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"DAQ6510 CS: [red]not active")
-
-
-if __name__ == "__main__":
-
-    logging.basicConfig(level=logging.DEBUG, format=Settings.LOG_FORMAT_FULL)
-
-    sys.exit(cli())

egse/tempcontrol/keithley/daq6510_devif.py

@@ -1,343 +0,0 @@
-import logging
-import socket
-import time
-
-from egse.command import ClientServerCommand
-from egse.device import DeviceConnectionError
-from egse.device import DeviceConnectionInterface
-from egse.device import DeviceError
-from egse.device import DeviceTimeoutError
-from egse.device import DeviceTransport
-from egse.settings import Settings
-from egse.system import Timer
-
-logger = logging.getLogger(__name__)
-
-IDENTIFICATION_QUERY = "*IDN?"
-
-DEVICE_SETTINGS = Settings.load("Keithley DAQ6510")
-DEVICE_NAME = "DAQ6510"
-READ_TIMEOUT = DEVICE_SETTINGS.TIMEOUT # READ_TIMEOUT in second. READ_TIMEOUT can be smaller than timeout (for DAQ6510Proxy) (e.g. 1 second)
-
-class DAQ6510Command(ClientServerCommand):
-    def get_cmd_string(self, *args, **kwargs) -> str:
-        out = super().get_cmd_string(*args, **kwargs)
-        return out + "\n"
-
-
-class DAQ6510EthernetInterface(DeviceConnectionInterface, DeviceTransport):
-    """Defines the low-level interface to the Keithley DAQ6510 Controller."""
-
-    def __init__(self, hostname=None, port=None):
-        self.hostname = DEVICE_SETTINGS.HOSTNAME if hostname is None else hostname
-        self.port = DEVICE_SETTINGS.PORT if port is None else port
-        self.sock = None
-
-        self.is_connection_open = False
-
-    def connect(self):
-        """Connect the 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)
-            # The following lines are to experiment with blocking and timeout, but there is no need.
-            # self.sock.setblocking(1)
-            # 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. 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(3)
-            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
-
-        # Check that we are connected to the controller by issuing the "VERSION" or
-        # "*ISDN?" query. If we don't get the right response, then disconnect automatically.
-
-        if not self.is_connected():
-            raise DeviceConnectionError(
-                DEVICE_NAME, "Device is not connected, check logging messages for the cause."
-            )
-
-    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. This will send a query for the device identification
-        and validate the answer.
-
-        Returns:
-             True is the device is connected and answered with the proper ID, False otherwise.
-        """
-
-        if not self.is_connection_open:
-            return False
-
-        try:
-            response = self.query(IDENTIFICATION_QUERY)
-        except DeviceError as exc:
-            logger.exception(exc)
-            logger.error("Most probably the client connection was closed. Disconnecting...")
-            self.disconnect()
-            return False
-
-        version = response
-
-        if "DAQ6510" not in version:
-            logger.error(
-                f'Device did not respond correctly to a "VERSION" command, response={response}. '
-                f"Disconnecting..."
-            )
-            self.disconnect()
-            return False
-
-        return True
-
-    def write(self, command: str):
-        """
-        Send a single command to the device controller without waiting for a response.
-
-        Args:
-            command: an order command for the controller.
-
-        Raises:
-            DeviceConnectionError when the command could not be sent due to a
-            communication problem.
-
-            DeviceTimeoutError when the command could not be sent due to a timeout.
-        """
-
-        try:
-
-            command += "\n" if not command.endswith("\n") else ""
-
-            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 a connection error
-            raise DeviceConnectionError(DEVICE_NAME, "Socket communication error.") from e_socket
-        except AttributeError:
-            if not self.is_connection_open:
-                msg = "The DAQ6510 is not connected, use the connect() method."
-                raise DeviceConnectionError(DEVICE_NAME, msg)
-            raise
-
-    def trans(self, command: str) -> str:
-        """
-        Send a single command to the device controller and block until a response from the
-        controller. This is seen as a transaction.
-
-        Args:
-            command: is the command to be sent
-        Returns:
-            Either a string returned by the controller (on success), or an error message (on
-            failure).
-        Raises:
-            DeviceConnectionError when there was an I/O problem during communication with the
-            controller.
-
-            DeviceTimeoutError when there was a timeout in either sending the command or
-            receiving the response.
-        """
-
-        try:
-
-            # Attempt to send the complete command
-
-            command += "\n" if not command.endswith("\n") else ""
-
-            self.sock.sendall(command.encode())
-
-            # wait for, read and return the response from HUBER (will be at most TBD chars)
-
-            return_string = self.read()
-
-            response = return_string.decode().rstrip()
-
-            return response
-
-        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
-        except ConnectionError as exc:
-            raise DeviceConnectionError(DEVICE_NAME, "Connection error.") from exc
-        except AttributeError:
-            if not self.is_connection_open:
-                raise DeviceConnectionError(
-                    DEVICE_NAME, "Device not connected, use the connect() method."
-                )
-            raise
-
-    def read(self) -> bytes:
-        n_total = 0
-        buf_size = 2048
-
-        # 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.001)  # Give the device time to fill the buffer
-                data = self.sock.recv(buf_size)
-                n = len(data)
-                n_total += n
-                if n < buf_size:
-                    break
-        except socket.timeout as e_timeout:
-            logger.warning(f"Socket timeout error for {self.hostname}:{self.port}")
-            return b"\r\n"
-        except TimeoutError as exc:
-            logger.warning(f"Socket timeout error: {exc}")
-            return b"\r\n"
-        finally:
-            self.sock.settimeout(saved_timeout)
-
-        # logger.debug(f"Total number of bytes received is {n_total}, idx={idx}")
-
-        return data
-
-
-if __name__ == "__main__":
-
-    daq = DAQ6510EthernetInterface()
-
-    with Timer():
-        daq.connect()
-
-    # print(daq.info())
-
-    # Initialize
-
-    daq.write('TRAC:DEL "test1"\n')
-
-    for cmd, response in [
-        ('TRAC:MAKE "test1", 1000', False),  # create a new buffer
-        # settings for channel 1 and 2 of slot 1
-        ('SENS:FUNC "TEMP", (@101:102)', False),  # set the function to temperature
-        ("SENS:TEMP:TRAN FRTD, (@101:102)", False),  # set the transducer to 4-wire RTD
-        ("SENS:TEMP:RTD:FOUR PT100, (@101:102)", False),  # set the type of the 4-wire RTD
-        ('ROUT:SCAN:BUFF "test1"', False),
-        ("ROUT:SCAN:CRE (@101:102)", False),
-        ("ROUT:CHAN:OPEN (@101:102)", False),
-        ("ROUT:STAT? (@101:102)", True),
-        ("ROUT:SCAN:STAR:STIM NONE", False),
-        # ("ROUT:SCAN:ADD:SING (@101, 102)", False),  # not sure what this does, not really needed
-        ("ROUT:SCAN:COUN:SCAN 1", False),  # not sure if this is needed in this setting
-        # ("ROUT:SCAN:INT 1", False),
-    ]:
-        print(f"Sending {cmd}...")
-        if response:
-            print(daq.trans(cmd), end="")
-        else:
-            daq.write(cmd)
-
-    # Read out the channels
-
-    # daq.write('TRAC:CLE "test1"\n')
-
-    for _ in range(10):
-        daq.write("INIT:IMM")
-        daq.write("*WAI")
-
-        # Reading the data
-
-        # When a trigger mode is running, these READ? commands can not be used.
-
-        # print(daq.trans('READ? "test1", CHAN, TST, READ\n', wait=False), end="")
-        # print(daq.trans('READ? "test1", CHAN, TST, READ\n', wait=False), end="")
-        # time.sleep(1)
-        # print(daq.trans('READ? "test1", CHAN, TST, READ\n', wait=False), end="")
-        # print(daq.trans('READ? "test1", CHAN, TST, READ\n', wait=False), end="")
-
-        # Read out the buffer
-
-        response = daq.trans('TRAC:DATA? 1, 2, "test1", CHAN, TST, READ')
-        ch1, tst1, val1, ch2, tst2, val2 = response[:-1].split(",")
-        print(f"Channel: {ch1} Time: {tst1} Value: {float(val1):.4f}\t", end="")
-        print(f"Channel: {ch2} Time: {tst2} Value: {float(val2):.4f}")
-        time.sleep(2)
-
-    daq.disconnect()

egse/tempcontrol/keithley/daq6510_protocol.py

@@ -1,78 +0,0 @@
-import logging
-
-from egse.control import ControlServer
-from egse.device import DeviceTimeoutError
-from egse.hk import read_conversion_dict
-from egse.metrics import define_metrics
-from egse.protocol import CommandProtocol
-from egse.settings import Settings
-from egse.state import GlobalState
-from egse.synoptics import SynopticsManagerProxy
-from egse.system import format_datetime
-from egse.tempcontrol.keithley.daq6510 import DAQ6510Controller
-from egse.tempcontrol.keithley.daq6510 import DAQ6510Interface
-from egse.tempcontrol.keithley.daq6510 import DAQ6510Simulator
-from egse.tempcontrol.keithley.daq6510_devif import DAQ6510Command
-from egse.zmq_ser import bind_address
-
-COMMAND_SETTINGS = Settings.load(filename="daq6510.yaml")
-
-MODULE_LOGGER = logging.getLogger(__name__)
-
-
-class DAQ6510Protocol(CommandProtocol):
-    def __init__(self, control_server: ControlServer):
-        super().__init__()
-        self.control_server = control_server
-
-        if Settings.simulation_mode():
-            self.daq = DAQ6510Simulator()
-        else:
-            self.daq = DAQ6510Controller()
-
-        try:
-            self.daq.connect()
-        except (ConnectionError, DeviceTimeoutError) as exc:
-            MODULE_LOGGER.warning(
-                f"Couldn't establish a connection to the DAQ6510, check the log messages.")
-
-        self.load_commands(COMMAND_SETTINGS.Commands, DAQ6510Command, DAQ6510Interface)
-        self.build_device_method_lookup_table(self.daq)
-
-        self.channels = GlobalState.setup.gse.DAQ6510.channels
-
-        self.hk_conversion_table = read_conversion_dict(self.control_server.get_storage_mnemonic())
-
-        self.synoptics = SynopticsManagerProxy()
-        self.metrics = define_metrics(origin="DAS-DAQ6510", use_site=True)
-
-    def get_bind_address(self):
-        return bind_address(
-            self.control_server.get_communication_protocol(),
-            self.control_server.get_commanding_port(),
-        )
-
-    def get_status(self):
-        return super().get_status()
-
-    def get_housekeeping(self) -> dict:
-
-        hk_dict = dict()
-        hk_dict["timestamp"] = format_datetime()
-
-        # # TODO I guess we have to do something along those lines
-        # # (We'll have to increase the HK delay, cfr. Agilents)
-        # measurement = self.daq.perform_measurement(channel_list=self.channels)
-        # temperatures = convert_hk_names(measurement, self.hk_conversion_table)
-        # hk_dict.update(temperatures)
-        #
-        # self.synoptics.store_th_synoptics(hk_dict)
-        #
-        # for key, value in hk_dict.items():
-        #     if key != "timestamp":
-        #         self.metrics[key].set(value)
-
-        return hk_dict
-
-    def quit(self):
-        self.synoptics.disconnect_cs()