Model 224 Temperature Monitor

The Lake Shore Model 224 measures up to 12 temperature sensor channels.

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

Configuring the model 224 with 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)

Instrument class methods

class lakeshore.model_224.Model224(serial_number=None, com_port=None, baud_rate=57600, data_bits=7, stop_bits=1, parity='O', flow_control=False, handshaking=False, timeout=2.0, ip_address=None, tcp_port=7777, **kwargs)

A class object representing the Lake Shore Model 224 temperature monitor

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.
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.
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

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 (Model224StandardEventRegister):
An StandardEventRegister class object with all bits set to a value
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.

reset_instrument()

Sets controller parameters to power-up settings

set_service_request(register_mask)

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

Args:
register_mask (Model224ServiceRequestRegister):
A Model224ServiceRequestRegister class object with all bits configured
get_service_request()

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

get_status_byte()

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

get_self_test()

Instrument self test result completed at power up

Return:
test_errors (bool):
  • True = errors found
  • False = no errors found
set_wait_to_continue()

Causes the IEEE-488 interface to hold off until all pending operations have been completed. This has the same function as the set_operation_complete() method, except that it does not set the Operation Complete event bit in the Event Status Register

set_to_factory_defaults()

Sets all the settings and configurations to their factory default values.

get_reading_status(input_channel)

Returns the reading status of any input status flags that may be set.

Args:
input_channel (str):
  • The input to check for reading status flags.
  • Options are:
    • A
    • B
    • C(1 - 5)
    • D(1 - 5)
Returns:
(dict):
{invalid_reading: bool, temperature_under_range: bool, temperature_over_range: bool, sensor_units_zero: bool, sensor_units_over_range: bool}
get_kelvin_reading(input_channel)

Returns the temperature value in kelvin of either channel

Args:
input_channel:
  • Selects the channel to retrieve measurement.
  • Options are:
    • A
    • B
    • C(1 - 5)
    • D(1 - 5)
Returns:
(float):
The reading of the sensor in kelvin
get_sensor_reading(input_channel)

Returns the sensor reading in the sensor’s units.

Args:
input_channel:
  • Selects the channel to retrieve measurement.
  • Options are:
    • A
    • B
    • C(1 - 5)
    • D(1 - 5)
Returns:
reading (float):
  • The raw sensor reading in the units of the connected sensor
get_celsius_reading(input_channel)

Returns the given input’s temperature reading in degrees Celsius.

Args:
input_channel (str)
Selects input to retrieve measurement from.
Returns:
(float):
Temperature readings in degrees Celsius
get_all_inputs_celsius_reading()

Returns the temperature reading in degrees Celsius of all the inputs.

Returns:
(dict):
{input_a_reading: float, input_b_reading: float, input_c1_reading: float, input_c2_reading: float, input_c3_reading: float, input_c4_reading: float, input_c5_reading: float, input_d1_reading: float, input_d2_reading: float, input_d3_reading: float, input_d4_reading: float, input_d5_reading: float}
set_input_diode_excitation_current(input_channel, diode_current)

Sets the excitation current of a diode sensor. Input must be configured for a diode sensor for command to work. Current defaults to 10uA.

Args:
input_channel (str):
  • The input to configure the diode excitation current for.
diode_current (Model224DiodeExcitationCurrent):
  • The excitation current for the diode sensor.
get_input_diode_excitation_current(input_channel)

Returns the diode excitation current for the given diode sensor.

Args:
input_channel (str):
The diode sensor input to query the current of.
Returns:
diode_current (Model224DiodeExcitationCurrent):
A member of the Model224DiodeExcitationCurrent enum class.
set_sensor_name(channel, sensor_name)

Sets a given name to a sensor on the specified channel

Args:
channel (str):
  • Specifies which the sensor to name is on.
  • Options are:
    • A
    • B
    • C(1 - 5)
    • D(1 - 5)
sensor_name(str):
  • Name user wants to give to the sensor on the specified channel
get_sensor_name(channel)

Returns the name of the sensor on the specified channel

Args:
channel (str):
  • Specifies which input sensor to retrieve name of.
  • Options are:
    • A
    • B
    • C(1 - 5)
    • D(1 - 5)
Returns:
name (str)
  • Name associated with the sensor
set_display_contrast(contrast_level)

Sets the contrast level for the front panel display

Args:
contrast_level (int):
  • Display contrast for the front panel LCD screen
  • Options are:
    • 1 - 32
