pymodaq_plugins_andor 5.0.0__py3-none-any.whl

pymodaq_plugins_andor/__init__.py

@@ -0,0 +1,13 @@
+from pathlib import Path
+
+from pymodaq_utils.logger import set_logger, get_module_name
+
+from pathlib import Path
+from .utils import Config
+from pymodaq_utils.utils import get_version, PackageNotFoundError
+
+config = Config()
+try:
+    __version__ = get_version(__package__)
+except PackageNotFoundError:
+    __version__ = '0.0.0dev'

pymodaq_plugins_andor/daq_move_plugins/__init__.py

@@ -0,0 +1,14 @@
+import importlib
+from pathlib import Path
+from .. import set_logger
+
+logger = set_logger('move_plugins', add_to_console=False)
+
+for path in Path(__file__).parent.iterdir():
+    try:
+        if '__init__' not in str(path):
+            importlib.import_module('.' + path.stem, __package__)
+    except Exception as e:
+        logger.warning("{:} plugin couldn't be loaded due to some missing packages or errors: {:}".format(path.stem, str(e)))
+        pass
+

pymodaq_plugins_andor/daq_move_plugins/daq_move_Shamrock.py

@@ -0,0 +1,241 @@
+
+from easydict import EasyDict as edict
+from pymodaq.control_modules.move_utility_classes import DAQ_Move_base, comon_parameters_fun, main
+from pymodaq_utils.utils import ThreadCommand
+from pymodaq_plugins_andor.hardware import shamrock_sdk
+
+
+libpath = shamrock_sdk.dllpath
+
+
+class DAQ_Move_Shamrock(DAQ_Move_base):
+
+    _controller_units = 'nm'
+    is_multiaxes = False
+    axes_names = []  # "list of strings of the multiaxes
+    _epsilon = 0.1
+
+    params = [
+        {'title': 'Dll library:', 'name': 'andor_lib', 'type': 'browsepath', 'value': str(libpath), 'readonly': True},
+        {'title': 'Spectro Settings:', 'name': 'spectro_settings', 'type': 'group', 'expanded': True,
+            'children': [
+                {'title': 'Spectro SN:', 'name': 'spectro_serialnumber', 'type': 'str', 'value': '',
+                    'readonly': True},
+                {'title': 'Wavelength (nm):', 'name': 'spectro_wl', 'type': 'float', 'value': 600, 'min': 0,
+                    'readonly': True},
+                {'title': 'Home Wavelength (nm):', 'name': 'spectro_wl_home', 'type': 'float', 'value': 600, 'min': 0,
+                 'readonly': False},
+                {'title': 'Grating Settings:', 'name': 'grating_settings', 'type': 'group', 'expanded': True,
+                    'children': [
+                        {'title': 'Grating:', 'name': 'grating', 'type': 'list'},
+                        {'title': 'Lines (/mm):', 'name': 'lines', 'type': 'int', 'readonly': True},
+                        {'title': 'Blaze WL (nm):', 'name': 'blaze', 'type': 'str', 'readonly': True},
+                    ]},
+                {'title': 'Flip wavelength axis:', 'name': 'flip_wavelength', 'type': 'bool', 'value': False,
+                    'visible': False},
+                {'title': 'Go to zero order:', 'name': 'zero_order', 'type': 'bool'},
+            ]},
+        ] + comon_parameters_fun(is_multiaxes, axes_names, epsilon=_epsilon)
+
+    def commit_settings(self, param):
+        """
+            | Activate parameters changes on the hardware from parameter's name.
+            |
+
+            =============== ================================    =========================
+            **Parameters**   **Type**                           **Description**
+            *param*          instance of pyqtgraph parameter    The parameter to activate
+            =============== ================================    =========================
+
+            Three profile of parameter :
+                * **bin_x** : set binning camera from bin_x parameter's value
+                * **bin_y** : set binning camera from bin_y parameter's value
+                * **set_point** : Set the camera's temperature from parameter's value.
+
+        """
+        try:
+            if param.name() == 'grating':
+                index_grating = self.grating_list.index(param.value())
+                self.get_set_grating(index_grating)
+                self.set_wavelength(self.settings.child('spectro_settings', 'spectro_wl').value())
+
+            elif param.name() == 'spectro_wl':
+                self.set_wavelength(param.value())
+
+            elif param.name() == 'zero_order':
+                if param.value():
+                    param.setValue(False)
+                    self.emit_status(ThreadCommand('show_splash', "Moving to zero order, please wait!"))
+                    err = self.shamrock_controller.GotoZeroOrderSR(0)
+                    if err != 'SHAMROCK_SUCCESS':
+                        raise Exception(err)
+                    self.check_position()
+                    self.emit_status(ThreadCommand('close_splash'))
+
+        except Exception as e:
+            self.emit_status(ThreadCommand('Update_Status', [str(e), 'log']))
+
+    def ini_stage(self, controller=None):
+        """Actuator communication initialization
+
+        Parameters
+        ----------
+        controller: (object) custom object of a PyMoDAQ plugin (Slave case). None if only one actuator by controller (Master case)
+
+        Returns
+        -------
+        self.status (edict): with initialization status: three fields:
+            * info (str)
+            * controller (object) initialized controller
+            *initialized: (bool): False if initialization failed otherwise True
+        """
+        self.shamrock_controller = self.ini_stage_init(old_controller=controller,
+                                                       new_controller=shamrock_sdk.ShamrockSDK())
+
+        self.emit_status(ThreadCommand('show_splash', "Set/Get Shamrock's settings"))
+        self.ini_spectro()
+
+        initialized = True
+        self.emit_status(ThreadCommand('close_splash'))
+        return '', initialized
+
+    def get_actuator_value(self):
+        """Get the current position from the hardware with scaling conversion.
+
+        Returns
+        -------
+        float: The position obtained after scaling conversion.
+        """
+        pos = self.get_wavelength()
+        ##
+
+        pos = self.get_position_with_scaling(pos)
+        return pos
+
+    def move_abs(self, position):
+        """ Move the actuator to the absolute target defined by position
+
+        Parameters
+        ----------
+        position: (flaot) value of the absolute target positioning
+        """
+
+        position = self.check_bound(position)  # if user checked bounds, the defined bounds are applied here
+        position = self.set_position_with_scaling(position)  # apply scaling if the user specified one
+
+        self.set_wavelength(position)
+
+        ##############################
+
+        self.target_position = position
+        self.poll_moving()  # start a loop to poll the current actuator value and compare it with target position
+
+    def move_rel(self, position):
+        """ Move the actuator to the relative target actuator value defined by position
+
+        Parameters
+        ----------
+        position: (flaot) value of the relative target positioning
+        """
+        position = self.check_bound(self.current_position + position) - self.current_position
+        self.target_position = position + self.current_position
+
+        self.set_wavelength(self.target_position)
+        ##############################
+
+        self.poll_moving()
+
+    def move_home(self):
+        """
+
+        """
+        self.move_abs(self.settings.child('spectro_settings', 'spectro_wl_home').value())
+
+    def stop_motion(self):
+        """
+        Call the specific move_done function (depending on the hardware).
+
+        See Also
+        --------
+        move_done
+        """
+
+        self.move_done()  # to let the interface know the actuator stopped. Direct call as the setwavelength call is
+        # blocking anyway
+
+    def close(self):
+        """
+
+        """
+        if self.shamrock_controller is not None:
+            self.shamrock_controller.close()
+
+    def set_wavelength(self, wavelength):
+        self.emit_status(ThreadCommand('show_splash', "Setting wavelength, please wait!"))
+        err = self.shamrock_controller.SetWavelengthSR(0, wavelength)
+        self.emit_status(ThreadCommand('close_splash'))
+
+        if err != 'SHAMROCK_SUCCESS':
+            raise IOError(err)
+
+        self.get_wavelength()
+
+    def get_wavelength(self):
+        err, wl = self.shamrock_controller.GetWavelengthSR(0)
+        if err == "SHAMROCK_SUCCESS":
+            self.settings.child('spectro_settings', 'spectro_wl').setValue(wl)
+        return float(wl)
+
+    def ini_spectro(self):
+        self.settings.child('spectro_settings', 'spectro_serialnumber').setValue(
+            self.shamrock_controller.GetSerialNumberSR(0)[1].decode())
+
+        # get grating info
+        (err, Ngratings) = self.shamrock_controller.GetNumberGratingsSR(0)
+        self.grating_list = []
+        for ind_grating in range(1, Ngratings + 1):
+            (err, lines, blaze, home, offset) = self.shamrock_controller.GetGratingInfoSR(0, ind_grating)
+            self.grating_list.append(str(int(lines)))
+
+        self.settings.child('spectro_settings', 'grating_settings', 'grating').setLimits(self.grating_list)
+        err, ind_grating = self.shamrock_controller.GetGratingSR(0)
+        self.settings.child('spectro_settings', 'grating_settings', 'grating').setValue(
+            self.grating_list[ind_grating - 1])
+
+        self.get_set_grating(ind_grating - 1)
+
+    def get_set_grating(self, ind_grating):
+        """
+        set the current grating to ind_grating+1. ind_grating corresponds to the index in the GUI graitng list while the SDK index starts at 1...
+
+        """
+        self.emit_status(ThreadCommand('show_splash', "Moving grating please wait"))
+        err = self.shamrock_controller.SetGratingSR(0, ind_grating + 1)
+        err, ind_grating = self.shamrock_controller.GetGratingSR(0)
+
+        (err, lines, blaze, home, offset) = self.shamrock_controller.GetGratingInfoSR(0, ind_grating)
+        self.settings.child('spectro_settings', 'grating_settings', 'grating').setValue(
+            self.grating_list[ind_grating - 1])
+        self.settings.child('spectro_settings', 'grating_settings', 'lines').setValue(lines)
+        self.settings.child('spectro_settings', 'grating_settings', 'blaze').setValue(blaze)
+
+        (err, wl_min, wl_max) = self.shamrock_controller.GetWavelengthLimitsSR(0, ind_grating)
+
+        if err == "SHAMROCK_SUCCESS":
+            self.settings.child('spectro_settings',
+                                'spectro_wl').setOpts(limits=(wl_min, wl_max),
+                                                      tip=f'Possible values are within {wl_min} and {wl_max} for'
+                                                          f' the selected grating')
+            self.settings.child('spectro_settings',
+                                'spectro_wl_home').setOpts(limits=(wl_min, wl_max),
+                                                           tip=f'Possible values are within {wl_min} and {wl_max} for'
+                                                               f' the selected grating')
+
+        self.emit_status(ThreadCommand('close_splash'))
+
+    def stop(self):
+        pass
+
+
+if __name__ == '__main__':
+    main(__file__, True)

