mirror of
https://github.com/gnss-sdr/gnss-sdr
synced 2024-06-17 18:49:57 +00:00
![Carles Fernandez](/assets/img/avatar_default.png)
GNSS-SDR.internal_fs_sps The old name was misleading, since the units are samples per second and not Hertz. Backward compatibility is kept, so this change does not break any existing configuration.
158 lines
5.7 KiB
C++
158 lines
5.7 KiB
C++
/*!
|
|
* \file galileo_e1_dll_pll_veml_tracking_test.cc
|
|
* \brief This class implements a tracking test for Galileo_E5a_DLL_PLL_Tracking
|
|
* implementation based on some input parameters.
|
|
* \author Marc Sales, 2014. marcsales92(at)gmail.com
|
|
*
|
|
*
|
|
* -------------------------------------------------------------------------
|
|
*
|
|
* Copyright (C) 2012-2015 (see AUTHORS file for a list of contributors)
|
|
*
|
|
* GNSS-SDR is a software defined Global Navigation
|
|
* Satellite Systems receiver
|
|
*
|
|
* This file is part of GNSS-SDR.
|
|
*
|
|
* GNSS-SDR is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* GNSS-SDR is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
* -------------------------------------------------------------------------
|
|
*/
|
|
|
|
|
|
#include <chrono>
|
|
#include <iostream>
|
|
#include <gnuradio/top_block.h>
|
|
#include <gnuradio/blocks/file_source.h>
|
|
#include <gnuradio/analog/sig_source_waveform.h>
|
|
#include <gnuradio/analog/sig_source_c.h>
|
|
#include <gnuradio/msg_queue.h>
|
|
#include <gnuradio/blocks/null_sink.h>
|
|
#include <gnuradio/blocks/skiphead.h>
|
|
#include "gnss_block_factory.h"
|
|
#include "gnss_block_interface.h"
|
|
#include "in_memory_configuration.h"
|
|
#include "gnss_sdr_valve.h"
|
|
#include "gnss_synchro.h"
|
|
#include "galileo_e5a_dll_pll_tracking.h"
|
|
|
|
|
|
class GalileoE5aTrackingTest: public ::testing::Test
|
|
{
|
|
protected:
|
|
GalileoE5aTrackingTest()
|
|
{
|
|
factory = std::make_shared<GNSSBlockFactory>();
|
|
config = std::make_shared<InMemoryConfiguration>();
|
|
item_size = sizeof(gr_complex);
|
|
stop = false;
|
|
message = 0;
|
|
gnss_synchro = Gnss_Synchro();
|
|
}
|
|
|
|
~GalileoE5aTrackingTest()
|
|
{}
|
|
|
|
void init();
|
|
|
|
gr::msg_queue::sptr queue;
|
|
gr::top_block_sptr top_block;
|
|
std::shared_ptr<GNSSBlockFactory> factory;
|
|
std::shared_ptr<InMemoryConfiguration> config;
|
|
Gnss_Synchro gnss_synchro;
|
|
size_t item_size;
|
|
bool stop;
|
|
int message;
|
|
};
|
|
|
|
|
|
void GalileoE5aTrackingTest::init()
|
|
{
|
|
gnss_synchro.Channel_ID = 0;
|
|
gnss_synchro.System = 'E';
|
|
std::string signal = "5Q";
|
|
signal.copy(gnss_synchro.Signal, 2, 0);
|
|
gnss_synchro.PRN = 11;
|
|
|
|
config->set_property("GNSS-SDR.internal_fs_sps", "32000000");
|
|
config->set_property("Tracking_Galileo.item_type", "gr_complex");
|
|
config->set_property("Tracking_Galileo.dump", "false");
|
|
config->set_property("Tracking_Galileo.dump_filename", "../data/e5a_tracking_ch_");
|
|
config->set_property("Tracking_Galileo.implementation", "Galileo_E5a_DLL_PLL_Tracking");
|
|
config->set_property("Tracking_Galileo.early_late_space_chips", "0.5");
|
|
config->set_property("Tracking_Galileo.order", "2");
|
|
config->set_property("Tracking_Galileo.pll_bw_hz_init","20.0");
|
|
config->set_property("Tracking_Galileo.pll_bw_hz", "5");
|
|
config->set_property("Tracking_Galileo.dll_bw_hz_init","2.0");
|
|
config->set_property("Tracking_Galileo.dll_bw_hz", "2");
|
|
config->set_property("Tracking_Galileo.ti_ms", "1");
|
|
}
|
|
|
|
|
|
TEST_F(GalileoE5aTrackingTest, ValidationOfResults)
|
|
{
|
|
std::chrono::time_point<std::chrono::system_clock> start, end;
|
|
std::chrono::duration<double> elapsed_seconds(0);
|
|
int fs_in = 32000000;
|
|
int nsamples = 32000000*5;
|
|
init();
|
|
queue = gr::msg_queue::make(0);
|
|
top_block = gr::make_top_block("Tracking test");
|
|
|
|
// Example using smart pointers and the block factory
|
|
std::shared_ptr<GNSSBlockInterface> trk_ = factory->GetBlock(config, "Tracking", "Galileo_E5a_DLL_PLL_Tracking", 1, 1);
|
|
std::shared_ptr<TrackingInterface> tracking = std::dynamic_pointer_cast<TrackingInterface>(trk_);
|
|
|
|
//REAL
|
|
gnss_synchro.Acq_delay_samples = 10; // 32 Msps
|
|
// gnss_synchro.Acq_doppler_hz = 3500; // 32 Msps
|
|
gnss_synchro.Acq_doppler_hz = 2000; // 500 Hz resolution
|
|
// gnss_synchro.Acq_samplestamp_samples = 98000;
|
|
gnss_synchro.Acq_samplestamp_samples = 0;
|
|
|
|
ASSERT_NO_THROW( {
|
|
tracking->set_channel(gnss_synchro.Channel_ID);
|
|
}) << "Failure setting channel." << std::endl;
|
|
|
|
ASSERT_NO_THROW( {
|
|
tracking->set_gnss_synchro(&gnss_synchro);
|
|
}) << "Failure setting gnss_synchro." << std::endl;
|
|
|
|
ASSERT_NO_THROW( {
|
|
tracking->connect(top_block);
|
|
}) << "Failure connecting tracking to the top_block." << std::endl;
|
|
|
|
ASSERT_NO_THROW( {
|
|
gr::analog::sig_source_c::sptr source = gr::analog::sig_source_c::make(fs_in, gr::analog::GR_SIN_WAVE, 1000, 1, gr_complex(0));
|
|
boost::shared_ptr<gr::block> valve = gnss_sdr_make_valve(sizeof(gr_complex), nsamples, queue);
|
|
gr::blocks::null_sink::sptr sink = gr::blocks::null_sink::make(sizeof(Gnss_Synchro));
|
|
top_block->connect(source, 0, valve, 0);
|
|
top_block->connect(valve, 0, tracking->get_left_block(), 0);
|
|
top_block->connect(tracking->get_right_block(), 0, sink, 0);
|
|
|
|
}) << "Failure connecting the blocks of tracking test." << std::endl;
|
|
|
|
tracking->start_tracking();
|
|
|
|
EXPECT_NO_THROW( {
|
|
start = std::chrono::system_clock::now();
|
|
top_block->run(); // Start threads and wait
|
|
end = std::chrono::system_clock::now();
|
|
elapsed_seconds = end - start;
|
|
}) << "Failure running the top_block." << std::endl;
|
|
|
|
std::cout << "Tracked " << nsamples << " samples in " << elapsed_seconds.count() * 1e6 << " microseconds" << std::endl;
|
|
}
|
|
|