Alazar Tech Drivers

Classes:

AcquisitionController(name, alazar_name, ...)

Compatibility class.

AcquisitionInterface()

This class represents all choices that the end-user has to make regarding the data-acquisition.

AlazarTechATS(name[, system_id, board_id, ...])

This is the BaseClass for the qcodes drivers for Alazar data acquisition cards.

AlazarTechATS9360(name[, dll_path])

This class is the driver for the ATS9360 board it inherits from the ATS base class

AlazarTechATS9373(name[, dll_path])

This class is the driver for the ATS9373 board.

AlazarTechATS9440(name[, dll_path])

This class is the driver for the ATS9440 board it inherits from the ATS base class

AlazarTechATS9870(name[, dll_path])

This class is the driver for the ATS9870 board it inherits from the ATS base class

DemodulationAcquisitionController(name, ...)

This class represents an example acquisition controller.

class qcodes.instrument_drivers.AlazarTech.AcquisitionController(name: str, alazar_name: str, **kwargs: Unpack[InstrumentBaseKWArgs])[source]

Bases: Instrument, AcquisitionInterface[Any], Generic[OutputType]

Compatibility class. The methods of AcquisitionController have been extracted. This class is the base class fro AcquisitionInterfaces that are intended to be QCoDeS instruments at the same time.

Parameters:
  • name – The name of the AcquisitionController

  • alazar_name – The name of the alazar instrument.

  • **kwargs – kwargs are forwarded to base class.

class qcodes.instrument_drivers.AlazarTech.AcquisitionInterface[source]

Bases: Generic[OutputType]

This class represents all choices that the end-user has to make regarding the data-acquisition. this class should be subclassed to program these choices.

The basic structure of an acquisition is:

Methods:

pre_start_capture()

Use this method to prepare yourself for the data acquisition The Alazar instrument will call this method right before 'AlazarStartCapture' is called

pre_acquire()

This method is called immediately after 'AlazarStartCapture' is called

handle_buffer(buffer[, buffer_number])

This method should store or process the information that is contained in the buffers obtained during the acquisition.

post_acquire()

This method should return any information you want to save from this acquisition.

buffer_done_callback(buffers_completed)

This method is called when a buffer is completed.

pre_start_capture() None[source]

Use this method to prepare yourself for the data acquisition The Alazar instrument will call this method right before ‘AlazarStartCapture’ is called

pre_acquire() None[source]

This method is called immediately after ‘AlazarStartCapture’ is called

handle_buffer(buffer: ndarray, buffer_number: int | None = None) None[source]

This method should store or process the information that is contained in the buffers obtained during the acquisition.

Parameters:
  • buffer – np.array with the data from the Alazar card

  • buffer_number – counter for which buffer we are handling

post_acquire() OutputType[source]

This method should return any information you want to save from this acquisition. The acquisition method from the Alazar driver will use this data as its own return value

Returns:

this function should return all relevant data that you want to get form the acquisition

buffer_done_callback(buffers_completed: int) None[source]

This method is called when a buffer is completed. It can be used if you want to implement an event that happens for each buffer. You will probably want to combine this with AUX_IN_TRIGGER_ENABLE to wait before starting capture of the next buffer.

Parameters:

buffers_completed – how many buffers have been completed and copied to local memory at the time of this callback.

class qcodes.instrument_drivers.AlazarTech.AlazarTechATS(name: str, system_id: int = 1, board_id: int = 1, dll_path: str | None = None, api: AlazarATSAPI | None = None, **kwargs: Unpack[InstrumentBaseKWArgs])[source]

Bases: Instrument

This is the BaseClass for the qcodes drivers for Alazar data acquisition cards. This should not be instantiated directly, but should be subclassed for a specific card should be used.

Parameters:
  • name – name for this instrument

  • system_id – target system id for this board

  • board_id – target board id within the system for this board

  • dll_path – path to the ATS driver dll library file

  • api – AlazarATSAPI interface, defaults to the dll api. This argument makes it possible to provide another api, e.g. for a simulated driver for which the binary Alazar drivers do not need to be installed.

Attributes:

Methods:

find_boards([dll_path])

Find connected Alazar boards

get_board_info(api, system_id, board_id)

Get the information from a connected Alazar board

get_idn()

This methods gets the most relevant information of this instrument

syncing()

Context manager for syncing settings to Alazar card.

sync_settings_to_card()

Syncs all parameters to Alazar card

allocate_and_post_buffer(sample_type, n_bytes)

acquire([mode, samples_per_record, ...])

perform a single acquisition with the Alazar board, and set certain parameters to the appropriate values for the parameters, see the ATS-SDK programmer's guide

clear_buffers()

This method uncommits all buffers that were committed by the driver.

signal_to_volt(channel, signal)

convert a value from a buffer to an actual value in volts based on the ranges of the channel

get_sample_rate([include_decimation])

Obtain the effective sampling rate of the acquisition based on clock speed and decimation

get_num_channels(byte_rep)

Return the number of channels for a specific channel mask

dll_path = 'C:\\WINDOWS\\System32\\ATSApi'
channels = 2
classmethod find_boards(dll_path: str | None = None) list[dict[str, Any]][source]

Find connected Alazar boards

Parameters:

dll_path – path to the Alazar API DLL library

Returns:

list of board info dictionaries for each connected board

classmethod get_board_info(api: AlazarATSAPI, system_id: int, board_id: int) dict[str, str | int][source]

Get the information from a connected Alazar board

Parameters:
  • api – An AlazarATSAPI that wraps around the CTypes CDLL

  • system_id – id of the Alazar system

  • board_id – id of the board within the alazar system

Returns:

Dictionary containing

  • system_id

  • board_id

  • board_kind (as string)

  • max_samples

  • bits_per_sample

api: AlazarATSAPI = api or AlazarATSAPI(dll_path or self.dll_path)
buffer_list: list[Buffer] = []
get_idn() dict[str, str | int | None][source]

This methods gets the most relevant information of this instrument

The firmware version reported should match the version number of downloadable fw files from AlazarTech. But note that the firmware version has often been found to be incorrect for several firmware versions. At the time of writing it is known to be correct for the 9360 (v 21.07) and 9373 (v 30.04) but incorrect for several earlier versions. In Alazar DSO this is reported as FPGA Version.

Returns:

Dictionary containing
  • ’firmware’: as string

  • ’model’: as string

  • ’serial’: board serial number

  • ’vendor’: ‘AlazarTech’

  • ’CPLD_version’: version of the CPLD

  • ’driver_version’: version of the driver dll

  • ’SDK_version’: version of the SDK

  • ’latest_cal_date’: date of the latest calibration (as string)

  • ’memory_size’: size of the memory in samples

  • ’asopc_type’: type of asopc (as decimal number)

  • ’pcie_link_speed’: the speed of a single pcie link (in GB/s)

  • ’pcie_link_width’: number of pcie links

  • ’bits_per_sample’: number of bits per one sample

  • ’max_samples’: board memory size in samples

syncing() Iterator[None][source]

Context manager for syncing settings to Alazar card. It will automatically call sync_settings_to_card at the end of the context.

Example

This is intended to be used around multiple parameter sets to ensure syncing is done exactly once:

