Lakeshore Drivers

Classes:

LakeshoreBaseOutput(parent, output_name, ...)

Base class for the outputs of Lakeshore temperature controllers

LakeshoreBase(name, address[, ...])

This base class has been written to be that base for the Lakeshore 336 and 372.

LakeshoreBaseSensorChannel(parent, name, ...)

Base class for Lakeshore Temperature Controller sensor channels

LakeshoreModel325(name, address, **kwargs)

QCoDeS driver for Lakeshore Model 325 Temperature Controller.

LakeshoreModel325Curve(parent, index, **kwargs)

An InstrumentChannel representing a curve on a Lakeshore Model 325

LakeshoreModel325Heater(parent, name, loop, ...)

InstrumentChannel for heater control on a Lakeshore Model 325.

LakeshoreModel325Sensor(parent, name, inp, ...)

InstrumentChannel for a single sensor of a Lakeshore Model 325.

LakeshoreModel325Status(value[, names, ...])

IntFlag that defines status codes for Lakeshore Model 325

LakeshoreModel335(name, address, **kwargs)

Lakeshore Model 335 Temperature Controller Driver

LakeshoreModel335Channel(parent, name, ...)

An InstrumentChannel representing a single sensor on a Lakeshore Model 335.

LakeshoreModel335CurrentSource(parent, ...)

InstrumentChannel for current sources on Lakeshore Model 335.

LakeshoreModel336(name, address, **kwargs)

QCoDeS driver for Lakeshore Model 336 Temperature Controller.

LakeshoreModel336Channel(parent, name, ...)

An InstrumentChannel representing a single sensor on a Lakeshore Model 336.

LakeshoreModel336CurrentSource(parent, ...)

InstrumentChannel for current sources on Lakeshore Model 336.

LakeshoreModel336VoltageSource(parent, ...)

InstrumentChannel for voltage sources on Lakeshore Model 336.

LakeshoreModel372(name, address, **kwargs)

QCoDeS driver for Lakeshore Model 372 Temperature Controller.

LakeshoreModel372Channel(parent, name, ...)

An InstrumentChannel representing a single sensor on a Lakeshore Model 372.

LakeshoreModel372Output(parent, output_name, ...)

An InstrumentChannel for control outputs (heaters) of Lakeshore Model 372

class qcodes.instrument_drivers.Lakeshore.LakeshoreBaseOutput(parent: LakeshoreBase, output_name: str, output_index: int, has_pid: bool = True, **kwargs: Unpack[InstrumentBaseKWArgs])[source]

Bases: InstrumentChannel

Base class for the outputs of Lakeshore temperature controllers

Parameters:
  • parent – instrument that this channel belongs to

  • output_name – name of this output

  • output_index – identifier for this output that is used in VISA commands of the instrument

  • has_pid – if True, then the output supports closed loop control, hence it will have three parameters to set it up: ‘P’, ‘I’, and ‘D’

  • **kwargs – Forwarded to baseclass.

Attributes:

MODES

RANGES

mode

Specifies the control mode

input_channel

Specifies which measurement input to control from (note that only measurement inputs are available)

powerup_enable

Specifies whether the output remains on or shuts off after power cycle.

P

The value for closed control loop Proportional (gain)

I

The value for closed control loop Integral (reset)

D

The value for closed control loop Derivative (rate)

output_range

Specifies heater output range.

output

Specifies heater output in percent of the current heater output range.

setpoint

The value of the setpoint in the preferred units of the control loop sensor (which is set via input_channel parameter)

range_limits

Use this parameter to define which temperature corresponds to which output range; then use the set_range_from_temperature method to set the output range via temperature instead of doing it directly

wait_cycle_time

Time between two readings when waiting for temperature to equilibrate

wait_tolerance

Acceptable tolerance when waiting for temperature to equilibrate

wait_equilibration_time

Duration during which temperature has to be within tolerance

blocking_t

Sets the setpoint value, and input range, and waits until it is reached.

Methods:

set_range_from_temperature(temperature)

Sets the output range of this given heater from a given temperature.

set_setpoint_and_range(temperature)

Sets the range from the given temperature, and then sets the setpoint to this given temperature.

wait_until_set_point_reached([...])

This function runs a loop that monitors the value of the heater's input channel until the read values is close to the setpoint value that has been set before.

MODES: ClassVar[dict[str, int]] = {}
RANGES: ClassVar[dict[str, int]] = {}
INVERSE_RANGES: dict[int, str] = {v: k for k, v in self.RANGES.items()}
mode: GroupParameter = self.add_parameter( "mode", label="Control mode", docstring="Specifies the control mode", val_mapping=self.MODES, parameter_class=GroupParameter, )

Specifies the control mode

input_channel: GroupParameter = self.add_parameter( "input_channel", label="Input channel", docstring="Specifies which measurement input to " "control from (note that only " "measurement inputs are available)", parameter_class=GroupParameter, **self._input_channel_parameter_kwargs, )

Specifies which measurement input to control from (note that only measurement inputs are available)

powerup_enable: GroupParameter = self.add_parameter( "powerup_enable", label="Power-up enable on/off", docstring="Specifies whether the output remains on " "or shuts off after power cycle.", val_mapping={True: 1, False: 0}, parameter_class=GroupParameter, )

Specifies whether the output remains on or shuts off after power cycle.

P: GroupParameter

The value for closed control loop Proportional (gain)

I: GroupParameter

The value for closed control loop Integral (reset)

D: GroupParameter

The value for closed control loop Derivative (rate)

output_range: Parameter = self.add_parameter( "output_range", label="Heater range", docstring="Specifies heater output range. The range " "setting has no effect if an output is in " "the `Off` mode, and does not apply to " "an output in `Monitor Out` mode. " "An output in `Monitor Out` mode is " "always on.", val_mapping=self.RANGES, set_cmd=f"RANGE {output_index}, {{}}", get_cmd=f"RANGE? {output_index}", )

Specifies heater output range. The range setting has no effect if an output is in the Off mode, and does not apply to an output in Monitor Out mode. An output in Monitor Out mode is always on.

output: Parameter = self.add_parameter( "output", label="Output", unit="% of heater range", docstring="Specifies heater output in percent of " "the current heater output range.\n" "Note that when the heater is off, " "this parameter will return the value " "of 0.005.", get_parser=float, get_cmd=f"HTR? {output_index}", set_cmd=False, )

Specifies heater output in percent of the current heater output range. Note that when the heater is off, this parameter will return the value of 0.005.

