keithley-tempcontrol 0.17.2__tar.gz → 0.17.3__tar.gz

{keithley_tempcontrol-0.17.2 → keithley_tempcontrol-0.17.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: keithley-tempcontrol
-Version: 0.17.2
+Version: 0.17.3
 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.2 → keithley_tempcontrol-0.17.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "keithley-tempcontrol"
-version = "0.17.2"
+version = "0.17.3"
 description = "Keithley Temperature Control for CGSE"
 authors = [
     {name = "IvS KU Leuven"}

{keithley_tempcontrol-0.17.2 → keithley_tempcontrol-0.17.3}/src/egse/tempcontrol/keithley/daq6510.py

@@ -1,40 +1,33 @@
 import logging
 import re
 from pathlib import Path
-from typing import Dict
+from typing import Dict, Union
 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.log import logger
-from egse.mixin import CommandType
-from egse.mixin import DynamicCommandMixin
+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.settings import Settings
-from egse.tempcontrol.keithley.daq6510_dev import DAQ6510
+from egse.tempcontrol.keithley.daq6510_dev import DAQ6510EthernetInterface
+from egse.zmq_ser import connect_address
+
+logger = logging.getLogger(__name__)
 
 HERE = Path(__file__).parent
 
-cs_settings = Settings.load("Keithley Control Server")
-dev_settings = Settings.load("Keithley DAQ6510")
+CTRL_SETTINGS = Settings.load("Keithley Control Server")
+FW_SETTINGS = Settings.load("Keithley DAQ6510")
+DEVICE_SETTINGS = Settings.load(location=HERE, filename="daq6510.yaml")
 
-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):
     """
@@ -42,7 +35,7 @@ class DAQ6510Interface(DeviceInterface):
     """
 
     @dynamic_interface
-    def send_command(self, command: str, response: bool) -> str | None:
+    def send_command(self, command: str, response: bool) -> Union[None, str]:
         """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].
@@ -226,12 +219,12 @@ class DAQ6510Controller(DAQ6510Interface, DynamicCommandMixin):
     through an Ethernet interface.
     """
 
-    def __init__(self, hostname: str = DEV_HOST, port: int = DEV_PORT):
+    def __init__(self, hostname: str = FW_SETTINGS.HOSTNAME, port: int = FW_SETTINGS.PORT):
         """Opens a TCP/IP socket connection with the Keithley DAQ6510 Hardware.
 
         Args:
-            hostname (str): IP address or fully qualified hostname of the DAQ6510 hardware controller.
-                The default is defined in the ``settings.yaml`` configuration file.
+            hostname (str): IP address or fully qualified hostname of the Hexapod 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:
@@ -242,7 +235,7 @@ class DAQ6510Controller(DAQ6510Interface, DynamicCommandMixin):
 
         logger.debug(f"Initializing the DAQ6510 Controller with hostname={hostname} on port={port}")
 
-        self.daq = self.transport = DAQ6510(hostname, port)
+        self.daq = self.transport = DAQ6510EthernetInterface(hostname, port)
 
         # We set the default buffer here, this can be changed with the `create_buffer()` method.
 
@@ -284,7 +277,7 @@ class DAQ6510Controller(DAQ6510Interface, DynamicCommandMixin):
 
         return self.daq.is_connected()
 
-    def send_command(self, command: str, response: bool) -> str | None:
+    def send_command(self, command: str, response: bool) -> Union[None, str]:
         """Sends an SCPI command to the device.
 
         The valid commands are described in the DAQ6510 Reference Manual [DAQ6510-901-01 Rev. B / September 2019].
@@ -299,7 +292,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:
@@ -573,10 +566,10 @@ class DAQ6510Proxy(Proxy, DAQ6510Interface):
 
     def __init__(
         self,
-        protocol: str = PROTOCOL,
-        hostname: str = HOSTNAME,
-        port: int = COMMANDING_PORT,
-        timeout: float = TIMEOUT,  # Timeout [s]: > scan count * interval + (one scan duration)
+        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)
     ):
         """Initialisation of a DAQ6510Proxy.
 
@@ -585,12 +578,10 @@ 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 (float): Timeout by which to establish the connection [s]
+            timeout (int): Timeout by which to establish the connection [ms]
         """
 
-        endpoint = get_endpoint(SERVICE_TYPE, protocol, hostname, port)
-
-        super().__init__(endpoint, timeout=timeout)
+        super().__init__(connect_address(protocol, hostname, port), timeout=timeout)
 
 
 def create_channel_list(*args) -> str:

keithley_tempcontrol-0.17.3/src/egse/tempcontrol/keithley/daq6510_adev.py