with alazar.syncing():
     alazar.trigger_source1('EXTERNAL')
     alazar.trigger_level1(100)
sync_settings_to_card() None[source]

Syncs all parameters to Alazar card

allocate_and_post_buffer(sample_type: type[c_ubyte] | type[c_ushort] | type[c_uint] | type[c_int] | type[c_float], n_bytes: int) Buffer[source]
acquire(mode: str | None = None, samples_per_record: int | None = None, records_per_buffer: int | None = None, buffers_per_acquisition: int | None = None, channel_selection: str | None = None, transfer_offset: int | None = None, external_startcapture: str | None = None, enable_record_headers: str | None = None, alloc_buffers: str | None = None, fifo_only_streaming: str | None = None, interleave_samples: str | None = None, get_processed_data: str | None = None, allocated_buffers: int | None = None, buffer_timeout: int | None = None, acquisition_controller: AcquisitionController[OutputType] | None = None) OutputType[source]

perform a single acquisition with the Alazar board, and set certain parameters to the appropriate values for the parameters, see the ATS-SDK programmer’s guide

Parameters:
  • mode

  • samples_per_record

  • records_per_buffer

  • buffers_per_acquisition

  • channel_selection

  • transfer_offset

  • external_startcapture

  • enable_record_headers

  • alloc_buffers

  • fifo_only_streaming

  • interleave_samples

  • get_processed_data

  • allocated_buffers

  • buffer_timeout

  • acquisition_controller – An instance of an acquisition controller that handles the dataflow of an acquisition

Returns:

Whatever is given by acquisition_controller.post_acquire method

clear_buffers() None[source]

This method uncommits all buffers that were committed by the driver. This method only has to be called when the acquistion crashes, otherwise the driver will uncommit the buffers itself

Returns:

None

signal_to_volt(channel: int, signal: float) float[source]

convert a value from a buffer to an actual value in volts based on the ranges of the channel

Parameters:
  • channel – number of the channel where the signal value came from

  • signal – the value that needs to be converted

Returns:

the corresponding value in volts

get_sample_rate(include_decimation: bool = True) float[source]

Obtain the effective sampling rate of the acquisition based on clock speed and decimation

Returns:

the number of samples (per channel) per second

static get_num_channels(byte_rep: int) int[source]

Return the number of channels for a specific channel mask

Each single channel is represented by a bitarray with one non zero entry i.e. powers of two. All multichannel masks can be constructed by summing the single channel ones. However, not all configurations are supported. See table 4 Input Channel Configurations on page 241 of the Alazar SDK manual. This contains the complete mapping for all current Alazar cards. It’s left to the driver to ensure that only the ones supported for a specific card can be selected

parameters: dict[str, ParameterBase] = {}

All the parameters supported by this instrument. Usually populated via add_parameter().

functions: dict[str, Function] = {}

All the functions supported by this instrument. Usually populated via add_function().

submodules: dict[str, InstrumentModule | ChannelTuple] = {}

All the submodules of this instrument such as channel lists or logical groupings of parameters. Usually populated via add_submodule().

instrument_modules: dict[str, InstrumentModule] = {}

All the InstrumentModule of this instrument Usually populated via add_submodule().

log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)
metadata: dict[str, Any] = {}
class qcodes.instrument_drivers.AlazarTech.AlazarTechATS9360(name: str, dll_path: str = 'C:\\WINDOWS\\System32\\ATSApi.dll', **kwargs: Any)[source]

Bases: AlazarTechATS

This class is the driver for the ATS9360 board it inherits from the ATS base class

Attributes:

samples_divisor

clock_source

Parameter clock_source

external_sample_rate

Parameter external_sample_rate

sample_rate

Parameter sample_rate

clock_edge

Parameter clock_edge

decimation

Parameter decimation

trigger_operation

Parameter trigger_operation

external_trigger_coupling

Parameter external_trigger_coupling

external_trigger_range

Parameter external_trigger_range

trigger_delay

Parameter trigger_delay

timeout_ticks

Parameter timeout_ticks

aux_io_mode

Parameter aux_io_mode

aux_io_param

Parameter aux_io_param

mode

Parameter mode

samples_per_record

Parameter samples_per_record

records_per_buffer

Parameter records_per_buffer

buffers_per_acquisition

Parameter buffers_per_acquisition

channel_selection

Parameter channel_selection

transfer_offset

Parameter transfer_offset

external_startcapture

Parameter external_startcapture

enable_record_headers

Parameter enable_record_headers

alloc_buffers

Parameter alloc_buffers

fifo_only_streaming

Parameter fifo_only_streaming

interleave_samples

Parameter interleave_samples

get_processed_data

Parameter get_processed_data

allocated_buffers

Parameter allocated_buffers

buffer_timeout

Parameter buffer_timeout

trigger_holdoff

If enabled Alazar will ignore any additional triggers while capturing a record.

samples_divisor = 128
clock_source: TraceParameter = self.add_parameter( name="clock_source", parameter_class=TraceParameter, label="Clock Source", unit=None, initial_value="INTERNAL_CLOCK", val_mapping={ "INTERNAL_CLOCK": 1, "FAST_EXTERNAL_CLOCK": 2, "EXTERNAL_CLOCK_10MHz_REF": 7, }, )

Parameter clock_source

external_sample_rate: TraceParameter = self.add_parameter( name="external_sample_rate", parameter_class=TraceParameter, label="External Sample Rate", unit="S/s", vals=validators.MultiType( validators.Ints(300000000, 1800000000), validators.Enum("UNDEFINED") ), initial_value="UNDEFINED", )

Parameter external_sample_rate

sample_rate: TraceParameter = self.add_parameter( name="sample_rate", parameter_class=TraceParameter, label="Internal Sample Rate", unit="S/s", initial_value="UNDEFINED", val_mapping={ 1_000: 1, 2_000: 2, 5_000: 4, 10_000: 8, 20_000: 10, 50_000: 12, 100_000: 14, 200_000: 16, 500_000: 18, 1_000_000: 20, 2_000_000: 24, 5_000_000: 26, 10_000_000: 28, 20_000_000: 30, 50_000_000: 34, 100_000_000: 36, 200_000_000: 40, 500_000_000: 48, 800_000_000: 50, 1_000_000_000: 53, 1_200_000_000: 55, 1_500_000_000: 58, 1_800_000_000: 61, "EXTERNAL_CLOCK": 64, "UNDEFINED": "UNDEFINED", }, )

Parameter sample_rate

clock_edge: TraceParameter = self.add_parameter( name="clock_edge", parameter_class=TraceParameter, label="Clock Edge", unit=None, initial_value="CLOCK_EDGE_RISING", val_mapping={"CLOCK_EDGE_RISING": 0, "CLOCK_EDGE_FALLING": 1}, )

Parameter clock_edge

decimation: TraceParameter = self.add_parameter( name="decimation", parameter_class=TraceParameter, label="Decimation", unit=None, initial_value=1, vals=validators.Ints(0, 100000), )

Parameter decimation