setpoint: Parameter = self.add_parameter( "setpoint", label="Setpoint value (in sensor units)", docstring="The value of the setpoint in the " "preferred units of the control loop " "sensor (which is set via " "`input_channel` parameter)", vals=vals.Numbers( -273.15, 400 ), # union of [0..400]K and [-273.15..126.85]degC get_parser=float, set_cmd=f"SETP {output_index}, {{}}", get_cmd=f"SETP? {output_index}", )

The value of the setpoint in the preferred units of the control loop sensor (which is set via input_channel parameter)

range_limits: Parameter = self.add_parameter( "range_limits", set_cmd=None, get_cmd=None, vals=vals.Sequence( vals.Numbers(0, 400), require_sorted=True, length=len(self.RANGES) - 1 ), label="Temperature limits for output ranges", unit="K", docstring="Use this parameter to define which " "temperature corresponds to which output " "range; then use the " "`set_range_from_temperature` method to " "set the output range via temperature " "instead of doing it directly", )

Use this parameter to define which temperature corresponds to which output range; then use the set_range_from_temperature method to set the output range via temperature instead of doing it directly

wait_cycle_time: Parameter = self.add_parameter( "wait_cycle_time", set_cmd=None, get_cmd=None, vals=vals.Numbers(0, 100), label="Waiting cycle time", docstring="Time between two readings when waiting " "for temperature to equilibrate", unit="s", )

Time between two readings when waiting for temperature to equilibrate

wait_tolerance: Parameter = self.add_parameter( "wait_tolerance", set_cmd=None, get_cmd=None, vals=vals.Numbers(0, 100), label="Waiting tolerance", docstring="Acceptable tolerance when waiting for " "temperature to equilibrate", unit="", )

Acceptable tolerance when waiting for temperature to equilibrate

wait_equilibration_time: Parameter = self.add_parameter( "wait_equilibration_time", set_cmd=None, get_cmd=None, vals=vals.Numbers(0, 100), label="Waiting equilibration time", docstring="Duration during which temperature has to be within tolerance", unit="s", )

Duration during which temperature has to be within tolerance

blocking_t: Parameter = self.add_parameter( "blocking_t", label="Setpoint value with blocking until it is reached", docstring="Sets the setpoint value, and input " "range, and waits until it is reached. " "Added for compatibility with Loop. Note " "that if the setpoint value is in " "a different range, this function may " "wait forever because that setpoint " "cannot be reached within the current " "range.", vals=vals.Numbers(0, 400), set_cmd=self._set_blocking_t, snapshot_exclude=True, )

Sets the setpoint value, and input range, and waits until it is reached. Added for compatibility with Loop. Note that if the setpoint value is in a different range, this function may wait forever because that setpoint cannot be reached within the current range.

set_range_from_temperature(temperature: float) str[source]

Sets the output range of this given heater from a given temperature.

The output range is determined by the limits given through the parameter range_limits. The output range is used for temperatures between the limits range_limits[i-1] and range_limits[i]; that is range_limits is the upper limit for using a certain heater current.

Parameters:

temperature – temperature to set the range from

Returns:

the value of the resulting output_range, that is also available from the output_range parameter itself

set_setpoint_and_range(temperature: float) None[source]

Sets the range from the given temperature, and then sets the setpoint to this given temperature.

Note that the preferred units of the heater output are expected to be kelvin.

Parameters:

temperature – temperature in K

wait_until_set_point_reached(wait_cycle_time: float | None = None, wait_tolerance: float | None = None, wait_equilibration_time: float | None = None) None[source]

This function runs a loop that monitors the value of the heater’s input channel until the read values is close to the setpoint value that has been set before.

Note that if the setpoint value is in a different range, this function may wait forever because that setpoint cannot be reached within the current range.

Parameters:
  • wait_cycle_time – this time is being waited between the readings (same as wait_cycle_time parameter); if None, then the value of the corresponding wait_cycle_time parameter is used

  • wait_tolerance – this value is used to determine if the reading value is close enough to the setpoint value according to the following formula: abs(t_reading - t_setpoint)/t_reading < wait_tolerance (same as wait_tolerance parameter); if None, then the value of the corresponding wait_tolerance parameter is used

  • wait_equilibration_time – within this time, the reading value has to stay within the defined tolerance in order for this function to return (same as wait_equilibration_time parameter); if None, then the value of the corresponding wait_equilibration_time parameter is used

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.Lakeshore.LakeshoreBase(name: str, address: str, print_connect_message: bool = True, **kwargs: Unpack[VisaInstrumentKWArgs])[source]

Bases: VisaInstrument

This base class has been written to be that base for the Lakeshore 336 and 372. There are probably other lakeshore modes that can use the functionality provided here. If you add another lakeshore driver please make sure to extend this class accordingly, or create a new one.

In order to use a variation of the BaseSensorChannel class for sensor channels, just set CHANNEL_CLASS to that variation of the class inside your LakeshoreBase’s subclass.

In order to add heaters (output channels) to the driver, add BaseOutput instances (subclasses of those) in your LakeshoreBase’s subclass constructor via add_submodule method.

Classes:

CHANNEL_CLASS

alias of LakeshoreBaseSensorChannel

Attributes:

channel_name_command

input_channel_parameter_values_to_channel_name_on_instrument

default_terminator

The default terminator to use if the terminator is not specified when creating the instrument.

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

alias of LakeshoreBaseSensorChannel Attributes:

SENSOR_STATUSES

temperature

Parameter temperature

t_limit

The temperature limit in kelvin for which to shut down all control outputs when exceeded.

sensor_raw

Parameter sensor_raw

sensor_status

Parameter sensor_status

sensor_name

Parameter sensor_name

channel_name_command: ClassVar[dict[str, str]] = {}
input_channel_parameter_values_to_channel_name_on_instrument: ClassVar[dict[Any, str]]
default_terminator: str | None = '\r\n'

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

class qcodes.instrument_drivers.Lakeshore.LakeshoreBaseSensorChannel(parent: LakeshoreBase, name: str, channel: str, **kwargs: Unpack[InstrumentBaseKWArgs])[source]

Bases: InstrumentChannel

Base class for Lakeshore Temperature Controller sensor channels

Parameters:
  • parent – instrument instance that this channel belongs to

  • name – name of the channel

  • channel – string identifier of the channel as referenced in commands; for example, ‘1’ or ‘6’ for model 372, or ‘A’ and ‘C’ for model 336

  • **kwargs – Forwarded to base class.

Attributes:

SENSOR_STATUSES

parameters

All the parameters supported by this instrument.

functions

All the functions supported by this instrument.

submodules

All the submodules of this instrument such as channel lists or logical groupings of parameters.

instrument_modules

All the InstrumentModule of this instrument Usually populated via add_submodule().

log

metadata

temperature

Parameter temperature

t_limit

The temperature limit in kelvin for which to shut down all control outputs when exceeded.

sensor_raw

Parameter sensor_raw

sensor_status

Parameter sensor_status

sensor_name

Parameter sensor_name

SENSOR_STATUSES: ClassVar[dict[int, str]] = {}
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] = {}
temperature: Parameter = self.add_parameter( "temperature", get_cmd=f"KRDG? {self._channel}", get_parser=float, label="Temperature", unit="K", )

Parameter temperature

t_limit: Parameter = self.add_parameter( "t_limit", get_cmd=f"TLIMIT? {self._channel}", set_cmd=f"TLIMIT {self._channel}, {{}}", get_parser=float, label="Temperature limit", docstring="The temperature limit in kelvin for " "which to shut down all control outputs " "when exceeded. A temperature limit of " "zero turns the temperature limit " "feature off for the given sensor input.", unit="K", )

The temperature limit in kelvin for which to shut down all control outputs when exceeded. A temperature limit of zero turns the temperature limit feature off for the given sensor input.

sensor_raw: Parameter = self.add_parameter( "sensor_raw", get_cmd=f"SRDG? {self._channel}", get_parser=float, label="Raw reading", unit="Ohms", )

Parameter sensor_raw

sensor_status: Parameter = self.add_parameter( "sensor_status", get_cmd=f"RDGST? {self._channel}", get_parser=self._decode_sensor_status, label="Sensor status", )

Parameter sensor_status

sensor_name: Parameter = self.add_parameter( "sensor_name", get_cmd=f"INNAME? {self._channel}", get_parser=str, set_cmd=f'INNAME {self._channel},"{{}}"', vals=vals.Strings(15), label="Sensor name", )

Parameter sensor_name

class qcodes.instrument_drivers.Lakeshore.LakeshoreModel325(name: str, address: str, **kwargs: Unpack[VisaInstrumentKWArgs])[source]

Bases: VisaInstrument

QCoDeS driver for Lakeshore Model 325 Temperature Controller.

Attributes:

default_terminator

The default terminator to use if the terminator is not specified when creating the instrument.

Methods:

upload_curve(index, name, serial_number, ...)

Upload a curve to the given index

upload_curve_from_file(index, file_path)

Upload a curve from a curve file.

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] = {}
default_terminator: str | None = '\r\n'

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

upload_curve(index: int, name: str, serial_number: str, data_dict: dict[Any, Any]) None[source]

Upload a curve to the given index

Parameters:
  • index – The index to upload the curve to. We can only use indices reserved for user defined curves, 21-35

  • name – Name of the curve

  • serial_number – Serial number of the curve

  • data_dict – A dictionary containing the curve data

upload_curve_from_file(index: int, file_path: str) None[source]

Upload a curve from a curve file. Note that we only support curve files with extension .330

class qcodes.instrument_drivers.Lakeshore.LakeshoreModel325Curve(parent: LakeshoreModel325, index: int, **kwargs: Unpack[InstrumentBaseKWArgs])[source]

Bases: InstrumentChannel

An InstrumentChannel representing a curve on a Lakeshore Model 325

Attributes:

valid_sensor_units

temperature_key

serial_number

Parameter serial_number

format

Parameter format

limit_value

Parameter limit_value

coefficient

Parameter coefficient

curve_name

Parameter curve_name

Methods:

get_data()

validate_datadict(data_dict)

A data dict has two keys, one of which is 'Temperature (K)'.

set_data(data_dict[, sensor_unit])

Set the curve data according to the values found the the dictionary.

valid_sensor_units = ('mV', 'V', 'Ohm', 'log Ohm')
temperature_key = 'Temperature (K)'
serial_number: GroupParameter = self.add_parameter( "serial_number", parameter_class=GroupParameter )

Parameter serial_number

format: GroupParameter = self.add_parameter( "format", val_mapping={ f"{unt}/K": i + 1 for i, unt in enumerate(self.valid_sensor_units) }, parameter_class=GroupParameter, )

Parameter format

limit_value: GroupParameter = self.add_parameter( "limit_value", parameter_class=GroupParameter )

Parameter limit_value

coefficient: GroupParameter = self.add_parameter( "coefficient", val_mapping={"negative": 1, "positive": 2}, parameter_class=GroupParameter, )

Parameter coefficient

curve_name: GroupParameter = self.add_parameter( "curve_name", parameter_class=GroupParameter )

Parameter curve_name

get_data() dict[Any, Any][source]
classmethod validate_datadict(data_dict: dict[Any, Any]) str[source]

A data dict has two keys, one of which is ‘Temperature (K)’. The other contains the units in which the curve is defined and must be one of: ‘mV’, ‘V’, ‘Ohm’ or ‘log Ohm’

This method validates this and returns the sensor unit encountered in the data dict

set_data(data_dict: dict[Any, Any], sensor_unit: str | None = None) None[source]

Set the curve data according to the values found the the dictionary.

Parameters:
  • data_dict (dict) – See validate_datadict to see the format of this dictionary

  • sensor_unit (str) – If None, the data dict is validated and the units are extracted.

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.Lakeshore.LakeshoreModel325Heater(parent: LakeshoreModel325, name: str, loop: int, **kwargs: Unpack[InstrumentBaseKWArgs])[source]

Bases: InstrumentChannel

InstrumentChannel for heater control on a Lakeshore Model 325.

Parameters:
  • parent – The instrument this heater belongs to

  • name – Name of the Channel

  • loop – Either 1 or 2

  • **kwargs – Forwarded to baseclass.

