Model 372 AC Resistance Bridge

The Model 372 is both an AC resistance bridge and temperature controller designed for measurements below 100 milliKelvin.

More information about the instrument can be found on our website including the manual which has a list of all commands and queries.

Example scripts

Setting a temperature curve

import matplotlib.pyplot as plt
from lakeshore import Model224
from lakeshore.model_224 import Model224CurveHeader, Model224CurveFormat, Model224CurveTemperatureCoefficients, \
    Model224SoftCalSensorTypes

# Connect to a temperature instrument (the Model 224 in this case) over USB
myinstrument = Model224()

# Configure a curve by first setting its header parameters. First, set the name and serial number of the curve.
# Then, select the units used to set map the sensor units to temperature units. Set a temperature limit, and
# then specify whether the coefficients are positive or negative.
curve_header_25 = Model224CurveHeader("My_Curve", "ABC123", Model224CurveFormat.VOLTS_PER_KELVIN, 300.0,
                                      Model224CurveTemperatureCoefficients.POSITIVE)
myinstrument.set_curve_header(25, curve_header_25)

# Edit individual data points of the curve. In this case, a sensor value of 1.23 is set to equal a Kelvin value of
# 276.0
myinstrument.set_curve_data_point(25, 1, 1.23, 276.0)

# You can create a softcal curve by inputting 1-3 calibration sensor/temperature points. The instrument generates
# a new curve using your entered data points and the selected standard curve
myinstrument.generate_and_apply_soft_cal_curve(Model224SoftCalSensorTypes.DT_400, 30, "SN123", (276, 10),
                                               (300, 5), (310, 2))

# Use the get_curve method to get all the data points for a curve as a list. This can then be used to create a plot
# of the calibration curve.
data_points_list = myinstrument.get_curve(30)
x_list = [item[0] for item in data_points_list]
y_list = [item[1] for item in data_points_list]
plt.plot(x_list, y_list)

# Finally, a curve can be deleted if you would like to reset the data points for that curve. Only user curves
# can be deleted.
myinstrument.delete_curve(25)

Using enums to configure an input sensor

from lakeshore import Model372
from lakeshore import Model372SensorExcitationMode, Model372MeasurementInputCurrentRange, \
    Model372AutoRangeMode, Model372InputSensorUnits, Model372MeasurementInputResistance, Model372InputSetupSettings

# Include baud rate when initializing instrument
my_model_372 = Model372(57600)

# Configure a sensor
# Create Model372InputSetupSettings object with current excitation mode, 31.6 uA excitation current, autoranging on
# (tracking current), current source not shunted, preferred units of Kelvin, and a resistance range of 20.0 kOhms
sensor_settings = Model372InputSetupSettings(Model372SensorExcitationMode.CURRENT,
                                             Model372MeasurementInputCurrentRange.RANGE_31_POINT_6_MICRO_AMPS,
                                             Model372AutoRangeMode.CURRENT, False, Model372InputSensorUnits.KELVIN,
                                             Model372MeasurementInputResistance.RANGE_20_KIL_OHMS)

# Pass settings into method along with desired input channel
my_model_372.configure_input(1, sensor_settings)

# Get all readings (temperature, resistance, excitation power, quadrature) from sensor
sensor_1_readings = my_model_372.get_all_input_readings(1)

# Record readings to a file
file = open("372_sensor_1_data.csv", "w")
file.write("Header information\n")
# Call readings using the keys of the returned dictionary
file.write("Temperature Reading," + str(sensor_1_readings['kelvin']) + "\n")
file.write("Resistance Reading," + str(sensor_1_readings['resistance']) + "\n")
file.write("Excitation Power," + str(sensor_1_readings['power']) + "\n")
file.write("Imaginary Part of Resistance," + str(sensor_1_readings['quadrature']) + "\n")
file.close()

Setting up a control loop with the model 372

from lakeshore import Model372
from lakeshore import Model372HeaterOutputSettings, Model372OutputMode, Model372InputChannel, Model372ControlLoopZoneSettings

# Include baud rate when initializing instrument
my_model_372 = Model372(57600)

# Configure output for zone mode, controlled by control input, with power up enabled filter enabled and a reading
# delay of 10 seconds
# Note; it's assumed that the control input is enabled and configured
heater_settings = Model372HeaterOutputSettings(Model372OutputMode.ZONE, Model372InputChannel.CONTROL, True, True, 10)
my_model_372.configure_heater(1, heater_settings)

# Configure a relay for Warmup Heater Zone
my_model_372.set_relay_for_warmup_heater_control_zone(1)

# Set up control loop with an upper bound of 15K, a gain of 50, an integral value of 5000, a derivative of 2000, and a
# manual output of 50%. Range is set to true, setpoint ramp rate is set to 10 seconds, and relay 1 is configured for
# the zone and relay 2 is not configured
control_loop_settings = Model372ControlLoopZoneSettings(15, 50.0, 5000, 2000, 50, True, 10, True, False)
# Set control loop on output 1 (Warmup Heater) in zone 4
my_model_372.set_control_loop_parameters(1, 4, control_loop_settings)

# Create a setpoint for 5 K
my_model_372.set_setpoint_kelvin(1, 5.0)
# Enable ramping to setpoint for output 1 at a rate of 10 Kelvin/minute
my_model_372.set_setpoint_ramp_parameter(1, True, 10)

Instrument class methods

class lakeshore.model_372.Model372(baud_rate, serial_number=None, com_port=None, timeout=2.0, ip_address=None, tcp_port=7777, **kwargs)

A class object representing the Lake Shore Model 372 AC bridge and temperature controller

clear_interface()

Clears the interace, such as all bits in the status byte register and the standard event status register. Does not clear the instrument.

reset_instrument()

Resets the instrument to power-up settings and parameters.

set_display_settings(mode, number_of_fields='', displayed_info='')

Sets which parameters to display and how to display them.

Args:
mode (Model372DisplayMode):
Sets the input to monitor on the display, or configures display for custom.
number_of_fields (Model372DisplayFields):
Configures the number of display fields to include in a custom display.
displayed_info (Model372DisplayInfo):
Determines whether to display information about the loop of the active scan channel or a specific heater in the bottom left of the display in custom mode.
get_display_mode()

Returns the current mode of the display.

Returns:
(Model372DisplayMode):
Enumerated object representing the current mode of the display
get_custom_display_settings()

Returns the settings of the display in custom mode.

Returns:
(dict):
mode: Model372DisplayMode, number_of_fields: Model372DisplayFields, displayed_info: Model372DisplayInfo
get_resistance_reading(input_channel)

Returns the input reading in Ohms.

Args:
input_channel (str or int)
  • Specifies which input channel to read from. Options are:
    • 1-16
    • “A” (for control input)
