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])

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

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:

• Call to AlazarTech_ATS.acquire() internal configuration

• Call to AcquisitionInterface.pre_start_capture()

• Call to the start capture of the Alazar board

• Call to AcquisitionInterface.pre_acquire()

• Loop over all buffers that need to be acquired dump each buffer to acquisitioncontroller.handle_buffer (only if buffers need to be recycled to finish the acquisiton)

• Dump remaining buffers to AcquisitionInterface.handle_buffer() alazar internals

• Return return value from AcquisitionController.post_acquire()

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

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

This method is called immediately after ‘AlazarStartCapture’ is called

handle_buffer(buffer: ndarray, buffer_number: int | None = None) → None

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

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

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])

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:

dll_path
channels
api

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]]

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]

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]

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]

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

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

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

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

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

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

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

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)

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)

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)

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)

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)

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

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

do_acquisition() → float

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

pre_start_capture() → None

See AcquisitionController

pre_acquire() → None

See AcquisitionController :return:

handle_buffer(buffer: ndarray, buffer_number: int | None = None) → None

See AcquisitionController :return:

post_acquire() → float

See AcquisitionController :return:

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

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] = {}