get_display_contrast()

Returns the contrast level of front panel display

Return:
(int):
  • Contrast level of the front panel LCD screen
set_ieee_488(address)

Specifies the IEEE address

Args:
address (int):
  • 1-30 (0 and 31 reserved)
get_ieee_488()

Returns the IEEE address set

Return:
address (int):
  • 1-30 (0 and 31 reserved)
set_led_state(state)

Sets the front panel LEDs to on or off.

Args:
state (bool)
  • Sets the LEDs to functional or nonfunctional. Options are:
  • False for off or True for on
get_led_state()

Returns whether or not front panel LEDs are enabled.

Returns:
state (bool)
  • Specifies whether front panel LEDs are functional. Returns:
  • False if disabled, True enabled.
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
get_keypad_lock()

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

Return:
(dict):
  • [state: bool, code: int]
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:
min_max_data (dict):
  • [minimum: float, maximum: float]
reset_min_max_data()

Resets the minimum and maximum input data

set_input_curve(input_channel, curve_number)

Specifies the curve an input uses for temperature conversion

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

Returns the curve number being used for a given input

Args:
input_channel (str):
Specifies which input to query
Return:
curve_number (int):
  • 0-59
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:
(dict):
{username: str, password: str}
set_alarm_parameters(input_channel, alarm_enable, alarm_settings=None)

Configures the alarm parameters for an input

Args:
input_channel (str):
Specifies which input to configure
alarm_enable (bool):
Specifies whether to turn on the alarm for the input, or turn the alarm off.
alarm_settings (Model224AlarmParameters):
See Model224AlarmParameters class. Optional if alarm_enable is set to False
get_alarm_parameters(input_channel)

Returns the present state of all alarm parameters

Args:
input_channel (str):
Specifies which input to configure
Return:
(dict):
{alarm_enable: bool, alarm_settings: Model224AlarmParameters}
get_alarm_status(input_channel)

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

Args:
input_channel (str)
  • Specifies which input channel to read from.
  • Options are:
    • A
    • B
    • C(1 - 5)
    • D(1 - 5)
Returns:
(dict):
{high_state: bool, low_state: bool}
  • 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
reset_alarm_status()

Clears the high and low status of all alarms.

set_curve_header(curve_number, curve_header)

Configures the user curve header

Args:
curve_number (int):
  • Specifies which curve to configure.
  • Options are:
    • 21 - 59
curve_header (Model224CurveHeader):
  • A Model224CurveHeader class object containing the desired curve information
get_curve_header(curve)

Returns parameters set on a particular user curve header

Args:
curve (int):
  • Specifies a curve to retrieve
  • Options are:
    • 21 - 59
Returns:
header (Model224CurveHeader):
  • A Model224CurveHeader class object containing the desired curve information
set_curve_data_point(curve, index, sensor_units, temperature)

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
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))
delete_curve(curve)

Deletes the user curve

Args:
curve (int):
  • Specifies a user curve to delete
generate_and_apply_soft_cal_curve(source_curve, curve_number, serial_number, calibration_point_1, calibration_point_2=(0, 0), calibration_point_3=(0, 0))

Creates a SoftCal curve from 1-3 temperature/sensor points and a standard curve. Inputs generated curve into the given curve number.

Args:
source_curve (Model224SoftCalSensorTypes):
  • The standard curve to use to generate the SoftCal curve from along with calibration points.
curve_number (int):
  • The curve number to save the generated curve to.
  • Options are:
    • 21 - 59
serial_number (str):
  • Serial number of the user curve.
  • Maximum of 10 characters
calibration_point_1 (tuple):
  • Tuple of two floats in the form (temperature_value, sensor_value)
calibration_point_2 (tuple):
  • Tuple of two floats in the form (temperature_value, sensor_value)
  • Optional parameter
calibration_point_3 (tuple):
  • Tuple of two floats in the form (temperature_value, sensor_value)
  • Optional parameter
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):
  • A list containing every point in the curve represented as a tuple
    • (sensor_units: float, temp_value: float)
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)
get_relay_status(relay_channel)

Returns whether the specified relay is On or Off.

Args:
relay_channel (int)
  • The relay channel to query.
  • Options are:
    • 1 or 2
Returns:
(bool):
  • True if relay is on, False if relay is off.
set_filter(input_channel, filter_enabled, number_of_points=8, filter_reset_threshold=10)

