keithley-tempcontrol 0.17.3__py3-none-any.whl → 0.18.1__py3-none-any.whl

egse/tempcontrol/keithley/__init__.py

@@ -1,4 +1,2 @@
 class TemperatureControlError(Exception):
     """Temperature control error for Keithley temperature control systems."""
-
-    pass

egse/tempcontrol/keithley/daq6510.py

@@ -1,33 +1,53 @@
 import logging
-import re
 from pathlib import Path
-from typing import Dict, Union
-from typing import List
-from typing import Tuple
+from typing import Dict, List, Tuple
 
+from egse.connect import get_endpoint
 from egse.decorators import dynamic_interface
-from egse.device import DeviceConnectionState
-from egse.device import DeviceInterface
-from egse.mixin import DynamicCommandMixin, CommandType
-from egse.mixin import add_lf
-from egse.mixin import dynamic_command
-from egse.proxy import Proxy
+from egse.device import DeviceConnectionState, DeviceInterface
+from egse.env import bool_env
+from egse.response import Failure
+from egse.log import logger
+from egse.mixin import CommandType, DynamicCommandMixin, add_lf, dynamic_command
+from egse.proxy import DynamicProxy
+from egse.scpi import count_number_of_channels, create_channel_list, get_channel_names
 from egse.settings import Settings
-from egse.tempcontrol.keithley.daq6510_dev import DAQ6510EthernetInterface
-from egse.zmq_ser import connect_address
+from egse.tempcontrol.keithley.daq6510_dev import DAQ6510
 
-logger = logging.getLogger(__name__)
+VERBOSE_DEBUG = bool_env("VERBOSE_DEBUG")
 
 HERE = Path(__file__).parent
 
-CTRL_SETTINGS = Settings.load("Keithley Control Server")
-FW_SETTINGS = Settings.load("Keithley DAQ6510")
-DEVICE_SETTINGS = Settings.load(location=HERE, filename="daq6510.yaml")
+cs_settings = Settings.load("Keithley Control Server")
+dev_settings = Settings.load("Keithley DAQ6510")
 
+PROTOCOL = cs_settings.get("PROTOCOL", "tcp")
+HOSTNAME = cs_settings.get("HOSTNAME", "localhost")
+COMMANDING_PORT = cs_settings.get("COMMANDING_PORT", 0)
+TIMEOUT = cs_settings.get("TIMEOUT", 60)
+SERVICE_TYPE = cs_settings.get("SERVICE_TYPE", "daq6510")
 
 DEFAULT_BUFFER_1 = "defbuffer1"
 DEFAULT_BUFFER_2 = "defbuffer2"
 
+DEV_HOST = dev_settings.get("HOSTNAME", "localhost")
+DEV_PORT = dev_settings.get("PORT", 5025)
+
+
+def decode_response(response: bytes) -> str | Failure:
+    """Decodes the bytes object, strips off the trailing 'CRLF'."""
+
+    if VERBOSE_DEBUG:
+        logger.debug(f"{response = } <- decode_response")
+
+    if isinstance(response, Failure):
+        return response
+
+    if isinstance(response, memoryview):
+        response = response.tobytes()
+
+    return response.decode().rstrip()
+
 
 class DAQ6510Interface(DeviceInterface):
     """
@@ -35,7 +55,7 @@ class DAQ6510Interface(DeviceInterface):
     """
 
     @dynamic_interface
-    def send_command(self, command: str, response: bool) -> Union[None, str]:
+    def send_command(self, command: str, response: bool) -> str | None:
         """Sends the given SCPI command to the device.
 
         The valid commands are described in the DAQ6510 Reference Manual [DAQ6510-901-01 Rev. B / September 2019].
@@ -54,6 +74,23 @@ class DAQ6510Interface(DeviceInterface):
         cmd_type=CommandType.TRANSACTION,
         cmd_string="*IDN?",
         process_cmd_string=add_lf,
+        process_response=decode_response,
+    )
+    def get_idn(self) -> str:
+        """Returns basic information about the device, its name, firmware version, etc.
+
+        The string returned is subject to change without notice and can not be used for parsing information.
+
+        Returns: Identification string of the instrument.
+        """
+
+        raise NotImplementedError
+
+    @dynamic_command(
+        cmd_type=CommandType.TRANSACTION,
+        cmd_string="*IDN?",
+        process_cmd_string=add_lf,
+        process_response=decode_response,
     )
     def info(self) -> str:
         """Returns basic information about the device, its name, firmware version, etc.
