cgse 2023.38.0__py3-none-any.whl → 2024.1.4__py3-none-any.whl

egse/powermeter/ni/cdaq9184.yaml

@@ -1,73 +0,0 @@
-BaseClass:
-    egse.powermeter.ni.cdaq9184.cdaq9184Interface
-
-ProxyClass:
-    egse.powermeter.ni.cdaq9184.cdaq9184Proxy
-
-ControlServerClass:
-    egse.powermeter.ni.cdaq9184_cs.cdaq9184ControlServer
-
-ControlServer:
-    egse.powermeter.ni.cdaq9184_cs
-
-UserInterface:
-    egse.powermeter.ni.cdaq9184_ui
-
-Commands:
-
-    # Each of these groups is parsed and used on both the server and the client side.
-    # The group name (e.g. is_simulator) will be monkey patched in the Proxy class for the device or service.
-    # The other field are:
-    #   description:   Used by the doc_string method to generate a help string
-    #   cmd:           Command string that will eventually be send to the hardware controller for the
-    #                  device after the arguments have been filled.
-    #   device_method: The name of the method to be called on the device class.
-    #                  These should all be defined by the base class for the device.
-    #                  This method should exist in the subclass of the CommandProtocol base class.
-
-    # Definition of the the DeviceInterface
-
-    disconnect:
-        description: Disconnect from the NI device controller. This command will be send to the
-                       NI Control Server which will then disconnect from the hardware controller.
-                       This command doesn't affect the ZeroMQ connection of this Proxy to the
-                       control server. Use the service command ``disconnect_cs()`` to disconnect
-                       from the control server.
-
-    connect:
-        description:    Connect the temperature hardware controller
-
-    reconnect:
-        description:    Reconnect the temperature hardware controller.
-
-                        This command will force a disconnect and then try to re-connect to the controller.
-
-    is_simulator:
-        description:   Ask if the control server is a simulator instead of the real cdaq9184Controller class.
-        returns:       bool | True if the far end is a simulator instead of the real hardware
-
-    is_connected:
-        description:   Check if the SRS Hardware Controller is connected.
-
-
-    # Definition of the device commands
-    info:
-        description:   Returns basic information about the device, its name, firmwre version etc.
-        returns:       str
-
-
-    read_values:
-        description:   Reads the timestamped signals of the CDAQ9184. Returns all the values with date.
-        returns:       list
-
-    read_photodiodes:
-        description:   À MODIFIER Returns the timestamped and voltage signals from the photodidodes connected to the NI9239.
-                       Returns 2 lists in a tuple, 1st list with mean and 2nd with standard deviation.
-        returns:       dict
-
-    read_temperatures:
-        description:   Returns the timestamped and temperature signals from the PT1000 connected to the NI9226
-                       Returns a dictionary with 2 elements which are lists, 1st list with mean temperature
-                       and 2nd with standard deviation temperature.
-        returns:       dict
-

egse/powermeter/ni/cdaq9184_cs.py

