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

egse/shutter/thorlabs/__init__.py

@@ -1,19 +0,0 @@
-"""
-This module defines the basic classes to access the Thorlabs Shutter KSC01 controller.
-
-The main entry point for the user of this package is through the `ThorlabsPM100Proxy` class:
-
-```python
->>> from egse.shutter.thorlabs.ksc101 import ShutterKSC101Proxy
-```
-
-This class will connect to the control server of the Thorlabs KSC101 Shutter Controller and provides all commands to
-control and monitor the shutter status. The control server is a small server application
-that is started as shown below. The control server directly connects to the Shutter Controller through an USB
-interface. When you have now hardware available, the control server can be started in simulator mode by appending the
-`--sim` string to the command below.
-
-```bash
-$ python -m egse.shutter.thorlabs.ksc101_cs
-```
-"""

egse/shutter/thorlabs/ksc101.py

@@ -1,205 +0,0 @@
-import logging
-
-from egse.decorators import dynamic_interface
-from egse.device import DeviceInterface
-from egse.proxy import Proxy
-from egse.settings import Settings
-from egse.shutter.thorlabs.ksc101_devif import ShutterKSC101Error
-from egse.shutter.thorlabs.ksc101_devif import ShutterKSC101USBInterface
-from egse.zmq_ser import connect_address
-
-
-logger = logging.getLogger(__name__)
-
-CTRL_SETTINGS = Settings.load("Shutter KSC101 Control Server")
-DEVICE_SETTINGS = Settings.load(filename="ksc101.yaml")
-
-
-class ShutterKSC101Interface(DeviceInterface):
-    """
-    The Shutter KSC101 base class.
-    """
-
-    @dynamic_interface
-    def set_mode(self):
-        """
-        Sets the Shutter KSC101 Controller control mode
-        """
-        return NotImplemented
-
-    @dynamic_interface
-    def set_enable(self):
-        """
-        Sets the Shutter KSC101 Controller control mode
-        """
-        return NotImplemented
-
-    @dynamic_interface
-    def set_cycle(self):
-        """
-        Sets the Shutter KSC101 Controller cycling parameters
-        """
-        return NotImplemented
-
-    @dynamic_interface
-    def get_mode(self):
-        """
-        Sets the Shutter KSC101 Controller control mode
-        """
-        return NotImplemented
-
-    @dynamic_interface
-    def get_enable(self):
-        """
-        Sets the Shutter KSC101 Controller solenoid status
-        """
-        return NotImplemented
-
-    @dynamic_interface
-    def get_cycle(self):
-        """
-        Sets the Shutter KSC101 Controller cycle parameters
-        """
-        return NotImplemented
-
-
-class ShutterKSC101Simulator(ShutterKSC101Interface):
-    """
-    The Thorlabs KSC101 Simulator class.
-    """
-
-    def __init__(self):
-        self._is_connected = True
-        self._mode = "single"
-        self._cycle = {"Ontime": 1000, "Offtime": 1000, "Number of cycles": 10}
-        self._status = False
-
-    def is_connected(self):
-        return self._is_connected
-
-    def is_simulator(self):
-        return True
-
-    def connect(self):
-        self._is_connected = True
-
-    def disconnect(self):
-        self._is_connected = False
-
-    def reconnect(self):
-        if self.is_connected():
-            self.disconnect()
-        self.connect()
-
-    def set_mode(self, mode):
-        self._mode = mode
-
-    def set_enable(self, status):
-        self._status = status
-
-    def set_cycle(self, on, off, number):
-        self._cycle["Ontime"] = on
-        self._cycle["Offtime"] = off
-        self._cycle["Number of cycles"] = number
-
-    def get_mode(self) -> int:
-        mode = {"manual": 0x01, "single": 0x02, "auto": 0x03, "trigger": 0x04}
-        return mode[self._mode]
-
-    def get_enable(self) -> int:
-        return int(self._status)
-
-    def get_cycle(self) -> dict:
-        return self._cycle
-
-
-class ShutterKSC101Controller(ShutterKSC101Interface):
-    def __init__(self):
-        """Initialize the Shutter KSC101 Controller interface."""
-
-        super().__init__()
-
-        logger.debug(f"Initializing Shutter KSC101 Controller")
-
-        try:
-            self.shutter = ShutterKSC101USBInterface()
-            self.shutter.connect()
-
-        except ShutterKSC101Error as exc:
-            logger.warning(f"KSC101Error caught: Couldn't establish connection ({exc})")
-            raise ShutterKSC101Error(
-                "Couldn't establish a connection with the Shutter KSC101 controller."
-            ) from exc
-
-    # FIXME: connect and disconnect methods are not working properly
-
-    def connect(self):
-        """Connects to the Shutter KSC101 device.
-
-        Raises:
-            DeviceNotFoundError: when the Shutter KSC101 device is not connected.
-        """
-        try:
-            self.shutter.connect()
-        except ShutterKSC101Error as exc:
-            raise ConnectionError("Couldn't establish a connection with the Shutter KSC101 controller.") from exc
-        # if not self.shutter.is_connected():
-        #     self.shutter.connect()
-
-    def disconnect(self):
-        try:
-            self.shutter.disconnect()
-        except ShutterKSC101Error as exc:
-            raise ConnectionError("Couldn't establish a connection with the Shutter KSC101 controller.") from exc
-
-    def reconnect(self):
-        if self.is_connected():
-            self.disconnect()
-        self.connect()
-
-    def is_simulator(self):
-        return False
-
-    def is_connected(self):
-        """Check if the Shutter Controller is connected."""
-        return self.shutter.is_connected()
-
-    def get_response(self, cmd_string):
-        response = self.shutter.get_response(cmd_string)
-        return response
-
-    def set_mode(self, mode):
-        self.shutter.set_mode(mode)
-
-    def set_enable(self, status):
-        self.shutter.set_enable(status)
-
-    def set_cycle(self, on, off, number):
-        self.shutter.set_cycle(on, off, number)
-
-    def get_mode(self) -> int:
-        return self.shutter.get_mode()
-
-    def get_enable(self) -> int:
-        return self.shutter.get_enable()
-
-    def get_cycle(self) -> dict:
-        return self.shutter.get_cycle()
-
-
-class ShutterKSC101Proxy(Proxy, ShutterKSC101Interface):
-    def __init__(
-        self,
-        protocol=CTRL_SETTINGS.PROTOCOL,
-        hostname=CTRL_SETTINGS.HOSTNAME,
-        port=CTRL_SETTINGS.COMMANDING_PORT,
-    ):
-        """
-        Args:
-            protocol: the transport protocol [default is taken from settings file]
-            hostname: location of the control server (IP address)
-                [default is taken from settings file]
-            port: TCP port on which the control server is listening for commands
-                [default is taken from settings file]
-        """
-        super().__init__(connect_address(protocol, hostname, port))

