qcodes_contrib_drivers.drivers.Tektronix package

Submodules

qcodes_contrib_drivers.drivers.Tektronix.AFG3000 module

class qcodes_contrib_drivers.drivers.Tektronix.AFG3000.AFG3000(*args: Any, **kwargs: Any)

Bases: VisaInstrument

Qcodes driver for Tektronix AFG3000 series arbitrary function generator.

Not all instrument functionality is included here.

abort() → None

recall(location: int) → None

reset() → None

reset_edit_memory(points: int = 1000)

Reset the contents of the edit memory (EMEM), and set its size to points.

Each point will be initialized with the value 8191, which corresponds to the voltage half-way between voltage_low and voltage_high.

save(location: int) → None

self_calibrate() → None

self_test() → None

synchronize_phase(src: int) → None

upload_waveform(waveform: Sequence[float], memory: int)

Upload a waveform to the editable memory (EMEM), and then copy it to the USER1, USER2, USER3 or USER4 memory.

The waveform data should contain values in the range 0..1. Note that the actual voltage values that are output will depend on the values of the voltage_low1/2 and voltage_high1/2 parameters; 0 will be mapped to voltage_low and 1 to voltage_high.

Parameters:

• waveform – sequence of points containing the waveform data, containing values from 0 to 1.

• memory – The USER# memory where to to store the waveform, from 1 to 4.

wait() → None

class qcodes_contrib_drivers.drivers.Tektronix.AFG3000.AFG3252(*args: Any, **kwargs: Any)

Bases: AFG3000

qcodes_contrib_drivers.drivers.Tektronix.AWG520 module

class qcodes_contrib_drivers.drivers.Tektronix.AWG520.Tektronix_AWG520(*args: Any, **kwargs: Any)

Bases: VisaInstrument

This is the python driver for the Tektronix AWG520 Arbitrary Waveform Generator

Work pending:

1. Get All

2. Remove test_send??

3. Add docstrings

Work pending:

use inheritance for common use with 520, currently contains a lot of repetition

__init__(name, address, reset=False, clock=1000000000.0, numpoints=1000, **kw)

Initializes the AWG520.

Parameters:

• name (str) – name of the instrument

• address (str) – GPIB address (Note: 520 cannot be controlled via ethernet)

• reset (bool) – resets to default values, default=false

• numpoints (int) – sets the number of datapoints

Output:

None

change_folder(dir)

clear_waveforms()

Clears the waveform on both channels.

Input:

None

Output:

None

delete_all_waveforms_from_list()

for compatibillity with awg, is not relevant for AWG520 since it has no waveform list

force_logicjump()

forces a jumplogic event (used as a conditional event during waveform executions)

note: jump_logic events&mode have to be set properly!

Ron

force_trigger()

forces a trigger event (used for wait_trigger option in sequences)

Ron

get_all(update=True)

get_current_folder_name()

get_filenames()

get_folder_contents()

get_jumpmode(mode)

get the jump mode for jump logic events

Ron

get_state()

goto_root()

load_and_set_sequence(wfs, rep, wait, goto, logic_jump, filename)

Loads and sets the awg sequecne

make_directory(dir, root)

makes a directory if root = True, new dir in main folder

resend_waveform(channel, w=[], m1=[], m2=[], clock=[])

Resends the last sent waveform for the designated channel Overwrites only the parameters specifiedta

Input: (mandatory)

channel (int) : 1 or 2, the number of the designated channel

Input: (optional)

w (float[numpoints]) : waveform m1 (int[numpoints]) : marker1 m2 (int[numpoints]) : marker2 clock (int) : frequency

Output:

None

return_self()

send_pattern(w, m1, m2, filename, clock)

Sends a pattern file. similar to waveform except diff file extension number of poitns different. diff byte conversion See also: resend_waveform()

Input:

w (float[numpoints]) : waveform m1 (int[numpoints]) : marker1 m2 (int[numpoints]) : marker2 filename (str) : filename clock (int) : frequency (Hz)

Output:

None

send_sequence(wfs, rep, wait, goto, logic_jump, filename)

Sends a sequence file (for the moment only for ch1)

Parameters:

wfs – list of filenames

Returs:

None

send_sequence2(wfs1, wfs2, rep, wait, goto, logic_jump, filename)

Sends a sequence file

Parameters:

• wfs1 – list of filenames for ch1 (all must end with .pat)

• wfs2 – list of filenames for ch2 (all must end with .pat)

