mirrors/gnss-sdr
1
0
Fork 0
mirror of https://github.com/gnss-sdr/gnss-sdr synced 2025-01-19 05:33:02 +00:00
Code Issues Releases Wiki Activity

Fix shadowed variables

Browse Source
This commit is contained in:
Carles Fernandez 2020-02-26 18:16:04 +01:00
parent 57517b44dd
commit 538c1e6182
18 changed files with 77 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/algorithms/PVT/libs/rtcm.cc
View File

@ -1673,7 +1673,7 @@ int32_t Rtcm::read_MT1019(const std::string& message, Gps_Ephemeris& gps_eph)
gps_eph.d_Cuc = static_cast<double>(Rtcm::bin_to_int(message_bin.substr(index, 16))) * C_UC_LSB; gps_eph.d_Cuc = static_cast<double>(Rtcm::bin_to_int(message_bin.substr(index, 16))) * C_UC_LSB;
index += 16; index += 16;
gps_eph.d_e_eccentricity = static_cast<double>(Rtcm::bin_to_uint(message_bin.substr(index, 32))) * E_LSB; gps_eph.d_e_eccentricity = static_cast<double>(Rtcm::bin_to_uint(message_bin.substr(index, 32))) * ECCENTRICITY_LSB;
index += 32; index += 32;
gps_eph.d_Cus = static_cast<double>(Rtcm::bin_to_int(message_bin.substr(index, 16))) * C_US_LSB; gps_eph.d_Cus = static_cast<double>(Rtcm::bin_to_int(message_bin.substr(index, 16))) * C_US_LSB;
@ -4372,7 +4372,7 @@ int32_t Rtcm::set_DF089(const Gps_Ephemeris& gps_eph)
int32_t Rtcm::set_DF090(const Gps_Ephemeris& gps_eph) int32_t Rtcm::set_DF090(const Gps_Ephemeris& gps_eph)
{ {
auto ecc = static_cast<uint64_t>(std::round(gps_eph.d_e_eccentricity / E_LSB)); auto ecc = static_cast<uint64_t>(std::round(gps_eph.d_e_eccentricity / ECCENTRICITY_LSB));
DF090 = std::bitset<32>(ecc); DF090 = std::bitset<32>(ecc);
return 0; return 0;
} }

24
src/algorithms/libs/rtklib/rtklib_stream.cc
View File