Returns:
(float):
  • Sensor reading in Ohms
get_quadrature_reading(input_channel)

Returns the imaginary part of the reading in Ohms. Only valid for measurement inputs.

Args:
input_channel (int)
  • Specifies which input channel to read from. Options are:
    • 1-16
Returns:
(float):
  • The imaginary part of the sensor reading, in Ohms
get_all_input_readings(input_channel)

Returns the kelvin reading, resistance reading, and, if a measurement input, the quadrature reading.

Args:
input_channel (str or int)
  • Specifies which input channel to read from. Options are:
    • 1-16
    • “A” (for control input)
Returns:
(dict):
  • If measurement input:
    • {kelvin: float, resistance: float, power: float, quadrature: float)
  • If control input:
    • {kelvin: float, resistance: float, power: float}
get_input_setup_parameters(input_channel)

Returns the settings on the specified input.

Args:
input_channel (str or int)
  • Specifies which input channel to read from. Options are:
    • 1-16
    • “A” (control input)
Returns:
input_sensor_settings (Model372InputSetupSettings)
  • object of Model372InputSetupSettings representing the parameters of the excitation of the sensor
    on the specified channel
configure_input(input_channel, settings)

Sets the desired setup settings on the specified input.

Args:
input_channel (str or int)
  • Specifies which input channel to read from. Options are:
    • 1-16
    • “A” (control input)
settings (Model372InputSetupSettings)
  • object of Model372InputSetupSettings representing the parameters of the excitation of the sensor
    on the specified channel
disable_input(input_channel)

Disables the desired input channel.

Args:
input_channel (str or int)
  • Specifies which input channel to disable. Options are:
  • 1-16
  • “A” (control input)
get_input_channel_parameters(input_channel)

Returns the settings on the specified input channel

Args:
input_channel (str or int)
  • Specifies which input channel to read from. Options are:
    • 1-16
    • “A” (control input)
Returns:
input_channel_settings (Model372InputChannelSettings)
  • Contains variables representing the different channel settings parameters
set_input_channel_parameters(input_channel, settings)

Sets the desired channel settings on the specified input channel

Args:
input_channel (str or int)
  • Specifies which input channel to read from. Options are:
    • 1-16
    • “A” (control input)
settings (Model372InputChannelSettings)
  • Defines how to set the various parameters
get_analog_heater_output(output_channel)

Returns the output of the warm-up or analog/still heater

Args:
output_channel (int)
  • Specifies which heater to read from. Options:
    • 1 output 1 (warm up heater)
    • 2 output 2 (analog heater)
Returns:
reading (float)
  • Output of the analog heater being queried
all_off()

Recreates the front panel safety feature of shutting off all heaters

set_heater_output_range(output_channel, heater_range)

Sets the output range

Args:
output_channel (int)
  • Specifies which heater to set. Options:
    • 0: sample heater
    • 1: output 1 (warm up heater)
    • 2: output 2 (analog heater)
heater_range (Enum or bool)
  • Specifies the range of the output. Options:

    Sample Heater (Enum):
    • Object of type Model372SampleHeaterOutputRange
    Warmup Heater/Still Heater (bool):
    • False: output off
    • True: output on
get_heater_output_range(output_channel)

Return’s the range of the output on a given channel

Args:
output_channel (int)
  • Specifies which heater to read from. Options:
    • 0: sample heater
    • 1: output 1 (warm up heater)
    • 2: output 2 (analog heater)
Returns:
heater_range (bool or Enum)
  • If channel 1 or 2, returns bool for if output is on or off.
  • If channel 0, an object of enum type Model372SampleHeaterOutputRange
set_filter(input_channel, state, settle_time, window)

Sets a filter for the specified input channel.

Args:
input_channel (str or int)
  • Specifies which input channel to read from. Options are:
    • 0 (all channels/measurement inputs)
    • 1-16
    • “A” (control input)
state (bool)
  • Specifies whether to turn filter on or off. Options are:
    • False for off, True for on
settle_time (float)
  • Specifies filter settle time. Options are:
    • 1 - 200 s
window (float)
  • Specifies what percent of full scale reading limits the filtering function.
  • Options are:
    • 1 - 80
get_filter(input_channel)

Returns information about the filter set on the specified channel.

Args:
input_channel (str or int)
  • Specifies which input channel to read from. Options are:
  • 1-16
  • “A” (control input)
Returns:
state (bool)
  • Specifies whether to turn filter on or off.
settle_time (int)
  • Specifies filter settle time.
window (int)
  • Specifies what percent of full scale reading limits the filtering function.
set_ieee_interface_parameter(address)

Sets the IEEE address of the instrument.

Args:
address (int) * Specifies the IEEE address. Options are: * 1 - 30
get_ieee_interface_parameter()

Returns the IEEE address of the instrument.

Returns:
address (int)
  • The IEEE address.
get_excitation_power(input_channel)

Returns the most recent power calculation for the selected input channel

Args:
input_channel (str or int)
  • Specifies which input channel to read from. Options are:
  • 1-16
  • “A” (control input)
Returns:
power (float)
  • Most recent power calculation for the input being queried
get_heater_output_settings(output_channel)

Returns the mode and settings of the given output channel.

Args:
output_channel (int)
  • Specifies which heater to read from. Options:
    • 0: sample heater
    • 1: output 1 (warm up heater)
    • 2: output 2 (analog heater)
Returns:
outputmode_settings (Model372HeaterOutputSettings)
  • Object of class Model372HeaterOutputSettings whose variables are set to reflect the
    current output settings of the queried heater.
configure_heater(output_channel, settings)

Sets up a heater output. Analog heaters (outputs 1 and 2) might need to configure further settings in configure_analog_heater.

Args:
output_channel (int)
  • Specifies which heater to read from. Options:
    • 0: sample heater
    • 1: output 1 (warm up heater)
    • 2: output 2 (analog heater)
settings (Model372HeaterOutputSettings)
  • Defines how to set the output mode settings
set_common_mode_reduction(state)

Sets common mode reduction to given state for all measurement channels.

Args:
state (bool)
  • Sets CMR to enabled or disable. Options are:
  • False (for disable) or True (for enable)
get_common_mode_reduction()

Returns whether or not CMR is set for measurement channels

Returns:
  • False (boolean) if CMR is disabled
  • True (boolean) if CMR is enabled
set_scanner_status(input_channel, status)

Sets the scanner to the specified channel, and enables or disables auto scan

Args:
input_channel (int)
  • Specifies which measurement input to set the scanner to. Options are:
    • 1 - 16
status (bool)
  • Specifies whether to turn auto scan feature on. Options are:
    • False (disable) or True (enable)
get_scanner_status()

Returns which channel the scanner is on and whether the auto scan feature is enabled

