horiba-sdk 0.3.3__py3-none-any.whl → 0.5.2__py3-none-any.whl

horiba_sdk/devices/single_devices/monochromator.py

@@ -1,6 +1,6 @@
 from enum import Enum
 from types import TracebackType
-from typing import Optional, final
+from typing import Any, Optional, final
 
 from loguru import logger
 from overrides import override
@@ -19,6 +19,13 @@ class Monochromator(AbstractDevice):
     should be used to access the detected Monochromators on the system.
     """
 
+    @final
+    class Shutter(Enum):
+        """Shutters installed in the monochromator."""
+
+        FIRST = 0
+        SECOND = 1
+
     @final
     class ShutterPosition(Enum):
         """Position of the shutter."""
@@ -34,6 +41,18 @@ class Monochromator(AbstractDevice):
         SECOND = 1
         THIRD = 2
 
+    @final
+    class FilterWheel(Enum):
+        """Filter wheels installed in the monochromator.
+
+        .. note:: the filter wheel is an optional module
+
+        """
+
+        # TODO: clarify naming of filter wheel
+        FIRST = 0
+        SECOND = 1
+
     @final
     class FilterWheelPosition(Enum):
         """Positions of the filter wheel installed in the monochromator.
@@ -52,17 +71,15 @@ class Monochromator(AbstractDevice):
     class Mirror(Enum):
         """Mirrors installed in the monochromator"""
 
-        # TODO: clarify how the mirrors are called
-        FIRST = 0
-        SECOND = 1
+        ENTRANCE = 0
+        EXIT = 1
 
     @final
     class MirrorPosition(Enum):
         """Possible positions of the mirrors"""
 
-        # TODO: clarify what possible position there are
-        A = 0
-        B = 1
+        AXIAL = 0
+        LATERAL = 1
 
     @final
     class Slit(Enum):
@@ -74,16 +91,6 @@ class Monochromator(AbstractDevice):
         C = 2
         D = 3
 
-    @final
-    class SlitStepPosition(Enum):
-        """Slits steps available on the monochromator."""
-
-        # TODO: clarify how the slits are called
-        A = 0
-        B = 1
-        C = 2
-        D = 3
-
     def __init__(self, device_id: int, communicator: AbstractCommunicator, error_db: AbstractErrorDB) -> None:
         super().__init__(device_id, communicator, error_db)
 
@@ -106,7 +113,7 @@ class Monochromator(AbstractDevice):
         """Opens the connection to the Monochromator
 
         Raises:
-            Exception: When an error occured on the device side
+            Exception: When an error occurred on the device side
         """
         await super().open()
         await super()._execute_command('mono_open', {'index': self._id})
@@ -116,7 +123,7 @@ class Monochromator(AbstractDevice):
         """Closes the connection to the Monochromator
 
         Raises:
-            Exception: When an error occured on the device side
+            Exception: When an error occurred on the device side
         """
         await super()._execute_command('mono_close', {'index': self._id})
 
@@ -124,7 +131,7 @@ class Monochromator(AbstractDevice):
         """Checks if the connection to the monochromator is open.
 
         Raises:
-            Exception: When an error occured on the device side
+            Exception: When an error occurred on the device side
         """
         response: Response = await super()._execute_command('mono_isOpen', {'index': self._id})
         return bool(response.results['open'])
@@ -133,29 +140,42 @@ class Monochromator(AbstractDevice):
         """Checks if the monochromator is busy.
 
         Raises:
-            Exception: When an error occured on the device side
+            Exception: When an error occurred on the device side
         """
         response: Response = await super()._execute_command('mono_isBusy', {'index': self._id})
         return bool(response.results['busy'])
 
-    async def home(self) -> None:
+    async def initialize(self) -> None:
         """Starts the monochromator initialization process called "homing".
 
         Use :func:`Monochromator.is_busy()` to know if the operation is still taking place.
 
         Raises:
-            Exception: When an error occured on the device side
+            Exception: When an error occurred on the device side
         """
         await super()._execute_command('mono_init', {'index': self._id})
 