egse/shutter/thorlabs/ksc101.yaml

@@ -1,105 +0,0 @@
-BaseClass:
-    egse.shutter.thorlabs.ksc101.ShutterKSC101Interface
-
-ProxyClass:
-    egse.shutter.thorlabs.ksc101.ShutterKSC101Proxy
-
-ControlServerClass:
-    egse.shutter.thorlabs.ksc101_cs.ShutterKSC101ControlServer
-
-ControlServer:
-    egse.shutter.thorlabs.ksc101_cs
-
-UserInterface:
-    egse.shutter.thorlabs.ksc101_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 Shutter 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.
-
-    connect:
-        description:    Connect to the Thorlabs Shutter.
-
-    reconnect:
-        description:    Reconnect to the Thorlabs Shutter.
-
-                        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 ShutterKSC01Controller class.
-        returns:       bool | True if the far end is a simulator instead of the real hardware
-
-    is_connected:
-        description:   Check if the Thorlabs Hardware Controller is connected.
-
-
-    # Definition of the device commands
-
-    set_mode:
-        description:  Sets the KSC101 control mode.
-                      Manual - In this mode, operation of the solenoid is via the top panel wheel.Move the wheel up to
-                      open the solenoid (ON) and down to close (OFF).
-                      Single - In this mode, the solenoid will open/close each time the top panel wheel ismoved up/down.
-                      Auto - In this mode, the solenoid will open and close continuously after the toppanel wheel is
-                      moved up. The ON and OFF times, and the number of cyclesperformed
-                      Trigger - The K-Cube solenoid controllers have two bidirectional trigger ports(TRIG1 and TRIG2)
-                      that can be used to read an external logic signal or outputa logic level to control external
-                      equipment. By default, TRIG 1 is configured asan input and TRIG 2 as an output.
-                      The active logic state can be selected Highor Low to suit the requirements of the application
-        args:
-          mode:       str | Available modes are "Manual", "Single", "Auto", "Trigger"
-        cmd:          "{mode}"
-        returns:      None
-
-    set_enable:
-      description:  This message sets the output state of the solenoid unit, and overrides any existing settings.
-                    It can also be operated by the SET_CHANENABLESTATE message.
-      args:
-        status:     bool | True = open, False = closed
-      cmd:          "{status}"
-      returns:      None
-
-    set_cycle:
-      description:  Used to set the cycle parameters (On time, Off time, and number of cycles) that are applicable when
-                    the solenoid controller is operating in one of the non‐manual modes (Single and Automatic mode
-                    operations).
-      args:
-        on:         int | The duration of an on (open) state of the solenoid in ms ()
-        off:        int | The duration of an off (closed) state of the solenoid in ms ().
-        number:     int | The number of cycles from 0 to . If 0 is set then infinity cycles are foreseen in automatic
-                    mode, the cycling can then be stopped with the set_enable command.
-      cmd:          "{on} {off} {number}"
-      returns:      None
-
-    get_mode:
-      description:  Retrieves the operating control mode of the KSC101 Controller.
-      returns:      int | 1 = manual, 2 = single, 3 = auto, 4 = trigger, None = error
-
-    get_enable:
-      description:  Retrieves the shutter solenoid status.
-      returns:      int | 1 = enabled (open); 0 = disabled (closed)
-
-    get_cycle:
-      description:  Retrives the the cycle parameters (On time, Off time, and number of cycles) that are applicable when
-                    the solenoid controller is operating in one of the non‐manual modes (Single and Automatic mode
-                    operations).
-      returns:      dict |

