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

egse/filterwheel/eksma/fw8smc5.py

@@ -1,111 +0,0 @@
-import logging
-
-from prometheus_client import Gauge
-
-from egse.control import ControlServer
-from egse.protocol import CommandProtocol
-from egse.command import ClientServerCommand
-from egse.proxy import Proxy
-from egse.settings import Settings
-from egse.state import GlobalState
-from egse.synoptics import SynopticsManagerProxy
-from egse.zmq_ser import bind_address
-from egse.system import format_datetime
-from egse.filterwheel.eksma.fw8smc5_interface import Fw8Smc5Interface
-from egse.filterwheel.eksma.fw8smc5_controller import Fw8Smc5Controller
-from egse.filterwheel.eksma.fw8smc5_simulator import Fw8Smc5Simulator
-from egse.zmq_ser import connect_address
-
-logger = logging.getLogger(__name__)
-
-FDIR_PREFIX = 400
-
-DEVICE_SETTINGS = Settings.load(filename="fw8smc5.yaml")
-CTRL_SETTINGS = Settings.load("Standa 8SMC5 Control Server")
-
-gauge_position_0 = Gauge('GSRON_FW8SMC5_POS_0', 'wheel 0 position in encoder steps')
-gauge_position_1 = Gauge('GSRON_FW8SMC5_POS_1', 'wheel 1 position in encoder steps')
-gauge_relative_intensity = Gauge('GSRON_FW8SMC5_RI', 'filter attenuation as relative index')
-gauge_fwc_fraction = Gauge('GSRON_FW8SMC5_FWC_FRACTION', 'FWC fraction')
-
-
-class Fw8Smc5Command(ClientServerCommand):
-    pass
-
-
-class Fw8Smc5Protocol(CommandProtocol):
-
-    def __init__(self, control_server: ControlServer):
-
-        super().__init__()
-        self.control_server = control_server
-
-        self.fwc_calibration = GlobalState.setup.gse.ogse.calibration.fwc_calibration
-
-        if Settings.simulation_mode():
-            self.dev = Fw8Smc5Simulator()
-        else:
-            self.dev = Fw8Smc5Controller()
-
-        self.load_commands(DEVICE_SETTINGS.Commands, Fw8Smc5Command, Fw8Smc5Interface)
-        self.build_device_method_lookup_table(self.dev)
-
-        self.synoptics = SynopticsManagerProxy()
-
-
-    # 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 = {
-            'RelativeIntensity': self.dev.get_relative_intensity(),
-            'FullWellCapacity': self.dev.get_relative_intensity() / self.fwc_calibration,
-            'FW1Position' : self.dev.get_position_steps(0),
-            'FW2Position' : self.dev.get_position_steps(1)
-        }
-        status_dict['fw8smc5_status'] = 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:
-            result["GSRON_FW8SMC5_RI"] = self.dev.get_relative_intensity()
-            result["GSRON_FW8SMC5_FWC_FRACTION"] = result["GSRON_FW8SMC5_RI"] / self.fwc_calibration
-            # TODO Include FWC fraction in result
-
-            # Send the HK acquired so far to the Synoptics Manager
-            self.synoptics.store_th_synoptics(result)
-
-            result["GSRON_FW8SMC5_POS_0"] = self.dev.get_position_steps(0)
-            result["GSRON_FW8SMC5_POS_1"] = self.dev.get_position_steps(1)
-
-        except Exception as exc:
-            logger.warning(f'failed to get HK ({exc})')
-            return result
-
-        gauge_position_0.set(result[f"GSRON_FW8SMC5_POS_0"])
-        gauge_position_1.set(result[f"GSRON_FW8SMC5_POS_1"])
-        gauge_relative_intensity.set(result[f"GSRON_FW8SMC5_RI"])
-        gauge_fwc_fraction.set(result["GSRON_FW8SMC5_FWC_FRACTION"])
-
-        return result
-
-
-class Fw8Smc5Proxy(Proxy, Fw8Smc5Interface):
-
-    def __init__(self):
-        super().__init__(
-            connect_address(
-                CTRL_SETTINGS.PROTOCOL, CTRL_SETTINGS.HOSTNAME, CTRL_SETTINGS.COMMANDING_PORT))

