def encode(self):
"""
Encode the data into RTB format.
:return:
"""
result = []
# Generate header
result += Ensemble.generate_header(self.ds_type, self.num_elements,
self.element_multiplier, self.image,
self.name_len, self.Name)
# Add the data
result += Ensemble.float_to_bytes(self.FirstBinRange)
result += Ensemble.float_to_bytes(self.BinSize)
result += Ensemble.float_to_bytes(self.FirstPingTime)
result += Ensemble.float_to_bytes(self.LastPingTime)
result += Ensemble.float_to_bytes(self.Heading)
result += Ensemble.float_to_bytes(self.Pitch)
result += Ensemble.float_to_bytes(self.Roll)
result += Ensemble.float_to_bytes(self.WaterTemp)
result += Ensemble.float_to_bytes(self.SystemTemp)
result += Ensemble.float_to_bytes(self.Salinity)
result += Ensemble.float_to_bytes(self.Pressure)
result += Ensemble.float_to_bytes(self.TransducerDepth)
result += Ensemble.float_to_bytes(self.SpeedOfSound)
result += Ensemble.float_to_bytes(self.RawMagFieldStrength)
result += Ensemble.float_to_bytes(self.RawMagFieldStrength2)
result += Ensemble.float_to_bytes(self.RawMagFieldStrength3)
result += Ensemble.float_to_bytes(self.PitchGravityVector)
result += Ensemble.float_to_bytes(self.RollGravityVector)
result += Ensemble.float_to_bytes(self.VerticalGravityVector)
return result
def test_generate_header():
value_type = 10 # Float
num_elements = 25 # 25 elements
element_multiplier = 1 # no multiplier
imag = 0 # NOT USED
name_length = 8 # Length of name
name = "E000014\0" # System Setup name
header = Ensemble.generate_header(value_type,
num_elements,
element_multiplier,
imag,
name_length,
name)
# Value type
assert 0xA == header[0]
assert 0x0 == header[1]
assert 0x0 == header[2]
assert 0x0 == header[3]
# Num Elements
assert 0x19 == header[4]
assert 0x0 == header[5]
assert 0x0 == header[6]
assert 0x0 == header[7]
# Element Multiplier
assert 0x1 == header[8]
assert 0x0 == header[9]
assert 0x0 == header[10]
assert 0x0 == header[11]
# Imag
assert 0x0 == header[12]
assert 0x0 == header[13]
assert 0x0 == header[14]
assert 0x0 == header[15]
# Name Length
assert 0x8 == header[16]
assert 0x0 == header[17]
assert 0x0 == header[18]
assert 0x0 == header[19]
# Name
assert ord('E') == header[20]
assert ord('0') == header[21]
assert ord('0') == header[22]
assert ord('0') == header[23]
assert ord('0') == header[24]
assert ord('1') == header[25]
assert ord('4') == header[26]
assert ord('\0') == header[27]
def test_generate_header():
value_type = 10 # Float
num_elements = 30 # 30 bins
element_multiplier = 4 # 4 Beams
imag = 0 # NOT USED
name_length = 8 # Length of name
name = "E000001\0" # Beam Vel name
header = Ensemble.generate_header(value_type,
num_elements,
element_multiplier,
imag,
name_length,
name)
# Value type
assert 0xA == header[0]
assert 0x0 == header[1]
assert 0x0 == header[2]
assert 0x0 == header[3]
# Num Elements
assert 0x1E == header[4]
assert 0x0 == header[5]
assert 0x0 == header[6]
assert 0x0 == header[7]
# Element Multiplier
assert 0x4 == header[8]
assert 0x0 == header[9]
assert 0x0 == header[10]
assert 0x0 == header[11]
# Imag
assert 0x0 == header[12]
assert 0x0 == header[13]
assert 0x0 == header[14]
assert 0x0 == header[15]
# Name Length
assert 0x8 == header[16]
assert 0x0 == header[17]
assert 0x0 == header[18]
assert 0x0 == header[19]
# Name
assert ord('E') == header[20]
assert ord('0') == header[21]
assert ord('0') == header[22]
assert ord('0') == header[23]
assert ord('0') == header[24]
assert ord('0') == header[25]
assert ord('1') == header[26]
assert ord('\0') == header[27]
def test_generate_header():
value_type = 50 # Byte
num_elements = 11 # 17 elements
element_multiplier = 1 # no multiplier
imag = 0 # NOT USED
name_length = 8 # Length of name
name = "E000011\0" # Ancillary name
header = Ensemble.generate_header(value_type, num_elements,
element_multiplier, imag, name_length,
name)
# Value type
assert 0x32 == header[0]
assert 0x0 == header[1]
assert 0x0 == header[2]
assert 0x0 == header[3]
# Num Elements
assert 0x0B == header[4]
assert 0x0 == header[5]
assert 0x0 == header[6]
assert 0x0 == header[7]
# Element Multiplier
assert 0x1 == header[8]
assert 0x0 == header[9]
assert 0x0 == header[10]
assert 0x0 == header[11]
# Imag
assert 0x0 == header[12]
assert 0x0 == header[13]
assert 0x0 == header[14]
assert 0x0 == header[15]
# Name Length
assert 0x8 == header[16]
assert 0x0 == header[17]
assert 0x0 == header[18]
assert 0x0 == header[19]
# Name
assert ord('E') == header[20]
assert ord('0') == header[21]
assert ord('0') == header[22]
assert ord('0') == header[23]
assert ord('0') == header[24]
assert ord('1') == header[25]
assert ord('1') == header[26]
assert ord('\0') == header[27]
def test_generate_header():
value_type = 20 # Int
num_elements = 19 # 19 elements
element_multiplier = 1 # no multiplier
imag = 0 # NOT USED
name_length = 8 # Length of name
name = "E000008\0" # Ensemble Dataset name
header = Ensemble.generate_header(value_type, num_elements,
element_multiplier, imag, name_length,
name)
# Value type
assert 0x14 == header[0]
assert 0x0 == header[1]
assert 0x0 == header[2]
assert 0x0 == header[3]
# Num Elements
assert 0x13 == header[4]
assert 0x0 == header[5]
assert 0x0 == header[6]
assert 0x0 == header[7]
# Element Multiplier
assert 0x1 == header[8]
assert 0x0 == header[9]
assert 0x0 == header[10]
assert 0x0 == header[11]
# Imag
assert 0x0 == header[12]
assert 0x0 == header[13]
assert 0x0 == header[14]
assert 0x0 == header[15]
# Name Length
assert 0x8 == header[16]
assert 0x0 == header[17]
assert 0x0 == header[18]
assert 0x0 == header[19]
# Name
assert ord('E') == header[20]
assert ord('0') == header[21]
assert ord('0') == header[22]
assert ord('0') == header[23]
assert ord('0') == header[24]
assert ord('0') == header[25]
assert ord('8') == header[26]
assert ord('\0') == header[27]
def encode(self):
"""
Encode the data into RTB format.
:return:
"""
result = []
# Generate header
result += Ensemble.generate_header(self.ds_type, self.num_elements,
self.element_multiplier, self.image,
self.name_len, self.Name)
# Add the data
for beam in range(self.element_multiplier):
for bin_num in range(self.num_elements):
val = self.Correlation[bin_num][beam]
result += Ensemble.float_to_bytes(val)
return result
def encode(self):
"""
Encode the data into RTB format.
:return:
"""
result = []
self.num_elements = (8 * int(
self.NumBeams)) + 1 # 8 is the number of list plus 1 for NumBeams
# Generate header
result += Ensemble.generate_header(self.ds_type, self.num_elements,
self.element_multiplier, self.image,
self.name_len, self.Name)
# Add the data
result += Ensemble.float_to_bytes(self.NumBeams)
for beam in range(len(self.SNR)):
result += Ensemble.float_to_bytes(self.SNR[beam])
for beam in range(len(self.Range)):
result += Ensemble.float_to_bytes(self.Range[beam])
for beam in range(len(self.Pings)):
result += Ensemble.float_to_bytes(self.Pings[beam])
for beam in range(len(self.Amplitude)):
result += Ensemble.float_to_bytes(self.Amplitude[beam])
for beam in range(len(self.Correlation)):
result += Ensemble.float_to_bytes(self.Correlation[beam])
for beam in range(len(self.BeamVelocity)):
result += Ensemble.float_to_bytes(self.BeamVelocity[beam])
for beam in range(len(self.InstrumentVelocity)):
result += Ensemble.float_to_bytes(self.InstrumentVelocity[beam])
for beam in range(len(self.EarthVelocity)):
result += Ensemble.float_to_bytes(self.EarthVelocity[beam])
return result
def encode(self):
"""
Encode the data into RTB format.
:return:
"""
result = []
# Generate header
result += Ensemble.generate_header(self.ds_type, self.num_elements,
self.element_multiplier, self.image,
self.name_len, self.Name)
# Add the data
result += Ensemble.float_to_bytes(self.BtSamplesPerSecond)
result += Ensemble.float_to_bytes(self.BtSystemFreqHz)
result += Ensemble.float_to_bytes(self.BtCPCE)
result += Ensemble.float_to_bytes(self.BtNCE)
result += Ensemble.float_to_bytes(self.BtRepeatN)
result += Ensemble.float_to_bytes(self.WpSamplesPerSecond)
result += Ensemble.float_to_bytes(self.WpSystemFreqHz)
result += Ensemble.float_to_bytes(self.WpCPCE)
result += Ensemble.float_to_bytes(self.WpNCE)
result += Ensemble.float_to_bytes(self.WpRepeatN)
result += Ensemble.float_to_bytes(self.WpLagSamples)
result += Ensemble.float_to_bytes(self.Voltage)
result += Ensemble.float_to_bytes(self.XmtVoltage)
result += Ensemble.float_to_bytes(self.BtBroadband)
result += Ensemble.float_to_bytes(self.BtLagLength)
result += Ensemble.float_to_bytes(self.BtNarrowband)
result += Ensemble.float_to_bytes(self.BtBeamMux)
result += Ensemble.float_to_bytes(self.WpBroadband)
result += Ensemble.float_to_bytes(self.WpLagLength)
result += Ensemble.float_to_bytes(self.WpTransmitBandwidth)
result += Ensemble.float_to_bytes(self.WpReceiveBandwidth)
result += Ensemble.float_to_bytes(self.TransmitBoostNegVolt)
result += Ensemble.float_to_bytes(self.WpBeamMux)
result += Ensemble.float_to_bytes(self.Reserved)
result += Ensemble.float_to_bytes(self.Reserved1)
return result
def encode(self):
"""
Encode the data into RTB format.
:return:
"""
result = []
# Generate header
result += Ensemble.generate_header(self.ds_type, self.num_elements,
self.element_multiplier, self.image,
self.name_len, self.Name)
# Add the data
result += Ensemble.int32_to_bytes(self.EnsembleNumber)
result += Ensemble.int32_to_bytes(self.NumBins)
result += Ensemble.int32_to_bytes(self.NumBeams)
result += Ensemble.int32_to_bytes(self.DesiredPingCount)
result += Ensemble.int32_to_bytes(self.ActualPingCount)
result += Ensemble.int32_to_bytes(self.Status)
result += Ensemble.int32_to_bytes(self.Year)
result += Ensemble.int32_to_bytes(self.Month)
result += Ensemble.int32_to_bytes(self.Day)
result += Ensemble.int32_to_bytes(self.Hour)
result += Ensemble.int32_to_bytes(self.Minute)
result += Ensemble.int32_to_bytes(self.Second)
result += Ensemble.int32_to_bytes(self.HSec)
result += self.SerialNumber.encode("UTF-8")
result += bytes([self.SysFirmwareRevision])
result += bytes([self.SysFirmwareMinor])
result += bytes([self.SysFirmwareMajor])
result += self.SysFirmwareSubsystemCode.encode("UTF-8")
result += bytes([0])
result += bytes([0])
result += bytes([0])
result += bytes([self.SubsystemConfig])
return result
def encode(self):
"""
Encode the data into RTB format.
:return:
"""
result = []
# Combine all the NMEA strings into one long string
str_nmea = ""
for nmea in self.nmea_sentences:
str_nmea += nmea + "\n"
# Generate the number of elements from the number of characters
self.num_elements = len(str_nmea)
# Generate header
result += Ensemble.generate_header(self.ds_type, self.num_elements,
self.element_multiplier, self.image,
self.name_len, self.Name)
# Convert the strings to bytes
result += str_nmea.encode("UTF-8")
return result
def encode(self):
"""
Encode the data into RTB format.
:return:
"""
result = []
self.num_elements = (15 * int(self.NumBeams)) + 14
# Generate header
result += Ensemble.generate_header(self.ds_type, self.num_elements,
self.element_multiplier, self.image,
self.name_len, self.Name)
# Add the data
result += Ensemble.float_to_bytes(self.FirstPingTime)
result += Ensemble.float_to_bytes(self.LastPingTime)
result += Ensemble.float_to_bytes(self.Heading)
result += Ensemble.float_to_bytes(self.Pitch)
result += Ensemble.float_to_bytes(self.Roll)
result += Ensemble.float_to_bytes(self.WaterTemp)
result += Ensemble.float_to_bytes(self.SystemTemp)
result += Ensemble.float_to_bytes(self.Salinity)
result += Ensemble.float_to_bytes(self.Pressure)
result += Ensemble.float_to_bytes(self.TransducerDepth)
result += Ensemble.float_to_bytes(self.SpeedOfSound)
result += Ensemble.float_to_bytes(self.Status)
result += Ensemble.float_to_bytes(self.NumBeams)
result += Ensemble.float_to_bytes(self.ActualPingCount)
for beam in range(len(self.Range)):
result += Ensemble.float_to_bytes(self.Range[beam])
for beam in range(len(self.SNR)):
result += Ensemble.float_to_bytes(self.SNR[beam])
for beam in range(len(self.Amplitude)):
result += Ensemble.float_to_bytes(self.Amplitude[beam])
for beam in range(len(self.Correlation)):
result += Ensemble.float_to_bytes(self.Correlation[beam])
for beam in range(len(self.BeamVelocity)):
result += Ensemble.float_to_bytes(self.BeamVelocity[beam])
for beam in range(len(self.BeamGood)):
result += Ensemble.float_to_bytes(self.BeamGood[beam])
for beam in range(len(self.InstrumentVelocity)):
result += Ensemble.float_to_bytes(self.InstrumentVelocity[beam])
for beam in range(len(self.InstrumentGood)):
result += Ensemble.float_to_bytes(self.InstrumentGood[beam])
for beam in range(len(self.EarthVelocity)):
result += Ensemble.float_to_bytes(self.EarthVelocity[beam])
for beam in range(len(self.EarthGood)):
result += Ensemble.float_to_bytes(self.EarthGood[beam])
for beam in range(len(self.SNR_PulseCoherent)):
result += Ensemble.float_to_bytes(self.SNR_PulseCoherent[beam])
for beam in range(len(self.Amp_PulseCoherent)):
result += Ensemble.float_to_bytes(self.Amp_PulseCoherent[beam])
for beam in range(len(self.Vel_PulseCoherent)):
result += Ensemble.float_to_bytes(self.Vel_PulseCoherent[beam])
for beam in range(len(self.Noise_PulseCoherent)):
result += Ensemble.float_to_bytes(self.Vel_PulseCoherent[beam])
for beam in range(len(self.Corr_PulseCoherent)):
result += Ensemble.float_to_bytes(self.Vel_PulseCoherent[beam])
return result
