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

egse/vacuum/pfeiffer/acp40.py

@@ -1,87 +0,0 @@
-import logging
-
-from prometheus_client import Gauge
-
-from egse.control import ControlServer
-from egse.command import ClientServerCommand
-from egse.protocol import CommandProtocol
-from egse.proxy import Proxy
-from egse.settings import Settings
-from egse.zmq_ser import bind_address
-from egse.system import format_datetime
-from egse.vacuum.pfeiffer.acp40_interface import Acp40Interface
-from egse.vacuum.pfeiffer.acp40_controller import Acp40Controller
-from egse.vacuum.pfeiffer.acp40_simulator import Acp40Simulator
-from egse.zmq_ser import connect_address
-from egse.serialdevice import SerialTimeoutException, SerialException
-logger = logging.getLogger(__name__)
-
-DEVICE_SETTINGS = Settings.load(filename="acp40.yaml")
-CTRL_SETTINGS = Settings.load("Pfeiffer ACP40 Control Server")
-SITE_ID = Settings.load("SITE").ID
-
-gauge_status = Gauge('GSRON_ACP40_STATUS', 'device status word')
-gauge_faults = Gauge('GSRON_ACP40_FAULTS', 'device faults word')
-
-
-class Acp40Command(ClientServerCommand):
-    pass
-
-
-class Acp40Protocol(CommandProtocol):
-
-    def __init__(self, control_server: ControlServer):
-
-        super().__init__()
-        self.control_server = control_server
-
-        if Settings.simulation_mode():
-            self.dev = Acp40Simulator()
-        else:
-            self.dev = Acp40Controller()
-
-        self.load_commands(DEVICE_SETTINGS.Commands, Acp40Command, Acp40Interface)
-        self.build_device_method_lookup_table(self.dev)
-
-
-    # move to parent class?
-    def get_bind_address(self):
-        return bind_address(
-            self.control_server.get_communication_protocol(),
-            self.control_server.get_commanding_port(),
-        )
-
-
-    def get_status(self):
-        status_dict = super().get_status()
-
-        # need to get the channel from somewhere
-        # status_dict['device_status'] = self.dev.get_status(channel)
-
-        return status_dict
-
-
-    def get_housekeeping(self) -> dict:
-        result = dict()
-        result["timestamp"] = format_datetime()
-        
-        try:
-            status_list = self.dev.get_device_status().split(',')
-
-            result[f"GSRON_ACP40_STATUS"] = status_list[0]
-            result[f"GSRON_ACP40_FAULTS"] = status_list[1]
-
-            gauge_status.set(result[f"GSRON_ACP40_STATUS"])
-            gauge_faults.set(result[f"GSRON_ACP40_FAULTS"])
-        except Exception as e:
-            logger.warning(f"An exception was raised by the serial device: {e}")
-            self.dev.reconnect()
-        return result
-
-
-class Acp40Proxy(Proxy, Acp40Interface):
-
-    def __init__(self):
-        super().__init__(
-            connect_address(
-                CTRL_SETTINGS.PROTOCOL, CTRL_SETTINGS.HOSTNAME, CTRL_SETTINGS.COMMANDING_PORT))

egse/vacuum/pfeiffer/acp40.yaml

@@ -1,60 +0,0 @@
-BaseClass:
-    egse.vacuum.pfeiffer.acp40_interface.Acp40Interface
-
-ProxyClass:
-    egse.vacuum.pfeiffer.acp40.Acp40Proxy
-
-ControlServer:
-    egse.vacuum.pfeiffer.acp40_cs
-
-Commands:
-    # The commands in this file are fake.
-    # One of the parameters of the command is the device index. If this is included here, the client
-    # will have to pass this argument for every function call. I prefer to add this on the
-    # controller side. Note that arguments must be included in the cmd string for the proxy interface.
-
-    disconnect:
-        description:        Disconnect from the device.
-
-    connect:
-        description:        Connect to the device.
-
-    reconnect:
-        description:        Reconnect to the device.
-                            This command will force a disconnect and then try to re-connect to the controller.
-    is_connected:
-        description:        Check if the Thorlabs Hardware Controller is connected.
-
-    is_simulator:
-        description:        Ask if the control server is a simulator instead of the real ShutterKSC01Controller class.
-        returns:            bool | True if the far end is a simulator instead of the real hardware
-
-    get_idn:
-        description:        Get device IDN message.
-        returns:            str | ID string
-
-    get_device_status:
-        description:        Get the device status word
-        returns:            str | Status word
-
-    get_address:
-        description:        Get the device addres
-        returns:            int | Device address
-
-    set_standby:
-        description:        Switches from stand-by speed to the default setting (?)
-
-    set_nominal_speed:
-        description:        Set the pump to nominal speed (80 RPM). Must be preceded by a set_standby command
-
-    set_rpm:
-        description:        Set the pump to a specific RPM.
-        args:
-            rpm:            int | Pump speed (RMP) [35, 80].
-        cmd:                "{address}"
-
-    set_enable:
-        description:        Turn the pump on or off.
-        args:
-            enable:         bool | True = on
-        cmd:                "{enable}"

