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

horiba_sdk/devices/single_devices/ccd.py

@@ -1,14 +1,15 @@
-from enum import Enum
 from types import TracebackType
 from typing import Any, Optional, final
 
-import pint
 from loguru import logger
 from overrides import override
 
-from horiba_sdk import ureg
 from horiba_sdk.communication import AbstractCommunicator, Response
+from horiba_sdk.core.acquisition_format import AcquisitionFormat
+from horiba_sdk.core.clean_count_mode import CleanCountMode
 from horiba_sdk.core.resolution import Resolution
+from horiba_sdk.core.timer_resolution import TimerResolution
+from horiba_sdk.core.x_axis_conversion_type import XAxisConversionType
 from horiba_sdk.icl_error import AbstractErrorDB
 
 from .abstract_device import AbstractDevice
@@ -22,40 +23,6 @@ class ChargeCoupledDevice(AbstractDevice):
     should be used to access the detected CCDs on the system.
     """
 
-    @final
-    class Gain(Enum):
-        HIGH_LIGHT = 0
-        BEST_DYNAMIC_RANGE = 1
-        HIGH_SENSITIVITY = 2
-
-    @final
-    class Speed(Enum):
-        SLOW_45_kHz = 0
-        MEDIUM_1_MHz = 1
-        FAST_1_MHz_Ultra = 2
-
-    @final
-    class AcquisitionFormat(Enum):
-        SPECTRA = 0
-        IMAGE = 1
-        CROP = 2
-        FAST_KINETICS = 3
-
-    @final
-    class CleanCountMode(Enum):
-        Mode1 = 238
-
-    @final
-    class XAxisConversionType(Enum):
-        """
-        Enumeration of possible XAxisConversionTypes
-        None = 0, CCD-Firmware = 1, ICL ini settings file = 2
-        """
-
-        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)
 
@@ -82,6 +49,7 @@ class ChargeCoupledDevice(AbstractDevice):
         """
         await super().open()
         await super()._execute_command('ccd_open', {'index': self._id})
+        self._config: dict[str, Any] = await self.get_configuration()
 
     @override
     async def close(self) -> None:
@@ -121,131 +89,156 @@ class ChargeCoupledDevice(AbstractDevice):
             Exception: When an error occurred on the device side
         """
         response: Response = await super()._execute_command('ccd_getConfig', {'index': self._id})
-        return response.results
+        return response.results['configuration']
+
+    async def get_gain_token(self) -> int:
+        """Returns the current gain token.
 
-    async def get_number_of_averages(self) -> int:
-        """Returns the number of averages of the CCD
+        .. note:: The CCD can have different sensors installed, which can have different gain values. This is why only
+        the token to the gain is returned. You need to first check what gain values are available for the CCD using the
+        get_configuration function. Please see the according "Gain and Speed" documentation.
 
         Returns:
-            int: Number of averages
+            int: Gain token of the ccd
 
         Raises:
             Exception: When an error occurred on the device side
         """
-        response: Response = await super()._execute_command('ccd_getNumberOfAvgs', {'index': self._id})
-        return int(response.results['count'])
+        response: Response = await super()._execute_command('ccd_getGain', {'index': self._id})
+        gain: int = int(response.results['token'])
+        return gain
+
+    async def set_gain(self, gain_token: int) -> None:
+        """Sets the gain of the CCD.
 
-    async def set_number_of_averages(self, number_of_averages: int) -> None:
-        """Sets the number of averages of the CCD
+        .. note:: The CCD can have different sensors installed, which can have different gain values. Therefore you need
+        to first check what gain values are available for the CCD using the get_configuration function. Please see the
+        according "Gain and Speed" documentation.
 
         Args:
-            number_of_averages (int): Number of averages
+            gain_token (int): Token of the desired gain
 
         Raises:
             Exception: When an error occurred on the device side
         """
-        await super()._execute_command('ccd_setNumberOfAvgs', {'index': self._id, 'count': number_of_averages})
+        await super()._execute_command('ccd_setGain', {'index': self._id, 'token': gain_token})
 
-    async def get_gain(self) -> str:
-        """Returns the gain of the CCD
+    async def get_speed_token(self) -> int:
+        """Returns the speed token.
+
+        .. note:: The CCD can have different sensors installed, which can have different speed values. This is why only
+        the token to the speed is returned. You need to first check what speed values are available for the CCD using
+        the get_configuration function. Please see the according "Gain and Speed" documentation.
 
         Returns:
-            str: Gain
+            int: Speed token of the CCD.
 
         Raises:
             Exception: When an error occurred on the device side
         """
-        response: Response = await super()._execute_command('ccd_getGain', {'index': self._id})
-        return str(response.results['info'])
+        response: Response = await super()._execute_command('ccd_getSpeed', {'index': self._id})
+        speed_token: int = int(response.results['token'])
+        return speed_token
 
-    async def set_gain(self, gain: Gain) -> None:
-        """Sets the gain of the CCD
+    async def set_speed(self, speed_token: int) -> None:
+        """Sets the speed of the CCD
+
+        .. note:: The CCD can have different sensors installed, which can have different speed values. Therefore you
+        need to first check what speed values are available for the CCD using the get_configuration function. Please
+        see the according "Gain and Speed" documentation.
 
         Args:
-            gain (Gain): Gain
+            speed_token (int): Token of the desired speed.
 
         Raises:
             Exception: When an error occurred on the device side
         """
-        await super()._execute_command('ccd_setGain', {'index': self._id, 'token': gain.value})
+        await super()._execute_command('ccd_setSpeed', {'index': self._id, 'token': speed_token})
 
-    async def get_speed(self) -> str:
-        """Returns the speed of the CCD
+    async def get_parallel_speed(self) -> int:
+        """Gets the current parallel speed token
 
         Returns:
-            str: Speed
+            int: current parallel speed token
 
         Raises:
             Exception: When an error occurred on the device side
         """
-        response: Response = await super()._execute_command('ccd_getSpeed', {'index': self._id})
-        return str(response.results['info'])
+        response: Response = await super()._execute_command('ccd_getParallelSpeed', {'index': self._id})
+        parallel_speed_token: int = int(response.results['token'])
+        return parallel_speed_token
 
-    async def set_speed(self, speed: Speed) -> None:
-        """Sets the speed of the CCD
-
-        Args:
-            speed (Speed): Speed
+    async def set_parallel_speed(self, parallel_speed_token: int) -> None:
+        """Sets the desired parallel speed token
 
         Raises:
             Exception: When an error occurred on the device side
         """
-        await super()._execute_command('ccd_setSpeed', {'index': self._id, 'token': speed.value})
+        await super()._execute_command('ccd_setParallelSpeed', {'index': self._id, 'token': parallel_speed_token})
 
-    async def get_fit_params(self) -> str:
+    async def get_fit_parameters(self) -> list[int]:
         """Returns the fit parameters of the CCD
 
         Returns:
-            str: Fit parameters
+            List[int]: Fit parameters
 
         Raises:
             Exception: When an error occurred on the device side
         """
         response: Response = await super()._execute_command('ccd_getFitParams', {'index': self._id})
-        return str(response.results['params'])
+        fit_params: list[int] = response.results['fitParameters']
+        return fit_params
 
-    async def set_fit_params(self, fit_params: str) -> None:
+    async def set_fit_parameters(self, fit_params: list[int]) -> None:
         """Sets the fit parameters of the CCD
 
         Args:
-            fit_params (str): Fit parameters
+            fit_params (List[int]): Fit parameters
 
         Raises:
             Exception: When an error occurred on the device side
         """
-        await super()._execute_command('ccd_setFitParams', {'index': self._id, 'params': fit_params})
+        fit_params_str: str = ','.join(map(str, fit_params))
+        await super()._execute_command('ccd_setFitParams', {'index': self._id, 'params': fit_params_str})
 
-    async def get_timer_resolution(self) -> int:
-        """Returns the timer resolution of the CCD
+    async def get_timer_resolution(self) -> TimerResolution:
+        """Returns the timer resolution of the CCD in microseconds [μs]
 
         Returns:
-            int: Timer resolution
+            int: Timer resolution in microseconds [μs]
 
         Raises:
             Exception: When an error occurred on the device side
         """
         response: Response = await super()._execute_command('ccd_getTimerResolution', {'index': self._id})