Returns:
input_channel (int)
  • The measurement channel the scanner is currently on.
status (bool)
  • True if autoscan in on, False if autoscan is off
set_alarm_beep(status)

Enables or disables a beep for alarms

Args:
status (bool)
  • False (for disable) or True (for enable)
get_alarm_beep_status()

Returns whether beep for alarms is enabled or disabled.

Returns
status (bool)
  • Returns True is beep is enabled.
  • Returns False is beep is disabled.
set_still_output(power)

Sets the still output of the still/analog heater to power% of full power. Heater gets configured for Still mode if not currently configured.

Args:
power (float)
  • Specifies the percent of full power for still output. Options are: * 0 - 100
get_still_output()

Returns the percent of full power being outputted by still heater in still mode.

Returns:
power (float)
  • percent of full power being outputted by heater.
set_warmup_output(auto_control, current)

Sets up the warmup output to continuous control at the percent current specified. Configures the warmup heater for continuous control mode from the control input.

Args:
auto_control (bool)
  • Specifies whether or not to turn on auto control. Options are:
    • False for auto off, True for continuous
current (float)
  • Specifies percent of full current to apply to external output. Options are:
    • 0 - 100
get_warmup_output()

Returns the control setting and percent current outputted in the warmup heater in warmup mode.

Returns:
auto_control (bool)
  • Specifies whether or not to turn on auto control. Returns:
    • False for auto off, True for continuous
current (float)
  • Specifies percent of full current to apply to external output.
set_setpoint_kelvin(output_channel, setpoint)

Sets the control setpoint in Kelvin. Changes input parameters so preferred units are Kelvin.

Args:
output_channel (int)
  • Specifies which heater to set a setpoint. Options are:
    • 0: sample heater
    • 1: output 1 (warm up heater)
setpoint (float)
  • Specifies the setpoint the heater ramps to, in Kelvin.
set_setpoint_ohms(output_channel, setpoint)

Sets the control setpoint in Ohms. Changes input parameters so preferred units are Ohms.

Args:
output_channel (int)
  • Specifies which heater to set a setpoint. Options are:
    • 0: sample heater
    • 1: output 1 (warm up heater)
setpoint (float)
  • Specifies the setpoint the heater ramps to, in Kelvin.
get_setpoint_kelvin(output_channel)

Returns the setpoint for the given output channel in kelvin. Changes the control input’s preferred units to Kelvin as a result.

Args:
output_channel (int)
  • Specifies which heater to set a setpoint. Options are:
    • 0: sample heater
    • 1: output 1 (warm up heater)
Returns:
setpoint (float)
  • Setpoint of the output in Kelvin.
get_setpoint_ohms(output_channel)

Returns the setpoint for the given output channel in kelvin. Changes the control input’s preferred units to Kelvin as a result.

Args:
output_channel (int)
  • Specifies which heater to set a setpoint. Options are:
    • 0: sample heater
    • 1: output 1 (warm up heater)
Returns:
setpoint (float)
  • Setpoint of the output in Ohms.
get_excitation_frequency(input_channel)

Returns the excitation frequency in Hz for either the measurement or control inputs.

Args:
input_channel (int or str)
  • Specifies which input to get frequency from. Options are:
    • 0 : measurement inputs
    • “A” : control input
Returns:
frequency (Enum)
  • The excitation frequency in Hz, returned as an object of Model372InputFrequency Enum type
set_excitation_frequency(input_channel, frequency)

Sets the excitation frequency (in Hz) for either the measurement or control inputs.

Args:
input_channel (int or str)
  • Specifies which input to get frequency from. Options are:
    • 0 : measurement inputs
    • “A” : control input
frequency (Enum)
  • The excitation frequency in Hz (if float), represented as an object of type Model372InputFrequency
set_digital_output(bit_weight)

Sets the status of the 5 digital output lines to high or low.

Args:
bit_weight (DigitalOutputRegister)
  • Determines which bits to set or reset
get_digital_output()

Returns which digital output bits are set or reset by representing them in a binary number.

Returns:
bit_weight (DigitalOutputRegister)
  • Determines which bits to set or reset
set_interface(interface)

Sets the interface for the instrument to communicate over.

Args:
interface (Model372Interface)
  • selects the interface based on the values as defined in the Model372Interface enum class
get_interface()

Returns the interface connected to the instrument.

Returns:
interface (Model372Interface)
  • returns the interface as an object of the Model372Interface enum class.
set_alarm_parameters(input_channel, alarm_enable, alarm_settings=None)

Sets an alarm on the specified channel as defined by parameters.

Args:
input_channel (int or str)
  • Defines which channel to configure an alarm on. Options are:
    • 0 for all measurement inputs
    • 1 - 16
    • “A” for control input
alarm_enable (bool)
  • Defines whether to turn alarm on or off
alarm_settings (Model372AlarmParameters)
  • Model372AlarmParameters object containing desired alarm settings
  • Optional if alarm is disabled
get_alarm_parameters(input_channel)

Returns the parameters for the alarm set for the input at the specified channel.

Args:
input_channel (int or str)
  • Defines which channel to configure an alarm on. Options are:
  • 1 - 16
  • “A” for control input
