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

egse/vacuum/pfeiffer/tc400_controller.py

@@ -1,140 +0,0 @@
-import logging
-import time
-from functools import partial
-from copy import deepcopy
-
-from egse.serialdevice import SerialDevice
-from egse.command import Command
-from egse.settings import Settings
-from egse.vacuum.pfeiffer.tc400_interface import Tc400Interface, Tc400Command
-
-logger = logging.getLogger(__name__)
-
-# Load the device settings from the global common-egse config file
-DEVICE_SETTINGS = Settings.load("Pfeiffer TC400 Controller")
-
-# Load the device protocol
-DEVICE_PROTOCOL = Settings.load(filename='tc400.yaml')['Commands']
-
-
-
-def get_checksum(data):
-    """ Checksum is the addition modulo 265 of ascii values in the dataword. """
-
-    charsum = sum(ord(c) for c in data)
-    return charsum % 256
-
-
-class Tc400Controller(SerialDevice, Tc400Interface):
-
-    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)
-        self.connect()
-
-    def get_idn(self):
-        cmd = f"{self._address:03d}0034902=?"
-        cmd += f"{get_checksum(cmd):03d}" + "\r"
-        return self.query(cmd)
-
-    def get_last_error(self):
-        cmd = f"{self._address:03d}0030302=?"
-        cmd += f"{get_checksum(cmd):03d}" + "\r"
-        return int(self.query(cmd))
-
-    def get_active_speed(self):
-        cmd = f"{self._address:03d}0030902=?"
-        cmd += f"{get_checksum(cmd):03d}" + "\r"
-        return int(self.query(cmd))
-
-    def get_drive_power(self):
-        cmd = f"{self._address:03d}0031602=?"
-        cmd += f"{get_checksum(cmd):03d}" + "\r"
-        return int(self.query(cmd))
-
-    def get_motor_temperature(self):
-        cmd = f"{self._address:03d}0034602=?"
-        cmd += f"{get_checksum(cmd):03d}" + "\r"
-        return int(self.query(cmd))
-
-    def set_heating(self, enable):
-        cmd = f"{self._address:03d}1000101{int(enable):1d}"
-        cmd += f"{get_checksum(cmd):03d}" + "\r"
-        return self.query(cmd)
-
-    def set_standby(self, enable):
-        cmd = f"{self._address:03d}1000201{int(enable):1d}"
-        cmd += f"{get_checksum(cmd):03d}" + "\r"
-        return self.query(cmd)
-
-    def set_pumpingstation(self, enable):
-        cmd = f"{self._address:03d}1001001{int(enable):1d}"
-        cmd += f"{get_checksum(cmd):03d}" + "\r"
-        return self.query(cmd)
-
-    def set_motorpump(self, enable):
-        cmd = f"{self._address:03d}1002301{int(enable):1d}"
-        cmd += f"{get_checksum(cmd):03d}" + "\r"
-        return self.query(cmd)
-
-    def set_gasmode(self, mode):
-        cmd = f"{self._address:03d}100271{mode:1d}"
-        cmd += f"{get_checksum(cmd):03d}" + "\r"
-        return self.query(cmd)
-
-    def query(self, command: str):
-        """ Override the parent class to do some error checking on the response. """
-
-        response = super().query(command)
-
-        if len(response) == 0:
-            raise ConnectionError(f"No reply from device")
-
-        elif response[-1] != '\r':
-            raise ConnectionError(f"Invalid termination character in response: {response}")
-
-        elif int(response[:3]) != self._address:
-            raise ConnectionError(
-                f"Got response with incorrect address from device: {response[:3]}")
-
-        elif response[3] != '1':
-            raise ConnectionError(f"Invalid opcode in response: {response}")
-
-        elif Tc400Command.get_checksum(response[:-4]) != int(response[-4:-1]):
-            raise ConnectionError(
-                f"Invalid checksum in response: {get_checksum(response[:-4])} != {int(response[-4:-1])}")
-
-        elif int(response[8:10]) == 6:
-            if response[10:16] == 'NO_DEF':
-                raise ConnectionError(f"Error response: parameter {response[5:8]} does not exist")
-            elif response[10:16] == '_RANGE':
-                raise ConnectionError(f"Error response: data outside permitted range")
-            elif response[10:16] == '_LOGIC':
-                raise ConnectionError(f"Error response: Logic access violation")
-
-        return response[10:-4]
-
-
-def main():
-    logging.basicConfig()
-
-    dev = Tc400Controller()
-
-    print(dev.get_idn())
-    print(dev.get_active_speed())
-    print(dev.get_drive_power())
-    print(dev.get_motor_temperature())
-    print(dev.get_last_error())
-
-    #print(dev.set_motorpump(False))
-    # print(dev.set_pumpingstation(False))
-
-
-if __name__ == '__main__':
-    main()