• rep – list

• wait – list

• goto – list

• logic_jump – list

• filename – name of output file (must end with .seq)

Returns:

None

send_waveform(w, m1, m2, filename, clock)

Sends a complete waveform. All parameters need to be specified. choose a file extension ‘wfm’ (must end with .pat) See also: resend_waveform()

Input:

w (float[numpoints]) : waveform m1 (int[numpoints]) : marker1 m2 (int[numpoints]) : marker2 filename (str) : filename clock (int) : frequency (Hz)

Output:

None

set_current_folder_name(file_path)

set_jumpmode(mode)

sets the jump mode for jump logic events, possibilities: LOGic,TABle,SOFTware give mode as string

note: jump_logic events&mode have to be set properly!

Ron

set_sequence(filename)

loads a sequence file on all channels. Waveforms/patterns to be executed on respective channel must be defined inside the sequence file itself make sure to send all waveforms before setting a seq

set_setup_filename(fname, force_reload=False)

start()

stop()

qcodes_contrib_drivers.drivers.Tektronix.FCA3100 module

class qcodes_contrib_drivers.drivers.Tektronix.FCA3100.CompleteTimeStatistics(name: str, instrument: FCA3100, **kwargs: Any)

Bases: ParameterWithSetpoints

get_raw() → ndarray

Gets the data from the instrument.

Returns:

Array of swithing times

Return type:

np.ndarray

class qcodes_contrib_drivers.drivers.Tektronix.FCA3100.FCA3100(*args: Any, **kwargs: Any)

Bases: VisaInstrument

This is the qcodes driver for the FCA3100 counter

__init__(name: str, address: str, terminator: str = '\n', timeout: int = 10, **kwargs) → None

Qcodes driver for the Textronix FCA3100 frequency counter.

Parameters:

• name – Name of the instrument

• address – Address of the instrument

• terminator (optional) – Terminator character of the string reply. Defaults to “n”.

• timeout (optional) – VISA timeout is set purposely to a long time to allow long measurements. Defaults to 10.

class qcodes_contrib_drivers.drivers.Tektronix.FCA3100.GeneratedSetPoints(numpointsparam, *args, **kwargs)

Bases: Parameter

A parameter that generates a setpoint array from start, stop and num points parameters.

get_raw()

get_raw is called to perform the actual data acquisition from the instrument. This method should either be overwritten to perform the desired operation or alternatively for Parameter a suitable method is automatically generated if get_cmd is supplied to the parameter constructor. The method is automatically wrapped to provide a get method on the parameter instance.

class qcodes_contrib_drivers.drivers.Tektronix.FCA3100.TimeStatistics(name: str, instrument: FCA3100, **kwargs: Any)

Bases: MultiParameter

Returns the statistical values of a timing statistics.

__init__(name: str, instrument: FCA3100, **kwargs: Any) → None

Statistical values of a timing statistics.

Parameters:

• name – name of the timing statistics

• instrument – Instrument to which the timing statistic is bound to.

get_raw() → Tuple[float, float, float, float]

Gets data from the instrument

Returns:

Statistical values of the time statistic

Return type:

Tuple

qcodes_contrib_drivers.drivers.Tektronix.Keithley_2000_Scan module

class qcodes_contrib_drivers.drivers.Tektronix.Keithley_2000_Scan.Keithley_2000_Scan_Channel(dmm: Keithley_6500, channel: int, **kwargs)

Bases: InstrumentChannel

This is the qcodes driver for a channel of the 2000-SCAN scanner card.

__init__(dmm: Keithley_6500, channel: int, **kwargs) → None

Initialize instance of scanner card Keithley 2000-SCAN :param dmm: Instance of digital multimeter Keithley6500 containing the scanner card :param channel: Channel number :param **kwargs: Keyword arguments to pass to __init__ function of InstrumentChannel class

qcodes_contrib_drivers.drivers.Tektronix.Keithley_2182A module

QCoDeS driver for the Keithley 2182A nanovoltmeter.

This driver implements the full functionality based on the Keithley 2182A user manual, with particular focus on the MEASure and FETCh commands and related functionality.

class qcodes_contrib_drivers.drivers.Tektronix.Keithley_2182A.ApertureTimeValidator(instrument: Keithley2182A, max_value: float = 999999.999)

Bases: Validator

Validator for trigger delay that adjusts minimum value based on line frequency.