trigger_operation: TraceParameter = self.add_parameter( name="trigger_operation", parameter_class=TraceParameter, label="Trigger Operation", unit=None, initial_value="TRIG_ENGINE_OP_J", val_mapping={ "TRIG_ENGINE_OP_J": 0, "TRIG_ENGINE_OP_K": 1, "TRIG_ENGINE_OP_J_OR_K": 2, "TRIG_ENGINE_OP_J_AND_K": 3, "TRIG_ENGINE_OP_J_XOR_K": 4, "TRIG_ENGINE_OP_J_AND_NOT_K": 5, "TRIG_ENGINE_OP_NOT_J_AND_K": 6, }, )

Parameter trigger_operation

external_trigger_coupling: TraceParameter = self.add_parameter( name="external_trigger_coupling", parameter_class=TraceParameter, label="External Trigger Coupling", unit=None, initial_value="DC", val_mapping={"AC": 1, "DC": 2}, )

Parameter external_trigger_coupling

external_trigger_range: TraceParameter = self.add_parameter( name="external_trigger_range", parameter_class=TraceParameter, label="External Trigger Range", unit=None, initial_value="ETR_2V5", val_mapping={"ETR_TTL": 2, "ETR_2V5": 3}, )

Parameter external_trigger_range

trigger_delay: TraceParameter = self.add_parameter( name="trigger_delay", parameter_class=TraceParameter, label="Trigger Delay", unit="Sample clock cycles", initial_value=0, vals=validators.Multiples(divisor=8, min_value=0), )

Parameter trigger_delay

timeout_ticks: TraceParameter = self.add_parameter( name="timeout_ticks", parameter_class=TraceParameter, label="Timeout Ticks", unit="10 us", initial_value=0, vals=validators.Ints(min_value=0), )

Parameter timeout_ticks

aux_io_mode: TraceParameter = self.add_parameter( name="aux_io_mode", parameter_class=TraceParameter, label="AUX I/O Mode", unit=None, initial_value="AUX_IN_AUXILIARY", val_mapping={ "AUX_OUT_TRIGGER": 0, "AUX_IN_TRIGGER_ENABLE": 1, "AUX_IN_AUXILIARY": 13, }, )

Parameter aux_io_mode

aux_io_param: TraceParameter = self.add_parameter( name="aux_io_param", parameter_class=TraceParameter, label="AUX I/O Param", unit=None, initial_value="NONE", val_mapping={"NONE": 0, "TRIG_SLOPE_POSITIVE": 1, "TRIG_SLOPE_NEGATIVE": 2}, )

Parameter aux_io_param

mode: Parameter = self.add_parameter( name="mode", label="Acquisition mode", unit=None, initial_value="NPT", set_cmd=None, val_mapping={"NPT": 0x200, "TS": 0x400}, )

Parameter mode

samples_per_record: Parameter = self.add_parameter( name="samples_per_record", label="Samples per Record", unit=None, initial_value=1024, set_cmd=None, vals=validators.Multiples(divisor=self.samples_divisor, min_value=256), )

Parameter samples_per_record

records_per_buffer: Parameter = self.add_parameter( name="records_per_buffer", label="Records per Buffer", unit=None, initial_value=10, set_cmd=None, vals=validators.Ints(min_value=0), )

Parameter records_per_buffer

api: AlazarATSAPI = api or AlazarATSAPI(dll_path or self.dll_path)
buffer_list: list[Buffer] = []
parameters: dict[str, ParameterBase] = {}

All the parameters supported by this instrument. Usually populated via add_parameter().

functions: dict[str, Function] = {}

All the functions supported by this instrument. Usually populated via add_function().

submodules: dict[str, InstrumentModule | ChannelTuple] = {}

All the submodules of this instrument such as channel lists or logical groupings of parameters. Usually populated via add_submodule().

instrument_modules: dict[str, InstrumentModule] = {}

All the InstrumentModule of this instrument Usually populated via add_submodule().

log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)
metadata: dict[str, Any] = {}
buffers_per_acquisition: Parameter = self.add_parameter( name="buffers_per_acquisition", label="Buffers per Acquisition", unit=None, set_cmd=None, initial_value=10, vals=validators.Ints(min_value=0), )

Parameter buffers_per_acquisition

channel_selection: Parameter = self.add_parameter( name="channel_selection", label="Channel Selection", unit=None, set_cmd=None, initial_value="AB", val_mapping={"A": 1, "B": 2, "AB": 3}, )

Parameter channel_selection

transfer_offset: Parameter = self.add_parameter( name="transfer_offset", label="Transfer Offset", unit="Samples", set_cmd=None, initial_value=0, vals=validators.Ints(min_value=0), )

Parameter transfer_offset

external_startcapture: Parameter = self.add_parameter( name="external_startcapture", label="External Startcapture", unit=None, set_cmd=None, initial_value="ENABLED", val_mapping={"DISABLED": 0x0, "ENABLED": 0x1}, )

Parameter external_startcapture

enable_record_headers: Parameter = self.add_parameter( name="enable_record_headers", label="Enable Record Headers", unit=None, set_cmd=None, initial_value="DISABLED", val_mapping={"DISABLED": 0x0, "ENABLED": 0x8}, )

Parameter enable_record_headers

alloc_buffers: Parameter = self.add_parameter( name="alloc_buffers", label="Alloc Buffers", unit=None, set_cmd=None, initial_value="DISABLED", val_mapping={"DISABLED": 0x0, "ENABLED": 0x20}, )

Parameter alloc_buffers

fifo_only_streaming: Parameter = self.add_parameter( name="fifo_only_streaming", label="Fifo Only Streaming", unit=None, set_cmd=None, initial_value="DISABLED", val_mapping={"DISABLED": 0x0, "ENABLED": 0x800}, )

Parameter fifo_only_streaming

interleave_samples: Parameter = self.add_parameter( name="interleave_samples", label="Interleave Samples", unit=None, set_cmd=None, initial_value="DISABLED", val_mapping={"DISABLED": 0x0, "ENABLED": 0x1000}, )

Parameter interleave_samples

get_processed_data: Parameter = self.add_parameter( name="get_processed_data", label="Get Processed Data", unit=None, set_cmd=None, initial_value="DISABLED", val_mapping={"DISABLED": 0x0, "ENABLED": 0x2000}, )

Parameter get_processed_data

allocated_buffers: Parameter = self.add_parameter( name="allocated_buffers", label="Allocated Buffers", unit=None, set_cmd=None, initial_value=4, vals=validators.Ints(min_value=0), )

Parameter allocated_buffers

buffer_timeout: Parameter = self.add_parameter( name="buffer_timeout", label="Buffer Timeout", unit="ms", set_cmd=None, initial_value=1000, vals=validators.Ints(min_value=0), )

Parameter buffer_timeout

trigger_holdoff: Parameter = self.add_parameter( name="trigger_holdoff", label="Trigger Holdoff", docstring=f"If enabled Alazar will " f"ignore any additional triggers " f"while capturing a record. If disabled " f"a trigger signal during a capture " f" will result in corrupt data. " f"Support for this requires at least " f"firmware version " f"{self._trigger_holdoff_min_fw_version}", vals=validators.Bool(), get_cmd=self._get_trigger_holdoff, set_cmd=self._set_trigger_holdoff, )