Attributes:

control_mode

Parameter control_mode

input_channel

Parameter input_channel

unit

Parameter unit

powerup_enable

Parameter powerup_enable

output_metric

Parameter output_metric

P

Parameter P

I

Parameter I

D

Parameter D

output_range

Parameter output_range

setpoint

Parameter setpoint

ramp_state

Parameter ramp_state

ramp_rate

Parameter ramp_rate

is_ramping

Parameter is_ramping

resistance

Parameter resistance

heater_output

Parameter heater_output

control_mode: Parameter = self.add_parameter( "control_mode", get_cmd=f"CMODE? {self._loop}", set_cmd=f"CMODE {self._loop},{{}}", val_mapping={ "Manual PID": "1", "Zone": "2", "Open Loop": "3", "AutoTune PID": "4", "AutoTune PI": "5", "AutoTune P": "6", }, )

Parameter control_mode

input_channel: GroupParameter = self.add_parameter( "input_channel", vals=Enum("A", "B"), parameter_class=GroupParameter )

Parameter input_channel

unit: GroupParameter = self.add_parameter( "unit", val_mapping={"Kelvin": "1", "Celsius": "2", "Sensor Units": "3"}, parameter_class=GroupParameter, )

Parameter unit

powerup_enable: GroupParameter = self.add_parameter( "powerup_enable", val_mapping={True: 1, False: 0}, parameter_class=GroupParameter, )

Parameter powerup_enable

output_metric: GroupParameter = self.add_parameter( "output_metric", val_mapping={ "current": "1", "power": "2", }, parameter_class=GroupParameter, )

Parameter output_metric

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] = {}
P: GroupParameter = self.add_parameter( "P", vals=Numbers(0, 1000), get_parser=float, parameter_class=GroupParameter )

Parameter P

I: GroupParameter = self.add_parameter( "I", vals=Numbers(0, 1000), get_parser=float, parameter_class=GroupParameter )

Parameter I

D: GroupParameter = self.add_parameter( "D", vals=Numbers(0, 1000), get_parser=float, parameter_class=GroupParameter )

Parameter D

output_range: Parameter = self.add_parameter( "output_range", vals=valid_output_ranges, set_cmd=f"RANGE {self._loop}, {{}}", get_cmd=f"RANGE? {self._loop}", val_mapping={"Off": "0", "Low (2.5W)": "1", "High (25W)": "2"}, )

Parameter output_range

setpoint: Parameter = self.add_parameter( "setpoint", vals=Numbers(0, 400), get_parser=float, set_cmd=f"SETP {self._loop}, {{}}", get_cmd=f"SETP? {self._loop}", )

Parameter setpoint

ramp_state: GroupParameter = self.add_parameter( "ramp_state", vals=Enum(0, 1), parameter_class=GroupParameter )

Parameter ramp_state

ramp_rate: GroupParameter = self.add_parameter( "ramp_rate", vals=Numbers(0, 100 / 60 * 1e3), unit="mK/s", parameter_class=GroupParameter, get_parser=lambda v: float(v) / 60 * 1e3, # We get values in K/min, set_parser=lambda v: v * 60 * 1e-3, # Convert to K/min )

Parameter ramp_rate

is_ramping: Parameter = self.add_parameter( "is_ramping", get_cmd=f"RAMPST? {self._loop}" )

Parameter is_ramping

resistance: Parameter = self.add_parameter( "resistance", get_cmd=f"HTRRES? {self._loop}", set_cmd=f"HTRRES {self._loop}, {{}}", val_mapping={ 25: 1, 50: 2, }, label="Resistance", unit="Ohm", )

Parameter resistance

heater_output: Parameter = self.add_parameter( "heater_output", get_cmd=f"HTR? {self._loop}", get_parser=float, label="Heater Output", unit="%", )

Parameter heater_output

class qcodes.instrument_drivers.Lakeshore.LakeshoreModel325Sensor(parent: LakeshoreModel325, name: str, inp: str, **kwargs: Unpack[InstrumentBaseKWArgs])[source]

Bases: InstrumentChannel

InstrumentChannel for a single sensor of a Lakeshore Model 325.

Parameters:
  • parent (LakeshoreModel325) – The instrument this heater belongs to

  • name (str)

  • inp (str) – Either “A” or “B”

Attributes:

temperature

Parameter temperature

status

Parameter status

type

Parameter type

compensation

Parameter compensation

curve_index

Parameter curve_index

curve

Methods:

decode_sensor_status(sum_of_codes)

temperature: Parameter = self.add_parameter( "temperature", get_cmd=f"KRDG? {self._input}", get_parser=float, label="Temperature", unit="K", )

Parameter temperature

status: Parameter = self.add_parameter( "status", get_cmd=f"RDGST? {self._input}", get_parser=lambda status: self.decode_sensor_status(int(status)), label="Sensor_Status", )

Parameter status

type: GroupParameter = self.add_parameter( "type", val_mapping={ "Silicon diode": 0, "GaAlAs diode": 1, "100 Ohm platinum/250": 2, "100 Ohm platinum/500": 3, "1000 Ohm platinum": 4, "NTC RTD": 5, "Thermocouple 25mV": 6, "Thermocouple 50 mV": 7, "2.5 V, 1 mA": 8, "7.5 V, 1 mA": 9, }, parameter_class=GroupParameter, )

Parameter type

compensation: GroupParameter = self.add_parameter( "compensation", vals=Enum(0, 1), parameter_class=GroupParameter )

Parameter compensation

curve_index: Parameter = self.add_parameter( "curve_index", set_cmd=f"INCRV {self._input}, {{}}", get_cmd=f"INCRV? {self._input}", get_parser=int, vals=Numbers(min_value=1, max_value=35), )

Parameter curve_index

static decode_sensor_status(sum_of_codes: int) str[source]
property curve: LakeshoreModel325Curve
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.Lakeshore.LakeshoreModel325Status(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)[source]

Bases: IntFlag

IntFlag that defines status codes for Lakeshore Model 325

Attributes:

sensor_units_overrang

sensor_units_zero

temp_overrange

temp_underrange

invalid_reading

Methods:

from_bytes(bytes[, byteorder, signed])

Return the integer represented by the given array of bytes.

to_bytes([length, byteorder, signed])

Return an array of bytes representing an integer.

sensor_units_overrang = 128
sensor_units_zero = 64
temp_overrange = 32
temp_underrange = 16
invalid_reading = 1
classmethod from_bytes(bytes: Iterable[SupportsIndex] | SupportsBytes | Buffer, byteorder: Literal['big', 'little'] = 'big', *, signed: bool = False) Self[source]

Return the integer represented by the given array of bytes.

Parameters:
  • bytes – Holds the array of bytes to convert. The argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol.

  • byteorder – The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use sys.byteorder as the byte order value. Default is to use ‘big’.

  • signed – Indicates whether two’s complement is used to represent the integer.

to_bytes(length: SupportsIndex = 1, byteorder: Literal['little', 'big'] = 'big', *, signed: bool = False) bytes[source]

Return an array of bytes representing an integer.

Parameters:
  • length – Length of bytes object to use. An OverflowError is raised if the integer is not representable with the given number of bytes. Default is length 1.

  • byteorder – The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use sys.byteorder as the byte order value. Default is to use ‘big’.

  • signed – Determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.

class qcodes.instrument_drivers.Lakeshore.LakeshoreModel335(name: str, address: str, **kwargs: Unpack[VisaInstrumentKWArgs])[source]

Bases: LakeshoreBase

Lakeshore Model 335 Temperature Controller Driver

Attributes:

channel_name_command

input_channel_parameter_values_to_channel_name_on_instrument

Classes:

CHANNEL_CLASS

alias of LakeshoreModel335Channel

channel_name_command: ClassVar[dict[str, str]] = {'A': 'A', 'B': 'B'}
CHANNEL_CLASS

alias of LakeshoreModel335Channel Attributes:

SENSOR_STATUSES

sensor_type

Specifies input sensor type

auto_range_enabled

Specifies if autoranging is enabled.

range

Specifies input range when autorange is not enabled.

compensation_enabled

Specifies input compensation.

units

Specifies the preferred units parameter for sensor readings and for the control setpoint (kelvin, celsius, or sensor)

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] = {}
input_channel_parameter_values_to_channel_name_on_instrument: ClassVar[dict[Any, str]] = {'A': 'A', 'B': 'B'}
class qcodes.instrument_drivers.Lakeshore.LakeshoreModel335Channel(parent: LakeshoreModel335, name: str, channel: str, **kwargs: Unpack[InstrumentBaseKWArgs])[source]

Bases: LakeshoreBaseSensorChannel

An InstrumentChannel representing a single sensor on a Lakeshore Model 335.

Base class for Lakeshore Temperature Controller sensor channels

Parameters:
  • parent – instrument instance that this channel belongs to

  • name – name of the channel

  • channel – string identifier of the channel as referenced in commands; for example, ‘1’ or ‘6’ for model 372, or ‘A’ and ‘C’ for model 336

  • **kwargs – Forwarded to base class.

Attributes:

SENSOR_STATUSES

sensor_type

Specifies input sensor type

auto_range_enabled

Specifies if autoranging is enabled.

range

Specifies input range when autorange is not enabled.

