horiba-sdk 0.3.2__py3-none-any.whl

horiba_sdk/sync/devices/single_devices/ccd.py

@@ -0,0 +1,219 @@
+from enum import Enum
+from types import TracebackType
+from typing import Any, Optional, Union, final
+
+import pint
+from loguru import logger
+from overrides import override
+
+from horiba_sdk import ureg
+from horiba_sdk.communication import Response
+from horiba_sdk.core.resolution import Resolution
+from horiba_sdk.icl_error import AbstractErrorDB
+from horiba_sdk.sync.communication.abstract_communicator import AbstractCommunicator
+from horiba_sdk.sync.devices.single_devices.abstract_device import AbstractDevice
+
+
+@final
+class ChargeCoupledDevice(AbstractDevice):
+    """Charge Coupled Device
+
+    This class should not be instanced by the end user. Instead, the :class:`horiba_sdk.devices.DeviceManager`
+    should be used to access the detected CCDs on the system.
+    """
+
+    @final
+    class XAxisConversionType(Enum):
+        NONE = 0
+        FROM_CCD_FIRMWARE = 1
+        FROM_ICL_SETTINGS_INI = 2
+
+    def __init__(self, device_id: int, communicator: AbstractCommunicator, error_db: AbstractErrorDB) -> None:
+        super().__init__(device_id, communicator, error_db)
+
+    def __enter__(self) -> 'ChargeCoupledDevice':
+        self.open()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[type[BaseException]],
+        exc_value: Optional[BaseException],
+        traceback: Optional[TracebackType],
+    ) -> None:
+        is_open = self.is_open()
+        if not is_open:
+            logger.debug('CCD is already closed')
+            return
+
+        self.close()
+
+    @override
+    def open(self) -> None:
+        """Opens the connection to the Charge Coupled Device
+
+        Raises:
+            Exception: When an error occurred on the device side
+        """
+        super().open()
+        super()._execute_command('ccd_open', {'index': self._id})
+
+    @override
+    def close(self) -> None:
+        """Closes the connection to the ChargeCoupledDevice
+
+        Raises:
+            Exception: When an error occurred on the device side
+        """
+        super()._execute_command('ccd_close', {'index': self._id})
+
+    def is_open(self) -> bool:
+        """Checks if the connection to the charge coupled device is open.
+
+        Raises:
+            Exception: When an error occurred on the device side
+        """
+        response: Response = super()._execute_command('ccd_isOpen', {'index': self._id})
+        return bool(response.results['open'])
+
+    def get_temperature(self) -> pint.Quantity:
+        """Chip temperature of the CCD.
+
+        Returns:
+            pint.Quantity: chip's temperature in degree Celsius
+
+        Raises:
+            Exception: When an error occurred on the device side
+        """
+        response: Response = super()._execute_command('ccd_getChipTemperature', {'index': self._id})
+        return ureg.Quantity(response.results['temperature'], ureg.degC)  # type: ignore
+
+    def get_chip_size(self) -> Resolution:
+        """Chip resolution of the CCD.
+
+        Returns:
+            Resolution: chip resolution (width, height)
+
+        Raises:
+            Exception: When an error occurred on the device side
+        """
+        response: Response = super()._execute_command('ccd_getChipSize', {'index': self._id})
+        width: int = response.results['x']
+        height: int = response.results['y']
+        resolution: Resolution = Resolution(width, height)
+        return resolution
+
+    def get_speed(self) -> Union[pint.Quantity, None]:
+        """Chip transfer speed in kHz
+
+        Returns:
+            pint.Quantity: Transfer speed in kilo Hertz
+
+        Raises:
+            Exception: When an error occurred on the device side
+        """
+        response: Response = super()._execute_command('ccd_getSpeed', {'index': self._id})
+        return ureg(response.results['info'])
+
+    def get_exposure_time(self) -> Union[pint.Quantity, None]:
+        """Returns the exposure time in ms
+
+        Returns:
+            pint.Quantity: Exposure time in ms
+        Raises:
+            Exception: When an error occurred on the device side
+        """
+        response: Response = super()._execute_command('ccd_getExposureTime', {'index': self._id})
+        exposure = ureg.Quantity(response.results['time'], 'ms')
+        return exposure
+
+    def set_exposure_time(self, exposure_time_ms: int) -> None:
+        """Sets the exposure time in ms
+
+        Args:
+            exposure_time_ms (int): Exposure time in ms
+        Raises:
+            Exception: When an error occurred on the device side
+        """
+
+        super()._execute_command('ccd_setExposureTime', {'index': self._id, 'time': exposure_time_ms})
+
+    def get_acquisition_ready(self) -> bool:
+        """Returns true if the CCD is ready to acquire
+
+        Returns:
+            bool: True if the CCD is ready to acquire
+        Raises:
+            Exception: When an error occurred on the device side
+        """
+        response: Response = super()._execute_command('ccd_getAcquisitionReady', {'index': self._id})
+        return bool(response.results['ready'])
+
+    def set_acquisition_start(self, open_shutter: bool) -> None:
+        """Starts the acquisition of the CCD
+
+        Args:
+            open_shutter (bool): Whether the shutter of the camera should be open
+        Raises:
+            Exception: When an error occurred on the device side
+        """
+        super()._execute_command('ccd_setAcquisitionStart', {'index': self._id, 'openShutter': open_shutter})
+
+    def set_region_of_interest(
+        self,
+        roi_index: int = 1,
+        x_origin: int = 0,
+        y_origin: int = 0,
+        x_size: int = 1024,
+        y_size: int = 256,
+        x_bin: int = 1,
+        y_bin: int = 256,
+    ) -> None:
+        """Sets the region of interest of the CCD
+        an example json command looks like this:
+
+        Args:
+            roi_index (int, optional): Index of the region of interest. Defaults to 1.
+            x_origin (int, optional): X origin of the region of interest. Defaults to 0.
+            y_origin (int, optional): Y origin of the region of interest. Defaults to 0.
+            x_size (int, optional): X size of the region of interest. Defaults to 1024.
+            y_size (int, optional): Y size of the region of interest. Defaults to 256.
+            x_bin (int, optional): X bin of the region of interest. Defaults to 1.
+            y_bin (int, optional): Y bin of the region of interest. Defaults to 256.
+
+        Raises:
+            Exception: When an error occurred on the device side
+        """
+        super()._execute_command(
+            'ccd_setRoi',
+            {
+                'index': self._id,
+                'roiIndex': roi_index,
+                'xOrigin': x_origin,
+                'yOrigin': y_origin,
+                'xSize': x_size,
+                'ySize': y_size,
+                'xBin': x_bin,
+                'yBin': y_bin,
+            },
+        )
+
+    def get_acquisition_data(self) -> dict[Any, Any]:
+        """Returns the acquisition data of the CCD
+        nina: atm this returns data still formatted for telnet communication, not formatted as json"""
+        response: Response = super()._execute_command('ccd_getAcquisitionData', {'index': self._id})
+        return response.results
+
+    def get_acquisition_busy(self) -> bool:
+        """Returns true if the CCD is busy with the acquisition"""
+        response: Response = super()._execute_command('ccd_getAcquisitionBusy', {'index': self._id})
+        return bool(response.results['isBusy'])
+
+    def set_x_axis_conversion_type(self, conversion_type: XAxisConversionType) -> None:
+        """Sets the conversion type of the x axis"""
+        super()._execute_command('ccd_setXAxisConversionType', {'index': self._id, 'type': conversion_type.value})
+
+    def get_x_axis_conversion_type(self) -> XAxisConversionType:
+        """Gets the conversion type of the x axis"""
+        response: Response = super()._execute_command('ccd_getXAxisConversionType', {'index': self._id})
+        return self.XAxisConversionType(response.results['type'])