If enabled Alazar will ignore any additional triggers while capturing a record.

class qcodes.instrument_drivers.AlazarTech.AlazarTechATS9373(name: str, dll_path: str = 'C:\\WINDOWS\\System32\\ATSApi.dll', **kwargs: Any)[source]

Bases: AlazarTechATS

This class is the driver for the ATS9373 board.

Note that this board is very similar to ATS9360. Refer to ATS SDK for details.

Note that channels of this board have 12-bit resolution (see IDN()[‘bits_per_sample’]) which means that the raw data that is returned by the card should be converted to uint16 type with a bit shift by 4 bits. Refer to ATS SDK for more infromation.

Attributes:

samples_divisor

clock_source

Parameter clock_source

external_sample_rate

Parameter external_sample_rate

sample_rate

Parameter sample_rate

clock_edge

Parameter clock_edge

decimation

Parameter decimation

trigger_operation

Parameter trigger_operation

external_trigger_coupling

Parameter external_trigger_coupling

external_trigger_range

Parameter external_trigger_range

trigger_delay

Parameter trigger_delay

timeout_ticks

Parameter timeout_ticks

aux_io_mode

Parameter aux_io_mode

aux_io_param

Parameter aux_io_param

mode

Parameter mode

samples_per_record

Parameter samples_per_record

records_per_buffer

Parameter records_per_buffer

buffers_per_acquisition

Parameter buffers_per_acquisition

channel_selection

Parameter channel_selection

transfer_offset

Parameter transfer_offset

external_startcapture

Parameter external_startcapture

enable_record_headers

Parameter enable_record_headers

alloc_buffers

Parameter alloc_buffers

fifo_only_streaming

Parameter fifo_only_streaming

interleave_samples

Parameter interleave_samples

get_processed_data

Parameter get_processed_data

allocated_buffers

Parameter allocated_buffers

buffer_timeout

Parameter buffer_timeout

trigger_holdoff

If enabled Alazar will ignore any additional triggers while capturing a record.

samples_divisor = 128
clock_source: TraceParameter = self.add_parameter( name="clock_source", parameter_class=TraceParameter, label="Clock Source", unit=None, initial_value="INTERNAL_CLOCK", val_mapping={ "INTERNAL_CLOCK": 1, "FAST_EXTERNAL_CLOCK": 2, "EXTERNAL_CLOCK_10MHz_REF": 7, }, )

Parameter clock_source

external_sample_rate: TraceParameter = self.add_parameter( name="external_sample_rate", parameter_class=TraceParameter, label="External Sample Rate", unit="S/s", vals=validators.MultiType( validators.Ints(300000000, 2000000000), validators.Enum("UNDEFINED") ), initial_value="UNDEFINED", )

Parameter external_sample_rate

sample_rate: TraceParameter = self.add_parameter( name="sample_rate", parameter_class=TraceParameter, label="Internal Sample Rate", unit="S/s", initial_value="UNDEFINED", val_mapping={ 1_000: 1, 2_000: 2, 5_000: 4, 10_000: 8, 20_000: 10, 50_000: 12, 100_000: 14, 200_000: 16, 500_000: 18, 1_000_000: 20, 2_000_000: 24, 5_000_000: 26, 10_000_000: 28, 20_000_000: 30, 25_000_000: 33, 50_000_000: 34, 100_000_000: 36, 125_000_000: 37, 160_000_000: 38, 180_000_000: 39, 200_000_000: 40, 250_000_000: 43, 500_000_000: 48, 800_000_000: 50, 1_000_000_000: 53, 1_200_000_000: 55, 1_500_000_000: 58, 1_800_000_000: 61, 2_000_000_000: 63, 2_400_000_000: 106, 3_000_000_000: 117, 3_600_000_000: 123, 4_000_000_000: 128, "EXTERNAL_CLOCK": 64, "UNDEFINED": "UNDEFINED", }, )

Parameter sample_rate

clock_edge: TraceParameter = self.add_parameter( name="clock_edge", parameter_class=TraceParameter, label="Clock Edge", unit=None, initial_value="CLOCK_EDGE_RISING", val_mapping={"CLOCK_EDGE_RISING": 0, "CLOCK_EDGE_FALLING": 1}, )

Parameter clock_edge

decimation: TraceParameter = self.add_parameter( name="decimation", parameter_class=TraceParameter, label="Decimation", unit=None, initial_value=1, vals=validators.Ints(0, 100000), )

Parameter decimation

trigger_operation: TraceParameter = self.add_parameter( name="trigger_operation", parameter_class=TraceParameter, label="Trigger Operation", unit=None, initial_value="TRIG_ENGINE_OP_J", val_mapping={ "TRIG_ENGINE_OP_J": 0, "TRIG_ENGINE_OP_K": 1, "TRIG_ENGINE_OP_J_OR_K": 2, "TRIG_ENGINE_OP_J_AND_K": 3, "TRIG_ENGINE_OP_J_XOR_K": 4, "TRIG_ENGINE_OP_J_AND_NOT_K": 5, "TRIG_ENGINE_OP_NOT_J_AND_K": 6, }, )

Parameter trigger_operation

external_trigger_coupling: TraceParameter = self.add_parameter( name="external_trigger_coupling", parameter_class=TraceParameter, label="External Trigger Coupling", unit=None, initial_value="DC", val_mapping={"AC": 1, "DC": 2}, )

Parameter external_trigger_coupling

external_trigger_range: TraceParameter = self.add_parameter( name="external_trigger_range", parameter_class=TraceParameter, label="External Trigger Range", unit=None, initial_value="ETR_2V5", val_mapping={"ETR_TTL": 2, "ETR_2V5": 3}, )

Parameter external_trigger_range

trigger_delay: TraceParameter = self.add_parameter( name="trigger_delay", parameter_class=TraceParameter, label="Trigger Delay", unit="Sample clock cycles", initial_value=0, vals=validators.Multiples(divisor=8, min_value=0), )

Parameter trigger_delay

timeout_ticks: TraceParameter = self.add_parameter( name="timeout_ticks", parameter_class=TraceParameter, label="Timeout Ticks", unit="10 us", initial_value=0, vals=validators.Ints(min_value=0), )

Parameter timeout_ticks

aux_io_mode: TraceParameter = self.add_parameter( name="aux_io_mode", parameter_class=TraceParameter, label="AUX I/O Mode", unit=None, initial_value="AUX_IN_AUXILIARY", val_mapping={ "AUX_OUT_TRIGGER": 0, "AUX_IN_TRIGGER_ENABLE": 1, "AUX_IN_AUXILIARY": 13, }, )

Parameter aux_io_mode

aux_io_param: TraceParameter = self.add_parameter( name="aux_io_param", parameter_class=TraceParameter, label="AUX I/O Param", unit=None, initial_value="NONE", val_mapping={"NONE": 0, "TRIG_SLOPE_POSITIVE": 1, "TRIG_SLOPE_NEGATIVE": 2}, )

Parameter aux_io_param

mode: Parameter = self.add_parameter( name="mode", label="Acquisition mode", unit=None, initial_value="NPT", set_cmd=None, val_mapping={"NPT": 0x200, "TS": 0x400}, )