compensation_enabled

Specifies input compensation.

units

Specifies the preferred units parameter for sensor readings and for the control setpoint (kelvin, celsius, or sensor)

temperature

Parameter temperature

t_limit

The temperature limit in kelvin for which to shut down all control outputs when exceeded.

sensor_raw

Parameter sensor_raw

sensor_status

Parameter sensor_status

sensor_name

Parameter sensor_name

parameters

All the parameters supported by this instrument.

functions

All the functions supported by this instrument.

submodules

All the submodules of this instrument such as channel lists or logical groupings of parameters.

instrument_modules

All the InstrumentModule of this instrument Usually populated via add_submodule().

log

metadata

SENSOR_STATUSES: ClassVar[dict[int, str]] = {0: 'OK', 1: 'Invalid Reading', 16: 'Temp Underrange', 32: 'Temp Overrange', 64: 'Sensor Units Zero', 128: 'Sensor Units Overrange'}
sensor_type: GroupParameter = self.add_parameter( "sensor_type", label="Input sensor type", docstring="Specifies input sensor type", val_mapping={ "disabled": 0, "diode": 1, "platinum_rtd": 2, "ntc_rtd": 3, "thermocouple": 4, }, parameter_class=GroupParameter, )

Specifies input sensor type

auto_range_enabled: GroupParameter = self.add_parameter( "auto_range_enabled", label="Autoranging", docstring="Specifies if autoranging is enabled. " "Does not apply for diode sensor type", val_mapping={False: 0, True: 1}, parameter_class=GroupParameter, )

Specifies if autoranging is enabled. Does not apply for diode sensor type

range: GroupParameter = self.add_parameter( "range", label="Range", docstring="Specifies input range when autorange is " "not enabled. If autorange is on, the " "returned value corresponds to the " "currently auto-selected range. The list " "of available ranges depends on the " "chosen sensor type: diode 0-1, platinum " "RTD 0-6, NTC RTD 0-8. Refer to the page " "136 of the manual for the lookup table", vals=vals.Numbers(0, 8), parameter_class=GroupParameter, )

Specifies input range when autorange is not enabled. If autorange is on, the returned value corresponds to the currently auto-selected range. The list of available ranges depends on the chosen sensor type: diode 0-1, platinum RTD 0-6, NTC RTD 0-8. Refer to the page 136 of the manual for the lookup table

compensation_enabled: GroupParameter = self.add_parameter( "compensation_enabled", label="Compensation enabled", docstring="Specifies input compensation. Reversal " "for thermal EMF compensation if input " "is resistive, room compensation if " "input is thermocouple. Always 0 if input " "is a diode", val_mapping={False: 0, True: 1}, parameter_class=GroupParameter, )

Specifies input compensation. Reversal for thermal EMF compensation if input is resistive, room compensation if input is thermocouple. Always 0 if input is a diode

units: GroupParameter = self.add_parameter( "units", label="Preferred units", docstring="Specifies the preferred units parameter " "for sensor readings and for the control " "setpoint (kelvin, celsius, or sensor)", val_mapping={"kelvin": 1, "celsius": 2, "sensor": 3}, parameter_class=GroupParameter, )

Specifies the preferred units parameter for sensor readings and for the control setpoint (kelvin, celsius, or sensor)

temperature: Parameter = self.add_parameter( "temperature", get_cmd=f"KRDG? {self._channel}", get_parser=float, label="Temperature", unit="K", )

Parameter temperature

t_limit: Parameter = self.add_parameter( "t_limit", get_cmd=f"TLIMIT? {self._channel}", set_cmd=f"TLIMIT {self._channel}, {{}}", get_parser=float, label="Temperature limit", docstring="The temperature limit in kelvin for " "which to shut down all control outputs " "when exceeded. A temperature limit of " "zero turns the temperature limit " "feature off for the given sensor input.", unit="K", )

The temperature limit in kelvin for which to shut down all control outputs when exceeded. A temperature limit of zero turns the temperature limit feature off for the given sensor input.

sensor_raw: Parameter = self.add_parameter( "sensor_raw", get_cmd=f"SRDG? {self._channel}", get_parser=float, label="Raw reading", unit="Ohms", )

Parameter sensor_raw

sensor_status: Parameter = self.add_parameter( "sensor_status", get_cmd=f"RDGST? {self._channel}", get_parser=self._decode_sensor_status, label="Sensor status", )

Parameter sensor_status

sensor_name: Parameter = self.add_parameter( "sensor_name", get_cmd=f"INNAME? {self._channel}", get_parser=str, set_cmd=f'INNAME {self._channel},"{{}}"', vals=vals.Strings(15), label="Sensor name", )

Parameter sensor_name

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.Lakeshore.LakeshoreModel335CurrentSource(parent: LakeshoreModel335, output_name: str, output_index: int, **kwargs: Unpack[InstrumentBaseKWArgs])[source]

Bases: LakeshoreBaseOutput

InstrumentChannel for current sources on Lakeshore Model 335.

Class for control outputs 1 and 2 of Lakeshore Model 335 that are variable DC current sources referenced to chassis ground.

Base class for the outputs of Lakeshore temperature controllers

Parameters:
  • parent – instrument that this channel belongs to

  • output_name – name of this output

  • output_index – identifier for this output that is used in VISA commands of the instrument

  • has_pid – if True, then the output supports closed loop control, hence it will have three parameters to set it up: ‘P’, ‘I’, and ‘D’

  • **kwargs – Forwarded to baseclass.

Attributes:

MODES

RANGES

MODES: ClassVar[dict[str, int]] = {'closed_loop': 1, 'off': 0, 'open_loop': 3, 'zone': 2}
RANGES: ClassVar[dict[str, int]] = {'high': 3, 'low': 1, 'medium': 2, 'off': 0}
INVERSE_RANGES: dict[int, str] = {v: k for k, v in self.RANGES.items()}
mode: GroupParameter = self.add_parameter( "mode", label="Control mode", docstring="Specifies the control mode", val_mapping=self.MODES, parameter_class=GroupParameter, )

Specifies the control mode

input_channel: GroupParameter = self.add_parameter( "input_channel", label="Input channel", docstring="Specifies which measurement input to " "control from (note that only " "measurement inputs are available)", parameter_class=GroupParameter, **self._input_channel_parameter_kwargs, )

Specifies which measurement input to control from (note that only measurement inputs are available)

powerup_enable: GroupParameter = self.add_parameter( "powerup_enable", label="Power-up enable on/off", docstring="Specifies whether the output remains on " "or shuts off after power cycle.", val_mapping={True: 1, False: 0}, parameter_class=GroupParameter, )

Specifies whether the output remains on or shuts off after power cycle.

P: GroupParameter

The value for closed control loop Proportional (gain)

I: GroupParameter

The value for closed control loop Integral (reset)

D: GroupParameter

The value for closed control loop Derivative (rate)

output_range: Parameter = self.add_parameter( "output_range", label="Heater range", docstring="Specifies heater output range. The range " "setting has no effect if an output is in " "the `Off` mode, and does not apply to " "an output in `Monitor Out` mode. " "An output in `Monitor Out` mode is " "always on.", val_mapping=self.RANGES, set_cmd=f"RANGE {output_index}, {{}}", get_cmd=f"RANGE? {output_index}", )

Specifies heater output range. The range setting has no effect if an output is in the Off mode, and does not apply to an output in Monitor Out mode. An output in Monitor Out mode is always on.

output: Parameter = self.add_parameter( "output", label="Output", unit="% of heater range", docstring="Specifies heater output in percent of " "the current heater output range.\n" "Note that when the heater is off, " "this parameter will return the value " "of 0.005.", get_parser=float, get_cmd=f"HTR? {output_index}", set_cmd=False, )

Specifies heater output in percent of the current heater output range. Note that when the heater is off, this parameter will return the value of 0.005.

