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

egse/tempcontrol/keithley/daq6510.py

@@ -1,33 +1,40 @@
 import logging
 import re
 from pathlib import Path
-from typing import Dict, Union
+from typing import Dict
 from typing import List
 from typing import 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.log import logger
+from egse.mixin import CommandType
+from egse.mixin import DynamicCommandMixin
 from egse.mixin import add_lf
 from egse.mixin import dynamic_command
 from egse.proxy import Proxy
 from egse.settings import Settings
-from egse.tempcontrol.keithley.daq6510_dev import DAQ6510EthernetInterface
-from egse.zmq_ser import connect_address
-
-logger = logging.getLogger(__name__)
+from egse.tempcontrol.keithley.daq6510_dev import DAQ6510
 
 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")
+SERVICE_TYPE = cs_settings.get("SERVICE_TYPE", "daq6510")
 
 DEFAULT_BUFFER_1 = "defbuffer1"
 DEFAULT_BUFFER_2 = "defbuffer2"
 
+DEV_HOST = dev_settings.get("HOSTNAME")
+DEV_PORT = dev_settings.get("PORT")
+
 
 class DAQ6510Interface(DeviceInterface):
     """
@@ -35,7 +42,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].
@@ -219,12 +226,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 +242,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 +284,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].
@@ -292,7 +299,7 @@ class DAQ6510Controller(DAQ6510Interface, DynamicCommandMixin):
 
         return self.daq.trans(command) 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):
         """Reads specific data elements (measurements) from the given buffer.
 
         Elements that can be specified to read out:
@@ -566,10 +573,10 @@ 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.
 
@@ -578,10 +585,12 @@ class DAQ6510Proxy(Proxy, DAQ6510Interface):
             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)
+        endpoint = get_endpoint(SERVICE_TYPE, protocol, hostname, port)
+
+        super().__init__(endpoint, timeout=timeout)
 
 
 def create_channel_list(*args) -> str:

egse/tempcontrol/keithley/daq6510_adev.py

@@ -1,18 +1,28 @@
+__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", 0)
+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 +31,15 @@ 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
         )
 
         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.
 

egse/tempcontrol/keithley/daq6510_cs.py

@@ -1,22 +1,29 @@
-import logging
 import multiprocessing
 import sys
 
-import click
-import invoke
 import rich
+import typer
 import zmq
+
+from egse.connect import get_endpoint
 from egse.control import ControlServer
 from egse.control import is_control_server_active
+from egse.log import logger
+from egse.logger import remote_logging
+from egse.registry.client import RegistryClient
 from egse.settings import Settings
+from egse.storage import store_housekeeping_information
 from egse.tempcontrol.keithley.daq6510 import DAQ6510Proxy
 from egse.tempcontrol.keithley.daq6510_protocol import DAQ6510Protocol
 from egse.zmq_ser import connect_address
-from prometheus_client import start_http_server
 
-logger = logging.getLogger(__name__)
+cs_settings = Settings.load("Keithley Control Server")
 
-CTRL_SETTINGS = Settings.load("Keithley Control Server")
+PROTOCOL = cs_settings.get("PROTOCOL", "tcp")
+HOSTNAME = cs_settings.get("HOSTNAME", "localhost")
+COMMANDING_PORT = cs_settings.get("COMMANDING_PORT", 0)
+STORAGE_MNEMONIC = cs_settings.get("STORAGE_MNEMONIC", "DAQ6510")
+SERVICE_TYPE = cs_settings.get("SERVICE_TYPE", "daq6510")
 
 
 def is_daq6510_cs_active(timeout: float = 0.5) -> bool:
@@ -28,7 +35,14 @@ def is_daq6510_cs_active(timeout: float = 0.5) -> bool:
     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)
+    if COMMANDING_PORT == 0:
+        with RegistryClient() as client:
+            endpoint = client.get_endpoint(SERVICE_TYPE)
+            if endpoint is None:
+                logger.debug(f"No endpoint for {SERVICE_TYPE}")
+                return False
+    else:
+        endpoint = connect_address(PROTOCOL, HOSTNAME, COMMANDING_PORT)
 
     return is_control_server_active(endpoint, timeout)
 
@@ -62,13 +76,15 @@ class DAQ6510ControlServer(ControlServer):
 
         self.poller.register(self.dev_ctrl_cmd_sock, zmq.POLLIN)
 
+        self.register_service(service_type=cs_settings.SERVICE_TYPE)
+
     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
+        return cs_settings.PROTOCOL
 
     def get_commanding_port(self) -> int:
         """Returns the commanding port used by the Control Server.
@@ -76,7 +92,7 @@ class DAQ6510ControlServer(ControlServer):
         Returns: Commanding port used by the Control Server, as specified in the settings.
         """
 
-        return CTRL_SETTINGS.COMMANDING_PORT
+        return cs_settings.COMMANDING_PORT
 
     def get_service_port(self):
         """Returns the service port used by the Control Server.
@@ -84,7 +100,7 @@ class DAQ6510ControlServer(ControlServer):
         Returns: Service port used by the Control Server, as specified in the settings.
         """
 
-        return CTRL_SETTINGS.SERVICE_PORT
+        return cs_settings.SERVICE_PORT
 
     def get_monitoring_port(self):
         """Returns the monitoring port used by the Control Server.
@@ -92,7 +108,7 @@ class DAQ6510ControlServer(ControlServer):
         Returns: Monitoring port used by the Control Server, as specified in the settings.
         """
 