-        return int(response.results['resolution'])
+        timer_resolution: int = int(response.results['resolutionToken'])
+        return TimerResolution(timer_resolution)
 
-    async def set_timer_resolution(self, timer_resolution: int) -> None:
+    async def set_timer_resolution(self, timer_resolution: TimerResolution) -> None:
         """Sets the timer resolution of the CCD
 
+        .. note:: The timer resolution value of 1 microsecond is not supported by all CCDs.
+
         Args:
             timer_resolution (int): Timer resolution
 
         Raises:
             Exception: When an error occurred on the device side
         """
-        await super()._execute_command('ccd_setTimerResolution', {'index': self._id, 'resolution': timer_resolution})
+        await super()._execute_command(
+            'ccd_setTimerResolution', {'index': self._id, 'resolutionToken': timer_resolution.value}
+        )
 
     async def set_acquisition_format(self, number_of_rois: int, acquisition_format: AcquisitionFormat) -> None:
-        """Sets the acquisition format and the number of ROIs (Regions of Interest) or areas. After using this command
-         to set the number of ROIs and format, the ccd_setRoi command should be used to define each ROI.
-         Note: The Crop (2) and Fast Kinetics (3) acquisition formats are not supported by every CCD.
+        """Sets the acquisition format and the number of ROIs (Regions of Interest) or areas.
+
+        After using this command to set the number of ROIs and format, the set_region_of_interest function
+        should be used to define each ROI. Note: The Crop and Fast Kinetics acquisition formats are not
+        supported by every CCD.
 
         Args:
-            acquisition_format (AcquisitionFormat): Acquisition format
             number_of_rois (int): Number of regions of interest
+            acquisition_format (AcquisitionFormat): Acquisition format
 
         Raises:
             Exception: When an error occurred on the device side
@@ -254,6 +247,45 @@ class ChargeCoupledDevice(AbstractDevice):
             'ccd_setAcqFormat', {'index': self._id, 'format': acquisition_format.value, 'numberOfRois': number_of_rois}
         )
 
+    async 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): One based 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
+        """
+        await 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,
+            },
+        )
+
     async def set_x_axis_conversion_type(self, conversion_type: XAxisConversionType) -> None:
         """Sets the X-axis pixel conversion type to be used when retrieving the acquisition data with the
         ccd_getAcquisitionData command.
@@ -274,13 +306,15 @@ class ChargeCoupledDevice(AbstractDevice):
         2 = Mono Wavelength parameters contained in the icl_settings.ini file
         """
         response: Response = await super()._execute_command('ccd_getXAxisConversionType', {'index': self._id})
-        return self.XAxisConversionType(self.XAxisConversionType(response.results['type']))
+        return XAxisConversionType(response.results['type'])
 
     async def set_acquisition_count(self, count: int) -> None:
-        """Sets the number of acquisitions to be performed. The acquisition count is used to perform multiple
-            acquisitions in a row.
+        """Sets the number of acquisition measurements to be performed sequentially by the hardware.
+
+        A count > 1 is commonly referred to as "MultiAcq".
+
         Args:
-            count (int): The number of acquisitions to be performed.
+            count (int): The number of acquisition measurements.
         """
         await super()._execute_command('ccd_setAcqCount', {'index': self._id, 'count': count})
 
@@ -291,11 +325,18 @@ class ChargeCoupledDevice(AbstractDevice):
         response: Response = await super()._execute_command('ccd_getAcqCount', {'index': self._id})
         return int(response.results['count'])
 
