Inheritance diagram for microscope.cameras.pvcam.PVCamera:

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

	get_id (self)

	abort (self)

	initialize (self)

	set_readout_mode (self, index)

	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
	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
	handle = None

tuple	shape = (None, None)

tuple	roi = (None, None, None, None)

	binning = microscope.Binning(1, 1)

float	exposure_time = 0.001

float	cycle_time = self.exposure_time

	set_exposure_time

dict	roi = self._params[PARAM_READOUT_PORT].values

Public Attributes inherited from microscope.abc.Camera
	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

Static Public Attributes
list	open_cameras = []

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)

Protected Member Functions
	_region (self)

	_fetch_data (self)

	_do_enable (self)

	_do_disable (self)

None	_do_shutdown (self)

	_get_sensor_shape (self)

	_get_binning (self)

	_set_binning (self, binning)

	_get_roi (self)

	_set_roi (self, roi)

None	_do_trigger (self)

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
	_pv_name = None

	_trigger = TRIG_STROBED

	_buffer = None

dict	_params = {}

int	_circ_buffer_length = 10

bool	_using_callback = True

	_eof_callback = CALLBACK(cb)

bool	_acquiring = True

dict	_cbs

list	_readout_modes = []

list	_readout_mode_parameters = []

	_readout_mode = index

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)

bool	_acquiring = False

	_new_data_condition = threading.Condition()

	_client = None

tuple	_new_data = (data, timestamp)

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

Detailed Description

Implements the CameraDevice interface for the pvcam library.

Definition at line 1404 of file pvcam.py.

Constructor & Destructor Documentation

◆ init()

microscope.cameras.pvcam.PVCamera.__init__	(		self,
			index = 0,
		**	kwargs )

Reimplemented from microscope.abc.FloatingDeviceMixin.

Definition at line 1413 of file pvcam.py.

    def __init__(self, index=0, **kwargs):
        super().__init__(index=index, **kwargs)
        # Camera name in DLL.
        self._pv_name = None
        # Camera handle.
        self.handle = None
        # Sensor shape.
        self.shape = (None, None)
        # Region of interest.
        self.roi = (None, None, None, None)
        # Binning setting.
        self.binning = microscope.Binning(1, 1)
        self._trigger = TRIG_STROBED
        self.exposure_time = 0.001  # in seconds
        # Cycle time
        self.cycle_time = self.exposure_time
        # Data buffer.
        self._buffer = None
        # This devices PVCAM parameters.
        self._params = {}
        # Circular buffer length.
        self._circ_buffer_length = 10
 
        # Add common settings.
        self.add_setting(
            "exposure time",
            "float",
            lambda: self.exposure_time,
            self.set_exposure_time,
            lambda: (1e-6, 1),
        )
        self.add_setting(
            "trigger mode",
            "enum",
            lambda: self._trigger,
            lambda value: setattr(self, "_trigger", value),
            {k: v.label for k, v in TRIGGER_MODES.items()},
        )
        self.add_setting(
            "circular buffer length",
            "int",
            lambda: self._circ_buffer_length,
            lambda value: setattr(self, "_circ_buffer_length", value),
            (2, 100),
        )
 
        self.initialize()
 

Member Function Documentation

◆ _do_disable()

microscope.cameras.pvcam.PVCamera._do_disable ( self )

protected

Disable the hardware for a short period of inactivity.

Reimplemented from microscope.abc.Device.

Definition at line 1613 of file pvcam.py.

    def _do_disable(self):
        """Disable the hardware for a short period of inactivity."""
        self.abort()
        _cam_deregister_callback(self.handle, PL_CALLBACK_EOF)
 

◆ _do_enable()

microscope.cameras.pvcam.PVCamera._do_enable ( self )

protected

Enable the camera hardware and make ready to respond to triggers.

Return True if successful, False if not.

Reimplemented from microscope.abc.Device.

