Keithley DriversΒΆ
Classes:
|
Driver for the Keithley 2000 multimeter. |
|
QCoDeS driver for the Keithley 2400 voltage source. |
|
The QCoDeS driver for the Keithley 2450 SMU |
|
Treat the reading buffer as a submodule, similar to Sense and Source |
|
The sense module of the Keithley 2450 SMU. |
|
The source module of the Keithley 2450 SMU. |
|
Keeps track of measurement status. |
|
This is the base class for all qcodes driver for the Keithley 2600 Source-Meter series. |
|
Class to hold the two Keithley channels, i.e. SMUA and SMUB. |
|
QCoDeS driver for the Keithley 2601B Source-Meter |
|
QCoDeS driver for the Keithley 2602A Source-Meter |
|
QCoDeS driver for the Keithley 2602B Source-Meter |
|
QCoDeS driver for the Keithley 2604B Source-Meter |
|
QCoDeS driver for the Keithley 2611B Source-Meter |
|
QCoDeS driver for the Keithley 2612B Source-Meter |
|
QCoDeS driver for the Keithley 2614B Source-Meter |
|
QCoDeS driver for the Keithley 2634B Source-Meter |
|
QCoDeS driver for the Keithley 2635B Source-Meter |
|
QCoDeS driver for the Keithley 2636B Source-Meter |
|
This is the QCoDeS instrument driver for the Keithley 3706A-SNFP System Switch. |
|
Driver for the Keithley 6500 multimeter. |
|
The QCoDeS driver for the Keithley 7510 DMM |
|
Treat the reading buffer as a submodule, similar to Sense. |
|
The Digitize sense module of the Keithley 7510 DMM. |
|
The sense module of the Keithley 7510 DMM, based on the sense module of Keithley 2450 SMU. |
|
|
|
The S46 either has six pole or a four pole relays. |
Data:
Type alias for all Keithley 26xx SMUs supported by QCoDeS. |
Exceptions:
- class qcodes.instrument_drivers.Keithley.Keithley2000(name: str, address: str, reset: bool = False, **kwargs: Unpack[VisaInstrumentKWArgs])[source]ΒΆ
Bases:
VisaInstrument
Driver for the Keithley 2000 multimeter.
Attributes:
The default terminator to use if the terminator is not specified when creating the instrument.
Parameter mode
Parameter nplc
Parameter range
Parameter auto_range_enabled
Parameter digits
Parameter averaging_type
Parameter averaging_count
Parameter averaging_enabled
Parameter display_enabled
Parameter trigger_continuous
Parameter trigger_count
Parameter trigger_delay
Parameter trigger_source
Parameter trigger_timer
Parameter amplitude
Methods:
trigger
()- default_terminator: str | None = '\n'ΒΆ
The default terminator to use if the terminator is not specified when creating the instrument. None means use the default terminator from PyVisa.
- mode: Parameter = self.add_parameter( "mode", get_cmd="SENS:FUNC?", set_cmd="SENS:FUNC {}", val_mapping=self._mode_map, )ΒΆ
Parameter mode
- nplc: Parameter = self.add_parameter( "nplc", get_cmd=partial(self._get_mode_param, "NPLC", float), set_cmd=partial(self._set_mode_param, "NPLC"), vals=Numbers(min_value=0.01, max_value=10), )ΒΆ
Parameter nplc
- range: Parameter = self.add_parameter( "range", get_cmd=partial(self._get_mode_param, "RANG", float), set_cmd=partial(self._set_mode_param, "RANG"), vals=Numbers(), )ΒΆ
Parameter range
- auto_range_enabled: Parameter = self.add_parameter( "auto_range_enabled", get_cmd=partial(self._get_mode_param, "RANG:AUTO", _parse_output_bool), set_cmd=partial(self._set_mode_param, "RANG:AUTO"), vals=Bool(), )ΒΆ
Parameter auto_range_enabled
- digits: Parameter = self.add_parameter( "digits", get_cmd=partial(self._get_mode_param, "DIG", int), set_cmd=partial(self._set_mode_param, "DIG"), vals=Ints(min_value=4, max_value=7), )ΒΆ
Parameter digits
- averaging_type: Parameter = self.add_parameter( "averaging_type", get_cmd=partial(self._get_mode_param, "AVER:TCON", _parse_output_string), set_cmd=partial(self._set_mode_param, "AVER:TCON"), vals=Enum("moving", "repeat"), )ΒΆ
Parameter averaging_type
- averaging_count: Parameter = self.add_parameter( "averaging_count", get_cmd=partial(self._get_mode_param, "AVER:COUN", int), set_cmd=partial(self._set_mode_param, "AVER:COUN"), vals=Ints(min_value=1, max_value=100), )ΒΆ
Parameter averaging_count
- averaging_enabled: Parameter = self.add_parameter( "averaging_enabled", get_cmd=partial(self._get_mode_param, "AVER:STAT", _parse_output_bool), set_cmd=partial(self._set_mode_param, "AVER:STAT"), vals=Bool(), )ΒΆ
Parameter averaging_enabled
- display_enabled: Parameter = self.add_parameter( "display_enabled", get_cmd="DISP:ENAB?", get_parser=_parse_output_bool, set_cmd="DISP:ENAB {}", set_parser=int, vals=Bool(), )ΒΆ
Parameter display_enabled
- trigger_continuous: Parameter = self.add_parameter( "trigger_continuous", get_cmd="INIT:CONT?", get_parser=_parse_output_bool, set_cmd="INIT:CONT {}", set_parser=int, vals=Bool(), )ΒΆ
Parameter trigger_continuous
- visa_handle: pyvisa.resources.MessageBasedResource = visa_handleΒΆ
The VISA resource used by this instrument.
- 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 viaadd_submodule()
.
- log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)ΒΆ
- trigger_count: Parameter = self.add_parameter( "trigger_count", get_cmd="TRIG:COUN?", get_parser=int, set_cmd="TRIG:COUN {}", vals=MultiType( Ints(min_value=1, max_value=9999), Enum("inf", "default", "minimum", "maximum"), ), )ΒΆ
Parameter trigger_count
- trigger_delay: Parameter = self.add_parameter( "trigger_delay", get_cmd="TRIG:DEL?", get_parser=float, set_cmd="TRIG:DEL {}", unit="s", vals=Numbers(min_value=0, max_value=999999.999), )ΒΆ
Parameter trigger_delay
- trigger_source: Parameter = self.add_parameter( "trigger_source", get_cmd="TRIG:SOUR?", set_cmd="TRIG:SOUR {}", val_mapping={ "immediate": "IMM", "timer": "TIM", "manual": "MAN", "bus": "BUS", "external": "EXT", }, )ΒΆ
Parameter trigger_source
- trigger_timer: Parameter = self.add_parameter( "trigger_timer", get_cmd="TRIG:TIM?", get_parser=float, set_cmd="TRIG:TIM {}", unit="s", vals=Numbers(min_value=0.001, max_value=999999.999), )ΒΆ
Parameter trigger_timer
- class qcodes.instrument_drivers.Keithley.Keithley2400(name: str, address: str, **kwargs: Unpack[VisaInstrumentKWArgs])[source]ΒΆ
Bases:
VisaInstrument
QCoDeS driver for the Keithley 2400 voltage source.
Attributes:
The default terminator to use if the terminator is not specified when creating the instrument.
Parameter rangev
Parameter rangei
Parameter compliancev
Parameter compliancei
Sets voltage in 'VOLT' mode.
Sets current in 'CURR' mode.
Parameter mode
Parameter sense
Parameter output
Parameter nplcv
Parameter nplci
Measure resistance from current and voltage.
Methods:
reset
()Reset the instrument.
- default_terminator: str | None = '\n'ΒΆ
The default terminator to use if the terminator is not specified when creating the instrument. None means use the default terminator from PyVisa.
- rangev: Parameter = self.add_parameter( "rangev", get_cmd="SENS:VOLT:RANG?", get_parser=float, set_cmd="SOUR:VOLT:RANG {:f}", label="Voltage range", )ΒΆ
Parameter rangev
- rangei: Parameter = self.add_parameter( "rangei", get_cmd="SENS:CURR:RANG?", get_parser=float, set_cmd="SOUR:CURR:RANG {:f}", label="Current range", )ΒΆ
Parameter rangei
- compliancev: Parameter = self.add_parameter( "compliancev", get_cmd="SENS:VOLT:PROT?", get_parser=float, set_cmd="SENS:VOLT:PROT {:f}", label="Voltage Compliance", )ΒΆ
Parameter compliancev
- compliancei: Parameter = self.add_parameter( "compliancei", get_cmd="SENS:CURR:PROT?", get_parser=float, set_cmd="SENS:CURR:PROT {:f}", label="Current Compliance", )ΒΆ
Parameter compliancei
- volt: Parameter = self.add_parameter( "volt", get_cmd=self._get_read_output_protected, get_parser=self._volt_parser, set_cmd=":SOUR:VOLT:LEV {:.8f}", label="Voltage", unit="V", docstring="Sets voltage in 'VOLT' mode. " "Get returns measured voltage if " "sensing 'VOLT' otherwise it returns " "setpoint value. " "Note that it is an error to read voltage with " "output off", )ΒΆ
Sets voltage in βVOLTβ mode. Get returns measured voltage if sensing βVOLTβ otherwise it returns setpoint value. Note that it is an error to read voltage with output off
- curr: Parameter = self.add_parameter( "curr", get_cmd=self._get_read_output_protected, get_parser=self._curr_parser, set_cmd=":SOUR:CURR:LEV {:.8f}", label="Current", unit="A", docstring="Sets current in 'CURR' mode. " "Get returns measured current if " "sensing 'CURR' otherwise it returns " "setpoint value. " "Note that it is an error to read current with " "output off", )ΒΆ
Sets current in βCURRβ mode. Get returns measured current if sensing βCURRβ otherwise it returns setpoint value. Note that it is an error to read current with output off
- mode: Parameter = self.add_parameter( "mode", vals=Enum("VOLT", "CURR"), get_cmd=":SOUR:FUNC?", set_cmd=self._set_mode_and_sense, label="Mode", )ΒΆ
Parameter mode
- sense: Parameter = self.add_parameter( "sense", vals=Strings(), get_cmd=":SENS:FUNC?", set_cmd=':SENS:FUNC "{:s}"', label="Sense mode", )ΒΆ
Parameter sense
- output: Parameter = self.add_parameter( "output", set_cmd=":OUTP:STAT {}", get_cmd=":OUTP:STAT?", val_mapping=create_on_off_val_mapping(on_val="1", off_val="0"), )ΒΆ
Parameter output
- visa_handle: pyvisa.resources.MessageBasedResource = visa_handleΒΆ
The VISA resource used by this instrument.
- 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 viaadd_submodule()
.
- log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)ΒΆ
- nplcv: Parameter = self.add_parameter( "nplcv", get_cmd="SENS:VOLT:NPLC?", get_parser=float, set_cmd="SENS:VOLT:NPLC {:f}", label="Voltage integration time", )ΒΆ
Parameter nplcv
- nplci: Parameter = self.add_parameter( "nplci", get_cmd="SENS:CURR:NPLC?", get_parser=float, set_cmd="SENS:CURR:NPLC {:f}", label="Current integration time", )ΒΆ
Parameter nplci
- resistance: Parameter = self.add_parameter( "resistance", get_cmd=self._get_read_output_protected, get_parser=self._resistance_parser, label="Resistance", unit="Ohm", docstring="Measure resistance from current and voltage. " "Note that it is an error to read current " "and voltage with output off", )ΒΆ
Measure resistance from current and voltage. Note that it is an error to read current and voltage with output off
- class qcodes.instrument_drivers.Keithley.Keithley2450(name: str, address: str, **kwargs: Unpack)[source]ΒΆ
Bases:
VisaInstrument
The QCoDeS driver for the Keithley 2450 SMU
Attributes:
The default terminator to use if the terminator is not specified when creating the instrument.
Parameter source_function
Parameter sense_function
Parameter terminals
Parameter output_enabled
returns the power line frequency setting that is used for NPLC calculations
name of the reading buffer in using
We have different source modules depending on the source function, which can be 'current' or 'voltage'
We have different sense modules depending on the sense function, which can be 'current', 'voltage' or 'resistance'
Methods:
buffer
(name[, size, style])npts
()Get the number of points in the sweep axis
The correct communication protocol is SCPI, make sure this is set
abort
()This command stops all trigger model commands on the instrument.
initiate
()This command starts the trigger model.
wait
()This command postpones the execution of subsequent commands until all previous overlapped commands are finished.
This function clears event registers.
This command clears the event log.
reset
()Returns instrument to default settings, cancels all pending commands.
- visa_handle: pyvisa.resources.MessageBasedResource = visa_handleΒΆ
The VISA resource used by this instrument.
- 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 viaadd_submodule()
.
- log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)ΒΆ
- default_terminator: str | None = '\n'ΒΆ
The default terminator to use if the terminator is not specified when creating the instrument. None means use the default terminator from PyVisa.
- source_function: Parameter = self.add_parameter( "source_function", set_cmd=self._set_source_function, get_cmd=":SOUR:FUNC?", val_mapping={ key: value["name"] for key, value in Keithley2450Source.function_modes.items() }, )ΒΆ
Parameter source_function
- sense_function: Parameter = self.add_parameter( "sense_function", set_cmd=self._set_sense_function, get_cmd=":SENS:FUNC?", val_mapping={ key: value["name"] for key, value in Keithley2450Sense.function_modes.items() }, )ΒΆ
Parameter sense_function
- terminals: Parameter = self.add_parameter( "terminals", set_cmd="ROUTe:TERMinals {}", get_cmd="ROUTe:TERMinals?", vals=Enum("rear", "front"), )ΒΆ
Parameter terminals
- output_enabled: Parameter = self.add_parameter( "output_enabled", set_cmd=":OUTP {}", get_cmd=":OUTP?", val_mapping=create_on_off_val_mapping(on_val="1", off_val="0"), )ΒΆ
Parameter output_enabled
- line_frequency: Parameter = self.add_parameter( "line_frequency", get_cmd=":SYSTem:LFRequency?", unit="Hz", docstring="returns the power line frequency setting that is used " "for NPLC calculations", )ΒΆ
returns the power line frequency setting that is used for NPLC calculations
- buffer_name: Parameter = self.add_parameter( "buffer_name", get_cmd=None, set_cmd=None, docstring="name of the reading buffer in using", )ΒΆ
name of the reading buffer in using
- property source: Keithley2450SourceΒΆ
We have different source modules depending on the source function, which can be βcurrentβ or βvoltageβ
Return the correct source module based on the source function
- property sense: Keithley2450SenseΒΆ
We have different sense modules depending on the sense function, which can be βcurrentβ, βvoltageβ or βresistanceβ
Return the correct source module based on the sense function
- set_correct_language() None [source]ΒΆ
The correct communication protocol is SCPI, make sure this is set
- class qcodes.instrument_drivers.Keithley.Keithley2450Buffer(parent: Keithley2450, name: str, size: int | None = None, style: str = '')[source]ΒΆ
Bases:
InstrumentChannel
Treat the reading buffer as a submodule, similar to Sense and Source
Attributes:
The number of readings a buffer can store.
To get the number of readings in the reading buffer.
List of buffer elements to read.
Methods:
from_name_to_scpi
(element_names)from_scpi_to_name
(element_scpis)This method requests the latest reading from a reading buffer.
get_data
(start_idx, end_idx[, readings_only])This command returns specified data elements from reading buffer.
Clear the data in the buffer
This method makes readings using the active measure function and stores them in a reading buffer.
delete
()- buffer_elements: ClassVar[dict[str, str]] = {'date': 'DATE', 'fractional_seconds': 'FRACtional', 'measurement': 'READing', 'measurement_formatted': 'FORMatted', 'measurement_status': 'STATus', 'measurement_unit': 'UNIT', 'relative_time': 'RELative', 'seconds': 'SEConds', 'source_value': 'SOURce', 'source_value_formatted': 'SOURFORMatted', 'source_value_status': 'SOURSTATus', 'source_value_unit': 'SOURUNIT', 'time': 'TIME', 'timestamp': 'TSTamp'}ΒΆ
- inverted_buffer_elements = {'DATE': 'date', 'FORMatted': 'measurement_formatted', 'FRACtional': 'fractional_seconds', 'READing': 'measurement', 'RELative': 'relative_time', 'SEConds': 'seconds', 'SOURFORMatted': 'source_value_formatted', 'SOURSTATus': 'source_value_status', 'SOURUNIT': 'source_value_unit', 'SOURce': 'source_value', 'STATus': 'measurement_status', 'TIME': 'time', 'TSTamp': 'timestamp', 'UNIT': 'measurement_unit'}ΒΆ
- size: Parameter = self.add_parameter( "size", get_cmd=f":TRACe:POINts? '{self.buffer_name}'", set_cmd=f":TRACe:POINts {{}}, '{self.buffer_name}'", get_parser=int, docstring="The number of readings a buffer can store.", )ΒΆ
The number of readings a buffer can store.
- number_of_readings: Parameter = self.add_parameter( "number_of_readings", get_cmd=f":TRACe:ACTual? '{self.buffer_name}'", get_parser=int, docstring="To get the number of readings in the reading buffer.", )ΒΆ
To get the number of readings in the reading buffer.
- elements: Parameter = self.add_parameter( "elements", get_cmd=None, get_parser=self.from_scpi_to_name, set_cmd=None, set_parser=self.from_name_to_scpi, vals=Lists(Enum(*list(self.buffer_elements.keys()))), docstring="List of buffer elements to read.", )ΒΆ
List of buffer elements to read.
- get_data(start_idx: int, end_idx: int, readings_only: bool = False) list[Any] [source]ΒΆ
This command returns specified data elements from reading buffer.
- Parameters:
start_idx β beginning index of the buffer to return
end_idx β ending index of the buffer to return
readings_only β a flag to temporarily disable the elements and output only the numerical readings
- Returns:
data elements from the reading buffer
- trigger_start() None [source]ΒΆ
This method makes readings using the active measure function and stores them in a reading 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 viaadd_submodule()
.
- log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)ΒΆ
- class qcodes.instrument_drivers.Keithley.Keithley2450Sense(parent: Keithley2450, name: str, proper_function: str)[source]ΒΆ
Bases:
InstrumentChannel
The sense module of the Keithley 2450 SMU.
- Parameters:
parent
name
proper_function β This can be one of either βcurrentβ, βvoltageβ or βresistanceβ. All parameters and methods in this submodule should only be accessible to the user if self.parent.sense_function.get() == self._proper_function. We ensure this through the βsenseβ property on the main driver class which returns the proper submodule for any given function mode
Attributes:
Parameter four_wire_measurement
Parameter range
Parameter auto_range
Parameter sweep
Parameter nplc
Parameter user_number
Parameter user_delay
This command enables or disables automatic updates to the internal reference measurements (autozero) of the instrument.
The number of measurements to make when a measurement is requested.
Methods:
This command causes the instrument to refresh the reference and zero measurements once.
clear_trace
([buffer_name])Clear the data buffer
- function_modes: ClassVar[dict[str, _FunctionMode]] = {'current': {'name': '"CURR:DC"', 'range_vals': <Numbers 1e-08<=v<=1>, 'unit': 'A'}, 'resistance': {'name': '"RES"', 'range_vals': <Numbers 20<=v<=200000000.0>, 'unit': 'Ohm'}, 'voltage': {'name': '"VOLT:DC"', 'range_vals': <Numbers 0.02<=v<=200>, 'unit': 'V'}}ΒΆ
- four_wire_measurement: Parameter = self.add_parameter( "four_wire_measurement", set_cmd=f":SENSe:{self._proper_function}:RSENse {{}}", get_cmd=f":SENSe:{self._proper_function}:RSENse?", val_mapping=create_on_off_val_mapping(on_val="1", off_val="0"), )ΒΆ
Parameter four_wire_measurement
- range: Parameter = self.add_parameter( "range", set_cmd=f":SENSe:{self._proper_function}:RANGe {{}}", get_cmd=f":SENSe:{self._proper_function}:RANGe?", vals=range_vals, get_parser=float, unit=unit, )ΒΆ
Parameter range
- auto_range: Parameter = self.add_parameter( "auto_range", set_cmd=f":SENSe:{self._proper_function}:RANGe:AUTO {{}}", get_cmd=f":SENSe:{self._proper_function}:RANGe:AUTO?", val_mapping=create_on_off_val_mapping(on_val="1", off_val="0"), )ΒΆ
Parameter auto_range
- sweep: ParameterWithSetpointsCustomized = self.add_parameter( "sweep", label=self._proper_function, get_cmd=self._measure_sweep, unit=unit, vals=Arrays(shape=(self.parent.npts,)), parameter_class=ParameterWithSetpointsCustomized, )ΒΆ
Parameter sweep
- nplc: Parameter = self.add_parameter( "nplc", get_cmd=f":SENSe:{self._proper_function}:NPLCycles?", set_cmd=f":SENSe:{self._proper_function}:NPLCycles {{}}", vals=Numbers(0.001, 10), )ΒΆ
Parameter nplc
- user_number: Parameter = self.add_parameter( "user_number", get_cmd=None, set_cmd=None, vals=Ints(1, 5) )ΒΆ
Parameter user_number
- user_delay: Parameter = self.add_parameter( "user_delay", get_cmd=self._get_user_delay, set_cmd=self._set_user_delay, get_parser=float, vals=Numbers(0, 1e4), )ΒΆ
Parameter user_delay
- auto_zero_enabled: Parameter = self.add_parameter( "auto_zero_enabled", get_cmd=f":SENSe:{self._proper_function}:AZERo?", set_cmd=f":SENSe:{self._proper_function}:AZERo {{}}", val_mapping=create_on_off_val_mapping(on_val="1", off_val="0"), docstring="This command enables or disables automatic updates to " "the internal reference measurements (autozero) of the " "instrument.", )ΒΆ
This command enables or disables automatic updates to the internal reference measurements (autozero) of the instrument.
- count: Parameter = self.add_parameter( "count", get_cmd=":SENSe:COUNt?", set_cmd=":SENSe:COUNt {}", docstring="The number of measurements to make when a measurement " "is requested.", )ΒΆ
The number of measurements to make when a measurement is requested.
- auto_zero_once() None [source]ΒΆ
This command causes the instrument to refresh the reference and zero measurements once.
- 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 viaadd_submodule()
.
- log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)ΒΆ
- class qcodes.instrument_drivers.Keithley.Keithley2450Source(parent: Keithley2450, name: str, proper_function: str)[source]ΒΆ
Bases:
InstrumentChannel
The source module of the Keithley 2450 SMU.
- Parameters:
parent
name
proper_function β This can be one of either βcurrentβ or βvoltageβ All parameters and methods in this submodule should only be accessible to the user if self.parent.source_function.get() == self._proper_function. We ensure this through the βsourceβ property on the main driver class which returns the proper submodule for any given function mode
Attributes:
Parameter range
Parameter auto_range
Parameter limit
Parameter limit_tripped
Parameter sweep_axis
Parameter delay
Parameter user_number
Parameter user_delay
Parameter auto_delay
This command determines if the instrument records the measured source value or the configured source value when making a measurement.
Setting the source output level alone cannot block the execution of subsequent code.
Methods:
sweep_setup
(start, stop, step_count[, ...])Start a sweep and return when the sweep has finished.
- function_modes: ClassVar[dict[str, _FunctionMode]] = {'current': {'name': 'CURR', 'range_vals': <Numbers -1<=v<=1>, 'unit': 'A'}, 'voltage': {'name': 'VOLT', 'range_vals': <Numbers -200<=v<=200>, 'unit': 'V'}}ΒΆ
- range: Parameter = self.add_parameter( "range", set_cmd=f":SOUR:{self._proper_function}:RANGe {{}}", get_cmd=f":SOUR:{self._proper_function}:RANGe?", vals=range_vals, get_parser=float, unit=unit, )ΒΆ
Parameter range
- auto_range: Parameter = self.add_parameter( "auto_range", set_cmd=f":SOURce:{self._proper_function}:RANGe:AUTO {{}}", get_cmd=f":SOURce:{self._proper_function}:RANGe:AUTO?", val_mapping=create_on_off_val_mapping(on_val="1", off_val="0"), )ΒΆ
Parameter auto_range
- limit: Parameter = self.add_parameter( "limit", set_cmd=f"SOUR:{self._proper_function}:{limit_cmd} {{}}", get_cmd=f"SOUR:{self._proper_function}:{limit_cmd}?", get_parser=float, unit=unit, )ΒΆ
Parameter limit
- limit_tripped: Parameter = self.add_parameter( "limit_tripped", get_cmd=f":SOUR:{self._proper_function}:{limit_cmd}:TRIPped?", val_mapping={True: 1, False: 0}, )ΒΆ
Parameter limit_tripped
- sweep_axis: Parameter = self.add_parameter( "sweep_axis", label=self._proper_function, get_cmd=self.get_sweep_axis, vals=Arrays(shape=(self.parent.npts,)), unit=unit, )ΒΆ
Parameter sweep_axis
- delay: Parameter = self.add_parameter( "delay", get_cmd=f":SOURce:{self._proper_function}:DELay?", set_cmd=f":SOURce:{self._proper_function}:DELay {{}}", vals=Numbers(0, 1e4), )ΒΆ
Parameter delay
- user_number: Parameter = self.add_parameter( "user_number", get_cmd=None, set_cmd=None, vals=Ints(1, 5) )ΒΆ
Parameter user_number
- user_delay: Parameter = self.add_parameter( "user_delay", get_cmd=self._get_user_delay, set_cmd=self._set_user_delay, vals=Numbers(0, 1e4), )ΒΆ
Parameter user_delay
- auto_delay: Parameter = self.add_parameter( "auto_delay", get_cmd=f":SOURce:{self._proper_function}:DELay:AUTO?", set_cmd=f":SOURce:{self._proper_function}:DELay:AUTO {{}}", val_mapping=create_on_off_val_mapping(on_val="1", off_val="0"), )ΒΆ
Parameter auto_delay
- read_back_enabled: Parameter = self.add_parameter( "read_back_enabled", get_cmd=f":SOURce:{self._proper_function}:READ:BACK?", set_cmd=f":SOURce:{self._proper_function}:READ:BACK {{}}", val_mapping=create_on_off_val_mapping(on_val="1", off_val="0"), docstring="This command determines if the instrument records the " "measured source value or the configured source value " "when making a measurement.", )ΒΆ
This command determines if the instrument records the measured source value or the configured source value when making a measurement.
- block_during_ramp: Parameter = self.add_parameter( "block_during_ramp", initial_value=False, get_cmd=None, set_cmd=None, vals=Bool(), docstring="Setting the source output level alone cannot block the " "execution of subsequent code. This parameter allows _proper_function" "to either block or not.", )ΒΆ
Setting the source output level alone cannot block the execution of subsequent code. This parameter allows _proper_functionto either block or not.
- sweep_setup(start: float, stop: float, step_count: int, delay: float = 0, sweep_count: int = 1, range_mode: str = 'AUTO', fail_abort: str = 'ON', dual: str = 'OFF', buffer_name: str = 'defbuffer1') None [source]ΒΆ
- sweep_start() None [source]ΒΆ
Start a sweep and return when the sweep has finished. Note: This call is blocking
- 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 viaadd_submodule()
.
- log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)ΒΆ
- class qcodes.instrument_drivers.Keithley.Keithley2600MeasurementStatus(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)[source]ΒΆ
Bases:
StrEnum
Keeps track of measurement status.
Attributes:
- CURRENT_COMPLIANCE_ERROR = 'Reached current compliance limit.'ΒΆ
- VOLTAGE_COMPLIANCE_ERROR = 'Reached voltage compliance limit.'ΒΆ
- VOLTAGE_AND_CURRENT_COMPLIANCE_ERROR = 'Reached both voltage and current compliance limits.'ΒΆ
- NORMAL = 'No error occured.'ΒΆ
- COMPLIANCE_ERROR = 'Reached compliance limit.'ΒΆ
- class qcodes.instrument_drivers.Keithley.Keithley2600(name: str, address: str, **kwargs: Unpack[VisaInstrumentKWArgs])[source]ΒΆ
Bases:
VisaInstrument
This is the base class for all qcodes driver for the Keithley 2600 Source-Meter series. This class should not be instantiated directly. Rather one of the subclasses for a specific instrument should be used.
- Parameters:
name β Name to use internally in QCoDeS
address β VISA resource address
**kwargs β kwargs are forwarded to base class.
Attributes:
The default terminator to use if the terminator is not specified when creating the instrument.
Parameter display_settext
Methods:
get_idn
()Parse a standard VISA
*IDN?
response into an ID dict.This function clears the display, but also leaves it in user mode
Set the display to the default mode
exit_key
()Get back the normal screen after an error: send an EXIT key press event
reset
()Reset instrument to factory defaults.
ask
(cmd)Override of normal ask.
- visa_handle: pyvisa.resources.MessageBasedResource = visa_handleΒΆ
The VISA resource used by this instrument.
- 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 viaadd_submodule()
.
- log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)ΒΆ
- default_terminator: str | None = '\n'ΒΆ
The default terminator to use if the terminator is not specified when creating the instrument. None means use the default terminator from PyVisa.
- channels: list[Keithley2600Channel] = []ΒΆ
- display_settext: Parameter = self.add_parameter( "display_settext", set_cmd=self._display_settext, vals=vals.Strings() )ΒΆ
Parameter display_settext
- get_idn() dict[str, str | None] [source]ΒΆ
Parse a standard VISA
*IDN?
response into an ID dict.Even though this is the VISA standard, it applies to various other types as well, such as IPInstruments, so it is included here in the Instrument base class.
Override this if your instrument does not support
*IDN?
or returns a nonstandard IDN string. This string is supposed to be a comma-separated list of vendor, model, serial, and firmware, but semicolon and colon are also common separators so we accept them here as well.- Returns:
A dict containing vendor, model, serial, and firmware.
- qcodes.instrument_drivers.Keithley.Keithley26xx = qcodes.instrument_drivers.Keithley.Keithley_2601B.Keithley2601B | qcodes.instrument_drivers.Keithley.Keithley_2602A.Keithley2602A | qcodes.instrument_drivers.Keithley.Keithley_2602B.Keithley2602B | qcodes.instrument_drivers.Keithley.Keithley_2604B.Keithley2604B | qcodes.instrument_drivers.Keithley.Keithley_2611B.Keithley2611B | qcodes.instrument_drivers.Keithley.Keithley_2612B.Keithley2612B | qcodes.instrument_drivers.Keithley.Keithley_2614B.Keithley2614B | qcodes.instrument_drivers.Keithley.Keithley_2634B.Keithley2634B | qcodes.instrument_drivers.Keithley.Keithley_2635B.Keithley2635B | qcodes.instrument_drivers.Keithley.Keithley_2636B.Keithley2636BΒΆ
Type alias for all Keithley 26xx SMUs supported by QCoDeS.
- class qcodes.instrument_drivers.Keithley.Keithley2600Channel(parent: Instrument, name: str, channel: str)[source]ΒΆ
Bases:
InstrumentChannel
Class to hold the two Keithley channels, i.e. SMUA and SMUB.
- Parameters:
parent β The Instrument instance to which the channel is to be attached.
name β The βcolloquialβ name of the channel
channel β The name used by the Keithley, i.e. either βsmuaβ or βsmubβ
Attributes:
Parameter volt
Parameter curr
Parameter res
Selects the output source type.
Parameter output
Parameter linefreq
Number of power line cycles, used to perform measurements
The range used when sourcing voltage This affects the range and the precision of the source.
Set autorange on/off for source voltage.
The range to perform voltage measurements in.
Set autorange on/off for measure voltage.
The range used when sourcing current This affects the range and the precision of the source.
Set autorange on/off for source current.
The range to perform current measurements in.
Set autorange on/off for measure current.
Voltage limit e.g. the maximum voltage allowed in current mode.
Current limit e.g. the maximum current allowed in voltage mode.
Parameter fastsweep
Parameter timetrace_npts
Parameter timetrace_dt
Parameter time_axis
Parameter timetrace
Parameter timetrace_mode
Methods:
reset
()Reset instrument to factory defaults.
doFastSweep
(start, stop, steps, mode)Perform a fast sweep using a deployed lua script and return a QCoDeS DataSet with the sweep.
- volt: _MeasurementVoltageParameter = self.add_parameter( "volt", parameter_class=_MeasurementVoltageParameter, label="Voltage", unit="V", snapshot_get=False, )ΒΆ
Parameter volt
- curr: _MeasurementCurrentParameter = self.add_parameter( "curr", parameter_class=_MeasurementCurrentParameter, label="Current", unit="A", snapshot_get=False, )ΒΆ
Parameter curr
- res: Parameter = self.add_parameter( "res", get_cmd=f"{channel}.measure.r()", get_parser=float, set_cmd=False, label="Resistance", unit="Ohm", )ΒΆ
Parameter res
- mode: Parameter = self.add_parameter( "mode", get_cmd=f"{channel}.source.func", get_parser=float, set_cmd=f"{channel}.source.func={{:d}}", val_mapping={"current": 0, "voltage": 1}, docstring="Selects the output source type. " "Can be either voltage or current.", )ΒΆ
Selects the output source type. Can be either voltage or current.
- output: Parameter = self.add_parameter( "output", get_cmd=f"{channel}.source.output", get_parser=float, set_cmd=f"{channel}.source.output={{:d}}", val_mapping=create_on_off_val_mapping(on_val=1, off_val=0), )ΒΆ
Parameter output
- linefreq: Parameter = self.add_parameter( "linefreq", label="Line frequency", get_cmd="localnode.linefreq", get_parser=float, set_cmd=False, unit="Hz", )ΒΆ
Parameter linefreq
- nplc: Parameter = self.add_parameter( "nplc", label="Number of power line cycles", set_cmd=f"{channel}.measure.nplc={{}}", get_cmd=f"{channel}.measure.nplc", get_parser=float, docstring="Number of power line cycles, used to perform measurements", vals=vals.Numbers(0.001, 25), )ΒΆ
Number of power line cycles, used to perform measurements
- sourcerange_v: Parameter = self.add_parameter( "sourcerange_v", label="voltage source range", get_cmd=f"{channel}.source.rangev", get_parser=float, set_cmd=self._set_sourcerange_v, unit="V", docstring="The range used when sourcing voltage " "This affects the range and the precision " "of the source.", vals=vals.Enum(*vranges[self.model]), )ΒΆ
The range used when sourcing voltage This affects the range and the precision of the source.
- source_autorange_v_enabled: Parameter = self.add_parameter( "source_autorange_v_enabled", label="voltage source autorange", get_cmd=f"{channel}.source.autorangev", get_parser=float, set_cmd=f"{channel}.source.autorangev={{}}", docstring="Set autorange on/off for source voltage.", val_mapping=create_on_off_val_mapping(on_val=1, off_val=0), )ΒΆ
Set autorange on/off for source voltage.
- measurerange_v: Parameter = self.add_parameter( "measurerange_v", label="voltage measure range", get_cmd=f"{channel}.measure.rangev", get_parser=float, set_cmd=self._set_measurerange_v, unit="V", docstring="The range to perform voltage " "measurements in. This affects the range " "and the precision of the measurement. " "Note that if you both measure and " "source current this will have no effect, " "set `sourcerange_v` instead", vals=vals.Enum(*vranges[self.model]), )ΒΆ
The range to perform voltage measurements in. This affects the range and the precision of the measurement. Note that if you both measure and source current this will have no effect, set sourcerange_v instead
- measure_autorange_v_enabled: Parameter = self.add_parameter( "measure_autorange_v_enabled", label="voltage measure autorange", get_cmd=f"{channel}.measure.autorangev", get_parser=float, set_cmd=f"{channel}.measure.autorangev={{}}", docstring="Set autorange on/off for measure voltage.", val_mapping=create_on_off_val_mapping(on_val=1, off_val=0), )ΒΆ
Set autorange on/off for measure voltage.
- sourcerange_i: Parameter = self.add_parameter( "sourcerange_i", label="current source range", get_cmd=f"{channel}.source.rangei", get_parser=float, set_cmd=self._set_sourcerange_i, unit="A", docstring="The range used when sourcing current " "This affects the range and the " "precision of the source.", vals=vals.Enum(*iranges[self.model]), )ΒΆ
The range used when sourcing current This affects the range and the precision of the source.
- source_autorange_i_enabled: Parameter = self.add_parameter( "source_autorange_i_enabled", label="current source autorange", get_cmd=f"{channel}.source.autorangei", get_parser=float, set_cmd=f"{channel}.source.autorangei={{}}", docstring="Set autorange on/off for source current.", val_mapping=create_on_off_val_mapping(on_val=1, off_val=0), )ΒΆ
Set autorange on/off for source current.
- measurerange_i: Parameter = self.add_parameter( "measurerange_i", label="current measure range", get_cmd=f"{channel}.measure.rangei", get_parser=float, set_cmd=self._set_measurerange_i, unit="A", docstring="The range to perform current " "measurements in. This affects the range " "and the precision of the measurement. " "Note that if you both measure and source " "current this will have no effect, set " "`sourcerange_i` instead", vals=vals.Enum(*iranges[self.model]), )ΒΆ
The range to perform current measurements in. This affects the range and the precision of the measurement. Note that if you both measure and source current this will have no effect, set sourcerange_i instead
- measure_autorange_i_enabled: Parameter = self.add_parameter( "measure_autorange_i_enabled", label="current autorange", get_cmd=f"{channel}.measure.autorangei", get_parser=float, set_cmd=f"{channel}.measure.autorangei={{}}", docstring="Set autorange on/off for measure current.", val_mapping=create_on_off_val_mapping(on_val=1, off_val=0), )ΒΆ
Set autorange on/off for measure current.
- limitv: Parameter = self.add_parameter( "limitv", get_cmd=f"{channel}.source.limitv", get_parser=float, set_cmd=f"{channel}.source.limitv={{}}", docstring="Voltage limit e.g. the maximum voltage " "allowed in current mode. If exceeded " "the current will be clipped.", vals=vals.Numbers( vlimit_minmax[self.model][0], vlimit_minmax[self.model][1] ), unit="V", )ΒΆ
Voltage limit e.g. the maximum voltage allowed in current mode. If exceeded the current will be clipped.
- limiti: Parameter = self.add_parameter( "limiti", get_cmd=f"{channel}.source.limiti", get_parser=float, set_cmd=f"{channel}.source.limiti={{}}", docstring="Current limit e.g. the maximum current " "allowed in voltage mode. If exceeded " "the voltage will be clipped.", vals=vals.Numbers( ilimit_minmax[self.model][0], ilimit_minmax[self.model][1] ), unit="A", )ΒΆ
Current limit e.g. the maximum current allowed in voltage mode. If exceeded the voltage will be clipped.
- fastsweep: LuaSweepParameter = self.add_parameter( "fastsweep", parameter_class=LuaSweepParameter )ΒΆ
Parameter fastsweep
- timetrace_npts: Parameter = self.add_parameter( "timetrace_npts", initial_value=500, label="Number of points", get_cmd=None, set_cmd=None, )ΒΆ
Parameter timetrace_npts
- timetrace_dt: Parameter = self.add_parameter( "timetrace_dt", initial_value=1e-3, label="Time resolution", unit="s", get_cmd=None, set_cmd=None, )ΒΆ
Parameter timetrace_dt
- time_axis: TimeAxis = self.add_parameter( name="time_axis", label="Time", unit="s", snapshot_value=False, vals=vals.Arrays(shape=(self.timetrace_npts,)), parameter_class=TimeAxis, )ΒΆ
Parameter time_axis
- timetrace: TimeTrace = self.add_parameter( "timetrace", vals=vals.Arrays(shape=(self.timetrace_npts,)), setpoints=(self.time_axis,), parameter_class=TimeTrace, )ΒΆ
Parameter timetrace
- timetrace_mode: Parameter = self.add_parameter( "timetrace_mode", initial_value="current", get_cmd=None, set_cmd=self.timetrace._set_mode, vals=vals.Enum("current", "voltage"), )ΒΆ
Parameter timetrace_mode
- reset() None [source]ΒΆ
Reset instrument to factory defaults. This resets only the relevant channel.
- doFastSweep(start: float, stop: float, steps: int, mode: str) DataSet [source]ΒΆ
Perform a fast sweep using a deployed lua script and return a QCoDeS DataSet with the sweep.
- Parameters:
start β starting sweep value (V or A)
stop β end sweep value (V or A)
steps β number of steps
mode β Type of sweep, either βIVβ (voltage sweep), βVIβ (current sweep two probe setup) or βVIfourprobeβ (current sweep four probe setup)
- 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 viaadd_submodule()
.
- log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)ΒΆ
- class qcodes.instrument_drivers.Keithley.Keithley2601B(name: str, address: str, **kwargs: Unpack[VisaInstrumentKWArgs])[source]ΒΆ
Bases:
Keithley2600
QCoDeS driver for the Keithley 2601B Source-Meter
- Parameters:
name β Name to use internally in QCoDeS
address β VISA resource address
**kwargs β kwargs are forwarded to base class.
- class qcodes.instrument_drivers.Keithley.Keithley2602A(name: str, address: str, **kwargs: Unpack[VisaInstrumentKWArgs])[source]ΒΆ
Bases:
Keithley2600
QCoDeS driver for the Keithley 2602A Source-Meter
- Parameters:
name β Name to use internally in QCoDeS
address β VISA resource address
**kwargs β kwargs are forwarded to base class.
- class qcodes.instrument_drivers.Keithley.Keithley2602B(name: str, address: str, **kwargs: Unpack[VisaInstrumentKWArgs])[source]ΒΆ
Bases:
Keithley2600
QCoDeS driver for the Keithley 2602B Source-Meter
- Parameters:
name β Name to use internally in QCoDeS
address β VISA resource address
**kwargs β kwargs are forwarded to base class.
- class qcodes.instrument_drivers.Keithley.Keithley2604B(name: str, address: str, **kwargs: Unpack[VisaInstrumentKWArgs])[source]ΒΆ
Bases:
Keithley2600
QCoDeS driver for the Keithley 2604B Source-Meter
- Parameters:
name β Name to use internally in QCoDeS
address β VISA resource address
**kwargs β kwargs are forwarded to base class.
- class qcodes.instrument_drivers.Keithley.Keithley2611B(name: str, address: str, **kwargs: Unpack[VisaInstrumentKWArgs])[source]ΒΆ
Bases:
Keithley2600
QCoDeS driver for the Keithley 2611B Source-Meter
- Parameters:
name β Name to use internally in QCoDeS
address β VISA resource address
**kwargs β kwargs are forwarded to base class.
- class qcodes.instrument_drivers.Keithley.Keithley2612B(name: str, address: str, **kwargs: Unpack[VisaInstrumentKWArgs])[source]ΒΆ
Bases:
Keithley2600
QCoDeS driver for the Keithley 2612B Source-Meter
- Parameters:
name β Name to use internally in QCoDeS
address β VISA resource address
**kwargs β kwargs are forwarded to base class.
- class qcodes.instrument_drivers.Keithley.Keithley2614B(name: str, address: str, **kwargs: Unpack[VisaInstrumentKWArgs])[source]ΒΆ
Bases:
Keithley2600
QCoDeS driver for the Keithley 2614B Source-Meter
- Parameters:
name β Name to use internally in QCoDeS
address β VISA resource address
**kwargs β kwargs are forwarded to base class.
- class qcodes.instrument_drivers.Keithley.Keithley2634B(name: str, address: str, **kwargs: Unpack[VisaInstrumentKWArgs])[source]ΒΆ
Bases:
Keithley2600
QCoDeS driver for the Keithley 2634B Source-Meter
- Parameters:
name β Name to use internally in QCoDeS
address β VISA resource address
**kwargs β kwargs are forwarded to base class.
- class qcodes.instrument_drivers.Keithley.Keithley2635B(name: str, address: str, **kwargs: Unpack[VisaInstrumentKWArgs])[source]ΒΆ
Bases:
Keithley2600
QCoDeS driver for the Keithley 2635B Source-Meter
- Parameters:
name β Name to use internally in QCoDeS
address β VISA resource address
**kwargs β kwargs are forwarded to base class.
- class qcodes.instrument_drivers.Keithley.Keithley2636B(name: str, address: str, **kwargs: Unpack[VisaInstrumentKWArgs])[source]ΒΆ
Bases:
Keithley2600
QCoDeS driver for the Keithley 2636B Source-Meter
- Parameters:
name β Name to use internally in QCoDeS
address β VISA resource address
**kwargs β kwargs are forwarded to base class.
- class qcodes.instrument_drivers.Keithley.Keithley3706A(name: str, address: str, **kwargs: Unpack[VisaInstrumentKWArgs])[source]ΒΆ
Bases:
VisaInstrument
This is the QCoDeS instrument driver for the Keithley 3706A-SNFP System Switch.
- Parameters:
name β Name to use internally in QCoDeS
address β VISA resource address
**kwargs β kwargs are forwarded to base class.
Attributes:
The default terminator to use if the terminator is not specified when creating the instrument.
Controls the connection rule for closing and opening channels when using exclusive_close and exclusive_slot_close parameters.
Enables or disables GPIB connection.
Sets and gets the GPIB address.
Enables or disables LAN connection.
Methods:
reset_channel
(val)Resets the specified channels to factory default settings.
open_channel
(val)Opens the specified channels and backplane relays.
close_channel
(val)Closes the channels and backplane relays.
exclusive_close
(val)Closes the specified channels such that any presently closed channels opens if they are not in the specified by the parameter.
exclusive_slot_close
(val)Closes the specified channels on the associated slots abd opens any other channels if they are not specified by the parameter.
get_closed_channels
(val)Queries for the closed channels.
Prevents the closing of specified channels and backplane relays.
Returns a string that lists the channels and backplane relays that are forbidden to close.
Clears the list of channels that are forbidden to close.
set_delay
(val, delay_time)Sets an additional delay time for the specified channels.
get_delay
(val)Queries for the delay times.
set_backplane
(val, backplane)Sets the analog backplane relays to use with given channels when they are used in switching applications.
get_backplane
(val)Lists the backplane relays that are controlled in switching applications for specified channels.
This function returns the name of the matrix channels.
get_channels_by_slot
(slot_no)Returns the channel names of a given slot.
Returns a list of comma separated strings representing available analog backplane relays.
connect_row_to_columns
(slot_id, row_id, columns)A convenient function that connects given columns to a row of a slot and opens the formed channels.
disconnect_row_from_columns
(slot_id, row_id, ...)A convenient function that disconnects given columns to a row of a slot and closes the formed channels.
connect_column_to_rows
(slot_id, column_id, rows)A convenient function that connects given rows to a column of a slot and opens the formed channels.
disconnect_column_from_rows
(slot_id, ...)A convenient function that disconnects given rows to a column of a slot and closes the formed channels.
get_idn
()Overwrites the generic QCoDeS get IDN method.
Returns a list of dictionaries listing the properties of the installed switch cards including the slot number tha it is installed, model, firmware version and serial number.
Returns the amount of memory that is currently available for storing scripts, configurations and channel patterns.
A function that collects the interlock status of the installed cards.
Returns the current IP address of the instrument.
Resets the local network (LAN).
save_setup
([val])Saves the present setup.
load_setup
(val)Loads the settings from a saved setup.
connect_message
([idn_param, begin_time])Overwrites the generic QCoDeS instrument connect message.
ask
(cmd)Override of normal ask.
- default_terminator: str | None = '\n'ΒΆ
The default terminator to use if the terminator is not specified when creating the instrument. None means use the default terminator from PyVisa.
- channel_connect_rule: Parameter = self.add_parameter( "channel_connect_rule", get_cmd=self._get_channel_connect_rule, set_cmd=self._set_channel_connect_rule, docstring=textwrap.dedent( """\ Controls the connection rule for closing and opening channels when using `exclusive_close` and `exclusive_slot_close` parameters. If it is set to break before make, it is ensured that all channels open before any channels close. If it is set to make before break, it is ensured that all channels close before any channels open. If it is off, channels open and close simultaneously.""" ), vals=vals.Enum("BREAK_BEFORE_MAKE", "MAKE_BEFORE_BREAK", "OFF"), )ΒΆ
Controls the connection rule for closing and opening channels when using exclusive_close and exclusive_slot_close parameters.
If it is set to break before make, it is ensured that all channels open before any channels close.
If it is set to make before break, it is ensured that all channels close before any channels open.
If it is off, channels open and close simultaneously.
- gpib_enabled: Parameter = self.add_parameter( "gpib_enabled", get_cmd=self._get_gpib_status, set_cmd=self._set_gpib_status, docstring="Enables or disables GPIB connection.", val_mapping=create_on_off_val_mapping(on_val="true", off_val="false"), )ΒΆ
Enables or disables GPIB connection.
- gpib_address: Parameter = self.add_parameter( "gpib_address", get_cmd=self._get_gpib_address, get_parser=int, set_cmd=self._set_gpib_address, docstring="Sets and gets the GPIB address.", vals=vals.Ints(1, 30), )ΒΆ
Sets and gets the GPIB address.
- lan_enabled: Parameter = self.add_parameter( "lan_enabled", get_cmd=self._get_lan_status, set_cmd=self._set_lan_status, docstring="Enables or disables LAN connection.", val_mapping=create_on_off_val_mapping(on_val="true", off_val="false"), )ΒΆ
Enables or disables LAN connection.
- reset_channel(val: str) None [source]ΒΆ
Resets the specified channels to factory default settings.
- Parameters:
val β A string representing the channels, channel ranges, backplane relays, slots or channel patterns to be queried.
- open_channel(val: str) None [source]ΒΆ
Opens the specified channels and backplane relays.
- Parameters:
val β A string representing the channels, channel ranges, backplane relays, slots or channel patterns to be queried.
- close_channel(val: str) None [source]ΒΆ
Closes the channels and backplane relays.
- Parameters:
val β A string representing the channels, channel ranges, backplane relays to be queried.
- exclusive_close(val: str) None [source]ΒΆ
Closes the specified channels such that any presently closed channels opens if they are not in the specified by the parameter.
- Parameters:
val β A string representing the channels, channel ranges, backplane relays to be queried.
- exclusive_slot_close(val: str) None [source]ΒΆ
Closes the specified channels on the associated slots abd opens any other channels if they are not specified by the parameter.
- Parameters:
val β A string representing the channels, channel ranges, backplane relays to be queried.
- get_closed_channels(val: str) list[str] | None [source]ΒΆ
Queries for the closed channels.
- Parameters:
val β A string representing the channels, backplane relays or channel patterns to be queried.
- set_forbidden_channels(val: str) None [source]ΒΆ
Prevents the closing of specified channels and backplane relays.
- Parameters:
val β A string representing channels and backplane relays to make forbidden to close.
- get_forbidden_channels(val: str) str [source]ΒΆ
Returns a string that lists the channels and backplane relays that are forbidden to close.
- Parameters:
val β A string representing the channels, backplane relays or channel patterns to be queried to see if they are forbidden to close.
- clear_forbidden_channels(val: str) None [source]ΒΆ
Clears the list of channels that are forbidden to close.
- Parameters:
val β A string representing the channels that will no longer be listed as forbidden to close.
- set_delay(val: str, delay_time: float) None [source]ΒΆ
Sets an additional delay time for the specified channels.
- Parameters:
val β A string representing the channels for which there will be an additional delay time.
delay_time β Delay time for the specified channels in seconds.
- get_delay(val: str) list[float] [source]ΒΆ
Queries for the delay times.
- Parameters:
val β A string representing the channels to query for additional delay times.
- set_backplane(val: str, backplane: str) None [source]ΒΆ
Sets the analog backplane relays to use with given channels when they are used in switching applications.
- Parameters:
val β A string representing the list of channels to change.
backplane β A string representing the list of analog backplane relays to set for the channels specified.
- get_backplane(val: str) str [source]ΒΆ
Lists the backplane relays that are controlled in switching applications for specified channels.
- Parameters:
val β A string representing the channels being queried.
- get_channels() list[str] [source]ΒΆ
This function returns the name of the matrix channels. User can call this function to see the names of the available channels, in case he/she is not familiar with the naming convention. However, note that, this is a standalone helper function and the usage of channel attributes of the instrument driver does not depend on the functionality of this method.
- get_channels_by_slot(slot_no: int) list[str] [source]ΒΆ
Returns the channel names of a given slot.
- Parameters:
slot_no β An integer value specifying the slot number.
- get_analog_backplane_specifiers() list[str] [source]ΒΆ
Returns a list of comma separated strings representing available analog backplane relays. This function should not be mixed with the get_backplane method. The latter returns backplane relays which are associated with a channel by using set_backplane method.
- connect_row_to_columns(slot_id: int, row_id: int, columns: list[int]) list[str] [source]ΒΆ
A convenient function that connects given columns to a row of a slot and opens the formed channels.
- Parameters:
slot_id β The specifier for the slot from which the row and columns will be selected.
row_id β The specifier for the row to which the provided columns will be connected.
columns β The specifiers of the columns will be connected to the provided row.
- disconnect_row_from_columns(slot_id: int, row_id: int, columns: list[int]) list[str] [source]ΒΆ
A convenient function that disconnects given columns to a row of a slot and closes the formed channels.
- Parameters:
slot_id β The specifier for the slot from which the row and columns will be selected.
row_id β The specifier for the row to which the provided columns will be disconnected.
columns β The specifiers of the columns will be disconnected from the provided row.
- connect_column_to_rows(slot_id: int, column_id: int, rows: list[int]) list[str] [source]ΒΆ
A convenient function that connects given rows to a column of a slot and opens the formed channels.
- Parameters:
slot_id β The specifier for the slot from which the row and columns will be selected.
column_id β The specifier for the column to which the provided rows will be connected.
rows β The specifiers of the rows will be connected to the provided column.
- disconnect_column_from_rows(slot_id: int, column_id: int, rows: list[int]) list[str] [source]ΒΆ
A convenient function that disconnects given rows to a column of a slot and closes the formed channels.
- Parameters:
slot_id β The specifier for the slot from which the row and columns will be selected.
column_id β The specifier for the column to which the provided rows will be disconnected.
rows β The specifiers of the rows will be disconnected from the provided column.
- get_idn() dict[str, str | None] [source]ΒΆ
Overwrites the generic QCoDeS get IDN method. Returns a dictionary including the vendor, model, serial number and firmware version of the instrument.
- get_switch_cards() tuple[dict[str, str], ...] [source]ΒΆ
Returns a list of dictionaries listing the properties of the installed switch cards including the slot number tha it is installed, model, firmware version and serial number.
- get_available_memory() dict[str, str | None] [source]ΒΆ
Returns the amount of memory that is currently available for storing scripts, configurations and channel patterns.
- get_interlock_state() tuple[dict[str, str], ...] [source]ΒΆ
A function that collects the interlock status of the installed cards. The channel relays can continue to operate even if the interlock in the corresponding slot is disengaged, one cannot perform measurements through the switching card, as the analog backplanes cannot be energized.
- save_setup(val: str | None = None) None [source]ΒΆ
Saves the present setup.
- Parameters:
val β An optional string representing the path and the file name to which the setup shall be saved on a USB flash drive. If not provided, the setup will be saved to the nonvolatile memory of the instrument, any previous saves will be overwritten.
- load_setup(val: int | str) None [source]ΒΆ
Loads the settings from a saved setup.
- Parameters:
val β An integer or a string that specifies the location of saved setup. If it is 0, factory defaults load. If it is 1, the saved setup from the nonvolatile memory is recalled. Otherwise, a string specifying the relative path to the saved setup on a USB drive should be passed in.
- visa_handle: pyvisa.resources.MessageBasedResource = visa_handleΒΆ
The VISA resource used by this instrument.
- 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 viaadd_submodule()
.
- log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)ΒΆ
- exception qcodes.instrument_drivers.Keithley.Keithley3706AUnknownOrEmptySlot[source]ΒΆ
Bases:
Exception
- class qcodes.instrument_drivers.Keithley.Keithley6500(name: str, address: str, reset_device: bool = False, **kwargs: Unpack[VisaInstrumentKWArgs])[source]ΒΆ
Bases:
VisaInstrument
Driver for the Keithley 6500 multimeter. Based on the Keithley 2000 driver, commands have been adapted for the Keithley 6500. This driver does not contain all commands available, but only the ones most commonly used.
Status: beta-version.
- Parameters:
name β The name used internally by QCoDeS in the DataSet.
address β The VISA device address.
reset_device β Reset the device on startup if true.
**kwargs β kwargs are forwarded to base class.
Attributes:
The default terminator to use if the terminator is not specified when creating the instrument.
Parameter mode
Parameter nplc
Parameter range
Parameter auto_range_enabled
Parameter digits
Parameter averaging_type
Parameter averaging_count
Parameter averaging_enabled
Control the brightness of the display backligt.
Parameter trigger_count
Parameter trigger_timer
Parameter amplitude
Methods:
reset
()Reset the device
- default_terminator: str | None = '\n'ΒΆ
The default terminator to use if the terminator is not specified when creating the instrument. None means use the default terminator from PyVisa.
- mode: Parameter = self.add_parameter( "mode", get_cmd="SENS:FUNC?", set_cmd="SENS:FUNC '{}'", val_mapping=self._mode_map, )ΒΆ
Parameter mode
- nplc: Parameter = self.add_parameter( "nplc", get_cmd=partial(self._get_mode_param, "NPLC", float), set_cmd=partial(self._set_mode_param, "NPLC"), vals=Numbers(min_value=0.01, max_value=10), )ΒΆ
Parameter nplc
- range: Parameter = self.add_parameter( "range", get_cmd=partial(self._get_mode_param, "RANG", float), set_cmd=partial(self._set_mode_param, "RANG"), vals=Numbers(), )ΒΆ
Parameter range
- auto_range_enabled: Parameter = self.add_parameter( "auto_range_enabled", get_cmd=partial(self._get_mode_param, "RANG:AUTO", _parse_output_bool), set_cmd=partial(self._set_mode_param, "RANG:AUTO"), vals=Bool(), )ΒΆ
Parameter auto_range_enabled
- digits: Parameter = self.add_parameter( "digits", get_cmd="DISP:VOLT:DC:DIG?", get_parser=int, set_cmd="DISP:VOLT:DC:DIG? {}", vals=Ints(min_value=4, max_value=7), )ΒΆ
Parameter digits
- averaging_type: Parameter = self.add_parameter( "averaging_type", get_cmd=partial(self._get_mode_param, "AVER:TCON", _parse_output_string), set_cmd=partial(self._set_mode_param, "AVER:TCON"), vals=Enum("moving", "repeat"), )ΒΆ
Parameter averaging_type
- averaging_count: Parameter = self.add_parameter( "averaging_count", get_cmd=partial(self._get_mode_param, "AVER:COUN", int), set_cmd=partial(self._set_mode_param, "AVER:COUN"), vals=Ints(min_value=1, max_value=100), )ΒΆ
Parameter averaging_count
- averaging_enabled: Parameter = self.add_parameter( "averaging_enabled", get_cmd=partial(self._get_mode_param, "AVER:STAT", _parse_output_bool), set_cmd=partial(self._set_mode_param, "AVER:STAT"), vals=Bool(), )ΒΆ
Parameter averaging_enabled
- visa_handle: pyvisa.resources.MessageBasedResource = visa_handleΒΆ
The VISA resource used by this instrument.
- 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 viaadd_submodule()
.
- log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)ΒΆ
- display_backlight: Parameter = self.add_parameter( "display_backlight", docstring="Control the brightness of the display " "backligt. Off turns the display off and" "Blackout also turns off indicators and " "key lights on the device.", get_cmd="DISP:LIGH:STAT?", set_cmd="DISP:LIGH:STAT {}", val_mapping={ "On 100": "ON100", "On 75": "ON75", "On 50": "ON50", "On 25": "ON25", "Off": "OFF", "Blackout": "BLACkout", }, )ΒΆ
Control the brightness of the display backligt. Off turns the display off andBlackout also turns off indicators and key lights on the device.
- trigger_count: Parameter = self.add_parameter( "trigger_count", get_parser=int, get_cmd="ROUT:SCAN:COUN:SCAN?", set_cmd="ROUT:SCAN:COUN:SCAN {}", vals=MultiType( Ints(min_value=1, max_value=9999), Enum("inf", "default", "minimum", "maximum"), ), )ΒΆ
Parameter trigger_count
- trigger_timer: Parameter = self.add_parameter( "trigger_timer", get_parser=float, get_cmd="ROUT:SCAN:INT?", set_cmd="ROUT:SCAN:INT {}", unit="s", vals=Numbers(min_value=0, max_value=999999.999), )ΒΆ
Parameter trigger_timer
- class qcodes.instrument_drivers.Keithley.Keithley7510(name: str, address: str, **kwargs: Unpack[VisaInstrumentKWArgs])[source]ΒΆ
Bases:
VisaInstrument
The QCoDeS driver for the Keithley 7510 DMM
Create an instance of the instrument.
- Parameters:
name β Name of the instrument instance
address β Visa-resolvable instrument address
**kwargs β kwargs are forwarded to base class.
Attributes:
The default terminator to use if the terminator is not specified when creating the instrument.
Add sense functions listed in the function modes.
Make readings using the active digitize function.
Name of the reading buffer in use.
Return the settings for all trigger model blocks.
Clear the trigger event on the external in line.
Type of edge that is detected as an input on the external trigger in line
Return the event detector overrun status.
Set the instrument to digitize a measurement the next time it detects the specified trigger event.
Return the oldest unread error message from the event log and removes it from the log.
We have different sense modules depending on the sense function.
We have different sense modules depending on the sense function.
Methods:
buffer
(name[, size, style])initiate
()This command starts the trigger model.
wait
()This command postpones the execution of subsequent commands until all previous overlapped commands are finished.
This command clears the event registers of the Questionable Event and Operation Event Register set.
reset
()Returns the instrument to default settings, cancels all pending commands.
- visa_handle: pyvisa.resources.MessageBasedResource = visa_handleΒΆ
The VISA resource used by this instrument.
- 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 viaadd_submodule()
.
- log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)ΒΆ
- default_terminator: str | None = '\n'ΒΆ
The default terminator to use if the terminator is not specified when creating the instrument. None means use the default terminator from PyVisa.
- sense_function: Parameter = self.add_parameter( "sense_function", set_cmd=":SENSe:FUNCtion {}", get_cmd=":SENSe:FUNCtion?", val_mapping={ key: value["name"] for key, value in Keithley7510Sense.function_modes.items() }, docstring="Add sense functions listed in the function modes.", )ΒΆ
Add sense functions listed in the function modes.
- digi_sense_function: Parameter = self.add_parameter( "digi_sense_function", set_cmd=":DIGitize:FUNCtion {}", get_cmd=":DIGitize:FUNCtion?", val_mapping={ key: value["name"] for key, value in Keithley7510DigitizeSense.function_modes.items() }, docstring="Make readings using the active digitize function.", )ΒΆ
Make readings using the active digitize function.
- buffer_name: Parameter = self.add_parameter( "buffer_name", get_cmd=None, set_cmd=None, docstring="Name of the reading buffer in use.", )ΒΆ
Name of the reading buffer in use.
- trigger_block_list: Parameter = self.add_parameter( "trigger_block_list", get_cmd=":TRIGger:BLOCk:LIST?", docstring="Return the settings for all trigger model blocks.", )ΒΆ
Return the settings for all trigger model blocks.
- trigger_in_ext_clear: Parameter = self.add_parameter( "trigger_in_ext_clear", set_cmd=":TRIGger:EXTernal:IN:CLEar", docstring="Clear the trigger event on the external in line.", )ΒΆ
Clear the trigger event on the external in line.
- trigger_in_ext_edge: Parameter = self.add_parameter( "trigger_in_ext_edge", get_cmd=":TRIGger:EXTernal:IN:EDGE?", set_cmd=":TRIGger:EXTernal:IN:EDGE {}", vals=Enum("FALL", "RIS", "falling", "rising", "EITH", "either"), docstring="Type of edge that is detected as an input on the " "external trigger in line", )ΒΆ
Type of edge that is detected as an input on the external trigger in line
- overrun_status: Parameter = self.add_parameter( "overrun_status", get_cmd=":TRIGger:EXTernal:IN:OVERrun?", docstring="Return the event detector overrun status.", )ΒΆ
Return the event detector overrun status.
- digitize_trigger: Parameter = self.add_parameter( "digitize_trigger", get_cmd=":TRIGger:DIGitize:STIMulus?", set_cmd=":TRIGger:DIGitize:STIMulus {}", vals=Enum("EXT", "external", "NONE"), docstring="Set the instrument to digitize a measurement the next " "time it detects the specified trigger event.", )ΒΆ
Set the instrument to digitize a measurement the next time it detects the specified trigger event.
- system_errors: Parameter = self.add_parameter( "system_errors", get_cmd=":SYSTem:ERRor?", docstring="Return the oldest unread error message from the event " "log and removes it from the log.", )ΒΆ
Return the oldest unread error message from the event log and removes it from the log.
- property sense: Keithley7510SenseΒΆ
We have different sense modules depending on the sense function.
Return the correct source module based on the sense function.
- property digi_sense: Keithley7510DigitizeSenseΒΆ
We have different sense modules depending on the sense function.
Return the correct source module based on the sense function.
- wait() None [source]ΒΆ
This command postpones the execution of subsequent commands until all previous overlapped commands are finished.
- class qcodes.instrument_drivers.Keithley.Keithley7510Buffer(parent: Keithley7510, name: str, size: int | None = None, style: str = '')[source]ΒΆ
Bases:
InstrumentChannel
Treat the reading buffer as a submodule, similar to Sense.
Attributes:
The number of readings a buffer can store.
Get the number of readings in the reading buffer.
Get the last index of readings in the reading buffer.
Get the starting index of readings in the reading buffer.
First index of the data to be returned.
Last index of the data to be returned.
List of buffer elements to read.
Parameter setpoints_start
Parameter setpoints_stop
Parameter n_pts
Parameter setpoints
Parameter t_start
Parameter t_stop
if a reading buffer is filled continuously or is filled once and stops
Methods:
set_setpoints
(start, stop[, label])This method requests the latest reading from a reading buffer.
Clear the data in the buffer
This method makes readings using the active measure function and stores them in a reading buffer.
delete
()- buffer_elements: ClassVar[dict[str, str]] = {'date': 'DATE', 'fractional_seconds': 'FRACtional', 'measurement': 'READing', 'measurement_formatted': 'FORMatted', 'measurement_status': 'STATus', 'measurement_unit': 'UNIT', 'relative_time': 'RELative', 'seconds': 'SEConds', 'time': 'TIME', 'timestamp': 'TSTamp'}ΒΆ
- inverted_buffer_elements = {'DATE': 'date', 'FORMatted': 'measurement_formatted', 'FRACtional': 'fractional_seconds', 'READing': 'measurement', 'RELative': 'relative_time', 'SEConds': 'seconds', 'STATus': 'measurement_status', 'TIME': 'time', 'TSTamp': 'timestamp', 'UNIT': 'measurement_unit'}ΒΆ
- size: Parameter = self.add_parameter( "size", get_cmd=f":TRACe:POINts? '{self.short_name}'", set_cmd=f":TRACe:POINts {{}}, '{self.short_name}'", get_parser=int, docstring="The number of readings a buffer can store.", )ΒΆ
The number of readings a buffer can store.
- number_of_readings: Parameter = self.add_parameter( "number_of_readings", get_cmd=f":TRACe:ACTual? '{self.short_name}'", get_parser=int, docstring="Get the number of readings in the reading buffer.", )ΒΆ
Get the number of readings in the reading buffer.
- last_index: Parameter = self.add_parameter( "last_index", get_cmd=f":TRACe:ACTual:END? '{self.short_name}'", get_parser=int, docstring="Get the last index of readings in the reading buffer.", )ΒΆ
Get the last index of readings in the reading buffer.
- first_index: Parameter = self.add_parameter( "first_index", get_cmd=f":TRACe:ACTual:STARt? '{self.short_name}'", get_parser=int, docstring="Get the starting index of readings in the reading buffer.", )ΒΆ
Get the starting index of readings in the reading buffer.
- data_start: Parameter = self.add_parameter( "data_start", initial_value=1, get_cmd=None, set_cmd=None, docstring="First index of the data to be returned.", )ΒΆ
First index of the data to be returned.
- data_end: Parameter = self.add_parameter( "data_end", initial_value=1, get_cmd=None, set_cmd=None, docstring="Last index of the data to be returned.", )ΒΆ
Last index of the data to be returned.
- elements: Parameter = self.add_parameter( "elements", get_cmd=None, get_parser=self._from_scpi_to_name, set_cmd=None, set_parser=self._from_name_to_scpi, vals=Lists(Enum(*list(self.buffer_elements.keys()))), docstring="List of buffer elements to read.", )ΒΆ
List of buffer elements to read.
- setpoints_start: DelegateParameter = self.add_parameter( "setpoints_start", label="start value for the setpoints", source=None, parameter_class=DelegateParameter, )ΒΆ
Parameter setpoints_start
- setpoints_stop: DelegateParameter = self.add_parameter( "setpoints_stop", label="stop value for the setpoints", source=None, parameter_class=DelegateParameter, )ΒΆ
Parameter setpoints_stop
- n_pts: Parameter = self.add_parameter( "n_pts", label="total n for the setpoints", get_cmd=self._get_n_pts )ΒΆ
Parameter n_pts
- setpoints: GeneratedSetPoints = self.add_parameter( "setpoints", parameter_class=GeneratedSetPoints, start=self.setpoints_start, stop=self.setpoints_stop, n_points=self.n_pts, vals=Arrays(shape=(self.n_pts.get_latest,)), )ΒΆ
Parameter setpoints
- t_start: Parameter = self.add_parameter( "t_start", label="start time", unit="s", initial_value=0, get_cmd=None, set_cmd=None, set_parser=float, )ΒΆ
Parameter t_start
- t_stop: Parameter = self.add_parameter( "t_stop", label="stop time", unit="s", initial_value=1, get_cmd=None, set_cmd=None, set_parser=float, )ΒΆ
Parameter t_stop
- fill_mode: Parameter = self.add_parameter( "fill_mode", get_cmd=f":TRACe:FILL:MODE? '{self.short_name}'", set_cmd=f":TRACe:FILL:MODE {{}}, '{self.short_name}'", vals=Enum("CONT", "continuous", "ONCE", "once"), docstring="if a reading buffer is filled continuously or is filled" " once and stops", )ΒΆ
if a reading buffer is filled continuously or is filled once and stops
- property data: DataArray7510ΒΆ
- trigger_start() None [source]ΒΆ
This method makes readings using the active measure function and stores them in a reading 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 viaadd_submodule()
.
- log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)ΒΆ
- class qcodes.instrument_drivers.Keithley.Keithley7510DigitizeSense(parent: VisaInstrument, name: str, proper_function: str)[source]ΒΆ
Bases:
InstrumentChannel
The Digitize sense module of the Keithley 7510 DMM.
Attributes:
Determine the positive full-scale measure range.
Determine when the 10 MΞ© input divider is enabled.
Define the precise acquisition rate at which the digitizing measurements are made.
Determine the aperture setting.
Set the number of measurements to digitize when a measurement is requested
- function_modes: ClassVar[dict[str, _FunctionMode]] = {'None': {'name': '"NONE"', 'range_vals': None, 'unit': ''}, 'current': {'name': '"CURR"', 'range_vals': <Numbers 1e-05<=v<=10>, 'unit': 'V'}, 'voltage': {'name': '"VOLT"', 'range_vals': <Numbers 0.1<=v<=1000>, 'unit': 'V'}}ΒΆ
- 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 viaadd_submodule()
.
- log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)ΒΆ
- range: Parameter = self.add_parameter( "range", get_cmd=f":SENSe:DIGitize:{self._proper_function}:RANGe?", set_cmd=f":SENSe:DIGitize:{self._proper_function}:RANGe {{}}", vals=range_vals, get_parser=float, unit=unit, docstring="Determine the positive full-scale measure range.", )ΒΆ
Determine the positive full-scale measure range.
- input_impedance: Parameter = self.add_parameter( "input_impedance", get_cmd=":SENSe:DIGitize:VOLTage:INPutimpedance?", set_cmd=":SENSe:DIGitize:VOLTage:INPutimpedance {}", vals=Enum("AUTO", "MOHM10"), docstring="Determine when the 10 MΞ© input divider is enabled. " "'MOHM10' means 10 MΞ© for all ranges.", )ΒΆ
Determine when the 10 MΞ© input divider is enabled. βMOHM10β means 10 MΞ© for all ranges.
- acq_rate: Parameter = self.add_parameter( "acq_rate", get_cmd=f":SENSe:DIGitize:{self._proper_function}:SRATE?", set_cmd=f":SENSe:DIGitize:{self._proper_function}:SRATE {{}}", vals=Ints(1000, 1000000), docstring="Define the precise acquisition rate at which the " "digitizing measurements are made.", )ΒΆ
Define the precise acquisition rate at which the digitizing measurements are made.
- aperture: Parameter = self.add_parameter( "aperture", get_cmd=f":SENSe:DIGitize:{self._proper_function}:APERture?", set_cmd=f":SENSe:DIGitize:{self._proper_function}:APERture {{}}", unit="us", docstring="Determine the aperture setting.", )ΒΆ
Determine the aperture setting.
- count: Parameter = self.add_parameter( "count", get_cmd="SENSe:DIGitize:COUNt?", set_cmd="SENSe:DIGitize:COUNt {}", vals=Ints(1, 55000000), docstring="Set the number of measurements to digitize when a " "measurement is requested", )ΒΆ
Set the number of measurements to digitize when a measurement is requested
- class qcodes.instrument_drivers.Keithley.Keithley7510Sense(parent: VisaInstrument, name: str, proper_function: str, **kwargs: Unpack[InstrumentBaseKWArgs])[source]ΒΆ
Bases:
InstrumentChannel
The sense module of the Keithley 7510 DMM, based on the sense module of Keithley 2450 SMU.
All parameters and methods in this submodule should only be accessible to the user if self.parent.sense_function.get() == self._proper_function. We ensure this through the βsenseβ property on the main driver class which returns the proper submodule for any given function mode.
- Parameters:
parent β Parent instrument.
name β Name of the channel.
proper_function β This can be one of modes listed in the dictionary βfunction_modesβ, e.g., βcurrentβ, βvoltageβ, or βresistanceβ. βvoltageβ/βcurrentβ is for DC voltage/current. βAvoltageβ/βAcurrentβ is for AC voltage/current. βresistanceβ is for two-wire measurement of resistance. βFresistanceβ is for Four-wire measurement of resistance.
**kwargs β Forwarded to base class.
Attributes:
Determine if the measurement range is set manually or automatically for the selected measure function.
Determine the positive full-scale measure range.
Set the time that the input signal is measured for the selected function.(NPLC = number of power line cycles)
Enable or disable the automatic delay that occurs before each measurement.
Set the user number for user-defined delay.
Set a user-defined delay that you can use in the trigger model.
Enable or disable automatic updates to the internal reference measurements (autozero) of the instrument.
Cause the instrument to refresh the reference and zero measurements once
Enable or disable the averaging filter for measurements of the selected function.
Set the number of measurements that are averaged when filtering is enabled.
Set the type of averaging filter that is used for the selected measure function when the measurement filter is enabled.
Methods:
clear_trace
([buffer_name])Clear the data buffer
- function_modes: ClassVar[dict[str, _FunctionMode]] = {'Acurrent': {'name': '"CURR:AC"', 'range_vals': <Numbers 0.001<=v<=10>, 'unit': 'A'}, 'Avoltage': {'name': '"VOLT:AC"', 'range_vals': <Numbers 0.1<=v<=700>, 'unit': 'V'}, 'Fresistance': {'name': '"FRES"', 'range_vals': <Numbers 1<=v<=1000000000.0>, 'unit': 'Ohm'}, 'current': {'name': '"CURR:DC"', 'range_vals': <Numbers 1e-05<=v<=10>, 'unit': 'V'}, 'resistance': {'name': '"RES"', 'range_vals': <Numbers 10<=v<=1000000000.0>, 'unit': 'Ohm'}, 'voltage': {'name': '"VOLT:DC"', 'range_vals': <Numbers 0.1<=v<=1000>, 'unit': 'V'}}ΒΆ
- auto_range: Parameter = self.add_parameter( "auto_range", get_cmd=f":SENSe:{self._proper_function}:RANGe:AUTO?", set_cmd=f":SENSe:{self._proper_function}:RANGe:AUTO {{}}", val_mapping=create_on_off_val_mapping(on_val="1", off_val="0"), docstring="Determine if the measurement range is set manually or " "automatically for the selected measure function.", )ΒΆ
Determine if the measurement range is set manually or automatically for the selected measure function.
- range: Parameter = self.add_parameter( "range", get_cmd=f":SENSe:{self._proper_function}:RANGe?", set_cmd=f":SENSe:{self._proper_function}:RANGe {{}}", vals=range_vals, get_parser=float, unit=unit, docstring="Determine the positive full-scale measure range.", )ΒΆ
Determine the positive full-scale measure range.
- nplc: Parameter = self.add_parameter( "nplc", get_cmd=f":SENSe:{self._proper_function}:NPLCycles?", set_cmd=f":SENSe:{self._proper_function}:NPLCycles {{}}", vals=Numbers(0.01, 10), get_parser=float, docstring="Set the time that the input signal is measured for the " "selected function.(NPLC = number of power line cycles)", )ΒΆ
Set the time that the input signal is measured for the selected function.(NPLC = number of power line cycles)
- auto_delay: Parameter = self.add_parameter( "auto_delay", get_cmd=f":SENSe:{self._proper_function}:DELay:AUTO?", set_cmd=f":SENSe:{self._proper_function}:DELay:AUTO {{}}", val_mapping=create_on_off_val_mapping(on_val="ON", off_val="OFF"), docstring="Enable or disable the automatic delay that occurs " "before each measurement.", )ΒΆ
Enable or disable the automatic delay that occurs before each measurement.
- user_number: Parameter = self.add_parameter( "user_number", get_cmd=None, set_cmd=None, vals=Ints(1, 5), docstring="Set the user number for user-defined delay.", )ΒΆ
Set the user number for user-defined delay.
- user_delay: Parameter = self.add_parameter( "user_delay", get_cmd=self._get_user_delay, set_cmd=self._set_user_delay, vals=Numbers(0, 1e4), unit="second", docstring="Set a user-defined delay that you can use in the " "trigger model.", )ΒΆ
Set a user-defined delay that you can use in the trigger model.
- auto_zero: Parameter = self.add_parameter( "auto_zero", get_cmd=f":SENSe:{self._proper_function}:AZERo?", set_cmd=f":SENSe:{self._proper_function}:AZERo {{}}", val_mapping=create_on_off_val_mapping(on_val="1", off_val="0"), docstring="Enable or disable automatic updates to the internal " "reference measurements (autozero) of the instrument.", )ΒΆ
Enable or disable automatic updates to the internal reference measurements (autozero) of the instrument.
- auto_zero_once: Parameter = self.add_parameter( "auto_zero_once", set_cmd=":SENSe:AZERo:ONCE", docstring="Cause the instrument to refresh the reference and " "zero measurements once", )ΒΆ
Cause the instrument to refresh the reference and zero measurements once
- average: Parameter = self.add_parameter( "average", get_cmd=f":SENSe:{self._proper_function}:AVERage?", set_cmd=f":SENSe:{self._proper_function}:AVERage {{}}", val_mapping=create_on_off_val_mapping(on_val="1", off_val="0"), docstring="Enable or disable the averaging filter for measurements " "of the selected function.", )ΒΆ
Enable or disable the averaging filter for measurements of the selected function.
- average_count: Parameter = self.add_parameter( "average_count", get_cmd=f":SENSe:{self._proper_function}:AVERage:COUNt?", set_cmd=f":SENSe:{self._proper_function}:AVERage:COUNt {{}}", vals=Numbers(1, 100), docstring="Set the number of measurements that are averaged when " "filtering is enabled.", )ΒΆ
Set the number of measurements that are averaged when filtering is enabled.
- average_type: Parameter = self.add_parameter( "average_type", get_cmd=f":SENSe:{self._proper_function}:AVERage:TCONtrol?", set_cmd=f":SENSe:{self._proper_function}:AVERage:TCONtrol {{}}", vals=Enum("REP", "rep", "MOV", "mov"), docstring="Set the type of averaging filter that is used for the " "selected measure function when the measurement filter " "is enabled.", )ΒΆ
Set the type of averaging filter that is used for the selected measure function when the measurement filter is enabled.
- 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 viaadd_submodule()
.
- log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)ΒΆ
- class qcodes.instrument_drivers.Keithley.KeithleyS46(name: str, address: str, **kwargs: Unpack[VisaInstrumentKWArgs])[source]ΒΆ
Bases:
VisaInstrument
Attributes:
The default terminator to use if the terminator is not specified when creating the instrument.
Parameter closed_channels
The relay layout tells us how many channels we have per relay.
Methods:
- channel_numbers: ClassVar[dict[str, int]] = {'A1': 1, 'A2': 2, 'A3': 3, 'A4': 4, 'A5': 5, 'A6': 6, 'B1': 7, 'B2': 8, 'B3': 9, 'B4': 10, 'B5': 11, 'B6': 12, 'C1': 13, 'C2': 14, 'C3': 15, 'C4': 16, 'C5': 17, 'C6': 18, 'D1': 19, 'D2': 20, 'D3': 21, 'D4': 22, 'D5': 23, 'D6': 24, 'R1': 25, 'R2': 26, 'R3': 27, 'R4': 28, 'R5': 29, 'R6': 30, 'R7': 31, 'R8': 32}ΒΆ
- aliases: ClassVar[dict[int, str]] = {1: 'A1', 2: 'A2', 3: 'A3', 4: 'A4', 5: 'A5', 6: 'A6', 7: 'B1', 8: 'B2', 9: 'B3', 10: 'B4', 11: 'B5', 12: 'B6', 13: 'C1', 14: 'C2', 15: 'C3', 16: 'C4', 17: 'C5', 18: 'C6', 19: 'D1', 20: 'D2', 21: 'D3', 22: 'D4', 23: 'D5', 24: 'D6', 25: 'R1', 26: 'R2', 27: 'R3', 28: 'R4', 29: 'R5', 30: 'R6', 31: 'R7', 32: 'R8'}ΒΆ
- default_terminator: str | None = '\n'ΒΆ
The default terminator to use if the terminator is not specified when creating the instrument. None means use the default terminator from PyVisa.
- property relay_layout: list[int]ΒΆ
The relay layout tells us how many channels we have per relay. Note that we can have zero channels per relay.
- visa_handle: pyvisa.resources.MessageBasedResource = visa_handleΒΆ
The VISA resource used by this instrument.
- 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 viaadd_submodule()
.
- log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)ΒΆ
- exception qcodes.instrument_drivers.Keithley.KeithleyS46LockAcquisitionError[source]ΒΆ
Bases:
Exception
- class qcodes.instrument_drivers.Keithley.KeithleyS46RelayLock(relay_name: str)[source]ΒΆ
Bases:
object
The S46 either has six pole or a four pole relays. For example, channels βA1β to βA6β are all on relay βAβ. However, channels βR1β to βR8β are all on individual relays.
Only one channel per relay may be closed at any given time to prevent degradation of RF performance and even switch damage. See page 2-11 of the manual. To enforce this, a lock mechanism has been implemented.
Methods: