mirrors/gnss-sdr
1
0
Fork 0
mirror of https://github.com/gnss-sdr/gnss-sdr synced 2024-06-24 22:13:15 +00:00
Code Issues Releases Wiki Activity

Completing the migration to the new receiver channels and commands events queue. Fix unit test execution

Browse Source
This commit is contained in:
Javier Arribas 2019-07-18 19:29:14 +02:00
parent 5b1f541a74
commit 601230ce37
22 changed files with 84 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
src/core/receiver/gnss_flowgraph.cc
View File

@ -1245,25 +1245,25 @@ void GNSSFlowgraph::apply_action(unsigned int who, unsigned int what)
start_acquisition = true;
}
//todo: add configuration parameter to enable the mandatory acquisition assistance in secondary freq
if (start_acquisition == true)
{
channels_state_[ch_index] = 1;
acq_channels_count_++;
std::cout << "Channel " << ch_index << " Starting acquisition " << channels_[ch_index]->get_signal().get_satellite() << ", Signal " << channels_[ch_index]->get_signal().get_signal_str();
DLOG(INFO) << "Channel " << ch_index << " Starting acquisition " << channels_[ch_index]->get_signal().get_satellite() << ", Signal " << channels_[ch_index]->get_signal().get_signal_str();
// if (start_acquisition == true)
// {
channels_state_[ch_index] = 1;
acq_channels_count_++;
std::cout << "Channel " << ch_index << " Starting acquisition " << channels_[ch_index]->get_signal().get_satellite() << ", Signal " << channels_[ch_index]->get_signal().get_signal_str();
DLOG(INFO) << "Channel " << ch_index << " Starting acquisition " << channels_[ch_index]->get_signal().get_satellite() << ", Signal " << channels_[ch_index]->get_signal().get_signal_str();
#ifndef ENABLE_FPGA
channels_[ch_index]->start_acquisition();
channels_[ch_index]->start_acquisition();
#else
// create a task for the FPGA such that it doesn't stop the flow
std::thread tmp_thread(&ChannelInterface::start_acquisition, channels_[ch_index]);
tmp_thread.detach();
// create a task for the FPGA such that it doesn't stop the flow
std::thread tmp_thread(&ChannelInterface::start_acquisition, channels_[ch_index]);
tmp_thread.detach();
#endif
}
else
{
push_back_signal(gnss_signal);
DLOG(INFO) << "Channel " << ch_index << " secondary frequency acquisition assistance not available in " << channels_[ch_index]->get_signal().get_satellite() << ", Signal " << channels_[ch_index]->get_signal().get_signal_str();
}
// }
// else
// {
// push_back_signal(gnss_signal);
// DLOG(INFO) << "Channel " << ch_index << " secondary frequency acquisition assistance not available in " << channels_[ch_index]->get_signal().get_satellite() << ", Signal " << channels_[ch_index]->get_signal().get_signal_str();
// }
}
DLOG(INFO) << "Channel " << ch_index << " in state " << channels_state_[ch_index];
}
@ -1307,26 +1307,26 @@ void GNSSFlowgraph::apply_action(unsigned int who, unsigned int what)
}
//todo: add configuration parameter to enable the mandatory acquisition assistance in secondary freq
if (start_acquisition == true)
{
channels_state_[i] = 1;
acq_channels_count_++;
DLOG(INFO) << "Channel " << i << " Starting acquisition " << channels_[i]->get_signal().get_satellite() << ", Signal " << channels_[i]->get_signal().get_signal_str();
// if (start_acquisition == true)
// {
channels_state_[i] = 1;
acq_channels_count_++;
DLOG(INFO) << "Channel " << i << " Starting acquisition " << channels_[i]->get_signal().get_satellite() << ", Signal " << channels_[i]->get_signal().get_signal_str();
#ifndef ENABLE_FPGA
channels_[i]->start_acquisition();
channels_[i]->start_acquisition();
#else
// create a task for the FPGA such that it doesn't stop the flow
std::thread tmp_thread(&ChannelInterface::start_acquisition, channels_[i]);
tmp_thread.detach();
start_acquisition = is_primary_freq or assistance_available;
// create a task for the FPGA such that it doesn't stop the flow
std::thread tmp_thread(&ChannelInterface::start_acquisition, channels_[i]);
tmp_thread.detach();
start_acquisition = is_primary_freq or assistance_available;
#endif
}
else
{
push_back_signal(gnss_signal);
DLOG(INFO) << "Channel " << i << " secondary frequency acquisition assistance not available in " << channels_[i]->get_signal().get_satellite() << ", Signal " << channels_[i]->get_signal().get_signal_str();
std::cout << "Channel " << i << " secondary frequency acquisition assistance not available in " << channels_[i]->get_signal().get_satellite() << ", Signal " << channels_[i]->get_signal().get_signal_str();
}
// }
// else
// {
// push_back_signal(gnss_signal);
// DLOG(INFO) << "Channel " << i << " secondary frequency acquisition assistance not available in " << channels_[i]->get_signal().get_satellite() << ", Signal " << channels_[i]->get_signal().get_signal_str();
// std::cout << "Channel " << i << " secondary frequency acquisition assistance not available in " << channels_[i]->get_signal().get_satellite() << ", Signal " << channels_[i]->get_signal().get_signal_str()<<"\n";
// }
}
DLOG(INFO) << "Channel " << i << " in state " << channels_state_[i];
}