Definition at line 1480 of file pvcam.py.

    def _do_enable(self):
        """Enable the camera hardware and make ready to respond to triggers.
 
        Return True if successful, False if not."""
        # Set exposure time resolution on camera and determine t_exp, the
        # integer value used to set exposure time on the hardware later.
        if self.exposure_time < 1e-3:
            self._params[PARAM_EXP_RES].set_value(EXP_RES_ONE_MICROSEC)
            t_exp = int(self.exposure_time * 1e6)
        else:
            self._params[PARAM_EXP_RES].set_value(EXP_RES_ONE_MILLISEC)
            t_exp = int(self.exposure_time * 1e3)
        # Determine the data type of the buffer
        # Kinetix has an 8 bit mode, may need more options for colour
        # cameras.
        buffer_dtype = "uint16"
        if self._params[PARAM_BIT_DEPTH].current == 8:
            buffer_dtype = "uint8"
        # Configure camera, allocate buffer, and register callback.
        if self._trigger == TRIG_SOFT:
            # Software triggering for single frames.
            # Set up callback.
            self._using_callback = True
 
            def cb():
                """Soft trigger mode end-of-frame callback."""
                timestamp = time.time()
                frame = self._buffer.copy()
                _logger.debug("Fetched single frame.")
                _exp_finish_seq(self.handle, CCS_CLEAR)
                self._put(frame, timestamp)
                return
 
            # Need to keep a reference to the callback.
            self._eof_callback = CALLBACK(cb)
            _cam_register_callback(
                self.handle, PL_CALLBACK_EOF, self._eof_callback
            )
            nbytes = _exp_setup_seq(
                self.handle,
                1,
                1,  # cam, num epxosures, num regions
                self._region,
                TRIGGER_MODES[self._trigger].pv_mode,
                t_exp,
            )
            buffer_shape = (
                self.roi.height // self.binning.v,
                self.roi.width // self.binning.h,
            )
            self._buffer = np.require(
                np.empty(buffer_shape, dtype=buffer_dtype),
                requirements=["C_CONTIGUOUS", "ALIGNED", "OWNDATA"],
            )
        else:
            # Use a circular buffer.
            self._using_callback = True
 
            # Determine the data type of the frame
            frame_type = uns16
            if buffer_dtype == "uint8":
                frame_type = uns8
 
            def cb():
                """Circular buffer mode end-of-frame callback."""
                timestamp = time.time()
                frame_p = ctypes.cast(
                    _exp_get_latest_frame(self.handle),
                    ctypes.POINTER(frame_type),
                )
                frame = np.ctypeslib.as_array(
                    frame_p, (self.roi[2], self.roi[3])
                ).copy()
                _logger.debug("Fetched frame from circular buffer.")
                self._put(frame, timestamp)
                return
 
            # Need to keep a reference to the callback.
            self._eof_callback = CALLBACK(cb)
            _cam_register_callback(
                self.handle, PL_CALLBACK_EOF, self._eof_callback
            )
            buffer_shape = (
                self._circ_buffer_length,
                self.roi.height // self.binning.v,
                self.roi.width // self.binning.h,
            )
            self._buffer = np.require(
                np.empty(buffer_shape, dtype=buffer_dtype),
                requirements=["C_CONTIGUOUS", "ALIGNED", "OWNDATA"],
            )
            nbytes = _exp_setup_cont(
                self.handle,
                1,
                self._region,
                TRIGGER_MODES[self._trigger].pv_mode,
                t_exp,
                CIRC_OVERWRITE,
            ).value
 
        # Read back exposure time.
        t_readback = self._params[PARAM_EXPOSURE_TIME].current
        t_resolution = self._params[PARAM_EXP_RES].current
        multipliers = {
            EXP_RES_ONE_SEC: 1.0,
            EXP_RES_ONE_MILLISEC: 1e-3,
            EXP_RES_ONE_MICROSEC: 1e-6,
        }
        if isinstance(t_resolution, tuple):
            self.exposure_time = t_readback * multipliers[t_resolution[0]]
        else:
            self.exposure_time = t_readback * multipliers[t_resolution]
        # Update cycle time. Exposure time in seconds; readout time in microseconds.
        self.cycle_time = (
            self.exposure_time
            + 1e-6 * self._params[PARAM_READOUT_TIME].current
        )
        # Set up exposure time for VARIABLE_TIMED_MODE, as according to documentation.
        # It doesn't seem to work.
        if self._trigger == TRIG_VARIABLE:
            self._params[PARAM_EXP_TIME].set_value(t_exp)
        # If using real triggering, start triggered acquisition.
        # (Software triggering will start acquisition in soft_trigger().)
        if self._trigger != TRIG_SOFT:
            _exp_start_cont(
                self.handle,
                self._buffer.ctypes.data_as(ctypes.c_void_p),
                self._buffer.nbytes,
            )
        # Done.
        self._acquiring = True
        return self._acquiring
 