egse/vacuum/pfeiffer/tc400_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.tc400 import Tc400Protocol, Tc400Proxy
-
-
-logging.basicConfig(level=logging.DEBUG, format=Settings.LOG_FORMAT_FULL)
-
-logger = logging.getLogger(__name__)
-
-CTRL_SETTINGS = Settings.load("Pfeiffer TC400 Control Server")
-
-
-class Tc400ControlServer(ControlServer):
-    """
-    Tc400ControlServer - Command and monitor the Tc400 roots pump controller.
-    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 = Tc400Protocol(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 "TC400"
-
-    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 TC400 Simulator as the backend.")
-def start(simulator):
-    """Start the TC400 Control Server."""
-
-    if simulator:
-        Settings.set_simulation_mode(True)
-    try:
-        controller = Tc400ControlServer()
-        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 TC400 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 TC400 Control Server."""
-
-    with Tc400Proxy() as proxy:
-
-        sp = proxy.get_service_proxy()
-        sp.quit_server()
-
-
-if __name__ == "__main__":
-
-    sys.exit(cli())

egse/vacuum/pfeiffer/tc400_interface.py

@@ -1,70 +0,0 @@
-from egse.device import DeviceInterface
-from egse.decorators import dynamic_interface
-from egse.command import ClientServerCommand
-
-
-class Tc400Command(ClientServerCommand):
-    """ Subclass to handle the checksum. Note that only kwargs are supported """
-
-
-    @staticmethod
-    def get_checksum(data):
-        """ Checksum is the addition modulo 265 of ascii values in the dataword. """
-
-        charsum = sum(ord(c) for c in data)
-        return charsum % 256
-
-
-    def get_cmd_string(self, *args, **kwargs) -> str:
-        """ The TC400 commands include a checksum at the end. To avoid having to calculate this at
-            the client side, it is not included in the cmd string definition in the yaml file
-        """
-
-        cmd_string = super().get_cmd_string(*args, **kwargs)
-        cmd_string += f"{Tc400Command.get_checksum(cmd_string):03d}"
-        cmd_string += "\r"
-
-        return cmd_string
-
-
-class Tc400Interface(DeviceInterface):
-
-    @dynamic_interface
-    def get_idn(self):
-        return NotImplemented
-
-    @dynamic_interface
-    def get_last_error(self):
-        return NotImplemented
-
-    @dynamic_interface
-    def get_active_speed(self):
-        return NotImplemented
-
-    @dynamic_interface
-    def get_drive_power(self):
-        return NotImplemented
-
-    @dynamic_interface
-    def get_motor_temperature(self):
-        return NotImplemented
-
-    @dynamic_interface
-    def set_heating(self, enable):
-        return NotImplemented
-
-    @dynamic_interface
-    def set_standby(self, enable):
-        return NotImplemented
-
-    @dynamic_interface
-    def set_pumpingstation(self, enable):
-        return NotImplemented
-
-    @dynamic_interface
-    def set_motorpump(self, enable):
-        return NotImplemented
-
-    @dynamic_interface
-    def set_gasmode(self, mode):
-        return NotImplemented

egse/vacuum/pfeiffer/tc400_simulator.py

@@ -1,24 +0,0 @@
-import logging
-
-from egse.settings import Settings
-from egse.simulator import Simulator
-from egse.command import Command
-from egse.vacuum.pfeiffer.tc400_interface import Tc400Interface
-
-logger = logging.getLogger(__name__)
-
-# Load the device protocol
-DEVICE_PROTOCOL = Settings.load(filename='tc400.yaml')['Commands']
-
-
-class Tc400Simulator(Tc400Interface, Simulator):
-
-    def __init__(self):
-        super().__init__()
-        self.connect()
-
-    def is_simulator(self):
-        return True
-    
-    def get_idn(self):
-        return "TM 700 (simulator)"

