Lakeshore Drivers

Classes:

LakeshoreBase(name, address[, ...])	This base class has been written to be that base for the Lakeshore 336 and 372.
LakeshoreBaseOutput(parent, output_name, ...)	Base class for the outputs of Lakeshore temperature controllers
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.LakeshoreBase(name: str, address: str, print_connect_message: bool = True, **kwargs: Unpack[VisaInstrumentKWArgs])

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

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.LakeshoreBaseOutput(parent: LakeshoreBase, output_name: str, output_index: int, has_pid: bool = True, **kwargs: Unpack[InstrumentBaseKWArgs])

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_type	0=Current, 1=Voltage
output_heater_resistance	25/50ohm
output_max_current	User Specified, 0.707 A, 1 A, 1.141 A, 1.732
output_max_user_current	Specifies the maximum heater output current if max current is set to User Specified.
output_display	Specifies whether the heater output displays in current or power (current mode only)
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)
setpoint_ramp_enabled	Specifies whether setpoint ramping is 0 = Off or 1 = On
setpoint_ramp_rate	Specifies setpoint ramp rate in kelvin per minute from 0.1 to 100.
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_type: GroupParameter = self.add_parameter( name="output_type", docstring="Output type (Output 2 only): 0=Current, 1=Voltage", val_mapping=( {"current": 0, "voltage": 1} if output_index == 1 else {"current": 0} ), parameter_class=GroupParameter, )

0=Current, 1=Voltage

Type:

Output type (Output 2 only)

output_heater_resistance: GroupParameter = self.add_parameter( name="output_heater_resistance", docstring="Heater Resistance Setting: 25/50ohm", val_mapping={"25ohm": 1, "50ohm": 2}, parameter_class=GroupParameter, )

25/50ohm

Type:

Heater Resistance Setting

output_max_current: GroupParameter = self.add_parameter( name="output_max_current", docstring="Specifies the maximum heater output current: User Specified, 0.707 A, 1 A, 1.141 A, 1.732", val_mapping={"user": 0, "0.707A": 1, "1A": 2, "1.141A": 3, "1.732A": 4}, parameter_class=GroupParameter, )

User Specified, 0.707 A, 1 A, 1.141 A, 1.732

Type:

Specifies the maximum heater output current

output_max_user_current: GroupParameter = self.add_parameter( name="output_max_user_current", docstring="Specifies the maximum heater output current if max current is set to User Specified.", vals=vals.Numbers(0, 1.732), unit="A", get_parser=float, parameter_class=GroupParameter, )

Specifies the maximum heater output current if max current is set to User Specified.

output_display: GroupParameter = self.add_parameter( name="output_display", docstring="Specifies whether the heater output displays in current or power (current mode only)", val_mapping={"current": 1, "power": 2}, parameter_class=GroupParameter, )

Specifies whether the heater output displays in current or power (current mode only)

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)

setpoint_ramp_enabled: GroupParameter = self.add_parameter( "setpoint_ramp_enabled", label="Setpoint ramping enabled", docstring="Specifies whether setpoint ramping is 0 = Off or 1 = On", val_mapping={False: 0, True: 1}, parameter_class=GroupParameter, )

Specifies whether setpoint ramping is 0 = Off or 1 = On

setpoint_ramp_rate: GroupParameter = self.add_parameter( "setpoint_ramp_rate", label="Setpoint ramping rate", unit="K/min", get_parser=float, docstring="Specifies setpoint ramp rate in kelvin per minute from" "0.1 to 100. The rate is always positive, but will respond to" "ramps up or down. A rate of 0 is interpreted as infinite, and" "will therefore respond as if setpoint ramping were off", vals=vals.Numbers(0, 100), parameter_class=GroupParameter, )

Specifies setpoint ramp rate in kelvin per minute from 0.1 to 100. The rate is always positive, but will respond to ramps up or down. A rate of 0 is interpreted as infinite, and will therefore respond as if setpoint ramping were off