-        return CTRL_SETTINGS.MONITORING_PORT
+        return cs_settings.MONITORING_PORT
 
     def get_storage_mnemonic(self):
         """Returns the storage mnemonics used by the Control Server.
@@ -104,57 +120,88 @@ class DAQ6510ControlServer(ControlServer):
                  settings, "DAQ6510" will be used.
         """
 
-        try:
-            return CTRL_SETTINGS.STORAGE_MNEMONIC
-        except AttributeError:
-            return "DAQ6510"
+        return STORAGE_MNEMONIC
+
+    def is_storage_manager_active(self):
+        from egse.storage import is_storage_manager_active
+
+        return is_storage_manager_active()
+
+    def store_housekeeping_information(self, data):
+        """Send housekeeping information to the Storage manager."""
+
+        origin = self.get_storage_mnemonic()
+        store_housekeeping_information(origin, data)
+
+    def register_to_storage_manager(self):
+        from egse.storage import register_to_storage_manager
+        from egse.storage.persistence import TYPES
+
+        register_to_storage_manager(
+            origin=self.get_storage_mnemonic(),
+            persistence_class=TYPES["CSV"],
+            prep={
+                "column_names": list(self.device_protocol.get_housekeeping().keys()),
+                "mode": "a",
+            },
+        )
+
+    def unregister_from_storage_manager(self):
+        from egse.storage import unregister_from_storage_manager
+
+        unregister_from_storage_manager(origin=self.get_storage_mnemonic())
 
     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
+app = typer.Typer(name="daq6510_cs")
 
 
-@cli.command()
+@app.command()
 def start():
     """Starts the Keithley DAQ6510 Control Server."""
 
     multiprocessing.current_process().name = "daq6510_cs (start)"
 
-    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}.")
+    with remote_logging():
+        from egse.env import setup_env
+
+        setup_env()
+
+        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.code)
+        except Exception:
+            msg = "Cannot start the DAQ6510 Control Server"
+            logger.exception(msg)
+            rich.print(f"[red]{msg}.")
 
     return 0
 
 
-@cli.command()
+@app.command()
 def start_bg():
     """Starts the DAQ6510 Control Server in the background."""
 
-    invoke.run("daq6510_cs start", disown=True)
+    print("Starting the DAQ6510 in the background is not implemented.")
 
 
-@cli.command()
+@app.command()
 def stop():
     """Sends a 'quit_server' command to the Keithley DAQ6510 Control Server."""
 
     multiprocessing.current_process().name = "daq6510_cs (stop)"
 
+    from egse.env import setup_env
+
+    setup_env()
+
     try:
         with DAQ6510Proxy() as daq:
             sp = daq.get_service_proxy()
@@ -165,17 +212,17 @@ def stop():
         rich.print(f"[red]{msg}, could not send the Quit command. [black]Check log messages.")
 
 
-@cli.command()
+@app.command()
 def status():
     """Requests status information from the Control Server."""
 
     multiprocessing.current_process().name = "daq6510_cs (status)"
 
-    protocol = CTRL_SETTINGS.PROTOCOL
-    hostname = CTRL_SETTINGS.HOSTNAME
-    port = CTRL_SETTINGS.COMMANDING_PORT
+    from egse.env import setup_env
 
-    endpoint = connect_address(protocol, hostname, port)
+    setup_env()
+
+    endpoint = get_endpoint(SERVICE_TYPE, PROTOCOL, HOSTNAME, COMMANDING_PORT)
 
     if is_control_server_active(endpoint):
         rich.print("DAQ6510 CS: [green]active")
@@ -190,6 +237,4 @@ def status():
 
 
 if __name__ == "__main__":
-    logging.basicConfig(level=logging.DEBUG, format=Settings.LOG_FORMAT_FULL)
-
-    sys.exit(cli())
+    sys.exit(app())

egse/tempcontrol/keithley/daq6510_dev.py

@@ -1,23 +1,30 @@
-import logging
+__all__ = [
+    "DAQ6510",
+    "DAQ6510Command",
+]
 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 DeviceInterface
 from egse.device import DeviceTimeoutError
 from egse.device import DeviceTransport
+from egse.log import logger
 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)
+dev_settings = Settings.load("Keithley DAQ6510")
+
+DEVICE_NAME = dev_settings.get("DEVICE_NAME", "DAQ6510")
+DEV_HOST = dev_settings.get("HOSTNAME")
+DEV_PORT = dev_settings.get("PORT")
+READ_TIMEOUT = dev_settings.get("TIMEOUT")  # [s], can be smaller than timeout (for DAQ6510Proxy) (e.g. 1s)
+
+SEPARATOR = b"\n"
+SEPARATOR_STR = SEPARATOR.decode()
 
 
 class DAQ6510Command(ClientServerCommand):
@@ -32,13 +39,13 @@ class DAQ6510Command(ClientServerCommand):
         """
 
         out = super().get_cmd_string(*args, **kwargs)
-        return out + "\n"
+        return out + SEPARATOR_STR
 
 
-class DAQ6510EthernetInterface(DeviceConnectionInterface, DeviceTransport):
+class DAQ6510(DeviceInterface, DeviceTransport):
     """Defines the low-level interface to the Keithley DAQ6510 Controller."""
 
-    def __init__(self, hostname: str = None, port: int = None):
+    def __init__(self, hostname: str = DEV_HOST, port: int = DEV_PORT):
         """Initialisation of an Ethernet interface for the DAQ6510.
 
         Args:
@@ -48,12 +55,66 @@ class DAQ6510EthernetInterface(DeviceConnectionInterface, DeviceTransport):
 
         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.device_name = DEVICE_NAME
+        self.hostname = hostname
+        self.port = port
         self._sock = None
 
         self._is_connection_open = False
 
+    def initialize(self, commands: list[tuple[str, bool]] = None, reset_device: bool = False) -> list[str | None]:
+        """Initialize the device with optional reset and command sequence.
+
+        Performs device initialization by optionally resetting the device and then
+        executing a sequence of commands. Each command can optionally expect a
+        response that will be logged for debugging purposes.
+
+        Args:
+           commands: List of tuples containing (command_string, expects_response).
+               Each tuple specifies a command to send and whether to wait for and
+               log the response. Defaults to None (no commands executed).
+           reset_device: Whether to send a reset command (*RST) before executing
+               the command sequence. Defaults to False.
+
+        Returns:
+           Response for each of the commands, or None when no response was expected.
+
+        Raises:
+           Any exceptions raised by the underlying write() or trans() methods,
+           typically communication errors or device timeouts.
+
+        Example:
+            responses = device.initialize(
+                [
+                    ("*IDN?", True),           # Query device ID, expect response
+                    ("SYST:ERR?", True),       # Check for errors, expect response
+                    ("OUTP ON", False)         # Enable output, no response expected
+                ],
+                reset_device=True
+            )
+        """
+
+        commands = commands or []
+        responses = []
+
+        if reset_device:
+            logger.info(f"Resetting the {self.device_name}...")
+            self.write("*RST")  # this also resets the user-defined buffer
+
+        for cmd, expects_response in commands:
+            if expects_response:
+                logger.debug(f"Sending {cmd}...")
+                response = self.trans(cmd).decode().strip()
+                logger.debug(f"{response = }")
+            else:
+                logger.debug(f"Sending {cmd}...")
+                self.write(cmd)
+
+        return responses
+
+    def is_simulator(self) -> bool:
+        return False
+
     def connect(self) -> None:
         """Connects the device.
 
@@ -187,7 +248,7 @@ class DAQ6510EthernetInterface(DeviceConnectionInterface, DeviceTransport):
         """
 
         try:
-            command += "\n" if not command.endswith("\n") else ""
+            command += SEPARATOR_STR if not command.endswith(SEPARATOR_STR) else ""
 
             self._sock.sendall(command.encode())
 
@@ -202,7 +263,7 @@ class DAQ6510EthernetInterface(DeviceConnectionInterface, DeviceTransport):
                 raise DeviceConnectionError(DEVICE_NAME, msg)
             raise
 