Parameter mode

samples_per_record: Parameter = self.add_parameter( name="samples_per_record", label="Samples per Record", unit=None, initial_value=1024, set_cmd=None, vals=validators.Multiples(divisor=self.samples_divisor, min_value=256), )

Parameter samples_per_record

records_per_buffer: Parameter = self.add_parameter( name="records_per_buffer", label="Records per Buffer", unit=None, initial_value=10, set_cmd=None, vals=validators.Ints(min_value=0), )

Parameter records_per_buffer

api: AlazarATSAPI = api or AlazarATSAPI(dll_path or self.dll_path)
buffer_list: list[Buffer] = []
parameters: dict[str, ParameterBase] = {}

All the parameters supported by this instrument. Usually populated via add_parameter().

functions: dict[str, Function] = {}

All the functions supported by this instrument. Usually populated via add_function().

submodules: dict[str, InstrumentModule | ChannelTuple] = {}

All the submodules of this instrument such as channel lists or logical groupings of parameters. Usually populated via add_submodule().

instrument_modules: dict[str, InstrumentModule] = {}

All the InstrumentModule of this instrument Usually populated via add_submodule().

log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)
metadata: dict[str, Any] = {}
buffers_per_acquisition: Parameter = self.add_parameter( name="buffers_per_acquisition", label="Buffers per Acquisition", unit=None, set_cmd=None, initial_value=10, vals=validators.Ints(min_value=0), )

Parameter buffers_per_acquisition

channel_selection: Parameter = self.add_parameter( name="channel_selection", label="Channel Selection", unit=None, set_cmd=None, initial_value="AB", val_mapping={"A": 1, "B": 2, "AB": 3}, )

Parameter channel_selection

transfer_offset: Parameter = self.add_parameter( name="transfer_offset", label="Transfer Offset", unit="Samples", set_cmd=None, initial_value=0, vals=validators.Ints(min_value=0), )

Parameter transfer_offset

external_startcapture: Parameter = self.add_parameter( name="external_startcapture", label="External Startcapture", unit=None, set_cmd=None, initial_value="ENABLED", val_mapping={"DISABLED": 0x0, "ENABLED": 0x1}, )

Parameter external_startcapture

enable_record_headers: Parameter = self.add_parameter( name="enable_record_headers", label="Enable Record Headers", unit=None, set_cmd=None, initial_value="DISABLED", val_mapping={"DISABLED": 0x0, "ENABLED": 0x8}, )

Parameter enable_record_headers

alloc_buffers: Parameter = self.add_parameter( name="alloc_buffers", label="Alloc Buffers", unit=None, set_cmd=None, initial_value="DISABLED", val_mapping={"DISABLED": 0x0, "ENABLED": 0x20}, )

Parameter alloc_buffers

fifo_only_streaming: Parameter = self.add_parameter( name="fifo_only_streaming", label="Fifo Only Streaming", unit=None, set_cmd=None, initial_value="DISABLED", val_mapping={"DISABLED": 0x0, "ENABLED": 0x800}, )

Parameter fifo_only_streaming

interleave_samples: Parameter = self.add_parameter( name="interleave_samples", label="Interleave Samples", unit=None, set_cmd=None, initial_value="DISABLED", val_mapping={"DISABLED": 0x0, "ENABLED": 0x1000}, )

Parameter interleave_samples

get_processed_data: Parameter = self.add_parameter( name="get_processed_data", label="Get Processed Data", unit=None, set_cmd=None, initial_value="DISABLED", val_mapping={"DISABLED": 0x0, "ENABLED": 0x2000}, )

Parameter get_processed_data

allocated_buffers: Parameter = self.add_parameter( name="allocated_buffers", label="Allocated Buffers", unit=None, set_cmd=None, initial_value=4, vals=validators.Ints(min_value=0), )

Parameter allocated_buffers

buffer_timeout: Parameter = self.add_parameter( name="buffer_timeout", label="Buffer Timeout", unit="ms", set_cmd=None, initial_value=1000, vals=validators.Ints(min_value=0), )

Parameter buffer_timeout

trigger_holdoff: Parameter = self.add_parameter( name="trigger_holdoff", label="Trigger Holdoff", docstring=f"If enabled Alazar will " f"ignore any additional triggers " f"while capturing a record. If disabled " f"a trigger signal during a capture " f"will result in corrupt data. " f"Support for this requires at least " f"firmware version " f"{self._trigger_holdoff_min_fw_version}", vals=validators.Bool(), get_cmd=self._get_trigger_holdoff, set_cmd=self._set_trigger_holdoff, )

If enabled Alazar will ignore any additional triggers while capturing a record.

class qcodes.instrument_drivers.AlazarTech.AlazarTechATS9440(name: str, dll_path: str = 'C:\\WINDOWS\\System32\\ATSApi.dll', **kwargs: Any)[source]

Bases: AlazarTechATS

This class is the driver for the ATS9440 board it inherits from the ATS base class

Attributes:

samples_divisor

channels

clock_source

Parameter clock_source

external_sample_rate

Parameter external_sample_rate

sample_rate

Parameter sample_rate

clock_edge

Parameter clock_edge

decimation

Parameter decimation

trigger_operation

Parameter trigger_operation

external_trigger_coupling

Parameter external_trigger_coupling

external_trigger_range

Parameter external_trigger_range

trigger_delay

Parameter trigger_delay

timeout_ticks

Parameter timeout_ticks

aux_io_mode

Parameter aux_io_mode

aux_io_param

Parameter aux_io_param

mode

Parameter mode

samples_per_record

Parameter samples_per_record

records_per_buffer

Parameter records_per_buffer

buffers_per_acquisition

Parameter buffers_per_acquisition

channel_selection

Parameter channel_selection

transfer_offset

Parameter transfer_offset

external_startcapture

Parameter external_startcapture

enable_record_headers

Parameter enable_record_headers

alloc_buffers

Parameter alloc_buffers

fifo_only_streaming

Parameter fifo_only_streaming

interleave_samples

Parameter interleave_samples

get_processed_data

Parameter get_processed_data

allocated_buffers

Parameter allocated_buffers

buffer_timeout

Parameter buffer_timeout

samples_divisor = 32
channels = 4
clock_source: TraceParameter = self.add_parameter( name="clock_source", parameter_class=TraceParameter, label="Clock Source", unit=None, initial_value="INTERNAL_CLOCK", val_mapping={ "INTERNAL_CLOCK": 1, "FAST_EXTERNAL_CLOCK": 2, "SLOW_EXTERNAL_CLOCK": 4, "EXTERNAL_CLOCK_10MHz_REF": 7, }, )

Parameter clock_source

external_sample_rate: TraceParameter = self.add_parameter( name="external_sample_rate", parameter_class=TraceParameter, label="External Sample Rate", unit="S/s", vals=validators.MultiType( validators.Ints(1000000, 125000000), validators.Enum("UNDEFINED") ), initial_value="UNDEFINED", )

Parameter external_sample_rate

