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)
Beispiel #2
0
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
Beispiel #3
0
    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 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)
Beispiel #5
0
    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)
Beispiel #6
0
    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)