setpoint_ramp_status: Parameter = self.add_parameter( "setpoint_ramp_status", label="Setpoint is ramping", docstring="0 = Not ramping, 1 = Setpoint is ramping", val_mapping={True: 1, False: 0}, get_cmd=f"RAMPST? {output_index}", )

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

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

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

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

wait_until_set_point_reached(wait_cycle_time: float | None = None, wait_tolerance: float | None = None, wait_equilibration_time: float | None = None) → None

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

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

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

SENSOR_STATUSES: ClassVar[dict[int, str]] = {}

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])

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

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

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])

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]

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

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

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])

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])

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

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)

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

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

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])

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

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])

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)

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])

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_type: GroupParameter = self.add_parameter( name="output_type", docstring="Output type (Output 2 only): 0=Current, 1=Voltage", val_mapping=( {"current": 0, "voltage": 1} if output_index == 1 else {"current": 0} ), parameter_class=GroupParameter, )

0=Current, 1=Voltage

Type:

Output type (Output 2 only)

output_heater_resistance: GroupParameter = self.add_parameter( name="output_heater_resistance", docstring="Heater Resistance Setting: 25/50ohm", val_mapping={"25ohm": 1, "50ohm": 2}, parameter_class=GroupParameter, )

25/50ohm

Type:

Heater Resistance Setting

output_max_current: GroupParameter = self.add_parameter( name="output_max_current", docstring="Specifies the maximum heater output current: User Specified, 0.707 A, 1 A, 1.141 A, 1.732", val_mapping={"user": 0, "0.707A": 1, "1A": 2, "1.141A": 3, "1.732A": 4}, parameter_class=GroupParameter, )

User Specified, 0.707 A, 1 A, 1.141 A, 1.732

Type:

Specifies the maximum heater output current

output_max_user_current: GroupParameter = self.add_parameter( name="output_max_user_current", docstring="Specifies the maximum heater output current if max current is set to User Specified.", vals=vals.Numbers(0, 1.732), unit="A", get_parser=float, parameter_class=GroupParameter, )

Specifies the maximum heater output current if max current is set to User Specified.

output_display: GroupParameter = self.add_parameter( name="output_display", docstring="Specifies whether the heater output displays in current or power (current mode only)", val_mapping={"current": 1, "power": 2}, parameter_class=GroupParameter, )

Specifies whether the heater output displays in current or power (current mode only)

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)

setpoint_ramp_enabled: GroupParameter = self.add_parameter( "setpoint_ramp_enabled", label="Setpoint ramping enabled", docstring="Specifies whether setpoint ramping is 0 = Off or 1 = On", val_mapping={False: 0, True: 1}, parameter_class=GroupParameter, )

Specifies whether setpoint ramping is 0 = Off or 1 = On

setpoint_ramp_rate: GroupParameter = self.add_parameter( "setpoint_ramp_rate", label="Setpoint ramping rate", unit="K/min", get_parser=float, docstring="Specifies setpoint ramp rate in kelvin per minute from" "0.1 to 100. The rate is always positive, but will respond to" "ramps up or down. A rate of 0 is interpreted as infinite, and" "will therefore respond as if setpoint ramping were off", vals=vals.Numbers(0, 100), parameter_class=GroupParameter, )

Specifies setpoint ramp rate in kelvin per minute from 0.1 to 100. The rate is always positive, but will respond to ramps up or down. A rate of 0 is interpreted as infinite, and will therefore respond as if setpoint ramping were off

setpoint_ramp_status: Parameter = self.add_parameter( "setpoint_ramp_status", label="Setpoint is ramping", docstring="0 = Not ramping, 1 = Setpoint is ramping", val_mapping={True: 1, False: 0}, get_cmd=f"RAMPST? {output_index}", )

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])

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

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]] = {'A': 'A', 'B': 'B', 'C': 'C', 'D': 'D'}

CHANNEL_CLASS

alias of LakeshoreModel336Channel

input_channel_parameter_values_to_channel_name_on_instrument: ClassVar[dict[Any, str]] = {'A': 'A', 'B': 'B', 'C': 'C', 'D': 'D'}

class qcodes.instrument_drivers.Lakeshore.LakeshoreModel336Channel(parent: LakeshoreModel336, name: str, channel: str, **kwargs: Unpack[InstrumentBaseKWArgs])

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)
curve_number	Temperature calibration curve number that is selected now
curve_name	Temperature calibration curve name for the current curve as selected by curve_number
curve_sn	Temperature calibration curve SN for the current curve as selected by curve_number
curve_format	Temperature calibration curve format for the current curve as selected by curve_number
curve_limit	Temperature calibration curve limit value for the current curve as selected by curve_number
curve_coefficient	Temperature calibration curve coefficient for the current curve as selected by curve_number

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)

curve_number: Parameter = self.add_parameter( "curve_number", get_cmd=f"INCRV? {self._channel}", set_cmd=False, get_parser=int, label="Temperature calibration curve number", )

Temperature calibration curve number that is selected now

curve_name: GroupParameter = self.add_parameter( "curve_name", label="Temperature calibration curve name", parameter_class=GroupParameter, )

Temperature calibration curve name for the current curve as selected by curve_number

curve_sn: GroupParameter = self.add_parameter( "curve_sn", label="Temperature calibration curve SN", parameter_class=GroupParameter, )

Temperature calibration curve SN for the current curve as selected by curve_number

curve_format: GroupParameter = self.add_parameter( "curve_format", label="Temperature calibration curve format", get_parser=int, val_mapping={"mV/K": 1, "V/K": 2, "Ohms/K": 3, "log Ohms/K": 4}, parameter_class=GroupParameter, )

Temperature calibration curve format for the current curve as selected by curve_number

curve_limit: GroupParameter = self.add_parameter( "curve_limit", get_parser=float, label="Temperature calibration curve limit value", parameter_class=GroupParameter, )

Temperature calibration curve limit value for the current curve as selected by curve_number

curve_coefficient: GroupParameter = self.add_parameter( "curve_coefficient", get_parser=int, label="Temperature calibration curve coefficient", val_mapping={"negative": 1, "positive": 2}, parameter_class=GroupParameter, )

Temperature calibration curve coefficient for the current curve as selected by curve_number

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])

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_type: GroupParameter = self.add_parameter( name="output_type", docstring="Output type (Output 2 only): 0=Current, 1=Voltage", val_mapping=( {"current": 0, "voltage": 1} if output_index == 1 else {"current": 0} ), parameter_class=GroupParameter, )

0=Current, 1=Voltage

Type:

Output type (Output 2 only)

output_heater_resistance: GroupParameter = self.add_parameter( name="output_heater_resistance", docstring="Heater Resistance Setting: 25/50ohm", val_mapping={"25ohm": 1, "50ohm": 2}, parameter_class=GroupParameter, )

25/50ohm

Type:

Heater Resistance Setting

output_max_current: GroupParameter = self.add_parameter( name="output_max_current", docstring="Specifies the maximum heater output current: User Specified, 0.707 A, 1 A, 1.141 A, 1.732", val_mapping={"user": 0, "0.707A": 1, "1A": 2, "1.141A": 3, "1.732A": 4}, parameter_class=GroupParameter, )

User Specified, 0.707 A, 1 A, 1.141 A, 1.732

Type:

Specifies the maximum heater output current

output_max_user_current: GroupParameter = self.add_parameter( name="output_max_user_current", docstring="Specifies the maximum heater output current if max current is set to User Specified.", vals=vals.Numbers(0, 1.732), unit="A", get_parser=float, parameter_class=GroupParameter, )

Specifies the maximum heater output current if max current is set to User Specified.