-    def trans(self, command: str) -> str:
+    def trans(self, command: str) -> bytes:
         """Sends a single command to the device controller and block until a response from the controller.
 
         This is seen as a transaction.
@@ -221,7 +282,7 @@ class DAQ6510EthernetInterface(DeviceConnectionInterface, DeviceTransport):
         try:
             # Attempt to send the complete command
 
-            command += "\n" if not command.endswith("\n") else ""
+            command += SEPARATOR_STR if not command.endswith(SEPARATOR_STR) else ""
 
             self._sock.sendall(command.encode())
 
@@ -267,10 +328,7 @@ class DAQ6510EthernetInterface(DeviceConnectionInterface, DeviceTransport):
                     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"
+            return SEPARATOR
         finally:
             self._sock.settimeout(saved_timeout)
 

egse/tempcontrol/keithley/daq6510_mon.py

@@ -1,22 +1,31 @@
 import asyncio
 import datetime
 import json
-import logging
 import signal
 import time
 from asyncio import Task
 from pathlib import Path
 from typing import Any
+from typing import Callable
 from typing import Optional
 
+import typer
 import zmq
 import zmq.asyncio
 
 from egse.device import DeviceConnectionError
 from egse.device import DeviceTimeoutError
+from egse.log import logger
+from egse.settings import Settings
+from egse.system import TyperAsyncCommand
 from egse.tempcontrol.keithley.daq6510_adev import DAQ6510
 
-logger = logging.getLogger("daq6510-mon")
+settings = Settings.load("Keithley DAQ6510")
+
+DAQ_DEV_HOST = settings.get("HOSTNAME")
+DAQ_DEV_PORT = settings.get("PORT")
+
+DAQ_MON_CMD_PORT = 5556
 
 
 class DAQ6510Monitor:
@@ -28,8 +37,8 @@ class DAQ6510Monitor:
     def __init__(
         self,
         daq_hostname: str,
-        daq_port: int = 5025,
-        zmq_port: int = 5556,
+        daq_port: int = DAQ_DEV_PORT,
+        zmq_port: int = DAQ_MON_CMD_PORT,
         log_file: str = "temperature_readings.log",
         channels: list[str] = None,
         poll_interval: float = 60.0,
@@ -60,7 +69,7 @@ class DAQ6510Monitor:
         self.running = False
         self.polling_active = False
         self.daq_interface = None
-        self.command_handlers = {
+        self.command_handlers: dict[str, Callable] = {
             "START_POLLING": self._handle_start_polling,
             "STOP_POLLING": self._handle_stop_polling,
             "SET_INTERVAL": self._handle_set_interval,
@@ -78,6 +87,8 @@ class DAQ6510Monitor:
         self.log_file.parent.mkdir(exist_ok=True, parents=True)
 
         # Create DAQ interface
+        # In this case we use the device itself, no control server. That means
+        # the monitoring must be the only service connecting to the device.
         self.daq_interface = DAQ6510(hostname=daq_hostname, port=daq_port)
 
     async def start(self):
@@ -85,9 +96,12 @@ class DAQ6510Monitor:
         logger.info(f"Starting DAQ6510 Monitoring Service on ZMQ port {self.zmq_port}")
         self.running = True
 
+        def handle_shutdown():
+            asyncio.create_task(self.shutdown())
+
         # Register signal handlers for graceful shutdown
         for sig in (signal.SIGINT, signal.SIGTERM):
-            asyncio.get_event_loop().add_signal_handler(sig, lambda: asyncio.create_task(self.shutdown()))
+            asyncio.get_event_loop().add_signal_handler(sig, handle_shutdown)
 
         # Start the main service tasks
         await asyncio.gather(self.command_listener(), self.connect_daq(), return_exceptions=True)
@@ -101,11 +115,29 @@ class DAQ6510Monitor:
     async def connect_daq(self):
         """Establish connection to the DAQ6510."""
         while self.running:
+            init_commands = [
+                ('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),
+            ]
+
             try:
                 logger.info(f"Connecting to DAQ6510 at {self.daq_hostname}:{self.daq_port}")
                 await self.daq_interface.connect()
                 logger.info("Successfully connected to DAQ6510.")
-                await self.daq_interface.initialize()
+                await self.daq_interface.initialize(commands=init_commands, reset_device=True)
                 logger.info("Successfully initialized DAQ6510 for measurements.")
 
                 # If we were polling before, restart it.
@@ -367,9 +399,9 @@ class DAQ6510Monitor:
 
 
 class DAQMonitorClient:
-    """Simple client for interacting with the DAQ Monitor Service."""
+    """A simple client for interacting with the DAQ Monitor Service."""
 
-    def __init__(self, server_address: str = "localhost", port: int = 5556, timeout: float = 5.0):
+    def __init__(self, server_address: str = "localhost", port: int = DAQ_MON_CMD_PORT, timeout: float = 5.0):
         """Initialize the client.
 
         Args:
@@ -412,7 +444,7 @@ class DAQMonitorClient:
             params: Optional command parameters
 
         Returns:
-            Response from the service
+            Response from the service as a dictionary.
         """
         params = params or {}
         message = {"command": command, "params": params}
@@ -488,8 +520,10 @@ class DAQMonitorClient:
     def get_status(self) -> dict[str, Any]:
         """Get current service status.
 
+        To confirm the status is 'ok', check the response for the key 'status'.
+
         Returns:
-            Status information
+            Status information as dictionary.
         """
         return self._send_command("GET_STATUS")
 
@@ -502,12 +536,19 @@ class DAQMonitorClient:
         return self._send_command("SHUTDOWN")
 
 
-async def main():
+app = typer.Typer(name="daq6510_mon")
+
+
+@app.command(cls=TyperAsyncCommand, name="monitor")
+async def main(log_file: str = "temperature_readings.log"):
+    """
+    Start the DAQ6510 monitoring app in the background.
+    """
     monitor = DAQ6510Monitor(
-        daq_hostname="192.168.68.77",
-        daq_port=5025,
-        zmq_port=5556,
-        log_file="temperature_readings.log",
+        daq_hostname=DAQ_DEV_HOST,
+        daq_port=DAQ_DEV_PORT,
+        zmq_port=DAQ_MON_CMD_PORT,
+        log_file=log_file,
         channels=["101", "102"],
         poll_interval=10.0,
     )
@@ -516,9 +557,4 @@ async def main():
 
 
 if __name__ == "__main__":
-    logging.basicConfig(
-        level=logging.DEBUG,
-        format="[%(asctime)s] %(threadName)-12s %(levelname)-8s %(name)-12s %(lineno)5d:%(module)-20s %(message)s",
-    )
-
-    asyncio.run(main())
+    asyncio.run(app())

egse/tempcontrol/keithley/daq6510_protocol.py

@@ -1,21 +1,20 @@
 import logging
+from pathlib import Path
 
 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.setup import load_setup
-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_dev import DAQ6510Command
 from egse.zmq_ser import bind_address
 
-COMMAND_SETTINGS = Settings.load(filename="daq6510.yaml")
+HERE = Path(__file__).parent
+
+COMMAND_SETTINGS = Settings.load(location=HERE, filename="daq6510.yaml")
 
 MODULE_LOGGER = logging.getLogger(__name__)
 
@@ -28,13 +27,9 @@ class DAQ6510Protocol(CommandProtocol):
             control_server: Control Server for which to send out status and monitoring information
         """
 
-        super().__init__()
-        self.control_server = control_server
+        super().__init__(control_server)
 