◆ _do_shutdown()

None microscope.cameras.pvcam.PVCamera._do_shutdown ( self )

protected

Disable the hardware for a prolonged period of inactivity.

Reimplemented from microscope.abc.Device.

Definition at line 1618 of file pvcam.py.

    def _do_shutdown(self) -> None:
        """Disable the hardware for a prolonged period of inactivity."""
        self.abort()
        _cam_close(self.handle)
        PVCamera.open_cameras.remove(self.handle)
        if not PVCamera.open_cameras:
            _logger.info("No more open cameras - calling _pvcam_uninit.")
            _pvcam_uninit()
 

◆ _do_trigger()

None microscope.cameras.pvcam.PVCamera._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 1893 of file pvcam.py.

    def _do_trigger(self) -> None:
        _exp_start_seq(
            self.handle, self._buffer.ctypes.data_as(ctypes.c_void_p)
        )

◆ _fetch_data()

microscope.cameras.pvcam.PVCamera._fetch_data ( self )

protected

Fetch data - for use in fetch_loop.

Reimplemented from microscope.abc.DataDevice.

Definition at line 1475 of file pvcam.py.

    def _fetch_data(self):
        """Fetch data - for use in fetch_loop."""
        # Not used: images fetched using callback.
        return None
 

◆ _get_binning()

microscope.cameras.pvcam.PVCamera._get_binning ( self )

protected

Return the current binning (horizontal, vertical).

Reimplemented from microscope.abc.Camera.

Definition at line 1635 of file pvcam.py.

    def _get_binning(self):
        """Return the current binning (horizontal, vertical)."""
        return self.binning
 

◆ _get_roi()

microscope.cameras.pvcam.PVCamera._get_roi ( self )

protected

Return the current ROI (left, top, width, height).

Reimplemented from microscope.abc.Camera.

Definition at line 1645 of file pvcam.py.

    def _get_roi(self):
        """Return the current ROI (left, top, width, height)."""
        return self.roi
 

◆ _get_sensor_shape()

microscope.cameras.pvcam.PVCamera._get_sensor_shape ( self )

protected

Return the sensor shape (width, height).

Reimplemented from microscope.abc.Camera.

Definition at line 1631 of file pvcam.py.

    def _get_sensor_shape(self):
        """Return the sensor shape (width, height)."""
        return self.shape
 

◆ _region()

microscope.cameras.pvcam.PVCamera._region ( self )

protected

Return a rgn_type for current roi and binning settings.

Definition at line 1462 of file pvcam.py.

    def _region(self):
        """Return a rgn_type for current roi and binning settings."""
        return rgn_type(
            self.roi.left,
            self.roi.left + self.roi.width - 1,
            self.binning.h,
            self.roi.top,
            self.roi.top + self.roi.height - 1,
            self.binning.v,
        )
 

◆ _set_binning()

microscope.cameras.pvcam.PVCamera._set_binning	(		self,
			binning )

protected

Set binning to (h, v).

Reimplemented from microscope.abc.Camera.

Definition at line 1640 of file pvcam.py.

    def _set_binning(self, binning):
        """Set binning to (h, v)."""
        #  The keep_acquiring decorator will cause recreation of buffers.
        self.binning = microscope.Binning(binning.h, binning.v)
 