2
src/tests/unit-tests/signal-processing-blocks/acquisition/beidou_b1i_pcps_acquisition_test.cc
View File

@ -262,7 +262,7 @@ TEST_F(BeidouB1iPcpsAcquisitionTest, ConnectAndRun)
int nsamples = 25000;
std::chrono::time_point<std::chrono::system_clock> start, end;
std::chrono::duration<double> elapsed_seconds(0);
std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>();std::shared_ptr<Concurrent_Queue<pmt::pmt_t>>
std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>();
top_block = gr::make_top_block("Acquisition test");
init();

2
src/tests/unit-tests/signal-processing-blocks/acquisition/glonass_l2_ca_pcps_acquisition_test.cc
View File

@ -141,7 +141,7 @@ protected:
void process_message();
void stop_queue();
concurrent_queue<int> channel_internal_queue;
Concurrent_Queue<int> channel_internal_queue;
std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue;
gr::top_block_sptr top_block;

8
src/tests/unit-tests/signal-processing-blocks/acquisition/gps_l1_ca_pcps_acquisition_test.cc
View File

@ -31,14 +31,15 @@
*/
#include "gps_l1_ca_pcps_acquisition.h"
#include "GPS_L1_CA.h"
#include "acquisition_dump_reader.h"
#include "concurrent_queue.h"
#include "gnss_block_factory.h"
#include "gnss_block_interface.h"
#include "gnss_sdr_valve.h"
#include "gnss_synchro.h"
#include "gnuplot_i.h"
#include "gps_l1_ca_pcps_acquisition.h"
#include "in_memory_configuration.h"
#include "test_flags.h"
#include <boost/make_shared.hpp>
@ -46,7 +47,6 @@
#include <gnuradio/analog/sig_source_waveform.h>
#include <gnuradio/blocks/file_source.h>
#include <gnuradio/blocks/null_sink.h>
#include "concurrent_queue.h"
#include <gnuradio/top_block.h>
#include <gtest/gtest.h>
#include <chrono>
@ -199,7 +199,7 @@ void GpsL1CaPcpsAcquisitionTest::plot_grid()
std::vector<int> *doppler = &acq_dump.doppler;
std::vector<unsigned int> *samples = &acq_dump.samples;
std::vector<std::vector<float> > *mag = &acq_dump.mag;
std::vector<std::vector<float>> *mag = &acq_dump.mag;
const std::string gnuplot_executable(FLAGS_gnuplot_executable);
if (gnuplot_executable.empty())
@ -262,7 +262,7 @@ TEST_F(GpsL1CaPcpsAcquisitionTest, ConnectAndRun)
int nsamples = 4000;
std::chrono::time_point<std::chrono::system_clock> start, end;
std::chrono::duration<double> elapsed_seconds(0);
std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue = std::shared_ptr<Concurrent_Queue<pmt::pmt_t>>();
std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>();
top_block = gr::make_top_block("Acquisition test");
init();

6
src/tests/unit-tests/signal-processing-blocks/acquisition/gps_l1_ca_pcps_opencl_acquisition_gsoc2013_test.cc
View File