setpoint: Parameter = self.add_parameter( "setpoint", label="Setpoint value (in sensor units)", docstring="The value of the setpoint in the " "preferred units of the control loop " "sensor (which is set via " "`input_channel` parameter)", vals=vals.Numbers( -273.15, 400 ), # union of [0..400]K and [-273.15..126.85]degC get_parser=float, set_cmd=f"SETP {output_index}, {{}}", get_cmd=f"SETP? {output_index}", )

The value of the setpoint in the preferred units of the control loop sensor (which is set via input_channel parameter)

range_limits: Parameter = self.add_parameter( "range_limits", set_cmd=None, get_cmd=None, vals=vals.Sequence( vals.Numbers(0, 400), require_sorted=True, length=len(self.RANGES) - 1 ), label="Temperature limits for output ranges", unit="K", docstring="Use this parameter to define which " "temperature corresponds to which output " "range; then use the " "`set_range_from_temperature` method to " "set the output range via temperature " "instead of doing it directly", )

Use this parameter to define which temperature corresponds to which output range; then use the set_range_from_temperature method to set the output range via temperature instead of doing it directly

wait_cycle_time: Parameter = self.add_parameter( "wait_cycle_time", set_cmd=None, get_cmd=None, vals=vals.Numbers(0, 100), label="Waiting cycle time", docstring="Time between two readings when waiting " "for temperature to equilibrate", unit="s", )

Time between two readings when waiting for temperature to equilibrate

wait_tolerance: Parameter = self.add_parameter( "wait_tolerance", set_cmd=None, get_cmd=None, vals=vals.Numbers(0, 100), label="Waiting tolerance", docstring="Acceptable tolerance when waiting for " "temperature to equilibrate", unit="", )

Acceptable tolerance when waiting for temperature to equilibrate

wait_equilibration_time: Parameter = self.add_parameter( "wait_equilibration_time", set_cmd=None, get_cmd=None, vals=vals.Numbers(0, 100), label="Waiting equilibration time", docstring="Duration during which temperature has to be within tolerance", unit="s", )

Duration during which temperature has to be within tolerance

blocking_t: Parameter = self.add_parameter( "blocking_t", label="Setpoint value with blocking until it is reached", docstring="Sets the setpoint value, and input " "range, and waits until it is reached. " "Added for compatibility with Loop. Note " "that if the setpoint value is in " "a different range, this function may " "wait forever because that setpoint " "cannot be reached within the current " "range.", vals=vals.Numbers(0, 400), set_cmd=self._set_blocking_t, snapshot_exclude=True, )

Sets the setpoint value, and input range, and waits until it is reached. Added for compatibility with Loop. Note that if the setpoint value is in a different range, this function may wait forever because that setpoint cannot be reached within the current 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.Lakeshore.LakeshoreModel336(name: str, address: str, **kwargs: Unpack[VisaInstrumentKWArgs])[source]

Bases: LakeshoreBase

QCoDeS driver for Lakeshore Model 336 Temperature Controller.

Attributes:

channel_name_command

input_channel_parameter_values_to_channel_name_on_instrument

Classes:

CHANNEL_CLASS

alias of LakeshoreModel336Channel

channel_name_command: ClassVar[dict[str, str]] = {'A': 'A', 'B': 'B', 'C': 'C', 'D': 'D'}
CHANNEL_CLASS

alias of LakeshoreModel336Channel Attributes:

SENSOR_STATUSES

sensor_type

Specifies input sensor type

auto_range_enabled

Specifies if autoranging is enabled.

range

Specifies input range when autorange is not enabled.

compensation_enabled

Specifies input compensation.

units

Specifies the preferred units parameter for sensor readings and for the control setpoint (kelvin, celsius, or sensor)

input_channel_parameter_values_to_channel_name_on_instrument: ClassVar[dict[Any, str]] = {'A': 'A', 'B': 'B', 'C': 'C', 'D': 'D'}
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] = {}
class qcodes.instrument_drivers.Lakeshore.LakeshoreModel336Channel(parent: LakeshoreModel336, name: str, channel: str, **kwargs: Unpack[InstrumentBaseKWArgs])[source]

Bases: LakeshoreBaseSensorChannel

An InstrumentChannel representing a single sensor on a Lakeshore Model 336.

Base class for Lakeshore Temperature Controller sensor channels

Parameters:
  • parent – instrument instance that this channel belongs to

  • name – name of the channel

  • channel – string identifier of the channel as referenced in commands; for example, ‘1’ or ‘6’ for model 372, or ‘A’ and ‘C’ for model 336

  • **kwargs – Forwarded to base class.

Attributes:

SENSOR_STATUSES

sensor_type

Specifies input sensor type

auto_range_enabled

Specifies if autoranging is enabled.

range

Specifies input range when autorange is not enabled.

compensation_enabled

Specifies input compensation.

units

Specifies the preferred units parameter for sensor readings and for the control setpoint (kelvin, celsius, or sensor)

temperature

Parameter temperature

t_limit

The temperature limit in kelvin for which to shut down all control outputs when exceeded.

sensor_raw

Parameter sensor_raw

sensor_status

Parameter sensor_status

sensor_name

Parameter sensor_name

parameters

All the parameters supported by this instrument.

functions

All the functions supported by this instrument.

submodules

All the submodules of this instrument such as channel lists or logical groupings of parameters.

instrument_modules

All the InstrumentModule of this instrument Usually populated via add_submodule().

log

metadata

SENSOR_STATUSES: ClassVar[dict[int, str]] = {0: 'OK', 1: 'Invalid Reading', 16: 'Temp Underrange', 32: 'Temp Overrange', 64: 'Sensor Units Zero', 128: 'Sensor Units Overrange'}
sensor_type: GroupParameter = self.add_parameter( "sensor_type", label="Input sensor type", docstring="Specifies input sensor type", val_mapping={"disabled": 0, "diode": 1, "platinum_rtd": 2, "ntc_rtd": 3}, parameter_class=GroupParameter, )

Specifies input sensor type

auto_range_enabled: GroupParameter = self.add_parameter( "auto_range_enabled", label="Autoranging", docstring="Specifies if autoranging is enabled. " "Does not apply for diode sensor type", val_mapping={False: 0, True: 1}, parameter_class=GroupParameter, )

Specifies if autoranging is enabled. Does not apply for diode sensor type

range: GroupParameter = self.add_parameter( "range", label="Range", docstring="Specifies input range when autorange is " "not enabled. If autorange is on, the " "returned value corresponds to the " "currently auto-selected range. The list " "of available ranges depends on the " "chosen sensor type: diode 0-1, platinum " "RTD 0-6, NTC RTD 0-8. Refer to the page " "136 of the manual for the lookup table", vals=vals.Numbers(0, 8), parameter_class=GroupParameter, )

Specifies input range when autorange is not enabled. If autorange is on, the returned value corresponds to the currently auto-selected range. The list of available ranges depends on the chosen sensor type: diode 0-1, platinum RTD 0-6, NTC RTD 0-8. Refer to the page 136 of the manual for the lookup table

compensation_enabled: GroupParameter = self.add_parameter( "compensation_enabled", label="Compensation enabled", docstring="Specifies input compensation. Reversal " "for thermal EMF compensation if input " "is resistive, room compensation if " "input is thermocouple. Always 0 if input " "is a diode", val_mapping={False: 0, True: 1}, parameter_class=GroupParameter, )

Specifies input compensation. Reversal for thermal EMF compensation if input is resistive, room compensation if input is thermocouple. Always 0 if input is a diode

units: GroupParameter = self.add_parameter( "units", label="Preferred units", docstring="Specifies the preferred units parameter " "for sensor readings and for the control " "setpoint (kelvin, celsius, or sensor)", val_mapping={"kelvin": 1, "celsius": 2, "sensor": 3}, parameter_class=GroupParameter, )

Specifies the preferred units parameter for sensor readings and for the control setpoint (kelvin, celsius, or sensor)

temperature: Parameter = self.add_parameter( "temperature", get_cmd=f"KRDG? {self._channel}", get_parser=float, label="Temperature", unit="K", )

Parameter temperature

t_limit: Parameter = self.add_parameter( "t_limit", get_cmd=f"TLIMIT? {self._channel}", set_cmd=f"TLIMIT {self._channel}, {{}}", get_parser=float, label="Temperature limit", docstring="The temperature limit in kelvin for " "which to shut down all control outputs " "when exceeded. A temperature limit of " "zero turns the temperature limit " "feature off for the given sensor input.", unit="K", )

The temperature limit in kelvin for which to shut down all control outputs when exceeded. A temperature limit of zero turns the temperature limit feature off for the given sensor input.

sensor_raw: Parameter = self.add_parameter( "sensor_raw", get_cmd=f"SRDG? {self._channel}", get_parser=float, label="Raw reading", unit="Ohms", )

Parameter sensor_raw

sensor_status: Parameter = self.add_parameter( "sensor_status", get_cmd=f"RDGST? {self._channel}", get_parser=self._decode_sensor_status, label="Sensor status", )

Parameter sensor_status

sensor_name: Parameter = self.add_parameter( "sensor_name", get_cmd=f"INNAME? {self._channel}", get_parser=str, set_cmd=f'INNAME {self._channel},"{{}}"', vals=vals.Strings(15), label="Sensor name", )

Parameter sensor_name

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.Lakeshore.LakeshoreModel336CurrentSource(parent: LakeshoreModel336, output_name: str, output_index: int, **kwargs: Unpack[InstrumentBaseKWArgs])[source]

Bases: LakeshoreBaseOutput

InstrumentChannel for current sources on Lakeshore Model 336.

Class for control outputs 1 and 2 of Lakeshore Model 336 that are variable DC current sources referenced to chassis ground.

Base class for the outputs of Lakeshore temperature controllers

Parameters:
  • parent – instrument that this channel belongs to

  • output_name – name of this output

  • output_index – identifier for this output that is used in VISA commands of the instrument

  • has_pid – if True, then the output supports closed loop control, hence it will have three parameters to set it up: ‘P’, ‘I’, and ‘D’

  • **kwargs – Forwarded to baseclass.

Attributes:

MODES

RANGES

MODES: ClassVar[dict[str, int]] = {'closed_loop': 1, 'off': 0, 'open_loop': 3, 'zone': 2}
RANGES: ClassVar[dict[str, int]] = {'high': 3, 'low': 1, 'medium': 2, 'off': 0}
INVERSE_RANGES: dict[int, str] = {v: k for k, v in self.RANGES.items()}
mode: GroupParameter = self.add_parameter( "mode", label="Control mode", docstring="Specifies the control mode", val_mapping=self.MODES, parameter_class=GroupParameter, )

Specifies the control mode