◆ _set_roi()

microscope.cameras.pvcam.PVCamera._set_roi	(		self,
			roi )

protected

Set the ROI to (left, tip, width, height).

Reimplemented from microscope.abc.Camera.

Definition at line 1650 of file pvcam.py.

    def _set_roi(self, roi):
        """Set the ROI to (left, tip, width, height)."""
        right = roi.left + roi.width
        bottom = roi.top + roi.height
        if (right, bottom) > self.shape:
            raise ValueError("ROI exceeds sensor area.")
        self.roi = roi
 

◆ abort()

microscope.cameras.pvcam.PVCamera.abort ( self )

Abort acquisition.

This should put the camera into a state in which settings can
be modified.

Reimplemented from microscope.abc.DataDevice.

Definition at line 1664 of file pvcam.py.

    def abort(self):
        """Abort acquisition.
 
        This should put the camera into a state in which settings can
        be modified."""
        if self._trigger == TRIG_SOFT:
            _exp_finish_seq(self.handle, CCS_CLEAR)
        else:
            _exp_stop_cont(self.handle, CCS_CLEAR)
        _exp_abort(self.handle, CCS_HALT)
        self._acquiring = False
 

◆ get_cycle_time()

microscope.cameras.pvcam.PVCamera.get_cycle_time ( self )

Return the cycle time.

Just return self.cycle_time, which is updated with the real
value during _do_enable.

Reimplemented from microscope.abc.Camera.

Definition at line 1839 of file pvcam.py.

    def get_cycle_time(self):
        """Return the cycle time.
 
        Just return self.cycle_time, which is updated with the real
        value during _do_enable."""
        return self.cycle_time
 

◆ get_exposure_time()

microscope.cameras.pvcam.PVCamera.get_exposure_time ( self )

Return the current exposure time.

Just return self.exposure_time, which is updated with the real
value during _do_enable.

Reimplemented from microscope.abc.Camera.

Definition at line 1832 of file pvcam.py.

    def get_exposure_time(self):
        """Return the current exposure time.
 
        Just return self.exposure_time, which is updated with the real
        value during _do_enable."""
        return self.exposure_time
 

◆ get_id()

microscope.cameras.pvcam.PVCamera.get_id ( self )

Get hardware's unique identifier.

Reimplemented from microscope.abc.FloatingDeviceMixin.

Definition at line 1660 of file pvcam.py.

    def get_id(self):
        """Get hardware's unique identifier."""
        return self._params[PARAM_HEAD_SER_NUM_ALPHA].current
 

◆ initialize()

microscope.cameras.pvcam.PVCamera.initialize ( self )

Initialise the camera.

Reimplemented from microscope.abc.Device.

