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

Code cleaning, comments, code style fixes

Browse Source 
git-svn-id: https://svn.code.sf.net/p/gnss-sdr/code/trunk@251 64b25241-fba3-4117-9849-534c7e92360d
This commit is contained in:
Carles Fernandez 2012-10-19 16:00:40 +00:00
parent c241b7b1d6
commit 323e8e6765
2 changed files with 153 additions and 166 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

100
src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_cc.cc
View File

@ -6,11 +6,9 @@
* <li> Luis Esteve, 2012. luis(at)epsilon-formacion.com * <li> Luis Esteve, 2012. luis(at)epsilon-formacion.com
* </ul> * </ul>
* *
* Detailed description of the file here if needed.
*
* ------------------------------------------------------------------------- * -------------------------------------------------------------------------
* *
* Copyright (C) 2010-2011 (see AUTHORS file for a list of contributors) * Copyright (C) 2010-2012 (see AUTHORS file for a list of contributors)
* *
* GNSS-SDR is a software defined Global Navigation * GNSS-SDR is a software defined Global Navigation
* Satellite Systems receiver * Satellite Systems receiver
@ -55,13 +53,15 @@ pcps_acquisition_cc_sptr pcps_make_acquisition_cc(
fs_in, samples_per_ms, queue, dump, dump_filename)); fs_in, samples_per_ms, queue, dump, dump_filename));
} }
pcps_acquisition_cc::pcps_acquisition_cc( pcps_acquisition_cc::pcps_acquisition_cc(
unsigned int sampled_ms, unsigned int doppler_max, long freq, unsigned int sampled_ms, unsigned int doppler_max, long freq,
long fs_in, int samples_per_ms, gr_msg_queue_sptr queue, bool dump, long fs_in, int samples_per_ms, gr_msg_queue_sptr queue, bool dump,
std::string dump_filename) : std::string dump_filename) :
gr_block("pcps_acquisition_cc", gr_make_io_signature(1, 1, gr_block("pcps_acquisition_cc",
sizeof(gr_complex) * sampled_ms *samples_per_ms), gr_make_io_signature(0, 0, gr_make_io_signature(1, 1, sizeof(gr_complex) * sampled_ms * samples_per_ms),
sizeof(gr_complex) * sampled_ms *samples_per_ms)) gr_make_io_signature(0, 0, sizeof(gr_complex) * sampled_ms * samples_per_ms))
{ {
d_sample_counter = 0; // SAMPLE COUNTER d_sample_counter = 0; // SAMPLE COUNTER
d_active = false; d_active = false;
@ -85,39 +85,39 @@ pcps_acquisition_cc::pcps_acquisition_cc(
// Inverse FFT // Inverse FFT
d_ifft = new gri_fft_complex(d_fft_size, false); d_ifft = new gri_fft_complex(d_fft_size, false);
// For dumping samples into a file
d_dump = dump; d_dump = dump;
d_dump_filename = dump_filename; d_dump_filename = dump_filename;
} }
pcps_acquisition_cc::~pcps_acquisition_cc() pcps_acquisition_cc::~pcps_acquisition_cc()
{ {
free(d_carrier); free(d_carrier);
free(d_fft_codes); free(d_fft_codes);
delete d_ifft; delete d_ifft;
delete d_fft_if; delete d_fft_if;
if (d_dump) if (d_dump)
{ {
d_dump_file.close(); d_dump_file.close();
} }
} }
void pcps_acquisition_cc::set_local_code(std::complex<float> * code) void pcps_acquisition_cc::set_local_code(std::complex<float> * code)
{ {
memcpy(d_fft_if->get_inbuf(),code,sizeof(gr_complex)*d_fft_size); memcpy(d_fft_if->get_inbuf(),code,sizeof(gr_complex)*d_fft_size);
} }
void pcps_acquisition_cc::init() void pcps_acquisition_cc::init()
{ {
d_gnss_synchro->Acq_delay_samples = 0.0; d_gnss_synchro->Acq_delay_samples = 0.0;
d_gnss_synchro->Acq_doppler_hz = 0.0; d_gnss_synchro->Acq_doppler_hz = 0.0;
d_gnss_synchro->Acq_samplestamp_samples = 0; d_gnss_synchro->Acq_samplestamp_samples = 0;
d_mag = 0.0; d_mag = 0.0;
d_input_power = 0.0; d_input_power = 0.0;
@ -128,7 +128,6 @@ void pcps_acquisition_cc::init()
{ {
d_fft_codes[i] = std::complex<float>(conj(d_fft_if->get_outbuf()[i])); d_fft_codes[i] = std::complex<float>(conj(d_fft_if->get_outbuf()[i]));
} }
} }
@ -137,7 +136,6 @@ int pcps_acquisition_cc::general_work(int noutput_items,
gr_vector_int &ninput_items, gr_vector_const_void_star &input_items, gr_vector_int &ninput_items, gr_vector_const_void_star &input_items,
gr_vector_void_star &output_items) gr_vector_void_star &output_items)
{ {
/* /*
* By J.Arribas and L.Esteve * By J.Arribas and L.Esteve
* Acquisition strategy (Kay Borre book + CFAR threshold): * Acquisition strategy (Kay Borre book + CFAR threshold):
@ -156,6 +154,18 @@ int pcps_acquisition_cc::general_work(int noutput_items,
} }
else else
{ {
// initialize acquisition algorithm
int doppler;
unsigned int indext = 0;
float magt = 0.0;
float tmp_magt = 0.0;
const gr_complex *in = (const gr_complex *)input_items[0]; //Get the input samples pointer
bool positive_acquisition = false;
int acquisition_message = -1; //0=STOP_CHANNEL 1=ACQ_SUCCEES 2=ACQ_FAIL
//aux vars
unsigned int i;
float fft_normalization_factor;
d_sample_counter += d_fft_size; // sample counter d_sample_counter += d_fft_size; // sample counter
//restart acquisition variables //restart acquisition variables
@ -164,21 +174,6 @@ int pcps_acquisition_cc::general_work(int noutput_items,
d_mag = 0.0; d_mag = 0.0;
d_input_power = 0.0; d_input_power = 0.0;
// initialize acquisition algorithm
int doppler;
unsigned int indext = 0;
float magt = 0.0;
float tmp_magt = 0.0;
const gr_complex *in = (const gr_complex *)input_items[0]; //Get the input samples pointer
bool positive_acquisition = false;
int acquisition_message = -1; //0=STOP_CHANNEL 1=ACQ_SUCCEES 2=ACQ_FAIL
//aux vars
unsigned int i;
float fft_normalization_factor;
DLOG(INFO) << "Channel: " << d_channel DLOG(INFO) << "Channel: " << d_channel
<< " , doing acquisition of satellite: " << d_gnss_synchro->System << " "<< d_gnss_synchro->PRN << " , doing acquisition of satellite: " << d_gnss_synchro->System << " "<< d_gnss_synchro->PRN
<< " ,sample stamp: " << d_sample_counter << ", threshold: " << " ,sample stamp: " << d_sample_counter << ", threshold: "
@ -190,7 +185,6 @@ int pcps_acquisition_cc::general_work(int noutput_items,
{ {
d_input_power += std::norm(in[i]); d_input_power += std::norm(in[i]);
} }
d_input_power = d_input_power / (float)d_fft_size; d_input_power = d_input_power / (float)d_fft_size;
// 2- Doppler frequency search loop // 2- Doppler frequency search loop
@ -199,28 +193,31 @@ int pcps_acquisition_cc::general_work(int noutput_items,
// doppler search steps // doppler search steps
// Perform the carrier wipe-off // Perform the carrier wipe-off
complex_exp_gen_conj(d_carrier, d_freq + doppler, d_fs_in, d_fft_size); complex_exp_gen_conj(d_carrier, d_freq + doppler, d_fs_in, d_fft_size);
if (is_unaligned()==true) if (is_unaligned()==true)
{ {
volk_32fc_x2_multiply_32fc_u(d_fft_if->get_inbuf(), in, d_carrier, d_fft_size); volk_32fc_x2_multiply_32fc_u(d_fft_if->get_inbuf(), in, d_carrier, d_fft_size);
}else{ }
else
{
//use directly the input vector //use directly the input vector
volk_32fc_x2_multiply_32fc_a(d_fft_if->get_inbuf(), in, d_carrier, d_fft_size); volk_32fc_x2_multiply_32fc_a(d_fft_if->get_inbuf(), in, d_carrier, d_fft_size);
} }
//3- Perform the FFT-based circular convolution (parallel time search) // 3- Perform the FFT-based convolution (parallel time search)
// Compute the FFT of the carrier wiped--off incoming signal
d_fft_if->execute(); d_fft_if->execute();
// Using SIMD operations with VOLK library // Multiply carrier wiped--off, Fourier transformed incoming signal
// with the local FFT'd code reference using SIMD operations with VOLK library
volk_32fc_x2_multiply_32fc_a(d_ifft->get_inbuf(), d_fft_if->get_outbuf(), d_fft_codes, d_fft_size); volk_32fc_x2_multiply_32fc_a(d_ifft->get_inbuf(), d_fft_if->get_outbuf(), d_fft_codes, d_fft_size);
// compute the inverse FFT
d_ifft->execute(); d_ifft->execute();
// Search maximum // Search maximum
indext = 0; indext = 0;
magt = 0; magt = 0;
fft_normalization_factor = (float)d_fft_size * (float)d_fft_size; fft_normalization_factor = (float)d_fft_size * (float)d_fft_size;
for (i = 0; i < d_fft_size; i++) for (i = 0; i < d_fft_size; i++)
{ {
tmp_magt = std::norm(d_ifft->get_outbuf()[i]); tmp_magt = std::norm(d_ifft->get_outbuf()[i]);
@ -230,23 +227,9 @@ int pcps_acquisition_cc::general_work(int noutput_items,
indext = i; indext = i;
} }
} }
// Normalize the maximum value to correct the scale factor introduced by FFTW // Normalize the maximum value to correct the scale factor introduced by FFTW
magt = magt / (fft_normalization_factor * fft_normalization_factor); magt = magt / (fft_normalization_factor * fft_normalization_factor);
// Record results to files
if (d_dump)
{
std::stringstream filename;
std::streamsize n = 2 * sizeof(float) * (d_fft_size); // complex file write
filename.str("");
filename << "../data/test_statistics_"<<d_gnss_synchro->System<<"_"<<d_gnss_synchro->Signal<<"_sat_" << d_gnss_synchro->PRN << "_doppler_"<< doppler << ".dat";
d_dump_file.open(filename.str().c_str(), std::ios::out
| std::ios::binary);
d_dump_file.write((char*)d_ifft->get_outbuf(), n); //write directly |abs(x)|^2 in this Doppler bin?
d_dump_file.close();
}
// 4- record the maximum peak and the associated synchronization parameters // 4- record the maximum peak and the associated synchronization parameters
if (d_mag < magt) if (d_mag < magt)
{ {
@ -254,18 +237,31 @@ int pcps_acquisition_cc::general_work(int noutput_items,
d_gnss_synchro->Acq_delay_samples = (double)indext; d_gnss_synchro->Acq_delay_samples = (double)indext;
d_gnss_synchro->Acq_doppler_hz = (double)doppler; d_gnss_synchro->Acq_doppler_hz = (double)doppler;
} }
// Record results to file if required
if (d_dump)
{
std::stringstream filename;
std::streamsize n = 2 * sizeof(float) * (d_fft_size); // complex file write
filename.str("");
filename << "../data/test_statistics_" << d_gnss_synchro->System
<<"_" << d_gnss_synchro->Signal << "_sat_"
<< d_gnss_synchro->PRN << "_doppler_" << doppler << ".dat";
d_dump_file.open(filename.str().c_str(), std::ios::out
| std::ios::binary);
d_dump_file.write((char*)d_ifft->get_outbuf(), n); //write directly |abs(x)|^2 in this Doppler bin?
d_dump_file.close();
}
} }
// 5- Compute the test statistics and compare to the threshold // 5- Compute the test statistics and compare to the threshold
d_test_statistics = 2 * d_fft_size * d_mag / d_input_power; d_test_statistics = 2 * d_fft_size * d_mag / d_input_power;
// 6- Declare positive or negative acquisition using a message queue // 6- Declare positive or negative acquisition using a message queue
if (d_test_statistics > d_threshold) if (d_test_statistics > d_threshold)
{ {
positive_acquisition = true; positive_acquisition = true;
d_gnss_synchro->Acq_samplestamp_samples = d_sample_counter; d_gnss_synchro->Acq_samplestamp_samples = d_sample_counter;
DLOG(INFO) << "positive acquisition"; DLOG(INFO) << "positive acquisition";
DLOG(INFO) << "satellite " << d_gnss_synchro->System << " " << d_gnss_synchro->PRN; DLOG(INFO) << "satellite " << d_gnss_synchro->System << " " << d_gnss_synchro->PRN;
DLOG(INFO) << "sample_stamp " << d_sample_counter; DLOG(INFO) << "sample_stamp " << d_sample_counter;
@ -299,9 +295,7 @@ int pcps_acquisition_cc::general_work(int noutput_items,
{ {
acquisition_message = 2; acquisition_message = 2;
} }
d_channel_internal_queue->push(acquisition_message); d_channel_internal_queue->push(acquisition_message);
consume_each(1); consume_each(1);
} }
return 0; return 0;

21
src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_cc.h
View File

@ -46,8 +46,8 @@
* ------------------------------------------------------------------------- * -------------------------------------------------------------------------
*/ */
#ifndef PCPS_ACQUISITION_CC_H_ #ifndef GNSS_SDR_PCPS_ACQUISITION_CC_H_
#define PCPS_ACQUISITION_CC_H_ #define GNSS_SDR_PCPS_ACQUISITION_CC_H_
#include <fstream> #include <fstream>
#include <gnuradio/gr_block.h> #include <gnuradio/gr_block.h>
@ -73,9 +73,7 @@ pcps_make_acquisition_cc(unsigned int sampled_ms,
*/ */
class pcps_acquisition_cc: public gr_block { class pcps_acquisition_cc: public gr_block {
private: private:
friend pcps_acquisition_cc_sptr friend pcps_acquisition_cc_sptr
pcps_make_acquisition_cc(unsigned int sampled_ms, pcps_make_acquisition_cc(unsigned int sampled_ms,
unsigned int doppler_max, long freq, long fs_in, unsigned int doppler_max, long freq, long fs_in,
@ -102,37 +100,32 @@ private:
unsigned int d_fft_size; unsigned int d_fft_size;
unsigned long int d_sample_counter; unsigned long int d_sample_counter;
gr_complex* d_carrier; gr_complex* d_carrier;
gr_complex* d_fft_codes; gr_complex* d_fft_codes;
gri_fft_complex* d_fft_if; gri_fft_complex* d_fft_if;
gri_fft_complex* d_ifft; gri_fft_complex* d_ifft;
Gnss_Synchro *d_gnss_synchro; Gnss_Synchro *d_gnss_synchro;
unsigned int d_code_phase; unsigned int d_code_phase;
float d_doppler_freq; float d_doppler_freq;
float d_mag; float d_mag;
float d_input_power; float d_input_power;
float d_test_statistics; float d_test_statistics;
gr_msg_queue_sptr d_queue; gr_msg_queue_sptr d_queue;
concurrent_queue<int> *d_channel_internal_queue; concurrent_queue<int> *d_channel_internal_queue;
std::ofstream d_dump_file; std::ofstream d_dump_file;
bool d_active; bool d_active;
bool d_dump; bool d_dump;
unsigned int d_channel; unsigned int d_channel;
std::string d_dump_filename; std::string d_dump_filename;
public: public:
/*!
* \brief Default destructor
*/
~pcps_acquisition_cc(); ~pcps_acquisition_cc();
/*! /*!
* \brief Set acquisition/tracking common Gnss_Synchro object pointer * \brief Set acquisition/tracking common Gnss_Synchro object pointer
* to efficiently exchange synchronization data between acquisition and * to exchange synchronization data between acquisition and tracking blocks
* tracking blocks
*/ */
void set_gnss_synchro(Gnss_Synchro* p_gnss_synchro) void set_gnss_synchro(Gnss_Synchro* p_gnss_synchro)
{ {
@ -212,4 +205,4 @@ public:
gr_vector_void_star &output_items); gr_vector_void_star &output_items);
}; };
#endif /* PCPS_ACQUISITION_CC_H_*/ #endif /* GNSS_SDR_PCPS_ACQUISITION_CC_H_*/