digilent 0.17.4__py3-none-any.whl

egse/digilent/measurpoint/digilent_devif.py

@@ -0,0 +1,278 @@
+import logging
+import socket
+
+import time
+
+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
+
+logger = logging.getLogger(__name__)
+
+IDENTIFICATION_QUERY = "*IDN?"
+
+
+class DigilentEthernetInterface(DeviceConnectionInterface, DeviceTransport):
+    """Defines the low-level interface to the Digilent Controller."""
+
+    def __init__(self, hostname: str, port: int, device_name: str, read_timeout: float = 60):
+        """Initialisation of an Ethernet interface for a Digilent.
+
+        Args:
+            hostname(str): Hostname to which to open a socket.
+            port (int): Port to which to open a socket.
+            device_name (str): Device name to which to open a socket.
+            read_timeout (float): Timeout for reading commands [s].
+        """
+
+        super().__init__()
+
+        self.hostname = hostname
+        self.port = port
+        self._sock = None
+
+        self._is_connection_open = False
+
+        self.device_name = device_name
+        self.read_timeout = read_timeout
+
+    def connect(self) -> None:
+        """Connects to the Digilent hardware.
+
+        Raises:
+            DeviceConnectionError: When the connection could not be established. Check the logging messages for more
+                                   details.
+            DeviceTimeoutError: When the connection timed out.
+            ValueError: When hostname or port number are not provided.
+        """
+
+        # Sanity checks
+
+        if self._is_connection_open:
+            logger.warning(f"{self.device_name}: trying to connect to an already connected socket.")
+            return
+
+        if self.hostname in (None, ""):
+            raise ValueError(f"{self.device_name}: hostname is not initialised.")
+
+        if self.port in (None, 0):
+            raise ValueError(f"{self.device_name}: port number is not initialised.")
+
+        # 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(self.device_name, "Failed to create socket.") from e_socket
+
+        # Attempt to establish a connection to the remote host
+
+        # FIXME: Socket shall be closed on exception?
+
+        # We set a timeout of 3s before connecting and reset to None (=blocking) after the `connect` method has been
+        # called. This is because when no device is available, e.g. during testing, the timeout will take about
+        # two minutes, which is way too long. It needs to be evaluated if this approach is acceptable and not causing
+        # problems during production.
+
+        try:
+            logger.debug(f'Connecting a socket to host "{self.hostname}" using port {self.port}')
+            self._sock.settimeout(3)
+            self._sock.connect((self.hostname, self.port))
+            self._sock.settimeout(None)
+        except ConnectionRefusedError as exc:
+            raise DeviceConnectionError(
+                self.device_name, f"Connection refused to {self.hostname}:{self.port}."
+            ) from exc
+        except TimeoutError as exc:
+            raise DeviceTimeoutError(self.device_name, f"Connection to {self.hostname}:{self.port} timed out.") from exc
+        except socket.gaierror as exc:
+            raise DeviceConnectionError(self.device_name, f"Socket address info error for {self.hostname}") from exc
+        except socket.herror as exc:
+            raise DeviceConnectionError(self.device_name, f"Socket host address error for {self.hostname}") from exc
+        except OSError as exc:
+            raise DeviceConnectionError(self.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(
+                self.device_name, "Device is not connected, check logging messages for the cause."
+            )
+
+    def disconnect(self) -> None:
+        """Disconnects from the Digilent hardware.
+
+        Raises:
+            DeviceConnectionError when the socket could not be closed.
+        """
+
+        try:
+            if self._is_connection_open:
+                logger.debug(f"Disconnecting from {self.hostname}")
+                self._sock.close()
+                self._is_connection_open = False
+        except Exception as e_exc:
+            raise DeviceConnectionError(self.device_name, f"Could not close socket to {self.hostname}") from e_exc
+
+    def reconnect(self):
+        """Reconnects to the Digilent hardware.
+
+        Raises:
+            ConnectionError when the device cannot be reconnected for some reason.
+        """
+
+        if self._is_connection_open:
+            self.disconnect()
+        self.connect()
+
+    def is_connected(self) -> bool:
+        """Checks if the Digilent hardware is connected.
+
+        This will send a query for the device identification and validate the answer.
+
+        Returns: True is the device is connected and answered with the proper ID; False otherwise.
+        """
+
+        if not self._is_connection_open:
+            return False
+
+        try:
+            print(f"Result from identification query: {self.query(IDENTIFICATION_QUERY)}")
+            # noinspection PyTypeChecker
+            manufacturer, model, _, _ = self.query(IDENTIFICATION_QUERY).split(",")
+
+        except DeviceError as exc:
+            logger.exception(exc)
+            logger.error("Most probably the client connection was closed. Disconnecting...")
+            self.disconnect()
+            return False
+
+        if "Data Translation" not in manufacturer or "DT" not in model:
+            logger.error(
+                f'Device did not respond correctly to a "IDN?" command, manufacturer={manufacturer}, model={model}. Disconnecting...'
+            )
+            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(self.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(self.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(self.device_name, msg)
+            raise
+
+    def trans(self, command: str) -> str | bytes:
+        """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 UnicodeError:
+            # noinspection PyUnboundLocalVariable
+            return return_string
+        except socket.timeout as e_timeout:
+            raise DeviceTimeoutError(self.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(self.device_name, "Socket communication error.") from e_socket
+        except ConnectionError as exc:
+            raise DeviceConnectionError(self.device_name, "Connection error.") from exc
+        except AttributeError:
+            if not self._is_connection_open:
+                raise DeviceConnectionError(self.device_name, "Device not connected, use the connect() method.")
+            raise
+
+    def read(self) -> bytes:
+        """Reads from the device buffer.
+
+        Returns: Content of the device buffer.
+        """
+
+        n_total = 0
+        buf_size = 2048
+
+        # Set a timeout of READ_TIMEOUT to the socket.recv
+
+        saved_timeout = self._sock.gettimeout()
+        self._sock.settimeout(self.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)
+
+        # noinspection PyUnboundLocalVariable
+        return data
+
+
+def main():
+    return 0
+
+
+if __name__ == "__main__":
+    main()

egse/digilent/measurpoint/dt8874/__init__.py

@@ -0,0 +1,21 @@
+from pathlib import Path
+
+from egse.settings import Settings
+
+HERE = Path(__file__).parent
+settings = Settings.load("Digilent MEASURpoint DT8874 Control Server")
+
+# General information about the Digilent MEASURpoint DT8874 Control Server
+
+PROCESS_NAME = settings.get("PROCESS_NAME", "dt8874_cs")  # Name under which it is registered in the service registry
+SERVICE_TYPE = settings.get(
+    "SERVICE_TYPE", "dt8874_cs"
+)  # Service type under which it is registered in the service registry
+PROTOCOL = settings.get("PROTOCOL", "tcp")  # Communication protocol
+HOSTNAME = settings.get("HOSTNAME", "localhost")  # Hostname
+COMMANDING_PORT = settings.get("COMMANDING_PORT", 0)  # Commanding port (as per settings or dynamically assigned)
+SERVICE_PORT = settings.get("SERVICE_PORT", 0)  # Service port (as per settings or dynamically assigned)
+MONITORING_PORT = settings.get("MONITORING_PORT", 0)  # Monitoring port (as per settings or dynamically assigned)
+ORIGIN = settings.get("STORAGE_MNEMONIC", "DT8874")  # Storage mnemonic (used in the HK filenames)
+
+PROXY_TIMEOUT = 10

egse/digilent/measurpoint/dt8874/dt8874.py

@@ -0,0 +1,71 @@
+"""Digilent MEASURPOINT DT8874 commanding."""
+
+import logging
+
+from egse.digilent.digilent import DigilentController, DigilentInterface
+from egse.digilent.measurpoint.dt8874 import COMMANDING_PORT, PROTOCOL, HOSTNAME, SERVICE_TYPE, PROXY_TIMEOUT
+from egse.digilent.measurpoint.dt8874.dt8874_devif import Dt8874EthernetInterface
+from egse.proxy import DynamicProxy
+from egse.registry.client import RegistryClient
+from egse.zmq_ser import connect_address
+
+LOGGER = logging.getLogger("egse.digilent.measurpoint.dt8874")
+
+
+class Dt8874Interface(DigilentInterface):
+    """Base class for Digilent MEASURpoint DT8874 instruments."""
+
+
+class Dt8874Controller(DigilentController, Dt8874Interface):
+    def __init__(self):
+        """Initialisation of an Ariel TCU controller."""
+
+        super().__init__()
+
+        self.transport = self.dt8874 = Dt8874EthernetInterface()
+
+
+class Dt8874Simulator(Dt8874Interface):
+    def __init__(self):
+        """Initialisation of a Digilent MEASURpoint DT8874 simulator."""
+
+        super().__init__()
+
+        self._is_pwd_protected_cmds_enabled = True
+
+    def enable_pwd_protected_cmds(self, password: str):
+        self._is_pwd_protected_cmds_enabled = True
+
+    def disable_pwd_protected_cmds(self, password: str):
+        self._is_pwd_protected_cmds_enabled = False
+
+
+class Dt8874Proxy(DynamicProxy, Dt8874Interface):
+    """
+    The Dt8874Proxy class is used to connect to the Digilent MEASURpoint DT8874 Control Server and send commands to
+    the Digilent MEASURpoint DT8874 Hardware Controller remotely.
+    """
+
+    def __init__(self):
+        """Initialisation of a Dt8874Proxy."""
+
+        # Fixed ports -> Use information from settings
+
+        if COMMANDING_PORT != 0:
+            super().__init__(connect_address(PROTOCOL, HOSTNAME, COMMANDING_PORT))
+
+        # Dynamic port allocation -> Use Registry Client
+
+        else:
+            with RegistryClient() as reg:
+                service = reg.discover_service(SERVICE_TYPE)
+
+                if service:
+                    protocol = service.get("protocol", "tcp")
+                    hostname = service["host"]
+                    port = service["port"]
+
+                    super().__init__(connect_address(protocol, hostname, port), timeout=PROXY_TIMEOUT)
+
+                else:
+                    raise RuntimeError(f"No service registered as {SERVICE_TYPE}")

egse/digilent/measurpoint/dt8874/dt8874.yaml

@@ -0,0 +1,43 @@
+BaseClass:
+    egse.digilent.measurpoint.dt8874.Dt8874Interface
+
+ProxyClass:
+    egse.digilent.measurpoint.dt8874.Dt8874Proxy
+
+ControlServerClass:
+    egse.digilent.measurpoint.dt8874.Dt8874ControlServer
+
+ControlServer:
+    egse.digilent.measurpoint.dt8874.dt8874_cs
+
+#UserInterface:
+#    egse.digilent.measurpoint.dt8874.dt8874_ui
+
+Commands:
+
+    # Definition of the DeviceInterface
+
+    is_simulator:
+        description: Ask if the connected class is a simulator instead of the real device Controller class.
+        returns: bool | True if the far end is a simulator instead of the real hardware
+
+    is_connected:
+        description: Check if the Digilent MEASURpoint DT8874 hardware controller is connected.
+
+    connect:
+        description: Connect the Digilent MEASURpoint DT8874 hardware controller
+
+    reconnect:
+        description: Reconnect the Digilent MEASURpoint DT8874 hardware controller.
+            
+            This command will force a disconnect and then try to re-connect to the controller.
+
+    disconnect:
+        description: Disconnect from the Digilent MEASURpoint DT8874 hardware controller.
+            
+            This command will be send to the DT8874 Control Server which will then
+            disconnect from the hardware controller.
+            
+            This command does not affect the ZeroMQ connection of the Proxy to the
+            control server. Use the service command `disconnect_cs()` to disconnect
+            from the control server.