Enables or disables a filter for the readings of the specified input channel. Filter is a running average that smooths input readings exponentially.

Args:
input_channel (str):
  • The input to set or disable a filter for.
  • Options are:
    • A
    • B
    • C(1 - 5)
    • D(1 - 5)
filter_enabled (bool):
  • Enables or disables a filter for the input channel.
  • True for enabled, False for disabled.
number_of_points (int):
  • Specifies the number of points used for the filter.
  • Inputting a larger number of points will slow down the instrument’s response to changes in
    temperature.
  • Options are:
    • 2 - 64
  • Optional if disabling the filter function.
filter_reset_threshold (int):
  • Specifies the limit for restarting the filter, represented by a percent of the full scale reading.
    If raw reading differs from filtered value by more than this threshold, filter averaging resets.
  • Options are:
    • 1% - 10%
  • Optional if disabling the filter function.
get_filter(input_channel)

Retrieves information about the filter set on the specified input channel.

Args:
input_channel (str):
  • The input to query for filter information.
  • Options are:
    • A
    • B
    • C(1 - 5)
    • D(1 - 5)
Returns:
(dict):
{filter_enabled: bool, number_of_points: int, filter_reset_threshold: int}
configure_input(input_channel, settings)

Configures a sensor for measurement input readings.

Args:
input_channel (str):
The input to configure the input for. Options are:
  • A
  • B
  • C(1 - 5)
  • D(1 - 5)
settings (Model224InputSensorSettings):
Object of the Model224InputSensorSettings containing information for sensor setup.
disable_input(input_channel)

Disables the selected input channel.

Args:
input_channel (str):
The input to disable. Options are:
  • A
  • B
  • C (1 - 5)
  • D (1 - 5)
get_input_configuration(input_channel)

Returns the configuration settings of the sensor at the specified input channel.

Args:
input_channel (str)
The input to query. Options are:
  • A
  • B
  • C(1 - 5)
  • D(1 - 5)
Returns:
(Model224InputSensorSettings):
Object of type Model224InputSensorSettings containing information about the sensor at the given input_channel
select_remote_interface(remote_interface)

Selects the remote interface to use for communications.

Args:
remote_interface (Model224RemoteInterface):
Object of enum type Model224RemoteInterface, representing the type of interface used for communications
get_remote_interface()

Returns the remote interface being used for communications.

Returns:
(Model224RemoteInterface):
Object of enum type Model224RemoteInterface representing the interface being used for communications
select_interface_mode(interface_mode)

Selects the mode for the remote interface being used.

Args:
interface_mode (Model224InterfaceMode):
Object of enum type Model224InterfaceMode representing the desired communication mode.
get_interface_mode()

Returns the mode of the remote interface.

Returns:
(Model224InterfaceMode):
Object of enum type Model224InterfaceMode representing the communication mode.
set_display_field_settings(field, input_channel, display_units)

Configures a display field in custom display mode.

Args:
field (int):
  • Specifies which display field to configure.
  • Options are:
    • 1 - 8
input_channel (Model224InputChannel)
  • Defines which input to display.
display_units (Model224DisplayFieldUnits)
  • Defines which units to display reading in.
get_display_field_settings(field)

Returns the settings of a single display field in custom display mode.

Args:
field (int):
  • Specifies the display field to query.
  • Options are:
    • 1 - 8
Returns:
(dict):
{input_channel: Model224InputChannel, display_units: Model224DisplayFieldUnits}
configure_display(display_mode, number_of_fields=0)

Configures the display of the instrument.

Args:
display_mode (Model224DisplayMode):
  • Defines what mode to set the display in.
  • Mode either defines which input to display, or sets up a custom display using display fields.
number_of_fields (Model224NumberOfFields):
  • Defines the number of display locations to display.
  • Only valid if mode is set to CUSTOM
get_display_configuration()

Returns the mode of the display. If display mode is Custom, this method also returns the number of display fields in the custom display.

Returns:
(dict):
{display_mode: Model224DisplayMode, number_of_fields: Model224NumberOfFields}
turn_relay_on(relay_number)

Turns the specified relay on.

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

Turns the specified relay off.

Args:
relay_number (int):
  • The relay to turn off.
  • Options are:
    • 1 or 2
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):
  • Specifies which input alarm activates the relay when the relay is in alarm mode
  • Only applies if ALARM mode is chosen.
  • Options are:
    • A
    • B
    • C(1 - 5)
    • D(1 - 5)