pymodaq_plugins_andor/daq_viewer_plugins/plugins_0D/__init__.py

@@ -0,0 +1,14 @@
+import importlib
+from pathlib import Path
+from ... import set_logger, get_module_name
+
+logger = set_logger('move_plugins', add_to_console=False)
+
+for path in Path(__file__).parent.iterdir():
+    try:
+        if '__init__' not in str(path):
+            importlib.import_module('.' + path.stem, __package__)
+    except Exception as e:
+        logger.warning("{:} plugin couldn't be loaded due to some missing packages or errors: {:}".format(path.stem, str(e)))
+        pass
+

pymodaq_plugins_andor/daq_viewer_plugins/plugins_1D/__init__.py

@@ -0,0 +1,14 @@
+import importlib
+from pathlib import Path
+from ... import set_logger, get_module_name
+
+logger = set_logger('move_plugins', add_to_console=False)
+
+for path in Path(__file__).parent.iterdir():
+    try:
+        if '__init__' not in str(path):
+            importlib.import_module('.' + path.stem, __package__)
+    except Exception as e:
+        logger.warning("{:} plugin couldn't be loaded due to some missing packages or errors: {:}".format(path.stem, str(e)))
+        pass
+

pymodaq_plugins_andor/daq_viewer_plugins/plugins_1D/daq_1Dviewer_ShamrockCCD.py

@@ -0,0 +1,186 @@
+import numpy as np
+from qtpy import QtWidgets
+
+from pymodaq_utils.logger import set_logger, get_module_name
+from pymodaq_utils.utils import ThreadCommand, find_dict_in_list_from_key_val
+
+from pymodaq_gui.parameter import utils as putils
+
+from pymodaq.utils.data import Axis, DataFromPlugins
+from pymodaq.control_modules.viewer_utility_classes import main
+
+from pymodaq_plugins_andor.daq_viewer_plugins.plugins_2D.daq_2Dviewer_AndorCCD import DAQ_2DViewer_AndorCCD
+from pymodaq_plugins_andor.daq_move_plugins.daq_move_Shamrock import DAQ_Move_Shamrock
+
+
+logger = set_logger(get_module_name(__file__))
+
+
+class DAQ_1DViewer_ShamrockCCD(DAQ_2DViewer_AndorCCD, DAQ_Move_Shamrock):
+    """
+        =============== ==================
+
+        =============== ==================
+
+        See Also
+        --------
+        utility_classes.DAQ_Viewer_base
+    """
+    param_camera = DAQ_2DViewer_AndorCCD.params
+    params_shamrock = DAQ_Move_Shamrock.params
+    putils.get_param_dict_from_name(params_shamrock, 'andor_lib', pop=True)
+
+    d = putils.get_param_dict_from_name(params_shamrock, 'spectro_wl')
+    if d is not None:
+        d['readonly'] = False
+    d = putils.get_param_dict_from_name(params_shamrock, 'flip_wavelength')
+    if d is not None:
+        d['visible'] = True
+
+    params = [{'title': 'Get Calibration:', 'name': 'get_calib', 'type': 'bool_push', 'value': False,
+              'label': 'Update!'}] + param_camera + params_shamrock
+
+    def __init__(self, parent=None, params_state=None):
+        DAQ_Move_Shamrock.__init__(self, parent, params_state)
+        DAQ_2DViewer_AndorCCD.__init__(self, parent, params_state)
+
+        self.camera_controller = None  # this will be the controller attribute of the  DAQ_2DViewer_AndorCCD instance
+        self.shamrock_controller = None  # this will be the controller attribute of the  DAQ_Move_Shamrock instance
+        # both plugins don't have the generic controller name 'controller' but specific one for this reason
+
+        self.x_axis: Axis = None
+        self.is_calibrated = False
+
+    def commit_settings(self, param):
+
+        if param.name() == 'flip_wavelength':
+            self.get_xaxis()
+        elif 'camera_settings' in putils.get_param_path(param):
+            DAQ_2DViewer_AndorCCD.commit_settings(self, param)
+        elif 'spectro_settings' in putils.get_param_path(param):
+            DAQ_Move_Shamrock.commit_settings(self, param)
+        QtWidgets.QApplication.processEvents()
+        if param.name() == 'spectro_wl':
+            self.is_calibrated = False
+            self.get_xaxis()
+        elif param.name() == 'zero_order':
+            self.is_calibrated = False
+        elif param.name() == 'flip_wavelength':
+            self.get_xaxis()
+        elif param.name() == 'readout' or param.name() in \
+            putils.iter_children(self.settings.child('camera_settings', 'readout_settings')):
+            self.get_xaxis()
+        elif param.name() == 'get_calib':
+            if param.value():
+                self.get_xaxis()
+                param.setValue(False)
+
+    def ini_detector(self, controller=None):
+        _, shamrock_initialized = DAQ_Move_Shamrock.ini_stage(self, controller)
+        QtWidgets.QApplication.processEvents()
+        # if status_shamrock.initialized:
+        #     self.move_Home()
+
+        _, camera_initialized = DAQ_2DViewer_AndorCCD.ini_detector(self, controller)
+        QtWidgets.QApplication.processEvents()
+
+        initialized = shamrock_initialized and camera_initialized
+
+        self.setCalibration()
+        #self.emit_status(ThreadCommand('close_splash'))
+        return '', initialized
+
+    def setCalibration(self):
+        #setNpixels
+        width, height = self.get_pixel_size()
+        err = self.shamrock_controller.SetNumberPixelsSR(0, self.get_ROI_size_x())
+        err = self.shamrock_controller.SetPixelWidthSR(0, width)
+
+        self.get_wavelength()
+        self.x_axis = self.get_xaxis()
+
+
+    def getCalibration(self):
+
+        if self.shamrock_controller is not None:
+            (err, calib) = self.shamrock_controller.GetCalibrationSR(0, self.get_ROI_size_x())
+            if err != "SHAMROCK_SUCCESS":
+                raise Exception(err)
+
+            calib = np.array(calib)
+        else:
+            raise(Exception('controller not defined'))
+        self.is_calibrated = True
+        return calib
+
+    def get_xaxis(self):
+        """
+            Obtain the horizontal axis of the image.
+
+            Returns
+            -------
+            1D numpy array
+                Contains a vector of integer corresponding to the horizontal camera pixels.
+        """
+
+        if np.abs(self.settings.child('spectro_settings', 'spectro_wl').value()) < 1e-3:
+            DAQ_2DViewer_AndorCCD.get_xaxis(self)
+        else:
+            calib = self.getCalibration()
+
+            if (calib.astype('int') != 0).all():  # check if calib values are equal to zero
+                if self.settings.child('spectro_settings', 'flip_wavelength').value():
+                    calib = calib[::-1]
+
+            else:
+                self.settings.child('spectro_settings', 'flip_wavelength').setValue(False)
+                #self.emit_status(ThreadCommand('Update_Status', ['Impossible to flip wavelength', "log"]))
+
+            self.x_axis = Axis(data=calib, label='Wavelength (nm)')
+        return self.x_axis
+
+    def get_exposure_ms(self):
+        #for compatibility with PyMoDAQ Spectro module
+        self.emit_status(ThreadCommand('exposure_ms', [self.settings.child('camera_settings', 'exposure').value()]))
+
+    def set_exposure_ms(self, exposure):
+        self.settings.child('camera_settings', 'exposure').setValue(exposure)
+        QtWidgets.QApplication.processEvents()
+        self.emit_status(ThreadCommand('exposure_ms', [self.settings.child('camera_settings', 'exposure').value()]))
+
+    def stop(self):
+        DAQ_2DViewer_AndorCCD.stop(self)
+
+    def close(self):
+        if self.camera_controller is not None:
+            DAQ_2DViewer_AndorCCD.stop(self)
+        if self.shamrock_controller is not None:
+            DAQ_Move_Shamrock.stop(self)
+
+    def grab_data(self, Naverage=1, **kwargs):
+        if not self.is_calibrated:
+            self.get_xaxis()
+        DAQ_2DViewer_AndorCCD.grab_data(self, Naverage, **kwargs)
+
+    def emit_data(self):
+        """
+            overloadded function from DAQ_2DViewer_AndorCCD
+        """
+        try:
+            self.ind_grabbed += 1
+            sizey = self.settings.child('camera_settings', 'image_size', 'Ny').value()
+            sizex = self.settings.child('camera_settings', 'image_size', 'Nx').value()
+            self.camera_controller.GetAcquiredDataNumpy(self.data_pointer, sizex * sizey)
+            self.data_grabed_signal.emit([DataFromPlugins(name='Camera',
+                                                          data=[np.squeeze(
+                                                              self.data.reshape((sizey, sizex)).astype(float))],
+                                                          dim=self.data_shape,
+                                                          axes=[self.x_axis]),])
+            QtWidgets.QApplication.processEvents()  # here to be sure the timeevents are executed even if in continuous grab mode
+
+        except Exception as e:
+            self.emit_status(ThreadCommand('Update_Status', [str(e), 'log']))
+
+
+if __name__ == '__main__':
+    main(__file__, True)

pymodaq_plugins_andor/daq_viewer_plugins/plugins_1D/daq_1Dviewer_ShamrockCCDComposition.py

@@ -0,0 +1,197 @@
+import numpy as np
+from qtpy import QtWidgets
+
+from pymodaq_utils.logger import set_logger, get_module_name
+from pymodaq_utils.utils import ThreadCommand, find_dict_in_list_from_key_val
+
+from pymodaq_gui.parameter import utils as putils
+
+from pymodaq.utils.data import Axis, DataFromPlugins, DataToExport
+from pymodaq.control_modules.viewer_utility_classes import main, DAQ_Viewer_base, comon_parameters
+
+from pymodaq_plugins_andor.daq_viewer_plugins.plugins_2D.daq_2Dviewer_AndorCCD import DAQ_2DViewer_AndorCCD
+from pymodaq_plugins_andor.daq_move_plugins.daq_move_Shamrock import DAQ_Move_Shamrock
+
+logger = set_logger(get_module_name(__file__))
+
+
+class DAQ_1DViewer_ShamrockCCDComposition(DAQ_2DViewer_AndorCCD):
+    """
+        =============== ==================
+
+        =============== ==================
+
+        See Also
+        --------
+        utility_classes.DAQ_Viewer_base
+    """
+    param_camera = DAQ_2DViewer_AndorCCD.params
+    params_shamrock = DAQ_Move_Shamrock.params
+    putils.get_param_dict_from_name(params_shamrock, 'andor_lib', pop=True)
+
+    d = putils.get_param_dict_from_name(params_shamrock, 'spectro_wl')
+    if d is not None:
+        d['readonly'] = False
+    d = putils.get_param_dict_from_name(params_shamrock, 'flip_wavelength')
+    if d is not None:
+        d['visible'] = True
+
+    params = [{'title': 'Get Calibration:', 'name': 'get_calib', 'type': 'bool_push', 'value': False,
+              'label': 'Update!'},] + param_camera + [
+              {'title': 'Shamrock Settings:', 'name': 'sham_settings', 'type': 'group', 'children': params_shamrock},
+    ]
+
+
+    def ini_attributes(self):
+        self.controller: DAQ_2DViewer_AndorCCD = None
+        self.shamrock_controller: DAQ_Move_Shamrock = None
+
+        self.x_axis: Axis = None
+        self.is_calibrated = False
+
+        super().ini_attributes()
+
+    def commit_settings(self, param):
+
+        if param.name() == 'flip_wavelength':
+            self.get_xaxis()
+        elif 'camera_settings' in putils.get_param_path(param):
+            super().commit_settings(param)
+        elif 'spectro_settings' in putils.get_param_path(param):
+            self.shamrock_controller.commit_settings(param)
+        QtWidgets.QApplication.processEvents()
+        if param.name() == 'spectro_wl':
+            self.is_calibrated = False
+            self.get_xaxis()
+        elif param.name() == 'zero_order':
+            self.is_calibrated = False
+        elif param.name() == 'flip_wavelength':
+            self.get_xaxis()
+        elif param.name() == 'readout' or param.name() in \
+            putils.iter_children(self.settings.child('camera_settings', 'readout_settings')):
+            self.get_xaxis()
+        elif param.name() == 'get_calib':
+            if param.value():
+                self.get_xaxis()
+                param.setValue(False)
+
+    def ini_detector(self, controller=None):
+        cam_status, cam_init = super().ini_detector(controller)
+        QtWidgets.QApplication.processEvents()
+
+        self.shamrock_controller = DAQ_Move_Shamrock(None, self.settings.child('sham_settings').saveState())
+        self.shamrock_controller.settings = self.settings.child('sham_settings')
+        self.shamrock_controller.emit_status = self.emit_status
+        sham_status, sham_init = self.shamrock_controller.ini_stage(controller)
+
+        QtWidgets.QApplication.processEvents()
+
+
+        initialized = sham_init and cam_init
+
+        self.setCalibration()
+        return sham_status + cam_status, initialized
+
+    def setCalibration(self):
+        #setNpixels
+        width, height = self.get_pixel_size()
+        err = self.shamrock_controller.controller.SetNumberPixelsSR(0, self.get_ROI_size_x())
+        err = self.shamrock_controller.controller.SetPixelWidthSR(0, width)
+
+        self.shamrock_controller.get_wavelength()
+        self.x_axis = self.get_xaxis()
+
+
+    def getCalibration(self):
+
+        if self.shamrock_controller is not None and self.shamrock_controller.controller is not None:
+            (err, calib) = self.shamrock_controller.controller.GetCalibrationSR(0, self.get_ROI_size_x())
+            if err != "SHAMROCK_SUCCESS":
+                raise Exception(err)
+
+            calib = np.array(calib)
+        else:
+            raise(Exception('controller not defined'))
+        self.is_calibrated = True
+        return calib
+
+    def get_xaxis(self):
+        """
+            Obtain the horizontal axis of the image.
+
+            Returns
+            -------
+            1D numpy array
+                Contains a vector of integer corresponding to the horizontal camera pixels.
+        """
+
+        if self.shamrock_controller is None or np.abs(self.settings.child('sham_settings', 'spectro_settings', 'spectro_wl').value()) < 1e-3:
+            nx = self.get_ROI_size_x()
+            calib = np.linspace(0, nx, nx-1)
+            self.x_axis = Axis(data=calib, label='Wavelength (nm)')
+        else:
+            calib = self.getCalibration()
+
+            if (calib.astype('int') != 0).all():  # check if calib values are equal to zero
+                if self.settings.child('sham_settings', 'spectro_settings', 'flip_wavelength').value():
+                    calib = calib[::-1]
+
+            else:
+                self.settings.child('sham_settings', 'spectro_settings', 'flip_wavelength').setValue(False)
+                #self.emit_status(ThreadCommand('Update_Status', ['Impossible to flip wavelength', "log"]))
+
+            self.x_axis = Axis(data=calib, label='Wavelength (nm)')
+        return self.x_axis
+
+    def get_exposure_ms(self):
+        #for compatibility with PyMoDAQ Spectro module
+        self.emit_status(ThreadCommand('exposure_ms', [self.settings.child('camera_settings', 'exposure').value()]))
+
+    def set_exposure_ms(self, exposure):
+        self.settings.child('camera_settings', 'exposure').setValue(exposure)
+        QtWidgets.QApplication.processEvents()
+        self.emit_status(ThreadCommand('exposure_ms', [self.settings.child('camera_settings', 'exposure').value()]))
+
+    def stop(self):
+        if self.controller is not None:
+            super().stop()
+        if self.shamrock_controller is not None:
+            self.shamrock_controller.stop()
+
+    def close(self):
+        self.stop()
+        if self.shamrock_controller is not None:
+            self.shamrock_controller.close()
+        super().close()
+
+    def grab_data(self, Naverage=1, **kwargs):
+        if not self.is_calibrated:
+            self.get_xaxis()
+        super().grab_data( Naverage, **kwargs)
+
+    def emit_data(self):
+        """
+            overloadded function from DAQ_2DViewer_AndorCCD
+        """
+        try:
+            self.ind_grabbed += 1
+            sizey = self.settings.child('camera_settings', 'image_size', 'Ny').value()
+            sizex = self.settings.child('camera_settings', 'image_size', 'Nx').value()
+            self.controller.GetAcquiredDataNumpy(self.data_pointer, sizex * sizey)
+            self.dte_signal.emit(
+                DataToExport('Spectro',
+                             data=[
+                                 DataFromPlugins(name='Camera',
+                                                 data=[np.atleast_1d(np.squeeze(self.data.reshape(
+                                                     (sizey, sizex)))).astype(float)],
+                                                 dim=self.data_shape,
+                                                 axes=[self.x_axis]),
+                             ]))
+            QtWidgets.QApplication.processEvents()  # here to be sure the timeevents are executed even if in continuous grab mode
+
+        except Exception as e:
+            self.emit_status(ThreadCommand('Update_Status', [str(e), 'log']))
+
+
+if __name__ == '__main__':
+    main(__file__, True)