-    async def configuration(self) -> str:
+    async def is_initialized(self) -> bool:
+        """This command returns true when the mono is initialized. Otherwise, it returns false.
+        Note: This command may also return false when the mono is busy with another command.
+
+        Returns:
+            bool: If the monochromator is initialized or not
+
+        Raises:
+            Exception: When an error occurred on the device side
+        """
+        response: Response = await super()._execute_command('mono_isInitialized', {'index': self._id})
+        return bool(response.results['initialized'])
+
+    async def configuration(self) -> dict[str, Any]:
         """Returns the configuration of the monochromator.
 
         Returns:
             str: configuration of the monochromator
         """
         response: Response = await super()._execute_command('mono_getConfig', {'index': self._id, 'compact': False})
-        return str(response.results)
+        return response.results['configuration']
 
     async def get_current_wavelength(self) -> float:
         """Current wavelength of the monochromator's position in nm.
@@ -194,16 +214,20 @@ class Monochromator(AbstractDevice):
         Raises:
             Exception: When an error occurred on the device side
         """
-        await super()._execute_command('mono_moveToPosition', {'index': self._id, 'wavelength': wavelength}, 60)
+        await super()._execute_command('mono_moveToPosition', {'index': self._id, 'wavelength': wavelength}, 180)
 
     async def get_turret_grating(self) -> Grating:
-        """Current grating of the turret
+        """Current grating of the turret.
+
+        .. note:: Prior to the initialization of the grating turret, this value may not reflect the actual position
+                  of the turret. To read the current position of the grating turret, please run
+                  :func:`Monochromator.home()` prior to running this command.
 
         Returns:
             Grating: current grating of turret. See :class:`Monochromator.Grating` for possible values.
 
         Raises:
-            Exception: When an error occured on the device side
+            Exception: When an error occurred on the device side
         """
         response: Response = await super()._execute_command('mono_getGratingPosition', {'index': self._id})
         return self.Grating(response.results['position'])
@@ -211,15 +235,18 @@ class Monochromator(AbstractDevice):
     async def set_turret_grating(self, grating: Grating) -> None:
         """Select turret grating
 
+        .. note:: Note: The turret sensor does not re-read the position each time it is moved, therefore the position
+                  may not be accurate prior to initialization. See note for get_turret_grating().
+
         Args:
-            position (Grating): new grating of the turret. See :class:`Monochromator.Grating` for possible values.
+            grating (Grating): new grating of the turret. See :class:`Monochromator.Grating` for possible values.
 
         Raises:
-            Exception: When an error occured on the device side
+            Exception: When an error occurred on the device side
         """
         await super()._execute_command('mono_moveGrating', {'index': self._id, 'position': grating.value})
 
-    async def get_filter_wheel_position(self) -> FilterWheelPosition:
+    async def get_filter_wheel_position(self, filter_wheel: FilterWheel) -> FilterWheelPosition:
         """Current position of the filter wheel.
 
         Returns:
@@ -227,16 +254,14 @@ class Monochromator(AbstractDevice):
             for possible values.
 
         Raises:
-            Exception: When an error occured on the device side
+            Exception: When an error occurred on the device side
         """
-        # TODO: refactor in case there can be more than one filter wheel. What should be done if no filter wheel is
-        # installed?
         response: Response = await super()._execute_command(
-            'mono_getFilterWheelPosition', {'index': self._id, 'type': 1}
+            'mono_getFilterWheelPosition', {'index': self._id, 'locationId': filter_wheel.value}
         )
         return self.FilterWheelPosition(response.results['position'])
 
-    async def set_filter_wheel_position(self, position: FilterWheelPosition) -> None:
+    async def set_filter_wheel_position(self, filter_wheel: FilterWheel, position: FilterWheelPosition) -> None:
         """Sets the current position of the filter wheel.
 
         Returns:
@@ -244,12 +269,10 @@ class Monochromator(AbstractDevice):
             for possible values.
 
         Raises:
-            Exception: When an error occured on the device side
+            Exception: When an error occurred on the device side
         """
-        # TODO: refactor in case there can be more than one filter wheel. What should be done if no filter wheel is
-        # installed?
         await super()._execute_command(
-            'mono_moveFilterWheel', {'index': self._id, 'type': 1, 'position': position.value}
+            'mono_moveFilterWheel', {'index': self._id, 'locationId': filter_wheel.value, 'position': position.value}
         )
 
     async def get_mirror_position(self, mirror: Mirror) -> MirrorPosition:
@@ -268,7 +291,7 @@ class Monochromator(AbstractDevice):
             Exception: When an error occurred on the device side
         """
         response: Response = await super()._execute_command(
-            'mono_getMirrorPosition', {'index': self._id, 'type': mirror.value}
+            'mono_getMirrorPosition', {'index': self._id, 'locationId': mirror.value}
         )
         return self.MirrorPosition(response.results['position'])
 