For 60Hz line frequency: min_value = 0.16667ms For 50Hz line frequency: min_value = 0.2ms

validate(value: float, context: str = '') → None

Validate the trigger delay value against line frequency-dependent limits.

is_numeric = True

property valid_values: tuple[float, float]

Return the valid number range as a tuple (min, max).

class qcodes_contrib_drivers.drivers.Tektronix.Keithley_2182A.Keithley2182A(*args: Any, **kwargs: Any)

Bases: VisaInstrument

QCoDeS driver for the Keithley 2182A nanovoltmeter.

This driver provides comprehensive functionality for the Keithley 2182A, including voltage measurements and various configuration options as specified in the user manual sections 12-15.

The driver implements the MEASure and FETCh commands along with all related measurement and configuration functionality.

__init__(name: str, address: str, reset: bool = False, **kwargs: Unpack[VisaInstrumentKWArgs]) → None

Initialize the Keithley 2182A nanovoltmeter.

Parameters:

• name – Name of the instrument

• address – VISA address of the instrument

• reset – Whether to reset the instrument upon initialization

• **kwargs – Additional arguments passed to VisaInstrument

abort_measurement() → None

Abort the current measurement and return to idle state.

check_ranges() → dict

Get available measurement ranges for the current mode.

Returns:

Dictionary with range information

clear() → None

Clear all errors from the error queue.

configure_voltage_measurement(voltage_range: float | None = None, auto_range: bool = True, nplc: float = 1.0, auto_zero: bool = True) → None

Configure the instrument for voltage measurements.

Parameters:

• voltage_range – Measurement range in volts (if auto_range is False)

• auto_range – Enable auto-ranging

• nplc – Integration time in power line cycles

• auto_zero – Enable auto-zero

fetch() → float

Fetch the last measurement from the instrument buffer.

The FETCh command retrieves the most recent measurement without triggering a new measurement.

Returns:

Last measured value

get_error() → tuple[int, str]

Get the oldest error from the error queue.

Returns:

Tuple of (error_code, error_message)

get_measurement_status() → dict

Get comprehensive measurement status information.

Returns:

Dictionary containing measurement configuration and status

initiate_measurement() → None

Initiate a measurement.

This command moves the instrument from the idle state to the wait-for-trigger state.

measure_voltage_statistics(num_measurements: int = 10) → dict

Take multiple voltage measurements and return statistics.

Parameters:

num_measurements – Number of measurements to take

Returns:

Dictionary with mean, std, min, max values

optimize_for_low_noise() → None

Configure the instrument for lowest noise measurements.

This enables all noise reduction features and sets slow integration time.

optimize_for_speed() → None

Configure the instrument for fastest measurements.

This disables noise reduction features for maximum speed.

read() → float

Trigger and fetch a measurement.

The READ command combines INIT and FETC operations.

Returns:

Measured value

reset() → None

Reset the instrument to default settings.

self_test() → bool

Perform instrument self-test.

Returns:

True if self-test passed, False otherwise

set_measurement_speed(speed: str) → None

Set measurement speed preset (affects NPLC and filtering).

Parameters:

speed – Speed setting (“fast”, “medium”, “slow”)

trigger() → None

Send a software trigger to the instrument.

analog_filter: Parameter = self.add_parameter( "analog_filter", label="Analog Filter", get_cmd="SENS:VOLT:DC:LPAS?", set_cmd="SENS:VOLT:DC:LPAS {}", val_mapping=on_off_vals, docstring="Enable/disable analog low-pass filter for noise reduction", )

aperture_time: Parameter = self.add_parameter( "aperture_time", label="Aperture Time", unit="s", get_cmd=partial(self._get_mode_param, "VOLT:APER", float), set_cmd=partial(self._set_mode_param, "VOLT:APER"), vals=ApertureTimeValidator(self, max_value=1.0), docstring="Set/get the measurement aperture time in seconds", )

auto_range_enabled: Parameter = self.add_parameter( "auto_range_enabled", label="Auto Range", get_cmd="SENS:VOLT:RANG:AUTO?", set_cmd="SENS:VOLT:RANG:AUTO {}", val_mapping=on_off_vals, docstring="Enable/disable auto ranging", )

auto_zero: Parameter = self.add_parameter( "auto_zero", label="Auto Zero", get_cmd="SYST:AZER?", set_cmd="SYST:AZER {}", val_mapping=on_off_vals, docstring="Enable/disable auto-zero functionality", )

default_terminator = '\n'

The default terminator to use if the terminator is not specified when creating the instrument. None means use the default terminator from PyVisa.

digital_filter: Parameter = self.add_parameter( "digital_filter", label="Digital Filter", get_cmd="SENS:VOLT:DC:DFIL?", set_cmd="SENS:VOLT:DC:DFIL {}", val_mapping=on_off_vals, docstring="Enable/disable digital filter for noise reduction", )

display_enabled: Parameter = self.add_parameter( "display_enabled", label="Display Enabled", get_cmd="DISP:ENAB?", set_cmd="DISP:ENAB {}", val_mapping=on_off_vals, docstring="Enable/disable the front panel display", )

line_frequency: Parameter = self.add_parameter( "line_frequency", label="Line Frequency", unit="Hz", get_cmd="SYST:LFR?", get_parser=float, docstring="Get the detected power line frequency (50 or 60 Hz)", )

mode: Parameter = self.add_parameter( "mode", label="Measurement Mode", get_cmd="SENS:FUNC?", set_cmd="SENS:FUNC {}", val_mapping=self._mode_map, docstring="Set/get the measurement function (DC voltage)", )

nplc: Parameter = self.add_parameter( "nplc", label="Integration Time (NPLC)", get_cmd=partial(self._get_mode_param, "VOLT:NPLC", float), set_cmd=partial(self._set_mode_param, "VOLT:NPLC"), vals=NPLCValidator(self, min_value=0.01), docstring="Set/get the integration time in number of power line cycles (max depends on line frequency)", )

range: Parameter = self.add_parameter( "range", label="Measurement Range", unit="V", get_cmd=partial(self._get_mode_param, "VOLT:RANG", float), set_cmd=partial(self._set_mode_param, "VOLT:RANG"), vals=Numbers(min_value=1e-6, max_value=120), docstring="Set/get the measurement range", )

trigger_delay: Parameter = self.add_parameter( "trigger_delay", label="Trigger Delay", unit="s", get_cmd="TRIG:DEL?", set_cmd="TRIG:DEL {}", get_parser=float, vals=Numbers(min_value=0.0, max_value=999999.999), docstring="Set/get trigger delay in seconds (min value depends on line frequency)", )

trigger_source: Parameter = self.add_parameter( "trigger_source", label="Trigger Source", get_cmd="TRIG:SOUR?", set_cmd="TRIG:SOUR {}", val_mapping={ "immediate": "IMM", "external": "EXT", "timer": "TIM", "manual": "MAN", "bus": "BUS", }, docstring="Set/get the trigger source", )

voltage: Parameter = self.add_parameter( "voltage", label="DC Voltage", unit="V", get_cmd=self._measure_voltage, docstring="Measure DC voltage using the MEASure command", )

class qcodes_contrib_drivers.drivers.Tektronix.Keithley_2182A.NPLCValidator(instrument: Keithley2182A, min_value: float = 0.01)

Bases: Validator

Validator for NPLC that adjusts maximum value based on line frequency.

For 60Hz line frequency: max_value = 60 cycles For 50Hz line frequency: max_value = 50 cycles Minimum is always 0.01 cycles

validate(value: float, context: str = '') → None

Validate the NPLC value against line frequency-dependent limits.

is_numeric = True

property valid_values: tuple[float, float]

Return the valid number range as a tuple (min, max).

qcodes_contrib_drivers.drivers.Tektronix.Keithley_2401 module

class qcodes_contrib_drivers.drivers.Tektronix.Keithley_2401.Keithley2400(*args: Any, **kwargs: Any)

Bases: VisaInstrument

QCoDeS driver for Keithley 2400 SourceMeter. Provides functionality for sourcing and measuring voltage, current, and resistance. Includes support for voltage sweeps and detailed parameter configuration.

__init__(name: str, address: str, **kwargs)

Initialize the Keithley 2400 SourceMeter. :param name: Name of the instrument. :type name: str :param address: Visa address of the instrument. :type address: str

enable_output(state: bool = True)

Enable or disable the output. :param state: Set True to enable, False to disable. :type state: bool

set_voltage(voltage: float)

Set the output voltage. :param voltage: The voltage level to set in volts. :type voltage: float

sweep_voltage_measure(voltage_start: float, voltage_stop: float, steps: int)

Sweep voltage from start to stop in specified steps and measure voltage and current. :param voltage_start: Starting voltage. :type voltage_start: float :param voltage_stop: Ending voltage. :type voltage_stop: float :param steps: Number of steps. :type steps: int