@@ -98,7 +135,7 @@ class DAQ6510Interface(DeviceInterface):
 
         raise NotImplementedError
 
-    @dynamic_command(cmd_type=CommandType.TRANSACTION, cmd_string=":SYST:TIME? 1")
+    @dynamic_command(cmd_type=CommandType.TRANSACTION, cmd_string=":SYST:TIME? 1", process_response=decode_response)
     def get_time(self) -> str:
         """Gets the date and time from the device in UTC.
 
@@ -126,7 +163,7 @@ class DAQ6510Interface(DeviceInterface):
 
         raise NotImplementedError
 
-    @dynamic_command(cmd_type=CommandType.TRANSACTION, cmd_string="TRAC:ACTUAL? ${buffer_name}")
+    @dynamic_command(cmd_type=CommandType.TRANSACTION, cmd_string='TRAC:ACTUAL? "${buffer_name}"')
     def get_buffer_count(self, buffer_name: str = DEFAULT_BUFFER_1):
         """Returns the number of data points in the specified buffer.
 
@@ -136,8 +173,12 @@ class DAQ6510Interface(DeviceInterface):
 
         raise NotImplementedError
 
-    @dynamic_command(cmd_type=CommandType.TRANSACTION, cmd_string="TRACE:POINTS? ${buffer_name}")
-    def get_buffer_capacity(self, buffer_name: str):
+    @dynamic_command(
+        cmd_type=CommandType.TRANSACTION,
+        cmd_string='TRACE:POINTS? "${buffer_name}"',
+        process_cmd_string=add_lf,
+    )
+    def get_buffer_capacity(self, buffer_name: str = DEFAULT_BUFFER_1):
         """Returns the capacity of the specified buffer.
 
         Args:
@@ -146,7 +187,7 @@ class DAQ6510Interface(DeviceInterface):
 
         raise NotImplementedError
 
-    @dynamic_command(cmd_type=CommandType.WRITE, cmd_string="TRACE:DELETE ${buffer_name}")
+    @dynamic_command(cmd_type=CommandType.WRITE, cmd_string='TRACE:DELETE "${buffer_name}"')
     def delete_buffer(self, buffer_name: str) -> None:
         """Deletes the specified buffer.
 
@@ -189,7 +230,7 @@ class DAQ6510Interface(DeviceInterface):
         raise NotImplementedError
 
     @dynamic_interface
-    def setup_measurements(self, *, buffer_name: str, channel_list: str):
+    def setup_measurements(self, *, buffer_name: str = DEFAULT_BUFFER_1, channel_list: str):
         """Sets up the measurements for the given channel list.
 
         Args:
@@ -200,11 +241,13 @@ class DAQ6510Interface(DeviceInterface):
         raise NotImplementedError
 
     @dynamic_interface
-    def perform_measurement(self, *, buffer_name: str, channel_list: str, count: int, interval: int) -> list:
+    def perform_measurement(
+        self, *, buffer_name: str = DEFAULT_BUFFER_1, channel_list: str, count: int, interval: int
+    ) -> list:
         """Performs the actual measurements.
 
         Args:
-            buffer_name (str): Name of the buffer
+            buffer_name (str): Name of the buffer [default: defbuffer1]
             channel_list (str): List of channels, as understood by the device
             count (int): Number of measurements to perform
             interval (int): Interval between measurements [s]