@@ -286,18 +309,15 @@ class Monochromator(AbstractDevice):
             Exception: When an error occurred on the device side
         """
         await super()._execute_command(
-            'mono_moveMirror', {'index': self._id, 'type': mirror.value, 'position': position.value}
+            'mono_moveMirror', {'index': self._id, 'locationId': mirror.value, 'position': position.value}
         )
 
     async def get_slit_position_in_mm(self, slit: Slit) -> float:
         """Returns the position in millimeters [mm] of the selected slit.
 
-        .. todo:: Get more information about possible values and explain elements contained in monochromator at top
-           of this class.
-
         Args:
             slit (Slit): desired slit to get the position from. See :class:`Monochromator.Slit` for possible
-            values
+
         Returns:
             float: position in mm
 
@@ -306,64 +326,53 @@ class Monochromator(AbstractDevice):
         """
 
         response: Response = await super()._execute_command(
-            'mono_getSlitPositionInMM', {'index': self._id, 'type': slit.value}
+            'mono_getSlitPositionInMM', {'index': self._id, 'locationId': slit.value}
         )
         return float(response.results['position'])
 
     async def set_slit_position(self, slit: Slit, position_in_mm: float) -> None:
         """Sets the position of the selected slit.
 
-        .. todo:: Get more information about possible values and explain elements contained in monochromator at top
-           of this class.
-
         Args:
             slit (Slit): desired slit to set the position. See :class:`Monochromator.Slit` for possible values.
-            position (float): position to set in millimeters [mm].
+            position_in_mm (float): position to set in millimeters [mm].
 
         Raises:
             Exception: When an error occurred on the device side
         """
         await super()._execute_command(
-            'mono_moveSlitMM', {'index': self._id, 'type': slit.value, 'position': position_in_mm}
+            'mono_moveSlitMM', {'index': self._id, 'locationId': slit.value, 'position': position_in_mm}
         )
 
-    async def get_slit_step_position(self, slit: Slit) -> SlitStepPosition:
-        """Returns the step position of the selected slit.
-
-        .. todo:: Get more information about possible values and explain elements contained in monochromator at top
-           of this class.
+    async def get_slit_step_position(self, slit: Slit) -> int:
+        """Returns the position of the specified slit in steps.
 
         Args:
             slit (Slit): desired slit to get the position from. See :class:`Monochromator.Slit` for possible
-            values
         Returns:
-            SlitStepPosition: step position. See :class:`Monochromator.SlitStepPosition` for possible values
+            int: step position.
 
         Raises:
             Exception: When an error occurred on the device side
         """
 
         response: Response = await super()._execute_command(
-            'mono_getSlitStepPosition', {'index': self._id, 'type': slit.value}
+            'mono_getSlitStepPosition', {'index': self._id, 'locationId': slit.value}
         )
-        return self.SlitStepPosition(response.results['position'])
+        return int(response.results['position'])
 
-    async def set_slit_step_position(self, slit: Slit, step_position: SlitStepPosition) -> None:
-        """Sets the step position of the selected slit.
-
-        .. todo:: Get more information about possible values and explain elements contained in monochromator at top
-           of this class.
+    async def set_slit_step_position(self, slit: Slit, step_position: int) -> None:
+        """Moves the specified slit to the position in steps.
 
         Args:
             slit (Slit): desired slit to set the step position. See :class:`Monochromator.Slit` for possible values.
-            step_position (SlitStepPosition): the step position. See :class:`Monochromator.SlitStepPosition` for
-            possible values
+            step_position (int): the step position.
 
         Raises:
             Exception: When an error occurred on the device side
         """
         await super()._execute_command(
-            'mono_moveSlit', {'index': self._id, 'type': slit.value, 'position': step_position.value}
+            'mono_moveSlit', {'index': self._id, 'locationId': slit.value, 'position': step_position}
         )
 
     async def open_shutter(self) -> None:
@@ -382,7 +391,7 @@ class Monochromator(AbstractDevice):
         """
         await super()._execute_command('mono_shutterClose', {'index': self._id})
 