egse/filterwheel/eksma/fw8smc5.yaml

@@ -1,105 +0,0 @@
-BaseClass:
-    egse.filterwheel.eksma.fw8smc5_interface.Fw8Smc5Interface
-
-ProxyClass:
-    egse.filterwheel.eksma.fw8smc5.Fw8Smc5Proxy
-
-ControlServer:
-    egse.filterwheel.eksma.fw8smc5_cs
-
-UserInterface:
-    egse.filterwheel.eksma.fw8smc5_ui
-
-Commands:
-
-    connect:
-        description:        Connect the Filter Wheel hardware controller.
-
-    reconnect:
-        description:        Reconnect the Lamp hardware controller.
-
-                            This command will force a disconnect and then try to re-connect to the controller.
-
-    disconnect:
-        description:        Disconnect from the Lamp controller. This command will be send to the
-                            Thorlabs 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.
-
-    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:        Get the device ID string.
-        returns:            str | ID string
-
-    get_error_flags:
-        description:        Read the error status word for both controllers.
-        returs:             (int, int)
-
-    is_moving:
-        description:        Check whether either of the two wheels is currently moving.
-        returns:            (bool, bool)
-
-    get_position_steps:
-        description:        Read the current position of one wheel in encoder steps.
-        args:
-            id:             int | wheel ID [0, 1]
-        returns:            int | position in encoder steps
-        cmd:                "{id}" # Not a real command.
-
-    set_position_steps:
-        description:        Move one wheel to a encoder step position (blocking).
-        args:
-            id:             int | wheel ID [0, 1]
-            position:       int | position in encoder steps
-        cmd:                "{id}{position}" # Not a real command.
-
-    get_position_wheels:
-        description:        Return the filter position of both wheels.
-        returns:            (int, int) | index [0 - 7]
-
-    set_position_wheels:
-        description:        Set the wheels to specific filter positions.
-        args:
-            position_a:     int | position index of wheel 0
-            position_b:     int | position index of wheel 1
-        cmd:                "{position_a}{position_b}" # Not a real command.
-
-    get_position_index:
-        description:        Get the position of both wheels as a single index (sorted by attenuation).
-        returns:            int | index [0 - 63]
-
-    set_position_index:
-        description:        Move the wheels to a single filter index position (blocking).
-        args:
-            index:          int | index [0 - 63]
-        cmd:                "{index}" # Not a real command.
-
-    get_relative_intensity:
-        description:        Read the relative intensity value of the current filter.
-        returns:            float | relative intensity [0 - 1] = [opaque - transparent]
-
-    set_relative_intensity:
-        description:        Set filter combination that matches the relative intensity the closest.
-        args:
-            rel_intensity:  float | relative intensity [0 - 1] = [opaque - transparent]
-        cmd:                "{rel_intensity}" # Not a real command.
-
-    intensity_level_up:
-        description:        Increase the relative intensity by one level
-
-    intensity_level_down:
-        description:        Decrease the relative intensity by one level
-
-    home:
-        description:        Move both wheels to the home position (blocking).
-
-    set_position_wheel:
-        description:
-        cmd:                "{id}{position}"

egse/filterwheel/eksma/fw8smc5_controller.py