Definition at line 1676 of file pvcam.py.

    def initialize(self):
        """Initialise the camera."""
        # Init the DLL if necessary.
        if not PVCamera.open_cameras:
            try:
                _pvcam_init()
            except:
                pass
        # If no cameras detected, need to deinit DLL so it can be reinited to update count.
        if _cam_get_total().value == 0:
            _pvcam_uninit()
            raise microscope.InitialiseError("No cameras detected.")
        # Connect to the camera.
        _logger.info("DLL version: %s", _pvcam_get_ver().value)
        self._pv_name = _cam_get_name(self._index).value
        _logger.info("Initializing %s", self._pv_name)
        self.handle = _cam_open(self._pv_name, OPEN_EXCLUSIVE)
        PVCamera.open_cameras.append(self.handle)
        # Set up event callbacks. Tried to use the resume callback to reinit camera
        # after power loss, but any attempt to close/reopen the camera or deinit the
        # DLL throws a Windows Error 0xE06D7363.
        def _cb(event):
            _logger.info("Received %s event.", event)
            if event == "removed":
                _logger.critical("Can not re-init hardware. Exiting.")
                exit(-1)
            return
 
        self._cbs = {
            "check": CALLBACK(lambda: _cb("check")),
            "resumed": CALLBACK(lambda: _cb("resumed")),
            "removed": CALLBACK(lambda: _cb("removed")),
        }
        _cam_register_callback(
            self.handle, PL_CALLBACK_CHECK_CAMS, self._cbs["check"]
        )
        _cam_register_callback(
            self.handle, PL_CALLBACK_CAM_REMOVED, self._cbs["removed"]
        )
        _cam_register_callback(
            self.handle, PL_CALLBACK_CAM_RESUMED, self._cbs["resumed"]
        )
        # Repopulate _params.
        self._params = {}
        for (param_id, name) in _param_to_name.items():
            try:
                p = PVParam.factory(self, param_id)
            except:
                _logger.warn("Skipping unsupported parameter %s.", name)
                continue
            if not p.dtype or not p.available:
                continue
            self._params[param_id] = p
            name = name[6:]
 
            try:
                p.current
            except KeyError:
                # Raise these here, as the message is a tuple, not a str.
                raise
            except Exception as err:
                # Test on err.args prevents indexing into empty tuple.
                if err.args and not err.args[0].startswith("pvcam error 49"):
                    _logger.warn(
                        "Skipping parameter %s: not supported" " in python.",
                        p.name,
                    )
                    continue
            self.add_setting(
                p.name,
                p.dtype,
                lambda p=p: p.current,
                p.set_value
                if p.access in [ACC_READ_WRITE, ACC_WRITE_ONLY]
                else None,
                lambda p=p: p.values,
            )
        if PARAM_GAIN_MULT_FACTOR in self._params:
            self.add_setting(
                "gain",
                self._params[PARAM_GAIN_MULT_FACTOR].dtype,
                lambda: self._params[PARAM_GAIN_MULT_FACTOR].current,
                self._params[PARAM_GAIN_MULT_FACTOR].set_value,
                self._params[PARAM_GAIN_MULT_FACTOR].values,
            )
 
        if PARAM_PMODE in self._params:
            self.add_setting(
                "frame transfer mode",
                self._params[PARAM_PMODE].dtype,
                lambda: self._params[PARAM_PMODE].current,
                self._params[PARAM_PMODE].set_value,
                self._params[PARAM_PMODE].values,
            )
 
        self.shape = (
            self._params[PARAM_PAR_SIZE].current,
            self._params[PARAM_SER_SIZE].current,
        )
        self.roi = microscope.ROI(0, 0, self.shape[0], self.shape[1])
 
        # Populate readout modes by iterating over readout ports and speed
        # table entries.
        ro_ports = self._params[PARAM_READOUT_PORT].values
        self._readout_modes = []
        self._readout_mode_parameters = []
        for i, port in ro_ports.items():
            self._params[PARAM_READOUT_PORT].set_value(i)
            ro_speeds = self._params[PARAM_SPDTAB_INDEX].values
            for j in range(ro_speeds[0], ro_speeds[1] + 1):
                self._params[PARAM_SPDTAB_INDEX].set_value(j)
                bit_depth = self._params[PARAM_BIT_DEPTH].current
                freq = 1e9 / self._params[PARAM_PIX_TIME].current
                if freq > 1e6:
                    freq *= 1e-6
                    prefix = "M"
                elif freq > 1e3:
                    freq *= 1e-3
                    prefix = "k"
                else:
                    prefix = "Hz"
                mode_str = "%s, %s-bit, %s %sHz" % (
                    port,
                    bit_depth,
                    freq,
                    prefix,
                )
                self._readout_modes.append(mode_str)
                self._readout_mode_parameters.append(
                    {"port": i, "spdtab_index": j}
                )
        # Set to default mode.
        self.set_readout_mode(0)
        self._params[PARAM_CLEAR_MODE].set_value(CLEAR_PRE_EXPOSURE_POST_SEQ)
 

◆ set_exposure_time()

microscope.cameras.pvcam.PVCamera.set_exposure_time	(		self,
			value )

Set the exposure time to value.

Reimplemented from microscope.abc.Camera.