-        if Settings.simulation_mode():
-            self.daq = DAQ6510Simulator()
-        else:
-            self.daq = DAQ6510Controller()
+        self.daq = DAQ6510Controller()
 
         try:
             self.daq.connect()
@@ -47,16 +42,12 @@ class DAQ6510Protocol(CommandProtocol):
         setup = load_setup()
         self.channels = setup.gse.DAQ6510.channels
 
-        self.hk_conversion_table = read_conversion_dict(self.control_server.get_storage_mnemonic(), setup=setup)
-
-        self.synoptics = SynopticsManagerProxy()
-        self.metrics = define_metrics(origin="DAS-DAQ6510", use_site=True, setup=setup)
-
     def get_bind_address(self) -> str:
-        """Returns a string with the bind address, the endpoint, for accepting connections and bind a socket to.
-
+        """
+        Returns a string with the bind address, the endpoint, for accepting connections and bind a socket to.
 
-        Returns: String with the protocol and port to bind a socket to.
+        Returns:
+            String with the protocol and port to bind a socket to.
         """
 
         return bind_address(
@@ -65,34 +56,26 @@ class DAQ6510Protocol(CommandProtocol):
         )
 
     def get_status(self) -> dict:
-        """Returns a dictionary with status information for the Control Server and the DAQ6510.
+        """
+        Returns a dictionary with status information for the Control Server and the DAQ6510.
 
-        Returns: Dictionary with status information for the Control Server and the DAQ6510.
+        Returns:
+            Dictionary with status information for the Control Server and the DAQ6510.
         """
 
         return super().get_status()
 
     def get_housekeeping(self) -> dict:
-        """Returns a dictionary with housekeeping information about the DAQ6510.
+        """
+        Returns a dictionary with housekeeping information about the DAQ6510.
 
-        Returns: Dictionary with housekeeping information about the DAQ6510.
+        Returns:
+            Dictionary with housekeeping information about the DAQ6510.
         """
 
         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) -> None:

egse/tempcontrol/keithley/daq6510_sim.py

@@ -1,21 +1,32 @@
-from __future__ import annotations
-
 import contextlib
 import datetime
-import logging
 import re
 import socket
 import time
+from functools import partial
+from typing import Annotated
 
 import typer
+
+from egse.env import bool_env
+from egse.log import logging
 from egse.settings import Settings
 from egse.system import SignalCatcher
 
-logger = logging.getLogger("daq6510-sim")
+logger = logging.getLogger("egse.daq6510-sim")
 
+VERSION = "0.1.0"
+VERBOSE_DEBUG = bool_env("VERBOSE_DEBUG")
 HOST = "localhost"
 DAQ_SETTINGS = Settings.load("Keithley DAQ6510")
 
+READ_TIMEOUT = 2.0
+"""The timeout set on the connection socket, applicable when reading from the socket with `recv`."""
+CONNECTION_TIMEOUT = 2.0
+"""The timeout set on the socket before accepting a connection."""
+
+SEPARATOR = b"\n"
+SEPARATOR_STR = SEPARATOR.decode()
 
 device_time = datetime.datetime.now(datetime.timezone.utc)
 reference_time = device_time
@@ -23,8 +34,8 @@ reference_time = device_time
 
 app = typer.Typer(help="DAQ6510 Simulator")
 
-error_msg: str | None = None
-"""Global error message, always contains the last error. Reset in the inner loop of run_simulator."""
+error_msg: str = ""
+"""Global error message, always contains the last error. Reset to an empty string in the inner loop of run_simulator."""
 
 
 def create_datetime(year, month, day, hour, minute, second):
@@ -62,8 +73,14 @@ def reset():
     logger.info("RESET")
 
 
+def log(level: int, msg: str):
+    logger.log(level, msg)
+
+
 COMMAND_ACTIONS_RESPONSES = {
-    "*IDN?": (None, "KEITHLEY INSTRUMENTS, MODEL DAQ6510, SIMULATOR"),
+    "*IDN?": (None, f"KEITHLEY INSTRUMENTS,DAQ6510,SIMULATOR,{VERSION}"),
+    "*ACTION-RESPONSE?": (partial(log, logging.INFO, "Requested action with response."), get_time),
+    "*ACTION-NO-RESPONSE": (partial(log, logging.INFO, "Requested action without response."), None),
 }
 
 # Check the regex at https://regex101.com
@@ -79,65 +96,105 @@ COMMAND_PATTERNS_ACTIONS_RESPONSES = {
 
 
 def write(conn, response: str):
-    response = f"{response}\n".encode()
-    logger.debug(f"write: {response = }")
+    response = f"{response}{SEPARATOR_STR}".encode()
+    if VERBOSE_DEBUG:
+        logger.debug(f"write: {response = }")
     conn.sendall(response)
 
 
+# Keep a receive buffer per connection
+_recv_buffers: dict[int, bytes] = {}
+
+
 def read(conn) -> str:
     """
