Inheritance diagram for microscope.cameras.atmcd.AndorAtmcd:

Public Member Functions
	__init__ (self, index=0, **kwargs)

	__enter__ (self)

	__exit__ (self, exc_type, exc_value, traceback)

	abort (self)

	initialize (self)

	get_id (self)

	set_exposure_time (self, value)

	get_exposure_time (self)

	get_cycle_time (self)

	soft_trigger (self)

microscope.TriggerMode	trigger_mode (self)

microscope.TriggerType	trigger_type (self)

None	set_trigger (self, microscope.TriggerType ttype, microscope.TriggerMode tmode)

Public Member Functions inherited from microscope.abc.FloatingDeviceMixin
Public Member Functions inherited from microscope.abc.Camera
	set_readout_mode (self, description)

	get_transform (self)

	set_transform (self, transform)

typing.Tuple[int, int]	get_sensor_shape (self)

microscope.Binning	get_binning (self)

None	set_binning (self, microscope.Binning binning)

microscope.ROI	get_roi (self)

None	set_roi (self, microscope.ROI roi)

Public Member Functions inherited from microscope.abc.TriggerTargetMixin
None	trigger (self)

Public Member Functions inherited from microscope.abc.DataDevice
	__del__ (self)

None	enable (self)

None	disable (self)

None	set_client (self, new_client)

None	update_settings (self, settings, bool init=False)

None	receiveClient (self, str client_uri)

	grab_next_data (self, bool soft_trigger=True)

None	receiveData (self, data, timestamp)

Public Member Functions inherited from microscope.abc.Device
bool	get_is_enabled (self)

None	shutdown (self)

None	add_setting (self, name, dtype, get_func, set_func, values, typing.Optional[typing.Callable[[], bool]] readonly=None)

	get_setting (self, str name)

	get_all_settings (self)

None	set_setting (self, str name, value)

	describe_setting (self, str name)

	describe_settings (self)

Public Attributes
	amplifiers

	get_binning = "Binning"

	set_binning

	get_roi = "Roi"

Public Attributes inherited from microscope.abc.Camera
	set_readout_mode

	get_roi

	set_roi

Public Attributes inherited from microscope.abc.DataDevice
bool	enabled = False

bool	_fetch_thread = True

bool	_dispatch_thread = True

None	_fetch_thread_run = self._fetch_data()

Public Attributes inherited from microscope.abc.Device
bool	enabled = False

Protected Member Functions
	_bind (self, fn)

	_acquiring (self)

	_acquiring (self, value)

	_set_cooler_state (self, state)

	_fetch_data (self)

None	_do_shutdown (self)

	_do_disable (self)

	_do_enable (self)

	_set_image (self)

	_set_readout_mode (self, mode_index)

	_get_sensor_shape (self)

	_get_sensor_temperature (self)

None	_do_trigger (self)

	_get_binning (self)

	_set_binning (self, binning)

	_get_roi (self)

	_set_roi (self, roi)

Protected Member Functions inherited from microscope.abc.Camera
	_process_data (self, data)

	_set_readout_transform (self, new_transform)

Protected Member Functions inherited from microscope.abc.TriggerTargetMixin
Protected Member Functions inherited from microscope.abc.DataDevice
	_send_data (self, client, data, timestamp)

None	_dispatch_loop (self)

None	_fetch_loop (self)

	_client (self)

	_client (self, val)

None	_put (self, data, timestamp)

Protected Member Functions inherited from microscope.abc.Device

Protected Attributes
int	_rdepth = 0

	_handle = None

	_roi = None

	_binning = None

	_caps = GetCapabilities()

list	_readout_modes = []

	_set_readout_mode

	_get_sensor_temperature

	_set_cooler_state

	_acquiring

Protected Attributes inherited from microscope.abc.FloatingDeviceMixin
	_index = index

Protected Attributes inherited from microscope.abc.Camera
list	_readout_modes = ["default"]

int	_readout_mode = 0

tuple	_readout_transform = (False, False, False)

tuple	_client_transform = (False, False, False)

tuple	_transform = (False, False, False)

Protected Attributes inherited from microscope.abc.DataDevice
	_fetch_thread = None

bool	_fetch_thread_run = False

bool	_using_callback = False

list	_clientStack = []

	_liveClients = set()

	_dispatch_thread = None

	_dispatch_buffer = queue.Queue(maxsize=buffer_length)

	_new_data_condition = threading.Condition()

	_client = None