sample_rate: TraceParameter = self.add_parameter( name="sample_rate", parameter_class=TraceParameter, label="Internal Sample Rate", unit="S/s", initial_value=100000000, val_mapping={ 1_000: 1, 2_000: 2, 5_000: 4, 10_000: 8, 20_000: 10, 50_000: 12, 100_000: 14, 200_000: 16, 500_000: 18, 1_000_000: 20, 2_000_000: 24, 5_000_000: 26, 10_000_000: 28, 20_000_000: 30, 50_000_000: 34, 100_000_000: 36, 125_000_000: 38, "EXTERNAL_CLOCK": 64, "UNDEFINED": "UNDEFINED", }, )

Parameter sample_rate

clock_edge: TraceParameter = self.add_parameter( name="clock_edge", parameter_class=TraceParameter, label="Clock Edge", unit=None, initial_value="CLOCK_EDGE_RISING", val_mapping={"CLOCK_EDGE_RISING": 0, "CLOCK_EDGE_FALLING": 1}, )

Parameter clock_edge

decimation: TraceParameter = self.add_parameter( name="decimation", parameter_class=TraceParameter, label="Decimation", unit=None, initial_value=1, vals=validators.Ints(1, 100000), )

Parameter decimation

trigger_operation: TraceParameter = self.add_parameter( name="trigger_operation", parameter_class=TraceParameter, label="Trigger Operation", unit=None, initial_value="TRIG_ENGINE_OP_J", val_mapping={ "TRIG_ENGINE_OP_J": 0, "TRIG_ENGINE_OP_K": 1, "TRIG_ENGINE_OP_J_OR_K": 2, "TRIG_ENGINE_OP_J_AND_K": 3, "TRIG_ENGINE_OP_J_XOR_K": 4, "TRIG_ENGINE_OP_J_AND_NOT_K": 5, "TRIG_ENGINE_OP_NOT_J_AND_K": 6, }, )

Parameter trigger_operation

external_trigger_coupling: TraceParameter = self.add_parameter( name="external_trigger_coupling", parameter_class=TraceParameter, label="External Trigger Coupling", unit=None, initial_value="DC", val_mapping={"AC": 1, "DC": 2}, )

Parameter external_trigger_coupling

external_trigger_range: TraceParameter = self.add_parameter( name="external_trigger_range", parameter_class=TraceParameter, label="External Trigger Range", unit=None, initial_value="ETR_5V", val_mapping={"ETR_5V": 0, "ETR_TTL": 2}, )

Parameter external_trigger_range

trigger_delay: TraceParameter = self.add_parameter( name="trigger_delay", parameter_class=TraceParameter, label="Trigger Delay", unit="Sample clock cycles", initial_value=0, vals=validators.Multiples(divisor=8, min_value=0), )

Parameter trigger_delay

timeout_ticks: TraceParameter = self.add_parameter( name="timeout_ticks", parameter_class=TraceParameter, label="Timeout Ticks", unit="10 us", initial_value=0, vals=validators.Ints(min_value=0), )

Parameter timeout_ticks

aux_io_mode: TraceParameter = self.add_parameter( name="aux_io_mode", parameter_class=TraceParameter, label="AUX I/O Mode", unit=None, initial_value="AUX_OUT_TRIGGER", val_mapping={ "AUX_OUT_TRIGGER": 0, "AUX_IN_TRIGGER_ENABLE": 1, "AUX_IN_AUXILIARY": 13, }, )

Parameter aux_io_mode

aux_io_param: TraceParameter = self.add_parameter( name="aux_io_param", parameter_class=TraceParameter, label="AUX I/O Param", unit=None, initial_value="NONE", val_mapping={"NONE": 0, "TRIG_SLOPE_POSITIVE": 1, "TRIG_SLOPE_NEGATIVE": 2}, )

Parameter aux_io_param

mode: Parameter = self.add_parameter( name="mode", label="Acquisition mode", unit=None, initial_value="NPT", set_cmd=None, val_mapping={"NPT": 0x200, "TS": 0x400}, )

Parameter mode

samples_per_record: Parameter = self.add_parameter( name="samples_per_record", label="Samples per Record", unit=None, initial_value=1024, set_cmd=None, vals=validators.Multiples(divisor=self.samples_divisor, min_value=256), )

Parameter samples_per_record

api: AlazarATSAPI = api or AlazarATSAPI(dll_path or self.dll_path)
buffer_list: list[Buffer] = []
parameters: dict[str, ParameterBase] = {}

All the parameters supported by this instrument. Usually populated via add_parameter().

functions: dict[str, Function] = {}

All the functions supported by this instrument. Usually populated via add_function().

submodules: dict[str, InstrumentModule | ChannelTuple] = {}

All the submodules of this instrument such as channel lists or logical groupings of parameters. Usually populated via add_submodule().

instrument_modules: dict[str, InstrumentModule] = {}

All the InstrumentModule of this instrument Usually populated via add_submodule().

log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)
metadata: dict[str, Any] = {}
records_per_buffer: Parameter = self.add_parameter( name="records_per_buffer", label="Records per Buffer", unit=None, initial_value=10, set_cmd=None, vals=validators.Ints(min_value=0), )

Parameter records_per_buffer

buffers_per_acquisition: Parameter = self.add_parameter( name="buffers_per_acquisition", label="Buffers per Acquisition", unit=None, set_cmd=None, initial_value=10, vals=validators.Ints(min_value=0), )

Parameter buffers_per_acquisition

channel_selection: Parameter = self.add_parameter( name="channel_selection", label="Channel Selection", unit=None, set_cmd=None, initial_value="AB", val_mapping={ "A": 1, "B": 2, "AB": 3, "C": 4, "AC": 5, "BC": 6, "D": 8, "AD": 9, "BD": 10, "CD": 12, "ABCD": 15, }, )

Parameter channel_selection

transfer_offset: Parameter = self.add_parameter( name="transfer_offset", label="Transfer Offset", unit="Samples", set_cmd=None, initial_value=0, vals=validators.Ints(min_value=0), )

Parameter transfer_offset

external_startcapture: Parameter = self.add_parameter( name="external_startcapture", label="External Startcapture", unit=None, set_cmd=None, initial_value="ENABLED", val_mapping={"DISABLED": 0x0, "ENABLED": 0x1}, )

Parameter external_startcapture

enable_record_headers: Parameter = self.add_parameter( name="enable_record_headers", label="Enable Record Headers", unit=None, set_cmd=None, initial_value="DISABLED", val_mapping={"DISABLED": 0x0, "ENABLED": 0x8}, )

Parameter enable_record_headers

alloc_buffers: Parameter = self.add_parameter( name="alloc_buffers", label="Alloc Buffers", unit=None, set_cmd=None, initial_value="DISABLED", val_mapping={"DISABLED": 0x0, "ENABLED": 0x20}, )

Parameter alloc_buffers

fifo_only_streaming: Parameter = self.add_parameter( name="fifo_only_streaming", label="Fifo Only Streaming", unit=None, set_cmd=None, initial_value="DISABLED", val_mapping={"DISABLED": 0x0, "ENABLED": 0x800}, )

Parameter fifo_only_streaming

interleave_samples: Parameter = self.add_parameter( name="interleave_samples", label="Interleave Samples", unit=None, set_cmd=None, initial_value="DISABLED", val_mapping={"DISABLED": 0x0, "ENABLED": 0x1000}, )