-    async def get_clean_count(self) -> str:
-        """Gets the clean count mode of the CCD and the according mode"""
+    async def get_clean_count(self) -> tuple[int, CleanCountMode]:
+        """Gets the number of cleans to be performed prior to measurement.
+
+        Returns:
+            Tuple[int, CleanCountMode]:
+                count: Number of cleans,
+                mode: Specifies how the cleans will be performed.
+        """
         response: Response = await super()._execute_command('ccd_getCleanCount', {'index': self._id})
-        answer: str = 'count: ' + str(response.results['count']) + ' ' + 'mode: ' + str(response.results['mode'])
-        return answer
+        count: int = int(response.results['count'])
+        mode: CleanCountMode = CleanCountMode(response.results['mode'])
+        return count, mode
 
     async def set_clean_count(self, count: int, mode: CleanCountMode) -> None:
         """Sets the clean count mode of the CCD and the according mode
@@ -305,8 +346,8 @@ class ChargeCoupledDevice(AbstractDevice):
         """
         await super()._execute_command('ccd_setCleanCount', {'index': self._id, 'count': count, 'mode': mode.value})
 
-    async def get_data_size(self) -> int:
-        """Returns the size of the data of the CCD
+    async def get_acquisition_data_size(self) -> int:
+        """Returns the size of the acquisition data of the CCD
 
         Returns:
             int: Size of the data
@@ -317,17 +358,17 @@ class ChargeCoupledDevice(AbstractDevice):
         response: Response = await super()._execute_command('ccd_getDataSize', {'index': self._id})
         return int(response.results['size'])
 
-    async def get_temperature(self) -> pint.Quantity:
+    async def get_chip_temperature(self) -> float:
         """Chip temperature of the CCD.
 
         Returns:
-            pint.Quantity: chip's temperature in degree Celsius
+            float: chip's temperature in degree Celsius
 
         Raises:
             Exception: When an error occurred on the device side
         """
         response: Response = await super()._execute_command('ccd_getChipTemperature', {'index': self._id})
-        return ureg.Quantity(response.results['temperature'], ureg.degC)  # type: ignore
+        return float(response.results['temperature'])
 
     async def get_chip_size(self) -> Resolution:
         """Chip resolution of the CCD.
@@ -356,16 +397,176 @@ class ChargeCoupledDevice(AbstractDevice):
         exposure = int(response.results['time'])
         return exposure
 
-    async def set_exposure_time(self, exposure_time_ms: int) -> None:
-        """Sets the exposure time in ms
+    async def set_exposure_time(self, exposure_time: int) -> None:
+        """Sets the exposure time in timer resolution units (1us or 1000us)
+
+        Examples:
+        - If exposure_time is set to 50, and the timer resolution value is 1000, the CCD exposure time
+          (integration time) = 50 milliseconds.
+        - If exposure_time is set to 50, and the timer resolution value is 1, the CCD exposure time
+          (integration time) = 50 microseconds.
 
         Args:
-            exposure_time_ms (int): Exposure time in ms
+            exposure_time (int): Exposure time in timer resolution units (1us or 1000us)
+        Raises:
+            Exception: When an error occurred on the device side
+        """
+
+        await super()._execute_command('ccd_setExposureTime', {'index': self._id, 'time': exposure_time})
+
+    async def get_trigger_input(self) -> tuple[bool, int, int, int]:
+        """This command is used to get the current setting of the input trigger.
+
+        The address, event, and signalType parameters are used to define the input trigger based on the
+        supported options of that particular CCD.
+
+        The supported trigger options are retrieved using the get_configuration function, and begin with the
+        “Triggers” string contained in the configuration.
+
+        Returns:
+            Tuple[bool, int, int, int]:
+                enabled: Specifies if the signal is enabled (e.g. False = Disabled),
+                address: used to specify where the trigger is located. (e.g. 0 = Trigger Input).
+                         Note: Value of -1 indicates that the input trigger is disabled,
+                event: used to specify when the trigger event should occur. (e.g. 0 = Once - Start All)
+                       Note: Value of -1 indicates that the input trigger is disabled,
+                signal type: used to specify how the signal will cause the input trigger. (e.g. 0 = TTL Falling Edge)
+                       Note: Value of -1 indicates that the input trigger is disabled,
+
         Raises:
             Exception: When an error occurred on the device side
         """