-    async def get_shutter_position(self) -> ShutterPosition:
+    async def get_shutter_position(self, shutter: Shutter) -> ShutterPosition:
         """Returns the shutter position.
 
         Returns:
@@ -392,4 +401,11 @@ class Monochromator(AbstractDevice):
             Exception: When an error occurred on the device side
         """
         response: Response = await super()._execute_command('mono_getShutterStatus', {'index': self._id})
-        return self.ShutterPosition(response.results['position'])
+        # TODO: How many shutters are there?
+        if shutter == self.Shutter.FIRST:
+            return self.ShutterPosition(response.results['shutter 1'])
+        elif shutter == self.Shutter.SECOND:
+            return self.ShutterPosition(response.results['shutter 2'])
+        else:
+            logger.error(f'shutter {shutter} not implemented')
+            raise Exception('shutter not implemented')

horiba_sdk/sync/communication/abstract_communicator.py

@@ -26,14 +26,13 @@ class AbstractCommunicator(ABC):
         pass
 
     @abstractmethod
-    def request_with_response(self, command: Command, time_to_wait_for_response_in_s: float = 0.1) -> Response:
+    def request_with_response(self, command: Command, response_timeout_s: float = 5) -> Response:
         """
         Abstract method to fetch a response from a command.
 
         Args:
             command (Command): Command for which a response is desired
-            time_to_wait_for_response_in_s (float, optional): Time, in seconds, to wait between request and response.
-            Defaults to 0.1s
+            response_timeout_s (float, optional): Timeout in seconds. Defaults to 5.
 
         Returns:
             Response: The response corresponding to the sent command.

horiba_sdk/sync/communication/websocket_communicator.py

@@ -28,7 +28,7 @@ class WebsocketCommunicator(AbstractCommunicator):
         self.listen_thread: Optional[Thread] = None
         self.running_binary_message_handling_thread: bool = False
         self.binary_message_handling_thread: Optional[Thread] = None
-        self.json_message_queue: Queue[str] = Queue()
+        self.json_message_dict: dict[int, JSONResponse] = {}
         self.binary_message_queue: Queue[bytes] = Queue()
         self.binary_message_callback: Optional[Callable[[bytes], Any]] = None
         self.icl_info: dict[str, Any] = {}
@@ -99,8 +99,12 @@ class WebsocketCommunicator(AbstractCommunicator):
         """
         return self.websocket is not None
 
-    def response(self) -> Response:
-        """Fetches the next response
+    def response(self, command_id: int, timeout_s: float = 5.0) -> Response:
+        """Fetches the response belonging to the command_id.
+
+        Args:
+            command_id (int): The command id of the command.
+            timeout_s (float): The timeout in seconds.
 
         Returns:
             Response: The response from the server