egse/vacuum/pfeiffer/acp40_controller.py

@@ -1,117 +0,0 @@
-import logging
-from serial import SerialTimeoutException
-
-from egse.serialdevice import SerialDevice
-from egse.command import Command
-from egse.settings import Settings
-from egse.vacuum.pfeiffer.acp40_interface import Acp40Interface
-
-logger = logging.getLogger(__name__)
-
-# Load the device settings from the global common-egse config file
-DEVICE_SETTINGS = Settings.load("Pfeiffer ACP40 Controller")
-
-# Load the device protocol
-DEVICE_PROTOCOL = Settings.load(filename='acp40.yaml')['Commands']
-
-
-class Acp40Controller(SerialDevice, Acp40Interface):
-
-    def __init__(self, port=None, baudrate=None, address=None):
-
-        # Load device configuration from the common-egse global config file
-        self._port     = DEVICE_SETTINGS.PORT if port is None else port
-        self._baudrate = DEVICE_SETTINGS.BAUDRATE if baudrate is None else baudrate
-        self._address  = DEVICE_SETTINGS.ADDRESS if address is None else address
-
-        # Initialize the parent class with the port and baudrate
-        super().__init__(port=self._port, baudrate=self._baudrate, terminator='\r', timeout=1)
-        self.connect()
-
-    def is_connected(self):
-        return True
-    
-    def is_simulator(self):
-        return False
-    
-    def get_idn(self):
-        cmd = f"#{self._address:03d}IDN\r"
-        return self.query(cmd)
-
-    def get_device_status(self):
-        cmd = f"#{self._address:03d}STA\r"
-        return self.query(cmd)
-
-    def get_address(self):
-        cmd = "#???ADR\r"
-        return self.query(cmd)
-
-    def set_standby(self):
-        cmd = f"#{self._address:03d}SBY\r"
-        return self.query(cmd)
-
-    def set_nominal_speed(self):
-        cmd = f"#{self._address:03d}NSP\r"
-        return self.query(cmd)
-
-    def set_rpm(self, rpm):
-        cmd = f"#{self._address:03d}RPM{rpm:02d}\r"
-        return self.query(cmd)
-
-    def set_enable(self, enable):
-        enablestr = 'ON' if enable else 'OFF'
-        cmd = f"#{self._address:03d}ACP{enablestr:s}\r"
-        return self.query(cmd)
-
-    def query(self, command: str):
-        """ The ACP40 does some strange undocumented things that does not allow using the normal
-            parent class query function other serial controllers use.
-        """
-
-        # Attempt to send the command
-        self.send_command(command)
-
-        try:
-            with self._lock:
-                return_string = self._serial.read_until(b'\r', size=1024)
-
-        except SerialTimeoutException as e_timeout:
-            raise ConnectionError("Serial timeout during query") from e_timeout
-
-        if len(return_string) == 0:
-            raise ConnectionError(f"No reply from device")
-
-        if not b'#' in return_string:
-            raise ConnectionError(f"Invalid header character in response: {return_string}")
-
-        # the device sends garbage characters before the `#` starting character.
-        # Mostly \x00's but sometimes other non-ascii characters
-        response = (b'#' + return_string.split(b'#')[1]).decode()
-
-        return_value = response[5:-1]
-
-        if return_value == 'ERR0':
-            raise ConnectionError(f"Setting fault for command: {command}")
-        if return_value == 'ERR1':
-            raise ConnectionError(f"Context fault for command: {command}")
-        if return_value == 'ERR2':
-            raise ConnectionError(f"Parameter fault for command: {command}")
-        if return_value == 'ERR3':
-            raise ConnectionError(f"Order fault for command: {command}")
-
-        return return_value
-
-
-def main():
-    logging.basicConfig()
-
-
-    dev = Acp40Controller()
-
-    #print(dev.get_address())
-    print(dev.get_idn())
-    print(dev.get_device_status())
-    # print(dev.set_enable(False, address=0))
-
-if __name__ == '__main__':
-    main()