tuple	_new_data = (data, timestamp)

Protected Attributes inherited from microscope.abc.Device
dict	_settings = {}

Additional Inherited Members
Static Public Attributes inherited from microscope.abc.Camera
list	ALLOWED_TRANSFORMS = [p for p in itertools.product(3 [[False, True]])]

Static Public Attributes inherited from microscope.abc.DataDevice
	set_setting = keep_acquiring(Device.set_setting)

Detailed Description

Implements CameraDevice interface for Andor ATMCD library.

Definition at line 1364 of file atmcd.py.

Constructor & Destructor Documentation

◆ init()

microscope.cameras.atmcd.AndorAtmcd.__init__	(		self,
			index = 0,
		**	kwargs )

Reimplemented from microscope.abc.FloatingDeviceMixin.

Definition at line 1370 of file atmcd.py.

    def __init__(self, index=0, **kwargs):
        super().__init__(index=index, **kwargs)
        # Recursion depth for context manager behaviour.
        self._rdepth = 0
        # The handle used by the DLL to identify this camera.
        self._handle = None
        # The following parameters will be populated after hardware init.
        self._roi = None
        self._binning = None
        self.initialize()
 

Member Function Documentation

◆ enter()

microscope.cameras.atmcd.AndorAtmcd.__enter__ ( self )

Context manager entry code.

The camera class is also a context manager that ensures DLL calls act
on this camera by obtaining the _dll_lock.

We could use RLock to give re-entrant behaviour, but we track recursion
ourselves so that we know when we must call SetCurrentCamera.

Definition at line 1391 of file atmcd.py.

    def __enter__(self):
        """Context manager entry code.
 
        The camera class is also a context manager that ensures DLL calls act
        on this camera by obtaining the _dll_lock.
 
        We could use RLock to give re-entrant behaviour, but we track recursion
        ourselves so that we know when we must call SetCurrentCamera.
        """
        if self._rdepth == 0:
            _dll_lock.acquire()
            SetCurrentCamera(self._handle)
        self._rdepth += 1
 

◆ exit()

microscope.cameras.atmcd.AndorAtmcd.__exit__	(	self,
		exc_type,
		exc_value,
		traceback )

Context manager exit code.

Definition at line 1405 of file atmcd.py.

    def __exit__(self, exc_type, exc_value, traceback):
        """Context manager exit code."""
        self._rdepth -= 1
        if self._rdepth == 0:
            _dll_lock.release()
 

◆ _acquiring() [1/2]

microscope.cameras.atmcd.AndorAtmcd._acquiring ( self )

protected

Indicate whether or not camera is acquiring data.

Reimplemented from microscope.abc.DataDevice.

Definition at line 1412 of file atmcd.py.

    def _acquiring(self):
        """Indicate whether or not camera is acquiring data."""
        with self:
            return GetStatus() == DRV_ACQUIRING
 

◆ _acquiring() [2/2]

microscope.cameras.atmcd.AndorAtmcd._acquiring	(		self,
			value )

protected

Reimplemented from microscope.abc.DataDevice.

Definition at line 1418 of file atmcd.py.

    def _acquiring(self, value):
        # Here to prevent an error when super.__init__ intializes
        # self._acquiring. Doesn't do anything, because the DLL keeps
        # track of acquisition state.
        pass
 

◆ _bind()

microscope.cameras.atmcd.AndorAtmcd._bind	(		self,
			fn )

protected

Binds unbound SDK functions to this camera.

Definition at line 1381 of file atmcd.py.

    def _bind(self, fn):
        """Binds unbound SDK functions to this camera."""
 
        @functools.wraps(fn)
        def wrapper(*args, **kwargs):
            with self:
                return fn(*args, **kwargs)
 
        return wrapper
 

◆ _do_disable()

microscope.cameras.atmcd.AndorAtmcd._do_disable ( self )

protected

Call abort to stop acquisition.

Reimplemented from microscope.abc.Device.

Definition at line 1650 of file atmcd.py.

    def _do_disable(self):
        """Call abort to stop acquisition."""
        self.abort()
 

◆ _do_enable()

microscope.cameras.atmcd.AndorAtmcd._do_enable ( self )

protected

Enter data acquisition state.

Reimplemented from microscope.abc.Device.