@@ -108,13 +112,27 @@ class WebsocketCommunicator(AbstractCommunicator):
         Raises:
             CommunicationException: When the connection terminated with an error
         """
-        if not self.json_message_queue or self.json_message_queue.empty():
-            raise CommunicationException(None, 'No message to be received.')
-
-        logger.debug(f'#{self.json_message_queue.qsize()} messages in the queue, taking first')
-        response: str = self.json_message_queue.get()
-        logger.debug('retrieved message in queue')
-        return JSONResponse(response)
+        waited_time_in_s: float = 0.0
+        sleep_time_in_s: float = 0.1
+        while waited_time_in_s < timeout_s and (
+            not self.json_message_dict
+            or len(self.json_message_dict) == 0
+            or self.json_message_dict.get(command_id) is None
+        ):
+            time.sleep(sleep_time_in_s)
+            waited_time_in_s += sleep_time_in_s
+
+        if not self.json_message_dict or len(self.json_message_dict) == 0:
+            raise CommunicationException(None, 'no message to be received.')
+
+        if self.json_message_dict.get(command_id) is None:
+            raise CommunicationException(None, f'no response with id {command_id}')
+
+        logger.debug(f'#{len(self.json_message_dict)} messages, taking the one with id:{command_id}')
+        response: JSONResponse = self.json_message_dict[command_id]
+        del self.json_message_dict[command_id]
+        logger.debug('retrieved message in dict')
+        return response
 
     @override
     def close(self) -> None:
@@ -151,7 +169,7 @@ class WebsocketCommunicator(AbstractCommunicator):
             raise CommunicationException(None, 'Binary message callback already registered')
 
         self.binary_message_callback = callback
-        logger.info('Binary message callback registered.')
+        logger.debug('Binary message callback registered.')
         self.running_binary_message_handling_thread = True
         self.binary_message_handling_thread = Thread(target=self._run_binary_message_callback)
         self.binary_message_handling_thread.start()
@@ -166,7 +184,8 @@ class WebsocketCommunicator(AbstractCommunicator):
                 for message in self.websocket:
                     logger.debug(f'Received message: {message!r}')
                     if isinstance(message, str):
-                        self.json_message_queue.put(message)
+                        response: JSONResponse = JSONResponse(message)
+                        self.json_message_dict[response.id] = response
                     elif isinstance(message, bytes) and self.binary_message_callback:
                         self.binary_message_queue.put(message)
                     else:
@@ -192,21 +211,22 @@ class WebsocketCommunicator(AbstractCommunicator):
             self.binary_message_callback(binary_message)
 
     @override
-    def request_with_response(self, command: Command, time_to_wait_for_response_in_s: float = 0.1) -> Response:
+    def request_with_response(self, command: Command, response_timeout_s: float = 5) -> Response:
         """
         Concrete method to fetch a response from a command.
 
         Args:
             command (Command): Command for which a response is desired
-            time_to_wait_for_response_in_s (float, optional): Time, in seconds, to wait between request and response.
-            Defaults to 0.1s
+            response_timeout_s (float, optional): Timeout in seconds. Defaults to 5.
 
         Returns:
             Response: The response corresponding to the sent command.
         """
         self.send(command)
-        logger.debug('sent command, waiting for response')
-        time.sleep(time_to_wait_for_response_in_s)
-        response: Response = self.response()
+        response: Response = self.response(command.id, response_timeout_s)
+
+        if response.id != command.id:
+            logger.error(f'got wrong response id: {response.id}, command id: {command.id}')
+            raise Exception('got wrong response id')
 
         return response

horiba_sdk/sync/devices/device_discovery.py

@@ -1,5 +1,4 @@
-import re
-from typing import Any, final
+from typing import final
 
 from loguru import logger
 from overrides import override
@@ -37,41 +36,18 @@ class DeviceDiscovery(AbstractDeviceDiscovery):
                 raise Exception(f'No {device_type} connected')
             response = self._communicator.request_with_response(Command(list_command, {}))
 
-            # as the responses of ccd_list and mono_list differ, we need to parse them separately
-            if device_type == 'CCD':
-                raw_device_list = response.results
-                self._charge_coupled_devices = self._parse_ccds(raw_device_list)
-                logger.info(f'Found {len(self._charge_coupled_devices)} CCD devices: {self._charge_coupled_devices}')
-            elif device_type == 'Monochromator':
-                raw_device_list = response.results['list']
-                self._monochromators = self._parse_monos(raw_device_list)
-                logger.info(f'Found {len(self._monochromators)} Monochromator devices: {self._monochromators}')
-
-    def _parse_ccds(self, raw_device_list: dict[str, Any]) -> list[ChargeCoupledDevice]:
-        detected_ccds: list[ChargeCoupledDevice] = []
-        for key, value in raw_device_list.items():
-            logger.debug(f'Parsing CCD: {key} - {value}')
-            ccd_index: int = int(key.split(':')[0].replace('index', '').strip())
-            ccd_type_match = re.search(r'deviceType: (.*?),', value)
-            if not ccd_type_match:
-                raise Exception(f'Failed to find ccd type "deviceType" in string "{value}"')
-            ccd_type: str = str(ccd_type_match.group(1).strip())
-
-            logger.info(f'Detected CCD: {ccd_type}')
-            detected_ccds.append(ChargeCoupledDevice(ccd_index, self._communicator, self._error_db))
-
-        return detected_ccds
-
-    def _parse_monos(self, raw_device_list: dict[str, Any]) -> list[Monochromator]:
-        detected_monos = []
-        for device_string in raw_device_list:
-            mono_index: int = int(device_string.split(';')[0])
-            mono_type: str = device_string.split(';')[1]
-
-            logger.info(f'Detected Monochromator: {mono_type}')
-            detected_monos.append(Monochromator(mono_index, self._communicator, self._error_db))
-
-        return detected_monos
+            for device in response.results['devices']:
+                if device_type == 'CCD':
+                    ccd = ChargeCoupledDevice(device['index'], self._communicator, self._error_db)
+                    logger.info(f'Detected CCD: {device["deviceType"]}')
+                    self._charge_coupled_devices.append(ccd)
+                elif device_type == 'Monochromator':
+                    mono = Monochromator(device['index'], self._communicator, self._error_db)
+                    logger.info(f'Detected Monochromator: {device["deviceType"]}')
+                    self._monochromators.append(mono)
+
+        logger.info(f'Found {len(self._monochromators)} Monochromator devices')
+        logger.info(f'Found {len(self._charge_coupled_devices)} CCD devices')
 
     @override
     def charge_coupled_devices(self) -> list[ChargeCoupledDevice]:

horiba_sdk/sync/devices/device_manager.py

@@ -3,6 +3,7 @@ Synchronous Device Manager Module
 
 This Device Manager uses threads instead of asyncio
 """