@@ -219,12 +262,12 @@ class DAQ6510Controller(DAQ6510Interface, DynamicCommandMixin):
     through an Ethernet interface.
     """
 
-    def __init__(self, hostname: str = FW_SETTINGS.HOSTNAME, port: int = FW_SETTINGS.PORT):
+    def __init__(self, hostname: str = DEV_HOST, port: int = DEV_PORT):
         """Opens a TCP/IP socket connection with the Keithley DAQ6510 Hardware.
 
         Args:
-            hostname (str): IP address or fully qualified hostname of the Hexapod hardware controller. The default is
-                            defined in the ``settings.yaml`` configuration file.
+            hostname (str): IP address or fully qualified hostname of the DAQ6510 hardware controller.
+                The default is defined in the ``settings.yaml`` configuration file.
             port (int): IP port number to connect to, by default set in the ``settings.yaml`` configuration file.
 
         Raises:
@@ -235,7 +278,7 @@ class DAQ6510Controller(DAQ6510Interface, DynamicCommandMixin):
 
         logger.debug(f"Initializing the DAQ6510 Controller with hostname={hostname} on port={port}")
 
-        self.daq = self.transport = DAQ6510EthernetInterface(hostname, port)
+        self.daq = self.transport = DAQ6510(hostname, port)
 
         # We set the default buffer here, this can be changed with the `create_buffer()` method.
 
@@ -277,7 +320,7 @@ class DAQ6510Controller(DAQ6510Interface, DynamicCommandMixin):
 
         return self.daq.is_connected()
 
-    def send_command(self, command: str, response: bool) -> Union[None, str]:
+    def send_command(self, command: str, response: bool) -> str | None:
         """Sends an SCPI command to the device.
 
         The valid commands are described in the DAQ6510 Reference Manual [DAQ6510-901-01 Rev. B / September 2019].
@@ -290,9 +333,11 @@ class DAQ6510Controller(DAQ6510Interface, DynamicCommandMixin):
                  None will be returned.
         """
 
-        return self.daq.trans(command) if response else self.daq.write(command)
+        return self.daq.trans(command).decode() if response else self.daq.write(command)
 
-    def read_buffer(self, start: int, end: int, buffer_name: str = DEFAULT_BUFFER_1, elements: List[str] = None):
+    def read_buffer(
+        self, start: int, end: int, buffer_name: str = DEFAULT_BUFFER_1, elements: list[str] | None = None
+    ) -> bytes:
         """Reads specific data elements (measurements) from the given buffer.
 
         Elements that can be specified to read out:
@@ -308,17 +353,17 @@ class DAQ6510Controller(DAQ6510Interface, DynamicCommandMixin):
             start: (int) First index of the buffer that should be returned (>= 1)
             end (int): Last index of the buffer that should be returned
             buffer_name (str): Name of the buffer to read out
-            elements (List[str]): List of elements from the buffer to include in the response
+            elements (list[str] | None): List of elements from the buffer to include in the response
 
         Returns: List of all the readings.
         """
 
         if elements is None:
-            elements = ["READING"]
+            elements_str = ["READING"]
         else:
-            elements = ", ".join(elements)
+            elements_str = ", ".join(elements)
 