@ -120,7 +120,7 @@ serial_t *openserial(const char *path, int mode, char *msg)
std::string s_aux = "/dev/" + std::string(port); std::string s_aux = "/dev/" + std::string(port);
s_aux.resize(128, '\0'); s_aux.resize(128, '\0');
int n = s_aux.length(); int n = s_aux.length();
for (int i = 0; i < n; i++) for (i = 0; i < n; i++)
{ {
dev[i] = s_aux[i]; dev[i] = s_aux[i];
} }
@ -695,7 +695,7 @@ void syncfile(file_t *file1, file_t *file2)
void decodetcppath(const char *path, char *addr, char *port, char *user, void decodetcppath(const char *path, char *addr, char *port, char *user,
char *passwd, char *mntpnt, char *str) char *passwd, char *mntpnt, char *str)
{ {
char buff[MAXSTRPATH]; char buff[MAXSTRPATH] = "";
char *p; char *p;
char *q; char *q;
@ -1556,7 +1556,7 @@ int rspntrip_s(ntrip_t *ntrip, char *msg)
// strncpy(msg, (char *)ntrip->buff, nb); This line triggers a warning. Replaced by; // strncpy(msg, (char *)ntrip->buff, nb); This line triggers a warning. Replaced by;
std::string s_aux(reinterpret_cast<char *>(ntrip->buff)); std::string s_aux(reinterpret_cast<char *>(ntrip->buff));
s_aux.resize(nb, '\0'); s_aux.resize(nb, '\0');
for (int i = 0; i < nb; i++) for (i = 0; i < nb; i++)
{ {
msg[i] = s_aux[i]; msg[i] = s_aux[i];
} }
@ -1815,7 +1815,7 @@ int statentrip(ntrip_t *ntrip)
void decodeftppath(const char *path, char *addr, char *file, char *user, void decodeftppath(const char *path, char *addr, char *file, char *user,
char *passwd, int *topts) char *passwd, int *topts)
{ {
char buff[MAXSTRPATH]; char buff[MAXSTRPATH] = "";
char *p; char *p;
char *q; char *q;
@ -2006,7 +2006,7 @@ void *ftpthread(void *arg)
/* download command (ref [2]) */ /* download command (ref [2]) */
if (ftp->proto == 0) if (ftp->proto == 0)
{ /* ftp */ { /* ftp */
std::string s_aux = "--ftp-user=" + std::string(ftp->user) + " --ftp-password=" + std::string(ftp->passwd) + s_aux = "--ftp-user=" + std::string(ftp->user) + " --ftp-password=" + std::string(ftp->passwd) +
" --glob=off --passive-ftp " + std::string(proxyopt) + "s-t 1 -T " + std::to_string(FTP_TIMEOUT) + " --glob=off --passive-ftp " + std::string(proxyopt) + "s-t 1 -T " + std::to_string(FTP_TIMEOUT) +
" -O \"" + std::string(local) + "\""; " -O \"" + std::string(local) + "\"";
int k = s_aux.length(); int k = s_aux.length();
@ -2018,7 +2018,7 @@ void *ftpthread(void *arg)
} }
} }
std::string s_aux2 = std::string(env) + std::string(FTP_CMD) + " " + std::string(opt) + " " + s_aux2 = std::string(env) + std::string(FTP_CMD) + " " + std::string(opt) + " " +
"\"ftp://" + std::string(ftp->addr) + "/" + std::string(remote) + "\" 2> \"" + std::string(errfile) + "\"\n"; "\"ftp://" + std::string(ftp->addr) + "/" + std::string(remote) + "\" 2> \"" + std::string(errfile) + "\"\n";
k = s_aux2.length(); k = s_aux2.length();
for (int i = 0; (i < k) && (i < 1024); i++) for (int i = 0; (i < k) && (i < 1024); i++)
@ -2028,14 +2028,14 @@ void *ftpthread(void *arg)
} }
else else
{ /* http */ { /* http */
std::string s_aux = std::string(proxyopt) + " -t 1 -T " + std::to_string(FTP_TIMEOUT) + " -O \"" + std::string(local) + "\""; s_aux = std::string(proxyopt) + " -t 1 -T " + std::to_string(FTP_TIMEOUT) + " -O \"" + std::string(local) + "\"";
int l = s_aux.length(); int l = s_aux.length();
for (int i = 0; (i < l) && (i < 1024); i++) for (int i = 0; (i < l) && (i < 1024); i++)
{ {
opt[i] = s_aux[i]; opt[i] = s_aux[i];
} }
std::string s_aux2 = std::string(env) + std::string(FTP_CMD) + " " + std::string(opt) + " " + s_aux2 = std::string(env) + std::string(FTP_CMD) + " " + std::string(opt) + " " +
"\"http://" + std::string(ftp->addr) + "/" + std::string(remote) + "\" 2> \"" + std::string(errfile) + "\"\n"; "\"http://" + std::string(ftp->addr) + "/" + std::string(remote) + "\" 2> \"" + std::string(errfile) + "\"\n";
l = s_aux2.length(); l = s_aux2.length();
for (int i = 0; (i < l) && (i < 1024); i++) for (int i = 0; (i < l) && (i < 1024); i++)
@ -2680,15 +2680,15 @@ void strsetopt(const int *opt)
/* set timeout time ------------------------------------------------------------ /* set timeout time ------------------------------------------------------------
* set timeout time * set timeout time
* args : stream_t *stream I stream (STR_TCPCLI, STR_NTRIPCLI, STR_NTRIPSVR) * args : stream_t *stream I stream (STR_TCPCLI, STR_NTRIPCLI, STR_NTRIPSVR)
* int toinact I inactive timeout (ms) (0: no timeout) * int inactive_timeout I inactive timeout (ms) (0: no timeout)
* int tirecon I reconnect interval (ms) (0: no reconnect) * int tirecon I reconnect interval (ms) (0: no reconnect)
* return : none * return : none
*-----------------------------------------------------------------------------*/ *-----------------------------------------------------------------------------*/
void strsettimeout(stream_t *stream, int toinact, int tirecon) void strsettimeout(stream_t *stream, int inactive_timeout, int tirecon)
{ {
tcpcli_t *tcpcli; tcpcli_t *tcpcli;
tracet(3, "strsettimeout: toinact=%d tirecon=%d\n", toinact, tirecon); tracet(3, "strsettimeout: toinact=%d tirecon=%d\n", inactive_timeout, tirecon);
if (stream->type == STR_TCPCLI) if (stream->type == STR_TCPCLI)
{ {
@ -2703,7 +2703,7 @@ void strsettimeout(stream_t *stream, int toinact, int tirecon)
return; return;
} }
tcpcli->toinact = toinact; tcpcli->toinact = inactive_timeout;
tcpcli->tirecon = tirecon; tcpcli->tirecon = tirecon;
} }

2
src/algorithms/signal_generator/gnuradio_blocks/signal_generator_c.cc
View File

@ -133,8 +133,6 @@ void signal_generator_c::init()
} }
} }
} }
std::uniform_int_distribution<int> uniform_dist(0, RAND_MAX);
} }