Parameter interleave_samples

get_processed_data: Parameter = self.add_parameter( name="get_processed_data", label="Get Processed Data", unit=None, set_cmd=None, initial_value="DISABLED", val_mapping={"DISABLED": 0x0, "ENABLED": 0x2000}, )

Parameter get_processed_data

allocated_buffers: Parameter = self.add_parameter( name="allocated_buffers", label="Allocated Buffers", unit=None, set_cmd=None, initial_value=4, vals=validators.Ints(min_value=0), )

Parameter allocated_buffers

buffer_timeout: Parameter = self.add_parameter( name="buffer_timeout", label="Buffer Timeout", unit="ms", set_cmd=None, initial_value=1000, vals=validators.Ints(min_value=0), )

Parameter buffer_timeout

class qcodes.instrument_drivers.AlazarTech.AlazarTechATS9870(name: str, dll_path: str = 'C:\\WINDOWS\\System32\\ATSApi.dll', **kwargs: Any)[source]

Bases: AlazarTechATS

This class is the driver for the ATS9870 board it inherits from the ATS base class

It creates all necessary parameters for the Alazar card

Attributes:

clock_source

Parameter clock_source

external_sample_rate

Parameter external_sample_rate

sample_rate

Parameter sample_rate

clock_edge

Parameter clock_edge

decimation

Parameter decimation

trigger_operation

Parameter trigger_operation

external_trigger_coupling

Parameter external_trigger_coupling

external_trigger_range

Parameter external_trigger_range

trigger_delay

Parameter trigger_delay

timeout_ticks

Parameter timeout_ticks

aux_io_mode

Parameter aux_io_mode

aux_io_param

Parameter aux_io_param

mode

Parameter mode

samples_per_record

Parameter samples_per_record

records_per_buffer

Parameter records_per_buffer

buffers_per_acquisition

Parameter buffers_per_acquisition

channel_selection

Parameter channel_selection

transfer_offset

Parameter transfer_offset

external_startcapture

Parameter external_startcapture

enable_record_headers

Parameter enable_record_headers

alloc_buffers

Parameter alloc_buffers

fifo_only_streaming

Parameter fifo_only_streaming

interleave_samples

Parameter interleave_samples

get_processed_data

Parameter get_processed_data

allocated_buffers

Parameter allocated_buffers

buffer_timeout

Parameter buffer_timeout

clock_source: TraceParameter = self.add_parameter( name="clock_source", parameter_class=TraceParameter, label="Clock Source", unit=None, initial_value="INTERNAL_CLOCK", val_mapping={ "INTERNAL_CLOCK": 1, "SLOW_EXTERNAL_CLOCK": 4, "EXTERNAL_CLOCK_AC": 5, "EXTERNAL_CLOCK_10MHz_REF": 7, }, )

Parameter clock_source

external_sample_rate: TraceParameter = self.add_parameter( name="external_sample_rate", get_cmd=None, parameter_class=TraceParameter, label="External Sample Rate", unit="S/s", vals=validators.Enum(1_000_000_000), initial_value=1_000_000_000, )

Parameter external_sample_rate

sample_rate: TraceParameter = self.add_parameter( name="sample_rate", parameter_class=TraceParameter, label="Sample Rate", unit="S/s", initial_value=1000000000, val_mapping={ 1000: 0x1, 2000: 0x2, 5000: 0x4, 10000: 0x8, 20000: 0xA, 50000: 0xC, 100000: 0xE, 200000: 0x10, 500000: 0x12, 1000000: 0x14, 2000000: 0x18, 5000000: 0x1A, 10000000: 0x1C, 20000000: 0x1E, 50000000: 0x22, 100000000: 0x24, 250000000: 0x2B, 500000000: 0x30, 1000000000: 0x35, "EXTERNAL_CLOCK": 0x40, "1GHz_REFERENCE_CLOCK": 1000000000, }, )

Parameter sample_rate

clock_edge: TraceParameter = self.add_parameter( name="clock_edge", parameter_class=TraceParameter, label="Clock Edge", unit=None, initial_value="CLOCK_EDGE_RISING", val_mapping={"CLOCK_EDGE_RISING": 0, "CLOCK_EDGE_FALLING": 1}, )

Parameter clock_edge

decimation: TraceParameter = self.add_parameter( name="decimation", parameter_class=TraceParameter, label="Decimation", unit=None, initial_value=0, vals=validators.Ints(0, 100000), )

Parameter decimation

trigger_operation: TraceParameter = self.add_parameter( name="trigger_operation", parameter_class=TraceParameter, label="Trigger Operation", unit=None, initial_value="TRIG_ENGINE_OP_J", val_mapping={ "TRIG_ENGINE_OP_J": 0, "TRIG_ENGINE_OP_K": 1, "TRIG_ENGINE_OP_J_OR_K": 2, "TRIG_ENGINE_OP_J_AND_K": 3, "TRIG_ENGINE_OP_J_XOR_K": 4, "TRIG_ENGINE_OP_J_AND_NOT_K": 5, "TRIG_ENGINE_OP_NOT_J_AND_K": 6, }, )

Parameter trigger_operation

external_trigger_coupling: TraceParameter = self.add_parameter( name="external_trigger_coupling", parameter_class=TraceParameter, label="External Trigger Coupling", unit=None, initial_value="DC", val_mapping={"DC": 2}, )

Parameter external_trigger_coupling

external_trigger_range: TraceParameter = self.add_parameter( name="external_trigger_range", parameter_class=TraceParameter, label="External Trigger Range", unit=None, initial_value="ETR_5V", val_mapping={"ETR_5V": 0, "ETR_1V": 1}, )

Parameter external_trigger_range

trigger_delay: TraceParameter = self.add_parameter( name="trigger_delay", parameter_class=TraceParameter, label="Trigger Delay", unit="Sample clock cycles", initial_value=0, vals=validators.Ints(min_value=0), )

Parameter trigger_delay

timeout_ticks: TraceParameter = self.add_parameter( name="timeout_ticks", parameter_class=TraceParameter, label="Timeout Ticks", unit="10 us", initial_value=0, vals=validators.Ints(min_value=0), )

Parameter timeout_ticks

aux_io_mode: TraceParameter = self.add_parameter( name="aux_io_mode", parameter_class=TraceParameter, label="AUX I/O Mode", unit=None, initial_value="AUX_IN_AUXILIARY", val_mapping={ "AUX_OUT_TRIGGER": 0, "AUX_IN_TRIGGER_ENABLE": 1, "AUX_IN_AUXILIARY": 13, }, )

Parameter aux_io_mode

aux_io_param: TraceParameter = self.add_parameter( name="aux_io_param", parameter_class=TraceParameter, label="AUX I/O Param", unit=None, initial_value="NONE", val_mapping={"NONE": 0, "TRIG_SLOPE_POSITIVE": 1, "TRIG_SLOPE_NEGATIVE": 2}, )

Parameter aux_io_param

mode: Parameter = self.add_parameter( name="mode", label="Acquisition mode", unit=None, initial_value="NPT", set_cmd=None, val_mapping={"NPT": 0x200, "TS": 0x400}, )

