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

Merge branch 'next' of https://github.com/gnss-sdr/gnss-sdr into next

Browse Source
This commit is contained in:
Carles Fernandez
2018-04-11 18:18:47 +02:00
parent bdd1a0e977 c2dfc82bf3
commit ddc2603681
7 changed files with 223 additions and 72 deletions
Download Patch File Download Diff File Expand all files Collapse all files

135
src/algorithms/libs/gnss_circular_deque.h Normal file
View File

@@ -0,0 +1,135 @@
/*!
* \file gnss_circular_deque.h
* \brief This class implements a circular deque for Gnss_Synchro
*
* \author Luis Esteve, 2018. antonio.ramos(at)cttc.es
*
* Detailed description of the file here if needed.
*
* -------------------------------------------------------------------------
*
* Copyright (C) 2010-2018 (see AUTHORS file for a list of contributors)
*
* GNSS-SDR is a software defined Global Navigation
* Satellite Systems receiver
*
* This file is part of GNSS-SDR.
*
* GNSS-SDR is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* GNSS-SDR is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GNSS-SDR. If not, see <http://www.gnu.org/licenses/>.
*
* -------------------------------------------------------------------------
*/
#ifndef GNSS_SDR_CIRCULAR_DEQUE_H_
#define GNSS_SDR_CIRCULAR_DEQUE_H_
#include <vector>
#include <boost/circular_buffer.hpp>
template <class T>
class Gnss_circular_deque
{
public:
Gnss_circular_deque(); // Default constructor
Gnss_circular_deque(const unsigned int max_size, const unsigned int nchann); // nchann = number of channels; max_size = channel capacity
unsigned int size(const unsigned int ch); // Returns the number of available elements in a channel
T& at(const unsigned int ch, const unsigned int pos); // Returns a reference to an element
T& front(const unsigned int ch); // Returns a reference to the first element in the deque
T& back(const unsigned int ch); // Returns a reference to the last element in the deque
void push_back(const unsigned int ch, const T& new_data); // Inserts an element at the end of the deque
void pop_front(const unsigned int ch); // Removes the first element of the deque
void clear(const unsigned int ch); // Removes all the elements of the deque (Sets size to 0). Capacity is not modified
void reset(const unsigned int max_size, const unsigned int nchann); // Removes all the elements in all the channels. Re-sets the number of channels and their capacity
void reset(); // Removes all the channels (Sets nchann to 0)
private:
std::vector<boost::circular_buffer<T>> d_data;
};
template <class T>
Gnss_circular_deque<T>::Gnss_circular_deque()
{
reset();
}
template <class T>
Gnss_circular_deque<T>::Gnss_circular_deque(const unsigned int max_size, const unsigned int nchann)
{
reset(max_size, nchann);
}
template <class T>
unsigned int Gnss_circular_deque<T>::size(const unsigned int ch)
{
return d_data.at(ch).size();
}
template <class T>
T& Gnss_circular_deque<T>::back(const unsigned int ch)
{
return d_data.at(ch).back();
}
template <class T>
T& Gnss_circular_deque<T>::front(const unsigned int ch)
{
return d_data.at(ch).front();
}
template <class T>
T& Gnss_circular_deque<T>::at(const unsigned int ch, const unsigned int pos)
{
return d_data.at(ch).at(pos);
}
template <class T>
void Gnss_circular_deque<T>::clear(const unsigned int ch)
{
d_data.at(ch).clear();
}
template <class T>
void Gnss_circular_deque<T>::reset(const unsigned int max_size, const unsigned int nchann)
{
d_data.clear();
if (max_size > 0 and nchann > 0)
{
for (unsigned int i = 0; i < nchann; i++)
{
d_data.push_back(boost::circular_buffer<T>(max_size));
}
}
}
template <class T>
void Gnss_circular_deque<T>::reset()
{
d_data.clear();
}
template <class T>
void Gnss_circular_deque<T>::pop_front(const unsigned int ch)
{
d_data.at(ch).pop_front();
}
template <class T>
void Gnss_circular_deque<T>::push_back(const unsigned int ch, const T& new_data)
{
d_data.at(ch).push_back(new_data);
}
#endif /* GNSS_SDR_CIRCULAR_DEQUE_H_ */

