Yokogawa Drivers

Classes:

`YokogawaGS200`(name, address, **kwargs)	QCoDeS driver for the Yokogawa GS200 voltage and current source.
`YokogawaGS200Monitor`(parent, name, present, ...)	Monitor part of the GS200.
`YokogawaGS200Program`(parent, name, **kwargs)

Exceptions:

YokogawaGS200Exception

class qcodes.instrument_drivers.yokogawa.YokogawaGS200(name: str, address: str, **kwargs: Unpack[VisaInstrumentKWArgs])[source]

Bases: VisaInstrument

QCoDeS driver for the Yokogawa GS200 voltage and current source.

Parameters:

name – What this instrument is called locally.
address – The GPIB or USB address of this instrument
kwargs – kwargs to be passed to VisaInstrument class

Attributes:

`default_terminator`	The default terminator to use if the terminator is not specified when creating the instrument.
`output`	Parameter output
`source_mode`	Parameter source_mode
`voltage_range`	Parameter voltage_range
`current_range`	Parameter current_range
`range`	Parameter range
`auto_range`	Parameter auto_range
`voltage`	Parameter voltage
`current`	Parameter current
`output_level`	Parameter output_level
`voltage_limit`	Parameter voltage_limit
`current_limit`	Parameter current_limit
`four_wire`	Parameter four_wire
`guard`	Parameter guard
`line_freq`	Parameter line_freq
`BNC_out`	Sets or queries the output BNC signal
`BNC_in`	Sets or queries the input BNC signal
`system_errors`	returns the oldest unread error message from the event log and removes it from the log.

Methods:

`on`()	Turn output on
`off`()	Turn output off
`state`()	Check state
`ramp_voltage`(ramp_to, step, delay)	Ramp the voltage from the current level to the specified output.
`ramp_current`(ramp_to, step, delay)	Ramp the current from the current level to the specified output.

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.

output: Parameter = self.add_parameter( "output", label="Output State", get_cmd=self.state, set_cmd=lambda x: self.on() if x else self.off(), val_mapping={ "off": 0, "on": 1, }, ): Parameter output

source_mode: Parameter = self.add_parameter( "source_mode", label="Source Mode", get_cmd=":SOUR:FUNC?", set_cmd=self._set_source_mode, vals=Enum("VOLT", "CURR"), ): Parameter source_mode

voltage_range: Parameter = self.add_parameter( "voltage_range", label="Voltage Source Range", unit="V", get_cmd=partial(self._get_range, "VOLT"), set_cmd=partial(self._set_range, "VOLT"), vals=Enum(10e-3, 100e-3, 1e0, 10e0, 30e0), snapshot_exclude=self.source_mode() == "CURR", ): Parameter voltage_range

current_range: Parameter = self.add_parameter( "current_range", label="Current Source Range", unit="I", get_cmd=partial(self._get_range, "CURR"), set_cmd=partial(self._set_range, "CURR"), vals=Enum(1e-3, 10e-3, 100e-3, 200e-3), snapshot_exclude=self.source_mode() == "VOLT", ): Parameter current_range

range: DelegateParameter = self.add_parameter( "range", parameter_class=DelegateParameter, source=None ): Parameter range

auto_range: Parameter = self.add_parameter( "auto_range", label="Auto Range", set_cmd=self._set_auto_range, get_cmd=None, initial_cache_value=False, vals=Bool(), ): Parameter auto_range

voltage: Parameter = self.add_parameter( "voltage", label="Voltage", unit="V", set_cmd=partial(self._get_set_output, "VOLT"), get_cmd=partial(self._get_set_output, "VOLT"), snapshot_exclude=self.source_mode() == "CURR", ): Parameter voltage

current: Parameter = self.add_parameter( "current", label="Current", unit="I", set_cmd=partial(self._get_set_output, "CURR"), get_cmd=partial(self._get_set_output, "CURR"), snapshot_exclude=self.source_mode() == "VOLT", ): Parameter current

output_level: DelegateParameter = self.add_parameter( "output_level", parameter_class=DelegateParameter, source=None ): Parameter output_level

visabackend: str = visabackend