@@ -0,0 +1,97 @@
+import asyncio
+import logging
+from typing import Any
+from typing import Dict
+from typing import Optional
+
+from egse.scpi import AsyncSCPIInterface
+
+logger = logging.getLogger(__name__)
+
+
+class DAQ6510(AsyncSCPIInterface):
+    """Keithley DAQ6510 specific implementation."""
+
+    def __init__(self, hostname: str, port: int = 5025, settings: Optional[Dict[str, Any]] = None):
+        """Initialize a Keithley DAQ6510 interface.
+
+        Args:
+            hostname: Hostname or IP address
+            port: TCP port (default 5025 for SCPI)
+            settings: Additional device settings
+        """
+        super().__init__(
+            device_name="DAQ6510",
+            hostname=hostname,
+            port=port,
+            settings=settings,
+            id_validation="DAQ6510",  # 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.
+
+        Args:
+            channel: Channel to measure (e.g., "101")
+
+        Returns:
+            The measured value as a float
+        """
+        async with self._measurement_lock:
+            cmd = "INIT:IMM"
+            logger.info(f"Sending {cmd}...")
+            await self.write(cmd)
+            cmd = "*WAI"
+            logger.info(f"Sending {cmd}...")
+            await self.write(cmd)
+
+            if channel == "101":
+                start_index = end_index = 1
+            elif channel == "102":
+                start_index = end_index = 2
+            else:
+                return float("nan")
+
+            response = (
+                (await self.trans(f'TRAC:DATA? {start_index}, {end_index}, "test1", CHAN, TST, READ')).decode().strip()
+            )
+
+            logger.info(f"{response = }")
+
+            ch, tst, val = response.split(",")
+
+            logger.info(f"Channel: {ch} Time: {tst} Value: {float(val):.4f}")
+
+            return float(val)

{keithley_tempcontrol-0.17.2 → keithley_tempcontrol-0.17.3}/src/egse/tempcontrol/keithley/daq6510_cs.py

@@ -1,29 +1,22 @@
+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
 
-cs_settings = Settings.load("Keithley Control Server")
+logger = logging.getLogger(__name__)
 
-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")
+CTRL_SETTINGS = Settings.load("Keithley Control Server")
 
 
 def is_daq6510_cs_active(timeout: float = 0.5) -> bool:
@@ -35,14 +28,7 @@ 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.
     """
 
-    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)
+    endpoint = connect_address(CTRL_SETTINGS.PROTOCOL, CTRL_SETTINGS.HOSTNAME, CTRL_SETTINGS.COMMANDING_PORT)
 
     return is_control_server_active(endpoint, timeout)
 
@@ -76,15 +62,13 @@ 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 cs_settings.PROTOCOL
+        return CTRL_SETTINGS.PROTOCOL
 
     def get_commanding_port(self) -> int:
         """Returns the commanding port used by the Control Server.
@@ -92,7 +76,7 @@ class DAQ6510ControlServer(ControlServer):
         Returns: Commanding port used by the Control Server, as specified in the settings.
         """
 
-        return cs_settings.COMMANDING_PORT
+        return CTRL_SETTINGS.COMMANDING_PORT
 
     def get_service_port(self):
         """Returns the service port used by the Control Server.
@@ -100,7 +84,7 @@ class DAQ6510ControlServer(ControlServer):
         Returns: Service port used by the Control Server, as specified in the settings.
         """
 
-        return cs_settings.SERVICE_PORT
+        return CTRL_SETTINGS.SERVICE_PORT
 
     def get_monitoring_port(self):
         """Returns the monitoring port used by the Control Server.
@@ -108,7 +92,7 @@ class DAQ6510ControlServer(ControlServer):
         Returns: Monitoring port used by the Control Server, as specified in the settings.
         """
 
-        return cs_settings.MONITORING_PORT
+        return CTRL_SETTINGS.MONITORING_PORT
 
     def get_storage_mnemonic(self):
         """Returns the storage mnemonics used by the Control Server.
@@ -120,88 +104,57 @@ class DAQ6510ControlServer(ControlServer):
                  settings, "DAQ6510" will be used.
         """
 
-        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())
+        try:
+            return CTRL_SETTINGS.STORAGE_MNEMONIC
+        except AttributeError:
+            return "DAQ6510"
 
     def before_serve(self):
         """Steps to take before the Control Server is activated."""
 
+        start_http_server(CTRL_SETTINGS.METRICS_PORT)
+
 
-app = typer.Typer(name="daq6510_cs")
+@click.group()
+def cli():
+    pass
 
 
-@app.command()
+@cli.command()
 def start():
     """Starts the Keithley DAQ6510 Control Server."""
 
     multiprocessing.current_process().name = "daq6510_cs (start)"
 
-    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}.")
+    try:
+        control_server = DAQ6510ControlServer()
+        control_server.serve()
+    except KeyboardInterrupt:
+        logger.debug("Shutdown requested...exiting")
+    except SystemExit as exit_code:
+        logger.debug("System Exit with code {}.".format(exit_code))
+        sys.exit(exit_code)
+    except Exception:
+        msg = "Cannot start the DAQ6510 Control Server"
+        logger.exception(msg)
+        rich.print(f"[red]{msg}.")
 
     return 0
 
 