Definition at line 1828 of file pvcam.py.

    def set_exposure_time(self, value):
        """Set the exposure time to value."""
        self.exposure_time = value
 

◆ set_readout_mode()

microscope.cameras.pvcam.PVCamera.set_readout_mode	(		self,
			index )

Set the readout mode and transform.

Reimplemented from microscope.abc.Camera.

Definition at line 1812 of file pvcam.py.

    def set_readout_mode(self, index):
        """Set the readout mode and transform."""
        params = self._readout_mode_parameters[index]
        self._params[PARAM_READOUT_PORT].set_value(params["port"])
        self._params[PARAM_SPDTAB_INDEX].set_value(params["spdtab_index"])
        self._readout_mode = index
        # Update transforms, if available.
        chip = self._params[PARAM_CHIP_NAME].current
        new_readout_transform = None
        readout_map = READOUT_TRANSFORMS.get(chip, None)
        if readout_map:
            new_readout_transform = readout_map.get(params["port"], None)
        if new_readout_transform:
            self._set_readout_transform(new_readout_transform)
 

◆ set_trigger()

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

Set device for a specific trigger.

Reimplemented from microscope.abc.TriggerTargetMixin.

Definition at line 1883 of file pvcam.py.

    ) -> None:
        try:
            self._trigger = TRIGGER_TO_PV_MODE[(ttype, tmode)]
        except KeyError:
            raise microscope.UnsupportedFeatureError(
                "no PVCam mode for %s and %s" % (ttype, tmode)
            )
 

◆ soft_trigger()

microscope.cameras.pvcam.PVCamera.soft_trigger ( self )

Expose software triggering to a client.

Deprecated, use trigger().

Trigger an exposure in TRIG_SOFT mode.
Log some debugging stats in other trigger modes.

Definition at line 1847 of file pvcam.py.

    def soft_trigger(self):
        """Expose software triggering to a client.
 
        Deprecated, use trigger().
 
        Trigger an exposure in TRIG_SOFT mode.
        Log some debugging stats in other trigger modes."""
        if self._trigger == TRIG_SOFT:
            _logger.debug("Received soft trigger ...")
            _exp_start_seq(
                self.handle, self._buffer.ctypes.data_as(ctypes.c_void_p)
            )
        else:
            cstatus, cbytes, cframes = _exp_check_cont_status(self.handle)
            status, bytes = _exp_check_status(self.handle)
 
            _logger.debug(
                "Status checks\n"
                "check_cont:   %s \t bytes: %d\tframes: %d\n"
                "check_status: %s \t bytes: %d\t",
                STATUS_STRINGS[cstatus.value],
                cbytes.value,
                cframes.value,
                STATUS_STRINGS[status.value],
                bytes.value,
            )
        return
 

◆ trigger_mode()

microscope.TriggerMode microscope.cameras.pvcam.PVCamera.trigger_mode ( self )

Reimplemented from microscope.abc.TriggerTargetMixin.

Definition at line 1876 of file pvcam.py.

    def trigger_mode(self) -> microscope.TriggerMode:
        return PV_MODE_TO_TRIGGER[self._trigger][1]
 

◆ trigger_type()

microscope.TriggerType microscope.cameras.pvcam.PVCamera.trigger_type ( self )

Reimplemented from microscope.abc.TriggerTargetMixin.

Definition at line 1880 of file pvcam.py.

    def trigger_type(self) -> microscope.TriggerType:
        return PV_MODE_TO_TRIGGER[self._trigger][0]
 

Member Data Documentation

◆ _acquiring

bool microscope.cameras.pvcam.PVCamera._acquiring = True

protected

Definition at line 1610 of file pvcam.py.

◆ _buffer

microscope.cameras.pvcam.PVCamera._buffer = None

protected

Definition at line 1430 of file pvcam.py.

◆ _cbs

dict microscope.cameras.pvcam.PVCamera._cbs

protected

Initial value:

=  {
            "check": CALLBACK(lambda: _cb("check")),
            "resumed": CALLBACK(lambda: _cb("resumed")),
            "removed": CALLBACK(lambda: _cb("removed")),
        }