Returns:

Contains ‘voltage_set’, ‘voltage_measured’, and ‘current_measured’.

Return type:

list of dict

qcodes_contrib_drivers.drivers.Tektronix.Keithley_2700 module

class qcodes_contrib_drivers.drivers.Tektronix.Keithley_2700.Keithley_2700(*args: Any, **kwargs: Any)

Bases: VisaInstrument

This is the qcodes driver for the Keithley_2700 Multimeter

Usage: Initialize with:

<name> =  = Keithley_2700(<name>, address='<GPIB address>', reset=<bool>,
    change_display=<bool>, change_autozero=<bool>)

Status: beta-version.

This driver will most likely work for multiple Keithley SourceMeters.

This driver does not contain all commands available, but only the ones most commonly used.

get_all()

Reads all relevant parameters from instrument

Input:

None

Output:

None

reset()

Resets instrument to default values

Input:

None

Output:

None

set_defaults()

Set to driver defaults: Output=data only Mode=Volt:DC Digits=7 Trigger=Continous Range=10 V NPLC=1 Averaging=off

set_mode(mode)

Set the mode to the specified value

Input:

mode (string) : mode to be set. Choose from self._modes

Output:

None

set_mode_volt_dc()

Set mode to DC Voltage

Input:

None

Output:

None

qcodes_contrib_drivers.drivers.Tektronix.Keithley_2700.bool_to_str(val)

Function to convert boolean to ‘ON’ or ‘OFF’

qcodes_contrib_drivers.drivers.Tektronix.Keithley_2700.parsebool(v)

qcodes_contrib_drivers.drivers.Tektronix.Keithley_2700.parseint(v)

qcodes_contrib_drivers.drivers.Tektronix.Keithley_2700.parsestr(v)

qcodes_contrib_drivers.drivers.Tektronix.Keithley_6430 module

class qcodes_contrib_drivers.drivers.Tektronix.Keithley_6430.Keithley_6430(*args: Any, **kwargs: Any)

Bases: VisaInstrument

This is the Qcodes driver for the Keithley 6430 SMU.

Parameters:

• name – The name used internally by QCoDeS

• address – Network address or alias of the instrument

• terminator – Termination character in VISA communication

• reset – resets to default values

init() → None

Go into the arm/trigger layers from the idle mode.

read() → Tuple[float, float, float]

Arm, trigger, and readout. Note that the values may not be valid if sense mode doesn’t include them. :returns: tuple of (voltage (V), current (A), resistance (Ohm))

reset() → None

Resets instrument to default values

set_trigger_immediate() → None

Set trigger and arm modes to immediate.

qcodes_contrib_drivers.drivers.Tektronix.Keithley_6500 module

class qcodes_contrib_drivers.drivers.Tektronix.Keithley_6500.Keithley6500Buffer(parent: Keithley_6500, name: str, size: int | None = None, style: str = '')

Bases: InstrumentChannel

Reading buffer submodule for the Keithley DMM6500.

Buffers store measurement data and provide a timetrace parameter for retrieving digitized waveforms as a NumPy array with time setpoints.

clear_buffer() → None

Abort any active trigger model, then clear all readings from the buffer.

Sending :TRACe:CLEar while a trigger model or :TRACe:TRIGger acquisition is still running will cause the instrument to hold the VISA bus until the acquisition completes, making the write() call appear to hang. Aborting first guarantees the instrument is idle before the clear is sent.

delete() → None

Delete this buffer (no-op for default buffers).

trigger_start() → None

Trigger acquisition into this buffer using the active measure function.

default_buffer: ClassVar[set[str]] = {'defbuffer1', 'defbuffer2'}

class qcodes_contrib_drivers.drivers.Tektronix.Keithley_6500.Keithley6500DigitizeSense(parent: Keithley_6500, name: str, proper_function: str)

Bases: InstrumentChannel

Digitize-sense submodule for the Keithley DMM6500.

Exposes the :SENSe:DIGitize namespace which enables high-speed time-domain (timetrace) measurements at up to 100 kS/s for voltage.

acq_rate: Parameter = self.add_parameter( "acq_rate", get_cmd=f":SENSe:DIGitize:{proper_function}:SRATE?", set_cmd=f":SENSe:DIGitize:{proper_function}:SRATE {{}}", vals=rate_vals, get_parser=int, unit="S/s", docstring="Sample rate for digitized measurements.", )