visa_handle: pyvisa.resources.MessageBasedResource = visa_handle: The VISA resource used by this instrument.

visalib: str | None = visalib

parameters: dict[str, ParameterBase] = {}: All the parameters supported by this instrument. Usually populated via add_parameter().

functions: dict[str, Function] = {}: All the functions supported by this instrument. Usually populated via add_function().

submodules: dict[str, InstrumentModule | ChannelTuple] = {}: All the submodules of this instrument such as channel lists or logical groupings of parameters. Usually populated via add_submodule().

instrument_modules: dict[str, InstrumentModule] = {}: All the InstrumentModule of this instrument Usually populated via add_submodule().

log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)

metadata: dict[str, Any] = {}

voltage_limit: Parameter = self.add_parameter( "voltage_limit", label="Voltage Protection Limit", unit="V", vals=Ints(1, 30), get_cmd=":SOUR:PROT:VOLT?", set_cmd=":SOUR:PROT:VOLT {}", get_parser=_float_round, set_parser=int, ): Parameter voltage_limit

current_limit: Parameter = self.add_parameter( "current_limit", label="Current Protection Limit", unit="I", vals=Numbers(1e-3, 200e-3), get_cmd=":SOUR:PROT:CURR?", set_cmd=":SOUR:PROT:CURR {:.3f}", get_parser=float, set_parser=float, ): Parameter current_limit

four_wire: Parameter = self.add_parameter( "four_wire", label="Four Wire Sensing", get_cmd=":SENS:REM?", set_cmd=":SENS:REM {}", val_mapping={ "off": 0, "on": 1, }, ): Parameter four_wire

guard: Parameter = self.add_parameter( "guard", label="Guard Terminal", get_cmd=":SENS:GUAR?", set_cmd=":SENS:GUAR {}", val_mapping={"off": 0, "on": 1}, ): Parameter guard

line_freq: Parameter = self.add_parameter( "line_freq", label="Line Frequency", unit="Hz", get_cmd="SYST:LFR?", get_parser=int, ): Parameter line_freq

BNC_out: Parameter = self.add_parameter( "BNC_out", label="BNC trigger out", get_cmd=":ROUT:BNCO?", set_cmd=":ROUT:BNCO {}", vals=Enum("trigger", "output", "ready"), docstring="Sets or queries the output BNC signal", ): Sets or queries the output BNC signal

BNC_in: Parameter = self.add_parameter( "BNC_in", label="BNC trigger in", get_cmd=":ROUT:BNCI?", set_cmd=":ROUT:BNCI {}", vals=Enum("trigger", "output"), docstring="Sets or queries the input BNC signal", ): Sets or queries the input BNC signal

system_errors: Parameter = self.add_parameter( "system_errors", get_cmd=":SYSTem:ERRor?", docstring="returns the oldest unread error message from the event " "log and removes it from the log.", ): returns the oldest unread error message from the event log and removes it from the log.

on() → None[source]: Turn output on

off() → None[source]: Turn output off

state() → int[source]: Check state

ramp_voltage(ramp_to: float, step: float, delay: float) → None[source]

Ramp the voltage from the current level to the specified output.

Parameters:

ramp_to – The ramp target in Volt
step – The ramp steps in Volt
delay – The time between finishing one step and starting another in seconds.

ramp_current(ramp_to: float, step: float, delay: float) → None[source]

Ramp the current from the current level to the specified output.

Parameters:

ramp_to – The ramp target in Ampere
step – The ramp steps in Ampere
delay – The time between finishing one step and starting another in seconds.

exception qcodes.instrument_drivers.yokogawa.YokogawaGS200Exception[source]: Bases: Exception

class qcodes.instrument_drivers.yokogawa.YokogawaGS200Monitor(parent: YokogawaGS200, name: str, present: bool, **kwargs: Unpack[InstrumentBaseKWArgs])[source]

Bases: InstrumentChannel

Monitor part of the GS200. This is only enabled if it is installed in the GS200 (it is an optional extra).

The units will be automatically updated as required.

To measure: GS200.measure.measure()

Parameters:

parent (GS200)
name – instrument name
present

