cgse 2024.7.0__py3-none-any.whl → 2025.0.2__py3-none-any.whl

egse/tempcontrol/lakeshore/lsci.yaml

@@ -1,162 +0,0 @@
-BaseClass:
-    egse.tempcontrol.lakeshore.LakeShoreInterface
-
-ProxyClass:
-    egse.tempcontrol.lakeshore.LakeShoreProxy
-
-ControlServerClass:
-    egse.tempcontrol.lakeshore.LakeShoreControlServer
-
-ControlServer:
-    egse.tempcontrol.lakeshore.lsci_cs
-
-UserInterface:
-    egse.tempcontrol.lakeshore.lsci_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, i.e. LakeShoreBase.
-    #   response:      The name of the method to be called from the device protocol.
-    #                  This method should exist in the subclass of the CommandProtocol base class, i.e.
-    #                  in this case it will be the LakeShoreProtocol class.
-
-    # Definition of the the DeviceInterface
-
-    disconnect:
-        description  : Disconnect from the LakeShore controller. This command will be send to the
-                       LakeShore 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()`` to disconnect
-                       from the control server.
-
-    connect:
-        description:    Connect the LakeShore hardware controller
-
-    reconnect:
-        description:    Reconnect the LakeShore 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 LakeShoreController class.
-        returns:       bool | True if the far end is a simulator instead of the real hardware
-
-    is_connected:
-        description:   Check if the LakeShore Hardware Controller is connected.
-
-
-    # Definition of the device commands
-
-    info:
-        description:   Retrieve basic information about the LakeShore and the Controller.
-        cmd:           "*IDN?\n"
-        returns:        str | Model number
-
-    get_id:
-        description:   Return LakeShore ID.
-        returns:       str | Returns return id LakeShore LS_X
-  
-    get_temperature:
-        description:   Retrieve the temperature from the given channel.
-        cmd:           "CRDG?\n"
-        returns:       float | The current temperature for the given channel
-
-    get_params_pid:
-        description:   Returns control loop PID values. See the PID command for parameter descriptions.
-        args:
-          output:     int | output Specifies which output’s control loop to configure 1–4      
-        cmd:           "PID? {output}\n"
-        returns:        list | [P, I, D]
-
-    get_setpoint:
-        description:   Returns Control Setpoint Query.
-        args:
-          output:     int | output Specifies which output’s control loop to configure 1–4      
-        cmd:           "SETP? {output}\n"
-        returns:        str | value
-
-    get_tuning_status:
-        description:   Returns Tuning Status   
-        cmd:           "TUNEST?\n"
-        returns:        list 
-
-    get_heater_setup:
-        description:   Returns Heater Setup   
-        args:
-          output:     int | output Specifies which output’s control loop to configure 1–4   
-        cmd:           "HTRSET? {output}\n"
-        returns:        list 
-
-    get_range:
-        description:   Get Range mode.
-        args:
-          output:     int | output Specifies which output’s control loop to configure 1–4          
-        cmd:           "RANGE? {output}\n"
-        returns:       int | Returns the remote interface mode
-  
-    get_heater_status:
-        description:   Returns Heater Status
-        args:
-          output:     int | output Specifies which output’s control loop to configure 1–4             
-        cmd:           "HTRST? {output}\n"
-        returns:        list 
-
-    get_heater:
-        description:   Heater Output Query
-        args:
-          output:     int | output Specifies which output’s control loop to configure 1–4             
-        cmd:           "HTR? {output}\n"
-        returns:        float 
-
-    set_params_pid:
-        description:   Set control loop PID values.
-        args:
-          output:     int | output PID      
-          p:        int | P Value      
-          i:        int | I Value
-          d:        int | D Value
-        cmd:           "PID {output},{p},{i},{d}\n"
-        returns:        None
-
-    set_setpoint:
-        description:   Returns Control Setpoint Command.
-        args:
-          output:     int | output Specifies which output’s control loop to configure 1–4    
-          value:      srt | value The value for the setpoint (in the preferred units of the control loop sensor).        
-        cmd:           "SETP {output},{value}\n"
-        returns:        None
-    
-    set_autotune:
-        description:   Set Autotune params.
-        args:
-          output:     int | output Specifies which output’s control loop to configure 1–4    
-          value:      srt | value The value for the setpoint (in the preferred units of the control loop sensor).        
-        cmd:           "ATUNE {output},{mode}\n"
-        returns:        None
-
-    set_heater_setup:
-        description:   Set Heater params.
-        args:
-          output:           int 
-          heater_resistant: int
-          max_current:      int 
-          max_user_current: str
-          output_display:   int
-
-        cmd:           "ATUNE {output},{mode}\n"
-        returns:        None
-    
-    set_range:
-        description:   Set Range params.
-        args:
-          output:     int | output Specifies which output’s control loop to configure 1–4    
-          value:      srt | value The value for the setpoint (in the preferred units of the control loop sensor).        
-        cmd:           "RANGE {output},{mode}\n"
-        returns:        None