@@ -1,130 +0,0 @@
-import argparse
-import click
-import logging
-import sys
-
-import zmq
-
-from egse.control import ControlServer
-from egse.control import is_control_server_active
-
-from egse.powermeter.ni.cdaq9184 import cdaq9184Proxy
-from egse.powermeter.ni.cdaq9184_protocol import cdaq9184Protocol
-from egse.settings import Settings
-from egse.zmq_ser import connect_address
-
-
-logger = logging.getLogger(__name__)
-
-
-CTRL_SETTINGS = Settings.load("NI Control Server")
-
-def is_cdaq9184_cs_active(timeout: float = 0.5):
-    """Check if the CDAQ9184 Control Server is running.
-
-    Args:
-        timeout (float): timeout when waiting for a reply [seconds, default=0.5]
-    Returns:
-        True if the control server is running and replied with the expected answer.
-    """
-
-    endpoint = connect_address(
-        CTRL_SETTINGS.PROTOCOL, CTRL_SETTINGS.HOSTNAME, CTRL_SETTINGS.CDAQ9184.get("COMMANDING_PORT")
-    )
-
-    return is_control_server_active(endpoint, timeout)
-
-
-class cdaq9184ControlServer(ControlServer):
-    """
-    cdaq9184ControlServer - Command and monitor the NI CDAQ 9184 Controllers.
-    This class works as a command and monitoring server to control the Temp Controller remotely.
-    The sever binds to the following ZeroMQ sockets:
-    * a REQ-REP socket that can be used as a command server. Any client can connect and
-      send a command to the Temp controller.
-    * a PUB-SUP socket that serves as a monitoring server. It will send out Temp status
-      information to all the connected clients every DELAY seconds.
-    """
-
-    def __init__(self):
-        super().__init__()
-
-        self.device_protocol = cdaq9184Protocol(self)
-
-        self.logger.debug(f"Binding ZeroMQ socket to {self.device_protocol.get_bind_address()}")
-
-        self.device_protocol.bind(self.dev_ctrl_cmd_sock)
-
-        self.poller.register(self.dev_ctrl_cmd_sock, zmq.POLLIN)
-
-    def get_communication_protocol(self):
-        return CTRL_SETTINGS.PROTOCOL
-
-    def get_commanding_port(self):
-        return CTRL_SETTINGS.CDAQ9184.get("COMMANDING_PORT")
-
-    def get_service_port(self):
-        return CTRL_SETTINGS.CDAQ9184.get("SERVICE_PORT")
-
-    def get_monitoring_port(self):
-        return CTRL_SETTINGS.CDAQ9184.get("MONITORING_PORT")
-
-    def get_storage_mnemonic(self):
-        try:
-            return CTRL_SETTINGS.CDAQ9184.get("STORAGE_MNEMONIC")
-        except AttributeError:
-            return "DAS-CDAQ-PHOTODIODES-EMPTY"
-
-
-@click.group()
-def cli():
-    pass
-
-
-@cli.command()
-@click.option("--simulator", "--sim", is_flag=True, help="Start the NI CDAQ9184 Simulator as the backend.")
-def start(simulator):
-    """Start the NI CDAQ9184 Control Server."""
-
-    if simulator:
-
-        Settings.set_simulation_mode(True)
-
-    try:
-
-        controller = cdaq9184ControlServer()
-        controller.serve()
-
-    except KeyboardInterrupt:
-
-        print("Shutdown requested...exiting")
-
-    except SystemExit as exit_code:
-
-        print("System Exit with code {}.".format(exit_code))
-        sys.exit(exit_code)
-
-    except Exception:
-
-        logger.exception("Cannot start the NI CDAQ9184Control Server")
-
-        # The above line does exactly the same as the traceback, but on the logger
-        # import traceback
-        # traceback.print_exc(file=sys.stdout)
-
-    return 0
-
-
-@cli.command()
-def stop():
-    """Send a 'quit_server' command to the NI CDAQ9184 Control Server."""
-
-    with cdaq9184Proxy() as proxy:
-
-        sp = proxy.get_service_proxy()
-        sp.quit_server()
-
-
-if __name__ == "__main__":
-
-    sys.exit(cli())

egse/powermeter/ni/cdaq9184_devif.py

