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, Model224CurveHeader
# 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", myinstrument.CurveFormat.VOLTS_PER_KELVIN, 300.0,
myinstrument.CurveTemperatureCoefficients.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(myinstrument.SoftCalSensorTypes.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)
Sends an SCPI command or multiple commands to the instrument.
- Args:
- commands (str):
A serial command.
- check_errors (bool):
Chooses whether to check for and raise errors after sending a command. True by default. kwarg. Optional Parameter
- 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.
- Returns:
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 of the interface and terminates all pending operations.
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.
- Returns:
- test_errors (bool):
True means errors found, and False means 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: 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. Options are: A, B, C(1 - 5), D(1 - 5).
- 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.
- Returns:
- (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.
- Returns:
- 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, True for on.
- get_led_state()
Returns whether 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.
- Returns:
- (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.
- Returns:
- 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.
- Returns:
- 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.
- Returns:
- (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}
- 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.
- Returns:
- 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”: DisplayMode, “number_of_fields”: NumberOfFields}.
- 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.
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 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 set-points 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. Optional parameter.
- compensation (bool):
Defines if thermal input compensation is on or off. Not applicable for diode sensors. Defaults to false. Optional parameter.
- 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.Model224Enums
Class containing the enums relevant to the Model 224.
- class InputSensorType(value)
Enumeration for the type of sensor being used for a given input.
- INPUT_DISABLED = 0
- DIODE = 1
- PLATINUM_RTD = 2
- NTC_RTD = 3
- class InputSensorUnits(value)
Enumeration for the preferred units of an input sensor.
- KELVIN = 1
- CELSIUS = 2
- SENSOR = 3
- class DiodeSensorRange(value)
Enumeration for the voltage range of a diode sensor.
- RANGE_2_POINT_5_VOLTS = 0
- RANGE_10_VOLTS = 1
- class PlatinumRTDSensorResistanceRange(value)
Enumeration of the resistance range of a platinum RTD input sensor.
- TEN_OHMS = 0
- THIRTY_OHMS = 1
- ONE_HUNDRED_OHMS = 2
- THREE_HUNDRED_OHMS = 3
- ONE_KILOHM = 4
- THREE_KILOHMS = 5
- TEN_KILOHMS = 6
- class NTCRTDSensorResistanceRange(value)
Enumeration of the resistance range of a NTC RTD input sensor.
- TEN_OHMS = 0
- THIRTY_OHMS = 1
- ONE_HUNDRED_OHMS = 2
- THREE_HUNDRED_OHMS = 3
- ONE_KILOHM = 4
- THREE_KILOHMS = 5
- TEN_KILOHMS = 6
- THIRTY_KILOHMS = 7
- ONE_HUNDRED_KILOHMS = 8
- class InterfaceMode(value)
Enumeration for the mode of the remote interface.
- LOCAL = 0
- REMOTE = 1
- REMOTE_LOCAL_LOCK = 2
- class RemoteInterface(value)
Enumeration for the remote interface being used to communicate with the instrument.
- USB = 0
- ETHERNET = 1
- IEEE_488 = 2
- class DisplayFieldUnits(value)
Enumerated type defining how units are enumerated for settings and using Display Fields.
- KELVIN = 1
- CELSIUS = 2
- SENSOR = 3
- MINIMUM_DATA = 4
- MAXIMUM_DATA = 5
- class InputChannel(value)
Enumerated type defining which input channels correspond to ints for setting and using Display Fields.
- NO_INPUT = 0
- INPUT_A = 1
- INPUT_B = 2
- INPUT_C = 3
- INPUT_D1 = 4
- INPUT_D2 = 5
- INPUT_D3 = 6
- INPUT_D4 = 7
- INPUT_D5 = 8
- INPUT_C2 = 9
- INPUT_C3 = 10
- INPUT_C4 = 11
- INPUT_C5 = 12
- class DisplayMode(value)
Enumeration defining what input or information is shown on the front panel display.
- INPUT_A = 0
- INPUT_B = 1
- INPUT_C = 2
- INPUT_D1 = 3
- CUSTOM = 4
- ALL_INPUTS = 5
- INPUT_D2 = 6
- INPUT_D3 = 7
- INPUT_D4 = 8
- INPUT_D5 = 9
- INPUT_C2 = 10
- INPUT_C3 = 11
- INPUT_C4 = 12
- INPUT_C5 = 13
- class NumberOfFields(value)
Enumerated type specifying the number of display fields to configure in the Custom display mode.
- LARGE_4 = 0
- LARGE_8 = 1
- LARGE_4_SMALL_8 = 2
- SMALL_16 = 3
- class RelayControlAlarm(value)
Enumeration of the setting determining which alarm(s) cause a relay to activate in alarm mode.
- LOW_ALARM = 0
- HIGH_ALARM = 1
- BOTH_ALARMS = 2
- class RelayControlMode(value)
Enumeration of the configured mode of a relay.
- RELAY_OFF = 0
- RELAY_ON = 1
- ALARMS = 2
- class CurveFormat(value)
Enumerations specify formats for temperature sensor curves.
- MILLIVOLT_PER_KELVIN = 1
- VOLTS_PER_KELVIN = 2
- OHMS_PER_KELVIN = 3
- LOG_OHMS_PER_KELVIN = 4
- class CurveTemperatureCoefficients(value)
Enumerations specify positive/negative temperature sensor curve coefficients.
- NEGATIVE = 1
- POSITIVE = 2
Status register classes
- lakeshore.model_224.Model224StandardEventRegister
alias of
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 convenient to represent this functionality as a register.
- bit_names = ['invalid_reading', '', '', '', 'temperature_under_range', 'temperature_over_range', 'sensor_units_zero', 'sensor_units_over_range']