+        response: Response = await super()._execute_command('ccd_getTriggerIn', {'index': self._id})
+        address = int(response.results['address'])
+        event = int(response.results['event'])
+        signal_type = int(response.results['signalType'])
+        enabled = address > -1 and event > -1 and signal_type > -1
+        return enabled, address, event, signal_type
 
-        await super()._execute_command('ccd_setExposureTime', {'index': self._id, 'time': exposure_time_ms})
+    async def set_trigger_input(self, enabled: bool, address: int, event: int, signal_type: int) -> None:
+        """This command is used to enable or disable the trigger input.
+
+        When enabling the trigger input, the address, event, and signalType parameters are used to define
+        the input trigger based on the supported options of that particular CCD.
+
+        The supported trigger options are retrieved using the get_configuration function, and begin with the
+        “Triggers” string contained in the configuration.
+
+        Args:
+            enabled (bool): Enable or disable the trigger input. Note: When disabling the input trigger,
+                            the address, event, and signalType parameters are ignored.
+            address (int): Used to specify where the trigger is located. (e.g. 0 = Trigger Input)
+            event (int): Used to specify when the trigger event should occur. (e.g. 0 = Once - Start All)
+            signal_type (int): Used to specify how the signal will cause the input trigger. (e.g. 0 = TTL Falling Edge)
+
+        Raises:
+            Exception: When an error occurred on the device side
+        """
+        if not enabled:
+            address = -1
+            event = -1
+            signal_type = -1
+
+            await super()._execute_command(
+                'ccd_setTriggerIn',
+                {'index': self._id, 'enable': enabled, 'address': address, 'event': event, 'signalType': signal_type},
+            )
+            return
+
+        found_triggers = [trigger for trigger in self._config['triggers'] if trigger['token'] == address]
+        if not found_triggers:
+            raise Exception(f'Trigger address {address} not found in the configuration')
+
+        found_events = [
+            trigger_event for trigger_event in found_triggers[0]['events'] if trigger_event['token'] == event
+        ]
+        if not found_events:
+            raise Exception(f'Trigger event {event} not found in the configuration')
+
+        found_signal_types = [signal for signal in found_events[0]['types'] if signal['token'] == signal_type]
+        if not found_signal_types:
+            raise Exception(f'Trigger signal type {signal_type} not found in the configuration')
+
+        await super()._execute_command(
+            'ccd_setTriggerIn',
+            {'index': self._id, 'enable': enabled, 'address': address, 'event': event, 'signalType': signal_type},
+        )
+
+    async def get_signal_output(self) -> tuple[bool, int, int, int]:
+        """This command is used to get the current setting of the signal output.
+
+        The address, event, and signalType parameters are used to define the signal based on the supported
+        options of that particular CCD.
+
+        The supported signal options are retrieved using the get_configuration command, and begin with the
+        “Signals” string contained in the configuration.
+
+        Returns:
+            Tuple[bool, int, int, int]:
+                enabled: Specifies if the signal is enabled (e.g. False = Disabled),
+                address: Used to specify where the signal is located (e.g. 0 = Signal Output),
+                         Note: Value of -1 indicates that the signal output is disabled,
+                event: Used to specify when the signal event should occur. (e.g. 3 = Shutter Open)
+                       Note: Value of -1 indicates that the signal output is disabled,
+                signal type: how the signal will cause the event. (e.g. 0 = TTL Active High)
+                       Note: Value of -1 indicates that the signal output is disabled,
+
+        Raises:
+            Exception: When an error occurred on the device side
+        """
+        response: Response = await super()._execute_command('ccd_getSignalOut', {'index': self._id})
+        address = int(response.results['address'])
+        event = int(response.results['event'])
+        signal_type = int(response.results['signalType'])
+        enabled = address > -1 and event > -1 and signal_type > -1
+        return enabled, address, event, signal_type
+
+    async def set_signal_output(self, enabled: bool, address: int, event: int, signal_type: int) -> None:
+        """This command is used to enable or disable the signal output.
+
+        When enabling the signal output, the address, event, and signalType parameters are used to
+        define the signal based on the supported options of that particular CCD.
+
+        The supported signal options are retrieved using the ccd_getConfig command, and begin with the
+        “Signals” string contained in the configuration.
+
+        Args:
+            enabled (bool): Enable or disable the signal output. Note: When disabling the signal output,
+                            the address, event, and signal_type parameters are ignored.
+            address (int): Used to specify where the signal is located (e.g. 0 = Signal Output)
+            event (int): Used to specify when the signal event should occur. (e.g. 3 = Shutter Open)
+            signal_type (int): How the signal will cause the event. (e.g. 0 = TTL Active High)
+
+        """
+        if not enabled:
+            address = -1
+            event = -1
+            signal_type = -1
+
+            await super()._execute_command(
+                'ccd_setSignalOut',
+                {'index': self._id, 'enable': enabled, 'address': address, 'event': event, 'signalType': signal_type},
+            )
+            return
+
+        found_triggers = [trigger for trigger in self._config['signals'] if trigger['token'] == address]
+        if not found_triggers:
+            raise Exception(f'Signal address {address} not found in the configuration')
+
+        found_events = [
+            trigger_event for trigger_event in found_triggers[0]['events'] if trigger_event['token'] == event
+        ]
+        if not found_events:
+            raise Exception(f'Signal event {event} not found in the configuration')
+
+        found_signal_types = [signal for signal in found_events[0]['types'] if signal['token'] == signal_type]
+        if not found_signal_types:
+            raise Exception(f'Signal type {signal_type} not found in the configuration')
+
+        await super()._execute_command(
+            'ccd_setSignalOut',
+            {'index': self._id, 'enable': enabled, 'address': address, 'event': event, 'signalType': signal_type},
+        )
 
     async def get_acquisition_ready(self) -> bool:
         """Returns true if the CCD is ready to acquire
@@ -378,66 +579,110 @@ class ChargeCoupledDevice(AbstractDevice):
         response: Response = await super()._execute_command('ccd_getAcquisitionReady', {'index': self._id})
         return bool(response.results['ready'])
 
-    async def set_acquisition_start(self, open_shutter: bool) -> None:
-        """Starts the acquisition of the CCD
+    async def acquisition_start(self, open_shutter: bool) -> None:
+        """Starts an acquisition that has been set up according to the previously defined acquisition parameters.
+
+        Note: To specify the acquisiton parameters please see set_region_of_interest, set_x_axis_conversion_type.
+        If there are no acquisition parameters set at the time of acquisition it may result in no data being generated.
 
         Args:
-            open_shutter (bool): Whether the shutter of the camera should be open
+            open_shutter (bool): Whether the shutter of the camera should be open during the acquisition.
         Raises:
             Exception: When an error occurred on the device side
         """