Attributes:

`enabled`	Parameter enabled
`measure`	Parameter measure
`NPLC`	Parameter NPLC
`delay`	Parameter delay
`trigger`	Parameter trigger
`interval`	Parameter interval

Methods:

`off`()	Turn measurement off
`on`()	Turn measurement on
`state`()	Check measurement state
`update_measurement_enabled`(unit, output_range)

enabled: Parameter: Parameter enabled

measure: Parameter: Parameter measure

NPLC: Parameter: Parameter NPLC

delay: Parameter: Parameter delay

trigger: Parameter: Parameter trigger

interval: Parameter: Parameter interval

off() → None[source]: Turn measurement off

on() → None[source]: Turn measurement on

state() → int[source]: Check measurement state

update_measurement_enabled(unit: Literal['CURR', 'VOLT'], output_range: float) → None[source]

Parameters:

unit – Unit to update either VOLT or CURR.
output_range – new range.

parameters: dict[str, ParameterBase] = {}: All the parameters supported by this instrument. Usually populated via add_parameter().

functions: dict[str, Function] = {}: All the functions supported by this instrument. Usually populated via add_function().

submodules: dict[str, InstrumentModule | ChannelTuple] = {}: All the submodules of this instrument such as channel lists or logical groupings of parameters. Usually populated via add_submodule().

instrument_modules: dict[str, InstrumentModule] = {}: All the InstrumentModule of this instrument Usually populated via add_submodule().

log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)

metadata: dict[str, Any] = {}

class qcodes.instrument_drivers.yokogawa.YokogawaGS200Program(parent: YokogawaGS200, name: str, **kwargs: Unpack[InstrumentBaseKWArgs])[source]

Bases: InstrumentChannel

Attributes:

`interval`	Parameter interval
`slope`	Parameter slope
`trigger`	Parameter trigger
`save`	save the program to the system memory (.csv file)
`load`	load the program (.csv file) from the system memory
`repeat`	Parameter repeat
`count`	Parameter count

interval: Parameter = self.add_parameter( "interval", label="the program interval time", unit="s", vals=Numbers(0.1, 3600.0), get_cmd=":PROG:INT?", set_cmd=":PROG:INT {}", ): Parameter interval

slope: Parameter = self.add_parameter( "slope", label="the program slope time", unit="s", vals=Numbers(0.1, 3600.0), get_cmd=":PROG:SLOP?", set_cmd=":PROG:SLOP {}", ): Parameter slope

trigger: Parameter = self.add_parameter( "trigger", label="the program trigger", get_cmd=":PROG:TRIG?", set_cmd=":PROG:TRIG {}", vals=Enum("normal", "mend"), ): Parameter trigger

save: Parameter = self.add_parameter( "save", set_cmd=":PROG:SAVE '{}'", docstring="save the program to the system memory (.csv file)", ): save the program to the system memory (.csv file)

load: Parameter = self.add_parameter( "load", get_cmd=":PROG:LOAD?", set_cmd=":PROG:LOAD '{}'", docstring="load the program (.csv file) from the system memory", ): load the program (.csv file) from the system memory

repeat: Parameter = self.add_parameter( "repeat", label="program execution repetition", get_cmd=":PROG:REP?", set_cmd=":PROG:REP {}", val_mapping={"OFF": 0, "ON": 1}, ): Parameter repeat

count: Parameter = self.add_parameter( "count", label="step of the current program", get_cmd=":PROG:COUN?", set_cmd=":PROG:COUN {}", vals=Ints(1, 10000), ): Parameter count

parameters: dict[str, ParameterBase] = {}: All the parameters supported by this instrument. Usually populated via add_parameter().

functions: dict[str, Function] = {}: All the functions supported by this instrument. Usually populated via add_function().

submodules: dict[str, InstrumentModule | ChannelTuple] = {}: All the submodules of this instrument such as channel lists or logical groupings of parameters. Usually populated via add_submodule().

instrument_modules: dict[str, InstrumentModule] = {}: All the InstrumentModule of this instrument Usually populated via add_submodule().

log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)

metadata: dict[str, Any] = {}