Parameter mode

samples_per_record: Parameter = self.add_parameter( name="samples_per_record", label="Samples per Record", unit=None, initial_value=96000, set_cmd=None, vals=validators.Multiples(divisor=64, min_value=256), )

Parameter samples_per_record

api: AlazarATSAPI = api or AlazarATSAPI(dll_path or self.dll_path)
buffer_list: list[Buffer] = []
parameters: dict[str, ParameterBase] = {}

All the parameters supported by this instrument. Usually populated via add_parameter().

functions: dict[str, Function] = {}

All the functions supported by this instrument. Usually populated via add_function().

submodules: dict[str, InstrumentModule | ChannelTuple] = {}

All the submodules of this instrument such as channel lists or logical groupings of parameters. Usually populated via add_submodule().

instrument_modules: dict[str, InstrumentModule] = {}

All the InstrumentModule of this instrument Usually populated via add_submodule().

log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)
metadata: dict[str, Any] = {}
records_per_buffer: Parameter = self.add_parameter( name="records_per_buffer", label="Records per Buffer", unit=None, initial_value=1, set_cmd=None, vals=validators.Ints(min_value=0), )

Parameter records_per_buffer

buffers_per_acquisition: Parameter = self.add_parameter( name="buffers_per_acquisition", label="Buffers per Acquisition", unit=None, set_cmd=None, initial_value=1, vals=validators.Ints(min_value=0), )

Parameter buffers_per_acquisition

channel_selection: Parameter = self.add_parameter( name="channel_selection", label="Channel Selection", unit=None, set_cmd=None, initial_value="AB", val_mapping={"A": 1, "B": 2, "AB": 3}, )

Parameter channel_selection

transfer_offset: Parameter = self.add_parameter( name="transfer_offset", label="Transfer Offset", unit="Samples", set_cmd=None, initial_value=0, vals=validators.Ints(min_value=0), )

Parameter transfer_offset

external_startcapture: Parameter = self.add_parameter( name="external_startcapture", label="External Startcapture", unit=None, set_cmd=None, initial_value="ENABLED", val_mapping={"DISABLED": 0x0, "ENABLED": 0x1}, )

Parameter external_startcapture

enable_record_headers: Parameter = self.add_parameter( name="enable_record_headers", label="Enable Record Headers", unit=None, set_cmd=None, initial_value="DISABLED", val_mapping={"DISABLED": 0x0, "ENABLED": 0x8}, )

Parameter enable_record_headers

alloc_buffers: Parameter = self.add_parameter( name="alloc_buffers", label="Alloc Buffers", unit=None, set_cmd=None, initial_value="DISABLED", val_mapping={"DISABLED": 0x0, "ENABLED": 0x20}, )

Parameter alloc_buffers

fifo_only_streaming: Parameter = self.add_parameter( name="fifo_only_streaming", label="Fifo Only Streaming", unit=None, set_cmd=None, initial_value="DISABLED", val_mapping={"DISABLED": 0x0, "ENABLED": 0x800}, )

Parameter fifo_only_streaming

interleave_samples: Parameter = self.add_parameter( name="interleave_samples", label="Interleave Samples", unit=None, set_cmd=None, initial_value="DISABLED", val_mapping={"DISABLED": 0x0, "ENABLED": 0x1000}, )

Parameter interleave_samples

get_processed_data: Parameter = self.add_parameter( name="get_processed_data", label="Get Processed Data", unit=None, set_cmd=None, initial_value="DISABLED", val_mapping={"DISABLED": 0x0, "ENABLED": 0x2000}, )

Parameter get_processed_data

allocated_buffers: Parameter = self.add_parameter( name="allocated_buffers", label="Allocated Buffers", unit=None, set_cmd=None, initial_value=1, vals=validators.Ints(min_value=0), )

Parameter allocated_buffers

buffer_timeout: Parameter = self.add_parameter( name="buffer_timeout", label="Buffer Timeout", unit="ms", set_cmd=None, initial_value=1000, vals=validators.Ints(min_value=0), )

Parameter buffer_timeout

class qcodes.instrument_drivers.AlazarTech.DemodulationAcquisitionController(name: str, alazar_name: str, demodulation_frequency: float, **kwargs: Any)[source]

Bases: AcquisitionController[float]

This class represents an example acquisition controller. End users will probably want to use something more sophisticated. It will average all buffers and then perform a fourier transform on the resulting average trace for one frequency component. The amplitude of the result of channel_a will be returned.

Parameters:
  • name – name for this acquisition_conroller as an instrument

  • alazar_name – the name of the alazar instrument such that this controller can communicate with the Alazar

  • demodulation_frequency – the selected component for the fourier transform

  • **kwargs – kwargs are forwarded to the Instrument base class

  • name – The name of the AcquisitionController

  • alazar_name – The name of the alazar instrument.

  • **kwargs – kwargs are forwarded to base class.

Attributes:

acquisition

Parameter acquisition

Methods:

update_acquisitionkwargs(**kwargs)

This method must be used to update the kwargs used for the acquisition with the alazar_driver.acquire :param kwargs: :return:

do_acquisition()

this method performs an acquisition, which is the get_cmd for the acquisiion parameter of this instrument :return:

pre_start_capture()

See AcquisitionController

pre_acquire()

See AcquisitionController :return:

handle_buffer(buffer[, buffer_number])

See AcquisitionController :return:

post_acquire()

See AcquisitionController :return:

fit(buf)

the DFT is implemented in this method :param buf: buffer to perform the transform on :return: return amplitude and phase of the resulted transform

acquisitionkwargs: dict[str, Any] = {}
cos_list: np.ndarray | None = None
sin_list: np.ndarray | None = None
buffer: np.ndarray | None = None
acquisition: Parameter = self.add_parameter( "acquisition", get_cmd=self.do_acquisition )

Parameter acquisition

update_acquisitionkwargs(**kwargs: Any) None[source]

This method must be used to update the kwargs used for the acquisition with the alazar_driver.acquire :param kwargs: :return:

do_acquisition() float[source]

this method performs an acquisition, which is the get_cmd for the acquisiion parameter of this instrument :return:

pre_start_capture() None[source]

See AcquisitionController

pre_acquire() None[source]

See AcquisitionController :return:

handle_buffer(buffer: ndarray, buffer_number: int | None = None) None[source]

See AcquisitionController :return:

post_acquire() float[source]

See AcquisitionController :return:

fit(buf: ndarray) tuple[float, float][source]

the DFT is implemented in this method :param buf: buffer to perform the transform on :return: return amplitude and phase of the resulted transform

parameters: dict[str, ParameterBase] = {}

All the parameters supported by this instrument. Usually populated via add_parameter().

functions: dict[str, Function] = {}

All the functions supported by this instrument. Usually populated via add_function().

submodules: dict[str, InstrumentModule | ChannelTuple] = {}

All the submodules of this instrument such as channel lists or logical groupings of parameters. Usually populated via add_submodule().

instrument_modules: dict[str, InstrumentModule] = {}

All the InstrumentModule of this instrument Usually populated via add_submodule().

log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)
metadata: dict[str, Any] = {}