horiba_sdk/sync/devices/single_devices/monochromator.py

@@ -0,0 +1,150 @@
+from types import TracebackType
+from typing import Optional, final
+
+from loguru import logger
+from numericalunits import nm
+from overrides import override
+
+from horiba_sdk.communication import Response
+from horiba_sdk.icl_error import AbstractErrorDB
+from horiba_sdk.sync.communication.abstract_communicator import AbstractCommunicator
+from horiba_sdk.sync.devices.single_devices.abstract_device import AbstractDevice
+
+
+@final
+class Monochromator(AbstractDevice):
+    """Monochromator device
+
+    This class should not be instanced by the end user. Instead, the :class:`horiba_sdk.sync.devices.DeviceManager`
+    should be used to access the detected Monochromators on the system.
+    """
+
+    def __init__(self, device_id: int, communicator: AbstractCommunicator, error_db: AbstractErrorDB) -> None:
+        super().__init__(device_id, communicator, error_db)
+
+    def __enter__(self) -> 'Monochromator':
+        self.open()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[type[BaseException]],
+        exc_value: Optional[BaseException],
+        traceback: Optional[TracebackType],
+    ) -> None:
+        if not self.is_open():
+            logger.debug('Monochromator is already closed')
+            return
+
+        self.close()
+
+    @override
+    def open(self) -> None:
+        """Opens the connection to the Monochromator
+
+        Raises:
+            Exception: When an error occured on the device side
+        """
+        super().open()
+        super()._execute_command('mono_open', {'index': self._id}, 0.5)
+
+    @override
+    def close(self) -> None:
+        """Closes the connection to the Monochromator
+
+        Raises:
+            Exception: When an error occured on the device side
+        """
+        super()._execute_command('mono_close', {'index': self._id})
+
+    def is_open(self) -> bool:
+        """Checks if the connection to the monochromator is open.
+
+        Raises:
+            Exception: When an error occured on the device side
+        """
+        response: Response = super()._execute_command('mono_isOpen', {'index': self._id})
+        return bool(response.results['open'])
+
+    @property
+    def is_busy(self) -> bool:
+        """Checks if the monochromator is busy.
+
+        Raises:
+            Exception: When an error occured on the device side
+        """
+        response: Response = super()._execute_command('mono_isBusy', {'index': self._id})
+        return bool(response.results['busy'])
+
+    def home(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
+        """
+        super()._execute_command('mono_init', {'index': self._id})
+
+    @property
+    def wavelength(self) -> nm:
+        """Current wavelength of the monochromator's position in nm.
+
+        Raises:
+            Exception: When an error occured on the device side
+        """
+        response = super()._execute_command('mono_getPosition', {'index': self._id})
+        return float(response.results['wavelength']) * nm
+
+    def set_current_wavelength(self, wavelength: int) -> None:
+        """This command sets the wavelength value of the current grating position of the monochromator.
+
+        .. warning:: This could potentially uncalibrate the monochromator and report an incorrect wavelength compared to
+                     the actual output wavelength.
+
+        Args:
+            wavelength (nm): wavelength
+
+        Raises:
+            Exception: When an error occured on the device side
+        """
+        super()._execute_command('mono_setPosition', {'index': self._id, 'wavelength': wavelength})
+
+    def move_to_wavelength(self, wavelength: nm) -> None:
+        """Orders the monochromator to move to the requested wavelength.
+
+        Use :func:`Monochromator.is_busy()` to know if the operation is still taking place.
+
+        Args:
+            wavelength (nm): wavelength
+
+        Raises:
+            Exception: When an error occured on the device side
+        """
+        super()._execute_command('mono_moveToPosition', {'index': self._id, 'wavelength': wavelength / nm})
+
+    @property
+    def turret_grating_position(self) -> int:
+        """Grating turret position.
+
+        Returns:
+            int: current grating turret position
+
+        Raises:
+            Exception: When an error occured on the device side
+        """
+        response: Response = super()._execute_command('mono_getGratingPosition', {'index': self._id})
+        return int(response.results['position'])
+
+    def move_turret_to_grating(self, position: int) -> None:
+        """Move turret to grating position
+
+        .. todo:: Get more information about how it works and clarify veracity of returned data
+
+        Args:
+            position (int): new grating position
+
+        Raises:
+            Exception: When an error occured on the device side
+        """
+        super()._execute_command('mono_getPosition', {'index': self._id, 'position': position})

horiba_sdk-0.3.2.dist-info/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+Copyright (c) 2023 ZühlkeEngineering
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+OR OTHER DEALINGS IN THE SOFTWARE.