input_channel: GroupParameter = self.add_parameter( "input_channel", label="Input channel", docstring="Specifies which measurement input to " "control from (note that only " "measurement inputs are available)", parameter_class=GroupParameter, **self._input_channel_parameter_kwargs, )

Specifies which measurement input to control from (note that only measurement inputs are available)

powerup_enable: GroupParameter = self.add_parameter( "powerup_enable", label="Power-up enable on/off", docstring="Specifies whether the output remains on " "or shuts off after power cycle.", val_mapping={True: 1, False: 0}, parameter_class=GroupParameter, )

Specifies whether the output remains on or shuts off after power cycle.

P: GroupParameter

The value for closed control loop Proportional (gain)

I: GroupParameter

The value for closed control loop Integral (reset)

D: GroupParameter

The value for closed control loop Derivative (rate)

output_range: Parameter = self.add_parameter( "output_range", label="Heater range", docstring="Specifies heater output range. The range " "setting has no effect if an output is in " "the `Off` mode, and does not apply to " "an output in `Monitor Out` mode. " "An output in `Monitor Out` mode is " "always on.", val_mapping=self.RANGES, set_cmd=f"RANGE {output_index}, {{}}", get_cmd=f"RANGE? {output_index}", )

Specifies heater output range. The range setting has no effect if an output is in the Off mode, and does not apply to an output in Monitor Out mode. An output in Monitor Out mode is always on.

output: Parameter = self.add_parameter( "output", label="Output", unit="% of heater range", docstring="Specifies heater output in percent of " "the current heater output range.\n" "Note that when the heater is off, " "this parameter will return the value " "of 0.005.", get_parser=float, get_cmd=f"HTR? {output_index}", set_cmd=False, )

Specifies heater output in percent of the current heater output range. Note that when the heater is off, this parameter will return the value of 0.005.