egse/vacuum/pfeiffer/tpg261.py

@@ -1,81 +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.tpg261_interface import Tpg261Command, Tpg261Interface
-from egse.vacuum.pfeiffer.tpg261_controller import Tpg261Controller
-from egse.vacuum.pfeiffer.tpg261_simulator import Tpg261Simulator
-from egse.zmq_ser import connect_address
-
-LOGGER = logging.getLogger(__name__)
-
-DEVICE_SETTINGS = Settings.load(filename="tpg261.yaml")
-CTRL_SETTINGS = Settings.load("Pfeiffer TPG261 Control Server")
-
-class Tpg261Protocol(CommandProtocol):
-
-    gauge_pressure_1 = Gauge('GSRON_TPG261_P_1', '')
-    gauge_errors     = Gauge('GSRON_TPG261_ERR', '')
-    
-    def __init__(self, control_server: ControlServer):
-
-        super().__init__()
-        self.control_server = control_server
-
-        if Settings.simulation_mode():
-            self.dev = Tpg261Simulator()
-        else:
-            self.dev = Tpg261Controller()
-
-        self.load_commands(DEVICE_SETTINGS.Commands, Tpg261Command, Tpg261Interface)
-
-        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()
-
-        status_dict['P1'] = self.dev.pressure_1
-
-        return status_dict
-
-
-    def get_housekeeping(self) -> dict:
-        result = dict()
-        result["timestamp"] = format_datetime()
-        try:
-            self.dev.pressure_1 = self.dev.get_gauge_pressure()
-            result['GSRON_TPG261_P_1'] = self.dev.pressure_1
-            result['GSRON_TPG261_ERR'] = self.dev.get_errors()
-        except Exception as e:
-            LOGGER.warning(f'Failed to get HK: {e}')
-            return result
-        
-        self.gauge_pressure_1.set(result['GSRON_TPG261_P_1'])
-        self.gauge_errors.set(result['GSRON_TPG261_ERR'])
-        
-        return result
-
-
-
-class Tpg261Proxy(Proxy, Tpg261Interface):
-
-    def __init__(self):
-        super().__init__(
-            connect_address(
-                CTRL_SETTINGS.PROTOCOL, CTRL_SETTINGS.HOSTNAME, CTRL_SETTINGS.COMMANDING_PORT))

egse/vacuum/pfeiffer/tpg261.yaml

@@ -1,66 +0,0 @@
-BaseClass:
-    egse.vacuum.pfeiffer.tpg261_interface.Tpg261Interface
-
-ProxyClass:
-    egse.vacuum.pfeiffer.tpg261.Tpg261Proxy
-
-ControlServer:
-    egse.vacuum.pfeiffer.tpg261_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:
-        returns:            str | firmware version
-
-    get_errors:
-        description:        Get errors
-        returns:            bytes | errors
-
-    reset:
-        description:        Reset all errors
-        returns:            bytes | list of errors
-    
-    turn_off_gauge:
-        description:        Turn off a gauge
-        cmd:                '{gauge}'
-        returns:            bytes | status
-
-    turn_on_gauge:
-        description:        Turn on a gauge
-        cmd:                '{gauge}'
-        returns:            bytes | status
-
-    get_gauge_pressure:
-        description:        Get the pressure on a specific gauge
-        cmd:                ''
-        returns:            float | pressure
-
-    request:
-        description:        Request information
-        cmd:                '{cmd}'
-        returns:            bool | acknowledge or not
-
-    enquire:
-        description:        Get the requested information
-        returns:            bytes | requested information
-
-
-    

egse/vacuum/pfeiffer/tpg261_controller.py