1
src/algorithms/observables/adapters/CMakeLists.txt
View File

@@ -26,6 +26,7 @@ include_directories(
${CMAKE_SOURCE_DIR}/src/core/interfaces
${CMAKE_SOURCE_DIR}/src/core/receiver
${CMAKE_SOURCE_DIR}/src/algorithms/observables/gnuradio_blocks
${CMAKE_SOURCE_DIR}/src/algorithms/libs
${CMAKE_SOURCE_DIR}/src/algorithms/PVT/libs
${GLOG_INCLUDE_DIRS}
${GFlags_INCLUDE_DIRS}

6
src/algorithms/observables/gnuradio_blocks/CMakeLists.txt
View File

@@ -39,8 +39,8 @@ list(SORT OBS_GR_BLOCKS_HEADERS)
add_library(obs_gr_blocks ${OBS_GR_BLOCKS_SOURCES} ${OBS_GR_BLOCKS_HEADERS})
source_group(Headers FILES ${OBS_GR_BLOCKS_HEADERS})
if(MATIO_FOUND)
add_dependencies(obs_gr_blocks glog-${glog_RELEASE} armadillo-${armadillo_RELEASE})
add_dependencies(obs_gr_blocks gnss_sp_libs glog-${glog_RELEASE} armadillo-${armadillo_RELEASE})
else(MATIO_FOUND)
add_dependencies(obs_gr_blocks glog-${glog_RELEASE} armadillo-${armadillo_RELEASE} matio-${GNSSSDR_MATIO_LOCAL_VERSION})
add_dependencies(obs_gr_blocks gnss_sp_libs glog-${glog_RELEASE} armadillo-${armadillo_RELEASE} matio-${GNSSSDR_MATIO_LOCAL_VERSION})
endif(MATIO_FOUND)
target_link_libraries(obs_gr_blocks ${GNURADIO_RUNTIME_LIBRARIES} ${ARMADILLO_LIBRARIES} ${MATIO_LIBRARIES})
target_link_libraries(obs_gr_blocks gnss_sp_libs ${GNURADIO_RUNTIME_LIBRARIES} ${ARMADILLO_LIBRARIES} ${MATIO_LIBRARIES})

130
src/algorithms/observables/gnuradio_blocks/hybrid_observables_cc.cc
View File

@@ -63,14 +63,11 @@ hybrid_observables_cc::hybrid_observables_cc(unsigned int nchannels_in,
d_dump_filename = dump_filename;
T_rx_s = 0.0;
T_rx_step_s = 0.001; // 1 ms
max_delta = 0.15; // 150 ms
max_delta = 3.5; // 3.5 s
d_latency = 0.08; // 80 ms
valid_channels.resize(d_nchannels, false);
d_num_valid_channels = 0;
for (unsigned int i = 0; i < d_nchannels; i++)
{
d_gnss_synchro_history.push_back(std::deque<Gnss_Synchro>());
}
d_gnss_synchro_history = new Gnss_circular_deque<Gnss_Synchro>(static_cast<unsigned int>(max_delta * 1000.0), d_nchannels);
// ############# ENABLE DATA FILE LOG #################
if (d_dump)
@@ -95,6 +92,7 @@ hybrid_observables_cc::hybrid_observables_cc(unsigned int nchannels_in,
hybrid_observables_cc::~hybrid_observables_cc()
{
delete d_gnss_synchro_history;
if (d_dump_file.is_open())
{
try
@@ -302,40 +300,29 @@ int hybrid_observables_cc::save_matfile()
}
bool hybrid_observables_cc::interpolate_data(Gnss_Synchro &out, std::deque<Gnss_Synchro> &data, const double &ti)
bool hybrid_observables_cc::interpolate_data(Gnss_Synchro &out, const unsigned int &ch, const double &ti)
{
if ((ti < data.front().RX_time) or (ti > data.back().RX_time))
if ((ti < d_gnss_synchro_history->front(ch).RX_time) or (ti > d_gnss_synchro_history->back(ch).RX_time))
{
return false;
}
std::deque<Gnss_Synchro>::iterator it;
std::pair<unsigned int, unsigned int> ind = find_interp_elements(ch, ti);
arma::vec t = arma::vec(data.size());
arma::vec dop = t;
arma::vec cph = t;
arma::vec tow = t;
arma::vec tiv = arma::vec(1);
arma::vec result;
tiv(0) = ti;
//Linear interpolation: y(t) = y(t1) + (y(t2) - y(t1)) * (t - t1) / (t2 - t1)
unsigned int aux = 0;
for (it = data.begin(); it != data.end(); it++)
{
t(aux) = it->RX_time;
dop(aux) = it->Carrier_Doppler_hz;
cph(aux) = it->Carrier_phase_rads;
tow(aux) = it->TOW_at_current_symbol_s;
// CARRIER PHASE INTERPOLATION
aux++;
}
arma::interp1(t, dop, tiv, result);
out.Carrier_Doppler_hz = result(0);
arma::interp1(t, cph, tiv, result);
out.Carrier_phase_rads = result(0);
arma::interp1(t, tow, tiv, result);
out.TOW_at_current_symbol_s = result(0);
out.Carrier_phase_rads = d_gnss_synchro_history->at(ch, ind.first).Carrier_phase_rads + (d_gnss_synchro_history->at(ch, ind.second).Carrier_phase_rads - d_gnss_synchro_history->at(ch, ind.first).Carrier_phase_rads) * (ti - d_gnss_synchro_history->at(ch, ind.first).RX_time) / (d_gnss_synchro_history->at(ch, ind.second).RX_time - d_gnss_synchro_history->at(ch, ind.first).RX_time);
return result.is_finite();
// CARRIER DOPPLER INTERPOLATION
out.Carrier_Doppler_hz = d_gnss_synchro_history->at(ch, ind.first).Carrier_Doppler_hz + (d_gnss_synchro_history->at(ch, ind.second).Carrier_Doppler_hz - d_gnss_synchro_history->at(ch, ind.first).Carrier_Doppler_hz) * (ti - d_gnss_synchro_history->at(ch, ind.first).RX_time) / (d_gnss_synchro_history->at(ch, ind.second).RX_time - d_gnss_synchro_history->at(ch, ind.first).RX_time);
// TOW INTERPOLATION
out.TOW_at_current_symbol_s = d_gnss_synchro_history->at(ch, ind.first).TOW_at_current_symbol_s + (d_gnss_synchro_history->at(ch, ind.second).TOW_at_current_symbol_s - d_gnss_synchro_history->at(ch, ind.first).TOW_at_current_symbol_s) * (ti - d_gnss_synchro_history->at(ch, ind.first).RX_time) / (d_gnss_synchro_history->at(ch, ind.second).RX_time - d_gnss_synchro_history->at(ch, ind.first).RX_time);
return true;
}
@@ -351,6 +338,40 @@ double hybrid_observables_cc::compute_T_rx_s(const Gnss_Synchro &a)
}
}
std::pair<unsigned int, unsigned int> hybrid_observables_cc::find_interp_elements(const unsigned int &ch, const double &ti)
{
unsigned int closest = 0;
double dif = std::numeric_limits<double>::max();
double dt = 0.0;
for (unsigned int i = 0; i < d_gnss_synchro_history->size(ch); i++)
{
dt = ti - d_gnss_synchro_history->at(ch, i).RX_time;
if (dt < dif and dt > 0.0)
{
dif = dt;
closest = i;
}
}
unsigned int index1;
unsigned int index2;
if (closest == 0)
{
index1 = 0;
index2 = 1;
}
else if (closest == (d_gnss_synchro_history->size(ch) - 1))
{
index1 = d_gnss_synchro_history->size(ch) - 2;
index2 = d_gnss_synchro_history->size(ch) - 1;
}
else
{
index1 = closest;
index2 = closest + 1;
}
return std::pair<unsigned int, unsigned int>(index1, index2);
}
void hybrid_observables_cc::forecast(int noutput_items __attribute__((unused)),
gr_vector_int &ninput_items_required)
@@ -363,13 +384,13 @@ void hybrid_observables_cc::forecast(int noutput_items __attribute__((unused)),
}
void hybrid_observables_cc::clean_history(std::deque<Gnss_Synchro> &data)
void hybrid_observables_cc::clean_history(unsigned int pos)
{
while (data.size() > 0)
while (d_gnss_synchro_history->size(pos) > 0)
{
if ((T_rx_s - data.front().RX_time) > max_delta)
if ((T_rx_s - d_gnss_synchro_history->front(pos).RX_time) > max_delta)
{
data.pop_front();
d_gnss_synchro_history->pop_front(pos);
}
else
{
@@ -454,11 +475,9 @@ int hybrid_observables_cc::general_work(int noutput_items __attribute__((unused)
}
//////////////////////////////////////////////////////////////////////////
std::vector<std::deque<Gnss_Synchro>>::iterator it;
if (total_input_items > 0)
{
i = 0;
for (it = d_gnss_synchro_history.begin(); it != d_gnss_synchro_history.end(); it++)
for (i = 0; i < d_nchannels; i++)
{
if (ninput_items[i] > 0)
{
@@ -467,26 +486,25 @@ int hybrid_observables_cc::general_work(int noutput_items __attribute__((unused)
{
if (in[i][aux].Flag_valid_word)
{
it->push_back(in[i][aux]);
it->back().RX_time = compute_T_rx_s(in[i][aux]);
d_gnss_synchro_history->push_back(i, in[i][aux]);
d_gnss_synchro_history->back(i).RX_time = compute_T_rx_s(in[i][aux]);
// Check if the last Gnss_Synchro comes from the same satellite as the previous ones
if (it->size() > 1)
if (d_gnss_synchro_history->size(i) > 1)
{
if (it->front().PRN != it->back().PRN)
if (d_gnss_synchro_history->front(i).PRN != d_gnss_synchro_history->back(i).PRN)
{
it->clear();
d_gnss_synchro_history->clear(i);
}
}
}
}
consume(i, ninput_items[i]);
}
i++;
}
}
for (i = 0; i < d_nchannels; i++)
{
if (d_gnss_synchro_history.at(i).size() > 2)
if (d_gnss_synchro_history->size(i) > 2)
{
valid_channels[i] = true;
}
@@ -506,8 +524,8 @@ int hybrid_observables_cc::general_work(int noutput_items __attribute__((unused)
{
if (valid_channels[i])
{
clean_history(d_gnss_synchro_history.at(i));
if (d_gnss_synchro_history.at(i).size() < 2)
clean_history(i);
if (d_gnss_synchro_history->size(i) < 2)
{
valid_channels[i] = false;
}
@@ -516,20 +534,19 @@ int hybrid_observables_cc::general_work(int noutput_items __attribute__((unused)
// Check if there is any valid channel after computing the time distance between the Gnss_Synchro data and the receiver time
d_num_valid_channels = valid_channels.count();
double T_rx_s_out = T_rx_s - (max_delta / 2.0);
double T_rx_s_out = T_rx_s - d_latency;
if ((d_num_valid_channels == 0) or (T_rx_s_out < 0.0))
{
return 0;
}
std::vector<Gnss_Synchro> epoch_data;
i = 0;
for (it = d_gnss_synchro_history.begin(); it != d_gnss_synchro_history.end(); it++)
for (i = 0; i < d_nchannels; i++)
{
if (valid_channels[i])
{
Gnss_Synchro interpolated_gnss_synchro = it->back();
if (interpolate_data(interpolated_gnss_synchro, *it, T_rx_s_out))
Gnss_Synchro interpolated_gnss_synchro = d_gnss_synchro_history->back(i);
if (interpolate_data(interpolated_gnss_synchro, i, T_rx_s_out))
{
epoch_data.push_back(interpolated_gnss_synchro);
}
@@ -538,7 +555,6 @@ int hybrid_observables_cc::general_work(int noutput_items __attribute__((unused)
valid_channels[i] = false;
}
}
i++;
}
d_num_valid_channels = valid_channels.count();
if (d_num_valid_channels == 0)
@@ -546,14 +562,14 @@ int hybrid_observables_cc::general_work(int noutput_items __attribute__((unused)
return 0;
}
correct_TOW_and_compute_prange(epoch_data);
std::vector<Gnss_Synchro>::iterator it2 = epoch_data.begin();
std::vector<Gnss_Synchro>::iterator it = epoch_data.begin();
for (i = 0; i < d_nchannels; i++)
{
if (valid_channels[i])
{
out[i][0] = (*it2);
out[i][0] = (*it);
out[i][0].Flag_valid_pseudorange = true;
it2++;
it++;
}
else
{

12
src/algorithms/observables/gnuradio_blocks/hybrid_observables_cc.h
View File

@@ -35,12 +35,12 @@
#define GNSS_SDR_HYBRID_OBSERVABLES_CC_H
#include "gnss_synchro.h"
#include "gnss_circular_deque.h"
#include <gnuradio/block.h>
#include <boost/dynamic_bitset.hpp>
#include <fstream>
#include <string>
#include <vector>
#include <deque>
#include <utility>
class hybrid_observables_cc;
@@ -65,18 +65,20 @@ private:
friend hybrid_observables_cc_sptr
hybrid_make_observables_cc(unsigned int nchannels_in, unsigned int nchannels_out, bool dump, std::string dump_filename);
hybrid_observables_cc(unsigned int nchannels_in, unsigned int nchannels_out, bool dump, std::string dump_filename);
void clean_history(std::deque<Gnss_Synchro>& data);
void clean_history(unsigned int pos);
double compute_T_rx_s(const Gnss_Synchro& a);
bool interpolate_data(Gnss_Synchro& out, std::deque<Gnss_Synchro>& data, const double& ti);
bool interpolate_data(Gnss_Synchro& out, const unsigned int& ch, const double& ti);
std::pair<unsigned int, unsigned int> find_interp_elements(const unsigned int& ch, const double& ti);
void correct_TOW_and_compute_prange(std::vector<Gnss_Synchro>& data);
int save_matfile();
//Tracking observable history
std::vector<std::deque<Gnss_Synchro>> d_gnss_synchro_history;
Gnss_circular_deque<Gnss_Synchro>* d_gnss_synchro_history;
boost::dynamic_bitset<> valid_channels;
double T_rx_s;
double T_rx_step_s;
double max_delta;
double d_latency;
bool d_dump;
unsigned int d_nchannels;
unsigned int d_num_valid_channels;

7
src/algorithms/telemetry_decoder/gnuradio_blocks/gps_l1_ca_telemetry_decoder_cc.cc
View File

@@ -105,6 +105,8 @@ gps_l1_ca_telemetry_decoder_cc::gps_l1_ca_telemetry_decoder_cc(
flag_PLL_180_deg_phase_locked = false;
d_preamble_time_samples = 0;
d_TOW_at_current_symbol_ms = 0;
d_symbol_history.resize(GPS_CA_PREAMBLE_LENGTH_SYMBOLS + 1); // Change fixed buffer size
d_symbol_history.clear(); // Clear all the elements in the buffer
}
@@ -395,11 +397,6 @@ int gps_l1_ca_telemetry_decoder_cc::general_work(int noutput_items __attribute__
}
}
// remove used symbols from history
if (d_symbol_history.size() > required_symbols)
{
d_symbol_history.pop_front();
}
//3. Make the output (copy the object contents to the GNURadio reserved memory)
*out[0] = current_symbol;

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

@@ -36,9 +36,9 @@
#include "gnss_satellite.h"
#include "gnss_synchro.h"
#include <gnuradio/block.h>
#include <deque>
#include <fstream>
#include <string>
#include <boost/circular_buffer.hpp>
class gps_l1_ca_telemetry_decoder_cc;
@@ -79,7 +79,7 @@ private:
bool d_flag_frame_sync;
// symbols
std::deque<Gnss_Synchro> d_symbol_history;
boost::circular_buffer<Gnss_Synchro> d_symbol_history;
double d_symbol_accumulator;
short int d_symbol_accumulator_counter;