diff --git a/src/algorithms/libs/gnss_circular_deque.h b/src/algorithms/libs/gnss_circular_deque.h
new file mode 100644
index 000000000..f453be3d2
--- /dev/null
+++ b/src/algorithms/libs/gnss_circular_deque.h
@@ -0,0 +1,213 @@
+/*!
+ * \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 .
+ *
+ * -------------------------------------------------------------------------
+ */
+
+#ifndef GNSS_SDR_CIRCULAR_DEQUE_H_
+#define GNSS_SDR_CIRCULAR_DEQUE_H_
+
+template
+class Gnss_circular_deque
+{
+public:
+ Gnss_circular_deque();
+ Gnss_circular_deque(const unsigned int max_size, const unsigned int nchann);
+ ~Gnss_circular_deque();
+ unsigned int size(const unsigned int ch);
+ T& at(const unsigned int ch, const unsigned int pos);
+ T& front(const unsigned int ch);
+ T& back(const unsigned int ch);
+ void push_back(const unsigned int ch, const T& new_data);
+ T pop_front(const unsigned int ch);
+ void clear(const unsigned int ch);
+ T* get_vector(const unsigned int ch);
+
+private:
+ T** d_history;
+ T d_return_void; // Void object for avoid compiler errors
+ unsigned int* d_index_pop;
+ unsigned int* d_index_push;
+ unsigned int* d_size;
+ unsigned int d_max_size;
+ unsigned int d_nchannels;
+};
+
+
+template
+Gnss_circular_deque::Gnss_circular_deque()
+{
+ d_max_size = 0;
+ d_nchannels = 0;
+ d_size = nullptr;
+ d_index_pop = nullptr;
+ d_index_push = nullptr;
+ d_history = nullptr;
+}
+
+template
+Gnss_circular_deque::Gnss_circular_deque(const unsigned int max_size, const unsigned int nchann)
+{
+ d_max_size = max_size;
+ d_nchannels = nchann;
+ if (d_max_size > 0 and d_nchannels > 0)
+ {
+ d_size = new unsigned int[d_nchannels];
+ d_index_pop = new unsigned int[d_nchannels];
+ d_index_push = new unsigned int[d_nchannels];
+ d_history = new T*[d_nchannels];
+ for (unsigned int i = 0; i < d_nchannels; i++)
+ {
+ d_size[i] = 0;
+ d_index_pop[i] = 0;
+ d_index_push[i] = 0;
+ d_history[i] = new T[d_max_size];
+ }
+ }
+}
+
+template
+Gnss_circular_deque::~Gnss_circular_deque()
+{
+ if (d_max_size > 0 and d_nchannels > 0)
+ {
+ delete[] d_size;
+ delete[] d_index_pop;
+ delete[] d_index_push;
+ for (unsigned int i = 0; i < d_nchannels; i++)
+ {
+ delete[] d_history[i];
+ }
+ delete[] d_history;
+ }
+}
+
+template
+unsigned int Gnss_circular_deque::size(const unsigned int ch)
+{
+ return d_size[ch];
+}
+
+template
+T& Gnss_circular_deque::back(const unsigned int ch)
+{
+ if (d_size[ch] > 0)
+ {
+ unsigned int index = 0;
+ if (d_index_push[ch] > 0)
+ {
+ index = d_index_push[ch] - 1;
+ }
+ else
+ {
+ index = d_max_size;
+ }
+ return d_history[ch][index];
+ }
+ else
+ {
+ return d_return_void;
+ }
+}
+
+template
+T& Gnss_circular_deque::front(const unsigned int ch)
+{
+ if (d_size[ch] > 0)
+ {
+ return d_history[ch][d_index_pop[ch]];
+ }
+ else
+ {
+ return d_return_void;
+ }
+}
+
+template
+T& Gnss_circular_deque::at(const unsigned int ch, const unsigned int pos)
+{
+ if (d_size[ch] > 0 and pos < d_size[ch])
+ {
+ unsigned int index = (d_index_pop[ch] + pos) % d_max_size;
+ return d_history[ch][index];
+ }
+ else
+ {
+ return d_return_void;
+ }
+}
+
+template
+void Gnss_circular_deque::clear(const unsigned int ch)
+{
+ d_size[ch] = 0;
+ d_index_pop[ch] = 0;
+ d_index_push[ch] = 0;
+}
+
+template
+T Gnss_circular_deque::pop_front(const unsigned int ch)
+{
+ T result;
+ if (d_size[ch] > 0)
+ {
+ d_size[ch]--;
+ result = d_history[ch][d_index_pop[ch]];
+ d_index_pop[ch]++;
+ d_index_pop[ch] %= d_max_size;
+ }
+ return result;
+}
+
+template
+void Gnss_circular_deque::push_back(const unsigned int ch, const T& new_data)
+{
+ d_history[ch][d_index_push[ch]] = new_data;
+ d_index_push[ch]++;
+ d_index_push[ch] %= d_max_size;
+ if (d_size[ch] < d_max_size)
+ {
+ d_size[ch]++;
+ }
+ else
+ {
+ d_index_pop[ch]++;
+ d_index_pop[ch] %= d_max_size;
+ }
+}
+
+template
+T* Gnss_circular_deque::get_vector(const unsigned int ch)
+{
+ return d_history[ch];
+}
+
+
+#endif /* GNSS_SDR_CIRCULAR_DEQUE_H_ */
diff --git a/src/algorithms/observables/adapters/CMakeLists.txt b/src/algorithms/observables/adapters/CMakeLists.txt
index 5129e4157..882b22d83 100644
--- a/src/algorithms/observables/adapters/CMakeLists.txt
+++ b/src/algorithms/observables/adapters/CMakeLists.txt
@@ -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}
diff --git a/src/algorithms/observables/gnuradio_blocks/CMakeLists.txt b/src/algorithms/observables/gnuradio_blocks/CMakeLists.txt
index 98b8213d8..e3db8ebcf 100644
--- a/src/algorithms/observables/gnuradio_blocks/CMakeLists.txt
+++ b/src/algorithms/observables/gnuradio_blocks/CMakeLists.txt
@@ -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})
diff --git a/src/algorithms/observables/gnuradio_blocks/hybrid_observables_cc.cc b/src/algorithms/observables/gnuradio_blocks/hybrid_observables_cc.cc
index 6e95da824..4b03988aa 100644
--- a/src/algorithms/observables/gnuradio_blocks/hybrid_observables_cc.cc
+++ b/src/algorithms/observables/gnuradio_blocks/hybrid_observables_cc.cc
@@ -66,11 +66,7 @@ hybrid_observables_cc::hybrid_observables_cc(unsigned int nchannels_in,
max_delta = 0.15; // 150 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());
- }
+ d_gnss_synchro_history = Gnss_circular_deque(200, d_nchannels);
// ############# ENABLE DATA FILE LOG #################
if (d_dump)
@@ -302,15 +298,37 @@ int hybrid_observables_cc::save_matfile()
}
-bool hybrid_observables_cc::interpolate_data(Gnss_Synchro &out, std::deque &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::iterator it;
+ std::pair ind = find_interp_elements(ch, ti);
- arma::vec t = arma::vec(data.size());
+ double m = 0.0;
+ double c = 0.0;
+
+ // CARRIER PHASE INTERPOLATION
+
+ m = (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).RX_time - d_gnss_synchro_history.at(ch, ind.second).RX_time);
+ c = d_gnss_synchro_history.at(ch, ind.first).Carrier_phase_rads - m * d_gnss_synchro_history.at(ch, ind.first).RX_time;
+ out.Carrier_phase_rads = m * ti + c;
+
+ // CARRIER DOPPLER INTERPOLATION
+ m = (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).RX_time - d_gnss_synchro_history.at(ch, ind.second).RX_time);
+ c = d_gnss_synchro_history.at(ch, ind.first).Carrier_Doppler_hz - m * d_gnss_synchro_history.at(ch, ind.first).RX_time;
+ out.Carrier_Doppler_hz = m * ti + c;
+
+ // TOW INTERPOLATION
+ m = (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).RX_time - d_gnss_synchro_history.at(ch, ind.second).RX_time);
+ c = d_gnss_synchro_history.at(ch, ind.first).TOW_at_current_symbol_s - m * d_gnss_synchro_history.at(ch, ind.first).RX_time;
+ out.TOW_at_current_symbol_s = m * ti + c;
+
+ return true;
+
+ /*
+ arma::vec t = arma::vec(d_gnss_synchro_history.size(ch));
arma::vec dop = t;
arma::vec cph = t;
arma::vec tow = t;
@@ -336,6 +354,7 @@ bool hybrid_observables_cc::interpolate_data(Gnss_Synchro &out, std::deque hybrid_observables_cc::find_interp_elements(const unsigned int &ch, const double &ti)
+{
+ unsigned int closest = 0;
+ double dif = std::numeric_limits::max();
+ double dt = 0.0;
+ for (unsigned int i = 0; i < d_gnss_synchro_history.size(ch); i++)
+ {
+ dt = std::fabs(ti - d_gnss_synchro_history.at(ch, i).RX_time);
+ if (dt < dif)
+ {
+ 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
+ {
+ if (d_gnss_synchro_history.at(ch, closest).RX_time < ti)
+ {
+ index1 = closest;
+ index2 = closest + 1;
+ }
+ else
+ {
+ index1 = closest - 1;
+ index2 = closest;
+ }
+ }
+ return std::pair(index1, index2);
+}
+
void hybrid_observables_cc::forecast(int noutput_items __attribute__((unused)),
gr_vector_int &ninput_items_required)
@@ -363,13 +424,13 @@ void hybrid_observables_cc::forecast(int noutput_items __attribute__((unused)),
}
-void hybrid_observables_cc::clean_history(std::deque &data)
+void hybrid_observables_cc::clean_history(Gnss_circular_deque &data, unsigned int pos)
{
- while (data.size() > 0)
+ while (data.size(pos) > 0)
{
- if ((T_rx_s - data.front().RX_time) > max_delta)
+ if ((T_rx_s - data.front(pos).RX_time) > max_delta)
{
- data.pop_front();
+ data.pop_front(pos);
}
else
{
@@ -454,11 +515,9 @@ int hybrid_observables_cc::general_work(int noutput_items __attribute__((unused)
}
//////////////////////////////////////////////////////////////////////////
- std::vector>::iterator it;
if (total_input_items > 0)
{
- i = 0;
- for (it = d_gnss_synchro_history.begin(); it != d_gnss_synchro_history.end(); it++)
+ for (unsigned int i = 0; i < d_nchannels; i++)
{
if (ninput_items[i] > 0)
{
@@ -467,26 +526,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 +564,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(d_gnss_synchro_history, i);
+ if (d_gnss_synchro_history.size(i) < 2)
{
valid_channels[i] = false;
}
@@ -523,13 +581,12 @@ int hybrid_observables_cc::general_work(int noutput_items __attribute__((unused)
}
std::vector epoch_data;
- i = 0;
- for (it = d_gnss_synchro_history.begin(); it != d_gnss_synchro_history.end(); it++)
+ for (unsigned int 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 +595,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 +602,14 @@ int hybrid_observables_cc::general_work(int noutput_items __attribute__((unused)
return 0;
}
correct_TOW_and_compute_prange(epoch_data);
- std::vector::iterator it2 = epoch_data.begin();
+ std::vector::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
{
diff --git a/src/algorithms/observables/gnuradio_blocks/hybrid_observables_cc.h b/src/algorithms/observables/gnuradio_blocks/hybrid_observables_cc.h
index aedba43ab..298a9a0bb 100644
--- a/src/algorithms/observables/gnuradio_blocks/hybrid_observables_cc.h
+++ b/src/algorithms/observables/gnuradio_blocks/hybrid_observables_cc.h
@@ -35,12 +35,12 @@
#define GNSS_SDR_HYBRID_OBSERVABLES_CC_H
#include "gnss_synchro.h"
+#include "gnss_circular_deque.h"
#include
#include
#include
#include
-#include
-#include
+#include
class hybrid_observables_cc;
@@ -65,14 +65,15 @@ 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& data);
+ void clean_history(Gnss_circular_deque& data, unsigned int pos);
double compute_T_rx_s(const Gnss_Synchro& a);
- bool interpolate_data(Gnss_Synchro& out, std::deque& data, const double& ti);
+ bool interpolate_data(Gnss_Synchro& out, const unsigned int& ch, const double& ti);
+ std::pair find_interp_elements(const unsigned int& ch, const double& ti);
void correct_TOW_and_compute_prange(std::vector& data);
int save_matfile();
//Tracking observable history
- std::vector> d_gnss_synchro_history;
+ Gnss_circular_deque d_gnss_synchro_history;
boost::dynamic_bitset<> valid_channels;
double T_rx_s;
double T_rx_step_s;