-@app.command()
+@cli.command()
 def start_bg():
     """Starts the DAQ6510 Control Server in the background."""
 
-    print("Starting the DAQ6510 in the background is not implemented.")
+    invoke.run("daq6510_cs start", disown=True)
 
 
-@app.command()
+@cli.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()
@@ -212,17 +165,17 @@ def stop():
         rich.print(f"[red]{msg}, could not send the Quit command. [black]Check log messages.")
 
 
-@app.command()
+@cli.command()
 def status():
     """Requests status information from the Control Server."""
 
     multiprocessing.current_process().name = "daq6510_cs (status)"
 
-    from egse.env import setup_env
+    protocol = CTRL_SETTINGS.PROTOCOL
+    hostname = CTRL_SETTINGS.HOSTNAME
+    port = CTRL_SETTINGS.COMMANDING_PORT
 
-    setup_env()
-
-    endpoint = get_endpoint(SERVICE_TYPE, PROTOCOL, HOSTNAME, COMMANDING_PORT)
+    endpoint = connect_address(protocol, hostname, port)
 
     if is_control_server_active(endpoint):
         rich.print("DAQ6510 CS: [green]active")
@@ -237,4 +190,6 @@ def status():
 
 
 if __name__ == "__main__":
-    sys.exit(app())
+    logging.basicConfig(level=logging.DEBUG, format=Settings.LOG_FORMAT_FULL)
+
+    sys.exit(cli())

{keithley_tempcontrol-0.17.2 → keithley_tempcontrol-0.17.3}/src/egse/tempcontrol/keithley/daq6510_dev.py

@@ -1,30 +1,23 @@
-__all__ = [
-    "DAQ6510",
-    "DAQ6510Command",
-]
+import logging
 import socket
 import time
 
 from egse.command import ClientServerCommand
 from egse.device import DeviceConnectionError
+from egse.device import DeviceConnectionInterface
 from egse.device import DeviceError
-from egse.device import 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
 
-IDENTIFICATION_QUERY = "*IDN?"
-
-dev_settings = Settings.load("Keithley DAQ6510")
+logger = logging.getLogger(__name__)
 
-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)
+IDENTIFICATION_QUERY = "*IDN?"
 
-SEPARATOR = b"\n"
-SEPARATOR_STR = SEPARATOR.decode()
+DEVICE_SETTINGS = Settings.load("Keithley DAQ6510")
+DEVICE_NAME = "DAQ6510"
+READ_TIMEOUT = DEVICE_SETTINGS.TIMEOUT  # [s], can be smaller than timeout (for DAQ6510Proxy) (e.g. 1s)
 
 
 class DAQ6510Command(ClientServerCommand):
@@ -39,13 +32,13 @@ class DAQ6510Command(ClientServerCommand):
         """
 
         out = super().get_cmd_string(*args, **kwargs)
-        return out + SEPARATOR_STR
+        return out + "\n"
 
 
-class DAQ6510(DeviceInterface, DeviceTransport):
+class DAQ6510EthernetInterface(DeviceConnectionInterface, DeviceTransport):
     """Defines the low-level interface to the Keithley DAQ6510 Controller."""
 
-    def __init__(self, hostname: str = DEV_HOST, port: int = DEV_PORT):
+    def __init__(self, hostname: str = None, port: int = None):
         """Initialisation of an Ethernet interface for the DAQ6510.
 
         Args:
@@ -55,66 +48,12 @@ class DAQ6510(DeviceInterface, DeviceTransport):
 
         super().__init__()
 
-        self.device_name = DEVICE_NAME
-        self.hostname = hostname
-        self.port = port
+        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 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.
 
@@ -248,7 +187,7 @@ class DAQ6510(DeviceInterface, DeviceTransport):
         """
 
         try:
-            command += SEPARATOR_STR if not command.endswith(SEPARATOR_STR) else ""
+            command += "\n" if not command.endswith("\n") else ""
 
             self._sock.sendall(command.encode())
 
@@ -263,7 +202,7 @@ class DAQ6510(DeviceInterface, DeviceTransport):
                 raise DeviceConnectionError(DEVICE_NAME, msg)
             raise
 
-    def trans(self, command: str) -> bytes:
+    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.
@@ -282,7 +221,7 @@ class DAQ6510(DeviceInterface, DeviceTransport):
         try:
             # Attempt to send the complete command
 
-            command += SEPARATOR_STR if not command.endswith(SEPARATOR_STR) else ""
+            command += "\n" if not command.endswith("\n") else ""
 
             self._sock.sendall(command.encode())
 
@@ -328,7 +267,10 @@ class DAQ6510(DeviceInterface, DeviceTransport):
                     break
         except socket.timeout:
             logger.warning(f"Socket timeout error for {self.hostname}:{self.port}")
-            return SEPARATOR
+            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)