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)

param unit:

Unit to update either VOLT or CURR.

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