Lakeshore Drivers

Classes:

`LakeshoreBaseOutput`(parent, output_name, ...)	Base class for the outputs of Lakeshore temperature controllers
`LakeshoreBase`(name, address[, ...])	This base class has been written to be that base for the Lakeshore 336 and 372.
`LakeshoreBaseSensorChannel`(parent, name, ...)	Base class for Lakeshore Temperature Controller sensor channels
`LakeshoreModel325`(name, address, **kwargs)	QCoDeS driver for Lakeshore Model 325 Temperature Controller.
`LakeshoreModel325Curve`(parent, index, **kwargs)	An InstrumentChannel representing a curve on a Lakeshore Model 325
`LakeshoreModel325Heater`(parent, name, loop, ...)	InstrumentChannel for heater control on a Lakeshore Model 325.
`LakeshoreModel325Sensor`(parent, name, inp, ...)	InstrumentChannel for a single sensor of a Lakeshore Model 325.
`LakeshoreModel325Status`(value[, names, ...])	IntFlag that defines status codes for Lakeshore Model 325
`LakeshoreModel335`(name, address, **kwargs)	Lakeshore Model 335 Temperature Controller Driver
`LakeshoreModel335Channel`(parent, name, ...)	An InstrumentChannel representing a single sensor on a Lakeshore Model 335.
`LakeshoreModel335CurrentSource`(parent, ...)	InstrumentChannel for current sources on Lakeshore Model 335.
`LakeshoreModel336`(name, address, **kwargs)	QCoDeS driver for Lakeshore Model 336 Temperature Controller.
`LakeshoreModel336Channel`(parent, name, ...)	An InstrumentChannel representing a single sensor on a Lakeshore Model 336.
`LakeshoreModel336CurrentSource`(parent, ...)	InstrumentChannel for current sources on Lakeshore Model 336.
`LakeshoreModel336VoltageSource`(parent, ...)	InstrumentChannel for voltage sources on Lakeshore Model 336.
`LakeshoreModel372`(name, address, **kwargs)	QCoDeS driver for Lakeshore Model 372 Temperature Controller.
`LakeshoreModel372Channel`(parent, name, ...)	An InstrumentChannel representing a single sensor on a Lakeshore Model 372.
`LakeshoreModel372Output`(parent, output_name, ...)	An InstrumentChannel for control outputs (heaters) of Lakeshore Model 372

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

Bases: InstrumentChannel

Base class for the outputs of Lakeshore temperature controllers

Parameters:

parent – instrument that this channel belongs to
output_name – name of this output
output_index – identifier for this output that is used in VISA commands of the instrument
has_pid – if True, then the output supports closed loop control, hence it will have three parameters to set it up: ‘P’, ‘I’, and ‘D’
**kwargs – Forwarded to baseclass.

Attributes:

`MODES`
`RANGES`
`mode`	Specifies the control mode
`input_channel`	Specifies which measurement input to control from (note that only measurement inputs are available)
`powerup_enable`	Specifies whether the output remains on or shuts off after power cycle.
`P`	The value for closed control loop Proportional (gain)
`I`	The value for closed control loop Integral (reset)
`D`	The value for closed control loop Derivative (rate)
`output_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)
`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)

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

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

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

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

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

set_range_from_temperature(temperature: float) → str[source]

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

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

Parameters:: temperature – temperature to set the range from
Returns:: the value of the resulting output_range, that is also available from the output_range parameter itself

set_setpoint_and_range(temperature: float) → None[source]

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

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

Parameters:: temperature – temperature in K

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

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

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

Parameters:

wait_cycle_time – this time is being waited between the readings (same as wait_cycle_time parameter); if None, then the value of the corresponding wait_cycle_time parameter is used
wait_tolerance – this value is used to determine if the reading value is close enough to the setpoint value according to the following formula: abs(t_reading - t_setpoint)/t_reading < wait_tolerance (same as wait_tolerance parameter); if None, then the value of the corresponding wait_tolerance parameter is used
wait_equilibration_time – within this time, the reading value has to stay within the defined tolerance in order for this function to return (same as wait_equilibration_time parameter); if None, then the value of the corresponding wait_equilibration_time parameter is used

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

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

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

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