@@ -1,307 +0,0 @@
-
-import logging
-from collections import OrderedDict
-from ctypes import cast, byref, c_int, POINTER
-
-import numpy as np
-import time
-
-from egse.device import DeviceConnectionError
-from egse.filterwheel.eksma.fw8smc5 import Fw8Smc5Interface
-from egse.lib.ximc.pyximc import device_information_t, get_position_t, status_t, MoveState
-from egse.lib.ximc.pyximc import lib as ximc
-from egse.settings import Settings
-from egse.state import GlobalState
-
-logger = logging.getLogger(__name__)
-
-CTRL_SETTINGS = Settings.load("Standa 8SMC5 Controller")
-
-
-class Fw8Smc5Exception(Exception):
-    pass
-
-
-class Fw8Smc5Controller(Fw8Smc5Interface):
-    """ This class controls a 8smc5 dual filterwheel controller through two serial devices
-        connected via USB. It uses a wrapped c library (ximc) to communicate with the device.
-    """
-
-    DEVICE_NAME     = "Standa 8SMC5"
-    WHEEL_POSITIONS = 8
-    TOTAL_POSITIONS = WHEEL_POSITIONS * WHEEL_POSITIONS
-    ROTATION_STEPS  = 600 # number of encoder steps in a full rotation
-    POSITION_STEPS  = ROTATION_STEPS // WHEEL_POSITIONS # number of encoder steps between filter positions
-
-
-    def __init__(self, port0=None, port1=None):
-        self._port0 = CTRL_SETTINGS.PORT_0 if port0 is None else port0
-        self._port1 = CTRL_SETTINGS.PORT_1 if port1 is None else port1
-        self._devIds = [None, None]
-        self._is_connected = False
-
-
-        # Get device calibration from the setup
-        self.setup = GlobalState.setup
-        self.relative_intensities = self.setup.gse.ogse.calibration.relative_intensity_by_index
-        self.home_offsets = self.setup.gse.filterwheel.home_offset
-        self.ri_wheel_positions = self.setup.gse.ogse.calibration.relative_intensity_by_wheel
-
-        self.ri_wheel_positions = {eval(k): v for k, v in self.ri_wheel_positions.items()} # convert wheel indices from strings to tuples
-        self.ri_wheel_positions = OrderedDict( # Convert to ordereddict sorted by values to match self.relative_intensities
-            sorted(self.ri_wheel_positions.items(), key=lambda x: x[1]))
-
-        # self.disconnect()
-        try:
-            self.connect()
-        except Exception as exc:
-            logger.error(f"Could not connect to device ({exc})")
-
-        self.home() # avoid being in an invalid position
-
-
-    # The device sometimes becomes unresponsive when the connection is not closed
-    def __del__(self):
-        self.disconnect()
-
-
-    def connect(self):
-
-        if self._is_connected:
-            logger.warning("Trying to connect to an already connected device")
-        else:
-            try:
-                self._devIds[0] = ximc.open_device(f"xi-com:{self._port0}".encode())
-                self._devIds[1] = ximc.open_device(f"xi-com:{self._port1}".encode())
-            except OSError as exc:
-                raise DeviceConnectionError(self.DEVICE_NAME, f"Could not connect ({exc}).") from exc
-            else:
-                self._is_connected = True
-
-
-    def disconnect(self):
-
-        if not self._is_connected:
-            logger.warning("Trying to disconnect to an already disconnected device")
-        else:
-            try:
-                ximc.close_device(byref(cast(self._devIds[0], POINTER(c_int))))
-                ximc.close_device(byref(cast(self._devIds[1], POINTER(c_int))))
-            except OSError as exc:
-                raise DeviceConnectionError(self.DEVICE_NAME, f"Could not disconnect ({exc}).") from exc
-            else:
-                self._is_connected = False
-
-
-    def reconnect(self):
-
-        if self._is_connected:
-            self.disconnect()
-        self.connect()
-
-
-    def is_connected(self):
-
-        return self._is_connected
-
-
-    def is_simulator(self):
-
-        return False
-
-
-    def get_idn(self):
-
-        device_information = device_information_t()
-        result = ximc.get_device_information(self._devIds[0], byref(device_information))
-
-        return device_information.ProductDescription.decode()
-
-
-    def get_error_flags(self):
-
-        status0, status1 = self._get_status()
-
-        return (status0.Flags, status1.Flags)
-
-
-    def is_moving(self):
-
-        status0, status1 = self._get_status()
-
-        return (bool(status0.MoveSts & MoveState.MOVE_STATE_MOVING),
-                bool(status1.MoveSts & MoveState.MOVE_STATE_MOVING))
-
-
-    def get_position_steps(self, id):
-
-        get_position = get_position_t()
-        ximc.get_position(self._devIds[id], byref(get_position))
-
-        return get_position.Position
-
-
-    def set_position_steps(self, id, position):
-
-        assert id in [0, 1], 'Device id must be in [0, 1]'
-
-        position = position % self.ROTATION_STEPS
-
-        ximc.command_move(self._devIds[id], position, 0)
-
-        # TODO: add some error checking and maybe a timout to this loop
-        while self.get_position_steps(id) != position:
-            time.sleep(0.1)
-
-
-    def get_position_wheels(self):
-
-        return self._get_position_wheel(0), self._get_position_wheel(1)
-
-
-    def set_position_wheels(self, position_a, position_b):
-
-        self.set_position_wheel(0, position_a)
-        self.set_position_wheel(1, position_b)
-
-
-    def get_position_index(self):
-
-        # Get the current wheel positions
-        p0, p1 = self.get_position_wheels()
-
-        if p0 is None or p1 is None:
-            raise Fw8Smc5Exception('Wheel(s) in intermediate position')
-
-        try:
-            return list(self.ri_wheel_positions.keys()).index((p0, p1))
-        except ValueError:
-            return None
-            # Do we really need to crash the CS/Leave a log message if the comination is non indexed?
-            # I think we are better off just returning an impossible value
-            # logger.warning("Filterwheel is in a non-indexed combination of wheel positions")
-            # raise Fw8Smc5Exception("Filterwheel is in a non-indexed combination of wheel positions")
-
-
-    def set_position_index(self, index):
-
-        index0, index1 = list(self.ri_wheel_positions.keys())[index]
-        self.set_position_wheels(index0, index1)
-
-
-    def get_relative_intensity(self):
-        index = self.get_position_index()
-        if index in self.relative_intensities:
-            return self.relative_intensities[index]
-        else:
-            return 9.99999e9
-
-
-    def set_relative_intensity(self, relative_intensity):
-
-        # Find the index that matches the desired relative_intensity the closest.
-        index = int(np.abs(
-            np.array(list(self.relative_intensities.values())) - relative_intensity).argmin())
-
-        # Look up corresponding wheel positions
-        p0, p1 = list(self.ri_wheel_positions.keys())[index]
-
-        self.set_position_wheels(p0, p1)
-
-        logger.info(f'set relative intensity to {relative_intensity}')
-
-
-    def intensity_level_up(self):
-
-        index = self.get_position_index() # get current index
-        index = min(index + 1, self.TOTAL_POSITIONS - 1) # increment
-        self.set_position_index(index)
-
-
-    def intensity_level_down(self):
-
-        index = self.get_position_index() # get current index
-        index = max(index - 1, 0) # decrement
-        self.set_position_index(index)
-
-
-    # NOTE: this is blocking but the position might still be outdated when read directly after homing
-    def home(self):
-
-        logger.info('Homing started...')
-
-        ximc.command_homezero(self._devIds[0])
-        ximc.command_homezero(self._devIds[1])
-
-        self.set_position_steps(0, self.home_offsets[0])
-        self.set_position_steps(1, self.home_offsets[1])
-
-        logger.info('Homing complete')
-
-
-    def _get_status(self):
-
-        status0 = status_t()
-        status1 = status_t()
-
-        ximc.get_status(self._devIds[0], byref(status0))
-        ximc.get_status(self._devIds[1], byref(status1))
-
-        return (status0, status1)
-
-
-    def _get_position_wheel(self, id):
-        """ Get the position of one of the wheels.
-            Returns None for inbetween positions.
-        """
-
-        position = self.get_position_steps(id) - self.home_offsets[id]
-        offset = position % self.POSITION_STEPS
-
-        if offset != 0:
-            return None
-        else:
-            return position // self.POSITION_STEPS % self.WHEEL_POSITIONS
-
-
-    def set_position_wheel(self, id, position):
-        """ Set the position of one of the wheels. """
-
-        assert 0 <= position < self.WHEEL_POSITIONS, f"Filterwheel index out of range ({position})"
-
-        position_steps = (position * self.POSITION_STEPS + self.home_offsets[id]) % self.ROTATION_STEPS
-        self.set_position_steps(id, position_steps)
-
-        logger.debug(f'set wheel {id} to step position {position_steps}')
-
-        while(self.get_position_steps(id) != position_steps):
-            logger.info(f'position = {self.get_position_steps(id)}')
-            time.sleep(1)
-
-
-def main():
-    dev = Fw8Smc5Controller()
-
-    print('id      :', dev.get_idn())
-    print('status  :', dev.get_error_flags())
-    print('position:', (dev.get_position_steps(0), dev.get_position_steps(0)))
-
-    print(list(dev.ri_wheel_positions.keys()).index(('(0, 0)')))
-
-
-    # dev.home()
-    # print(dev.get_position_index())
-    # print(dev.get_position_wheels())
-    #
-    # dev.set_position_index(24)
-    # print(dev.get_position_index())
-    # print(dev.get_position_wheels())
-    #
-    # dev.set_relative_intensity(1E-4)
-    # print(dev.get_position_index())
-    # print(dev.get_position_wheels())
-
-
-
-if __name__ == '__main__':
-    main()