-        return self.daq.trans(f'TRACE:DATA? {start}, {end}, "{buffer_name}", {elements}')
+        return self.daq.trans(f'TRACE:DATA? {start}, {end}, "{buffer_name}", {elements_str}')
 
     def clear_buffer(self, buffer_name: str = DEFAULT_BUFFER_1) -> None:
         """Clears the given buffer.
@@ -473,7 +518,7 @@ class DAQ6510Controller(DAQ6510Interface, DynamicCommandMixin):
 
         # Read out the buffer
 
-        logger.debug("Buffer count = ", self.get_buffer_count())
+        logger.debug(f"Buffer count = {self.get_buffer_count()}")
 
         num_sensors = count_number_of_channels(channel_list)
 
@@ -483,82 +528,24 @@ class DAQ6510Controller(DAQ6510Interface, DynamicCommandMixin):
             response = self.read_buffer(
                 idx, idx, buffer_name=buffer_name, elements=["CHANNEL", "TSTAMP", "READING", "UNIT"]
             )
-            if response != "" and response != str(count * num_sensors):
-                if "\n" in response:
-                    response = response.split("\n")
-                    for i in range(len(response)):
-                        readings.append(response[i].split(","))
+            response_str = response.decode().strip()
+
+            if response_str != "" and response_str != str(count * num_sensors):
+                if "\n" in response_str:
+                    response_str = response_str.split("\n")
+                    for i in range(len(response_str)):
+                        readings.append(response_str[i].split(","))
                 else:
-                    readings.append(response.split(","))
+                    readings.append(response_str.split(","))
+
+                # Remove incomplete readings
                 if len(readings[0]) < 4:
                     del readings[0]
 
         return readings
 
 
-class DAQ6510Simulator(DAQ6510Interface):
-    """
-    Simulator for the Keithley DAQ6510 system.
-    """
-
-    def read_buffer(self, start: int, end: int, buffer_name: str, elements: List[str]):
-        pass
-
-    def get_buffer_count(self, buffer_name: str = DEFAULT_BUFFER_1):
-        pass
-
-    def get_buffer_capacity(self, buffer_name: str):
-        pass
-
-    def delete_buffer(self, buffer_name: str):
-        pass
-
-    def clear_buffer(self, buffer_name: str):
-        pass
-
-    def create_buffer(self, buffer_name: str, size: int):
-        pass
-
-    def configure_sensors(self, channel_list: str, *, sense: Dict[str, List[Tuple]]):
-        pass
-
-    def setup_measurements(self, *, buffer_name: str, channel_list: str):
-        pass
-
-    def perform_measurement(self, *, buffer_name: str, channel_list: str, count: int, interval: int):
-        pass
-
-    def send_command(self, command: str, response: bool):
-        pass
-
-    def info(self) -> str:
-        pass
-
-    def reset(self):
-        pass
-
-    def is_simulator(self):
-        """Indicates that the device is a simulator.
-
-        Returns: True.
-        """
-
-        return True
-
-    def connect(self):
-        pass
-
-    def disconnect(self):
-        pass
-
-    def reconnect(self):
-        pass
-
-    def is_connected(self):
-        pass
-
-
-class DAQ6510Proxy(Proxy, DAQ6510Interface):
+class DAQ6510Proxy(DynamicProxy, DAQ6510Interface):
     """
     The DAQ6510Proxy class is used to connect to the Keithley Control Server and send commands
     to the Keithley Hardware Controller remotely.
@@ -566,162 +553,21 @@ class DAQ6510Proxy(Proxy, DAQ6510Interface):
 
     def __init__(
         self,
-        protocol: str = CTRL_SETTINGS.PROTOCOL,
-        hostname: str = CTRL_SETTINGS.HOSTNAME,
-        port: int = CTRL_SETTINGS.COMMANDING_PORT,
-        timeout: int = CTRL_SETTINGS.TIMEOUT * 1000,  # Timeout [ms]: > scan count * interval + (one scan duration)
+        protocol: str = PROTOCOL,
+        hostname: str = HOSTNAME,
+        port: int = COMMANDING_PORT,
+        timeout: float = TIMEOUT,  # Timeout [s]: > scan count * interval + (one scan duration)
     ):
-        """Initialisation of a DAQ6510Proxy.
+        """Initialization of a DAQ6510Proxy.
 
         Args:
             protocol (str): Transport protocol [default is taken from settings file]
             hostname (str): Location of the Control Server (IP address) [default is taken from settings file]
             port (int): TCP port on which the Control Server is listening for commands [default is taken from settings
                         file]
