mirrors/gnss-sdr
1
0
Fork 0
mirror of https://github.com/gnss-sdr/gnss-sdr synced 2025-10-31 07:13:03 +00:00
Code Issues Releases Wiki Activity

Replace boost::shared_ptr by std::shared_ptr

Browse Source
This commit is contained in:
Carles Fernandez
2020-04-02 13:23:20 +02:00
parent 1f62756fdf
commit 5f974a8f17
131 changed files with 372 additions and 372 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/algorithms/PVT/gnuradio_blocks/rtklib_pvt_gs.h
View File

@@ -24,7 +24,7 @@
#include "rtklib.h" #include "rtklib.h"
#include <boost/date_time/gregorian/gregorian.hpp> #include <boost/date_time/gregorian/gregorian.hpp>
#include <boost/date_time/posix_time/posix_time.hpp> #include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/shared_ptr.hpp> // for boost::shared_ptr #include <memory> // for std::shared_ptr
#include <gnuradio/sync_block.h> // for sync_block #include <gnuradio/sync_block.h> // for sync_block
#include <gnuradio/types.h> // for gr_vector_const_void_star #include <gnuradio/types.h> // for gr_vector_const_void_star
#include <pmt/pmt.h> // for pmt_t #include <pmt/pmt.h> // for pmt_t
@@ -55,7 +55,7 @@ class Rtcm_Printer;
class Rtklib_Solver; class Rtklib_Solver;
class rtklib_pvt_gs; class rtklib_pvt_gs;
using rtklib_pvt_gs_sptr = boost::shared_ptr<rtklib_pvt_gs>; using rtklib_pvt_gs_sptr = std::shared_ptr<rtklib_pvt_gs>;
rtklib_pvt_gs_sptr rtklib_make_pvt_gs(uint32_t nchannels, rtklib_pvt_gs_sptr rtklib_make_pvt_gs(uint32_t nchannels,
const Pvt_Conf& conf_, const Pvt_Conf& conf_,

8
src/algorithms/acquisition/adapters/gps_l1_ca_pcps_acquisition_fine_doppler.cc
View File

@@ -162,7 +162,7 @@ void GpsL1CaPcpsAcquisitionFineDoppler::set_state(int state)
} }
void GpsL1CaPcpsAcquisitionFineDoppler::connect(boost::shared_ptr<gr::top_block> top_block) void GpsL1CaPcpsAcquisitionFineDoppler::connect(std::shared_ptr<gr::top_block> top_block)
{ {
if (top_block) if (top_block)
{ /* top_block is not null */ { /* top_block is not null */
@@ -171,7 +171,7 @@ void GpsL1CaPcpsAcquisitionFineDoppler::connect(boost::shared_ptr<gr::top_block>
} }
void GpsL1CaPcpsAcquisitionFineDoppler::disconnect(boost::shared_ptr<gr::top_block> top_block) void GpsL1CaPcpsAcquisitionFineDoppler::disconnect(std::shared_ptr<gr::top_block> top_block)
{ {
if (top_block) if (top_block)
{ /* top_block is not null */ { /* top_block is not null */
@@ -180,13 +180,13 @@ void GpsL1CaPcpsAcquisitionFineDoppler::disconnect(boost::shared_ptr<gr::top_blo
} }
boost::shared_ptr<gr::basic_block> GpsL1CaPcpsAcquisitionFineDoppler::get_left_block() std::shared_ptr<gr::basic_block> GpsL1CaPcpsAcquisitionFineDoppler::get_left_block()
{ {
return acquisition_cc_; return acquisition_cc_;
} }
boost::shared_ptr<gr::basic_block> GpsL1CaPcpsAcquisitionFineDoppler::get_right_block() std::shared_ptr<gr::basic_block> GpsL1CaPcpsAcquisitionFineDoppler::get_right_block()
{ {
return acquisition_cc_; return acquisition_cc_;
} }

8
src/algorithms/acquisition/adapters/gps_l1_ca_pcps_acquisition_fine_doppler.h
View File

@@ -64,10 +64,10 @@ public:
return item_size_; return item_size_;
} }
void connect(boost::shared_ptr<gr::top_block> top_block) override; void connect(std::shared_ptr<gr::top_block> top_block) override;
void disconnect(boost::shared_ptr<gr::top_block> top_block) override; void disconnect(std::shared_ptr<gr::top_block> top_block) override;
boost::shared_ptr<gr::basic_block> get_left_block() override; std::shared_ptr<gr::basic_block> get_left_block() override;
boost::shared_ptr<gr::basic_block> get_right_block() override; std::shared_ptr<gr::basic_block> get_right_block() override;
/*! /*!
* \brief Set acquisition/tracking common Gnss_Synchro object pointer * \brief Set acquisition/tracking common Gnss_Synchro object pointer

2
src/algorithms/acquisition/gnuradio_blocks/galileo_e5a_noncoherent_iq_acquisition_caf_cc.h
View File

@@ -40,7 +40,7 @@
class galileo_e5a_noncoherentIQ_acquisition_caf_cc; class galileo_e5a_noncoherentIQ_acquisition_caf_cc;
using galileo_e5a_noncoherentIQ_acquisition_caf_cc_sptr = boost::shared_ptr<galileo_e5a_noncoherentIQ_acquisition_caf_cc>; using galileo_e5a_noncoherentIQ_acquisition_caf_cc_sptr = std::shared_ptr<galileo_e5a_noncoherentIQ_acquisition_caf_cc>;
galileo_e5a_noncoherentIQ_acquisition_caf_cc_sptr galileo_e5a_noncoherentIQ_make_acquisition_caf_cc( galileo_e5a_noncoherentIQ_acquisition_caf_cc_sptr galileo_e5a_noncoherentIQ_make_acquisition_caf_cc(
unsigned int sampled_ms, unsigned int sampled_ms,

2
src/algorithms/acquisition/gnuradio_blocks/galileo_pcps_8ms_acquisition_cc.h
View File

@@ -34,7 +34,7 @@
class galileo_pcps_8ms_acquisition_cc; class galileo_pcps_8ms_acquisition_cc;
using galileo_pcps_8ms_acquisition_cc_sptr = boost::shared_ptr<galileo_pcps_8ms_acquisition_cc>; using galileo_pcps_8ms_acquisition_cc_sptr = std::shared_ptr<galileo_pcps_8ms_acquisition_cc>;
galileo_pcps_8ms_acquisition_cc_sptr galileo_pcps_8ms_acquisition_cc_sptr
galileo_pcps_8ms_make_acquisition_cc(uint32_t sampled_ms, galileo_pcps_8ms_make_acquisition_cc(uint32_t sampled_ms,

2
src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition.h
View File

@@ -66,7 +66,7 @@
class Gnss_Synchro; class Gnss_Synchro;
class pcps_acquisition; class pcps_acquisition;
using pcps_acquisition_sptr = boost::shared_ptr<pcps_acquisition>; using pcps_acquisition_sptr = std::shared_ptr<pcps_acquisition>;
pcps_acquisition_sptr pcps_make_acquisition(const Acq_Conf& conf_); pcps_acquisition_sptr pcps_make_acquisition(const Acq_Conf& conf_);

2
src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_fine_doppler_cc.h
View File

@@ -58,7 +58,7 @@
class pcps_acquisition_fine_doppler_cc; class pcps_acquisition_fine_doppler_cc;
using pcps_acquisition_fine_doppler_cc_sptr = boost::shared_ptr<pcps_acquisition_fine_doppler_cc>; using pcps_acquisition_fine_doppler_cc_sptr = std::shared_ptr<pcps_acquisition_fine_doppler_cc>;
pcps_acquisition_fine_doppler_cc_sptr pcps_make_acquisition_fine_doppler_cc(const Acq_Conf& conf_); pcps_acquisition_fine_doppler_cc_sptr pcps_make_acquisition_fine_doppler_cc(const Acq_Conf& conf_);

4
src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_fpga.h
View File

@@ -32,7 +32,7 @@
#include "channel_fsm.h" #include "channel_fsm.h"
#include "fpga_acquisition.h" #include "fpga_acquisition.h"
#include <boost/shared_ptr.hpp> #include <memory>
#include <glog/logging.h> #include <glog/logging.h>
#include <cstdint> // for uint32_t #include <cstdint> // for uint32_t
#include <memory> // for shared_ptr #include <memory> // for shared_ptr
@@ -62,7 +62,7 @@ typedef struct
class pcps_acquisition_fpga; class pcps_acquisition_fpga;
using pcps_acquisition_fpga_sptr = boost::shared_ptr<pcps_acquisition_fpga>; using pcps_acquisition_fpga_sptr = std::shared_ptr<pcps_acquisition_fpga>;
pcps_acquisition_fpga_sptr pcps_make_acquisition_fpga(pcpsconf_fpga_t conf_); pcps_acquisition_fpga_sptr pcps_make_acquisition_fpga(pcpsconf_fpga_t conf_);

2
src/algorithms/acquisition/gnuradio_blocks/pcps_assisted_acquisition_cc.h
View File

@@ -50,7 +50,7 @@
class pcps_assisted_acquisition_cc; class pcps_assisted_acquisition_cc;
using pcps_assisted_acquisition_cc_sptr = boost::shared_ptr<pcps_assisted_acquisition_cc>; using pcps_assisted_acquisition_cc_sptr = std::shared_ptr<pcps_assisted_acquisition_cc>;
pcps_assisted_acquisition_cc_sptr pcps_make_assisted_acquisition_cc( pcps_assisted_acquisition_cc_sptr pcps_make_assisted_acquisition_cc(
int32_t max_dwells, int32_t max_dwells,

2
src/algorithms/acquisition/gnuradio_blocks/pcps_cccwsr_acquisition_cc.h
View File

@@ -40,7 +40,7 @@
class pcps_cccwsr_acquisition_cc; class pcps_cccwsr_acquisition_cc;
using pcps_cccwsr_acquisition_cc_sptr = boost::shared_ptr<pcps_cccwsr_acquisition_cc>; using pcps_cccwsr_acquisition_cc_sptr = std::shared_ptr<pcps_cccwsr_acquisition_cc>;
pcps_cccwsr_acquisition_cc_sptr pcps_cccwsr_make_acquisition_cc( pcps_cccwsr_acquisition_cc_sptr pcps_cccwsr_make_acquisition_cc(
uint32_t sampled_ms, uint32_t sampled_ms,

2
src/algorithms/acquisition/gnuradio_blocks/pcps_opencl_acquisition_cc.h
View File

@@ -56,7 +56,7 @@
class pcps_opencl_acquisition_cc; class pcps_opencl_acquisition_cc;
typedef boost::shared_ptr<pcps_opencl_acquisition_cc> pcps_opencl_acquisition_cc_sptr; typedef std::shared_ptr<pcps_opencl_acquisition_cc> pcps_opencl_acquisition_cc_sptr;
pcps_opencl_acquisition_cc_sptr pcps_make_opencl_acquisition_cc( pcps_opencl_acquisition_cc_sptr pcps_make_opencl_acquisition_cc(
uint32_t sampled_ms, uint32_t sampled_ms,

2
src/algorithms/acquisition/gnuradio_blocks/pcps_quicksync_acquisition_cc.h
View File

@@ -56,7 +56,7 @@
class pcps_quicksync_acquisition_cc; class pcps_quicksync_acquisition_cc;
using pcps_quicksync_acquisition_cc_sptr = boost::shared_ptr<pcps_quicksync_acquisition_cc>; using pcps_quicksync_acquisition_cc_sptr = std::shared_ptr<pcps_quicksync_acquisition_cc>;
pcps_quicksync_acquisition_cc_sptr pcps_quicksync_make_acquisition_cc( pcps_quicksync_acquisition_cc_sptr pcps_quicksync_make_acquisition_cc(
uint32_t folding_factor, uint32_t folding_factor,

2
src/algorithms/acquisition/gnuradio_blocks/pcps_tong_acquisition_cc.h
View File

@@ -54,7 +54,7 @@
class pcps_tong_acquisition_cc; class pcps_tong_acquisition_cc;
using pcps_tong_acquisition_cc_sptr = boost::shared_ptr<pcps_tong_acquisition_cc>; using pcps_tong_acquisition_cc_sptr = std::shared_ptr<pcps_tong_acquisition_cc>;
pcps_tong_acquisition_cc_sptr pcps_tong_make_acquisition_cc( pcps_tong_acquisition_cc_sptr pcps_tong_make_acquisition_cc(
uint32_t sampled_ms, uint32_t sampled_ms,

2
src/algorithms/channel/libs/channel_msg_receiver_cc.h
View File

@@ -27,7 +27,7 @@
class channel_msg_receiver_cc; class channel_msg_receiver_cc;
using channel_msg_receiver_cc_sptr = boost::shared_ptr<channel_msg_receiver_cc>; using channel_msg_receiver_cc_sptr = std::shared_ptr<channel_msg_receiver_cc>;
channel_msg_receiver_cc_sptr channel_msg_receiver_make_cc(std::shared_ptr<ChannelFsm> channel_fsm, bool repeat); channel_msg_receiver_cc_sptr channel_msg_receiver_make_cc(std::shared_ptr<ChannelFsm> channel_fsm, bool repeat);

4
src/algorithms/data_type_adapter/gnuradio_blocks/interleaved_byte_to_complex_byte.h
View File

@@ -20,12 +20,12 @@
#ifndef GNSS_SDR_INTERLEAVED_BYTE_TO_COMPLEX_BYTE_H #ifndef GNSS_SDR_INTERLEAVED_BYTE_TO_COMPLEX_BYTE_H
#define GNSS_SDR_INTERLEAVED_BYTE_TO_COMPLEX_BYTE_H #define GNSS_SDR_INTERLEAVED_BYTE_TO_COMPLEX_BYTE_H
#include <boost/shared_ptr.hpp>
#include <gnuradio/sync_decimator.h> #include <gnuradio/sync_decimator.h>
#include <memory>
class interleaved_byte_to_complex_byte; class interleaved_byte_to_complex_byte;
using interleaved_byte_to_complex_byte_sptr = boost::shared_ptr<interleaved_byte_to_complex_byte>; using interleaved_byte_to_complex_byte_sptr = std::shared_ptr<interleaved_byte_to_complex_byte>;
interleaved_byte_to_complex_byte_sptr make_interleaved_byte_to_complex_byte(); interleaved_byte_to_complex_byte_sptr make_interleaved_byte_to_complex_byte();

4
src/algorithms/data_type_adapter/gnuradio_blocks/interleaved_byte_to_complex_short.h
View File

@@ -20,12 +20,12 @@
#ifndef GNSS_SDR_INTERLEAVED_BYTE_TO_COMPLEX_SHORT_H #ifndef GNSS_SDR_INTERLEAVED_BYTE_TO_COMPLEX_SHORT_H
#define GNSS_SDR_INTERLEAVED_BYTE_TO_COMPLEX_SHORT_H #define GNSS_SDR_INTERLEAVED_BYTE_TO_COMPLEX_SHORT_H
#include <boost/shared_ptr.hpp> #include <memory>
#include <gnuradio/sync_decimator.h> #include <gnuradio/sync_decimator.h>
class interleaved_byte_to_complex_short; class interleaved_byte_to_complex_short;
using interleaved_byte_to_complex_short_sptr = boost::shared_ptr<interleaved_byte_to_complex_short>; using interleaved_byte_to_complex_short_sptr = std::shared_ptr<interleaved_byte_to_complex_short>;
interleaved_byte_to_complex_short_sptr make_interleaved_byte_to_complex_short(); interleaved_byte_to_complex_short_sptr make_interleaved_byte_to_complex_short();

4
src/algorithms/data_type_adapter/gnuradio_blocks/interleaved_short_to_complex_short.h
View File

@@ -20,12 +20,12 @@
#ifndef GNSS_SDR_INTERLEAVED_SHORT_TO_COMPLEX_SHORT_H #ifndef GNSS_SDR_INTERLEAVED_SHORT_TO_COMPLEX_SHORT_H
#define GNSS_SDR_INTERLEAVED_SHORT_TO_COMPLEX_SHORT_H #define GNSS_SDR_INTERLEAVED_SHORT_TO_COMPLEX_SHORT_H
#include <boost/shared_ptr.hpp> #include <memory>
#include <gnuradio/sync_decimator.h> #include <gnuradio/sync_decimator.h>
class interleaved_short_to_complex_short; class interleaved_short_to_complex_short;
using interleaved_short_to_complex_short_sptr = boost::shared_ptr<interleaved_short_to_complex_short>; using interleaved_short_to_complex_short_sptr = std::shared_ptr<interleaved_short_to_complex_short>;
interleaved_short_to_complex_short_sptr make_interleaved_short_to_complex_short(); interleaved_short_to_complex_short_sptr make_interleaved_short_to_complex_short();

2
src/algorithms/input_filter/gnuradio_blocks/beamformer.h
View File

@@ -25,7 +25,7 @@
class beamformer; class beamformer;
using beamformer_sptr = boost::shared_ptr<beamformer>; using beamformer_sptr = std::shared_ptr<beamformer>;
beamformer_sptr make_beamformer_sptr(); beamformer_sptr make_beamformer_sptr();

4
src/algorithms/input_filter/gnuradio_blocks/notch_cc.h
View File

@@ -20,7 +20,7 @@
#ifndef GNSS_SDR_NOTCH_H #ifndef GNSS_SDR_NOTCH_H
#define GNSS_SDR_NOTCH_H #define GNSS_SDR_NOTCH_H
#include <boost/shared_ptr.hpp> #include <memory>
#include <gnuradio/block.h> #include <gnuradio/block.h>
#include <gnuradio/fft/fft.h> #include <gnuradio/fft/fft.h>
#include <cstdint> #include <cstdint>
@@ -28,7 +28,7 @@
class Notch; class Notch;
using notch_sptr = boost::shared_ptr<Notch>; using notch_sptr = std::shared_ptr<Notch>;
notch_sptr make_notch_filter( notch_sptr make_notch_filter(
float pfa, float pfa,

4
src/algorithms/input_filter/gnuradio_blocks/notch_lite_cc.h
View File

@@ -20,7 +20,7 @@
#ifndef GNSS_SDR_NOTCH_LITE_H #ifndef GNSS_SDR_NOTCH_LITE_H
#define GNSS_SDR_NOTCH_LITE_H #define GNSS_SDR_NOTCH_LITE_H
#include <boost/shared_ptr.hpp> #include <memory>
#include <gnuradio/block.h> #include <gnuradio/block.h>
#include <gnuradio/fft/fft.h> #include <gnuradio/fft/fft.h>
#include <cstdint> #include <cstdint>
@@ -28,7 +28,7 @@
class NotchLite; class NotchLite;
using notch_lite_sptr = boost::shared_ptr<NotchLite>; using notch_lite_sptr = std::shared_ptr<NotchLite>;
notch_lite_sptr make_notch_filter_lite( notch_lite_sptr make_notch_filter_lite(
float p_c_factor, float p_c_factor,

4
src/algorithms/input_filter/gnuradio_blocks/pulse_blanking_cc.h
View File

@@ -20,13 +20,13 @@
#ifndef GNSS_SDR_PULSE_BLANKING_H #ifndef GNSS_SDR_PULSE_BLANKING_H
#define GNSS_SDR_PULSE_BLANKING_H #define GNSS_SDR_PULSE_BLANKING_H
#include <boost/shared_ptr.hpp> #include <memory>
#include <gnuradio/block.h> #include <gnuradio/block.h>
#include <cstdint> #include <cstdint>
class pulse_blanking_cc; class pulse_blanking_cc;
using pulse_blanking_cc_sptr = boost::shared_ptr<pulse_blanking_cc>; using pulse_blanking_cc_sptr = std::shared_ptr<pulse_blanking_cc>;
pulse_blanking_cc_sptr make_pulse_blanking_cc( pulse_blanking_cc_sptr make_pulse_blanking_cc(
float pfa, float pfa,

4
src/algorithms/libs/byte_x2_to_complex_byte.h
View File

@@ -21,13 +21,13 @@
#define GNSS_SDR_BYTE_X2_TO_COMPLEX_BYTE_H #define GNSS_SDR_BYTE_X2_TO_COMPLEX_BYTE_H
#include <boost/shared_ptr.hpp> #include <memory>
#include <gnuradio/sync_block.h> #include <gnuradio/sync_block.h>
#include <gnuradio/types.h> // for gr_vector_const_void_star #include <gnuradio/types.h> // for gr_vector_const_void_star
class byte_x2_to_complex_byte; class byte_x2_to_complex_byte;
using byte_x2_to_complex_byte_sptr = boost::shared_ptr<byte_x2_to_complex_byte>; using byte_x2_to_complex_byte_sptr = std::shared_ptr<byte_x2_to_complex_byte>;
byte_x2_to_complex_byte_sptr make_byte_x2_to_complex_byte(); byte_x2_to_complex_byte_sptr make_byte_x2_to_complex_byte();

4
src/algorithms/libs/complex_byte_to_float_x2.h
View File

@@ -21,13 +21,13 @@
#define GNSS_SDR_COMPLEX_BYTE_TO_FLOAT_X2_H #define GNSS_SDR_COMPLEX_BYTE_TO_FLOAT_X2_H
#include <boost/shared_ptr.hpp> #include <memory>
#include <gnuradio/sync_block.h> #include <gnuradio/sync_block.h>
#include <gnuradio/types.h> // for gr_vector_const_void_star #include <gnuradio/types.h> // for gr_vector_const_void_star
class complex_byte_to_float_x2; class complex_byte_to_float_x2;
using complex_byte_to_float_x2_sptr = boost::shared_ptr<complex_byte_to_float_x2>; using complex_byte_to_float_x2_sptr = std::shared_ptr<complex_byte_to_float_x2>;
complex_byte_to_float_x2_sptr make_complex_byte_to_float_x2(); complex_byte_to_float_x2_sptr make_complex_byte_to_float_x2();

4
src/algorithms/libs/complex_float_to_complex_byte.h
View File

@@ -20,14 +20,14 @@
#ifndef GNSS_SDR_COMPLEX_FLOAT_TO_COMPLEX_BYTE_H #ifndef GNSS_SDR_COMPLEX_FLOAT_TO_COMPLEX_BYTE_H
#define GNSS_SDR_COMPLEX_FLOAT_TO_COMPLEX_BYTE_H #define GNSS_SDR_COMPLEX_FLOAT_TO_COMPLEX_BYTE_H
#include <boost/shared_ptr.hpp> #include <memory>
#include <gnuradio/sync_block.h> #include <gnuradio/sync_block.h>
#include <gnuradio/types.h> // for gr_vector_const_void_star #include <gnuradio/types.h> // for gr_vector_const_void_star
class complex_float_to_complex_byte; class complex_float_to_complex_byte;
using complex_float_to_complex_byte_sptr = boost::shared_ptr<complex_float_to_complex_byte>; using complex_float_to_complex_byte_sptr = std::shared_ptr<complex_float_to_complex_byte>;
complex_float_to_complex_byte_sptr make_complex_float_to_complex_byte(); complex_float_to_complex_byte_sptr make_complex_float_to_complex_byte();

4
src/algorithms/libs/conjugate_cc.h
View File

@@ -20,13 +20,13 @@
#ifndef GNSS_SDR_CONJUGATE_CC_H #ifndef GNSS_SDR_CONJUGATE_CC_H
#define GNSS_SDR_CONJUGATE_CC_H #define GNSS_SDR_CONJUGATE_CC_H
#include <boost/shared_ptr.hpp> #include <memory>
#include <gnuradio/sync_block.h> #include <gnuradio/sync_block.h>
#include <gnuradio/types.h> // for gr_vector_const_void_star #include <gnuradio/types.h> // for gr_vector_const_void_star
class conjugate_cc; class conjugate_cc;
using conjugate_cc_sptr = boost::shared_ptr<conjugate_cc>; using conjugate_cc_sptr = std::shared_ptr<conjugate_cc>;
conjugate_cc_sptr make_conjugate_cc(); conjugate_cc_sptr make_conjugate_cc();

4
src/algorithms/libs/conjugate_ic.h
View File

@@ -20,13 +20,13 @@
#ifndef GNSS_SDR_CONJUGATE_IC_H #ifndef GNSS_SDR_CONJUGATE_IC_H
#define GNSS_SDR_CONJUGATE_IC_H #define GNSS_SDR_CONJUGATE_IC_H
#include <boost/shared_ptr.hpp>
#include <gnuradio/sync_block.h> #include <gnuradio/sync_block.h>
#include <gnuradio/types.h> // for gr_vector_const_void_star #include <gnuradio/types.h> // for gr_vector_const_void_star
#include <memory>
class conjugate_ic; class conjugate_ic;
using conjugate_ic_sptr = boost::shared_ptr<conjugate_ic>; using conjugate_ic_sptr = std::shared_ptr<conjugate_ic>;
conjugate_ic_sptr make_conjugate_ic(); conjugate_ic_sptr make_conjugate_ic();

4
src/algorithms/libs/conjugate_sc.h
View File

@@ -20,13 +20,13 @@
#ifndef GNSS_SDR_CONJUGATE_SC_H #ifndef GNSS_SDR_CONJUGATE_SC_H
#define GNSS_SDR_CONJUGATE_SC_H #define GNSS_SDR_CONJUGATE_SC_H
#include <boost/shared_ptr.hpp> #include <memory>
#include <gnuradio/sync_block.h> #include <gnuradio/sync_block.h>
#include <gnuradio/types.h> // for gr_vector_const_void_star #include <gnuradio/types.h> // for gr_vector_const_void_star
class conjugate_sc; class conjugate_sc;
using conjugate_sc_sptr = boost::shared_ptr<conjugate_sc>; using conjugate_sc_sptr = std::shared_ptr<conjugate_sc>;
conjugate_sc_sptr make_conjugate_sc(); conjugate_sc_sptr make_conjugate_sc();

4
src/algorithms/libs/cshort_to_float_x2.h
View File

@@ -21,13 +21,13 @@
#define GNSS_SDR_CSHORT_TO_FLOAT_X2_H #define GNSS_SDR_CSHORT_TO_FLOAT_X2_H
#include <boost/shared_ptr.hpp> #include <memory>
#include <gnuradio/sync_block.h> #include <gnuradio/sync_block.h>
#include <gnuradio/types.h> // for gr_vector_const_void_star #include <gnuradio/types.h> // for gr_vector_const_void_star
class cshort_to_float_x2; class cshort_to_float_x2;
using cshort_to_float_x2_sptr = boost::shared_ptr<cshort_to_float_x2>; using cshort_to_float_x2_sptr = std::shared_ptr<cshort_to_float_x2>;
cshort_to_float_x2_sptr make_cshort_to_float_x2(); cshort_to_float_x2_sptr make_cshort_to_float_x2();

4
src/algorithms/libs/short_x2_to_cshort.h
View File

@@ -21,13 +21,13 @@
#define GNSS_SDR_SHORT_X2_TO_CSHORT_H #define GNSS_SDR_SHORT_X2_TO_CSHORT_H
#include <boost/shared_ptr.hpp> #include <memory>
#include <gnuradio/sync_block.h> #include <gnuradio/sync_block.h>
#include <gnuradio/types.h> // for gr_vector_const_void_star #include <gnuradio/types.h> // for gr_vector_const_void_star
class short_x2_to_cshort; class short_x2_to_cshort;
using short_x2_to_cshort_sptr = boost::shared_ptr<short_x2_to_cshort>; using short_x2_to_cshort_sptr = std::shared_ptr<short_x2_to_cshort>;
short_x2_to_cshort_sptr make_short_x2_to_cshort(); short_x2_to_cshort_sptr make_short_x2_to_cshort();

4
src/algorithms/observables/gnuradio_blocks/hybrid_observables_gs.h
View File

@@ -25,7 +25,7 @@
#include "obs_conf.h" #include "obs_conf.h"
#include <boost/circular_buffer.hpp> // for boost::circular_buffer #include <boost/circular_buffer.hpp> // for boost::circular_buffer
#include <boost/shared_ptr.hpp> // for boost::shared_ptr #include <memory> // for std::shared_ptr
#include <gnuradio/block.h> // for block #include <gnuradio/block.h> // for block
#include <gnuradio/types.h> // for gr_vector_int #include <gnuradio/types.h> // for gr_vector_int
#include <cstdint> // for int32_t #include <cstdint> // for int32_t
@@ -41,7 +41,7 @@ class hybrid_observables_gs;
template <class T> template <class T>
class Gnss_circular_deque; class Gnss_circular_deque;
using hybrid_observables_gs_sptr = boost::shared_ptr<hybrid_observables_gs>; using hybrid_observables_gs_sptr = std::shared_ptr<hybrid_observables_gs>;
hybrid_observables_gs_sptr hybrid_observables_gs_make(const Obs_Conf& conf_); hybrid_observables_gs_sptr hybrid_observables_gs_make(const Obs_Conf& conf_);

4
src/algorithms/resampler/gnuradio_blocks/direct_resampler_conditioner_cb.h
View File

@@ -21,12 +21,12 @@
#ifndef GNSS_SDR_DIRECT_RESAMPLER_CONDITIONER_CB_H #ifndef GNSS_SDR_DIRECT_RESAMPLER_CONDITIONER_CB_H
#define GNSS_SDR_DIRECT_RESAMPLER_CONDITIONER_CB_H #define GNSS_SDR_DIRECT_RESAMPLER_CONDITIONER_CB_H
#include <boost/shared_ptr.hpp> #include <memory>
#include <gnuradio/block.h> #include <gnuradio/block.h>
#include <cstdint> #include <cstdint>
class direct_resampler_conditioner_cb; class direct_resampler_conditioner_cb;
using direct_resampler_conditioner_cb_sptr = boost::shared_ptr<direct_resampler_conditioner_cb>; using direct_resampler_conditioner_cb_sptr = std::shared_ptr<direct_resampler_conditioner_cb>;
direct_resampler_conditioner_cb_sptr direct_resampler_make_conditioner_cb( direct_resampler_conditioner_cb_sptr direct_resampler_make_conditioner_cb(
double sample_freq_in, double sample_freq_in,

4
src/algorithms/resampler/gnuradio_blocks/direct_resampler_conditioner_cc.h
View File

@@ -28,13 +28,13 @@
#ifndef GNSS_SDR_DIRECT_RESAMPLER_CONDITIONER_CC_H #ifndef GNSS_SDR_DIRECT_RESAMPLER_CONDITIONER_CC_H
#define GNSS_SDR_DIRECT_RESAMPLER_CONDITIONER_CC_H #define GNSS_SDR_DIRECT_RESAMPLER_CONDITIONER_CC_H
#include <boost/shared_ptr.hpp> #include <memory>
#include <gnuradio/block.h> #include <gnuradio/block.h>
#include <cstdint> #include <cstdint>
class direct_resampler_conditioner_cc; class direct_resampler_conditioner_cc;
using direct_resampler_conditioner_cc_sptr = boost::shared_ptr<direct_resampler_conditioner_cc>; using direct_resampler_conditioner_cc_sptr = std::shared_ptr<direct_resampler_conditioner_cc>;
direct_resampler_conditioner_cc_sptr direct_resampler_make_conditioner_cc( direct_resampler_conditioner_cc_sptr direct_resampler_make_conditioner_cc(
double sample_freq_in, double sample_freq_in,

4
src/algorithms/resampler/gnuradio_blocks/direct_resampler_conditioner_cs.h
View File

@@ -21,12 +21,12 @@
#ifndef GNSS_SDR_DIRECT_RESAMPLER_CONDITIONER_CS_H #ifndef GNSS_SDR_DIRECT_RESAMPLER_CONDITIONER_CS_H
#define GNSS_SDR_DIRECT_RESAMPLER_CONDITIONER_CS_H #define GNSS_SDR_DIRECT_RESAMPLER_CONDITIONER_CS_H
#include <boost/shared_ptr.hpp> #include <memory>
#include <gnuradio/block.h> #include <gnuradio/block.h>
#include <cstdint> #include <cstdint>
class direct_resampler_conditioner_cs; class direct_resampler_conditioner_cs;
using direct_resampler_conditioner_cs_sptr = boost::shared_ptr<direct_resampler_conditioner_cs>; using direct_resampler_conditioner_cs_sptr = std::shared_ptr<direct_resampler_conditioner_cs>;
direct_resampler_conditioner_cs_sptr direct_resampler_make_conditioner_cs( direct_resampler_conditioner_cs_sptr direct_resampler_make_conditioner_cs(
double sample_freq_in, double sample_freq_in,

2
src/algorithms/signal_generator/adapters/signal_generator.h
View File

@@ -79,7 +79,7 @@ private:
size_t item_size_; size_t item_size_;
bool dump_; bool dump_;
std::string dump_filename_; std::string dump_filename_;
boost::shared_ptr<gr::block> gen_source_; std::shared_ptr<gr::block> gen_source_;
gr::blocks::vector_to_stream::sptr vector_to_stream_; gr::blocks::vector_to_stream::sptr vector_to_stream_;
gr::blocks::file_sink::sptr file_sink_; gr::blocks::file_sink::sptr file_sink_;
std::shared_ptr<Concurrent_Queue<pmt::pmt_t> > queue_; std::shared_ptr<Concurrent_Queue<pmt::pmt_t> > queue_;

6
src/algorithms/signal_generator/gnuradio_blocks/signal_generator_c.h
View File

@@ -30,16 +30,16 @@
class signal_generator_c; class signal_generator_c;
/* /*
* We use boost::shared_ptr's instead of raw pointers for all access * We use std::shared_ptr's instead of raw pointers for all access
* to gr_blocks (and many other data structures). The shared_ptr gets * to gr_blocks (and many other data structures). The shared_ptr gets
* us transparent reference counting, which greatly simplifies storage * us transparent reference counting, which greatly simplifies storage
* management issues. * management issues.
* *
* See https://www.boost.org/doc/libs/release/libs/smart_ptr/doc/html/smart_ptr.html * See https://www.boost.org/doc/libs/release/libs/smart_ptr/doc/html/smart_ptr.html
* *
* As a convention, the _sptr suffix indicates a boost::shared_ptr * As a convention, the _sptr suffix indicates a std::shared_ptr
*/ */
using signal_generator_c_sptr = boost::shared_ptr<signal_generator_c>; using signal_generator_c_sptr = std::shared_ptr<signal_generator_c>;
/*! /*!
* \brief Return a shared_ptr to a new instance of gen_source. * \brief Return a shared_ptr to a new instance of gen_source.

2
src/algorithms/signal_source/adapters/ad9361_fpga_signal_source.h
View File

@@ -24,7 +24,7 @@
#include "concurrent_queue.h" #include "concurrent_queue.h"
#include "fpga_switch.h" #include "fpga_switch.h"
#include "gnss_block_interface.h" #include "gnss_block_interface.h"
#include <boost/shared_ptr.hpp> #include <memory>
#include <pmt/pmt.h> #include <pmt/pmt.h>
#include <cstdint> #include <cstdint>
#include <memory> #include <memory>

6
src/algorithms/signal_source/adapters/custom_udp_signal_source.h
View File

@@ -24,7 +24,7 @@
#include "concurrent_queue.h" #include "concurrent_queue.h"
#include "gnss_block_interface.h" #include "gnss_block_interface.h"
#include "gr_complex_ip_packet_source.h" #include "gr_complex_ip_packet_source.h"
#include <boost/shared_ptr.hpp> #include <memory>
#include <gnuradio/blocks/file_sink.h> #include <gnuradio/blocks/file_sink.h>
#include <gnuradio/blocks/null_sink.h> #include <gnuradio/blocks/null_sink.h>
#include <pmt/pmt.h> #include <pmt/pmt.h>
@@ -86,9 +86,9 @@ private:
size_t item_size_; size_t item_size_;
bool dump_; bool dump_;
std::string dump_filename_; std::string dump_filename_;
std::vector<boost::shared_ptr<gr::block>> null_sinks_; std::vector<std::shared_ptr<gr::block>> null_sinks_;
Gr_Complex_Ip_Packet_Source::sptr udp_gnss_rx_source_; Gr_Complex_Ip_Packet_Source::sptr udp_gnss_rx_source_;
std::vector<boost::shared_ptr<gr::block>> file_sink_; std::vector<std::shared_ptr<gr::block>> file_sink_;
std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue_; std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue_;
}; };

2
src/algorithms/signal_source/adapters/file_signal_source.h
View File

@@ -110,7 +110,7 @@ private:
uint32_t in_streams_; uint32_t in_streams_;
uint32_t out_streams_; uint32_t out_streams_;
gr::blocks::file_source::sptr file_source_; gr::blocks::file_source::sptr file_source_;
boost::shared_ptr<gr::block> valve_; std::shared_ptr<gr::block> valve_;
gr::blocks::file_sink::sptr sink_; gr::blocks::file_sink::sptr sink_;
gr::blocks::throttle::sptr throttle_; gr::blocks::throttle::sptr throttle_;
std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue_; std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue_;

4
src/algorithms/signal_source/adapters/flexiband_signal_source.h
View File

@@ -96,8 +96,8 @@ private:
gr::block_sptr flexiband_source_; gr::block_sptr flexiband_source_;
std::vector<boost::shared_ptr<gr::block>> char_to_float; std::vector<std::shared_ptr<gr::block>> char_to_float;
std::vector<boost::shared_ptr<gr::block>> float_to_complex_; std::vector<std::shared_ptr<gr::block>> float_to_complex_;
std::vector<gr::blocks::null_sink::sptr> null_sinks_; std::vector<gr::blocks::null_sink::sptr> null_sinks_;
std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue_; std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue_;

4
src/algorithms/signal_source/adapters/fmcomms2_signal_source.h
View File

@@ -23,7 +23,7 @@
#define GNSS_SDR_FMCOMMS2_SIGNAL_SOURCE_H #define GNSS_SDR_FMCOMMS2_SIGNAL_SOURCE_H
#include "gnss_block_interface.h" #include "gnss_block_interface.h"
#include <boost/shared_ptr.hpp> #include <memory>
#include <gnuradio/blocks/file_sink.h> #include <gnuradio/blocks/file_sink.h>
#if GRIIO_INCLUDE_HAS_GNURADIO #if GRIIO_INCLUDE_HAS_GNURADIO
#include <gnuradio/iio/fmcomms2_source.h> #include <gnuradio/iio/fmcomms2_source.h>
@@ -118,7 +118,7 @@ private:
gr::iio::fmcomms2_source_f32c::sptr fmcomms2_source_f32c_; gr::iio::fmcomms2_source_f32c::sptr fmcomms2_source_f32c_;
boost::shared_ptr<gr::block> valve_; std::shared_ptr<gr::block> valve_;
gr::blocks::file_sink::sptr file_sink_; gr::blocks::file_sink::sptr file_sink_;
std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue_; std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue_;
}; };

2
src/algorithms/signal_source/adapters/multichannel_file_signal_source.h
View File

@@ -110,7 +110,7 @@ private:
uint32_t in_streams_; uint32_t in_streams_;
uint32_t out_streams_; uint32_t out_streams_;
std::vector<gr::blocks::file_source::sptr> file_source_vec_; std::vector<gr::blocks::file_source::sptr> file_source_vec_;
boost::shared_ptr<gr::block> valve_; std::shared_ptr<gr::block> valve_;
gr::blocks::file_sink::sptr sink_; gr::blocks::file_sink::sptr sink_;
std::vector<gr::blocks::throttle::sptr> throttle_vec_; std::vector<gr::blocks::throttle::sptr> throttle_vec_;
std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue_; std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue_;

2
src/algorithms/signal_source/adapters/nsr_file_signal_source.h
View File

@@ -110,7 +110,7 @@ private:
uint32_t out_streams_; uint32_t out_streams_;
gr::blocks::file_source::sptr file_source_; gr::blocks::file_source::sptr file_source_;
unpack_byte_2bit_samples_sptr unpack_byte_; unpack_byte_2bit_samples_sptr unpack_byte_;
boost::shared_ptr<gr::block> valve_; std::shared_ptr<gr::block> valve_;
gr::blocks::file_sink::sptr sink_; gr::blocks::file_sink::sptr sink_;
gr::blocks::throttle::sptr throttle_; gr::blocks::throttle::sptr throttle_;
std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue_; std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue_;

4
src/algorithms/signal_source/adapters/osmosdr_signal_source.h
View File

@@ -24,7 +24,7 @@
#include "concurrent_queue.h" #include "concurrent_queue.h"
#include "gnss_block_interface.h" #include "gnss_block_interface.h"
#include <boost/shared_ptr.hpp> #include <memory>
#include <gnuradio/blocks/file_sink.h> #include <gnuradio/blocks/file_sink.h>
#include <pmt/pmt.h> #include <pmt/pmt.h>
#include <cstdint> #include <cstdint>
@@ -99,7 +99,7 @@ private:
std::string antenna_; std::string antenna_;
boost::shared_ptr<gr::block> valve_; std::shared_ptr<gr::block> valve_;
gr::blocks::file_sink::sptr file_sink_; gr::blocks::file_sink::sptr file_sink_;
std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue_; std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue_;
}; };

4
src/algorithms/signal_source/adapters/plutosdr_signal_source.h
View File

@@ -22,7 +22,7 @@
#define GNSS_SDR_PLUTOSDR_SIGNAL_SOURCE_H #define GNSS_SDR_PLUTOSDR_SIGNAL_SOURCE_H
#include "gnss_block_interface.h" #include "gnss_block_interface.h"
#include <boost/shared_ptr.hpp> #include <memory>
#include <gnuradio/blocks/file_sink.h> #include <gnuradio/blocks/file_sink.h>
#if GRIIO_INCLUDE_HAS_GNURADIO #if GRIIO_INCLUDE_HAS_GNURADIO
#include <gnuradio/iio/pluto_source.h> #include <gnuradio/iio/pluto_source.h>
@@ -103,7 +103,7 @@ private:
gr::iio::pluto_source::sptr plutosdr_source_; gr::iio::pluto_source::sptr plutosdr_source_;
boost::shared_ptr<gr::block> valve_; std::shared_ptr<gr::block> valve_;
gr::blocks::file_sink::sptr file_sink_; gr::blocks::file_sink::sptr file_sink_;
std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue_; std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue_;
}; };

4
src/algorithms/signal_source/adapters/rtl_tcp_signal_source.h
View File

@@ -24,7 +24,7 @@
#include "concurrent_queue.h" #include "concurrent_queue.h"
#include "gnss_block_interface.h" #include "gnss_block_interface.h"
#include "rtl_tcp_signal_source_c.h" #include "rtl_tcp_signal_source_c.h"
#include <boost/shared_ptr.hpp> #include <memory>
#include <gnuradio/blocks/deinterleave.h> #include <gnuradio/blocks/deinterleave.h>
#include <gnuradio/blocks/file_sink.h> #include <gnuradio/blocks/file_sink.h>
#include <gnuradio/blocks/float_to_complex.h> #include <gnuradio/blocks/float_to_complex.h>
@@ -102,7 +102,7 @@ private:
rtl_tcp_signal_source_c_sptr signal_source_; rtl_tcp_signal_source_c_sptr signal_source_;
boost::shared_ptr<gr::block> valve_; std::shared_ptr<gr::block> valve_;
gr::blocks::file_sink::sptr file_sink_; gr::blocks::file_sink::sptr file_sink_;
std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue_; std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue_;
}; };

2
src/algorithms/signal_source/adapters/spir_file_signal_source.h
View File

@@ -108,7 +108,7 @@ private:
unsigned int out_streams_; unsigned int out_streams_;
gr::blocks::file_source::sptr file_source_; gr::blocks::file_source::sptr file_source_;
unpack_intspir_1bit_samples_sptr unpack_intspir_; unpack_intspir_1bit_samples_sptr unpack_intspir_;
boost::shared_ptr<gr::block> valve_; std::shared_ptr<gr::block> valve_;
gr::blocks::file_sink::sptr sink_; gr::blocks::file_sink::sptr sink_;
gr::blocks::throttle::sptr throttle_; gr::blocks::throttle::sptr throttle_;
std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue_; std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue_;

2
src/algorithms/signal_source/adapters/spir_gss6450_file_signal_source.h
View File

@@ -119,7 +119,7 @@ private:
std::vector<gr::blocks::endian_swap::sptr> endian_vec_; std::vector<gr::blocks::endian_swap::sptr> endian_vec_;
std::vector<gr::blocks::null_sink::sptr> null_sinks_; std::vector<gr::blocks::null_sink::sptr> null_sinks_;
std::vector<unpack_spir_gss6450_samples_sptr> unpack_spir_vec_; std::vector<unpack_spir_gss6450_samples_sptr> unpack_spir_vec_;
std::vector<boost::shared_ptr<gr::block>> valve_vec_; std::vector<std::shared_ptr<gr::block>> valve_vec_;
std::vector<gr::blocks::file_sink::sptr> sink_vec_; std::vector<gr::blocks::file_sink::sptr> sink_vec_;
std::vector<gr::blocks::throttle::sptr> throttle_vec_; std::vector<gr::blocks::throttle::sptr> throttle_vec_;
std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue_; std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue_;

2
src/algorithms/signal_source/adapters/two_bit_cpx_file_signal_source.h
View File

@@ -115,7 +115,7 @@ private:
gr::blocks::file_source::sptr file_source_; gr::blocks::file_source::sptr file_source_;
unpack_byte_2bit_cpx_samples_sptr unpack_byte_; unpack_byte_2bit_cpx_samples_sptr unpack_byte_;
gr::blocks::interleaved_short_to_complex::sptr inter_shorts_to_cpx_; gr::blocks::interleaved_short_to_complex::sptr inter_shorts_to_cpx_;
boost::shared_ptr<gr::block> valve_; std::shared_ptr<gr::block> valve_;
gr::blocks::file_sink::sptr sink_; gr::blocks::file_sink::sptr sink_;
gr::blocks::throttle::sptr throttle_; gr::blocks::throttle::sptr throttle_;
std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue_; std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue_;

2
src/algorithms/signal_source/adapters/two_bit_packed_file_signal_source.h
View File

@@ -134,7 +134,7 @@ private:
gr::blocks::file_source::sptr file_source_; gr::blocks::file_source::sptr file_source_;
unpack_2bit_samples_sptr unpack_samples_; unpack_2bit_samples_sptr unpack_samples_;
gr::basic_block_sptr char_to_float_; gr::basic_block_sptr char_to_float_;
boost::shared_ptr<gr::block> valve_; std::shared_ptr<gr::block> valve_;
gr::blocks::file_sink::sptr sink_; gr::blocks::file_sink::sptr sink_;
gr::blocks::throttle::sptr throttle_; gr::blocks::throttle::sptr throttle_;
std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue_; std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue_;

4
src/algorithms/signal_source/adapters/uhd_signal_source.h
View File

@@ -22,7 +22,7 @@
#include "concurrent_queue.h" #include "concurrent_queue.h"
#include "gnss_block_interface.h" #include "gnss_block_interface.h"
#include <boost/shared_ptr.hpp> #include <memory>
#include <gnuradio/blocks/file_sink.h> #include <gnuradio/blocks/file_sink.h>
#include <gnuradio/hier_block2.h> #include <gnuradio/hier_block2.h>
#include <gnuradio/uhd/usrp_source.h> #include <gnuradio/uhd/usrp_source.h>
@@ -95,7 +95,7 @@ private:
std::vector<bool> dump_; std::vector<bool> dump_;
std::vector<std::string> dump_filename_; std::vector<std::string> dump_filename_;
std::vector<boost::shared_ptr<gr::block>> valve_; std::vector<std::shared_ptr<gr::block>> valve_;
std::vector<gr::blocks::file_sink::sptr> file_sink_; std::vector<gr::blocks::file_sink::sptr> file_sink_;
std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue_; std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue_;

2
src/algorithms/signal_source/gnuradio_blocks/gr_complex_ip_packet_source.h
View File

@@ -35,7 +35,7 @@
class Gr_Complex_Ip_Packet_Source : virtual public gr::sync_block class Gr_Complex_Ip_Packet_Source : virtual public gr::sync_block
{ {
public: public:
typedef boost::shared_ptr<Gr_Complex_Ip_Packet_Source> sptr; typedef std::shared_ptr<Gr_Complex_Ip_Packet_Source> sptr;
static sptr make(std::string src_device, static sptr make(std::string src_device,
const std::string &origin_address, const std::string &origin_address,
int udp_port, int udp_port,

2
src/algorithms/signal_source/gnuradio_blocks/labsat23_source.h
View File

@@ -31,7 +31,7 @@
class labsat23_source; class labsat23_source;
using labsat23_source_sptr = boost::shared_ptr<labsat23_source>; using labsat23_source_sptr = std::shared_ptr<labsat23_source>;
labsat23_source_sptr labsat23_make_source_sptr( labsat23_source_sptr labsat23_make_source_sptr(
const char *signal_file_basename, const char *signal_file_basename,

2
src/algorithms/signal_source/gnuradio_blocks/rtl_tcp_signal_source_c.h
View File

@@ -40,7 +40,7 @@
class rtl_tcp_signal_source_c; class rtl_tcp_signal_source_c;
using rtl_tcp_signal_source_c_sptr = boost::shared_ptr<rtl_tcp_signal_source_c>; using rtl_tcp_signal_source_c_sptr = std::shared_ptr<rtl_tcp_signal_source_c>;
#if BOOST_GREATER_1_65 #if BOOST_GREATER_1_65
using b_io_context = boost::asio::io_context; using b_io_context = boost::asio::io_context;

2
src/algorithms/signal_source/gnuradio_blocks/unpack_2bit_samples.h
View File

@@ -63,7 +63,7 @@
class unpack_2bit_samples; class unpack_2bit_samples;
using unpack_2bit_samples_sptr = boost::shared_ptr<unpack_2bit_samples>; using unpack_2bit_samples_sptr = std::shared_ptr<unpack_2bit_samples>;
unpack_2bit_samples_sptr make_unpack_2bit_samples( unpack_2bit_samples_sptr make_unpack_2bit_samples(
bool big_endian_bytes, bool big_endian_bytes,

2
src/algorithms/signal_source/gnuradio_blocks/unpack_byte_2bit_cpx_samples.h
View File

@@ -28,7 +28,7 @@
class unpack_byte_2bit_cpx_samples; class unpack_byte_2bit_cpx_samples;
using unpack_byte_2bit_cpx_samples_sptr = boost::shared_ptr<unpack_byte_2bit_cpx_samples>; using unpack_byte_2bit_cpx_samples_sptr = std::shared_ptr<unpack_byte_2bit_cpx_samples>;
unpack_byte_2bit_cpx_samples_sptr make_unpack_byte_2bit_cpx_samples(); unpack_byte_2bit_cpx_samples_sptr make_unpack_byte_2bit_cpx_samples();

2
src/algorithms/signal_source/gnuradio_blocks/unpack_byte_2bit_samples.h
View File

@@ -24,7 +24,7 @@
class unpack_byte_2bit_samples; class unpack_byte_2bit_samples;
using unpack_byte_2bit_samples_sptr = boost::shared_ptr<unpack_byte_2bit_samples>; using unpack_byte_2bit_samples_sptr = std::shared_ptr<unpack_byte_2bit_samples>;
unpack_byte_2bit_samples_sptr make_unpack_byte_2bit_samples(); unpack_byte_2bit_samples_sptr make_unpack_byte_2bit_samples();

2
src/algorithms/signal_source/gnuradio_blocks/unpack_byte_4bit_samples.h
View File

@@ -26,7 +26,7 @@
class unpack_byte_4bit_samples; class unpack_byte_4bit_samples;
using unpack_byte_4bit_samples_sptr = boost::shared_ptr<unpack_byte_4bit_samples>; using unpack_byte_4bit_samples_sptr = std::shared_ptr<unpack_byte_4bit_samples>;
unpack_byte_4bit_samples_sptr make_unpack_byte_4bit_samples(); unpack_byte_4bit_samples_sptr make_unpack_byte_4bit_samples();

2
src/algorithms/signal_source/gnuradio_blocks/unpack_intspir_1bit_samples.h
View File

@@ -24,7 +24,7 @@
class unpack_intspir_1bit_samples; class unpack_intspir_1bit_samples;
using unpack_intspir_1bit_samples_sptr = boost::shared_ptr<unpack_intspir_1bit_samples>; using unpack_intspir_1bit_samples_sptr = std::shared_ptr<unpack_intspir_1bit_samples>;
unpack_intspir_1bit_samples_sptr make_unpack_intspir_1bit_samples(); unpack_intspir_1bit_samples_sptr make_unpack_intspir_1bit_samples();

2
src/algorithms/signal_source/gnuradio_blocks/unpack_spir_gss6450_samples.h
View File

@@ -25,7 +25,7 @@
class unpack_spir_gss6450_samples; class unpack_spir_gss6450_samples;
using unpack_spir_gss6450_samples_sptr = boost::shared_ptr<unpack_spir_gss6450_samples>; using unpack_spir_gss6450_samples_sptr = std::shared_ptr<unpack_spir_gss6450_samples>;
unpack_spir_gss6450_samples_sptr make_unpack_spir_gss6450_samples(unsigned int adc_nbit_); unpack_spir_gss6450_samples_sptr make_unpack_spir_gss6450_samples(unsigned int adc_nbit_);

8
src/algorithms/signal_source/libs/gnss_sdr_valve.cc
View File

@@ -44,16 +44,16 @@ Gnss_Sdr_Valve::Gnss_Sdr_Valve(size_t sizeof_stream_item,
} }
boost::shared_ptr<Gnss_Sdr_Valve> gnss_sdr_make_valve(size_t sizeof_stream_item, uint64_t nitems, std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue, bool stop_flowgraph) std::shared_ptr<Gnss_Sdr_Valve> gnss_sdr_make_valve(size_t sizeof_stream_item, uint64_t nitems, std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue, bool stop_flowgraph)
{ {
boost::shared_ptr<Gnss_Sdr_Valve> valve_(new Gnss_Sdr_Valve(sizeof_stream_item, nitems, std::move(queue), stop_flowgraph)); std::shared_ptr<Gnss_Sdr_Valve> valve_(new Gnss_Sdr_Valve(sizeof_stream_item, nitems, std::move(queue), stop_flowgraph));
return valve_; return valve_;
} }
boost::shared_ptr<Gnss_Sdr_Valve> gnss_sdr_make_valve(size_t sizeof_stream_item, uint64_t nitems, std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue) std::shared_ptr<Gnss_Sdr_Valve> gnss_sdr_make_valve(size_t sizeof_stream_item, uint64_t nitems, std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue)
{ {
boost::shared_ptr<Gnss_Sdr_Valve> valve_(new Gnss_Sdr_Valve(sizeof_stream_item, nitems, std::move(queue), true)); std::shared_ptr<Gnss_Sdr_Valve> valve_(new Gnss_Sdr_Valve(sizeof_stream_item, nitems, std::move(queue), true));
return valve_; return valve_;
} }

10
src/algorithms/signal_source/libs/gnss_sdr_valve.h
View File

@@ -24,7 +24,7 @@
#define GNSS_SDR_GNSS_SDR_VALVE_H #define GNSS_SDR_GNSS_SDR_VALVE_H
#include "concurrent_queue.h" #include "concurrent_queue.h"
#include <boost/shared_ptr.hpp> #include <memory>
#include <gnuradio/sync_block.h> // for sync_block #include <gnuradio/sync_block.h> // for sync_block
#include <gnuradio/types.h> // for gr_vector_const_void_star #include <gnuradio/types.h> // for gr_vector_const_void_star
#include <pmt/pmt.h> #include <pmt/pmt.h>
@@ -34,12 +34,12 @@
class Gnss_Sdr_Valve; class Gnss_Sdr_Valve;
boost::shared_ptr<Gnss_Sdr_Valve> gnss_sdr_make_valve( std::shared_ptr<Gnss_Sdr_Valve> gnss_sdr_make_valve(
size_t sizeof_stream_item, size_t sizeof_stream_item,
uint64_t nitems, uint64_t nitems,
std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue); std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue);
boost::shared_ptr<Gnss_Sdr_Valve> gnss_sdr_make_valve( std::shared_ptr<Gnss_Sdr_Valve> gnss_sdr_make_valve(
size_t sizeof_stream_item, size_t sizeof_stream_item,
uint64_t nitems, uint64_t nitems,
std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue, std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue,
@@ -59,12 +59,12 @@ public:
gr_vector_void_star &output_items); gr_vector_void_star &output_items);
private: private:
friend boost::shared_ptr<Gnss_Sdr_Valve> gnss_sdr_make_valve( friend std::shared_ptr<Gnss_Sdr_Valve> gnss_sdr_make_valve(
size_t sizeof_stream_item, size_t sizeof_stream_item,
uint64_t nitems, uint64_t nitems,
std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue); std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue);
friend boost::shared_ptr<Gnss_Sdr_Valve> gnss_sdr_make_valve( friend std::shared_ptr<Gnss_Sdr_Valve> gnss_sdr_make_valve(
size_t sizeof_stream_item, size_t sizeof_stream_item,
uint64_t nitems, uint64_t nitems,
std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue, std::shared_ptr<Concurrent_Queue<pmt::pmt_t>> queue,

4
src/algorithms/telemetry_decoder/gnuradio_blocks/beidou_b1i_telemetry_decoder_gs.h
View File

@@ -26,7 +26,7 @@
#include "beidou_dnav_navigation_message.h" #include "beidou_dnav_navigation_message.h"
#include "gnss_satellite.h" #include "gnss_satellite.h"
#include <boost/circular_buffer.hpp> #include <boost/circular_buffer.hpp>
#include <boost/shared_ptr.hpp> // for boost::shared_ptr #include <memory> // for std::shared_ptr
#include <gnuradio/block.h> // for block #include <gnuradio/block.h> // for block
#include <gnuradio/types.h> // for gr_vector_const_void_star #include <gnuradio/types.h> // for gr_vector_const_void_star
#include <array> #include <array>
@@ -37,7 +37,7 @@
class beidou_b1i_telemetry_decoder_gs; class beidou_b1i_telemetry_decoder_gs;
using beidou_b1i_telemetry_decoder_gs_sptr = boost::shared_ptr<beidou_b1i_telemetry_decoder_gs>; using beidou_b1i_telemetry_decoder_gs_sptr = std::shared_ptr<beidou_b1i_telemetry_decoder_gs>;
beidou_b1i_telemetry_decoder_gs_sptr beidou_b1i_make_telemetry_decoder_gs( beidou_b1i_telemetry_decoder_gs_sptr beidou_b1i_make_telemetry_decoder_gs(
const Gnss_Satellite &satellite, const Gnss_Satellite &satellite,

4
src/algorithms/telemetry_decoder/gnuradio_blocks/beidou_b3i_telemetry_decoder_gs.h
View File

@@ -23,7 +23,7 @@
#include "beidou_dnav_navigation_message.h" #include "beidou_dnav_navigation_message.h"
#include "gnss_satellite.h" #include "gnss_satellite.h"
#include <boost/circular_buffer.hpp> #include <boost/circular_buffer.hpp>
#include <boost/shared_ptr.hpp> // for boost::shared_ptr #include <memory> // for std::shared_ptr
#include <gnuradio/block.h> // for block #include <gnuradio/block.h> // for block
#include <gnuradio/types.h> // for gr_vector_const_void_star #include <gnuradio/types.h> // for gr_vector_const_void_star
#include <array> #include <array>
@@ -34,7 +34,7 @@
class beidou_b3i_telemetry_decoder_gs; class beidou_b3i_telemetry_decoder_gs;
using beidou_b3i_telemetry_decoder_gs_sptr = using beidou_b3i_telemetry_decoder_gs_sptr =
boost::shared_ptr<beidou_b3i_telemetry_decoder_gs>; std::shared_ptr<beidou_b3i_telemetry_decoder_gs>;
beidou_b3i_telemetry_decoder_gs_sptr beidou_b3i_make_telemetry_decoder_gs( beidou_b3i_telemetry_decoder_gs_sptr beidou_b3i_make_telemetry_decoder_gs(
const Gnss_Satellite &satellite, const Gnss_Satellite &satellite,

4
src/algorithms/telemetry_decoder/gnuradio_blocks/galileo_telemetry_decoder_gs.h
View File

@@ -26,7 +26,7 @@
#include "galileo_navigation_message.h" #include "galileo_navigation_message.h"
#include "gnss_satellite.h" #include "gnss_satellite.h"
#include <boost/circular_buffer.hpp> #include <boost/circular_buffer.hpp>
#include <boost/shared_ptr.hpp> // for boost::shared_ptr #include <memory> // for std::shared_ptr
#include <gnuradio/block.h> // for block #include <gnuradio/block.h> // for block
#include <gnuradio/types.h> // for gr_vector_const_void_star #include <gnuradio/types.h> // for gr_vector_const_void_star
#include <array> #include <array>
@@ -37,7 +37,7 @@
class galileo_telemetry_decoder_gs; class galileo_telemetry_decoder_gs;
using galileo_telemetry_decoder_gs_sptr = boost::shared_ptr<galileo_telemetry_decoder_gs>; using galileo_telemetry_decoder_gs_sptr = std::shared_ptr<galileo_telemetry_decoder_gs>;
galileo_telemetry_decoder_gs_sptr galileo_make_telemetry_decoder_gs( galileo_telemetry_decoder_gs_sptr galileo_make_telemetry_decoder_gs(
const Gnss_Satellite &satellite, const Gnss_Satellite &satellite,

4
src/algorithms/telemetry_decoder/gnuradio_blocks/glonass_l1_ca_telemetry_decoder_gs.h
View File

@@ -27,7 +27,7 @@
#include "gnss_satellite.h" #include "gnss_satellite.h"
#include "gnss_synchro.h" #include "gnss_synchro.h"
#include <boost/circular_buffer.hpp> #include <boost/circular_buffer.hpp>
#include <boost/shared_ptr.hpp> // for boost::shared_ptr #include <memory> // for std::shared_ptr
#include <gnuradio/block.h> // for block #include <gnuradio/block.h> // for block
#include <gnuradio/types.h> // for gr_vector_const_void_star #include <gnuradio/types.h> // for gr_vector_const_void_star
#include <array> #include <array>
@@ -38,7 +38,7 @@
class glonass_l1_ca_telemetry_decoder_gs; class glonass_l1_ca_telemetry_decoder_gs;
using glonass_l1_ca_telemetry_decoder_gs_sptr = boost::shared_ptr<glonass_l1_ca_telemetry_decoder_gs>; using glonass_l1_ca_telemetry_decoder_gs_sptr = std::shared_ptr<glonass_l1_ca_telemetry_decoder_gs>;
glonass_l1_ca_telemetry_decoder_gs_sptr glonass_l1_ca_make_telemetry_decoder_gs( glonass_l1_ca_telemetry_decoder_gs_sptr glonass_l1_ca_make_telemetry_decoder_gs(
const Gnss_Satellite &satellite, const Gnss_Satellite &satellite,

4
src/algorithms/telemetry_decoder/gnuradio_blocks/glonass_l2_ca_telemetry_decoder_gs.h
View File

@@ -26,7 +26,7 @@
#include "gnss_satellite.h" #include "gnss_satellite.h"
#include "gnss_synchro.h" #include "gnss_synchro.h"
#include <boost/circular_buffer.hpp> #include <boost/circular_buffer.hpp>
#include <boost/shared_ptr.hpp> // for boost::shared_ptr #include <memory> // for std::shared_ptr
#include <gnuradio/block.h> #include <gnuradio/block.h>
#include <gnuradio/types.h> // for gr_vector_const_void_star #include <gnuradio/types.h> // for gr_vector_const_void_star
#include <array> #include <array>
@@ -37,7 +37,7 @@
class glonass_l2_ca_telemetry_decoder_gs; class glonass_l2_ca_telemetry_decoder_gs;
using glonass_l2_ca_telemetry_decoder_gs_sptr = boost::shared_ptr<glonass_l2_ca_telemetry_decoder_gs>; using glonass_l2_ca_telemetry_decoder_gs_sptr = std::shared_ptr<glonass_l2_ca_telemetry_decoder_gs>;
glonass_l2_ca_telemetry_decoder_gs_sptr glonass_l2_ca_make_telemetry_decoder_gs( glonass_l2_ca_telemetry_decoder_gs_sptr glonass_l2_ca_make_telemetry_decoder_gs(
const Gnss_Satellite &satellite, const Gnss_Satellite &satellite,

4
src/algorithms/telemetry_decoder/gnuradio_blocks/gps_l1_ca_telemetry_decoder_gs.h
View File

@@ -25,7 +25,7 @@
#include "gnss_synchro.h" #include "gnss_synchro.h"
#include "gps_navigation_message.h" #include "gps_navigation_message.h"
#include <boost/circular_buffer.hpp> #include <boost/circular_buffer.hpp>
#include <boost/shared_ptr.hpp> // for boost::shared_ptr #include <memory> // for std::shared_ptr
#include <gnuradio/block.h> // for block #include <gnuradio/block.h> // for block
#include <gnuradio/types.h> // for gr_vector_const_void_star #include <gnuradio/types.h> // for gr_vector_const_void_star
#include <array> // for array #include <array> // for array
@@ -36,7 +36,7 @@
class gps_l1_ca_telemetry_decoder_gs; class gps_l1_ca_telemetry_decoder_gs;
using gps_l1_ca_telemetry_decoder_gs_sptr = boost::shared_ptr<gps_l1_ca_telemetry_decoder_gs>; using gps_l1_ca_telemetry_decoder_gs_sptr = std::shared_ptr<gps_l1_ca_telemetry_decoder_gs>;
gps_l1_ca_telemetry_decoder_gs_sptr gps_l1_ca_make_telemetry_decoder_gs( gps_l1_ca_telemetry_decoder_gs_sptr gps_l1_ca_make_telemetry_decoder_gs(
const Gnss_Satellite &satellite, const Gnss_Satellite &satellite,

4
src/algorithms/telemetry_decoder/gnuradio_blocks/gps_l2c_telemetry_decoder_gs.h
View File

@@ -22,11 +22,11 @@
#include "gnss_satellite.h" #include "gnss_satellite.h"
#include "gps_cnav_navigation_message.h" #include "gps_cnav_navigation_message.h"
#include <boost/shared_ptr.hpp> // for boost::shared_ptr
#include <gnuradio/block.h> #include <gnuradio/block.h>
#include <gnuradio/types.h> // for gr_vector_const_void_star #include <gnuradio/types.h> // for gr_vector_const_void_star
#include <cstdint> #include <cstdint>
#include <fstream> #include <fstream>
#include <memory> // for std::shared_ptr
#include <string> #include <string>
extern "C" extern "C"
@@ -37,7 +37,7 @@ extern "C"
class gps_l2c_telemetry_decoder_gs; class gps_l2c_telemetry_decoder_gs;
using gps_l2c_telemetry_decoder_gs_sptr = boost::shared_ptr<gps_l2c_telemetry_decoder_gs>; using gps_l2c_telemetry_decoder_gs_sptr = std::shared_ptr<gps_l2c_telemetry_decoder_gs>;
gps_l2c_telemetry_decoder_gs_sptr gps_l2c_make_telemetry_decoder_gs( gps_l2c_telemetry_decoder_gs_sptr gps_l2c_make_telemetry_decoder_gs(
const Gnss_Satellite &satellite, const Gnss_Satellite &satellite,

4
src/algorithms/telemetry_decoder/gnuradio_blocks/gps_l5_telemetry_decoder_gs.h
View File

@@ -24,7 +24,7 @@
#include "gnss_satellite.h" // for Gnss_Satellite #include "gnss_satellite.h" // for Gnss_Satellite
#include "gps_cnav_navigation_message.h" // for Gps_CNAV_Navigation_Message #include "gps_cnav_navigation_message.h" // for Gps_CNAV_Navigation_Message
#include <boost/circular_buffer.hpp> #include <boost/circular_buffer.hpp>
#include <boost/shared_ptr.hpp> // for boost::shared_ptr #include <memory> // for std::shared_ptr
#include <gnuradio/block.h> #include <gnuradio/block.h>
#include <gnuradio/types.h> // for gr_vector_const_void_star #include <gnuradio/types.h> // for gr_vector_const_void_star
#include <cstdint> #include <cstdint>
@@ -39,7 +39,7 @@ extern "C"
class gps_l5_telemetry_decoder_gs; class gps_l5_telemetry_decoder_gs;
using gps_l5_telemetry_decoder_gs_sptr = boost::shared_ptr<gps_l5_telemetry_decoder_gs>; using gps_l5_telemetry_decoder_gs_sptr = std::shared_ptr<gps_l5_telemetry_decoder_gs>;
gps_l5_telemetry_decoder_gs_sptr gps_l5_make_telemetry_decoder_gs( gps_l5_telemetry_decoder_gs_sptr gps_l5_make_telemetry_decoder_gs(
const Gnss_Satellite &satellite, const Gnss_Satellite &satellite,

4
src/algorithms/telemetry_decoder/gnuradio_blocks/sbas_l1_telemetry_decoder_gs.h
View File

@@ -22,7 +22,7 @@
#include "gnss_satellite.h" #include "gnss_satellite.h"
#include <boost/crc.hpp> // for crc_optimal #include <boost/crc.hpp> // for crc_optimal
#include <boost/shared_ptr.hpp> // for boost::shared_ptr #include <memory> // for std::shared_ptr
#include <gnuradio/block.h> #include <gnuradio/block.h>
#include <gnuradio/types.h> // for gr_vector_const_void_star #include <gnuradio/types.h> // for gr_vector_const_void_star
#include <cstddef> // for size_t #include <cstddef> // for size_t
@@ -38,7 +38,7 @@ class Viterbi_Decoder;
class sbas_l1_telemetry_decoder_gs; class sbas_l1_telemetry_decoder_gs;
using sbas_l1_telemetry_decoder_gs_sptr = boost::shared_ptr<sbas_l1_telemetry_decoder_gs>; using sbas_l1_telemetry_decoder_gs_sptr = std::shared_ptr<sbas_l1_telemetry_decoder_gs>;
sbas_l1_telemetry_decoder_gs_sptr sbas_l1_make_telemetry_decoder_gs( sbas_l1_telemetry_decoder_gs_sptr sbas_l1_make_telemetry_decoder_gs(
const Gnss_Satellite &satellite, const Gnss_Satellite &satellite,

4
src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking.h
View File

@@ -27,7 +27,7 @@
#include "tracking_FLL_PLL_filter.h" // for PLL/FLL filter #include "tracking_FLL_PLL_filter.h" // for PLL/FLL filter
#include "tracking_loop_filter.h" // for DLL filter #include "tracking_loop_filter.h" // for DLL filter
#include <boost/circular_buffer.hpp> #include <boost/circular_buffer.hpp>
#include <boost/shared_ptr.hpp> // for boost::shared_ptr #include <memory> // for std::shared_ptr
#include <gnuradio/block.h> // for block #include <gnuradio/block.h> // for block
#include <gnuradio/gr_complex.h> // for gr_complex #include <gnuradio/gr_complex.h> // for gr_complex
#include <gnuradio/types.h> // for gr_vector_int, gr_vector... #include <gnuradio/types.h> // for gr_vector_int, gr_vector...
@@ -41,7 +41,7 @@
class Gnss_Synchro; class Gnss_Synchro;
class dll_pll_veml_tracking; class dll_pll_veml_tracking;
using dll_pll_veml_tracking_sptr = boost::shared_ptr<dll_pll_veml_tracking>; using dll_pll_veml_tracking_sptr = std::shared_ptr<dll_pll_veml_tracking>;
dll_pll_veml_tracking_sptr dll_pll_veml_make_tracking(const Dll_Pll_Conf &conf_); dll_pll_veml_tracking_sptr dll_pll_veml_make_tracking(const Dll_Pll_Conf &conf_);

4
src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking_fpga.h
View File

@@ -26,7 +26,7 @@
#include "tracking_FLL_PLL_filter.h" // for PLL/FLL filter #include "tracking_FLL_PLL_filter.h" // for PLL/FLL filter
#include "tracking_loop_filter.h" // for DLL filter #include "tracking_loop_filter.h" // for DLL filter
#include <boost/circular_buffer.hpp> #include <boost/circular_buffer.hpp>
#include <boost/shared_ptr.hpp> // for boost::shared_ptr #include <memory> // for std::shared_ptr
#include <gnuradio/block.h> // for block #include <gnuradio/block.h> // for block
#include <gnuradio/gr_complex.h> // for gr_complex #include <gnuradio/gr_complex.h> // for gr_complex
#include <gnuradio/types.h> // for gr_vector_int, gr_vector... #include <gnuradio/types.h> // for gr_vector_int, gr_vector...
@@ -42,7 +42,7 @@ class Fpga_Multicorrelator_8sc;
class Gnss_Synchro; class Gnss_Synchro;
class dll_pll_veml_tracking_fpga; class dll_pll_veml_tracking_fpga;
using dll_pll_veml_tracking_fpga_sptr = boost::shared_ptr<dll_pll_veml_tracking_fpga>; using dll_pll_veml_tracking_fpga_sptr = std::shared_ptr<dll_pll_veml_tracking_fpga>;
dll_pll_veml_tracking_fpga_sptr dll_pll_veml_make_tracking_fpga(const Dll_Pll_Conf_Fpga &conf_); dll_pll_veml_tracking_fpga_sptr dll_pll_veml_make_tracking_fpga(const Dll_Pll_Conf_Fpga &conf_);

2
src/algorithms/tracking/gnuradio_blocks/galileo_e1_tcp_connector_tracking_cc.h
View File

@@ -40,7 +40,7 @@
class Galileo_E1_Tcp_Connector_Tracking_cc; class Galileo_E1_Tcp_Connector_Tracking_cc;
using galileo_e1_tcp_connector_tracking_cc_sptr = boost::shared_ptr<Galileo_E1_Tcp_Connector_Tracking_cc>; using galileo_e1_tcp_connector_tracking_cc_sptr = std::shared_ptr<Galileo_E1_Tcp_Connector_Tracking_cc>;
galileo_e1_tcp_connector_tracking_cc_sptr galileo_e1_tcp_connector_tracking_cc_sptr
galileo_e1_tcp_connector_make_tracking_cc( galileo_e1_tcp_connector_make_tracking_cc(

2
src/algorithms/tracking/gnuradio_blocks/glonass_l1_ca_dll_pll_c_aid_tracking_cc.h
View File

@@ -44,7 +44,7 @@
class glonass_l1_ca_dll_pll_c_aid_tracking_cc; class glonass_l1_ca_dll_pll_c_aid_tracking_cc;
using glonass_l1_ca_dll_pll_c_aid_tracking_cc_sptr = boost::shared_ptr<glonass_l1_ca_dll_pll_c_aid_tracking_cc>; using glonass_l1_ca_dll_pll_c_aid_tracking_cc_sptr = std::shared_ptr<glonass_l1_ca_dll_pll_c_aid_tracking_cc>;
glonass_l1_ca_dll_pll_c_aid_tracking_cc_sptr glonass_l1_ca_dll_pll_c_aid_tracking_cc_sptr
glonass_l1_ca_dll_pll_c_aid_make_tracking_cc( glonass_l1_ca_dll_pll_c_aid_make_tracking_cc(

2
src/algorithms/tracking/gnuradio_blocks/glonass_l1_ca_dll_pll_c_aid_tracking_sc.h
View File

@@ -43,7 +43,7 @@
class glonass_l1_ca_dll_pll_c_aid_tracking_sc; class glonass_l1_ca_dll_pll_c_aid_tracking_sc;
using glonass_l1_ca_dll_pll_c_aid_tracking_sc_sptr = boost::shared_ptr<glonass_l1_ca_dll_pll_c_aid_tracking_sc>; using glonass_l1_ca_dll_pll_c_aid_tracking_sc_sptr = std::shared_ptr<glonass_l1_ca_dll_pll_c_aid_tracking_sc>;
glonass_l1_ca_dll_pll_c_aid_tracking_sc_sptr glonass_l1_ca_dll_pll_c_aid_tracking_sc_sptr
glonass_l1_ca_dll_pll_c_aid_make_tracking_sc( glonass_l1_ca_dll_pll_c_aid_make_tracking_sc(

2
src/algorithms/tracking/gnuradio_blocks/glonass_l1_ca_dll_pll_tracking_cc.h
View File

@@ -40,7 +40,7 @@
class Glonass_L1_Ca_Dll_Pll_Tracking_cc; class Glonass_L1_Ca_Dll_Pll_Tracking_cc;
using glonass_l1_ca_dll_pll_tracking_cc_sptr = boost::shared_ptr<Glonass_L1_Ca_Dll_Pll_Tracking_cc>; using glonass_l1_ca_dll_pll_tracking_cc_sptr = std::shared_ptr<Glonass_L1_Ca_Dll_Pll_Tracking_cc>;
glonass_l1_ca_dll_pll_tracking_cc_sptr glonass_l1_ca_dll_pll_tracking_cc_sptr
glonass_l1_ca_dll_pll_make_tracking_cc( glonass_l1_ca_dll_pll_make_tracking_cc(

2
src/algorithms/tracking/gnuradio_blocks/glonass_l2_ca_dll_pll_c_aid_tracking_cc.h
View File

@@ -40,7 +40,7 @@
class glonass_l2_ca_dll_pll_c_aid_tracking_cc; class glonass_l2_ca_dll_pll_c_aid_tracking_cc;
using glonass_l2_ca_dll_pll_c_aid_tracking_cc_sptr = boost::shared_ptr<glonass_l2_ca_dll_pll_c_aid_tracking_cc>; using glonass_l2_ca_dll_pll_c_aid_tracking_cc_sptr = std::shared_ptr<glonass_l2_ca_dll_pll_c_aid_tracking_cc>;
glonass_l2_ca_dll_pll_c_aid_tracking_cc_sptr glonass_l2_ca_dll_pll_c_aid_tracking_cc_sptr
glonass_l2_ca_dll_pll_c_aid_make_tracking_cc( glonass_l2_ca_dll_pll_c_aid_make_tracking_cc(

2
src/algorithms/tracking/gnuradio_blocks/glonass_l2_ca_dll_pll_c_aid_tracking_sc.h
View File

@@ -40,7 +40,7 @@
class glonass_l2_ca_dll_pll_c_aid_tracking_sc; class glonass_l2_ca_dll_pll_c_aid_tracking_sc;
using glonass_l2_ca_dll_pll_c_aid_tracking_sc_sptr = boost::shared_ptr<glonass_l2_ca_dll_pll_c_aid_tracking_sc>; using glonass_l2_ca_dll_pll_c_aid_tracking_sc_sptr = std::shared_ptr<glonass_l2_ca_dll_pll_c_aid_tracking_sc>;
glonass_l2_ca_dll_pll_c_aid_tracking_sc_sptr glonass_l2_ca_dll_pll_c_aid_tracking_sc_sptr
glonass_l2_ca_dll_pll_c_aid_make_tracking_sc( glonass_l2_ca_dll_pll_c_aid_make_tracking_sc(

2
src/algorithms/tracking/gnuradio_blocks/glonass_l2_ca_dll_pll_tracking_cc.h
View File

@@ -38,7 +38,7 @@
class Glonass_L2_Ca_Dll_Pll_Tracking_cc; class Glonass_L2_Ca_Dll_Pll_Tracking_cc;
using glonass_l2_ca_dll_pll_tracking_cc_sptr = boost::shared_ptr<Glonass_L2_Ca_Dll_Pll_Tracking_cc>; using glonass_l2_ca_dll_pll_tracking_cc_sptr = std::shared_ptr<Glonass_L2_Ca_Dll_Pll_Tracking_cc>;
glonass_l2_ca_dll_pll_tracking_cc_sptr glonass_l2_ca_dll_pll_tracking_cc_sptr
glonass_l2_ca_dll_pll_make_tracking_cc( glonass_l2_ca_dll_pll_make_tracking_cc(

2
src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_dll_pll_tracking_gpu_cc.h
View File

@@ -38,7 +38,7 @@
class Gps_L1_Ca_Dll_Pll_Tracking_GPU_cc; class Gps_L1_Ca_Dll_Pll_Tracking_GPU_cc;
typedef boost::shared_ptr<Gps_L1_Ca_Dll_Pll_Tracking_GPU_cc> typedef std::shared_ptr<Gps_L1_Ca_Dll_Pll_Tracking_GPU_cc>
gps_l1_ca_dll_pll_tracking_gpu_cc_sptr; gps_l1_ca_dll_pll_tracking_gpu_cc_sptr;
gps_l1_ca_dll_pll_tracking_gpu_cc_sptr gps_l1_ca_dll_pll_tracking_gpu_cc_sptr

2
src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_kf_tracking_cc.h
View File

@@ -47,7 +47,7 @@
class Gps_L1_Ca_Kf_Tracking_cc; class Gps_L1_Ca_Kf_Tracking_cc;
using gps_l1_ca_kf_tracking_cc_sptr = boost::shared_ptr<Gps_L1_Ca_Kf_Tracking_cc>; using gps_l1_ca_kf_tracking_cc_sptr = std::shared_ptr<Gps_L1_Ca_Kf_Tracking_cc>;
gps_l1_ca_kf_tracking_cc_sptr gps_l1_ca_kf_tracking_cc_sptr
gps_l1_ca_kf_make_tracking_cc(uint32_t order, gps_l1_ca_kf_make_tracking_cc(uint32_t order,

2
src/algorithms/tracking/gnuradio_blocks/gps_l1_ca_tcp_connector_tracking_cc.h
View File

@@ -38,7 +38,7 @@
class Gps_L1_Ca_Tcp_Connector_Tracking_cc; class Gps_L1_Ca_Tcp_Connector_Tracking_cc;
using gps_l1_ca_tcp_connector_tracking_cc_sptr = boost::shared_ptr<Gps_L1_Ca_Tcp_Connector_Tracking_cc>; using gps_l1_ca_tcp_connector_tracking_cc_sptr = std::shared_ptr<Gps_L1_Ca_Tcp_Connector_Tracking_cc>;
gps_l1_ca_tcp_connector_tracking_cc_sptr gps_l1_ca_tcp_connector_tracking_cc_sptr
gps_l1_ca_tcp_connector_make_tracking_cc( gps_l1_ca_tcp_connector_make_tracking_cc(

2
src/core/libs/channel_status_msg_receiver.h
View File

@@ -29,7 +29,7 @@
class channel_status_msg_receiver; class channel_status_msg_receiver;
using channel_status_msg_receiver_sptr = boost::shared_ptr<channel_status_msg_receiver>; using channel_status_msg_receiver_sptr = std::shared_ptr<channel_status_msg_receiver>;
channel_status_msg_receiver_sptr channel_status_msg_receiver_make(); channel_status_msg_receiver_sptr channel_status_msg_receiver_make();

4
src/core/libs/gnss_sdr_fpga_sample_counter.h
View File

@@ -22,7 +22,7 @@
#ifndef GNSS_SDR_GNSS_SDR_FPGA_SAMPLE_COUNTER_H #ifndef GNSS_SDR_GNSS_SDR_FPGA_SAMPLE_COUNTER_H
#define GNSS_SDR_GNSS_SDR_FPGA_SAMPLE_COUNTER_H #define GNSS_SDR_GNSS_SDR_FPGA_SAMPLE_COUNTER_H
#include <boost/shared_ptr.hpp> #include <memory>
#include <gnuradio/block.h> #include <gnuradio/block.h>
#include <gnuradio/types.h> // for gr_vector_const_void_star #include <gnuradio/types.h> // for gr_vector_const_void_star
#include <cstdint> #include <cstdint>
@@ -30,7 +30,7 @@
class gnss_sdr_fpga_sample_counter; class gnss_sdr_fpga_sample_counter;
using gnss_sdr_fpga_sample_counter_sptr = boost::shared_ptr<gnss_sdr_fpga_sample_counter>; using gnss_sdr_fpga_sample_counter_sptr = std::shared_ptr<gnss_sdr_fpga_sample_counter>;
gnss_sdr_fpga_sample_counter_sptr gnss_sdr_make_fpga_sample_counter(double _fs, int32_t _interval_ms); gnss_sdr_fpga_sample_counter_sptr gnss_sdr_make_fpga_sample_counter(double _fs, int32_t _interval_ms);

4
src/core/libs/gnss_sdr_sample_counter.h
View File

@@ -21,7 +21,7 @@
#ifndef GNSS_SDR_GNSS_SDR_SAMPLE_COUNTER_H #ifndef GNSS_SDR_GNSS_SDR_SAMPLE_COUNTER_H
#define GNSS_SDR_GNSS_SDR_SAMPLE_COUNTER_H #define GNSS_SDR_GNSS_SDR_SAMPLE_COUNTER_H
#include <boost/shared_ptr.hpp> #include <memory>
#include <gnuradio/sync_decimator.h> #include <gnuradio/sync_decimator.h>
#include <gnuradio/types.h> // for gr_vector_const_void_star #include <gnuradio/types.h> // for gr_vector_const_void_star
#include <cstddef> // for size_t #include <cstddef> // for size_t
@@ -30,7 +30,7 @@
class gnss_sdr_sample_counter; class gnss_sdr_sample_counter;
using gnss_sdr_sample_counter_sptr = boost::shared_ptr<gnss_sdr_sample_counter>; using gnss_sdr_sample_counter_sptr = std::shared_ptr<gnss_sdr_sample_counter>;
gnss_sdr_sample_counter_sptr gnss_sdr_make_sample_counter( gnss_sdr_sample_counter_sptr gnss_sdr_make_sample_counter(
double _fs, double _fs,

4
src/core/libs/gnss_sdr_time_counter.h
View File

@@ -21,14 +21,14 @@
#ifndef GNSS_SDR_GNSS_SDR_TIME_COUNTER_H #ifndef GNSS_SDR_GNSS_SDR_TIME_COUNTER_H
#define GNSS_SDR_GNSS_SDR_TIME_COUNTER_H #define GNSS_SDR_GNSS_SDR_TIME_COUNTER_H
#include <boost/shared_ptr.hpp> #include <memory>
#include <gnuradio/block.h> #include <gnuradio/block.h>
#include <gnuradio/types.h> // for gr_vector_const_void_star #include <gnuradio/types.h> // for gr_vector_const_void_star
#include <cstdint> #include <cstdint>
class gnss_sdr_time_counter; class gnss_sdr_time_counter;
using gnss_sdr_time_counter_sptr = boost::shared_ptr<gnss_sdr_time_counter>; using gnss_sdr_time_counter_sptr = std::shared_ptr<gnss_sdr_time_counter>;
gnss_sdr_time_counter_sptr gnss_sdr_make_time_counter(); gnss_sdr_time_counter_sptr gnss_sdr_make_time_counter();

4
src/core/monitor/gnss_synchro_monitor.h
View File

@@ -24,7 +24,7 @@
#define GNSS_SDR_GNSS_SYNCHRO_MONITOR_H #define GNSS_SDR_GNSS_SYNCHRO_MONITOR_H
#include "gnss_synchro_udp_sink.h" #include "gnss_synchro_udp_sink.h"
#include <boost/shared_ptr.hpp> #include <memory>
#include <gnuradio/runtime_types.h> // for gr_vector_void_star #include <gnuradio/runtime_types.h> // for gr_vector_void_star
#include <gnuradio/sync_block.h> #include <gnuradio/sync_block.h>
#include <memory> #include <memory>
@@ -34,7 +34,7 @@
class gnss_synchro_monitor; class gnss_synchro_monitor;
using gnss_synchro_monitor_sptr = boost::shared_ptr<gnss_synchro_monitor>; using gnss_synchro_monitor_sptr = std::shared_ptr<gnss_synchro_monitor>;
gnss_synchro_monitor_sptr gnss_synchro_make_monitor(unsigned int n_channels, gnss_synchro_monitor_sptr gnss_synchro_make_monitor(unsigned int n_channels,
int decimation_factor, int decimation_factor,

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

@@ -36,7 +36,6 @@
#include "gnss_satellite.h" #include "gnss_satellite.h"
#include "gnss_synchro_monitor.h" #include "gnss_synchro_monitor.h"
#include <boost/lexical_cast.hpp> // for boost::lexical_cast #include <boost/lexical_cast.hpp> // for boost::lexical_cast
#include <boost/shared_ptr.hpp> // for boost::shared_ptr
#include <boost/tokenizer.hpp> // for boost::tokenizer #include <boost/tokenizer.hpp> // for boost::tokenizer
#include <glog/logging.h> // for LOG #include <glog/logging.h> // for LOG
#include <gnuradio/basic_block.h> // for basic_block #include <gnuradio/basic_block.h> // for basic_block
@@ -50,6 +49,7 @@
#include <exception> // for exception #include <exception> // for exception
#include <iostream> // for operator<< #include <iostream> // for operator<<
#include <iterator> // for insert_iterator, inserter #include <iterator> // for insert_iterator, inserter
#include <memory> // for std::shared_ptr
#include <set> // for set #include <set> // for set
#include <stdexcept> // for invalid_argument #include <stdexcept> // for invalid_argument
#include <thread> // for thread #include <thread> // for thread

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

@@ -100,7 +100,7 @@ DEFINE_bool(acq_test_dump, false, "Dump the results of an acquisition block into
// ######## GNURADIO BLOCK MESSAGE RECEVER ######### // ######## GNURADIO BLOCK MESSAGE RECEVER #########
class AcqPerfTest_msg_rx; class AcqPerfTest_msg_rx;
using AcqPerfTest_msg_rx_sptr = boost::shared_ptr<AcqPerfTest_msg_rx>; using AcqPerfTest_msg_rx_sptr = std::shared_ptr<AcqPerfTest_msg_rx>;
AcqPerfTest_msg_rx_sptr AcqPerfTest_msg_rx_make(Concurrent_Queue<int>& queue); AcqPerfTest_msg_rx_sptr AcqPerfTest_msg_rx_make(Concurrent_Queue<int>& queue);
@@ -577,7 +577,7 @@ int AcquisitionPerformanceTest::run_receiver()
gr::blocks::interleaved_char_to_complex::sptr gr_interleaved_char_to_complex = gr::blocks::interleaved_char_to_complex::make(); gr::blocks::interleaved_char_to_complex::sptr gr_interleaved_char_to_complex = gr::blocks::interleaved_char_to_complex::make();
top_block = gr::make_top_block("Acquisition test"); top_block = gr::make_top_block("Acquisition test");
boost::shared_ptr<AcqPerfTest_msg_rx> msg_rx = AcqPerfTest_msg_rx_make(channel_internal_queue); std::shared_ptr<AcqPerfTest_msg_rx> msg_rx = AcqPerfTest_msg_rx_make(channel_internal_queue);
gr::blocks::skiphead::sptr skiphead = gr::blocks::skiphead::make(sizeof(gr_complex), FLAGS_acq_test_skiphead); gr::blocks::skiphead::sptr skiphead = gr::blocks::skiphead::make(sizeof(gr_complex), FLAGS_acq_test_skiphead);
queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>(); queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>();
@@ -585,7 +585,7 @@ int AcquisitionPerformanceTest::run_receiver()
init(); init();
int nsamples = floor(config->property("GNSS-SDR.internal_fs_sps", 2000000) * generated_signal_duration_s); int nsamples = floor(config->property("GNSS-SDR.internal_fs_sps", 2000000) * generated_signal_duration_s);
boost::shared_ptr<gr::block> valve = gnss_sdr_make_valve(sizeof(gr_complex), nsamples, queue); std::shared_ptr<gr::block> valve = gnss_sdr_make_valve(sizeof(gr_complex), nsamples, queue);
if (implementation == "GPS_L1_CA_PCPS_Acquisition") if (implementation == "GPS_L1_CA_PCPS_Acquisition")
{ {
acquisition = std::make_shared<GpsL1CaPcpsAcquisition>(config.get(), "Acquisition", 1, 0); acquisition = std::make_shared<GpsL1CaPcpsAcquisition>(config.get(), "Acquisition", 1, 0);

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

@@ -64,7 +64,7 @@ namespace fs = boost::filesystem;
// ######## GNURADIO BLOCK MESSAGE RECEVER ######### // ######## GNURADIO BLOCK MESSAGE RECEVER #########
class BeidouB1iPcpsAcquisitionTest_msg_rx; class BeidouB1iPcpsAcquisitionTest_msg_rx;
using BeidouB1iPcpsAcquisitionTest_msg_rx_sptr = boost::shared_ptr<BeidouB1iPcpsAcquisitionTest_msg_rx>; using BeidouB1iPcpsAcquisitionTest_msg_rx_sptr = std::shared_ptr<BeidouB1iPcpsAcquisitionTest_msg_rx>;
BeidouB1iPcpsAcquisitionTest_msg_rx_sptr BeidouB1iPcpsAcquisitionTest_msg_rx_make(); BeidouB1iPcpsAcquisitionTest_msg_rx_sptr BeidouB1iPcpsAcquisitionTest_msg_rx_make();
@@ -241,7 +241,7 @@ void BeidouB1iPcpsAcquisitionTest::plot_grid()
TEST_F(BeidouB1iPcpsAcquisitionTest, Instantiate) TEST_F(BeidouB1iPcpsAcquisitionTest, Instantiate)
{ {
init(); init();
boost::shared_ptr<BeidouB1iPcpsAcquisition> acquisition = boost::make_shared<BeidouB1iPcpsAcquisition>(config.get(), "Acquisition_B1", 1, 0); std::shared_ptr<BeidouB1iPcpsAcquisition> acquisition = boost::make_shared<BeidouB1iPcpsAcquisition>(config.get(), "Acquisition_B1", 1, 0);
} }
@@ -255,13 +255,13 @@ TEST_F(BeidouB1iPcpsAcquisitionTest, ConnectAndRun)
top_block = gr::make_top_block("Acquisition test"); top_block = gr::make_top_block("Acquisition test");
init(); init();
boost::shared_ptr<BeidouB1iPcpsAcquisition> acquisition = boost::make_shared<BeidouB1iPcpsAcquisition>(config.get(), "Acquisition_B1", 1, 0); std::shared_ptr<BeidouB1iPcpsAcquisition> acquisition = boost::make_shared<BeidouB1iPcpsAcquisition>(config.get(), "Acquisition_B1", 1, 0);
boost::shared_ptr<BeidouB1iPcpsAcquisitionTest_msg_rx> msg_rx = BeidouB1iPcpsAcquisitionTest_msg_rx_make(); std::shared_ptr<BeidouB1iPcpsAcquisitionTest_msg_rx> msg_rx = BeidouB1iPcpsAcquisitionTest_msg_rx_make();
ASSERT_NO_THROW({ ASSERT_NO_THROW({
acquisition->connect(top_block); acquisition->connect(top_block);
boost::shared_ptr<gr::analog::sig_source_c> source = gr::analog::sig_source_c::make(fs_in, gr::analog::GR_SIN_WAVE, 1000, 1, gr_complex(0)); std::shared_ptr<gr::analog::sig_source_c> 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); std::shared_ptr<gr::block> valve = gnss_sdr_make_valve(sizeof(gr_complex), nsamples, queue);
top_block->connect(source, 0, valve, 0); top_block->connect(source, 0, valve, 0);
top_block->connect(valve, 0, acquisition->get_left_block(), 0); top_block->connect(valve, 0, acquisition->get_left_block(), 0);
top_block->msg_connect(acquisition->get_right_block(), pmt::mp("events"), msg_rx, pmt::mp("events")); top_block->msg_connect(acquisition->get_right_block(), pmt::mp("events"), msg_rx, pmt::mp("events"));
@@ -300,7 +300,7 @@ TEST_F(BeidouB1iPcpsAcquisitionTest, ValidationOfResults)
} }
std::shared_ptr<BeidouB1iPcpsAcquisition> acquisition = std::make_shared<BeidouB1iPcpsAcquisition>(config.get(), "Acquisition_B1", 1, 0); std::shared_ptr<BeidouB1iPcpsAcquisition> acquisition = std::make_shared<BeidouB1iPcpsAcquisition>(config.get(), "Acquisition_B1", 1, 0);
boost::shared_ptr<BeidouB1iPcpsAcquisitionTest_msg_rx> msg_rx = BeidouB1iPcpsAcquisitionTest_msg_rx_make(); std::shared_ptr<BeidouB1iPcpsAcquisitionTest_msg_rx> msg_rx = BeidouB1iPcpsAcquisitionTest_msg_rx_make();
ASSERT_NO_THROW({ ASSERT_NO_THROW({
acquisition->set_channel(1); acquisition->set_channel(1);

14
src/tests/unit-tests/signal-processing-blocks/acquisition/beidou_b3i_pcps_acquisition_test.cc
View File

@@ -64,7 +64,7 @@ namespace fs = boost::filesystem;
// ######## GNURADIO BLOCK MESSAGE RECEVER ######### // ######## GNURADIO BLOCK MESSAGE RECEVER #########
class BeidouB3iPcpsAcquisitionTest_msg_rx; class BeidouB3iPcpsAcquisitionTest_msg_rx;
using BeidouB3iPcpsAcquisitionTest_msg_rx_sptr = boost::shared_ptr<BeidouB3iPcpsAcquisitionTest_msg_rx>; using BeidouB3iPcpsAcquisitionTest_msg_rx_sptr = std::shared_ptr<BeidouB3iPcpsAcquisitionTest_msg_rx>;
BeidouB3iPcpsAcquisitionTest_msg_rx_sptr BeidouB3iPcpsAcquisitionTest_msg_rx_make(); BeidouB3iPcpsAcquisitionTest_msg_rx_sptr BeidouB3iPcpsAcquisitionTest_msg_rx_make();
@@ -240,7 +240,7 @@ void BeidouB3iPcpsAcquisitionTest::plot_grid()
TEST_F(BeidouB3iPcpsAcquisitionTest, Instantiate) TEST_F(BeidouB3iPcpsAcquisitionTest, Instantiate)
{ {
init(); init();
boost::shared_ptr<BeidouB3iPcpsAcquisition> acquisition = boost::make_shared<BeidouB3iPcpsAcquisition>(config.get(), "Acquisition_B3", 1, 0); std::shared_ptr<BeidouB3iPcpsAcquisition> acquisition = boost::make_shared<BeidouB3iPcpsAcquisition>(config.get(), "Acquisition_B3", 1, 0);
} }
@@ -254,13 +254,13 @@ TEST_F(BeidouB3iPcpsAcquisitionTest, ConnectAndRun)
top_block = gr::make_top_block("Acquisition test"); top_block = gr::make_top_block("Acquisition test");
init(); init();
boost::shared_ptr<BeidouB3iPcpsAcquisition> acquisition = boost::make_shared<BeidouB3iPcpsAcquisition>(config.get(), "Acquisition_B3", 1, 0); std::shared_ptr<BeidouB3iPcpsAcquisition> acquisition = boost::make_shared<BeidouB3iPcpsAcquisition>(config.get(), "Acquisition_B3", 1, 0);
boost::shared_ptr<BeidouB3iPcpsAcquisitionTest_msg_rx> msg_rx = BeidouB3iPcpsAcquisitionTest_msg_rx_make(); std::shared_ptr<BeidouB3iPcpsAcquisitionTest_msg_rx> msg_rx = BeidouB3iPcpsAcquisitionTest_msg_rx_make();
ASSERT_NO_THROW({ ASSERT_NO_THROW({
acquisition->connect(top_block); acquisition->connect(top_block);
boost::shared_ptr<gr::analog::sig_source_c> source = gr::analog::sig_source_c::make(fs_in, gr::analog::GR_SIN_WAVE, 1000, 1, gr_complex(0)); std::shared_ptr<gr::analog::sig_source_c> 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); std::shared_ptr<gr::block> valve = gnss_sdr_make_valve(sizeof(gr_complex), nsamples, queue);
top_block->connect(source, 0, valve, 0); top_block->connect(source, 0, valve, 0);
top_block->connect(valve, 0, acquisition->get_left_block(), 0); top_block->connect(valve, 0, acquisition->get_left_block(), 0);
top_block->msg_connect(acquisition->get_right_block(), pmt::mp("events"), msg_rx, pmt::mp("events")); top_block->msg_connect(acquisition->get_right_block(), pmt::mp("events"), msg_rx, pmt::mp("events"));
@@ -299,7 +299,7 @@ TEST_F(BeidouB3iPcpsAcquisitionTest, ValidationOfResults)
} }
std::shared_ptr<BeidouB3iPcpsAcquisition> acquisition = std::make_shared<BeidouB3iPcpsAcquisition>(config.get(), "Acquisition_B3", 1, 0); std::shared_ptr<BeidouB3iPcpsAcquisition> acquisition = std::make_shared<BeidouB3iPcpsAcquisition>(config.get(), "Acquisition_B3", 1, 0);
boost::shared_ptr<BeidouB3iPcpsAcquisitionTest_msg_rx> msg_rx = BeidouB3iPcpsAcquisitionTest_msg_rx_make(); std::shared_ptr<BeidouB3iPcpsAcquisitionTest_msg_rx> msg_rx = BeidouB3iPcpsAcquisitionTest_msg_rx_make();
ASSERT_NO_THROW({ ASSERT_NO_THROW({
acquisition->set_channel(1); acquisition->set_channel(1);

18
src/tests/unit-tests/signal-processing-blocks/acquisition/galileo_e1_pcps_8ms_ambiguous_acquisition_gsoc2013_test.cc
View File

@@ -29,7 +29,7 @@
#include "in_memory_configuration.h" #include "in_memory_configuration.h"
#include "signal_generator.h" #include "signal_generator.h"
#include "signal_generator_c.h" #include "signal_generator_c.h"
#include <boost/shared_ptr.hpp> #include <memory>
#include <gnuradio/analog/sig_source_waveform.h> #include <gnuradio/analog/sig_source_waveform.h>
#include <gnuradio/blocks/file_source.h> #include <gnuradio/blocks/file_source.h>
#include <gnuradio/blocks/null_sink.h> #include <gnuradio/blocks/null_sink.h>
@@ -47,7 +47,7 @@
// ######## GNURADIO BLOCK MESSAGE RECEVER ######### // ######## GNURADIO BLOCK MESSAGE RECEVER #########
class GalileoE1Pcps8msAmbiguousAcquisitionGSoC2013Test_msg_rx; class GalileoE1Pcps8msAmbiguousAcquisitionGSoC2013Test_msg_rx;
using GalileoE1Pcps8msAmbiguousAcquisitionGSoC2013Test_msg_rx_sptr = boost::shared_ptr<GalileoE1Pcps8msAmbiguousAcquisitionGSoC2013Test_msg_rx>; using GalileoE1Pcps8msAmbiguousAcquisitionGSoC2013Test_msg_rx_sptr = std::shared_ptr<GalileoE1Pcps8msAmbiguousAcquisitionGSoC2013Test_msg_rx>;
GalileoE1Pcps8msAmbiguousAcquisitionGSoC2013Test_msg_rx_sptr GalileoE1Pcps8msAmbiguousAcquisitionGSoC2013Test_msg_rx_make(Concurrent_Queue<int>& queue); GalileoE1Pcps8msAmbiguousAcquisitionGSoC2013Test_msg_rx_sptr GalileoE1Pcps8msAmbiguousAcquisitionGSoC2013Test_msg_rx_make(Concurrent_Queue<int>& queue);
@@ -428,7 +428,7 @@ TEST_F(GalileoE1Pcps8msAmbiguousAcquisitionGSoC2013Test, ConnectAndRun)
std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_8ms_Ambiguous_Acquisition", 1, 0); std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_8ms_Ambiguous_Acquisition", 1, 0);
acquisition = std::dynamic_pointer_cast<GalileoE1Pcps8msAmbiguousAcquisition>(acq_); acquisition = std::dynamic_pointer_cast<GalileoE1Pcps8msAmbiguousAcquisition>(acq_);
boost::shared_ptr<GalileoE1Pcps8msAmbiguousAcquisitionGSoC2013Test_msg_rx> msg_rx = GalileoE1Pcps8msAmbiguousAcquisitionGSoC2013Test_msg_rx_make(channel_internal_queue); std::shared_ptr<GalileoE1Pcps8msAmbiguousAcquisitionGSoC2013Test_msg_rx> msg_rx = GalileoE1Pcps8msAmbiguousAcquisitionGSoC2013Test_msg_rx_make(channel_internal_queue);
ASSERT_NO_THROW({ ASSERT_NO_THROW({
acquisition->set_channel(1); acquisition->set_channel(1);
@@ -452,8 +452,8 @@ TEST_F(GalileoE1Pcps8msAmbiguousAcquisitionGSoC2013Test, ConnectAndRun)
ASSERT_NO_THROW({ ASSERT_NO_THROW({
acquisition->connect(top_block); acquisition->connect(top_block);
boost::shared_ptr<gr::analog::sig_source_c> source = gr::analog::sig_source_c::make(fs_in, gr::analog::GR_SIN_WAVE, 1000, 1, gr_complex(0)); std::shared_ptr<gr::analog::sig_source_c> 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); std::shared_ptr<gr::block> valve = gnss_sdr_make_valve(sizeof(gr_complex), nsamples, queue);
top_block->connect(source, 0, valve, 0); top_block->connect(source, 0, valve, 0);
top_block->connect(valve, 0, acquisition->get_left_block(), 0); top_block->connect(valve, 0, acquisition->get_left_block(), 0);
top_block->msg_connect(acquisition->get_right_block(), pmt::mp("events"), msg_rx, pmt::mp("events")); top_block->msg_connect(acquisition->get_right_block(), pmt::mp("events"), msg_rx, pmt::mp("events"));
@@ -478,7 +478,7 @@ TEST_F(GalileoE1Pcps8msAmbiguousAcquisitionGSoC2013Test, ValidationOfResults)
std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_8ms_Ambiguous_Acquisition", 1, 0, queue); std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_8ms_Ambiguous_Acquisition", 1, 0, queue);
acquisition = std::dynamic_pointer_cast<GalileoE1Pcps8msAmbiguousAcquisition>(acq_); acquisition = std::dynamic_pointer_cast<GalileoE1Pcps8msAmbiguousAcquisition>(acq_);
boost::shared_ptr<GalileoE1Pcps8msAmbiguousAcquisitionGSoC2013Test_msg_rx> msg_rx = GalileoE1Pcps8msAmbiguousAcquisitionGSoC2013Test_msg_rx_make(channel_internal_queue); std::shared_ptr<GalileoE1Pcps8msAmbiguousAcquisitionGSoC2013Test_msg_rx> msg_rx = GalileoE1Pcps8msAmbiguousAcquisitionGSoC2013Test_msg_rx_make(channel_internal_queue);
ASSERT_NO_THROW({ ASSERT_NO_THROW({
acquisition->set_channel(1); acquisition->set_channel(1);
@@ -507,7 +507,7 @@ TEST_F(GalileoE1Pcps8msAmbiguousAcquisitionGSoC2013Test, ValidationOfResults)
acquisition->init(); acquisition->init();
ASSERT_NO_THROW({ ASSERT_NO_THROW({
boost::shared_ptr<GenSignalSource> signal_source; std::shared_ptr<GenSignalSource> signal_source;
SignalGenerator* signal_generator = new SignalGenerator(config.get(), "SignalSource", 0, 1, queue); SignalGenerator* signal_generator = new SignalGenerator(config.get(), "SignalSource", 0, 1, queue);
FirFilter* filter = new FirFilter(config.get(), "InputFilter", 1, 1); FirFilter* filter = new FirFilter(config.get(), "InputFilter", 1, 1);
signal_source.reset(new GenSignalSource(signal_generator, filter, "SignalSource", queue)); signal_source.reset(new GenSignalSource(signal_generator, filter, "SignalSource", queue));
@@ -566,7 +566,7 @@ TEST_F(GalileoE1Pcps8msAmbiguousAcquisitionGSoC2013Test, ValidationOfResultsProb
top_block = gr::make_top_block("Acquisition test"); top_block = gr::make_top_block("Acquisition test");
std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_8ms_Ambiguous_Acquisition", 1, 0); std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_8ms_Ambiguous_Acquisition", 1, 0);
acquisition = std::dynamic_pointer_cast<GalileoE1Pcps8msAmbiguousAcquisition>(acq_); acquisition = std::dynamic_pointer_cast<GalileoE1Pcps8msAmbiguousAcquisition>(acq_);
boost::shared_ptr<GalileoE1Pcps8msAmbiguousAcquisitionGSoC2013Test_msg_rx> msg_rx = GalileoE1Pcps8msAmbiguousAcquisitionGSoC2013Test_msg_rx_make(channel_internal_queue); std::shared_ptr<GalileoE1Pcps8msAmbiguousAcquisitionGSoC2013Test_msg_rx> msg_rx = GalileoE1Pcps8msAmbiguousAcquisitionGSoC2013Test_msg_rx_make(channel_internal_queue);
ASSERT_NO_THROW({ ASSERT_NO_THROW({
acquisition->set_channel(1); acquisition->set_channel(1);
@@ -595,7 +595,7 @@ TEST_F(GalileoE1Pcps8msAmbiguousAcquisitionGSoC2013Test, ValidationOfResultsProb
acquisition->init(); acquisition->init();
ASSERT_NO_THROW({ ASSERT_NO_THROW({
boost::shared_ptr<GenSignalSource> signal_source; std::shared_ptr<GenSignalSource> signal_source;
SignalGenerator* signal_generator = new SignalGenerator(config.get(), "SignalSource", 0, 1, queue); SignalGenerator* signal_generator = new SignalGenerator(config.get(), "SignalSource", 0, 1, queue);
FirFilter* filter = new FirFilter(config.get(), "InputFilter", 1, 1); FirFilter* filter = new FirFilter(config.get(), "InputFilter", 1, 1);
signal_source.reset(new GenSignalSource(signal_generator, filter, "SignalSource", queue)); signal_source.reset(new GenSignalSource(signal_generator, filter, "SignalSource", queue));

16
src/tests/unit-tests/signal-processing-blocks/acquisition/galileo_e1_pcps_ambiguous_acquisition_gsoc2013_test.cc
View File

@@ -46,7 +46,7 @@
// ######## GNURADIO BLOCK MESSAGE RECEVER ######### // ######## GNURADIO BLOCK MESSAGE RECEVER #########
class GalileoE1PcpsAmbiguousAcquisitionGSoC2013Test_msg_rx; class GalileoE1PcpsAmbiguousAcquisitionGSoC2013Test_msg_rx;
using GalileoE1PcpsAmbiguousAcquisitionGSoC2013Test_msg_rx_sptr = boost::shared_ptr<GalileoE1PcpsAmbiguousAcquisitionGSoC2013Test_msg_rx>; using GalileoE1PcpsAmbiguousAcquisitionGSoC2013Test_msg_rx_sptr = std::shared_ptr<GalileoE1PcpsAmbiguousAcquisitionGSoC2013Test_msg_rx>;
GalileoE1PcpsAmbiguousAcquisitionGSoC2013Test_msg_rx_sptr GalileoE1PcpsAmbiguousAcquisitionGSoC2013Test_msg_rx_make(Concurrent_Queue<int>& queue); GalileoE1PcpsAmbiguousAcquisitionGSoC2013Test_msg_rx_sptr GalileoE1PcpsAmbiguousAcquisitionGSoC2013Test_msg_rx_make(Concurrent_Queue<int>& queue);
@@ -430,12 +430,12 @@ TEST_F(GalileoE1PcpsAmbiguousAcquisitionGSoC2013Test, ConnectAndRun)
std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Ambiguous_Acquisition", 1, 0); std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Ambiguous_Acquisition", 1, 0);
acquisition = std::dynamic_pointer_cast<GalileoE1PcpsAmbiguousAcquisition>(acq_); acquisition = std::dynamic_pointer_cast<GalileoE1PcpsAmbiguousAcquisition>(acq_);
boost::shared_ptr<GalileoE1PcpsAmbiguousAcquisitionGSoC2013Test_msg_rx> msg_rx = GalileoE1PcpsAmbiguousAcquisitionGSoC2013Test_msg_rx_make(channel_internal_queue); std::shared_ptr<GalileoE1PcpsAmbiguousAcquisitionGSoC2013Test_msg_rx> msg_rx = GalileoE1PcpsAmbiguousAcquisitionGSoC2013Test_msg_rx_make(channel_internal_queue);
ASSERT_NO_THROW({ ASSERT_NO_THROW({
acquisition->connect(top_block); acquisition->connect(top_block);
boost::shared_ptr<gr::analog::sig_source_c> source = gr::analog::sig_source_c::make(fs_in, gr::analog::GR_SIN_WAVE, 1000, 1, gr_complex(0)); std::shared_ptr<gr::analog::sig_source_c> 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); std::shared_ptr<gr::block> valve = gnss_sdr_make_valve(sizeof(gr_complex), nsamples, queue);
top_block->connect(source, 0, valve, 0); top_block->connect(source, 0, valve, 0);
top_block->connect(valve, 0, acquisition->get_left_block(), 0); top_block->connect(valve, 0, acquisition->get_left_block(), 0);
top_block->msg_connect(acquisition->get_right_block(), pmt::mp("events"), msg_rx, pmt::mp("events")); top_block->msg_connect(acquisition->get_right_block(), pmt::mp("events"), msg_rx, pmt::mp("events"));
@@ -459,7 +459,7 @@ TEST_F(GalileoE1PcpsAmbiguousAcquisitionGSoC2013Test, ValidationOfResults)
queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>(); queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>();
std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Ambiguous_Acquisition", 1, 0); std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Ambiguous_Acquisition", 1, 0);
acquisition = std::dynamic_pointer_cast<GalileoE1PcpsAmbiguousAcquisition>(acq_); acquisition = std::dynamic_pointer_cast<GalileoE1PcpsAmbiguousAcquisition>(acq_);
boost::shared_ptr<GalileoE1PcpsAmbiguousAcquisitionGSoC2013Test_msg_rx> msg_rx = GalileoE1PcpsAmbiguousAcquisitionGSoC2013Test_msg_rx_make(channel_internal_queue); std::shared_ptr<GalileoE1PcpsAmbiguousAcquisitionGSoC2013Test_msg_rx> msg_rx = GalileoE1PcpsAmbiguousAcquisitionGSoC2013Test_msg_rx_make(channel_internal_queue);
ASSERT_NO_THROW({ ASSERT_NO_THROW({
acquisition->set_channel(1); acquisition->set_channel(1);
@@ -484,7 +484,7 @@ TEST_F(GalileoE1PcpsAmbiguousAcquisitionGSoC2013Test, ValidationOfResults)
acquisition->init(); acquisition->init();
ASSERT_NO_THROW({ ASSERT_NO_THROW({
boost::shared_ptr<GenSignalSource> signal_source; std::shared_ptr<GenSignalSource> signal_source;
SignalGenerator* signal_generator = new SignalGenerator(config.get(), "SignalSource", 0, 1, queue); SignalGenerator* signal_generator = new SignalGenerator(config.get(), "SignalSource", 0, 1, queue);
FirFilter* filter = new FirFilter(config.get(), "InputFilter", 1, 1); FirFilter* filter = new FirFilter(config.get(), "InputFilter", 1, 1);
signal_source.reset(new GenSignalSource(signal_generator, filter, "SignalSource", queue)); signal_source.reset(new GenSignalSource(signal_generator, filter, "SignalSource", queue));
@@ -540,7 +540,7 @@ TEST_F(GalileoE1PcpsAmbiguousAcquisitionGSoC2013Test, ValidationOfResultsProbabi
queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>(); queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>();
std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Ambiguous_Acquisition", 1, 0); std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Ambiguous_Acquisition", 1, 0);
acquisition = std::dynamic_pointer_cast<GalileoE1PcpsAmbiguousAcquisition>(acq_); acquisition = std::dynamic_pointer_cast<GalileoE1PcpsAmbiguousAcquisition>(acq_);
boost::shared_ptr<GalileoE1PcpsAmbiguousAcquisitionGSoC2013Test_msg_rx> msg_rx = GalileoE1PcpsAmbiguousAcquisitionGSoC2013Test_msg_rx_make(channel_internal_queue); std::shared_ptr<GalileoE1PcpsAmbiguousAcquisitionGSoC2013Test_msg_rx> msg_rx = GalileoE1PcpsAmbiguousAcquisitionGSoC2013Test_msg_rx_make(channel_internal_queue);
ASSERT_NO_THROW({ ASSERT_NO_THROW({
acquisition->set_channel(1); acquisition->set_channel(1);
@@ -565,7 +565,7 @@ TEST_F(GalileoE1PcpsAmbiguousAcquisitionGSoC2013Test, ValidationOfResultsProbabi
acquisition->init(); acquisition->init();
ASSERT_NO_THROW({ ASSERT_NO_THROW({
boost::shared_ptr<GenSignalSource> signal_source; std::shared_ptr<GenSignalSource> signal_source;
SignalGenerator* signal_generator = new SignalGenerator(config.get(), "SignalSource", 0, 1, queue); SignalGenerator* signal_generator = new SignalGenerator(config.get(), "SignalSource", 0, 1, queue);
FirFilter* filter = new FirFilter(config.get(), "InputFilter", 1, 1); FirFilter* filter = new FirFilter(config.get(), "InputFilter", 1, 1);
signal_source.reset(new GenSignalSource(signal_generator, filter, "SignalSource", queue)); signal_source.reset(new GenSignalSource(signal_generator, filter, "SignalSource", queue));

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

@@ -55,7 +55,7 @@
// ######## GNURADIO BLOCK MESSAGE RECEVER ######### // ######## GNURADIO BLOCK MESSAGE RECEVER #########
class GalileoE1PcpsAmbiguousAcquisitionGSoCTest_msg_rx; class GalileoE1PcpsAmbiguousAcquisitionGSoCTest_msg_rx;
using GalileoE1PcpsAmbiguousAcquisitionGSoCTest_msg_rx_sptr = boost::shared_ptr<GalileoE1PcpsAmbiguousAcquisitionGSoCTest_msg_rx>; using GalileoE1PcpsAmbiguousAcquisitionGSoCTest_msg_rx_sptr = std::shared_ptr<GalileoE1PcpsAmbiguousAcquisitionGSoCTest_msg_rx>;
GalileoE1PcpsAmbiguousAcquisitionGSoCTest_msg_rx_sptr GalileoE1PcpsAmbiguousAcquisitionGSoCTest_msg_rx_make(Concurrent_Queue<int>& queue); GalileoE1PcpsAmbiguousAcquisitionGSoCTest_msg_rx_sptr GalileoE1PcpsAmbiguousAcquisitionGSoCTest_msg_rx_make(Concurrent_Queue<int>& queue);
@@ -214,12 +214,12 @@ TEST_F(GalileoE1PcpsAmbiguousAcquisitionGSoCTest, ConnectAndRun)
init(); init();
std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Ambiguous_Acquisition", 1, 0); std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Ambiguous_Acquisition", 1, 0);
std::shared_ptr<AcquisitionInterface> acquisition = std::dynamic_pointer_cast<AcquisitionInterface>(acq_); std::shared_ptr<AcquisitionInterface> acquisition = std::dynamic_pointer_cast<AcquisitionInterface>(acq_);
boost::shared_ptr<GalileoE1PcpsAmbiguousAcquisitionGSoCTest_msg_rx> msg_rx = GalileoE1PcpsAmbiguousAcquisitionGSoCTest_msg_rx_make(channel_internal_queue); std::shared_ptr<GalileoE1PcpsAmbiguousAcquisitionGSoCTest_msg_rx> msg_rx = GalileoE1PcpsAmbiguousAcquisitionGSoCTest_msg_rx_make(channel_internal_queue);
ASSERT_NO_THROW({ ASSERT_NO_THROW({
acquisition->connect(top_block); acquisition->connect(top_block);
boost::shared_ptr<gr::analog::sig_source_c> source = gr::analog::sig_source_c::make(fs_in, gr::analog::GR_SIN_WAVE, 1000, 1, gr_complex(0)); std::shared_ptr<gr::analog::sig_source_c> 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); std::shared_ptr<gr::block> valve = gnss_sdr_make_valve(sizeof(gr_complex), nsamples, queue);
top_block->connect(source, 0, valve, 0); top_block->connect(source, 0, valve, 0);
top_block->connect(valve, 0, acquisition->get_left_block(), 0); top_block->connect(valve, 0, acquisition->get_left_block(), 0);
top_block->msg_connect(acquisition->get_right_block(), pmt::mp("events"), msg_rx, pmt::mp("events")); top_block->msg_connect(acquisition->get_right_block(), pmt::mp("events"), msg_rx, pmt::mp("events"));
@@ -245,7 +245,7 @@ TEST_F(GalileoE1PcpsAmbiguousAcquisitionGSoCTest, ValidationOfResults)
init(); init();
std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Ambiguous_Acquisition", 1, 0); std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Ambiguous_Acquisition", 1, 0);
std::shared_ptr<GalileoE1PcpsAmbiguousAcquisition> acquisition = std::dynamic_pointer_cast<GalileoE1PcpsAmbiguousAcquisition>(acq_); std::shared_ptr<GalileoE1PcpsAmbiguousAcquisition> acquisition = std::dynamic_pointer_cast<GalileoE1PcpsAmbiguousAcquisition>(acq_);
boost::shared_ptr<GalileoE1PcpsAmbiguousAcquisitionGSoCTest_msg_rx> msg_rx = GalileoE1PcpsAmbiguousAcquisitionGSoCTest_msg_rx_make(channel_internal_queue); std::shared_ptr<GalileoE1PcpsAmbiguousAcquisitionGSoCTest_msg_rx> msg_rx = GalileoE1PcpsAmbiguousAcquisitionGSoCTest_msg_rx_make(channel_internal_queue);
ASSERT_NO_THROW({ ASSERT_NO_THROW({
acquisition->set_channel(gnss_synchro.Channel_ID); acquisition->set_channel(gnss_synchro.Channel_ID);

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

@@ -66,7 +66,7 @@ namespace fs = boost::filesystem;
// ######## GNURADIO BLOCK MESSAGE RECEVER ######### // ######## GNURADIO BLOCK MESSAGE RECEVER #########
class GalileoE1PcpsAmbiguousAcquisitionTest_msg_rx; class GalileoE1PcpsAmbiguousAcquisitionTest_msg_rx;
using GalileoE1PcpsAmbiguousAcquisitionTest_msg_rx_sptr = boost::shared_ptr<GalileoE1PcpsAmbiguousAcquisitionTest_msg_rx>; using GalileoE1PcpsAmbiguousAcquisitionTest_msg_rx_sptr = std::shared_ptr<GalileoE1PcpsAmbiguousAcquisitionTest_msg_rx>;
GalileoE1PcpsAmbiguousAcquisitionTest_msg_rx_sptr GalileoE1PcpsAmbiguousAcquisitionTest_msg_rx_make(); GalileoE1PcpsAmbiguousAcquisitionTest_msg_rx_sptr GalileoE1PcpsAmbiguousAcquisitionTest_msg_rx_make();
@@ -260,12 +260,12 @@ TEST_F(GalileoE1PcpsAmbiguousAcquisitionTest, ConnectAndRun)
init(); init();
std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Ambiguous_Acquisition", 1, 0); std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Ambiguous_Acquisition", 1, 0);
std::shared_ptr<AcquisitionInterface> acquisition = std::dynamic_pointer_cast<AcquisitionInterface>(acq_); std::shared_ptr<AcquisitionInterface> acquisition = std::dynamic_pointer_cast<AcquisitionInterface>(acq_);
boost::shared_ptr<GalileoE1PcpsAmbiguousAcquisitionTest_msg_rx> msg_rx = GalileoE1PcpsAmbiguousAcquisitionTest_msg_rx_make(); std::shared_ptr<GalileoE1PcpsAmbiguousAcquisitionTest_msg_rx> msg_rx = GalileoE1PcpsAmbiguousAcquisitionTest_msg_rx_make();
ASSERT_NO_THROW({ ASSERT_NO_THROW({
acquisition->connect(top_block); acquisition->connect(top_block);
boost::shared_ptr<gr::analog::sig_source_c> source = gr::analog::sig_source_c::make(fs_in, gr::analog::GR_SIN_WAVE, 1000, 1, gr_complex(0)); std::shared_ptr<gr::analog::sig_source_c> 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); std::shared_ptr<gr::block> valve = gnss_sdr_make_valve(sizeof(gr_complex), nsamples, queue);
top_block->connect(source, 0, valve, 0); top_block->connect(source, 0, valve, 0);
top_block->connect(valve, 0, acquisition->get_left_block(), 0); top_block->connect(valve, 0, acquisition->get_left_block(), 0);
top_block->msg_connect(acquisition->get_right_block(), pmt::mp("events"), msg_rx, pmt::mp("events")); top_block->msg_connect(acquisition->get_right_block(), pmt::mp("events"), msg_rx, pmt::mp("events"));
@@ -302,7 +302,7 @@ TEST_F(GalileoE1PcpsAmbiguousAcquisitionTest, ValidationOfResults)
top_block = gr::make_top_block("Acquisition test"); top_block = gr::make_top_block("Acquisition test");
std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Ambiguous_Acquisition", 1, 0); std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Ambiguous_Acquisition", 1, 0);
std::shared_ptr<GalileoE1PcpsAmbiguousAcquisition> acquisition = std::dynamic_pointer_cast<GalileoE1PcpsAmbiguousAcquisition>(acq_); std::shared_ptr<GalileoE1PcpsAmbiguousAcquisition> acquisition = std::dynamic_pointer_cast<GalileoE1PcpsAmbiguousAcquisition>(acq_);
boost::shared_ptr<GalileoE1PcpsAmbiguousAcquisitionTest_msg_rx> msg_rx = GalileoE1PcpsAmbiguousAcquisitionTest_msg_rx_make(); std::shared_ptr<GalileoE1PcpsAmbiguousAcquisitionTest_msg_rx> msg_rx = GalileoE1PcpsAmbiguousAcquisitionTest_msg_rx_make();
ASSERT_NO_THROW({ ASSERT_NO_THROW({
acquisition->set_channel(gnss_synchro.Channel_ID); acquisition->set_channel(gnss_synchro.Channel_ID);

18
src/tests/unit-tests/signal-processing-blocks/acquisition/galileo_e1_pcps_cccwsr_ambiguous_acquisition_gsoc2013_test.cc
View File

@@ -30,7 +30,7 @@
#include "in_memory_configuration.h" #include "in_memory_configuration.h"
#include "signal_generator.h" #include "signal_generator.h"
#include "signal_generator_c.h" #include "signal_generator_c.h"
#include <boost/shared_ptr.hpp> #include <memory>
#include <gnuradio/analog/sig_source_waveform.h> #include <gnuradio/analog/sig_source_waveform.h>
#include <gnuradio/blocks/file_source.h> #include <gnuradio/blocks/file_source.h>
#include <gnuradio/blocks/null_sink.h> #include <gnuradio/blocks/null_sink.h>
@@ -48,7 +48,7 @@
// ######## GNURADIO BLOCK MESSAGE RECEVER ######### // ######## GNURADIO BLOCK MESSAGE RECEVER #########
class GalileoE1PcpsCccwsrAmbiguousAcquisitionTest_msg_rx; class GalileoE1PcpsCccwsrAmbiguousAcquisitionTest_msg_rx;
using GalileoE1PcpsCccwsrAmbiguousAcquisitionTest_msg_rx_sptr = boost::shared_ptr<GalileoE1PcpsCccwsrAmbiguousAcquisitionTest_msg_rx>; using GalileoE1PcpsCccwsrAmbiguousAcquisitionTest_msg_rx_sptr = std::shared_ptr<GalileoE1PcpsCccwsrAmbiguousAcquisitionTest_msg_rx>;
GalileoE1PcpsCccwsrAmbiguousAcquisitionTest_msg_rx_sptr GalileoE1PcpsCccwsrAmbiguousAcquisitionTest_msg_rx_make(Concurrent_Queue<int>& queue); GalileoE1PcpsCccwsrAmbiguousAcquisitionTest_msg_rx_sptr GalileoE1PcpsCccwsrAmbiguousAcquisitionTest_msg_rx_make(Concurrent_Queue<int>& queue);
@@ -432,12 +432,12 @@ TEST_F(GalileoE1PcpsCccwsrAmbiguousAcquisitionTest, ConnectAndRun)
std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_CCCWSR_Ambiguous_Acquisition", 1, 0); std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_CCCWSR_Ambiguous_Acquisition", 1, 0);
acquisition = std::dynamic_pointer_cast<GalileoE1PcpsCccwsrAmbiguousAcquisition>(acq_); acquisition = std::dynamic_pointer_cast<GalileoE1PcpsCccwsrAmbiguousAcquisition>(acq_);
boost::shared_ptr<GalileoE1PcpsCccwsrAmbiguousAcquisitionTest_msg_rx> msg_rx = GalileoE1PcpsCccwsrAmbiguousAcquisitionTest_msg_rx_make(channel_internal_queue); std::shared_ptr<GalileoE1PcpsCccwsrAmbiguousAcquisitionTest_msg_rx> msg_rx = GalileoE1PcpsCccwsrAmbiguousAcquisitionTest_msg_rx_make(channel_internal_queue);
ASSERT_NO_THROW({ ASSERT_NO_THROW({
acquisition->connect(top_block); acquisition->connect(top_block);
boost::shared_ptr<gr::analog::sig_source_c> source = gr::analog::sig_source_c::make(fs_in, gr::analog::GR_SIN_WAVE, 1000, 1, gr_complex(0)); std::shared_ptr<gr::analog::sig_source_c> 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); std::shared_ptr<gr::block> valve = gnss_sdr_make_valve(sizeof(gr_complex), nsamples, queue);
top_block->connect(source, 0, valve, 0); top_block->connect(source, 0, valve, 0);
top_block->connect(valve, 0, acquisition->get_left_block(), 0); top_block->connect(valve, 0, acquisition->get_left_block(), 0);
top_block->msg_connect(acquisition->get_right_block(), pmt::mp("events"), msg_rx, pmt::mp("events")); top_block->msg_connect(acquisition->get_right_block(), pmt::mp("events"), msg_rx, pmt::mp("events"));
@@ -461,7 +461,7 @@ TEST_F(GalileoE1PcpsCccwsrAmbiguousAcquisitionTest, ValidationOfResults)
queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>(); queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>();
std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_CCCWSR_Ambiguous_Acquisition", 1, 0); std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_CCCWSR_Ambiguous_Acquisition", 1, 0);
acquisition = std::dynamic_pointer_cast<GalileoE1PcpsCccwsrAmbiguousAcquisition>(acq_); acquisition = std::dynamic_pointer_cast<GalileoE1PcpsCccwsrAmbiguousAcquisition>(acq_);
boost::shared_ptr<GalileoE1PcpsCccwsrAmbiguousAcquisitionTest_msg_rx> msg_rx = GalileoE1PcpsCccwsrAmbiguousAcquisitionTest_msg_rx_make(channel_internal_queue); std::shared_ptr<GalileoE1PcpsCccwsrAmbiguousAcquisitionTest_msg_rx> msg_rx = GalileoE1PcpsCccwsrAmbiguousAcquisitionTest_msg_rx_make(channel_internal_queue);
ASSERT_NO_THROW({ ASSERT_NO_THROW({
acquisition->set_channel(1); acquisition->set_channel(1);
@@ -491,7 +491,7 @@ TEST_F(GalileoE1PcpsCccwsrAmbiguousAcquisitionTest, ValidationOfResults)
acquisition->reset(); acquisition->reset();
ASSERT_NO_THROW({ ASSERT_NO_THROW({
boost::shared_ptr<GenSignalSource> signal_source; std::shared_ptr<GenSignalSource> signal_source;
SignalGenerator* signal_generator = new SignalGenerator(config.get(), "SignalSource", 0, 1, queue); SignalGenerator* signal_generator = new SignalGenerator(config.get(), "SignalSource", 0, 1, queue);
FirFilter* filter = new FirFilter(config.get(), "InputFilter", 1, 1); FirFilter* filter = new FirFilter(config.get(), "InputFilter", 1, 1);
signal_source.reset(new GenSignalSource(signal_generator, filter, "SignalSource", queue)); signal_source.reset(new GenSignalSource(signal_generator, filter, "SignalSource", queue));
@@ -554,7 +554,7 @@ TEST_F(GalileoE1PcpsCccwsrAmbiguousAcquisitionTest, ValidationOfResultsProbabili
queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>(); queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>();
std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_CCCWSR_Ambiguous_Acquisition", 1, 0); std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_CCCWSR_Ambiguous_Acquisition", 1, 0);
acquisition = std::dynamic_pointer_cast<GalileoE1PcpsCccwsrAmbiguousAcquisition>(acq_); acquisition = std::dynamic_pointer_cast<GalileoE1PcpsCccwsrAmbiguousAcquisition>(acq_);
boost::shared_ptr<GalileoE1PcpsCccwsrAmbiguousAcquisitionTest_msg_rx> msg_rx = GalileoE1PcpsCccwsrAmbiguousAcquisitionTest_msg_rx_make(channel_internal_queue); std::shared_ptr<GalileoE1PcpsCccwsrAmbiguousAcquisitionTest_msg_rx> msg_rx = GalileoE1PcpsCccwsrAmbiguousAcquisitionTest_msg_rx_make(channel_internal_queue);
ASSERT_NO_THROW({ ASSERT_NO_THROW({
acquisition->set_channel(1); acquisition->set_channel(1);
@@ -584,7 +584,7 @@ TEST_F(GalileoE1PcpsCccwsrAmbiguousAcquisitionTest, ValidationOfResultsProbabili
acquisition->reset(); acquisition->reset();
ASSERT_NO_THROW({ ASSERT_NO_THROW({
boost::shared_ptr<GenSignalSource> signal_source; std::shared_ptr<GenSignalSource> signal_source;
SignalGenerator* signal_generator = new SignalGenerator(config.get(), "SignalSource", 0, 1, queue); SignalGenerator* signal_generator = new SignalGenerator(config.get(), "SignalSource", 0, 1, queue);
FirFilter* filter = new FirFilter(config.get(), "InputFilter", 1, 1); FirFilter* filter = new FirFilter(config.get(), "InputFilter", 1, 1);
signal_source.reset(new GenSignalSource(signal_generator, filter, "SignalSource", queue)); signal_source.reset(new GenSignalSource(signal_generator, filter, "SignalSource", queue));

22
src/tests/unit-tests/signal-processing-blocks/acquisition/galileo_e1_pcps_quicksync_ambiguous_acquisition_gsoc2014_test.cc
View File

@@ -29,7 +29,7 @@
#include "in_memory_configuration.h" #include "in_memory_configuration.h"
#include "signal_generator.h" #include "signal_generator.h"
#include "signal_generator_c.h" #include "signal_generator_c.h"
#include <boost/shared_ptr.hpp> #include <memory>
#include <glog/logging.h> #include <glog/logging.h>
#include <gnuradio/analog/sig_source_waveform.h> #include <gnuradio/analog/sig_source_waveform.h>
#include <gnuradio/blocks/file_source.h> #include <gnuradio/blocks/file_source.h>
@@ -54,7 +54,7 @@ DEFINE_int32(e1_value_CN0_dB_0, 50, "Value for the CN0_dB_0 in channel 0");
// ######## GNURADIO BLOCK MESSAGE RECEVER ######### // ######## GNURADIO BLOCK MESSAGE RECEVER #########
class GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test_msg_rx; class GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test_msg_rx;
using GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test_msg_rx_sptr = boost::shared_ptr<GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test_msg_rx>; using GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test_msg_rx_sptr = std::shared_ptr<GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test_msg_rx>;
GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test_msg_rx_sptr GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test_msg_rx_make(Concurrent_Queue<int>& queue); GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test_msg_rx_sptr GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test_msg_rx_make(Concurrent_Queue<int>& queue);
@@ -556,13 +556,13 @@ TEST_F(GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test, ConnectAndRun)
std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_QuickSync_Ambiguous_Acquisition", 1, 0); std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_QuickSync_Ambiguous_Acquisition", 1, 0);
acquisition = std::dynamic_pointer_cast<GalileoE1PcpsQuickSyncAmbiguousAcquisition>(acq_); acquisition = std::dynamic_pointer_cast<GalileoE1PcpsQuickSyncAmbiguousAcquisition>(acq_);
boost::shared_ptr<GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test_msg_rx> msg_rx = GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test_msg_rx_make(channel_internal_queue); std::shared_ptr<GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test_msg_rx> msg_rx = GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test_msg_rx_make(channel_internal_queue);
ASSERT_NO_THROW({ ASSERT_NO_THROW({
acquisition->connect(top_block); acquisition->connect(top_block);
boost::shared_ptr<gr::analog::sig_source_c> source = std::shared_ptr<gr::analog::sig_source_c> source =
gr::analog::sig_source_c::make(fs_in, gr::analog::GR_SIN_WAVE, 1000, 1, gr_complex(0)); gr::analog::sig_source_c::make(fs_in, gr::analog::GR_SIN_WAVE, 1000, 1, gr_complex(0));
boost::shared_ptr<gr::block> valve = std::shared_ptr<gr::block> valve =
gnss_sdr_make_valve(sizeof(gr_complex), nsamples, queue); gnss_sdr_make_valve(sizeof(gr_complex), nsamples, queue);
top_block->connect(source, 0, valve, 0); top_block->connect(source, 0, valve, 0);
top_block->connect(valve, 0, acquisition->get_left_block(), 0); top_block->connect(valve, 0, acquisition->get_left_block(), 0);
@@ -591,7 +591,7 @@ TEST_F(GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test, ValidationOfResul
std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_QuickSync_Ambiguous_Acquisition", 1, 0); std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_QuickSync_Ambiguous_Acquisition", 1, 0);
acquisition = std::dynamic_pointer_cast<GalileoE1PcpsQuickSyncAmbiguousAcquisition>(acq_); acquisition = std::dynamic_pointer_cast<GalileoE1PcpsQuickSyncAmbiguousAcquisition>(acq_);
boost::shared_ptr<GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test_msg_rx> msg_rx = GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test_msg_rx_make(channel_internal_queue); std::shared_ptr<GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test_msg_rx> msg_rx = GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test_msg_rx_make(channel_internal_queue);
ASSERT_NO_THROW({ ASSERT_NO_THROW({
acquisition->set_channel(0); acquisition->set_channel(0);
@@ -621,7 +621,7 @@ TEST_F(GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test, ValidationOfResul
acquisition->reset(); acquisition->reset();
ASSERT_NO_THROW({ ASSERT_NO_THROW({
boost::shared_ptr<GenSignalSource> signal_source; std::shared_ptr<GenSignalSource> signal_source;
SignalGenerator* signal_generator = new SignalGenerator(config.get(), "SignalSource", 0, 1, queue); SignalGenerator* signal_generator = new SignalGenerator(config.get(), "SignalSource", 0, 1, queue);
FirFilter* filter = new FirFilter(config.get(), "InputFilter", 1, 1); FirFilter* filter = new FirFilter(config.get(), "InputFilter", 1, 1);
signal_source.reset(new GenSignalSource(signal_generator, filter, "SignalSource", queue)); signal_source.reset(new GenSignalSource(signal_generator, filter, "SignalSource", queue));
@@ -682,7 +682,7 @@ TEST_F(GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test, ValidationOfResul
std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_QuickSync_Ambiguous_Acquisition", 1, 0); std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_QuickSync_Ambiguous_Acquisition", 1, 0);
acquisition = std::dynamic_pointer_cast<GalileoE1PcpsQuickSyncAmbiguousAcquisition>(acq_); acquisition = std::dynamic_pointer_cast<GalileoE1PcpsQuickSyncAmbiguousAcquisition>(acq_);
boost::shared_ptr<GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test_msg_rx> msg_rx = GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test_msg_rx_make(channel_internal_queue); std::shared_ptr<GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test_msg_rx> msg_rx = GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test_msg_rx_make(channel_internal_queue);
ASSERT_NO_THROW({ ASSERT_NO_THROW({
acquisition->set_channel(1); acquisition->set_channel(1);
@@ -712,7 +712,7 @@ TEST_F(GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test, ValidationOfResul
acquisition->reset(); acquisition->reset();
ASSERT_NO_THROW({ ASSERT_NO_THROW({
boost::shared_ptr<GenSignalSource> signal_source; std::shared_ptr<GenSignalSource> signal_source;
SignalGenerator* signal_generator = new SignalGenerator(config.get(), "SignalSource", 0, 1, queue); SignalGenerator* signal_generator = new SignalGenerator(config.get(), "SignalSource", 0, 1, queue);
FirFilter* filter = new FirFilter(config.get(), "InputFilter", 1, 1); FirFilter* filter = new FirFilter(config.get(), "InputFilter", 1, 1);
signal_source.reset(new GenSignalSource(signal_generator, filter, "SignalSource", queue)); signal_source.reset(new GenSignalSource(signal_generator, filter, "SignalSource", queue));
@@ -770,7 +770,7 @@ TEST_F(GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test, ValidationOfResul
std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_QuickSync_Ambiguous_Acquisition", 1, 0); std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_QuickSync_Ambiguous_Acquisition", 1, 0);
acquisition = std::dynamic_pointer_cast<GalileoE1PcpsQuickSyncAmbiguousAcquisition>(acq_); acquisition = std::dynamic_pointer_cast<GalileoE1PcpsQuickSyncAmbiguousAcquisition>(acq_);
boost::shared_ptr<GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test_msg_rx> msg_rx = GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test_msg_rx_make(channel_internal_queue); std::shared_ptr<GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test_msg_rx> msg_rx = GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test_msg_rx_make(channel_internal_queue);
ASSERT_NO_THROW({ ASSERT_NO_THROW({
acquisition->set_channel(1); acquisition->set_channel(1);
@@ -799,7 +799,7 @@ TEST_F(GalileoE1PcpsQuickSyncAmbiguousAcquisitionGSoC2014Test, ValidationOfResul
acquisition->init(); acquisition->init();
ASSERT_NO_THROW({ ASSERT_NO_THROW({
boost::shared_ptr<GenSignalSource> signal_source; std::shared_ptr<GenSignalSource> signal_source;
SignalGenerator* signal_generator = new SignalGenerator(config.get(), "SignalSource", 0, 1, queue); SignalGenerator* signal_generator = new SignalGenerator(config.get(), "SignalSource", 0, 1, queue);
FirFilter* filter = new FirFilter(config.get(), "InputFilter", 1, 1); FirFilter* filter = new FirFilter(config.get(), "InputFilter", 1, 1);
signal_source.reset(new GenSignalSource(signal_generator, filter, "SignalSource", queue)); signal_source.reset(new GenSignalSource(signal_generator, filter, "SignalSource", queue));

16
src/tests/unit-tests/signal-processing-blocks/acquisition/galileo_e1_pcps_tong_ambiguous_acquisition_gsoc2013_test.cc
View File

@@ -30,7 +30,7 @@
#include "in_memory_configuration.h" #include "in_memory_configuration.h"
#include "signal_generator.h" #include "signal_generator.h"
#include "signal_generator_c.h" #include "signal_generator_c.h"
#include <boost/shared_ptr.hpp> #include <memory>
#include <gnuradio/analog/sig_source_waveform.h> #include <gnuradio/analog/sig_source_waveform.h>
#include <gnuradio/blocks/file_source.h> #include <gnuradio/blocks/file_source.h>
#include <gnuradio/blocks/null_sink.h> #include <gnuradio/blocks/null_sink.h>
@@ -49,7 +49,7 @@
// ######## GNURADIO BLOCK MESSAGE RECEVER ######### // ######## GNURADIO BLOCK MESSAGE RECEVER #########
class GalileoE1PcpsTongAmbiguousAcquisitionGSoC2013Test_msg_rx; class GalileoE1PcpsTongAmbiguousAcquisitionGSoC2013Test_msg_rx;
using GalileoE1PcpsTongAmbiguousAcquisitionGSoC2013Test_msg_rx_sptr = boost::shared_ptr<GalileoE1PcpsTongAmbiguousAcquisitionGSoC2013Test_msg_rx>; using GalileoE1PcpsTongAmbiguousAcquisitionGSoC2013Test_msg_rx_sptr = std::shared_ptr<GalileoE1PcpsTongAmbiguousAcquisitionGSoC2013Test_msg_rx>;
GalileoE1PcpsTongAmbiguousAcquisitionGSoC2013Test_msg_rx_sptr GalileoE1PcpsTongAmbiguousAcquisitionGSoC2013Test_msg_rx_make(Concurrent_Queue<int>& queue); GalileoE1PcpsTongAmbiguousAcquisitionGSoC2013Test_msg_rx_sptr GalileoE1PcpsTongAmbiguousAcquisitionGSoC2013Test_msg_rx_make(Concurrent_Queue<int>& queue);
@@ -435,8 +435,8 @@ TEST_F(GalileoE1PcpsTongAmbiguousAcquisitionGSoC2013Test, ConnectAndRun)
ASSERT_NO_THROW({ ASSERT_NO_THROW({
acquisition->connect(top_block); acquisition->connect(top_block);
boost::shared_ptr<gr::analog::sig_source_c> source = gr::analog::sig_source_c::make(fs_in, gr::analog::GR_SIN_WAVE, 1000, 1, gr_complex(0)); std::shared_ptr<gr::analog::sig_source_c> 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); std::shared_ptr<gr::block> valve = gnss_sdr_make_valve(sizeof(gr_complex), nsamples, queue);
top_block->connect(source, 0, valve, 0); top_block->connect(source, 0, valve, 0);
top_block->connect(valve, 0, acquisition->get_left_block(), 0); top_block->connect(valve, 0, acquisition->get_left_block(), 0);
}) << "Failure connecting the blocks of acquisition test."; }) << "Failure connecting the blocks of acquisition test.";
@@ -459,7 +459,7 @@ TEST_F(GalileoE1PcpsTongAmbiguousAcquisitionGSoC2013Test, ValidationOfResults)
queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>(); queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>();
std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Tong_Ambiguous_Acquisition", 1, 0); std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Tong_Ambiguous_Acquisition", 1, 0);
acquisition = std::dynamic_pointer_cast<GalileoE1PcpsTongAmbiguousAcquisition>(acq_); acquisition = std::dynamic_pointer_cast<GalileoE1PcpsTongAmbiguousAcquisition>(acq_);
boost::shared_ptr<GalileoE1PcpsTongAmbiguousAcquisitionGSoC2013Test_msg_rx> msg_rx = GalileoE1PcpsTongAmbiguousAcquisitionGSoC2013Test_msg_rx_make(channel_internal_queue); std::shared_ptr<GalileoE1PcpsTongAmbiguousAcquisitionGSoC2013Test_msg_rx> msg_rx = GalileoE1PcpsTongAmbiguousAcquisitionGSoC2013Test_msg_rx_make(channel_internal_queue);
ASSERT_NO_THROW({ ASSERT_NO_THROW({
acquisition->set_channel(1); acquisition->set_channel(1);
@@ -489,7 +489,7 @@ TEST_F(GalileoE1PcpsTongAmbiguousAcquisitionGSoC2013Test, ValidationOfResults)
acquisition->init(); acquisition->init();
ASSERT_NO_THROW({ ASSERT_NO_THROW({
boost::shared_ptr<GenSignalSource> signal_source; std::shared_ptr<GenSignalSource> signal_source;
SignalGenerator* signal_generator = new SignalGenerator(config.get(), "SignalSource", 0, 1, queue); SignalGenerator* signal_generator = new SignalGenerator(config.get(), "SignalSource", 0, 1, queue);
FirFilter* filter = new FirFilter(config.get(), "InputFilter", 1, 1); FirFilter* filter = new FirFilter(config.get(), "InputFilter", 1, 1);
signal_source.reset(new GenSignalSource(signal_generator, filter, "SignalSource", queue)); signal_source.reset(new GenSignalSource(signal_generator, filter, "SignalSource", queue));
@@ -548,7 +548,7 @@ TEST_F(GalileoE1PcpsTongAmbiguousAcquisitionGSoC2013Test, ValidationOfResultsPro
queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>(); queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>();
std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Tong_Ambiguous_Acquisition", 1, 0); std::shared_ptr<GNSSBlockInterface> acq_ = factory->GetBlock(config, "Acquisition_1B", "Galileo_E1_PCPS_Tong_Ambiguous_Acquisition", 1, 0);
acquisition = std::dynamic_pointer_cast<GalileoE1PcpsTongAmbiguousAcquisition>(acq_); acquisition = std::dynamic_pointer_cast<GalileoE1PcpsTongAmbiguousAcquisition>(acq_);
boost::shared_ptr<GalileoE1PcpsTongAmbiguousAcquisitionGSoC2013Test_msg_rx> msg_rx = GalileoE1PcpsTongAmbiguousAcquisitionGSoC2013Test_msg_rx_make(channel_internal_queue); std::shared_ptr<GalileoE1PcpsTongAmbiguousAcquisitionGSoC2013Test_msg_rx> msg_rx = GalileoE1PcpsTongAmbiguousAcquisitionGSoC2013Test_msg_rx_make(channel_internal_queue);
ASSERT_NO_THROW({ ASSERT_NO_THROW({
acquisition->set_channel(1); acquisition->set_channel(1);
@@ -577,7 +577,7 @@ TEST_F(GalileoE1PcpsTongAmbiguousAcquisitionGSoC2013Test, ValidationOfResultsPro
acquisition->init(); acquisition->init();
ASSERT_NO_THROW({ ASSERT_NO_THROW({
boost::shared_ptr<GenSignalSource> signal_source; std::shared_ptr<GenSignalSource> signal_source;
SignalGenerator* signal_generator = new SignalGenerator(config.get(), "SignalSource", 0, 1, queue); SignalGenerator* signal_generator = new SignalGenerator(config.get(), "SignalSource", 0, 1, queue);
FirFilter* filter = new FirFilter(config.get(), "InputFilter", 1, 1); FirFilter* filter = new FirFilter(config.get(), "InputFilter", 1, 1);
signal_source.reset(new GenSignalSource(signal_generator, filter, "SignalSource", queue)); signal_source.reset(new GenSignalSource(signal_generator, filter, "SignalSource", queue));

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

@@ -45,7 +45,7 @@
// ######## GNURADIO BLOCK MESSAGE RECEVER ######### // ######## GNURADIO BLOCK MESSAGE RECEVER #########
class GalileoE5aPcpsAcquisitionGSoC2014GensourceTest_msg_rx; class GalileoE5aPcpsAcquisitionGSoC2014GensourceTest_msg_rx;
using GalileoE5aPcpsAcquisitionGSoC2014GensourceTest_msg_rx_sptr = boost::shared_ptr<GalileoE5aPcpsAcquisitionGSoC2014GensourceTest_msg_rx>; using GalileoE5aPcpsAcquisitionGSoC2014GensourceTest_msg_rx_sptr = std::shared_ptr<GalileoE5aPcpsAcquisitionGSoC2014GensourceTest_msg_rx>;
GalileoE5aPcpsAcquisitionGSoC2014GensourceTest_msg_rx_sptr GalileoE5aPcpsAcquisitionGSoC2014GensourceTest_msg_rx_make(Concurrent_Queue<int>& queue); GalileoE5aPcpsAcquisitionGSoC2014GensourceTest_msg_rx_sptr GalileoE5aPcpsAcquisitionGSoC2014GensourceTest_msg_rx_make(Concurrent_Queue<int>& queue);
@@ -529,14 +529,14 @@ TEST_F(GalileoE5aPcpsAcquisitionGSoC2014GensourceTest, ConnectAndRun)
std::chrono::time_point<std::chrono::system_clock> start, end; std::chrono::time_point<std::chrono::system_clock> start, end;
std::chrono::duration<double> elapsed_seconds(0); std::chrono::duration<double> elapsed_seconds(0);
acquisition = std::make_shared<GalileoE5aNoncoherentIQAcquisitionCaf>(config.get(), "Acquisition_5X", 1, 0); acquisition = std::make_shared<GalileoE5aNoncoherentIQAcquisitionCaf>(config.get(), "Acquisition_5X", 1, 0);
boost::shared_ptr<GalileoE5aPcpsAcquisitionGSoC2014GensourceTest_msg_rx> msg_rx = GalileoE5aPcpsAcquisitionGSoC2014GensourceTest_msg_rx_make(channel_internal_queue); std::shared_ptr<GalileoE5aPcpsAcquisitionGSoC2014GensourceTest_msg_rx> msg_rx = GalileoE5aPcpsAcquisitionGSoC2014GensourceTest_msg_rx_make(channel_internal_queue);
queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>(); queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>();
top_block = gr::make_top_block("Acquisition test"); top_block = gr::make_top_block("Acquisition test");
ASSERT_NO_THROW({ ASSERT_NO_THROW({
acquisition->connect(top_block); acquisition->connect(top_block);
boost::shared_ptr<gr::analog::sig_source_c> source = gr::analog::sig_source_c::make(fs_in, gr::analog::GR_SIN_WAVE, 1000, 1, gr_complex(0)); std::shared_ptr<gr::analog::sig_source_c> 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); std::shared_ptr<gr::block> valve = gnss_sdr_make_valve(sizeof(gr_complex), nsamples, queue);
top_block->connect(source, 0, valve, 0); top_block->connect(source, 0, valve, 0);
top_block->connect(valve, 0, acquisition->get_left_block(), 0); top_block->connect(valve, 0, acquisition->get_left_block(), 0);
top_block->msg_connect(acquisition->get_right_block(), pmt::mp("events"), msg_rx, pmt::mp("events")); top_block->msg_connect(acquisition->get_right_block(), pmt::mp("events"), msg_rx, pmt::mp("events"));
@@ -559,7 +559,7 @@ TEST_F(GalileoE5aPcpsAcquisitionGSoC2014GensourceTest, ValidationOfSIM)
queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>(); queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>();
top_block = gr::make_top_block("Acquisition test"); top_block = gr::make_top_block("Acquisition test");
acquisition = std::make_shared<GalileoE5aNoncoherentIQAcquisitionCaf>(config.get(), "Acquisition_5X", 1, 0); acquisition = std::make_shared<GalileoE5aNoncoherentIQAcquisitionCaf>(config.get(), "Acquisition_5X", 1, 0);
boost::shared_ptr<GalileoE5aPcpsAcquisitionGSoC2014GensourceTest_msg_rx> msg_rx = GalileoE5aPcpsAcquisitionGSoC2014GensourceTest_msg_rx_make(channel_internal_queue); std::shared_ptr<GalileoE5aPcpsAcquisitionGSoC2014GensourceTest_msg_rx> msg_rx = GalileoE5aPcpsAcquisitionGSoC2014GensourceTest_msg_rx_make(channel_internal_queue);
ASSERT_NO_THROW({ ASSERT_NO_THROW({
acquisition->set_channel(0); acquisition->set_channel(0);
@@ -588,7 +588,7 @@ TEST_F(GalileoE5aPcpsAcquisitionGSoC2014GensourceTest, ValidationOfSIM)
// USING THE SIGNAL GENERATOR // USING THE SIGNAL GENERATOR
ASSERT_NO_THROW({ ASSERT_NO_THROW({
boost::shared_ptr<GenSignalSource> signal_source; std::shared_ptr<GenSignalSource> signal_source;
SignalGenerator* signal_generator = new SignalGenerator(config.get(), "SignalSource", 0, 1, queue); SignalGenerator* signal_generator = new SignalGenerator(config.get(), "SignalSource", 0, 1, queue);
FirFilter* filter = new FirFilter(config.get(), "InputFilter", 1, 1); FirFilter* filter = new FirFilter(config.get(), "InputFilter", 1, 1);
filter->connect(top_block); filter->connect(top_block);

14
src/tests/unit-tests/signal-processing-blocks/acquisition/glonass_l1_ca_pcps_acquisition_gsoc2017_test.cc
View File

@@ -32,7 +32,7 @@
#include "pass_through.h" #include "pass_through.h"
#include "signal_generator.h" #include "signal_generator.h"
#include "signal_generator_c.h" #include "signal_generator_c.h"
#include <boost/shared_ptr.hpp> #include <memory>
#include <gnuradio/analog/sig_source_waveform.h> #include <gnuradio/analog/sig_source_waveform.h>
#include <gnuradio/blocks/file_source.h> #include <gnuradio/blocks/file_source.h>
#include <gnuradio/blocks/null_sink.h> #include <gnuradio/blocks/null_sink.h>
@@ -51,7 +51,7 @@
// ######## GNURADIO BLOCK MESSAGE RECEVER ######### // ######## GNURADIO BLOCK MESSAGE RECEVER #########
class GlonassL1CaPcpsAcquisitionGSoC2017Test_msg_rx; class GlonassL1CaPcpsAcquisitionGSoC2017Test_msg_rx;
using GlonassL1CaPcpsAcquisitionGSoC2017Test_msg_rx_sptr = boost::shared_ptr<GlonassL1CaPcpsAcquisitionGSoC2017Test_msg_rx>; using GlonassL1CaPcpsAcquisitionGSoC2017Test_msg_rx_sptr = std::shared_ptr<GlonassL1CaPcpsAcquisitionGSoC2017Test_msg_rx>;
GlonassL1CaPcpsAcquisitionGSoC2017Test_msg_rx_sptr GlonassL1CaPcpsAcquisitionGSoC2017Test_msg_rx_make(Concurrent_Queue<int>& queue); GlonassL1CaPcpsAcquisitionGSoC2017Test_msg_rx_sptr GlonassL1CaPcpsAcquisitionGSoC2017Test_msg_rx_make(Concurrent_Queue<int>& queue);
@@ -438,12 +438,12 @@ TEST_F(GlonassL1CaPcpsAcquisitionGSoC2017Test, ConnectAndRun)
config_1(); config_1();
acquisition = new GlonassL1CaPcpsAcquisition(config.get(), "Acquisition", 1, 0); acquisition = new GlonassL1CaPcpsAcquisition(config.get(), "Acquisition", 1, 0);
boost::shared_ptr<GlonassL1CaPcpsAcquisitionGSoC2017Test_msg_rx> msg_rx = GlonassL1CaPcpsAcquisitionGSoC2017Test_msg_rx_make(channel_internal_queue); std::shared_ptr<GlonassL1CaPcpsAcquisitionGSoC2017Test_msg_rx> msg_rx = GlonassL1CaPcpsAcquisitionGSoC2017Test_msg_rx_make(channel_internal_queue);
ASSERT_NO_THROW({ ASSERT_NO_THROW({
acquisition->connect(top_block); acquisition->connect(top_block);
boost::shared_ptr<gr::analog::sig_source_c> source = gr::analog::sig_source_c::make(fs_in, gr::analog::GR_SIN_WAVE, 1000, 1, gr_complex(0)); std::shared_ptr<gr::analog::sig_source_c> 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); std::shared_ptr<gr::block> valve = gnss_sdr_make_valve(sizeof(gr_complex), nsamples, queue);
top_block->connect(source, 0, valve, 0); top_block->connect(source, 0, valve, 0);
top_block->connect(valve, 0, acquisition->get_left_block(), 0); top_block->connect(valve, 0, acquisition->get_left_block(), 0);
top_block->msg_connect(acquisition->get_right_block(), pmt::mp("events"), msg_rx, pmt::mp("events")); top_block->msg_connect(acquisition->get_right_block(), pmt::mp("events"), msg_rx, pmt::mp("events"));
@@ -469,7 +469,7 @@ TEST_F(GlonassL1CaPcpsAcquisitionGSoC2017Test, ValidationOfResults)
top_block = gr::make_top_block("Acquisition test"); top_block = gr::make_top_block("Acquisition test");
acquisition = new GlonassL1CaPcpsAcquisition(config.get(), "Acquisition", 1, 0); acquisition = new GlonassL1CaPcpsAcquisition(config.get(), "Acquisition", 1, 0);
boost::shared_ptr<GlonassL1CaPcpsAcquisitionGSoC2017Test_msg_rx> msg_rx = GlonassL1CaPcpsAcquisitionGSoC2017Test_msg_rx_make(channel_internal_queue); std::shared_ptr<GlonassL1CaPcpsAcquisitionGSoC2017Test_msg_rx> msg_rx = GlonassL1CaPcpsAcquisitionGSoC2017Test_msg_rx_make(channel_internal_queue);
ASSERT_NO_THROW({ ASSERT_NO_THROW({
acquisition->set_channel(1); acquisition->set_channel(1);
@@ -553,7 +553,7 @@ TEST_F(GlonassL1CaPcpsAcquisitionGSoC2017Test, ValidationOfResultsProbabilities)
queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>(); queue = std::make_shared<Concurrent_Queue<pmt::pmt_t>>();
top_block = gr::make_top_block("Acquisition test"); top_block = gr::make_top_block("Acquisition test");
acquisition = new GlonassL1CaPcpsAcquisition(config.get(), "Acquisition", 1, 0); acquisition = new GlonassL1CaPcpsAcquisition(config.get(), "Acquisition", 1, 0);
boost::shared_ptr<GlonassL1CaPcpsAcquisitionGSoC2017Test_msg_rx> msg_rx = GlonassL1CaPcpsAcquisitionGSoC2017Test_msg_rx_make(channel_internal_queue); std::shared_ptr<GlonassL1CaPcpsAcquisitionGSoC2017Test_msg_rx> msg_rx = GlonassL1CaPcpsAcquisitionGSoC2017Test_msg_rx_make(channel_internal_queue);
ASSERT_NO_THROW({ ASSERT_NO_THROW({
acquisition->set_channel(1); acquisition->set_channel(1);

Some files were not shown because too many files have changed in this diff Show More