Definition at line 1654 of file atmcd.py.

    def _do_enable(self):
        """Enter data acquisition state."""
        if self._acquiring:
            self.abort()
        with self:
            SetAcquisitionMode(AcquisitionMode.RUNTILLABORT)
            SetShutter(1, 1, 1, 1)
            SetReadMode(ReadMode.IMAGE)
            x, y = GetDetector()
            self._set_image()
            if not IsTriggerModeAvailable(self.get_setting("TriggerMode")):
                raise microscope.UnsupportedFeatureError(
                    "Trigger mode is not valid."
                )
            StartAcquisition()
        return True
 

◆ _do_shutdown()

None microscope.cameras.atmcd.AndorAtmcd._do_shutdown ( self )

protected

Warm up the sensor then shut down the camera.

This may take some time, so we should ensure that the _dll_lock is
released when we don't need it.

Reimplemented from microscope.abc.Device.

Definition at line 1623 of file atmcd.py.

    def _do_shutdown(self) -> None:
        """Warm up the sensor then shut down the camera.
 
        This may take some time, so we should ensure that the _dll_lock is
        released when we don't need it."""
        # Switch off cooler then release lock.
        with self:
            CoolerOFF()
 
        _logger.info(
            "Waiting for temperature to rise above -20C" " before shutdown ..."
        )
 
        while True:
            # Check temperature then release lock.
            with self:
                t = GetTemperature()[1]
                _logger.info("... T = %dC", t)
            if t > -20:
                break
            time.sleep(10)
 
        _logger.info("Temperature is %dC: shutting down camera.", t)
 
        with self:
            ShutDown()
 

◆ _do_trigger()

None microscope.cameras.atmcd.AndorAtmcd._do_trigger ( self )

protected

Actual trigger of the device.

Classes implementing this interface should implement this
method instead of `trigger`.

Reimplemented from microscope.abc.TriggerTargetMixin.

Definition at line 1779 of file atmcd.py.

    def _do_trigger(self) -> None:
        with self:
            SendSoftwareTrigger()
 

◆ _fetch_data()

microscope.cameras.atmcd.AndorAtmcd._fetch_data ( self )

protected

Poll for data and return it, with minimal processing.

Returns the data, or None if no data is available.

Reimplemented from microscope.abc.DataDevice.

Definition at line 1599 of file atmcd.py.

    def _fetch_data(self):
        """Poll for data and return it, with minimal processing.
 
        Returns the data, or None if no data is available.
        """
        binning = self._binning
        roi = self._roi
        width = roi.width // binning.h
        height = roi.height // binning.v
        try:
            with self:
                data = GetOldestImage16(width * height).reshape(height, width)
        except AtmcdException as e:
            if e.status == DRV_NO_NEW_DATA:
                return None
            else:
                raise e
        return data
 

◆ _get_binning()

microscope.cameras.atmcd.AndorAtmcd._get_binning ( self )

protected

Return the binning setting.

Reimplemented from microscope.abc.Camera.

Definition at line 1783 of file atmcd.py.

    def _get_binning(self):
        """Return the binning setting."""
        return self._binning
 

◆ _get_roi()

microscope.cameras.atmcd.AndorAtmcd._get_roi ( self )

protected

Return the current ROI setting.

Reimplemented from microscope.abc.Camera.

Definition at line 1793 of file atmcd.py.

    def _get_roi(self):
        """Return the current ROI setting."""
        return self._roi
 

◆ _get_sensor_shape()

microscope.cameras.atmcd.AndorAtmcd._get_sensor_shape ( self )

protected

Return the sensor geometry.

Reimplemented from microscope.abc.Camera.

Definition at line 1742 of file atmcd.py.

    def _get_sensor_shape(self):
        """Return the sensor geometry."""
        with self:
            return GetDetector()
 

◆ _get_sensor_temperature()

microscope.cameras.atmcd.AndorAtmcd._get_sensor_temperature ( self )

protected

Return the sensor temperature.

Definition at line 1747 of file atmcd.py.

    def _get_sensor_temperature(self):
        """Return the sensor temperature."""
        with self:
            return GetTemperature()[1]
 

◆ _set_binning()

microscope.cameras.atmcd.AndorAtmcd._set_binning	(		self,
			binning )

protected

Set horizontal and vertical binning. Default to single pixel.

Reimplemented from microscope.abc.Camera.

Definition at line 1788 of file atmcd.py.

    def _set_binning(self, binning):
        """Set horizontal and vertical binning. Default to single pixel."""
        self._binning = binning
        return True
 