setpoint: Parameter = self.add_parameter( "setpoint", label="Setpoint value (in sensor units)", docstring="The value of the setpoint in the " "preferred units of the control loop " "sensor (which is set via " "`input_channel` parameter)", vals=vals.Numbers( -273.15, 400 ), # union of [0..400]K and [-273.15..126.85]degC get_parser=float, set_cmd=f"SETP {output_index}, {{}}", get_cmd=f"SETP? {output_index}", )

The value of the setpoint in the preferred units of the control loop sensor (which is set via input_channel parameter)

range_limits: Parameter = self.add_parameter( "range_limits", set_cmd=None, get_cmd=None, vals=vals.Sequence( vals.Numbers(0, 400), require_sorted=True, length=len(self.RANGES) - 1 ), label="Temperature limits for output ranges", unit="K", docstring="Use this parameter to define which " "temperature corresponds to which output " "range; then use the " "`set_range_from_temperature` method to " "set the output range via temperature " "instead of doing it directly", )

Use this parameter to define which temperature corresponds to which output range; then use the set_range_from_temperature method to set the output range via temperature instead of doing it directly

wait_cycle_time: Parameter = self.add_parameter( "wait_cycle_time", set_cmd=None, get_cmd=None, vals=vals.Numbers(0, 100), label="Waiting cycle time", docstring="Time between two readings when waiting " "for temperature to equilibrate", unit="s", )

Time between two readings when waiting for temperature to equilibrate

wait_tolerance: Parameter = self.add_parameter( "wait_tolerance", set_cmd=None, get_cmd=None, vals=vals.Numbers(0, 100), label="Waiting tolerance", docstring="Acceptable tolerance when waiting for " "temperature to equilibrate", unit="", )

Acceptable tolerance when waiting for temperature to equilibrate

wait_equilibration_time: Parameter = self.add_parameter( "wait_equilibration_time", set_cmd=None, get_cmd=None, vals=vals.Numbers(0, 100), label="Waiting equilibration time", docstring="Duration during which temperature has to be within tolerance", unit="s", )

Duration during which temperature has to be within tolerance

blocking_t: Parameter = self.add_parameter( "blocking_t", label="Setpoint value with blocking until it is reached", docstring="Sets the setpoint value, and input " "range, and waits until it is reached. " "Added for compatibility with Loop. Note " "that if the setpoint value is in " "a different range, this function may " "wait forever because that setpoint " "cannot be reached within the current " "range.", vals=vals.Numbers(0, 400), set_cmd=self._set_blocking_t, snapshot_exclude=True, )

Sets the setpoint value, and input range, and waits until it is reached. Added for compatibility with Loop. Note that if the setpoint value is in a different range, this function may wait forever because that setpoint cannot be reached within the current 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.Lakeshore.LakeshoreModel336VoltageSource(parent: LakeshoreModel336, output_name: str, output_index: int, **kwargs: Unpack[InstrumentBaseKWArgs])[source]

Bases: LakeshoreBaseOutput

InstrumentChannel for voltage sources on Lakeshore Model 336.

This is used for control outputs 3 and 4 that are variable DC voltage sources.

Base class for the outputs of Lakeshore temperature controllers

Parameters:
  • parent – instrument that this channel belongs to

  • output_name – name of this output

  • output_index – identifier for this output that is used in VISA commands of the instrument

  • has_pid – if True, then the output supports closed loop control, hence it will have three parameters to set it up: ‘P’, ‘I’, and ‘D’

  • **kwargs – Forwarded to baseclass.

Attributes:

MODES

RANGES

MODES: ClassVar[dict[str, int]] = {'closed_loop': 1, 'monitor_out': 4, 'off': 0, 'open_loop': 3, 'warm_up': 5, 'zone': 2}
RANGES: ClassVar[dict[str, int]] = {'high': 3, 'low': 1, 'medium': 2, 'off': 0}
INVERSE_RANGES: dict[int, str] = {v: k for k, v in self.RANGES.items()}
mode: GroupParameter = self.add_parameter( "mode", label="Control mode", docstring="Specifies the control mode", val_mapping=self.MODES, parameter_class=GroupParameter, )

Specifies the control mode

input_channel: GroupParameter = self.add_parameter( "input_channel", label="Input channel", docstring="Specifies which measurement input to " "control from (note that only " "measurement inputs are available)", parameter_class=GroupParameter, **self._input_channel_parameter_kwargs, )

Specifies which measurement input to control from (note that only measurement inputs are available)

powerup_enable: GroupParameter = self.add_parameter( "powerup_enable", label="Power-up enable on/off", docstring="Specifies whether the output remains on " "or shuts off after power cycle.", val_mapping={True: 1, False: 0}, parameter_class=GroupParameter, )

Specifies whether the output remains on or shuts off after power cycle.

P: GroupParameter

The value for closed control loop Proportional (gain)

I: GroupParameter

The value for closed control loop Integral (reset)

D: GroupParameter

The value for closed control loop Derivative (rate)

output_range: Parameter = self.add_parameter( "output_range", label="Heater range", docstring="Specifies heater output range. The range " "setting has no effect if an output is in " "the `Off` mode, and does not apply to " "an output in `Monitor Out` mode. " "An output in `Monitor Out` mode is " "always on.", val_mapping=self.RANGES, set_cmd=f"RANGE {output_index}, {{}}", get_cmd=f"RANGE? {output_index}", )

Specifies heater output range. The range setting has no effect if an output is in the Off mode, and does not apply to an output in Monitor Out mode. An output in Monitor Out mode is always on.

output: Parameter = self.add_parameter( "output", label="Output", unit="% of heater range", docstring="Specifies heater output in percent of " "the current heater output range.\n" "Note that when the heater is off, " "this parameter will return the value " "of 0.005.", get_parser=float, get_cmd=f"HTR? {output_index}", set_cmd=False, )

Specifies heater output in percent of the current heater output range. Note that when the heater is off, this parameter will return the value of 0.005.

setpoint: Parameter = self.add_parameter( "setpoint", label="Setpoint value (in sensor units)", docstring="The value of the setpoint in the " "preferred units of the control loop " "sensor (which is set via " "`input_channel` parameter)", vals=vals.Numbers( -273.15, 400 ), # union of [0..400]K and [-273.15..126.85]degC get_parser=float, set_cmd=f"SETP {output_index}, {{}}", get_cmd=f"SETP? {output_index}", )

The value of the setpoint in the preferred units of the control loop sensor (which is set via input_channel parameter)

range_limits: Parameter = self.add_parameter( "range_limits", set_cmd=None, get_cmd=None, vals=vals.Sequence( vals.Numbers(0, 400), require_sorted=True, length=len(self.RANGES) - 1 ), label="Temperature limits for output ranges", unit="K", docstring="Use this parameter to define which " "temperature corresponds to which output " "range; then use the " "`set_range_from_temperature` method to " "set the output range via temperature " "instead of doing it directly", )

Use this parameter to define which temperature corresponds to which output range; then use the set_range_from_temperature method to set the output range via temperature instead of doing it directly

wait_cycle_time: Parameter = self.add_parameter( "wait_cycle_time", set_cmd=None, get_cmd=None, vals=vals.Numbers(0, 100), label="Waiting cycle time", docstring="Time between two readings when waiting " "for temperature to equilibrate", unit="s", )

Time between two readings when waiting for temperature to equilibrate

wait_tolerance: Parameter = self.add_parameter( "wait_tolerance", set_cmd=None, get_cmd=None, vals=vals.Numbers(0, 100), label="Waiting tolerance", docstring="Acceptable tolerance when waiting for " "temperature to equilibrate", unit="", )

Acceptable tolerance when waiting for temperature to equilibrate

wait_equilibration_time: Parameter = self.add_parameter( "wait_equilibration_time", set_cmd=None, get_cmd=None, vals=vals.Numbers(0, 100), label="Waiting equilibration time", docstring="Duration during which temperature has to be within tolerance", unit="s", )

Duration during which temperature has to be within tolerance

blocking_t: Parameter = self.add_parameter( "blocking_t", label="Setpoint value with blocking until it is reached", docstring="Sets the setpoint value, and input " "range, and waits until it is reached. " "Added for compatibility with Loop. Note " "that if the setpoint value is in " "a different range, this function may " "wait forever because that setpoint " "cannot be reached within the current " "range.", vals=vals.Numbers(0, 400), set_cmd=self._set_blocking_t, snapshot_exclude=True, )

Sets the setpoint value, and input range, and waits until it is reached. Added for compatibility with Loop. Note that if the setpoint value is in a different range, this function may wait forever because that setpoint cannot be reached within the current 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.Lakeshore.LakeshoreModel372(name: str, address: str, **kwargs: Unpack[VisaInstrumentKWArgs])[source]

Bases: LakeshoreBase

QCoDeS driver for Lakeshore Model 372 Temperature Controller.

Note that interaction with the control input (referred to as ‘A’ in the Computer Interface Operation section of the manual) is not implemented.

Attributes:

channel_name_command

input_channel_parameter_values_to_channel_name_on_instrument

Classes:

CHANNEL_CLASS

alias of LakeshoreModel372Channel

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] = {}
channel_name_command: ClassVar[dict[str, str]] = {'ch01': '1', 'ch02': '2', 'ch03': '3', 'ch04': '4', 'ch05': '5', 'ch06': '6', 'ch07': '7', 'ch08': '8', 'ch09': '9', 'ch10': '10', 'ch11': '11', 'ch12': '12', 'ch13': '13', 'ch14': '14', 'ch15': '15', 'ch16': '16'}
input_channel_parameter_values_to_channel_name_on_instrument: ClassVar[dict[int, str]] = {1: 'ch01', 2: 'ch02', 3: 'ch03', 4: 'ch04', 5: 'ch05', 6: 'ch06', 7: 'ch07', 8: 'ch08', 9: 'ch09', 10: 'ch10', 11: 'ch11', 12: 'ch12', 13: 'ch13', 14: 'ch14', 15: 'ch15', 16: 'ch16'}
CHANNEL_CLASS

alias of LakeshoreModel372Channel Attributes:

SENSOR_STATUSES

enabled

Specifies whether the input/channel is enabled or disabled.

dwell

Specifies a value for the autoscanning dwell time.

pause

Specifies a value for the change pause time

curve_number

0 = no curve, 1 to 59 = standard/user curves.

temperature_coefficient

Sets the temperature coefficient that will be used for temperature control if no curve is selected (negative or positive).

excitation_mode

Specifies excitation mode

excitation_range_number

Specifies excitation range number (1-12 for voltage excitation, 1-22 for current excitation); refer to the manual for the table of ranges

auto_range

Specifies auto range setting

range

Parameter range

current_source_shunted

Current source either not shunted (excitation on), or shunted (excitation off)

units

Specifies the preferred units parameter for sensor readings and for the control setpoint (kelvin or ohms)

class qcodes.instrument_drivers.Lakeshore.LakeshoreModel372Channel(parent: LakeshoreModel372, name: str, channel: str, **kwargs: Unpack[InstrumentBaseKWArgs])[source]

Bases: LakeshoreBaseSensorChannel

An InstrumentChannel representing a single sensor on a Lakeshore Model 372.

Base class for Lakeshore Temperature Controller sensor channels

Parameters:
  • parent – instrument instance that this channel belongs to

  • name – name of the channel

  • channel – string identifier of the channel as referenced in commands; for example, ‘1’ or ‘6’ for model 372, or ‘A’ and ‘C’ for model 336

  • **kwargs – Forwarded to base class.

Attributes:

SENSOR_STATUSES

enabled

Specifies whether the input/channel is enabled or disabled.

dwell

Specifies a value for the autoscanning dwell time.

pause

Specifies a value for the change pause time

curve_number

0 = no curve, 1 to 59 = standard/user curves.

temperature_coefficient

Sets the temperature coefficient that will be used for temperature control if no curve is selected (negative or positive).

excitation_mode

Specifies excitation mode

excitation_range_number

Specifies excitation range number (1-12 for voltage excitation, 1-22 for current excitation); refer to the manual for the table of ranges

temperature

Parameter temperature

t_limit

The temperature limit in kelvin for which to shut down all control outputs when exceeded.

sensor_raw

Parameter sensor_raw

sensor_status

Parameter sensor_status

sensor_name

Parameter sensor_name

parameters

All the parameters supported by this instrument.

functions

All the functions supported by this instrument.

submodules

All the submodules of this instrument such as channel lists or logical groupings of parameters.

instrument_modules

All the InstrumentModule of this instrument Usually populated via add_submodule().

log

metadata

auto_range

Specifies auto range setting

range

Parameter range

current_source_shunted

Current source either not shunted (excitation on), or shunted (excitation off)

units

Specifies the preferred units parameter for sensor readings and for the control setpoint (kelvin or ohms)

SENSOR_STATUSES: ClassVar[dict[int, str]] = {0: 'OK', 1: 'CS OVL', 2: 'VCM OVL', 4: 'VMIX OVL', 8: 'VDIF OVL', 16: 'R. OVER', 32: 'R. UNDER', 64: 'T. OVER', 128: 'T. UNDER'}
enabled: GroupParameter = self.add_parameter( "enabled", label="Enabled", docstring="Specifies whether the input/channel is " "enabled or disabled. At least one " "measurement input channel must be " "enabled. If all are configured to " "disabled, channel 1 will change to " "enabled.", val_mapping={True: 1, False: 0}, parameter_class=GroupParameter, )

Specifies whether the input/channel is enabled or disabled. At least one measurement input channel must be enabled. If all are configured to disabled, channel 1 will change to enabled.

dwell: GroupParameter = self.add_parameter( "dwell", label="Dwell", docstring="Specifies a value for the autoscanning dwell time.", unit="s", get_parser=int, vals=vals.Numbers(1, 200), parameter_class=GroupParameter, )

Specifies a value for the autoscanning dwell time.

pause: GroupParameter = self.add_parameter( "pause", label="Change pause time", docstring="Specifies a value for the change pause time", unit="s", get_parser=int, vals=vals.Numbers(3, 200), parameter_class=GroupParameter, )

Specifies a value for the change pause time

curve_number: GroupParameter = self.add_parameter( "curve_number", label="Curve", docstring="Specifies which curve the channel uses: " "0 = no curve, 1 to 59 = standard/user " "curves. Do not change this parameter " "unless you know what you are doing.", get_parser=int, vals=vals.Numbers(0, 59), parameter_class=GroupParameter, )

0 = no curve, 1 to 59 = standard/user curves. Do not change this parameter unless you know what you are doing.

Type:

Specifies which curve the channel uses

temperature_coefficient: GroupParameter = self.add_parameter( "temperature_coefficient", label="Change pause time", docstring="Sets the temperature coefficient that " "will be used for temperature control if " "no curve is selected (negative or " "positive). Do not change this parameter " "unless you know what you are doing.", val_mapping={"negative": 1, "positive": 2}, parameter_class=GroupParameter, )

Sets the temperature coefficient that will be used for temperature control if no curve is selected (negative or positive). Do not change this parameter unless you know what you are doing.

excitation_mode: GroupParameter = self.add_parameter( "excitation_mode", label="Excitation mode", docstring="Specifies excitation mode", val_mapping={"voltage": 0, "current": 1}, parameter_class=GroupParameter, )

Specifies excitation mode

excitation_range_number: GroupParameter = self.add_parameter( "excitation_range_number", label="Excitation range number", docstring="Specifies excitation range number " "(1-12 for voltage excitation, 1-22 for " "current excitation); refer to the manual " "for the table of ranges", get_parser=int, vals=vals.Numbers(1, 22), parameter_class=GroupParameter, )

Specifies excitation range number (1-12 for voltage excitation, 1-22 for current excitation); refer to the manual for the table of ranges

temperature: Parameter = self.add_parameter( "temperature", get_cmd=f"KRDG? {self._channel}", get_parser=float, label="Temperature", unit="K", )

Parameter temperature

t_limit: Parameter = self.add_parameter( "t_limit", get_cmd=f"TLIMIT? {self._channel}", set_cmd=f"TLIMIT {self._channel}, {{}}", get_parser=float, label="Temperature limit", docstring="The temperature limit in kelvin for " "which to shut down all control outputs " "when exceeded. A temperature limit of " "zero turns the temperature limit " "feature off for the given sensor input.", unit="K", )

The temperature limit in kelvin for which to shut down all control outputs when exceeded. A temperature limit of zero turns the temperature limit feature off for the given sensor input.

sensor_raw: Parameter = self.add_parameter( "sensor_raw", get_cmd=f"SRDG? {self._channel}", get_parser=float, label="Raw reading", unit="Ohms", )

Parameter sensor_raw

sensor_status: Parameter = self.add_parameter( "sensor_status", get_cmd=f"RDGST? {self._channel}", get_parser=self._decode_sensor_status, label="Sensor status", )

Parameter sensor_status

sensor_name: Parameter = self.add_parameter( "sensor_name", get_cmd=f"INNAME? {self._channel}", get_parser=str, set_cmd=f'INNAME {self._channel},"{{}}"', vals=vals.Strings(15), label="Sensor name", )

Parameter sensor_name

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] = {}
auto_range: GroupParameter = self.add_parameter( "auto_range", label="Auto range", docstring="Specifies auto range setting", val_mapping={"off": 0, "current": 1}, parameter_class=GroupParameter, )

