Lakeshore Drivers¶
Classes:
|
Base class for the outputs of Lakeshore temperature controllers |
|
This base class has been written to be that base for the Lakeshore 336 and 372. |
|
Base class for Lakeshore Temperature Controller sensor channels |
|
QCoDeS driver for Lakeshore Model 325 Temperature Controller. |
|
An InstrumentChannel representing a curve on a Lakeshore Model 325 |
|
InstrumentChannel for heater control on a Lakeshore Model 325. |
|
InstrumentChannel for a single sensor of a Lakeshore Model 325. |
|
IntFlag that defines status codes for Lakeshore Model 325 |
|
Lakeshore Model 335 Temperature Controller Driver |
|
An InstrumentChannel representing a single sensor on a Lakeshore Model 335. |
|
InstrumentChannel for current sources on Lakeshore Model 335. |
|
QCoDeS driver for Lakeshore Model 336 Temperature Controller. |
|
An InstrumentChannel representing a single sensor on a Lakeshore Model 336. |
|
InstrumentChannel for current sources on Lakeshore Model 336. |
|
InstrumentChannel for voltage sources on Lakeshore Model 336. |
|
QCoDeS driver for Lakeshore Model 372 Temperature Controller. |
|
An InstrumentChannel representing a single sensor on a Lakeshore Model 372. |
|
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:
Specifies the control mode
Specifies which measurement input to control from (note that only measurement inputs are available)
Specifies whether the output remains on or shuts off after power cycle.
The value for closed control loop Proportional (gain)
The value for closed control loop Integral (reset)
The value for closed control loop Derivative (rate)
0=Current, 1=Voltage
25/50ohm
User Specified, 0.707 A, 1 A, 1.141 A, 1.732
Specifies the maximum heater output current if max current is set to User Specified.
Specifies whether the heater output displays in current or power (current mode only)
Specifies heater output range.
Specifies heater output in percent of the current heater output range.
The value of the setpoint in the preferred units of the control loop sensor (which is set via input_channel parameter)
Specifies whether setpoint ramping is 0 = Off or 1 = On
Specifies setpoint ramp rate in kelvin per minute from 0.1 to 100.
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
Time between two readings when waiting for temperature to equilibrate
Acceptable tolerance when waiting for temperature to equilibrate
Duration during which temperature has to be within tolerance
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.
- mode: GroupParameter = self.add_parameter( "mode", label="Control mode", docstring="Specifies the control mode", val_mapping=self.MODES, parameter_class=GroupParameter, )¶
Specifies the control mode
- input_channel: GroupParameter = self.add_parameter( "input_channel", label="Input channel", docstring="Specifies which measurement input to " "control from (note that only " "measurement inputs are available)", parameter_class=GroupParameter, **self._input_channel_parameter_kwargs, )¶
Specifies which measurement input to control from (note that only measurement inputs are available)
- powerup_enable: GroupParameter = self.add_parameter( "powerup_enable", label="Power-up enable on/off", docstring="Specifies whether the output remains on " "or shuts off after power cycle.", val_mapping={True: 1, False: 0}, parameter_class=GroupParameter, )¶
Specifies whether the output remains on or shuts off after power cycle.
- P: GroupParameter¶
The value for closed control loop Proportional (gain)
- I: GroupParameter¶
The value for closed control loop Integral (reset)
- D: GroupParameter¶
The value for closed control loop Derivative (rate)
- output_type: GroupParameter = self.add_parameter( name="output_type", docstring="Output type (Output 2 only): 0=Current, 1=Voltage", val_mapping=( {"current": 0, "voltage": 1} if output_index == 1 else {"current": 0} ), parameter_class=GroupParameter, )¶
0=Current, 1=Voltage
- Type:
Output type (Output 2 only)
- output_heater_resistance: GroupParameter = self.add_parameter( name="output_heater_resistance", docstring="Heater Resistance Setting: 25/50ohm", val_mapping={"25ohm": 1, "50ohm": 2}, parameter_class=GroupParameter, )¶
25/50ohm
- Type:
Heater Resistance Setting
- output_max_current: GroupParameter = self.add_parameter( name="output_max_current", docstring="Specifies the maximum heater output current: User Specified, 0.707 A, 1 A, 1.141 A, 1.732", val_mapping={"user": 0, "0.707A": 1, "1A": 2, "1.141A": 3, "1.732A": 4}, parameter_class=GroupParameter, )¶
User Specified, 0.707 A, 1 A, 1.141 A, 1.732
- Type:
Specifies the maximum heater output current
- output_max_user_current: GroupParameter = self.add_parameter( name="output_max_user_current", docstring="Specifies the maximum heater output current if max current is set to User Specified.", vals=vals.Numbers(0, 1.732), unit="A", get_parser=float, parameter_class=GroupParameter, )¶
Specifies the maximum heater output current if max current is set to User Specified.
- output_display: GroupParameter = self.add_parameter( name="output_display", docstring="Specifies whether the heater output displays in current or power (current mode only)", val_mapping={"current": 1, "power": 2}, parameter_class=GroupParameter, )¶
Specifies whether the heater output displays in current or power (current mode only)
- output_range: Parameter = self.add_parameter( "output_range", label="Heater range", docstring="Specifies heater output range. The range " "setting has no effect if an output is in " "the `Off` mode, and does not apply to " "an output in `Monitor Out` mode. " "An output in `Monitor Out` mode is " "always on.", val_mapping=self.RANGES, set_cmd=f"RANGE {output_index}, {{}}", get_cmd=f"RANGE? {output_index}", )¶
Specifies heater output range. The range setting has no effect if an output is in the Off mode, and does not apply to an output in Monitor Out mode. An output in Monitor Out mode is always on.
- output: Parameter = self.add_parameter( "output", label="Output", unit="% of heater range", docstring="Specifies heater output in percent of " "the current heater output range.\n" "Note that when the heater is off, " "this parameter will return the value " "of 0.005.", get_parser=float, get_cmd=f"HTR? {output_index}", set_cmd=False, )¶
Specifies heater output in percent of the current heater output range. Note that when the heater is off, this parameter will return the value of 0.005.
- setpoint: Parameter = self.add_parameter( "setpoint", label="Setpoint value (in sensor units)", docstring="The value of the setpoint in the " "preferred units of the control loop " "sensor (which is set via " "`input_channel` parameter)", vals=vals.Numbers( -273.15, 400 ), # union of [0..400]K and [-273.15..126.85]degC get_parser=float, set_cmd=f"SETP {output_index}, {{}}", get_cmd=f"SETP? {output_index}", )¶
The value of the setpoint in the preferred units of the control loop sensor (which is set via input_channel parameter)
- setpoint_ramp_enabled: GroupParameter = self.add_parameter( "setpoint_ramp_enabled", label="Setpoint ramping enabled", docstring="Specifies whether setpoint ramping is 0 = Off or 1 = On", val_mapping={False: 0, True: 1}, parameter_class=GroupParameter, )¶
Specifies whether setpoint ramping is 0 = Off or 1 = On
- setpoint_ramp_rate: GroupParameter = self.add_parameter( "setpoint_ramp_rate", label="Setpoint ramping rate", unit="K/min", get_parser=float, docstring="Specifies setpoint ramp rate in kelvin per minute from" "0.1 to 100. The rate is always positive, but will respond to" "ramps up or down. A rate of 0 is interpreted as infinite, and" "will therefore respond as if setpoint ramping were off", vals=vals.Numbers(0, 100), parameter_class=GroupParameter, )¶
Specifies setpoint ramp rate in kelvin per minute from 0.1 to 100. The rate is always positive, but will respond to ramps up or down. A rate of 0 is interpreted as infinite, and will therefore respond as if setpoint ramping were off
- setpoint_ramp_status: Parameter = self.add_parameter( "setpoint_ramp_status", label="Setpoint is ramping", docstring="0 = Not ramping, 1 = Setpoint is ramping", val_mapping={True: 1, False: 0}, get_cmd=f"RAMPST? {output_index}", )¶
- range_limits: Parameter = self.add_parameter( "range_limits", set_cmd=None, get_cmd=None, vals=vals.Sequence( vals.Numbers(0, 400), require_sorted=True, length=len(self.RANGES) - 1 ), label="Temperature limits for output ranges", unit="K", docstring="Use this parameter to define which " "temperature corresponds to which output " "range; then use the " "`set_range_from_temperature` method to " "set the output range via temperature " "instead of doing it directly", )¶
Use this parameter to define which temperature corresponds to which output range; then use the set_range_from_temperature method to set the output range via temperature instead of doing it directly
- wait_cycle_time: Parameter = self.add_parameter( "wait_cycle_time", set_cmd=None, get_cmd=None, vals=vals.Numbers(0, 100), label="Waiting cycle time", docstring="Time between two readings when waiting " "for temperature to equilibrate", unit="s", )¶
Time between two readings when waiting for temperature to equilibrate
- wait_tolerance: Parameter = self.add_parameter( "wait_tolerance", set_cmd=None, get_cmd=None, vals=vals.Numbers(0, 100), label="Waiting tolerance", docstring="Acceptable tolerance when waiting for " "temperature to equilibrate", unit="", )¶
Acceptable tolerance when waiting for temperature to equilibrate
- wait_equilibration_time: Parameter = self.add_parameter( "wait_equilibration_time", set_cmd=None, get_cmd=None, vals=vals.Numbers(0, 100), label="Waiting equilibration time", docstring="Duration during which temperature has to be within tolerance", unit="s", )¶
Duration during which temperature has to be within tolerance
- blocking_t: Parameter = self.add_parameter( "blocking_t", label="Setpoint value with blocking until it is reached", docstring="Sets the setpoint value, and input " "range, and waits until it is reached. " "Added for compatibility with Loop. Note " "that if the setpoint value is in " "a different range, this function may " "wait forever because that setpoint " "cannot be reached within the current " "range.", vals=vals.Numbers(0, 400), set_cmd=self._set_blocking_t, snapshot_exclude=True, )¶
Sets the setpoint value, and input range, and waits until it is reached. Added for compatibility with Loop. Note that if the setpoint value is in a different range, this function may wait forever because that setpoint cannot be reached within the current range.
- set_range_from_temperature(temperature: float) str [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
- 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 viaadd_submodule()
.
- log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)¶
- 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
- 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:
alias of
LakeshoreBaseSensorChannel
Attributes:
input_channel_parameter_values_to_channel_name_on_instrument
The default terminator to use if the terminator is not specified when creating the instrument.
- visa_handle: pyvisa.resources.MessageBasedResource = visa_handle¶
The VISA resource used by this instrument.
- 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 viaadd_submodule()
.
- log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)¶
- 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
- 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:
All the parameters supported by this instrument.
All the functions supported by this instrument.
All the submodules of this instrument such as channel lists or logical groupings of parameters.
All the
InstrumentModule
of this instrument Usually populated viaadd_submodule()
.Parameter temperature
The temperature limit in kelvin for which to shut down all control outputs when exceeded.
Parameter sensor_raw
Parameter sensor_status
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 viaadd_submodule()
.
- log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)¶
- 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
- 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:
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.
- visa_handle: pyvisa.resources.MessageBasedResource = visa_handle¶
The VISA resource used by this instrument.
- 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 viaadd_submodule()
.
- log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)¶
- 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
- 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:
Parameter serial_number
Parameter format
Parameter limit_value
Parameter coefficient
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
- 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: 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 viaadd_submodule()
.
- log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)¶
- 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:
Parameter control_mode
Parameter input_channel
Parameter unit
Parameter powerup_enable
Parameter output_metric
Parameter P
Parameter I
Parameter D
Parameter output_range
Parameter setpoint
Parameter ramp_state
Parameter ramp_rate
Parameter is_ramping
Parameter resistance
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 viaadd_submodule()
.
- log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)¶
- 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
- 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:
Parameter temperature
Parameter status
Parameter type
Parameter compensation
Parameter curve_index
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
- 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 viaadd_submodule()
.
- log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)¶
- 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:
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:
Classes:
alias of
LakeshoreModel335Channel
- 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)
- visa_handle: pyvisa.resources.MessageBasedResource = visa_handle¶
The VISA resource used by this instrument.
- 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 viaadd_submodule()
.
- log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)¶
- 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:
Specifies input sensor type
Specifies if autoranging is enabled.
Specifies input range when autorange is not enabled.
Specifies input compensation.
Specifies the preferred units parameter for sensor readings and for the control setpoint (kelvin, celsius, or sensor)
Parameter temperature
The temperature limit in kelvin for which to shut down all control outputs when exceeded.
Parameter sensor_raw
Parameter sensor_status
Parameter sensor_name
All the parameters supported by this instrument.
All the functions supported by this instrument.
All the submodules of this instrument such as channel lists or logical groupings of parameters.
All the
InstrumentModule
of this instrument Usually populated viaadd_submodule()
.- 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 viaadd_submodule()
.
- log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)¶
- 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:
- mode: GroupParameter = self.add_parameter( "mode", label="Control mode", docstring="Specifies the control mode", val_mapping=self.MODES, parameter_class=GroupParameter, )¶
Specifies the control mode
- input_channel: GroupParameter = self.add_parameter( "input_channel", label="Input channel", docstring="Specifies which measurement input to " "control from (note that only " "measurement inputs are available)", parameter_class=GroupParameter, **self._input_channel_parameter_kwargs, )¶
Specifies which measurement input to control from (note that only measurement inputs are available)
- powerup_enable: GroupParameter = self.add_parameter( "powerup_enable", label="Power-up enable on/off", docstring="Specifies whether the output remains on " "or shuts off after power cycle.", val_mapping={True: 1, False: 0}, parameter_class=GroupParameter, )¶
Specifies whether the output remains on or shuts off after power cycle.
- P: GroupParameter¶
The value for closed control loop Proportional (gain)
- I: GroupParameter¶
The value for closed control loop Integral (reset)
- D: GroupParameter¶
The value for closed control loop Derivative (rate)
- output_type: GroupParameter = self.add_parameter( name="output_type", docstring="Output type (Output 2 only): 0=Current, 1=Voltage", val_mapping=( {"current": 0, "voltage": 1} if output_index == 1 else {"current": 0} ), parameter_class=GroupParameter, )¶
0=Current, 1=Voltage
- Type:
Output type (Output 2 only)
- output_heater_resistance: GroupParameter = self.add_parameter( name="output_heater_resistance", docstring="Heater Resistance Setting: 25/50ohm", val_mapping={"25ohm": 1, "50ohm": 2}, parameter_class=GroupParameter, )¶
25/50ohm
- Type:
Heater Resistance Setting
- output_max_current: GroupParameter = self.add_parameter( name="output_max_current", docstring="Specifies the maximum heater output current: User Specified, 0.707 A, 1 A, 1.141 A, 1.732", val_mapping={"user": 0, "0.707A": 1, "1A": 2, "1.141A": 3, "1.732A": 4}, parameter_class=GroupParameter, )¶
User Specified, 0.707 A, 1 A, 1.141 A, 1.732
- Type:
Specifies the maximum heater output current
- output_max_user_current: GroupParameter = self.add_parameter( name="output_max_user_current", docstring="Specifies the maximum heater output current if max current is set to User Specified.", vals=vals.Numbers(0, 1.732), unit="A", get_parser=float, parameter_class=GroupParameter, )¶
Specifies the maximum heater output current if max current is set to User Specified.
- output_display: GroupParameter = self.add_parameter( name="output_display", docstring="Specifies whether the heater output displays in current or power (current mode only)", val_mapping={"current": 1, "power": 2}, parameter_class=GroupParameter, )¶
Specifies whether the heater output displays in current or power (current mode only)
- output_range: Parameter = self.add_parameter( "output_range", label="Heater range", docstring="Specifies heater output range. The range " "setting has no effect if an output is in " "the `Off` mode, and does not apply to " "an output in `Monitor Out` mode. " "An output in `Monitor Out` mode is " "always on.", val_mapping=self.RANGES, set_cmd=f"RANGE {output_index}, {{}}", get_cmd=f"RANGE? {output_index}", )¶
Specifies heater output range. The range setting has no effect if an output is in the Off mode, and does not apply to an output in Monitor Out mode. An output in Monitor Out mode is always on.
- output: Parameter = self.add_parameter( "output", label="Output", unit="% of heater range", docstring="Specifies heater output in percent of " "the current heater output range.\n" "Note that when the heater is off, " "this parameter will return the value " "of 0.005.", get_parser=float, get_cmd=f"HTR? {output_index}", set_cmd=False, )¶
Specifies heater output in percent of the current heater output range. Note that when the heater is off, this parameter will return the value of 0.005.
- setpoint: Parameter = self.add_parameter( "setpoint", label="Setpoint value (in sensor units)", docstring="The value of the setpoint in the " "preferred units of the control loop " "sensor (which is set via " "`input_channel` parameter)", vals=vals.Numbers( -273.15, 400 ), # union of [0..400]K and [-273.15..126.85]degC get_parser=float, set_cmd=f"SETP {output_index}, {{}}", get_cmd=f"SETP? {output_index}", )¶
The value of the setpoint in the preferred units of the control loop sensor (which is set via input_channel parameter)
- setpoint_ramp_enabled: GroupParameter = self.add_parameter( "setpoint_ramp_enabled", label="Setpoint ramping enabled", docstring="Specifies whether setpoint ramping is 0 = Off or 1 = On", val_mapping={False: 0, True: 1}, parameter_class=GroupParameter, )¶
Specifies whether setpoint ramping is 0 = Off or 1 = On
- setpoint_ramp_rate: GroupParameter = self.add_parameter( "setpoint_ramp_rate", label="Setpoint ramping rate", unit="K/min", get_parser=float, docstring="Specifies setpoint ramp rate in kelvin per minute from" "0.1 to 100. The rate is always positive, but will respond to" "ramps up or down. A rate of 0 is interpreted as infinite, and" "will therefore respond as if setpoint ramping were off", vals=vals.Numbers(0, 100), parameter_class=GroupParameter, )¶
Specifies setpoint ramp rate in kelvin per minute from 0.1 to 100. The rate is always positive, but will respond to ramps up or down. A rate of 0 is interpreted as infinite, and will therefore respond as if setpoint ramping were off
- setpoint_ramp_status: Parameter = self.add_parameter( "setpoint_ramp_status", label="Setpoint is ramping", docstring="0 = Not ramping, 1 = Setpoint is ramping", val_mapping={True: 1, False: 0}, get_cmd=f"RAMPST? {output_index}", )¶
- range_limits: Parameter = self.add_parameter( "range_limits", set_cmd=None, get_cmd=None, vals=vals.Sequence( vals.Numbers(0, 400), require_sorted=True, length=len(self.RANGES) - 1 ), label="Temperature limits for output ranges", unit="K", docstring="Use this parameter to define which " "temperature corresponds to which output " "range; then use the " "`set_range_from_temperature` method to " "set the output range via temperature " "instead of doing it directly", )¶
Use this parameter to define which temperature corresponds to which output range; then use the set_range_from_temperature method to set the output range via temperature instead of doing it directly
- wait_cycle_time: Parameter = self.add_parameter( "wait_cycle_time", set_cmd=None, get_cmd=None, vals=vals.Numbers(0, 100), label="Waiting cycle time", docstring="Time between two readings when waiting " "for temperature to equilibrate", unit="s", )¶
Time between two readings when waiting for temperature to equilibrate
- wait_tolerance: Parameter = self.add_parameter( "wait_tolerance", set_cmd=None, get_cmd=None, vals=vals.Numbers(0, 100), label="Waiting tolerance", docstring="Acceptable tolerance when waiting for " "temperature to equilibrate", unit="", )¶
Acceptable tolerance when waiting for temperature to equilibrate
- wait_equilibration_time: Parameter = self.add_parameter( "wait_equilibration_time", set_cmd=None, get_cmd=None, vals=vals.Numbers(0, 100), label="Waiting equilibration time", docstring="Duration during which temperature has to be within tolerance", unit="s", )¶
Duration during which temperature has to be within tolerance
- blocking_t: Parameter = self.add_parameter( "blocking_t", label="Setpoint value with blocking until it is reached", docstring="Sets the setpoint value, and input " "range, and waits until it is reached. " "Added for compatibility with Loop. Note " "that if the setpoint value is in " "a different range, this function may " "wait forever because that setpoint " "cannot be reached within the current " "range.", vals=vals.Numbers(0, 400), set_cmd=self._set_blocking_t, snapshot_exclude=True, )¶
Sets the setpoint value, and input range, and waits until it is reached. Added for compatibility with Loop. Note that if the setpoint value is in a different range, this function may wait forever because that setpoint cannot be reached within the current range.
- parameters: dict[str, ParameterBase] = {}¶
All the parameters supported by this instrument. Usually populated via
add_parameter()
.
- functions: dict[str, Function] = {}¶
All the functions supported by this instrument. Usually populated via
add_function()
.
- submodules: dict[str, InstrumentModule | ChannelTuple] = {}¶
All the submodules of this instrument such as channel lists or logical groupings of parameters. Usually populated via
add_submodule()
.
- instrument_modules: dict[str, InstrumentModule] = {}¶
All the
InstrumentModule
of this instrument Usually populated viaadd_submodule()
.
- log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)¶
- 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:
Classes:
alias of
LakeshoreModel336Channel
- 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'}¶
- visa_handle: pyvisa.resources.MessageBasedResource = visa_handle¶
The VISA resource used by this instrument.
- 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 viaadd_submodule()
.
- log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)¶
- 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:
Specifies input sensor type
Specifies if autoranging is enabled.
Specifies input range when autorange is not enabled.
Specifies input compensation.
Specifies the preferred units parameter for sensor readings and for the control setpoint (kelvin, celsius, or sensor)
Parameter temperature
The temperature limit in kelvin for which to shut down all control outputs when exceeded.
Parameter sensor_raw
Parameter sensor_status
Parameter sensor_name
All the parameters supported by this instrument.
All the functions supported by this instrument.
All the submodules of this instrument such as channel lists or logical groupings of parameters.
All the
InstrumentModule
of this instrument Usually populated viaadd_submodule()
.- 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 viaadd_submodule()
.
- log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)¶
- 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:
- mode: GroupParameter = self.add_parameter( "mode", label="Control mode", docstring="Specifies the control mode", val_mapping=self.MODES, parameter_class=GroupParameter, )¶
Specifies the control mode
- input_channel: GroupParameter = self.add_parameter( "input_channel", label="Input channel", docstring="Specifies which measurement input to " "control from (note that only " "measurement inputs are available)", parameter_class=GroupParameter, **self._input_channel_parameter_kwargs, )¶
Specifies which measurement input to control from (note that only measurement inputs are available)
- powerup_enable: GroupParameter = self.add_parameter( "powerup_enable", label="Power-up enable on/off", docstring="Specifies whether the output remains on " "or shuts off after power cycle.", val_mapping={True: 1, False: 0}, parameter_class=GroupParameter, )¶
Specifies whether the output remains on or shuts off after power cycle.
- P: GroupParameter¶
The value for closed control loop Proportional (gain)
- I: GroupParameter¶
The value for closed control loop Integral (reset)
- D: GroupParameter¶
The value for closed control loop Derivative (rate)
- output_type: GroupParameter = self.add_parameter( name="output_type", docstring="Output type (Output 2 only): 0=Current, 1=Voltage", val_mapping=( {"current": 0, "voltage": 1} if output_index == 1 else {"current": 0} ), parameter_class=GroupParameter, )¶
0=Current, 1=Voltage
- Type:
Output type (Output 2 only)
- output_heater_resistance: GroupParameter = self.add_parameter( name="output_heater_resistance", docstring="Heater Resistance Setting: 25/50ohm", val_mapping={"25ohm": 1, "50ohm": 2}, parameter_class=GroupParameter, )¶
25/50ohm
- Type:
Heater Resistance Setting
- output_max_current: GroupParameter = self.add_parameter( name="output_max_current", docstring="Specifies the maximum heater output current: User Specified, 0.707 A, 1 A, 1.141 A, 1.732", val_mapping={"user": 0, "0.707A": 1, "1A": 2, "1.141A": 3, "1.732A": 4}, parameter_class=GroupParameter, )¶
User Specified, 0.707 A, 1 A, 1.141 A, 1.732
- Type:
Specifies the maximum heater output current
- output_max_user_current: GroupParameter = self.add_parameter( name="output_max_user_current", docstring="Specifies the maximum heater output current if max current is set to User Specified.", vals=vals.Numbers(0, 1.732), unit="A", get_parser=float, parameter_class=GroupParameter, )¶
Specifies the maximum heater output current if max current is set to User Specified.
- output_display: GroupParameter = self.add_parameter( name="output_display", docstring="Specifies whether the heater output displays in current or power (current mode only)", val_mapping={"current": 1, "power": 2}, parameter_class=GroupParameter, )¶
Specifies whether the heater output displays in current or power (current mode only)
- output_range: Parameter = self.add_parameter( "output_range", label="Heater range", docstring="Specifies heater output range. The range " "setting has no effect if an output is in " "the `Off` mode, and does not apply to " "an output in `Monitor Out` mode. " "An output in `Monitor Out` mode is " "always on.", val_mapping=self.RANGES, set_cmd=f"RANGE {output_index}, {{}}", get_cmd=f"RANGE? {output_index}", )¶
Specifies heater output range. The range setting has no effect if an output is in the Off mode, and does not apply to an output in Monitor Out mode. An output in Monitor Out mode is always on.
- output: Parameter = self.add_parameter( "output", label="Output", unit="% of heater range", docstring="Specifies heater output in percent of " "the current heater output range.\n" "Note that when the heater is off, " "this parameter will return the value " "of 0.005.", get_parser=float, get_cmd=f"HTR? {output_index}", set_cmd=False, )¶
Specifies heater output in percent of the current heater output range. Note that when the heater is off, this parameter will return the value of 0.005.
- setpoint: Parameter = self.add_parameter( "setpoint", label="Setpoint value (in sensor units)", docstring="The value of the setpoint in the " "preferred units of the control loop " "sensor (which is set via " "`input_channel` parameter)", vals=vals.Numbers( -273.15, 400 ), # union of [0..400]K and [-273.15..126.85]degC get_parser=float, set_cmd=f"SETP {output_index}, {{}}", get_cmd=f"SETP? {output_index}", )¶
The value of the setpoint in the preferred units of the control loop sensor (which is set via input_channel parameter)
- setpoint_ramp_enabled: GroupParameter = self.add_parameter( "setpoint_ramp_enabled", label="Setpoint ramping enabled", docstring="Specifies whether setpoint ramping is 0 = Off or 1 = On", val_mapping={False: 0, True: 1}, parameter_class=GroupParameter, )¶
Specifies whether setpoint ramping is 0 = Off or 1 = On
- setpoint_ramp_rate: GroupParameter = self.add_parameter( "setpoint_ramp_rate", label="Setpoint ramping rate", unit="K/min", get_parser=float, docstring="Specifies setpoint ramp rate in kelvin per minute from" "0.1 to 100. The rate is always positive, but will respond to" "ramps up or down. A rate of 0 is interpreted as infinite, and" "will therefore respond as if setpoint ramping were off", vals=vals.Numbers(0, 100), parameter_class=GroupParameter, )¶
Specifies setpoint ramp rate in kelvin per minute from 0.1 to 100. The rate is always positive, but will respond to ramps up or down. A rate of 0 is interpreted as infinite, and will therefore respond as if setpoint ramping were off
- setpoint_ramp_status: Parameter = self.add_parameter( "setpoint_ramp_status", label="Setpoint is ramping", docstring="0 = Not ramping, 1 = Setpoint is ramping", val_mapping={True: 1, False: 0}, get_cmd=f"RAMPST? {output_index}", )¶
- range_limits: Parameter = self.add_parameter( "range_limits", set_cmd=None, get_cmd=None, vals=vals.Sequence( vals.Numbers(0, 400), require_sorted=True, length=len(self.RANGES) - 1 ), label="Temperature limits for output ranges", unit="K", docstring="Use this parameter to define which " "temperature corresponds to which output " "range; then use the " "`set_range_from_temperature` method to " "set the output range via temperature " "instead of doing it directly", )¶
Use this parameter to define which temperature corresponds to which output range; then use the set_range_from_temperature method to set the output range via temperature instead of doing it directly
- wait_cycle_time: Parameter = self.add_parameter( "wait_cycle_time", set_cmd=None, get_cmd=None, vals=vals.Numbers(0, 100), label="Waiting cycle time", docstring="Time between two readings when waiting " "for temperature to equilibrate", unit="s", )¶
Time between two readings when waiting for temperature to equilibrate
- wait_tolerance: Parameter = self.add_parameter( "wait_tolerance", set_cmd=None, get_cmd=None, vals=vals.Numbers(0, 100), label="Waiting tolerance", docstring="Acceptable tolerance when waiting for " "temperature to equilibrate", unit="", )¶
Acceptable tolerance when waiting for temperature to equilibrate
- wait_equilibration_time: Parameter = self.add_parameter( "wait_equilibration_time", set_cmd=None, get_cmd=None, vals=vals.Numbers(0, 100), label="Waiting equilibration time", docstring="Duration during which temperature has to be within tolerance", unit="s", )¶
Duration during which temperature has to be within tolerance
- blocking_t: Parameter = self.add_parameter( "blocking_t", label="Setpoint value with blocking until it is reached", docstring="Sets the setpoint value, and input " "range, and waits until it is reached. " "Added for compatibility with Loop. Note " "that if the setpoint value is in " "a different range, this function may " "wait forever because that setpoint " "cannot be reached within the current " "range.", vals=vals.Numbers(0, 400), set_cmd=self._set_blocking_t, snapshot_exclude=True, )¶
Sets the setpoint value, and input range, and waits until it is reached. Added for compatibility with Loop. Note that if the setpoint value is in a different range, this function may wait forever because that setpoint cannot be reached within the current range.
- parameters: dict[str, ParameterBase] = {}¶
All the parameters supported by this instrument. Usually populated via
add_parameter()
.
- functions: dict[str, Function] = {}¶
All the functions supported by this instrument. Usually populated via
add_function()
.
- submodules: dict[str, InstrumentModule | ChannelTuple] = {}¶
All the submodules of this instrument such as channel lists or logical groupings of parameters. Usually populated via
add_submodule()
.
- instrument_modules: dict[str, InstrumentModule] = {}¶
All the
InstrumentModule
of this instrument Usually populated viaadd_submodule()
.
- log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)¶
- 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: ClassVar[dict[str, int]] = {'closed_loop': 1, 'monitor_out': 4, 'off': 0, 'open_loop': 3, 'warm_up': 5, 'zone': 2}¶
- mode: GroupParameter = self.add_parameter( "mode", label="Control mode", docstring="Specifies the control mode", val_mapping=self.MODES, parameter_class=GroupParameter, )¶
Specifies the control mode
- input_channel: GroupParameter = self.add_parameter( "input_channel", label="Input channel", docstring="Specifies which measurement input to " "control from (note that only " "measurement inputs are available)", parameter_class=GroupParameter, **self._input_channel_parameter_kwargs, )¶
Specifies which measurement input to control from (note that only measurement inputs are available)
- powerup_enable: GroupParameter = self.add_parameter( "powerup_enable", label="Power-up enable on/off", docstring="Specifies whether the output remains on " "or shuts off after power cycle.", val_mapping={True: 1, False: 0}, parameter_class=GroupParameter, )¶
Specifies whether the output remains on or shuts off after power cycle.
- P: GroupParameter¶
The value for closed control loop Proportional (gain)
- I: GroupParameter¶
The value for closed control loop Integral (reset)
- D: GroupParameter¶
The value for closed control loop Derivative (rate)
- output_type: GroupParameter = self.add_parameter( name="output_type", docstring="Output type (Output 2 only): 0=Current, 1=Voltage", val_mapping=( {"current": 0, "voltage": 1} if output_index == 1 else {"current": 0} ), parameter_class=GroupParameter, )¶
0=Current, 1=Voltage
- Type:
Output type (Output 2 only)
- output_heater_resistance: GroupParameter = self.add_parameter( name="output_heater_resistance", docstring="Heater Resistance Setting: 25/50ohm", val_mapping={"25ohm": 1, "50ohm": 2}, parameter_class=GroupParameter, )¶
25/50ohm
- Type:
Heater Resistance Setting
- output_max_current: GroupParameter = self.add_parameter( name="output_max_current", docstring="Specifies the maximum heater output current: User Specified, 0.707 A, 1 A, 1.141 A, 1.732", val_mapping={"user": 0, "0.707A": 1, "1A": 2, "1.141A": 3, "1.732A": 4}, parameter_class=GroupParameter, )¶
User Specified, 0.707 A, 1 A, 1.141 A, 1.732
- Type:
Specifies the maximum heater output current
- output_max_user_current: GroupParameter = self.add_parameter( name="output_max_user_current", docstring="Specifies the maximum heater output current if max current is set to User Specified.", vals=vals.Numbers(0, 1.732), unit="A", get_parser=float, parameter_class=GroupParameter, )¶
Specifies the maximum heater output current if max current is set to User Specified.
- output_display: GroupParameter = self.add_parameter( name="output_display", docstring="Specifies whether the heater output displays in current or power (current mode only)", val_mapping={"current": 1, "power": 2}, parameter_class=GroupParameter, )¶
Specifies whether the heater output displays in current or power (current mode only)
- output_range: Parameter = self.add_parameter( "output_range", label="Heater range", docstring="Specifies heater output range. The range " "setting has no effect if an output is in " "the `Off` mode, and does not apply to " "an output in `Monitor Out` mode. " "An output in `Monitor Out` mode is " "always on.", val_mapping=self.RANGES, set_cmd=f"RANGE {output_index}, {{}}", get_cmd=f"RANGE? {output_index}", )¶
Specifies heater output range. The range setting has no effect if an output is in the Off mode, and does not apply to an output in Monitor Out mode. An output in Monitor Out mode is always on.
- output: Parameter = self.add_parameter( "output", label="Output", unit="% of heater range", docstring="Specifies heater output in percent of " "the current heater output range.\n" "Note that when the heater is off, " "this parameter will return the value " "of 0.005.", get_parser=float, get_cmd=f"HTR? {output_index}", set_cmd=False, )¶
Specifies heater output in percent of the current heater output range. Note that when the heater is off, this parameter will return the value of 0.005.
- setpoint: Parameter = self.add_parameter( "setpoint", label="Setpoint value (in sensor units)", docstring="The value of the setpoint in the " "preferred units of the control loop " "sensor (which is set via " "`input_channel` parameter)", vals=vals.Numbers( -273.15, 400 ), # union of [0..400]K and [-273.15..126.85]degC get_parser=float, set_cmd=f"SETP {output_index}, {{}}", get_cmd=f"SETP? {output_index}", )¶
The value of the setpoint in the preferred units of the control loop sensor (which is set via input_channel parameter)
- setpoint_ramp_enabled: GroupParameter = self.add_parameter( "setpoint_ramp_enabled", label="Setpoint ramping enabled", docstring="Specifies whether setpoint ramping is 0 = Off or 1 = On", val_mapping={False: 0, True: 1}, parameter_class=GroupParameter, )¶
Specifies whether setpoint ramping is 0 = Off or 1 = On
- setpoint_ramp_rate: GroupParameter = self.add_parameter( "setpoint_ramp_rate", label="Setpoint ramping rate", unit="K/min", get_parser=float, docstring="Specifies setpoint ramp rate in kelvin per minute from" "0.1 to 100. The rate is always positive, but will respond to" "ramps up or down. A rate of 0 is interpreted as infinite, and" "will therefore respond as if setpoint ramping were off", vals=vals.Numbers(0, 100), parameter_class=GroupParameter, )¶
Specifies setpoint ramp rate in kelvin per minute from 0.1 to 100. The rate is always positive, but will respond to ramps up or down. A rate of 0 is interpreted as infinite, and will therefore respond as if setpoint ramping were off
- setpoint_ramp_status: Parameter = self.add_parameter( "setpoint_ramp_status", label="Setpoint is ramping", docstring="0 = Not ramping, 1 = Setpoint is ramping", val_mapping={True: 1, False: 0}, get_cmd=f"RAMPST? {output_index}", )¶
- range_limits: Parameter = self.add_parameter( "range_limits", set_cmd=None, get_cmd=None, vals=vals.Sequence( vals.Numbers(0, 400), require_sorted=True, length=len(self.RANGES) - 1 ), label="Temperature limits for output ranges", unit="K", docstring="Use this parameter to define which " "temperature corresponds to which output " "range; then use the " "`set_range_from_temperature` method to " "set the output range via temperature " "instead of doing it directly", )¶
Use this parameter to define which temperature corresponds to which output range; then use the set_range_from_temperature method to set the output range via temperature instead of doing it directly
- wait_cycle_time: Parameter = self.add_parameter( "wait_cycle_time", set_cmd=None, get_cmd=None, vals=vals.Numbers(0, 100), label="Waiting cycle time", docstring="Time between two readings when waiting " "for temperature to equilibrate", unit="s", )¶
Time between two readings when waiting for temperature to equilibrate
- wait_tolerance: Parameter = self.add_parameter( "wait_tolerance", set_cmd=None, get_cmd=None, vals=vals.Numbers(0, 100), label="Waiting tolerance", docstring="Acceptable tolerance when waiting for " "temperature to equilibrate", unit="", )¶
Acceptable tolerance when waiting for temperature to equilibrate
- wait_equilibration_time: Parameter = self.add_parameter( "wait_equilibration_time", set_cmd=None, get_cmd=None, vals=vals.Numbers(0, 100), label="Waiting equilibration time", docstring="Duration during which temperature has to be within tolerance", unit="s", )¶
Duration during which temperature has to be within tolerance
- blocking_t: Parameter = self.add_parameter( "blocking_t", label="Setpoint value with blocking until it is reached", docstring="Sets the setpoint value, and input " "range, and waits until it is reached. " "Added for compatibility with Loop. Note " "that if the setpoint value is in " "a different range, this function may " "wait forever because that setpoint " "cannot be reached within the current " "range.", vals=vals.Numbers(0, 400), set_cmd=self._set_blocking_t, snapshot_exclude=True, )¶
Sets the setpoint value, and input range, and waits until it is reached. Added for compatibility with Loop. Note that if the setpoint value is in a different range, this function may wait forever because that setpoint cannot be reached within the current range.
- parameters: dict[str, ParameterBase] = {}¶
All the parameters supported by this instrument. Usually populated via
add_parameter()
.
- functions: dict[str, Function] = {}¶
All the functions supported by this instrument. Usually populated via
add_function()
.
- submodules: dict[str, InstrumentModule | ChannelTuple] = {}¶
All the submodules of this instrument such as channel lists or logical groupings of parameters. Usually populated via
add_submodule()
.
- instrument_modules: dict[str, InstrumentModule] = {}¶
All the
InstrumentModule
of this instrument Usually populated viaadd_submodule()
.
- log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)¶
- 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:
Classes:
alias of
LakeshoreModel372Channel
- visa_handle: pyvisa.resources.MessageBasedResource = visa_handle¶
The VISA resource used by this instrument.
- 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 viaadd_submodule()
.
- log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)¶
- 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:
Specifies whether the input/channel is enabled or disabled.
Specifies a value for the autoscanning dwell time.
Specifies a value for the change pause time
0 = no curve, 1 to 59 = standard/user curves.
Sets the temperature coefficient that will be used for temperature control if no curve is selected (negative or positive).
Specifies excitation mode
Specifies excitation range number (1-12 for voltage excitation, 1-22 for current excitation); refer to the manual for the table of ranges
Parameter temperature
The temperature limit in kelvin for which to shut down all control outputs when exceeded.
Parameter sensor_raw
Parameter sensor_status
Parameter sensor_name
All the parameters supported by this instrument.
All the functions supported by this instrument.
All the submodules of this instrument such as channel lists or logical groupings of parameters.
All the
InstrumentModule
of this instrument Usually populated viaadd_submodule()
.Specifies auto range setting
Parameter range
Current source either not shunted (excitation on), or shunted (excitation off)
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 viaadd_submodule()
.
- log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)¶
- 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:
Specifies output polarity (not applicable to warm-up heater)
Specifies controlling on unfiltered or filtered readings
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}¶
- 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
- mode: GroupParameter = self.add_parameter( "mode", label="Control mode", docstring="Specifies the control mode", val_mapping=self.MODES, parameter_class=GroupParameter, )¶
Specifies the control mode
- input_channel: GroupParameter = self.add_parameter( "input_channel", label="Input channel", docstring="Specifies which measurement input to " "control from (note that only " "measurement inputs are available)", parameter_class=GroupParameter, **self._input_channel_parameter_kwargs, )¶
Specifies which measurement input to control from (note that only measurement inputs are available)
- powerup_enable: GroupParameter = self.add_parameter( "powerup_enable", label="Power-up enable on/off", docstring="Specifies whether the output remains on " "or shuts off after power cycle.", val_mapping={True: 1, False: 0}, parameter_class=GroupParameter, )¶
Specifies whether the output remains on or shuts off after power cycle.
- P: GroupParameter¶
The value for closed control loop Proportional (gain)
- I: GroupParameter¶
The value for closed control loop Integral (reset)
- D: GroupParameter¶
The value for closed control loop Derivative (rate)
- output_type: GroupParameter = self.add_parameter( name="output_type", docstring="Output type (Output 2 only): 0=Current, 1=Voltage", val_mapping=( {"current": 0, "voltage": 1} if output_index == 1 else {"current": 0} ), parameter_class=GroupParameter, )¶
0=Current, 1=Voltage
- Type:
Output type (Output 2 only)
- output_heater_resistance: GroupParameter = self.add_parameter( name="output_heater_resistance", docstring="Heater Resistance Setting: 25/50ohm", val_mapping={"25ohm": 1, "50ohm": 2}, parameter_class=GroupParameter, )¶
25/50ohm
- Type:
Heater Resistance Setting
- output_max_current: GroupParameter = self.add_parameter( name="output_max_current", docstring="Specifies the maximum heater output current: User Specified, 0.707 A, 1 A, 1.141 A, 1.732", val_mapping={"user": 0, "0.707A": 1, "1A": 2, "1.141A": 3, "1.732A": 4}, parameter_class=GroupParameter, )¶
User Specified, 0.707 A, 1 A, 1.141 A, 1.732
- Type:
Specifies the maximum heater output current
- output_max_user_current: GroupParameter = self.add_parameter( name="output_max_user_current", docstring="Specifies the maximum heater output current if max current is set to User Specified.", vals=vals.Numbers(0, 1.732), unit="A", get_parser=float, parameter_class=GroupParameter, )¶
Specifies the maximum heater output current if max current is set to User Specified.
- output_display: GroupParameter = self.add_parameter( name="output_display", docstring="Specifies whether the heater output displays in current or power (current mode only)", val_mapping={"current": 1, "power": 2}, parameter_class=GroupParameter, )¶
Specifies whether the heater output displays in current or power (current mode only)
- output_range: Parameter = self.add_parameter( "output_range", label="Heater range", docstring="Specifies heater output range. The range " "setting has no effect if an output is in " "the `Off` mode, and does not apply to " "an output in `Monitor Out` mode. " "An output in `Monitor Out` mode is " "always on.", val_mapping=self.RANGES, set_cmd=f"RANGE {output_index}, {{}}", get_cmd=f"RANGE? {output_index}", )¶
Specifies heater output range. The range setting has no effect if an output is in the Off mode, and does not apply to an output in Monitor Out mode. An output in Monitor Out mode is always on.
- output: Parameter = self.add_parameter( "output", label="Output", unit="% of heater range", docstring="Specifies heater output in percent of " "the current heater output range.\n" "Note that when the heater is off, " "this parameter will return the value " "of 0.005.", get_parser=float, get_cmd=f"HTR? {output_index}", set_cmd=False, )¶
Specifies heater output in percent of the current heater output range. Note that when the heater is off, this parameter will return the value of 0.005.
- setpoint: Parameter = self.add_parameter( "setpoint", label="Setpoint value (in sensor units)", docstring="The value of the setpoint in the " "preferred units of the control loop " "sensor (which is set via " "`input_channel` parameter)", vals=vals.Numbers( -273.15, 400 ), # union of [0..400]K and [-273.15..126.85]degC get_parser=float, set_cmd=f"SETP {output_index}, {{}}", get_cmd=f"SETP? {output_index}", )¶
The value of the setpoint in the preferred units of the control loop sensor (which is set via input_channel parameter)
- setpoint_ramp_enabled: GroupParameter = self.add_parameter( "setpoint_ramp_enabled", label="Setpoint ramping enabled", docstring="Specifies whether setpoint ramping is 0 = Off or 1 = On", val_mapping={False: 0, True: 1}, parameter_class=GroupParameter, )¶
Specifies whether setpoint ramping is 0 = Off or 1 = On
- setpoint_ramp_rate: GroupParameter = self.add_parameter( "setpoint_ramp_rate", label="Setpoint ramping rate", unit="K/min", get_parser=float, docstring="Specifies setpoint ramp rate in kelvin per minute from" "0.1 to 100. The rate is always positive, but will respond to" "ramps up or down. A rate of 0 is interpreted as infinite, and" "will therefore respond as if setpoint ramping were off", vals=vals.Numbers(0, 100), parameter_class=GroupParameter, )¶
Specifies setpoint ramp rate in kelvin per minute from 0.1 to 100. The rate is always positive, but will respond to ramps up or down. A rate of 0 is interpreted as infinite, and will therefore respond as if setpoint ramping were off
- setpoint_ramp_status: Parameter = self.add_parameter( "setpoint_ramp_status", label="Setpoint is ramping", docstring="0 = Not ramping, 1 = Setpoint is ramping", val_mapping={True: 1, False: 0}, get_cmd=f"RAMPST? {output_index}", )¶
- range_limits: Parameter = self.add_parameter( "range_limits", set_cmd=None, get_cmd=None, vals=vals.Sequence( vals.Numbers(0, 400), require_sorted=True, length=len(self.RANGES) - 1 ), label="Temperature limits for output ranges", unit="K", docstring="Use this parameter to define which " "temperature corresponds to which output " "range; then use the " "`set_range_from_temperature` method to " "set the output range via temperature " "instead of doing it directly", )¶
Use this parameter to define which temperature corresponds to which output range; then use the set_range_from_temperature method to set the output range via temperature instead of doing it directly
- wait_cycle_time: Parameter = self.add_parameter( "wait_cycle_time", set_cmd=None, get_cmd=None, vals=vals.Numbers(0, 100), label="Waiting cycle time", docstring="Time between two readings when waiting " "for temperature to equilibrate", unit="s", )¶
Time between two readings when waiting for temperature to equilibrate
- wait_tolerance: Parameter = self.add_parameter( "wait_tolerance", set_cmd=None, get_cmd=None, vals=vals.Numbers(0, 100), label="Waiting tolerance", docstring="Acceptable tolerance when waiting for " "temperature to equilibrate", unit="", )¶
Acceptable tolerance when waiting for temperature to equilibrate
- wait_equilibration_time: Parameter = self.add_parameter( "wait_equilibration_time", set_cmd=None, get_cmd=None, vals=vals.Numbers(0, 100), label="Waiting equilibration time", docstring="Duration during which temperature has to be within tolerance", unit="s", )¶
Duration during which temperature has to be within tolerance
- blocking_t: Parameter = self.add_parameter( "blocking_t", label="Setpoint value with blocking until it is reached", docstring="Sets the setpoint value, and input " "range, and waits until it is reached. " "Added for compatibility with Loop. Note " "that if the setpoint value is in " "a different range, this function may " "wait forever because that setpoint " "cannot be reached within the current " "range.", vals=vals.Numbers(0, 400), set_cmd=self._set_blocking_t, snapshot_exclude=True, )¶
Sets the setpoint value, and input range, and waits until it is reached. Added for compatibility with Loop. Note that if the setpoint value is in a different range, this function may wait forever because that setpoint cannot be reached within the current range.
- parameters: dict[str, ParameterBase] = {}¶
All the parameters supported by this instrument. Usually populated via
add_parameter()
.
- functions: dict[str, Function] = {}¶
All the functions supported by this instrument. Usually populated via
add_function()
.
- submodules: dict[str, InstrumentModule | ChannelTuple] = {}¶
All the submodules of this instrument such as channel lists or logical groupings of parameters. Usually populated via
add_submodule()
.
- instrument_modules: dict[str, InstrumentModule] = {}¶
All the
InstrumentModule
of this instrument Usually populated viaadd_submodule()
.
- log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)¶