◆ _set_cooler_state()

microscope.cameras.atmcd.AndorAtmcd._set_cooler_state	(		self,
			state )

protected

Turn the sensor cooler on (True) or off (False)

Definition at line 1434 of file atmcd.py.

    def _set_cooler_state(self, state):
        """Turn the sensor cooler on (True) or off (False)"""
        with self:
            if state:
                CoolerON()
            else:
                CoolerOFF()
 

◆ _set_image()

microscope.cameras.atmcd.AndorAtmcd._set_image ( self )

protected

Set ROI and binning prior to acquisition.

Definition at line 1671 of file atmcd.py.

    def _set_image(self):
        """Set ROI and binning prior to acquisition."""
        binning = (
            self._binning
        )  # Binning is mode-dependent, so not validated yet.
        roi = self._roi  # ROI validated in _set_roi, so should be OK
        with self:
            try:
                SetImage(
                    binning.h,
                    binning.v,
                    roi.left,
                    roi.left + roi.width - 1,
                    roi.top,
                    roi.top + roi.height - 1,
                )
            except AtmcdException as e:
                if e.status == DRV_P1INVALID:
                    out_e = ValueError("Horizontal binning invalid.")
                elif e.status == DRV_P2INVALID:
                    e = ValueError("Vertical binning invalid.")
                elif e.status == DRV_P3INVALID:
                    out_e = ValueError("roi.left invalid.")
                elif e.status == DRV_P4INVALID:
                    out_e = ValueError("roi.width invalid.")
                elif e.status == DRV_P5INVALID:
                    out_e = ValueError("roi.top invalid.")
                elif e.status == DRV_P6INVALID:
                    out_e = ValueError("roi.height invalid.")
                else:
                    out_e = e
                # Just raise the descriptive exception, not the chain.
                raise out_e from None
 

◆ _set_readout_mode()

microscope.cameras.atmcd.AndorAtmcd._set_readout_mode	(		self,
			mode_index )

protected

Configure channel, amplifier and VS-speed.

Definition at line 1728 of file atmcd.py.

    def _set_readout_mode(self, mode_index):
        """Configure channel, amplifier and VS-speed."""
        mode = self._readout_modes[mode_index]
        _logger.info("Setting readout mode to %s", mode)
        with self:
            SetADChannel(mode.channel)
            SetOutputAmplifier(mode.amp)
            # On (at least) the Ixon Ultra, the two amplifiers read from
            # opposite edges from the chip. We set the horizontal flip
            # so that the returned image orientation is independent of
            # amplifier selection
            SetImageFlip(not mode.amp, 0)
            SetHSSpeed(mode.amp, mode.hsindex)
 

◆ _set_roi()

microscope.cameras.atmcd.AndorAtmcd._set_roi	(		self,
			roi )

protected

Set the ROI, defaulting to full sensor area.

Reimplemented from microscope.abc.Camera.

Definition at line 1798 of file atmcd.py.

    def _set_roi(self, roi):
        """Set the ROI, defaulting to full sensor area."""
        with self:
            x, y = GetDetector()
        left = roi.left or 1
        top = roi.top or 1
        width = roi.width or x
        height = roi.height or y
        if any(
            [left < 1, top < 1, left + width - 1 > x, top + height - 1 > y]
        ):
            return False
        self._roi = microscope.ROI(left, top, width, height)
        return True

◆ abort()

microscope.cameras.atmcd.AndorAtmcd.abort ( self )

Abort acquisition.

Reimplemented from microscope.abc.DataDevice.

Definition at line 1424 of file atmcd.py.

    def abort(self):
        """Abort acquisition."""
        _logger.debug("Disabling acquisition.")
        try:
            with self:
                AbortAcquisition()
        except AtmcdException as e:
            if e.status != DRV_IDLE:
                raise
 

◆ get_cycle_time()

microscope.cameras.atmcd.AndorAtmcd.get_cycle_time ( self )

Determine the minimum time between exposures.

Reimplemented from microscope.abc.Camera.

Definition at line 1717 of file atmcd.py.

    def get_cycle_time(self):
        """Determine the minimum time between exposures."""
        with self:
            exposure, accumulate, kinetic = GetAcquisitionTimings()
            readout = GetReadOutTime()
            # IMD 20210422 DeepSIM timing is wrong as the keepclear cycles are
            # not accounted for.
            # return exposure + readout
            # This appears to allow the correct time between trigger pulses.
            return kinetic
 