+
 import importlib.resources
 import platform
 import subprocess
@@ -30,8 +31,8 @@ class DeviceManager(AbstractDeviceManager):
     def __init__(
         self,
         start_icl: bool = True,
-        websocket_ip: str = '127.0.0.1',
-        websocket_port: str = '25010',
+        icl_ip: str = '127.0.0.1',
+        icl_port: str = '25010',
         enable_binary_messages: bool = True,
     ):
         """
@@ -39,17 +40,15 @@ class DeviceManager(AbstractDeviceManager):
 
         Args:
             start_icl (bool) = True: If True, the ICL software is started and communication is established.
-            websocket_ip (str) = '127.0.0.1': websocket IP
-            websocket_port (str) = '25010': websocket port
+            icl_ip (str) = '127.0.0.1': websocket IP
+            icl_port (str) = '25010': websocket port
             enable_binary_messages (bool) = True: If True, binary messages are enabled.
         """
         super().__init__()
         self._start_icl = start_icl
-        self._icl_communicator: WebsocketCommunicator = WebsocketCommunicator(
-            'ws://' + websocket_ip + ':' + str(websocket_port)
-        )
-        self._icl_websocket_ip: str = websocket_ip
-        self._icl_websocket_port: str = websocket_port
+        self._icl_communicator: WebsocketCommunicator = WebsocketCommunicator('ws://' + icl_ip + ':' + str(icl_port))
+        self._icl_websocket_ip: str = icl_ip
+        self._icl_websocket_port: str = icl_port
         self._icl_process: Optional[Popen[bytes]] = None
         self._binary_messages: bool = enable_binary_messages
         self._charge_coupled_devices: list[ChargeCoupledDevice] = []
@@ -76,7 +75,12 @@ class DeviceManager(AbstractDeviceManager):
 
     @override
     def stop(self) -> None:
-        self.stop_icl()
+        if self._start_icl:
+            self.stop_icl()
+            return
+
+        if self._icl_communicator.opened():
+            self._icl_communicator.close()
 
     def start_icl(self) -> None:
         """

horiba_sdk/sync/devices/fake_icl_server.py

@@ -55,14 +55,17 @@ class FakeICLServer:
                 websocket.send(message)
                 continue
             if command['command'].startswith('icl_'):
-                response = json.dumps(self.icl_responses[command['command']])
-                websocket.send(response)
+                response = self.icl_responses[command['command']]
+                response['id'] = command['id']
+                websocket.send(json.dumps(response))
             elif command['command'].startswith('mono_'):
-                response = json.dumps(self.monochromator_responses[command['command']])
-                websocket.send(response)
+                response = self.monochromator_responses[command['command']]
+                response['id'] = command['id']
+                websocket.send(json.dumps(response))
             elif command['command'].startswith('ccd_'):
-                response = json.dumps(self.ccd_responses[command['command']])
-                websocket.send(response)
+                response = self.ccd_responses[command['command']]
+                response['id'] = command['id']
+                websocket.send(json.dumps(response))
             else:
                 logger.info('unknown command, responding with message')
                 websocket.send(message)