@@ -1,150 +0,0 @@
-# from egse.serialdevice import SerialDevice, SerialTimeoutException
-from serial import Serial, SerialTimeoutException
-from egse.command import Command
-from egse.settings import Settings
-from egse.vacuum.pfeiffer.tpg261_interface import Tpg261Interface
-import rich
-from threading import Lock
-from time import sleep
-
-# Load the device settings from the global common-egse config file
-DEVICE_SETTINGS = Settings.load("Pfeiffer TPG261 Controller")
-
-# Load the device protocol
-DEVICE_PROTOCOL = Settings.load(filename='tpg261.yaml')['Commands']
-
-class Tpg261Controller(Tpg261Interface):
-    
-    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._lock = Lock()
-        self._current_mode = None
-        
-        self.pressure_1 = 0
-        
-        # Initialize the serial device with the port and baudrate
-        self.dev = Serial(port=self._port, baudrate=self._baudrate, timeout=1)
-
-    def connect(self):
-        self.dev.open()
-    
-    def disconnect(self):
-        self.dev.close()
-    
-    def reconnect(self):
-        self.dev.close()
-        self.dev.open()
-
-    def is_connected(self):
-        return self.dev.is_open
-    
-    def is_simulator(self):
-        return False
-
-    def get_idn(self):
-            if self._current_mode == 'PNR':
-                return_string = self.enquire()
-                return return_string
-            else:
-                if self.request(f"PNR\r\n"):
-                    sleep(1)
-                    return_string = self.enquire()
-                    self._current_mode = 'PNR'
-                    return return_string
-                else:
-                    raise RuntimeError('Command not acknowledged')
-                sleep(1)
-
-    def get_errors(self):
-        if self._current_mode == 'ERR':
-            return_string = self.enquire()
-            return return_string
-        else:
-            if self.request(f"ERR\r\n"):
-                self._current_mode = 'ERR'
-                return_string = self.enquire()
-                return int(return_string)
-
-            else:
-                raise RuntimeError('Command not acknowledged')           
-
-    def reset(self):
-        if self.request(f"RES\r\n"):
-            return_string = self.enquire()
-            return return_string
-        else:
-            raise RuntimeError('Command not acknowledged')
- 
-    def turn_off_gauge(self, gauge: int):
-        assert 1 <= gauge <= 2
-        if self.request(f"SEN1,0\r\n" if gauge == 1 else f"SEN0,1\r\n"):
-            return_string = self.enquire()
-            return return_string
-        else:
-            raise RuntimeError('Command not acknowledged')
-    
-    def turn_on_gauge(self, gauge: int):
-        assert 1 <= gauge <= 2
-        if self.request(f"SEN20\r\n" if gauge == 1 else f"SEN02\r\n"):
-            return_string = self.enquire()
-            return return_string
-        else:
-            raise RuntimeError('Command not acknowledged')
-    
-    def get_gauge_pressure(self):
-            if self._current_mode == 'PR':
-                return_string = self.enquire()
-            else:
-                if self.request('PR1\r\n'):
-                    self._current_mode = 'PR'
-                    return_string = self.enquire()
-                else:
-                    raise RuntimeError('Command not acknowledged')    
-            return float(return_string[2:-2])     
-    
-    def send_command(self, command: str):
-        try:
-            with self._lock:
-                self.dev.write(command.encode('ascii', 'ignore'))
-        
-        except SerialTimeoutException as e_timeout:
-            raise ConnectionError("Serial timeout error") from e_timeout
-    
-    def request(self, command: str):
-        self.send_command(command)
-
-        try:
-            with self._lock:
-                return_string = self.dev.read_until(b'\r\n', size=None)
-        except SerialTimeoutException as e_timeout:
-            raise ConnectionError("Serial timeout during query") from e_timeout
-           
-        if return_string[0:1] == b'\x06':
-            return True
-        elif return_string[0:1] == b'\x05':
-            return False
-    
-    def enquire(self):
-        self.send_command('\x05')
-
-        try:
-            with self._lock:
-                return_string = self.dev.read_until(b'\r\n', size=None)
-        except SerialTimeoutException as e_timeout:
-            raise ConnectionError("Serial timeout during query") from e_timeout
-
-            
-        return return_string
-        
-            
-if __name__ == "__main__":
-    tpg = Tpg261Controller()
-    tpg.get_idn()
-    tpg.get_gauge_pressure()
-    tpg.get_gauge_pressure()
-    tpg.get_errors()
-    tpg.get_gauge_pressure()
-