log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)

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

class qcodes.instrument_drivers.Lakeshore.LakeshoreBase(name: str, address: str, print_connect_message: bool = True, **kwargs: Unpack[VisaInstrumentKWArgs])[source]

Bases: VisaInstrument

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

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

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

Classes:

CHANNEL_CLASS

alias of LakeshoreBaseSensorChannel

Attributes:

`channel_name_command`
`input_channel_parameter_values_to_channel_name_on_instrument`
`default_terminator`	The default terminator to use if the terminator is not specified when creating the instrument.

visabackend: str = visabackend

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

visalib: str | None = visalib

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

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

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

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

log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)

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

CHANNEL_CLASS

alias of LakeshoreBaseSensorChannel Attributes:

`SENSOR_STATUSES`
`temperature`	Parameter temperature
`t_limit`	The temperature limit in kelvin for which to shut down all control outputs when exceeded.
`sensor_raw`	Parameter sensor_raw
`sensor_status`	Parameter sensor_status
`sensor_name`	Parameter sensor_name

channel_name_command: ClassVar[dict[str, str]] = {}

input_channel_parameter_values_to_channel_name_on_instrument: ClassVar[dict[Any, str]]

default_terminator: str | None = '\r\n': The default terminator to use if the terminator is not specified when creating the instrument. None means use the default terminator from PyVisa.

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

Bases: InstrumentChannel

Base class for Lakeshore Temperature Controller sensor channels

Parameters:

parent – instrument instance that this channel belongs to
name – name of the channel
channel – string identifier of the channel as referenced in commands; for example, ‘1’ or ‘6’ for model 372, or ‘A’ and ‘C’ for model 336
**kwargs – Forwarded to base class.

Attributes:

`parameters`	All the parameters supported by this instrument.
`functions`	All the functions supported by this instrument.
`submodules`	All the submodules of this instrument such as channel lists or logical groupings of parameters.
`instrument_modules`	All the `InstrumentModule` of this instrument Usually populated via `add_submodule()`.
`log`
`metadata`
`SENSOR_STATUSES`
`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])[source]

Bases: VisaInstrument

QCoDeS driver for Lakeshore Model 325 Temperature Controller.

Attributes:

default_terminator

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

Methods:

`upload_curve`(index, name, serial_number, ...)	Upload a curve to the given index
`upload_curve_from_file`(index, file_path)	Upload a curve from a curve file.

visabackend: str = visabackend

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

visalib: str | None = visalib

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

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

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

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

log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)

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

default_terminator: str | None = '\r\n': The default terminator to use if the terminator is not specified when creating the instrument. None means use the default terminator from PyVisa.

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

Upload a curve to the given index

Parameters:

index – The index to upload the curve to. We can only use indices reserved for user defined curves, 21-35
name – Name of the curve
serial_number – Serial number of the curve
data_dict – A dictionary containing the curve data

upload_curve_from_file(index: int, file_path: str) → None[source]: Upload a curve from a curve file. Note that we only support curve files with extension .330

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

Bases: InstrumentChannel

An InstrumentChannel representing a curve on a Lakeshore Model 325

Attributes:

`valid_sensor_units`
`temperature_key`
`serial_number`	Parameter serial_number
`format`	Parameter format
`limit_value`	Parameter limit_value
`coefficient`	Parameter coefficient
`curve_name`	Parameter curve_name

Methods:

`get_data`()
`validate_datadict`(data_dict)	A data dict has two keys, one of which is 'Temperature (K)'.
`set_data`(data_dict[, sensor_unit])	Set the curve data according to the values found the the dictionary.

valid_sensor_units = ('mV', 'V', 'Ohm', 'log Ohm')

temperature_key = 'Temperature (K)'

serial_number: GroupParameter = self.add_parameter( "serial_number", parameter_class=GroupParameter ): Parameter serial_number

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

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

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

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

get_data() → dict[Any, Any][source]

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

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

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

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

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

Parameters:

data_dict (dict) – See validate_datadict to see the format of this dictionary
sensor_unit (str) – If None, the data dict is validated and the units are extracted.

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

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

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

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

log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)

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

class qcodes.instrument_drivers.Lakeshore.LakeshoreModel325Heater(parent: LakeshoreModel325, name: str, loop: int, **kwargs: Unpack[InstrumentBaseKWArgs])[source]

Bases: InstrumentChannel

InstrumentChannel for heater control on a Lakeshore Model 325.

Parameters:

parent – The instrument this heater belongs to
name – Name of the Channel
loop – Either 1 or 2
**kwargs – Forwarded to baseclass.

Attributes:

`control_mode`	Parameter control_mode
`input_channel`	Parameter input_channel
`unit`	Parameter unit
`powerup_enable`	Parameter powerup_enable
`output_metric`	Parameter output_metric
`P`	Parameter P
`I`	Parameter I
`D`	Parameter D
`output_range`	Parameter output_range
`setpoint`	Parameter setpoint
`ramp_state`	Parameter ramp_state
`ramp_rate`	Parameter ramp_rate
`is_ramping`	Parameter is_ramping
`resistance`	Parameter resistance
`heater_output`	Parameter heater_output

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

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

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

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

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

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

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

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

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

log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)

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

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

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

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

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

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

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

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

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

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

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

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

Bases: InstrumentChannel

InstrumentChannel for a single sensor of a Lakeshore Model 325.

Parameters:

parent (LakeshoreModel325) – The instrument this heater belongs to
name (str)
inp (str) – Either “A” or “B”

Attributes:

`temperature`	Parameter temperature
`status`	Parameter status
`type`	Parameter type
`compensation`	Parameter compensation
`curve_index`	Parameter curve_index
`curve`

Methods:

decode_sensor_status(sum_of_codes)

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

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

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

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

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

static decode_sensor_status(sum_of_codes: int) → str[source]

property curve: LakeshoreModel325Curve

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

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

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

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

log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)

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

class qcodes.instrument_drivers.Lakeshore.LakeshoreModel325Status(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)[source]

Bases: IntFlag

IntFlag that defines status codes for Lakeshore Model 325

Attributes:

`sensor_units_overrang`
`sensor_units_zero`
`temp_overrange`
`temp_underrange`
`invalid_reading`

Methods:

`from_bytes`(bytes[, byteorder, signed])	Return the integer represented by the given array of bytes.
`to_bytes`([length, byteorder, signed])	Return an array of bytes representing an integer.

sensor_units_overrang = 128

sensor_units_zero = 64

temp_overrange = 32

temp_underrange = 16

invalid_reading = 1

classmethod from_bytes(bytes: Iterable[SupportsIndex] | SupportsBytes | Buffer, byteorder: Literal['big', 'little'] = 'big', *, signed: bool = False) → Self[source]

Return the integer represented by the given array of bytes.

Parameters:

bytes – Holds the array of bytes to convert. The argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol.
byteorder – The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use sys.byteorder as the byte order value. Default is to use ‘big’.
signed – Indicates whether two’s complement is used to represent the integer.

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

Return an array of bytes representing an integer.

Parameters:

length – Length of bytes object to use. An OverflowError is raised if the integer is not representable with the given number of bytes. Default is length 1.
byteorder – The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use sys.byteorder as the byte order value. Default is to use ‘big’.
signed – Determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.

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

Bases: LakeshoreBase

Lakeshore Model 335 Temperature Controller Driver

Attributes:

`channel_name_command`
`input_channel_parameter_values_to_channel_name_on_instrument`

Classes:

CHANNEL_CLASS

alias of LakeshoreModel335Channel

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

CHANNEL_CLASS

alias of LakeshoreModel335Channel Attributes:

`SENSOR_STATUSES`
`sensor_type`	Specifies input sensor type
`auto_range_enabled`	Specifies if autoranging is enabled.
`range`	Specifies input range when autorange is not enabled.
`compensation_enabled`	Specifies input compensation.
`units`	Specifies the preferred units parameter for sensor readings and for the control setpoint (kelvin, celsius, or sensor)

visabackend: str = visabackend

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

visalib: str | None = visalib

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

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

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

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

log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)

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

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

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

Bases: LakeshoreBaseSensorChannel

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

Base class for Lakeshore Temperature Controller sensor channels

Parameters:

parent – instrument instance that this channel belongs to
name – name of the channel
channel – string identifier of the channel as referenced in commands; for example, ‘1’ or ‘6’ for model 372, or ‘A’ and ‘C’ for model 336
**kwargs – Forwarded to base class.

Attributes:

`SENSOR_STATUSES`
`sensor_type`	Specifies input sensor type
`auto_range_enabled`	Specifies if autoranging is enabled.
`range`	Specifies input range when autorange is not enabled.
`compensation_enabled`	Specifies input compensation.
`units`	Specifies the preferred units parameter for sensor readings and for the control setpoint (kelvin, celsius, or sensor)
`temperature`	Parameter temperature
`t_limit`	The temperature limit in kelvin for which to shut down all control outputs when exceeded.
`sensor_raw`	Parameter sensor_raw
`sensor_status`	Parameter sensor_status
`sensor_name`	Parameter sensor_name
`parameters`	All the parameters supported by this instrument.
`functions`	All the functions supported by this instrument.
`submodules`	All the submodules of this instrument such as channel lists or logical groupings of parameters.
`instrument_modules`	All the `InstrumentModule` of this instrument Usually populated via `add_submodule()`.
`log`
`metadata`

SENSOR_STATUSES: ClassVar[dict[int, str]] = {0: 'OK', 1: 'Invalid Reading', 16: 'Temp Underrange', 32: 'Temp Overrange', 64: 'Sensor Units Zero', 128: 'Sensor Units Overrange'}

sensor_type: GroupParameter = self.add_parameter( "sensor_type", label="Input sensor type", docstring="Specifies input sensor type", val_mapping={ "disabled": 0, "diode": 1, "platinum_rtd": 2, "ntc_rtd": 3, "thermocouple": 4, }, parameter_class=GroupParameter, ): Specifies input sensor type

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

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

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

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

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

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

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

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

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

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

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

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

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

log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)

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

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

Bases: LakeshoreBaseOutput

InstrumentChannel for current sources on Lakeshore Model 335.

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

Base class for the outputs of Lakeshore temperature controllers

Parameters:

parent – instrument that this channel belongs to
output_name – name of this output
output_index – identifier for this output that is used in VISA commands of the instrument
has_pid – if True, then the output supports closed loop control, hence it will have three parameters to set it up: ‘P’, ‘I’, and ‘D’
**kwargs – Forwarded to baseclass.

Attributes:

`MODES`
`RANGES`

MODES: ClassVar[dict[str, int]] = {'closed_loop': 1, 'off': 0, 'open_loop': 3, 'zone': 2}

RANGES: ClassVar[dict[str, int]] = {'high': 3, 'low': 1, 'medium': 2, 'off': 0}

INVERSE_RANGES: dict[int, str] = {v: k for k, v in self.RANGES.items()}

mode: GroupParameter = self.add_parameter( "mode", label="Control mode", docstring="Specifies the control mode", val_mapping=self.MODES, parameter_class=GroupParameter, ): Specifies the control mode

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

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

P: GroupParameter: The value for closed control loop Proportional (gain)

I: GroupParameter: The value for closed control loop Integral (reset)

D: GroupParameter: The value for closed control loop Derivative (rate)

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

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

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

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

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

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

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

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

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

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

log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)

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

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

Bases: LakeshoreBase

QCoDeS driver for Lakeshore Model 336 Temperature Controller.

Attributes:

`channel_name_command`
`input_channel_parameter_values_to_channel_name_on_instrument`

Classes:

CHANNEL_CLASS

alias of LakeshoreModel336Channel

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

CHANNEL_CLASS

alias of LakeshoreModel336Channel Attributes:

`SENSOR_STATUSES`
`sensor_type`	Specifies input sensor type
`auto_range_enabled`	Specifies if autoranging is enabled.
`range`	Specifies input range when autorange is not enabled.
`compensation_enabled`	Specifies input compensation.
`units`	Specifies the preferred units parameter for sensor readings and for the control setpoint (kelvin, celsius, or sensor)

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

visabackend: str = visabackend

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

visalib: str | None = visalib

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

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

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

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

log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)

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

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

Bases: LakeshoreBaseSensorChannel

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

Base class for Lakeshore Temperature Controller sensor channels

Parameters:

parent – instrument instance that this channel belongs to
name – name of the channel
channel – string identifier of the channel as referenced in commands; for example, ‘1’ or ‘6’ for model 372, or ‘A’ and ‘C’ for model 336
**kwargs – Forwarded to base class.

Attributes:

`SENSOR_STATUSES`
`sensor_type`	Specifies input sensor type
`auto_range_enabled`	Specifies if autoranging is enabled.
`range`	Specifies input range when autorange is not enabled.
`compensation_enabled`	Specifies input compensation.
`units`	Specifies the preferred units parameter for sensor readings and for the control setpoint (kelvin, celsius, or sensor)
`temperature`	Parameter temperature
`t_limit`	The temperature limit in kelvin for which to shut down all control outputs when exceeded.
`sensor_raw`	Parameter sensor_raw
`sensor_status`	Parameter sensor_status
`sensor_name`	Parameter sensor_name
`parameters`	All the parameters supported by this instrument.
`functions`	All the functions supported by this instrument.
`submodules`	All the submodules of this instrument such as channel lists or logical groupings of parameters.
`instrument_modules`	All the `InstrumentModule` of this instrument Usually populated via `add_submodule()`.
`log`
`metadata`

SENSOR_STATUSES: ClassVar[dict[int, str]] = {0: 'OK', 1: 'Invalid Reading', 16: 'Temp Underrange', 32: 'Temp Overrange', 64: 'Sensor Units Zero', 128: 'Sensor Units Overrange'}

sensor_type: GroupParameter = self.add_parameter( "sensor_type", label="Input sensor type", docstring="Specifies input sensor type", val_mapping={"disabled": 0, "diode": 1, "platinum_rtd": 2, "ntc_rtd": 3}, parameter_class=GroupParameter, ): Specifies input sensor type

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

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

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

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

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

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

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

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

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

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

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

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

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

log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)

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

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

Bases: LakeshoreBaseOutput

InstrumentChannel for current sources on Lakeshore Model 336.

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

Base class for the outputs of Lakeshore temperature controllers

Parameters:

parent – instrument that this channel belongs to
output_name – name of this output
output_index – identifier for this output that is used in VISA commands of the instrument
has_pid – if True, then the output supports closed loop control, hence it will have three parameters to set it up: ‘P’, ‘I’, and ‘D’
**kwargs – Forwarded to baseclass.

Attributes:

`MODES`
`RANGES`

MODES: ClassVar[dict[str, int]] = {'closed_loop': 1, 'off': 0, 'open_loop': 3, 'zone': 2}

RANGES: ClassVar[dict[str, int]] = {'high': 3, 'low': 1, 'medium': 2, 'off': 0}

INVERSE_RANGES: dict[int, str] = {v: k for k, v in self.RANGES.items()}

mode: GroupParameter = self.add_parameter( "mode", label="Control mode", docstring="Specifies the control mode", val_mapping=self.MODES, parameter_class=GroupParameter, ): Specifies the control mode

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

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

P: GroupParameter: The value for closed control loop Proportional (gain)

I: GroupParameter: The value for closed control loop Integral (reset)

D: GroupParameter: The value for closed control loop Derivative (rate)

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

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

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

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

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

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

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

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

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

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

log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)

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

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

Bases: LakeshoreBaseOutput

InstrumentChannel for voltage sources on Lakeshore Model 336.

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

Base class for the outputs of Lakeshore temperature controllers

Parameters:

parent – instrument that this channel belongs to
output_name – name of this output
output_index – identifier for this output that is used in VISA commands of the instrument
has_pid – if True, then the output supports closed loop control, hence it will have three parameters to set it up: ‘P’, ‘I’, and ‘D’
**kwargs – Forwarded to baseclass.

Attributes:

`MODES`
`RANGES`

MODES: ClassVar[dict[str, int]] = {'closed_loop': 1, 'monitor_out': 4, 'off': 0, 'open_loop': 3, 'warm_up': 5, 'zone': 2}

RANGES: ClassVar[dict[str, int]] = {'high': 3, 'low': 1, 'medium': 2, 'off': 0}

INVERSE_RANGES: dict[int, str] = {v: k for k, v in self.RANGES.items()}

mode: GroupParameter = self.add_parameter( "mode", label="Control mode", docstring="Specifies the control mode", val_mapping=self.MODES, parameter_class=GroupParameter, ): Specifies the control mode

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

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

P: GroupParameter: The value for closed control loop Proportional (gain)

I: GroupParameter: The value for closed control loop Integral (reset)

D: GroupParameter: The value for closed control loop Derivative (rate)

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

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

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

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

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

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

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

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

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

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

log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)

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

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

Bases: LakeshoreBase

QCoDeS driver for Lakeshore Model 372 Temperature Controller.

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

Attributes:

`channel_name_command`
`input_channel_parameter_values_to_channel_name_on_instrument`

Classes:

CHANNEL_CLASS

alias of LakeshoreModel372Channel

visabackend: str = visabackend

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

visalib: str | None = visalib

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

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

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

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

log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)

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

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

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

CHANNEL_CLASS

alias of LakeshoreModel372Channel Attributes:

`SENSOR_STATUSES`
`enabled`	Specifies whether the input/channel is enabled or disabled.
`dwell`	Specifies a value for the autoscanning dwell time.
`pause`	Specifies a value for the change pause time
`curve_number`	0 = no curve, 1 to 59 = standard/user curves.
`temperature_coefficient`	Sets the temperature coefficient that will be used for temperature control if no curve is selected (negative or positive).
`excitation_mode`	Specifies excitation mode
`excitation_range_number`	Specifies excitation range number (1-12 for voltage excitation, 1-22 for current excitation); refer to the manual for the table of ranges
`auto_range`	Specifies auto range setting
`range`	Parameter range
`current_source_shunted`	Current source either not shunted (excitation on), or shunted (excitation off)
`units`	Specifies the preferred units parameter for sensor readings and for the control setpoint (kelvin or ohms)

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

Bases: LakeshoreBaseSensorChannel

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

Base class for Lakeshore Temperature Controller sensor channels

Parameters:

parent – instrument instance that this channel belongs to
name – name of the channel
channel – string identifier of the channel as referenced in commands; for example, ‘1’ or ‘6’ for model 372, or ‘A’ and ‘C’ for model 336
**kwargs – Forwarded to base class.

Attributes:

`SENSOR_STATUSES`
`enabled`	Specifies whether the input/channel is enabled or disabled.
`dwell`	Specifies a value for the autoscanning dwell time.
`pause`	Specifies a value for the change pause time
`curve_number`	0 = no curve, 1 to 59 = standard/user curves.
`temperature_coefficient`	Sets the temperature coefficient that will be used for temperature control if no curve is selected (negative or positive).
`excitation_mode`	Specifies excitation mode
`excitation_range_number`	Specifies excitation range number (1-12 for voltage excitation, 1-22 for current excitation); refer to the manual for the table of ranges
`temperature`	Parameter temperature
`t_limit`	The temperature limit in kelvin for which to shut down all control outputs when exceeded.
`sensor_raw`	Parameter sensor_raw
`sensor_status`	Parameter sensor_status
`sensor_name`	Parameter sensor_name
`parameters`	All the parameters supported by this instrument.
`functions`	All the functions supported by this instrument.
`submodules`	All the submodules of this instrument such as channel lists or logical groupings of parameters.
`instrument_modules`	All the `InstrumentModule` of this instrument Usually populated via `add_submodule()`.
`log`
`metadata`
`auto_range`	Specifies auto range setting
`range`	Parameter range
`current_source_shunted`	Current source either not shunted (excitation on), or shunted (excitation off)
`units`	Specifies the preferred units parameter for sensor readings and for the control setpoint (kelvin or ohms)

SENSOR_STATUSES: ClassVar[dict[int, str]] = {0: 'OK', 1: 'CS OVL', 2: 'VCM OVL', 4: 'VMIX OVL', 8: 'VDIF OVL', 16: 'R. OVER', 32: 'R. UNDER', 64: 'T. OVER', 128: 'T. UNDER'}

enabled: GroupParameter = self.add_parameter( "enabled", label="Enabled", docstring="Specifies whether the input/channel is " "enabled or disabled. At least one " "measurement input channel must be " "enabled. If all are configured to " "disabled, channel 1 will change to " "enabled.", val_mapping={True: 1, False: 0}, parameter_class=GroupParameter, ): Specifies whether the input/channel is enabled or disabled. At least one measurement input channel must be enabled. If all are configured to disabled, channel 1 will change to enabled.

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

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

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

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

Type:: Specifies which curve the channel uses

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

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

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

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

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

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

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

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

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

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

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

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

log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)

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

auto_range: GroupParameter = self.add_parameter( "auto_range", label="Auto range", docstring="Specifies auto range setting", val_mapping={"off": 0, "current": 1}, parameter_class=GroupParameter, ): Specifies auto range setting

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

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

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

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

Bases: LakeshoreBaseOutput

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

Base class for the outputs of Lakeshore temperature controllers

Parameters:

parent – instrument that this channel belongs to
output_name – name of this output
output_index – identifier for this output that is used in VISA commands of the instrument
has_pid – if True, then the output supports closed loop control, hence it will have three parameters to set it up: ‘P’, ‘I’, and ‘D’
**kwargs – Forwarded to baseclass.

Attributes:

`MODES`
`POLARITIES`
`RANGES`
`polarity`	Specifies output polarity (not applicable to warm-up heater)
`use_filter`	Specifies controlling on unfiltered or filtered readings
`delay`	Delay in seconds for setpoint change during Autoscanning

MODES: ClassVar[dict[str, int]] = {'closed_loop': 5, 'monitor_out': 1, 'off': 0, 'open_loop': 2, 'still': 4, 'warm_up': 6, 'zone': 3}

POLARITIES: ClassVar[dict[str, int]] = {'bipolar': 1, 'unipolar': 0}

RANGES: ClassVar[dict[str, int]] = {'100mA': 8, '100μA': 2, '10mA': 6, '1mA': 4, '3.16mA': 5, '31.6mA': 7, '31.6μA': 1, '316μA': 3, 'off': 0}

polarity: GroupParameter = self.add_parameter( "polarity", label="Output polarity", docstring="Specifies output polarity (not applicable to warm-up heater)", val_mapping=self.POLARITIES, parameter_class=GroupParameter, ): Specifies output polarity (not applicable to warm-up heater)

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

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

INVERSE_RANGES: dict[int, str] = {v: k for k, v in self.RANGES.items()}

mode: GroupParameter = self.add_parameter( "mode", label="Control mode", docstring="Specifies the control mode", val_mapping=self.MODES, parameter_class=GroupParameter, ): Specifies the control mode

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

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

P: GroupParameter: The value for closed control loop Proportional (gain)

I: GroupParameter: The value for closed control loop Integral (reset)

D: GroupParameter: The value for closed control loop Derivative (rate)

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

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