def _build_param_dict(self):
# We're going to build two complete sets of ADCP parameters here
# one set for the master instrument and one for the slave
for param in parameter_regexes:
self._param_dict.add(
param,
parameter_regexes.get(param),
parameter_extractors.get(param),
parameter_formatters.get(param),
type=parameter_types.get(param),
display_name=parameter_names.get(param),
value_description=parameter_descriptions.get(param),
range=parameter_ranges.get(param),
startup_param=parameter_startup.get(param, False),
direct_access=parameter_direct.get(param, False),
visibility=parameter_visibility.get(
param, ParameterDictVisibility.READ_WRITE),
default_value=master_parameter_defaults.get(param),
units=parameter_units.get(param))
for param in parameter_regexes:
# Scheduled events are handled by the master
if WorkhorseEngineeringParameter.has(param):
continue
self._param_dict.add(
param + '_5th',
r'DONTMATCHMEIMNOTREAL!',
parameter_extractors.get(param),
parameter_formatters.get(param),
type=parameter_types.get(param),
display_name=parameter_names.get(param) + ' (5th beam)',
value_description=parameter_descriptions.get(param),
range=parameter_ranges.get(param),
startup_param=parameter_startup.get(param, False),
direct_access=parameter_direct.get(param, False),
visibility=parameter_visibility.get(
param, ParameterDictVisibility.READ_WRITE),
default_value=slave_parameter_defaults.get(param),
units=parameter_units.get(param))
self._param_dict.set_default(WorkhorseParameter.CLOCK_SYNCH_INTERVAL)
self._param_dict.set_default(WorkhorseParameter.GET_STATUS_INTERVAL)
# now we're going to build a whole 'nother param dict for the slave parameters
# that contain regex values so we can fill them in easily...
for param in parameter_regexes:
# Scheduled events are handled by the master
if WorkhorseEngineeringParameter.has(param):
continue
self._param_dict2.add(param + '_5th', parameter_regexes.get(param),
parameter_extractors.get(param),
parameter_formatters.get(param))
def _build_param_dict(self):
# We're going to build two complete sets of ADCP parameters here
# one set for the master instrument and one for the slave
for param in parameter_regexes:
self._param_dict.add(param,
parameter_regexes.get(param),
parameter_extractors.get(param),
parameter_formatters.get(param),
type=parameter_types.get(param),
display_name=parameter_names.get(param),
description=parameter_descriptions.get(param),
range=parameter_ranges.get(param),
startup_param=parameter_startup.get(param, False),
direct_access=parameter_direct.get(param, False),
visibility=parameter_visibility.get(param, ParameterDictVisibility.READ_WRITE),
default_value=master_parameter_defaults.get(param),
units=parameter_units.get(param))
for param in parameter_regexes:
# Scheduled events are handled by the master
if WorkhorseEngineeringParameter.has(param):
continue
self._param_dict.add(param + '_5th',
r'DONTMATCHMEIMNOTREAL!',
parameter_extractors.get(param),
parameter_formatters.get(param),
type=parameter_types.get(param),
display_name=parameter_names.get(param) + ' (5th beam)',
description=parameter_descriptions.get(param),
range=parameter_ranges.get(param),
startup_param=parameter_startup.get(param, False),
direct_access=parameter_direct.get(param, False),
visibility=parameter_visibility.get(param, ParameterDictVisibility.READ_WRITE),
default_value=slave_parameter_defaults.get(param),
units=parameter_units.get(param))
self._param_dict.set_default(WorkhorseParameter.CLOCK_SYNCH_INTERVAL)
self._param_dict.set_default(WorkhorseParameter.GET_STATUS_INTERVAL)
# now we're going to build a whole 'nother param dict for the slave parameters
# that contain regex values so we can fill them in easily...
for param in parameter_regexes:
# Scheduled events are handled by the master
if WorkhorseEngineeringParameter.has(param):
continue
self._param_dict2.add(param + '_5th',
parameter_regexes.get(param),
parameter_extractors.get(param),
parameter_formatters.get(param))
def _update_params(self, *args, **kwargs):
"""
Update the parameter dictionary.
"""
# see if we passed in a list of parameters to query
# if not, use the whole parameter list
parameters = kwargs.get('params')
if parameters is None or WorkhorseParameter.ALL in parameters:
parameters = self._param_dict.get_keys()
# filter out the engineering parameters and ALL
parameters = [p for p in parameters if not WorkhorseEngineeringParameter.has(p) and p != WorkhorseParameter.ALL]
# Get old param dict config.
old_config = self._param_dict.get_config()
if parameters:
# MASTER
master_params = [p for p in parameters if '_5th' not in p]
if master_params:
resp = self._get_params(master_params, SlaveProtocol.FOURBEAM)
self._param_dict.update_many(resp)
# SLAVE
slave_params = [p.replace('_5th', '') for p in parameters if '_5th' in p]
if slave_params:
resp = self._get_params(slave_params, SlaveProtocol.FIFTHBEAM)
self._param_dict2.update_many(resp)
for key, value in self._param_dict2.get_all().iteritems():
self._param_dict.set_value(key, value)
new_config = self._param_dict.get_config()
# Check if there is any changes. Ignore TT
if not dict_equal(new_config, old_config, ['TT']) or kwargs.get('force'):
self._driver_event(DriverAsyncEvent.CONFIG_CHANGE)
def _set_params(self, *args, **kwargs):
"""
Issue commands to the instrument to set various parameters
"""
self._verify_not_readonly(*args, **kwargs)
params = args[0]
changed = []
old_config = self._param_dict.get_config()
master_commands = []
slave_commands = []
for key, val in params.iteritems():
if WorkhorseEngineeringParameter.has(key):
continue
if val != old_config.get(key):
changed.append(key)
if '_5th' in key:
slave_commands.append(self._build_set_command(
WorkhorseInstrumentCmds.SET, key.replace('_5th', ''), val))
else:
master_commands.append(self._build_set_command(WorkhorseInstrumentCmds.SET, key, val))
self._execute_set_params(master_commands, connection=SlaveProtocol.FOURBEAM)
self._execute_set_params(slave_commands, connection=SlaveProtocol.FIFTHBEAM)
# Handle engineering parameters
force = False
if WorkhorseParameter.CLOCK_SYNCH_INTERVAL in params:
if (params[WorkhorseParameter.CLOCK_SYNCH_INTERVAL] != self._param_dict.get(
WorkhorseParameter.CLOCK_SYNCH_INTERVAL)):
self._param_dict.set_value(WorkhorseParameter.CLOCK_SYNCH_INTERVAL,
params[WorkhorseParameter.CLOCK_SYNCH_INTERVAL])
self.start_scheduled_job(WorkhorseParameter.CLOCK_SYNCH_INTERVAL, WorkhorseScheduledJob.CLOCK_SYNC,
WorkhorseProtocolEvent.SCHEDULED_CLOCK_SYNC)
force = True
if WorkhorseParameter.GET_STATUS_INTERVAL in params:
if (params[WorkhorseParameter.GET_STATUS_INTERVAL] != self._param_dict.get(
WorkhorseParameter.GET_STATUS_INTERVAL)):
self._param_dict.set_value(WorkhorseParameter.GET_STATUS_INTERVAL,
params[WorkhorseParameter.GET_STATUS_INTERVAL])
self.start_scheduled_job(WorkhorseParameter.GET_STATUS_INTERVAL,
WorkhorseScheduledJob.GET_CONFIGURATION,
WorkhorseProtocolEvent.SCHEDULED_GET_STATUS)
force = True
self._update_params(params=changed, force=force)
return None