alarm_relay_trigger_type (Model224RelayControlAlarm):
  • Specifies the type of alarm that triggers the relay
  • Only applies if ALARM mode is chosen.
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):
{activating_input_channel: str, alarm_relay_trigger_type: Model224RelayControlAlarm}
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:
(Model224RelayControlMode):
  • The configured mode of the relay, represented as an object of the enum type
    Model224RelayControlMode
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

disconnect_tcp()

Disconnect the TCP connection

disconnect_usb()

Disconnect the USB connection

Settings classes

class lakeshore.model_224.Model224AlarmParameters(high_value, low_value, deadband, latch_enable, audible=None, visible=None)

Class used to disable or configure an alarm in conjunction with the set/get_alarm_parameters() method

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

Constructor for Model224AlarmParameters class

Args:
high_value (float):
Sets the value the source is checked against to activate the high alarm
low_value (float):
Sets the value the source is checked against to activate low alarm.
deadband (float):
Sets the value that the source must change outside of an alarm condition to deactivate an unlatched alarm.
latch_enable (bool):
Specifies a latched alarm (False = off, True = on)
audible (bool):
Specifies if the internal speaker will beep when an alarm condition occurs (False = off, True = on) Optional parameter.
visible (bool):
Specifies if the Alarm LED on the instrument front panel will blink when an alarm condition occurs (False = off, True = on) Optional parameter.
class lakeshore.model_224.Model224InputSensorSettings(sensor_type, preferred_units, sensor_range=None, autorange_enabled=False, compensation=False)

Class representing the parameters of a sensor in one of the instrument’s inputs.

__init__(sensor_type, preferred_units, sensor_range=None, autorange_enabled=False, compensation=False)

Constructor for the Model224InputSensorSettings class.

Args:
sensor_type (Model224InputSensorType or int):
  • Specifies what type of sensor is being used at the input.
preferred_units (Model224InputSensorUnits or int):
  • Specifies the preferred units used for sensor readings and alarm setpoints when displayed.
sensor_range (IntEnum):
  • Specifies the range of the sensor.
  • Optional if auto range is enabled
autorange_enabled (bool):
  • Defines if autorange is enabled.
  • Not applicable for diode sensors
  • Defaults to false
compensation (bool):
  • Defines if thermal input compensation is on or off.
  • Not applicable for diode sensors
  • Defaults to false
class lakeshore.model_224.Model224CurveHeader(curve_name, serial_number, curve_data_format, temperature_limit, coefficient)

A class that configures the user curve header and corresponding parameters

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

Constructor for Model224CurveHeader 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 (Model224CurveFormat):
Specifies the curve data format
temperature_limit (float):
  • Specifies the curve temperature limit in Kelvin
coefficient (Model224CurveTemperatureCoefficients):
  • Specifies the curve temperature coefficient

Enumeration objects

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

class lakeshore.model_224.Model224InputSensorType

Enumeration for the type of sensor being used for a given input.

DIODE = 1
INPUT_DISABLED = 0
NTC_RTD = 3
PLATINUM_RTD = 2
class lakeshore.model_224.Model224InputSensorUnits

Enumeration for the preferred units of an input sensor.

CELSIUS = 2
KELVIN = 1
SENSOR = 3
class lakeshore.model_224.Model224DiodeExcitationCurrent

Enum type representing the different excitation currents available for a diode sensor.

ONE_MILLI_AMP = 1
TEN_MICRO_AMPS = 0
class lakeshore.model_224.Model224DiodeSensorRange

Enumeration for the voltage range of a diode sensor.

RANGE_10_VOLTS = 1
RANGE_2_POINT_5_VOLTS = 0
class lakeshore.model_224.Model224PlatinumRTDSensorResistanceRange

Enumeration of the resistance range of a platinum RTD input sensor.

ONE_HUNDRED_OHMS = 2
ONE_KILOHM = 4
TEN_KILOHMS = 6
TEN_OHMS = 0
THIRTY_OHMS = 1
THREE_HUNDRED_OHMS = 3
THREE_KILOHMS = 5
class lakeshore.model_224.Model224NTCRTDSensorResistanceRange

Enumeration of the resistance range of a NTC RTD input sensor.