Returns:
(dict):
{alarm_enable: bool, alarm_settings: Model372AlarmParameters
set_relay_for_sample_heater_control_zone(relay_number)

Configures a relay to follow the sample heater output as part of a control zone. Settings can be further configured in set_control_loop_zone_parameters method.

Args:
relay_number (int):
  • The relay to configure.
  • Options are:
    • 1 or 2
set_relay_for_warmup_heater_control_zone(relay_number)

Configures a relay to follow the warm up heater output as part of a control zone. Settings can be further configured in set_control_loop_zone_parameters method.

Args:
relay_number (int):
  • The relay to configure.
  • Options are:
    • 1 or 2
get_ieee_interface_mode()

Returns the IEEE interface mode of the instrument.

Returns:
mode (Model372InterfaceMode)
  • returns the mode as an enum type of class Model372InterfaceMode
set_ieee_interface_mode(mode)

Sets the IEEE interface mode of the instrument.

Args:
mode (Model372InterfaceMode)
  • Defines the mode of the instrument as an object of the enum type Model372IEEEInterfaceMode
set_monitor_output_source(source)

Sets the source of the monitor output. Also affects the reference output.

Args:
source (Model372MonitorOutputSource)
  • Defines the source to run the monitor output off of.
get_monitor_output_source()

Returns the source for the monitor output.

Returns:
source (Model372MonitorOutputSource)
  • returns the source as an object of the Model372MonitorOutputSource class.
get_warmup_heater_setup()

Returns the settings regarding the resistance, current and units of the warmup heater (output channel 1).

Returns:
(dict):
{resistance: float, max_current: float, units: Model372HeaterOutputUnits}
get_sample_heater_setup()

Returns the setup of the sample heater (channel 0).

Returns:
(dict):
{resistance: float, units: Model372HeaterOutputUnits}
setup_warmup_heater(resistance, max_current, units)

Configures the current and power of the warmup heater (output channel 1). The max current must not cause the heater to exceed it’s max power (calculated by I = sqrt(P/R)) or it’s max voltage (calculated by I = V/R). Check your heater’s specifications before setting the max current, and use the lower current produced from the two calculations.

Args:
resistance (Model372HeaterResistance):
  • Heater load in ohms, as an object of the enum type Model372HeaterResistance
max_current (float):
  • User specified max current in A.
units (Model372HeaterOutputUnits):
  • Defines which units the output is displayed in (Current (A) or Power (W))
setup_sample_heater(resistance, units)

Configures the current and power of the sample heater (output channel 0.)

Args:
resistance (float):
  • Heater load in ohms. Options are:
    • 1 - 2000
units (Model372HeaterOutputUnits):
  • Defines which units the output is displayed in (Current (A) or Power (W))
configure_analog_monitor_output_heater(source, high_value, low_value, settings=None)

Configures the still heater’s analog settings for Monitor Out mode. Can fully configure the heater by including the settings parameter, but it is recommended to configure non-analog properties of the heater through the configure_heater method.

Args:
source (Model372InputSensorUnits)
The units to use for channel data
high_value (float)
The data at which the output reaches +100% output
low_value (float)
The data at which the outputs reaches 0% output for unipolar output, or -100% for bipolar output.
settings (Model372HeaterOutputSettings)
Optional if heater is already configured using configure_heater. Gives non-analog configurations for heater.
get_analog_monitor_output_settings()

Retrieves the analog monitor settings of output 2 configured in monitor output mode.

Returns:
(dict):
{source: Model372InputSensorUnits, high_value: float, low_value: float}
configure_analog_heater(output_channel, manual_value, settings=None)

Configures the analog settings of a heater for modes other than Monitor Out. (Use configure_analog_monitor_out_heater for Monitor Out mode). Can fully configure the heater by including the settings parameter, but it is recommended to first configure the heater using the configure_heater method before using this method.

Args:
output_channel (Model372HeaterOutput):
The output to configure.
manual_value (float):
The value of the analog output as it applies to the set analog mode.
settings (Model372HeaterOutputSettings)
Optional if heater is already configured using configure_heater. Gives non-analog configurations for heater.
get_analog_manual_value(output_channel)

Returns the manual value of an analog heater. The manual value is the analog value used for Open Loop, Closed Loop, Warm Up, or Still mode.

Args:
output_channel (int):
The analog output to query. Options are:
  • 1 (Warm up heater)
  • 2 (Still heater)
Returns:
(float):
The manual analog value for the heater.
set_website_login(username, password)

Sets the username and password to connect instrument to website.

Args:
username (str)
  • username to set for login. Must be less than or equal to 15 characters. Method
    automatically puts quotation marks around string, so they are not needed in the string literal passed into the method.
password (str)
  • password to set for login. Must be less than or equal to 15 characters. Method
    automatically puts quotation marks around string, so they are not needed in the string literal passed into the method.
get_website_login()

Returns the set username and password for web login for the instrument.

Returns:
username (str):
  • The current set username for the web login
password (str):
  • The current set password for the web login
get_control_loop_zone_parameters(output_channel, zone)

Returns the settings parameters of the control loop on the specified output channel and zone.

Args:
output_channel (int)
  • Channel of the heater being queried. Options are:
    • 0 for sample heater
    • 1 for warm-up heater
zone (int)
  • Control loop zone to configure. Options are:
    • 1 - 10
Returns:
settings (Model372ControlLoopZoneSettings)
  • An object of the Model372ControlLoopZoneSettings class containing information of the
    settings in the values of its variables.
set_control_loop_parameters(output_channel, zone, settings)

Returns the parameters of the control loop set in the specified zone for the specified heater output.

Args:
output_channel (int)
  • Channel of the heater being queried. Options are:
    • 0 for sample heater
    • 1 for warm-up heater
zone (int)
  • Control loop zone to configure. Options are:
    • 1 - 10
settings (Model372ControlLoopZoneSettings)
  • An object of the Model372ControlLoopZoneSettings with the variable set to
    configure the desired settings.
get_reading_status(input_channel)

Returns any flags raised during a measurement reading.

Args:
input_channel (str or int)
  • The input whose reading status is being queried. Options are:
    • 1 - 16
    • “A” (control input)
Returns:
bit_states (dict)
  • Dictionary containing the names of the flag and a boolean value corresponding to
    if the flag is raised or not.
clear_interface_command()

Clears the bits in the Status Byte Register, Standard Event Status Register, and Operation Event Register, and terminates all pending operations. Clears the interface, but not the controller.

command(*commands, check_errors=True)

Send a SCPI command or multiple commands to the instrument

Args:
commands (str):
  • A serial command
Kwargs:
check_errors (bool):
  • Chooses whether to check for and raise errors after sending a command. True by default.
connect_tcp(ip_address, tcp_port, timeout)

Establishes a TCP connection with the instrument on the specified IP address

connect_usb(serial_number=None, com_port=None, baud_rate=None, data_bits=None, stop_bits=None, parity=None, timeout=None, handshaking=None, flow_control=None)

Establish a serial USB connection

delete_curve(curve)

Deletes the user curve

Args:
curve (int):
  • Specifies a user curve to delete
disconnect_tcp()

Disconnect the TCP connection

disconnect_usb()

Disconnect the USB connection

get_alarm_status(channel)

Returns the high state and low state of the alarm for the specified channel

Args:
channel (str or int)
  • Specifies which input channel to read from.
Return:
(dict)
  • Keys:
  • “high_state”: bool
    • True if high state is on, False if high state is off
  • “low_state” bool
    • True if low state is on, False if low state is off
get_control_setpoint(output)

Returns the value for a given control output

Args:
output (int):
  • Specifies which output’s control loop to query (1 or 2)
Return:
value (float):
  • The value for the setpoint (in the preferred units of the control loop sensor)
get_curve(curve)

Returns a list of all the data points in a particular curve

Args:
curve (int):
  • Specifies which curve to set
Return:
data_points (list: tuple):
  • A list containing every point in the curve represented as a tuple
    • (sensor_units: float, temp_value: float, curvature_value: float (optional))
get_curve_data_point(curve, index)

Returns a standard or user curve data point

Args:
curve (int):
  • Specifies which curve to query
index (int):
  • Specifies the points index in the curve
Return:
curve_point (tuple)
  • (sensor_units: float, temp_value: float, curvature_value: float (optional))
get_curve_header(curve_number)

Returns parameters set on a particular user curve header

Args:
curve_number (int):
  • Specifies a curve to retrieve
Returns:
(CurveHeader):
  • A CurveHeader class object containing the curve information
get_display_field_settings(field)

Returns the settings of the specified display field when display is in Custom mode.

Args:
field (int)
Defines which field of the display to retrieve settings from
Return:
(dict):
  • See set_display_field_settings method
  • Keys:
  • “input_channel”: IntEnum
  • “display_units”: IntEnum
get_heater_output(output)

Sample heater output in percent, scale is dependent upon the instrument used and heater configuration

Args:
output (int):
  • Heater output to query
Return:
(float):
  • percent of full scale current/voltage/power
get_heater_pid(output)

Returns the closed loop control parameters of the heater output

Args:
output (int):
  • Specifies which output’s control loop to query
Return:
(dict):
  • Keys:
  • “gain”: float
    • Proportional term in PID control.
  • “integral”: float
    • Integral term in PID control.
  • “ramp_rate”: float
    • Derivative term in PID control
get_heater_status(output)

Returns the heater error code state, error is cleared upon querying the heater status

Args:
output (int):
  • Specifies which heater output to query (1 or 2)
Return:
(IntEnum):
  • Object of instrument’s HeaterError type
get_ieee_488()

Returns the IEEE address set

Return:
address (int):
  • 1-30 (0 and 31 reserved)
get_input_curve(input_channel)

Returns the curve number being used for a given input

Args:
input_channel (str or int):
  • Specifies which input to query
Return:
curve_number (int):
  • 0-59
get_kelvin_reading(input_channel)

Returns the temperature value in kelvin of the given channel

Args:
input_channel:
  • Selects the channel to retrieve measurement
get_keypad_lock()

Returns the state of the keypad lock and the lock-out code.

Return:
(dict):
  • Keys:
    • “state”: bool
    • “code”: int
get_led_state()

Returns whether or not front panel LEDs are enabled.

Return:
(bool)
  • Specifies whether front panel LEDs are functional
  • False if disabled, True enabled.
get_manual_output(output)

Returns the manual output value in percent

Args:
output (int):
  • Specifies output to query
Return:
(float):
  • Manual output percent
get_min_max_data(input_channel)

Returns the minimum and maximum data from an input

Args:
input_channel (str):
  • Specifies which input to query
Return:
(dict):
  • keys:
    • “minimum”: float
    • “maximum”: float
get_relay_alarm_control_parameters(relay_number)

Returns the relay alarm configuration for either of the two configurable relays. Relay must be configured for alarm mode to retrieve parameters.

Args:
relay_number (int)
  • Specifies which relay to query
  • Options are:
    • 1 or 2
Return:
(dict):
  • Keys:
  • “activating_input_channel”: str
  • “alarm_relay_trigger_type”: RelayControlAlarm
get_relay_control_mode(relay_number)

Returns the configured mode of the specified relay.

Args:
relay_number (int):
  • Specifies which relay to query
  • Options are:
    • 1 or 2
Returns:
(IntEnum):
  • The configured mode of the relay
  • Represented as a member of the instrument’s RelayControlMode IntEnum class
get_relay_status(relay_channel)

Returns whether the relay at the specified channel is On or Off.

Args:
relay_channel (int)
  • The relay channel to query.
Returns:
(bool)
  • True if relay is on, False if relay is off.
get_remote_interface_mode()

Returns the state of the interface mode

Return:
(IntEnum):
  • A member of the instrument’s InterfaceMode IntEnum class
get_self_test()

Instrument self test result completed at power up

Return:
(bool):
  • True = errors found
  • False = no errors found
get_sensor_name(input_channel)

Returns the name of the sensor on the specified channel

Args:
input_channel (str or int):
  • Specifies which input_channel channel to read from.
Returns:
name (str)
  • Name associated with the sensor
get_sensor_reading(input_channel)

Returns the sensor reading in the sensor’s units.

Returns:
reading (float):
  • The raw sensor reading in the units of the connected sensor
get_service_request()

Returns the status byte register bits and their values as a class instance

get_setpoint_ramp_parameter(output)

Returns the control loop parameters of a particular output

Args:
output (int):
  • Specifies which output’s control loop to return
Return:
(dict):
  • Keys:
  • “ramp_enable”: bool
  • “rate_value”: float
get_setpoint_ramp_status(output)

“Returns whether or not the setpoint is ramping

Args:
output (int):
  • Specifies which output’s control loop to query
Return:
(bool):
  • Ramp status
  • False = Not ramping, True = Ramping
get_standard_event_enable_mask()

Returns the names of the standard event enable register bits and their values. These values determine which bits propagate to the standard event register

get_status_byte()

Returns the status flag bits as a class instance without resetting the register

get_temperature_limit(input_channel)

Returns the value of the temperature limit in kelvin

Args:
input_channel (str or int):
  • Specifies which input to query
query(*queries, check_errors=True)

Send a query to the instrument and return the response

Args:
queries (str):
  • A serial query ending in a question mark
Return:
  • The instrument query response as a string.
reset_alarm_status()

Clears the high and low status of all alarms.

reset_min_max_data()

Resets the minimum and maximum input data

set_control_setpoint(output, value)

Control settings, that is, P, I, D, and Setpoint, are assigned to outputs, which results in the settings being applied to the control loop formed by the output and its control input

Args:
output (int):
  • Specifies which output’s control loop to configure
value (float):
The value for the setpoint (in the preferred units of the control loop sensor)
set_curve(curve, data_points)

Method to define a user curve using a list of data points

Args:
curve (int):
  • Specifies which curve to set
data_points (list):
  • A list containing every point in the curve represented as a tuple
    • (sensor_units: float, temp_value: float, curvature_value: float (optional))
set_curve_data_point(curve, index, sensor_units, temperature, curvature=None)

Configures a user curve point

Args:
curve (int or str):
  • Specifies which curve to configure
index (int):
  • Specifies the points index in the curve
sensor_units (float):
  • Specifies sensor units for this point to 6 digits
temperature (float):
  • Specifies the corresponding temperature in Kelvin for this point to 6 digits
curvature (float)
  • Optional argument
  • Specify only if the point is part of a cubic spindle curve
  • The curvature value scale used to calculate spindle coefficients to 6 digits
set_curve_header(curve_number, curve_header)

Configures the user curve header

Args:
curve_number:
  • Specifies which curve to configure
curve_header (CurveHeader):
  • Instrument’s CurveHeader class object containing the desired curve information
set_display_field_settings(field, input_channel, display_units)

Configures a display field when the display is in custom mode.

Args:
field (int):
  • Defines which field of the display is being configured
input_channel (IntEnum)
  • Defines which input to display.
  • A member of the instrument’s InputChannel IntEnum class
display_units (IntEnum)
  • Defines which units to display reading in.
  • A member of the instrument’s DisplayUnits IntEnum class
set_heater_pid(output, gain, integral, derivative)

Configure the closed loop control parameters of the heater output.

Args:
output (int):
  • Specifies which output’s control loop to configure
gain (float):
  • Proportional term in PID control.
  • This controls how strongly the control output reacts to the present error.
integral (float):
  • Integral term in PID control.
  • This controls how strongly the control output reacts to the past error history
derivative (float):
  • Derivative term in PID control
  • This value controls how quickly the present field setpoint will transition to a new setpoint.
  • The ramp rate is configured in field units per second.
set_ieee_488(address)

Specifies the IEEE address

Args:
address (int):
  • 1-30 (0 and 31 reserved)
set_input_curve(input_channel, curve_number)

Specifies the curve an input uses for temperature conversion

Args:
input_channel (str or int):
  • Specifies which input to configure
curve_number (int):
  • 0 = none, 1-20 = standard curves, 21-59 = user curves
set_keypad_lock(state, code)

Locks or unlocks front panel keypad (except for alarms and disabling heaters).

Args:
state (bool)
  • Sets the keypad to locked or unlocked. Options are:
  • False for unlocked or True for locked
code (int)
  • Specifies 3 digit lock-out code. Options are:
  • 000 - 999
set_led_state(state)

Sets the front panel LEDs to on or off.

Args:
state (bool)
  • Sets the LEDs to functional or nonfunctional
  • False if disabled, True enabled.
set_manual_output(output, value)

When instrument is in closed loop PID, Zone, or Open Loop modes a manual output may be set

Args:
output (int):
  • Specifies output to configure
value (float):
  • Specifies value for manual output in percent
set_relay_alarms(relay_number, activating_input_channel, alarm_relay_trigger_type)

Sets a relay to turn on and off automatically based on the state of the alarm of the specified input channel.

Args:
relay_number (int):
  • The relay to configure.
  • Options are:
    • 1 or 2
activating_input_channel (str or int):
  • Specifies which input alarm activates the relay
alarm_relay_trigger_type (RelayControlAlarm):
  • Specifies the type of alarm that triggers the relay
set_remote_interface_mode(mode)

Places the instrument in one of three interface modes

Args:
mode (IntEnum):
  • A member of the instrument’s InterfaceMode IntEnum class
set_sensor_name(input_channel, sensor_name)

Sets a given name to a sensor on the specified channel

Args:
input_channel (str or int):
  • Specifies which input_channel channel to read from
sensor_name(str):
  • Name user wants to give to the sensor on the specified channel
set_service_request(register_mask)

Manually enable/disable the mask of the corresponding status flag bit in the status byte register

Args:
register_mask (service_request_enable):
  • A service_request_enable class object with all bits configured
set_setpoint_ramp_parameter(output, ramp_enable, rate_value)

Sets the control loop of a particular output

Args:
output (int):
  • Specifies which output’s control loop to configure
ramp_enable (bool):
  • Specifies whether ramping is off or on (False = Off or True = On)
rate_value (float):
  • 0.1 to 100
  • Specifies setpoint ramp rate in kelvin per minute.
  • The rate is always positive but will respond to ramps up or down.
  • A rate of 0 is interpreted as infinite, and will respond as if setpoint ramping were off
set_standard_event_enable_mask(register_mask)

Configures values of the standard event enable register bits. These values determine which bits propagate to the standard event register

Args:
register_mask (StandardEventRegister):
An StandardEventRegister class object with all bits set to a value
set_temperature_limit(input_channel, limit)

After a set temperature limit is exceeded, all control outputs will shut down

Args:
input_channel (str or int):
  • Specifies which input to configure
limit (float):
  • The temperature limit in kelvin for which to shut down all control outputs when exceeded.
  • A limit of zero will turn the feature off
turn_relay_off(relay_number)

Turns the specified relay off.

Args:
relay_number (int):
  • The relay to turn off.
  • Options are:
    • 1 or 2
turn_relay_on(relay_number)

Turns the specified relay on.

Args:
relay_number (int):
  • The relay to turn on.
  • Options are:
    • 1 or 2

Instrument settings classes and registers

class lakeshore.model_372.Model372InputChannelSettings(enable, dwell_time, pause_time, curve_number, temperature_coefficient=None)

Class object representing parameters for the channel settings of an Model372InputChannel

__init__(enable, dwell_time, pause_time, curve_number, temperature_coefficient=None)

The constructor for Model372InputChannelSettings class.

Args:
enable (bool):
  • Whether to enable or disable input
dwell_time (int)
  • Specifies a value for the autoscanning dwell time in seconds. Not applicable to control input.
  • Options are: 1 to 200 s
pause_time (int)
  • Specifies a value for the change pause time in seconds.
  • Options are: 3 to 200 s
curve_number (int):
  • Specifies which calibration curve to use on input sensor.
  • Options are: 0 (none), 1 - 59
temperature_coefficient (Model372CurveTemperatureCoefficient)
  • Sets coefficient for temperature control if no curve is selected.
class lakeshore.model_372.Model372InputSetupSettings(mode, excitation_range, auto_range, current_source_shunted, units, resistance_range=None)

Class object representing parameters for the sensor and measurement settings of an Model372InputChannel

__init__(mode, excitation_range, auto_range, current_source_shunted, units, resistance_range=None)

The constructor for Model372InputSetupSettings class.

Args:
mode (Model372SensorExcitationMode):
  • Determines whether to use current or voltage for sensor excitation.
excitation_range (IntEnum)
  • the voltage or current (depending on mode) excitation range.
auto_range (Model372AutoRangeMode)
  • Specifies whether auto range is Off, Autoranging Current, or in ROX 102B mode.
current_source_shunted (bool):
  • Specifies whether or not the current source is shunted. If current source is shunted,
    excitation is off. If current source is not shunted, excitation is on.
units (Model372InputSensorUnits)
  • Specifies the preferred units, Kelvin or Ohms, for the sensor.
resistance_range (Model372MeasurementInputResistance):
  • For measurement inputs only, specifies the measurement input resistance range.
class lakeshore.model_372.Model372HeaterOutputSettings(output_mode, input_channel, powerup_enable, reading_filter, delay, polarity=None)

Class object representing parameters to configure Heater Output Settings.

__init__(output_mode, input_channel, powerup_enable, reading_filter, delay, polarity=None)

The constructor for Model372HeaterOutputSettings class.

Args:
output_mode (Model372OutputMode):
  • The control or output mode to configure the heater for. Defines how the output is controlled.
input_channel (Model372InputChannel):
  • Which input to control output from in a control loop.
powerup_enable (bool):
  • Specifies whether output stays on after powerup cycle.
  • True if enabled, False if disabled.
reading_filter (bool):
  • Specifies whether readings are filtered on unfiltered.
  • True if filtered, False if unfiltered
delay (int):
  • Specifies delay in seconds for setpoint during AutoScanning. Options are:
  • 1 - 255
polarity (Model372Polarity):
  • Specifies output polarity. Not applicable to warmup heater.
class lakeshore.model_372.Model372ControlLoopZoneSettings(upper_bound, p_value, i_value, d_value, manual_output, heater_range, ramp_rate, relay_1, relay_2)

Defines the parameters to set up a Control Loop.

__init__(upper_bound, p_value, i_value, d_value, manual_output, heater_range, ramp_rate, relay_1, relay_2)

The constructor for Model372ControlLoopZoneSettings class.

Args:
upper_bound (float):
  • upper bound setpoint in Kelvin
p_value (float)
  • The gain for a PID system. Options are:
  • 0.0 - 1000
i_value (float)
  • The integral value for a PID system. Options are:
  • 0 - 10000
d_value (float)
  • The rate for a PID system. Options are:
  • 0 - 2500
manual_output (float)
  • Percentage full scale manual output
heater_range (float or bool)
  • Heater range for the control zone.
  • Entered as a float for the sample heater
  • Entered as a bool for the warm-up heater
ramp_rate (float)
  • Specifies ramp rate for this zone
relay_1 (bool)
  • Specifies if relay 1 is on or off
  • Only applicable if relay is configured in zone mode and relay’s control
    output matches configured output.
relay_2 (bool)
  • Specifies if relay 2 is on or off
  • Only applicable if relay is configured in zone mode and relay’s control
    output matches configured output.
class lakeshore.model_372.Model372AlarmParameters(high_value, low_value, deadband, latch_enable, audible=None, visible=None)

Sets up an alarm for an input channel

__init__(high_value, low_value, deadband, latch_enable, audible=None, visible=None)

The constructor for Model372AlarmParameters class.

Args:
high_value (int):
  • Sets value for source to be checked against to set high alarm
low_value (int):
  • Sets value for source to be checked against to set low alarm
deadband (int):
  • Sets value that source must change outside of an alarm condition to deactivate an unlatched alarm.
latch_enable (bool)
  • Specifies if alarm is latched or not
audible (bool)
  • Specifies if an alarm is audible or not
visible (bool)
  • Specifies if an alarm is visible via LED on front panel or not
lakeshore.model_372.Model372CurveHeader

alias of lakeshore.temperature_controllers.CurveHeader

class lakeshore.model_372.CurveHeader(curve_name, serial_number, curve_data_format, temperature_limit, coefficient)

A class to configure the temperature sensor curve header parameters

__init__(curve_name, serial_number, curve_data_format, temperature_limit, coefficient)

Constructor for CurveHeader class

Args:
curve_name (str):
  • Specifies curve name (limit of 15 characters)
serial_number (str):
  • Specifies curve serial number (limit of 10 characters)
curve_data_format (IntEnum):
  • Member of the instrument’s CurveFormat IntEnum class
  • Specifies the curve data format
temperature_limit (float):
  • Specifies the curve temperature limit in Kelvin
coefficient (IntEnum):
  • Member of instrument’s CurveTemperatureCoefficient IntEnum class
  • Specifies the curve temperature coefficient
lakeshore.model_372.Model372StandardEventRegister

alias of lakeshore.temperature_controllers.StandardEventRegister

class lakeshore.model_372.StandardEventRegister(operation_complete, query_error, execution_error, command_error, power_on)

Class object representing the standard event register

class lakeshore.model_372.Model372ReadingStatusRegister(current_source_overload, voltage_common_mode_stage_overload, voltage_mixer_stage_overload, voltage_differential_stage_overload, resistance_over, resistance_under, temperature_over, temperature_under)

Class object representing the reading status of an input. While not a literal register, the return of an int representation of multiple booleans makes it convenient to represent this functionality as a register.

class lakeshore.model_372.Model372StatusByteRegister(warmup_heater_ramp_done, valid_reading_control_input, valid_reading_measurement_input, alarm, sensor_overload, event_summary, request_service_master_summary_status, sample_heater_ramp_done)

Class representing the status byte register.

class lakeshore.model_372.Model372ServiceRequestEnable(warmup_heater_ramp_done, valid_reading_control_input, valid_reading_measurement_input, alarm, sensor_overload, event_summary, sample_heater_ramp_done)

Class representing the status byte register.

Enumeration objects

This section describes the Enum type objects that have been created to name various settings of the model 372 that are represented as an int or single character to the instrument. The purpose of these objects is to make the settings more descriptive and obvious to the user rather than interpreting the ints taken by the instrument.

class lakeshore.model_372.Model372OutputMode

Enumeration of the different modes for heater output setup.

CLOSED_LOOP = 5
MONITOR_OUT = 1
OFF = 0
OPEN_LOOP = 2
STILL = 4
WARMUP = 6
ZONE = 3
class lakeshore.model_372.Model372InputChannel

Enumeration of the input channels of the Model 372

CONTROL = 'A'
EIGHT = 8
ELEVEN = 11
FIFTEEN = 15
FIVE = 5
FOUR = 4
FOURTEEN = 14
NINE = 9
NONE = 0
ONE = 1
SEVEN = 7
SIX = 6
SIXTEEN = 16
TEN = 10
THIRTEEN = 13
THREE = 3
TWELVE = 12
TWO = 2
class lakeshore.model_372.Model372SensorExcitationMode

Enumeration of the possible excitation modes for an input sensor.

CURRENT = 1
VOLTAGE = 0
class lakeshore.model_372.Model372AutoRangeMode

Enumeration for the possible modes of the auto ranging feature. ROX102B mode is a special autoranging mode that applies only to Lake Shore ROX-102B sensor.

CURRENT = 1
OFF = 0
ROX102B = 2
class lakeshore.model_372.Model372InputSensorUnits

Enumeration of the units to handle input readings and display in.

KELVIN = 1
OHMS = 2
class lakeshore.model_372.Model372MonitorOutputSource

Enumeration of the source for an output to monitor.

CS_NEG = 1
CS_POS = 2
OFF = 0
VAD_CONTROL = 7
VAD_MEASUREMENT = 6
VCM_NEG = 3
VCM_POS = 4
VDIF = 5
class lakeshore.model_372.Model372RelayControlMode

Enumeration of the control modes of the configurable relays of the 372

ALARMS = 2
RELAY_OFF = 0
RELAY_ON = 1
SAMPLE_HEATER_ZONE = 3
WARMUP_HEATER_ZONE = 4
class lakeshore.model_372.Model372DisplayMode

Enumeration of the possible information to display

CONTROL_INPUT = 1
CUSTOM = 2
MEASUREMENT_INPUT = 0
class lakeshore.model_372.Model372DisplayInfo

Enumeration of the information to a display in the bottom left of the custom display mode

ACTIVE_SCAN_CHANNEL = 3
NONE = 0
SAMPLE_HEATER = 1
WARMUP_HEATER = 2
class lakeshore.model_372.Model372CurveFormat

Enumeration of the units to use in a calibration curve

LOGOHM_PER_KELVIN = 4
OHM_PER_KELVIN = 3
OHM_PER_KELVIN_CUBIC_SPLINE = 7
class lakeshore.model_372.Model372DisplayFieldUnits

Enumeration for the possible units to display in a single display field.

KELVIN = 1
MAXIMUM_DATA = 5
MINIMUM_DATA = 4
OHMS = 2
QUADRATURE = 3
SENSOR_NAME = 6
class lakeshore.model_372.Model372SampleHeaterOutputRange

Enumeration of the output range of the sample heater (output 0).

OFF = 0
RANGE_100_MICRO_AMPS = 2
RANGE_100_MILLI_AMPS = 8
RANGE_10_MILLI_AMPS = 6
RANGE_1_MILLI_AMP = 4
RANGE_316_MICRO_AMPS = 3
RANGE_31_POINT_6_MICRO_AMPS = 1
RANGE_31_POINT_6_MILLI_AMPS = 7
RANGE_3_POINT_16_MILLI_AMPS = 5
class lakeshore.model_372.Model372InputFrequency

Defines the enumeration of the excitation frequency of an input.

FREQUENCY_11_POINT_6_HZ = 4
FREQUENCY_13_POINT_7_HZ = 2
FREQUENCY_16_POINT_2_HZ = 3
FREQUENCY_18_POINT_2_HZ = 5
FREQUENCY_9_POINT_8_HZ = 1
class lakeshore.model_372.Model372MeasurementInputVoltageRange

Enumerates the possible voltage ranges for a measurement input.

RANGE_200_MICRO_VOLTS = 5
RANGE_200_MILLI_VOLTS = 11
RANGE_20_MICRO_VOLTS = 3
RANGE_20_MILLI_VOLTS = 9
RANGE_2_MICRO_VOLTS = 1
RANGE_2_MILLI_VOLTS = 7
RANGE_632_MICRO_VOLTS = 6
RANGE_632_MILLI_VOLTS = 12
RANGE_63_POINT_2_MICRO_VOLTS = 4
RANGE_63_POINT_2_MILLI_VOLTS = 10
RANGE_6_POINT_32_MICRO_VOLTS = 2
RANGE_6_POINT_32_MILLI_VOLTS = 8
class lakeshore.model_372.Model372MeasurementInputCurrentRange

Enumeration of the current range of a measurement input.

RANGE_100_MICRO_AMPS = 17
RANGE_100_NANO_AMPS = 11
RANGE_100_PICO_AMPS = 5
RANGE_10_MICRO_AMPS = 15
RANGE_10_MILLI_AMPS = 21
RANGE_10_NANO_AMPS = 9
RANGE_10_PICO_AMPS = 3
RANGE_1_MICRO_AMP = 13
RANGE_1_MILLI_AMP = 19
RANGE_1_NANO_AMP = 7
RANGE_1_PICO_AMP = 1
RANGE_316_MICRO_AMPS = 18
RANGE_316_NANO_AMPS = 12
RANGE_316_PICO_AMPS = 6
RANGE_31_POINT_6_MICRO_AMPS = 16
RANGE_31_POINT_6_MILLI_AMPS = 22
RANGE_31_POINT_6_NANO_AMPS = 10
RANGE_31_POINT_6_PICO_AMPS = 4
RANGE_3_POINT_16_MICRO_AMPS = 14
RANGE_3_POINT_16_MILLI_AMPS = 20
RANGE_3_POINT_16_NANO_AMPS = 8
RANGE_3_POINT_16_PICO_AMPS = 2
class lakeshore.model_372.Model372ControlInputCurrentRange

Enumeration of the current range of the control input.

RANGE_100_NANO_AMPS = 6
RANGE_10_NANO_AMPS = 4
RANGE_1_NANO_AMP = 2
RANGE_316_PICO_AMPS = 1
RANGE_31_POINT_6_NANO_AMPS = 5
RANGE_3_POINT_16_NANO_AMPS = 3
class lakeshore.model_372.Model372MeasurementInputResistance

Enumeration of the resistance range of a measurement input.

RANGE_200_KIL_OHMS = 17
RANGE_200_MILLI_OHMS = 5
RANGE_200_OHMS = 11
RANGE_20_KIL_OHMS = 15
RANGE_20_MEGA_OHMS = 21
RANGE_20_MILLI_OHMS = 3
RANGE_20_OHMS = 9
RANGE_2_KIL_OHMS = 13
RANGE_2_MEGA_OHMS = 19
RANGE_2_MILLI_OHMS = 1
RANGE_2_OHMS = 7
RANGE_632_KIL_OHMS = 18
RANGE_632_MILLI_OHMS = 6
RANGE_632_OHMS = 12
RANGE_63_POINT_2_KIL_OHMS = 16
RANGE_63_POINT_2_MEGA_OHMS = 22
RANGE_63_POINT_2_MILLI_OHMS = 4
RANGE_63_POINT_2_OHMS = 10
RANGE_6_POINT_32_KIL_OHMS = 14
RANGE_6_POINT_32_MEGA_OHMS = 20
RANGE_6_POINT_32_MILLI_OHMS = 2
RANGE_6_POINT_32_OHMS = 8
lakeshore.model_372.Model372CurveTemperatureCoefficient

alias of lakeshore.temperature_controllers.CurveTemperatureCoefficient

lakeshore.model_372.Model372InterfaceMode

alias of lakeshore.temperature_controllers.InterfaceMode

lakeshore.model_372.Model372DisplayFields

alias of lakeshore.temperature_controllers.DisplayFields

lakeshore.model_372.Model372Polarity

alias of lakeshore.temperature_controllers.Polarity

lakeshore.model_372.Model372HeaterOutputUnits

alias of lakeshore.temperature_controllers.HeaterOutputUnits

lakeshore.model_372.Model372BrightnessLevel

alias of lakeshore.temperature_controllers.BrightnessLevel

lakeshore.model_372.Model372HeaterError

alias of lakeshore.temperature_controllers.HeaterError

lakeshore.model_372.Model372HeaterResistance

alias of lakeshore.temperature_controllers.HeaterResistance

lakeshore.model_372.Model372Interface

alias of lakeshore.temperature_controllers.Interface