Definition at line 1704 of file pvcam.py.

◆ _circ_buffer_length

microscope.cameras.pvcam.PVCamera._circ_buffer_length = 10

protected

Definition at line 1434 of file pvcam.py.

◆ _eof_callback

microscope.cameras.pvcam.PVCamera._eof_callback = CALLBACK(cb)

protected

Definition at line 1514 of file pvcam.py.

◆ _params

dict microscope.cameras.pvcam.PVCamera._params = {}

protected

Definition at line 1432 of file pvcam.py.

◆ _pv_name

microscope.cameras.pvcam.PVCamera._pv_name = None

protected

Definition at line 1416 of file pvcam.py.

◆ _readout_mode

microscope.cameras.pvcam.PVCamera._readout_mode = index

protected

Definition at line 1817 of file pvcam.py.

◆ _readout_mode_parameters

list microscope.cameras.pvcam.PVCamera._readout_mode_parameters = []

protected

Definition at line 1781 of file pvcam.py.

◆ _readout_modes

list microscope.cameras.pvcam.PVCamera._readout_modes = []

protected

Definition at line 1780 of file pvcam.py.

◆ _trigger

microscope.cameras.pvcam.PVCamera._trigger = TRIG_STROBED

protected

Definition at line 1425 of file pvcam.py.

◆ _using_callback

bool microscope.cameras.pvcam.PVCamera._using_callback = True

protected

Definition at line 1502 of file pvcam.py.

◆ binning

microscope.cameras.pvcam.PVCamera.binning = microscope.Binning(1, 1)

Definition at line 1424 of file pvcam.py.

◆ cycle_time

float microscope.cameras.pvcam.PVCamera.cycle_time = self.exposure_time

Definition at line 1428 of file pvcam.py.

◆ exposure_time

microscope.cameras.pvcam.PVCamera.exposure_time = 0.001

Definition at line 1426 of file pvcam.py.

◆ handle

microscope.cameras.pvcam.PVCamera.handle = None

Definition at line 1418 of file pvcam.py.

◆ open_cameras

list microscope.cameras.pvcam.PVCamera.open_cameras = []

static

Definition at line 1411 of file pvcam.py.

◆ roi [1/2]

tuple microscope.cameras.pvcam.PVCamera.roi = (None, None, None, None)

Definition at line 1422 of file pvcam.py.

◆ roi [2/2]

dict microscope.cameras.pvcam.PVCamera.roi = self._params[PARAM_READOUT_PORT].values

Definition at line 1775 of file pvcam.py.

◆ set_exposure_time

microscope.cameras.pvcam.PVCamera.set_exposure_time

Definition at line 1441 of file pvcam.py.

◆ shape

tuple microscope.cameras.pvcam.PVCamera.shape = (None, None)

Definition at line 1420 of file pvcam.py.

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

BioImager/PythonMicroscope/microscope/cameras/pvcam.py

Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ _do_disable()

◆ _do_enable()

◆ _do_shutdown()

◆ _do_trigger()

◆ _fetch_data()

◆ _get_binning()

◆ _get_roi()

◆ _get_sensor_shape()

◆ _region()

◆ _set_binning()

◆ _set_roi()

◆ abort()

◆ get_cycle_time()

◆ get_exposure_time()

◆ get_id()

◆ initialize()

◆ set_exposure_time()

◆ set_readout_mode()

◆ set_trigger()

◆ soft_trigger()

◆ trigger_mode()

◆ trigger_type()

Member Data Documentation

◆ _acquiring

◆ _buffer

◆ _cbs

◆ _circ_buffer_length

◆ _eof_callback

◆ _params

◆ _pv_name

◆ _readout_mode

◆ _readout_mode_parameters

◆ _readout_modes

◆ _trigger

◆ _using_callback

◆ binning

◆ cycle_time

◆ exposure_time

◆ handle

◆ open_cameras

◆ roi [1/2]

◆ roi [2/2]

◆ set_exposure_time

◆ shape

◆ init()