keithley-tempcontrol 2025.0.8__py3-none-any.whl

egse/tempcontrol/keithley/daq6510.yaml

@@ -0,0 +1,102 @@
+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 fields are:
+    #   description:   Used by the doc_string method to generate a help string
+    #   cmd:           Command string that will eventually be sent 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 sub-class of the CommandProtocol base class, i.e.
+    #                  in this case it will be the KeithleyProtocol class.
+
+    # Definition of the DeviceInterface
+
+    disconnect:
+        description  : Disconnects from the Keithley controller. This command will be sent 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:    Connects the Keithley hardware controller
+
+    reconnect:
+        description:    Reconnects the Keithley hardware controller.
+
+                        This command will force a disconnect and then try to re-connect to the controller.
+
+    is_simulator:
+        description:   Asks 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:   Checks if the Keithley Hardware Controller is connected.
+
+
+    # Definition of the device commands
+
+    info:
+        description:   Retrieves 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:   Sets the absolute date and time of the device.
+        cmd:           '{year} {month} {day} {hour} {minute} {second}'
+
+    get_time:
+        description:   Gets 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:   Sets up the measurements for the given channel list.
+        cmd:           '{channel_list}'
+
+    perform_measurement:
+        description:   Performs 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

@@ -0,0 +1,197 @@
+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) -> bool:
+    """ Checks if the DAQ6510 Control Server is running.
+
+    Args:
+        timeout (float): Timeout when waiting for a reply [s, default=0.5]
+
+    Returns:  True if the Control Server is running and replied with the expected answer; False otherwise.
+    """
+
+    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:
+
+        - REQ-REP socket that can be used as a command server. Any client can connect and send a command to the
+          DAQ6510 controller.
+
+        - 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):
+        """ Initialisation of a DAQ6510 Control Server."""
+
+        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) -> str:
+        """ Returns the communication protocol used by the Control Server.
+
+        Returns: Communication protocol used by the Control Server, as specified in the settings.
+        """
+
+        return CTRL_SETTINGS.PROTOCOL
+
+    def get_commanding_port(self) -> int:
+        """ Returns the commanding port used by the Control Server.
+
+        Returns: Commanding port used by the Control Server, as specified in the settings.
+        """
+
+        return CTRL_SETTINGS.COMMANDING_PORT
+
+    def get_service_port(self):
+        """ Returns the service port used by the Control Server.
+
+        Returns: Service port used by the Control Server, as specified in the settings.
+        """
+
+        return CTRL_SETTINGS.SERVICE_PORT
+
+    def get_monitoring_port(self):
+        """ Returns the monitoring port used by the Control Server.
+
+        Returns: Monitoring port used by the Control Server, as specified in the settings.
+        """
+
+        return CTRL_SETTINGS.MONITORING_PORT
+
+    def get_storage_mnemonic(self):
+        """ Returns the storage mnemonics used by the Control Server.
+
+        This is a string that will appear in the filename with the housekeeping information of the device, as a way of
+        identifying the device.  If this is not implemented in the sub-class, then the class name will be used.
+
+        Returns: Storage mnemonics used by the Control Server, as specified in the settings.  If not specified in the
+                 settings, "DAQ6510" will be used.
+        """
+
+        try:
+            return CTRL_SETTINGS.STORAGE_MNEMONIC
+        except AttributeError:
+            return "DAQ6510"
+
+    def before_serve(self):
+        """ Steps to take before the Control Server is activated."""
+
+        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():
+    """ Starts the DAQ6510 Control Server in the background."""
+
+    invoke.run("daq6510_cs start", disown=True)
+
+
+@cli.command()
+def stop():
+    """ Sends 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():
+    """ Requests 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

@@ -0,0 +1,359 @@
+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      # [s], can be smaller than timeout (for DAQ6510Proxy) (e.g. 1s)
+
+
+class DAQ6510Command(ClientServerCommand):
+
+    def get_cmd_string(self, *args, **kwargs) -> str:
+        """ Constructs the command string, based on the given positional and/or keyword arguments.
+
+        Args:
+            *args: Positional arguments that are needed to construct the command string
+            **kwargs: Keyword arguments that are needed to construct the command string
+
+        Returns: Command string with the given positional and/or keyword arguments filled out.
+        """
+
+        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: str = None, port: int = None):
+        """ Initialisation of an Ethernet interface for the DAQ6510.
+
+        Args:
+            hostname(str): Hostname to which to open a socket
+            port (int): Port to which to open a socket
+        """
+
+        super().__init__()
+
+        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):
+        """ Connects the device.
+
+        Raises:
+            DeviceConnectionError: When the connection could not be established. Check the logging messages for more
+                                   details.
+            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 3s before connecting and reset to None (=blocking) after the `connect` method has been
+        # called. 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):
+        """ Disconnects 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):
+        """ Reconnects to the device controller.
+
+        Raises:
+            ConnectionError when the device cannot be reconnected for some reason.
+        """
+
+        if self.is_connection_open:
+            self.disconnect()
+        self.connect()
+
+    def is_connected(self) -> bool:
+        """ Checks 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:
+            version = 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
+
+        if "DAQ6510" not in version:
+            logger.error(
+                f'Device did not respond correctly to a "VERSION" command, response={version}. '
+                f"Disconnecting..."
+            )
+            self.disconnect()
+            return False
+
+        return True
+
+    def write(self, command: str):
+        """ Senda a single command to the device controller without waiting for a response.
+
+        Args:
+            command (str): Command to send to 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:
+        """ Sends a single command to the device controller and block until a response from the controller.
+
+        This is seen as a transaction.
+
+        Args:
+            command (str): Command to send to the controller
+
+        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()
+
+            return return_string.decode().rstrip()
+
+        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:
+        """ Reads from the device buffer.
+
+        Returns: Content of the device buffer.
+        """
+
+        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:
+            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()