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 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 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 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