6
src/algorithms/telemetry_decoder/gnuradio_blocks/galileo_telemetry_decoder_gs.cc
View File

@ -576,25 +576,19 @@ int galileo_telemetry_decoder_gs::general_work(int noutput_items __attribute__((
// NEW Galileo page part is received // NEW Galileo page part is received
// 0. fetch the symbols into an array // 0. fetch the symbols into an array
if (flag_PLL_180_deg_phase_locked == false) // normal PLL lock if (flag_PLL_180_deg_phase_locked == false) // normal PLL lock
{
for (uint32_t i = 0; i < d_frame_length_symbols; i++)
{ {
for (uint32_t i = 0; i < d_frame_length_symbols; i++) for (uint32_t i = 0; i < d_frame_length_symbols; i++)
{ {
d_page_part_symbols[i] = d_symbol_history[i + d_samples_per_preamble]; // because last symbol of the preamble is just received now! d_page_part_symbols[i] = d_symbol_history[i + d_samples_per_preamble]; // because last symbol of the preamble is just received now!
} }
} }
}
else // 180 deg. inverted carrier phase PLL lock else // 180 deg. inverted carrier phase PLL lock
{
for (uint32_t i = 0; i < d_frame_length_symbols; i++)
{ {
for (uint32_t i = 0; i < d_frame_length_symbols; i++) for (uint32_t i = 0; i < d_frame_length_symbols; i++)
{ {
d_page_part_symbols[i] = -d_symbol_history[i + d_samples_per_preamble]; // because last symbol of the preamble is just received now! d_page_part_symbols[i] = -d_symbol_history[i + d_samples_per_preamble]; // because last symbol of the preamble is just received now!
} }
} }
}
decode_FNAV_word(d_page_part_symbols.data(), d_frame_length_symbols); decode_FNAV_word(d_page_part_symbols.data(), d_frame_length_symbols);
break; break;
default: default:

24
src/algorithms/telemetry_decoder/libs/viterbi_decoder.cc
View File

@ -442,12 +442,12 @@ Viterbi_Decoder::Prev::Prev(int states, int t)
this->t = t; this->t = t;
num_states = states; num_states = states;
state.reserve(num_states); state.reserve(num_states);
bit.reserve(num_states); v_bit.reserve(num_states);
metric.reserve(num_states); v_metric.reserve(num_states);
refcount = 1; refcount = 1;
std::fill_n(state.begin(), num_states, 0); std::fill_n(state.begin(), num_states, 0);
std::fill_n(bit.begin(), num_states, 0); std::fill_n(v_bit.begin(), num_states, 0);
std::fill_n(metric.begin(), num_states, 0.0F); std::fill_n(v_metric.begin(), num_states, 0.0F);
} }
@ -459,8 +459,8 @@ Viterbi_Decoder::Prev::Prev(const Prev& prev)
t = prev.t; t = prev.t;
state = prev.state; state = prev.state;
num_states = prev.num_states; num_states = prev.num_states;
bit = prev.bit; v_bit = prev.v_bit;
metric = prev.metric; v_metric = prev.v_metric;
VLOG(LMORE) << "Prev(" VLOG(LMORE) << "Prev("
<< "?" << "?"
<< ", " << t << ")" << ", " << t << ")"
@ -490,8 +490,8 @@ Viterbi_Decoder::Prev& Viterbi_Decoder::Prev::operator=(const Prev& other)
// take over resources // take over resources
t = other.t; t = other.t;
state = other.state; state = other.state;
bit = other.bit; v_bit = other.v_bit;
metric = other.metric; v_metric = other.v_metric;
VLOG(LMORE) << "Prev(" VLOG(LMORE) << "Prev("
<< "?" << "?"
@ -532,7 +532,7 @@ int Viterbi_Decoder::Prev::get_bit_of_current_state(int current_state)
// std::cout << "get prev bit : for state " << current_state << " at time " << t << ", the send bit is " << bit[current_state] << std::endl; // std::cout << "get prev bit : for state " << current_state << " at time " << t << ", the send bit is " << bit[current_state] << std::endl;
if (num_states > current_state) if (num_states > current_state)
{ {
return bit[current_state]; return v_bit[current_state];
} }
return 0; return 0;
} }
@ -542,7 +542,7 @@ float Viterbi_Decoder::Prev::get_metric_of_current_state(int current_state)
{ {
if (num_states > current_state) if (num_states > current_state)
{ {
return metric[current_state]; return v_metric[current_state];
} }
return 0; return 0;
} }
@ -567,7 +567,7 @@ void Viterbi_Decoder::Prev::set_decoded_bit_for_next_state(int next_state, int b
{ {
if (num_states > next_state) if (num_states > next_state)
{ {
this->bit[next_state] = bit; this->v_bit[next_state] = bit;
} }
} }
@ -576,6 +576,6 @@ void Viterbi_Decoder::Prev::set_survivor_branch_metric_of_next_state(int next_st
{ {
if (num_states > next_state) if (num_states > next_state)
{ {
this->metric[next_state] = metric; this->v_metric[next_state] = metric;
} }
} }

4
src/algorithms/telemetry_decoder/libs/viterbi_decoder.h
View File

@ -69,8 +69,8 @@ private:
private: private:
int t; int t;
std::vector<int> state; std::vector<int> state;
std::vector<int> bit; std::vector<int> v_bit;
std::vector<float> metric; std::vector<float> v_metric;
int refcount; int refcount;
}; };