◆ get_exposure_time()

microscope.cameras.atmcd.AndorAtmcd.get_exposure_time ( self )

Query the actual exposure time.

Reimplemented from microscope.abc.Camera.

Definition at line 1711 of file atmcd.py.

    def get_exposure_time(self):
        """Query the actual exposure time."""
        with self:
            exposure, accumulate, kinetic = GetAcquisitionTimings()
        return exposure
 

◆ get_id()

microscope.cameras.atmcd.AndorAtmcd.get_id ( self )

Return the device's unique identifier.

Reimplemented from microscope.abc.FloatingDeviceMixin.

Definition at line 1618 of file atmcd.py.

    def get_id(self):
        """Return the device's unique identifier."""
        with self:
            return GetCameraSerialNumber()
 

◆ initialize()

microscope.cameras.atmcd.AndorAtmcd.initialize ( self )

Initialize the library and hardware and create Setting objects.

Reimplemented from microscope.abc.Device.

Definition at line 1442 of file atmcd.py.

    def initialize(self):
        """Initialize the library and hardware and create Setting objects."""
        _logger.info("Initializing ...")
        num_cams = GetAvailableCameras()
        if self._index >= num_cams:
            msg = "Requested camera %d, but only found %d cameras" % (
                self._index,
                num_cams,
            )
            raise microscope.InitialiseError(msg)
        self._handle = GetCameraHandle(self._index)
 
        with self:
            # Initialize the library and connect to camera.
            Initialize(b"")
            # Initialise ROI to full sensor area and binning to single-pixel.
            self._set_roi(microscope.ROI(0, 0, 0, 0))
            self._set_binning(microscope.Binning(1, 1))
            # Check info bits to see if initialization successful.
            info = GetCameraInformation(self._index)
            if not info & 1 << 2:
                raise microscope.InitialiseError("... initialization failed.")
            self._caps = GetCapabilities()
            model = GetHeadModel()
            serial = self.get_id()
            # Populate amplifiers
            if GetNumberAmp() > 1:
                if self._caps.ulCameraType == AC_CAMERATYPE_CLARA:
                    self.amplifiers = IntEnum(
                        "Amplifiers",
                        (("CONVENTIONAL", 0), ("EXTENDED_NIR", 1)),
                    )
                else:
                    self.amplifiers = IntEnum(
                        "Amplifiers", (("EMCCD", 0), ("CONVENTIONAL", 1))
                    )
            # Populate readout modes
            self._readout_modes = []
            for ch in range(GetNumberADChannels()):
                for amp in self.amplifiers:
                    for s in range(GetNumberHSSpeeds(ch, amp.value)):
                        speed = GetHSSpeed(ch, amp.value, s)
                        self._readout_modes.append(
                            ReadoutMode(ch, amp, s, speed)
                        )
            _logger.info("... initilized %s s/n %s", model, serial)
        # Add settings. Some are write-only, so we set defaults here.
        # Mode
        name = "readout mode"
        if self._readout_modes:
            self.add_setting(
                name,
                "enum",
                None,
                self._set_readout_mode,
                lambda: [str(mode) for mode in self._readout_modes],
            )
            self.set_setting(name, 0)
        # TriggerMode
        name = "TriggerMode"
        self.add_setting(
            name, "enum", None, self._bind(SetTriggerMode), TriggerMode
        )
        if self._caps.ulTriggerModes & AC_TRIGGERMODE_EXTERNAL:
            self.set_setting(name, TriggerMode.EXTERNAL)
        elif self._caps.ulTriggerModes & AC_TRIGGERMODE_CONTINUOUS:
            self.set_setting(name, TriggerMode.SOFTWARE)
        # Gain - device will use either EMGain or MCPGain
        name = "gain"
        getter, setter, vrange = None, None, None
        if self._caps.ulGetFunctions & AC_GETFUNCTION_EMCCDGAIN:
            getter = self._bind(GetEMCCDGain)
        elif self._caps.ulGetFunctions & AC_GETFUNCTION_MCPGAIN:
            getter = self._bind(GetMCPGain)
        if self._caps.ulSetFunctions & AC_SETFUNCTION_EMCCDGAIN:
            setter = self._bind(SetEMCCDGain)
            vrange = self._bind(GetEMGainRange)
        elif self._caps.ulSetFunctions & AC_SETFUNCTION_MCPGAIN:
            setter = self._bind(SetMCPGain)
            vrange = self._bind(GetMCPGainRange)
        if getter or setter:
            self.add_setting(name, "int", getter, setter, vrange)
        # Temperature
        name = "TemperatureSetPoint"
        getter, setter, vrange = None, None, None
        if self._caps.ulSetFunctions & AC_SETFUNCTION_TEMPERATURE:
            setter = self._bind(SetTemperature)
        if self._caps.ulGetFunctions & AC_GETFUNCTION_TEMPERATURERANGE:
            vrange = self._bind(GetTemperatureRange)
        if setter:
            self.add_setting(name, "int", None, setter, vrange)
        # Set a conservative default temperature set-point.
        self.set_setting(name, -20)
        # Fan control
        name = "Temperature"
        self.add_setting(
            name, "int", self._get_sensor_temperature, None, (None, None)
        )
        name = "Fan mode"
        self.add_setting(
            name,
            "enum",
            None,  # Can't query fan mode
            self._bind(SetFanMode),
            {0: "full", 1: "low", 2: "off"},
        )
        # Cooler control
        name = "Cooler Enabled"
        self.add_setting(name, "bool", None, self._set_cooler_state, None)
        self.set_setting(name, True)
        # Binning
        name = "Binning"
        self.add_setting(
            name, "tuple", self.get_binning, self.set_binning, None
        )
        # Roi
        name = "Roi"
        self.add_setting(
            name, "tuple", self.get_roi, lambda roi: self.set_roi(*roi), None
        )
        # BaselineClamp
        name = "BaselineClamp"
        if self._caps.ulSetFunctions & AC_SETFUNCTION_BASELINECLAMP:
            self.add_setting(
                name, "bool", None, self._bind(SetBaselineClamp), None
            )
            self.set_setting(name, False)
        # BaselineOffset
        name = "BaselineOffset"
        if self._caps.ulSetFunctions & AC_SETFUNCTION_BASELINEOFFSET:
            self.add_setting(
                name, "int", None, self._bind(SetBaselineOffset), (-1000, 1000)
            )
            self.set_setting(name, 0)
        # EMAdvanced
        name = "EMAdvanced"
        if self._caps.ulSetFunctions & AC_SETFUNCTION_EMADVANCED:
            self.add_setting(
                name, "bool", None, self._bind(SetEMAdvanced), None
            )
            self.set_setting(name, False)
        # GateMode
        name = "GateMode"
        if self._caps.ulSetFunctions & AC_SETFUNCTION_GATEMODE:
            vrange = range(
                0, [5, 6][self._caps.ulCameraType & AC_CAMERATYPE_ISTAR]
            )
            self.add_setting(
                name, "int", None, self._bind(SetGateMode), vrange
            )
        # HighCapacity
        name = "HighCapacity"
        if self._caps.ulSetFunctions & AC_SETFUNCTION_HIGHCAPACITY:
            self.add_setting(
                name, "bool", None, self._bind(SetHighCapacity), None
            )
 