-    Reads one command string from the socket, i.e. until a linefeed ('\n') is received.
-
-    Returns:
-        The command string with the linefeed stripped off.
+    Read bytes from `conn` until a `SEPARATOR` is found (or connection closed / timeout).
+    Returns the first chunk (separator stripped). Any bytes after the separator are kept
+    in a per-connection buffer for the next call.
     """
-
-    n_total = 0
-    buf_size = 1024 * 4
-    command_string = bytes()
+    fileno = conn.fileno()
+    buf = _recv_buffers.get(fileno, b"")
 
     try:
-        for _ in range(100):
-            data = conn.recv(buf_size)
-            n = len(data)
-            n_total += n
-            command_string += data
-            # if data.endswith(b'\n'):
-            if n < buf_size:
-                break
+        while True:
+            # If we already have a full line in the buffer, split and return it.
+            if SEPARATOR in buf:
+                line, rest = buf.split(SEPARATOR, 1)
+                _recv_buffers[fileno] = rest
+                logger.info(f"read: {line=}")
+                return line.decode().rstrip()
+
+            # Read more data
+            data = conn.recv(1024 * 4)
+            if not data:
+                # Connection closed by peer; return whatever we have (may be empty)
+                _recv_buffers.pop(fileno, None)
+                logger.info(f"read (connection closed): {buf=}")
+                return buf.decode().rstrip()
+            buf += data
+            _recv_buffers[fileno] = buf
+
     except socket.timeout:
-        # This timeout is caught at the caller, where the timeout is set.
+        # If we have accumulated data without a separator, return it (partial read),
+        # otherwise propagate the timeout so caller can handle/suppress it.
+        if buf:
+            _recv_buffers[fileno] = buf
+            logger.info(f"read (timeout, partial): {buf=}")
+            return buf.decode().rstrip()
         raise
 
-    logger.info(f"read: {command_string=}")
-
-    return command_string.decode().rstrip()
-
 
-def process_command(command_string: str) -> str:
+def process_command(command_string: str) -> str | None:
+    """Process the given command string and return a response."""
     global COMMAND_ACTIONS_RESPONSES
     global COMMAND_PATTERNS_ACTIONS_RESPONSES
     global error_msg
 
-    # LOGGER.debug(f"{command_string=}")
+    if VERBOSE_DEBUG:
+        logger.debug(f"{command_string=}")
 
     try:
         action, response = COMMAND_ACTIONS_RESPONSES[command_string]
-        action and action()
-        if error_msg:
-            return error_msg
+        if VERBOSE_DEBUG:
+            logger.debug(f"{action=}, {response=}")
+
+        if action:
+            action()
+
+        if response:
+            if error_msg:
+                return error_msg
+            else:
+                return response() if callable(response) else response
         else:
-            return response if isinstance(response, str) else response()
+            if error_msg:
+                logger.error(f"Error occurred during process command: {error_msg}")
+            return None
     except KeyError:
         # try to match with a value
         for key, value in COMMAND_PATTERNS_ACTIONS_RESPONSES.items():
             if match := re.match(key, command_string, flags=re.IGNORECASE):
-                # LOGGER.debug(f"{match=}, {match.groups()}")
+                if VERBOSE_DEBUG:
+                    logger.debug(f"{match=}, {match.groups()}")
                 action, response = value
-                # LOGGER.debug(f"{action=}, {response=}")
-                action and action(*match.groups())
-                return error_msg or (response if isinstance(response, str) or response is None else response())
-        return f"ERROR: unknown command string: {command_string}"
+                if VERBOSE_DEBUG:
+                    logger.debug(f"{action=}, {response=}")
+
+                if action:
+                    action(*match.groups())
+
+                if response:
+                    if error_msg:
+                        return error_msg
+                    else:
+                        return response() if callable(response) else response
+                else:
+                    if error_msg:
+                        logger.error(f"Error occurred during process command: {error_msg}")
+                    return None
+
+        logger.error(f"ERROR: unknown command string: {command_string}")
+        return None
 
 
 def run_simulator():
@@ -150,7 +207,7 @@ def run_simulator():
     with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
         s.bind((HOST, DAQ_SETTINGS.PORT))
         s.listen()
-        s.settimeout(2.0)
+        s.settimeout(CONNECTION_TIMEOUT)
         while True:
             while True:
                 with contextlib.suppress(socket.timeout):
@@ -161,13 +218,17 @@ def run_simulator():
             with conn:
                 logger.info(f"Accepted connection from {addr}")
                 write(conn, "This is PLATO DAQ6510 X.X.sim")
-                conn.settimeout(2.0)
+                conn.settimeout(READ_TIMEOUT)
                 try:
                     while True:
                         error_msg = ""
                         with contextlib.suppress(socket.timeout):
                             data = read(conn)
-                            logger.info(f"{data = }")
+                            if VERBOSE_DEBUG:
+                                logger.debug(f"{data = }")
+                            if not data:
+                                logger.info("Client closed connection, accepting new connection...")
+                                break
                             if data.strip() == "STOP":
                                 logger.info("Client requested to terminate...")
                                 s.close()
@@ -176,9 +237,6 @@ def run_simulator():
                                 response = process_command(cmd.strip())
                                 if response is not None:
                                     write(conn, response)
-                            if not data:
-                                logger.info("Client closed connection, accepting new connection...")
-                                break
                         if killer.term_signal_received:
                             logger.info("Terminating...")
                             s.close()
@@ -196,20 +254,20 @@ def run_simulator():
                     logger.info(f"{exc.__class__.__name__} caught: {exc.args}")
 
 
-def send_request(cmd: str, type_: str = "query"):
-    from egse.tempcontrol.keithley.daq6510_dev import DAQ6510EthernetInterface
+def send_request(cmd: str, cmd_type: str = "query") -> str | None:
+    from egse.tempcontrol.keithley.daq6510_dev import DAQ6510
 
     response = None
 
-    daq_dev = DAQ6510EthernetInterface(hostname="localhost", port=5025)
+    daq_dev = DAQ6510(hostname="localhost", port=5025)
     daq_dev.connect()
 
-    if type_.lower().strip() == "query":
+    if cmd_type.lower().strip() == "query":
         response = daq_dev.query(cmd)
-    elif type_.lower().strip() == "write":
+    elif cmd_type.lower().strip() == "write":
         daq_dev.write(cmd)
     else:
-        logger.info(f"Unknown type {type_} for send_request.")
+        logger.info(f"Unknown command type {cmd_type} for send_request.")
 
     daq_dev.disconnect()
 
@@ -234,15 +292,14 @@ def stop():
 
 
 @app.command()
-def command(type_: str, cmd: str):
-    response = send_request(cmd, type_)
+def command(
+    cmd: str,
+    cmd_type: Annotated[str, typer.Argument(help="either 'write', 'query'")] = "query",
+):
+    """Send an SCPI command directly to the simulator. The response will be in the log info."""
+    response = send_request(cmd, cmd_type)
     logger.info(f"{response}")
 
 
 if __name__ == "__main__":
-    logging.basicConfig(
-        level=logging.DEBUG,
-        format="%(asctime)s  %(threadName)-12s %(levelname)-8s %(name)-12s %(module)-20s %(message)s",
-    )
-
     app()

keithley_tempcontrol/cgse_services.py

@@ -2,14 +2,13 @@
 #
 import subprocess
 import sys
-from pathlib import Path
 
 import rich
 import typer
 
-daq6510 = typer.Typer(
-    name="daq6510", help="DAQ6510 Data Acquisition Unit, Keithley, temperature monitoring", no_args_is_help=True
-)
+from egse.system import redirect_output_to_log
+
+daq6510 = typer.Typer(name="daq6510", help="DAQ6510 Data Acquisition Unit, Keithley, temperature monitoring")
 
 
 @daq6510.command(name="start")
@@ -17,19 +16,39 @@ def start_daq6510():
     """Start the daq6510 service."""
     rich.print("Starting service daq6510")
 
+    out = redirect_output_to_log("daq6510_cs.start.log")
+
+    subprocess.Popen(
+        [sys.executable, "-m", "egse.tempcontrol.keithley.daq6510_cs", "start"],
+        stdout=out,
+        stderr=out,
+        stdin=subprocess.DEVNULL,
+        close_fds=True,
+    )
+
 
 @daq6510.command(name="stop")
 def stop_daq6510():
     """Stop the daq6510 service."""
     rich.print("Terminating service daq6510")
 
+    out = redirect_output_to_log("daq6510_cs.stop.log")
+
+    subprocess.Popen(
+        [sys.executable, "-m", "egse.tempcontrol.keithley.daq6510_cs", "stop"],
+        stdout=out,
+        stderr=out,
+        stdin=subprocess.DEVNULL,
+        close_fds=True,
+    )
+
 
 @daq6510.command(name="status")
 def status_daq6510():
     """Print status information on the daq6510 service."""
 
     proc = subprocess.Popen(
-        [sys.executable, "-m", "egse.tempcontrol.keithley.daq6510_sim", "status"],
+        [sys.executable, "-m", "egse.tempcontrol.keithley.daq6510_cs", "status"],
         stdout=subprocess.PIPE,
         stderr=subprocess.PIPE,
         stdin=subprocess.DEVNULL,
@@ -47,7 +66,7 @@ def start_daq6510_sim():
     """Start the DAQ6510 Simulator."""
     rich.print("Starting service DAQ6510 Simulator")
 
-    out = open(Path("~/.daq6510_sim.start.out").expanduser(), "w")
+    out = redirect_output_to_log("daq6510_sim.start.log")
 
     subprocess.Popen(
         [sys.executable, "-m", "egse.tempcontrol.keithley.daq6510_sim", "start"],
@@ -63,7 +82,7 @@ def stop_daq6510_sim():
     """Stop the DAQ6510 Simulator."""
     rich.print("Terminating the DAQ6510 simulator.")
 
-    out = open(Path("~/.daq6510_sim.stop.out").expanduser(), "w")
+    out = redirect_output_to_log("daq6510_sim.stop.log")
 
     subprocess.Popen(
         [sys.executable, "-m", "egse.tempcontrol.keithley.daq6510_sim", "stop"],

{keithley_tempcontrol-0.17.3.dist-info → keithley_tempcontrol-0.17.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: keithley-tempcontrol
-Version: 0.17.3
+Version: 0.17.4
 Summary: Keithley Temperature Control for CGSE
 Author: IvS KU Leuven
 Maintainer-email: Rik Huygen <rik.huygen@kuleuven.be>, Sara Regibo <sara.regibo@kuleuven.be>

keithley_tempcontrol-0.17.4.dist-info/RECORD

@@ -0,0 +1,17 @@
+egse/tempcontrol/keithley/__init__.py,sha256=QMm0vy6OMqzWmJZ1K6IwKSOpgYeCmUdbcRhv75LH9ZY,130
+egse/tempcontrol/keithley/daq6510.py,sha256=pe12HIC2Yav5ZCGYecoQzhypYcCwecEaJpWZn-OHi8A,24867
+egse/tempcontrol/keithley/daq6510.yaml,sha256=dHHVNyUpOQpdrZpnxPbT6slsl-8Gbnhifj4Q8QOfOYg,4400
+egse/tempcontrol/keithley/daq6510_adev.py,sha256=Pp5U6a0FrUs1TFLqzvGQHhb3vfw6bhtAt4uX0OVRjBI,2263
+egse/tempcontrol/keithley/daq6510_cs.py,sha256=Ga7z8S6z0oTxL_qQP8FXPaNKlJ6o9RrsPFOXeIJ2TT4,7700
+egse/tempcontrol/keithley/daq6510_dev.py,sha256=EKFFDhP8-FdIPBPosc1DfzE3h4DQmNU1d0Fi7Yhx4I4,12906
+egse/tempcontrol/keithley/daq6510_mon.py,sha256=Xbn2U-l9uxPwNN1-aYW72oJodL2sx13suCiPPbDSti0,20932
+egse/tempcontrol/keithley/daq6510_protocol.py,sha256=v8FUrxEm7bnRzM_iQzW0mMCHTgAMZw4f2Ronl8fdKIE,2676
+egse/tempcontrol/keithley/daq6510_sim.py,sha256=Ys5jroT-2i-V_qCR0L6yOYM9CiktnNbB3LvVLGwaD8A,9917
+keithley_tempcontrol/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+keithley_tempcontrol/cgse_explore.py,sha256=y_FkFxJW0vdqGNp9yTU0ELBKxby74-ev3fTuf99Vl1s,400
+keithley_tempcontrol/cgse_services.py,sha256=tndviv2rvygkNSsGy1oA43VfFpyVkdB9If-9sVlLbK4,2466
+keithley_tempcontrol/settings.yaml,sha256=wbrgSZQAdqFl6AxiLJIN36UsdiVHQCzdsgi7Hs7dv7o,1467
+keithley_tempcontrol-0.17.4.dist-info/METADATA,sha256=D8Uz0pSzzRUVMpVz05Uhy-4l_u21GF-eryb17PkqhZs,962
+keithley_tempcontrol-0.17.4.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+keithley_tempcontrol-0.17.4.dist-info/entry_points.txt,sha256=_0j2BwcwPi4LlRrhvEWfp9GO9KT8WhCkJe2gFgMzOPs,491
+keithley_tempcontrol-0.17.4.dist-info/RECORD,,

keithley_tempcontrol-0.17.3.dist-info/RECORD

@@ -1,17 +0,0 @@
-egse/tempcontrol/keithley/__init__.py,sha256=QMm0vy6OMqzWmJZ1K6IwKSOpgYeCmUdbcRhv75LH9ZY,130
-egse/tempcontrol/keithley/daq6510.py,sha256=QA3K0xJ_-bsY6D4jzOyeDHz1uYSrgf8Z8O-9RynCB5E,24711
-egse/tempcontrol/keithley/daq6510.yaml,sha256=dHHVNyUpOQpdrZpnxPbT6slsl-8Gbnhifj4Q8QOfOYg,4400
-egse/tempcontrol/keithley/daq6510_adev.py,sha256=kodJGonsy_whr15XbVC5CA94mMqm1036FGK0DXmZtxo,3482
-egse/tempcontrol/keithley/daq6510_cs.py,sha256=YVmUtEkGZ0ZKQ7BtvloL_da_fSy_rVr0EB1V2SjLdq0,6089
-egse/tempcontrol/keithley/daq6510_dev.py,sha256=ZjzDU3x7XYRLRoNK9lcqE-t32XDMt0IHW26GO87xt98,10780
-egse/tempcontrol/keithley/daq6510_mon.py,sha256=uox4IaHKwC_hXDQpj4sGEnZyK-dKXjqQdZ2yiaCbt_c,19103
-egse/tempcontrol/keithley/daq6510_protocol.py,sha256=fdcJxsOFYaEDVIY4XzLVC4PSIAL20gKj8os8f0nsSh4,3655
-egse/tempcontrol/keithley/daq6510_sim.py,sha256=GHC7NY2NZ5fm20AjMx7glSGWY1OOynndHUnCPcs5MZM,7568
-keithley_tempcontrol/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-keithley_tempcontrol/cgse_explore.py,sha256=y_FkFxJW0vdqGNp9yTU0ELBKxby74-ev3fTuf99Vl1s,400
-keithley_tempcontrol/cgse_services.py,sha256=H62jEzwRQMvKjkefFw9mSQTYRnT8ga_-SdJ26gPaUE8,1960
-keithley_tempcontrol/settings.yaml,sha256=wbrgSZQAdqFl6AxiLJIN36UsdiVHQCzdsgi7Hs7dv7o,1467
-keithley_tempcontrol-0.17.3.dist-info/METADATA,sha256=JhlNFJaYoCoFBeh8A3boUq3XSNPLxJs72_0NrW7BgcY,962
-keithley_tempcontrol-0.17.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-keithley_tempcontrol-0.17.3.dist-info/entry_points.txt,sha256=_0j2BwcwPi4LlRrhvEWfp9GO9KT8WhCkJe2gFgMzOPs,491
-keithley_tempcontrol-0.17.3.dist-info/RECORD,,