mirrors/gnss-sdr
1
0
Fork 0
mirror of https://github.com/gnss-sdr/gnss-sdr synced 2025-01-18 21:23:02 +00:00
Code Issues Releases Wiki Activity

used clang-format

Browse Source
This commit is contained in:
Marc Majoral 2019-12-30 18:43:46 +01:00
parent 9bfe37877e
commit 1d5ff14619
4 changed files with 546 additions and 623 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
src/tests/unit-tests/signal-processing-blocks/acquisition/galileo_e1_pcps_ambiguous_acquisition_test_fpga.cc
View File

@ -44,12 +44,12 @@
#include "in_memory_configuration.h"
#include "test_flags.h"
#include <boost/make_shared.hpp>
#include <cmath> // for abs, pow, floor
#include <glog/logging.h>
#include <gtest/gtest.h>
#include <pmt/pmt.h>
#include <pthread.h>
#include <chrono>
#include <cmath> // for abs, pow, floor
#include <pthread.h>
#include <utility>
#ifdef GR_GREATER_38
@ -98,7 +98,6 @@ public:
static constexpr float DMA_SIGNAL_SCALING_FACTOR = (pow(2, DMA_BITS_PER_SAMPLE - 1) - 1) / MAX_SAMPLE_VALUE;
protected:
GalileoE1PcpsAmbiguousAcquisitionTestFpga();
~GalileoE1PcpsAmbiguousAcquisitionTestFpga() = default;
@ -109,14 +108,11 @@ protected:
unsigned int doppler_max;
unsigned int doppler_step;
unsigned int nsamples_to_transfer;
};
GalileoE1PcpsAmbiguousAcquisitionTestFpga::GalileoE1PcpsAmbiguousAcquisitionTestFpga()
{
config = std::make_shared<InMemoryConfiguration>();
doppler_max = 5000;
@ -149,7 +145,7 @@ void* handler_DMA_galileo_e1_pcps_ambiguous_acq_test(void* arguments)
{
infile.open(Filename, std::ios::binary);
}
catch (const std::ifstream::failure &e)
catch (const std::ifstream::failure& e)
{
std::cerr << "Exception opening file " << Filename << std::endl;
return nullptr;
@ -177,7 +173,7 @@ void* handler_DMA_galileo_e1_pcps_ambiguous_acq_test(void* arguments)
{
infile.ignore((skip_samples + skip_used_samples) * 2);
}
catch (const std::ifstream::failure &e)
catch (const std::ifstream::failure& e)
{
std::cerr << "Exception reading file " << Filename << std::endl;
}
@ -202,25 +198,23 @@ void* handler_DMA_galileo_e1_pcps_ambiguous_acq_test(void* arguments)
try
{
// 2 bytes per complex sample
infile.read(reinterpret_cast<char *>(input_samples.data()), nsamples_block_size * 2 * sizeof(float));
infile.read(reinterpret_cast<char*>(input_samples.data()), nsamples_block_size * 2 * sizeof(float));
}
catch (const std::ifstream::failure &e)
catch (const std::ifstream::failure& e)
{
std::cerr << "Exception reading file " << Filename << std::endl;
}
for (int index0 = 0; index0 < (nsamples_block_size * 2); index0 += 2)
{
// channel 1 (queue 1) -> E5/L5
input_samples_dma[dma_index] = static_cast<int8_t>(input_samples[index0]*args->scaling_factor);
input_samples_dma[dma_index + 1] = static_cast<int8_t>(input_samples[index0 + 1]*args->scaling_factor);
input_samples_dma[dma_index] = static_cast<int8_t>(input_samples[index0] * args->scaling_factor);
input_samples_dma[dma_index + 1] = static_cast<int8_t>(input_samples[index0 + 1] * args->scaling_factor);
// channel 0 (queue 0) -> E1/L1
input_samples_dma[dma_index + 2] = 0;
input_samples_dma[dma_index + 3] = 0;
dma_index += 4;
}
if (write(tx_fd, input_samples_dma.data(), nsamples_block_size * 2 * 2) != nsamples_block_size * 2 * 2)
@ -238,14 +232,13 @@ void* handler_DMA_galileo_e1_pcps_ambiguous_acq_test(void* arguments)
{
file_completed = true;
}
}
try
{
infile.close();
}
catch (const std::ifstream::failure &e)
catch (const std::ifstream::failure& e)
{
std::cerr << "Exception closing files " << Filename << std::endl;
}
@ -254,7 +247,7 @@ void* handler_DMA_galileo_e1_pcps_ambiguous_acq_test(void* arguments)
{
close(tx_fd);
}
catch (const std::ifstream::failure &e)
catch (const std::ifstream::failure& e)
{
std::cerr << "Exception closing loop device " << std::endl;
}
@ -263,7 +256,6 @@ void* handler_DMA_galileo_e1_pcps_ambiguous_acq_test(void* arguments)
}
void* handler_acquisition_galileo_e1_pcps_ambiguous_acq_test(void* arguments)
{
// the acquisition is a blocking function so we have to
@ -283,10 +275,9 @@ void* handler_acquisition_galileo_e1_pcps_ambiguous_acq_test(void* arguments)
// of the channel state machine are modified here, in order to
// simplify the instantiation of the acquisition class in the
// unit test.
class ChannelFsm_galileo_e1_pcps_ambiguous_acq_test: public ChannelFsm
class ChannelFsm_galileo_e1_pcps_ambiguous_acq_test : public ChannelFsm
{
public:
bool Event_valid_acquisition() override
{
acquisition_successful = true;
@ -318,16 +309,12 @@ public:
}
private:
bool acquisition_successful;
};
bool GalileoE1PcpsAmbiguousAcquisitionTestFpga::acquire_signal()
{
pthread_t thread_DMA, thread_acquisition;
// 1. Setup GNU Radio flowgraph (file_source -> Acquisition_10m)
@ -477,6 +464,4 @@ TEST_F(GalileoE1PcpsAmbiguousAcquisitionTestFpga, ValidationOfResults)
EXPECT_LE(doppler_error_hz, 666) << "Doppler error exceeds the expected value: 666 Hz = 2/(3*integration period)";
EXPECT_LT(delay_error_chips, 0.5) << "Delay error exceeds the expected value: 0.5 chips";
}

35
src/tests/unit-tests/signal-processing-blocks/acquisition/gps_l1_ca_pcps_acquisition_test_fpga.cc
View File

@ -43,10 +43,10 @@
#include "in_memory_configuration.h"
#include "test_flags.h"
#include <boost/make_shared.hpp>
#include <cmath> // for abs, pow, floor
#include <glog/logging.h>
#include <gtest/gtest.h>
#include <chrono>
#include <cmath> // for abs, pow, floor
#include <pthread.h>
#include <utility>
@ -96,7 +96,6 @@ public:
static constexpr float DMA_SIGNAL_SCALING_FACTOR = (pow(2, DMA_BITS_PER_SAMPLE - 1) - 1) / MAX_SAMPLE_VALUE;
protected:
GpsL1CaPcpsAcquisitionTestFpga();
~GpsL1CaPcpsAcquisitionTestFpga() = default;
@ -107,14 +106,11 @@ protected:
unsigned int doppler_max;
unsigned int doppler_step;
unsigned int nsamples_to_transfer;
};
GpsL1CaPcpsAcquisitionTestFpga::GpsL1CaPcpsAcquisitionTestFpga()
{
config = std::make_shared<InMemoryConfiguration>();
doppler_max = 5000;
@ -147,7 +143,7 @@ void* handler_DMA_gps_l1_acq_test(void* arguments)
{
infile.open(Filename, std::ios::binary);
}
catch (const std::ifstream::failure &e)
catch (const std::ifstream::failure& e)
{
std::cerr << "Exception opening file " << Filename << std::endl;
return nullptr;
@ -175,7 +171,7 @@ void* handler_DMA_gps_l1_acq_test(void* arguments)
{
infile.ignore((skip_samples + skip_used_samples) * 2);
}
catch (const std::ifstream::failure &e)
catch (const std::ifstream::failure& e)
{
std::cerr << "Exception reading file " << Filename << std::endl;
}
@ -200,25 +196,23 @@ void* handler_DMA_gps_l1_acq_test(void* arguments)
try
{
// 2 bytes per complex sample
infile.read(reinterpret_cast<char *>(input_samples.data()), nsamples_block_size * 2 * sizeof(float));
infile.read(reinterpret_cast<char*>(input_samples.data()), nsamples_block_size * 2 * sizeof(float));
}
catch (const std::ifstream::failure &e)
catch (const std::ifstream::failure& e)
{
std::cerr << "Exception reading file " << Filename << std::endl;
}
for (int index0 = 0; index0 < (nsamples_block_size * 2); index0 += 2)
{
// channel 1 (queue 1) -> E5/L5
input_samples_dma[dma_index] = static_cast<int8_t>(input_samples[index0]*args->scaling_factor);
input_samples_dma[dma_index + 1] = static_cast<int8_t>(input_samples[index0 + 1]*args->scaling_factor);
input_samples_dma[dma_index] = static_cast<int8_t>(input_samples[index0] * args->scaling_factor);
input_samples_dma[dma_index + 1] = static_cast<int8_t>(input_samples[index0 + 1] * args->scaling_factor);
// channel 0 (queue 0) -> E1/L1
input_samples_dma[dma_index + 2] = 0;
input_samples_dma[dma_index + 3] = 0;
dma_index += 4;
}
if (write(tx_fd, input_samples_dma.data(), nsamples_block_size * 2 * 2) != nsamples_block_size * 2 * 2)
@ -236,14 +230,13 @@ void* handler_DMA_gps_l1_acq_test(void* arguments)
{
file_completed = true;
}
}
try
{
infile.close();
}
catch (const std::ifstream::failure &e)
catch (const std::ifstream::failure& e)
{
std::cerr << "Exception closing files " << Filename << std::endl;
}
@ -252,7 +245,7 @@ void* handler_DMA_gps_l1_acq_test(void* arguments)
{
close(tx_fd);
}
catch (const std::ifstream::failure &e)
catch (const std::ifstream::failure& e)
{
std::cerr << "Exception closing loop device " << std::endl;
}
@ -261,7 +254,6 @@ void* handler_DMA_gps_l1_acq_test(void* arguments)
}
void* handler_acquisition_gps_l1_acq_test(void* arguments)
{
// the acquisition is a blocking function so we have to
@ -281,10 +273,9 @@ void* handler_acquisition_gps_l1_acq_test(void* arguments)
// of the channel state machine are modified here, in order to
// simplify the instantiation of the acquisition class in the
// unit test.
class ChannelFsm_gps_l1_acq_test: public ChannelFsm
class ChannelFsm_gps_l1_acq_test : public ChannelFsm
{
public:
bool Event_valid_acquisition() override
{
acquisition_successful = true;
@ -316,16 +307,12 @@ public:
}
private:
bool acquisition_successful;
};
bool GpsL1CaPcpsAcquisitionTestFpga::acquire_signal()
{
pthread_t thread_DMA, thread_acquisition;
// 1. Setup GNU Radio flowgraph (file_source -> Acquisition_10m)
@ -475,6 +462,4 @@ TEST_F(GpsL1CaPcpsAcquisitionTestFpga, ValidationOfResults)
EXPECT_LE(doppler_error_hz, 666) << "Doppler error exceeds the expected value: 666 Hz = 2/(3*integration period)";
EXPECT_LT(delay_error_chips, 0.5) << "Delay error exceeds the expected value: 0.5 chips";
}

47
src/tests/unit-tests/signal-processing-blocks/observables/hybrid_observables_test_fpga.cc
View File

@ -272,7 +272,6 @@ public:
static const int32_t TEST_OBS_SKIP_SAMPLES = 1024;
static constexpr float DMA_SIGNAL_SCALING_FACTOR = 8.0;
};
int HybridObservablesTestFpga::configure_generator()
@ -369,7 +368,7 @@ void* handler_DMA_obs_test(void* arguments)
{
infile.open(Filename, std::ios::binary);
}
catch (const std::ifstream::failure &e)
catch (const std::ifstream::failure& e)
{
std::cerr << "Exception opening file " << Filename << std::endl;
return nullptr;
@ -397,7 +396,7 @@ void* handler_DMA_obs_test(void* arguments)
{
infile.ignore((skip_samples + skip_used_samples) * 2);
}
catch (const std::ifstream::failure &e)
catch (const std::ifstream::failure& e)
{
std::cerr << "Exception reading file " << Filename << std::endl;
}
@ -422,42 +421,39 @@ void* handler_DMA_obs_test(void* arguments)
try
{
// 2 bytes per complex sample
infile.read(reinterpret_cast<char *>(input_samples.data()), nsamples_block_size * 2);
infile.read(reinterpret_cast<char*>(input_samples.data()), nsamples_block_size * 2);
}
catch (const std::ifstream::failure &e)
catch (const std::ifstream::failure& e)
{
std::cerr << "Exception reading file " << Filename << std::endl;
}
for (int index0 = 0; index0 < (nsamples_block_size * 2); index0 += 2)
{
if (args->freq_band == 0)
{
// channel 1 (queue 1) -> E5/L5
input_samples_dma[dma_index] = 0;
input_samples_dma[dma_index + 1] = 0;
// channel 0 (queue 0) -> E1/L1
input_samples_dma[dma_index + 2] = static_cast<int8_t>(input_samples[index0]*args->scaling_factor);
input_samples_dma[dma_index + 3] = static_cast<int8_t>(input_samples[index0 + 1]*args->scaling_factor);
input_samples_dma[dma_index + 2] = static_cast<int8_t>(input_samples[index0] * args->scaling_factor);
input_samples_dma[dma_index + 3] = static_cast<int8_t>(input_samples[index0 + 1] * args->scaling_factor);
}
else
{
// channel 1 (queue 1) -> E5/L5
input_samples_dma[dma_index] = static_cast<int8_t>(input_samples[index0]*args->scaling_factor);
input_samples_dma[dma_index + 1] = static_cast<int8_t>(input_samples[index0 + 1]*args->scaling_factor);
input_samples_dma[dma_index] = static_cast<int8_t>(input_samples[index0] * args->scaling_factor);
input_samples_dma[dma_index + 1] = static_cast<int8_t>(input_samples[index0 + 1] * args->scaling_factor);
// channel 0 (queue 0) -> E1/L1
input_samples_dma[dma_index + 2] = 0;
input_samples_dma[dma_index + 3] = 0;
}
dma_index += 4;
}
//std::cout << "DMA: sending nsamples_block_size = " << nsamples_block_size << " samples" << std::endl;
if (write(tx_fd, input_samples_dma.data(), (int) (nsamples_block_size * 4)) != (int) (nsamples_block_size * 4))
if (write(tx_fd, input_samples_dma.data(), (int)(nsamples_block_size * 4)) != (int)(nsamples_block_size * 4))
{
std::cerr << "Error: DMA could not send all the required samples " << std::endl;
}
@ -472,14 +468,13 @@ void* handler_DMA_obs_test(void* arguments)
{
file_completed = true;
}
}
try
{
infile.close();
}
catch (const std::ifstream::failure &e)
catch (const std::ifstream::failure& e)
{
std::cerr << "Exception closing files " << Filename << std::endl;
}
@ -488,7 +483,7 @@ void* handler_DMA_obs_test(void* arguments)
{
close(tx_fd);
}
catch (const std::ifstream::failure &e)
catch (const std::ifstream::failure& e)
{
std::cerr << "Exception closing loop device " << std::endl;
}
@ -497,10 +492,6 @@ void* handler_DMA_obs_test(void* arguments)
}
// When using the FPGA the acquisition class calls the states
// of the channel finite state machine directly. This is done
// in order to reduce the latency of the receiver when going
@ -510,10 +501,9 @@ void* handler_DMA_obs_test(void* arguments)
// of the channel state machine are modified here, in order to
// simplify the instantiation of the acquisition class in the
// unit test.
class ChannelFsm_obs_test: public ChannelFsm
class ChannelFsm_obs_test : public ChannelFsm
{
public:
bool Event_valid_acquisition() override
{
acquisition_successful = true;
@ -545,14 +535,11 @@ public:
}
private:
bool acquisition_successful;
};
bool HybridObservablesTestFpga::acquire_signal()
{
pthread_t thread_DMA, thread_acquisition;
// 1. Setup GNU Radio flowgraph (file_source -> Acquisition_10m)
@ -597,7 +584,6 @@ bool HybridObservablesTestFpga::acquire_signal()
acquisition = std::make_shared<GpsL1CaPcpsAcquisitionFpga>(config.get(), "Acquisition", 0, 0);
args.freq_band = 0; // frequency band on which the DMA has to transfer the samples
}
else if (implementation == "Galileo_E1_DLL_PLL_VEML_Tracking_Fpga")
{
@ -610,7 +596,6 @@ bool HybridObservablesTestFpga::acquire_signal()
acquisition = std::make_shared<GalileoE1PcpsAmbiguousAcquisitionFpga>(config.get(), "Acquisition", 0, 0);
args.freq_band = 0; // frequency band on which the DMA has to transfer the samples
}
else if (implementation == "Galileo_E5a_DLL_PLL_Tracking_Fpga")
{
@ -623,7 +608,6 @@ bool HybridObservablesTestFpga::acquire_signal()
acquisition = std::make_shared<GalileoE5aPcpsAcquisitionFpga>(config.get(), "Acquisition", 0, 0);
args.freq_band = 1; // frequency band on which the DMA has to transfer the samples
}
else if (implementation == "GPS_L5_DLL_PLL_Tracking_Fpga")
{
@ -636,7 +620,6 @@ bool HybridObservablesTestFpga::acquire_signal()
acquisition = std::make_shared<GpsL5iPcpsAcquisitionFpga>(config.get(), "Acquisition", 0, 0);
args.freq_band = 1; // frequency band on which the DMA has to transfer the samples
}
else
{
@ -696,7 +679,6 @@ bool HybridObservablesTestFpga::acquire_signal()
for (unsigned int PRN = 1; PRN < MAX_PRN_IDX; PRN++)
{
tmp_gnss_synchro.PRN = PRN;
channel_fsm_->Event_clear_test_result();
@ -774,7 +756,6 @@ bool HybridObservablesTestFpga::acquire_signal()
}
std::cout.flush();
}
std::cout << "]" << std::endl;
@ -1976,7 +1957,6 @@ TEST_F(HybridObservablesTestFpga, ValidationOfResults)
std::string file;
ASSERT_NO_THROW({
if (!FLAGS_enable_external_signal_file)
{
file = "./" + filename_raw_data;
@ -2100,7 +2080,6 @@ TEST_F(HybridObservablesTestFpga, ValidationOfResults)
}
else
{
if (!FLAGS_duplicated_satellites_test)
{
ASSERT_EQ(ReadRinexObs(&true_obs_vec, gnss_synchro_master), true)
@ -2109,7 +2088,6 @@ TEST_F(HybridObservablesTestFpga, ValidationOfResults)
}
// read measured values
Observables_Dump_Reader estimated_observables(tracking_ch_vec.size());
ASSERT_NO_THROW({
@ -2377,6 +2355,5 @@ TEST_F(HybridObservablesTestFpga, ValidationOfResults)
}
std::cout << "Test completed in " << elapsed_seconds.count() << " [s]" << std::endl;
}

50
src/tests/unit-tests/signal-processing-blocks/tracking/tracking_pull-in_test_fpga.cc
View File

@ -9,6 +9,7 @@
*
*
* -------------------------------------------------------------------------
*
* Copyright (C) 2012-2019 (see AUTHORS file for a list of contributors)
*
* GNSS-SDR is a software defined Global Navigation
@ -61,9 +62,9 @@
#include <gnuradio/top_block.h>
#include <gtest/gtest.h>
#include <pmt/pmt.h>
#include <pthread.h>
#include <chrono>
#include <cstdint>
#include <pthread.h>
#include <utility>
#include <vector>
@ -187,7 +188,7 @@ void* handler_DMA_trk_pull_in_test(void* arguments)
{
infile.open(Filename, std::ios::binary);
}
catch (const std::ifstream::failure &e)
catch (const std::ifstream::failure& e)
{
std::cerr << "Exception opening file " << Filename << std::endl;
return nullptr;
@ -215,7 +216,7 @@ void* handler_DMA_trk_pull_in_test(void* arguments)
{
infile.ignore((skip_samples + skip_used_samples) * 2);
}
catch (const std::ifstream::failure &e)
catch (const std::ifstream::failure& e)
{
std::cerr << "Exception reading file " << Filename << std::endl;
}
@ -240,41 +241,35 @@ void* handler_DMA_trk_pull_in_test(void* arguments)
try
{
// 2 bytes per complex sample
infile.read(reinterpret_cast<char *>(input_samples.data()), nsamples_block_size * 2);
infile.read(reinterpret_cast<char*>(input_samples.data()), nsamples_block_size * 2);
}
catch (const std::ifstream::failure &e)
catch (const std::ifstream::failure& e)
{
std::cerr << "Exception reading file " << Filename << std::endl;
}
for (int index0 = 0; index0 < (nsamples_block_size * 2); index0 += 2)
{
if (args->freq_band == 0)
{
// channel 1 (queue 1) -> E5/L5
input_samples_dma[dma_index] = 0;
input_samples_dma[dma_index + 1] = 0;
// channel 0 (queue 0) -> E1/L1
// input_samples_dma[dma_index + 2] = input_samples[index0];
// input_samples_dma[dma_index + 3] = input_samples[index0 + 1];
input_samples_dma[dma_index + 2] = static_cast<int8_t>(input_samples[index0]*args->scaling_factor);
input_samples_dma[dma_index + 3] = static_cast<int8_t>(input_samples[index0 + 1]*args->scaling_factor);
input_samples_dma[dma_index + 2] = static_cast<int8_t>(input_samples[index0] * args->scaling_factor);
input_samples_dma[dma_index + 3] = static_cast<int8_t>(input_samples[index0 + 1] * args->scaling_factor);
}
else
{
// channel 1 (queue 1) -> E5/L5
// input_samples_dma[dma_index] = input_samples[index0];
// input_samples_dma[dma_index + 1] = input_samples[index0 + 1];
input_samples_dma[dma_index] = static_cast<int8_t>(input_samples[index0]*args->scaling_factor);
input_samples_dma[dma_index + 1] = static_cast<int8_t>(input_samples[index0 + 1]*args->scaling_factor);
input_samples_dma[dma_index] = static_cast<int8_t>(input_samples[index0] * args->scaling_factor);
input_samples_dma[dma_index + 1] = static_cast<int8_t>(input_samples[index0 + 1] * args->scaling_factor);
// channel 0 (queue 0) -> E1/L1
input_samples_dma[dma_index + 2] = 0;
input_samples_dma[dma_index + 3] = 0;
}
dma_index += 4;
}
if (write(tx_fd, input_samples_dma.data(), nsamples_block_size * 2 * 2) != nsamples_block_size * 2 * 2)
@ -292,14 +287,13 @@ void* handler_DMA_trk_pull_in_test(void* arguments)
{
file_completed = true;
}
}
try
{
infile.close();
}
catch (const std::ifstream::failure &e)
catch (const std::ifstream::failure& e)
{
std::cerr << "Exception closing files " << Filename << std::endl;
}
@ -308,7 +302,7 @@ void* handler_DMA_trk_pull_in_test(void* arguments)
{
close(tx_fd);
}
catch (const std::ifstream::failure &e)
catch (const std::ifstream::failure& e)
{
std::cerr << "Exception closing loop device " << std::endl;
}
@ -396,7 +390,6 @@ public:
static const int32_t TEST_TRK_PULL_IN_TEST_SKIP_SAMPLES = 1024; //48
static constexpr float DMA_SIGNAL_SCALING_FACTOR = 8.0;
};
int TrackingPullInTestFpga::configure_generator(double CN0_dBHz, int file_idx)
@ -454,10 +447,9 @@ int TrackingPullInTestFpga::generate_signal()
// of the channel state machine are modified here, in order to
// simplify the instantiation of the acquisition class in the
// unit test.
class ChannelFsm_trk_pull_in_test: public ChannelFsm
class ChannelFsm_trk_pull_in_test : public ChannelFsm
{
public:
bool Event_valid_acquisition() override
{
acquisition_successful = true;
@ -489,9 +481,7 @@ public:
}
private:
bool acquisition_successful;
};
void TrackingPullInTestFpga::configure_receiver(
@ -583,7 +573,6 @@ void TrackingPullInTestFpga::configure_receiver(
bool TrackingPullInTestFpga::acquire_signal(int SV_ID)
{
pthread_t thread_DMA, thread_acquisition;
// fsm
@ -625,7 +614,6 @@ bool TrackingPullInTestFpga::acquire_signal(int SV_ID)
acquisition = std::make_shared<GpsL1CaPcpsAcquisitionFpga>(config.get(), "Acquisition", 0, 0);
args.freq_band = 0; // frequency band on which the DMA has to transfer the samples
}
else if (implementation == "Galileo_E1_DLL_PLL_VEML_Tracking_Fpga")
{
@ -638,7 +626,6 @@ bool TrackingPullInTestFpga::acquire_signal(int SV_ID)
acquisition = std::make_shared<GalileoE1PcpsAmbiguousAcquisitionFpga>(config.get(), "Acquisition", 0, 0);
args.freq_band = 0; // frequency band on which the DMA has to transfer the samples
}
else if (implementation == "Galileo_E5a_DLL_PLL_Tracking_Fpga")
{
@ -651,7 +638,6 @@ bool TrackingPullInTestFpga::acquire_signal(int SV_ID)
acquisition = std::make_shared<GalileoE5aPcpsAcquisitionFpga>(config.get(), "Acquisition", 0, 0);
args.freq_band = 1; // frequency band on which the DMA has to transfer the samples
}
else if (implementation == "GPS_L5_DLL_PLL_Tracking_Fpga")
{
@ -664,7 +650,6 @@ bool TrackingPullInTestFpga::acquire_signal(int SV_ID)
acquisition = std::make_shared<GpsL5iPcpsAcquisitionFpga>(config.get(), "Acquisition", 0, 0);
args.freq_band = 1; // frequency band on which the DMA has to transfer the samples
}
else
{
@ -728,7 +713,6 @@ bool TrackingPullInTestFpga::acquire_signal(int SV_ID)
for (unsigned int PRN = 1; PRN < MAX_PRN_IDX; PRN++)
{
tmp_gnss_synchro.PRN = PRN;
channel_fsm_->Event_clear_test_result();
@ -810,7 +794,6 @@ bool TrackingPullInTestFpga::acquire_signal(int SV_ID)
}
std::cout.flush();
}
std::cout << "]" << std::endl;
@ -1010,7 +993,6 @@ TEST_F(TrackingPullInTestFpga, ValidationOfResults)
acquisition->stop_acquisition(); // reset the whole system including the sample counters
// create flowgraph
top_block = gr::make_top_block("Tracking test");
std::shared_ptr<GNSSBlockInterface> trk_ = factory->GetBlock(config, "Tracking", config->property("Tracking.implementation", std::string("undefined")), 1, 1);
@ -1043,8 +1025,6 @@ TEST_F(TrackingPullInTestFpga, ValidationOfResults)
gr::blocks::null_sink::sptr sink = gr::blocks::null_sink::make(sizeof(Gnss_Synchro));
top_block->connect(tracking->get_right_block(), 0, sink, 0);
top_block->msg_connect(tracking->get_right_block(), pmt::mp("events"), msg_rx, pmt::mp("events"));
}) << "Failure connecting the blocks of tracking test.";
@ -1057,7 +1037,6 @@ TEST_F(TrackingPullInTestFpga, ValidationOfResults)
std::chrono::time_point<std::chrono::system_clock> start, end;
top_block->start();
@ -1338,8 +1317,5 @@ TEST_F(TrackingPullInTestFpga, ValidationOfResults)
g4.savetops("trk_pull_in_grid_external_file");
g4.savetopdf("trk_pull_in_grid_external_file", 12);
}
}
}