mirrors/gnss-sdr
1
0
Fork 0
mirror of https://github.com/gnss-sdr/gnss-sdr synced 2024-12-14 20:20:35 +00:00
Code Issues Releases Wiki Activity

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

Browse Source
This commit is contained in:
Javier Arribas 2020-11-23 10:58:53 +01:00
commit f78512462f
75 changed files with 1666 additions and 251 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
.github/workflows/main.yml vendored
View File

@ -44,7 +44,7 @@ jobs:
- name: install dependencies
run: brew install clang-format
- name: run clang-format
run: find . -iname \*.h -o -iname \*.c -o -iname \*.cpp | xargs clang-format -style=file -i
run: find . -iname \*.h -o -iname \*.c -o -iname \*.cc | xargs clang-format -style=file -i
- name: check
run: git diff > clang_format.patch && echo -e "if \n [ -s clang_format.patch ] \nthen \n echo "clang-format not applied:"; echo ""; more clang_format.patch; exit 1 \nfi \n" > detect && chmod +x ./detect && ./detect
@ -112,6 +112,10 @@ jobs:
- name: test
shell: powershell
run: cd build; ctest -C Release
- name: install
run: cmake --install build
- name: run profile
run: cd 'C:\Program Files (x86)\volk_gnsssdr\bin'; .\volk_gnsssdr_profile.exe
volk-gnsssdr-ubuntu:

2
CMakeLists.txt
View File

@ -14,7 +14,7 @@ if(${CMAKE_SOURCE_DIR} STREQUAL ${CMAKE_BINARY_DIR})
message(FATAL_ERROR "Prevented in-tree build, it is bad practice.\nTry 'cd build && cmake ..' instead.")
endif()
cmake_minimum_required(VERSION 2.8.12...3.18)
cmake_minimum_required(VERSION 2.8.12...3.19)
project(gnss-sdr CXX C)
list(APPEND CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/Modules)

8
docs/changelog.md
View File

@ -57,6 +57,8 @@ SPDX-FileCopyrightText: 2011-2020 Carles Fernandez-Prades <carles.fernandez@cttc
GNSS-SDR, the old method is still used in old development environments. No
extra dependency is needed. This change is transparent to the user, since
everything is managed by the CMake scripts.
- The `volk_gnsssdr` library can be built on Microsoft Windows and can execute
SIMD instructions on that OS.
- Fix building with `-DENABLE_CUDA=ON` for blocks implemented with CUDA.
### Improvements in Usability:
@ -67,6 +69,8 @@ SPDX-FileCopyrightText: 2011-2020 Carles Fernandez-Prades <carles.fernandez@cttc
parameters for the `DataTypeAdapter`, `InputFilter` and `Resampler` blocks are
ignored. This was the default behavior in GNSS-SDR v0.0.12, but it changed in
v0.0.13. This change recovers the old behavior.
- Fixed occasional segmentation fault when exiting with `q` + `[Enter]` keys if
`Acquisition_XX.blocking=false`.
- Fixed the termination of the receiver with `q` + `[Enter]` keys when using the
`Osmosdr_Signal_Source` implementation of the `SignalSource` block.
- The `Labsat_Signal_Source` implementation of the `SignalSource` block now can
@ -85,6 +89,10 @@ SPDX-FileCopyrightText: 2011-2020 Carles Fernandez-Prades <carles.fernandez@cttc
Make use of MathJax for equation rendering. Added new building option
`ENABLE_EXTERNAL_MATHJAX`, set to `ON` by default. If set to `OFF`, it allows
using a local installation of MathJax 2.
- Improved dumps in Telemetry Decoding blocks. Now they include the raw
navigation message bits. If `TelemetryDecoder_XX.dump=true`, the resulting
`.dat` binary file is also delivered in `.mat` format, which is readable from
Matlab and Python.
&nbsp;

2
src/algorithms/PVT/libs/geojson_printer.cc
View File