output_display: GroupParameter = self.add_parameter( name="output_display", docstring="Specifies whether the heater output displays in current or power (current mode only)", val_mapping={"current": 1, "power": 2}, parameter_class=GroupParameter, )

Specifies whether the heater output displays in current or power (current mode only)

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)

setpoint_ramp_enabled: GroupParameter = self.add_parameter( "setpoint_ramp_enabled", label="Setpoint ramping enabled", docstring="Specifies whether setpoint ramping is 0 = Off or 1 = On", val_mapping={False: 0, True: 1}, parameter_class=GroupParameter, )

Specifies whether setpoint ramping is 0 = Off or 1 = On

setpoint_ramp_rate: GroupParameter = self.add_parameter( "setpoint_ramp_rate", label="Setpoint ramping rate", unit="K/min", get_parser=float, docstring="Specifies setpoint ramp rate in kelvin per minute from" "0.1 to 100. The rate is always positive, but will respond to" "ramps up or down. A rate of 0 is interpreted as infinite, and" "will therefore respond as if setpoint ramping were off", vals=vals.Numbers(0, 100), parameter_class=GroupParameter, )

Specifies setpoint ramp rate in kelvin per minute from 0.1 to 100. The rate is always positive, but will respond to ramps up or down. A rate of 0 is interpreted as infinite, and will therefore respond as if setpoint ramping were off

setpoint_ramp_status: Parameter = self.add_parameter( "setpoint_ramp_status", label="Setpoint is ramping", docstring="0 = Not ramping, 1 = Setpoint is ramping", val_mapping={True: 1, False: 0}, get_cmd=f"RAMPST? {output_index}", )

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])

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_type: GroupParameter = self.add_parameter( name="output_type", docstring="Output type (Output 2 only): 0=Current, 1=Voltage", val_mapping=( {"current": 0, "voltage": 1} if output_index == 1 else {"current": 0} ), parameter_class=GroupParameter, )

0=Current, 1=Voltage

Type:

Output type (Output 2 only)

output_heater_resistance: GroupParameter = self.add_parameter( name="output_heater_resistance", docstring="Heater Resistance Setting: 25/50ohm", val_mapping={"25ohm": 1, "50ohm": 2}, parameter_class=GroupParameter, )

25/50ohm

Type:

Heater Resistance Setting

output_max_current: GroupParameter = self.add_parameter( name="output_max_current", docstring="Specifies the maximum heater output current: User Specified, 0.707 A, 1 A, 1.141 A, 1.732", val_mapping={"user": 0, "0.707A": 1, "1A": 2, "1.141A": 3, "1.732A": 4}, parameter_class=GroupParameter, )

User Specified, 0.707 A, 1 A, 1.141 A, 1.732

Type:

Specifies the maximum heater output current

output_max_user_current: GroupParameter = self.add_parameter( name="output_max_user_current", docstring="Specifies the maximum heater output current if max current is set to User Specified.", vals=vals.Numbers(0, 1.732), unit="A", get_parser=float, parameter_class=GroupParameter, )

Specifies the maximum heater output current if max current is set to User Specified.

output_display: GroupParameter = self.add_parameter( name="output_display", docstring="Specifies whether the heater output displays in current or power (current mode only)", val_mapping={"current": 1, "power": 2}, parameter_class=GroupParameter, )

Specifies whether the heater output displays in current or power (current mode only)

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)

setpoint_ramp_enabled: GroupParameter = self.add_parameter( "setpoint_ramp_enabled", label="Setpoint ramping enabled", docstring="Specifies whether setpoint ramping is 0 = Off or 1 = On", val_mapping={False: 0, True: 1}, parameter_class=GroupParameter, )

Specifies whether setpoint ramping is 0 = Off or 1 = On