@ -31,13 +31,14 @@
*/
#include "gps_l1_ca_pcps_opencl_acquisition.h"
#include "concurrent_queue.h"
#include "configuration_interface.h"
#include "fir_filter.h"
#include "gen_signal_source.h"
#include "gnss_block_interface.h"
#include "gnss_sdr_valve.h"
#include "gnss_synchro.h"
#include "gps_l1_ca_pcps_opencl_acquisition.h"
#include "in_memory_configuration.h"
#include "signal_generator.h"
#include "signal_generator_c.h"
@ -45,7 +46,6 @@
#include <gnuradio/analog/sig_source_waveform.h>
#include <gnuradio/blocks/file_source.h>
#include <gnuradio/blocks/null_sink.h>
#include "concurrent_queue.h"
#include <gnuradio/top_block.h>
#include <chrono>
#include <thread>
@ -118,7 +118,7 @@ class GpsL1CaPcpsOpenClAcquisitionGSoC2013Test : public ::testing::Test
protected:
GpsL1CaPcpsOpenClAcquisitionGSoC2013Test()
{
queue = std::shared_ptr<Concurrent_Queue<pmt::pmt_t>>();
queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>();
top_block = gr::make_top_block("Acquisition test");
item_size = sizeof(gr_complex);
stop = false;

12
src/tests/unit-tests/signal-processing-blocks/acquisition/gps_l1_ca_pcps_quicksync_acquisition_gsoc2014_test.cc
View File

@ -31,11 +31,12 @@
*/
#include "gps_l1_ca_pcps_quicksync_acquisition.h"
#include "concurrent_queue.h"
#include "gnss_block_factory.h"
#include "gnss_block_interface.h"
#include "gnss_sdr_valve.h"
#include "gnss_synchro.h"
#include "gps_l1_ca_pcps_quicksync_acquisition.h"
#include "in_memory_configuration.h"
#include "signal_generator.h"
#include "signal_generator_c.h"
@ -43,7 +44,6 @@
#include <gnuradio/analog/sig_source_waveform.h>
#include <gnuradio/blocks/file_source.h>
#include <gnuradio/blocks/null_sink.h>
#include "concurrent_queue.h"
#include <gnuradio/top_block.h>
#include <gtest/gtest.h>
#include <chrono>
@ -545,7 +545,7 @@ TEST_F(GpsL1CaPcpsQuickSyncAcquisitionGSoC2014Test, ConnectAndRun)
std::chrono::time_point<std::chrono::system_clock> start, end;
std::chrono::duration<double> elapsed_seconds(0.0);
top_block = gr::make_top_block("Acquisition test");
queue = std::shared_ptr<Concurrent_Queue<pmt::pmt_t>>();
queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>();
boost::shared_ptr<GpsL1CaPcpsAcquisitionGSoC2013Test_msg_rx> msg_rx = GpsL1CaPcpsAcquisitionGSoC2013Test_msg_rx_make(channel_internal_queue);
config_1();
@ -575,7 +575,7 @@ TEST_F(GpsL1CaPcpsQuickSyncAcquisitionGSoC2014Test, ValidationOfResults)
{
config_1();
top_block = gr::make_top_block("Acquisition test");
queue = std::shared_ptr<Concurrent_Queue<pmt::pmt_t>>();
queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>();
acquisition = std::make_shared<GpsL1CaPcpsQuickSyncAcquisition>(config.get(), "Acquisition_1C", 1, 0);
boost::shared_ptr<GpsL1CaPcpsAcquisitionGSoC2013Test_msg_rx> msg_rx = GpsL1CaPcpsAcquisitionGSoC2013Test_msg_rx_make(channel_internal_queue);
@ -669,7 +669,7 @@ TEST_F(GpsL1CaPcpsQuickSyncAcquisitionGSoC2014Test, ValidationOfResultsWithNoise
//config_3();
config_1();
top_block = gr::make_top_block("Acquisition test");
queue = std::shared_ptr<Concurrent_Queue<pmt::pmt_t>>();
queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>();
acquisition = std::make_shared<GpsL1CaPcpsQuickSyncAcquisition>(config.get(), "Acquisition_1C", 1, 0);
boost::shared_ptr<GpsL1CaPcpsAcquisitionGSoC2013Test_msg_rx> msg_rx = GpsL1CaPcpsAcquisitionGSoC2013Test_msg_rx_make(channel_internal_queue);
@ -760,7 +760,7 @@ TEST_F(GpsL1CaPcpsQuickSyncAcquisitionGSoC2014Test, ValidationOfResultsProbabili
{
config_2();
top_block = gr::make_top_block("Acquisition test");
queue = std::shared_ptr<Concurrent_Queue<pmt::pmt_t>>();
queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>();
acquisition = std::make_shared<GpsL1CaPcpsQuickSyncAcquisition>(config.get(), "Acquisition_1C", 1, 0);
boost::shared_ptr<GpsL1CaPcpsAcquisitionGSoC2013Test_msg_rx> msg_rx = GpsL1CaPcpsAcquisitionGSoC2013Test_msg_rx_make(channel_internal_queue);

10
src/tests/unit-tests/signal-processing-blocks/acquisition/gps_l1_ca_pcps_tong_acquisition_gsoc2013_test.cc
View File

@ -31,13 +31,14 @@
*/
#include "gps_l1_ca_pcps_tong_acquisition.h"
#include "concurrent_queue.h"
#include "configuration_interface.h"
#include "fir_filter.h"
#include "gen_signal_source.h"
#include "gnss_block_interface.h"
#include "gnss_sdr_valve.h"
#include "gnss_synchro.h"
#include "gps_l1_ca_pcps_tong_acquisition.h"
#include "in_memory_configuration.h"
#include "signal_generator.h"
#include "signal_generator_c.h"
@ -45,7 +46,6 @@
#include <gnuradio/analog/sig_source_waveform.h>
#include <gnuradio/blocks/file_source.h>
#include <gnuradio/blocks/null_sink.h>
#include "concurrent_queue.h"
#include <gnuradio/top_block.h>
#include <gtest/gtest.h>
#include <chrono>
@ -431,7 +431,7 @@ TEST_F(GpsL1CaPcpsTongAcquisitionGSoC2013Test, ConnectAndRun)
std::chrono::time_point<std::chrono::system_clock> start, end;
std::chrono::duration<double> elapsed_seconds(0);
top_block = gr::make_top_block("Acquisition test");
queue = std::shared_ptr<Concurrent_Queue<pmt::pmt_t>>();
queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>();
config_1();
acquisition = std::make_shared<GpsL1CaPcpsTongAcquisition>(config.get(), "Acquisition_1C", 1, 0);
@ -461,7 +461,7 @@ TEST_F(GpsL1CaPcpsTongAcquisitionGSoC2013Test, ValidationOfResults)
{
config_1();
top_block = gr::make_top_block("Acquisition test");
queue = std::shared_ptr<Concurrent_Queue<pmt::pmt_t>>();
queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>();
acquisition = std::make_shared<GpsL1CaPcpsTongAcquisition>(config.get(), "Acquisition_1C", 1, 0);
boost::shared_ptr<GpsL1CaPcpsTongAcquisitionGSoC2013Test_msg_rx> msg_rx = GpsL1CaPcpsTongAcquisitionGSoC2013Test_msg_rx_make(channel_internal_queue);
@ -550,7 +550,7 @@ TEST_F(GpsL1CaPcpsTongAcquisitionGSoC2013Test, ValidationOfResultsProbabilities)
{
config_2();
top_block = gr::make_top_block("Acquisition test");
queue = std::shared_ptr<Concurrent_Queue<pmt::pmt_t>>();
queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>();
acquisition = std::make_shared<GpsL1CaPcpsTongAcquisition>(config.get(), "Acquisition_1C", 1, 0);
boost::shared_ptr<GpsL1CaPcpsTongAcquisitionGSoC2013Test_msg_rx> msg_rx = GpsL1CaPcpsTongAcquisitionGSoC2013Test_msg_rx_make(channel_internal_queue);

12
src/tests/unit-tests/signal-processing-blocks/acquisition/gps_l2_m_pcps_acquisition_test.cc
View File

@ -31,14 +31,15 @@
*/
#include "gps_l2_m_pcps_acquisition.h"
#include "GPS_L2C.h"
#include "acquisition_dump_reader.h"
#include "concurrent_queue.h"
#include "gnss_block_factory.h"
#include "gnss_block_interface.h"
#include "gnss_sdr_valve.h"
#include "gnss_synchro.h"
#include "gnuplot_i.h"
#include "gps_l2_m_pcps_acquisition.h"
#include "in_memory_configuration.h"
#include "test_flags.h"
#include <boost/make_shared.hpp>
@ -47,7 +48,6 @@
#include <gnuradio/blocks/file_source.h>
#include <gnuradio/blocks/interleaved_short_to_complex.h>
#include <gnuradio/blocks/null_sink.h>
#include "concurrent_queue.h"
#include <gnuradio/top_block.h>
#include <gtest/gtest.h>
#include <chrono>
@ -202,7 +202,7 @@ void GpsL2MPcpsAcquisitionTest::plot_grid()
std::vector<int> *doppler = &acq_dump.doppler;
std::vector<unsigned int> *samples = &acq_dump.samples;
std::vector<std::vector<float> > *mag = &acq_dump.mag;
std::vector<std::vector<float>> *mag = &acq_dump.mag;
const std::string gnuplot_executable(FLAGS_gnuplot_executable);
if (gnuplot_executable.empty())
@ -255,7 +255,7 @@ void GpsL2MPcpsAcquisitionTest::plot_grid()
TEST_F(GpsL2MPcpsAcquisitionTest, Instantiate)
{
init();
queue = std::shared_ptr<Concurrent_Queue<pmt::pmt_t>>();
queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>();
std::shared_ptr<GpsL2MPcpsAcquisition> acquisition = std::make_shared<GpsL2MPcpsAcquisition>(config.get(), "Acquisition_2S", 1, 0);
}
@ -265,7 +265,7 @@ TEST_F(GpsL2MPcpsAcquisitionTest, ConnectAndRun)
std::chrono::time_point<std::chrono::system_clock> start, end;
std::chrono::duration<double> elapsed_seconds(0);
top_block = gr::make_top_block("Acquisition test");
queue = std::shared_ptr<Concurrent_Queue<pmt::pmt_t>>();
queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>();
init();
std::shared_ptr<GpsL2MPcpsAcquisition> acquisition = std::make_shared<GpsL2MPcpsAcquisition>(config.get(), "Acquisition_2S", 1, 0);
@ -295,7 +295,7 @@ TEST_F(GpsL2MPcpsAcquisitionTest, ValidationOfResults)
std::chrono::time_point<std::chrono::system_clock> start, end;
std::chrono::duration<double> elapsed_seconds(0);
top_block = gr::make_top_block("Acquisition test");
queue = std::shared_ptr<Concurrent_Queue<pmt::pmt_t>>();
queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>();
double expected_delay_samples = 1; //2004;
double expected_doppler_hz = 1200; //3000;

2
src/tests/unit-tests/signal-processing-blocks/filter/fir_filter_test.cc
View File

@ -59,7 +59,7 @@ class FirFilterTest : public ::testing::Test
protected:
FirFilterTest()
{
queue = std::shared_ptr<Concurrent_Queue<pmt::pmt_t>>();
queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>();
item_size = sizeof(gr_complex);
config = std::make_shared<InMemoryConfiguration>();
}

2
src/tests/unit-tests/signal-processing-blocks/filter/notch_filter_lite_test.cc
View File

@ -57,7 +57,7 @@ class NotchFilterLiteTest : public ::testing::Test
protected:
NotchFilterLiteTest()
{
queue = std::shared_ptr<Concurrent_Queue<pmt::pmt_t>>();
queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>();
item_size = sizeof(gr_complex);
config = std::make_shared<InMemoryConfiguration>();
nsamples = FLAGS_notch_filter_lite_test_nsamples;

2
src/tests/unit-tests/signal-processing-blocks/filter/notch_filter_test.cc
View File

@ -57,7 +57,7 @@ class NotchFilterTest : public ::testing::Test
protected:
NotchFilterTest()
{
queue = std::shared_ptr<Concurrent_Queue<pmt::pmt_t>>();
queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>();
item_size = sizeof(gr_complex);
config = std::make_shared<InMemoryConfiguration>();
nsamples = FLAGS_notch_filter_test_nsamples;

2
src/tests/unit-tests/signal-processing-blocks/filter/pulse_blanking_filter_test.cc
View File

@ -57,7 +57,7 @@ class PulseBlankingFilterTest : public ::testing::Test
protected:
PulseBlankingFilterTest()
{
queue = std::shared_ptr<Concurrent_Queue<pmt::pmt_t>>();
queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>();
item_size = sizeof(gr_complex);
config = std::make_shared<InMemoryConfiguration>();
nsamples = FLAGS_pb_filter_test_nsamples;

4
src/tests/unit-tests/signal-processing-blocks/resampler/direct_resampler_conditioner_cc_test.cc
View File

@ -39,10 +39,10 @@
#else
#include <gnuradio/analog/sig_source_c.h>
#endif
#include "concurrent_queue.h"
#include "direct_resampler_conditioner_cc.h"
#include "gnss_sdr_valve.h"
#include <gnuradio/blocks/null_sink.h>
#include "concurrent_queue.h"
TEST(DirectResamplerConditionerCcTest, InstantiationAndRunTest)
@ -52,7 +52,7 @@ TEST(DirectResamplerConditionerCcTest, InstantiationAndRunTest)
std::chrono::time_point<std::chrono::system_clock> start, end;
std::chrono::duration<double> elapsed_seconds(0);
int nsamples = 1000000; //Number of samples to be computed
std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue = std::shared_ptr<Concurrent_Queue<pmt::pmt_t>>();
std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>();
gr::top_block_sptr top_block = gr::make_top_block("direct_resampler_conditioner_cc_test");
boost::shared_ptr<gr::analog::sig_source_c> source = gr::analog::sig_source_c::make(fs_in, gr::analog::GR_SIN_WAVE, 1000.0, 1.0, gr_complex(0.0));
boost::shared_ptr<gr::block> valve = gnss_sdr_make_valve(sizeof(gr_complex), nsamples, queue);

6
src/tests/unit-tests/signal-processing-blocks/resampler/mmse_resampler_test.cc
View File

@ -37,10 +37,10 @@
#else
#include <gnuradio/analog/sig_source_c.h>
#endif
#include "concurrent_queue.h"
#include "gnss_sdr_valve.h"
#include "mmse_resampler_conditioner.h"
#include <gnuradio/blocks/null_sink.h>
#include "concurrent_queue.h"
TEST(MmseResamplerTest, InstantiationAndRunTestWarning)
{
@ -49,7 +49,7 @@ TEST(MmseResamplerTest, InstantiationAndRunTestWarning)
std::chrono::time_point<std::chrono::system_clock> start, end;
std::chrono::duration<double> elapsed_seconds(0);
int nsamples = 1000000; //Number of samples to be computed
std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue = std::shared_ptr<Concurrent_Queue<pmt::pmt_t>>();
std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>();
gr::top_block_sptr top_block = gr::make_top_block("mmse_resampler_conditioner_cc_test");
boost::shared_ptr<gr::analog::sig_source_c> source = gr::analog::sig_source_c::make(fs_in, gr::analog::GR_SIN_WAVE, 1000.0, 1.0, gr_complex(0.0));
boost::shared_ptr<gr::block> valve = gnss_sdr_make_valve(sizeof(gr_complex), nsamples, queue);
@ -90,7 +90,7 @@ TEST(MmseResamplerTest, InstantiationAndRunTest2)
std::chrono::time_point<std::chrono::system_clock> start, end;
std::chrono::duration<double> elapsed_seconds(0);
int nsamples = 1000000; //Number of samples to be computed
std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue = std::shared_ptr<Concurrent_Queue<pmt::pmt_t>>();
std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>();
gr::top_block_sptr top_block = gr::make_top_block("mmse_resampler_conditioner_cc_test");
boost::shared_ptr<gr::analog::sig_source_c> source = gr::analog::sig_source_c::make(fs_in, gr::analog::GR_SIN_WAVE, 1000.0, 1.0, gr_complex(0.0));
boost::shared_ptr<gr::block> valve = gnss_sdr_make_valve(sizeof(gr_complex), nsamples, queue);

4
src/tests/unit-tests/signal-processing-blocks/sources/file_signal_source_test.cc
View File

@ -38,7 +38,7 @@
TEST(FileSignalSource, Instantiate)
{
std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue = std::shared_ptr<Concurrent_Queue<pmt::pmt_t>>();
std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>();
std::shared_ptr<InMemoryConfiguration> config = std::make_shared<InMemoryConfiguration>();
config->set_property("Test.samples", "0");
@ -57,7 +57,7 @@ TEST(FileSignalSource, Instantiate)
TEST(FileSignalSource, InstantiateFileNotExists)
{
std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue = std::shared_ptr<Concurrent_Queue<pmt::pmt_t>>();
std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>();
std::shared_ptr<InMemoryConfiguration> config = std::make_shared<InMemoryConfiguration>();
config->set_property("Test.samples", "0");

2
src/tests/unit-tests/signal-processing-blocks/sources/gnss_sdr_valve_test.cc
View File

@ -45,7 +45,7 @@
TEST(ValveTest, CheckEventSentAfter100Samples)
{
std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue = std::shared_ptr<Concurrent_Queue<pmt::pmt_t>>();
std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>();
gr::top_block_sptr top_block = gr::make_top_block("gnss_sdr_valve_test");

6
src/tests/unit-tests/signal-processing-blocks/tracking/galileo_e1_dll_pll_veml_tracking_test.cc
View File

@ -32,6 +32,7 @@
#include "galileo_e1_dll_pll_veml_tracking.h"
#include "concurrent_queue.h"
#include "gnss_block_factory.h"
#include "gnss_block_interface.h"
#include "gnss_sdr_valve.h"
@ -41,7 +42,6 @@
#include <gnuradio/blocks/file_source.h>
#include <gnuradio/blocks/null_sink.h>
#include <gnuradio/blocks/skiphead.h>
#include "concurrent_queue.h"
#include <gnuradio/top_block.h>
#include <gtest/gtest.h>
#include <chrono>
@ -114,7 +114,7 @@ TEST_F(GalileoE1DllPllVemlTrackingInternalTest, ConnectAndRun)
std::chrono::time_point<std::chrono::system_clock> start, end;
std::chrono::duration<double> elapsed_seconds(0);
init();
queue = std::shared_ptr<Concurrent_Queue<pmt::pmt_t>>();
queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>();
top_block = gr::make_top_block("Tracking test");
// Example using smart pointers and the block factory
@ -161,7 +161,7 @@ TEST_F(GalileoE1DllPllVemlTrackingInternalTest, ValidationOfResults)
int num_samples = 80000000; // 8 Msps
unsigned int skiphead_sps = 8000000; // 8 Msps
init();
queue = std::shared_ptr<Concurrent_Queue<pmt::pmt_t>>();
queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>();
top_block = gr::make_top_block("Tracking test");
// Example using smart pointers and the block factory

4
src/tests/unit-tests/signal-processing-blocks/tracking/galileo_e5a_tracking_test.cc
View File

@ -31,6 +31,7 @@
*/
#include "concurrent_queue.h"
#include "galileo_e5a_dll_pll_tracking.h"
#include "gnss_block_factory.h"
#include "gnss_block_interface.h"
@ -41,7 +42,6 @@
#include <gnuradio/blocks/file_source.h>
#include <gnuradio/blocks/null_sink.h>
#include <gnuradio/blocks/skiphead.h>
#include "concurrent_queue.h"
#include <gnuradio/top_block.h>
#include <gtest/gtest.h>
#include <chrono>
@ -110,7 +110,7 @@ TEST_F(GalileoE5aTrackingTest, ValidationOfResults)
int fs_in = 32000000;
int nsamples = 32000000 * 5;
init();
queue = std::shared_ptr<Concurrent_Queue<pmt::pmt_t>>();
queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>();
top_block = gr::make_top_block("Tracking test");
// Example using smart pointers and the block factory

4
src/tests/unit-tests/signal-processing-blocks/tracking/glonass_l1_ca_dll_pll_c_aid_tracking_test.cc
View File

@ -32,6 +32,7 @@
#include "glonass_l1_ca_dll_pll_c_aid_tracking.h"
#include "concurrent_queue.h"
#include "gnss_block_factory.h"
#include "gnss_block_interface.h"
#include "gnss_sdr_valve.h"
@ -42,7 +43,6 @@
#include <gnuradio/blocks/file_source.h>
#include <gnuradio/blocks/null_sink.h>
#include <gnuradio/blocks/skiphead.h>
#include "concurrent_queue.h"
#include <gnuradio/top_block.h>
#include <gtest/gtest.h>
#include <chrono>
@ -156,7 +156,7 @@ TEST_F(GlonassL1CaDllPllCAidTrackingTest, ValidationOfResults)
int nsamples = fs_in * 4e-3 * 2;
init();
queue = std::shared_ptr<Concurrent_Queue<pmt::pmt_t>>();
queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>();
top_block = gr::make_top_block("Tracking test");
std::shared_ptr<TrackingInterface> tracking = std::make_shared<GlonassL1CaDllPllCAidTracking>(config.get(), "Tracking_1G", 1, 1);
boost::shared_ptr<GlonassL1CaDllPllCAidTrackingTest_msg_rx> msg_rx = GlonassL1CaDllPllCAidTrackingTest_msg_rx_make();

4
src/tests/unit-tests/signal-processing-blocks/tracking/glonass_l1_ca_dll_pll_tracking_test.cc
View File

@ -32,6 +32,7 @@
#include "glonass_l1_ca_dll_pll_tracking.h"
#include "concurrent_queue.h"
#include "gnss_block_factory.h"
#include "gnss_block_interface.h"
#include "gnss_sdr_valve.h"
@ -42,7 +43,6 @@
#include <gnuradio/blocks/file_source.h>
#include <gnuradio/blocks/null_sink.h>
#include <gnuradio/blocks/skiphead.h>
#include "concurrent_queue.h"
#include <gnuradio/top_block.h>
#include <gtest/gtest.h>
#include <chrono>
@ -156,7 +156,7 @@ TEST_F(GlonassL1CaDllPllTrackingTest, ValidationOfResults)
int nsamples = fs_in * 4e-3 * 2;
init();
queue = std::shared_ptr<Concurrent_Queue<pmt::pmt_t>>();
queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>();
top_block = gr::make_top_block("Tracking test");
std::shared_ptr<TrackingInterface> tracking = std::make_shared<GlonassL1CaDllPllTracking>(config.get(), "Tracking_1G", 1, 1);
boost::shared_ptr<GlonassL1CaDllPllTrackingTest_msg_rx> msg_rx = GlonassL1CaDllPllTrackingTest_msg_rx_make();

6
src/tests/unit-tests/signal-processing-blocks/tracking/gps_l2_m_dll_pll_tracking_test.cc
View File

@ -31,18 +31,18 @@
*/
#include "gps_l2_m_dll_pll_tracking.h"
#include "concurrent_queue.h"
#include "gnss_block_factory.h"
#include "gnss_block_interface.h"
#include "gnss_sdr_valve.h"
#include "gnss_synchro.h"
#include "gps_l2_m_dll_pll_tracking.h"
#include "in_memory_configuration.h"
#include "tracking_interface.h"
#include <gnuradio/analog/sig_source_waveform.h>
#include <gnuradio/blocks/file_source.h>
#include <gnuradio/blocks/null_sink.h>
#include <gnuradio/blocks/skiphead.h>
#include "concurrent_queue.h"
#include <gnuradio/top_block.h>
#include <gtest/gtest.h>
#include <chrono>
@ -160,7 +160,7 @@ TEST_F(GpsL2MDllPllTrackingTest, ValidationOfResults)
int nsamples = fs_in * 9;
init();
queue = std::shared_ptr<Concurrent_Queue<pmt::pmt_t>>();
queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>();
top_block = gr::make_top_block("Tracking test");
std::shared_ptr<TrackingInterface> tracking = std::make_shared<GpsL2MDllPllTracking>(config.get(), "Tracking_2S", 1, 1);
boost::shared_ptr<GpsL2MDllPllTrackingTest_msg_rx> msg_rx = GpsL2MDllPllTrackingTest_msg_rx_make();

2
src/tests/unit-tests/signal-processing-blocks/tracking/tracking_pull-in_test.cc
View File

@ -795,7 +795,7 @@ TEST_F(TrackingPullInTest, ValidationOfResults)
// create the msg queue for valve
queue = std::shared_ptr<Concurrent_Queue<pmt::pmt_t>>();
queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>();
long long int acq_to_trk_delay_samples = ceil(static_cast<double>(FLAGS_fs_gen_sps) * FLAGS_acq_to_trk_delay_s);
auto resetable_valve_ = gnss_sdr_make_valve(sizeof(gr_complex), acq_to_trk_delay_samples, queue, false);