-            timeout (int): Timeout by which to establish the connection [ms]
+            timeout (float): Timeout by which to establish the connection [s]
         """
 
-        super().__init__(connect_address(protocol, hostname, port), timeout=timeout)
-
-
-def create_channel_list(*args) -> str:
-    """Createa a channel list that is understood by the SCPI commands of the DAQ6510.
-
-    Channel names contain both the slot number and the channel number. The slot number is the number of the slot where
-    the card is installed at the back of the device.
-
-    When addressing multiple individual channels, add each of them as a separate argument, e.g. to include channels 1,
-    3, and 7 from slot 1, use the following command:
-
-        >>> create_channel_list(101, 103, 107)
-        '(@101, 103, 107)'
-
-    To designate a range of channels, only one argument should be given, i.e. a tuple containing two channels
-    representing the range. The following tuple `(101, 110)` will create the following response: `"(@101:110)"`. The
-    range is inclusive, so this will define a range of 10 channels in slot 1.
-
-        >>> create_channel_list((201, 205))
-        '(@201:205)'
-
-    See reference manual for the Keithley DAQ6510 [DAQ6510-901-01 Rev. B / September 2019], chapter 11: Introduction to
-    SCPI commands, SCPI command formatting, channel naming.
-
-    Args:
-        *args: Tuple or a list of channels
-
-    Returns: String containing the channel list as understood by the device.
-    """
-
-    if not args:
-        return ""
-
-    # If only one argument is given, I expect either a tuple defining a range or just one channel. When several
-    # arguments are given, I expect them all to be individual channels.
-
-    if len(args) == 1:
-        arg = args[0]
-        if isinstance(arg, tuple):
-            ch_list = f"(@{arg[0]}:{arg[1]})"
-        else:
-            ch_list = f"(@{arg})"
-
-    else:
-        ch_list = "(@" + ", ".join([str(arg) for arg in args]) + ")"
-
-    return ch_list
-
-
-def count_number_of_channels(channel_list: str) -> int:
-    """Given a proper channel list, this function counts the number of channels.
-
-    For ranges, it returns the actual number of channels that are included in the range.
-
-        >>> count_number_of_channels("(@1,2,3,4,5)")
-        5
-        >>> count_number_of_channels("(@1, 3, 5)")
-        3
-        >>> count_number_of_channels("(@2:7)")
-        6
-
-    Args:
-        channel_list (str): Channel list as understood by the SCPI commands of DAQ6510
-
-    Returns: Number of channels in the list.
-    """
-
-    match = re.match(r"\(@(.*)\)", channel_list)
-    group = match.groups()[0]
-
-    parts = group.replace(" ", "").split(",")
-    count = 0
-    for part in parts:
-        if ":" in part:
-            split_part = part.split(":")
-            count += int(split_part[1]) - int(split_part[0]) + 1
-        else:
-            count += 1
-
-    return count
-
-
-def get_channel_names(channel_list: str) -> List[str]:
-    """Generates a list of channel names from a given channel list.
-
-    Args:
-        channel_list (str): Channel list as understood by the SCPI commands of DAQ6510
-
-    Returns: List of channel names.
-    """
-
-    match = re.match(r"\(@(.*)\)", channel_list)
-    group = match.groups()[0]
-
-    parts = group.replace(" ", "").split(",")
-    names = []
-    for part in parts:
-        if ":" in part:
-            split_part = part.split(":")
-            names.extend(str(ch) for ch in range(int(split_part[0]), int(split_part[1]) + 1))
-        else:
-            names.append(part)
-
-    return names
-
-
-if __name__ == "__main__":
-    logging.basicConfig(level=20)
-
-    print(f'{get_channel_names("(@101:105)")=}')
-    print(f'{get_channel_names("(@101, 102, 103, 105)")=}')
-    # sys.exit(0)
-
-    daq = DAQ6510Controller()
-    daq.connect()
-    daq.reset()
-
-    print(daq.info())
-
-    buffer_capacity = daq.get_buffer_capacity()
-    print(f"buffer {DEFAULT_BUFFER_1} can still hold {buffer_capacity} readings")
-
-    buffer_count = daq.get_buffer_count()
-    print(f"buffer {DEFAULT_BUFFER_1} holds {buffer_count} readings")
-
-    channels = create_channel_list((101, 102))
-
-    print(channels)
-
-    sense_dict = {"TEMPERATURE": [("TRANSDUCER", "FRTD"), ("RTD:FOUR", "PT100"), ("UNIT", "KELVIN")]}
-
-    daq.configure_sensors(channels, sense=sense_dict)
-
-    daq.setup_measurements(channel_list=channels)
-
-    meas_response = daq.perform_measurement(channel_list=channels, count=5, interval=1)
-
-    print(meas_response)
-
-    buffer_count = daq.get_buffer_count()
-    print(f"buffer {DEFAULT_BUFFER_1} holds {buffer_count} readings")
+        endpoint = get_endpoint(SERVICE_TYPE, protocol, hostname, port)
 
-    daq.disconnect()
+        super().__init__(endpoint, timeout=timeout)

egse/tempcontrol/keithley/daq6510_adev.py

@@ -1,18 +1,39 @@
+"""
+Keithley DAQ6510 device implementation as an SCPI interface.
+
+This module provides an asynchronous interface to communicate with
+the Keithley DAQ6510 data acquisition unit using SCPI commands.
+
+Classes:
+    DAQ6510: An asynchronous SCPI interface for the Keithley DAQ6510 device.
+
+"""
+
+__all__ = [
+    "DAQ6510",
+]
+
 import asyncio
-import logging
 from typing import Any
 from typing import Dict
 from typing import Optional
 
+from egse.log import logger
 from egse.scpi import AsyncSCPIInterface
+from egse.settings import Settings
+
+dev_settings = Settings.load("Keithley DAQ6510")
 
-logger = logging.getLogger(__name__)
+DEV_HOST = dev_settings.get("HOSTNAME", "localhost")
+DEV_PORT = dev_settings.get("PORT", 5025)
+DEVICE_NAME = dev_settings.get("DEVICE_NAME", "DAQ6510")
+DEV_ID_VALIDATION = "DAQ6510"
 
 
 class DAQ6510(AsyncSCPIInterface):
     """Keithley DAQ6510 specific implementation."""
 
-    def __init__(self, hostname: str, port: int = 5025, settings: Optional[Dict[str, Any]] = None):
+    def __init__(self, hostname: str = DEV_HOST, port: int = DEV_PORT, settings: Optional[Dict[str, Any]] = None):
         """Initialize a Keithley DAQ6510 interface.
 
         Args:
@@ -21,45 +42,16 @@ class DAQ6510(AsyncSCPIInterface):
             settings: Additional device settings
         """
         super().__init__(
-            device_name="DAQ6510",
+            device_name=DEVICE_NAME,
             hostname=hostname,
             port=port,
             settings=settings,
-            id_validation="DAQ6510",  # String that must appear in IDN? response
+            id_validation=DEV_ID_VALIDATION,  # String that must appear in IDN? response
+            read_timeout=5.0,
         )
 
         self._measurement_lock = asyncio.Lock()
 
-    async def initialize(self):
-        # Initialize
-
-        await self.write("*RST")  # this also the user-defined buffer "test1"
-
-        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)", False),  # set the transducer to 4-wire RTD
-            ("SENS:TEMP:RTD:FOUR PT100, (@101)", False),  # set the type of the 4-wire RTD
-            ("SENS:TEMP:TRAN RTD, (@102)", False),  # set the transducer to 2-wire RTD
-            ("SENS:TEMP:RTD:TWO PT100, (@102)", False),  # set the type of the 2-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),
-        ]:
-            if response:
-                logger.info(f"Sending {cmd}...")
-                response = (await self.trans(cmd)).decode().strip()
-                logger.info(f"{response = }")
-            else:
-                logger.info(f"Sending {cmd}...")
-                await self.write(cmd)
-
     async def get_measurement(self, channel: str) -> float:
         """Get a measurement from a specific channel.