2
src/core/libs/gnss_sdr_supl_client.cc
View File

@ -313,7 +313,7 @@ void Gnss_Sdr_Supl_Client::read_supl_data()
gps_eph_iterator->second.d_Delta_n = static_cast<double>(e->delta_n) * DELTA_N_LSB; gps_eph_iterator->second.d_Delta_n = static_cast<double>(e->delta_n) * DELTA_N_LSB;
gps_eph_iterator->second.d_M_0 = static_cast<double>(e->M0) * M_0_LSB; gps_eph_iterator->second.d_M_0 = static_cast<double>(e->M0) * M_0_LSB;
gps_eph_iterator->second.d_Cuc = static_cast<double>(e->Cuc) * C_UC_LSB; gps_eph_iterator->second.d_Cuc = static_cast<double>(e->Cuc) * C_UC_LSB;
gps_eph_iterator->second.d_e_eccentricity = static_cast<double>(e->e) * E_LSB; gps_eph_iterator->second.d_e_eccentricity = static_cast<double>(e->e) * ECCENTRICITY_LSB;
gps_eph_iterator->second.d_Cus = static_cast<double>(e->Cus) * C_US_LSB; gps_eph_iterator->second.d_Cus = static_cast<double>(e->Cus) * C_US_LSB;
gps_eph_iterator->second.d_sqrt_A = static_cast<double>(e->A_sqrt) * SQRT_A_LSB; gps_eph_iterator->second.d_sqrt_A = static_cast<double>(e->A_sqrt) * SQRT_A_LSB;
gps_eph_iterator->second.d_Toe = static_cast<double>(e->toe) * T_OE_LSB; gps_eph_iterator->second.d_Toe = static_cast<double>(e->toe) * T_OE_LSB;

1
src/core/monitor/gnss_synchro_udp_sink.h
View File

@ -50,7 +50,6 @@ private:
boost::asio::ip::udp::socket socket; boost::asio::ip::udp::socket socket;
boost::system::error_code error; boost::system::error_code error;
std::vector<boost::asio::ip::udp::endpoint> endpoints; std::vector<boost::asio::ip::udp::endpoint> endpoints;
std::vector<Gnss_Synchro> stocks;
Serdes_Gnss_Synchro serdes; Serdes_Gnss_Synchro serdes;
bool use_protobuf; bool use_protobuf;
}; };

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

