def test_encode_decode(): 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 ss.TransmitBoostNegVolt = 6.0 ss.WpBeamMux = 6.0 ss.Reserved = 6.0 ss.Reserved1 = 6.0 # Populate data result = ss.encode() # Encode ss1 = SystemSetup() ss1.decode(bytearray(result)) # Decode assert ss.BtSamplesPerSecond == pytest.approx(ss1.BtSamplesPerSecond, 0.1) assert ss.BtSystemFreqHz == pytest.approx(ss1.BtSystemFreqHz, 0.1) assert ss.BtCPCE == pytest.approx(ss1.BtCPCE, 0.1) assert ss.BtNCE == pytest.approx(ss1.BtNCE, 0.1) assert ss.BtRepeatN == pytest.approx(ss1.BtRepeatN, 0.1) assert ss.WpSamplesPerSecond == pytest.approx(ss1.WpSamplesPerSecond, 0.1) assert ss.WpSystemFreqHz == pytest.approx(ss1.WpSystemFreqHz, 0.1) assert ss.WpCPCE == pytest.approx(ss1.WpCPCE, 0.1) assert ss.WpNCE == pytest.approx(ss1.WpNCE, 0.1) assert ss.WpRepeatN == pytest.approx(ss1.WpRepeatN, 0.1) assert ss.WpLagSamples == pytest.approx(ss1.WpLagSamples, 0.1) assert ss.Voltage == pytest.approx(ss1.Voltage, 0.1) assert ss.XmtVoltage == pytest.approx(ss1.XmtVoltage, 0.1) assert ss.BtBroadband == pytest.approx(ss1.BtBroadband, 0.1) assert ss.BtLagLength == pytest.approx(ss1.BtLagLength, 0.1) assert ss.BtNarrowband == pytest.approx(ss1.BtNarrowband, 0.1) assert ss.BtBeamMux == pytest.approx(ss1.BtBeamMux, 0.1) assert ss.WpBroadband == pytest.approx(ss1.WpBroadband, 0.1) assert ss.WpLagLength == pytest.approx(ss1.WpLagLength, 0.1) assert ss.WpTransmitBandwidth == pytest.approx(ss1.WpTransmitBandwidth, 0.1) assert ss.WpReceiveBandwidth == pytest.approx(ss1.WpReceiveBandwidth, 0.1) assert ss.TransmitBoostNegVolt == pytest.approx(ss1.TransmitBoostNegVolt, 0.1) assert ss.WpBeamMux == pytest.approx(ss1.WpBeamMux, 0.1) assert ss.Reserved == pytest.approx(ss1.Reserved, 0.1) assert ss.Reserved1 == pytest.approx(ss1.Reserved1, 0.1)
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