-        await super()._execute_command('ccd_setAcquisitionStart', {'index': self._id, 'openShutter': open_shutter})
+        await super()._execute_command('ccd_acquisitionStart', {'index': self._id, 'openShutter': open_shutter})
 
-    async 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:
+    async def get_acquisition_busy(self) -> bool:
+        """Returns true if the CCD is busy with the acquisition"""
+        response: Response = await super()._execute_command('ccd_getAcquisitionBusy', {'index': self._id})
+        return bool(response.results['isBusy'])
+
+    async def acquisition_abort(self) -> None:
+        """Stops the acquisition of the CCD"""
+        await super()._execute_command('ccd_acquisitionAbort', {'index': self._id})
+
+    async def get_acquisition_data(self) -> dict[Any, Any]:
+        """Retrieves data from the last acquisition.
+
+        The acquisition description string consists of the following information:
+        - acqIndex: Acquisition number
+        - roiIndex: Region of Interest number
+        - xOrigin: ROI’s X Origin
+        - yOrigin: ROI’s Y Origin
+        - xSize: ROI’s X Size
+        - ySize: ROI’s Y Size
+        - xBinning: ROI’s X Bin
+        - yBinning: ROI’s Y Bin
+        - Timestamp: This is a timestamp that relates to the time when the all the programmed acquisitions have
+                     completed. The data from all programmed acquisitions are retrieve from the CCD after all
+                     acquisitions have completed, therefore the same timestamp is used for all acquisitions.
+        """
+        response: Response = await super()._execute_command('ccd_getAcquisitionData', {'index': self._id})
+        return response.results['acquisition']
+
+    async def set_center_wavelength(self, mono_index: float, center_wavelength: float) -> None:
+        """Sets the center wavelength value to be used in the grating equation.
+
+        Used when X axis conversion is XAxisConversionType.FROM_ICL_SETTINGS_INI
 
         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.
+            mono_index (float): Index for which mono to pull info from icl_settings.ini for
+            center_wavelength (float): Center wavelength
 
         Raises:
             Exception: When an error occurred on the device side
         """
         await super()._execute_command(
-            'ccd_setRoi',
+            'ccd_setCenterWavelength',
+            {'index': self._id, 'monoIndex': mono_index, 'wavelength': center_wavelength},
+        )
+
+    async def range_mode_center_wavelengths(
+        self, monochromator_index: int, start_wavelength: float, end_wavelength: float, pixel_overlap: int
+    ) -> list[float]:
+        """Finds the center wavelength positions based on the input range and pixel overlap.
+
+        The following commands are prerequisites and should be called prior to using this command:
+        - :func:`ChargeCoupledDevice.set_x`,
+        - :func:`ChargeCoupledDevice.ccd_setAcqFormat`,
+        - :func:`ChargeCoupledDevice.ccd_setRoi`
+
+        Args:
+            monochromator_index (int): Index of the monochromator that is connected to the setup
+            start_wavelength (float): Start wavelength
+            end_wavelength (float): End wavelength
+            pixel_overlap (int): Overlap size in pixels between the scans.
+
+        Returns:
+            List[float]: List of center wavelength positions to cover the desired range.
+        Raises:
+            Exception: When an error occurred on the device side
+        """
+        response: Response = await super()._execute_command(
+            'ccd_calculateRangeModePositions',
             {
                 'index': self._id,
-                'roiIndex': roi_index,
-                'xOrigin': x_origin,
-                'yOrigin': y_origin,
-                'xSize': x_size,
-                'ySize': y_size,
-                'xBin': x_bin,
-                'yBin': y_bin,
+                'monoIndex': monochromator_index,
+                'start': start_wavelength,
+                'end': end_wavelength,
+                'overlap': pixel_overlap,
             },
         )
+        return response.results['centerWavelengths']
 
-    async 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 = await super()._execute_command('ccd_getAcquisitionData', {'index': self._id})
-        return response.results
+    @staticmethod
+    async def raman_convert(spectrum: list[float], excitation_wavelength: float) -> list[float]:
+        """Calculates the raman shift for every wavelength in the list relative to the excitation wavelength.
 
-    async def get_acquisition_busy(self) -> bool:
-        """Returns true if the CCD is busy with the acquisition"""
-        response: Response = await super()._execute_command('ccd_getAcquisitionBusy', {'index': self._id})
-        return bool(response.results['isBusy'])
+        Args:
+            spectrum (list[float]): Wavelengths
+            excitation_wavelength: Excitation wavelength
 
-    async def set_acquisition_abort(self) -> None:
-        """Stops the acquisition of the CCD"""
-        await super()._execute_command('ccd_setAcquisitionAbort', {'index': self._id})
+        Returns:
+            list[float]: Wavelengths converted to raman shifts
+        """
+        raman_values = []
+        for wave_length in spectrum:
+            raman_shift = ((1 / excitation_wavelength) - (1 / wave_length)) * (10**7)
+            raman_values.append(raman_shift)
+        return raman_values