Specifies auto range setting

range: GroupParameter = self.add_parameter( "range", label="Range", val_mapping={ "2.0 mOhm": 1, "6.32 mOhm": 2, "20.0 mOhm": 3, "63.2 mOhm": 4, "200 mOhm": 5, "632 mOhm": 6, "2.00 Ohm": 7, "6.32 Ohm": 8, "20.0 Ohm": 9, "63.2 Ohm": 10, "200 Ohm": 11, "632 Ohm": 12, "2.00 kOhm": 13, "6.32 kOhm": 14, "20.0 kOhm": 15, "63.2 kOhm": 16, "200 kOhm": 17, "632 kOhm": 18, "2.0 MOhm": 19, "6.32 MOhm": 20, "20.0 MOhm": 21, "63.2 MOhm": 22, }, parameter_class=GroupParameter, )

Parameter range

current_source_shunted: GroupParameter = self.add_parameter( "current_source_shunted", label="Current source shunt", docstring="Current source either not shunted " "(excitation on), or shunted " "(excitation off)", val_mapping={False: 0, True: 1}, parameter_class=GroupParameter, )

Current source either not shunted (excitation on), or shunted (excitation off)

units: GroupParameter = self.add_parameter( "units", label="Preferred units", docstring="Specifies the preferred units parameter " "for sensor readings and for the control " "setpoint (kelvin or ohms)", val_mapping={"kelvin": 1, "ohms": 2}, parameter_class=GroupParameter, )

Specifies the preferred units parameter for sensor readings and for the control setpoint (kelvin or ohms)

class qcodes.instrument_drivers.Lakeshore.LakeshoreModel372Output(parent: LakeshoreModel372, output_name: str, output_index: int, **kwargs: Unpack[InstrumentBaseKWArgs])[source]

Bases: LakeshoreBaseOutput

An InstrumentChannel for control outputs (heaters) of Lakeshore Model 372

Base class for the outputs of Lakeshore temperature controllers

Parameters:
  • parent – instrument that this channel belongs to

  • output_name – name of this output

  • output_index – identifier for this output that is used in VISA commands of the instrument

  • has_pid – if True, then the output supports closed loop control, hence it will have three parameters to set it up: ‘P’, ‘I’, and ‘D’

  • **kwargs – Forwarded to baseclass.

Attributes:

MODES

POLARITIES

RANGES

polarity

Specifies output polarity (not applicable to warm-up heater)

use_filter

Specifies controlling on unfiltered or filtered readings

delay

Delay in seconds for setpoint change during Autoscanning

MODES: ClassVar[dict[str, int]] = {'closed_loop': 5, 'monitor_out': 1, 'off': 0, 'open_loop': 2, 'still': 4, 'warm_up': 6, 'zone': 3}
POLARITIES: ClassVar[dict[str, int]] = {'bipolar': 1, 'unipolar': 0}
RANGES: ClassVar[dict[str, int]] = {'100mA': 8, '100μA': 2, '10mA': 6, '1mA': 4, '3.16mA': 5, '31.6mA': 7, '31.6μA': 1, '316μA': 3, 'off': 0}
polarity: GroupParameter = self.add_parameter( "polarity", label="Output polarity", docstring="Specifies output polarity (not applicable to warm-up heater)", val_mapping=self.POLARITIES, parameter_class=GroupParameter, )

Specifies output polarity (not applicable to warm-up heater)

use_filter: GroupParameter = self.add_parameter( "use_filter", label="Use filter for readings", docstring="Specifies controlling on unfiltered or filtered readings", val_mapping={True: 1, False: 0}, parameter_class=GroupParameter, )

Specifies controlling on unfiltered or filtered readings

delay: GroupParameter = self.add_parameter( "delay", label="Delay", unit="s", docstring="Delay in seconds for setpoint change during Autoscanning", vals=vals.Ints(0, 255), get_parser=int, parameter_class=GroupParameter, )

Delay in seconds for setpoint change during Autoscanning

INVERSE_RANGES: dict[int, str] = {v: k for k, v in self.RANGES.items()}
mode: GroupParameter = self.add_parameter( "mode", label="Control mode", docstring="Specifies the control mode", val_mapping=self.MODES, parameter_class=GroupParameter, )

Specifies the control mode

input_channel: GroupParameter = self.add_parameter( "input_channel", label="Input channel", docstring="Specifies which measurement input to " "control from (note that only " "measurement inputs are available)", parameter_class=GroupParameter, **self._input_channel_parameter_kwargs, )

Specifies which measurement input to control from (note that only measurement inputs are available)

powerup_enable: GroupParameter = self.add_parameter( "powerup_enable", label="Power-up enable on/off", docstring="Specifies whether the output remains on " "or shuts off after power cycle.", val_mapping={True: 1, False: 0}, parameter_class=GroupParameter, )

Specifies whether the output remains on or shuts off after power cycle.

P: GroupParameter

The value for closed control loop Proportional (gain)

I: GroupParameter

The value for closed control loop Integral (reset)

D: GroupParameter

The value for closed control loop Derivative (rate)

output_range: Parameter = self.add_parameter( "output_range", label="Heater range", docstring="Specifies heater output range. The range " "setting has no effect if an output is in " "the `Off` mode, and does not apply to " "an output in `Monitor Out` mode. " "An output in `Monitor Out` mode is " "always on.", val_mapping=self.RANGES, set_cmd=f"RANGE {output_index}, {{}}", get_cmd=f"RANGE? {output_index}", )

Specifies heater output range. The range setting has no effect if an output is in the Off mode, and does not apply to an output in Monitor Out mode. An output in Monitor Out mode is always on.

output: Parameter = self.add_parameter( "output", label="Output", unit="% of heater range", docstring="Specifies heater output in percent of " "the current heater output range.\n" "Note that when the heater is off, " "this parameter will return the value " "of 0.005.", get_parser=float, get_cmd=f"HTR? {output_index}", set_cmd=False, )

Specifies heater output in percent of the current heater output range. Note that when the heater is off, this parameter will return the value of 0.005.

setpoint: Parameter = self.add_parameter( "setpoint", label="Setpoint value (in sensor units)", docstring="The value of the setpoint in the " "preferred units of the control loop " "sensor (which is set via " "`input_channel` parameter)", vals=vals.Numbers( -273.15, 400 ), # union of [0..400]K and [-273.15..126.85]degC get_parser=float, set_cmd=f"SETP {output_index}, {{}}", get_cmd=f"SETP? {output_index}", )

The value of the setpoint in the preferred units of the control loop sensor (which is set via input_channel parameter)

range_limits: Parameter = self.add_parameter( "range_limits", set_cmd=None, get_cmd=None, vals=vals.Sequence( vals.Numbers(0, 400), require_sorted=True, length=len(self.RANGES) - 1 ), label="Temperature limits for output ranges", unit="K", docstring="Use this parameter to define which " "temperature corresponds to which output " "range; then use the " "`set_range_from_temperature` method to " "set the output range via temperature " "instead of doing it directly", )

Use this parameter to define which temperature corresponds to which output range; then use the set_range_from_temperature method to set the output range via temperature instead of doing it directly

wait_cycle_time: Parameter = self.add_parameter( "wait_cycle_time", set_cmd=None, get_cmd=None, vals=vals.Numbers(0, 100), label="Waiting cycle time", docstring="Time between two readings when waiting " "for temperature to equilibrate", unit="s", )

Time between two readings when waiting for temperature to equilibrate

wait_tolerance: Parameter = self.add_parameter( "wait_tolerance", set_cmd=None, get_cmd=None, vals=vals.Numbers(0, 100), label="Waiting tolerance", docstring="Acceptable tolerance when waiting for " "temperature to equilibrate", unit="", )

Acceptable tolerance when waiting for temperature to equilibrate

wait_equilibration_time: Parameter = self.add_parameter( "wait_equilibration_time", set_cmd=None, get_cmd=None, vals=vals.Numbers(0, 100), label="Waiting equilibration time", docstring="Duration during which temperature has to be within tolerance", unit="s", )

Duration during which temperature has to be within tolerance

blocking_t: Parameter = self.add_parameter( "blocking_t", label="Setpoint value with blocking until it is reached", docstring="Sets the setpoint value, and input " "range, and waits until it is reached. " "Added for compatibility with Loop. Note " "that if the setpoint value is in " "a different range, this function may " "wait forever because that setpoint " "cannot be reached within the current " "range.", vals=vals.Numbers(0, 400), set_cmd=self._set_blocking_t, snapshot_exclude=True, )

Sets the setpoint value, and input range, and waits until it is reached. Added for compatibility with Loop. Note that if the setpoint value is in a different range, this function may wait forever because that setpoint cannot be reached within the current 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] = {}