aperture: Parameter = self.add_parameter( "aperture", get_cmd=f":SENSe:DIGitize:{proper_function}:APERture?", set_cmd=f":SENSe:DIGitize:{proper_function}:APERture {{}}", get_parser=float, unit="us", docstring="Acquisition aperture (integration window) in microseconds.", )

count: Parameter = self.add_parameter( "count", get_cmd="SENSe:DIGitize:COUNt?", set_cmd="SENSe:DIGitize:COUNt {}", vals=Ints(1, 55_000_000), get_parser=int, docstring="Number of samples to acquire per trigger.", )

function_modes: ClassVar[dict[str, dict]] = {'current': {'name': '"CURR"', 'range_vals': <Numbers 1e-05<=v<=10>, 'rate_vals': <Ints 1000<=v<=10000>, 'unit': 'A'}, 'voltage': {'name': '"VOLT"', 'range_vals': <Numbers 0.1<=v<=1000>, 'rate_vals': <Ints 1000<=v<=100000>, 'unit': 'V'}}

range: Parameter = self.add_parameter( "range", get_cmd=f":SENSe:DIGitize:{proper_function}:RANGe?", set_cmd=f":SENSe:DIGitize:{proper_function}:RANGe {{}}", vals=range_vals, get_parser=float, unit=unit, docstring="Full-scale input range for the digitize function.", )

class qcodes_contrib_drivers.drivers.Tektronix.Keithley_6500.Keithley_6500(*args: Any, **kwargs: Any)

Bases: VisaInstrument

This is the qcodes driver for a Keithley DMM6500 digital multimeter.

__init__(name: str, address: str, terminator='\n', **kwargs)

Initialize instance of digital multimeter Keithley6500. Check if scanner card is inserted. :param name: Name of instrument :param address: Address of instrument :param terminator: Termination character for SCPI commands :param **kwargs: Keyword arguments to pass to __init__ function of VisaInstrument class

abort() → None

Stop any running trigger model or active acquisition (*ABORt).

Call this before Keithley6500Buffer.clear_buffer() or any other command that would conflict with an in-progress acquisition.

buffer(name: str, size: int | None = None, style: str = '') → Keithley6500Buffer

Return the buffer submodule for name, creating it if necessary.

Parameters:

• name – Buffer name (e.g. "defbuffer1" or a custom name).

• size – Number of readings the buffer can store (ignored for default buffers if the buffer already exists).

• style – Buffer style string passed to :TRACe:MAKE (e.g. "FULL"). Ignored for default and existing buffers.

Returns:

The Keithley6500Buffer submodule.

initiate() → None

Start the trigger model.

wait() → None

Wait for all pending operations to complete

property digi_sense: Keithley6500DigitizeSense

Return the active Keithley6500DigitizeSense submodule (selected by digi_sense_function).

class qcodes_contrib_drivers.drivers.Tektronix.Keithley_6500.Keithley_Sense(parent: VisaInstrument, name: str, channel: str)

Bases: InstrumentChannel

This is the class for a measurement channel, i.e. the quantity to be measured (e.g. resistance, voltage).

__init__(parent: VisaInstrument, name: str, channel: str) → None

Parameters:

• parent – VisaInstrument instance of the Keithley Digital Multimeter

• name – Channel name (e.g. ‘CH1’)

• channel – Name of the quantity to measure (e.g. ‘VOLT’ for DC voltage measurement)

qcodes_contrib_drivers.drivers.Tektronix.keithley_2280s module

Driver for the Keithley 2280S precision DC power supplies.

Command reference: Keithley 077085503, March 2019, sections 3 and 7. https://download.tek.com/manual/077085503_2280_Ref_Mar_20191.pdf

class qcodes_contrib_drivers.drivers.Tektronix.keithley_2280s.Keithley2280S(*args: Any, **kwargs: Any)

Bases: VisaInstrument

Keithley 2280S-32-6 and 2280S-60-3 DC power supplies.

source_voltage and source_current are numeric setpoints suitable for do1d/do2d. The current setpoint is the current limit in CV operation; the load determines whether the supply operates in CV or CC mode.

Measurement parameters are voltage.measure, current.measure, and the two-output MultiParameter concurrent.measure. They select their measurement function, temporarily select a numeric response format, and restore the previous format. The output must already be on.