egse/filterwheel/eksma/fw8smc5_cs.py

@@ -1,141 +0,0 @@
-import logging
-
-import click
-import rich
-import sys
-import zmq
-from prometheus_client import start_http_server
-
-from egse.control import ControlServer, is_control_server_active
-from egse.filterwheel.eksma.fw8smc5 import Fw8Smc5Protocol, Fw8Smc5Proxy
-from egse.settings import Settings
-from egse.zmq_ser import connect_address
-
-logging.basicConfig(level=logging.DEBUG, format=Settings.LOG_FORMAT_FULL)
-
-logger = logging.getLogger(__name__)
-
-CTRL_SETTINGS = Settings.load("Standa 8SMC5 Control Server")
-
-
-class Fw8Smc5ControlServer(ControlServer):
-    """
-    Fw8Smc5ControlServer - Command and monitor the 8SMC5 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 = Fw8Smc5Protocol(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 "8SMC5"
-
-    def before_serve(self):
-        start_http_server(CTRL_SETTINGS.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 8SMC5 Simulator as the backend.")
-def start(simulator):
-    """Start the 8SMC5 Control Server."""
-
-    if simulator:
-        Settings.set_simulation_mode(True)
-    try:
-        controller = Fw8Smc5ControlServer()
-        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 8SMC5 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 Fw8Smc5Proxy() as proxy:
-
-        sp = proxy.get_service_proxy()
-        sp.quit_server()
-
-
-@cli.command()
-def status():
-    """Send a 'quit_server' command to the FW8 SMC5 filterwheel."""
-
-    rich.print("FW8SMC5 filterwheel:")
-
-    protocol = CTRL_SETTINGS.PROTOCOL
-    hostname = CTRL_SETTINGS.HOSTNAME
-    port = CTRL_SETTINGS.COMMANDING_PORT
-
-    endpoint = connect_address(protocol, hostname, port)
-
-    if is_control_server_active(endpoint):
-        rich.print(f"  Status: [green]active")
-
-        with Fw8Smc5Proxy() as filterwheel:
-            rich.print(f"  Hostname: {filterwheel.get_ip_address()}")
-            rich.print(f"  Monitoring port: {filterwheel.get_monitoring_port()}")
-            rich.print(f"  Commanding port: {filterwheel.get_commanding_port()}")
-            rich.print(f"  Service port: {filterwheel.get_service_port()}")
-            sim = filterwheel.is_simulator()
-            connected = filterwheel.is_connected()
-            rich.print(f"mode: {'simulator' if sim else 'device'}{' not' if not connected else ''} connected")
-
-    else:
-        rich.print(f"  Status: [red]inactive")
-
-
-if __name__ == "__main__":
-
-    sys.exit(cli())