def _build_param_dict(self):
"""
Populate the parameter dictionary with XR-420 parameters.
For each parameter key add value formatting function for set commands.
"""
# The parameter dictionary.
self._param_dict = ProtocolParameterDict()
# Add parameter handlers to parameter dictionary for instrument configuration parameters.
self._param_dict.add(Parameter.CLOCK,
r'(.*)\r\n',
lambda match: match.group(1),
lambda string: str(string),
type=ParameterDictType.STRING,
display_name="clock",
expiration=0,
visibility=ParameterDictVisibility.READ_ONLY)
self._param_dict.add(
Parameter.SAMPLE_INTERVAL,
r'Not used. This parameter is not parsed from instrument response',
None,
self._int_to_string,
type=ParameterDictType.INT,
default_value=30,
value=30,
startup_param=True,
display_name="sample_interval",
visibility=ParameterDictVisibility.IMMUTABLE)
def __init__(self, prompts, newline, driver_event, connections=None):
"""
Constructor.
@param prompts Enum class containing possible device prompts used for
command response logic.
@param newline The device newline.
@driver_event The callback for asynchronous driver events.
"""
if not type(connections) is list:
raise InstrumentProtocolException(
'Unable to instantiate multi connection protocol without connection list'
)
self._param_dict2 = ProtocolParameterDict()
# Construct superclass.
WorkhorseProtocol.__init__(self, prompts, newline, driver_event)
# Create multiple connection versions of the pieces of protocol involving data to/from the instrument
self._linebuf = {connection: '' for connection in connections}
self._promptbuf = {connection: '' for connection in connections}
self._last_data_timestamp = {
connection: None
for connection in connections
}
self.connections = {connection: None for connection in connections}
self.chunkers = {
connection: StringChunker(self.sieve_function)
for connection in connections
}
def _set_params(self, *args, **kwargs):
if len(args) < 1:
raise InstrumentParameterException(
'Set command requires a parameter dict.')
params = args[0]
if not isinstance(params, dict):
raise InstrumentParameterException('Set parameters not a dict.')
self._param_dict = ProtocolParameterDict()
for param in params:
log.info('Creating new parameter: %s', param)
self._param_dict.add(param, '', None, None)
self._param_dict.set_value(param, params[param])
def test_get(self):
"""
test getting values with expiration
"""
# from mi.core.exceptions import InstrumentParameterExpirationException
pd = ProtocolParameterDict()
# No expiration, should work just fine
pd.add('noexp', r'', None, None, expiration=None)
pd.add('zeroexp', r'', None, None, expiration=0)
pd.add('lateexp', r'', None, None, expiration=2)
###
# Set and get with no expire
###
pd.set_value('noexp', 1)
self.assertEqual(pd.get('noexp'), 1)
###
# Set and get with a 0 expire
###
basetime = pd.get_current_timestamp()
pd.set_value('zeroexp', 2)
# We should fail because we are calculating exp against current time
with self.assertRaises(InstrumentParameterExpirationException):
pd.get('zeroexp')
# Should succeed because exp is calculated using basetime
self.assertEqual(pd.get('zeroexp', basetime), 2)
###
# Set and get with a delayed expire
###
basetime = pd.get_current_timestamp()
futuretime = pd.get_current_timestamp(3)
self.assertGreater(futuretime - basetime, 3)
pd.set_value('lateexp', 2)
# Success because data is not expired
self.assertEqual(pd.get('lateexp', basetime), 2)
# Fail because data is expired (simulated three seconds from now)
with self.assertRaises(InstrumentParameterExpirationException):
pd.get('lateexp', futuretime)
def __init__(self, config, memento, data_callback, state_callback, exception_callback):
self._config = config
self._data_callback = data_callback
self._state_callback = state_callback
self._exception_callback = exception_callback
self._memento = memento
self._publisher_thread = None
self._verify_config()
self._param_dict = ProtocolParameterDict()
# Updated my set_resource, defaults defined in build_param_dict
self._polling_interval = None
self._generate_particle_count = None
self._particle_count_per_second = None
self._build_param_dict()
def _build_param_dict(self):
"""
Populate the parameter dictionary with XR-420 parameters.
For each parameter key add value formatting function for set commands.
"""
# The parameter dictionary.
self._param_dict = ProtocolParameterDict()
# Add parameter handlers to parameter dictionary for instrument configuration parameters.
self._param_dict.add(
Parameter.FLUSH_VOLUME,
r'Flush Volume: (.*)mL',
None,
self._int_to_string,
type=ParameterDictType.INT,
default_value=FLUSH_VOLUME,
units=Prefixes.MILLI + Units.LITER,
startup_param=True,
display_name="Flush Volume",
description=
"Amount of sea water to flush prior to taking sample: (10 - 20000)",
visibility=ParameterDictVisibility.IMMUTABLE)
self._param_dict.add(Parameter.FLUSH_FLOWRATE,
r'Flush Flow Rate: (.*)mL/min',
None,
self._int_to_string,
type=ParameterDictType.INT,
default_value=FLUSH_RATE,
units=Prefixes.MILLI + Units.LITER + '/' +
Units.MINUTE,
startup_param=True,
display_name="Flush Flow Rate",
description="Rate at which to flush: (100 - 250)",
visibility=ParameterDictVisibility.IMMUTABLE)
self._param_dict.add(
Parameter.FLUSH_MINFLOW,
r'Flush Min Flow: (.*)mL/min',
None,
self._int_to_string,
type=ParameterDictType.INT,
default_value=FLUSH_MIN_RATE,
units=Prefixes.MILLI + Units.LITER + '/' + Units.MINUTE,
startup_param=True,
display_name="Flush Minimum Flow",
description=
"If the flow rate falls below this value the flush will be terminated, "
"obstruction suspected: (75 - 100)",
visibility=ParameterDictVisibility.IMMUTABLE)
self._param_dict.add(
Parameter.FILL_VOLUME,
r'Fill Volume: (.*)mL',
None,
self._int_to_string,
type=ParameterDictType.INT,
default_value=FILL_VOLUME,
units=Prefixes.MILLI + Units.LITER,
startup_param=True,
display_name="Fill Volume",
description=
"Amount of seawater to run through the collection filter (10 - 20000)",
visibility=ParameterDictVisibility.IMMUTABLE)
self._param_dict.add(
Parameter.FILL_FLOWRATE,
r'Fill Flow Rate: (.*)mL/min',
None,
self._int_to_string,
type=ParameterDictType.INT,
default_value=FILL_RATE,
units=Prefixes.MILLI + Units.LITER + '/' + Units.MINUTE,
startup_param=True,
display_name="Fill Flow Rate",
description="Flow rate during sampling: (100 - 250)",
visibility=ParameterDictVisibility.IMMUTABLE)
self._param_dict.add(
Parameter.FILL_MINFLOW,
r'Fill Min Flow: (.*)mL/min',
None,
self._int_to_string,
type=ParameterDictType.INT,
default_value=FILL_MIN_RATE,
units=Prefixes.MILLI + Units.LITER + '/' + Units.MINUTE,
startup_param=True,
display_name="Fill Minimum Flow",
description=
"If the flow rate falls below this value the fill will be terminated, "
"obstruction suspected: (75 - 100)",
visibility=ParameterDictVisibility.IMMUTABLE)
self._param_dict.add(
Parameter.CLEAR_VOLUME,
r'Reverse Volume: (.*)mL',
None,
self._int_to_string,
type=ParameterDictType.INT,
default_value=CLEAR_VOLUME,
units=Prefixes.MILLI + Units.LITER,
startup_param=True,
display_name="Clear Volume",
description=
"Amount of sea water to flush the home port after taking sample: (10 - 20000)",
visibility=ParameterDictVisibility.IMMUTABLE)
self._param_dict.add(Parameter.CLEAR_FLOWRATE,
r'Reverse Flow Rate: (.*)mL/min',
None,
self._int_to_string,
type=ParameterDictType.INT,
default_value=CLEAR_RATE,
units=Prefixes.MILLI + Units.LITER + '/' +
Units.MINUTE,
startup_param=True,
display_name="Clear Flow Rate",
description="Rate at which to flush: (100 - 250)",
visibility=ParameterDictVisibility.IMMUTABLE)
self._param_dict.add(
Parameter.CLEAR_MINFLOW,
r'Reverse Min Flow: (.*)mL/min',
None,
self._int_to_string,
type=ParameterDictType.INT,
default_value=CLEAR_MIN_RATE,
units=Prefixes.MILLI + Units.LITER + '/' + Units.MINUTE,
startup_param=True,
display_name="Clear Minimum Flow",
description=
"If the flow rate falls below this value the reverse flush will be terminated, "
"obstruction suspected: (75 - 100)",
visibility=ParameterDictVisibility.IMMUTABLE)
self._param_dict.set_value(Parameter.FLUSH_VOLUME, FLUSH_VOLUME)
self._param_dict.set_value(Parameter.FLUSH_FLOWRATE, FLUSH_RATE)
self._param_dict.set_value(Parameter.FLUSH_MINFLOW, FLUSH_MIN_RATE)
self._param_dict.set_value(Parameter.FILL_VOLUME, FILL_VOLUME)
self._param_dict.set_value(Parameter.FILL_FLOWRATE, FILL_RATE)
self._param_dict.set_value(Parameter.FILL_MINFLOW, FILL_MIN_RATE)
self._param_dict.set_value(Parameter.CLEAR_VOLUME, CLEAR_VOLUME)
self._param_dict.set_value(Parameter.CLEAR_FLOWRATE, CLEAR_RATE)
self._param_dict.set_value(Parameter.CLEAR_MINFLOW, CLEAR_MIN_RATE)
def _build_param_dict(self):
"""
Populate the parameter dictionary with XR-420 parameters.
For each parameter key add value formatting function for set commands.
"""
# The parameter dictionary.
self._param_dict = ProtocolParameterDict()
# Add parameter handlers to parameter dictionary for instrument configuration parameters.
self._param_dict.add(Parameter.FLUSH_VOLUME,
r'Flush Volume: (.*)mL',
None,
self._int_to_string,
type=ParameterDictType.INT,
default_value=150,
units='mL',
startup_param=True,
display_name="flush_volume",
visibility=ParameterDictVisibility.IMMUTABLE)
self._param_dict.add(Parameter.FLUSH_FLOWRATE,
r'Flush Flow Rate: (.*)mL/min',
None,
self._int_to_string,
type=ParameterDictType.INT,
default_value=100,
units='mL/min',
startup_param=True,
display_name="flush_flow_rate",
visibility=ParameterDictVisibility.IMMUTABLE)
self._param_dict.add(Parameter.FLUSH_MINFLOW,
r'Flush Min Flow: (.*)mL/min',
None,
self._int_to_string,
type=ParameterDictType.INT,
default_value=75,
units='mL/min',
startup_param=True,
display_name="flush_min_flow",
visibility=ParameterDictVisibility.IMMUTABLE)
self._param_dict.add(Parameter.FILL_VOLUME,
r'Fill Volume: (.*)mL',
None,
self._int_to_string,
type=ParameterDictType.INT,
default_value=4000,
units='mL',
startup_param=True,
display_name="fill_volume",
visibility=ParameterDictVisibility.IMMUTABLE)
self._param_dict.add(Parameter.FILL_FLOWRATE,
r'Fill Flow Rate: (.*)mL/min',
None,
self._int_to_string,
type=ParameterDictType.INT,
default_value=100,
units='mL/min',
startup_param=True,
display_name="fill_flow_rate",
visibility=ParameterDictVisibility.IMMUTABLE)
self._param_dict.add(Parameter.FILL_MINFLOW,
r'Fill Min Flow: (.*)mL/min',
None,
self._int_to_string,
type=ParameterDictType.INT,
default_value=75,
units='mL/min',
startup_param=True,
display_name="fill_min_flow",
visibility=ParameterDictVisibility.IMMUTABLE)
self._param_dict.add(Parameter.CLEAR_VOLUME,
r'Reverse Volume: (.*)mL',
None,
self._int_to_string,
type=ParameterDictType.INT,
default_value=100,
units='mL',
startup_param=True,
display_name="clear_volume",
visibility=ParameterDictVisibility.IMMUTABLE)
self._param_dict.add(Parameter.CLEAR_FLOWRATE,
r'Reverse Flow Rate: (.*)mL/min',
None,
self._int_to_string,
type=ParameterDictType.INT,
default_value=100,
units='mL/min',
startup_param=True,
display_name="clear_flow_rate",
visibility=ParameterDictVisibility.IMMUTABLE)
self._param_dict.add(Parameter.CLEAR_MINFLOW,
r'Reverse Min Flow: (.*)mL/min',
None,
self._int_to_string,
type=ParameterDictType.INT,
default_value=75,
units='mL/min',
startup_param=True,
display_name="clear_min_flow",
visibility=ParameterDictVisibility.IMMUTABLE)
def _build_param_dict(self):
"""
Populate the parameter dictionary with XR-420 parameters.
For each parameter key add value formatting function for set commands.
"""
# The parameter dictionary.
self._param_dict = ProtocolParameterDict()
# Add parameter handlers to parameter dictionary for instrument configuration parameters.
self._param_dict.add(Parameter.SAMPLE_INTERVAL,
'', # this is a driver only parameter
None,
int,
type=ParameterDictType.INT,
startup_param=True,
display_name='D1000 Sample Periodicity',
range=(1, 3600),
description='Periodicity of D1000 temperature sample in autosample mode: (1-3600)',
default_value=DEFAULT_SAMPLE_RATE,
units=Units.SECOND,
visibility=ParameterDictVisibility.READ_WRITE)
self._add_setup_param(Parameter.CHANNEL_ADDRESS,
int,
type=ParameterDictType.INT,
display_name='Base Channel Address',
description='Hex value of ASCII character to ID unit, e.g. 31 is the ASCII code for 1:'
' (30-31, 41-5A, 61-7A)',
range=(0x30, 0x7A),
default_value=0x31)
self._add_setup_param(Parameter.LINEFEED,
bool,
type=ParameterDictType.BOOL,
display_name='Line Feed Flag',
range={'True': True, 'False': False},
description='Enable D1000 to generate a linefeed before and after each response:'
' (true | false)',
default_value=False)
self._add_setup_param(Parameter.PARITY_TYPE,
bool,
type=ParameterDictType.BOOL,
display_name='Parity Type',
range={'Odd': True, 'Even': False},
description='Sets the parity: (true:odd | false:even)',
default_value=False)
self._add_setup_param(Parameter.PARITY_ENABLE,
bool,
type=ParameterDictType.BOOL,
display_name='Parity Flag',
range={'True': True, 'False': False},
description='Enable use of parity bit, a parity error will be issued if detected:'
' (true | false)',
default_value=False)
self._add_setup_param(Parameter.EXTENDED_ADDRESSING,
bool,
type=ParameterDictType.BOOL,
display_name='Extended Addressing',
range={'True': True, 'False': False},
description='Enable extended addressing: (true | false)',
default_value=False)
self._add_setup_param(Parameter.BAUD_RATE,
int,
type=ParameterDictType.INT,
display_name='Baud Rate',
range={'38400': 0, '19200': 1, '9600': 2, '4800': 3, '2400': 4, '1200': 5, '600': 6,
'300': 7, '57600': 8},
description='Using ethernet interface in deployed configuration: (300, 600, '
'1200, 2400, 4800, 9600, 19200, 38400, 57600)',
default_value=9600,
units=Units.BAUD)
self._add_setup_param(Parameter.ALARM_ENABLE,
bool,
type=ParameterDictType.BOOL,
display_name='Enable Alarms',
range={'True': True, 'False': False},
description='Enable alarms to be controlled by the Digital Output (DO) command:'
' (true | false)',
default_value=False)
self._add_setup_param(Parameter.LOW_ALARM_LATCH,
bool,
type=ParameterDictType.BOOL,
display_name='Low Alarm Latching',
range={'True': True, 'False': False},
description='Enable changing the alarm to latching mode: (true | false)',
default_value=False)
self._add_setup_param(Parameter.HIGH_ALARM_LATCH,
bool,
type=ParameterDictType.BOOL,
display_name='High Alarm Latching',
range={'True': True, 'False': False},
description='Enable changing the alarm to latching mode: (true | false)',
default_value=False)
self._add_setup_param(Parameter.RTD_4_WIRE,
bool,
type=ParameterDictType.BOOL,
display_name='4 Wire RTD Flag',
range={'True': True, 'False': False},
description='Represents a physical configuration of the instrument, '
'disabling may cause data to be misaligned: (true | false)',
default_value=True)
self._add_setup_param(Parameter.TEMP_UNITS,
bool,
type=ParameterDictType.BOOL,
display_name='Fahrenheit Flag',
range={'Fahrenheit': True, 'Celsius': False},
description='Flag to control the temperature format: (true:Fahrenheit | false:Celsius)',
default_value=False)
self._add_setup_param(Parameter.ECHO,
bool,
type=ParameterDictType.BOOL,
display_name='Daisy Chain',
range={'True': True, 'False': False},
description='If not set, only 1 out of 3 D1000s will process commands: (true | false)',
default_value=True)
self._add_setup_param(Parameter.COMMUNICATION_DELAY,
int,
type=ParameterDictType.INT,
display_name='Communication Delay',
range=(0, 3),
description='The number of delays to add when processing commands: (0-3)',
default_value=0)
self._add_setup_param(Parameter.PRECISION,
int,
type=ParameterDictType.INT,
display_name='Precision',
range={'4 digits': 0, '5 digits': 1, '6 digits': 2, '7 digits': 3},
description='Number of digits the instrument should output for temperature query: '
'(0=4-3=7)',
default_value=6)
self._add_setup_param(Parameter.LARGE_SIGNAL_FILTER_C,
float,
type=ParameterDictType.FLOAT,
display_name='Large Signal Filter Constant',
range={'0': 0, '.25': 1, '.5': 2, '1': 3, '2': 4, '4': 5, '8': 6, '16': 7},
description='Time to reach 63% of its final value: '
'(0 = 0.0, 1 = 0.25, 2 = 0.5, 3 = 1.0, 4 = 2.0, 5 = 4.0, 6 = 8.0, 7 = 16.0)',
default_value=0.0,
units=Units.SECOND)
self._add_setup_param(Parameter.SMALL_SIGNAL_FILTER_C,
float,
type=ParameterDictType.FLOAT,
display_name='Small Signal Filter Constant',
range={'0': 0, '.25': 1, '.5': 2, '1': 3, '2': 4, '4': 5, '8': 6, '16': 7},
description='Smaller filter constant, should be larger than large filter constant: '
'(0 = 0.0, 1 = 0.25, 2 = 0.5, 3 = 1.0, 4 = 2.0, 5 = 4.0, 6 = 8.0, 7 = 16.0)',
default_value=0.50,
units=Units.SECOND)
for key in self._param_dict.get_keys():
self._param_dict.set_default(key)
def test_empty_schema(self):
self.param_dict = ProtocolParameterDict()
result = self.param_dict.generate_dict()
self.assertEqual(result, {})
def setUp(self):
self.param_dict = ProtocolParameterDict()
self.param_dict.add("foo",
r'.*foo=(\d+).*',
lambda match: int(match.group(1)),
lambda x: str(x),
direct_access=True,
startup_param=True,
default_value=10,
visibility=ParameterDictVisibility.READ_WRITE)
self.param_dict.add("bar",
r'.*bar=(\d+).*',
lambda match: int(match.group(1)),
lambda x: str(x),
direct_access=False,
startup_param=True,
default_value=15,
visibility=ParameterDictVisibility.READ_WRITE)
self.param_dict.add(
"baz",
r'.*baz=(\d+).*',
lambda match: int(match.group(1)),
lambda x: str(x),
direct_access=True,
default_value=20,
visibility=ParameterDictVisibility.DIRECT_ACCESS,
get_timeout=30,
set_timeout=40,
display_name="Baz",
description="The baz parameter",
type=ParameterDictType.INT,
units="nano-bazers",
value_description="Should be an integer between 2 and 2000")
self.param_dict.add(
"bat",
r'.*bat=(\d+).*',
lambda match: int(match.group(1)),
lambda x: str(x),
startup_param=False,
default_value=20,
visibility=ParameterDictVisibility.READ_ONLY,
get_timeout=10,
set_timeout=20,
display_name="Bat",
description="The bat parameter",
type=ParameterDictType.INT,
units="nano-batbit",
value_description="Should be an integer between 1 and 1000")
self.param_dict.add("qux",
r'.*qux=(\d+).*',
lambda match: int(match.group(1)),
lambda x: str(x),
startup_param=False,
visibility=ParameterDictVisibility.READ_ONLY)
self.param_dict.add("pho",
r'.*qux=(\d+).*',
lambda match: int(match.group(1)),
lambda x: str(x),
startup_param=False,
visibility=ParameterDictVisibility.IMMUTABLE)
self.param_dict.add("dil",
r'.*qux=(\d+).*',
lambda match: int(match.group(1)),
lambda x: str(x),
startup_param=False,
visibility=ParameterDictVisibility.IMMUTABLE)
self.param_dict.add(
"qut",
r'.*qut=(\d+).*',
lambda match: int(match.group(1)),
lambda x: str(x),
direct_access=True,
default_value=[10, 100],
visibility=ParameterDictVisibility.DIRECT_ACCESS,
expiration=1,
get_timeout=10,
set_timeout=20,
display_name="Qut",
description="The qut list parameter",
type=ParameterDictType.LIST,
units="nano-qutters",
value_description=
"Should be a 2-10 element list of integers between 2 and 2000")
self.target_schema = {
"bar": {
"direct_access": False,
"get_timeout": 10,
"set_timeout": 10,
"startup": True,
"value": {
"default": 15
},
"visibility": "READ_WRITE",
"range": None,
},
"bat": {
"description": "The bat parameter",
"direct_access": False,
"display_name": "Bat",
"get_timeout": 10,
"set_timeout": 20,
"startup": False,
"value": {
"default": 20,
"description": "Should be an integer between 1 and 1000",
"type": "int",
"units": "nano-batbit"
},
"visibility": "READ_ONLY",
"range": None,
},
"baz": {
"description": "The baz parameter",
"direct_access": True,
"display_name": "Baz",
"get_timeout": 30,
"set_timeout": 40,
"startup": False,
"value": {
"default": 20,
"description": "Should be an integer between 2 and 2000",
"type": "int",
"units": "nano-bazers"
},
"visibility": "DIRECT_ACCESS",
"range": None,
},
"dil": {
"direct_access": False,
"get_timeout": 10,
"set_timeout": 10,
"startup": False,
"value": {},
"visibility": "IMMUTABLE",
"range": None,
},
"foo": {
"direct_access": True,
"get_timeout": 10,
"set_timeout": 10,
"startup": True,
"value": {
"default": 10
},
"visibility": "READ_WRITE",
"range": None,
},
"pho": {
"direct_access": False,
"get_timeout": 10,
"set_timeout": 10,
"startup": False,
"value": {},
"visibility": "IMMUTABLE",
"range": None,
},
"qut": {
"description": "The qut list parameter",
"direct_access": True,
"display_name": "Qut",
"get_timeout": 10,
"set_timeout": 20,
"startup": False,
"value": {
"default": [10, 100],
"description":
"Should be a 2-10 element list of integers between 2 and 2000",
"type": "list",
"units": "nano-qutters"
},
"visibility": "DIRECT_ACCESS",
"range": None,
},
"qux": {
"direct_access": False,
"get_timeout": 10,
"set_timeout": 10,
"startup": False,
"value": {},
"visibility": "READ_ONLY",
"range": None,
}
}
self.test_yaml = '''
def _build_param_dict(self):
"""
Populate the parameter dictionary with parameters.
For each parameter key, add match stirng, match lambda function,
and value formatting function for set commands.
"""
# Add parameter handlers to parameter dict.
self._param_dict = ProtocolParameterDict()
self._param_dict.add(Parameter.CYCLE_TIME,
r'(\d+)\s+= Cycle Time \(.*\)\r\n(0|1)\s+= Minutes or Seconds Cycle Time',
lambda match : self._to_seconds(int(match.group(1)),
int(match.group(2))),
self._int_to_string,
visibility=ParameterDictVisibility.READ_WRITE,
startup_param=True,
direct_access=False,
default_value=20,
menu_path_read=SubMenu.SHOW_PARAM,
submenu_read=[],
menu_path_write=SubMenu.CHANGE_PARAM,
submenu_write=[["1", Prompt.CYCLE_TIME_PROMPT]])
self._param_dict.add(Parameter.VERBOSE,
r'', # Write-only, so does it really matter?
lambda match : None,
self._int_to_string,
visibility=ParameterDictVisibility.READ_ONLY,
startup_param=True,
direct_access=True,
init_value=1,
menu_path_write=SubMenu.CHANGE_PARAM,
submenu_write=[["2", Prompt.VERBOSE_PROMPT]])
self._param_dict.add(Parameter.METADATA_POWERUP,
r'(0|1)\s+= Metadata Print Status on Power up',
lambda match : int(match.group(1)),
self._int_to_string,
visibility=ParameterDictVisibility.READ_ONLY,
startup_param=True,
direct_access=True,
init_value=0,
menu_path_write=SubMenu.CHANGE_PARAM,
submenu_write=[["3", Prompt.METADATA_PROMPT]])
self._param_dict.add(Parameter.METADATA_RESTART,
r'(0|1)\s+= Metadata Print Status on Restart Data Collection',
lambda match : int(match.group(1)),
self._int_to_string,
visibility=ParameterDictVisibility.READ_ONLY,
startup_param=True,
direct_access=True,
init_value=0,
menu_path_write=SubMenu.CHANGE_PARAM,
submenu_write=[["4", Prompt.METADATA_PROMPT]])
self._param_dict.add(Parameter.RES_SENSOR_POWER,
r'(0|1)\s+= Res Power Status',
lambda match : int(match.group(1)),
self._int_to_string,
visibility=ParameterDictVisibility.READ_ONLY,
startup_param=True,
direct_access=False,
init_value=1,
menu_path_read=SubMenu.SHOW_PARAM,
submenu_read=[],
menu_path_write=SubMenu.SENSOR_POWER,
submenu_write=[["1"]])
self._param_dict.add(Parameter.INST_AMP_POWER,
r'(0|1)\s+= Thermocouple & Hydrogen Amp Power Status',
lambda match : int(match.group(1)),
self._int_to_string,
visibility=ParameterDictVisibility.READ_ONLY,
startup_param=True,
direct_access=False,
init_value=1,
menu_path_read=SubMenu.SHOW_PARAM,
submenu_read=[],
menu_path_write=SubMenu.SENSOR_POWER,
submenu_write=[["2"]])
self._param_dict.add(Parameter.EH_ISOLATION_AMP_POWER,
r'(0|1)\s+= eh Amp Power Status',
lambda match : int(match.group(1)),
self._int_to_string,
visibility=ParameterDictVisibility.READ_ONLY,
startup_param=True,
direct_access=False,
init_value=1,
menu_path_read=SubMenu.SHOW_PARAM,
submenu_read=[],
menu_path_write=SubMenu.SENSOR_POWER,
submenu_write=[["3"]])
self._param_dict.add(Parameter.HYDROGEN_POWER,
r'(0|1)\s+= Hydrogen Sensor Power Status',
lambda match : int(match.group(1)),
self._int_to_string,
visibility=ParameterDictVisibility.READ_ONLY,
startup_param=True,
direct_access=False,
init_value=1,
menu_path_read=SubMenu.SHOW_PARAM,
submenu_read=[],
menu_path_write=SubMenu.SENSOR_POWER,
submenu_write=[["4"]])
self._param_dict.add(Parameter.REFERENCE_TEMP_POWER,
r'(0|1)\s+= Reference Temperature Power Status',
lambda match : int(match.group(1)),
self._int_to_string,
visibility=ParameterDictVisibility.READ_ONLY,
startup_param=True,
direct_access=False,
init_value=1,
menu_path_read=SubMenu.SHOW_PARAM,
submenu_read=[],
menu_path_write=SubMenu.SENSOR_POWER,
submenu_write=[["5"]])
def _build_param_dict(self):
"""
Populate the parameter dictionary with XR-420 parameters.
For each parameter key add value formatting function for set commands.
"""
# The parameter dictionary.
self._param_dict = ProtocolParameterDict()
# Add parameter handlers to parameter dictionary for instrument configuration parameters.
self._param_dict.add(
Parameter.SAMPLE_INTERVAL,
'', # this is a driver only parameter
None,
int,
type=ParameterDictType.INT,
default_value=DEFAULT_SAMPLE_RATE,
startup_param=True,
display_name='D1000 sample periodicity (sec)',
visibility=ParameterDictVisibility.READ_WRITE)
self._add_setup_param(Parameter.CHANNEL_ADDRESS,
int,
display_name='base channel address',
type=ParameterDictType.INT,
default_value=0x31)
self._add_setup_param(Parameter.LINEFEED,
bool,
display_name='line feed flag',
type=ParameterDictType.BOOL,
default_value=False)
self._add_setup_param(Parameter.PARITY_TYPE,
bool,
display_name='parity type',
type=ParameterDictType.BOOL,
default_value=False)
self._add_setup_param(Parameter.PARITY_ENABLE,
bool,
display_name='parity flag',
type=ParameterDictType.BOOL,
default_value=False)
self._add_setup_param(Parameter.EXTENDED_ADDRESSING,
bool,
display_name='extended addressing',
type=ParameterDictType.BOOL,
default_value=False)
self._add_setup_param(Parameter.BAUD_RATE,
int,
display_name='baud rate',
type=ParameterDictType.INT,
default_value=9600)
self._add_setup_param(Parameter.ALARM_ENABLE,
bool,
display_name='enable alarms',
type=ParameterDictType.BOOL,
default_value=False)
self._add_setup_param(Parameter.LOW_ALARM_LATCH,
bool,
display_name='low alarm latching',
type=ParameterDictType.BOOL,
default_value=False)
self._add_setup_param(Parameter.HIGH_ALARM_LATCH,
bool,
display_name='high alarm latching',
type=ParameterDictType.BOOL,
default_value=False)
self._add_setup_param(Parameter.RTD_4_WIRE,
bool,
display_name='4 wire RTD flag',
type=ParameterDictType.BOOL,
default_value=True)
self._add_setup_param(Parameter.TEMP_UNITS,
bool,
display_name='Fahrenheit flag',
type=ParameterDictType.BOOL,
default_value=False)
self._add_setup_param(Parameter.ECHO,
bool,
display_name='daisy chain',
type=ParameterDictType.BOOL,
default_value=True)
self._add_setup_param(Parameter.COMMUNICATION_DELAY,
int,
display_name='communication delay',
type=ParameterDictType.INT,
default_value=0)
self._add_setup_param(Parameter.PRECISION,
int,
display_name='precision',
type=ParameterDictType.INT,
default_value=6)
self._add_setup_param(Parameter.LARGE_SIGNAL_FILTER_C,
float,
display_name='large signal filter constant',
type=ParameterDictType.FLOAT,
default_value=0.0)
self._add_setup_param(Parameter.SMALL_SIGNAL_FILTER_C,
float,
display_name='small signal filter constant',
type=ParameterDictType.FLOAT,
default_value=0.50)
for key in self._param_dict.get_keys():
self._param_dict.set_default(key)
def _build_param_dict(self):
"""
For each parameter key, add match stirng, match lambda function,
and value formatting function for set commands.
"""
# Add parameter handlers to parameter dict.
self._param_dict = ProtocolParameterDict()
### example configuration string
# VALID_CONFIG_STRING = 'CEE90B0002C7EA0001E133800A000E100402000E10010B' + \
# '000000000D000000000D000000000D07' + \
# '1020FF54181C01003814' + \
# '000000000000000000000000000000000000000000000000000' + \
# '000000000000000000000000000000000000000000000000000' + \
# '0000000000000000000000000000' + \
# 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF' + \
# 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF' + \
# 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF' + \
# 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF' + \
# 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF' + \
# 'FFFFFFFFFFFFFFFFFFFFFFFFFFFFF' + NEWLINE
#
###
self._param_dict.add(Parameter.LAUNCH_TIME, CONFIGURATION_REGEX,
lambda match: int(match.group(1), 16),
lambda x: self._int_to_hexstring(x, 8),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x00000000,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='launch time')
self._param_dict.add(Parameter.START_TIME_FROM_LAUNCH, CONFIGURATION_REGEX,
lambda match: int(match.group(2), 16),
lambda x: self._int_to_hexstring(x, 8),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x02C7EA00,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='start time after launch time')
self._param_dict.add(Parameter.STOP_TIME_FROM_START, CONFIGURATION_REGEX,
lambda match: int(match.group(3), 16),
lambda x: self._int_to_hexstring(x, 8),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x01E13380,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='stop time after start time')
self._param_dict.add(Parameter.MODE_BITS, CONFIGURATION_REGEX,
lambda match: int(match.group(4), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x0A,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='mode bits (set to 00001010)')
self._param_dict.add(Parameter.SAMI_SAMPLE_INTERVAL, CONFIGURATION_REGEX,
lambda match: int(match.group(5), 16),
lambda x: self._int_to_hexstring(x, 6),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x000E10,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='sami sample interval')
self._param_dict.add(Parameter.SAMI_DRIVER_VERSION, CONFIGURATION_REGEX,
lambda match: int(match.group(6), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x04,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='sami driver version')
self._param_dict.add(Parameter.SAMI_PARAMS_POINTER, CONFIGURATION_REGEX,
lambda match: int(match.group(7), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x02,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='sami parameter pointer')
self._param_dict.add(Parameter.DEVICE1_SAMPLE_INTERVAL, CONFIGURATION_REGEX,
lambda match: int(match.group(8), 16),
lambda x: self._int_to_hexstring(x, 6),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x000E10,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='device 1 sample interval')
self._param_dict.add(Parameter.DEVICE1_DRIVER_VERSION, CONFIGURATION_REGEX,
lambda match: int(match.group(9), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x01,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='device 1 driver version')
self._param_dict.add(Parameter.DEVICE1_PARAMS_POINTER, CONFIGURATION_REGEX,
lambda match: int(match.group(10), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x0B,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='device 1 parameter pointer')
self._param_dict.add(Parameter.DEVICE2_SAMPLE_INTERVAL, CONFIGURATION_REGEX,
lambda match: int(match.group(11), 16),
lambda x: self._int_to_hexstring(x, 6),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x000000,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='device 2 sample interval')
self._param_dict.add(Parameter.DEVICE2_DRIVER_VERSION, CONFIGURATION_REGEX,
lambda match: int(match.group(12), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x00,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='device 2 driver version')
self._param_dict.add(Parameter.DEVICE2_PARAMS_POINTER, CONFIGURATION_REGEX,
lambda match: int(match.group(13), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x0D,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='device 2 parameter pointer')
self._param_dict.add(Parameter.DEVICE3_SAMPLE_INTERVAL, CONFIGURATION_REGEX,
lambda match: int(match.group(14), 16),
lambda x: self._int_to_hexstring(x, 6),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x000000,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='device 3 sample interval')
self._param_dict.add(Parameter.DEVICE3_DRIVER_VERSION, CONFIGURATION_REGEX,
lambda match: int(match.group(15), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x00,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='device 3 driver version')
self._param_dict.add(Parameter.DEVICE3_PARAMS_POINTER, CONFIGURATION_REGEX,
lambda match: int(match.group(16), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x0D,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='device 3 parameter pointer')
self._param_dict.add(Parameter.PRESTART_SAMPLE_INTERVAL, CONFIGURATION_REGEX,
lambda match: int(match.group(17), 16),
lambda x: self._int_to_hexstring(x, 6),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x000000,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='prestart sample interval')
self._param_dict.add(Parameter.PRESTART_DRIVER_VERSION, CONFIGURATION_REGEX,
lambda match: int(match.group(18), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x00,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='prestart driver version')
self._param_dict.add(Parameter.PRESTART_PARAMS_POINTER, CONFIGURATION_REGEX,
lambda match: int(match.group(19), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x0D,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='prestart parameter pointer')
self._param_dict.add(Parameter.GLOBAL_CONFIGURATION, CONFIGURATION_REGEX,
lambda match: int(match.group(20), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x00,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='global bits (set to 00000111)')
self._param_dict.add(Parameter.PUMP_PULSE, CONFIGURATION_REGEX,
lambda match: int(match.group(21), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x10,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='pump pulse duration')
self._param_dict.add(Parameter.PUMP_DURATION, CONFIGURATION_REGEX,
lambda match: int(match.group(22), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x20,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='pump measurement duration')
self._param_dict.add(Parameter.SAMPLES_PER_MEASUREMENT, CONFIGURATION_REGEX,
lambda match: int(match.group(23), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0xFF,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='samples per measurement')
self._param_dict.add(Parameter.CYCLES_BETWEEN_BLANKS, CONFIGURATION_REGEX,
lambda match: int(match.group(24), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0xA8,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='cycles between blanks')
self._param_dict.add(Parameter.NUMBER_REAGENT_CYCLES, CONFIGURATION_REGEX,
lambda match: int(match.group(25), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x18,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='number of reagent cycles')
self._param_dict.add(Parameter.NUMBER_BLANK_CYCLES, CONFIGURATION_REGEX,
lambda match: int(match.group(26), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x1C,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='number of blank cycles')
self._param_dict.add(Parameter.FLUSH_PUMP_INTERVAL, CONFIGURATION_REGEX,
lambda match: int(match.group(27), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x01,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='flush pump interval')
self._param_dict.add(Parameter.BIT_SWITCHES, CONFIGURATION_REGEX,
lambda match: int(match.group(28), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x00,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='bit switches')
self._param_dict.add(Parameter.NUMBER_EXTRA_PUMP_CYCLES, CONFIGURATION_REGEX,
lambda match: int(match.group(29), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x38,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='number of extra pump cycles')
self._param_dict.add(Parameter.EXTERNAL_PUMP_SETTINGS, CONFIGURATION_REGEX,
lambda match: int(match.group(30), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x14,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='external pump settings')
def _build_param_dict(self):
"""
Populate the parameter dictionary with parameters.
For each parameter key, add match stirng, match lambda function,
and value formatting function for set commands.
"""
# Add parameter handlers to parameter dict.
self._param_dict = ProtocolParameterDict()
self._param_dict.add(Parameter.LAUNCH_TIME,
CONFIGURATION_REGEX,
lambda match: int(match.group(1), 16),
lambda x: self._int_to_hexstring(x, 8),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x00000000,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='launch time')
self._param_dict.add(Parameter.START_TIME_FROM_LAUNCH,
CONFIGURATION_REGEX,
lambda match: int(match.group(2), 16),
lambda x: self._int_to_hexstring(x, 8),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x02C7EA00,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='start time after launch time')
self._param_dict.add(Parameter.STOP_TIME_FROM_START,
CONFIGURATION_REGEX,
lambda match: int(match.group(3), 16),
lambda x: self._int_to_hexstring(x, 8),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x01E13380,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='stop time after start time')
self._param_dict.add(Parameter.MODE_BITS,
CONFIGURATION_REGEX,
lambda match: int(match.group(4), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x0A,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='mode bits (set to 00001010)')
self._param_dict.add(Parameter.SAMI_SAMPLE_INTERVAL,
CONFIGURATION_REGEX,
lambda match: int(match.group(5), 16),
lambda x: self._int_to_hexstring(x, 6),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x000E10,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='sami sample interval')
self._param_dict.add(Parameter.SAMI_DRIVER_VERSION,
CONFIGURATION_REGEX,
lambda match: int(match.group(6), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x04,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='sami driver version')
self._param_dict.add(Parameter.SAMI_PARAMS_POINTER,
CONFIGURATION_REGEX,
lambda match: int(match.group(7), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x02,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='sami parameter pointer')
self._param_dict.add(Parameter.DEVICE1_SAMPLE_INTERVAL,
CONFIGURATION_REGEX,
lambda match: int(match.group(8), 16),
lambda x: self._int_to_hexstring(x, 6),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x000E10,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='device 1 sample interval')
self._param_dict.add(Parameter.DEVICE1_DRIVER_VERSION,
CONFIGURATION_REGEX,
lambda match: int(match.group(9), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x01,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='device 1 driver version')
self._param_dict.add(Parameter.DEVICE1_PARAMS_POINTER,
CONFIGURATION_REGEX,
lambda match: int(match.group(10), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x0B,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='device 1 parameter pointer')
self._param_dict.add(Parameter.DEVICE2_SAMPLE_INTERVAL,
CONFIGURATION_REGEX,
lambda match: int(match.group(11), 16),
lambda x: self._int_to_hexstring(x, 6),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x000000,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='device 2 sample interval')
self._param_dict.add(Parameter.DEVICE2_DRIVER_VERSION,
CONFIGURATION_REGEX,
lambda match: int(match.group(12), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x00,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='device 2 driver version')
self._param_dict.add(Parameter.DEVICE2_PARAMS_POINTER,
CONFIGURATION_REGEX,
lambda match: int(match.group(13), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x0D,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='device 2 parameter pointer')
self._param_dict.add(Parameter.DEVICE3_SAMPLE_INTERVAL,
CONFIGURATION_REGEX,
lambda match: int(match.group(14), 16),
lambda x: self._int_to_hexstring(x, 6),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x000000,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='device 3 sample interval')
self._param_dict.add(Parameter.DEVICE3_DRIVER_VERSION,
CONFIGURATION_REGEX,
lambda match: int(match.group(15), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x00,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='device 3 driver version')
self._param_dict.add(Parameter.DEVICE3_PARAMS_POINTER,
CONFIGURATION_REGEX,
lambda match: int(match.group(16), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x0D,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='device 3 parameter pointer')
self._param_dict.add(Parameter.PRESTART_SAMPLE_INTERVAL,
CONFIGURATION_REGEX,
lambda match: int(match.group(17), 16),
lambda x: self._int_to_hexstring(x, 6),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x000000,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='prestart sample interval')
self._param_dict.add(Parameter.PRESTART_DRIVER_VERSION,
CONFIGURATION_REGEX,
lambda match: int(match.group(18), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x00,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='prestart driver version')
self._param_dict.add(Parameter.PRESTART_PARAMS_POINTER,
CONFIGURATION_REGEX,
lambda match: int(match.group(19), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x0D,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='prestart parameter pointer')
self._param_dict.add(Parameter.GLOBAL_CONFIGURATION,
CONFIGURATION_REGEX,
lambda match: int(match.group(20), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x00,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='global bits (set to 00000111)')
self._param_dict.add(Parameter.NUMBER_SAMPLES_AVERAGED,
CONFIGURATION_REGEX,
lambda match: int(match.group(21), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x00,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='number of samples averaged',
description='')
self._param_dict.add(Parameter.NUMBER_FLUSHES,
CONFIGURATION_REGEX,
lambda match: int(match.group(22), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x00,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='number of samples averaged',
description='')
self._param_dict.add(Parameter.PUMP_ON_FLUSH,
CONFIGURATION_REGEX,
lambda match: int(match.group(23), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x00,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='number of samples averaged',
description='')
self._param_dict.add(Parameter.PUMP_OFF_FLUSH,
CONFIGURATION_REGEX,
lambda match: int(match.group(24), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x00,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='number of samples averaged',
description='')
self._param_dict.add(Parameter.NUMBER_REAGENT_PUMPS,
CONFIGURATION_REGEX,
lambda match: int(match.group(25), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x00,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='number of samples averaged',
description='')
self._param_dict.add(Parameter.VALVE_DELAY,
CONFIGURATION_REGEX,
lambda match: int(match.group(26), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x00,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='number of samples averaged',
description='')
self._param_dict.add(Parameter.PUMP_ON_IND,
CONFIGURATION_REGEX,
lambda match: int(match.group(27), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x00,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='number of samples averaged',
description='')
self._param_dict.add(Parameter.PV_OFF_IND,
CONFIGURATION_REGEX,
lambda match: int(match.group(28), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x00,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='number of samples averaged',
description='')
self._param_dict.add(Parameter.NUMBER_BLANKS,
CONFIGURATION_REGEX,
lambda match: int(match.group(29), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x00,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='number of samples averaged',
description='')
self._param_dict.add(Parameter.PUMP_MEASURE_T,
CONFIGURATION_REGEX,
lambda match: int(match.group(30), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x00,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='number of samples averaged',
description='')
self._param_dict.add(Parameter.PUMP_OFF_TO_MEASURE,
CONFIGURATION_REGEX,
lambda match: int(match.group(31), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x00,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='number of samples averaged',
description='')
self._param_dict.add(Parameter.MEASURE_TO_PUMP_ON,
CONFIGURATION_REGEX,
lambda match: int(match.group(32), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x00,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='number of samples averaged',
description='')
self._param_dict.add(Parameter.NUMBER_MEASUREMENTS,
CONFIGURATION_REGEX,
lambda match: int(match.group(33), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x00,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='number of samples averaged',
description='')
self._param_dict.add(Parameter.SALINITY_DELAY,
CONFIGURATION_REGEX,
lambda match: int(match.group(34), 16),
lambda x: self._int_to_hexstring(x, 2),
type=ParameterDictType.INT,
startup_param=False,
direct_access=True,
default_value=0x00,
visibility=ParameterDictVisibility.READ_ONLY,
display_name='number of samples averaged',
description='')
