def _create_set_output(self, parameters):
"""
load buffer with sync byte (A5), ID byte (01), and size word (# of words in little-endian form)
'user' configuration is 512 bytes = 256 words long = size 0x100
"""
output = ['\xa5\x00\x00\x01']
CHECK_SUM_SEED = 0xb58c
for param in self.order_of_user_config:
log.trace('_create_set_output: adding %s to list', param)
if param == Parameter.COMMENTS:
output.append(parameters.format(param).ljust(180, "\x00"))
elif param == Parameter.DEPLOYMENT_NAME:
output.append(parameters.format(param).ljust(6, "\x00"))
elif param == Parameter.QUAL_CONSTANTS:
output.append('\x00'.ljust(16, "\x00"))
elif param == Parameter.VELOCITY_ADJ_TABLE:
output.append(base64.b64decode(parameters.format(param)))
elif param in [
Parameter.A1_1_SPARE, Parameter.B0_1_SPARE,
Parameter.B1_1_SPARE, Parameter.USER_1_SPARE,
Parameter.A1_2_SPARE, Parameter.B0_2_SPARE,
Parameter.USER_2_SPARE, Parameter.USER_3_SPARE
]:
output.append(
self.spare_param_values.get(param).ljust(2, "\x00"))
elif param in [
Parameter.WAVE_MEASUREMENT_MODE,
Parameter.WAVE_TRANSMIT_PULSE,
Parameter.WAVE_BLANKING_DISTANCE, Parameter.WAVE_CELL_SIZE,
Parameter.NUMBER_DIAG_SAMPLES,
Parameter.DYN_PERCENTAGE_POSITION
]:
output.append('\x00'.ljust(2, "\x00"))
elif param == Parameter.USER_4_SPARE:
output.append(
self.spare_param_values.get(param).ljust(30, "\x00"))
else:
output.append(parameters.format(param))
log.trace('_create_set_output: ADDED %s output size = %s', param,
len(output))
log.debug("Created set output: %r with length: %s", output,
len(output))
checksum = CHECK_SUM_SEED
output = "".join(output)
for word_index in range(0, len(output), 2):
word_value = NortekProtocolParameterDict.convert_word_to_int(
output[word_index:word_index + 2])
checksum = (checksum + word_value) % 0x10000
log.debug('_create_set_output: user checksum = %r', checksum)
output += (NortekProtocolParameterDict.word_to_string(checksum))
return output
def _build_particle(self, match):
timestamp = NortekProtocolParameterDict.convert_time(match.group(1))
py_timestamp = time.strptime(timestamp, "%d/%m/%Y %H:%M:%S")
self.set_internal_timestamp(unix_time=time.mktime(py_timestamp))
battery = NortekProtocolParameterDict.convert_word_to_int(match.group(2))
sound_speed = NortekProtocolParameterDict.convert_word_to_int(match.group(3))
heading = NortekProtocolParameterDict.convert_word_to_int(match.group(4))
pitch = NortekProtocolParameterDict.convert_word_to_int(match.group(5))
roll = NortekProtocolParameterDict.convert_word_to_int(match.group(6))
temperature = NortekProtocolParameterDict.convert_word_to_int(match.group(7))
error = ord(match.group(8))
status = ord(match.group(9))
analog_input = NortekProtocolParameterDict.convert_word_to_int(match.group(10))
if None == timestamp:
raise SampleException("No timestamp parsed")
if None == battery:
raise SampleException("No battery value parsed")
if None == sound_speed:
raise SampleException("No sound_speed value parsed")
if None == heading:
raise SampleException("No heading value parsed")
if None == pitch:
raise SampleException("No pitch value parsed")
if None == roll:
raise SampleException("No roll value parsed")
if None == temperature:
raise SampleException("No temperature value parsed")
if None == error:
raise SampleException("No error value parsed")
if None == status:
raise SampleException("No status value parsed")
if None == analog_input:
raise SampleException("No analog_input value parsed")
result = [{DataParticleKey.VALUE_ID: VectorSystemDataParticleKey.TIMESTAMP,
DataParticleKey.VALUE: timestamp},
{DataParticleKey.VALUE_ID: VectorSystemDataParticleKey.BATTERY,
DataParticleKey.VALUE: battery},
{DataParticleKey.VALUE_ID: VectorSystemDataParticleKey.SOUND_SPEED,
DataParticleKey.VALUE: sound_speed},
{DataParticleKey.VALUE_ID: VectorSystemDataParticleKey.HEADING,
DataParticleKey.VALUE: heading},
{DataParticleKey.VALUE_ID: VectorSystemDataParticleKey.PITCH,
DataParticleKey.VALUE: pitch},
{DataParticleKey.VALUE_ID: VectorSystemDataParticleKey.ROLL,
DataParticleKey.VALUE: roll},
{DataParticleKey.VALUE_ID: VectorSystemDataParticleKey.TEMPERATURE,
DataParticleKey.VALUE: temperature},
{DataParticleKey.VALUE_ID: VectorSystemDataParticleKey.ERROR,
DataParticleKey.VALUE: error},
{DataParticleKey.VALUE_ID: VectorSystemDataParticleKey.STATUS,
DataParticleKey.VALUE: status},
{DataParticleKey.VALUE_ID: VectorSystemDataParticleKey.ANALOG_INPUT,
DataParticleKey.VALUE: analog_input}]
return result
def _build_particle(self, match):
timestamp = NortekProtocolParameterDict.convert_time(match.group(1))
py_timestamp = time.strptime(timestamp, "%d/%m/%Y %H:%M:%S")
self.set_internal_timestamp(unix_time=time.mktime(py_timestamp))
number_of_records = NortekProtocolParameterDict.convert_word_to_int(match.group(2))
noise1 = ord(match.group(3))
noise2 = ord(match.group(4))
noise3 = ord(match.group(5))
correlation1 = ord(match.group(6))
correlation2 = ord(match.group(7))
correlation3 = ord(match.group(8))
if None == timestamp:
raise SampleException("No timestamp parsed")
if None == number_of_records:
raise SampleException("No number_of_records value parsed")
if None == noise1:
raise SampleException("No noise1 value parsed")
if None == noise2:
raise SampleException("No noise2 value parsed")
if None == noise3:
raise SampleException("No noise3 value parsed")
if None == correlation1:
raise SampleException("No correlation1 value parsed")
if None == correlation2:
raise SampleException("No correlation2 value parsed")
if None == correlation3:
raise SampleException("No correlation3 value parsed")
result = [{DataParticleKey.VALUE_ID: VectorVelocityHeaderDataParticleKey.TIMESTAMP,
DataParticleKey.VALUE: timestamp},
{DataParticleKey.VALUE_ID: VectorVelocityHeaderDataParticleKey.NUMBER_OF_RECORDS,
DataParticleKey.VALUE: number_of_records},
{DataParticleKey.VALUE_ID: VectorVelocityHeaderDataParticleKey.NOISE1,
DataParticleKey.VALUE: noise1},
{DataParticleKey.VALUE_ID: VectorVelocityHeaderDataParticleKey.NOISE2,
DataParticleKey.VALUE: noise2},
{DataParticleKey.VALUE_ID: VectorVelocityHeaderDataParticleKey.NOISE3,
DataParticleKey.VALUE: noise3},
{DataParticleKey.VALUE_ID: VectorVelocityHeaderDataParticleKey.CORRELATION1,
DataParticleKey.VALUE: correlation1},
{DataParticleKey.VALUE_ID: VectorVelocityHeaderDataParticleKey.CORRELATION2,
DataParticleKey.VALUE: correlation2},
{DataParticleKey.VALUE_ID: VectorVelocityHeaderDataParticleKey.CORRELATION3,
DataParticleKey.VALUE: correlation3}]
return result
def _build_param_dict(self):
NortekInstrumentProtocol._build_param_dict(self)
self._param_dict.add_parameter(
NortekParameterDictVal(Parameter.NUMBER_SAMPLES_PER_BURST,
r'^.{%s}(.{2}).*' % str(452),
lambda match : NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL))
self._param_dict.add_parameter(
NortekParameterDictVal(Parameter.USER_3_SPARE,
r'^.{%s}(.{2}).*' % str(460),
lambda match : match.group(1),
lambda string : string,
visibility=ParameterDictVisibility.READ_ONLY,
regex_flags=re.DOTALL))
self._param_dict.load_strings(RESOURCE_FILE)
def _create_set_output(self, parameters):
"""
load buffer with sync byte (A5), ID byte (01), and size word (# of words in little-endian form)
'user' configuration is 512 bytes = 256 words long = size 0x100
"""
output = ['\xa5\x00\x00\x01']
CHECK_SUM_SEED = 0xb58c
for param in self.order_of_user_config:
log.trace('_create_set_output: adding %s to list', param)
if param == Parameter.COMMENTS:
output.append(parameters.format(param).ljust(180, "\x00"))
elif param == Parameter.DEPLOYMENT_NAME:
output.append(parameters.format(param).ljust(6, "\x00"))
elif param == Parameter.QUAL_CONSTANTS:
output.append('\x00'.ljust(16, "\x00"))
elif param == Parameter.VELOCITY_ADJ_TABLE:
output.append(base64.b64decode(parameters.format(param)))
elif param in [Parameter.A1_1_SPARE, Parameter.B0_1_SPARE, Parameter.B1_1_SPARE, Parameter.USER_1_SPARE,
Parameter.A1_2_SPARE, Parameter.B0_2_SPARE, Parameter.USER_2_SPARE, Parameter.USER_3_SPARE]:
output.append(self.spare_param_values.get(param).ljust(2, "\x00"))
elif param in [Parameter.WAVE_MEASUREMENT_MODE, Parameter.WAVE_TRANSMIT_PULSE, Parameter.WAVE_BLANKING_DISTANCE,
Parameter.WAVE_CELL_SIZE, Parameter.NUMBER_DIAG_SAMPLES, Parameter.DYN_PERCENTAGE_POSITION]:
output.append('\x00'.ljust(2, "\x00"))
elif param == Parameter.USER_4_SPARE:
output.append(self.spare_param_values.get(param).ljust(30, "\x00"))
else:
output.append(parameters.format(param))
log.trace('_create_set_output: ADDED %s output size = %s', param, len(output))
log.debug("Created set output: %r with length: %s", output, len(output))
checksum = CHECK_SUM_SEED
output = "".join(output)
for word_index in range(0, len(output), 2):
word_value = NortekProtocolParameterDict.convert_word_to_int(output[word_index:word_index+2])
checksum = (checksum + word_value) % 0x10000
log.debug('_create_set_output: user checksum = %r', checksum)
output += (NortekProtocolParameterDict.word_to_string(checksum))
return output
def _build_param_dict(self):
"""
Overwrite base classes method.
Creates base class's param dictionary, then sets parameter values for those specific to this instrument.
"""
NortekInstrumentProtocol._build_param_dict(self)
self._param_dict.add(
Parameter.TRANSMIT_PULSE_LENGTH,
r'^.{%s}(.{2}).*' % str(4),
lambda match: NortekProtocolParameterDict.convert_word_to_int(
match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.READ_WRITE,
display_name="Transmit Pulse Length",
description="Pulse duration of the transmitted signal.",
range=(1, 65535),
default_value=2,
units=Units.COUNTS,
startup_param=True,
direct_access=True)
self._param_dict.add(
Parameter.BLANKING_DISTANCE,
r'^.{%s}(.{2}).*' % str(6),
lambda match: NortekProtocolParameterDict.convert_word_to_int(
match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Blanking Distance",
description="Minimum sensing range of the sensor.",
range=(1, 65535),
default_value=16,
units=Units.COUNTS,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.RECEIVE_LENGTH,
r'^.{%s}(.{2}).*' % str(8),
lambda match: NortekProtocolParameterDict.
convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.READ_WRITE,
display_name="Receive Length",
description="Length of the received pulse.",
range=(1, 65535),
default_value=7,
units=Units.COUNTS,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.TIME_BETWEEN_PINGS,
r'^.{%s}(.{2}).*' % str(10),
lambda match: NortekProtocolParameterDict.
convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Time Between Pings",
description="Length of time between each ping.",
default_value=44,
units=Units.COUNTS,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.TIME_BETWEEN_BURST_SEQUENCES,
r'^.{%s}(.{2}).*' % str(12),
lambda match: NortekProtocolParameterDict.
convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.READ_WRITE,
display_name="Time Between Burst Sequences",
description="Length of time between each burst.",
range=(1, 65535),
default_value=0,
units=Units.COUNTS,
startup_param=True,
direct_access=True)
self._param_dict.add(
Parameter.NUMBER_PINGS,
r'^.{%s}(.{2}).*' % str(14),
lambda match: NortekProtocolParameterDict.convert_word_to_int(
match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Number Pings",
description="Number of pings in each burst sequence.",
range=(1, 65535),
default_value=0,
units=Units.HERTZ,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.AVG_INTERVAL,
r'^.{%s}(.{2}).*' % str(16),
lambda match: NortekProtocolParameterDict.
convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Average Interval",
description="Interval for continuous sampling.",
default_value=64,
range=(1, 65535),
units=Units.SECOND,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.MEASUREMENT_INTERVAL,
r'^.{%s}(.{2}).*' % str(38),
lambda match: NortekProtocolParameterDict.
convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Measurement Interval",
description="Interval for single measurements.",
units=Units.SECOND,
default_value=600,
range=(0, 65535),
startup_param=True,
direct_access=True)
self._param_dict.add(
Parameter.DIAGNOSTIC_INTERVAL,
r'^.{%s}(.{4}).*' % str(54),
lambda match: NortekProtocolParameterDict.
convert_double_word_to_int(match.group(1)),
NortekProtocolParameterDict.double_word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Diagnostic Interval",
description='Number of seconds between diagnostics measurements.',
default_value=10800,
units=Units.SECOND,
startup_param=True,
direct_access=True)
self._param_dict.add(
Parameter.ADJUSTMENT_SOUND_SPEED,
r'^.{%s}(.{2}).*' % str(60),
lambda match: NortekProtocolParameterDict.convert_word_to_int(
match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Adjustment Sound Speed",
description='User input sound speed adjustment factor.',
default_value=16657,
units=Units.METER + '/' + Units.SECOND,
startup_param=True,
direct_access=True)
self._param_dict.add(
Parameter.NUMBER_SAMPLES_DIAGNOSTIC,
r'^.{%s}(.{2}).*' % str(62),
lambda match: NortekProtocolParameterDict.convert_word_to_int(
match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Diagnostic Samples",
description='Number of samples in diagnostics mode.',
default_value=1,
startup_param=True,
direct_access=True)
self._param_dict.add(
Parameter.SW_VERSION,
r'^.{%s}(.{2}).*' % str(72),
lambda match: NortekProtocolParameterDict.convert_word_to_int(
match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.STRING,
visibility=ParameterDictVisibility.READ_ONLY,
direct_access=True,
display_name="Software Version",
description="Current software version installed on instrument.")
self._param_dict.add(Parameter.SAMPLE_RATE,
r'^.{%s}(.{2}).*' % str(454),
lambda match: NortekProtocolParameterDict.
convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.READ_WRITE,
display_name="Sample Rate",
description="Number of samples per burst.",
range=(1, 65535),
default_value=16,
startup_param=True)
self._param_dict.add(
Parameter.ANALOG_OUTPUT_SCALE,
r'^.{%s}(.{2}).*' % str(456),
lambda match: NortekProtocolParameterDict.convert_word_to_int(
match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Analog Output Scale Factor",
description="Scale factor used in calculating analog output.",
default_value=6711,
startup_param=True,
direct_access=True)
def _build_param_dict(self):
"""
Overwrite base classes method.
Creates base class's param dictionary, then sets parameter values for those specific to this instrument.
"""
NortekInstrumentProtocol._build_param_dict(self)
self._param_dict.add(Parameter.TRANSMIT_PULSE_LENGTH,
r'^.{%s}(.{2}).*' % str(4),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.READ_WRITE,
display_name="Transmit Pulse Length",
description="Pulse duration of the transmitted signal.",
default_value=2,
units=Units.COUNTS,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.BLANKING_DISTANCE,
r'^.{%s}(.{2}).*' % str(6),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Blanking Distance",
description="Minimum sensing range of the sensor.",
default_value=16,
units=Units.COUNTS,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.RECEIVE_LENGTH,
r'^.{%s}(.{2}).*' % str(8),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.READ_WRITE,
display_name="Receive Length",
description="Length of the received pulse.",
default_value=7,
units=Units.COUNTS,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.TIME_BETWEEN_PINGS,
r'^.{%s}(.{2}).*' % str(10),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Time Between Pings",
description="Length of time between each ping.",
default_value=44,
units=Units.COUNTS,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.TIME_BETWEEN_BURST_SEQUENCES,
r'^.{%s}(.{2}).*' % str(12),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.READ_WRITE,
display_name="Time Between Burst Sequences",
description="Length of time between each burst.",
default_value=0,
units=Units.COUNTS,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.NUMBER_PINGS,
r'^.{%s}(.{2}).*' % str(14),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Number Pings",
description="Number of pings in each burst sequence.",
default_value=0,
units=Units.HERTZ,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.AVG_INTERVAL,
r'^.{%s}(.{2}).*' % str(16),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Average Interval",
description="Interval for continuous sampling.",
default_value=64,
units=Units.SECOND,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.MEASUREMENT_INTERVAL,
r'^.{%s}(.{2}).*' % str(38),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Measurement Interval",
description="Interval for single measurements.",
units=Units.SECOND,
default_value=600,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.DIAGNOSTIC_INTERVAL,
r'^.{%s}(.{4}).*' % str(54),
lambda match: NortekProtocolParameterDict.convert_double_word_to_int(match.group(1)),
NortekProtocolParameterDict.double_word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Diagnostic Interval",
description='Number of seconds between diagnostics measurements.',
default_value=10800,
units=Units.SECOND,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.ADJUSTMENT_SOUND_SPEED,
r'^.{%s}(.{2}).*' % str(60),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Adjustment Sound Speed",
description='User input sound speed adjustment factor.',
default_value=16657,
units=Units.METER + '/' + Units.SECOND,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.NUMBER_SAMPLES_DIAGNOSTIC,
r'^.{%s}(.{2}).*' % str(62),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Diagnostic Samples",
description='Number of samples in diagnostics mode.',
default_value=1,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.SW_VERSION,
r'^.{%s}(.{2}).*' % str(72),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.STRING,
visibility=ParameterDictVisibility.READ_ONLY,
direct_access=True,
display_name="Software Version",
description="Current software version installed on instrument.")
self._param_dict.add(Parameter.SAMPLE_RATE,
r'^.{%s}(.{2}).*' % str(454),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.READ_WRITE,
display_name="Sample Rate",
description="Number of samples per burst.",
default_value=16,
startup_param=True)
self._param_dict.add(Parameter.ANALOG_OUTPUT_SCALE,
r'^.{%s}(.{2}).*' % str(456),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Analog Output Scale Factor",
description="Scale factor used in calculating analog output.",
default_value=6711,
startup_param=True,
direct_access=True)
def _build_parsed_values(self):
"""
Take something in the velocity data sample format and parse it into
values with appropriate tags.
@throws SampleException If there is a problem with sample creation
"""
match = VELOCITY_DATA_REGEX.match(self.raw_data)
if not match:
raise SampleException("VectorVelocityDataParticle: No regex match of parsed sample data: [%s]", self.raw_data)
analog_input2 = ord(match.group(1))
count = ord(match.group(2))
pressure = ord(match.group(3)) * 0x10000
analog_input2 += ord(match.group(4)) * 0x100
pressure += NortekProtocolParameterDict.convert_word_to_int(match.group(5))
analog_input1 = NortekProtocolParameterDict.convert_word_to_int(match.group(6))
velocity_beam1 = NortekProtocolParameterDict.convert_word_to_int(match.group(7))
velocity_beam2 = NortekProtocolParameterDict.convert_word_to_int(match.group(8))
velocity_beam3 = NortekProtocolParameterDict.convert_word_to_int(match.group(9))
amplitude_beam1 = ord(match.group(10))
amplitude_beam2 = ord(match.group(11))
amplitude_beam3 = ord(match.group(12))
correlation_beam1 = ord(match.group(13))
correlation_beam2 = ord(match.group(14))
correlation_beam3 = ord(match.group(15))
if None == analog_input2:
raise SampleException("No analog_input2 value parsed")
if None == count:
raise SampleException("No count value parsed")
if None == pressure:
raise SampleException("No pressure value parsed")
if None == analog_input1:
raise SampleException("No analog_input1 value parsed")
if None == velocity_beam1:
raise SampleException("No velocity_beam1 value parsed")
if None == velocity_beam2:
raise SampleException("No velocity_beam2 value parsed")
if None == velocity_beam3:
raise SampleException("No velocity_beam3 value parsed")
if None == amplitude_beam1:
raise SampleException("No amplitude_beam1 value parsed")
if None == amplitude_beam2:
raise SampleException("No amplitude_beam2 value parsed")
if None == amplitude_beam3:
raise SampleException("No amplitude_beam3 value parsed")
if None == correlation_beam1:
raise SampleException("No correlation_beam1 value parsed")
if None == correlation_beam2:
raise SampleException("No correlation_beam2 value parsed")
if None == correlation_beam3:
raise SampleException("No correlation_beam3 value parsed")
result = [{DataParticleKey.VALUE_ID: VectorVelocityDataParticleKey.ANALOG_INPUT2,
DataParticleKey.VALUE: analog_input2},
{DataParticleKey.VALUE_ID: VectorVelocityDataParticleKey.COUNT,
DataParticleKey.VALUE: count},
{DataParticleKey.VALUE_ID: VectorVelocityDataParticleKey.PRESSURE,
DataParticleKey.VALUE: pressure},
{DataParticleKey.VALUE_ID: VectorVelocityDataParticleKey.ANALOG_INPUT1,
DataParticleKey.VALUE: analog_input1},
{DataParticleKey.VALUE_ID: VectorVelocityDataParticleKey.VELOCITY_BEAM1,
DataParticleKey.VALUE: velocity_beam1},
{DataParticleKey.VALUE_ID: VectorVelocityDataParticleKey.VELOCITY_BEAM2,
DataParticleKey.VALUE: velocity_beam2},
{DataParticleKey.VALUE_ID: VectorVelocityDataParticleKey.VELOCITY_BEAM3,
DataParticleKey.VALUE: velocity_beam3},
{DataParticleKey.VALUE_ID: VectorVelocityDataParticleKey.AMPLITUDE_BEAM1,
DataParticleKey.VALUE: amplitude_beam1},
{DataParticleKey.VALUE_ID: VectorVelocityDataParticleKey.AMPLITUDE_BEAM2,
DataParticleKey.VALUE: amplitude_beam2},
{DataParticleKey.VALUE_ID: VectorVelocityDataParticleKey.AMPLITUDE_BEAM3,
DataParticleKey.VALUE: amplitude_beam3},
{DataParticleKey.VALUE_ID: VectorVelocityDataParticleKey.CORRELATION_BEAM1,
DataParticleKey.VALUE: correlation_beam1},
{DataParticleKey.VALUE_ID: VectorVelocityDataParticleKey.CORRELATION_BEAM2,
DataParticleKey.VALUE: correlation_beam2},
{DataParticleKey.VALUE_ID: VectorVelocityDataParticleKey.CORRELATION_BEAM3,
DataParticleKey.VALUE: correlation_beam3}]
log.debug('VectorVelocityDataParticle: particle=%s' %result)
return result
def _build_param_dict(self):
"""
Overwrite base classes method.
Creates base class's param dictionary, then sets parameter values for those specific to this instrument.
"""
NortekInstrumentProtocol._build_param_dict(self)
self._param_dict.add(Parameter.TRANSMIT_PULSE_LENGTH,
r'^.{%s}(.{2}).*' % str(4),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Transmit Pulse Length",
default_value=125,
units=ParameterUnits.CENTIMETERS,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.BLANKING_DISTANCE,
r'^.{%s}(.{2}).*' % str(6),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.READ_WRITE,
display_name="Blanking Distance",
default_value=49,
units=ParameterUnits.CENTIMETERS,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.RECEIVE_LENGTH,
r'^.{%s}(.{2}).*' % str(8),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Receive Length",
default_value=32,
units=ParameterUnits.CENTIMETERS,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.TIME_BETWEEN_PINGS,
r'^.{%s}(.{2}).*' % str(10),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Time Between Pings",
units=ParameterUnits.CENTIMETERS,
default_value=437,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.TIME_BETWEEN_BURST_SEQUENCES,
r'^.{%s}(.{2}).*' % str(12),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Time Between Burst Sequences",
default_value=512,
units=None,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.NUMBER_PINGS,
r'^.{%s}(.{2}).*' % str(14),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Number Pings",
default_value=1,
units=ParameterUnits.HERTZ,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.AVG_INTERVAL,
r'^.{%s}(.{2}).*' % str(16),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.READ_WRITE,
display_name="Average Interval",
default_value=60,
units=ParameterUnits.SECONDS,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.USER_NUMBER_BEAMS,
r'^.{%s}(.{2}).*' % str(18),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.READ_ONLY,
display_name="User Number Beams",
direct_access=True,
value=3)
self._param_dict.add(Parameter.TIMING_CONTROL_REGISTER,
r'^.{%s}(.{2}).*' % str(20),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.READ_WRITE,
display_name="Timing Control Register",
direct_access=True,
value=130)
self._param_dict.add(Parameter.POWER_CONTROL_REGISTER,
r'^.{%s}(.{2}).*' % str(22),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Power Control Register",
default_value=0,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.A1_1_SPARE,
r'^.{%s}(.{2}).*' % str(24),
lambda match: match.group(1).encode('hex'),
lambda string: string.decode('hex'),
regex_flags=re.DOTALL,
type=ParameterDictType.STRING,
visibility=ParameterDictVisibility.READ_ONLY,
display_name="A1 1 Spare",
description='Not used.')
self._param_dict.add(Parameter.B0_1_SPARE,
r'^.{%s}(.{2}).*' % str(26),
lambda match: match.group(1).encode('hex'),
lambda string: string.decode('hex'),
regex_flags=re.DOTALL,
type=ParameterDictType.STRING,
visibility=ParameterDictVisibility.READ_ONLY,
display_name="B0 1 Spare",
description='Not used.')
self._param_dict.add(Parameter.B1_1_SPARE,
r'^.{%s}(.{2}).*' % str(28),
lambda match: match.group(1).encode('hex'),
lambda string: string.decode('hex'),
regex_flags=re.DOTALL,
type=ParameterDictType.STRING,
visibility=ParameterDictVisibility.READ_ONLY,
display_name="B1 1 Spare",
description='Not used.')
self._param_dict.add(Parameter.COMPASS_UPDATE_RATE,
r'^.{%s}(.{2}).*' % str(30),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.READ_WRITE,
display_name="Compass Update Rate",
default_value=1,
units=ParameterUnits.HERTZ,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.COORDINATE_SYSTEM,
r'^.{%s}(.{2}).*' % str(32),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.READ_WRITE,
display_name="Coordinate System",
description='Coordinate System (0=ENU, 1=XYZ, 2=BEAM)',
default_value=2,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.NUMBER_BINS,
r'^.{%s}(.{2}).*' % str(34),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Number Bins",
default_value=1,
units=ParameterUnits.METERS,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.BIN_LENGTH,
r'^.{%s}(.{2}).*' % str(36),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Bin Length",
default_value=7,
units=ParameterUnits.SECONDS,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.MEASUREMENT_INTERVAL,
r'^.{%s}(.{2}).*' % str(38),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.READ_WRITE,
display_name="Measurement Interval",
default_value=60,
units=ParameterUnits.SECONDS,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.DEPLOYMENT_NAME,
r'^.{%s}(.{6}).*' % str(40),
lambda match: NortekProtocolParameterDict.convert_bytes_to_string(match.group(1)),
lambda string: string,
regex_flags=re.DOTALL,
type=ParameterDictType.STRING,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Deployment Name",
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.WRAP_MODE,
r'^.{%s}(.{2}).*' % str(46),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Wrap Mode",
description='Recorder wrap mode (0=NO WRAP, 1=WRAP WHEN FULL)',
default_value=0,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.CLOCK_DEPLOY,
r'^.{%s}(.{6}).*' % str(48),
lambda match: NortekProtocolParameterDict.convert_words_to_datetime(match.group(1)),
NortekProtocolParameterDict.convert_datetime_to_words,
regex_flags=re.DOTALL,
type=ParameterDictType.LIST,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Clock Deploy",
description='Deployment start time.',
default_value=[0, 0, 0, 0, 0, 0],
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.DIAGNOSTIC_INTERVAL,
r'^.{%s}(.{4}).*' % str(54),
lambda match: NortekProtocolParameterDict.convert_double_word_to_int(match.group(1)),
NortekProtocolParameterDict.double_word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Diagnostic Interval",
description='Number of seconds between diagnostics measurements.',
default_value=11250,
startup_param=True,
units=ParameterUnits.SECONDS,
direct_access=True)
self._param_dict.add(Parameter.MODE,
r'^.{%s}(.{2}).*' % str(58),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Mode",
default_value=48,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.ADJUSTMENT_SOUND_SPEED,
r'^.{%s}(.{2}).*' % str(60),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Adjustment Sound Speed",
description='User input sound speed adjustment factor.',
units=ParameterUnits.METERS_PER_SECOND,
default_value=1525,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.NUMBER_SAMPLES_DIAGNOSTIC,
r'^.{%s}(.{2}).*' % str(62),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Number Samples Diagnostic",
description='Samples in diagnostics mode.',
default_value=20,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.NUMBER_BEAMS_CELL_DIAGNOSTIC,
r'^.{%s}(.{2}).*' % str(64),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Number Beams Cell Diagnostic",
description='Beams/cell number to measure in diagnostics mode',
default_value=1,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.NUMBER_PINGS_DIAGNOSTIC,
r'^.{%s}(.{2}).*' % str(66),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Number Pings Diagnostic",
description='Pings in diagnostics/wave mode.',
default_value=1,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.MODE_TEST,
r'^.{%s}(.{2}).*' % str(68),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.STRING,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Mode Test",
default_value=4,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.ANALOG_INPUT_ADDR,
r'^.{%s}(.{2}).*' % str(70),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.STRING,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Analog Input Address",
default_value=0,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.SW_VERSION,
r'^.{%s}(.{2}).*' % str(72),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.STRING,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Software Version",
default_value=13902,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.USER_1_SPARE,
r'^.{%s}(.{2}).*' % str(74),
lambda match: match.group(1).encode('hex'),
lambda string: string.decode('hex'),
regex_flags=re.DOTALL,
type=ParameterDictType.STRING,
visibility=ParameterDictVisibility.READ_ONLY,
display_name="User 1 Spare",
description='Not used.')
self._param_dict.add(Parameter.VELOCITY_ADJ_TABLE,
r'^.{%s}(.{180}).*' % str(76),
lambda match: base64.b64encode(match.group(1)),
lambda string: string,
regex_flags=re.DOTALL,
type=ParameterDictType.STRING,
visibility=ParameterDictVisibility.READ_WRITE,
display_name="Velocity Adj Table",
units=ParameterUnits.PARTS_PER_TRILLION,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.COMMENTS,
r'^.{%s}(.{180}).*' % str(256),
lambda match: NortekProtocolParameterDict.convert_bytes_to_string(match.group(1)),
lambda string: string,
regex_flags=re.DOTALL,
type=ParameterDictType.STRING,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Comments",
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.WAVE_MEASUREMENT_MODE,
r'^.{%s}(.{2}).*' % str(436),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.STRING,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Wave Measurement Mode",
default_value=0,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.DYN_PERCENTAGE_POSITION,
r'^.{%s}(.{2}).*' % str(438),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Dyn Percentage Position",
description='Percentage for wave cell positioning.',
default_value=0,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.WAVE_TRANSMIT_PULSE,
r'^.{%s}(.{2}).*' % str(440),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Wave Transmit Pulse",
default_value=0,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.WAVE_BLANKING_DISTANCE,
r'^.{%s}(.{2}).*' % str(442),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Fixed Wave Blanking Distance",
default_value=0,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.WAVE_CELL_SIZE,
r'^.{%s}(.{2}).*' % str(444),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Wave Measurement Cell Size",
default_value=0,
units=ParameterUnits.METERS,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.NUMBER_DIAG_SAMPLES,
r'^.{%s}(.{2}).*' % str(446),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Number Diag Samples",
description='Number of diagnostics/wave samples.',
default_value=0,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.A1_2_SPARE,
r'^.{%s}(.{2}).*' % str(448),
lambda match: match.group(1).encode('hex'),
lambda string: string.decode('hex'),
regex_flags=re.DOTALL,
type=ParameterDictType.STRING,
visibility=ParameterDictVisibility.READ_ONLY,
display_name="A1 2 Spare",
description='Not used.')
self._param_dict.add(Parameter.B0_2_SPARE,
r'^.{%s}(.{2}).*' % str(450),
lambda match: match.group(1).encode('hex'),
lambda string: string.decode('hex'),
regex_flags=re.DOTALL,
type=ParameterDictType.STRING,
visibility=ParameterDictVisibility.READ_ONLY,
display_name="B0 2 Spare",
description='Not used.')
self._param_dict.add(Parameter.NUMBER_SAMPLES_PER_BURST,
r'^.{%s}(.{2}).*' % str(452),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
expiration=None,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Number of Samples per Burst",
default_value=0,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.USER_2_SPARE,
r'^.{%s}(.{2}).*' % str(454),
lambda match: match.group(1).encode('hex'),
lambda string: string.decode('hex'),
regex_flags=re.DOTALL,
type=ParameterDictType.STRING,
visibility=ParameterDictVisibility.READ_ONLY,
display_name="User 2 Spare",
description='Not used.')
self._param_dict.add(Parameter.ANALOG_OUTPUT_SCALE,
r'^.{%s}(.{2}).*' % str(456),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Analog Output Scale Factor",
default_value=0,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.CORRELATION_THRESHOLD,
r'^.{%s}(.{2}).*' % str(458),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Correlation Threshold",
description='Correlation threshold for resolving ambiguities.',
default_value=0,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.USER_3_SPARE,
r'^.{%s}(.{2}).*' % str(460),
lambda match: match.group(1).encode('hex'),
lambda string: string.decode('hex'),
regex_flags=re.DOTALL,
type=ParameterDictType.STRING,
visibility=ParameterDictVisibility.READ_ONLY,
display_name="User 3 Spare",
description='Not used.')
self._param_dict.add(Parameter.TRANSMIT_PULSE_LENGTH_SECOND_LAG,
r'^.{%s}(.{2}).*' % str(462),
lambda match: NortekProtocolParameterDict.convert_word_to_int(match.group(1)),
NortekProtocolParameterDict.word_to_string,
regex_flags=re.DOTALL,
type=ParameterDictType.INT,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Transmit Pulse Length Second Lag",
default_value=2,
startup_param=True,
direct_access=True)
self._param_dict.add(Parameter.USER_4_SPARE,
r'^.{%s}(.{30}).*' % str(464),
lambda match: match.group(1).encode('hex'),
lambda string: string.decode('hex'),
regex_flags=re.DOTALL,
type=ParameterDictType.STRING,
visibility=ParameterDictVisibility.READ_ONLY,
display_name="User 4 Spare",
description='Not used.')
self._param_dict.add(Parameter.QUAL_CONSTANTS,
r'^.{%s}(.{16}).*' % str(494),
lambda match: base64.b64encode(match.group(1)),
lambda string: string,
regex_flags=re.DOTALL,
type=ParameterDictType.STRING,
visibility=ParameterDictVisibility.IMMUTABLE,
display_name="Qual Constants",
description='Stage match filter constants.',
startup_param=True,
direct_access=True)
def _build_particle(self, match):
"""
Build a particle. Used for parsing Velocity
"""
timestamp = NortekProtocolParameterDict.convert_time(match.group(1))
error = NortekProtocolParameterDict.convert_word_to_int(match.group(2))
analog1 = NortekProtocolParameterDict.convert_word_to_int(match.group(3))
battery_voltage = NortekProtocolParameterDict.convert_word_to_int(match.group(4))
sound_speed = NortekProtocolParameterDict.convert_word_to_int(match.group(5))
heading = NortekProtocolParameterDict.convert_word_to_int(match.group(6))
pitch = NortekProtocolParameterDict.convert_word_to_int(match.group(7))
roll = NortekProtocolParameterDict.convert_word_to_int(match.group(8))
pressure = ord(match.group(9)) * 0x10000
status = ord(match.group(10))
pressure += NortekProtocolParameterDict.convert_word_to_int(match.group(11))
temperature = NortekProtocolParameterDict.convert_word_to_int(match.group(12))
velocity_beam1 = NortekProtocolParameterDict.convert_word_to_int(match.group(13))
velocity_beam2 = NortekProtocolParameterDict.convert_word_to_int(match.group(14))
velocity_beam3 = NortekProtocolParameterDict.convert_word_to_int(match.group(15))
amplitude_beam1 = ord(match.group(16))
amplitude_beam2 = ord(match.group(17))
amplitude_beam3 = ord(match.group(18))
result = [{DataParticleKey.VALUE_ID: AquadoppDwVelocityDataParticleKey.TIMESTAMP, DataParticleKey.VALUE: timestamp},
{DataParticleKey.VALUE_ID: AquadoppDwVelocityDataParticleKey.ERROR, DataParticleKey.VALUE: error},
{DataParticleKey.VALUE_ID: AquadoppDwVelocityDataParticleKey.ANALOG1, DataParticleKey.VALUE: analog1},
{DataParticleKey.VALUE_ID: AquadoppDwVelocityDataParticleKey.BATTERY_VOLTAGE, DataParticleKey.VALUE: battery_voltage},
{DataParticleKey.VALUE_ID: AquadoppDwVelocityDataParticleKey.SOUND_SPEED_ANALOG2, DataParticleKey.VALUE: sound_speed},
{DataParticleKey.VALUE_ID: AquadoppDwVelocityDataParticleKey.HEADING, DataParticleKey.VALUE: heading},
{DataParticleKey.VALUE_ID: AquadoppDwVelocityDataParticleKey.PITCH, DataParticleKey.VALUE: pitch},
{DataParticleKey.VALUE_ID: AquadoppDwVelocityDataParticleKey.ROLL, DataParticleKey.VALUE: roll},
{DataParticleKey.VALUE_ID: AquadoppDwVelocityDataParticleKey.STATUS, DataParticleKey.VALUE: status},
{DataParticleKey.VALUE_ID: AquadoppDwVelocityDataParticleKey.PRESSURE, DataParticleKey.VALUE: pressure},
{DataParticleKey.VALUE_ID: AquadoppDwVelocityDataParticleKey.TEMPERATURE, DataParticleKey.VALUE: temperature},
{DataParticleKey.VALUE_ID: AquadoppDwVelocityDataParticleKey.VELOCITY_BEAM1, DataParticleKey.VALUE: velocity_beam1},
{DataParticleKey.VALUE_ID: AquadoppDwVelocityDataParticleKey.VELOCITY_BEAM2, DataParticleKey.VALUE: velocity_beam2},
{DataParticleKey.VALUE_ID: AquadoppDwVelocityDataParticleKey.VELOCITY_BEAM3, DataParticleKey.VALUE: velocity_beam3},
{DataParticleKey.VALUE_ID: AquadoppDwVelocityDataParticleKey.AMPLITUDE_BEAM1, DataParticleKey.VALUE: amplitude_beam1},
{DataParticleKey.VALUE_ID: AquadoppDwVelocityDataParticleKey.AMPLITUDE_BEAM2, DataParticleKey.VALUE: amplitude_beam2},
{DataParticleKey.VALUE_ID: AquadoppDwVelocityDataParticleKey.AMPLITUDE_BEAM3, DataParticleKey.VALUE: amplitude_beam3}]
return result