egse/shutter/thorlabs/ksc101_cs.py

@@ -1,136 +0,0 @@
-import argparse
-import click
-import logging
-import sys
-import zmq
-
-from egse.control import ControlServer
-from egse.settings import Settings
-from egse.shutter.thorlabs.ksc101 import ShutterKSC101Proxy
-
-from egse.shutter.thorlabs.ksc101_protocol import ShutterKSC101Protocol
-
-from prometheus_client import start_http_server
-
-logging.basicConfig(level=logging.DEBUG, format=Settings.LOG_FORMAT_FULL)
-
-logger = logging.getLogger("KSC101 CS")
-
-# Restrict the logging output for the following loggers.
-
-# Note that, in production, the logging level for the different loggers can be changed with a
-# service command `set_logging_level(logger_name, level)`.
-
-logger_levels = [
-    ("egse.protocol", logging.INFO),
-    ("egse.command", logging.INFO),
-    ("egse.settings", logging.INFO),
-]
-
-for name, level in logger_levels:
-    logger = logging.getLogger(name)
-    logger.setLevel(level)
-
-CTRL_SETTINGS = Settings.load("Shutter KSC101 Control Server")
-
-
-class ShutterKSC101ControlServer(ControlServer):
-    """
-    ThorlabsControlServer - Command and monitor the Shutter KSC101 Controllers.
-
-    This class works as a command and monitoring server to control the Shutter 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 Thorlabs controller.
-
-    * a PUB-SUP socket that serves as a monitoring server. It will send out Thorlabs status
-      information to all the connected clients every DELAY seconds.
-
-    """
-
-    def __init__(self):
-        super().__init__()
-
-        self.device_protocol = ShutterKSC101Protocol(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 "KSC101"
-
-    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 Thorlabs KSC101 Shutter Simulator as the backend.")
-def start(simulator):
-    """Start the Thorlabs KSC101 Shutter Control Server."""
-
-    if simulator:
-
-        Settings.set_simulation_mode(True)
-
-    try:
-
-        controller = ShutterKSC101ControlServer()
-        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 Thorlabs KSC101 Shutter 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 Thorlabs KSC101 Shutter Control Server."""
-
-    with ShutterKSC101Proxy() as proxy:
-
-        sp = proxy.get_service_proxy()
-        sp.quit_server()
-
-
-if __name__ == "__main__":
-
-    sys.exit(cli())

egse/shutter/thorlabs/ksc101_devif.py

@@ -1,201 +0,0 @@
-import logging
-import struct
-import time
-
-import pylibftdi
-from pylibftdi import USB_VID_LIST, USB_PID_LIST
-
-USB_PID_LIST.append(0xfaf0) #adds shutter PID to the USB PID List
-
-from egse.command import ClientServerCommand
-from egse.exceptions import DeviceNotFoundError
-from egse.settings import Settings
-
-logger = logging.getLogger(__name__)
-ctrl_settings = Settings.load("Shutter KSC101 Controller")
-
-# TODO:
-#   Add functions to retrieve the controller info and the interlock/error state
-
-
-class ShutterKSC101Error(Exception):
-    """Base exception for all Shutter errors."""
-    pass
-
-
-class ShutterKSC101Command(ClientServerCommand):
-    def get_cmd_string(self, *args, **kwargs) -> str:
-        out = super().get_cmd_string(*args, **kwargs)
-        return out + "\n"
-
-
-class ShutterKSC101USBInterface:
-
-    def __init__(self):
-
-        self._shutter = None
-        self.baudrate = ctrl_settings.BAUDRATE
-        self.device_id = ctrl_settings.DEVICE_ID
-        self._is_connected = False
-
-        self._modes = {"manual": 0x01, "single": 0x02, "auto": 0x03, "trigger": 0x04}
-
-    def connect(self):
-        try:
-            # device mode 't' is latin-1 encoding, to be used later for unpacking the message reads
-            # you added PID and VID to the list of devices of pylibftdi as suggested by
-            # https://pylibftdi.readthedocs.io/en/latest/how_to.html
-            self._shutter = pylibftdi.Device(mode = 't', device_id = self.device_id)
-
-        # Steps to perform from APT Communication Protocol section 2.1:
-        # Baud rate = 115200
-            self._shutter.baudrate = self.baudrate
-
-        # 8 data bits, 1 stop bit, no parity
-            self._shutter.ftdi_fn.ftdi_set_line_property(8, 1, 0)
-
-        # Pre purge dwell 50 ms
-            time.sleep(50.0 / 1000)
-
-        # Purge the device
-            self._shutter.flush(pylibftdi.FLUSH_BOTH)
-
-        # Post purge dwell 50 ms
-            time.sleep(50.0 / 1000)
-
-        # Set flow control to RTS/CTS
-            SIO_RTS_CTS_HS = (0x1 << 8)
-            self._shutter.ftdi_fn.ftdi_setflowctrl(SIO_RTS_CTS_HS)  # returns 0 if OK
-
-        # Set RTS
-            self._shutter.ftdi_fn.ftdi_setrts(1)                    # returns 0 if OK
-
-        except (ValueError, Exception) as exc:
-            logger.warning(f"Could not open USB FTDI device: {exc}")
-            raise DeviceNotFoundError("Could not open USB FTDI device.") from exc
-
-        self._is_connected = True
-
-    def disconnect(self):
-        try:
-            if self._is_connected:
-                logger.debug(f'Disconnecting from {self.device_id}')
-                self._shutter.close()
-                self._is_connected = False
-        except Exception as e_exc:
-            raise ShutterKSC101Error(f"Could not close {self.device_id}") from e_exc
-
-        # if not self._shutter.closed:
-        #     self._shutter.close()
-        # else:
-        #     pass
-        # self.is_connected = False
-
-    def is_connected(self):
-        """Return True if the device is connected."""
-
-        if not self._is_connected:
-            return False
-        try:
-            self.get_id()
-        except OSError:  # FIXME: Check which errors are actually thrown here
-            self.disconnect()
-            return False
-
-        return True
-
-    def get_id(self):
-        return('To be implemented')
-
-    def info(self):
-        return f"Thorlabs KSC101 Shutter Controller: {self.get_id()}."
-
-    def get_response(self, cmd_string):
-        logger.debug(f"get_response() called with {cmd_string}")
-        return NotImplemented
-
-    def send_message(self, m):
-        "Sends the packed message to the KSC101 Controller"
-        self._shutter.write(m.pack())
-
-    def set_mode(self, mode):
-        if mode in self._modes.keys():
-            tx = struct.pack('HBBBB', 0x04C0, 0x01, self._modes[mode], 0x50, 0x01)
-            self._shutter.write(tx)
-        else:
-            print("Error, command not executed")
-        #TODO:ask Rik how to handle this error
-
-    def set_cycle(self, on, off, number):
-
-        tx = struct.pack('<HHBBBBLLL', 0x04C3, 0x000E, 0xD0, 0x01, 0x01, 0x00, on, off, number)
-        self._shutter.write(tx)
-
-    def set_enable(self, state):
-        if state:
-            parameter = 0x01        # Open
-        if not state:
-            parameter = 0x02        # Closed
-        tx = struct.pack('HBBBB', 0x04CB, 0x01, parameter, 0x50, 0x01)
-        self._shutter.write(tx)
-        #TODO: write else condition to avoid wrong parameter value
-
-##### TELEMETRY
-#     Apart from the last two categories (status update messages and error messages), in general
-# the message exchanges follow the SET ‐> REQUEST ‐> GET pattern, i.e. for most commands a
-# trio of messages are defined. The SET part of the trio is used by the host (or, sometimes in
-# card‐slot systems the motherboard) to set some parameter or other. If then the host
-# requires some information from the sub‐module, then it may send a REQUEST for this
-# information, and the sub‐module responds with the GET part of the command. Obviously,
-# there are cases when this general scheme does not apply and some part of this message trio
-# is not defined. For consistency, in the description of the messages this SET‐>REQUEST‐>GET
-# scheme will be used throughout.
-
-# FIXME:
-#   The shutter gets stuck if I follow the documentation from the Manual: Note that,
-#   as the scheme suggests, this is a master‐slave type of system, so sub‐modules
-
-    def get_enable(self):
-        tx = struct.pack('HBBBB', 0x04CB, 0x01, 0x00, 0x50, 0x01)    # requests enable state
-        self._shutter.write(tx)
-        rx =  struct.pack('HBBBB', 0x04CC, 0x01, 0x01, 0x50, 0x01)   # gets enable state
-        self._shutter.write(rx)
-
-        time.sleep(50.0 / 1000)                                 #wait time needed between write and read
-
-        _enable = bytes(self._shutter.read(6), "latin -1")         # gets the 6 read bytes
-        return _enable[3]
-
-    def get_mode(self):
-        tx = struct.pack('HBBBB', 0x04C1, 0x01, 0x00, 0x50, 0x01)    # requests enable state
-        self._shutter.write(tx)
-        rx = struct.pack('HBBBB', 0x04C2, 0x01, 0x01, 0x50, 0x01)   # gets enable state
-        self._shutter.write(rx)
-
-        time.sleep(50.0 / 1000)                                 #wait time needed between write and read
-
-        _mode = bytes(self._shutter.read(6), "latin -1")         # gets the 6 read bytes
-
-        if _mode[3] in self._modes.values():                    # byte 4 gets the mode status
-            mode = _mode[3]
-        else:
-            mode = None
-        return mode
-        #FIXME: put a case in which _mode is empty to prevent errors
-
-    def get_cycle(self):
-        tx = struct.pack('HBBBB',0x04C4,0x01,0x00,0x50,0x01)    # requests enable state
-        self._shutter.write(tx)
-        rx =  struct.pack('HBBBB',0x04C5,0x01,0x01,0x50,0x01)   # gets enable state
-        self._shutter.write(rx)
-
-        time.sleep(50.0 / 1000)                                 #wait time needed between write and read
-        # gets 20 bytes
-        _cycle = bytes(self._shutter.read(20), "latin -1")       # gets the 20 read bytes
-
-        # gets the 3 parameters coded in 4 bytes (long) little endian each
-        on =  struct.unpack('<L',_cycle[8:12])
-        off = struct.unpack('<L',_cycle[12:16])
-        number = struct.unpack('<L',_cycle[16:])
-
-        return {"Ontime": on[0],"Offtime": off[0], "Number of cycles": number[0]}