◆ set_exposure_time()

microscope.cameras.atmcd.AndorAtmcd.set_exposure_time	(		self,
			value )

Set exposure time.

Reimplemented from microscope.abc.Camera.

Definition at line 1706 of file atmcd.py.

    def set_exposure_time(self, value):
        """Set exposure time."""
        with self:
            SetExposureTime(value)
 

◆ set_trigger()

None microscope.cameras.atmcd.AndorAtmcd.set_trigger	(		self,
		microscope.TriggerType	ttype,
		microscope.TriggerMode	tmode )

Set device for a specific trigger.

Reimplemented from microscope.abc.TriggerTargetMixin.

Definition at line 1768 of file atmcd.py.

    ) -> None:
        try:
            atmcd_mode = TRIGGER_TO_ATMCD_MODE[(ttype, tmode)]
        except KeyError:
            raise microscope.UnsupportedFeatureError(
                "no ATMCD mode for %s and %s" % (ttype, tmode)
            )
        self.set_setting("TriggerMode", atmcd_mode)
 

◆ soft_trigger()

microscope.cameras.atmcd.AndorAtmcd.soft_trigger ( self )

Send a software trigger signal.

Deprecated, use trigger().

Definition at line 1752 of file atmcd.py.

    def soft_trigger(self):
        """Send a software trigger signal.
 
        Deprecated, use trigger().
        """
        with self:
            SendSoftwareTrigger()
 