egse/tempcontrol/lakeshore/lsci_cs.py

@@ -1,174 +0,0 @@
-import argparse
-import click
-import logging
-import sys
-import rich
-import zmq
-
-import multiprocessing
-multiprocessing.current_process().name = "lsci_cs"
-
-from egse.control import ControlServer
-from egse.control import is_control_server_active
-from egse.settings import Settings
-from egse.tempcontrol.lakeshore.lsci import LakeShoreProxy
-from egse.tempcontrol.lakeshore.lsci_protocol import LakeShoreProtocol
-from prometheus_client import start_http_server
-from egse.zmq_ser import connect_address
-
-logging.basicConfig(level=logging.DEBUG, format=Settings.LOG_FORMAT_FULL)
-logger = logging.getLogger("LSCI CS")
-
-CTRL_SETTINGS = Settings.load("LakeShore Control Server")
-
-
-
-
-def is_lsci_cs_active(timeout: float = 0.5):
-    """Check if the LSCI 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.COMMANDING_PORT
-    )
-
-    return is_control_server_active(endpoint, timeout)
-
-
-class LakeShoreControlServer(ControlServer):
-    """
-    LakeShoreControlServer - Command and monitor the LakeShore Temperature Controllers.
-
-    This class works as a command and monitoring server to control the LakeShore Controller.
-
-    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 LakeShore controller.
-
-    * a PUB-SUP socket that serves as a monitoring server. It will send out LakeShore status
-      information to all the connected clients every DELAY seconds.
-
-    """
-
-    def __init__(self, index):
-        self.index = index
-        self.name = "LS_"+str(index)
-        print(index)
-        super().__init__()
-        self.device_protocol = LakeShoreProtocol(self, self.index)
-
-        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[self.name]['COMMANDING_PORT']
-
-    def get_service_port(self):
-        return CTRL_SETTINGS[self.name]['SERVICE_PORT']
-
-    def get_monitoring_port(self):
-        return CTRL_SETTINGS[self.name]['MONITORING_PORT']
-    
-    def get_storage_mnemonic(self):
-        try:
-            return CTRL_SETTINGS[self.name]['STORAGE_MNEMONIC']
-        except AttributeError:
-            return f'LSCI_{self.index}'
-    def before_serve(self):
-        start_http_server(CTRL_SETTINGS[self.name]['METRICS_PORT'])
-
-    def after_serve(self):
-        self.device_protocol.synoptics.disconnect_cs()
-
-@click.group()
-def cli():
-    pass
-
-
-@cli.command()
-@click.option("--simulator", "--sim", is_flag=True, help="Start the Lakeshore LSCI Simulator as the backend.")
-@click.argument('index', type=click.IntRange(1, 3))
-def start(simulator,index):
-    """Start the LakeShore LSCI Control Server."""
-
-    if simulator:
-
-        Settings.set_simulation_mode(True)
-
-    try:
-        logger.debug(f'Starting LakeShore {index} Control Server')
-        multiprocessing.current_process().name = f"lsci_cs_{index}"
-
-        controller = LakeShoreControlServer(index)
-        controller.serve()
-
-    except KeyboardInterrupt:
-
-        logger.exception("Shutdown requested...exiting")
-
-    except SystemExit as exit_code:
-
-        logger.exception("System Exit with code {}.".format(exit_code))
-        sys.exit(exit_code)
-
-    except Exception:
-
-        logger.exception("Cannot start the LakeShore LSCI Control 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()
-@click.argument('index', type=click.IntRange(1, 3))
-def stop(index):
-    """Send a 'quit_server' command to the LakeShore LSCI Control Server."""
-
-    with LakeShoreProxy(index) as proxy:
-
-        sp = proxy.get_service_proxy()
-        sp.quit_server()
-
-@cli.command()
-@click.argument('index', type=click.IntRange(1, 3))
-def status(index):
-    """Request status information from the Control Server."""
-    name = "LS_"+str(index)
-    protocol = CTRL_SETTINGS.PROTOCOL
-    hostname = CTRL_SETTINGS.HOSTNAME
-    port = CTRL_SETTINGS[name]['COMMANDING_PORT']
-
-    endpoint = connect_address(protocol, hostname, port)
-
-    if is_control_server_active(endpoint):
-        rich.print(f"LSCI {index} CS: [green]active")
-        with LakeShoreProxy(index) as lsci:
-            sim = lsci.is_simulator()
-            connected = lsci.is_connected()
-            ip = lsci.get_ip_address()
-            rich.print(f"mode: {'simulator' if sim else 'device'}{' not' if not connected else ''} connected")
-            rich.print(f"hostname: {ip}")
-    else:
-        rich.print(f"LSCI {index} CS: [red]not active")
-
-
-
-
-if __name__ == "__main__":
-
-    sys.exit(cli())

egse/tempcontrol/lakeshore/lsci_devif.py

@@ -1,292 +0,0 @@
-import logging
-import socket
-import threading
-import time
-
-from egse.command import ClientServerCommand
-from egse.settings import Settings
-from egse.serialdevice import SerialDevice
-
-MODULE_LOGGER = logging.getLogger(__name__)
-
-LS_SETTINGS = Settings.load("LakeShore Controller")
-
-
-class LakeShoreError(Exception):
-    """Base exception for all LakeShore errors."""
-
-    pass
-
-
-class LakeShoreCommand(ClientServerCommand):
-    def get_cmd_string(self, *args, **kwargs) -> str:
-        out = super().get_cmd_string(*args, **kwargs)
-        return out + "\n"
-
-class LakeShoreEthernetInterface:
-    def __init__(self, device_index):
-        self.name = "LS_"+str(device_index)
-        self.hostname = LS_SETTINGS[self.name]['HOSTNAME']
-        self.port = LS_SETTINGS[self.name]['PORT']
-        self.sock = None
-
-        # Access-to-the-connection semaphore.
-        # Use this to lock/unlock I/O access to the connection (whatever type it is) in
-        # child classes.
-
-        self.semaphore = threading.Semaphore()
-
-        self.isConnectionOpen = False
-        self.connect()
-
-    def connect(self):
-
-        # Sanity checks
-
-        if self.isConnectionOpen:
-            raise LakeShoreError("Socket is already open")
-        if self.hostname in (None, ""):
-            raise LakeShoreError("ERROR: hostname not initialized")
-        if self.port in (None, 0):
-            raise LakeShoreError("ERROR: port number 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 LakeShoreError("ERROR: 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 3 sec before connecting and reset to None
-        # (=blocking) after the connect. The reason for this is because when no
-        # LakeShore 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:
-            MODULE_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 e_cr:
-            raise LakeShoreError(f"ERROR: Connection refused to {self.hostname}") from e_cr
-        except TimeoutError as e_timeout:
-            raise LakeShoreError(f"ERROR: Connection to {self.hostname} timed out") from e_timeout
-        except socket.gaierror as e_gai:
-            raise LakeShoreError(f"ERROR: socket address info error for {self.hostname}") from e_gai
-        except socket.herror as e_h:
-            raise LakeShoreError(f"ERROR: socket host address error for {self.hostname}") from e_h
-        except socket.timeout as e_timeout:
-            raise LakeShoreError(f"ERROR: socket timeout error for {self.hostname}") from e_timeout
-        except OSError as ose:
-            raise LakeShoreError(f"ERROR: OSError caught ({ose}).") from ose
-
-        self.isConnectionOpen = True
-
-        # Check that we are connected to a pmac by issuing the "VERSION" command --
-        # expecting the 1.947 in return.
-        # If we don't get the right response, then disconnect automatically
-
-        if not self.is_connected():
-            raise LakeShoreError("Device is not connected, check logging messages for the cause.")
-
-    def disconnect(self):
-        """
-        Disconnect from the Ethernet connection.
-
-        Raises a LakeShoreError on failure.
-        """
-        try:
-            if self.isConnectionOpen:
-                MODULE_LOGGER.debug(f"Disconnecting from {self.hostname}")
-                self.semaphore.acquire()
-                self.sock.close()
-                self.semaphore.release()
-                self.isConnectionOpen = False
-        except Exception as e_exc:
-            raise LakeShoreError(f"Could not close socket to {self.hostname}") from e_exc
-
-    def is_connected(self):
-
-        if not self.isConnectionOpen:
-            return False
-
-        try:
-            response = self.get_response("*IDN?\n")
-        except LakeShoreError as e_lakeshore:
-            if len(e_lakeshore.args) >= 2 and e_lakeshore.args[1] == -1:
-                MODULE_LOGGER.error(
-                    f"While trying to talk to the device the following exception occurred, "
-                    f"exception={e_lakeshore}"
-                )
-                MODULE_LOGGER.error(
-                    "Most probably the client connection was closed. Disconnecting..."
-                )
-                self.disconnect()
-                return False
-            else:
-                MODULE_LOGGER.error(
-                    f"While trying to talk to the device the following exception occurred, "
-                    f"exception={e_lakeshore}"
-                )
-                self.disconnect()
-                return False
-        finally:
-            pass
-
-        version = response
-
-        if not version.startswith("LSCI"):
-            # if the response string doesn't start with LSCI then we're not talking to a
-            # LakeShore device!
-            MODULE_LOGGER.error(
-                f'Device did not respond correctly to a "VERSION" command, response={response}. '
-                f"Disconnecting..."
-            )
-            self.disconnect()
-            return False
-
-        return True
-
-    def get_response(self, command: str, wait=True)-> str:
-        """
-        Send a single command to the controller and block until a response from the controller.
-
-        :param str command: is the command to be sent
-
-        :param bool wait: whether to wait on the semaphore [default = True].
-
-            This should normally be left default. If we have acquired the semaphore manually,
-            then specify wait = False (and don't forget to release the semaphore eventually).
-
-        :return: either a string returned by the PMAC (on success), or an error message (on failure)
-
-        :raises: LakeShoreError when there was an I/O problem during comm with the PMAC or
-        the response does
-                 not have recognised terminators.
-        """
-
-        try:
-            if wait:
-                self.semaphore.acquire()
-
-            # Attempt to send the complete command
-
-            self.sock.sendall(command.encode())
-
-            # wait for, read and return the response from HUBER (will be at most TBD chars)
-
-            return_string = self.wait_for_response()
-
-            return return_string.decode().replace("\r\n", "").replace("+","")
-        
-        except socket.timeout as e_timeout:
-            raise LakeShoreError("Socket timeout error") from e_timeout
-        except socket.error as e_socket:
-            # Interpret any socket-related error as an I/O error
-            raise LakeShoreError("Socket communication error.") from e_socket
-        finally:
-            if wait:
-                self.semaphore.release()
-
-    def write(self, command: str):
-        """
-        Send a single command to the device controller without waiting for a response.
-
-        Args:
-            command: an order command for 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:
-            self.sock.sendall(command.encode())
-
-        except socket.timeout as e_timeout:
-            raise LakeShoreError("Socket timeout error") from e_timeout
-        except socket.error as e_socket:
-            # Interpret any socket-related error as a connection error
-            raise LakeShoreError("Socket communication error.") from e_socket
-        except AttributeError:
-            if not self.is_connected:
-                msg = "The LakeShore is not connected, use the connect() method."
-                raise LakeShoreError(msg)
-            raise
-
-    def wait_for_response(self):
-        n_total = 0
-        buf_size = 2048
-
-        try:
-            for idx in range(100):
-                time.sleep(0.05)  # 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 as e_timeout:
-            MODULE_LOGGER.warning(f"Socket timeout error from {e_timeout}")
-            return b"\r\n"
-
-       # MODULE_LOGGER.debug(f"Total number of bytes received is {n_total}, idx={idx}")
-
-        return data
-
-    def info(self):
-        return self.get_response("*IDN?\n")
-    
-    def get_id(self):
-        return self.name
-    
-    def get_temperature(self):
-        return self.get_response("CRDG? A\n")
-
-    def get_params_pid(self, output:int):
-        return self.get_response(f"PID? {output}\n").split(",")
-
-    def get_setpoint(self, output:int):
-        return self.get_response(f"SETP? {output}\n",)
-    
-    def get_tuning_status(self):
-        return self.get_response(f"TUNEST?\n").split(",")
-    
-    def get_heater_setup(self, output:int):
-        return self.get_response(f"HTRSET? {output}\n").split(",")
-    
-    def get_range(self, output:int):
-        return self.write(f"RANGE? {output}\n")
-    
-    def get_heater_status(self, output:int):
-        return self.get_response(f"HTRST? {output}\n")
-    
-    def get_heater(self, output:int):
-        return self.get_response(f"HTR? {output}\n",)
-    
-    def set_params_pid(self, output:int, p:int, i:int, d:int):
-        self.write(f"PID {output} {p} {i} {d}\n")
-
-    def set_setpoint(self, outpout:int, value:str):
-        self.write(f"SETP {outpout},{value}\n")
-
-    def set_autotune(self, output:int, mode:int):
-        self.write(f"ATUNE {output},{mode}\n")
-
-    def set_heater_setup(self,output:int, heater_resistant:int, max_current:int, max_user_current:str, output_display:int):
-        self.write(f"HTRSET {output},{heater_resistant},{max_current},{max_user_current},{output_display}\n")
-
-    def set_range(self, output:int, range:int):
-        self.write(f"RANGE {output},{range}\n")

egse/tempcontrol/lakeshore/lsci_protocol.py

@@ -1,76 +0,0 @@
-import logging
-
-from egse.control import ControlServer
-from egse.metrics import define_metrics
-from egse.protocol import CommandProtocol
-from egse.settings import Settings
-from egse.setup import load_setup
-
-from egse.system import format_datetime
-from egse.zmq_ser import bind_address
-
-from egse.tempcontrol.lakeshore.lsci import (LakeShoreController, LakeShoreInterface, LakeShoreSimulator)
-from egse.tempcontrol.lakeshore.lsci_devif import LakeShoreCommand
-
-from egse.synoptics import SynopticsManagerProxy
-
-logger = logging.getLogger(__name__)
-
-COMMAND_SETTINGS = Settings.load(filename="lsci.yaml")
-SITE_ID = Settings.load("SITE").ID
-
-
-class LakeShoreProtocol(CommandProtocol):
-    def __init__(self, control_server: ControlServer, device_index):
-        super().__init__()
-        self.control_server = control_server
-        self.device_index = device_index
-        if Settings.simulation_mode():
-            self.lakeshore = LakeShoreSimulator()
-        else:
-            self.lakeshore = LakeShoreController(device_index)
-
-        setup = load_setup()
-
-        self.load_commands(COMMAND_SETTINGS.Commands, LakeShoreCommand, LakeShoreInterface)
-
-        self.build_device_method_lookup_table(self.lakeshore)
-        
-        self.synoptics = SynopticsManagerProxy()
-        
-        self.metrics = define_metrics(origin="LSCI", use_site=True, setup=setup)
-
-    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:
-        metrics_dict = self.metrics
-        hk_dict = dict()
-        hk_dict["timestamp"] = format_datetime()
-        try:
-            hk_dict[f"G{SITE_ID}_LSCI_{self.device_index}_TEMP_A"] = self.lakeshore.get_temperature()
-            pidParams = self.lakeshore.get_params_pid(1)
-            hk_dict[f"G{SITE_ID}_LSCI_{self.device_index}_P_VALUE"] = pidParams[0]
-            hk_dict[f"G{SITE_ID}_LSCI_{self.device_index}_I_VALUE"] = pidParams[1]
-            hk_dict[f"G{SITE_ID}_LSCI_{self.device_index}_D_VALUE"] = pidParams[2]
-            hk_dict[f"G{SITE_ID}_LSCI_{self.device_index}_HEATER_VALUE"] = self.lakeshore.get_heater(1)
-            hk_dict[f"G{SITE_ID}_LSCI_{self.device_index}_SET_POINT_VALUE"] = self.lakeshore.get_setpoint(1)
-
-            for hk_name in metrics_dict.keys():
-                index_lsci = hk_name.split("_")
-                if(len(index_lsci) > 2):
-                    if int(index_lsci[2]) ==  int(self.device_index):
-                        metrics_dict[hk_name].set(hk_dict[hk_name])
-
-            # Send the HK acquired so far to the Synoptics Manager
-            self.synoptics.store_th_synoptics(hk_dict)
-
-        except Exception as exc:
-            logger.warning(f'failed to get HK ({exc})')
-        return hk_dict