@@ -1,201 +0,0 @@
-"""
-The device interface for the NICDAQ 9184 Controller that will be used at IAS for TVAC the PLATO Cameras.
-
-"""
-
-import logging
-import time
-import socket
-import struct
-from typing import List
-
-from egse.settings import Settings
-from egse.exceptions import DeviceNotFoundError
-from egse.device import DeviceConnectionError, DeviceError
-from egse.device import DeviceConnectionInterface, DeviceTransport, DeviceTimeoutError
-from egse.command import ClientServerCommand
-
-logger = logging.getLogger(__name__)
-
-ctrl_settings = Settings.load("NI Controller")
-
-DEVICE_NAME = "CDAQ9184"
-
-READ_TIMEOUT = 1
-
-
-class cdaq9184Error(Exception):
-    """Base exception for all ptc10 errors."""
-    pass
-
-
-class cdaq9184Command(ClientServerCommand):
-    def get_cmd_string(self, *args, **kwargs) -> str:
-        out = super().get_cmd_string(*args, **kwargs)
-        return out + "\n"
-
-
-class cdaq9184SocketInterface(DeviceConnectionInterface, DeviceTransport):
-    """Defines the low-level interface to the NI CDAQ919 Controller.
-    Connects to the Labview interface via TCP/IP socket"""
-
-    def __init__(self, hostname=None, port=None):
-        self.hostname = ctrl_settings.HOSTNAME if hostname is None else hostname
-        self.port = ctrl_settings.CDAQ9174_PORT if port is None else port
-        self.sock = None
-
-        self.is_connection_open = False
-
-    def connect(self, hostname: str):
-        # Sanity checks
-        if self.is_connection_open:
-            logger.warning(f"{DEVICE_NAME}: trying to connect to an already connected socket.")
-            return
-        if self.hostname in (None, ""):
-            raise ValueError(f"{DEVICE_NAME}: hostname is not initialized.")
-
-        if self.port in (None, 0):
-            raise ValueError(f"{DEVICE_NAME}: port number is not initialized.")
-
-        try:
-            self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-            _id = self.get_id()
-            logger.warning(f"Connected to: {_id}")
-
-        except socket.error as e_socket:
-            raise DeviceConnectionError(DEVICE_NAME, "Failed to create socket.") from e_socket
-            # Asking for instrument description
-
-        # We set a timeout of 3 sec before connecting and reset to None
-        # (=blocking) after the connect. The reason for 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(
-                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
-
-        if not self.is_connected():
-            raise DeviceConnectionError(
-                DEVICE_NAME, "Device is not connected, check logging messages for the cause."
-            )
-
-    def disconnect(self):
-        """
-        Disconnects from the device
-        Raises:
-            DeviceConnectionError when the connection has not been closed correctly
-
-        """
-        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
-
-    def is_connected(self):
-        """Return True if the device is connected."""
-        if not self.is_connection_open:
-            return False
-        return True
-
-    def get_response(self, cmd_string):
-        pass
-
-    def get_id(self):
-        return DEVICE_NAME
-
-    def write(self, command: str):
-        try:
-            #logger.info(f"{command=}")
-            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 CDAQ9184 is not connected, use the connect() method."
-                raise DeviceConnectionError(DEVICE_NAME, msg)
-            raise
-
-    def read(self) -> List:
-        # Set a timeout of READ_TIMEOUT to the socket.recv
-        saved_timeout = self.sock.gettimeout()
-        self.sock.settimeout(READ_TIMEOUT)
-        try:
-            # Extracts the msg size from 4 bytes sent by Labview - mind the encoding. The number
-            # reprensets the number of bytes of data
-            size = struct.unpack('i', self.sock.recv(4))[0]
-            data = self.sock.recv(size)
-        except socket.timeout as e_timeout:
-            logger.warning(f"Socket timeout error from {e_timeout}")
-            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.info(f"Total number of bytes received from the cdaq 9184 is {size}")
-
-        data = data.decode("ascii")
-        data = data.replace("\x00", " ")
-        data = data.replace("\x08", " ")
-        data = data.replace("\n", " ")
-        data = data.replace(",", ".")
-        data = data.replace("\x0c", ",")
-        data = data.replace("\r", ",")
-        data = data.replace("\x04", ",")
-        data = data.replace("\x12", ",")
-        data = data.replace("\x0e", ",")
-        data = data.replace("    ", ",")
-        data = data.replace("0^", "E")
-        data = data.split(",")
-
-        data = [element.strip() for element in data]
-
-        # The first element of data is "#" so I delete it.
-        # But to avoid to delete a relevant value I check if this unwanted element is well in data before deleting.
-        if data[0] == "#":
-            del data[0]
-
-        return data
-
-    def trans(self, cmd: str) -> List:
-        self.write(cmd)
-        response = self.read()
-        return response
-

egse/powermeter/ni/cdaq9184_protocol.py

@@ -1,48 +0,0 @@
-import logging
-import datetime
-
-
-from egse.control import ControlServer
-from egse.powermeter.ni.cdaq9184 import cdaq9184Controller, cdaq9184Simulator, cdaq9184Interface
-from egse.powermeter.ni.cdaq9184_devif import cdaq9184Command
-
-from egse.protocol import CommandProtocol
-from egse.device import DeviceConnectionState
-from egse.settings import Settings
-from egse.system import format_datetime
-from egse.zmq_ser import bind_address
-
-COMMAND_SETTINGS = Settings.load(filename="cdaq9184.yaml")
-logger = logging.getLogger(__name__)
-
-
-
-class cdaq9184Protocol(CommandProtocol):
-    def __init__(self, control_server: ControlServer):
-        super().__init__()
-        self.control_server = control_server
-
-        if Settings.simulation_mode():
-            self.cdaq = cdaq9184Simulator()
-        else:
-            self.cdaq = cdaq9184Controller()
-
-        self.load_commands(
-            COMMAND_SETTINGS.Commands, cdaq9184Command, cdaq9184Interface
-        )
-
-        self.build_device_method_lookup_table(self.cdaq)
-
-    def get_bind_address(self):
-        return bind_address(
-            self.control_server.get_communication_protocol(),
-            self.control_server.get_commanding_port(),
-        )
-
-    def get_status(self):
-        return super().get_status()
-
-    def get_housekeeping(self) -> dict:
-
-        result = dict()
-        return result