def decode(self, data):
"""
Take the data bytearray. Decode the data to populate
the velocities.
:param data: Bytearray for the dataset.
"""
packet_pointer = Ensemble.GetBaseDataSize(self.name_len)
for beam in range(self.element_multiplier):
for bin_num in range(self.num_elements):
self.Velocities[bin_num][beam] = Ensemble.GetFloat(packet_pointer, Ensemble().BytesInFloat, data)
packet_pointer += Ensemble().BytesInFloat
logging.debug(self.Velocities)
def decode(self, data):
"""
Take the data bytearray. Decode the data to populate
the Good Beams.
:param data: Bytearray for the dataset.
"""
packet_pointer = Ensemble.GetBaseDataSize(self.name_len)
for beam in range(self.element_multiplier):
for bin_num in range(self.num_elements):
self.GoodBeam[bin_num][beam] = Ensemble.GetInt32(packet_pointer, Ensemble().BytesInInt32, data)
packet_pointer += Ensemble().BytesInInt32
logging.debug(self.GoodBeam)
def verify_ens_data(ens_data, ens_start=0):
"""
This will check the checksum and verify it is correct.
:param ens_data: Ensemble data.
:param ens_start: Start location in the ens_data
"""
try:
# Ensemble Length
ens_len = len(ens_data)
# Verify at least the minimum number of bytes are available to verify the ensemble
if ens_len <= Ensemble().HeaderSize + Ensemble().ChecksumSize:
return False
# Check Ensemble number
ens_num = struct.unpack("I",
ens_data[ens_start + 16:ens_start + 20])
# Check ensemble size
payload_size = struct.unpack(
"I", ens_data[ens_start + 24:ens_start + 28])
# Ensure the entire ensemble is in the buffer
if ens_len >= ens_start + Ensemble(
).HeaderSize + payload_size[0] + Ensemble().ChecksumSize:
# Check checksum
checksum_loc = ens_start + Ensemble(
).HeaderSize + payload_size[0]
checksum = struct.unpack(
"I", ens_data[checksum_loc:checksum_loc +
Ensemble().ChecksumSize])
# Calculate Checksum
# Use only the payload for the checksum
ens = ens_data[ens_start + Ensemble().HeaderSize:ens_start +
Ensemble().HeaderSize + payload_size[0]]
calc_checksum = binascii.crc_hqx(ens, 0)
# Verify checksum
if checksum[0] == calc_checksum:
logging.debug(ens_num[0])
return True
else:
logging.warning(
"Ensemble fails checksum. {:#04x} {:#04x}".format(
checksum[0], calc_checksum))
return False
else:
logging.warning("Incomplete ensemble.")
return False
except Exception as e:
logging.error("Error verifying Ensemble. " + str(e))
return False
return False
def run(self):
"""
Find the start of an ensemble. Then find the end of the ensemble.
Then remove the ensemble from the buffer and process the raw data.
:return:
"""
while self.thread_alive:
# Lock to look for the data
self.thread_lock.acquire()
# Create a buffer to hold the ensemble
bin_ens_list = []
timeout = 0
# Wait for the next ensemble added to the buffer
self.thread_lock.wait()
# Look for first 16 bytes of header
ens_start = self.buffer.find(self.DELIMITER)
# Verify enough data is in the buffer for an ensemble header
while ens_start >= 0 and len(
self.buffer) > Ensemble().HeaderSize + ens_start:
# Decode the Ensemble
bin_ens = self.decode_ensemble(ens_start)
# Add the data to the list or count for timeout
if len(bin_ens) > 0:
# Add it to the list
bin_ens_list.append(bin_ens)
else:
# Timeout if we are only getting bad data
timeout += 1
if timeout > 5:
logging.warning("Find good ensemble timeout")
break
# Search if there is a new start location
ens_start = self.buffer.find(self.DELIMITER)
self.thread_lock.release()
# If data was found for an ensemble
# Process the ensemble binary data
for ens in bin_ens_list:
if len(ens) > 0:
# Decode data
ensemble = BinaryCodec.decode_data_sets(ens)
if ensemble:
# Publish the ensemble
self.process_ensemble(ensemble)
else:
logging.debug("No Ensemble data found")
def __init__(self, num_elements, element_multiplier):
self.ds_type = 10
self.num_elements = num_elements
self.element_multiplier = element_multiplier
self.image = 0
self.name_len = 8
self.Name = "E000002\0"
self.Velocities = []
# Create enough entries for all the (bins x beams)
# Initialize with bad values
for bins in range(num_elements):
bins = []
for beams in range(element_multiplier):
bins.append([Ensemble().BadVelocity])
self.Velocities.append(bins)
def __init__(self, num_elements, element_multiplier):
self.ds_type = 10
self.num_elements = num_elements
self.element_multiplier = element_multiplier
self.image = 0
self.name_len = 8
self.Name = "E000004\0"
self.Amplitude = []
#self.EnsembleNumber = ensemble_number
#self.SerialNumber = serial_number
#self.DateTime = date_time
# Create enough entries for all the (bins x beams)
# Initialize with bad values
for bins in range(num_elements):
bins = []
for beams in range(element_multiplier):
bins.append([Ensemble().BadVelocity])
self.Amplitude.append(bins)
def decode(self, data):
"""
Take the data bytearray. Decode the data to populate
the values.
:param data: Bytearray for the dataset.
"""
packet_pointer = Ensemble.GetBaseDataSize(self.name_len)
self.EnsembleNumber = Ensemble.GetInt32(
packet_pointer + Ensemble().BytesInInt32 * 0,
Ensemble().BytesInInt32, data)
self.NumBins = Ensemble.GetInt32(
packet_pointer + Ensemble().BytesInInt32 * 1,
Ensemble().BytesInInt32, data)
self.NumBeams = Ensemble.GetInt32(
packet_pointer + Ensemble().BytesInInt32 * 2,
Ensemble().BytesInInt32, data)
self.DesiredPingCount = Ensemble.GetInt32(
packet_pointer + Ensemble().BytesInInt32 * 3,
Ensemble().BytesInInt32, data)
self.ActualPingCount = Ensemble.GetInt32(
packet_pointer + Ensemble().BytesInInt32 * 4,
Ensemble().BytesInInt32, data)
self.Status = Ensemble.GetInt32(
packet_pointer + Ensemble().BytesInInt32 * 5,
Ensemble().BytesInInt32, data)
self.Year = Ensemble.GetInt32(
packet_pointer + Ensemble().BytesInInt32 * 6,
Ensemble().BytesInInt32, data)
self.Month = Ensemble.GetInt32(
packet_pointer + Ensemble().BytesInInt32 * 7,
Ensemble().BytesInInt32, data)
self.Day = Ensemble.GetInt32(
packet_pointer + Ensemble().BytesInInt32 * 8,
Ensemble().BytesInInt32, data)
self.Hour = Ensemble.GetInt32(
packet_pointer + Ensemble().BytesInInt32 * 9,
Ensemble().BytesInInt32, data)
self.Minute = Ensemble.GetInt32(
packet_pointer + Ensemble().BytesInInt32 * 10,
Ensemble().BytesInInt32, data)
self.Second = Ensemble.GetInt32(
packet_pointer + Ensemble().BytesInInt32 * 11,
Ensemble().BytesInInt32, data)
self.HSec = Ensemble.GetInt32(
packet_pointer + Ensemble().BytesInInt32 * 12,
Ensemble().BytesInInt32, data)
self.SerialNumber = str(
data[packet_pointer + Ensemble().BytesInInt32 * 13:packet_pointer +
Ensemble().BytesInInt32 * 21], "UTF-8")
self.SysFirmwareRevision = struct.unpack(
"B", data[packet_pointer + Ensemble().BytesInInt32 * 21 +
0:packet_pointer + Ensemble().BytesInInt32 * 21 + 1])[0]
self.SysFirmwareMinor = struct.unpack(
"B", data[packet_pointer + Ensemble().BytesInInt32 * 21 +
1:packet_pointer + Ensemble().BytesInInt32 * 21 + 2])[0]
self.SysFirmwareMajor = struct.unpack(
"B", data[packet_pointer + Ensemble().BytesInInt32 * 21 +
2:packet_pointer + Ensemble().BytesInInt32 * 21 + 3])[0]
self.SysFirmwareSubsystemCode = str(
data[packet_pointer + Ensemble().BytesInInt32 * 21 +
3:packet_pointer + Ensemble().BytesInInt32 * 21 + 4], "UTF-8")
self.SubsystemConfig = struct.unpack(
"B", data[packet_pointer + Ensemble().BytesInInt32 * 22 +
3:packet_pointer + Ensemble().BytesInInt32 * 22 + 4])[0]
logging.debug(self.EnsembleNumber)
logging.debug(
str(self.Month) + "/" + str(self.Day) + "/" + str(self.Year) +
" " + str(self.Hour) + ":" + str(self.Minute) + ":" +
str(self.Second) + "." + str(self.HSec))
logging.debug(self.SerialNumber)
logging.debug(
str(self.SysFirmwareMajor) + "." + str(self.SysFirmwareMinor) +
"." + str(self.SysFirmwareRevision) + "-" +
str(self.SysFirmwareSubsystemCode))
logging.debug(self.SubsystemConfig)
def stream_data(self, ens):
"""
Stream the data to the UDP port.
When converting the dataset to JSON, a newline will be added
to end of the JSON string. This will allow the user to separate
the JSON strings.
:param ens: Ensemble data to stream.
"""
serial_number = ""
ensemble_number = 0
date_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")
if ens.IsEnsembleData:
# Get the serial number, ensemble number and the date and time to share with all the data
serial_number = ens.EnsembleData.SerialNumber
ensemble_number = ens.EnsembleData.EnsembleNumber
if ens.EnsembleData.Month > 0:
date_time = datetime.datetime(
year=ens.EnsembleData.Year,
month=ens.EnsembleData.Month,
day=ens.EnsembleData.Day,
hour=ens.EnsembleData.Hour,
minute=ens.EnsembleData.Minute,
second=ens.EnsembleData.Second,
microsecond=round(ens.EnsembleData.HSec *
10000)).strftime("%Y-%m-%d %H:%M:%S.%f")
# Stream the data
ens.EnsembleData.DateTime = date_time
else:
logging.error("BAD Date and Time: " + str(ensemble_number))
ens.EnsembleData.Meta = self.Meta
self.send_udp(Ensemble().toJSON(ens.EnsembleData).encode())
if ens.IsBeamVelocity:
ens.Wt.EnsembleNumber = ensemble_number
ens.Wt.SerialNumber = serial_number
ens.Wt.DateTime = date_time
ens.Wt.Meta = self.Meta
self.send_udp(Ensemble().toJSON(ens.Wt).encode())
if ens.IsInstrumentVelocity:
ens.InstrumentVelocity.EnsembleNumber = ensemble_number
ens.InstrumentVelocity.SerialNumber = serial_number
ens.InstrumentVelocity.DateTime = date_time
ens.InstrumentVelocity.Meta = self.Meta
self.send_udp(Ensemble().toJSON(ens.InstrumentVelocity).encode())
if ens.IsEarthVelocity:
ens.EarthVelocity.EnsembleNumber = ensemble_number
ens.EarthVelocity.SerialNumber = serial_number
ens.EarthVelocity.DateTime = date_time
ens.EarthVelocity.Meta = self.Meta
self.send_udp(Ensemble().toJSON(ens.EarthVelocity).encode())
if ens.IsAmplitude:
ens.Amplitude.EnsembleNumber = ensemble_number
ens.Amplitude.SerialNumber = serial_number
ens.Amplitude.DateTime = date_time
ens.Amplitude.Meta = self.Meta
self.send_udp(Ensemble().toJSON(ens.Amplitude).encode())
if ens.IsCorrelation:
ens.Correlation.EnsembleNumber = ensemble_number
ens.Correlation.SerialNumber = serial_number
ens.Correlation.DateTime = date_time
ens.Correlation.Meta = self.Meta
self.send_udp(Ensemble().toJSON(ens.Correlation).encode())
if ens.IsGoodBeam:
ens.GoodBeam.EnsembleNumber = ensemble_number
ens.GoodBeam.SerialNumber = serial_number
ens.GoodBeam.DateTime = date_time
ens.GoodBeam.Meta = self.Meta
self.send_udp(Ensemble().toJSON(ens.GoodBeam).encode())
if ens.IsGoodEarth:
ens.GoodEarth.EnsembleNumber = ensemble_number
ens.GoodEarth.SerialNumber = serial_number
ens.GoodEarth.DateTime = date_time
ens.GoodEarth.Meta = self.Meta
self.send_udp(Ensemble().toJSON(ens.GoodEarth).encode())
if ens.IsAncillaryData:
ens.AncillaryData.EnsembleNumber = ensemble_number
ens.AncillaryData.SerialNumber = serial_number
ens.AncillaryData.DateTime = date_time
ens.AncillaryData.Meta = self.Meta
self.send_udp(Ensemble().toJSON(ens.AncillaryData).encode())
if ens.IsBottomTrack:
ens.BottomTrack.EnsembleNumber = ensemble_number
ens.BottomTrack.SerialNumber = serial_number
ens.BottomTrack.DateTime = date_time
ens.BottomTrack.Meta = self.Meta
self.send_udp(Ensemble().toJSON(ens.BottomTrack).encode())
if ens.IsRangeTracking:
ens.RangeTracking.EnsembleNumber = ensemble_number
ens.RangeTracking.SerialNumber = serial_number
ens.RangeTracking.DateTime = date_time
ens.RangeTracking.Meta = self.Meta
self.send_udp(Ensemble().toJSON(ens.RangeTracking).encode())
def decode_data_sets(ens):
"""
Decode the datasets in the ensemble.
Use verify_ens_data if you are using this
as a static method to verify the data is correct.
:param ens: Ensemble data. Decode the dataset.
:return: Return the decoded ensemble.
"""
#print(ens)
packetPointer = Ensemble().HeaderSize
type = 0
numElements = 0
elementMultiplier = 0
imag = 0
nameLen = 0
name = ""
dataSetSize = 0
ens_len = len(ens)
# Create the ensemble
ensemble = Ensemble()
# Add the raw data to the ensemble
#ensemble.AddRawData(ens)
try:
# Decode the ensemble datasets
for x in range(Ensemble().MaxNumDataSets):
# Check if we are at the end of the payload
if packetPointer >= ens_len - Ensemble.ChecksumSize - Ensemble.HeaderSize:
break
try:
# Get the dataset info
ds_type = Ensemble.GetInt32(packetPointer + (Ensemble.BytesInInt32 * 0), Ensemble().BytesInInt32, ens)
num_elements = Ensemble.GetInt32(packetPointer + (Ensemble.BytesInInt32 * 1), Ensemble().BytesInInt32, ens)
element_multiplier = Ensemble.GetInt32(packetPointer + (Ensemble.BytesInInt32 * 2), Ensemble().BytesInInt32, ens)
image = Ensemble.GetInt32(packetPointer + (Ensemble.BytesInInt32 * 3), Ensemble().BytesInInt32, ens)
name_len = Ensemble.GetInt32(packetPointer + (Ensemble.BytesInInt32 * 4), Ensemble().BytesInInt32, ens)
name = str(ens[packetPointer+(Ensemble.BytesInInt32 * 5):packetPointer+(Ensemble.BytesInInt32 * 5)+8], 'UTF-8')
except Exception as e:
logging.warning("Bad Ensemble header" + str(e))
break
# Calculate the dataset size
data_set_size = Ensemble.GetDataSetSize(ds_type, name_len, num_elements, element_multiplier)
# Beam Velocity
if "E000001" in name:
logging.debug(name)
bv = BeamVelocity(num_elements, element_multiplier)
bv.decode(ens[packetPointer:packetPointer+data_set_size])
ensemble.AddBeamVelocity(bv)
# Instrument Velocity
if "E000002" in name:
logging.debug(name)
iv = InstrumentVelocity(num_elements, element_multiplier)
iv.decode(ens[packetPointer:packetPointer+data_set_size])
ensemble.AddInstrumentVelocity(iv)
# Earth Velocity
if "E000003" in name:
logging.debug(name)
ev = EarthVelocity(num_elements, element_multiplier)
ev.decode(ens[packetPointer:packetPointer+data_set_size])
ensemble.AddEarthVelocity(ev)
# Amplitude
if "E000004" in name:
logging.debug(name)
amp = Amplitude(num_elements, element_multiplier)
amp.decode(ens[packetPointer:packetPointer+data_set_size])
ensemble.AddAmplitude(amp)
# Correlation
if "E000005" in name:
logging.debug(name)
corr = Correlation(num_elements, element_multiplier)
corr.decode(ens[packetPointer:packetPointer+data_set_size])
ensemble.AddCorrelation(corr)
# Good Beam
if "E000006" in name:
logging.debug(name)
gb = GoodBeam(num_elements, element_multiplier)
gb.decode(ens[packetPointer:packetPointer+data_set_size])
ensemble.AddGoodBeam(gb)
# Good Earth
if "E000007" in name:
logging.debug(name)
ge = GoodEarth(num_elements, element_multiplier)
ge.decode(ens[packetPointer:packetPointer+data_set_size])
ensemble.AddGoodEarth(ge)
# Ensemble Data
if "E000008" in name:
logging.debug(name)
ed = EnsembleData(num_elements, element_multiplier)
ed.decode(ens[packetPointer:packetPointer+data_set_size])
ensemble.AddEnsembleData(ed)
# Ancillary Data
if "E000009" in name:
logging.debug(name)
ad = AncillaryData(num_elements, element_multiplier)
ad.decode(ens[packetPointer:packetPointer+data_set_size])
ensemble.AddAncillaryData(ad)
# Bottom Track
if "E000010" in name:
logging.debug(name)
bt = BottomTrack(num_elements, element_multiplier)
bt.decode(ens[packetPointer:packetPointer + data_set_size])
ensemble.AddBottomTrack(bt)
# NMEA data
if "E000011" in name:
logging.debug(name)
nd = NmeaData(num_elements, element_multiplier)
nd.decode(ens[packetPointer:packetPointer + data_set_size])
ensemble.AddNmeaData(nd)
# System Setup
if "E000014" in name:
logging.debug(name)
ss = SystemSetup(num_elements, element_multiplier)
ss.decode(ens[packetPointer:packetPointer + data_set_size])
ensemble.AddSystemSetup(ss)
# Range Tracking
if "E000015" in name:
logging.debug(name)
rt = RangeTracking(num_elements, element_multiplier)
rt.decode(ens[packetPointer:packetPointer + data_set_size])
ensemble.AddRangeTracking(rt)
# Move to the next dataset
packetPointer += data_set_size
except Exception as e:
logging.warning("Error decoding the ensemble. " + str(e))
return None
return ensemble
def decode(self, data):
"""
Take the data bytearray. Decode the data to populate
the values.
:param data: Bytearray for the dataset.
"""
packet_pointer = Ensemble.GetBaseDataSize(self.name_len)
self.FirstBinRange = Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 0, Ensemble().BytesInFloat, data)
self.BinSize = Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 1, Ensemble().BytesInFloat, data)
self.FirstPingTime = Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 2, Ensemble().BytesInFloat, data)
self.LastPingTime = Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 3, Ensemble().BytesInFloat, data)
self.Heading = Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 4, Ensemble().BytesInFloat, data)
self.Pitch = Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 5, Ensemble().BytesInFloat, data)
self.Roll = Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 6, Ensemble().BytesInFloat, data)
self.WaterTemp = Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 7, Ensemble().BytesInFloat, data)
self.SystemTemp = Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 8, Ensemble().BytesInFloat, data)
self.Salinity = Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 9, Ensemble().BytesInFloat, data)
self.Pressure = Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 10, Ensemble().BytesInFloat, data)
self.TransducerDepth = Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 11, Ensemble().BytesInFloat, data)
self.SpeedOfSound = Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 12, Ensemble().BytesInFloat, data)
if self.num_elements > 13:
self.RawMagFieldStrength = Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 13, Ensemble().BytesInFloat, data)
self.RawMagFieldStrength2 = Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 14, Ensemble().BytesInFloat, data)
self.RawMagFieldStrength3 = Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 15, Ensemble().BytesInFloat, data)
self.PitchGravityVector = Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 16, Ensemble().BytesInFloat, data)
self.RollGravityVector = Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 17, Ensemble().BytesInFloat, data)
self.VerticalGravityVector = Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 18, Ensemble().BytesInFloat, data)
logging.debug(self.FirstBinRange)
logging.debug(self.BinSize)
logging.debug(self.Heading)
logging.debug(self.Pitch)
logging.debug(self.Roll)
logging.debug(self.Salinity)
logging.debug(self.SpeedOfSound)
def test_good_earth():
gb = GoodEarth(30, 4)
# Populate data
val = 1
for beam in range(gb.element_multiplier):
for bin_num in range(gb.num_elements):
gb.GoodEarth[bin_num][beam] = val
val += 1
result = gb.encode()
# Value type
assert 0x14 == result[0]
assert 0x0 == result[1]
assert 0x0 == result[2]
assert 0x0 == result[3]
# Num Elements
assert 0x1E == result[4]
assert 0x0 == result[5]
assert 0x0 == result[6]
assert 0x0 == result[7]
# Element Multiplier
assert 0x4 == result[8]
assert 0x0 == result[9]
assert 0x0 == result[10]
assert 0x0 == result[11]
# Imag
assert 0x0 == result[12]
assert 0x0 == result[13]
assert 0x0 == result[14]
assert 0x0 == result[15]
# Name Length
assert 0x8 == result[16]
assert 0x0 == result[17]
assert 0x0 == result[18]
assert 0x0 == result[19]
# Name
assert ord('E') == result[20]
assert ord('0') == result[21]
assert ord('0') == result[22]
assert ord('0') == result[23]
assert ord('0') == result[24]
assert ord('0') == result[25]
assert ord('7') == result[26]
assert ord('\0') == result[27]
# Length
assert len(result) == 28 + (
(gb.element_multiplier * gb.num_elements) * Ensemble.BytesInInt32)
# Data
result_val = 1
index = 28 # 28 = Header size
for beam in range(gb.element_multiplier):
for bin_num in range(gb.num_elements):
test_val = Ensemble.GetInt32(index,
Ensemble().BytesInFloat,
bytearray(result))
assert result_val == pytest.approx(test_val, 0.1)
result_val += 1
index += Ensemble().BytesInFloat
def test_encode_decode():
num_bins = 33
num_beams = 4
ens = Ensemble()
ens_ds = EnsembleData()
ens_ds.EnsembleNumber = 2668
ens_ds.NumBins = 33
ens_ds.NumBeams = 4
ens_ds.DesiredPingCount = 45
ens_ds.ActualPingCount = 46
ens_ds.SerialNumber = "01H00000000000000000000000999999"
ens_ds.SysFirmwareMajor = 2
ens_ds.SysFirmwareMinor = 11
ens_ds.SysFirmwareRevision = 5
ens_ds.SysFirmwareSubsystemCode = "A"
ens_ds.SubsystemConfig = 3
ens_ds.Status = 9
ens_ds.Year = 2019
ens_ds.Month = 3
ens_ds.Day = 9
ens_ds.Hour = 12
ens_ds.Minute = 23
ens_ds.Second = 24
ens_ds.HSec = 33
anc = AncillaryData()
anc.FirstBinRange = 1.0 # Blank. Depth to the first bin in meters.
anc.BinSize = 3.0 # Size of a bin in meters.
anc.FirstPingTime = 1.2 # First Ping Time in seconds.
anc.LastPingTime = 2.3 # Last Ping Time in seconds. (If averaging pings, this will be the last ping)
anc.Heading = 23.5 # Heading in degrees.
anc.Pitch = 13.6 # Pitch in degrees.
anc.Roll = 11.25 # Roll in degrees.
anc.WaterTemp = 25.3 # Water Temperature in fahrenheit
anc.SystemTemp = 54.6 # System Temperature in fahrenheit
anc.Salinity = 35.0 # Water Salinity set by the user in PPT
anc.Pressure = 23.78 # Pressure from pressure sensor in Pascals
anc.TransducerDepth = 45.69 # Transducer Depth, used by Pressure sensor in meters
anc.SpeedOfSound = 1400.23 # Speed of Sound in m/s.
anc.RawMagFieldStrength = 3.0 # Raw magnetic field strength
anc.PitchGravityVector = 4.0 # Pitch Gravity Vector
anc.RollGravityVector = 5.0 # Roll Gravity Vector
anc.VerticalGravityVector = 6.0 # Vertical Gravity Vector
amp = Amplitude(num_bins, num_beams)
corr = Correlation(num_bins, num_beams)
beam_vel = BeamVelocity(num_bins, num_beams)
inst_vel = InstrumentVelocity(num_bins, num_beams)
earth_vel = EarthVelocity(num_bins, num_beams)
gb = GoodBeam(num_bins, num_beams)
ge = GoodEarth(num_bins, num_beams)
val = 1.0
for beam in range(amp.element_multiplier):
for bin_num in range(amp.num_elements):
amp.Amplitude[bin_num][beam] = val
corr.Correlation[bin_num][beam] = val
beam_vel.Velocities[bin_num][beam] = val
inst_vel.Velocities[bin_num][beam] = val
earth_vel.Velocities[bin_num][beam] = val
gb.GoodBeam[bin_num][beam] = 1 * int(beam)
ge.GoodEarth[bin_num][beam] = 1 * int(beam)
val += 1.1
bt = BottomTrack()
bt.FirstPingTime = 12.5
bt.LastPingTime = 12.8
bt.Heading = 152.36
bt.Pitch = 12.6
bt.Roll = 223.1
bt.WaterTemp = 15.23
bt.SystemTemp = 78.58
bt.Salinity = 35.0
bt.Pressure = 23.36
bt.TransducerDepth = 156.2
bt.SpeedOfSound = 1402.36
bt.Status = 9.0
bt.NumBeams = 4.0
bt.ActualPingCount = 23
bt.Range = [1.1, 2.2, 3.3, 4.4]
bt.SNR = [1.1, 2.2, 3.3, 4.4]
bt.Amplitude = [1.1, 2.2, 3.3, 4.4]
bt.Correlation = [1.1, 2.2, 3.3, 4.4]
bt.BeamVelocity = [1.1, 2.2, 3.3, 4.4]
bt.BeamGood = [1, 2, 3, 4]
bt.InstrumentVelocity = [1.1, 2.2, 3.3, 4.4]
bt.InstrumentGood = [1, 2, 3, 4]
bt.EarthVelocity = [1.1, 2.2, 3.3, 4.4]
bt.EarthGood = [1, 2, 3, 4]
bt.SNR_PulseCoherent = [1, 2, 3, 4]
bt.Amp_PulseCoherent = [1, 2, 3, 4]
bt.Vel_PulseCoherent = [1, 2, 3, 4]
bt.Noise_PulseCoherent = [1, 2, 3, 4]
bt.Corr_PulseCoherent = [1, 2, 3, 4]
rt = RangeTracking()
rt.NumBeams = 4.0
rt.Range = [1.1, 2.2, 3.3, 4.4]
rt.Pings = [1, 2, 3, 4]
rt.SNR = [1.1, 2.2, 3.3, 4.4]
rt.Amplitude = [1.1, 2.2, 3.3, 4.4]
rt.Correlation = [1.1, 2.2, 3.3, 4.4]
rt.BeamVelocity = [1.1, 2.2, 3.3, 4.4]
rt.InstrumentVelocity = [1.1, 2.2, 3.3, 4.4]
rt.EarthVelocity = [1.1, 2.2, 3.3, 4.4]
nmea = NmeaData()
nmea.add_nmea("$HEHDT,244.39,T*17\n")
nmea.add_nmea(
"$GPGGA,195949.00,3254.8103248,N,11655.5779629,W,2,08,1.1,222.174,M,-32.602,M,6.0,0138*75\n"
)
nmea.add_nmea("$GPVTG,306.20,T,294.73,M,0.13,N,0.24,K,D*2E\n")
nmea.add_nmea("$HEHDT,244.36,T*18\n")
ss = SystemSetup()
ss.BtSamplesPerSecond = 1.0
ss.BtSystemFreqHz = 3.0
ss.BtCPCE = 1.2
ss.BtNCE = 2.3
ss.BtRepeatN = 23.5
ss.WpSamplesPerSecond = 13.6
ss.WpSystemFreqHz = 11.25
ss.WpCPCE = 25.3
ss.WpNCE = 54.6
ss.WpRepeatN = 35.0
ss.WpLagSamples = 23.78
ss.Voltage = 45.69
ss.XmtVoltage = 1400.23
ss.BtBroadband = 3.0
ss.BtLagLength = 4.0
ss.BtNarrowband = 5.0
ss.BtBeamMux = 6.0
ss.WpBroadband = 6.0
ss.WpLagLength = 6.0
ss.WpTransmitBandwidth = 6.0
ss.WpReceiveBandwidth = 6.0
ens.AddAmplitude(amp)
ens.AddCorrelation(corr)
ens.AddBeamVelocity(beam_vel)
ens.AddInstrumentVelocity(inst_vel)
ens.AddEarthVelocity(earth_vel)
ens.AddGoodBeam(gb)
ens.AddGoodEarth(ge)
ens.AddAncillaryData(anc)
ens.AddEnsembleData(ens_ds)
ens.AddBottomTrack(bt)
ens.AddRangeTracking(rt)
ens.AddSystemSetup(ss)
ens.AddNmeaData(nmea)
# Encode the ensemble to binar
binary_ens = ens.encode()
# Use the codec to decode the data
ens1 = BinaryCodec.decode_data_sets(binary_ens[:-4]) # Remove the checksum
assert ens.EnsembleData.EnsembleNumber == ens1.EnsembleData.EnsembleNumber
assert ens.EnsembleData.NumBins == ens1.EnsembleData.NumBins
assert ens.EnsembleData.NumBeams == ens1.EnsembleData.NumBeams
assert ens.EnsembleData.DesiredPingCount == ens1.EnsembleData.DesiredPingCount
assert ens.EnsembleData.ActualPingCount == ens1.EnsembleData.ActualPingCount
assert ens.EnsembleData.SerialNumber == ens1.EnsembleData.SerialNumber
assert ens.EnsembleData.SysFirmwareMajor == ens1.EnsembleData.SysFirmwareMajor
assert ens.EnsembleData.SysFirmwareMinor == ens1.EnsembleData.SysFirmwareMinor
assert ens.EnsembleData.SysFirmwareRevision == ens1.EnsembleData.SysFirmwareRevision
assert ens.EnsembleData.SysFirmwareSubsystemCode == ens1.EnsembleData.SysFirmwareSubsystemCode
assert ens.EnsembleData.SubsystemConfig == ens1.EnsembleData.SubsystemConfig
assert ens.EnsembleData.Status == ens1.EnsembleData.Status
assert ens.EnsembleData.Year == ens1.EnsembleData.Year
assert ens.EnsembleData.Month == ens1.EnsembleData.Month
assert ens.EnsembleData.Day == ens1.EnsembleData.Day
assert ens.EnsembleData.Hour == ens1.EnsembleData.Hour
assert ens.EnsembleData.Minute == ens1.EnsembleData.Minute
assert ens.EnsembleData.Second == ens1.EnsembleData.Second
assert ens.EnsembleData.HSec == ens1.EnsembleData.HSec
assert anc.FirstBinRange == pytest.approx(ens1.AncillaryData.FirstBinRange,
0.1)
assert anc.BinSize == pytest.approx(ens1.AncillaryData.BinSize, 0.1)
assert anc.FirstPingTime == pytest.approx(ens1.AncillaryData.FirstPingTime,
0.1)
assert anc.LastPingTime == pytest.approx(ens1.AncillaryData.LastPingTime,
0.1)
assert anc.Heading == pytest.approx(ens1.AncillaryData.Heading, 0.1)
assert anc.Pitch == pytest.approx(ens1.AncillaryData.Pitch, 0.1)
assert anc.Roll == pytest.approx(ens1.AncillaryData.Roll, 0.1)
assert anc.WaterTemp == pytest.approx(ens1.AncillaryData.WaterTemp, 0.1)
assert anc.SystemTemp == pytest.approx(ens1.AncillaryData.SystemTemp, 0.1)
assert anc.Salinity == pytest.approx(ens1.AncillaryData.Salinity, 0.1)
assert anc.Pressure == pytest.approx(ens1.AncillaryData.Pressure, 0.1)
assert anc.TransducerDepth == pytest.approx(
ens1.AncillaryData.TransducerDepth, 0.1)
assert anc.SpeedOfSound == pytest.approx(ens1.AncillaryData.SpeedOfSound,
0.1)
assert anc.RawMagFieldStrength == pytest.approx(
ens1.AncillaryData.RawMagFieldStrength, 0.1)
assert anc.PitchGravityVector == pytest.approx(
ens1.AncillaryData.PitchGravityVector, 0.1)
assert anc.RollGravityVector == pytest.approx(
ens1.AncillaryData.RollGravityVector, 0.1)
assert anc.VerticalGravityVector == pytest.approx(
ens1.AncillaryData.VerticalGravityVector, 0.1)
for beam in range(amp.element_multiplier):
for bin_num in range(amp.num_elements):
assert amp.Amplitude[bin_num][beam] == pytest.approx(
ens1.Amplitude.Amplitude[bin_num][beam], 0.1)
for beam in range(corr.element_multiplier):
for bin_num in range(corr.num_elements):
assert corr.Correlation[bin_num][beam] == pytest.approx(
ens1.Correlation.Correlation[bin_num][beam], 0.1)
for beam in range(beam_vel.element_multiplier):
for bin_num in range(beam_vel.num_elements):
assert beam_vel.Velocities[bin_num][beam] == pytest.approx(
ens1.Wt.Velocities[bin_num][beam], 0.1)
for beam in range(beam_vel.element_multiplier):
for bin_num in range(beam_vel.num_elements):
assert inst_vel.Velocities[bin_num][beam] == pytest.approx(
ens1.InstrumentVelocity.Velocities[bin_num][beam], 0.1)
for beam in range(beam_vel.element_multiplier):
for bin_num in range(beam_vel.num_elements):
assert earth_vel.Velocities[bin_num][beam] == pytest.approx(
ens1.EarthVelocity.Velocities[bin_num][beam], 0.1)
#for beam in range(gb.element_multiplier):
# for bin_num in range(gb.num_elements):
# assert gb.GoodBeam[bin_num][beam] == pytest.approx(ens1.GoodBeam.GoodBeam[bin_num][beam], 0.1)
for beam in range(ge.element_multiplier):
for bin_num in range(ge.num_elements):
assert ge.GoodEarth[bin_num][beam] == pytest.approx(
ens1.GoodEarth.GoodEarth[bin_num][beam], 0.1)
assert bt.FirstPingTime == pytest.approx(ens1.BottomTrack.FirstPingTime)
assert bt.LastPingTime == pytest.approx(ens1.BottomTrack.LastPingTime)
assert bt.Heading == pytest.approx(ens1.BottomTrack.Heading)
assert bt.Pitch == pytest.approx(ens1.BottomTrack.Pitch)
assert bt.Roll == pytest.approx(ens1.BottomTrack.Roll)
assert bt.WaterTemp == pytest.approx(ens1.BottomTrack.WaterTemp)
assert bt.SystemTemp == pytest.approx(ens1.BottomTrack.SystemTemp)
assert bt.Salinity == pytest.approx(ens1.BottomTrack.Salinity)
assert bt.Pressure == pytest.approx(ens1.BottomTrack.Pressure)
assert bt.TransducerDepth == pytest.approx(
ens1.BottomTrack.TransducerDepth)
assert bt.SpeedOfSound == pytest.approx(ens1.BottomTrack.SpeedOfSound)
assert bt.Status == pytest.approx(ens1.BottomTrack.Status)
assert bt.NumBeams == pytest.approx(ens1.BottomTrack.NumBeams)
assert bt.ActualPingCount == pytest.approx(
ens1.BottomTrack.ActualPingCount)
assert bt.Range == pytest.approx(ens1.BottomTrack.Range)
assert bt.SNR == pytest.approx(ens1.BottomTrack.SNR)
assert bt.Amplitude == pytest.approx(ens1.BottomTrack.Amplitude)
assert bt.Correlation == pytest.approx(ens1.BottomTrack.Correlation)
assert bt.BeamVelocity == pytest.approx(ens1.BottomTrack.Wt)
assert bt.BeamGood == pytest.approx(ens1.BottomTrack.BeamGood, 0.1)
assert bt.InstrumentVelocity == pytest.approx(
ens1.BottomTrack.InstrumentVelocity)
assert bt.InstrumentGood == pytest.approx(ens1.BottomTrack.InstrumentGood,
0.1)
assert bt.EarthVelocity == pytest.approx(ens1.BottomTrack.EarthVelocity)
assert bt.EarthGood == pytest.approx(ens1.BottomTrack.EarthGood, 0.1)
assert bt.SNR_PulseCoherent == pytest.approx(
ens1.BottomTrack.SNR_PulseCoherent, 0.1)
assert bt.Amp_PulseCoherent == pytest.approx(
ens1.BottomTrack.Amp_PulseCoherent, 0.1)
assert bt.Vel_PulseCoherent == pytest.approx(
ens1.BottomTrack.Vel_PulseCoherent, 0.1)
assert bt.Noise_PulseCoherent == pytest.approx(
ens1.BottomTrack.Noise_PulseCoherent, 0.1)
assert bt.Corr_PulseCoherent == pytest.approx(
ens1.BottomTrack.Corr_PulseCoherent, 0.1)
assert rt.NumBeams == ens1.RangeTracking.NumBeams
assert rt.Range == pytest.approx(ens1.RangeTracking.Range)
assert rt.SNR == pytest.approx(ens1.RangeTracking.SNR)
assert rt.Amplitude == pytest.approx(ens1.RangeTracking.Amplitude)
assert rt.Correlation == pytest.approx(ens1.RangeTracking.Correlation)
assert rt.BeamVelocity == pytest.approx(ens1.RangeTracking.Wt)
assert rt.InstrumentVelocity == pytest.approx(
ens1.RangeTracking.InstrumentVelocity)
assert rt.EarthVelocity == pytest.approx(ens1.RangeTracking.EarthVelocity)
assert nmea.nmea_sentences == ens1.NmeaData.nmea_sentences
assert ss.BtSamplesPerSecond == pytest.approx(
ens1.SystemSetup.BtSamplesPerSecond, 0.1)
assert ss.BtSystemFreqHz == pytest.approx(ens1.SystemSetup.BtSystemFreqHz,
0.1)
assert ss.BtCPCE == pytest.approx(ens1.SystemSetup.BtCPCE, 0.1)
assert ss.BtNCE == pytest.approx(ens1.SystemSetup.BtNCE, 0.1)
assert ss.BtRepeatN == pytest.approx(ens1.SystemSetup.BtRepeatN, 0.1)
assert ss.WpSamplesPerSecond == pytest.approx(
ens1.SystemSetup.WpSamplesPerSecond, 0.1)
assert ss.WpSystemFreqHz == pytest.approx(ens1.SystemSetup.WpSystemFreqHz,
0.1)
assert ss.WpCPCE == pytest.approx(ens1.SystemSetup.WpCPCE, 0.1)
assert ss.WpNCE == pytest.approx(ens1.SystemSetup.WpNCE, 0.1)
assert ss.WpRepeatN == pytest.approx(ens1.SystemSetup.WpRepeatN, 0.1)
assert ss.WpLagSamples == pytest.approx(ens1.SystemSetup.WpLagSamples, 0.1)
assert ss.Voltage == pytest.approx(ens1.SystemSetup.Voltage, 0.1)
assert ss.XmtVoltage == pytest.approx(ens1.SystemSetup.XmtVoltage, 0.1)
assert ss.BtBroadband == pytest.approx(ens1.SystemSetup.BtBroadband, 0.1)
assert ss.BtLagLength == pytest.approx(ens1.SystemSetup.BtLagLength, 0.1)
assert ss.BtNarrowband == pytest.approx(ens1.SystemSetup.BtNarrowband, 0.1)
assert ss.BtBeamMux == pytest.approx(ens1.SystemSetup.BtBeamMux, 0.1)
assert ss.WpBroadband == pytest.approx(ens1.SystemSetup.WpBroadband, 0.1)
assert ss.WpLagLength == pytest.approx(ens1.SystemSetup.WpLagLength, 0.1)
assert ss.WpTransmitBandwidth == pytest.approx(
ens1.SystemSetup.WpTransmitBandwidth, 0.1)
assert ss.WpReceiveBandwidth == pytest.approx(
ens1.SystemSetup.WpReceiveBandwidth, 0.1)
def decode(self, data):
"""
Take the data bytearray. Decode the data to populate
the values.
:param data: Bytearray for the dataset.
"""
packet_pointer = Ensemble.GetBaseDataSize(self.name_len)
self.BtSamplesPerSecond = Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 0,
Ensemble().BytesInFloat, data)
self.BtSystemFreqHz = Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 1,
Ensemble().BytesInFloat, data)
self.BtCPCE = Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 2,
Ensemble().BytesInFloat, data)
self.BtNCE = Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 3,
Ensemble().BytesInFloat, data)
self.BtRepeatN = Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 4,
Ensemble().BytesInFloat, data)
self.WpSamplesPerSecond = Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 5,
Ensemble().BytesInFloat, data)
self.WpSystemFreqHz = Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 6,
Ensemble().BytesInFloat, data)
self.WpCPCE = Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 7,
Ensemble().BytesInFloat, data)
self.WpNCE = Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 8,
Ensemble().BytesInFloat, data)
self.WpRepeatN = Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 9,
Ensemble().BytesInFloat, data)
self.WpLagSamples = Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 10,
Ensemble().BytesInFloat, data)
self.Voltage = Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 11,
Ensemble().BytesInFloat, data)
if self.num_elements > 12:
self.XmtVoltage = Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 12,
Ensemble().BytesInFloat, data)
self.BtBroadband = Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 13,
Ensemble().BytesInFloat, data)
self.BtLagLength = Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 14,
Ensemble().BytesInFloat, data)
self.BtNarrowband = Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 15,
Ensemble().BytesInFloat, data)
self.BtBeamMux = Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 16,
Ensemble().BytesInFloat, data)
self.WpBroadband = Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 17,
Ensemble().BytesInFloat, data)
self.WpLagLength = Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 18,
Ensemble().BytesInFloat, data)
self.WpTransmitBandwidth = Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 19,
Ensemble().BytesInFloat, data)
self.WpReceiveBandwidth = Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 20,
Ensemble().BytesInFloat, data)
self.TransmitBoostNegVolt = Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 21,
Ensemble().BytesInFloat, data)
self.WpBeamMux = Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 22,
Ensemble().BytesInFloat, data)
if self.num_elements > 23:
self.Reserved = Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 23,
Ensemble().BytesInFloat, data)
self.Reserved1 = Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 24,
Ensemble().BytesInFloat, data)
logging.debug(self.BtSamplesPerSecond)
logging.debug(self.BtSystemFreqHz)
logging.debug(self.BtCPCE)
logging.debug(self.BtNCE)
logging.debug(self.BtRepeatN)
logging.debug(self.WpSamplesPerSecond)
logging.debug(self.WpSystemFreqHz)
logging.debug(self.WpCPCE)
logging.debug(self.WpNCE)
logging.debug(self.WpRepeatN)
logging.debug(self.WpLagSamples)
logging.debug(self.Voltage)
logging.debug(self.XmtVoltage)
logging.debug(self.BtBroadband)
logging.debug(self.BtLagLength)
logging.debug(self.BtNarrowband)
logging.debug(self.BtBeamMux)
logging.debug(self.WpBroadband)
logging.debug(self.WpLagLength)
logging.debug(self.WpTransmitBandwidth)
logging.debug(self.WpReceiveBandwidth)
def test_write_binary():
num_bins = 33
num_beams = 4
ens = Ensemble()
ens_ds = EnsembleData()
ens_ds.EnsembleNumber = 2668
ens_ds.NumBins = 33
ens_ds.NumBeams = 4
ens_ds.DesiredPingCount = 45
ens_ds.ActualPingCount = 46
ens_ds.SerialNumber = "01H00000000000000000000000999999"
ens_ds.SysFirmwareMajor = 2
ens_ds.SysFirmwareMinor = 11
ens_ds.SysFirmwareRevision = 5
ens_ds.SysFirmwareSubsystemCode = "A"
ens_ds.SubsystemConfig = 3
ens_ds.Status = 9
ens_ds.Year = 2019
ens_ds.Month = 3
ens_ds.Day = 9
ens_ds.Hour = 12
ens_ds.Minute = 23
ens_ds.Second = 24
ens_ds.HSec = 33
anc = AncillaryData()
anc.FirstBinRange = 1.0 # Blank. Depth to the first bin in meters.
anc.BinSize = 3.0 # Size of a bin in meters.
anc.FirstPingTime = 1.2 # First Ping Time in seconds.
anc.LastPingTime = 2.3 # Last Ping Time in seconds. (If averaging pings, this will be the last ping)
anc.Heading = 23.5 # Heading in degrees.
anc.Pitch = 13.6 # Pitch in degrees.
anc.Roll = 11.25 # Roll in degrees.
anc.WaterTemp = 25.3 # Water Temperature in fahrenheit
anc.SystemTemp = 54.6 # System Temperature in fahrenheit
anc.Salinity = 35.0 # Water Salinity set by the user in PPT
anc.Pressure = 23.78 # Pressure from pressure sensor in Pascals
anc.TransducerDepth = 45.69 # Transducer Depth, used by Pressure sensor in meters
anc.SpeedOfSound = 1400.23 # Speed of Sound in m/s.
anc.RawMagFieldStrength = 3.0 # Raw magnetic field strength
anc.PitchGravityVector = 4.0 # Pitch Gravity Vector
anc.RollGravityVector = 5.0 # Roll Gravity Vector
anc.VerticalGravityVector = 6.0 # Vertical Gravity Vector
amp = Amplitude(num_bins, num_beams)
corr = Correlation(num_bins, num_beams)
beam_vel = BeamVelocity(num_bins, num_beams)
inst_vel = InstrumentVelocity(num_bins, num_beams)
earth_vel = EarthVelocity(num_bins, num_beams)
gb = GoodBeam(num_bins, num_beams)
ge = GoodEarth(num_bins, num_beams)
val = 1.0
for beam in range(amp.element_multiplier):
for bin_num in range(amp.num_elements):
amp.Amplitude[bin_num][beam] = val
corr.Correlation[bin_num][beam] = val
beam_vel.Velocities[bin_num][beam] = val
inst_vel.Velocities[bin_num][beam] = val
earth_vel.Velocities[bin_num][beam] = val
gb.GoodBeam[bin_num][beam] = 1 * int(beam)
ge.GoodEarth[bin_num][beam] = 1 * int(beam)
val += 1.1
bt = BottomTrack()
bt.FirstPingTime = 12.5
bt.LastPingTime = 12.8
bt.Heading = 152.36
bt.Pitch = 12.6
bt.Roll = 223.1
bt.WaterTemp = 15.23
bt.SystemTemp = 78.58
bt.Salinity = 35.0
bt.Pressure = 23.36
bt.TransducerDepth = 156.2
bt.SpeedOfSound = 1402.36
bt.Status = 9.0
bt.NumBeams = 4.0
bt.ActualPingCount = 23
bt.Range = [1.1, 2.2, 3.3, 4.4]
bt.SNR = [1.1, 2.2, 3.3, 4.4]
bt.Amplitude = [1.1, 2.2, 3.3, 4.4]
bt.Correlation = [1.1, 2.2, 3.3, 4.4]
bt.BeamVelocity = [1.1, 2.2, 3.3, 4.4]
bt.BeamGood = [1, 2, 3, 4]
bt.InstrumentVelocity = [1.1, 2.2, 3.3, 4.4]
bt.InstrumentGood = [1, 2, 3, 4]
bt.EarthVelocity = [1.1, 2.2, 3.3, 4.4]
bt.EarthGood = [1, 2, 3, 4]
bt.SNR_PulseCoherent = [1, 2, 3, 4]
bt.Amp_PulseCoherent = [1, 2, 3, 4]
bt.Vel_PulseCoherent = [1, 2, 3, 4]
bt.Noise_PulseCoherent = [1, 2, 3, 4]
bt.Corr_PulseCoherent = [1, 2, 3, 4]
rt = RangeTracking()
rt.NumBeams = 4.0
rt.Range = [1.1, 2.2, 3.3, 4.4]
rt.Pings = [1, 2, 3, 4]
rt.SNR = [1.1, 2.2, 3.3, 4.4]
rt.Amplitude = [1.1, 2.2, 3.3, 4.4]
rt.Correlation = [1.1, 2.2, 3.3, 4.4]
rt.BeamVelocity = [1.1, 2.2, 3.3, 4.4]
rt.InstrumentVelocity = [1.1, 2.2, 3.3, 4.4]
rt.EarthVelocity = [1.1, 2.2, 3.3, 4.4]
nmea = NmeaData()
nmea.add_nmea("$HEHDT,244.39,T*17\n")
nmea.add_nmea(
"$GPGGA,195949.00,3254.8103248,N,11655.5779629,W,2,08,1.1,222.174,M,-32.602,M,6.0,0138*75\n"
)
nmea.add_nmea("$GPVTG,306.20,T,294.73,M,0.13,N,0.24,K,D*2E\n")
nmea.add_nmea("$HEHDT,244.36,T*18\n")
ss = SystemSetup()
ss.BtSamplesPerSecond = 1.0
ss.BtSystemFreqHz = 3.0
ss.BtCPCE = 1.2
ss.BtNCE = 2.3
ss.BtRepeatN = 23.5
ss.WpSamplesPerSecond = 13.6
ss.WpSystemFreqHz = 11.25
ss.WpCPCE = 25.3
ss.WpNCE = 54.6
ss.WpRepeatN = 35.0
ss.WpLagSamples = 23.78
ss.Voltage = 45.69
ss.XmtVoltage = 1400.23
ss.BtBroadband = 3.0
ss.BtLagLength = 4.0
ss.BtNarrowband = 5.0
ss.BtBeamMux = 6.0
ss.WpBroadband = 6.0
ss.WpLagLength = 6.0
ss.WpTransmitBandwidth = 6.0
ss.WpReceiveBandwidth = 6.0
ens.AddAmplitude(amp)
ens.AddCorrelation(corr)
ens.AddBeamVelocity(beam_vel)
ens.AddInstrumentVelocity(inst_vel)
ens.AddEarthVelocity(earth_vel)
ens.AddGoodBeam(gb)
ens.AddGoodEarth(ge)
ens.AddAncillaryData(anc)
ens.AddEnsembleData(ens_ds)
ens.AddBottomTrack(bt)
ens.AddRangeTracking(rt)
ens.AddSystemSetup(ss)
ens.AddNmeaData(nmea)
rti_writer = RtiBinaryWriter("C:\RTI_capture")
for ens_count in range(0, 100):
bin_data = ens.encode()
rti_writer.write(bin_data)
ens.EnsembleData.EnsembleNumber += 1
rti_writer.close()
def decode_ensemble(self, ensStart):
"""
Decode the raw ensemble data. This will check the checksum and verify it is correct,
then decode each datasets. Then remove the data from the buffer.
:param ensStart: Stare of the ensemble in the buffer.
"""
bin_ens = []
# Check Ensemble number
ens_num = struct.unpack("I", self.buffer[ensStart + 16:ensStart + 20])
# Check ensemble size
payload_size = struct.unpack("I",
self.buffer[ensStart + 24:ensStart + 28])
# Ensure the entire ensemble is in the buffer
if len(self.buffer) >= ensStart + Ensemble(
).HeaderSize + payload_size[0] + Ensemble().ChecksumSize:
# Reset timeout
self.timeout = 0
# Check checksum
checksumLoc = ensStart + Ensemble().HeaderSize + payload_size[0]
checksum = struct.unpack(
"I",
self.buffer[checksumLoc:checksumLoc + Ensemble().ChecksumSize])
# Calculate Checksum
# Use only the payload for the checksum
ens = self.buffer[ensStart + Ensemble().HeaderSize:ensStart +
Ensemble().HeaderSize + payload_size[0]]
calcChecksum = CRCCCITT().calculate(input_data=bytes(ens))
#print("Calc Checksum: ", calcChecksum)
#print("Checksum: ", checksum[0])
#print("Checksum good: ", calcChecksum == checksum[0])
if checksum[0] == calcChecksum:
logging.debug(ens_num[0])
try:
# Make a deep copy of the ensemble data
bin_ens = copy.deepcopy(
self.buffer[ensStart:ensStart + Ensemble().HeaderSize +
payload_size[0]])
# Remove ensemble from buffer
ens_end = ensStart + Ensemble(
).HeaderSize + payload_size[0] + Ensemble().ChecksumSize
del self.buffer[0:ens_end]
except Exception as e:
logging.error("Error processing ensemble. ", e)
else:
logging.warning("Not a complete buffer. Waiting for data")
# Give it a couple tries to see if more data will come in to make a complete header
self.timeout += 1
# Check for timeout
if self.timeout > self.MAX_TIMEOUT:
del self.buffer[0]
logging.warning(
"Buffered data did not have a good header. Header search TIMEOUT"
)
self.timeout = 0
return bin_ens
def decode(self, data):
"""
Take the data bytearray. Decode the data to populate
the velocities.
:param data: Bytearray for the dataset.
"""
packet_pointer = Ensemble.GetBaseDataSize(self.name_len)
self.FirstPingTime = Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 0,
Ensemble().BytesInFloat, data)
self.LastPingTime = Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 1,
Ensemble().BytesInFloat, data)
self.Heading = Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 2,
Ensemble().BytesInFloat, data)
self.Pitch = Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 3,
Ensemble().BytesInFloat, data)
self.Roll = Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 4,
Ensemble().BytesInFloat, data)
self.WaterTemp = Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 5,
Ensemble().BytesInFloat, data)
self.SystemTemp = Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 6,
Ensemble().BytesInFloat, data)
self.Salinity = Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 7,
Ensemble().BytesInFloat, data)
self.Pressure = Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 8,
Ensemble().BytesInFloat, data)
self.TransducerDepth = Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 9,
Ensemble().BytesInFloat, data)
self.SpeedOfSound = Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 10,
Ensemble().BytesInFloat, data)
self.Status = Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 11,
Ensemble().BytesInFloat, data)
self.NumBeams = Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 12,
Ensemble().BytesInFloat, data)
self.ActualPingCount = Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 13,
Ensemble().BytesInFloat, data)
index = 14
numBeam = int(self.NumBeams)
for beams in range(numBeam):
self.Range.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * index,
Ensemble().BytesInFloat, data))
index += 1
for beams in range(numBeam):
self.SNR.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * index,
Ensemble().BytesInFloat, data))
index += 1
for beams in range(numBeam):
self.Amplitude.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * index,
Ensemble().BytesInFloat, data))
index += 1
for beams in range(numBeam):
self.Correlation.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * index,
Ensemble().BytesInFloat, data))
index += 1
for beams in range(numBeam):
self.BeamVelocity.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * index,
Ensemble().BytesInFloat, data))
index += 1
for beams in range(numBeam):
self.BeamGood.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * index,
Ensemble().BytesInFloat, data))
index += 1
for beams in range(numBeam):
self.InstrumentVelocity.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * index,
Ensemble().BytesInFloat, data))
index += 1
for beams in range(numBeam):
self.InstrumentGood.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * index,
Ensemble().BytesInFloat, data))
index += 1
for beams in range(numBeam):
self.EarthVelocity.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * index,
Ensemble().BytesInFloat, data))
index += 1
for beams in range(numBeam):
self.EarthGood.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * index,
Ensemble().BytesInFloat, data))
index += 1
if self.num_elements > 54:
for beams in range(numBeam):
self.SNR_PulseCoherent.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * index,
Ensemble().BytesInFloat, data))
index += 1
for beams in range(numBeam):
self.Amp_PulseCoherent.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * index,
Ensemble().BytesInFloat, data))
index += 1
for beams in range(numBeam):
self.Vel_PulseCoherent.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * index,
Ensemble().BytesInFloat, data))
index += 1
for beams in range(numBeam):
self.Noise_PulseCoherent.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * index,
Ensemble().BytesInFloat, data))
index += 1
for beams in range(numBeam):
self.Corr_PulseCoherent.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * index,
Ensemble().BytesInFloat, data))
index += 1
else:
# Fill in with 0.0
for beams in range(numBeam):
self.SNR_PulseCoherent.append(0.0)
for beams in range(numBeam):
self.Amp_PulseCoherent.append(0.0)
for beams in range(numBeam):
self.Vel_PulseCoherent.append(0.0)
for beams in range(numBeam):
self.Noise_PulseCoherent.append(0.0)
for beams in range(numBeam):
self.Corr_PulseCoherent.append(0.0)
logging.debug(self.FirstPingTime)
logging.debug(self.LastPingTime)
logging.debug(self.Heading)
logging.debug(self.Pitch)
logging.debug(self.Roll)
logging.debug(self.Salinity)
logging.debug(self.SpeedOfSound)
logging.debug(self.EarthVelocity)
def test_encode_csv_no_anc():
num_bins = 33
num_beams = 4
ens = Ensemble()
amp = Amplitude(num_bins, num_beams)
corr = Correlation(num_bins, num_beams)
beam_vel = BeamVelocity(num_bins, num_beams)
inst_vel = InstrumentVelocity(num_bins, num_beams)
earth_vel = EarthVelocity(num_bins, num_beams)
gb = GoodBeam(num_bins, num_beams)
ge = GoodEarth(num_bins, num_beams)
anc = AncillaryData()
ensData = EnsembleData()
ss = SystemSetup()
bt = BottomTrack()
bt.NumBeams = 4
bt.Range = [1.1, 2.2, 3.3, 4.4]
bt.SNR = [1.1, 2.2, 3.3, 4.4]
bt.Amplitude = [1.1, 2.2, 3.3, 4.4]
bt.Correlation = [1.1, 2.2, 3.3, 4.4]
bt.BeamVelocity = [1.1, 2.2, 3.3, 4.4]
bt.BeamGood = [1, 2, 3, 4]
bt.InstrumentVelocity = [1.1, 2.2, 3.3, 4.4]
bt.InstrumentGood = [1, 2, 3, 4]
bt.EarthVelocity = [1.1, 2.2, 3.3, 4.4]
bt.EarthGood = [1, 2, 3, 4]
bt.SNR_PulseCoherent = [1, 2, 3, 4]
bt.Amp_PulseCoherent = [1, 2, 3, 4]
bt.Vel_PulseCoherent = [1, 2, 3, 4]
bt.Noise_PulseCoherent = [1, 2, 3, 4]
bt.Corr_PulseCoherent = [1, 2, 3, 4]
rt = RangeTracking()
rt.NumBeams = 4.0
rt.Range = [1.1, 2.2, 3.3, 4.4]
rt.Pings = [1, 2, 3, 4]
rt.SNR = [1.1, 2.2, 3.3, 4.4]
rt.Amplitude = [1.1, 2.2, 3.3, 4.4]
rt.Correlation = [1.1, 2.2, 3.3, 4.4]
rt.BeamVelocity = [1.1, 2.2, 3.3, 4.4]
rt.InstrumentVelocity = [1.1, 2.2, 3.3, 4.4]
rt.EarthVelocity = [1.1, 2.2, 3.3, 4.4]
ens.AddAmplitude(amp)
ens.AddCorrelation(corr)
ens.AddBeamVelocity(beam_vel)
ens.AddInstrumentVelocity(inst_vel)
ens.AddEarthVelocity(earth_vel)
ens.AddGoodBeam(gb)
ens.AddGoodEarth(ge)
ens.AddAncillaryData(anc)
ens.AddEnsembleData(ensData)
ens.AddBottomTrack(bt)
ens.AddRangeTracking(rt)
ens.AddSystemSetup(ss)
results = ens.encode_csv(is_ancillary_data=False)
total_lines = num_bins * num_beams * 7
total_lines += num_bins * 2 # Mag and Direction in EarthVelocity
total_lines += 6 + (num_beams * 7) # Bottom Track
total_lines += 1 # Ensemble Data
#total_lines += 10 # Ancillary Data
total_lines += 5 * num_beams # Range Tracking
total_lines += 1 # System Settings
assert len(results) == total_lines
def decode(self, data):
"""
Take the data bytearray. Decode the data to populate
the values.
:param data: Bytearray for the dataset.
"""
packet_pointer = Ensemble.GetBaseDataSize(self.name_len)
self.NumBeams = Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 0,
Ensemble().BytesInFloat, data)
self.num_elements = (8 * int(self.NumBeams)) + 1
if self.NumBeams == 4.0:
self.SNR.append(
Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 1,
Ensemble().BytesInFloat, data))
self.SNR.append(
Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 2,
Ensemble().BytesInFloat, data))
self.SNR.append(
Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 3,
Ensemble().BytesInFloat, data))
self.SNR.append(
Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 4,
Ensemble().BytesInFloat, data))
self.Range.append(
Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 5,
Ensemble().BytesInFloat, data))
self.Range.append(
Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 6,
Ensemble().BytesInFloat, data))
self.Range.append(
Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 7,
Ensemble().BytesInFloat, data))
self.Range.append(
Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 8,
Ensemble().BytesInFloat, data))
self.Pings.append(
Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 9,
Ensemble().BytesInFloat, data))
self.Pings.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 10,
Ensemble().BytesInFloat, data))
self.Pings.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 11,
Ensemble().BytesInFloat, data))
self.Pings.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 12,
Ensemble().BytesInFloat, data))
if len(data) > 80:
self.Amplitude.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 13,
Ensemble().BytesInFloat, data))
self.Amplitude.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 14,
Ensemble().BytesInFloat, data))
self.Amplitude.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 15,
Ensemble().BytesInFloat, data))
self.Amplitude.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 16,
Ensemble().BytesInFloat, data))
self.Correlation.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 17,
Ensemble().BytesInFloat, data))
self.Correlation.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 18,
Ensemble().BytesInFloat, data))
self.Correlation.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 19,
Ensemble().BytesInFloat, data))
self.Correlation.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 20,
Ensemble().BytesInFloat, data))
self.BeamVelocity.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 21,
Ensemble().BytesInFloat, data))
self.BeamVelocity.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 22,
Ensemble().BytesInFloat, data))
self.BeamVelocity.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 23,
Ensemble().BytesInFloat, data))
self.BeamVelocity.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 24,
Ensemble().BytesInFloat, data))
self.InstrumentVelocity.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 25,
Ensemble().BytesInFloat, data))
self.InstrumentVelocity.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 26,
Ensemble().BytesInFloat, data))
self.InstrumentVelocity.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 27,
Ensemble().BytesInFloat, data))
self.InstrumentVelocity.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 28,
Ensemble().BytesInFloat, data))
self.EarthVelocity.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 29,
Ensemble().BytesInFloat, data))
self.EarthVelocity.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 30,
Ensemble().BytesInFloat, data))
self.EarthVelocity.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 31,
Ensemble().BytesInFloat, data))
self.EarthVelocity.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 32,
Ensemble().BytesInFloat, data))
elif self.NumBeams == 3.0:
self.SNR.append(
Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 1,
Ensemble().BytesInFloat, data))
self.SNR.append(
Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 2,
Ensemble().BytesInFloat, data))
self.SNR.append(
Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 3,
Ensemble().BytesInFloat, data))
self.Range.append(
Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 4,
Ensemble().BytesInFloat, data))
self.Range.append(
Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 5,
Ensemble().BytesInFloat, data))
self.Range.append(
Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 6,
Ensemble().BytesInFloat, data))
self.Pings.append(
Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 7,
Ensemble().BytesInFloat, data))
self.Pings.append(
Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 8,
Ensemble().BytesInFloat, data))
self.Pings.append(
Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 9,
Ensemble().BytesInFloat, data))
if len(data) > 68:
self.Amplitude.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 10,
Ensemble().BytesInFloat, data))
self.Amplitude.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 11,
Ensemble().BytesInFloat, data))
self.Amplitude.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 12,
Ensemble().BytesInFloat, data))
self.Correlation.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 13,
Ensemble().BytesInFloat, data))
self.Correlation.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 14,
Ensemble().BytesInFloat, data))
self.Correlation.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 15,
Ensemble().BytesInFloat, data))
self.BeamVelocity.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 16,
Ensemble().BytesInFloat, data))
self.BeamVelocity.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 17,
Ensemble().BytesInFloat, data))
self.BeamVelocity.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 18,
Ensemble().BytesInFloat, data))
self.InstrumentVelocity.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 19,
Ensemble().BytesInFloat, data))
self.InstrumentVelocity.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 20,
Ensemble().BytesInFloat, data))
self.InstrumentVelocity.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 21,
Ensemble().BytesInFloat, data))
self.EarthVelocity.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 22,
Ensemble().BytesInFloat, data))
self.EarthVelocity.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 23,
Ensemble().BytesInFloat, data))
self.EarthVelocity.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 24,
Ensemble().BytesInFloat, data))
elif self.NumBeams == 2.0:
self.SNR.append(
Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 1,
Ensemble().BytesInFloat, data))
self.SNR.append(
Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 2,
Ensemble().BytesInFloat, data))
self.Range.append(
Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 3,
Ensemble().BytesInFloat, data))
self.Range.append(
Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 4,
Ensemble().BytesInFloat, data))
self.Pings.append(
Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 5,
Ensemble().BytesInFloat, data))
self.Pings.append(
Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 6,
Ensemble().BytesInFloat, data))
if len(data) > 56:
self.Amplitude.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 7,
Ensemble().BytesInFloat, data))
self.Amplitude.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 8,
Ensemble().BytesInFloat, data))
self.Correlation.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 9,
Ensemble().BytesInFloat, data))
self.Correlation.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 10,
Ensemble().BytesInFloat, data))
self.BeamVelocity.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 11,
Ensemble().BytesInFloat, data))
self.BeamVelocity.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 12,
Ensemble().BytesInFloat, data))
self.InstrumentVelocity.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 13,
Ensemble().BytesInFloat, data))
self.InstrumentVelocity.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 14,
Ensemble().BytesInFloat, data))
self.EarthVelocity.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 15,
Ensemble().BytesInFloat, data))
self.EarthVelocity.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 16,
Ensemble().BytesInFloat, data))
elif self.NumBeams == 1.0:
self.SNR.append(
Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 1,
Ensemble().BytesInFloat, data))
self.Range.append(
Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 2,
Ensemble().BytesInFloat, data))
self.Pings.append(
Ensemble.GetFloat(packet_pointer + Ensemble().BytesInFloat * 3,
Ensemble().BytesInFloat, data))
if len(data) > 44:
self.Amplitude.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 4,
Ensemble().BytesInFloat, data))
self.Correlation.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 5,
Ensemble().BytesInFloat, data))
self.BeamVelocity.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 6,
Ensemble().BytesInFloat, data))
self.InstrumentVelocity.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 7,
Ensemble().BytesInFloat, data))
self.EarthVelocity.append(
Ensemble.GetFloat(
packet_pointer + Ensemble().BytesInFloat * 8,
Ensemble().BytesInFloat, data))
logging.debug(self.NumBeams)
logging.debug(self.SNR)
logging.debug(self.Range)
logging.debug(self.Pings)
logging.debug(self.Amplitude)
logging.debug(self.Correlation)
logging.debug(self.BeamVelocity)
logging.debug(self.InstrumentVelocity)
logging.debug(self.EarthVelocity)
def test_amplitude():
amp = Amplitude(30, 4)
# Populate data
val = 1.0
for beam in range(amp.element_multiplier):
for bin_num in range(amp.num_elements):
amp.Amplitude[bin_num][beam] = val
val += 1.1
result = amp.encode()
# Value type
assert 0xA == result[0]
assert 0x0 == result[1]
assert 0x0 == result[2]
assert 0x0 == result[3]
# Num Elements
assert 0x1E == result[4]
assert 0x0 == result[5]
assert 0x0 == result[6]
assert 0x0 == result[7]
# Element Multiplier
assert 0x4 == result[8]
assert 0x0 == result[9]
assert 0x0 == result[10]
assert 0x0 == result[11]
# Imag
assert 0x0 == result[12]
assert 0x0 == result[13]
assert 0x0 == result[14]
assert 0x0 == result[15]
# Name Length
assert 0x8 == result[16]
assert 0x0 == result[17]
assert 0x0 == result[18]
assert 0x0 == result[19]
# Name
assert ord('E') == result[20]
assert ord('0') == result[21]
assert ord('0') == result[22]
assert ord('0') == result[23]
assert ord('0') == result[24]
assert ord('0') == result[25]
assert ord('4') == result[26]
assert ord('\0') == result[27]
# Length
assert len(result) == 28 + (
(amp.element_multiplier * amp.num_elements) * Ensemble.BytesInFloat)
# Amplitude data
result_val = 1.0
index = 28 # 28 = Header size
for beam in range(amp.element_multiplier):
for bin_num in range(amp.num_elements):
test_val = Ensemble.GetFloat(index,
Ensemble().BytesInFloat,
bytearray(result))
assert result_val == pytest.approx(test_val, 0.1)
result_val += 1.1
index += Ensemble().BytesInFloat
def test_calc_discharge():
ens = Ensemble()
ens_data = EnsembleData()
ens_data.NumBeams = 4
ens_data.NumBins = 4
ens.AddEnsembleData(ens_data)
anc = AncillaryData()
anc.BinSize = 1
anc.FirstBinRange = 0.5
ens.AddAncillaryData(anc)
vel = EarthVelocity(4, 4)
vel.Velocities[0][0] = 1.0
vel.Velocities[0][1] = 1.1
vel.Velocities[0][2] = 0.2
vel.Velocities[0][3] = 0.0
vel.Velocities[1][0] = 1.1
vel.Velocities[1][1] = 1.2
vel.Velocities[1][2] = 0.3
vel.Velocities[1][3] = 0.0
vel.Velocities[2][0] = 1.2
vel.Velocities[2][1] = 1.3
vel.Velocities[2][2] = 0.4
vel.Velocities[2][3] = 0.0
vel.Velocities[3][0] = 1.4
vel.Velocities[3][1] = 1.5
vel.Velocities[3][2] = 0.6
vel.Velocities[3][3] = 0.0
ens.AddEarthVelocity(vel)
bt = BottomTrack()
bt.NumBeams = 4
bt.Range = [23.5, 24.2, 22.4, 26.1]
ens.AddBottomTrack(bt)
discharge = CalcDischarge()
boat_draft = 0.1
beam_angle = 20
pulse_length = 0.8
pulse_lag = 0.1
bt_east = 0.9
bt_north = 0.9
bt_vert = 0.1
delta_time = 0.15
top_flow_mode = FlowMode.Constants
top_pwr_func_exponent = CalcDischarge.ONE_SIXTH_POWER_LAW
bottom_flow_mode = FlowMode.PowerFunction
result = discharge.calculate_ensemble_flow(ens, boat_draft, beam_angle,
pulse_length, pulse_lag,
bt_east, bt_north, bt_vert,
delta_time, top_flow_mode,
top_pwr_func_exponent,
bottom_flow_mode)
assert result.valid == True
assert -0.2284 == pytest.approx(result.bottom_flow, 0.001)
assert -0.00135 == pytest.approx(result.top_flow, 0.001)
assert -0.054 == pytest.approx(result.measured_flow, 0.001)