@ -29,6 +29,7 @@
#include <iostream> // for cout, cerr
#include <sstream> // for stringstream
// clang-format off
#if HAS_STD_FILESYSTEM
#include <system_error>
namespace errorlib = std;
@ -47,6 +48,7 @@ namespace fs = std::filesystem;
namespace fs = boost::filesystem;
namespace errorlib = boost::system;
#endif
// clang-format on
GeoJSON_Printer::GeoJSON_Printer(const std::string& base_path)
{

2
src/algorithms/PVT/libs/gpx_printer.cc
View File

@ -29,6 +29,7 @@
#include <iostream> // for cout, cerr
#include <sstream> // for stringstream
// clang-format off
#if HAS_STD_FILESYSTEM
#include <system_error>
namespace errorlib = std;
@ -47,6 +48,7 @@ namespace fs = std::filesystem;
namespace fs = boost::filesystem;
namespace errorlib = boost::system;
#endif
// clang-format on
Gpx_Printer::Gpx_Printer(const std::string& base_path)

2
src/algorithms/PVT/libs/kml_printer.cc
View File

@ -31,6 +31,7 @@
#include <sys/stat.h> // for S_IXUSR | S_IRWXG | S_IRWXO
#include <sys/types.h> // for mode_t
// clang-format off
#if HAS_STD_FILESYSTEM
#include <system_error>
namespace errorlib = std;
@ -49,6 +50,7 @@ namespace fs = std::filesystem;
namespace fs = boost::filesystem;
namespace errorlib = boost::system;
#endif
// clang-format on
Kml_Printer::Kml_Printer(const std::string& base_path)

2
src/algorithms/PVT/libs/nmea_printer.cc
View File

@ -34,6 +34,7 @@
#include <termios.h>
#include <utility>
// clang-format off
#if HAS_STD_FILESYSTEM
#include <system_error>
namespace errorlib = std;
@ -52,6 +53,7 @@ namespace fs = std::filesystem;
namespace fs = boost::filesystem;
namespace errorlib = boost::system;
#endif
// clang-format on
Nmea_Printer::Nmea_Printer(const std::string& filename, bool flag_nmea_output_file, bool flag_nmea_tty_port, std::string nmea_dump_devname, const std::string& base_path)

2
src/algorithms/PVT/libs/rinex_printer.cc
View File

@ -56,6 +56,7 @@
#include <utility>
#include <vector>
// clang-format off
#if HAS_STD_FILESYSTEM
#include <system_error>
namespace errorlib = std;
@ -74,6 +75,7 @@ namespace fs = std::filesystem;
namespace fs = boost::filesystem;
namespace errorlib = boost::system;
#endif
// clang-format on
Rinex_Printer::Rinex_Printer(int32_t conf_version, const std::string& base_path, const std::string& base_name)

3
src/algorithms/PVT/libs/rtcm_printer.cc
View File

@ -38,6 +38,8 @@
#include <iostream> // for cout, cerr
#include <termios.h> // for tcgetattr
#include <unistd.h> // for close, write
// clang-format off
#if HAS_STD_FILESYSTEM
#include <system_error>
namespace errorlib = std;
@ -56,6 +58,7 @@ namespace fs = std::filesystem;
namespace fs = boost::filesystem;
namespace errorlib = boost::system;
#endif
// clang-format off
Rtcm_Printer::Rtcm_Printer(const std::string& filename, bool flag_rtcm_file_dump, bool flag_rtcm_server, bool flag_rtcm_tty_port, uint16_t rtcm_tcp_port, uint16_t rtcm_station_id, const std::string& rtcm_dump_devname, bool time_tag_name, const std::string& base_path)

2
src/algorithms/PVT/libs/rtklib_solver.cc
View File

@ -41,6 +41,7 @@
#include <utility>
#include <vector>
// clang-format off
#if HAS_STD_FILESYSTEM
#include <system_error>
namespace errorlib = std;
@ -59,6 +60,7 @@ namespace fs = std::filesystem;
namespace fs = boost::filesystem;
namespace errorlib = boost::system;
#endif
// clang-format on
Rtklib_Solver::Rtklib_Solver(const rtk_t &rtk, int nchannels, const std::string &dump_filename, bool flag_dump_to_file, bool flag_dump_to_mat)

19
src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition.cc
View File

@ -659,8 +659,10 @@ void pcps_acquisition::acquisition_core(uint64_t samp_count)
<< ", doppler_step: " << d_doppler_step
<< ", use_CFAR_algorithm_flag: " << (d_use_CFAR_algorithm_flag ? "true" : "false");
lk.unlock();
if (d_acq_parameters.blocking)
{
lk.unlock();
}
// Doppler frequency grid loop
if (!d_step_two)
{
@ -782,7 +784,11 @@ void pcps_acquisition::acquisition_core(uint64_t samp_count)
}
}
lk.lock();
if (d_acq_parameters.blocking)
{
lk.lock();
}
if (!d_acq_parameters.bit_transition_flag)
{
if (d_test_statistics > d_threshold)
@ -872,7 +878,6 @@ void pcps_acquisition::acquisition_core(uint64_t samp_count)
send_negative_acquisition();
}
}
d_worker_active = false;
if ((d_num_noncoherent_integrations_counter == d_acq_parameters.max_dwells) or (d_positive_acq == 1))
{
@ -884,6 +889,8 @@ void pcps_acquisition::acquisition_core(uint64_t samp_count)
d_num_noncoherent_integrations_counter = 0U;
d_positive_acq = 0;
}
d_worker_active = false;
}
@ -930,6 +937,7 @@ int pcps_acquisition::general_work(int noutput_items __attribute__((unused)),
* 6. Declare positive or negative acquisition using a message port
*/
gr::thread::scoped_lock lk(d_setlock);
if (!d_active or d_worker_active)
{
if (!d_acq_parameters.blocking_on_standby)
@ -1016,7 +1024,8 @@ int pcps_acquisition::general_work(int noutput_items __attribute__((unused)),
}
else
{
gr::thread::thread d_worker(&pcps_acquisition::acquisition_core, this, d_sample_counter);
d_worker = std::thread([&] { pcps_acquisition::acquisition_core(d_sample_counter); });
d_worker.detach();
d_worker_active = true;
}
consume_each(0);

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

@ -61,8 +61,8 @@
#include <memory>
#include <queue>
#include <string>
#include <thread>
#include <utility>
#if HAS_STD_SPAN
#include <span>
namespace own = std;
@ -259,6 +259,7 @@ private:
arma::fmat d_narrow_grid;
std::string d_dump_filename;
std::thread d_worker;
int64_t d_dump_number;
uint64_t d_sample_counter;

4
src/algorithms/acquisition/gnuradio_blocks/pcps_opencl_acquisition_cc.cc
View File

@ -81,8 +81,8 @@ pcps_opencl_acquisition_cc::pcps_opencl_acquisition_cc(
bool dump,
const std::string &dump_filename,
bool enable_monitor_output) : gr::block("pcps_opencl_acquisition_cc",
gr::io_signature::make(1, 1, static_cast<int>(sizeof(gr_complex) * sampled_ms * samples_per_ms)),
gr::io_signature::make(0, 1, sizeof(Gnss_Synchro)))
gr::io_signature::make(1, 1, static_cast<int>(sizeof(gr_complex) * sampled_ms * samples_per_ms)),
gr::io_signature::make(0, 1, sizeof(Gnss_Synchro)))
{
this->message_port_register_out(pmt::mp("events"));
d_sample_counter = 0ULL; // SAMPLE COUNTER

2
src/algorithms/libs/gnss_sdr_create_directory.cc
View File

@ -22,6 +22,7 @@
#include <exception> // for exception
#include <fstream> // for ofstream
// clang-format off
#if HAS_STD_FILESYSTEM
#include <system_error>
namespace errorlib = std;
@ -40,6 +41,7 @@ namespace fs = std::filesystem;
namespace fs = boost::filesystem;
namespace errorlib = boost::system;
#endif
// clang-format on
bool gnss_sdr_create_directory(const std::string& foldername)
{

3
src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/CMakeLists.txt
View File

@ -247,7 +247,10 @@ if(CMAKE_VERSION VERSION_GREATER 3.0 AND SUPPORTED_CPU_FEATURES_ARCH)
FORCE
)
set(USE_CPU_FEATURES ON)
set(BUILD_SHARED_LIBS_SAVED "${BUILD_SHARED_LIBS}")
set(BUILD_SHARED_LIBS OFF)
add_subdirectory(cpu_features)
set(BUILD_SHARED_LIBS "${BUILD_SHARED_LIBS_SAVED}")
endif()
# Python

18
src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/README.md
View File

@ -139,6 +139,24 @@ $ volk_gnsssdr_profile
$ sudo ldconfig
```
### Building on Microsoft Windows
With Visual Studio 2019, in a Powershell run by administrator:
```
$ git clone https://github.com/gnss-sdr/gnss-sdr
$ cd gnss-sdr
$ git checkout next
$ cd build
$ cmake -G "Visual Studio 16 2019" ..\src\algorithms\libs\volk_gnsssdr_module\volk_gnsssdr
$ cd ..
$ cmake --build build --config Release
$ cd build
$ ctest -C Release
$ cd ..
$ cmake --install build
```
## References
If you use VOLK_GNSSSDR in your research and/or software, please cite the

3
src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/gen/archs.xml
View File

@ -68,7 +68,6 @@
<check name="mmx"></check>
<flag compiler="gnu">-mmmx</flag>
<flag compiler="clang">-mmmx</flag>
<flag compiler="msvc">/arch:SSE</flag>
<alignment>8</alignment>
</arch>
@ -84,7 +83,6 @@
<check name="sse"></check>
<flag compiler="gnu">-msse</flag>
<flag compiler="clang">-msse</flag>
<flag compiler="msvc">/arch:SSE</flag>
<environment>_MM_SET_FLUSH_ZERO_MODE(_MM_FLUSH_ZERO_ON);</environment>
<include>xmmintrin.h</include>
<alignment>16</alignment>
@ -94,7 +92,6 @@
<check name="sse2"></check>
<flag compiler="gnu">-msse2</flag>
<flag compiler="clang">-msse2</flag>
<flag compiler="msvc">/arch:SSE2</flag>
<alignment>16</alignment>
</arch>

17
src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn.h
View File

@ -63,7 +63,6 @@
#include <volk_gnsssdr/volk_gnsssdr_complex.h>
#include <volk_gnsssdr/volk_gnsssdr_malloc.h>
#include <math.h>
// #include <stdio.h>
#ifdef LV_HAVE_GENERIC
@ -74,7 +73,7 @@ static inline void volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn_generic(lv_32f
unsigned int n;
for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
{
result[n_vec] = lv_cmake(0, 0);
result[n_vec] = lv_cmake(0.0f, 0.0f);
}
for (n = 0; n < num_points; n++)
{
@ -115,7 +114,7 @@ static inline void volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn_generic_reload
unsigned int j;
for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
{
result[n_vec] = lv_cmake(0, 0);
result[n_vec] = lv_cmake(0.0f, 0.0f);
}
for (n = 0; n < num_points / ROTATOR_RELOAD; n++)
@ -158,6 +157,7 @@ static inline void volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn_generic_reload
#include <immintrin.h>
static inline void volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn_u_avx(lv_32fc_t* result, const lv_32fc_t* in_common, const lv_32fc_t phase_inc, lv_32fc_t* phase, const float** in_a, int num_a_vectors, unsigned int num_points)
{
#ifndef WIN32
unsigned int number = 0;
int vec_ind = 0;
unsigned int i = 0;
@ -287,7 +287,7 @@ static inline void volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn_u_avx(lv_32fc_
_mm256_store_ps((float*)dotProductVector, dotProdVal0[vec_ind]); // Store the results back into the dot product vector
result[vec_ind] = lv_cmake(0, 0);
result[vec_ind] = lv_cmake(0.0f, 0.0f);
for (i = 0; i < 4; ++i)
{
result[vec_ind] += dotProductVector[i];
@ -312,6 +312,9 @@ static inline void volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn_u_avx(lv_32fc_
}
*phase = _phase;
#else
volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn_generic_reload(result, in_common, phase_inc, phase, in_a, num_a_vectors, num_points);
#endif
}
#endif /* LV_HAVE_AVX */
@ -322,6 +325,7 @@ static inline void volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn_u_avx(lv_32fc_
#include <immintrin.h>
static inline void volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn_a_avx(lv_32fc_t* result, const lv_32fc_t* in_common, const lv_32fc_t phase_inc, lv_32fc_t* phase, const float** in_a, int num_a_vectors, unsigned int num_points)
{
#ifndef WIN32
unsigned int number = 0;
int vec_ind = 0;
unsigned int i = 0;
@ -451,7 +455,7 @@ static inline void volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn_a_avx(lv_32fc_
_mm256_store_ps((float*)dotProductVector, dotProdVal0[vec_ind]); // Store the results back into the dot product vector
result[vec_ind] = lv_cmake(0, 0);
result[vec_ind] = lv_cmake(0.0f, 0.0f);
for (i = 0; i < 4; ++i)
{
result[vec_ind] += dotProductVector[i];
@ -476,6 +480,9 @@ static inline void volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn_a_avx(lv_32fc_
}
*phase = _phase;
#else
volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn_generic_reload(result, in_common, phase_inc, phase, in_a, num_a_vectors, num_points);
#endif
}

10
src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_32fc_32f_rotator_dotprodxnpuppet_32fc.h
View File

@ -106,8 +106,11 @@ static inline void volk_gnsssdr_32fc_32f_rotator_dotprodxnpuppet_32fc_u_avx(lv_3
in_a[n] = (float*)volk_gnsssdr_malloc(sizeof(float) * num_points, volk_gnsssdr_get_alignment());
memcpy((float*)in_a[n], (float*)in, sizeof(float) * num_points);
}
#ifndef WIN32
volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn_u_avx(result, local_code, phase_inc[0], phase, (const float**)in_a, num_a_vectors, num_points);
#else
volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn_generic_reload(result, local_code, phase_inc[0], phase, (const float**)in_a, num_a_vectors, num_points);
#endif
for (n = 0; n < num_a_vectors; n++)
{
volk_gnsssdr_free(in_a[n]);
@ -136,8 +139,11 @@ static inline void volk_gnsssdr_32fc_32f_rotator_dotprodxnpuppet_32fc_a_avx(lv_3
in_a[n] = (float*)volk_gnsssdr_malloc(sizeof(float) * num_points, volk_gnsssdr_get_alignment());
memcpy((float*)in_a[n], (float*)in, sizeof(float) * num_points);
}
#ifndef WIN32
volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn_a_avx(result, local_code, phase_inc[0], phase, (const float**)in_a, num_a_vectors, num_points);
#else
volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn_generic_reload(result, local_code, phase_inc[0], phase, (const float**)in_a, num_a_vectors, num_points);
#endif
for (n = 0; n < num_a_vectors; n++)
{
volk_gnsssdr_free(in_a[n]);

34
src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn.h
View File

@ -74,7 +74,7 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_generic(lv_32fc
unsigned int n;
for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
{
result[n_vec] = lv_cmake(0, 0);
result[n_vec] = lv_cmake(0.0f, 0.0f);
}
for (n = 0; n < num_points; n++)
{
@ -115,7 +115,7 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_generic_reload(
unsigned int j;
for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
{
result[n_vec] = lv_cmake(0, 0);
result[n_vec] = lv_cmake(0.0f, 0.0f);
}
for (n = 0; n < num_points / ROTATOR_RELOAD; n++)
@ -158,7 +158,7 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_generic_reload(
#include <pmmintrin.h>
static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_u_sse3(lv_32fc_t* result, const lv_32fc_t* in_common, const lv_32fc_t phase_inc, lv_32fc_t* phase, const lv_32fc_t** in_a, int num_a_vectors, unsigned int num_points)
{
lv_32fc_t dotProduct = lv_cmake(0, 0);
lv_32fc_t dotProduct = lv_cmake(0.0f, 0.0f);
lv_32fc_t tmp32_1, tmp32_2;
const unsigned int sse_iters = num_points / 2;
int n_vec;
@ -240,7 +240,7 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_u_sse3(lv_32fc_
for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
{
_mm_store_ps((float*)dotProductVector, acc[n_vec]); // Store the results back into the dot product vector
dotProduct = lv_cmake(0, 0);
dotProduct = lv_cmake(0.0f, 0.0f);
for (i = 0; i < 2; ++i)
{
dotProduct = dotProduct + dotProductVector[i];
@ -270,7 +270,7 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_u_sse3(lv_32fc_
#include <pmmintrin.h>
static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_a_sse3(lv_32fc_t* result, const lv_32fc_t* in_common, const lv_32fc_t phase_inc, lv_32fc_t* phase, const lv_32fc_t** in_a, int num_a_vectors, unsigned int num_points)
{
lv_32fc_t dotProduct = lv_cmake(0, 0);
lv_32fc_t dotProduct = lv_cmake(0.0f, 0.0f);
lv_32fc_t tmp32_1, tmp32_2;
const unsigned int sse_iters = num_points / 2;
int n_vec;
@ -352,7 +352,7 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_a_sse3(lv_32fc_
for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
{
_mm_store_ps((float*)dotProductVector, acc[n_vec]); // Store the results back into the dot product vector
dotProduct = lv_cmake(0, 0);
dotProduct = lv_cmake(0.0f, 0.0f);
for (i = 0; i < 2; ++i)
{
dotProduct = dotProduct + dotProductVector[i];
@ -382,7 +382,7 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_a_sse3(lv_32fc_
#include <immintrin.h>
static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_u_avx(lv_32fc_t* result, const lv_32fc_t* in_common, const lv_32fc_t phase_inc, lv_32fc_t* phase, const lv_32fc_t** in_a, int num_a_vectors, unsigned int num_points)
{
lv_32fc_t dotProduct = lv_cmake(0, 0);
lv_32fc_t dotProduct = lv_cmake(0.0f, 0.0f);
lv_32fc_t tmp32_1, tmp32_2;
const unsigned int avx_iters = num_points / 4;
int n_vec;
@ -401,13 +401,14 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_u_avx(lv_32fc_t
for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
{
acc[n_vec] = _mm256_setzero_ps();
result[n_vec] = lv_cmake(0, 0);
result[n_vec] = lv_cmake(0.0f, 0.0f);
}
// phase rotation registers
__m256 a, four_phase_acc_reg, yl, yh, tmp1, tmp1p, tmp2, tmp2p, z;
__attribute__((aligned(32))) lv_32fc_t four_phase_inc[4];
__VOLK_ATTR_ALIGNED(32)
lv_32fc_t four_phase_inc[4];
const lv_32fc_t phase_inc2 = phase_inc * phase_inc;
const lv_32fc_t phase_inc3 = phase_inc2 * phase_inc;
const lv_32fc_t phase_inc4 = phase_inc3 * phase_inc;
@ -417,7 +418,8 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_u_avx(lv_32fc_t
four_phase_inc[3] = phase_inc4;
const __m256 four_phase_inc_reg = _mm256_load_ps((float*)four_phase_inc);
__attribute__((aligned(32))) lv_32fc_t four_phase_acc[4];
__VOLK_ATTR_ALIGNED(32)
lv_32fc_t four_phase_acc[4];
four_phase_acc[0] = _phase;
four_phase_acc[1] = _phase * phase_inc;
four_phase_acc[2] = _phase * phase_inc2;
@ -472,7 +474,7 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_u_avx(lv_32fc_t
for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
{
_mm256_store_ps((float*)dotProductVector, acc[n_vec]); // Store the results back into the dot product vector
dotProduct = lv_cmake(0, 0);
dotProduct = lv_cmake(0.0f, 0.0f);
for (i = 0; i < 4; ++i)
{
dotProduct = dotProduct + dotProductVector[i];
@ -510,7 +512,7 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_u_avx(lv_32fc_t
#include <immintrin.h>
static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_a_avx(lv_32fc_t* result, const lv_32fc_t* in_common, const lv_32fc_t phase_inc, lv_32fc_t* phase, const lv_32fc_t** in_a, int num_a_vectors, unsigned int num_points)
{
lv_32fc_t dotProduct = lv_cmake(0, 0);
lv_32fc_t dotProduct = lv_cmake(0.0f, 0.0f);
lv_32fc_t tmp32_1, tmp32_2;
const unsigned int avx_iters = num_points / 4;
int n_vec;
@ -529,7 +531,7 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_a_avx(lv_32fc_t
for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
{
acc[n_vec] = _mm256_setzero_ps();
result[n_vec] = lv_cmake(0, 0);
result[n_vec] = lv_cmake(0.0f, 0.0f);
}
// phase rotation registers
@ -602,7 +604,7 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_a_avx(lv_32fc_t
for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
{
_mm256_store_ps((float*)dotProductVector, acc[n_vec]); // Store the results back into the dot product vector
dotProduct = lv_cmake(0, 0);
dotProduct = lv_cmake(0.0f, 0.0f);
for (i = 0; i < 4; ++i)
{
dotProduct = dotProduct + dotProductVector[i];
@ -655,7 +657,7 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_neon(lv_32fc_t*
if (neon_iters > 0)
{
lv_32fc_t dotProduct = lv_cmake(0, 0);
lv_32fc_t dotProduct = lv_cmake(0.0f, 0.0f);
float32_t arg_phase0 = cargf(_phase);
float32_t arg_phase_inc = cargf(phase_inc);
float32_t phase_est;
@ -760,7 +762,7 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_neon(lv_32fc_t*
for (n_vec = 0; n_vec < num_a_vectors; n_vec++)
{
vst2q_f32((float32_t*)dotProductVector, accumulator1[n_vec]); // Store the results back into the dot product vector
dotProduct = lv_cmake(0, 0);
dotProduct = lv_cmake(0.0f, 0.0f);
for (i = 0; i < 4; ++i)
{
dotProduct = dotProduct + dotProductVector[i];

15
src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/lib/CMakeLists.txt
View File

@ -145,6 +145,11 @@ macro(OVERRULE_ARCH arch reason)
list(REMOVE_ITEM available_archs ${arch})
endmacro()
macro(FORCE_ARCH arch reason)
message(STATUS "${reason}, Forced arch ${arch}")
list(APPEND available_archs ${arch})
endmacro()
########################################################################
# eliminate AVX on if not on x86, or if the compiler does not accept
# the xgetbv instruction, or {if not cross-compiling and the xgetbv
@ -264,13 +269,13 @@ if(NOT CROSSCOMPILE_MULTILIB AND CPU_IS_x86)
endif()
# MSVC 64 bit does not have MMX, overrule it
if(${SIZEOF_CPU} EQUAL 64 AND MSVC)
overrule_arch(mmx "No MMX for Win64")
if(MSVC_VERSION GREATER 1700)
overrule_arch(sse "No SSE for Win64 Visual Studio 2013")
if(MSVC)
if(${SIZEOF_CPU} EQUAL 64)
overrule_arch(mmx "No MMX for Win64")
endif()
force_arch(sse "Built-in for MSVC > 2013")
force_arch(sse2 "Built-in for MSVC > 2013")
endif()
endif()
########################################################################

47
src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/lib/volk_gnsssdr_rank_archs.c
View File

@ -15,25 +15,10 @@
#include <string.h>
// clang-format on
#if __GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ >= 4
#define __popcnt __builtin_popcount
#else
inline unsigned __popcnt(unsigned num)
{
unsigned pop = 0;
while (num)
{
if (num & 0x1) pop++;
num >>= 1;
}
return pop;
}
#endif
int volk_gnsssdr_get_index(
const char *impl_names[], //list of implementations by name
const size_t n_impls, //number of implementations available
const char *impl_name //the implementation name to find
const char *impl_names[], // list of implementations by name
const size_t n_impls, // number of implementations available
const char *impl_name // the implementation name to find
)
{
unsigned int i;
@ -44,20 +29,20 @@ int volk_gnsssdr_get_index(
return i;
}
}
//TODO return -1;
//something terrible should happen here
// TODO return -1;
// something terrible should happen here
fprintf(stderr, "VOLK_GNSSSDR warning: no arch found, returning generic impl\n");
return volk_gnsssdr_get_index(impl_names, n_impls, "generic"); //but we'll fake it for now
}
int volk_gnsssdr_rank_archs(
const char *kern_name, //name of the kernel to rank
const char *impl_names[], //list of implementations by name
const int *impl_deps, //requirement mask per implementation
const bool *alignment, //alignment status of each implementation
size_t n_impls, //number of implementations available
const bool align //if false, filter aligned implementations
const char *kern_name, // name of the kernel to rank
const char *impl_names[], // list of implementations by name
const int *impl_deps, // requirement mask per implementation
const bool *alignment, // alignment status of each implementation
size_t n_impls, // number of implementations available
const bool align // if false, filter aligned implementations
)
{
size_t i;
@ -78,7 +63,7 @@ int volk_gnsssdr_rank_archs(
return volk_gnsssdr_get_index(impl_names, n_impls, "generic");
}
//now look for the function name in the prefs list
// now look for the function name in the prefs list
for (i = 0; i < n_arch_prefs; i++)
{
if (!strncmp(kern_name, volk_gnsssdr_arch_prefs[i].name, sizeof(volk_gnsssdr_arch_prefs[i].name))) //found it
@ -88,14 +73,14 @@ int volk_gnsssdr_rank_archs(
}
}
//return the best index with the largest deps
// return the best index with the largest deps
size_t best_index_a = 0;
size_t best_index_u = 0;
int best_value_a = -1;
int best_value_u = -1;
for (i = 0; i < n_impls; i++)
{
const signed val = __popcnt(impl_deps[i]);
const signed val = impl_deps[i];
if (alignment[i] && val > best_value_a)
{
best_index_a = i;
@ -108,9 +93,9 @@ int volk_gnsssdr_rank_archs(
}
}
//when align and we found a best aligned, use it
// when align and we found a best aligned, use it
if (align && best_value_a != -1) return best_index_a;
//otherwise return the best unaligned
// otherwise return the best unaligned
return best_index_u;
}

2
src/algorithms/observables/gnuradio_blocks/hybrid_observables_gs.cc
View File

@ -41,6 +41,7 @@
#include <boost/bind/bind.hpp>
#endif
// clang-format off
#if HAS_STD_FILESYSTEM
#include <system_error>
namespace errorlib = std;
@ -59,6 +60,7 @@ namespace fs = std::filesystem;
namespace fs = boost::filesystem;
namespace errorlib = boost::system;
#endif
// clang-format on
hybrid_observables_gs_sptr hybrid_observables_gs_make(const Obs_Conf &conf_)

2
src/algorithms/telemetry_decoder/adapters/CMakeLists.txt
View File

@ -60,11 +60,11 @@ endif()
target_link_libraries(telemetry_decoder_adapters
PUBLIC
telemetry_decoder_gr_blocks
telemetry_decoder_libs
PRIVATE
Gflags::gflags
Glog::glog
Gnuradio::runtime
telemetry_decoder_libs
)
target_include_directories(telemetry_decoder_adapters

6
src/algorithms/telemetry_decoder/adapters/beidou_b1i_telemetry_decoder.cc
View File

@ -32,12 +32,10 @@ BeidouB1iTelemetryDecoder::BeidouB1iTelemetryDecoder(
in_streams_(in_streams),
out_streams_(out_streams)
{
const std::string default_dump_filename("./navigation.dat");
DLOG(INFO) << "role " << role;
dump_ = configuration->property(role + ".dump", false);
dump_filename_ = configuration->property(role + ".dump_filename", default_dump_filename);
tlm_parameters_.SetFromConfiguration(configuration, role);
// make telemetry decoder object
telemetry_decoder_ = beidou_b1i_make_telemetry_decoder_gs(satellite_, dump_); // TODO fix me
telemetry_decoder_ = beidou_b1i_make_telemetry_decoder_gs(satellite_, tlm_parameters_);
DLOG(INFO) << "telemetry_decoder(" << telemetry_decoder_->unique_id() << ")";
channel_ = 0;
if (in_streams_ > 1)

4
src/algorithms/telemetry_decoder/adapters/beidou_b1i_telemetry_decoder.h
View File

@ -27,6 +27,7 @@
#include "gnss_satellite.h" // for Gnss_Satellite
#include "gnss_synchro.h"
#include "telemetry_decoder_interface.h"
#include "tlm_conf.h"
#include <gnuradio/runtime_types.h> // for basic_block_sptr, top_block_sptr
#include <cstddef> // for size_t
#include <string>
@ -86,12 +87,11 @@ public:
private:
beidou_b1i_telemetry_decoder_gs_sptr telemetry_decoder_;
Gnss_Satellite satellite_;
std::string dump_filename_;
Tlm_Conf tlm_parameters_;
std::string role_;
int channel_;
unsigned int in_streams_;
unsigned int out_streams_;
bool dump_;
};

7
src/algorithms/telemetry_decoder/adapters/beidou_b3i_telemetry_decoder.cc
View File

@ -27,13 +27,10 @@ BeidouB3iTelemetryDecoder::BeidouB3iTelemetryDecoder(
unsigned int in_streams, unsigned int out_streams)
: role_(role), in_streams_(in_streams), out_streams_(out_streams)
{
const std::string default_dump_filename("./navigation.dat");
DLOG(INFO) << "role " << role;
dump_ = configuration->property(role + ".dump", false);
dump_filename_ =
configuration->property(role + ".dump_filename", default_dump_filename);
tlm_parameters_.SetFromConfiguration(configuration, role);
// make telemetry decoder object
telemetry_decoder_ = beidou_b3i_make_telemetry_decoder_gs(satellite_, dump_);
telemetry_decoder_ = beidou_b3i_make_telemetry_decoder_gs(satellite_, tlm_parameters_);
DLOG(INFO) << "telemetry_decoder(" << telemetry_decoder_->unique_id() << ")";
channel_ = 0;
if (in_streams_ > 1)

4
src/algorithms/telemetry_decoder/adapters/beidou_b3i_telemetry_decoder.h
View File

@ -25,6 +25,7 @@
#include "gnss_satellite.h" // for Gnss_Satellite
#include "gnss_synchro.h"
#include "telemetry_decoder_interface.h"
#include "tlm_conf.h"
#include <gnuradio/runtime_types.h> // for basic_block_sptr, top_block_sptr
#include <cstddef> // for size_t
#include <string>
@ -81,12 +82,11 @@ public:
private:
beidou_b3i_telemetry_decoder_gs_sptr telemetry_decoder_;
Gnss_Satellite satellite_;
std::string dump_filename_;
Tlm_Conf tlm_parameters_;
std::string role_;
int channel_;
unsigned int in_streams_;
unsigned int out_streams_;
bool dump_;
};
/** \} */

6
src/algorithms/telemetry_decoder/adapters/galileo_e1b_telemetry_decoder.cc
View File

@ -33,12 +33,10 @@ GalileoE1BTelemetryDecoder::GalileoE1BTelemetryDecoder(
in_streams_(in_streams),
out_streams_(out_streams)
{
const std::string default_dump_filename("./navigation.dat");
DLOG(INFO) << "role " << role;
dump_ = configuration->property(role + ".dump", false);
dump_filename_ = configuration->property(role + ".dump_filename", default_dump_filename);
tlm_parameters_.SetFromConfiguration(configuration, role);
// make telemetry decoder object
telemetry_decoder_ = galileo_make_telemetry_decoder_gs(satellite_, 1, dump_); // unified galileo decoder set to INAV (frame_type=1)
telemetry_decoder_ = galileo_make_telemetry_decoder_gs(satellite_, tlm_parameters_, 1); // unified galileo decoder set to INAV (frame_type=1)
DLOG(INFO) << "telemetry_decoder(" << telemetry_decoder_->unique_id() << ")";
channel_ = 0;
if (in_streams_ > 1)

4
src/algorithms/telemetry_decoder/adapters/galileo_e1b_telemetry_decoder.h
View File

@ -28,6 +28,7 @@
#include "gnss_satellite.h"
#include "gnss_synchro.h"
#include "telemetry_decoder_interface.h"
#include "tlm_conf.h"
#include <gnuradio/runtime_types.h> // for basic_block_sptr, top_block_sptr
#include <cstddef> // for size_t
#include <string>
@ -89,12 +90,11 @@ public:
private:
galileo_telemetry_decoder_gs_sptr telemetry_decoder_;
Gnss_Satellite satellite_;
std::string dump_filename_;
Tlm_Conf tlm_parameters_;
std::string role_;
int channel_;
unsigned int in_streams_;
unsigned int out_streams_;
bool dump_;
};

6
src/algorithms/telemetry_decoder/adapters/galileo_e5a_telemetry_decoder.cc
View File

@ -36,12 +36,10 @@ GalileoE5aTelemetryDecoder::GalileoE5aTelemetryDecoder(
in_streams_(in_streams),
out_streams_(out_streams)
{
const std::string default_dump_filename("./navigation.dat");
DLOG(INFO) << "role " << role;
dump_ = configuration->property(role + ".dump", false);
dump_filename_ = configuration->property(role + ".dump_filename", default_dump_filename);
tlm_parameters_.SetFromConfiguration(configuration, role);
// make telemetry decoder object
telemetry_decoder_ = galileo_make_telemetry_decoder_gs(satellite_, 2, dump_); // unified galileo decoder set to FNAV (frame_type=2)
telemetry_decoder_ = galileo_make_telemetry_decoder_gs(satellite_, tlm_parameters_, 2); // unified galileo decoder set to FNAV (frame_type=2)
DLOG(INFO) << "telemetry_decoder(" << telemetry_decoder_->unique_id() << ")";
channel_ = 0;
if (in_streams_ > 1)

4
src/algorithms/telemetry_decoder/adapters/galileo_e5a_telemetry_decoder.h
View File

@ -30,6 +30,7 @@
#include "gnss_satellite.h" // for Gnss_Satellite
#include "gnss_synchro.h"
#include "telemetry_decoder_interface.h"
#include "tlm_conf.h"
#include <gnuradio/runtime_types.h> // for basic_block_sptr, top_block_sptr
#include <cstddef> // for size_t
#include <string>
@ -91,12 +92,11 @@ public:
private:
galileo_telemetry_decoder_gs_sptr telemetry_decoder_;
Gnss_Satellite satellite_;
std::string dump_filename_;
Tlm_Conf tlm_parameters_;
std::string role_;
int channel_;
unsigned int in_streams_;
unsigned int out_streams_;
bool dump_;
};

6
src/algorithms/telemetry_decoder/adapters/galileo_e5b_telemetry_decoder.cc
View File

@ -34,12 +34,10 @@ GalileoE5bTelemetryDecoder::GalileoE5bTelemetryDecoder(
in_streams_(in_streams),
out_streams_(out_streams)
{
const std::string default_dump_filename("./navigation.dat");
DLOG(INFO) << "role " << role;
dump_ = configuration->property(role + ".dump", false);
dump_filename_ = configuration->property(role + ".dump_filename", default_dump_filename);
tlm_parameters_.SetFromConfiguration(configuration, role);
// make telemetry decoder object
telemetry_decoder_ = galileo_make_telemetry_decoder_gs(satellite_, 1, dump_); // unified galileo decoder set to INAV (frame_type=1)
telemetry_decoder_ = galileo_make_telemetry_decoder_gs(satellite_, tlm_parameters_, 1); // unified galileo decoder set to INAV (frame_type=1)
DLOG(INFO) << "telemetry_decoder(" << telemetry_decoder_->unique_id() << ")";
channel_ = 0;
if (in_streams_ > 1)

4
src/algorithms/telemetry_decoder/adapters/galileo_e5b_telemetry_decoder.h
View File

@ -28,6 +28,7 @@
#include "gnss_satellite.h"
#include "gnss_synchro.h"
#include "telemetry_decoder_interface.h"
#include "tlm_conf.h"
#include <gnuradio/runtime_types.h> // for basic_block_sptr, top_block_sptr
#include <cstddef> // for size_t
#include <string>
@ -104,12 +105,11 @@ public:
private:
galileo_telemetry_decoder_gs_sptr telemetry_decoder_;
Gnss_Satellite satellite_;
std::string dump_filename_;
Tlm_Conf tlm_parameters_;
std::string role_;
int channel_;
unsigned int in_streams_;
unsigned int out_streams_;
bool dump_;
};

6
src/algorithms/telemetry_decoder/adapters/galileo_e6_telemetry_decoder.cc
View File

@ -33,12 +33,10 @@ GalileoE6TelemetryDecoder::GalileoE6TelemetryDecoder(
in_streams_(in_streams),
out_streams_(out_streams)
{
const std::string default_dump_filename("./navigation.dat");
DLOG(INFO) << "role " << role;
dump_ = configuration->property(role + ".dump", false);
dump_filename_ = configuration->property(role + ".dump_filename", default_dump_filename);
tlm_parameters_.SetFromConfiguration(configuration, role);
// make telemetry decoder object
telemetry_decoder_ = galileo_make_telemetry_decoder_gs(satellite_, 3, dump_); // unified galileo decoder set to CNAV (frame_type=3)
telemetry_decoder_ = galileo_make_telemetry_decoder_gs(satellite_, tlm_parameters_, 3); // unified galileo decoder set to CNAV (frame_type=3)
DLOG(INFO) << "telemetry_decoder(" << telemetry_decoder_->unique_id() << ")";
channel_ = 0;
if (in_streams_ > 1)

4
src/algorithms/telemetry_decoder/adapters/galileo_e6_telemetry_decoder.h
View File

@ -27,6 +27,7 @@
#include "gnss_satellite.h"
#include "gnss_synchro.h"
#include "telemetry_decoder_interface.h"
#include "tlm_conf.h"
#include <gnuradio/runtime_types.h> // for basic_block_sptr, top_block_sptr
#include <cstddef> // for size_t
#include <string>
@ -103,12 +104,11 @@ public:
private:
galileo_telemetry_decoder_gs_sptr telemetry_decoder_;
Gnss_Satellite satellite_;
std::string dump_filename_;
Tlm_Conf tlm_parameters_;
std::string role_;
int channel_;
unsigned int in_streams_;
unsigned int out_streams_;
bool dump_;
};

6
src/algorithms/telemetry_decoder/adapters/glonass_l1_ca_telemetry_decoder.cc
View File

@ -33,12 +33,10 @@ GlonassL1CaTelemetryDecoder::GlonassL1CaTelemetryDecoder(
in_streams_(in_streams),
out_streams_(out_streams)
{
const std::string default_dump_filename("./navigation.dat");
DLOG(INFO) << "role " << role;
dump_ = configuration->property(role + ".dump", false);
dump_filename_ = configuration->property(role + ".dump_filename", default_dump_filename);
tlm_parameters_.SetFromConfiguration(configuration, role);
// make telemetry decoder object
telemetry_decoder_ = glonass_l1_ca_make_telemetry_decoder_gs(satellite_, dump_);
telemetry_decoder_ = glonass_l1_ca_make_telemetry_decoder_gs(satellite_, tlm_parameters_);
DLOG(INFO) << "telemetry_decoder(" << telemetry_decoder_->unique_id() << ")";
channel_ = 0;
if (in_streams_ > 1)

4
src/algorithms/telemetry_decoder/adapters/glonass_l1_ca_telemetry_decoder.h
View File

@ -27,6 +27,7 @@
#include "gnss_satellite.h" // for Gnss_Satellite
#include "gnss_synchro.h"
#include "telemetry_decoder_interface.h"
#include "tlm_conf.h"
#include <gnuradio/runtime_types.h> // for basic_block_sptr, top_block_sptr
#include <cstddef> // for size_t
#include <string>
@ -85,12 +86,11 @@ public:
private:
glonass_l1_ca_telemetry_decoder_gs_sptr telemetry_decoder_;
Gnss_Satellite satellite_;
std::string dump_filename_;
Tlm_Conf tlm_parameters_;
std::string role_;
int channel_;
unsigned int in_streams_;
unsigned int out_streams_;
bool dump_;
};

6
src/algorithms/telemetry_decoder/adapters/glonass_l2_ca_telemetry_decoder.cc
View File

@ -32,12 +32,10 @@ GlonassL2CaTelemetryDecoder::GlonassL2CaTelemetryDecoder(
in_streams_(in_streams),
out_streams_(out_streams)
{
const std::string default_dump_filename("./navigation.dat");
DLOG(INFO) << "role " << role;
dump_ = configuration->property(role + ".dump", false);
dump_filename_ = configuration->property(role + ".dump_filename", default_dump_filename);
tlm_parameters_.SetFromConfiguration(configuration, role);
// make telemetry decoder object
telemetry_decoder_ = glonass_l2_ca_make_telemetry_decoder_gs(satellite_, dump_);
telemetry_decoder_ = glonass_l2_ca_make_telemetry_decoder_gs(satellite_, tlm_parameters_);
DLOG(INFO) << "telemetry_decoder(" << telemetry_decoder_->unique_id() << ")";
channel_ = 0;
if (in_streams_ > 1)

4
src/algorithms/telemetry_decoder/adapters/glonass_l2_ca_telemetry_decoder.h
View File

@ -26,6 +26,7 @@
#include "gnss_satellite.h" // for Gnss_Satellite
#include "gnss_synchro.h"
#include "telemetry_decoder_interface.h"
#include "tlm_conf.h"
#include <gnuradio/runtime_types.h> // for basic_block_sptr, top_block_sptr
#include <cstddef> // for size_t
#include <string>
@ -84,12 +85,11 @@ public:
private:
glonass_l2_ca_telemetry_decoder_gs_sptr telemetry_decoder_;
Gnss_Satellite satellite_;
std::string dump_filename_;
Tlm_Conf tlm_parameters_;
std::string role_;
int channel_;
unsigned int in_streams_;
unsigned int out_streams_;
bool dump_;
};

6
src/algorithms/telemetry_decoder/adapters/gps_l1_ca_telemetry_decoder.cc
View File

@ -32,12 +32,10 @@ GpsL1CaTelemetryDecoder::GpsL1CaTelemetryDecoder(
in_streams_(in_streams),
out_streams_(out_streams)
{
const std::string default_dump_filename("./navigation.dat");
DLOG(INFO) << "role " << role;
dump_ = configuration->property(role + ".dump", false);
dump_filename_ = configuration->property(role + ".dump_filename", default_dump_filename);
tlm_parameters_.SetFromConfiguration(configuration, role);
// make telemetry decoder object
telemetry_decoder_ = gps_l1_ca_make_telemetry_decoder_gs(satellite_, dump_); // TODO fix me
telemetry_decoder_ = gps_l1_ca_make_telemetry_decoder_gs(satellite_, tlm_parameters_);
DLOG(INFO) << "telemetry_decoder(" << telemetry_decoder_->unique_id() << ")";
channel_ = 0;
if (in_streams_ > 1)

4
src/algorithms/telemetry_decoder/adapters/gps_l1_ca_telemetry_decoder.h
View File

@ -26,6 +26,7 @@
#include "gnss_synchro.h"
#include "gps_l1_ca_telemetry_decoder_gs.h"
#include "telemetry_decoder_interface.h"
#include "tlm_conf.h"
#include <gnuradio/runtime_types.h> // for basic_block_sptr, top_block_sptr
#include <cstddef> // for size_t
#include <string>
@ -88,12 +89,11 @@ public:
private:
gps_l1_ca_telemetry_decoder_gs_sptr telemetry_decoder_;
Gnss_Satellite satellite_;
std::string dump_filename_;
Tlm_Conf tlm_parameters_;
std::string role_;
int channel_;
unsigned int in_streams_;
unsigned int out_streams_;
bool dump_;
};

6
src/algorithms/telemetry_decoder/adapters/gps_l2c_telemetry_decoder.cc
View File

@ -32,12 +32,10 @@ GpsL2CTelemetryDecoder::GpsL2CTelemetryDecoder(
in_streams_(in_streams),
out_streams_(out_streams)
{
const std::string default_dump_filename("./navigation.dat");
DLOG(INFO) << "role " << role;
dump_ = configuration->property(role + ".dump", false);
dump_filename_ = configuration->property(role + ".dump_filename", default_dump_filename);
tlm_parameters_.SetFromConfiguration(configuration, role);
// make telemetry decoder object
telemetry_decoder_ = gps_l2c_make_telemetry_decoder_gs(satellite_, dump_); // TODO fix me
telemetry_decoder_ = gps_l2c_make_telemetry_decoder_gs(satellite_, tlm_parameters_);
DLOG(INFO) << "telemetry_decoder(" << telemetry_decoder_->unique_id() << ")";
channel_ = 0;
if (in_streams_ > 1)

4
src/algorithms/telemetry_decoder/adapters/gps_l2c_telemetry_decoder.h
View File

@ -26,6 +26,7 @@
#include "gnss_synchro.h"
#include "gps_l2c_telemetry_decoder_gs.h"
#include "telemetry_decoder_interface.h"
#include "tlm_conf.h"
#include <gnuradio/runtime_types.h> // for basic_block_sptr, top_block_sptr
#include <cstddef> // for size_t
#include <string>
@ -86,12 +87,11 @@ public:
private:
gps_l2c_telemetry_decoder_gs_sptr telemetry_decoder_;
Gnss_Satellite satellite_;
std::string dump_filename_;
Tlm_Conf tlm_parameters_;
std::string role_;
int channel_;
unsigned int in_streams_;
unsigned int out_streams_;
bool dump_;
};

6
src/algorithms/telemetry_decoder/adapters/gps_l5_telemetry_decoder.cc
View File

@ -32,12 +32,10 @@ GpsL5TelemetryDecoder::GpsL5TelemetryDecoder(
in_streams_(in_streams),
out_streams_(out_streams)
{
const std::string default_dump_filename("./navigation.dat");
DLOG(INFO) << "role " << role;
dump_ = configuration->property(role + ".dump", false);
dump_filename_ = configuration->property(role + ".dump_filename", default_dump_filename);
tlm_parameters_.SetFromConfiguration(configuration, role);
// make telemetry decoder object
telemetry_decoder_ = gps_l5_make_telemetry_decoder_gs(satellite_, dump_);
telemetry_decoder_ = gps_l5_make_telemetry_decoder_gs(satellite_, tlm_parameters_);
DLOG(INFO) << "telemetry_decoder(" << telemetry_decoder_->unique_id() << ")";
channel_ = 0;
if (in_streams_ > 1)

3
src/algorithms/telemetry_decoder/adapters/gps_l5_telemetry_decoder.h
View File

@ -27,6 +27,7 @@
#include "gnss_synchro.h"
#include "gps_l5_telemetry_decoder_gs.h"
#include "telemetry_decoder_interface.h"
#include "tlm_conf.h"
#include <gnuradio/runtime_types.h> // for basic_block_sptr, top_block_sptr
#include <cstddef> // for size_t
#include <string>
@ -86,12 +87,12 @@ public:
private:
gps_l5_telemetry_decoder_gs_sptr telemetry_decoder_;
Gnss_Satellite satellite_;
Tlm_Conf tlm_parameters_;
std::string dump_filename_;
std::string role_;
int channel_;
unsigned int in_streams_;
unsigned int out_streams_;
bool dump_;
};

11
src/algorithms/telemetry_decoder/gnuradio_blocks/CMakeLists.txt
View File

@ -60,8 +60,19 @@ target_link_libraries(telemetry_decoder_gr_blocks
PRIVATE
Gflags::gflags
Glog::glog
Matio::matio
)
if(FILESYSTEM_FOUND)
target_compile_definitions(telemetry_decoder_gr_blocks PRIVATE -DHAS_STD_FILESYSTEM=1)
if(find_experimental)
target_compile_definitions(telemetry_decoder_gr_blocks PRIVATE -DHAS_STD_FILESYSTEM_EXPERIMENTAL=1)
endif()
target_link_libraries(telemetry_decoder_gr_blocks PRIVATE std::filesystem)
else()
target_link_libraries(telemetry_decoder_gr_blocks PRIVATE Boost::filesystem Boost::system)
endif()
if(GNURADIO_USES_STD_POINTERS)
target_compile_definitions(telemetry_decoder_gr_blocks
PUBLIC -DGNURADIO_USES_STD_POINTERS=1

166
src/algorithms/telemetry_decoder/gnuradio_blocks/beidou_b1i_telemetry_decoder_gs.cc
View File

@ -29,27 +29,51 @@
#include "gnss_synchro.h"
#include <glog/logging.h>
#include <gnuradio/io_signature.h>
#include <matio.h> // for Mat_VarCreate
#include <pmt/pmt.h> // for make_any
#include <pmt/pmt_sugar.h> // for mp
#include <cstddef> // for size_t
#include <cstdlib> // for abs
#include <exception> // for exception
#include <iostream> // for cout
#include <memory> // for shared_ptr, make_shared
#include <vector>
// clang-format off
#if HAS_STD_FILESYSTEM
#include <system_error>
namespace errorlib = std;
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#include <filesystem>
namespace fs = std::filesystem;
#endif
#else
#include <boost/filesystem/operations.hpp> // for remove
#include <boost/filesystem/path.hpp> // for path, operator<<
#include <boost/filesystem/path_traits.hpp> // for filesystem
#include <boost/system/error_code.hpp> // for error_code
namespace fs = boost::filesystem;
namespace errorlib = boost::system;
#endif
// clang-format on
#define CRC_ERROR_LIMIT 8
beidou_b1i_telemetry_decoder_gs_sptr
beidou_b1i_make_telemetry_decoder_gs(const Gnss_Satellite &satellite, bool dump)
beidou_b1i_make_telemetry_decoder_gs(const Gnss_Satellite &satellite, const Tlm_Conf &conf)
{
return beidou_b1i_telemetry_decoder_gs_sptr(new beidou_b1i_telemetry_decoder_gs(satellite, dump));
return beidou_b1i_telemetry_decoder_gs_sptr(new beidou_b1i_telemetry_decoder_gs(satellite, conf));
}
beidou_b1i_telemetry_decoder_gs::beidou_b1i_telemetry_decoder_gs(
const Gnss_Satellite &satellite,
bool dump) : gr::block("beidou_b1i_telemetry_decoder_gs",
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
const Tlm_Conf &conf) : gr::block("beidou_b1i_telemetry_decoder_gs",
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
{
// prevent telemetry symbols accumulation in output buffers
this->set_max_noutput_items(1);
@ -58,7 +82,9 @@ beidou_b1i_telemetry_decoder_gs::beidou_b1i_telemetry_decoder_gs(
// Control messages to tracking block
this->message_port_register_out(pmt::mp("telemetry_to_trk"));
// initialize internal vars
d_dump = dump;
d_dump_filename = conf.dump_filename;
d_dump = conf.dump;
d_dump_mat = conf.dump_mat;
d_satellite = Gnss_Satellite(satellite.get_system(), satellite.get_PRN());
LOG(INFO) << "Initializing BeiDou B1I Telemetry Decoding for satellite " << this->d_satellite;
@ -104,8 +130,10 @@ beidou_b1i_telemetry_decoder_gs::beidou_b1i_telemetry_decoder_gs(
beidou_b1i_telemetry_decoder_gs::~beidou_b1i_telemetry_decoder_gs()
{
DLOG(INFO) << "BeiDou B1I Telemetry decoder block (channel " << d_channel << ") destructor called.";
size_t pos = 0;
if (d_dump_file.is_open() == true)
{
pos = d_dump_file.tellp();
try
{
d_dump_file.close();
@ -114,7 +142,127 @@ beidou_b1i_telemetry_decoder_gs::~beidou_b1i_telemetry_decoder_gs()
{
LOG(WARNING) << "Exception in destructor closing the dump file " << ex.what();
}
if (pos == 0)
{
errorlib::error_code ec;
if (!fs::remove(fs::path(d_dump_filename), ec))
{
LOG(WARNING) << "Error deleting temporary file";
}
}
}
if (d_dump && (pos != 0) && d_dump_mat)
{
try
{
save_matfile();
}
catch (const std::exception &ex)
{
LOG(WARNING) << "Error saving the .mat file: " << ex.what();
}
}
}
int32_t beidou_b1i_telemetry_decoder_gs::save_matfile() const
{
std::ifstream::pos_type size;
const int32_t number_of_double_vars = 2;
const int32_t number_of_int_vars = 2;
const int32_t epoch_size_bytes = sizeof(uint64_t) + sizeof(double) * number_of_double_vars +
sizeof(int32_t) * number_of_int_vars;
std::ifstream dump_file;
std::string dump_filename_ = d_dump_filename;
std::cout << "Generating .mat file for " << dump_filename_ << '\n';
dump_file.exceptions(std::ifstream::failbit | std::ifstream::badbit);
try
{
dump_file.open(dump_filename_.c_str(), std::ios::binary | std::ios::ate);
}
catch (const std::ifstream::failure &e)
{
std::cerr << "Problem opening dump file:" << e.what() << '\n';
return 1;
}
// count number of epochs and rewind
int64_t num_epoch = 0;
if (dump_file.is_open())
{
size = dump_file.tellg();
num_epoch = static_cast<int64_t>(size) / static_cast<int64_t>(epoch_size_bytes);
if (num_epoch == 0LL)
{
// empty file, exit
return 1;
}
dump_file.seekg(0, std::ios::beg);
}
else
{
return 1;
}
auto TOW_at_current_symbol_ms = std::vector<double>(num_epoch);
auto tracking_sample_counter = std::vector<uint64_t>(num_epoch);
auto TOW_at_Preamble_ms = std::vector<double>(num_epoch);
auto nav_symbol = std::vector<int32_t>(num_epoch);
auto prn = std::vector<int32_t>(num_epoch);
try
{
if (dump_file.is_open())
{
for (int64_t i = 0; i < num_epoch; i++)
{
dump_file.read(reinterpret_cast<char *>(&TOW_at_current_symbol_ms[i]), sizeof(double));
dump_file.read(reinterpret_cast<char *>(&tracking_sample_counter[i]), sizeof(uint64_t));
dump_file.read(reinterpret_cast<char *>(&TOW_at_Preamble_ms[i]), sizeof(double));
dump_file.read(reinterpret_cast<char *>(&nav_symbol[i]), sizeof(int32_t));
dump_file.read(reinterpret_cast<char *>(&prn[i]), sizeof(int32_t));
}
}
dump_file.close();
}
catch (const std::ifstream::failure &e)
{
std::cerr << "Problem reading dump file:" << e.what() << '\n';
return 1;
}
// WRITE MAT FILE
mat_t *matfp;
matvar_t *matvar;
std::string filename = dump_filename_;
filename.erase(filename.length() - 4, 4);
filename.append(".mat");
matfp = Mat_CreateVer(filename.c_str(), nullptr, MAT_FT_MAT73);
if (reinterpret_cast<int64_t *>(matfp) != nullptr)
{
std::array<size_t, 2> dims{1, static_cast<size_t>(num_epoch)};
matvar = Mat_VarCreate("TOW_at_current_symbol_ms", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims.data(), TOW_at_current_symbol_ms.data(), 0);
Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE
Mat_VarFree(matvar);
matvar = Mat_VarCreate("tracking_sample_counter", MAT_C_UINT64, MAT_T_UINT64, 2, dims.data(), tracking_sample_counter.data(), 0);
Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE
Mat_VarFree(matvar);
matvar = Mat_VarCreate("TOW_at_Preamble_ms", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims.data(), TOW_at_Preamble_ms.data(), 0);
Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE
Mat_VarFree(matvar);
matvar = Mat_VarCreate("nav_symbol", MAT_C_INT32, MAT_T_INT32, 2, dims.data(), nav_symbol.data(), 0);
Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE
Mat_VarFree(matvar);
matvar = Mat_VarCreate("PRN", MAT_C_INT32, MAT_T_INT32, 2, dims.data(), prn.data(), 0);
Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE
Mat_VarFree(matvar);
}
Mat_Close(matfp);
return 0;
}
@ -348,7 +496,6 @@ void beidou_b1i_telemetry_decoder_gs::set_channel(int32_t channel)
{
try
{
d_dump_filename = "telemetry";
d_dump_filename.append(std::to_string(d_channel));
d_dump_filename.append(".dat");
d_dump_file.exceptions(std::ifstream::failbit | std::ifstream::badbit);
@ -585,12 +732,17 @@ int beidou_b1i_telemetry_decoder_gs::general_work(int noutput_items __attribute_
{
double tmp_double;
uint64_t tmp_ulong_int;
int32_t tmp_int;
tmp_double = static_cast<double>(d_TOW_at_current_symbol_ms) / 1000.0;
d_dump_file.write(reinterpret_cast<char *>(&tmp_double), sizeof(double));
tmp_ulong_int = current_symbol.Tracking_sample_counter;
d_dump_file.write(reinterpret_cast<char *>(&tmp_ulong_int), sizeof(uint64_t));
tmp_double = static_cast<double>(d_TOW_at_Preamble_ms) / 1000.0;
d_dump_file.write(reinterpret_cast<char *>(&tmp_double), sizeof(double));
tmp_int = (current_symbol.Prompt_I > 0.0 ? 1 : -1);
d_dump_file.write(reinterpret_cast<char *>(&tmp_int), sizeof(int32_t));
tmp_int = static_cast<int32_t>(current_symbol.PRN);
d_dump_file.write(reinterpret_cast<char *>(&tmp_int), sizeof(int32_t));
}
catch (const std::ifstream::failure &e)
{

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

@ -26,6 +26,7 @@
#include "beidou_dnav_navigation_message.h"
#include "gnss_block_interface.h"
#include "gnss_satellite.h"
#include "tlm_conf.h"
#include <boost/circular_buffer.hpp>
#include <gnuradio/block.h> // for block
#include <gnuradio/types.h> // for gr_vector_const_void_star
@ -46,7 +47,7 @@ using beidou_b1i_telemetry_decoder_gs_sptr = gnss_shared_ptr<beidou_b1i_telemetr
beidou_b1i_telemetry_decoder_gs_sptr beidou_b1i_make_telemetry_decoder_gs(
const Gnss_Satellite &satellite,
bool dump);
const Tlm_Conf &conf);
/*!
@ -70,9 +71,11 @@ public:
private:
friend beidou_b1i_telemetry_decoder_gs_sptr beidou_b1i_make_telemetry_decoder_gs(
const Gnss_Satellite &satellite,
bool dump);
const Tlm_Conf &conf);
beidou_b1i_telemetry_decoder_gs(const Gnss_Satellite &satellite, bool dump);
beidou_b1i_telemetry_decoder_gs(const Gnss_Satellite &satellite, const Tlm_Conf &conf);
int32_t save_matfile() const;
void decode_subframe(float *symbols);
void decode_word(int32_t word_counter, const float *enc_word_symbols, int32_t *dec_word_symbols);
@ -119,6 +122,7 @@ private:
bool d_sent_tlm_failed_msg;
bool Flag_valid_word;
bool d_dump;
bool d_dump_mat;
};

162
src/algorithms/telemetry_decoder/gnuradio_blocks/beidou_b3i_telemetry_decoder_gs.cc
View File

@ -28,25 +28,49 @@
#include "gnss_synchro.h"
#include <glog/logging.h>
#include <gnuradio/io_signature.h>
#include <matio.h> // for Mat_VarCreate
#include <pmt/pmt.h> // for make_any
#include <pmt/pmt_sugar.h> // for mp
#include <cstddef> // for size_t
#include <cstdlib> // for abs
#include <exception> // for exception
#include <iostream> // for cout
#include <memory> // for shared_ptr, make_shared
#include <vector>
// clang-format off
#if HAS_STD_FILESYSTEM
#include <system_error>
namespace errorlib = std;
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#include <filesystem>
namespace fs = std::filesystem;
#endif
#else
#include <boost/filesystem/operations.hpp> // for remove
#include <boost/filesystem/path.hpp> // for path, operator<<
#include <boost/filesystem/path_traits.hpp> // for filesystem
#include <boost/system/error_code.hpp> // for error_code
namespace fs = boost::filesystem;
namespace errorlib = boost::system;
#endif
// clang-format on
#define CRC_ERROR_LIMIT 8
beidou_b3i_telemetry_decoder_gs_sptr
beidou_b3i_make_telemetry_decoder_gs(const Gnss_Satellite &satellite,
bool dump)
const Tlm_Conf &conf)
{
return beidou_b3i_telemetry_decoder_gs_sptr(new beidou_b3i_telemetry_decoder_gs(satellite, dump));
return beidou_b3i_telemetry_decoder_gs_sptr(new beidou_b3i_telemetry_decoder_gs(satellite, conf));
}
beidou_b3i_telemetry_decoder_gs::beidou_b3i_telemetry_decoder_gs(
const Gnss_Satellite &satellite, bool dump)
const Gnss_Satellite &satellite, const Tlm_Conf &conf)
: gr::block("beidou_b3i_telemetry_decoder_gs",
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
@ -58,7 +82,9 @@ beidou_b3i_telemetry_decoder_gs::beidou_b3i_telemetry_decoder_gs(
// Control messages to tracking block
this->message_port_register_out(pmt::mp("telemetry_to_trk"));
// initialize internal vars
d_dump = dump;
d_dump_filename = conf.dump_filename;
d_dump = conf.dump;
d_dump_mat = conf.dump_mat;
d_satellite = Gnss_Satellite(satellite.get_system(), satellite.get_PRN());
LOG(INFO) << "Initializing BeiDou B3I Telemetry Decoding for satellite " << this->d_satellite;
@ -104,8 +130,10 @@ beidou_b3i_telemetry_decoder_gs::beidou_b3i_telemetry_decoder_gs(
beidou_b3i_telemetry_decoder_gs::~beidou_b3i_telemetry_decoder_gs()
{
DLOG(INFO) << "BeiDou B3I Telemetry decoder block (channel " << d_channel << ") destructor called.";
size_t pos = 0;
if (d_dump_file.is_open() == true)
{
pos = d_dump_file.tellp();
try
{
d_dump_file.close();
@ -114,7 +142,127 @@ beidou_b3i_telemetry_decoder_gs::~beidou_b3i_telemetry_decoder_gs()
{
LOG(WARNING) << "Exception in destructor closing the dump file " << ex.what();
}
if (pos == 0)
{
errorlib::error_code ec;
if (!fs::remove(fs::path(d_dump_filename), ec))
{
LOG(WARNING) << "Error deleting temporary file";
}
}
}
if (d_dump && (pos != 0) && d_dump_mat)
{
try
{
save_matfile();
}
catch (const std::exception &ex)
{
LOG(WARNING) << "Error saving the .mat file: " << ex.what();
}
}
}
int32_t beidou_b3i_telemetry_decoder_gs::save_matfile() const
{
std::ifstream::pos_type size;
const int32_t number_of_double_vars = 2;
const int32_t number_of_int_vars = 2;
const int32_t epoch_size_bytes = sizeof(uint64_t) + sizeof(double) * number_of_double_vars +
sizeof(int32_t) * number_of_int_vars;
std::ifstream dump_file;
std::string dump_filename_ = d_dump_filename;
std::cout << "Generating .mat file for " << dump_filename_ << '\n';
dump_file.exceptions(std::ifstream::failbit | std::ifstream::badbit);
try
{
dump_file.open(dump_filename_.c_str(), std::ios::binary | std::ios::ate);
}
catch (const std::ifstream::failure &e)
{
std::cerr << "Problem opening dump file:" << e.what() << '\n';
return 1;
}
// count number of epochs and rewind
int64_t num_epoch = 0;
if (dump_file.is_open())
{
size = dump_file.tellg();
num_epoch = static_cast<int64_t>(size) / static_cast<int64_t>(epoch_size_bytes);
if (num_epoch == 0LL)
{
// empty file, exit
return 1;
}
dump_file.seekg(0, std::ios::beg);
}
else
{
return 1;
}
auto TOW_at_current_symbol_ms = std::vector<double>(num_epoch);
auto tracking_sample_counter = std::vector<uint64_t>(num_epoch);
auto TOW_at_Preamble_ms = std::vector<double>(num_epoch);
auto nav_symbol = std::vector<int32_t>(num_epoch);
auto prn = std::vector<int32_t>(num_epoch);
try
{
if (dump_file.is_open())
{
for (int64_t i = 0; i < num_epoch; i++)
{
dump_file.read(reinterpret_cast<char *>(&TOW_at_current_symbol_ms[i]), sizeof(double));
dump_file.read(reinterpret_cast<char *>(&tracking_sample_counter[i]), sizeof(uint64_t));
dump_file.read(reinterpret_cast<char *>(&TOW_at_Preamble_ms[i]), sizeof(double));
dump_file.read(reinterpret_cast<char *>(&nav_symbol[i]), sizeof(int32_t));
dump_file.read(reinterpret_cast<char *>(&prn[i]), sizeof(int32_t));
}
}
dump_file.close();
}
catch (const std::ifstream::failure &e)
{
std::cerr << "Problem reading dump file:" << e.what() << '\n';
return 1;
}
// WRITE MAT FILE
mat_t *matfp;
matvar_t *matvar;
std::string filename = dump_filename_;
filename.erase(filename.length() - 4, 4);
filename.append(".mat");
matfp = Mat_CreateVer(filename.c_str(), nullptr, MAT_FT_MAT73);
if (reinterpret_cast<int64_t *>(matfp) != nullptr)
{
std::array<size_t, 2> dims{1, static_cast<size_t>(num_epoch)};
matvar = Mat_VarCreate("TOW_at_current_symbol_ms", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims.data(), TOW_at_current_symbol_ms.data(), 0);
Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE
Mat_VarFree(matvar);
matvar = Mat_VarCreate("tracking_sample_counter", MAT_C_UINT64, MAT_T_UINT64, 2, dims.data(), tracking_sample_counter.data(), 0);
Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE
Mat_VarFree(matvar);
matvar = Mat_VarCreate("TOW_at_Preamble_ms", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims.data(), TOW_at_Preamble_ms.data(), 0);
Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE
Mat_VarFree(matvar);
matvar = Mat_VarCreate("nav_symbol", MAT_C_INT32, MAT_T_INT32, 2, dims.data(), nav_symbol.data(), 0);
Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE
Mat_VarFree(matvar);
matvar = Mat_VarCreate("PRN", MAT_C_INT32, MAT_T_INT32, 2, dims.data(), prn.data(), 0);
Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE
Mat_VarFree(matvar);
}
Mat_Close(matfp);
return 0;
}
@ -365,7 +513,6 @@ void beidou_b3i_telemetry_decoder_gs::set_channel(int32_t channel)
{
try
{
d_dump_filename = "telemetry";
d_dump_filename.append(std::to_string(d_channel));
d_dump_filename.append(".dat");
d_dump_file.exceptions(std::ifstream::failbit | std::ifstream::badbit);
@ -615,12 +762,17 @@ int beidou_b3i_telemetry_decoder_gs::general_work(
{
double tmp_double;
uint64_t tmp_ulong_int;
int32_t tmp_int;
tmp_double = static_cast<double>(d_TOW_at_current_symbol_ms) / 1000.0;
d_dump_file.write(reinterpret_cast<char *>(&tmp_double), sizeof(double));
tmp_ulong_int = current_symbol.Tracking_sample_counter;
d_dump_file.write(reinterpret_cast<char *>(&tmp_ulong_int), sizeof(uint64_t));
tmp_double = static_cast<double>(d_TOW_at_Preamble_ms) / 1000.0;
d_dump_file.write(reinterpret_cast<char *>(&tmp_double), sizeof(double));
tmp_int = (current_symbol.Prompt_I > 0.0 ? 1 : -1);
d_dump_file.write(reinterpret_cast<char *>(&tmp_int), sizeof(int32_t));
tmp_int = static_cast<int32_t>(current_symbol.PRN);
d_dump_file.write(reinterpret_cast<char *>(&tmp_int), sizeof(int32_t));
}
catch (const std::ifstream::failure &e)
{

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

@ -23,6 +23,7 @@
#include "beidou_dnav_navigation_message.h"
#include "gnss_block_interface.h"
#include "gnss_satellite.h"
#include "tlm_conf.h"
#include <boost/circular_buffer.hpp>
#include <gnuradio/block.h> // for block
#include <gnuradio/types.h> // for gr_vector_const_void_star
@ -45,7 +46,7 @@ using beidou_b3i_telemetry_decoder_gs_sptr =
beidou_b3i_telemetry_decoder_gs_sptr beidou_b3i_make_telemetry_decoder_gs(
const Gnss_Satellite &satellite,
bool dump);
const Tlm_Conf &conf);
/*!
* \brief This class implements a block that decodes the BeiDou DNAV data.
@ -68,9 +69,11 @@ public:
private:
friend beidou_b3i_telemetry_decoder_gs_sptr beidou_b3i_make_telemetry_decoder_gs(
const Gnss_Satellite &satellite,
bool dump);
const Tlm_Conf &conf);
beidou_b3i_telemetry_decoder_gs(const Gnss_Satellite &satellite, bool dump);
beidou_b3i_telemetry_decoder_gs(const Gnss_Satellite &satellite, const Tlm_Conf &conf);
int32_t save_matfile() const;
void decode_subframe(float *symbols);
void decode_word(int32_t word_counter, const float *enc_word_symbols,
@ -116,6 +119,7 @@ private:
bool d_sent_tlm_failed_msg;
bool Flag_valid_word;
bool d_dump;
bool d_dump_mat;
};

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

@ -34,29 +34,52 @@
#include "gnss_synchro.h"
#include <glog/logging.h>
#include <gnuradio/io_signature.h>
#include <matio.h> // for Mat_VarCreate
#include <pmt/pmt.h> // for make_any
#include <pmt/pmt_sugar.h> // for mp
#include <cmath> // for fmod
#include <cstddef> // for size_t
#include <cstdlib> // for abs
#include <exception> // for exception
#include <iostream> // for cout
#include <memory> // for make_shared
// clang-format off
#if HAS_STD_FILESYSTEM
#include <system_error>
namespace errorlib = std;
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#include <filesystem>
namespace fs = std::filesystem;
#endif
#else
#include <boost/filesystem/operations.hpp> // for remove
#include <boost/filesystem/path.hpp> // for path, operator<<
#include <boost/filesystem/path_traits.hpp> // for filesystem
#include <boost/system/error_code.hpp> // for error_code
namespace fs = boost::filesystem;
namespace errorlib = boost::system;
#endif
// clang-format on
#define CRC_ERROR_LIMIT 6
galileo_telemetry_decoder_gs_sptr
galileo_make_telemetry_decoder_gs(const Gnss_Satellite &satellite, int frame_type, bool dump)
galileo_make_telemetry_decoder_gs(const Gnss_Satellite &satellite, const Tlm_Conf &conf, int frame_type)
{
return galileo_telemetry_decoder_gs_sptr(new galileo_telemetry_decoder_gs(satellite, frame_type, dump));
return galileo_telemetry_decoder_gs_sptr(new galileo_telemetry_decoder_gs(satellite, conf, frame_type));
}
galileo_telemetry_decoder_gs::galileo_telemetry_decoder_gs(
const Gnss_Satellite &satellite, int frame_type,
bool dump) : gr::block("galileo_telemetry_decoder_gs", gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
const Gnss_Satellite &satellite,
const Tlm_Conf &conf,
int frame_type) : gr::block("galileo_telemetry_decoder_gs", gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
{
// prevent telemetry symbols accumulation in output buffers
this->set_max_noutput_items(1);
@ -69,7 +92,9 @@ galileo_telemetry_decoder_gs::galileo_telemetry_decoder_gs(
d_band = '1';
// initialize internal vars
d_dump = dump;
d_dump_filename = conf.dump_filename;
d_dump = conf.dump;
d_dump_mat = conf.dump_mat;
d_satellite = Gnss_Satellite(satellite.get_system(), satellite.get_PRN());
d_frame_type = frame_type;
DLOG(INFO) << "Initializing GALILEO UNIFIED TELEMETRY DECODER";
@ -213,8 +238,10 @@ galileo_telemetry_decoder_gs::galileo_telemetry_decoder_gs(
galileo_telemetry_decoder_gs::~galileo_telemetry_decoder_gs()
{
DLOG(INFO) << "Galileo Telemetry decoder block (channel " << d_channel << ") destructor called.";
size_t pos = 0;
if (d_dump_file.is_open() == true)
{
pos = d_dump_file.tellp();
try
{
d_dump_file.close();
@ -223,7 +250,127 @@ galileo_telemetry_decoder_gs::~galileo_telemetry_decoder_gs()
{
LOG(WARNING) << "Exception in destructor closing the dump file " << ex.what();
}
if (pos == 0)
{
errorlib::error_code ec;
if (!fs::remove(fs::path(d_dump_filename), ec))
{
LOG(WARNING) << "Error deleting temporary file";
}
}
}
if (d_dump && (pos != 0) && d_dump_mat)
{
try
{
save_matfile();
}
catch (const std::exception &ex)
{
LOG(WARNING) << "Error saving the .mat file: " << ex.what();
}
}
}
int32_t galileo_telemetry_decoder_gs::save_matfile() const
{
std::ifstream::pos_type size;
const int32_t number_of_double_vars = 2;
const int32_t number_of_int_vars = 2;
const int32_t epoch_size_bytes = sizeof(uint64_t) + sizeof(double) * number_of_double_vars +
sizeof(int32_t) * number_of_int_vars;
std::ifstream dump_file;
std::string dump_filename_ = d_dump_filename;
std::cout << "Generating .mat file for " << dump_filename_ << '\n';
dump_file.exceptions(std::ifstream::failbit | std::ifstream::badbit);
try
{
dump_file.open(dump_filename_.c_str(), std::ios::binary | std::ios::ate);
}
catch (const std::ifstream::failure &e)
{
std::cerr << "Problem opening dump file:" << e.what() << '\n';
return 1;
}
// count number of epochs and rewind
int64_t num_epoch = 0;
if (dump_file.is_open())
{
size = dump_file.tellg();
num_epoch = static_cast<int64_t>(size) / static_cast<int64_t>(epoch_size_bytes);
if (num_epoch == 0LL)
{
// empty file, exit
return 1;
}
dump_file.seekg(0, std::ios::beg);
}
else
{
return 1;
}
auto TOW_at_current_symbol_ms = std::vector<double>(num_epoch);
auto tracking_sample_counter = std::vector<uint64_t>(num_epoch);
auto TOW_at_Preamble_ms = std::vector<double>(num_epoch);
auto nav_symbol = std::vector<int32_t>(num_epoch);
auto prn = std::vector<int32_t>(num_epoch);
try
{
if (dump_file.is_open())
{
for (int64_t i = 0; i < num_epoch; i++)
{
dump_file.read(reinterpret_cast<char *>(&TOW_at_current_symbol_ms[i]), sizeof(double));
dump_file.read(reinterpret_cast<char *>(&tracking_sample_counter[i]), sizeof(uint64_t));
dump_file.read(reinterpret_cast<char *>(&TOW_at_Preamble_ms[i]), sizeof(double));
dump_file.read(reinterpret_cast<char *>(&nav_symbol[i]), sizeof(int32_t));
dump_file.read(reinterpret_cast<char *>(&prn[i]), sizeof(int32_t));
}
}
dump_file.close();
}
catch (const std::ifstream::failure &e)
{
std::cerr << "Problem reading dump file:" << e.what() << '\n';
return 1;
}
// WRITE MAT FILE
mat_t *matfp;
matvar_t *matvar;
std::string filename = dump_filename_;
filename.erase(filename.length() - 4, 4);
filename.append(".mat");
matfp = Mat_CreateVer(filename.c_str(), nullptr, MAT_FT_MAT73);
if (reinterpret_cast<int64_t *>(matfp) != nullptr)
{
std::array<size_t, 2> dims{1, static_cast<size_t>(num_epoch)};
matvar = Mat_VarCreate("TOW_at_current_symbol_ms", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims.data(), TOW_at_current_symbol_ms.data(), 0);
Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE
Mat_VarFree(matvar);
matvar = Mat_VarCreate("tracking_sample_counter", MAT_C_UINT64, MAT_T_UINT64, 2, dims.data(), tracking_sample_counter.data(), 0);
Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE
Mat_VarFree(matvar);
matvar = Mat_VarCreate("TOW_at_Preamble_ms", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims.data(), TOW_at_Preamble_ms.data(), 0);
Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE
Mat_VarFree(matvar);
matvar = Mat_VarCreate("nav_symbol", MAT_C_INT32, MAT_T_INT32, 2, dims.data(), nav_symbol.data(), 0);
Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE
Mat_VarFree(matvar);
matvar = Mat_VarCreate("PRN", MAT_C_INT32, MAT_T_INT32, 2, dims.data(), prn.data(), 0);
Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE
Mat_VarFree(matvar);
}
Mat_Close(matfp);
return 0;
}
@ -535,7 +682,6 @@ void galileo_telemetry_decoder_gs::set_channel(int32_t channel)
{
try
{
d_dump_filename = "telemetry";
d_dump_filename.append(std::to_string(d_channel));
d_dump_filename.append(".dat");
d_dump_file.exceptions(std::ifstream::failbit | std::ifstream::badbit);
@ -907,12 +1053,31 @@ int galileo_telemetry_decoder_gs::general_work(int noutput_items __attribute__((
{
double tmp_double;
uint64_t tmp_ulong_int;
int32_t tmp_int;
tmp_double = static_cast<double>(d_TOW_at_current_symbol_ms) / 1000.0;
d_dump_file.write(reinterpret_cast<char *>(&tmp_double), sizeof(double));
tmp_ulong_int = current_symbol.Tracking_sample_counter;
d_dump_file.write(reinterpret_cast<char *>(&tmp_ulong_int), sizeof(uint64_t));
tmp_double = static_cast<double>(d_TOW_at_Preamble_ms) / 1000.0;
d_dump_file.write(reinterpret_cast<char *>(&tmp_double), sizeof(double));
switch (d_frame_type)
{
case 1:
tmp_int = (current_symbol.Prompt_I > 0.0 ? 1 : -1);
break;
case 2:
tmp_int = (current_symbol.Prompt_Q > 0.0 ? 1 : -1);
break;
case 3:
tmp_int = (current_symbol.Prompt_I > 0.0 ? 1 : -1);
break;
default:
tmp_int = 0;
break;
}
d_dump_file.write(reinterpret_cast<char *>(&tmp_int), sizeof(int32_t));
tmp_int = static_cast<int32_t>(current_symbol.PRN);
d_dump_file.write(reinterpret_cast<char *>(&tmp_int), sizeof(int32_t));
}
catch (const std::ifstream::failure &e)
{

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

@ -28,6 +28,7 @@
#include "galileo_inav_message.h"
#include "gnss_block_interface.h"
#include "gnss_satellite.h"
#include "tlm_conf.h"
#include <boost/circular_buffer.hpp>
#include <gnuradio/block.h> // for block
#include <gnuradio/types.h> // for gr_vector_const_void_star
@ -49,8 +50,8 @@ using galileo_telemetry_decoder_gs_sptr = gnss_shared_ptr<galileo_telemetry_deco
galileo_telemetry_decoder_gs_sptr galileo_make_telemetry_decoder_gs(
const Gnss_Satellite &satellite,
int frame_type,
bool dump);
const Tlm_Conf &conf,
int frame_type);
/*!
* \brief This class implements a block that decodes the INAV and FNAV data defined in Galileo ICD
@ -74,14 +75,16 @@ public:
private:
friend galileo_telemetry_decoder_gs_sptr galileo_make_telemetry_decoder_gs(
const Gnss_Satellite &satellite,
int frame_type,
bool dump);
const Tlm_Conf &conf,
int frame_type);
galileo_telemetry_decoder_gs(const Gnss_Satellite &satellite, int frame_type, bool dump);
galileo_telemetry_decoder_gs(const Gnss_Satellite &satellite, const Tlm_Conf &conf, int frame_type);
const int32_t d_nn = 2; // Coding rate 1/n
const int32_t d_KK = 7; // Constraint Length
int32_t save_matfile() const;
void viterbi_decoder(float *page_part_symbols, int32_t *page_part_bits);
void deinterleaver(int32_t rows, int32_t cols, const float *in, float *out);
void decode_INAV_word(float *page_part_symbols, int32_t frame_length);
@ -140,6 +143,7 @@ private:
bool d_flag_parity;
bool d_flag_preamble;
bool d_dump;
bool d_dump_mat;
};

164
src/algorithms/telemetry_decoder/gnuradio_blocks/glonass_l1_ca_telemetry_decoder_gs.cc
View File

@ -25,28 +25,52 @@
#include "glonass_gnav_utc_model.h"
#include <glog/logging.h>
#include <gnuradio/io_signature.h>
#include <matio.h> // for Mat_VarCreate
#include <pmt/pmt.h> // for make_any
#include <pmt/pmt_sugar.h> // for mp
#include <cmath> // for floor, round
#include <cstddef> // for size_t
#include <cstdlib> // for abs
#include <exception> // for exception
#include <iostream> // for cout
#include <memory> // for shared_ptr, make_shared
#include <vector>
// clang-format off
#if HAS_STD_FILESYSTEM
#include <system_error>
namespace errorlib = std;
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#include <filesystem>
namespace fs = std::filesystem;
#endif
#else
#include <boost/filesystem/operations.hpp> // for remove
#include <boost/filesystem/path.hpp> // for path, operator<<
#include <boost/filesystem/path_traits.hpp> // for filesystem
#include <boost/system/error_code.hpp> // for error_code
namespace fs = boost::filesystem;
namespace errorlib = boost::system;
#endif
// clang-format on
#define CRC_ERROR_LIMIT 6
glonass_l1_ca_telemetry_decoder_gs_sptr
glonass_l1_ca_make_telemetry_decoder_gs(const Gnss_Satellite &satellite, bool dump)
glonass_l1_ca_make_telemetry_decoder_gs(const Gnss_Satellite &satellite, const Tlm_Conf &conf)
{
return glonass_l1_ca_telemetry_decoder_gs_sptr(new glonass_l1_ca_telemetry_decoder_gs(satellite, dump));
return glonass_l1_ca_telemetry_decoder_gs_sptr(new glonass_l1_ca_telemetry_decoder_gs(satellite, conf));
}
glonass_l1_ca_telemetry_decoder_gs::glonass_l1_ca_telemetry_decoder_gs(
const Gnss_Satellite &satellite,
bool dump) : gr::block("glonass_l1_ca_telemetry_decoder_gs", gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
const Tlm_Conf &conf) : gr::block("glonass_l1_ca_telemetry_decoder_gs", gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
{
// prevent telemetry symbols accumulation in output buffers
this->set_max_noutput_items(1);
@ -55,7 +79,9 @@ glonass_l1_ca_telemetry_decoder_gs::glonass_l1_ca_telemetry_decoder_gs(
// Control messages to tracking block
this->message_port_register_out(pmt::mp("telemetry_to_trk"));
// initialize internal vars
d_dump = dump;
d_dump_filename = conf.dump_filename;
d_dump = conf.dump;
d_dump_mat = conf.dump_mat;
d_satellite = Gnss_Satellite(satellite.get_system(), satellite.get_PRN());
LOG(INFO) << "Initializing GLONASS L1 CA TELEMETRY DECODING";
@ -97,8 +123,10 @@ glonass_l1_ca_telemetry_decoder_gs::glonass_l1_ca_telemetry_decoder_gs(
glonass_l1_ca_telemetry_decoder_gs::~glonass_l1_ca_telemetry_decoder_gs()
{
DLOG(INFO) << "Glonass L1 Telemetry decoder block (channel " << d_channel << ") destructor called.";
size_t pos = 0;
if (d_dump_file.is_open() == true)
{
pos = d_dump_file.tellp();
try
{
d_dump_file.close();
@ -107,7 +135,127 @@ glonass_l1_ca_telemetry_decoder_gs::~glonass_l1_ca_telemetry_decoder_gs()
{
LOG(WARNING) << "Exception in destructor closing the dump file " << ex.what();
}
if (pos == 0)
{
errorlib::error_code ec;
if (!fs::remove(fs::path(d_dump_filename), ec))
{
LOG(WARNING) << "Error deleting temporary file";
}
}
}
if (d_dump && (pos != 0))
{
try
{
save_matfile();
}
catch (const std::exception &ex)
{
LOG(WARNING) << "Error saving the .mat file: " << ex.what();
}
}
}
int32_t glonass_l1_ca_telemetry_decoder_gs::save_matfile() const
{
std::ifstream::pos_type size;
const int32_t number_of_double_vars = 2;
const int32_t number_of_int_vars = 2;
const int32_t epoch_size_bytes = sizeof(uint64_t) + sizeof(double) * number_of_double_vars +
sizeof(int32_t) * number_of_int_vars;
std::ifstream dump_file;
std::string dump_filename_ = d_dump_filename;
std::cout << "Generating .mat file for " << dump_filename_ << '\n';
dump_file.exceptions(std::ifstream::failbit | std::ifstream::badbit);
try
{
dump_file.open(dump_filename_.c_str(), std::ios::binary | std::ios::ate);
}
catch (const std::ifstream::failure &e)
{
std::cerr << "Problem opening dump file:" << e.what() << '\n';
return 1;
}
// count number of epochs and rewind
int64_t num_epoch = 0;
if (dump_file.is_open())
{
size = dump_file.tellg();
num_epoch = static_cast<int64_t>(size) / static_cast<int64_t>(epoch_size_bytes);
if (num_epoch == 0LL)
{
// empty file, exit
return 1;
}
dump_file.seekg(0, std::ios::beg);
}
else
{
return 1;
}
auto TOW_at_current_symbol_ms = std::vector<double>(num_epoch);
auto tracking_sample_counter = std::vector<uint64_t>(num_epoch);
auto TOW_at_Preamble_ms = std::vector<double>(num_epoch);
auto nav_symbol = std::vector<int32_t>(num_epoch);
auto prn = std::vector<int32_t>(num_epoch);
try
{
if (dump_file.is_open())
{
for (int64_t i = 0; i < num_epoch; i++)
{
dump_file.read(reinterpret_cast<char *>(&TOW_at_current_symbol_ms[i]), sizeof(double));
dump_file.read(reinterpret_cast<char *>(&tracking_sample_counter[i]), sizeof(uint64_t));
dump_file.read(reinterpret_cast<char *>(&TOW_at_Preamble_ms[i]), sizeof(double));
dump_file.read(reinterpret_cast<char *>(&nav_symbol[i]), sizeof(int32_t));
dump_file.read(reinterpret_cast<char *>(&prn[i]), sizeof(int32_t));
}
}
dump_file.close();
}
catch (const std::ifstream::failure &e)
{
std::cerr << "Problem reading dump file:" << e.what() << '\n';
return 1;
}
// WRITE MAT FILE
mat_t *matfp;
matvar_t *matvar;
std::string filename = dump_filename_;
filename.erase(filename.length() - 4, 4);
filename.append(".mat");
matfp = Mat_CreateVer(filename.c_str(), nullptr, MAT_FT_MAT73);
if (reinterpret_cast<int64_t *>(matfp) != nullptr)
{
std::array<size_t, 2> dims{1, static_cast<size_t>(num_epoch)};
matvar = Mat_VarCreate("TOW_at_current_symbol_ms", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims.data(), TOW_at_current_symbol_ms.data(), 0);
Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE
Mat_VarFree(matvar);
matvar = Mat_VarCreate("tracking_sample_counter", MAT_C_UINT64, MAT_T_UINT64, 2, dims.data(), tracking_sample_counter.data(), 0);
Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE
Mat_VarFree(matvar);
matvar = Mat_VarCreate("TOW_at_Preamble_ms", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims.data(), TOW_at_Preamble_ms.data(), 0);
Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE
Mat_VarFree(matvar);
matvar = Mat_VarCreate("nav_symbol", MAT_C_INT32, MAT_T_INT32, 2, dims.data(), nav_symbol.data(), 0);
Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE
Mat_VarFree(matvar);
matvar = Mat_VarCreate("PRN", MAT_C_INT32, MAT_T_INT32, 2, dims.data(), prn.data(), 0);
Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE
Mat_VarFree(matvar);
}
Mat_Close(matfp);
return 0;
}
@ -234,7 +382,6 @@ void glonass_l1_ca_telemetry_decoder_gs::set_channel(int32_t channel)
{
try
{
d_dump_filename = "telemetry";
d_dump_filename.append(std::to_string(d_channel));
d_dump_filename.append(".dat");
d_dump_file.exceptions(std::ifstream::failbit | std::ifstream::badbit);
@ -414,12 +561,17 @@ int glonass_l1_ca_telemetry_decoder_gs::general_work(int noutput_items __attribu
{
double tmp_double;
uint64_t tmp_ulong_int;
int32_t tmp_int;
tmp_double = d_TOW_at_current_symbol;
d_dump_file.write(reinterpret_cast<char *>(&tmp_double), sizeof(double));
tmp_ulong_int = current_symbol.Tracking_sample_counter;
d_dump_file.write(reinterpret_cast<char *>(&tmp_ulong_int), sizeof(uint64_t));
tmp_double = 0;
d_dump_file.write(reinterpret_cast<char *>(&tmp_double), sizeof(double));
tmp_int = (current_symbol.Prompt_I > 0.0 ? 1 : -1);
d_dump_file.write(reinterpret_cast<char *>(&tmp_int), sizeof(int32_t));
tmp_int = static_cast<int32_t>(current_symbol.PRN);
d_dump_file.write(reinterpret_cast<char *>(&tmp_int), sizeof(int32_t));
}
catch (const std::ifstream::failure &e)
{

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

@ -27,6 +27,7 @@
#include "gnss_block_interface.h"
#include "gnss_satellite.h"
#include "gnss_synchro.h"
#include "tlm_conf.h"
#include <boost/circular_buffer.hpp>
#include <gnuradio/block.h> // for block
#include <gnuradio/types.h> // for gr_vector_const_void_star
@ -47,7 +48,7 @@ using glonass_l1_ca_telemetry_decoder_gs_sptr = gnss_shared_ptr<glonass_l1_ca_te
glonass_l1_ca_telemetry_decoder_gs_sptr glonass_l1_ca_make_telemetry_decoder_gs(
const Gnss_Satellite &satellite,
bool dump);
const Tlm_Conf &conf);
/*!
* \brief This class implements a block that decodes the GNAV data defined in GLONASS ICD v5.1
@ -74,14 +75,16 @@ public:
private:
friend glonass_l1_ca_telemetry_decoder_gs_sptr glonass_l1_ca_make_telemetry_decoder_gs(
const Gnss_Satellite &satellite,
bool dump);
const Tlm_Conf &conf);
glonass_l1_ca_telemetry_decoder_gs(const Gnss_Satellite &satellite, bool dump);
glonass_l1_ca_telemetry_decoder_gs(const Gnss_Satellite &satellite, const Tlm_Conf &conf);
const std::array<uint16_t, GLONASS_GNAV_PREAMBLE_LENGTH_BITS> d_preambles_bits{GLONASS_GNAV_PREAMBLE};
const int32_t d_symbols_per_preamble = GLONASS_GNAV_PREAMBLE_LENGTH_SYMBOLS;
int32_t save_matfile() const;
void decode_string(const double *symbols, int32_t frame_length);
// Help with coherent tracking
@ -118,6 +121,7 @@ private:
bool flag_TOW_set; // Indicates when time of week is set
bool Flag_valid_word;
bool d_dump;
bool d_dump_mat;
};

164
src/algorithms/telemetry_decoder/gnuradio_blocks/glonass_l2_ca_telemetry_decoder_gs.cc
View File

@ -25,28 +25,52 @@
#include "glonass_gnav_utc_model.h"
#include <glog/logging.h>
#include <gnuradio/io_signature.h>
#include <matio.h> // for Mat_VarCreate
#include <pmt/pmt.h> // for make_any
#include <pmt/pmt_sugar.h> // for mp
#include <cmath> // for floor, round
#include <cstddef> // for size_t
#include <cstdlib> // for abs
#include <exception> // for exception
#include <iostream> // for cout
#include <memory> // for shared_ptr, make_shared
#include <vector>
// clang-format off
#if HAS_STD_FILESYSTEM
#include <system_error>
namespace errorlib = std;
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#include <filesystem>
namespace fs = std::filesystem;
#endif
#else
#include <boost/filesystem/operations.hpp> // for remove
#include <boost/filesystem/path.hpp> // for path, operator<<
#include <boost/filesystem/path_traits.hpp> // for filesystem
#include <boost/system/error_code.hpp> // for error_code
namespace fs = boost::filesystem;
namespace errorlib = boost::system;
#endif
// clang-format on
#define CRC_ERROR_LIMIT 6
glonass_l2_ca_telemetry_decoder_gs_sptr
glonass_l2_ca_make_telemetry_decoder_gs(const Gnss_Satellite &satellite, bool dump)
glonass_l2_ca_make_telemetry_decoder_gs(const Gnss_Satellite &satellite, const Tlm_Conf &conf)
{
return glonass_l2_ca_telemetry_decoder_gs_sptr(new glonass_l2_ca_telemetry_decoder_gs(satellite, dump));
return glonass_l2_ca_telemetry_decoder_gs_sptr(new glonass_l2_ca_telemetry_decoder_gs(satellite, conf));
}
glonass_l2_ca_telemetry_decoder_gs::glonass_l2_ca_telemetry_decoder_gs(
const Gnss_Satellite &satellite,
bool dump) : gr::block("glonass_l2_ca_telemetry_decoder_gs", gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
const Tlm_Conf &conf) : gr::block("glonass_l2_ca_telemetry_decoder_gs", gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
{
// prevent telemetry symbols accumulation in output buffers
this->set_max_noutput_items(1);
@ -55,7 +79,9 @@ glonass_l2_ca_telemetry_decoder_gs::glonass_l2_ca_telemetry_decoder_gs(
// Control messages to tracking block
this->message_port_register_out(pmt::mp("telemetry_to_trk"));
// initialize internal vars
d_dump = dump;
d_dump_filename = conf.dump_filename;
d_dump = conf.dump;
d_dump_mat = conf.dump_mat;
d_satellite = Gnss_Satellite(satellite.get_system(), satellite.get_PRN());
LOG(INFO) << "Initializing GLONASS L2 CA TELEMETRY DECODING";
@ -97,8 +123,10 @@ glonass_l2_ca_telemetry_decoder_gs::glonass_l2_ca_telemetry_decoder_gs(
glonass_l2_ca_telemetry_decoder_gs::~glonass_l2_ca_telemetry_decoder_gs()
{
DLOG(INFO) << "Glonass L2 Telemetry decoder block (channel " << d_channel << ") destructor called.";
size_t pos = 0;
if (d_dump_file.is_open() == true)
{
pos = d_dump_file.tellp();
try
{
d_dump_file.close();
@ -107,7 +135,127 @@ glonass_l2_ca_telemetry_decoder_gs::~glonass_l2_ca_telemetry_decoder_gs()
{
LOG(WARNING) << "Exception in destructor closing the dump file " << ex.what();
}
if (pos == 0)
{
errorlib::error_code ec;
if (!fs::remove(fs::path(d_dump_filename), ec))
{
LOG(WARNING) << "Error deleting temporary file";
}
}
}
if (d_dump && (pos != 0) && d_dump_mat)
{
try
{
save_matfile();
}
catch (const std::exception &ex)
{
LOG(WARNING) << "Error saving the .mat file: " << ex.what();
}
}
}
int32_t glonass_l2_ca_telemetry_decoder_gs::save_matfile() const
{
std::ifstream::pos_type size;
const int32_t number_of_double_vars = 2;
const int32_t number_of_int_vars = 2;
const int32_t epoch_size_bytes = sizeof(uint64_t) + sizeof(double) * number_of_double_vars +
sizeof(int32_t) * number_of_int_vars;
std::ifstream dump_file;
std::string dump_filename_ = d_dump_filename;
std::cout << "Generating .mat file for " << dump_filename_ << '\n';
dump_file.exceptions(std::ifstream::failbit | std::ifstream::badbit);
try
{
dump_file.open(dump_filename_.c_str(), std::ios::binary | std::ios::ate);
}
catch (const std::ifstream::failure &e)
{
std::cerr << "Problem opening dump file:" << e.what() << '\n';
return 1;
}
// count number of epochs and rewind
int64_t num_epoch = 0;
if (dump_file.is_open())
{
size = dump_file.tellg();
num_epoch = static_cast<int64_t>(size) / static_cast<int64_t>(epoch_size_bytes);
if (num_epoch == 0LL)
{
// empty file, exit
return 1;
}
dump_file.seekg(0, std::ios::beg);
}
else
{
return 1;
}
auto TOW_at_current_symbol_ms = std::vector<double>(num_epoch);
auto tracking_sample_counter = std::vector<uint64_t>(num_epoch);
auto TOW_at_Preamble_ms = std::vector<double>(num_epoch);
auto nav_symbol = std::vector<int32_t>(num_epoch);
auto prn = std::vector<int32_t>(num_epoch);
try
{
if (dump_file.is_open())
{
for (int64_t i = 0; i < num_epoch; i++)
{
dump_file.read(reinterpret_cast<char *>(&TOW_at_current_symbol_ms[i]), sizeof(double));
dump_file.read(reinterpret_cast<char *>(&tracking_sample_counter[i]), sizeof(uint64_t));
dump_file.read(reinterpret_cast<char *>(&TOW_at_Preamble_ms[i]), sizeof(double));
dump_file.read(reinterpret_cast<char *>(&nav_symbol[i]), sizeof(int32_t));
dump_file.read(reinterpret_cast<char *>(&prn[i]), sizeof(int32_t));
}
}
dump_file.close();
}
catch (const std::ifstream::failure &e)
{
std::cerr << "Problem reading dump file:" << e.what() << '\n';
return 1;
}
// WRITE MAT FILE
mat_t *matfp;
matvar_t *matvar;
std::string filename = dump_filename_;
filename.erase(filename.length() - 4, 4);
filename.append(".mat");
matfp = Mat_CreateVer(filename.c_str(), nullptr, MAT_FT_MAT73);
if (reinterpret_cast<int64_t *>(matfp) != nullptr)
{
std::array<size_t, 2> dims{1, static_cast<size_t>(num_epoch)};
matvar = Mat_VarCreate("TOW_at_current_symbol_ms", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims.data(), TOW_at_current_symbol_ms.data(), 0);
Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE
Mat_VarFree(matvar);
matvar = Mat_VarCreate("tracking_sample_counter", MAT_C_UINT64, MAT_T_UINT64, 2, dims.data(), tracking_sample_counter.data(), 0);
Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE
Mat_VarFree(matvar);
matvar = Mat_VarCreate("TOW_at_Preamble_ms", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims.data(), TOW_at_Preamble_ms.data(), 0);
Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE
Mat_VarFree(matvar);
matvar = Mat_VarCreate("nav_symbol", MAT_C_INT32, MAT_T_INT32, 2, dims.data(), nav_symbol.data(), 0);
Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE
Mat_VarFree(matvar);
matvar = Mat_VarCreate("PRN", MAT_C_INT32, MAT_T_INT32, 2, dims.data(), prn.data(), 0);
Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE
Mat_VarFree(matvar);
}
Mat_Close(matfp);
return 0;
}
@ -233,7 +381,6 @@ void glonass_l2_ca_telemetry_decoder_gs::set_channel(int32_t channel)
{
try
{
d_dump_filename = "telemetry";
d_dump_filename.append(std::to_string(d_channel));
d_dump_filename.append(".dat");
d_dump_file.exceptions(std::ifstream::failbit | std::ifstream::badbit);
@ -413,12 +560,17 @@ int glonass_l2_ca_telemetry_decoder_gs::general_work(int noutput_items __attribu
{
double tmp_double;
uint64_t tmp_ulong_int;
int32_t tmp_int;
tmp_double = d_TOW_at_current_symbol;
d_dump_file.write(reinterpret_cast<char *>(&tmp_double), sizeof(double));
tmp_ulong_int = current_symbol.Tracking_sample_counter;
d_dump_file.write(reinterpret_cast<char *>(&tmp_ulong_int), sizeof(uint64_t));
tmp_double = 0;
d_dump_file.write(reinterpret_cast<char *>(&tmp_double), sizeof(double));
tmp_int = (current_symbol.Prompt_I > 0.0 ? 1 : -1);
d_dump_file.write(reinterpret_cast<char *>(&tmp_int), sizeof(int32_t));
tmp_int = static_cast<int32_t>(current_symbol.PRN);
d_dump_file.write(reinterpret_cast<char *>(&tmp_int), sizeof(int32_t));
}
catch (const std::ifstream::failure &e)
{

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

@ -26,6 +26,7 @@
#include "gnss_block_interface.h"
#include "gnss_satellite.h"
#include "gnss_synchro.h"
#include "tlm_conf.h"
#include <boost/circular_buffer.hpp>
#include <gnuradio/block.h>
#include <gnuradio/types.h> // for gr_vector_const_void_star
@ -46,7 +47,7 @@ using glonass_l2_ca_telemetry_decoder_gs_sptr = gnss_shared_ptr<glonass_l2_ca_te
glonass_l2_ca_telemetry_decoder_gs_sptr glonass_l2_ca_make_telemetry_decoder_gs(
const Gnss_Satellite &satellite,
bool dump);
const Tlm_Conf &conf);
/*!
* \brief This class implements a block that decodes the GNAV data defined in GLONASS ICD v5.1
@ -72,14 +73,16 @@ public:
private:
friend glonass_l2_ca_telemetry_decoder_gs_sptr glonass_l2_ca_make_telemetry_decoder_gs(
const Gnss_Satellite &satellite,
bool dump);
const Tlm_Conf &conf);
glonass_l2_ca_telemetry_decoder_gs(const Gnss_Satellite &satellite, bool dump);
glonass_l2_ca_telemetry_decoder_gs(const Gnss_Satellite &satellite, const Tlm_Conf &conf);
const std::array<uint16_t, GLONASS_GNAV_PREAMBLE_LENGTH_BITS> d_preambles_bits{GLONASS_GNAV_PREAMBLE};
const int32_t d_symbols_per_preamble = GLONASS_GNAV_PREAMBLE_LENGTH_SYMBOLS;
int32_t save_matfile() const;
void decode_string(const double *symbols, int32_t frame_length);
// Storage for incoming data
@ -112,6 +115,7 @@ private:
bool d_flag_preamble; // Flag indicating when preamble was found
bool flag_TOW_set; // Indicates when time of week is set
bool d_dump;
bool d_dump_mat;
};

164
src/algorithms/telemetry_decoder/gnuradio_blocks/gps_l1_ca_telemetry_decoder_gs.cc
View File

@ -24,14 +24,37 @@
#include "gps_utc_model.h" // for Gps_Utc_Model
#include <glog/logging.h>
#include <gnuradio/io_signature.h>
#include <matio.h> // for Mat_VarCreate
#include <pmt/pmt.h> // for make_any
#include <pmt/pmt_sugar.h> // for mp
#include <cmath> // for round
#include <cstddef> // for size_t
#include <cstring> // for memcpy
#include <exception> // for exception
#include <iostream> // for cout
#include <memory> // for shared_ptr
#include <vector>
// clang-format off
#if HAS_STD_FILESYSTEM
#include <system_error>
namespace errorlib = std;
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#include <filesystem>
namespace fs = std::filesystem;
#endif
#else
#include <boost/filesystem/operations.hpp> // for remove
#include <boost/filesystem/path.hpp> // for path, operator<<
#include <boost/filesystem/path_traits.hpp> // for filesystem
#include <boost/system/error_code.hpp> // for error_code
namespace fs = boost::filesystem;
namespace errorlib = boost::system;
#endif
// clang-format on
#ifdef COMPILER_HAS_ROTL
#include <bit>
@ -49,16 +72,16 @@ auto rotl = [](uint32_t x, uint32_t n) { return (((x) << (n)) ^ ((x) >> (32 - (n
gps_l1_ca_telemetry_decoder_gs_sptr
gps_l1_ca_make_telemetry_decoder_gs(const Gnss_Satellite &satellite, bool dump)
gps_l1_ca_make_telemetry_decoder_gs(const Gnss_Satellite &satellite, const Tlm_Conf &conf)
{
return gps_l1_ca_telemetry_decoder_gs_sptr(new gps_l1_ca_telemetry_decoder_gs(satellite, dump));
return gps_l1_ca_telemetry_decoder_gs_sptr(new gps_l1_ca_telemetry_decoder_gs(satellite, conf));
}
gps_l1_ca_telemetry_decoder_gs::gps_l1_ca_telemetry_decoder_gs(
const Gnss_Satellite &satellite,
bool dump) : gr::block("gps_navigation_gs", gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
const Tlm_Conf &conf) : gr::block("gps_navigation_gs", gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
{
// prevent telemetry symbols accumulation in output buffers
this->set_max_noutput_items(1);
@ -71,7 +94,10 @@ gps_l1_ca_telemetry_decoder_gs::gps_l1_ca_telemetry_decoder_gs(
d_sent_tlm_failed_msg = false;
// initialize internal vars
d_dump = dump;
d_dump_filename = conf.dump_filename;
d_dump = conf.dump;
d_dump_mat = conf.dump_mat;
d_satellite = Gnss_Satellite(satellite.get_system(), satellite.get_PRN());
DLOG(INFO) << "Initializing GPS L1 TELEMETRY DECODER";
@ -119,8 +145,10 @@ gps_l1_ca_telemetry_decoder_gs::gps_l1_ca_telemetry_decoder_gs(
gps_l1_ca_telemetry_decoder_gs::~gps_l1_ca_telemetry_decoder_gs()
{
DLOG(INFO) << "GPS L1 C/A Telemetry decoder block (channel " << d_channel << ") destructor called.";
size_t pos = 0;
if (d_dump_file.is_open() == true)
{
pos = d_dump_file.tellp();
try
{
d_dump_file.close();
@ -129,7 +157,127 @@ gps_l1_ca_telemetry_decoder_gs::~gps_l1_ca_telemetry_decoder_gs()
{
LOG(WARNING) << "Exception in destructor closing the dump file " << ex.what();
}
if (pos == 0)
{
errorlib::error_code ec;
if (!fs::remove(fs::path(d_dump_filename), ec))
{
LOG(WARNING) << "Error deleting temporary file";
}
}
}
if (d_dump && (pos != 0) && d_dump_mat)
{
try
{
save_matfile();
}
catch (const std::exception &ex)
{
LOG(WARNING) << "Error saving the .mat file: " << ex.what();
}
}
}
int32_t gps_l1_ca_telemetry_decoder_gs::save_matfile() const
{
std::ifstream::pos_type size;
const int32_t number_of_double_vars = 2;
const int32_t number_of_int_vars = 2;
const int32_t epoch_size_bytes = sizeof(uint64_t) + sizeof(double) * number_of_double_vars +
sizeof(int32_t) * number_of_int_vars;
std::ifstream dump_file;
std::string dump_filename_ = d_dump_filename;
std::cout << "Generating .mat file for " << dump_filename_ << '\n';
dump_file.exceptions(std::ifstream::failbit | std::ifstream::badbit);
try
{
dump_file.open(dump_filename_.c_str(), std::ios::binary | std::ios::ate);
}
catch (const std::ifstream::failure &e)
{
std::cerr << "Problem opening dump file:" << e.what() << '\n';
return 1;
}
// count number of epochs and rewind
int64_t num_epoch = 0;
if (dump_file.is_open())
{
size = dump_file.tellg();
num_epoch = static_cast<int64_t>(size) / static_cast<int64_t>(epoch_size_bytes);
if (num_epoch == 0LL)
{
// empty file, exit
return 1;
}
dump_file.seekg(0, std::ios::beg);
}
else
{
return 1;
}
auto TOW_at_current_symbol_ms = std::vector<double>(num_epoch);
auto tracking_sample_counter = std::vector<uint64_t>(num_epoch);
auto TOW_at_Preamble_ms = std::vector<double>(num_epoch);
auto nav_symbol = std::vector<int32_t>(num_epoch);
auto prn = std::vector<int32_t>(num_epoch);
try
{
if (dump_file.is_open())
{
for (int64_t i = 0; i < num_epoch; i++)
{
dump_file.read(reinterpret_cast<char *>(&TOW_at_current_symbol_ms[i]), sizeof(double));
dump_file.read(reinterpret_cast<char *>(&tracking_sample_counter[i]), sizeof(uint64_t));
dump_file.read(reinterpret_cast<char *>(&TOW_at_Preamble_ms[i]), sizeof(double));
dump_file.read(reinterpret_cast<char *>(&nav_symbol[i]), sizeof(int32_t));
dump_file.read(reinterpret_cast<char *>(&prn[i]), sizeof(int32_t));
}
}
dump_file.close();
}
catch (const std::ifstream::failure &e)
{
std::cerr << "Problem reading dump file:" << e.what() << '\n';
return 1;
}
// WRITE MAT FILE
mat_t *matfp;
matvar_t *matvar;
std::string filename = dump_filename_;
filename.erase(filename.length() - 4, 4);
filename.append(".mat");
matfp = Mat_CreateVer(filename.c_str(), nullptr, MAT_FT_MAT73);
if (reinterpret_cast<int64_t *>(matfp) != nullptr)
{
std::array<size_t, 2> dims{1, static_cast<size_t>(num_epoch)};
matvar = Mat_VarCreate("TOW_at_current_symbol_ms", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims.data(), TOW_at_current_symbol_ms.data(), 0);
Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE
Mat_VarFree(matvar);
matvar = Mat_VarCreate("tracking_sample_counter", MAT_C_UINT64, MAT_T_UINT64, 2, dims.data(), tracking_sample_counter.data(), 0);
Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE
Mat_VarFree(matvar);
matvar = Mat_VarCreate("TOW_at_Preamble_ms", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims.data(), TOW_at_Preamble_ms.data(), 0);
Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE
Mat_VarFree(matvar);
matvar = Mat_VarCreate("nav_symbol", MAT_C_INT32, MAT_T_INT32, 2, dims.data(), nav_symbol.data(), 0);
Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE
Mat_VarFree(matvar);
matvar = Mat_VarCreate("PRN", MAT_C_INT32, MAT_T_INT32, 2, dims.data(), prn.data(), 0);
Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE
Mat_VarFree(matvar);
}
Mat_Close(matfp);
return 0;
}
@ -181,7 +329,6 @@ void gps_l1_ca_telemetry_decoder_gs::set_channel(int32_t channel)
{
try
{
d_dump_filename = "telemetry";
d_dump_filename.append(std::to_string(d_channel));
d_dump_filename.append(".dat");
d_dump_file.exceptions(std::ifstream::failbit | std::ifstream::badbit);
@ -501,12 +648,17 @@ int gps_l1_ca_telemetry_decoder_gs::general_work(int noutput_items __attribute__
{
double tmp_double;
uint64_t tmp_ulong_int;
int32_t tmp_int;
tmp_double = static_cast<double>(d_TOW_at_current_symbol_ms) / 1000.0;
d_dump_file.write(reinterpret_cast<char *>(&tmp_double), sizeof(double));
tmp_ulong_int = current_symbol.Tracking_sample_counter;
d_dump_file.write(reinterpret_cast<char *>(&tmp_ulong_int), sizeof(uint64_t));
tmp_double = static_cast<double>(d_TOW_at_Preamble_ms) / 1000.0;
d_dump_file.write(reinterpret_cast<char *>(&tmp_double), sizeof(double));
tmp_int = (current_symbol.Prompt_I > 0.0 ? 1 : -1);
d_dump_file.write(reinterpret_cast<char *>(&tmp_int), sizeof(int32_t));
tmp_int = static_cast<int32_t>(current_symbol.PRN);
d_dump_file.write(reinterpret_cast<char *>(&tmp_int), sizeof(int32_t));
}
catch (const std::ifstream::failure &e)
{

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

@ -25,6 +25,7 @@
#include "gnss_satellite.h"
#include "gnss_synchro.h"
#include "gps_navigation_message.h"
#include "tlm_conf.h"
#include <boost/circular_buffer.hpp>
#include <gnuradio/block.h> // for block
#include <gnuradio/types.h> // for gr_vector_const_void_star
@ -46,7 +47,7 @@ using gps_l1_ca_telemetry_decoder_gs_sptr = gnss_shared_ptr<gps_l1_ca_telemetry_
gps_l1_ca_telemetry_decoder_gs_sptr gps_l1_ca_make_telemetry_decoder_gs(
const Gnss_Satellite &satellite,
bool dump);
const Tlm_Conf &conf);
/*!
* \brief This class implements a block that decodes the NAV data defined in IS-GPS-200K
@ -68,9 +69,11 @@ public:
private:
friend gps_l1_ca_telemetry_decoder_gs_sptr gps_l1_ca_make_telemetry_decoder_gs(
const Gnss_Satellite &satellite,
bool dump);
const Tlm_Conf &conf);
gps_l1_ca_telemetry_decoder_gs(const Gnss_Satellite &satellite, bool dump);
gps_l1_ca_telemetry_decoder_gs(const Gnss_Satellite &satellite, const Tlm_Conf &conf);
int32_t save_matfile() const;
bool gps_word_parityCheck(uint32_t gpsword);
bool decode_subframe();
@ -110,6 +113,7 @@ private:
bool d_flag_PLL_180_deg_phase_locked;
bool d_flag_TOW_set;
bool d_dump;
bool d_dump_mat;
};

166
src/algorithms/telemetry_decoder/gnuradio_blocks/gps_l2c_telemetry_decoder_gs.cc
View File

@ -27,26 +27,50 @@
#include "gps_cnav_utc_model.h" // for Gps_CNAV_Utc_Model
#include <glog/logging.h>
#include <gnuradio/io_signature.h>
#include <matio.h> // for Mat_VarCreate
#include <pmt/pmt.h> // for make_any
#include <pmt/pmt_sugar.h> // for mp
#include <bitset> // for bitset
#include <cmath> // for round
#include <cstddef> // for size_t
#include <exception> // for exception
#include <iostream> // for cout
#include <memory> // for shared_ptr, make_shared
#include <vector>
// clang-format off
#if HAS_STD_FILESYSTEM
#include <system_error>
namespace errorlib = std;
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#include <filesystem>
namespace fs = std::filesystem;
#endif
#else
#include <boost/filesystem/operations.hpp> // for remove
#include <boost/filesystem/path.hpp> // for path, operator<<
#include <boost/filesystem/path_traits.hpp> // for filesystem
#include <boost/system/error_code.hpp> // for error_code
namespace fs = boost::filesystem;
namespace errorlib = boost::system;
#endif
// clang-format on
gps_l2c_telemetry_decoder_gs_sptr
gps_l2c_make_telemetry_decoder_gs(const Gnss_Satellite &satellite, bool dump)
gps_l2c_make_telemetry_decoder_gs(const Gnss_Satellite &satellite, const Tlm_Conf &conf)
{
return gps_l2c_telemetry_decoder_gs_sptr(new gps_l2c_telemetry_decoder_gs(satellite, dump));
return gps_l2c_telemetry_decoder_gs_sptr(new gps_l2c_telemetry_decoder_gs(satellite, conf));
}
gps_l2c_telemetry_decoder_gs::gps_l2c_telemetry_decoder_gs(
const Gnss_Satellite &satellite, bool dump) : gr::block("gps_l2c_telemetry_decoder_gs",
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
const Gnss_Satellite &satellite,
const Tlm_Conf &conf) : gr::block("gps_l2c_telemetry_decoder_gs",
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
{
// prevent telemetry symbols accumulation in output buffers
this->set_max_noutput_items(1);
@ -59,7 +83,9 @@ gps_l2c_telemetry_decoder_gs::gps_l2c_telemetry_decoder_gs(
d_max_symbols_without_valid_frame = GPS_L2_CNAV_DATA_PAGE_BITS * GPS_L2_SYMBOLS_PER_BIT * 5; // rise alarm if 5 consecutive subframes have no valid CRC
// initialize internal vars
d_dump = dump;
d_dump_filename = conf.dump_filename;
d_dump = conf.dump;
d_dump_mat = conf.dump_mat;
d_satellite = Gnss_Satellite(satellite.get_system(), satellite.get_PRN());
DLOG(INFO) << "GPS L2C M TELEMETRY PROCESSING: satellite " << d_satellite;
// set_output_multiple (1);
@ -81,8 +107,10 @@ gps_l2c_telemetry_decoder_gs::gps_l2c_telemetry_decoder_gs(
gps_l2c_telemetry_decoder_gs::~gps_l2c_telemetry_decoder_gs()
{
DLOG(INFO) << "GPS L2C Telemetry decoder block (channel " << d_channel << ") destructor called.";
size_t pos = 0;
if (d_dump_file.is_open() == true)
{
pos = d_dump_file.tellp();
try
{
d_dump_file.close();
@ -91,7 +119,127 @@ gps_l2c_telemetry_decoder_gs::~gps_l2c_telemetry_decoder_gs()
{
LOG(WARNING) << "Exception in destructor closing the dump file " << ex.what();
}
if (pos == 0)
{
errorlib::error_code ec;
if (!fs::remove(fs::path(d_dump_filename), ec))
{
LOG(WARNING) << "Error deleting temporary file";
}
}
}
if (d_dump && (pos != 0) && d_dump_mat)
{
try
{
save_matfile();
}
catch (const std::exception &ex)
{
LOG(WARNING) << "Error saving the .mat file: " << ex.what();
}
}
}
int32_t gps_l2c_telemetry_decoder_gs::save_matfile() const
{
std::ifstream::pos_type size;
const int32_t number_of_double_vars = 2;
const int32_t number_of_int_vars = 2;
const int32_t epoch_size_bytes = sizeof(uint64_t) + sizeof(double) * number_of_double_vars +
sizeof(int32_t) * number_of_int_vars;
std::ifstream dump_file;
std::string dump_filename_ = d_dump_filename;
std::cout << "Generating .mat file for " << dump_filename_ << '\n';
dump_file.exceptions(std::ifstream::failbit | std::ifstream::badbit);
try
{
dump_file.open(dump_filename_.c_str(), std::ios::binary | std::ios::ate);
}
catch (const std::ifstream::failure &e)
{
std::cerr << "Problem opening dump file:" << e.what() << '\n';
return 1;
}
// count number of epochs and rewind
int64_t num_epoch = 0;
if (dump_file.is_open())
{
size = dump_file.tellg();
num_epoch = static_cast<int64_t>(size) / static_cast<int64_t>(epoch_size_bytes);
if (num_epoch == 0LL)
{
// empty file, exit
return 1;
}
dump_file.seekg(0, std::ios::beg);
}
else
{
return 1;
}
auto TOW_at_current_symbol_ms = std::vector<double>(num_epoch);
auto tracking_sample_counter = std::vector<uint64_t>(num_epoch);
auto TOW_at_Preamble_ms = std::vector<double>(num_epoch);
auto nav_symbol = std::vector<int32_t>(num_epoch);
auto prn = std::vector<int32_t>(num_epoch);
try
{
if (dump_file.is_open())
{
for (int64_t i = 0; i < num_epoch; i++)
{
dump_file.read(reinterpret_cast<char *>(&TOW_at_current_symbol_ms[i]), sizeof(double));
dump_file.read(reinterpret_cast<char *>(&tracking_sample_counter[i]), sizeof(uint64_t));
dump_file.read(reinterpret_cast<char *>(&TOW_at_Preamble_ms[i]), sizeof(double));
dump_file.read(reinterpret_cast<char *>(&nav_symbol[i]), sizeof(int32_t));
dump_file.read(reinterpret_cast<char *>(&prn[i]), sizeof(int32_t));
}
}
dump_file.close();
}
catch (const std::ifstream::failure &e)
{
std::cerr << "Problem reading dump file:" << e.what() << '\n';
return 1;
}
// WRITE MAT FILE
mat_t *matfp;
matvar_t *matvar;
std::string filename = dump_filename_;
filename.erase(filename.length() - 4, 4);
filename.append(".mat");
matfp = Mat_CreateVer(filename.c_str(), nullptr, MAT_FT_MAT73);
if (reinterpret_cast<int64_t *>(matfp) != nullptr)
{
std::array<size_t, 2> dims{1, static_cast<size_t>(num_epoch)};
matvar = Mat_VarCreate("TOW_at_current_symbol_ms", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims.data(), TOW_at_current_symbol_ms.data(), 0);
Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE
Mat_VarFree(matvar);
matvar = Mat_VarCreate("tracking_sample_counter", MAT_C_UINT64, MAT_T_UINT64, 2, dims.data(), tracking_sample_counter.data(), 0);
Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE
Mat_VarFree(matvar);
matvar = Mat_VarCreate("TOW_at_Preamble_ms", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims.data(), TOW_at_Preamble_ms.data(), 0);
Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE
Mat_VarFree(matvar);
matvar = Mat_VarCreate("nav_symbol", MAT_C_INT32, MAT_T_INT32, 2, dims.data(), nav_symbol.data(), 0);
Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE
Mat_VarFree(matvar);
matvar = Mat_VarCreate("PRN", MAT_C_INT32, MAT_T_INT32, 2, dims.data(), prn.data(), 0);
Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE
Mat_VarFree(matvar);
}
Mat_Close(matfp);
return 0;
}
@ -113,7 +261,6 @@ void gps_l2c_telemetry_decoder_gs::set_channel(int channel)
{
try
{
d_dump_filename = "telemetry_L2CM_";
d_dump_filename.append(std::to_string(d_channel));
d_dump_filename.append(".dat");
d_dump_file.exceptions(std::ifstream::failbit | std::ifstream::badbit);
@ -252,12 +399,17 @@ int gps_l2c_telemetry_decoder_gs::general_work(int noutput_items __attribute__((
{
double tmp_double;
uint64_t tmp_ulong_int;
int32_t tmp_int;
tmp_double = d_TOW_at_current_symbol;
d_dump_file.write(reinterpret_cast<char *>(&tmp_double), sizeof(double));
tmp_ulong_int = current_synchro_data.Tracking_sample_counter;
d_dump_file.write(reinterpret_cast<char *>(&tmp_ulong_int), sizeof(uint64_t));
tmp_double = d_TOW_at_Preamble;
d_dump_file.write(reinterpret_cast<char *>(&tmp_double), sizeof(double));
tmp_int = (current_synchro_data.Prompt_I > 0.0 ? 1 : -1);
d_dump_file.write(reinterpret_cast<char *>(&tmp_int), sizeof(int32_t));
tmp_int = static_cast<int32_t>(current_synchro_data.PRN);
d_dump_file.write(reinterpret_cast<char *>(&tmp_int), sizeof(int32_t));
}
catch (const std::ifstream::failure &e)
{

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

@ -23,6 +23,7 @@
#include "gnss_block_interface.h"
#include "gnss_satellite.h"
#include "gps_cnav_navigation_message.h"
#include "tlm_conf.h"
#include <gnuradio/block.h>
#include <gnuradio/types.h> // for gr_vector_const_void_star
#include <cstdint>
@ -46,7 +47,7 @@ using gps_l2c_telemetry_decoder_gs_sptr = gnss_shared_ptr<gps_l2c_telemetry_deco
gps_l2c_telemetry_decoder_gs_sptr gps_l2c_make_telemetry_decoder_gs(
const Gnss_Satellite &satellite,
bool dump);
const Tlm_Conf &conf);
/*!
* \brief This class implements a block that decodes CNAV data defined in IS-GPS-200K
@ -68,9 +69,11 @@ public:
private:
friend gps_l2c_telemetry_decoder_gs_sptr gps_l2c_make_telemetry_decoder_gs(
const Gnss_Satellite &satellite,
bool dump);
const Tlm_Conf &conf);
gps_l2c_telemetry_decoder_gs(const Gnss_Satellite &satellite, bool dump);
gps_l2c_telemetry_decoder_gs(const Gnss_Satellite &satellite, const Tlm_Conf &conf);
int32_t save_matfile() const;
Gnss_Satellite d_satellite;
@ -97,6 +100,7 @@ private:
bool d_sent_tlm_failed_msg;
bool d_flag_PLL_180_deg_phase_locked;
bool d_flag_valid_word;
bool d_dump_mat;
};

166
src/algorithms/telemetry_decoder/gnuradio_blocks/gps_l5_telemetry_decoder_gs.cc
View File

@ -26,26 +26,50 @@
#include "gps_cnav_utc_model.h" // for Gps_CNAV_Utc_Model
#include <glog/logging.h>
#include <gnuradio/io_signature.h>
#include <matio.h> // for Mat_VarCreate
#include <pmt/pmt.h> // for make_any
#include <pmt/pmt_sugar.h> // for mp
#include <bitset> // for std::bitset
#include <cstddef> // for size_t
#include <cstdlib> // for std::llabs
#include <exception> // for std::exception
#include <iostream> // for std::cout
#include <memory> // for shared_ptr, make_shared
#include <vector>
// clang-format off
#if HAS_STD_FILESYSTEM
#include <system_error>
namespace errorlib = std;
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
namespace fs = std::experimental::filesystem;
#else
#include <filesystem>
namespace fs = std::filesystem;
#endif
#else
#include <boost/filesystem/operations.hpp> // for remove
#include <boost/filesystem/path.hpp> // for path, operator<<
#include <boost/filesystem/path_traits.hpp> // for filesystem
#include <boost/system/error_code.hpp> // for error_code
namespace fs = boost::filesystem;
namespace errorlib = boost::system;
#endif
// clang-format on
gps_l5_telemetry_decoder_gs_sptr
gps_l5_make_telemetry_decoder_gs(const Gnss_Satellite &satellite, bool dump)
gps_l5_make_telemetry_decoder_gs(const Gnss_Satellite &satellite, const Tlm_Conf &conf)
{
return gps_l5_telemetry_decoder_gs_sptr(new gps_l5_telemetry_decoder_gs(satellite, dump));
return gps_l5_telemetry_decoder_gs_sptr(new gps_l5_telemetry_decoder_gs(satellite, conf));
}
gps_l5_telemetry_decoder_gs::gps_l5_telemetry_decoder_gs(
const Gnss_Satellite &satellite, bool dump) : gr::block("gps_l5_telemetry_decoder_gs",
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
const Gnss_Satellite &satellite,
const Tlm_Conf &conf) : gr::block("gps_l5_telemetry_decoder_gs",
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)),
gr::io_signature::make(1, 1, sizeof(Gnss_Synchro)))
{
// prevent telemetry symbols accumulation in output buffers
this->set_max_noutput_items(1);
@ -58,7 +82,9 @@ gps_l5_telemetry_decoder_gs::gps_l5_telemetry_decoder_gs(
d_max_symbols_without_valid_frame = GPS_L5_CNAV_DATA_PAGE_BITS * GPS_L5_SYMBOLS_PER_BIT * 10; // rise alarm if 20 consecutive subframes have no valid CRC
// initialize internal vars
d_dump = dump;
d_dump_filename = conf.dump_filename;
d_dump = conf.dump;
d_dump_mat = conf.dump_mat;
d_satellite = Gnss_Satellite(satellite.get_system(), satellite.get_PRN());
DLOG(INFO) << "GPS L5 TELEMETRY PROCESSING: satellite " << d_satellite;
d_channel = 0;
@ -76,8 +102,10 @@ gps_l5_telemetry_decoder_gs::gps_l5_telemetry_decoder_gs(
gps_l5_telemetry_decoder_gs::~gps_l5_telemetry_decoder_gs()
{
DLOG(INFO) << "GPS L5 Telemetry decoder block (channel " << d_channel << ") destructor called.";
size_t pos = 0;
if (d_dump_file.is_open() == true)
{
pos = d_dump_file.tellp();
try
{
d_dump_file.close();
@ -86,7 +114,127 @@ gps_l5_telemetry_decoder_gs::~gps_l5_telemetry_decoder_gs()
{
LOG(WARNING) << "Exception in destructor closing the dump file " << ex.what();
}
if (pos == 0)
{
errorlib::error_code ec;
if (!fs::remove(fs::path(d_dump_filename), ec))
{
LOG(WARNING) << "Error deleting temporary file";
}
}
}
if (d_dump && (pos != 0) && d_dump_mat)
{
try
{
save_matfile();
}
catch (const std::exception &ex)
{
LOG(WARNING) << "Error saving the .mat file: " << ex.what();
}
}
}
int32_t gps_l5_telemetry_decoder_gs::save_matfile() const
{
std::ifstream::pos_type size;
const int32_t number_of_double_vars = 2;
const int32_t number_of_int_vars = 2;
const int32_t epoch_size_bytes = sizeof(uint64_t) + sizeof(double) * number_of_double_vars +
sizeof(int32_t) * number_of_int_vars;
std::ifstream dump_file;
std::string dump_filename_ = d_dump_filename;
std::cout << "Generating .mat file for " << dump_filename_ << '\n';
dump_file.exceptions(std::ifstream::failbit | std::ifstream::badbit);
try
{
dump_file.open(dump_filename_.c_str(), std::ios::binary | std::ios::ate);
}
catch (const std::ifstream::failure &e)
{
std::cerr << "Problem opening dump file:" << e.what() << '\n';
return 1;
}
// count number of epochs and rewind
int64_t num_epoch = 0;
if (dump_file.is_open())
{
size = dump_file.tellg();
num_epoch = static_cast<int64_t>(size) / static_cast<int64_t>(epoch_size_bytes);
if (num_epoch == 0LL)
{
// empty file, exit
return 1;
}
dump_file.seekg(0, std::ios::beg);
}
else
{
return 1;
}
auto TOW_at_current_symbol_ms = std::vector<double>(num_epoch);
auto tracking_sample_counter = std::vector<uint64_t>(num_epoch);
auto TOW_at_Preamble_ms = std::vector<double>(num_epoch);
auto nav_symbol = std::vector<int32_t>(num_epoch);
auto prn = std::vector<int32_t>(num_epoch);
try
{
if (dump_file.is_open())
{
for (int64_t i = 0; i < num_epoch; i++)
{
dump_file.read(reinterpret_cast<char *>(&TOW_at_current_symbol_ms[i]), sizeof(double));
dump_file.read(reinterpret_cast<char *>(&tracking_sample_counter[i]), sizeof(uint64_t));
dump_file.read(reinterpret_cast<char *>(&TOW_at_Preamble_ms[i]), sizeof(double));
dump_file.read(reinterpret_cast<char *>(&nav_symbol[i]), sizeof(int32_t));
dump_file.read(reinterpret_cast<char *>(&prn[i]), sizeof(int32_t));
}
}
dump_file.close();
}
catch (const std::ifstream::failure &e)
{
std::cerr << "Problem reading dump file:" << e.what() << '\n';
return 1;
}
// WRITE MAT FILE
mat_t *matfp;
matvar_t *matvar;
std::string filename = dump_filename_;
filename.erase(filename.length() - 4, 4);
filename.append(".mat");
matfp = Mat_CreateVer(filename.c_str(), nullptr, MAT_FT_MAT73);
if (reinterpret_cast<int64_t *>(matfp) != nullptr)
{
std::array<size_t, 2> dims{1, static_cast<size_t>(num_epoch)};
matvar = Mat_VarCreate("TOW_at_current_symbol_ms", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims.data(), TOW_at_current_symbol_ms.data(), 0);
Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE
Mat_VarFree(matvar);
matvar = Mat_VarCreate("tracking_sample_counter", MAT_C_UINT64, MAT_T_UINT64, 2, dims.data(), tracking_sample_counter.data(), 0);
Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE
Mat_VarFree(matvar);
matvar = Mat_VarCreate("TOW_at_Preamble_ms", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims.data(), TOW_at_Preamble_ms.data(), 0);
Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE
Mat_VarFree(matvar);
matvar = Mat_VarCreate("nav_symbol", MAT_C_INT32, MAT_T_INT32, 2, dims.data(), nav_symbol.data(), 0);
Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE
Mat_VarFree(matvar);
matvar = Mat_VarCreate("PRN", MAT_C_INT32, MAT_T_INT32, 2, dims.data(), prn.data(), 0);
Mat_VarWrite(matfp, matvar, MAT_COMPRESSION_ZLIB); // or MAT_COMPRESSION_NONE
Mat_VarFree(matvar);
}
Mat_Close(matfp);
return 0;
}
@ -110,7 +258,6 @@ void gps_l5_telemetry_decoder_gs::set_channel(int32_t channel)
{
try
{
d_dump_filename = "telemetry_L5_";
d_dump_filename.append(std::to_string(d_channel));
d_dump_filename.append(".dat");
d_dump_file.exceptions(std::ifstream::failbit | std::ifstream::badbit);
@ -263,12 +410,17 @@ int gps_l5_telemetry_decoder_gs::general_work(int noutput_items __attribute__((u
{
double tmp_double;
uint64_t tmp_ulong_int;
int32_t tmp_int;
tmp_double = static_cast<double>(d_TOW_at_current_symbol_ms) / 1000.0;
d_dump_file.write(reinterpret_cast<char *>(&tmp_double), sizeof(double));
tmp_ulong_int = current_synchro_data.Tracking_sample_counter;
d_dump_file.write(reinterpret_cast<char *>(&tmp_ulong_int), sizeof(uint64_t));
tmp_double = static_cast<double>(d_TOW_at_Preamble_ms) / 1000.0;
d_dump_file.write(reinterpret_cast<char *>(&tmp_double), sizeof(double));
tmp_int = (current_synchro_data.Prompt_Q > 0.0 ? 1 : -1);
d_dump_file.write(reinterpret_cast<char *>(&tmp_int), sizeof(int32_t));
tmp_int = static_cast<int32_t>(current_synchro_data.PRN);
d_dump_file.write(reinterpret_cast<char *>(&tmp_int), sizeof(int32_t));
}
catch (const std::ifstream::failure &e)
{

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

@ -24,6 +24,7 @@
#include "gnss_block_interface.h"
#include "gnss_satellite.h" // for Gnss_Satellite
#include "gps_cnav_navigation_message.h" // for Gps_CNAV_Navigation_Message
#include "tlm_conf.h"
#include <boost/circular_buffer.hpp>
#include <gnuradio/block.h>
#include <gnuradio/types.h> // for gr_vector_const_void_star
@ -48,7 +49,7 @@ using gps_l5_telemetry_decoder_gs_sptr = gnss_shared_ptr<gps_l5_telemetry_decode
gps_l5_telemetry_decoder_gs_sptr gps_l5_make_telemetry_decoder_gs(
const Gnss_Satellite &satellite,
bool dump);
const Tlm_Conf &conf);
/*!
* \brief This class implements a GPS L5 Telemetry decoder
@ -67,9 +68,11 @@ public:
private:
friend gps_l5_telemetry_decoder_gs_sptr gps_l5_make_telemetry_decoder_gs(
const Gnss_Satellite &satellite,
bool dump);
const Tlm_Conf &conf);
gps_l5_telemetry_decoder_gs(const Gnss_Satellite &satellite, bool dump);
gps_l5_telemetry_decoder_gs(const Gnss_Satellite &satellite, const Tlm_Conf &conf);
int32_t save_matfile() const;
cnav_msg_decoder_t d_cnav_decoder{};
@ -93,6 +96,7 @@ private:
bool d_flag_valid_word;
bool d_sent_tlm_failed_msg;
bool d_dump;
bool d_dump_mat;
};

7
src/algorithms/telemetry_decoder/libs/CMakeLists.txt
View File

@ -11,10 +11,12 @@
add_subdirectory(libswiftcnav)
set(TELEMETRY_DECODER_LIB_SOURCES
tlm_conf.cc
viterbi_decoder.cc
)
set(TELEMETRY_DECODER_LIB_HEADERS
tlm_conf.h
viterbi_decoder.h
convolutional.h
)
@ -46,6 +48,11 @@ target_link_libraries(telemetry_decoder_libs
Glog::glog
)
target_include_directories(telemetry_decoder_libs
PUBLIC
${CMAKE_SOURCE_DIR}/src/core/interfaces
)
if(ENABLE_CLANG_TIDY)
if(CLANG_TIDY_EXE)
set_target_properties(telemetry_decoder_libs

37
src/algorithms/telemetry_decoder/libs/tlm_conf.cc Normal file
View File

@ -0,0 +1,37 @@
/*!
* \file tlm_conf.cc
* \brief Class that contains all the configuration parameters for generic
* telemetry decoder block.
* \author Carles Fernandez, 2020. cfernandez(at)cttc.es
*
* -----------------------------------------------------------------------------
*
* Copyright (C) 2010-2020 (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.
*
* SPDX-License-Identifier: GPL-3.0-or-later
*
* -----------------------------------------------------------------------------
*/
#include "tlm_conf.h"
Tlm_Conf::Tlm_Conf()
{
dump = false;
dump_mat = false;
}
void Tlm_Conf::SetFromConfiguration(const ConfigurationInterface *configuration,
const std::string &role)
{
const std::string default_dumpname("telemetry");
dump_filename = configuration->property(role + ".dump_filename", default_dumpname);
dump = configuration->property(role + ".dump", false);
dump_mat = configuration->property(role + ".dump_mat", dump);
}

48
src/algorithms/telemetry_decoder/libs/tlm_conf.h Normal file
View File

@ -0,0 +1,48 @@
/*!
* \file tlm_conf.h
* \brief Class that contains all the configuration parameters for generic
* telemetry decoder block.
* \author Carles Fernandez, 2020. cfernandez(at)cttc.es
*
* -----------------------------------------------------------------------------
*
* Copyright (C) 2010-2020 (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.
*
* SPDX-License-Identifier: GPL-3.0-or-later
*
* -----------------------------------------------------------------------------
*/
#ifndef GNSS_SDR_TLM_CONF_H
#define GNSS_SDR_TLM_CONF_H
#include "configuration_interface.h"
#include <string>
/** \addtogroup Telemetry_Decoder
* \{ */
/** \addtogroup Telemetry_Decoder_libs
* \{ */
class Tlm_Conf
{
public:
Tlm_Conf();
void SetFromConfiguration(const ConfigurationInterface *configuration, const std::string &role);
std::string dump_filename;
bool dump;
bool dump_mat;
};
/** \} */
/** \} */
#endif // GNSS_SDR_TLM_CONF_H

2
src/core/monitor/gnss_synchro_monitor.cc
View File

@ -56,7 +56,7 @@ gnss_synchro_monitor::gnss_synchro_monitor(int n_channels,
udp_sink_ptr = std::make_unique<Gnss_Synchro_Udp_Sink>(udp_addresses, udp_port, enable_protobuf);
}
void gnss_synchro_monitor::forecast(int noutput_items __attribute__((unused)), gr_vector_int &ninput_items_required)
void gnss_synchro_monitor::forecast(int noutput_items __attribute__((unused)), gr_vector_int& ninput_items_required)
{
for (int32_t channel_index = 0; channel_index < d_nchannels; channel_index++)
{

8
src/core/system_parameters/galileo_cnav_message.cc
View File

@ -213,9 +213,9 @@ void Galileo_Cnav_Message::read_MT1_body(const std::string& message_string)
std::string msg = message.substr(0, HAS_MSG_SATELLITE_MASK_LENGTH);
d_HAS_data.satellite_mask[i] = read_has_message_body_uint64(msg);
int ones_in_satellite_mask = 0;
for (size_t i = 0; i < msg.length(); i++)
for (char c : msg)
{
if (msg[i] == '1')
if (c == '1')
{
ones_in_satellite_mask++;
}
@ -226,9 +226,9 @@ void Galileo_Cnav_Message::read_MT1_body(const std::string& message_string)
msg = message.substr(0, HAS_MSG_SIGNAL_MASK_LENGTH);
d_HAS_data.signal_mask[i] = read_has_message_body_uint16(msg);
int ones_in_signal_mask = 0;
for (size_t i = 0; i < msg.length(); i++)
for (char c : msg)
{
if (msg[i] == '1')
if (c == '1')
{
ones_in_signal_mask++;
}

3
src/main/main.cc
View File

@ -49,6 +49,7 @@
#include <cuda_runtime.h>
#endif
// clang-format off
#if HAS_STD_FILESYSTEM
#include <system_error>
namespace errorlib = std;
@ -67,6 +68,8 @@ namespace fs = std::filesystem;
namespace fs = boost::filesystem;
namespace errorlib = boost::system;
#endif
// clang-format on
#if GFLAGS_OLD_NAMESPACE
namespace gflags
{

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

@ -24,6 +24,7 @@
#include <matio.h>
#include <array>
// clang-format off
#if HAS_STD_FILESYSTEM
#include <system_error>
namespace errorlib = std;
@ -42,6 +43,7 @@ namespace fs = std::filesystem;
namespace fs = boost::filesystem;
namespace errorlib = boost::system;
#endif
// clang-format on
TEST(MatioTest, WriteAndReadDoubles)
{

7
src/tests/unit-tests/signal-processing-blocks/libs/tlm_dump_reader.cc
View File

@ -29,6 +29,8 @@ bool Tlm_Dump_Reader::read_binary_obs()
d_dump_file.read(reinterpret_cast<char *>(&TOW_at_current_symbol), sizeof(double));
d_dump_file.read(reinterpret_cast<char *>(&Tracking_sample_counter), sizeof(uint64_t));
d_dump_file.read(reinterpret_cast<char *>(&d_TOW_at_Preamble), sizeof(double));
d_dump_file.read(reinterpret_cast<char *>(&nav_symbol), sizeof(int32_t));
d_dump_file.read(reinterpret_cast<char *>(&prn), sizeof(int32_t));
}
catch (const std::ifstream::failure &e)
{
@ -53,8 +55,9 @@ bool Tlm_Dump_Reader::restart()
int64_t Tlm_Dump_Reader::num_epochs()
{
std::ifstream::pos_type size;
int number_of_vars_in_epoch = 2;
int epoch_size_bytes = sizeof(double) * number_of_vars_in_epoch + sizeof(uint64_t);
int number_of_double_vars_in_epoch = 2;
int number_of_int_vars_in_epoch = 2;
int epoch_size_bytes = sizeof(double) * number_of_double_vars_in_epoch + sizeof(uint64_t) + sizeof(int32_t) * number_of_int_vars_in_epoch;
std::ifstream tmpfile(d_dump_filename.c_str(), std::ios::binary | std::ios::ate);
if (tmpfile.is_open())
{

2
src/tests/unit-tests/signal-processing-blocks/libs/tlm_dump_reader.h
View File

@ -38,6 +38,8 @@ public:
double TOW_at_current_symbol;
uint64_t Tracking_sample_counter;
double d_TOW_at_Preamble;
int32_t nav_symbol;
int32_t prn;
private:
std::string d_dump_filename;

2
src/tests/unit-tests/signal-processing-blocks/pvt/nmea_printer_test.cc
View File

@ -24,6 +24,7 @@
#include <fstream>
#include <string>
// clang-format off
#if HAS_STD_FILESYSTEM
#include <system_error>
namespace errorlib = std;
@ -42,6 +43,7 @@ namespace fs = std::filesystem;
namespace fs = boost::filesystem;
namespace errorlib = boost::system;
#endif
// clang-format on
class NmeaPrinterTest : public ::testing::Test
{

2
src/tests/unit-tests/signal-processing-blocks/pvt/rinex_printer_test.cc
View File

@ -23,6 +23,7 @@
#include <fstream>
#include <string>
// clang-format off
#if HAS_STD_FILESYSTEM
#include <system_error>
namespace errorlib = std;
@ -41,6 +42,7 @@ namespace fs = std::filesystem;
namespace fs = boost::filesystem;
namespace errorlib = boost::system;
#endif
// clang-format on
class RinexPrinterTest : public ::testing::Test
{

51
src/utils/matlab/libs/gps_l1_ca_read_telemetry_dump.m
View File

@ -21,9 +21,11 @@ function [telemetry] = gps_l1_ca_read_telemetry_dump (filename, count)
%%
m = nargchk (1,2,nargin);
num_double_vars=4;
num_double_vars=3;
double_size_bytes=8;
skip_bytes_each_read=double_size_bytes*num_double_vars;
num_int_vars=2;
int_size_bytes=4;
skip_bytes_each_read=double_size_bytes*num_double_vars+num_int_vars*int_size_bytes;
bytes_shift=0;
if (m)
usage (m);
@ -32,34 +34,27 @@ end
if (nargin < 3)
count = Inf;
end
%loops_counter = fread (f, count, 'uint32',4*12);
f = fopen (filename, 'rb');
if (f < 0)
else
telemetry.tow_current_symbol_ms = fread (f, count, 'float64',skip_bytes_each_read-double_size_bytes);
bytes_shift=bytes_shift+double_size_bytes;
fseek(f,bytes_shift,'bof'); % move to next interleaved
telemetry.tracking_sample_counter = fread (f, count, 'uint64',skip_bytes_each_read-double_size_bytes);
bytes_shift=bytes_shift+double_size_bytes;
fseek(f,bytes_shift,'bof'); % move to next interleaved
telemetry.tow = fread (f, count, 'float64',skip_bytes_each_read-double_size_bytes);
bytes_shift=bytes_shift+double_size_bytes;
fseek(f,bytes_shift,'bof'); % move to next interleaved
telemetry.required_symbols = fread (f, count, 'uint64',skip_bytes_each_read-double_size_bytes);
bytes_shift=bytes_shift+double_size_bytes;
fseek(f,bytes_shift,'bof'); % move to next interleaved
[x, loops_counter] = fread (f,skip_bytes_each_read);
fseek(f,0,-1);
for i=1:min(count, loops_counter),
telemetry(i).tow_current_symbol_ms = fread (f, count, 'float64',skip_bytes_each_read-double_size_bytes);
bytes_shift=bytes_shift+double_size_bytes;
fseek(f,bytes_shift,'bof'); % move to next interleaved
telemetry(i).tracking_sample_counter = fread (f, count, 'uint64',skip_bytes_each_read-double_size_bytes);
bytes_shift=bytes_shift+double_size_bytes;
fseek(f,bytes_shift,'bof'); % move to next interleaved
telemetry(i).tow = fread (f, count, 'float64',skip_bytes_each_read-double_size_bytes);
bytes_shift=bytes_shift+double_size_bytes;
fseek(f,bytes_shift,'bof'); % move to next interleaved
telemetry(i).nav_simbols = fread (f, count, 'int32',skip_bytes_each_read-int_size_bytes);
bytes_shift=bytes_shift+int_size_bytes;
fseek(f,bytes_shift,'bof'); % move to next interleaved
telemetry(i).prn = fread (f, count, 'int32',skip_bytes_each_read-int_size_bytes);
bytes_shift=bytes_shift+int_size_bytes;
fseek(f,bytes_shift,'bof'); % move to next interleaved
end
fclose (f);
%%%%%%%% output vars %%%%%%%%
% {
% double tmp_double;
% tmp_double = current_synchro_data.Preamble_delay_ms;
% d_dump_file.write((char*)&tmp_double, sizeof(double));
% tmp_double = current_synchro_data.Prn_delay_ms;
% d_dump_file.write((char*)&tmp_double, sizeof(double));
% tmp_double = current_synchro_data.Preamble_symbol_counter;
% d_dump_file.write((char*)&tmp_double, sizeof(double));
% }
end