egse/vacuum/pfeiffer/acp40_cs.py

@@ -1,109 +0,0 @@
-import click
-import logging
-import sys
-
-import zmq
-from prometheus_client import start_http_server
-
-from egse.control import ControlServer
-from egse.settings import Settings
-from egse.vacuum.pfeiffer.acp40 import Acp40Protocol, Acp40Proxy
-
-
-logging.basicConfig(level=logging.DEBUG, format=Settings.LOG_FORMAT_FULL)
-
-logger = logging.getLogger(__name__)
-
-CTRL_SETTINGS = Settings.load("Pfeiffer ACP40 Control Server")
-
-
-class Acp40ControlServer(ControlServer):
-    """
-    Acp40ControlServer - Command and monitor the ACP40 turbo pump.
-    This class works as a command and monitoring server to control the device remotely.
-    The sever binds to the following ZeroMQ sockets:
-    * a REP socket that can be used as a command server. Any client can connect and
-      send a command to the Lamp controller.
-    * a PUB socket that serves as a monitoring server. It will send out Lamp status
-      information to all the connected clients every DELAY seconds.
-    """
-
-    def __init__(self):
-        super().__init__()
-
-        self.device_protocol = Acp40Protocol(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.COMMANDING_PORT
-
-    def get_service_port(self):
-        return CTRL_SETTINGS.SERVICE_PORT
-
-    def get_monitoring_port(self):
-        return CTRL_SETTINGS.MONITORING_PORT
-
-    def get_storage_mnemonic(self):
-        try:
-            return CTRL_SETTINGS.STORAGE_MNEMONIC
-        except AttributeError:
-            return "ACP40"
-
-    def before_serve(self):
-        start_http_server(CTRL_SETTINGS.METRICS_PORT)
-
-
-@click.group()
-def cli():
-    pass
-
-
-@cli.command()
-@click.option("--simulator", "--sim", is_flag=True, help="Start the ACP40 Simulator as the backend.")
-def start(simulator):
-    """Start the ACP40 Control Server."""
-
-    if simulator:
-        Settings.set_simulation_mode(True)
-    try:
-        controller = Acp40ControlServer()
-        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 ACP40 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()
-def stop():
-    """Send a 'quit_server' command to the Control Server."""
-
-    with Acp40Proxy() as proxy:
-
-        sp = proxy.get_service_proxy()
-        sp.quit_server()
-
-
-if __name__ == "__main__":
-
-    sys.exit(cli())

egse/vacuum/pfeiffer/acp40_interface.py

@@ -1,40 +0,0 @@
-from egse.device import DeviceInterface
-from egse.decorators import dynamic_interface
-
-class Acp40Interface(DeviceInterface):
-
-    @dynamic_interface
-    def is_connected(self):
-        return NotImplemented
-    
-    @dynamic_interface
-    def is_simulator(self):
-        return NotImplemented
-    
-    @dynamic_interface
-    def get_idn(self):
-        return NotImplemented
-
-    @dynamic_interface
-    def get_device_status(self):
-        return NotImplemented
-
-    @dynamic_interface
-    def get_address(self):
-        return NotImplemented
-
-    @dynamic_interface
-    def set_standby(self):
-        return NotImplemented
-
-    @dynamic_interface
-    def set_nominal_speed(self):
-        return NotImplemented
-
-    @dynamic_interface
-    def set_rpm(self, rpm):
-        return NotImplemented
-
-    @dynamic_interface
-    def set_enable(self, enable):
-        return NotImplemented

egse/vacuum/pfeiffer/acp40_simulator.py

@@ -1,39 +0,0 @@
-import logging
-
-from egse.settings import Settings
-from egse.simulator import Simulator
-from egse.command import Command
-from egse.vacuum.pfeiffer.acp40_interface import Acp40Interface
-
-logger = logging.getLogger(__name__)
-
-
-class Acp40Simulator(Acp40Interface, Simulator):
-
-    def __init__(self):
-        super().__init__()
-        self.connect()
-
-    def is_simulator(self):
-        return True
-
-    def get_idn(self):
-        return "VPACP40-VB.1 (simulator)"
-
-    def get_device_status(self):
-        return "000100,100000,000000,00000,0000,000,027,000,01597"
-
-    def get_address(self):
-        raise NotImplementedError
-
-    def set_standby(self):
-        raise NotImplementedError
-
-    def set_nominal_speed(self):
-        raise NotImplementedError
-
-    def set_rpm(self, rpm):
-        raise NotImplementedError
-
-    def set_enable(self, enable):
-        raise NotImplementedError

egse/vacuum/pfeiffer/tc400.py

@@ -1,113 +0,0 @@
-import logging
-
-from prometheus_client import Gauge
-
-from egse.control import ControlServer
-from egse.protocol import CommandProtocol
-from egse.proxy import Proxy
-from egse.settings import Settings
-from egse.zmq_ser import bind_address
-from egse.system import format_datetime
-# from egse.fdir.fdir_manager import FdirManagerProxy
-from egse.vacuum.pfeiffer.tc400_interface import Tc400Command, Tc400Interface
-from egse.vacuum.pfeiffer.tc400_controller import Tc400Controller
-from egse.vacuum.pfeiffer.tc400_simulator import Tc400Simulator
-from egse.zmq_ser import connect_address
-
-LOGGER = logging.getLogger(__name__)
-
-DEVICE_SETTINGS = Settings.load(filename="tc400.yaml")
-CTRL_SETTINGS = Settings.load("Pfeiffer TC400 Control Server")
-
-gauge_active_speed = Gauge('GSRON_TC400_ACT_SPEED', 'active pump speed')
-gauge_drive_power = Gauge('GSRON_TC400_POWER', 'pump power')
-gauge_motor_temperature = Gauge('GSRON_TC400_MOTOR_TEMP', 'motor temperature')
-gauge_last_error = Gauge('GSRON_TC400_LAST_ERROR', 'last encountered error')
-
-
-class Tc400Protocol(CommandProtocol):
-
-    def __init__(self, control_server: ControlServer):
-
-        super().__init__()
-        self.control_server = control_server
-
-        if Settings.simulation_mode():
-            self.dev = Tc400Simulator()
-        else:
-            self.dev = Tc400Controller()
-
-        self.load_commands(DEVICE_SETTINGS.Commands, Tc400Command, Tc400Interface)
-
-        self.build_device_method_lookup_table(self.dev)
-
-
-    # move to parent class?
-    def get_bind_address(self):
-        return bind_address(
-            self.control_server.get_communication_protocol(),
-            self.control_server.get_commanding_port(),
-        )
-
-
-    def get_status(self):
-        status_dict = super().get_status()
-
-        # need to get the channel from somewhere
-        # status_dict['device_status'] = self.dev.get_status(channel)
-
-        return status_dict
-
-
-    def get_housekeeping(self) -> dict:
-        result = dict()
-        prev_err = None
-        result["timestamp"] = format_datetime()
-
-        try:
-            result[f"GSRON_TC400_LAST_ERROR"] = self.dev.get_last_error()
-            result[f"GSRON_TC400_ACT_SPEED"] = self.dev.get_active_speed()
-            result[f"GSRON_TC400_POWER"] = self.dev.get_drive_power()
-            result[f"GSRON_TC400_MOTOR_TEMP"] = self.dev.get_motor_temperature()
-        except Exception as e:
-            LOGGER.warning(f'failed to get HK ({e})')
-
-            # with FdirManagerProxy() as fdir:
-            #     fdir_code = 100010
-            #     fdir.signal_fdir(fdir_code)
-            #     LOGGER.warning(f'asserted fdir signal: {fdir_code}')
-
-            return result
-
-        # if prev_err is not result[f"G{SITE_ID}_TC400_LAST_ERROR"]:
-        #     LOGGER.info(f"Device has raised an error flag: {result[f"G{SITE_ID}_TC400_LAST_ERROR"]}")
-        #     with FdirManagerProxy() as fdir:
-        #         fdir_code = 1010
-        #         fdir.signal_fdir(fdir_code)
-        #         LOGGER.warning(f'asserted fdir signal: {fdir_code}')
-
-        prev_err = result['GSRON_TC400_LAST_ERROR']
-
-        gauge_active_speed.set(result[f"GSRON_TC400_ACT_SPEED"])
-        gauge_drive_power.set(result[f"GSRON_TC400_POWER"])
-        gauge_motor_temperature.set(result[f"GSRON_TC400_MOTOR_TEMP"])
-        gauge_last_error.set(result[f'GSRON_TC400_LAST_ERROR'])
-
-        return result
-
-
-class Tc400Proxy(Proxy, Tc400Interface):
-
-    def __init__(self):
-        super().__init__(
-            connect_address(
-                CTRL_SETTINGS.PROTOCOL, CTRL_SETTINGS.HOSTNAME, CTRL_SETTINGS.COMMANDING_PORT))
-
-    def connect_cs(self):
-        try:
-            super().connect_cs()
-        except Exception:
-            with FdirManagerProxy() as fdir:
-                fdir_code = 10010
-                fdir.signal_fdir(fdir_code)
-                LOGGER.warning(f'asserted fdir signal: {fdir_code}')

egse/vacuum/pfeiffer/tc400.yaml

@@ -1,83 +0,0 @@
-# The commands in this file are fake.
-# One of the parameters of the command is the device index. If this is included here, the client
-# will have to pass this argument for every function call. I prefer to add this on the
-# controller side. Note that arguments must be included in the cmd string for the proxy interface.
-# Additionally, this device requires a checksum that can only sensibly be calculated on the
-# controller side as well.
-
-BaseClass:
-    egse.vacuum.pfeiffer.tc400_interface.Tc400Interface
-
-ProxyClass:
-    egse.vacuum.pfeiffer.tc400.Tc400Proxy
-
-ControlServer:
-    egse.vacuum.pfeiffer.tc400_cs
-
-Commands:
-
-    disconnect:
-        description:        Disconnect from the device.
-
-    connect:
-        description:        Connect to the device.
-
-    reconnect:
-        description:        Reconnect to the device.
-                            This command will force a disconnect and then try to re-connect to the controller.
-    is_connected:
-        description:        Check if the Thorlabs Hardware Controller is connected.
-
-    is_simulator:
-        description:        Ask if the control server is a simulator instead of the real controller class.
-        returns:            bool | True if the far end is a simulator instead of the real hardware
-
-    get_idn:
-        description:        Read the type of display and control unit
-        returns:            str | ID string
-
-    get_last_error:
-        description:        Read latest error
-        returns:            int | error code of last encountered error
-
-    get_active_speed:
-        description:        Read the active rotation speed
-        returns:            int | current speed in Hz
-
-    get_drive_power:
-        description:        Read the power
-        returns:            int | current power in W
-
-    get_motor_temperature:
-        description:        Read the temperature
-        returns:            int | current temperature in C
-
-    set_heating:
-        description:        Turn heating on or off.
-        args:
-            enable:         bool | True to enable heating.
-        cmd:                "{enable}"
-
-    set_standby:
-        description:        Set the device in standby (idle).
-        args:
-            enable:         bool | True to enable standby.
-        cmd:                "{enable}"
-
-    set_pumpingstation:
-        description:        Enable the external power. Needs to be enabled before the pump.
-        args:
-            enable:         bool | Enable the external power.
-        cmd:                "{enable}"
-
-    set_motorpump:
-        description:        Turn the turbopump on or off.
-        args:
-            enable:         bool | True to turn on the pump motor.
-        cmd:                "{enable}"
-
-    set_gasmode:
-        description:        Select gas type setting.
-        args:
-            mode:           int | 0 - heavy, 1 - light, 2 - helium.
-        cmd:                "{mode}"