@ -431,7 +431,7 @@ void GNSSFlowgraph::connect()
{ {
decimation--; decimation--;
}; };
double acq_fs = static_cast<double>(fs) / static_cast<double>(decimation); double acq_fs_decimated = static_cast<double>(fs) / static_cast<double>(decimation);
if (decimation > 1) if (decimation > 1)
{ {
@ -455,8 +455,8 @@ void GNSSFlowgraph::connect()
taps = gr::filter::firdes::low_pass(1.0, taps = gr::filter::firdes::low_pass(1.0,
fs, fs,
acq_fs / 2.1, acq_fs_decimated / 2.1,
acq_fs / 2, acq_fs_decimated / 2,
gr::filter::firdes::win_type::WIN_HAMMING); gr::filter::firdes::win_type::WIN_HAMMING);
gr::basic_block_sptr fir_filter_ccf_ = gr::filter::fir_filter_ccf::make(decimation, taps); gr::basic_block_sptr fir_filter_ccf_ = gr::filter::fir_filter_ccf::make(decimation, taps);
@ -1361,8 +1361,8 @@ void GNSSFlowgraph::apply_action(unsigned int who, unsigned int what)
if (channels_state_[n] == 1 or channels_state_[n] == 2) // channel in acquisition or in tracking if (channels_state_[n] == 1 or channels_state_[n] == 2) // channel in acquisition or in tracking
{ {
// recover the satellite assigned // recover the satellite assigned
Gnss_Signal gs = channels_[n]->get_signal(); Gnss_Signal gs_assigned = channels_[n]->get_signal();
push_back_signal(gs); push_back_signal(gs_assigned);
channels_[n]->stop_channel(); // stop the acquisition or tracking operation channels_[n]->stop_channel(); // stop the acquisition or tracking operation
channels_state_[n] = 0; channels_state_[n] = 0;
@ -1950,7 +1950,6 @@ Gnss_Signal GNSSFlowgraph::search_next_signal(const std::string& searched_signal
// 1. Get the current channel status map // 1. Get the current channel status map
std::map<int, std::shared_ptr<Gnss_Synchro>> current_channels_status = channels_status_->get_current_status_map(); std::map<int, std::shared_ptr<Gnss_Synchro>> current_channels_status = channels_status_->get_current_status_map();
// 2. search the currently tracked GPS L1 satellites and assist the GPS L2 acquisition if the satellite is not tracked on L2 // 2. search the currently tracked GPS L1 satellites and assist the GPS L2 acquisition if the satellite is not tracked on L2
bool found_signal = false;
for (auto& current_status : current_channels_status) for (auto& current_status : current_channels_status)
{ {
if (std::string(current_status.second->Signal) == "1C") if (std::string(current_status.second->Signal) == "1C")

4
src/core/system_parameters/GPS_L1_CA.h
View File

@ -127,8 +127,8 @@ const std::vector<std::pair<int32_t, int32_t>> M_0({{107, 8}, {121, 24}});
const double M_0_LSB = PI_TWO_N31; const double M_0_LSB = PI_TWO_N31;
const std::vector<std::pair<int32_t, int32_t>> C_UC({{151, 16}}); const std::vector<std::pair<int32_t, int32_t>> C_UC({{151, 16}});
const double C_UC_LSB = TWO_N29; const double C_UC_LSB = TWO_N29;
const std::vector<std::pair<int32_t, int32_t>> E({{167, 8}, {181, 24}}); const std::vector<std::pair<int32_t, int32_t>> ECCENTRICITY({{167, 8}, {181, 24}});
const double E_LSB = TWO_N33; const double ECCENTRICITY_LSB = TWO_N33;
const std::vector<std::pair<int32_t, int32_t>> C_US({{211, 16}}); const std::vector<std::pair<int32_t, int32_t>> C_US({{211, 16}});
const double C_US_LSB = TWO_N29; const double C_US_LSB = TWO_N29;
const std::vector<std::pair<int32_t, int32_t>> SQRT_A({{227, 8}, {241, 24}}); const std::vector<std::pair<int32_t, int32_t>> SQRT_A({{227, 8}, {241, 24}});

1
src/core/system_parameters/galileo_navigation_message.cc
View File

@ -33,7 +33,6 @@ using CRC_Galileo_INAV_type = boost::crc_optimal<24, 0x1864CFBU, 0x0, 0x0, false
void Galileo_Navigation_Message::reset() void Galileo_Navigation_Message::reset()
{ {
flag_even_word = 0;
Page_type_time_stamp = 0; Page_type_time_stamp = 0;
flag_CRC_test = false; flag_CRC_test = false;

1
src/core/system_parameters/galileo_navigation_message.h
View File

@ -45,7 +45,6 @@ public:
Galileo_Navigation_Message(); Galileo_Navigation_Message();
int32_t Page_type_time_stamp; int32_t Page_type_time_stamp;
int32_t flag_even_word;
std::string page_Even; std::string page_Even;
bool flag_CRC_test; bool flag_CRC_test;
bool flag_all_ephemeris; //!< Flag indicating that all words containing ephemeris have been received bool flag_all_ephemeris; //!< Flag indicating that all words containing ephemeris have been received

4
src/core/system_parameters/gps_navigation_message.cc
View File

@ -290,8 +290,8 @@ int32_t Gps_Navigation_Message::subframe_decoder(char* subframe)
d_M_0 = d_M_0 * M_0_LSB; d_M_0 = d_M_0 * M_0_LSB;
d_Cuc = static_cast<double>(read_navigation_signed(subframe_bits, C_UC)); d_Cuc = static_cast<double>(read_navigation_signed(subframe_bits, C_UC));
d_Cuc = d_Cuc * C_UC_LSB; d_Cuc = d_Cuc * C_UC_LSB;
d_e_eccentricity = static_cast<double>(read_navigation_unsigned(subframe_bits, E)); d_e_eccentricity = static_cast<double>(read_navigation_unsigned(subframe_bits, ECCENTRICITY));
d_e_eccentricity = d_e_eccentricity * E_LSB; d_e_eccentricity = d_e_eccentricity * ECCENTRICITY_LSB;
d_Cus = static_cast<double>(read_navigation_signed(subframe_bits, C_US)); d_Cus = static_cast<double>(read_navigation_signed(subframe_bits, C_US));
d_Cus = d_Cus * C_US_LSB; d_Cus = d_Cus * C_US_LSB;
d_sqrt_A = static_cast<double>(read_navigation_unsigned(subframe_bits, SQRT_A)); d_sqrt_A = static_cast<double>(read_navigation_unsigned(subframe_bits, SQRT_A));

44
src/tests/system-tests/position_test.cc
View File

@ -489,11 +489,11 @@ void PositionSystemTest::check_results()
Rtklib_Solver_Dump_Reader pvt_reader; Rtklib_Solver_Dump_Reader pvt_reader;
pvt_reader.open_obs_file(FLAGS_pvt_solver_dump_filename); pvt_reader.open_obs_file(FLAGS_pvt_solver_dump_filename);
int64_t n_epochs = pvt_reader.num_epochs(); int64_t n_epochs_pvt = pvt_reader.num_epochs();
R_eb_e = arma::zeros(3, n_epochs); R_eb_e = arma::zeros(3, n_epochs_pvt);
V_eb_e = arma::zeros(3, n_epochs); V_eb_e = arma::zeros(3, n_epochs_pvt);
LLH = arma::zeros(3, n_epochs); LLH = arma::zeros(3, n_epochs_pvt);
receiver_time_s = arma::zeros(n_epochs, 1); receiver_time_s = arma::zeros(n_epochs_pvt, 1);
int64_t current_epoch = 0; int64_t current_epoch = 0;
while (pvt_reader.read_binary_obs()) while (pvt_reader.read_binary_obs())
{ {
@ -620,25 +620,25 @@ void PositionSystemTest::check_results()
// dynamic position // dynamic position
Spirent_Motion_Csv_Dump_Reader ref_reader; Spirent_Motion_Csv_Dump_Reader ref_reader;
ref_reader.open_obs_file(FLAGS_ref_motion_filename); ref_reader.open_obs_file(FLAGS_ref_motion_filename);
int64_t n_epochs = ref_reader.num_epochs(); int64_t n_epochs_ref = ref_reader.num_epochs();
ref_R_eb_e = arma::zeros(3, n_epochs); ref_R_eb_e = arma::zeros(3, n_epochs_ref);
ref_V_eb_e = arma::zeros(3, n_epochs); ref_V_eb_e = arma::zeros(3, n_epochs_ref);
ref_LLH = arma::zeros(3, n_epochs); ref_LLH = arma::zeros(3, n_epochs_ref);
ref_time_s = arma::zeros(n_epochs, 1); ref_time_s = arma::zeros(n_epochs_ref, 1);
int64_t current_epoch = 0; int64_t current_epoch_index = 0;
while (ref_reader.read_csv_obs()) while (ref_reader.read_csv_obs())
{ {
ref_time_s(current_epoch) = ref_reader.TOW_ms / 1000.0; ref_time_s(current_epoch_index) = ref_reader.TOW_ms / 1000.0;
ref_R_eb_e(0, current_epoch) = ref_reader.Pos_X; ref_R_eb_e(0, current_epoch_index) = ref_reader.Pos_X;
ref_R_eb_e(1, current_epoch) = ref_reader.Pos_Y; ref_R_eb_e(1, current_epoch_index) = ref_reader.Pos_Y;
ref_R_eb_e(2, current_epoch) = ref_reader.Pos_Z; ref_R_eb_e(2, current_epoch_index) = ref_reader.Pos_Z;
ref_V_eb_e(0, current_epoch) = ref_reader.Vel_X; ref_V_eb_e(0, current_epoch_index) = ref_reader.Vel_X;
ref_V_eb_e(1, current_epoch) = ref_reader.Vel_Y; ref_V_eb_e(1, current_epoch_index) = ref_reader.Vel_Y;
ref_V_eb_e(2, current_epoch) = ref_reader.Vel_Z; ref_V_eb_e(2, current_epoch_index) = ref_reader.Vel_Z;
ref_LLH(0, current_epoch) = ref_reader.Lat; ref_LLH(0, current_epoch_index) = ref_reader.Lat;
ref_LLH(1, current_epoch) = ref_reader.Long; ref_LLH(1, current_epoch_index) = ref_reader.Long;
ref_LLH(2, current_epoch) = ref_reader.Height; ref_LLH(2, current_epoch_index) = ref_reader.Height;
current_epoch++; current_epoch_index++;
} }
// interpolation of reference data to receiver epochs timestamps // interpolation of reference data to receiver epochs timestamps
arma::mat ref_interp_R_eb_e = arma::zeros(3, R_eb_e.n_cols); arma::mat ref_interp_R_eb_e = arma::zeros(3, R_eb_e.n_cols);

10
src/tests/unit-tests/arithmetic/matio_test.cc
View File

@ -152,18 +152,18 @@ TEST(MatioTest, WriteAndReadGrComplex)
auto *x_read_real = reinterpret_cast<float *>(x_read_st->Re); auto *x_read_real = reinterpret_cast<float *>(x_read_st->Re);
auto *x_read_imag = reinterpret_cast<float *>(x_read_st->Im); auto *x_read_imag = reinterpret_cast<float *>(x_read_st->Im);
std::vector<gr_complex> x_v_read; std::vector<gr_complex> x_v_read;
for (unsigned int i = 0; i < size; i++) for (unsigned int k = 0; k < size; k++)
{ {
x_v_read.emplace_back(x_read_real[i], x_read_imag[i]); x_v_read.emplace_back(x_read_real[k], x_read_imag[k]);
} }
Mat_Close(matfp_read); Mat_Close(matfp_read);
Mat_VarFree(matvar_read); Mat_VarFree(matvar_read);
for (unsigned int i = 0; i < size; i++) for (unsigned int k = 0; k < size; k++)
{ {
EXPECT_FLOAT_EQ(x_v[i].real(), x_v_read[i].real()); EXPECT_FLOAT_EQ(x_v[k].real(), x_v_read[k].real());
EXPECT_FLOAT_EQ(x_v[i].imag(), x_v_read[i].imag()); EXPECT_FLOAT_EQ(x_v[k].imag(), x_v_read[k].imag());
} }
errorlib::error_code ec; errorlib::error_code ec;
ASSERT_EQ(fs::remove(fs::path(filename), ec), true); ASSERT_EQ(fs::remove(fs::path(filename), ec), true);

4
src/tests/unit-tests/signal-processing-blocks/pvt/rtcm_test.cc
View File

@ -251,14 +251,14 @@ TEST(RtcmTest, MT1019)
gps_eph.i_satellite_PRN = 3; gps_eph.i_satellite_PRN = 3;
gps_eph.d_IODC = 4; gps_eph.d_IODC = 4;
gps_eph.d_e_eccentricity = 2.0 * E_LSB; gps_eph.d_e_eccentricity = 2.0 * ECCENTRICITY_LSB;
gps_eph.b_fit_interval_flag = true; gps_eph.b_fit_interval_flag = true;
std::string tx_msg = rtcm->print_MT1019(gps_eph); std::string tx_msg = rtcm->print_MT1019(gps_eph);
EXPECT_EQ(0, rtcm->read_MT1019(tx_msg, gps_eph_read)); EXPECT_EQ(0, rtcm->read_MT1019(tx_msg, gps_eph_read));
EXPECT_EQ(static_cast<unsigned int>(3), gps_eph_read.i_satellite_PRN); EXPECT_EQ(static_cast<unsigned int>(3), gps_eph_read.i_satellite_PRN);
EXPECT_DOUBLE_EQ(4, gps_eph_read.d_IODC); EXPECT_DOUBLE_EQ(4, gps_eph_read.d_IODC);
EXPECT_DOUBLE_EQ(2.0 * E_LSB, gps_eph_read.d_e_eccentricity); EXPECT_DOUBLE_EQ(2.0 * ECCENTRICITY_LSB, gps_eph_read.d_e_eccentricity);
EXPECT_EQ(expected_true, gps_eph_read.b_fit_interval_flag); EXPECT_EQ(expected_true, gps_eph_read.b_fit_interval_flag);
EXPECT_EQ(1, rtcm->read_MT1019(rtcm->bin_to_binary_data(rtcm->hex_to_bin("FFFFFFFFFFF")), gps_eph_read)); EXPECT_EQ(1, rtcm->read_MT1019(rtcm->bin_to_binary_data(rtcm->hex_to_bin("FFFFFFFFFFF")), gps_eph_read));
} }

6
src/utils/front-end-cal/front_end_cal.cc
View File

@ -293,7 +293,7 @@ arma::vec FrontEndCal::geodetic2ecef(double phi, double lambda, double h, const
} }
double FrontEndCal::estimate_doppler_from_eph(unsigned int PRN, double TOW, double lat, double lon, double height) noexcept(false) double FrontEndCal::estimate_doppler_from_eph(unsigned int PRN, double tow, double lat, double lon, double height) noexcept(false)
{ {
int num_secs = 10; int num_secs = 10;
double step_secs = 0.5; double step_secs = 0.5;
@ -318,8 +318,8 @@ double FrontEndCal::estimate_doppler_from_eph(unsigned int PRN, double TOW, doub
arma::vec SV_pos_ecef = "0.0 0.0 0.0 0.0"; arma::vec SV_pos_ecef = "0.0 0.0 0.0 0.0";
double obs_time_start; double obs_time_start;
double obs_time_stop; double obs_time_stop;
obs_time_start = TOW - static_cast<double>(num_secs) / 2.0; obs_time_start = tow - static_cast<double>(num_secs) / 2.0;
obs_time_stop = TOW + static_cast<double>(num_secs) / 2.0; obs_time_stop = tow + static_cast<double>(num_secs) / 2.0;
int n_points = round((obs_time_stop - obs_time_start) / step_secs); int n_points = round((obs_time_stop - obs_time_start) / step_secs);
arma::vec ranges = arma::zeros(n_points, 1); arma::vec ranges = arma::zeros(n_points, 1);
double obs_time = obs_time_start; double obs_time = obs_time_start;

2
src/utils/front-end-cal/front_end_cal.h
View File

@ -54,7 +54,7 @@ public:
* 3- Approximate receiver Latitude and Longitude (WGS-84) * 3- Approximate receiver Latitude and Longitude (WGS-84)
* *
*/ */
double estimate_doppler_from_eph(unsigned int PRN, double TOW, double lat, double lon, double height) noexcept(false); double estimate_doppler_from_eph(unsigned int PRN, double tow, double lat, double lon, double height) noexcept(false);
/*! /*!
* \brief This function models the Elonics E4000 + RTL2832 front-end * \brief This function models the Elonics E4000 + RTL2832 front-end