concurrent.current and concurrent.voltage each acquire both quantities but return a single scalar, for recording only one quantity while displaying both. Use concurrent.measure for a paired reading.

Construction does not reset the instrument unless reset=True. Source limits are selected from *IDN?, and NPLC is checked against the instrument’s line frequency. The hardware enforces voltage_limit too.

abort() → None

Abort the trigger model; continuous initiation can restart it.

acquire(count: int) → npt.NDArray[np.float64]

Acquire a finite concurrent trace, returning columns current, voltage, time.

Units are A, V, s. This clears the buffer and configures immediate, noncontinuous triggering, raw sense data, and count readings. The output must already be on. Increase timeout for long acquisitions. Measurement settings (NPLC, range, and filtering) are retained.

clear() → None

Clear status registers and the error queue (SCPI *CLS).

clear_error() → None

Clear the error queue.

clear_protection() → None

Clear a latched output protection fault.

clear_text() → None

Clear the custom display message.

fetch() → tuple[float | str, ...]

Fetch the latest reading without triggering, in data_format.

force_trigger() → None

Bypass the current arm or trigger event detector.

get_error() → tuple[int, str]

Pop the oldest error; code zero means the queue is empty.

initiate() → None

Start the configured trigger model.

local() → None

Return control to the front panel.

opc_set() → None

Set the operation-complete event bit when pending operations finish.

read() → tuple[float | str, ...]

Trigger acquisition and return the first reading in data_format.

Honors the configured trigger model; external/manual triggers can block until the VISA timeout. For a simple single reading use a measure parameter.

reset() → None

Restore instrument defaults, including turning the output off.

self_test() → bool

Run the instrument self-test; True means it passed.

trigger() → None

Send a bus trigger; select BUS as the arm source first.

wait() → None

Queue *WAI; use opc() to wait on the Python side.

default_terminator = '\n'

The default terminator to use if the terminator is not specified when creating the instrument. None means use the default terminator from PyVisa.

class qcodes_contrib_drivers.drivers.Tektronix.keithley_2280s.Keithley2280SBuffer(parent: Keithley2280S, name: str)

Bases: InstrumentChannel

The 2280S’s single reading buffer (2 to 2500 readings).

clear_buffer() → None

Stop acquisition and clear readings; continuous initiation is disabled.

get_data(start: int = 1, end: int | None = None, elements: str = 'READ,SOUR,REL') → tuple[float | str, ...]

Read an inclusive range of buffer indices as a flat tuple.

For concurrent data with the default elements, each record contains current (A), voltage (V), and relative time (s), in that order. The instrument controls element order, regardless of the supplied order.

autoclear: Parameter = self.add_parameter( "autoclear", get_cmd=":TRAC:CLE:AUTO?", set_cmd=":TRAC:CLE:AUTO {}", val_mapping=_ON_OFF, )

feed: Parameter = self.add_parameter( "feed", get_cmd=":TRAC:FEED?", set_cmd=":TRAC:FEED {}", vals=Enum("SENS", "CALC"), )

feed_control: Parameter = self.add_parameter( "feed_control", get_cmd=":TRAC:FEED:CONT?", set_cmd=":TRAC:FEED:CONT {}", vals=Enum("NEV", "NEXT", "ALW"), )

number_of_readings: Parameter = self.add_parameter( "number_of_readings", get_cmd=":TRAC:POIN:ACT?", get_parser=int )

size: Parameter = self.add_parameter( "size", get_cmd=":TRAC:POIN?", set_cmd=":TRAC:POIN {}", get_parser=int, vals=Ints(2, 2500), )

class qcodes_contrib_drivers.drivers.Tektronix.keithley_2280s.Keithley2280SCalculate(parent: Keithley2280S, name: str)

Bases: InstrumentChannel

Statistics over the instrument’s reading buffer.

data returns a flat tuple in the instrument’s response order, with timestamps preserved as strings. UNIT adds suffixes, not separate fields. Metadata is available only when all selected statistics are MIN and/or MAX. Use statistics() for an unambiguous dictionary of numeric results.

statistics() → dict[str, float]

Calculate all five statistics, restoring formats and enabled state.

Query each statistic separately because firmware versions differ in the order of PKPK and SDEV in a combined response.

data: Parameter = self.add_parameter( "data", get_cmd=":CALC2:IMM?", get_parser=_parse_data, set_cmd=False, snapshot_get=False, )