◆ trigger_mode()

microscope.TriggerMode microscope.cameras.atmcd.AndorAtmcd.trigger_mode ( self )

Reimplemented from microscope.abc.TriggerTargetMixin.

Definition at line 1761 of file atmcd.py.

    def trigger_mode(self) -> microscope.TriggerMode:
        return ATMCD_MODE_TO_TRIGGER[self.get_setting("TriggerMode")][1]
 

◆ trigger_type()

microscope.TriggerType microscope.cameras.atmcd.AndorAtmcd.trigger_type ( self )

Reimplemented from microscope.abc.TriggerTargetMixin.

Definition at line 1765 of file atmcd.py.

    def trigger_type(self) -> microscope.TriggerType:
        return ATMCD_MODE_TO_TRIGGER[self.get_setting("TriggerMode")][0]
 

Member Data Documentation

◆ _acquiring

microscope.cameras.atmcd.AndorAtmcd._acquiring

protected

Definition at line 1656 of file atmcd.py.

◆ _binning

microscope.cameras.atmcd.AndorAtmcd._binning = None

protected

Definition at line 1378 of file atmcd.py.

◆ _caps

microscope.cameras.atmcd.AndorAtmcd._caps = GetCapabilities()

protected

Definition at line 1464 of file atmcd.py.

◆ _get_sensor_temperature

microscope.cameras.atmcd.AndorAtmcd._get_sensor_temperature

protected

Definition at line 1538 of file atmcd.py.

◆ _handle

microscope.cameras.atmcd.AndorAtmcd._handle = None

protected

Definition at line 1375 of file atmcd.py.

◆ _rdepth

int microscope.cameras.atmcd.AndorAtmcd._rdepth = 0

protected

Definition at line 1373 of file atmcd.py.

◆ _readout_modes

list microscope.cameras.atmcd.AndorAtmcd._readout_modes = []

protected

Definition at line 1479 of file atmcd.py.

◆ _roi

microscope.cameras.atmcd.AndorAtmcd._roi = None

protected

Definition at line 1377 of file atmcd.py.

◆ _set_cooler_state

microscope.cameras.atmcd.AndorAtmcd._set_cooler_state

protected

Definition at line 1550 of file atmcd.py.

◆ _set_readout_mode

microscope.cameras.atmcd.AndorAtmcd._set_readout_mode

protected

Definition at line 1496 of file atmcd.py.

◆ amplifiers

microscope.cameras.atmcd.AndorAtmcd.amplifiers

Initial value:

=  IntEnum(
                        "Amplifiers",
                        (("CONVENTIONAL", 0), ("EXTENDED_NIR", 1)),
                    )

Definition at line 1470 of file atmcd.py.

◆ get_binning

microscope.cameras.atmcd.AndorAtmcd.get_binning = "Binning"

Definition at line 1555 of file atmcd.py.

◆ get_roi

microscope.cameras.atmcd.AndorAtmcd.get_roi = "Roi"

Definition at line 1560 of file atmcd.py.

◆ set_binning

microscope.cameras.atmcd.AndorAtmcd.set_binning

Definition at line 1555 of file atmcd.py.

The documentation for this class was generated from the following file:

BioImager/PythonMicroscope/microscope/cameras/atmcd.py

Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ __enter__()

◆ __exit__()

◆ _acquiring() [1/2]

◆ _acquiring() [2/2]

◆ _bind()

◆ _do_disable()

◆ _do_enable()

◆ _do_shutdown()

◆ _do_trigger()

◆ _fetch_data()

◆ _get_binning()

◆ _get_roi()

◆ _get_sensor_shape()

◆ _get_sensor_temperature()

◆ _set_binning()

◆ _set_cooler_state()

◆ _set_image()

◆ _set_readout_mode()

◆ _set_roi()

◆ abort()

◆ get_cycle_time()

◆ get_exposure_time()

◆ get_id()

◆ initialize()

◆ set_exposure_time()

◆ set_trigger()

◆ soft_trigger()

◆ trigger_mode()

◆ trigger_type()

Member Data Documentation

◆ _acquiring

◆ _binning

◆ _caps

◆ _get_sensor_temperature

◆ _handle

◆ _rdepth

◆ _readout_modes

◆ _roi

◆ _set_cooler_state

◆ _set_readout_mode

◆ amplifiers

◆ get_binning

◆ get_roi

◆ set_binning

◆ init()

◆ enter()

◆ exit()