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

egse/tempcontrol/keithley/daq6510_cs.py

@@ -1,22 +1,52 @@
-import logging
+"""
+Keithley DAQ6510 Synchronous Control Server.
+
+This module implements a Control Server to command and monitor a Keithley DAQ6510 Data Acquisition System.
+
+The control server can be started from the command line interface as follows:
+
+    $ daq6510_cs start
+
+It can also be stopped, queried for status information, etc.  Use the --help option to see all available commands:
+
+    $ daq6510_cs --help
+
+Functions:
+
+    is_daq6510_cs_active(timeout: float = 0.5) -> bool
+        Checks if the DAQ6510 Control Server is running.
+Classes:
+    DAQ6510ControlServer(ControlServer)
+        Keithley DAQ6510ControlServer - Command and monitor the Keithley Data Acquisition System.
+
+"""
+
 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 +58,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)
 
@@ -50,7 +87,7 @@ class DAQ6510ControlServer(ControlServer):
     """
 
     def __init__(self):
-        """Initialisation of a DAQ6510 Control Server."""
+        """Initialization of a DAQ6510 Control Server."""
 
         super().__init__()
 
@@ -62,13 +99,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 +115,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 +123,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 +131,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 +143,91 @@ 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)
+    def after_serve(self):
+        self.deregister_service()
 
 
-@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 +238,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
+
+    setup_env()
 
-    endpoint = connect_address(protocol, hostname, port)
+    endpoint = get_endpoint(SERVICE_TYPE, PROTOCOL, HOSTNAME, COMMANDING_PORT)
 
     if is_control_server_active(endpoint):
         rich.print("DAQ6510 CS: [green]active")
@@ -190,6 +263,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,28 @@
-import logging
-import socket
-import time
+__all__ = [
+    "DAQ6510",
+    "DAQ6510Command",
+]
 
 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.env import bool_env
+from egse.log import logger
 from egse.settings import Settings
-from egse.system import Timer
+from egse.socketdevice import SocketDevice
 
-logger = logging.getLogger(__name__)
+VERBOSE_DEBUG = bool_env("VERBOSE_DEBUG")
 
 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", "localhost")
+DEV_PORT = dev_settings.get("PORT", 5025)
+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,134 +37,96 @@ class DAQ6510Command(ClientServerCommand):
         """
 
         out = super().get_cmd_string(*args, **kwargs)
-        return out + "\n"
+        return out + SEPARATOR_STR
 
 
-class DAQ6510EthernetInterface(DeviceConnectionInterface, DeviceTransport):
+class DAQ6510(SocketDevice):
     """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.
+    def __init__(self, hostname: str = DEV_HOST, port: int = DEV_PORT):
+        """Initialization 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) -> None:
-        """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.
-        """
+        super().__init__(hostname, port, separator=SEPARATOR, read_timeout=READ_TIMEOUT)
 
-        # Sanity checks
+    @property
+    def device_name(self) -> str:
+        return DEVICE_NAME
 
-        if self._is_connection_open:
-            logger.warning(f"{DEVICE_NAME}: trying to connect to an already connected socket.")
-            return
+    def initialize(
+        self, commands: list[tuple[str, bool]] | None = None, reset_device: bool = False
+    ) -> list[str | None]:
+        """Initialize the device with optional reset and command sequence.
 
-        if self.hostname in (None, ""):
-            raise ValueError(f"{DEVICE_NAME}: hostname is not initialized.")
+        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.
 
-        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.
+        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.
 
-        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) -> None:
-        """Disconnects from the Ethernet connection.
+        Returns:
+           Response for each of the commands, or None when no response was expected.
 
         Raises:
-            DeviceConnectionError when the socket could not be closed.
+           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
+            )
         """
 
-        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
+        commands = commands or []
+        responses = []
 
-    def reconnect(self):
-        """Reconnects to the device controller.
+        if reset_device:
+            logger.info(f"Resetting the {self.device_name}...")
+            self.write("*RST")  # this also resets the user-defined buffer
 
-        Raises:
-            ConnectionError when the device cannot be reconnected for some reason.
-        """
+        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)
 
-        if self._is_connection_open:
-            self.disconnect()
-        self.connect()
+        return responses
+
+    # FIXME: this device interface might be connecting to a simulator instead of a real device!
+    def is_simulator(self) -> bool:
+        return False
 
     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.
+        Returns:
+            True is the device is connected and answered with the proper ID; False otherwise.
         """
 
-        if not self._is_connection_open:
+        if not self.is_connection_open:
             return False
 
         try:
-            version = self.query(IDENTIFICATION_QUERY)
+            version = self.query(IDENTIFICATION_QUERY).decode().strip()
         except DeviceError as exc:
             logger.exception(exc)
             logger.error("Most probably the client connection was closed. Disconnecting...")
@@ -173,110 +140,10 @@ class DAQ6510EthernetInterface(DeviceConnectionInterface, DeviceTransport):
             self.disconnect()
             return False
 
-        return True
-
-    def write(self, command: str) -> None:
-        """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.
+        if VERBOSE_DEBUG:
+            logger.debug(f"{self.device_name} connection check successful, version: {version}")
 
-        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
+        return True
 
 
 def main():