setpoint_ramp_rate: GroupParameter = self.add_parameter( "setpoint_ramp_rate", label="Setpoint ramping rate", unit="K/min", get_parser=float, docstring="Specifies setpoint ramp rate in kelvin per minute from" "0.1 to 100. The rate is always positive, but will respond to" "ramps up or down. A rate of 0 is interpreted as infinite, and" "will therefore respond as if setpoint ramping were off", vals=vals.Numbers(0, 100), parameter_class=GroupParameter, )

Specifies setpoint ramp rate in kelvin per minute from 0.1 to 100. The rate is always positive, but will respond to ramps up or down. A rate of 0 is interpreted as infinite, and will therefore respond as if setpoint ramping were off

setpoint_ramp_status: Parameter = self.add_parameter( "setpoint_ramp_status", label="Setpoint is ramping", docstring="0 = Not ramping, 1 = Setpoint is ramping", val_mapping={True: 1, False: 0}, get_cmd=f"RAMPST? {output_index}", )

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])

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

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

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
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])

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_type: GroupParameter = self.add_parameter( name="output_type", docstring="Output type (Output 2 only): 0=Current, 1=Voltage", val_mapping=( {"current": 0, "voltage": 1} if output_index == 1 else {"current": 0} ), parameter_class=GroupParameter, )

0=Current, 1=Voltage

Type:

Output type (Output 2 only)

output_heater_resistance: GroupParameter = self.add_parameter( name="output_heater_resistance", docstring="Heater Resistance Setting: 25/50ohm", val_mapping={"25ohm": 1, "50ohm": 2}, parameter_class=GroupParameter, )

25/50ohm

Type:

Heater Resistance Setting

output_max_current: GroupParameter = self.add_parameter( name="output_max_current", docstring="Specifies the maximum heater output current: User Specified, 0.707 A, 1 A, 1.141 A, 1.732", val_mapping={"user": 0, "0.707A": 1, "1A": 2, "1.141A": 3, "1.732A": 4}, parameter_class=GroupParameter, )

User Specified, 0.707 A, 1 A, 1.141 A, 1.732

Type:

Specifies the maximum heater output current

output_max_user_current: GroupParameter = self.add_parameter( name="output_max_user_current", docstring="Specifies the maximum heater output current if max current is set to User Specified.", vals=vals.Numbers(0, 1.732), unit="A", get_parser=float, parameter_class=GroupParameter, )

Specifies the maximum heater output current if max current is set to User Specified.

output_display: GroupParameter = self.add_parameter( name="output_display", docstring="Specifies whether the heater output displays in current or power (current mode only)", val_mapping={"current": 1, "power": 2}, parameter_class=GroupParameter, )

Specifies whether the heater output displays in current or power (current mode only)

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)

setpoint_ramp_enabled: GroupParameter = self.add_parameter( "setpoint_ramp_enabled", label="Setpoint ramping enabled", docstring="Specifies whether setpoint ramping is 0 = Off or 1 = On", val_mapping={False: 0, True: 1}, parameter_class=GroupParameter, )

Specifies whether setpoint ramping is 0 = Off or 1 = On

setpoint_ramp_rate: GroupParameter = self.add_parameter( "setpoint_ramp_rate", label="Setpoint ramping rate", unit="K/min", get_parser=float, docstring="Specifies setpoint ramp rate in kelvin per minute from" "0.1 to 100. The rate is always positive, but will respond to" "ramps up or down. A rate of 0 is interpreted as infinite, and" "will therefore respond as if setpoint ramping were off", vals=vals.Numbers(0, 100), parameter_class=GroupParameter, )

Specifies setpoint ramp rate in kelvin per minute from 0.1 to 100. The rate is always positive, but will respond to ramps up or down. A rate of 0 is interpreted as infinite, and will therefore respond as if setpoint ramping were off

setpoint_ramp_status: Parameter = self.add_parameter( "setpoint_ramp_status", label="Setpoint is ramping", docstring="0 = Not ramping, 1 = Setpoint is ramping", val_mapping={True: 1, False: 0}, get_cmd=f"RAMPST? {output_index}", )

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