ONE_HUNDRED_KILOHMS = 8
ONE_HUNDRED_OHMS = 2
ONE_KILOHM = 4
TEN_KILOHMS = 6
TEN_OHMS = 0
THIRTY_KILOHMS = 7
THIRTY_OHMS = 1
THREE_HUNDRED_OHMS = 3
THREE_KILOHMS = 5
class lakeshore.model_224.Model224InterfaceMode

Enumeration for the mode of the remote interface

LOCAL = 0
REMOTE = 1
REMOTE_LOCAL_LOCK = 2
class lakeshore.model_224.Model224RemoteInterface

Enumeration for the remote interface being used to communicate with the instrument.

ETHERNET = 1
IEEE_488 = 2
USB = 0
class lakeshore.model_224.Model224DisplayFieldUnits

Enumerated type defining how units are enumerated for settings and using Display Fields.

CELSIUS = 2
KELVIN = 1
MAXIMUM_DATA = 5
MINIMUM_DATA = 4
SENSOR = 3
class lakeshore.model_224.Model224InputChannel

Enumerated type defining which input channels correspond to ints for setting and using Display Fields.

INPUT_A = 1
INPUT_B = 2
INPUT_C = 3
INPUT_C2 = 9
INPUT_C3 = 10
INPUT_C4 = 11
INPUT_C5 = 12
INPUT_D1 = 4
INPUT_D2 = 5
INPUT_D3 = 6
INPUT_D4 = 7
INPUT_D5 = 8
NO_INPUT = 0
class lakeshore.model_224.Model224DisplayMode

Enumeration defining what input or information is shown on the front panel display.

ALL_INPUTS = 5
CUSTOM = 4
INPUT_A = 0
INPUT_B = 1
INPUT_C = 2
INPUT_C2 = 10
INPUT_C3 = 11
INPUT_C4 = 12
INPUT_C5 = 13
INPUT_D1 = 3
INPUT_D2 = 6
INPUT_D3 = 7
INPUT_D4 = 8
INPUT_D5 = 9
class lakeshore.model_224.Model224NumberOfFields

Enumerated type specifying the number of display fields to configure in the Custom display mode.

LARGE_4 = 0
LARGE_4_SMALL_8 = 2
LARGE_8 = 1
SMALL_16 = 3
class lakeshore.model_224.Model224RelayControlAlarm

Enumeration of the setting determining which alarm(s) cause a relay to activate in alarm mode.

BOTH_ALARMS = 2
HIGH_ALARM = 1
LOW_ALARM = 0
class lakeshore.model_224.Model224RelayControlMode

Enumeration of the configured mode of a relay.

ALARMS = 2
RELAY_OFF = 0
RELAY_ON = 1
class lakeshore.model_224.Model224CurveFormat

Enumerations specify formats for temperature sensor curves

LOG_OHMS_PER_KELVIN = 4
MILLIVOLT_PER_KELVIN = 1
OHMS_PER_KELVIN = 3
VOLTS_PER_KELVIN = 2
class lakeshore.model_224.Model224CurveTemperatureCoefficients

Enumerations specify positive/negative temperature sensor curve coefficients

NEGATIVE = 1
POSITIVE = 2
class lakeshore.model_224.Model224SoftCalSensorTypes

Enum type representing the standard curves used to generate a SoftCal curve. The 3 standard curves each represent a different type of sensor that can be calibrated with a SoftCal curve.

DT_400 = 1
PT_100 = 6
PT_1000 = 7

Status register classes

lakeshore.model_224.Model224StandardEventRegister

alias of lakeshore.temperature_controllers.StandardEventRegister

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

Class object representing the standard event register

bit_names = ['operation_complete', '', 'query_error', '', 'execution_error', 'command_error', '', 'power_on']
class lakeshore.model_224.Model224ServiceRequestRegister(message_available, event_summary, operation_summary)

Class object representing the Service Request Enable register.

bit_names = ['', '', '', '', 'message_available', 'event_summary', 'operation_summary']
class lakeshore.model_224.Model224StatusByteRegister(message_available, event_summary, master_summary_status, operation_summary)

Class object representing the status byte register.

bit_names = ['', '', '', '', 'message_available', 'event_summary', 'master_summary_statusoperation_summary']
class lakeshore.model_224.Model224ReadingStatusRegister(invalid_reading, temperature_under_range, temperature_over_range, sensor_units_zero, sensor_units_over_range)

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 conveninet to represent this functionality as a register.

bit_names = ['invalid_reading', '', '', '', 'temperature_under_range', 'temperature_over_range', 'sensor_units_zero', 'sensor_units_over_range']