data_format: Parameter = self.add_parameter( "data_format", get_cmd=":CALC2:FORM:ELEM?", set_cmd=partial(self._set_format, ":CALC2:FORM:ELEM", _STAT_ELEMENTS, True), get_parser=_unquote, vals=Strings(), )

enabled: Parameter = self.add_parameter( "enabled", get_cmd=":CALC2:STAT?", set_cmd=":CALC2:STAT {}", val_mapping=_ON_OFF, )

format: Parameter = self.add_parameter( "format", get_cmd=":CALC2:FORM?", set_cmd=partial(self._set_format, ":CALC2:FORM", _STATISTICS, False), get_parser=_unquote, vals=Strings(), )

function: Parameter = self.add_parameter( "function", get_cmd=":CALC2:FUNC?", set_cmd=":CALC2:FUNC {}", get_parser=_unquote, vals=Enum("CURR", "VOLT"), )

class qcodes_contrib_drivers.drivers.Tektronix.keithley_2280s.Keithley2280SSense(parent: Keithley2280S, name: str, function: str)

Bases: InstrumentChannel

Measurement settings for voltage, current, or concurrent measurements.

Concurrent range and relative offset apply to current. The instrument has only one voltage range. digits affects the display only; resolution also changes NPLC, autozero, filtering, and source delay.

On the concurrent channel, current and voltage each acquire both quantities and return only the named value, keeping both on the display. Reading them separately triggers two acquisitions. Use measure to obtain both values from one acquisition.

acquire_relative() → None

Take a reading of this function and store its relative offset.

A fresh reading is needed after changing function on firmware 01.07b. The output must be on; relative subtraction is enabled separately.

autorange: Parameter

current: Parameter

digits: Parameter = self.add_parameter( "digits", get_cmd=f"{prefix}:DIG?", set_cmd=f"{prefix}:DIG {{}}", get_parser=int, vals=MultiType(Enum(4, 5, 6), _PRESETS), )

filter_count: Parameter = self.add_parameter( "filter_count", get_cmd=f"{prefix}:AVER:COUN?", set_cmd=f"{prefix}:AVER:COUN {{}}", get_parser=int, vals=MultiType(Ints(2, 100), _PRESETS), )

filter_enabled: Parameter = self.add_parameter( "filter_enabled", get_cmd=f"{prefix}:AVER:STAT?", set_cmd=f"{prefix}:AVER:STAT {{}}", val_mapping=_ON_OFF, )

filter_type: Parameter = self.add_parameter( "filter_type", get_cmd=f"{prefix}:AVER:TCON?", set_cmd=f"{prefix}:AVER:TCON {{}}", val_mapping={"moving": "MOV"}, )

filter_window: Parameter = self.add_parameter( "filter_window", unit="%", get_cmd=f"{prefix}:AVER:WIND?", set_cmd=f"{prefix}:AVER:WIND {{}}", get_parser=float, vals=MultiType(Numbers(0.01, 100), _PRESETS), docstring="Rounds up to 0.01, 0.1, 1, 10, or 100 percent.", )

nplc: Parameter = self.add_parameter( "nplc", label=f"{name.capitalize()} integration time", get_cmd=f"{prefix}:NPLC?", set_cmd=self._set_nplc, get_parser=float, vals=MultiType(Numbers(0.002, 15), _PRESETS), docstring="Integration in PLC; maximum 12 at 50 Hz, 15 at 60 Hz.", )

range: Parameter = self.add_parameter( "range", unit=unit, get_cmd=f"{prefix}:RANG?", set_cmd=f"{prefix}:RANG {{}}", get_parser=float, vals=( Enum(parent.max_voltage) if voltage else MultiType(Numbers(0, 10), _PRESETS) ), docstring="A fixed current range disables autoranging; values round up.", )

relative: Parameter = self.add_parameter( "relative", unit=unit, get_cmd=f"{prefix}:REF?", set_cmd=f"{prefix}:REF {{}}", get_parser=float, vals=Numbers(-maximum, maximum), )

relative_enabled: Parameter = self.add_parameter( "relative_enabled", get_cmd=f"{prefix}:REF:STAT?", set_cmd=f"{prefix}:REF:STAT {{}}", val_mapping=_ON_OFF, )

resolution: Parameter = self.add_parameter( "resolution", get_cmd=False, set_cmd=f"{prefix}:RES {{}}", vals=Enum(4, 5, 6), docstring="Select the 4.5, 5.5, or 6.5 digit measurement preset.", )

voltage: Parameter

Module contents