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

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

Browse Source
This commit is contained in:
Javier Arribas 2021-01-22 17:34:46 +01:00
commit b1fee5c9bc
120 changed files with 552 additions and 1184 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

53
CMakeLists.txt
View File

@ -94,6 +94,8 @@ option(ENABLE_SYSTEM_TESTING_EXTRA "Download external tools and build extra syst
option(ENABLE_GNSS_SIM_INSTALL "Enable the installation of gnss_sim on the fly" ON)
option(ENABLE_OWN_CPUFEATURES "Force the building of the cpu_features library even if it is already installed" ON)
if(NOT (ENABLE_UNIT_TESTING_EXTRA OR ENABLE_SYSTEM_TESTING_EXTRA OR ENABLE_FPGA))
set(ENABLE_GNSS_SIM_INSTALL OFF)
endif()
@ -1102,11 +1104,17 @@ if(NOT VOLKGNSSSDR_FOUND)
set(VOLK_GNSSSDR_CMAKE_ARGS ${VOLK_GNSSSDR_COMPILER}
-DCMAKE_INSTALL_PREFIX=${CMAKE_BINARY_DIR}/volk_gnsssdr_module/install
-DENABLE_STATIC_LIBS=ON
-DENABLE_OWN_CPUFEATURES=${ENABLE_OWN_CPUFEATURES}
-DENABLE_PROFILING=${ENABLE_PROFILING}
-DENABLE_ORC=${ORC_ENABLED}
${STRIP_VOLK_GNSSSDR_PROFILE}
${USE_THIS_PYTHON}
)
if(CMAKE_VERSION VERSION_GREATER 3.18.99 AND CMAKE_GENERATOR STREQUAL Xcode)
if(XCODE_VERSION VERSION_GREATER 11)
set(VOLK_GNSSSDR_CMAKE_ARGS ${VOLK_GNSSSDR_CMAKE_ARGS} -T buildsystem=1)
endif()
endif()
if(DEFINED ENV{OECORE_TARGET_SYSROOT})
set(VOLK_GNSSSDR_CMAKE_ARGS ${VOLK_GNSSSDR_CMAKE_ARGS}
-DCROSSCOMPILE_MULTILIB=TRUE
@ -1156,6 +1164,33 @@ if(NOT VOLKGNSSSDR_FOUND)
)
else()
if(SUPPORTED_CPU_FEATURES_ARCH)
set(VOLK_GNSSSDR_BUILD_BYPRODUCTS
${CMAKE_BINARY_DIR}/volk_gnsssdr_module/install/lib${VOLK_GNSSSDR_LIB_SUFFIX}/${CMAKE_FIND_LIBRARY_PREFIXES}volk_gnsssdr${CMAKE_STATIC_LIBRARY_SUFFIX}
${CMAKE_BINARY_DIR}/volk_gnsssdr_module/install/bin/volk_gnsssdr_profile
)
if(NOT ENABLE_OWN_CPUFEATURES)
find_package(CpuFeatures QUIET)
set_package_properties(CpuFeatures PROPERTIES
URL "https://github.com/google/cpu_features"
PURPOSE "Used by the volk_gnsssdr library."
TYPE REQUIRED
)
endif()
if(CpuFeatures_FOUND)
message(STATUS "Found CpuFeatures: (found version ${CpuFeatures_VERSION})")
set_package_properties(CpuFeatures PROPERTIES
DESCRIPTION "A cross platform C99 library to get CPU features at runtime (found: v${CpuFeatures_VERSION})"
)
else()
set_package_properties(CpuFeatures PROPERTIES
DESCRIPTION "A cross platform C99 library to get CPU features at runtime"
PURPOSE "CpuFeatures will be built when doing '${CMAKE_MAKE_PROGRAM_PRETTY_NAME}'."
)
set(VOLK_GNSSSDR_BUILD_BYPRODUCTS
${VOLK_GNSSSDR_BUILD_BYPRODUCTS}
${CMAKE_BINARY_DIR}/volk_gnsssdr_module/install/${CMAKE_INSTALL_LIBDIR}/${CMAKE_FIND_LIBRARY_PREFIXES}cpu_features${CMAKE_STATIC_LIBRARY_SUFFIX}
)
endif()
ExternalProject_Add(volk_gnsssdr_module
PREFIX ${CMAKE_BINARY_DIR}/volk_gnsssdr_module
SOURCE_DIR ${CMAKE_SOURCE_DIR}/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr
@ -1167,9 +1202,7 @@ if(NOT VOLKGNSSSDR_FOUND)
UPDATE_COMMAND ""
PATCH_COMMAND ""
BUILD_COMMAND ${VOLK_GNSSSDR_BUILD_COMMAND} volk_gnsssdr_profile
BUILD_BYPRODUCTS ${CMAKE_BINARY_DIR}/volk_gnsssdr_module/install/lib${VOLK_GNSSSDR_LIB_SUFFIX}/${CMAKE_FIND_LIBRARY_PREFIXES}volk_gnsssdr${CMAKE_STATIC_LIBRARY_SUFFIX}
${CMAKE_BINARY_DIR}/volk_gnsssdr_module/install/bin/volk_gnsssdr_profile
${CMAKE_BINARY_DIR}/volk_gnsssdr_module/install/${CMAKE_INSTALL_LIBDIR}/${CMAKE_FIND_LIBRARY_PREFIXES}cpu_features${CMAKE_STATIC_LIBRARY_SUFFIX}
BUILD_BYPRODUCTS ${VOLK_GNSSSDR_BUILD_BYPRODUCTS}
INSTALL_DIR ${CMAKE_BINARY_DIR}/volk_gnsssdr_module/install
)
else()
@ -1200,6 +1233,9 @@ if(NOT VOLKGNSSSDR_FOUND)
set_property(TARGET volk_gnsssdr PROPERTY IMPORTED_LOCATION ${CMAKE_BINARY_DIR}/volk_gnsssdr_module/install/lib${VOLK_GNSSSDR_LIB_SUFFIX}/libvolk_gnsssdr${CMAKE_STATIC_LIBRARY_SUFFIX})
set(VOLK_GNSSSDR_INCLUDE_DIRS "${CMAKE_BINARY_DIR}/volk_gnsssdr_module/build/include/;${CMAKE_SOURCE_DIR}/src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/include;${ORC_INCLUDE_DIRS}")
set(VOLK_GNSSSDR_LIBRARIES volk_gnsssdr ${ORC_LIBRARIES_STATIC})
if(CpuFeatures_FOUND)
set(VOLK_GNSSSDR_LIBRARIES ${VOLK_GNSSSDR_LIBRARIES} CpuFeatures::cpu_features)
endif()
if(NOT TARGET Volkgnsssdr::volkgnsssdr)
file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/volk_gnsssdr_module/build/include)
@ -1213,9 +1249,11 @@ if(NOT VOLKGNSSSDR_FOUND)
INTERFACE_LINK_LIBRARIES "${VOLK_GNSSSDR_LIBRARIES}"
)
if(CMAKE_VERSION VERSION_GREATER 3.0 AND SUPPORTED_CPU_FEATURES_ARCH)
set_target_properties(Volkgnsssdr::volkgnsssdr PROPERTIES
INTERFACE_LINK_LIBRARIES ${CMAKE_BINARY_DIR}/volk_gnsssdr_module/install/${CMAKE_INSTALL_LIBDIR}/${CMAKE_FIND_LIBRARY_PREFIXES}cpu_features${CMAKE_STATIC_LIBRARY_SUFFIX}
)
if(NOT CpuFeatures_FOUND)
set_target_properties(Volkgnsssdr::volkgnsssdr PROPERTIES
INTERFACE_LINK_LIBRARIES ${CMAKE_BINARY_DIR}/volk_gnsssdr_module/install/${CMAKE_INSTALL_LIBDIR}/${CMAKE_FIND_LIBRARY_PREFIXES}cpu_features${CMAKE_STATIC_LIBRARY_SUFFIX}
)
endif()
endif()
endif()
@ -1240,6 +1278,8 @@ if(NOT VOLKGNSSSDR_FOUND)
set_package_properties(VOLKGNSSSDR PROPERTIES
PURPOSE "volk_gnsssdr will be built when doing '${CMAKE_MAKE_PROGRAM_PRETTY_NAME}'."
)
else()
set(ENABLE_OWN_CPUFEATURES OFF)
endif()
@ -3210,6 +3250,7 @@ add_feature_info(ENABLE_GNSS_SIM_INSTALL ENABLE_GNSS_SIM_INSTALL "Enables downlo
add_feature_info(ENABLE_INSTALL_TESTS ENABLE_INSTALL_TESTS "Install test binaries when doing '${CMAKE_MAKE_PROGRAM_PRETTY_NAME} install'.")
add_feature_info(ENABLE_BENCHMARKS ENABLE_BENCHMARKS "Enables building of code snippet benchmarks.")
add_feature_info(ENABLE_EXTERNAL_MATHJAX ENABLE_EXTERNAL_MATHJAX "Use MathJax from an external CDN in HTML docs when doing '${CMAKE_MAKE_PROGRAM_PRETTY_NAME} doc'.")
add_feature_info(ENABLE_OWN_CPUFEATURES ENABLE_OWN_CPUFEATURES "Force building own local version of the cpu_features library, even if it is already installed.")
message(STATUS "")
message(STATUS "***************************************")

23
docs/changelog.md
View File

@ -8,6 +8,29 @@ SPDX-FileCopyrightText: 2011-2021 Carles Fernandez-Prades <carles.fernandez@cttc
)
<!-- prettier-ignore-end -->
## [Unreleased](https://github.com/gnss-sdr/gnss-sdr/tree/next)
### Improvements in Portability:
- Avoid collision of the `cpu_features` library when installing the
`volk_gnsssdr` library by its own, and VOLK has already installed its version.
Added a new building option `ENABLE_OWN_CPUFEATURES`, defaulting to `ON` when
building `gnss-sdr` but defaulting to `OFF` when building a stand-alone
version of `volk_gnsssdr`. When this building option is set to `ON`, it forces
the building of the local version of the cpu_features library, regardless of
whether it is already installed or not.
- Fix building when using the Xcode generator, Xcode >= 12 and CMake >= 3.19.
- Fix building of FPGA blocks when linking against GNU Radio >= 3.9 and/or
Boost >= 1.74.
### Improvements in Maintainability:
- Improved handling of change in GNU Radio 3.9 FFT API.
- Improved handling of the filesystem library.
- Do not apply clang-tidy fixes to protobuf-generated headers.
&nbsp;
## [GNSS-SDR v0.0.14](https://github.com/gnss-sdr/gnss-sdr/releases/tag/v0.0.14)
### Improvements in Availability:

10
docs/doxygen/other/reference_docs.dox
View File

@ -1,7 +1,7 @@
# GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
# This file is part of GNSS-SDR.
#
# Copyright (C) 2012-2020 Carles Fernandez-Prades cfernandez(at)cttc.es
# Copyright (C) 2012-2021 Carles Fernandez-Prades cfernandez(at)cttc.es
# SPDX-License-Identifier: GPL-3.0-or-later
/*! \page reference_docs Reference Documents
@ -12,9 +12,9 @@
All the current GPS Interface Control Documents can be downloaded from <a href="https://www.gps.gov" target="_blank">GPS.gov</a>, the official U.S. Government webpage for GPS.
\li GPS L1 and L2C: Global Positioning System Directorate, <a href="https://www.gps.gov/technical/icwg/IS-GPS-200K.pdf" target="_blank"><b>Interface Specification IS-GPS-200 Revision K</b></a>. March, 2019.
\li GPS L1C (available with first Block III launch): Global Positioning System Directorate, <a href="https://www.gps.gov/technical/icwg/IS-GPS-800F.pdf" target="_blank"><b>Interface Specification IS-GPS-800 Revision F</b></a>. March, 2019.
\li GPS L5 (first Block IIF satellite launched on May, 2010): Global Positioning System Directorate, <a href="https://www.gps.gov/technical/icwg/IS-GPS-705F.pdf" target="_blank"><b>Interface Specification IS-GPS-705 Revision F</b></a>. March, 2019.
\li GPS L1 and L2C: Global Positioning System Directorate, <a href="https://www.gps.gov/technical/icwg/IS-GPS-200L.pdf" target="_blank"><b>Interface Specification IS-GPS-200 Revision L</b></a>. May, 2020.
\li GPS L1C (available with first Block III launch): Global Positioning System Directorate, <a href="https://www.gps.gov/technical/icwg/IS-GPS-800G.pdf" target="_blank"><b>Interface Specification IS-GPS-800 Revision G</b></a>. May, 2020.
\li GPS L5 (first Block IIF satellite launched on May, 2010): Global Positioning System Directorate, <a href="https://www.gps.gov/technical/icwg/IS-GPS-705G.pdf" target="_blank"><b>Interface Specification IS-GPS-705 Revision G</b></a>. May, 2020.
@ -33,7 +33,7 @@ Check the <a href="https://www.gsa.europa.eu/european-gnss/galileo/galileo-europ
<a href="https://www.esa.int/Our_Activities/Navigation/The_future_-_Galileo/What_is_Galileo" target="_blank">Galileo website of the European Space Agency</a>.
There is a website with <a href="https://www.gsc-europa.eu/system-service-status/constellation-information" target="_blank">Galileo constellation status information</a> from the GSA.
\li Galileo E5, E6, and E1: European GNSS (Galileo) Open Service. <a href="https://www.gsc-europa.eu/sites/default/files/sites/all/files/Galileo-OS-SIS-ICD.pdf" target="_blank"><b>Signal In Space Interface Control Document. Ref: OS SIS ICD, Issue 1.3</b></a>, European Commission, Dec. 2016.
\li Galileo E5, E6, and E1: European GNSS (Galileo) Open Service. <a href="https://www.gsc-europa.eu/sites/default/files/sites/all/files/Galileo_OS_SIS_ICD_v2.0.pdf" target="_blank"><b>Signal In Space Interface Control Document. Ref: OS SIS ICD, Issue 2.0</b></a>, European Union, Jan. 2021.
The European Commission is granting free access to the technical information on the future Galileo open service signal, i.e. the specifications manufacturers

16
docs/doxygen/other/signal_model.dox
View File

@ -1,7 +1,7 @@
# GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
# This file is part of GNSS-SDR.
#
# Copyright (C) 2012-2020 Carles Fernandez-Prades cfernandez(at)cttc.es
# Copyright (C) 2012-2021 Carles Fernandez-Prades cfernandez(at)cttc.es
# SPDX-License-Identifier: GPL-3.0-or-later
/*! \page the_signal_model Signal model
@ -62,7 +62,7 @@ and civilian users on a continuous, worldwide basis. Two GPS services are provid
the Precise Positioning Service (PPS), available primarily to the military of the United
States and its allies, and the Standard Positioning Service (SPS) open to civilian users.
\li <b>GPS L1</b>. Defined at <a href="https://www.gps.gov/technical/icwg/IS-GPS-200K.pdf" target="_blank"><b>Interface Specification IS-GPS-200 Revision K</b></a>, this band is centered at \f$f_{\text{GPS L1}}=1575.42\f$ MHz. The complex baseband transmitted signal can be written as
\li <b>GPS L1</b>. Defined at <a href="https://www.gps.gov/technical/icwg/IS-GPS-200L.pdf" target="_blank"><b>Interface Specification IS-GPS-200 Revision L</b></a>, this band is centered at \f$f_{\text{GPS L1}}=1575.42\f$ MHz. The complex baseband transmitted signal can be written as
\f{equation}{
s^{\text{(GPS L1)}}_{T}(t)=e_{L1I}(t) + j e_{L1Q}(t)~,
\f}
@ -76,12 +76,12 @@ s^{\text{(GPS L1)}}_{T}(t)=e_{L1I}(t) + j e_{L1Q}(t)~,
\f$L_{\text{P(Y)}}=6.1871 \cdot 10^{12}\f$, and \f$p(t)\f$ is a rectangular pulse of a chip-period duration centered at \f$t=0\f$ and filtered at the transmitter.
According to the chip rate, the binary phase-shift keying modulations in the equations above are denoted as BPSK(10) and BPSK(1), respectively. The precision P codes (named Y codes whenever
the anti-spoofing mode is activated, encrypting the code and thus denying non-U.S. military users) are sequences of \f$7\f$ days in length. Regarding the modernization plans for GPS, it
is worthwhile to mention that there is a new civilian-use signal planned, called L1C and defined at <a href="https://www.gps.gov/technical/icwg/IS-GPS-800F.pdf" target="_blank"><b>Interface Specification IS-GPS-800 Revision F</b></a>,
is worthwhile to mention that there is a new civilian-use signal planned, called L1C and defined at <a href="https://www.gps.gov/technical/icwg/IS-GPS-800G.pdf" target="_blank"><b>Interface Specification IS-GPS-800 Revision G</b></a>,
to be broadcast on the same L1 frequency that currently contains the C/A signal. The L1C will be available with first Block III launch, currently scheduled for 2013. The implementation will
provide C/A code to ensure backward compatibility.
\li <b>GPS L2C</b>. Defined at <a href="https://www.gps.gov/technical/icwg/IS-GPS-200K.pdf" target="_blank"><b>Interface Specification IS-GPS-200 Revision K</b></a>, is only available on
\li <b>GPS L2C</b>. Defined at <a href="https://www.gps.gov/technical/icwg/IS-GPS-200L.pdf" target="_blank"><b>Interface Specification IS-GPS-200 Revision L</b></a>, is only available on
Block IIR-M and subsequent satellite blocks. Centered at \f$f_{\text{GPS L2}}=1227.60\f$ MHz, the signal structure is the same than in (\ref{eq:GPSL1}), with the precision code in the In-phase
component, just as in (\ref{eq:L1CAI}) but with an optional presence of the navigation message \f$D_{\text{NAV}}\f$. For the Quadrature-phase component, three options are defined:
\f{align}{ e_{L2CQ}(t) =& \sum_{l=-\infty}^{\infty} D_{\text{CNAV}} \Big[ [l]_{10230} \Big] \oplus \left( C_{\text{CL}} \Big[ |l|_{L_{\text{CL}}} \Big] p_{\text{\tiny{1/2}}} \left( t - lT_{c,L2C} \right) + \right.\\ {} &+ \left. C_{\text{CM}} \Big[ |l|_{L_{\text{CM}}} \Big] p_{\text{\tiny{1/2}}}\left(t - \left(l+\frac{3}{4}\right)T_{c,L2C}\right) \right),\\
@ -94,7 +94,7 @@ component, just as in (\ref{eq:L1CAI}) but with an optional presence of the navi
data than the NAV data. It is transmitted at \f$25\f$ bps with forward error correction (FEC) encoding, resulting in \f$50\f$ sps.
\li <b>GPS L5</b>. The GPS L5 link, defined at <a href="https://www.gps.gov/technical/icwg/IS-GPS-705F.pdf" target="_blank"><b>Interface Specification IS-GPS-705 Revision F</b></a>, is only available
\li <b>GPS L5</b>. The GPS L5 link, defined at <a href="https://www.gps.gov/technical/icwg/IS-GPS-705G.pdf" target="_blank"><b>Interface Specification IS-GPS-705 Revision G</b></a>, is only available
in Block IIF (first satellite launched on May, 2010) and subsequent satellite blocks. Centered at \f$f_{\text{GPS L5}}=1176.45\f$ MHz, this signal in space can be written as:
\f{equation}{
s^{\text{(GPS L5)}}_{T}(t)=e_{L5I}(t) +j e_{L5Q}(t)~,
@ -158,7 +158,7 @@ nominal constellation configuration. The Galileo satellites are placed in quasi-
orbits with a nominal semi-major axis of about \f$30,000\f$ km and an approximate revolution
period of \f$14\f$ hours. The Control segment full infrastructure will be composed of \f$30-40\f$ sensor stations, \f$3\f$ control centers, \f$9\f$ Mission Uplink stations, and \f$5\f$ TT\&C stations.
Galileo's Open Service is defined at <a href="https://www.gsc-europa.eu/sites/default/files/sites/all/files/Galileo-OS-SIS-ICD.pdf" target="_blank"><b>Signal In Space Interface Control Document. Ref: OS SIS ICD, Issue 1.3</b></a>, where the following signal structures are specified:
Galileo's Open Service is defined at <a href="https://www.gsc-europa.eu/sites/default/files/sites/all/files/Galileo_OS_SIS_ICD_v2.0.pdf" target="_blank"><b>Signal In Space Interface Control Document. Ref: OS SIS ICD, Issue 2.0</b></a>, where the following signal structures are specified:
\li <b>Galileo E1</b>. This band, centered at \f$f_{\text{Gal E1}}=1575.420\f$ MHz and with a reference bandwidth of \f$24.5520\f$ MHz, uses the so-called composite binary offset carrier
@ -181,7 +181,7 @@ In case of channel \f$C\f$, it is a pilot (dataless) channel with a secondary co
\nonumber e_{E1C}(t)&= \sum_{m=-\infty}^{+\infty}C_{E1Cs}\Big[|m|_{25}\Big] \oplus \sum_{l=1}^{4092}C_{E1Cp}\Big[ l \Big] \cdot \\ {}& \; \; \cdot p(t-mT_{c,E1Cs}-lT_{c,E1Cp})~,\label{eq:E1C}
\f}
with \f$T_{c,E1B}=T_{c,E1Cp}=\frac{1}{1.023}\f$ \f$\mu\f$s and \f$T_{c,E1Cs}=4\f$ ms. The \f$C_{E1B}\f$ and \f$C_{E1Cp}\f$ primary codes are pseudorandom memory code sequences defined at
Annex C.7 and C.8 of <a href="https://www.gsc-europa.eu/sites/default/files/sites/all/files/Galileo-OS-SIS-ICD.pdf" target="_blank">OS SIS ICD</a>. The binary
Annex C of <a href="https://www.gsc-europa.eu/sites/default/files/sites/all/files/Galileo_OS_SIS_ICD_v2.0.pdf" target="_blank">OS SIS ICD</a>. The binary
sequence of the secondary code \f$C_{E1Cs}\f$ is 0011100000001010110110010. This band also contains another component, Galileo E1A, intended for the Public Regulated Service (PRS).
It uses a BOC(15,2.5) modulation with cosine-shaped subcarrier \f$f_{s,E1A}=15.345\f$ MHz and \f$T_{c, E1A}=\frac{1}{2.5575}\f$ \f$\mu\f$s.
The PRS spreading codes and the structure of the navigation message have not been made public.
@ -197,7 +197,7 @@ s_{T}^{\text{(Gal E6)}}(t) = \frac{1}{\sqrt{2}}\left(e_{E6B}(t)-e_{E6C}(t)\right
\f}
where \f$D_{\text{C/NAV}}\f$ is the C/NAV navigation data stream, which is modulated with the encrypted ranging code \f$C_{E6B}\f$ with chip period \f$T_{c,E6}=\frac{1}{5.115}\f$ \f$\mu\f$s, thus
being a BPSK(5) modulation. Codes \f$C_{E6B}\f$ and primary codes \f$C_{E6Cs}\f$ and their respective lengths, \f$L_{E6B}\f$ and \f$L_{E6C}\f$, have not been published. The secondary codes
for the pilot component, \f$C_{E6Cs}\f$, are available at the <a href="https://www.gsc-europa.eu/sites/default/files/sites/all/files/Galileo-OS-SIS-ICD.pdf" target="_blank">OS SIS ICD</a>.
for the pilot component, \f$C_{E6Cs}\f$, are available at the <a href="https://www.gsc-europa.eu/sites/default/files/sites/all/files/Galileo_OS_SIS_ICD_v2.0.pdf" target="_blank">OS SIS ICD</a>.
The receiver reference bandwidth for this signal is \f$40.920\f$ MHz. This band also contains another component, Galileo E6A, intended for PRS.
\li <b>Galileo E5</b>. Centered at \f$f_{\text{Gal E5}}=1191.795\f$ MHz and with a total bandwidth of \f$51.150\f$ MHz, its signal structure deserves some analysis. The AltBOC modulation can be generically expressed as

10
src/algorithms/PVT/gnuradio_blocks/CMakeLists.txt
View File

@ -18,16 +18,6 @@ else()
add_library(pvt_gr_blocks rtklib_pvt_gs.cc rtklib_pvt_gs.h)
endif()
if(${FILESYSTEM_FOUND})
target_compile_definitions(pvt_gr_blocks PRIVATE -DHAS_STD_FILESYSTEM=1)
if(${find_experimental})
target_compile_definitions(pvt_gr_blocks PRIVATE -DHAS_STD_FILESYSTEM_EXPERIMENTAL=1)
endif()
target_link_libraries(pvt_gr_blocks PRIVATE std::filesystem)
else()
target_link_libraries(pvt_gr_blocks PRIVATE Boost::filesystem Boost::system)
endif()
target_link_libraries(pvt_gr_blocks
PUBLIC
algorithms_libs_rtklib

18
src/algorithms/PVT/gnuradio_blocks/rtklib_pvt_gs.cc
View File

@ -32,6 +32,7 @@
#include "glonass_gnav_utc_model.h"
#include "gnss_frequencies.h"
#include "gnss_sdr_create_directory.h"
#include "gnss_sdr_filesystem.h"
#include "gnss_sdr_make_unique.h"
#include "gps_almanac.h"
#include "gps_cnav_ephemeris.h"
@ -80,23 +81,6 @@
#include <boost/bind/bind.hpp>
#endif
#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/path.hpp>
#include <boost/system/error_code.hpp> // for error_code
namespace fs = boost::filesystem;
namespace errorlib = boost::system;
#endif
#if USE_OLD_BOOST_MATH_COMMON_FACTOR
#include <boost/math/common_factor_rt.hpp>
namespace bc = boost::math;

23
src/algorithms/PVT/libs/CMakeLists.txt
View File

@ -54,16 +54,6 @@ else()
add_library(pvt_libs ${PVT_LIB_SOURCES} ${PROTO_SRCS} ${PVT_LIB_HEADERS} ${PROTO_HDRS})
endif()
if(${FILESYSTEM_FOUND})
target_compile_definitions(pvt_libs PRIVATE -DHAS_STD_FILESYSTEM=1)
if(${find_experimental})
target_compile_definitions(pvt_libs PRIVATE -DHAS_STD_FILESYSTEM_EXPERIMENTAL=1)
endif()
target_link_libraries(pvt_libs PRIVATE std::filesystem)
else()
target_link_libraries(pvt_libs PRIVATE Boost::filesystem Boost::system)
endif()
target_link_libraries(pvt_libs
PUBLIC
Boost::date_time
@ -71,19 +61,24 @@ target_link_libraries(pvt_libs
core_system_parameters
algorithms_libs_rtklib
PRIVATE
algorithms_libs
Gflags::gflags
Glog::glog
Matio::matio
)
get_filename_component(PROTO_INCLUDE_HEADERS ${PROTO_HDRS} DIRECTORY)
get_filename_component(PROTO_INCLUDE_HEADERS_DIR ${PROTO_HDRS} DIRECTORY)
# for concurrent_queue.h
target_include_directories(pvt_libs
PUBLIC
${CMAKE_SOURCE_DIR}/src/core/receiver
SYSTEM ${PROTO_INCLUDE_HEADERS}
PRIVATE
${CMAKE_SOURCE_DIR}/src/algorithms/libs # for gnss_sdr_make_unique.h
)
# Do not apply clang-tidy fixes to protobuf generated headers
target_include_directories(pvt_libs
SYSTEM PUBLIC
${PROTO_INCLUDE_HEADERS_DIR}
)
target_compile_definitions(pvt_libs PRIVATE -DGNSS_SDR_VERSION="${VERSION}")

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

@ -17,6 +17,7 @@
#include "geojson_printer.h"
#include "gnss_sdr_filesystem.h"
#include "pvt_solution.h"
#include <boost/date_time/posix_time/posix_time.hpp>
#include <glog/logging.h>
@ -26,26 +27,6 @@
#include <iostream> // for cout, cerr
#include <sstream> // for stringstream
// 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 create_directories, exists
#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
GeoJSON_Printer::GeoJSON_Printer(const std::string& base_path)
{

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

@ -17,6 +17,7 @@
#include "gpx_printer.h"
#include "gnss_sdr_filesystem.h"
#include "pvt_solution.h"
#include <boost/date_time/posix_time/posix_time.hpp>
#include <glog/logging.h>
@ -26,27 +27,6 @@
#include <iostream> // for cout, cerr
#include <sstream> // for stringstream
// 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 create_directories, exists
#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
Gpx_Printer::Gpx_Printer(const std::string& base_path)
{

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

@ -17,6 +17,7 @@
*/
#include "kml_printer.h"
#include "gnss_sdr_filesystem.h"
#include "pvt_solution.h"
#include <boost/date_time/posix_time/posix_time.hpp>
#include <glog/logging.h>
@ -28,27 +29,6 @@
#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;
#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 create_directories, exists
#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
Kml_Printer::Kml_Printer(const std::string& base_path)
{

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

@ -20,6 +20,7 @@
*/
#include "nmea_printer.h"
#include "gnss_sdr_filesystem.h"
#include "rtklib_solution.h"
#include "rtklib_solver.h"
#include <glog/logging.h>
@ -31,27 +32,6 @@
#include <termios.h>
#include <utility>
// 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 create_directories, exists
#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
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)
{

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

@ -29,6 +29,7 @@
#include "glonass_gnav_almanac.h"
#include "glonass_gnav_ephemeris.h"
#include "glonass_gnav_utc_model.h"
#include "gnss_sdr_filesystem.h"
#include "gnss_synchro.h"
#include "gps_cnav_ephemeris.h"
#include "gps_cnav_iono.h"
@ -54,27 +55,6 @@
#include <utility>
#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 create_directories, exists
#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
Rinex_Printer::Rinex_Printer(int32_t conf_version, const std::string& base_path, const std::string& base_name)
{
@ -5103,7 +5083,7 @@ void Rinex_Printer::log_rinex_nav(std::fstream& out, const std::map<int32_t, Gps
if (gps_ephemeris_iter->second.satelliteBlock.at(gps_ephemeris_iter->second.i_satellite_PRN) == "IIA")
{
// Block II/IIA (Table 20-XI IS-GPS-200K )
// Block II/IIA (Table 20-XI IS-GPS-200L )
if ((gps_ephemeris_iter->second.d_IODC > 239) && (gps_ephemeris_iter->second.d_IODC < 248))
{
curve_fit_interval = 8;
@ -5135,7 +5115,7 @@ void Rinex_Printer::log_rinex_nav(std::fstream& out, const std::map<int32_t, Gps
(gps_ephemeris_iter->second.satelliteBlock.at(gps_ephemeris_iter->second.i_satellite_PRN) == "IIF") ||
(gps_ephemeris_iter->second.satelliteBlock.at(gps_ephemeris_iter->second.i_satellite_PRN) == "IIIA"))
{
// Block IIR/IIR-M/IIF/IIIA (Table 20-XII IS-GPS-200K )
// Block IIR/IIR-M/IIF/IIIA (Table 20-XII IS-GPS-200L )
if ((gps_ephemeris_iter->second.d_IODC > 239) && (gps_ephemeris_iter->second.d_IODC < 248))
{
curve_fit_interval = 8;
@ -5222,7 +5202,7 @@ void Rinex_Printer::log_rinex_nav(std::fstream& out, const std::map<int32_t, Gps
line += std::string(5, ' ');
// If there is no IODE in CNAV, so we check if Toe in message Type 10, Toe in Message type 11 and Toc in message types 30-37.
// Whenever these three terms do not match, a data set cutover has occurred and new data must be collected.
// See IS-GPS-200K, p. 155
// See IS-GPS-200L, p. 155
if (!((gps_ephemeris_iter->second.d_Toe1 == gps_ephemeris_iter->second.d_Toe2) && (gps_ephemeris_iter->second.d_Toe1 == gps_ephemeris_iter->second.d_Toc))) // Toe1: Toe in message type 10, Toe2: Toe in message type 11
{
// Toe1: Toe in message type 10, Toe2: Toe in message type 11,
@ -5252,7 +5232,7 @@ void Rinex_Printer::log_rinex_nav(std::fstream& out, const std::map<int32_t, Gps
line += std::string(1, ' ');
line += Rinex_Printer::doub2for(gps_ephemeris_iter->second.d_Cus, 18, 2);
line += std::string(1, ' ');
const double A_REF = 26559710.0; // See IS-GPS-200K, pp. 163
const double A_REF = 26559710.0; // See IS-GPS-200L, pp. 161
double sqrt_A = sqrt(A_REF + gps_ephemeris_iter->second.d_DELTA_A);
line += Rinex_Printer::doub2for(sqrt_A, 18, 2);
Rinex_Printer::lengthCheck(line);
@ -5280,7 +5260,7 @@ void Rinex_Printer::log_rinex_nav(std::fstream& out, const std::map<int32_t, Gps
line += std::string(1, ' ');
line += Rinex_Printer::doub2for(gps_ephemeris_iter->second.d_OMEGA, 18, 2);
line += std::string(1, ' ');
const double OMEGA_DOT_REF = -2.6e-9; // semicircles / s, see IS-GPS-200K pp. 164
const double OMEGA_DOT_REF = -2.6e-9; // semicircles / s, see IS-GPS-200L pp. 160
double OMEGA_DOT_aux = OMEGA_DOT_REF + gps_ephemeris_iter->second.d_DELTA_OMEGA_DOT;
line += Rinex_Printer::doub2for(OMEGA_DOT_aux, 18, 2);
Rinex_Printer::lengthCheck(line);

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

@ -21,6 +21,7 @@
#include "galileo_ephemeris.h"
#include "glonass_gnav_ephemeris.h"
#include "glonass_gnav_utc_model.h"
#include "gnss_sdr_filesystem.h"
#include "gnss_sdr_make_unique.h"
#include "gnss_synchro.h"
#include "gps_cnav_ephemeris.h"
@ -36,27 +37,6 @@
#include <termios.h> // for tcgetattr
#include <unistd.h> // for close, write
// 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 create_directories, exists
#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 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)
{

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

@ -32,6 +32,7 @@
#include "rtklib_solver.h"
#include "Beidou_DNAV.h"
#include "gnss_sdr_filesystem.h"
#include "rtklib_conversions.h"
#include "rtklib_rtkpos.h"
#include "rtklib_solution.h"
@ -41,27 +42,6 @@
#include <utility>
#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 create_directories, exists
#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
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)
{

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

@ -123,7 +123,6 @@ if(ENABLE_FPGA)
PRIVATE
algorithms_libs
core_libs
Gnuradio::fft
Volk::volk
Volkgnsssdr::volkgnsssdr
)

6
src/algorithms/acquisition/adapters/galileo_e1_pcps_ambiguous_acquisition_fpga.cc
View File

@ -19,8 +19,8 @@
#include "Galileo_E1.h"
#include "configuration_interface.h"
#include "galileo_e1_signal_replica.h"
#include "gnss_sdr_fft.h"
#include "gnss_sdr_flags.h"
#include "gnss_sdr_make_unique.h"
#include "uio_fpga.h"
#include <glog/logging.h>
#include <gnuradio/fft/fft.h> // for fft_complex
@ -92,8 +92,8 @@ GalileoE1PcpsAmbiguousAcquisitionFpga::GalileoE1PcpsAmbiguousAcquisitionFpga(
// compute all the GALILEO E1 PRN Codes (this is done only once in the class constructor in order to avoid re-computing the PRN codes every time
// a channel is assigned)
auto fft_if = std::make_unique<gr::fft::fft_complex>(nsamples_total, true); // Direct FFT
volk_gnsssdr::vector<std::complex<float>> code(nsamples_total); // buffer for the local code
auto fft_if = gnss_fft_fwd_make_unique(nsamples_total); // Direct FFT
volk_gnsssdr::vector<std::complex<float>> code(nsamples_total); // buffer for the local code
volk_gnsssdr::vector<gr_complex> fft_codes_padded(nsamples_total);
d_all_fft_codes_ = std::vector<uint32_t>(nsamples_total * GALILEO_E1_NUMBER_OF_CODES); // memory containing all the possible fft codes for PRN 0 to 32

5
src/algorithms/acquisition/adapters/galileo_e5a_pcps_acquisition_fpga.cc
View File

@ -19,11 +19,10 @@
#include "Galileo_E5a.h"
#include "configuration_interface.h"
#include "galileo_e5_signal_replica.h"
#include "gnss_sdr_fft.h"
#include "gnss_sdr_flags.h"
#include "gnss_sdr_make_unique.h"
#include "uio_fpga.h"
#include <glog/logging.h>
#include <gnuradio/fft/fft.h> // for fft_complex
#include <gnuradio/gr_complex.h> // for gr_complex
#include <volk/volk.h> // for volk_32fc_conjugate_32fc
#include <volk_gnsssdr/volk_gnsssdr_alloc.h>
@ -94,7 +93,7 @@ GalileoE5aPcpsAcquisitionFpga::GalileoE5aPcpsAcquisitionFpga(
// compute all the GALILEO E5 PRN Codes (this is done only once in the class constructor in order to avoid re-computing the PRN codes every time
// a channel is assigned)
auto fft_if = std::make_unique<gr::fft::fft_complex>(nsamples_total, true); // Direct FFT
auto fft_if = gnss_fft_fwd_make_unique(nsamples_total); // Direct FFT
volk_gnsssdr::vector<std::complex<float>> code(nsamples_total);
volk_gnsssdr::vector<std::complex<float>> fft_codes_padded(nsamples_total);
d_all_fft_codes_ = std::vector<uint32_t>(nsamples_total * GALILEO_E5A_NUMBER_OF_CODES); // memory containing all the possible fft codes for PRN 0 to 32

6
src/algorithms/acquisition/adapters/galileo_e5b_pcps_acquisition_fpga.cc
View File

@ -20,10 +20,10 @@
#include "Galileo_E5b.h"
#include "configuration_interface.h"
#include "galileo_e5_signal_replica.h"
#include "gnss_sdr_fft.h"
#include "gnss_sdr_flags.h"
#include "uio_fpga.h"
#include <glog/logging.h>
#include <gnuradio/fft/fft.h> // for fft_complex
#include <gnuradio/gr_complex.h> // for gr_complex
#include <volk/volk.h> // for volk_32fc_conjugate_32fc
#include <volk_gnsssdr/volk_gnsssdr_alloc.h>
@ -93,8 +93,8 @@ GalileoE5bPcpsAcquisitionFpga::GalileoE5bPcpsAcquisitionFpga(const Configuration
// compute all the GALILEO E5b PRN Codes (this is done only once in the class constructor in order to avoid re-computing the PRN codes every time
// a channel is assigned)
auto fft_if = std::unique_ptr<gr::fft::fft_complex>(new gr::fft::fft_complex(nsamples_total, true)); // Direct FFT
volk_gnsssdr::vector<std::complex<float>> code(nsamples_total); // Buffer for local code
auto fft_if = gnss_fft_fwd_make_unique(nsamples_total); // Direct FFT
volk_gnsssdr::vector<std::complex<float>> code(nsamples_total); // Buffer for local code
volk_gnsssdr::vector<std::complex<float>> fft_codes_padded(nsamples_total);
d_all_fft_codes_ = std::vector<uint32_t>(nsamples_total * GALILEO_E5B_NUMBER_OF_CODES); // memory containing all the possible fft codes for PRN 0 to 32

5
src/algorithms/acquisition/adapters/gps_l1_ca_pcps_acquisition_fpga.cc
View File

@ -21,12 +21,11 @@
#include "gps_l1_ca_pcps_acquisition_fpga.h"
#include "GPS_L1_CA.h"
#include "configuration_interface.h"
#include "gnss_sdr_fft.h"
#include "gnss_sdr_flags.h"
#include "gnss_sdr_make_unique.h"
#include "gps_sdr_signal_replica.h"
#include "uio_fpga.h"
#include <glog/logging.h>
#include <gnuradio/fft/fft.h>
#include <gnuradio/gr_complex.h> // for gr_complex
#include <volk/volk.h> // for volk_32fc_conjugate_32fc
#include <volk_gnsssdr/volk_gnsssdr_alloc.h>
@ -86,7 +85,7 @@ GpsL1CaPcpsAcquisitionFpga::GpsL1CaPcpsAcquisitionFpga(
// compute all the GPS L1 PRN Codes (this is done only once upon the class constructor in order to avoid re-computing the PRN codes every time
// a channel is assigned)
auto fft_if = std::make_unique<gr::fft::fft_complex>(nsamples_total, true);
auto fft_if = gnss_fft_fwd_make_unique(nsamples_total);
// allocate memory to compute all the PRNs and compute all the possible codes
volk_gnsssdr::vector<std::complex<float>> code(nsamples_total);
volk_gnsssdr::vector<std::complex<float>> fft_codes_padded(nsamples_total);

5
src/algorithms/acquisition/adapters/gps_l2_m_pcps_acquisition_fpga.cc
View File

@ -20,13 +20,12 @@
#include "gps_l2_m_pcps_acquisition_fpga.h"
#include "GPS_L2C.h"
#include "configuration_interface.h"
#include "gnss_sdr_fft.h"
#include "gnss_sdr_flags.h"
#include "gnss_sdr_make_unique.h"
#include "gnss_synchro.h"
#include "gps_l2c_signal_replica.h"
#include "uio_fpga.h"
#include <glog/logging.h>
#include <gnuradio/fft/fft.h> // for fft_complex
#include <gnuradio/gr_complex.h> // for gr_complex
#include <volk/volk.h> // for volk_32fc_conjugate_32fc
#include <volk_gnsssdr/volk_gnsssdr_alloc.h>
@ -86,7 +85,7 @@ GpsL2MPcpsAcquisitionFpga::GpsL2MPcpsAcquisitionFpga(
// compute all the GPS L2C PRN Codes (this is done only once upon the class constructor in order to avoid re-computing the PRN codes every time
// a channel is assigned)
auto fft_if = std::make_unique<gr::fft::fft_complex>(nsamples_total, true); // Direct FFT
auto fft_if = gnss_fft_fwd_make_unique(nsamples_total); // Direct FFT
// allocate memory to compute all the PRNs and compute all the possible codes
volk_gnsssdr::vector<std::complex<float>> code(nsamples_total);
volk_gnsssdr::vector<std::complex<float>> fft_codes_padded(nsamples_total);

5
src/algorithms/acquisition/adapters/gps_l5i_pcps_acquisition_fpga.cc
View File

@ -21,12 +21,11 @@
#include "gps_l5i_pcps_acquisition_fpga.h"
#include "GPS_L5.h"
#include "configuration_interface.h"
#include "gnss_sdr_fft.h"
#include "gnss_sdr_flags.h"
#include "gnss_sdr_make_unique.h"
#include "gps_l5_signal_replica.h"
#include "uio_fpga.h"
#include <glog/logging.h>
#include <gnuradio/fft/fft.h> // for fft_complex
#include <gnuradio/gr_complex.h> // for gr_complex
#include <volk/volk.h> // for volk_32fc_conjugate_32fc
#include <volk_gnsssdr/volk_gnsssdr_alloc.h>
@ -90,7 +89,7 @@ GpsL5iPcpsAcquisitionFpga::GpsL5iPcpsAcquisitionFpga(
// compute all the GPS L5 PRN Codes (this is done only once upon the class constructor in order to avoid re-computing the PRN codes every time
// a channel is assigned)
auto fft_if = std::make_unique<gr::fft::fft_complex>(nsamples_total, true); // Direct FFT
auto fft_if = gnss_fft_fwd_make_unique(nsamples_total); // Direct FFT
volk_gnsssdr::vector<std::complex<float>> code(nsamples_total);
volk_gnsssdr::vector<std::complex<float>> fft_codes_padded(nsamples_total);
d_all_fft_codes_ = std::vector<uint32_t>(nsamples_total * NUM_PRNs); // memory containing all the possible fft codes for PRN 0 to 32

18
src/algorithms/acquisition/gnuradio_blocks/CMakeLists.txt
View File

@ -53,16 +53,6 @@ else()
add_library(acquisition_gr_blocks ${ACQ_GR_BLOCKS_SOURCES} ${ACQ_GR_BLOCKS_HEADERS})
endif()
if(${FILESYSTEM_FOUND})
target_compile_definitions(acquisition_gr_blocks PRIVATE -DHAS_STD_FILESYSTEM=1)
if(${find_experimental})
target_compile_definitions(acquisition_gr_blocks PRIVATE -DHAS_STD_FILESYSTEM_EXPERIMENTAL=1)
endif()
target_link_libraries(acquisition_gr_blocks PRIVATE std::filesystem)
else()
target_link_libraries(acquisition_gr_blocks PRIVATE Boost::filesystem)
endif()
target_link_libraries(acquisition_gr_blocks
PUBLIC
algorithms_libs
@ -81,8 +71,6 @@ target_link_libraries(acquisition_gr_blocks
)
target_include_directories(acquisition_gr_blocks
PUBLIC
${CMAKE_SOURCE_DIR}/src/algorithms/libs
PRIVATE
${CMAKE_SOURCE_DIR}/src/core/receiver
)
@ -93,12 +81,6 @@ if(GNURADIO_USES_STD_POINTERS)
)
endif()
if(GNURADIO_FFT_USES_TEMPLATES)
target_compile_definitions(acquisition_gr_blocks
PUBLIC -DGNURADIO_FFT_USES_TEMPLATES=1
)
endif()
if(ENABLE_ARMA_NO_DEBUG)
target_compile_definitions(acquisition_gr_blocks
PUBLIC -DARMA_NO_BOUND_CHECKING=1

16
src/algorithms/acquisition/gnuradio_blocks/galileo_e5a_noncoherent_iq_acquisition_caf_cc.cc
View File

@ -23,7 +23,6 @@
#include "galileo_e5a_noncoherent_iq_acquisition_caf_cc.h"
#include "MATH_CONSTANTS.h"
#include "gnss_sdr_make_unique.h"
#include <glog/logging.h>
#include <gnuradio/io_signature.h>
#include <volk/volk.h>
@ -119,18 +118,9 @@ galileo_e5a_noncoherentIQ_acquisition_caf_cc::galileo_e5a_noncoherentIQ_acquisit
}
}
#if GNURADIO_FFT_USES_TEMPLATES
// Direct FFT
d_fft_if = std::make_unique<gr::fft::fft_complex_fwd>(d_fft_size);
// Inverse FFT
d_ifft = std::make_unique<gr::fft::fft_complex_rev>(d_fft_size);
#else
// Direct FFT
d_fft_if = std::make_unique<gr::fft::fft_complex>(d_fft_size, true);
// Inverse FFT
d_ifft = std::make_unique<gr::fft::fft_complex>(d_fft_size, false);
#endif
// For dumping samples into a file
d_fft_if = gnss_fft_fwd_make_unique(d_fft_size);
d_ifft = gnss_fft_rev_make_unique(d_fft_size);
d_dump = dump;
d_dump_filename = dump_filename;

12
src/algorithms/acquisition/gnuradio_blocks/galileo_e5a_noncoherent_iq_acquisition_caf_cc.h
View File

@ -25,9 +25,9 @@
#define GNSS_SDR_GALILEO_E5A_NONCOHERENT_IQ_ACQUISITION_CAF_CC_H
#include "channel_fsm.h"
#include "gnss_sdr_fft.h"
#include "gnss_synchro.h"
#include <gnuradio/block.h>
#include <gnuradio/fft/fft.h>
#include <gnuradio/gr_complex.h>
#include <fstream>
#include <memory>
@ -204,13 +204,9 @@ private:
float estimate_input_power(gr_complex* in);
std::weak_ptr<ChannelFsm> d_channel_fsm;
#if GNURADIO_FFT_USES_TEMPLATES
std::unique_ptr<gr::fft::fft_complex_fwd> d_fft_if;
std::unique_ptr<gr::fft::fft_complex_rev> d_ifft;
#else
std::unique_ptr<gr::fft::fft_complex> d_fft_if;
std::unique_ptr<gr::fft::fft_complex> d_ifft;
#endif
std::unique_ptr<gnss_fft_complex_fwd> d_fft_if;
std::unique_ptr<gnss_fft_complex_rev> d_ifft;
std::vector<std::vector<gr_complex>> d_grid_doppler_wipeoffs;
std::vector<gr_complex> d_fft_code_I_A;
std::vector<gr_complex> d_fft_code_I_B;

15
src/algorithms/acquisition/gnuradio_blocks/galileo_pcps_8ms_acquisition_cc.cc
View File

@ -17,7 +17,6 @@
#include "galileo_pcps_8ms_acquisition_cc.h"
#include "MATH_CONSTANTS.h"
#include "gnss_sdr_make_unique.h"
#include <glog/logging.h>
#include <gnuradio/io_signature.h>
#include <volk/volk.h>
@ -76,18 +75,8 @@ galileo_pcps_8ms_acquisition_cc::galileo_pcps_8ms_acquisition_cc(
d_fft_code_A = std::vector<gr_complex>(d_fft_size, lv_cmake(0.0F, 0.0F));
d_fft_code_B = std::vector<gr_complex>(d_fft_size, lv_cmake(0.0F, 0.0F));
d_magnitude = std::vector<float>(d_fft_size, 0.0F);
#if GNURADIO_FFT_USES_TEMPLATES
// Direct FFT
d_fft_if = std::make_unique<gr::fft::fft_complex_fwd>(d_fft_size);
// Inverse FFT
d_ifft = std::make_unique<gr::fft::fft_complex_rev>(d_fft_size);
#else
// Direct FFT
d_fft_if = std::make_unique<gr::fft::fft_complex>(d_fft_size, true);
// Inverse FFT
d_ifft = std::make_unique<gr::fft::fft_complex>(d_fft_size, false);
#endif
d_fft_if = gnss_fft_fwd_make_unique(d_fft_size);
d_ifft = gnss_fft_rev_make_unique(d_fft_size);
// For dumping samples into a file
d_dump = dump;

12
src/algorithms/acquisition/gnuradio_blocks/galileo_pcps_8ms_acquisition_cc.h
View File

@ -19,9 +19,9 @@
#define GNSS_SDR_PCPS_8MS_ACQUISITION_CC_H
#include "channel_fsm.h"
#include "gnss_sdr_fft.h"
#include "gnss_synchro.h"
#include <gnuradio/block.h>
#include <gnuradio/fft/fft.h>
#include <gnuradio/gr_complex.h>
#include <fstream>
#include <memory>
@ -190,13 +190,9 @@ private:
int32_t doppler_offset);
std::weak_ptr<ChannelFsm> d_channel_fsm;
#if GNURADIO_FFT_USES_TEMPLATES
std::unique_ptr<gr::fft::fft_complex_fwd> d_fft_if;
std::unique_ptr<gr::fft::fft_complex_rev> d_ifft;
#else
std::unique_ptr<gr::fft::fft_complex> d_fft_if;
std::unique_ptr<gr::fft::fft_complex> d_ifft;
#endif
std::unique_ptr<gnss_fft_complex_fwd> d_fft_if;
std::unique_ptr<gnss_fft_complex_rev> d_ifft;
std::vector<std::vector<gr_complex>> d_grid_doppler_wipeoffs;
std::vector<gr_complex> d_fft_code_A;
std::vector<gr_complex> d_fft_code_B;

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

@ -24,17 +24,8 @@
#include "MATH_CONSTANTS.h" // for TWO_PI
#include "gnss_frequencies.h"
#include "gnss_sdr_create_directory.h"
#include "gnss_sdr_make_unique.h"
#include "gnss_sdr_filesystem.h"
#include "gnss_synchro.h"
#if HAS_STD_FILESYSTEM
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
#else
#include <filesystem>
#endif
#else
#include <boost/filesystem/path.hpp>
#endif
#include <boost/math/special_functions/gamma.hpp>
#include <gnuradio/io_signature.h>
#include <matio.h>
@ -49,16 +40,6 @@
#include <iostream>
#include <map>
#if HAS_STD_FILESYSTEM
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
namespace fs = std::experimental::filesystem;
#else
namespace fs = std::filesystem;
#endif
#else
namespace fs = boost::filesystem;
#endif
pcps_acquisition_sptr pcps_make_acquisition(const Acq_Conf& conf_)
{
@ -126,18 +107,8 @@ pcps_acquisition::pcps_acquisition(const Acq_Conf& conf_) : gr::block("pcps_acqu
d_tmp_buffer = volk_gnsssdr::vector<float>(d_fft_size);
d_fft_codes = volk_gnsssdr::vector<std::complex<float>>(d_fft_size);
d_input_signal = volk_gnsssdr::vector<std::complex<float>>(d_fft_size);
#if GNURADIO_FFT_USES_TEMPLATES
// Direct FFT
d_fft_if = std::make_unique<gr::fft::fft_complex_fwd>(d_fft_size);
// Inverse FFT
d_ifft = std::make_unique<gr::fft::fft_complex_rev>(d_fft_size);
#else
// Direct FFT
d_fft_if = std::make_unique<gr::fft::fft_complex>(d_fft_size, true);
// Inverse FFT
d_ifft = std::make_unique<gr::fft::fft_complex>(d_fft_size, false);
#endif
d_fft_if = gnss_fft_fwd_make_unique(d_fft_size);
d_ifft = gnss_fft_rev_make_unique(d_fft_size);
d_gnss_synchro = nullptr;
d_worker_active = false;

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

@ -44,10 +44,10 @@
#include "acq_conf.h"
#include "channel_fsm.h"
#include "gnss_sdr_fft.h"
#include <armadillo>
#include <glog/logging.h>
#include <gnuradio/block.h>
#include <gnuradio/fft/fft.h>
#include <gnuradio/gr_complex.h> // for gr_complex
#include <gnuradio/thread/thread.h> // for scoped_lock
#include <gnuradio/types.h> // for gr_vector_const_void_star
@ -240,14 +240,8 @@ private:
volk_gnsssdr::vector<std::complex<float>> d_data_buffer;
volk_gnsssdr::vector<lv_16sc_t> d_data_buffer_sc;
#if GNURADIO_FFT_USES_TEMPLATES
std::unique_ptr<gr::fft::fft_complex_fwd> d_fft_if;
std::unique_ptr<gr::fft::fft_complex_rev> d_ifft;
#else
std::unique_ptr<gr::fft::fft_complex> d_fft_if;
std::unique_ptr<gr::fft::fft_complex> d_ifft;
#endif
std::unique_ptr<gnss_fft_complex_fwd> d_fft_if;
std::unique_ptr<gnss_fft_complex_rev> d_ifft;
std::weak_ptr<ChannelFsm> d_channel_fsm;
Acq_Conf d_acq_parameters;

42
src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_fine_doppler_cc.cc
View File

@ -19,17 +19,8 @@
#include "pcps_acquisition_fine_doppler_cc.h"
#include "GPS_L1_CA.h" // for GPS_L1_CA_CHIP_PERIOD_S
#include "gnss_sdr_create_directory.h"
#include "gnss_sdr_make_unique.h"
#include "gnss_sdr_filesystem.h"
#include "gps_sdr_signal_replica.h"
#if HAS_STD_FILESYSTEM
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
#include <experimental/filesystem>
#else
#include <filesystem>
#endif
#else
#include <boost/filesystem/path.hpp>
#endif
#include <glog/logging.h>
#include <gnuradio/io_signature.h>
#include <matio.h>
@ -39,16 +30,6 @@
#include <sstream>
#include <vector>
#if HAS_STD_FILESYSTEM
#if HAS_STD_FILESYSTEM_EXPERIMENTAL
namespace fs = std::experimental::filesystem;
#else
namespace fs = std::filesystem;
#endif
#else
namespace fs = boost::filesystem;
#endif
pcps_acquisition_fine_doppler_cc_sptr pcps_make_acquisition_fine_doppler_cc(const Acq_Conf &conf_)
{
@ -77,17 +58,8 @@ pcps_acquisition_fine_doppler_cc::pcps_acquisition_fine_doppler_cc(const Acq_Con
d_fft_codes.reserve(d_fft_size);
d_magnitude.reserve(d_fft_size);
d_10_ms_buffer.reserve(50 * d_samples_per_ms);
#if GNURADIO_FFT_USES_TEMPLATES
// Direct FFT
d_fft_if = std::make_unique<gr::fft::fft_complex_fwd>(d_fft_size);
// Inverse FFT
d_ifft = std::make_unique<gr::fft::fft_complex_rev>(d_fft_size);
#else
// Direct FFT
d_fft_if = std::make_unique<gr::fft::fft_complex>(d_fft_size, true);
// Inverse FFT
d_ifft = std::make_unique<gr::fft::fft_complex>(d_fft_size, false);
#endif
d_fft_if = gnss_fft_fwd_make_unique(d_fft_size);
d_ifft = gnss_fft_rev_make_unique(d_fft_size);
// For dumping samples into a file
d_dump = conf_.dump;
@ -383,11 +355,9 @@ int pcps_acquisition_fine_doppler_cc::estimate_Doppler()
int signal_samples = prn_replicas * d_fft_size;
// int fft_size_extended = nextPowerOf2(signal_samples * zero_padding_factor);
int fft_size_extended = signal_samples * zero_padding_factor;
#if GNURADIO_FFT_USES_TEMPLATES
auto fft_operator = std::make_unique<gr::fft::fft_complex_fwd>(fft_size_extended);
#else
auto fft_operator = std::make_unique<gr::fft::fft_complex>(fft_size_extended, true);
#endif
auto fft_operator = gnss_fft_fwd_make_unique(fft_size_extended);
// zero padding the entire vector
std::fill_n(fft_operator->get_inbuf(), fft_size_extended, gr_complex(0.0, 0.0));

11
src/algorithms/acquisition/gnuradio_blocks/pcps_acquisition_fine_doppler_cc.h
View File

@ -41,10 +41,10 @@
#include "acq_conf.h"
#include "channel_fsm.h"
#include "gnss_sdr_fft.h"
#include "gnss_synchro.h"
#include <armadillo>
#include <gnuradio/block.h>
#include <gnuradio/fft/fft.h>
#include <gnuradio/gr_complex.h>
#include <volk_gnsssdr/volk_gnsssdr_alloc.h> // for volk_gnsssdr::vector
#include <cstdint>
@ -197,13 +197,8 @@ private:
bool start();
std::weak_ptr<ChannelFsm> d_channel_fsm;
#if GNURADIO_FFT_USES_TEMPLATES
std::unique_ptr<gr::fft::fft_complex_fwd> d_fft_if;
std::unique_ptr<gr::fft::fft_complex_rev> d_ifft;
#else
std::unique_ptr<gr::fft::fft_complex> d_fft_if;
std::unique_ptr<gr::fft::fft_complex> d_ifft;
#endif
std::unique_ptr<gnss_fft_complex_fwd> d_fft_if;
std::unique_ptr<gnss_fft_complex_rev> d_ifft;
volk_gnsssdr::vector<volk_gnsssdr::vector<std::complex<float>>> d_grid_doppler_wipeoffs;
volk_gnsssdr::vector<volk_gnsssdr::vector<float>> d_grid_data;

14
src/algorithms/acquisition/gnuradio_blocks/pcps_assisted_acquisition_cc.cc
View File

@ -19,7 +19,6 @@
#include "pcps_assisted_acquisition_cc.h"
#include "MATH_CONSTANTS.h"
#include "concurrent_map.h"
#include "gnss_sdr_make_unique.h"
#include "gps_acq_assist.h"
#include <glog/logging.h>
#include <gnuradio/io_signature.h>
@ -69,17 +68,8 @@ pcps_assisted_acquisition_cc::pcps_assisted_acquisition_cc(
d_disable_assist = false;
d_fft_codes.reserve(d_fft_size);
#if GNURADIO_FFT_USES_TEMPLATES
// Direct FFT
d_fft_if = std::make_unique<gr::fft::fft_complex_fwd>(d_fft_size);
// Inverse FFT
d_ifft = std::make_unique<gr::fft::fft_complex_rev>(d_fft_size);
#else
// Direct FFT
d_fft_if = std::make_unique<gr::fft::fft_complex>(d_fft_size, true);
// Inverse FFT
d_ifft = std::make_unique<gr::fft::fft_complex>(d_fft_size, false);
#endif
d_fft_if = gnss_fft_fwd_make_unique(d_fft_size);
d_ifft = gnss_fft_rev_make_unique(d_fft_size);
// For dumping samples into a file
d_dump = dump;

11
src/algorithms/acquisition/gnuradio_blocks/pcps_assisted_acquisition_cc.h
View File

@ -35,9 +35,9 @@
#define GNSS_SDR_PCPS_ASSISTED_ACQUISITION_CC_H
#include "channel_fsm.h"
#include "gnss_sdr_fft.h"
#include "gnss_synchro.h"
#include <gnuradio/block.h>
#include <gnuradio/fft/fft.h>
#include <gnuradio/gr_complex.h>
#include <fstream>
#include <memory>
@ -198,13 +198,8 @@ private:
void redefine_grid();
std::weak_ptr<ChannelFsm> d_channel_fsm;
#if GNURADIO_FFT_USES_TEMPLATES
std::unique_ptr<gr::fft::fft_complex_fwd> d_fft_if;
std::unique_ptr<gr::fft::fft_complex_rev> d_ifft;
#else
std::unique_ptr<gr::fft::fft_complex> d_fft_if;
std::unique_ptr<gr::fft::fft_complex> d_ifft;
#endif
std::unique_ptr<gnss_fft_complex_fwd> d_fft_if;
std::unique_ptr<gnss_fft_complex_rev> d_ifft;
std::vector<std::vector<std::complex<float>>> d_grid_doppler_wipeoffs;
std::vector<std::vector<float>> d_grid_data;

15
src/algorithms/acquisition/gnuradio_blocks/pcps_cccwsr_acquisition_cc.cc
View File

@ -22,7 +22,6 @@
#include "pcps_cccwsr_acquisition_cc.h"
#include "MATH_CONSTANTS.h" // TWO_PI
#include "gnss_sdr_make_unique.h"
#include <glog/logging.h>
#include <gnuradio/io_signature.h>
#include <volk/volk.h>
@ -86,17 +85,9 @@ pcps_cccwsr_acquisition_cc::pcps_cccwsr_acquisition_cc(
d_correlation_minus.reserve(d_fft_size);
d_magnitude.reserve(d_fft_size);
#if GNURADIO_FFT_USES_TEMPLATES
// Direct FFT
d_fft_if = std::make_unique<gr::fft::fft_complex_fwd>(d_fft_size);
// Inverse FFT
d_ifft = std::make_unique<gr::fft::fft_complex_rev>(d_fft_size);
#else
// Direct FFT
d_fft_if = std::make_unique<gr::fft::fft_complex>(d_fft_size, true);
// Inverse FFT
d_ifft = std::make_unique<gr::fft::fft_complex>(d_fft_size, false);
#endif
d_fft_if = gnss_fft_fwd_make_unique(d_fft_size);
d_ifft = gnss_fft_rev_make_unique(d_fft_size);
// For dumping samples into a file
d_dump = dump;
d_dump_filename = dump_filename;

11
src/algorithms/acquisition/gnuradio_blocks/pcps_cccwsr_acquisition_cc.h
View File

@ -24,9 +24,9 @@
#define GNSS_SDR_PCPS_CCCWSR_ACQUISITION_CC_H
#include "channel_fsm.h"
#include "gnss_sdr_fft.h"
#include "gnss_synchro.h"
#include <gnuradio/block.h>
#include <gnuradio/fft/fft.h>
#include <gnuradio/gr_complex.h>
#include <fstream>
#include <memory>
@ -183,13 +183,8 @@ private:
std::weak_ptr<ChannelFsm> d_channel_fsm;
#if GNURADIO_FFT_USES_TEMPLATES
std::unique_ptr<gr::fft::fft_complex_fwd> d_fft_if;
std::unique_ptr<gr::fft::fft_complex_rev> d_ifft;
#else
std::unique_ptr<gr::fft::fft_complex> d_fft_if;
std::unique_ptr<gr::fft::fft_complex> d_ifft;
#endif
std::unique_ptr<gnss_fft_complex_fwd> d_fft_if;
std::unique_ptr<gnss_fft_complex_rev> d_ifft;
std::vector<std::vector<gr_complex>> d_grid_doppler_wipeoffs;
std::vector<gr_complex> d_fft_code_data;

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

@ -36,7 +36,6 @@
#include "pcps_opencl_acquisition_cc.h"
#include "MATH_CONSTANTS.h" // TWO_PI
#include "gnss_sdr_make_unique.h"
#include "opencl/fft_base_kernels.h"
#include "opencl/fft_internal.h"
#include <glog/logging.h>
@ -112,10 +111,10 @@ pcps_opencl_acquisition_cc::pcps_opencl_acquisition_cc(
if (d_opencl != 0)
{
// Direct FFT
d_fft_if = std::make_unique<gr::fft::fft_complex>(d_fft_size, true);
d_fft_if = gnss_fft_fwd_make_unique(d_fft_size);
// Inverse FFT
d_ifft = std::make_unique<gr::fft::fft_complex>(d_fft_size, false);
d_ifft = gnss_fft_rev_make_unique(d_fft_size);
}
// For dumping samples into a file

6
src/algorithms/acquisition/gnuradio_blocks/pcps_opencl_acquisition_cc.h
View File

@ -40,10 +40,10 @@
#define CL_SILENCE_DEPRECATION
#include "channel_fsm.h"
#include "gnss_block_interface.h"
#include "gnss_sdr_fft.h"
#include "gnss_synchro.h"
#include "opencl/fft_internal.h"
#include <gnuradio/block.h>
#include <gnuradio/fft/fft.h>
#include <gnuradio/gr_complex.h>
#include "opencl/cl.hpp"
#include <cstdint>
@ -239,8 +239,8 @@ private:
std::weak_ptr<ChannelFsm> d_channel_fsm;
std::unique_ptr<gr::fft::fft_complex> d_fft_if;
std::unique_ptr<gr::fft::fft_complex> d_ifft;
std::unique_ptr<gnss_fft_complex_fwd> d_fft_if;
std::unique_ptr<gnss_fft_complex_rev> d_ifft;
std::vector<std::vector<gr_complex>> d_grid_doppler_wipeoffs;
std::vector<std::vector<gr_complex>> d_in_buffer;

14
src/algorithms/acquisition/gnuradio_blocks/pcps_quicksync_acquisition_cc.cc
View File

@ -16,7 +16,6 @@
#include "pcps_quicksync_acquisition_cc.h"
#include "MATH_CONSTANTS.h"
#include "gnss_sdr_make_unique.h"
#include <glog/logging.h>
#include <gnuradio/io_signature.h>
#include <volk/volk.h>
@ -95,17 +94,8 @@ pcps_quicksync_acquisition_cc::pcps_quicksync_acquisition_cc(
original form to perform later correlation in time domain*/
d_code = std::vector<gr_complex>(d_samples_per_code, lv_cmake(0.0F, 0.0F));
#if GNURADIO_FFT_USES_TEMPLATES
// Direct FFT
d_fft_if = std::make_unique<gr::fft::fft_complex_fwd>(d_fft_size);
// Inverse FFT
d_ifft = std::make_unique<gr::fft::fft_complex_rev>(d_fft_size);
#else
// Direct FFT
d_fft_if = std::make_unique<gr::fft::fft_complex>(d_fft_size, true);
// Inverse FFT
d_ifft = std::make_unique<gr::fft::fft_complex>(d_fft_size, false);
#endif
d_fft_if = gnss_fft_fwd_make_unique(d_fft_size);
d_ifft = gnss_fft_rev_make_unique(d_fft_size);
// For dumping samples into a file
d_dump = dump;

11
src/algorithms/acquisition/gnuradio_blocks/pcps_quicksync_acquisition_cc.h
View File

@ -38,9 +38,9 @@
#define GNSS_SDR_PCPS_QUICKSYNC_ACQUISITION_CC_H
#include "channel_fsm.h"
#include "gnss_sdr_fft.h"
#include "gnss_synchro.h"
#include <gnuradio/block.h>
#include <gnuradio/fft/fft.h>
#include <gnuradio/gr_complex.h>
#include <algorithm>
#include <cassert>
@ -212,13 +212,8 @@ private:
std::weak_ptr<ChannelFsm> d_channel_fsm;
#if GNURADIO_FFT_USES_TEMPLATES
std::unique_ptr<gr::fft::fft_complex_fwd> d_fft_if;
std::unique_ptr<gr::fft::fft_complex_rev> d_ifft;
#else
std::unique_ptr<gr::fft::fft_complex> d_fft_if;
std::unique_ptr<gr::fft::fft_complex> d_ifft;
#endif
std::unique_ptr<gnss_fft_complex_fwd> d_fft_if;
std::unique_ptr<gnss_fft_complex_rev> d_ifft;
std::vector<std::vector<gr_complex>> d_grid_doppler_wipeoffs;
std::vector<gr_complex> d_code;

15
src/algorithms/acquisition/gnuradio_blocks/pcps_tong_acquisition_cc.cc
View File

@ -36,7 +36,6 @@
#include "pcps_tong_acquisition_cc.h"
#include "MATH_CONSTANTS.h" // for TWO_PI
#include "gnss_sdr_make_unique.h"
#include <glog/logging.h>
#include <gnuradio/io_signature.h>
#include <volk/volk.h>
@ -102,17 +101,9 @@ pcps_tong_acquisition_cc::pcps_tong_acquisition_cc(
d_fft_codes.reserve(d_fft_size);
d_magnitude.reserve(d_fft_size);
#if GNURADIO_FFT_USES_TEMPLATES
// Direct FFT
d_fft_if = std::make_unique<gr::fft::fft_complex_fwd>(d_fft_size);
// Inverse FFT
d_ifft = std::make_unique<gr::fft::fft_complex_rev>(d_fft_size);
#else
// Direct FFT
d_fft_if = std::make_unique<gr::fft::fft_complex>(d_fft_size, true);
// Inverse FFT
d_ifft = std::make_unique<gr::fft::fft_complex>(d_fft_size, false);
#endif
d_fft_if = gnss_fft_fwd_make_unique(d_fft_size);
d_ifft = gnss_fft_rev_make_unique(d_fft_size);
// For dumping samples into a file
d_dump = dump;
d_dump_filename = dump_filename;

12
src/algorithms/acquisition/gnuradio_blocks/pcps_tong_acquisition_cc.h
View File

@ -38,9 +38,9 @@
#define GNSS_SDR_PCPS_TONG_ACQUISITION_CC_H
#include "channel_fsm.h"
#include "gnss_sdr_fft.h"
#include "gnss_synchro.h"
#include <gnuradio/block.h>
#include <gnuradio/fft/fft.h>
#include <gnuradio/gr_complex.h>
#include <fstream>
#include <memory> // for weak_ptr
@ -199,14 +199,8 @@ private:
int32_t doppler_offset);
std::weak_ptr<ChannelFsm> d_channel_fsm;
#if GNURADIO_FFT_USES_TEMPLATES
std::unique_ptr<gr::fft::fft_complex_fwd> d_fft_if;
std::unique_ptr<gr::fft::fft_complex_rev> d_ifft;
#else
std::unique_ptr<gr::fft::fft_complex> d_fft_if;
std::unique_ptr<gr::fft::fft_complex> d_ifft;
#endif
std::unique_ptr<gnss_fft_complex_fwd> d_fft_if;
std::unique_ptr<gnss_fft_complex_rev> d_ifft;
std::vector<std::vector<gr_complex>> d_grid_doppler_wipeoffs;
std::vector<std::vector<float>> d_grid_data;

9
src/algorithms/input_filter/gnuradio_blocks/CMakeLists.txt
View File

@ -43,8 +43,8 @@ target_link_libraries(input_filter_gr_blocks
Gnuradio::blocks
Gnuradio::filter
Volkgnsssdr::volkgnsssdr
PRIVATE
algorithms_libs
PRIVATE
Volk::volk
Log4cpp::log4cpp
)
@ -60,13 +60,6 @@ if(GNURADIO_USES_STD_POINTERS)
)
endif()
if(GNURADIO_FFT_USES_TEMPLATES)
target_compile_definitions(input_filter_gr_blocks
PUBLIC -DGNURADIO_FFT_USES_TEMPLATES=1
)
endif()
if(ENABLE_CLANG_TIDY)
if(CLANG_TIDY_EXE)
set_target_properties(input_filter_gr_blocks

7
src/algorithms/input_filter/gnuradio_blocks/notch_cc.cc
View File

@ -15,7 +15,6 @@
*/
#include "notch_cc.h"
#include "gnss_sdr_make_unique.h"
#include <boost/math/distributions/chi_squared.hpp>
#include <gnuradio/io_signature.h>
#include <volk/volk.h>
@ -57,11 +56,7 @@ Notch::Notch(float pfa,
angle_ = volk_gnsssdr::vector<float>(length_);
power_spect_ = volk_gnsssdr::vector<float>(length_);
last_out_ = gr_complex(0.0, 0.0);
#if GNURADIO_FFT_USES_TEMPLATES
d_fft_ = std::make_unique<gr::fft::fft_complex_fwd>(length_);
#else
d_fft_ = std::make_unique<gr::fft::fft_complex>(length_, true);
#endif
d_fft_ = gnss_fft_fwd_make_unique(length_);
}

9
src/algorithms/input_filter/gnuradio_blocks/notch_cc.h
View File

@ -19,8 +19,8 @@
#define GNSS_SDR_NOTCH_CC_H
#include "gnss_block_interface.h"
#include "gnss_sdr_fft.h"
#include <gnuradio/block.h>
#include <gnuradio/fft/fft.h>
#include <volk_gnsssdr/volk_gnsssdr_alloc.h> // for volk_gnsssdr::vector
#include <cstdint>
#include <memory>
@ -57,11 +57,8 @@ public:
private:
friend notch_sptr make_notch_filter(float pfa, float p_c_factor, int32_t length, int32_t n_segments_est, int32_t n_segments_reset);
Notch(float pfa, float p_c_factor, int32_t length, int32_t n_segments_est, int32_t n_segments_reset);
#if GNURADIO_FFT_USES_TEMPLATES
std::unique_ptr<gr::fft::fft_complex_fwd> d_fft_;
#else
std::unique_ptr<gr::fft::fft_complex> d_fft_;
#endif
std::unique_ptr<gnss_fft_complex_fwd> d_fft_;
volk_gnsssdr::vector<gr_complex> c_samples_;
volk_gnsssdr::vector<float> angle_;
volk_gnsssdr::vector<float> power_spect_;

7
src/algorithms/input_filter/gnuradio_blocks/notch_lite_cc.cc
View File

@ -16,7 +16,6 @@
*/
#include "notch_lite_cc.h"
#include "gnss_sdr_make_unique.h"
#include <boost/math/distributions/chi_squared.hpp>
#include <gnuradio/io_signature.h>
#include <volk/volk.h>
@ -63,11 +62,7 @@ NotchLite::NotchLite(float p_c_factor,
angle1_ = 0.0;
angle2_ = 0.0;
power_spect_ = volk_gnsssdr::vector<float>(length_);
#if GNURADIO_FFT_USES_TEMPLATES
d_fft_ = std::make_unique<gr::fft::fft_complex_fwd>(length_);
#else
d_fft_ = std::make_unique<gr::fft::fft_complex>(length_, true);
#endif
d_fft_ = gnss_fft_fwd_make_unique(length_);
}

9
src/algorithms/input_filter/gnuradio_blocks/notch_lite_cc.h
View File

@ -19,8 +19,8 @@
#define GNSS_SDR_NOTCH_LITE_CC_H
#include "gnss_block_interface.h"
#include "gnss_sdr_fft.h"
#include <gnuradio/block.h>
#include <gnuradio/fft/fft.h>
#include <volk_gnsssdr/volk_gnsssdr_alloc.h> // for volk_gnsssdr::vector
#include <cstdint>
#include <memory>
@ -58,11 +58,8 @@ public:
private:
friend notch_lite_sptr make_notch_filter_lite(float p_c_factor, float pfa, int32_t length, int32_t n_segments_est, int32_t n_segments_reset, int32_t n_segments_coeff);
NotchLite(float p_c_factor, float pfa, int32_t length, int32_t n_segments_est, int32_t n_segments_reset, int32_t n_segments_coeff);
#if GNURADIO_FFT_USES_TEMPLATES
std::unique_ptr<gr::fft::fft_complex_fwd> d_fft_;
#else
std::unique_ptr<gr::fft::fft_complex> d_fft_;
#endif
std::unique_ptr<gnss_fft_complex_fwd> d_fft_;
volk_gnsssdr::vector<float> power_spect_;
gr_complex last_out_;
gr_complex z_0_;

35
src/algorithms/libs/CMakeLists.txt
View File

@ -54,6 +54,8 @@ set(GNSS_SPLIBS_HEADERS
conjugate_ic.h
cshort_to_float_x2.h
gnss_sdr_create_directory.h
gnss_sdr_fft.h
gnss_sdr_filesystem.h
gnss_sdr_make_unique.h
gnss_circular_deque.h
geofunctions.h
@ -87,16 +89,6 @@ else()
add_library(algorithms_libs ${GNSS_SPLIBS_SOURCES} ${GNSS_SPLIBS_HEADERS})
endif()
if(${FILESYSTEM_FOUND})
target_compile_definitions(algorithms_libs PRIVATE -DHAS_STD_FILESYSTEM=1)
if(${find_experimental})
target_compile_definitions(algorithms_libs PRIVATE -DHAS_STD_FILESYSTEM_EXPERIMENTAL=1)
endif()
target_link_libraries(algorithms_libs PRIVATE std::filesystem)
else()
target_link_libraries(algorithms_libs PRIVATE Boost::filesystem Boost::system)
endif()
if(NOT has_span)
target_include_directories(algorithms_libs
PUBLIC
@ -110,6 +102,7 @@ target_link_libraries(algorithms_libs
Boost::headers
Gnuradio::runtime
Gnuradio::blocks
Gnuradio::fft
PRIVATE
core_system_parameters
Volk::volk
@ -124,12 +117,28 @@ if(GNURADIO_USES_STD_POINTERS)
)
endif()
if(FILESYSTEM_FOUND)
target_compile_definitions(algorithms_libs PUBLIC -DHAS_STD_FILESYSTEM=1)
if(find_experimental)
target_compile_definitions(algorithms_libs PUBLIC -DHAS_STD_FILESYSTEM_EXPERIMENTAL=1)
endif()
target_link_libraries(algorithms_libs PUBLIC std::filesystem)
else()
target_link_libraries(algorithms_libs PUBLIC Boost::filesystem Boost::system)
endif()
if(has_span)
target_compile_definitions(algorithms_libs
PUBLIC -DHAS_STD_SPAN=1
)
endif()
if(GNURADIO_FFT_USES_TEMPLATES)
target_compile_definitions(algorithms_libs
PUBLIC -DGNURADIO_FFT_USES_TEMPLATES=1
)
endif()
if(ENABLE_OPENCL)
target_link_libraries(algorithms_libs PUBLIC OpenCL::OpenCL)
target_include_directories(algorithms_libs PUBLIC
@ -187,14 +196,14 @@ else()
add_library(gnss_sdr_flags gnss_sdr_flags.cc gnss_sdr_flags.h)
endif()
if(${FILESYSTEM_FOUND})
if(FILESYSTEM_FOUND)
target_compile_definitions(gnss_sdr_flags PRIVATE -DHAS_STD_FILESYSTEM=1)
if(${find_experimental})
if(find_experimental)
target_compile_definitions(gnss_sdr_flags PRIVATE -DHAS_STD_FILESYSTEM_EXPERIMENTAL=1)
endif()
target_link_libraries(gnss_sdr_flags PRIVATE std::filesystem)
else()
target_link_libraries(gnss_sdr_flags PRIVATE Boost::filesystem)
target_link_libraries(gnss_sdr_flags PRIVATE Boost::filesystem Boost::system)
endif()
target_link_libraries(gnss_sdr_flags

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

@ -20,7 +20,7 @@
#include <array>
#include <cmath> // for sin, cos, sqrt, abs, pow
const double STRP_PI = 3.1415926535898; // Pi as defined in IS-GPS-200K
const double STRP_PI = 3.1415926535898; // Pi as defined in IS-GPS-200L
arma::mat Skew_symmetric(const arma::vec &a)
{

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

@ -16,30 +16,10 @@
*/
#include "gnss_sdr_create_directory.h"
#include "gnss_sdr_filesystem.h"
#include <exception> // for exception
#include <fstream> // for ofstream
// 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 create_directories, exists
#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
bool gnss_sdr_create_directory(const std::string& foldername)
{
std::string new_folder;

63
src/algorithms/libs/gnss_sdr_fft.h Normal file
View File

@ -0,0 +1,63 @@
/*!
* \file gnss_sdr_fft.h
* \brief Helper file for FFT interface
* \author Carles Fernandez Prades, 2021. cfernandez(at)cttc.es
*
* -----------------------------------------------------------------------------
*
* GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
* This file is part of GNSS-SDR.
*
* Copyright (C) 2010-2021 (see AUTHORS file for a list of contributors)
* SPDX-License-Identifier: GPL-3.0-or-later
*
* -----------------------------------------------------------------------------
*/
#ifndef GNSS_SDR_GNSS_SDR_FFT_H
#define GNSS_SDR_GNSS_SDR_FFT_H
#include "gnss_sdr_make_unique.h"
#include <gnuradio/fft/fft.h>
#if GNURADIO_FFT_USES_TEMPLATES
using gnss_fft_complex_fwd = gr::fft::fft_complex_fwd;
using gnss_fft_complex_rev = gr::fft::fft_complex_rev;
template <typename T>
using gnss_fft_fwd_unique_ptr = std::unique_ptr<T>;
template <typename... Args>
gnss_fft_fwd_unique_ptr<gr::fft::fft_complex_fwd> gnss_fft_fwd_make_unique(Args&&... args)
{
return std::make_unique<gr::fft::fft_complex_fwd>(std::forward<Args>(args)...);
}
template <typename T>
using gnss_fft_rev_unique_ptr = std::unique_ptr<T>;
template <typename... Args>
gnss_fft_rev_unique_ptr<gr::fft::fft_complex_rev> gnss_fft_rev_make_unique(Args&&... args)
{
return std::make_unique<gr::fft::fft_complex_rev>(std::forward<Args>(args)...);
}
#else
using gnss_fft_complex_fwd = gr::fft::fft_complex;
using gnss_fft_complex_rev = gr::fft::fft_complex;
template <typename T>
using gnss_fft_fwd_unique_ptr = std::unique_ptr<T>;
template <typename... Args>
gnss_fft_fwd_unique_ptr<gr::fft::fft_complex> gnss_fft_fwd_make_unique(Args&&... args)
{
return std::make_unique<gr::fft::fft_complex>(std::forward<Args>(args)..., true);
}
template <typename T>
using gnss_fft_rev_unique_ptr = std::unique_ptr<T>;
template <typename... Args>
gnss_fft_rev_unique_ptr<gr::fft::fft_complex> gnss_fft_rev_make_unique(Args&&... args)
{
return std::make_unique<gr::fft::fft_complex>(std::forward<Args>(args)..., false);
}
#endif
#endif // GNSS_SDR_GNSS_SDR_FFT_H

43
src/algorithms/libs/gnss_sdr_filesystem.h Normal file
View File

@ -0,0 +1,43 @@
/*!
* \file gnss_sdr_filesystem.h
* \brief Helper file for fylesystem library interface
* \author Carles Fernandez Prades, 2021. cfernandez(at)cttc.es
*
* -----------------------------------------------------------------------------
*
* GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
* This file is part of GNSS-SDR.
*
* Copyright (C) 2010-2021 (see AUTHORS file for a list of contributors)
* SPDX-License-Identifier: GPL-3.0-or-later
*
* -----------------------------------------------------------------------------
*/
#ifndef GNSS_SDR_GNSS_SDR_FILESYSTEM_H
#define GNSS_SDR_GNSS_SDR_FILESYSTEM_H
// 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 create_directories, exists
#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
#endif // GNSS_SDR_GNSS_SDR_FILESYSTEM_H

14
src/algorithms/libs/gnss_sdr_flags.cc
View File

@ -17,22 +17,10 @@
#include "gnss_sdr_flags.h"
#include "gnss_sdr_filesystem.h"
#include <iostream>
#include <string>
#if HAS_STD_FILESYSTEM
#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 exists
namespace fs = boost::filesystem;
#endif
DEFINE_string(c, "-", "Path to the configuration file (if set, overrides --config_file).");

4
src/algorithms/libs/rtklib/rtklib_conversions.cc
View File

@ -354,13 +354,13 @@ eph_t eph_to_rtklib(const Gps_CNAV_Ephemeris& gps_cnav_eph)
eph_t rtklib_sat = {0, 0, 0, 0, 0, 0, 0, 0, {0, 0}, {0, 0}, {0, 0}, 0.0, 0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, {}, {}, 0.0, 0.0};
rtklib_sat.sat = gps_cnav_eph.i_satellite_PRN;
const double A_REF = 26559710.0; // See IS-GPS-200K, pp. 170
const double A_REF = 26559710.0; // See IS-GPS-200L, pp. 161
rtklib_sat.A = A_REF + gps_cnav_eph.d_DELTA_A;
rtklib_sat.M0 = gps_cnav_eph.d_M_0;
rtklib_sat.deln = gps_cnav_eph.d_Delta_n;
rtklib_sat.OMG0 = gps_cnav_eph.d_OMEGA0;
// Compute the angle between the ascending node and the Greenwich meridian
const double OMEGA_DOT_REF = -2.6e-9; // semicircles / s, see IS-GPS-200K pp. 164
const double OMEGA_DOT_REF = -2.6e-9; // semicircles / s, see IS-GPS-200L pp. 160
double d_OMEGA_DOT = OMEGA_DOT_REF * GNSS_PI + gps_cnav_eph.d_DELTA_OMEGA_DOT;
rtklib_sat.OMGd = d_OMEGA_DOT;
rtklib_sat.omg = gps_cnav_eph.d_OMEGA;

2
src/algorithms/libs/rtklib/rtklib_rtkcmn.cc
View File

@ -1727,7 +1727,7 @@ double timediff(gtime_t t1, gtime_t t2)
*-----------------------------------------------------------------------------*/
double timediffweekcrossover(gtime_t t1, gtime_t t2)
{
// as stated in IS-GPS-200K table 20-IV footnote among other parts of the ICD,
// as stated in IS-GPS-200L table 20-IV footnote among other parts of the ICD,
// if tk=(t - toe) > 302400s then tk = tk - s
// if tk=(t - toe) < -302400s then tk = tk + 604800s
double tk = difftime(t1.time, t2.time) + t1.sec - t2.sec;

2
src/algorithms/libs/rtklib/rtklib_rtkcmn.h
View File

@ -29,7 +29,7 @@
*
*
* References :
* [1] IS-GPS-200K, Navstar GPS Space Segment/Navigation User Interfaces,
* [1] IS-GPS-200L, Navstar GPS Space Segment/Navigation User Interfaces,
* 7 March, 2006
* [2] RTCA/DO-229C, Minimum operational performanc standards for global
* positioning system/wide area augmentation system airborne equipment,

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

@ -1,7 +1,7 @@
# GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
# This file is part of GNSS-SDR.
#
# SPDX-FileCopyrightText: 2010-2020 C. Fernandez-Prades cfernandez(at)cttc.es
# SPDX-FileCopyrightText: 2010-2021 C. Fernandez-Prades cfernandez(at)cttc.es
# SPDX-License-Identifier: BSD-3-Clause
@ -203,7 +203,7 @@ message(STATUS "Build type set to ${CMAKE_BUILD_TYPE}.")
set(VERSION_INFO_MAJOR_VERSION 0)
set(VERSION_INFO_MINOR_VERSION 0)
set(VERSION_INFO_MAINT_VERSION 14)
set(VERSION_INFO_MAINT_VERSION 14.git)
include(VolkVersion) # setup version info
@ -244,6 +244,8 @@ endif()
########################################################################
# cpu_features
option(ENABLE_OWN_CPUFEATURES "Force the building of the cpu_features library even if it is already installed" OFF)
set(SUPPORTED_CPU_FEATURES_ARCH FALSE)
if(CMAKE_SYSTEM_PROCESSOR MATCHES "^mips")
set(SUPPORTED_CPU_FEATURES_ARCH TRUE)
@ -265,7 +267,14 @@ if(CMAKE_VERSION VERSION_GREATER 3.0 AND SUPPORTED_CPU_FEATURES_ARCH)
set(USE_CPU_FEATURES ON)
set(BUILD_SHARED_LIBS_SAVED "${BUILD_SHARED_LIBS}")
set(BUILD_SHARED_LIBS OFF)
add_subdirectory(cpu_features)
if(NOT ENABLE_OWN_CPUFEATURES)
find_package(CpuFeatures QUIET)
endif()
if(CpuFeatures_FOUND)
message(STATUS "Found CpuFeatures: (found version ${CpuFeatures_VERSION})")
else()
add_subdirectory(cpu_features)
endif()
set(BUILD_SHARED_LIBS "${BUILD_SHARED_LIBS_SAVED}")
endif()

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

@ -6,7 +6,7 @@ SPDX-License-Identifier: GPL-3.0-or-later
)
[comment]: # (
SPDX-FileCopyrightText: 2011-2020 Carles Fernandez-Prades <carles.fernandez@cttc.es>
SPDX-FileCopyrightText: 2011-2021 Carles Fernandez-Prades <carles.fernandez@cttc.es>
)
<!-- prettier-ignore-end -->
@ -57,6 +57,12 @@ not found by CMake on your system at configure time.
However, you can install and use VOLK_GNSSSDR kernels as you use VOLK's,
independently of GNSS-SDR.
If you want to install the VOLK and VOLK_GNSSSDR libraries in the same machine,
please install VOLK before building VOLK_GNSSSDR in order to avoid a clash of
the [cpu_features](https://github.com/google/cpu_features) library, used
internally by both. The CMake script will detect the presence of cpu_features
and will make use of it if already installed, thus avoiding to install it twice.
### Install dependencies
First, make sure that the required dependencies are installed in your machine:

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

@ -1,7 +1,7 @@
# GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
# This file is part of GNSS-SDR.
#
# SPDX-FileCopyrightText: 2010-2020 C. Fernandez-Prades cfernandez(at)cttc.es
# SPDX-FileCopyrightText: 2010-2021 C. Fernandez-Prades cfernandez(at)cttc.es
# SPDX-License-Identifier: BSD-3-Clause
@ -532,10 +532,17 @@ if(NOT (CMAKE_GENERATOR STREQUAL Xcode))
PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
)
if(USE_CPU_FEATURES)
target_include_directories(volk_gnsssdr_obj
PRIVATE
$<TARGET_PROPERTY:cpu_features,INTERFACE_INCLUDE_DIRECTORIES>
)
if(CpuFeatures_FOUND)
target_include_directories(volk_gnsssdr_obj
PRIVATE
$<TARGET_PROPERTY:CpuFeatures::cpu_features,INTERFACE_INCLUDE_DIRECTORIES>
)
else()
target_include_directories(volk_gnsssdr_obj
PRIVATE
$<TARGET_PROPERTY:cpu_features,INTERFACE_INCLUDE_DIRECTORIES>
)
endif()
endif()
# Configure object target properties
if(NOT MSVC)
@ -550,10 +557,17 @@ else()
add_library(volk_gnsssdr SHARED $<TARGET_OBJECTS:volk_gnsssdr_obj>)
endif()
if(USE_CPU_FEATURES)
target_link_libraries(volk_gnsssdr
PUBLIC ${volk_gnsssdr_libraries}
PRIVATE cpu_features
)
if(CpuFeatures_FOUND)
target_link_libraries(volk_gnsssdr
PUBLIC ${volk_gnsssdr_libraries}
PRIVATE CpuFeatures::cpu_features
)
else()
target_link_libraries(volk_gnsssdr
PUBLIC ${volk_gnsssdr_libraries}
PRIVATE cpu_features
)
endif()
else()
target_link_libraries(volk_gnsssdr PUBLIC ${volk_gnsssdr_libraries})
endif()
@ -566,10 +580,17 @@ target_include_directories(volk_gnsssdr
PUBLIC $<INSTALL_INTERFACE:include>
)
if(USE_CPU_FEATURES)
target_include_directories(volk_gnsssdr
PRIVATE
$<TARGET_PROPERTY:cpu_features,INTERFACE_INCLUDE_DIRECTORIES>
)
if(CpuFeatures_FOUND)
target_include_directories(volk_gnsssdr
PRIVATE
$<TARGET_PROPERTY:CpuFeatures::cpu_features,INTERFACE_INCLUDE_DIRECTORIES>
)
else()
target_include_directories(volk_gnsssdr
PRIVATE
$<TARGET_PROPERTY:cpu_features,INTERFACE_INCLUDE_DIRECTORIES>
)
endif()
endif()
# Configure target properties
if(ORC_FOUND)
@ -598,9 +619,15 @@ if(ENABLE_STATIC_LIBS)
endif()
target_link_libraries(volk_gnsssdr_static PUBLIC ${volk_gnsssdr_libraries})
if(USE_CPU_FEATURES)
target_link_libraries(volk_gnsssdr_static
PRIVATE cpu_features
)
if(CpuFeatures_FOUND)
target_link_libraries(volk_gnsssdr_static
PRIVATE CpuFeatures::cpu_features
)
else()
target_link_libraries(volk_gnsssdr_static
PRIVATE cpu_features
)
endif()
endif()
if(ORC_FOUND)
target_link_libraries(volk_gnsssdr_static PUBLIC ${ORC_LIBRARIES_STATIC})

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

@ -18,16 +18,6 @@ else()
add_library(obs_gr_blocks hybrid_observables_gs.cc hybrid_observables_gs.h)
endif()
if(${FILESYSTEM_FOUND})
target_compile_definitions(obs_gr_blocks PRIVATE -DHAS_STD_FILESYSTEM=1)
if(${find_experimental})
target_compile_definitions(obs_gr_blocks PRIVATE -DHAS_STD_FILESYSTEM_EXPERIMENTAL=1)
endif()
target_link_libraries(obs_gr_blocks PRIVATE std::filesystem)
else()
target_link_libraries(obs_gr_blocks PRIVATE Boost::filesystem)
endif()
target_include_directories(obs_gr_blocks
PUBLIC
${CMAKE_SOURCE_DIR}/src/algorithms/libs

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

@ -20,6 +20,7 @@
#include "gnss_circular_deque.h"
#include "gnss_frequencies.h"
#include "gnss_sdr_create_directory.h"
#include "gnss_sdr_filesystem.h"
#include "gnss_sdr_make_unique.h"
#include "gnss_synchro.h"
#include <glog/logging.h>
@ -38,27 +39,6 @@
#include <boost/bind/bind.hpp>
#endif
// 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 create_directories, exists
#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
hybrid_observables_gs_sptr hybrid_observables_gs_make(const Obs_Conf &conf_)
{

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

@ -162,7 +162,7 @@ bool gps_l1_ca_telemetry_decoder_gs::gps_word_parityCheck(uint32_t gpsword)
{
// XOR as many bits in parallel as possible. The magic constants pick
// up bits which are to be XOR'ed together to implement the GPS parity
// check algorithm described in IS-GPS-200K. This avoids lengthy shift-
// check algorithm described in IS-GPS-200L. This avoids lengthy shift-
// and-xor loops.
const uint32_t d1 = gpsword & 0xFBFFBF00U;
const uint32_t d2 = my_rotl::rotl(gpsword, 1U) & 0x07FFBF01U;

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

@ -47,7 +47,7 @@ gps_l1_ca_telemetry_decoder_gs_sptr gps_l1_ca_make_telemetry_decoder_gs(
const Tlm_Conf &conf);
/*!
* \brief This class implements a block that decodes the NAV data defined in IS-GPS-200K
* \brief This class implements a block that decodes the NAV data defined in IS-GPS-200L
*/
class gps_l1_ca_telemetry_decoder_gs : public gr::block
{

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

@ -48,7 +48,7 @@ gps_l2c_telemetry_decoder_gs_sptr gps_l2c_make_telemetry_decoder_gs(
const Tlm_Conf &conf);
/*!
* \brief This class implements a block that decodes CNAV data defined in IS-GPS-200K
* \brief This class implements a block that decodes CNAV data defined in IS-GPS-200L
*/
class gps_l2c_telemetry_decoder_gs : public gr::block
{

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

@ -43,21 +43,12 @@ target_link_libraries(telemetry_decoder_libs
PUBLIC
Volkgnsssdr::volkgnsssdr
PRIVATE
algorithms_libs
Gflags::gflags
Glog::glog
Matio::matio
)
if(FILESYSTEM_FOUND)
target_compile_definitions(telemetry_decoder_libs PRIVATE -DHAS_STD_FILESYSTEM=1)
if(find_experimental)
target_compile_definitions(telemetry_decoder_libs PRIVATE -DHAS_STD_FILESYSTEM_EXPERIMENTAL=1)
endif()
target_link_libraries(telemetry_decoder_libs PRIVATE std::filesystem)
else()
target_link_libraries(telemetry_decoder_libs PRIVATE Boost::filesystem Boost::system)
endif()
target_include_directories(telemetry_decoder_libs
PUBLIC
${CMAKE_SOURCE_DIR}/src/core/interfaces

21
src/algorithms/telemetry_decoder/libs/tlm_utils.cc
View File

@ -15,6 +15,7 @@
*/
#include "tlm_utils.h"
#include "gnss_sdr_filesystem.h"
#include <matio.h>
#include <array>
#include <cstdint>
@ -22,26 +23,6 @@
#include <iostream>
#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
int save_tlm_matfile(const std::string &dumpfile)
{

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

@ -77,21 +77,12 @@ else()
)
endif()
if(${FILESYSTEM_FOUND})
target_compile_definitions(tracking_gr_blocks PRIVATE -DHAS_STD_FILESYSTEM=1)
if(${find_experimental})
target_compile_definitions(tracking_gr_blocks PRIVATE -DHAS_STD_FILESYSTEM_EXPERIMENTAL=1)
endif()
target_link_libraries(tracking_gr_blocks PRIVATE std::filesystem)
else()
target_link_libraries(tracking_gr_blocks PRIVATE Boost::filesystem)
endif()
target_link_libraries(tracking_gr_blocks
PUBLIC
Gnuradio::blocks
tracking_libs
PRIVATE
algorithms_libs
Matio::matio
gnss_sdr_flags
Glog::glog

14
src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking.cc
View File

@ -38,6 +38,7 @@
#include "galileo_e6_signal_replica.h"
#include "gnss_satellite.h"
#include "gnss_sdr_create_directory.h"
#include "gnss_sdr_filesystem.h"
#include "gnss_synchro.h"
#include "gps_l2c_signal_replica.h"
#include "gps_l5_signal_replica.h"
@ -64,19 +65,6 @@
#include <boost/bind/bind.hpp>
#endif
#if HAS_STD_FILESYSTEM
#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/path.hpp>
namespace fs = boost::filesystem;
#endif
dll_pll_veml_tracking_sptr dll_pll_veml_make_tracking(const Dll_Pll_Conf &conf_)
{

13
src/algorithms/tracking/gnuradio_blocks/dll_pll_veml_tracking_fpga.cc
View File

@ -30,6 +30,7 @@
#include "fpga_multicorrelator.h"
#include "gnss_satellite.h"
#include "gnss_sdr_create_directory.h"
#include "gnss_sdr_filesystem.h"
#include "gnss_synchro.h"
#include "gps_sdr_signal_replica.h"
#include "lock_detectors.h"
@ -53,18 +54,6 @@
#include <boost/bind/bind.hpp>
#endif
#if HAS_STD_FILESYSTEM
#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/path.hpp>
namespace fs = boost::filesystem;
#endif
dll_pll_veml_tracking_fpga_sptr dll_pll_veml_make_tracking_fpga(const Dll_Pll_Conf_Fpga &conf_)
{

10
src/core/libs/CMakeLists.txt
View File

@ -123,15 +123,7 @@ if(USE_BOOST_BIND_PLACEHOLDERS)
endif()
if(ENABLE_FPGA OR ENABLE_AD9361)
if(FILESYSTEM_FOUND)
target_compile_definitions(core_libs PRIVATE -DHAS_STD_FILESYSTEM=1)
if(find_experimental)
target_compile_definitions(core_libs PRIVATE -DHAS_STD_FILESYSTEM_EXPERIMENTAL=1)
endif()
target_link_libraries(core_libs PRIVATE std::filesystem)
else()
target_link_libraries(core_libs PRIVATE Boost::filesystem Boost::system)
endif()
target_link_libraries(core_libs PRIVATE algorithms_libs)
endif()
if(ENABLE_CLANG_TIDY)

2
src/core/libs/supl/asn-rrlp/converter-sample.c
View File

@ -500,7 +500,7 @@ static void buffer_dump()
}
else
{
fprintf(stderr, " %ld\n", DynamicBuffer.length);
fprintf(stderr, " %lu\n", DynamicBuffer.length);
}
}

14
src/core/libs/uio_fpga.cc
View File

@ -16,6 +16,7 @@
*/
#include "uio_fpga.h"
#include "gnss_sdr_filesystem.h"
#include <algorithm> // sort
#include <cstdlib> // atoi, size_t
#include <fstream> // ifstream
@ -24,19 +25,6 @@
#include <sstream> // std::stringstream
#include <vector>
#if HAS_STD_FILESYSTEM
#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.hpp>
#include <boost/filesystem/path.hpp>
namespace fs = boost::filesystem;
#endif
int32_t get_uio_num(std::string uio_name)
{

11
src/core/monitor/CMakeLists.txt
View File

@ -53,14 +53,19 @@ target_link_libraries(core_monitor
Gnuradio::pmt
)
get_filename_component(PROTO_INCLUDE_HEADERS ${PROTO_HDRS} DIRECTORY)
get_filename_component(PROTO_INCLUDE_HEADERS_DIR ${PROTO_HDRS} DIRECTORY)
target_include_directories(core_monitor
PUBLIC
SYSTEM ${PROTO_INCLUDE_HEADERS}
${CMAKE_SOURCE_DIR}/src/core/interfaces
PRIVATE
${CMAKE_SOURCE_DIR}/src/algorithms/libs # for gnss_sdr_make_unique
${CMAKE_SOURCE_DIR}/src/algorithms/libs # for gnss_sdr_make_unique
)
# Do not apply clang-tidy fixes to protobuf generated headers
target_include_directories(core_monitor
SYSTEM PUBLIC
${PROTO_INCLUDE_HEADERS_DIR}
)
if(GNURADIO_USES_STD_POINTERS)

2
src/core/system_parameters/GLONASS_L1_L2_CA.h
View File

@ -240,7 +240,7 @@ const std::vector<int32_t> GLONASS_GNAV_CRC_P_INDEX{66, 67, 68, 69, 70, 71, 72,
const std::vector<int32_t> GLONASS_GNAV_CRC_Q_INDEX{9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85};
// GLONASS GNAV NAVIGATION MESSAGE STRUCTURE
// NAVIGATION MESSAGE FIELDS POSITIONS (from IS-GPS-200K Appendix II)
// NAVIGATION MESSAGE FIELDS POSITIONS (from IS-GPS-200L Appendix II)
// FRAME 1-4
// COMMON FIELDS

2
src/core/system_parameters/GPS_CNAV.h
View File

@ -30,7 +30,7 @@
// CNAV GPS NAVIGATION MESSAGE STRUCTURE
// NAVIGATION MESSAGE FIELDS POSITIONS (from IS-GPS-200K Appendix III)
// NAVIGATION MESSAGE FIELDS POSITIONS (from IS-GPS-200L Appendix III)
constexpr int32_t GPS_CNAV_DATA_PAGE_BITS = 300;

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

@ -73,7 +73,7 @@ constexpr char GPS_CA_PREAMBLE[9] = "10001011";
constexpr char GPS_CA_PREAMBLE_SYMBOLS_STR[161] = "1111111111111111111100000000000000000000000000000000000000000000000000000000000011111111111111111111000000000000000000001111111111111111111111111111111111111111";
// GPS NAVIGATION MESSAGE STRUCTURE
// NAVIGATION MESSAGE FIELDS POSITIONS (from IS-GPS-200K Appendix II)
// NAVIGATION MESSAGE FIELDS POSITIONS (from IS-GPS-200L Appendix II)
// SUBFRAME 1-5 (TLM and HOW)

8
src/core/system_parameters/MATH_CONSTANTS.h
View File

@ -28,12 +28,12 @@ constexpr double SPEED_OF_LIGHT_M_S = 299792458.0; //!< Speed of light in
constexpr double SPEED_OF_LIGHT_M_MS = 299792.4580; //!< Speed of light in vacuum [m/ms]
// Physical constants for GPS
constexpr double GPS_GM = 3.986005e14; //!< Universal gravitational constant times the mass of the Earth, [m^3/s^2] IS-GPS-200K, pag 92
constexpr double GPS_F = -4.442807633e-10; //!< Constant, [s/(m)^(1/2)], IS-GPS-200K, pag. 92
constexpr double GPS_GM = 3.986005e14; //!< Universal gravitational constant times the mass of the Earth, [m^3/s^2] IS-GPS-200L, pag 96
constexpr double GPS_F = -4.442807633e-10; //!< Constant, [s/(m)^(1/2)], IS-GPS-200L, pag. 95
// Physical constants for Galileo
constexpr double GALILEO_GM = 3.986004418e14; //!< Geocentric gravitational constant[m^3/s^2], OS SIS ICD v1.3, pag. 44
constexpr double GALILEO_F = -4.442807309e-10; //!< Constant, [s/(m)^(1/2)]. OS SIS ICD v1.3, pag. 47
constexpr double GALILEO_GM = 3.986004418e14; //!< Geocentric gravitational constant[m^3/s^2], OS SIS ICD v2.0, pag. 44
constexpr double GALILEO_F = -4.442807309e-10; //!< Constant, [s/(m)^(1/2)]. OS SIS ICD v2.0, pag. 47
// Physical constants for GLONASS
constexpr double GLONASS_OMEGA_EARTH_DOT = 7.292115e-5; //!< Earth rotation rate, [rad/s] ICD L1, L2 GLONASS Edition 5.1 2008 pag. 55

20
src/core/system_parameters/beidou_dnav_ephemeris.h
View File

@ -45,20 +45,20 @@ public:
/*!
* \brief Compute the ECEF SV coordinates and ECEF velocity
* Implementation of Table 20-IV (IS-GPS-200K)
* Implementation of Table 20-IV (IS-GPS-200L)
* and compute the clock bias term including relativistic effect (return value)
*/
double satellitePosition(double transmitTime);
/*!
* \brief Sets (\a d_satClkDrift)and returns the clock drift in seconds according to the User Algorithm for SV Clock Correction
* (IS-GPS-200K, 20.3.3.3.3.1)
* (IS-GPS-200L, 20.3.3.3.3.1)
*/
double sv_clock_drift(double transmitTime);
/*!
* \brief Sets (\a d_dtr) and returns the clock relativistic correction term in seconds according to the User Algorithm for SV Clock Correction
* (IS-GPS-200K, 20.3.3.3.3.1)
* (IS-GPS-200L, 20.3.3.3.3.1)
*/
double sv_clock_relativistic_term(double transmitTime);
@ -71,8 +71,8 @@ public:
double d_eccentricity{}; //!< Eccentricity [dimensionless]
double d_Cus{}; //!< Amplitude of the Sine Harmonic Correction Term to the Argument of Latitude [rad]
double d_sqrt_A{}; //!< Square Root of the Semi-Major Axis [sqrt(m)]
double d_Toe{}; //!< Ephemeris data reference time of week (Ref. 20.3.3.4.3 IS-GPS-200K) [s]
double d_Toc{}; //!< clock data reference time (Ref. 20.3.3.3.3.1 IS-GPS-200K) [s]
double d_Toe{}; //!< Ephemeris data reference time of week (Ref. 20.3.3.4.3 IS-GPS-200L) [s]
double d_Toc{}; //!< clock data reference time (Ref. 20.3.3.3.3.1 IS-GPS-200L) [s]
double d_Cic{}; //!< Amplitude of the Cosine Harmonic Correction Term to the Angle of Inclination [rad]
double d_OMEGA0{}; //!< Longitude of Ascending Node of Orbit Plane at Weekly Epoch [semi-circles]
double d_Cis{}; //!< Amplitude of the Sine Harmonic Correction Term to the Angle of Inclination [rad]
@ -82,7 +82,7 @@ public:
double d_OMEGA_DOT{}; //!< Rate of Right Ascension [semi-circles/s]
double d_IDOT{}; //!< Rate of Inclination Angle [semi-circles/s]
int i_BEIDOU_week{}; //!< BEIDOU week number, aka WN [week]
int i_SV_accuracy{}; //!< User Range Accuracy (URA) index of the SV (reference paragraph 6.2.1) for the standard positioning service user (Ref 20.3.3.3.1.3 IS-GPS-200K)
int i_SV_accuracy{}; //!< User Range Accuracy (URA) index of the SV (reference paragraph 6.2.1) for the standard positioning service user (Ref 20.3.3.3.1.3 IS-GPS-200L)
int i_SV_health{};
double d_TGD1{}; //!< Estimated Group Delay Differential on B1I [s]
double d_TGD2{}; //!< Estimated Group Delay Differential on B2I [s]
@ -154,8 +154,8 @@ public:
archive& make_nvp("d_e_eccentricity", d_eccentricity); //!< Eccentricity [dimensionless]
archive& make_nvp("d_Cus", d_Cus); //!< Amplitude of the Sine Harmonic Correction Term to the Argument of Latitude [rad]
archive& make_nvp("d_sqrt_A", d_sqrt_A); //!< Square Root of the Semi-Major Axis [sqrt(m)]
archive& make_nvp("d_Toe", d_Toe); //!< Ephemeris data reference time of week (Ref. 20.3.3.4.3 IS-GPS-200K) [s]
archive& make_nvp("d_Toc", d_Toe); //!< clock data reference time (Ref. 20.3.3.3.3.1 IS-GPS-200K) [s]
archive& make_nvp("d_Toe", d_Toe); //!< Ephemeris data reference time of week (Ref. 20.3.3.4.3 IS-GPS-200L) [s]
archive& make_nvp("d_Toc", d_Toe); //!< clock data reference time (Ref. 20.3.3.3.3.1 IS-GPS-200L) [s]
archive& make_nvp("d_Cic", d_Cic); //!< Amplitude of the Cosine Harmonic Correction Term to the Angle of Inclination [rad]
archive& make_nvp("d_OMEGA0", d_OMEGA0); //!< Longitude of Ascending Node of Orbit Plane at Weekly Epoch [semi-circles]
archive& make_nvp("d_Cis", d_Cis); //!< Amplitude of the Sine Harmonic Correction Term to the Angle of Inclination [rad]
@ -165,7 +165,7 @@ public:
archive& make_nvp("d_OMEGA_DOT", d_OMEGA_DOT); //!< Rate of Right Ascension [semi-circles/s]
archive& make_nvp("d_IDOT", d_IDOT); //!< Rate of Inclination Angle [semi-circles/s]
archive& make_nvp("i_BEIDOU_week", i_BEIDOU_week); //!< GPS week number, aka WN [week]
archive& make_nvp("i_SV_accuracy", i_SV_accuracy); //!< User Range Accuracy (URA) index of the SV (reference paragraph 6.2.1) for the standard positioning service user (Ref 20.3.3.3.1.3 IS-GPS-200K)
archive& make_nvp("i_SV_accuracy", i_SV_accuracy); //!< User Range Accuracy (URA) index of the SV (reference paragraph 6.2.1) for the standard positioning service user (Ref 20.3.3.3.1.3 IS-GPS-200L)
archive& make_nvp("i_SV_health", i_SV_health);
archive& make_nvp("d_AODC", d_AODC); //!< Issue of Data, Clock
archive& make_nvp("d_TGD1", d_TGD1); //!< Estimated Group Delay Differential: L1-L2 correction term only for the benefit of "L1 P(Y)" or "L2 P(Y)" s users [s]
@ -189,7 +189,7 @@ private:
/*
* Accounts for the beginning or end of week crossover
*
* See paragraph 20.3.3.3.3.1 (IS-GPS-200K)
* See paragraph 20.3.3.3.3.1 (IS-GPS-200L)
* \param[in] - time in seconds
* \param[out] - corrected time, in seconds
*/

2
src/core/system_parameters/galileo_almanac_helper.h
View File

@ -29,7 +29,7 @@
/*!
* \brief This class is a storage for the GALILEO ALMANAC data as described in GALILEO ICD
*
* See https://www.gsc-europa.eu/sites/default/files/sites/all/files/Galileo-OS-SIS-ICD.pdf paragraph 5.1.10
* See https://www.gsc-europa.eu/sites/default/files/sites/all/files/Galileo_OS_SIS_ICD_v2.0.pdf paragraph 5.1.10
*/
class Galileo_Almanac_Helper
{

2
src/core/system_parameters/galileo_ephemeris.h
View File

@ -30,7 +30,7 @@
/*!
* \brief This class is a storage and orbital model functions for the Galileo SV ephemeris data as described in Galileo ICD paragraph 5.1.1
* (See https://www.gsc-europa.eu/sites/default/files/sites/all/files/Galileo-OS-SIS-ICD.pdf )
* (See https://www.gsc-europa.eu/sites/default/files/sites/all/files/Galileo_OS_SIS_ICD_v2.0.pdf )
*
*/
class Galileo_Ephemeris

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

@ -44,8 +44,8 @@
/*!
* \brief This class handles the Galileo F/NAV Data message, as described in the
* Galileo Open Service Signal in Space Interface Control Document (OS SIS ICD), Issue 1.2 (Nov 2015).
* See https://www.gsc-europa.eu/sites/default/files/sites/all/files/Galileo-OS-SIS-ICD.pdf
* Galileo Open Service Signal in Space Interface Control Document (OS SIS ICD), Issue 2.0 (Jan. 2021).
* See https://www.gsc-europa.eu/sites/default/files/sites/all/files/Galileo_OS_SIS_ICD_v2.0.pdf
*/
class Galileo_Fnav_Message
{

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

@ -38,8 +38,8 @@
/*!
* \brief This class handles the Galileo I/NAV Data message, as described in the
* Galileo Open Service Signal in Space Interface Control Document (OS SIS ICD), Issue 1.2 (Nov 2015).
* See https://www.gsc-europa.eu/sites/default/files/sites/all/files/Galileo-OS-SIS-ICD.pdf
* Galileo Open Service Signal in Space Interface Control Document (OS SIS ICD), Issue 2.0 (Jan. 2021).
* See https://www.gsc-europa.eu/sites/default/files/sites/all/files/Galileo_OS_SIS_ICD_v2.0.pdf
*/
class Galileo_Inav_Message
{

2
src/core/system_parameters/galileo_iono.h
View File

@ -31,7 +31,7 @@
/*!
* \brief This class is a storage for the GALILEO IONOSPHERIC data as described in Galileo ICD paragraph 5.1.6
*
* See https://www.gsc-europa.eu/sites/default/files/sites/all/files/Galileo-OS-SIS-ICD.pdf
* See https://www.gsc-europa.eu/sites/default/files/sites/all/files/Galileo_OS_SIS_ICD_v2.0.pdf
*/
class Galileo_Iono
{

2
src/core/system_parameters/galileo_utc_model.h
View File

@ -30,7 +30,7 @@
/*!
* \brief This class is a storage for the GALILEO UTC MODEL data as described in Galileo ICD
* https://www.gsc-europa.eu/sites/default/files/sites/all/files/Galileo-OS-SIS-ICD.pdf
* https://www.gsc-europa.eu/sites/default/files/sites/all/files/Galileo_OS_SIS_ICD_v2.0.pdf
* paragraph 5.1.7
*/
class Galileo_Utc_Model

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

@ -90,7 +90,7 @@ public:
/*!
* \brief Sets (\a d_satClkDrift)and returns the clock drift in seconds according to the User Algorithm for SV Clock Correction
* (IS-GPS-200K, 20.3.3.3.3.1)
* (IS-GPS-200L, 20.3.3.3.3.1)
*/
double sv_clock_drift(double transmitTime, double timeCorrUTC);
@ -169,7 +169,7 @@ private:
/*
* Accounts for the beginning or end of week crossover
*
* See paragraph 20.3.3.3.3.1 (IS-GPS-200K)
* See paragraph 20.3.3.3.3.1 (IS-GPS-200L)
* \param[in] - time in seconds
* \param[out] - corrected time, in seconds
*/

6
src/core/system_parameters/gps_almanac.h
View File

@ -28,9 +28,9 @@
/*!
* \brief This class is a storage for the GPS SV ALMANAC data as described in IS-GPS-200K
* \brief This class is a storage for the GPS SV ALMANAC data as described in IS-GPS-200L
*
* See https://www.gps.gov/technical/icwg/IS-GPS-200K.pdf Appendix II
* See https://www.gps.gov/technical/icwg/IS-GPS-200L.pdf Appendix II
*/
class Gps_Almanac
{
@ -42,7 +42,7 @@ public:
uint32_t i_satellite_PRN{}; //!< SV PRN NUMBER
double d_Delta_i{}; //!< Inclination Angle at Reference Time (relative to i_0 = 0.30 semi-circles)
int32_t i_Toa{}; //!< Almanac data reference time of week (Ref. 20.3.3.4.3 IS-GPS-200K) [s]
int32_t i_Toa{}; //!< Almanac data reference time of week (Ref. 20.3.3.4.3 IS-GPS-200L) [s]
int32_t i_WNa{}; //!< Almanac week number
double d_M_0{}; //!< Mean Anomaly at Reference Time [semi-circles]
double d_e_eccentricity{}; //!< Eccentricity [dimensionless]

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

@ -2,7 +2,7 @@
* \file gps_cnav_ephemeris.cc
* \brief Interface of a GPS CNAV EPHEMERIS storage and orbital model functions
*
* See https://www.gps.gov/technical/icwg/IS-GPS-200K.pdf Appendix III
* See https://www.gps.gov/technical/icwg/IS-GPS-200L.pdf Appendix III
* \author Javier Arribas, 2015. jarribas(at)cttc.es
*
* -----------------------------------------------------------------------------
@ -53,7 +53,7 @@ double Gps_CNAV_Ephemeris::sv_clock_drift(double transmitTime)
// compute the relativistic correction term
double Gps_CNAV_Ephemeris::sv_clock_relativistic_term(double transmitTime)
{
const double A_REF = 26559710.0; // See IS-GPS-200K, pp. 163
const double A_REF = 26559710.0; // See IS-GPS-200L, pp. 161
const double d_sqrt_A = sqrt(A_REF + d_DELTA_A);
// Restore semi-major axis
@ -100,8 +100,8 @@ double Gps_CNAV_Ephemeris::sv_clock_relativistic_term(double transmitTime)
double Gps_CNAV_Ephemeris::satellitePosition(double transmitTime)
{
const double A_REF = 26559710.0; // See IS-GPS-200K, pp. 170
const double OMEGA_DOT_REF = -2.6e-9; // semicircles / s, see IS-GPS-200K pp. 164
const double A_REF = 26559710.0; // See IS-GPS-200L, pp. 161
const double OMEGA_DOT_REF = -2.6e-9; // semicircles / s, see IS-GPS-200L pp. 160
const double d_sqrt_A = sqrt(A_REF + d_DELTA_A);

22
src/core/system_parameters/gps_cnav_ephemeris.h
View File

@ -28,9 +28,9 @@
/*!
* \brief This class is a storage and orbital model functions for the GPS SV ephemeris data as described in IS-GPS-200K
* \brief This class is a storage and orbital model functions for the GPS SV ephemeris data as described in IS-GPS-200L
*
* See https://www.gps.gov/technical/icwg/IS-GPS-200K.pdf Appendix III
* See https://www.gps.gov/technical/icwg/IS-GPS-200L.pdf Appendix III
*/
class Gps_CNAV_Ephemeris
{
@ -42,19 +42,19 @@ public:
/*!
* \brief Compute the ECEF SV coordinates and ECEF velocity
* Implementation of Table 20-IV (IS-GPS-200K)
* Implementation of Table 20-IV (IS-GPS-200L)
*/
double satellitePosition(double transmitTime);
/*!
* \brief Sets (\a d_satClkDrift)and returns the clock drift in seconds according to the User Algorithm for SV Clock Correction
* (IS-GPS-200K, 20.3.3.3.3.1)
* (IS-GPS-200L, 20.3.3.3.3.1)
*/
double sv_clock_drift(double transmitTime);
/*!
* \brief Sets (\a d_dtr) and returns the clock relativistic correction term in seconds according to the User Algorithm for SV Clock Correction
* (IS-GPS-200K, 20.3.3.3.3.1)
* (IS-GPS-200L, 20.3.3.3.3.1)
*/
double sv_clock_relativistic_term(double transmitTime);
@ -73,8 +73,8 @@ public:
double d_e_eccentricity{}; //!< Eccentricity
double d_OMEGA{}; //!< Argument of Perigee [semi-cicles]
double d_OMEGA0{}; //!< Longitude of Ascending Node of Orbit Plane at Weekly Epoch [semi-cicles]
int32_t d_Toe1{}; //!< Ephemeris data reference time of week (Ref. 20.3.3.4.3 IS-GPS-200K) [s]
int32_t d_Toe2{}; //!< Ephemeris data reference time of week (Ref. 20.3.3.4.3 IS-GPS-200K) [s]
int32_t d_Toe1{}; //!< Ephemeris data reference time of week (Ref. 20.3.3.4.3 IS-GPS-200L) [s]
int32_t d_Toe2{}; //!< Ephemeris data reference time of week (Ref. 20.3.3.4.3 IS-GPS-200L) [s]
double d_DELTA_OMEGA_DOT{}; //!< Rate of Right Ascension difference [semi-circles/s]
double d_i_0{}; //!< Inclination Angle at Reference Time [semi-circles]
double d_IDOT{}; //!< Rate of Inclination Angle [semi-circles/s]
@ -86,7 +86,7 @@ public:
double d_Cuc{}; //!< Amplitude of the Cosine Harmonic Correction Term to the Argument of Latitude [rad]
// Clock Correction and Accuracy Parameters
int32_t d_Toc{}; //!< clock data reference time (Ref. 20.3.3.3.3.1 IS-GPS-200K) [s]
int32_t d_Toc{}; //!< clock data reference time (Ref. 20.3.3.3.3.1 IS-GPS-200L) [s]
double d_A_f0{}; //!< Coefficient 0 of code phase offset model [s]
double d_A_f1{}; //!< Coefficient 1 of code phase offset model [s/s]
double d_A_f2{}; //!< Coefficient 2 of code phase offset model [s/s^2]
@ -152,9 +152,9 @@ public:
archive& make_nvp("d_Cuc", d_Cuc); //!< Amplitude of the Cosine Harmonic Correction Term to the Argument of Latitude [rad]
archive& make_nvp("d_e_eccentricity", d_e_eccentricity); //!< Eccentricity [dimensionless]
archive& make_nvp("d_Cus", d_Cus); //!< Amplitude of the Sine Harmonic Correction Term to the Argument of Latitude [rad]
archive& make_nvp("d_Toe1", d_Toe1); //!< Ephemeris data reference time of week (Ref. 20.3.3.4.3 IS-GPS-200K) [s]
archive& make_nvp("d_Toe2", d_Toe2); //!< Ephemeris data reference time of week (Ref. 20.3.3.4.3 IS-GPS-200K) [s]
archive& make_nvp("d_Toc", d_Toc); //!< clock data reference time (Ref. 20.3.3.3.3.1 IS-GPS-200K) [s]
archive& make_nvp("d_Toe1", d_Toe1); //!< Ephemeris data reference time of week (Ref. 20.3.3.4.3 IS-GPS-200L) [s]
archive& make_nvp("d_Toe2", d_Toe2); //!< Ephemeris data reference time of week (Ref. 20.3.3.4.3 IS-GPS-200L) [s]
archive& make_nvp("d_Toc", d_Toc); //!< clock data reference time (Ref. 20.3.3.3.3.1 IS-GPS-200L) [s]
archive& make_nvp("d_Cic", d_Cic); //!< Amplitude of the Cosine Harmonic Correction Term to the Angle of Inclination [rad]
archive& make_nvp("d_OMEGA0", d_OMEGA0); //!< Longitude of Ascending Node of Orbit Plane at Weekly Epoch [semi-circles]
archive& make_nvp("d_Cis", d_Cis); //!< Amplitude of the Sine Harmonic Correction Term to the Angle of Inclination [rad]

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

@ -28,9 +28,9 @@
/*!
* \brief This class is a storage for the GPS IONOSPHERIC data as described in IS-GPS-200K
* \brief This class is a storage for the GPS IONOSPHERIC data as described in IS-GPS-200L
*
* See https://www.gps.gov/technical/icwg/IS-GPS-200K.pdf Appendix III
* See https://www.gps.gov/technical/icwg/IS-GPS-200L.pdf Appendix III
*/
class Gps_CNAV_Iono
{

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

@ -1,8 +1,8 @@
/*!
* \file gps_cnav_navigation_message.cc
* \brief Implementation of a GPS CNAV Data message decoder as described in IS-GPS-200K
* \brief Implementation of a GPS CNAV Data message decoder as described in IS-GPS-200L
*
* See https://www.gps.gov/technical/icwg/IS-GPS-200K.pdf Appendix III
* See https://www.gps.gov/technical/icwg/IS-GPS-200L.pdf Appendix III
* \author Javier Arribas, 2015. jarribas(at)cttc.es
*
* -----------------------------------------------------------------------------

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

@ -37,9 +37,9 @@
/*!
* \brief This class decodes a GPS CNAV Data message as described in IS-GPS-200K
* \brief This class decodes a GPS CNAV Data message as described in IS-GPS-200L
*
* See https://www.gps.gov/technical/icwg/IS-GPS-200K.pdf Appendix III
* See https://www.gps.gov/technical/icwg/IS-GPS-200L.pdf Appendix III
*/
class Gps_CNAV_Navigation_Message
{

12
src/core/system_parameters/gps_cnav_utc_model.h
View File

@ -28,9 +28,9 @@
/*!
* \brief This class is a storage for the GPS UTC MODEL data as described in in IS-GPS-200K
* \brief This class is a storage for the GPS UTC MODEL data as described in in IS-GPS-200L
*
* See https://www.gps.gov/technical/icwg/IS-GPS-200K.pdf Appendix III
* See https://www.gps.gov/technical/icwg/IS-GPS-200L.pdf Appendix III
*/
class Gps_CNAV_Utc_Model
{
@ -41,10 +41,10 @@ public:
Gps_CNAV_Utc_Model() = default;
// UTC parameters
double d_A2{}; //!< 2nd order term of a model that relates GPS and UTC time (ref. 20.3.3.5.2.4 IS-GPS-200K) [s/s]
double d_A1{}; //!< 1st order term of a model that relates GPS and UTC time (ref. 20.3.3.5.2.4 IS-GPS-200K) [s/s]
double d_A0{}; //!< Constant of a model that relates GPS and UTC time (ref. 20.3.3.5.2.4 IS-GPS-200K) [s]
int32_t d_t_OT{}; //!< Reference time for UTC data (reference 20.3.4.5 and 20.3.3.5.2.4 IS-GPS-200K) [s]
double d_A2{}; //!< 2nd order term of a model that relates GPS and UTC time (ref. 20.3.3.5.2.4 IS-GPS-200L) [s/s]
double d_A1{}; //!< 1st order term of a model that relates GPS and UTC time (ref. 20.3.3.5.2.4 IS-GPS-200L) [s/s]
double d_A0{}; //!< Constant of a model that relates GPS and UTC time (ref. 20.3.3.5.2.4 IS-GPS-200L) [s]
int32_t d_t_OT{}; //!< Reference time for UTC data (reference 20.3.4.5 and 20.3.3.5.2.4 IS-GPS-200L) [s]
int32_t i_WN_T{}; //!< UTC reference week number [weeks]
int32_t d_DeltaT_LS{}; //!< delta time due to leap seconds [s]. Number of leap seconds since 6-Jan-1980 as transmitted by the GPS almanac.
int32_t i_WN_LSF{}; //!< Week number at the end of which the leap second becomes effective [weeks]

2
src/core/system_parameters/gps_ephemeris.cc
View File

@ -2,7 +2,7 @@
* \file gps_ephemeris.cc
* \brief Interface of a GPS EPHEMERIS storage and orbital model functions
*
* See https://www.gps.gov/technical/icwg/IS-GPS-200K.pdf Appendix II
* See https://www.gps.gov/technical/icwg/IS-GPS-200L.pdf Appendix II
* \author Javier Arribas, 2013. jarribas(at)cttc.es
*
* -----------------------------------------------------------------------------

24
src/core/system_parameters/gps_ephemeris.h
View File

@ -31,9 +31,9 @@
/*!
* \brief This class is a storage and orbital model functions for the GPS SV ephemeris data as described in IS-GPS-200K
* \brief This class is a storage and orbital model functions for the GPS SV ephemeris data as described in IS-GPS-200L
*
* See https://www.gps.gov/technical/icwg/IS-GPS-200K.pdf Appendix II
* See https://www.gps.gov/technical/icwg/IS-GPS-200L.pdf Appendix II
*/
class Gps_Ephemeris
{
@ -45,20 +45,20 @@ public:
/*!
* \brief Compute the ECEF SV coordinates and ECEF velocity
* Implementation of Table 20-IV (IS-GPS-200K)
* Implementation of Table 20-IV (IS-GPS-200L)
* and compute the clock bias term including relativistic effect (return value)
*/
double satellitePosition(double transmitTime);
/*!
* \brief Sets (\a d_satClkDrift)and returns the clock drift in seconds according to the User Algorithm for SV Clock Correction
* (IS-GPS-200K, 20.3.3.3.3.1)
* (IS-GPS-200L, 20.3.3.3.3.1)
*/
double sv_clock_drift(double transmitTime);
/*!
* \brief Sets (\a d_dtr) and returns the clock relativistic correction term in seconds according to the User Algorithm for SV Clock Correction
* (IS-GPS-200K, 20.3.3.3.3.1)
* (IS-GPS-200L, 20.3.3.3.3.1)
*/
double sv_clock_relativistic_term(double transmitTime);
@ -71,8 +71,8 @@ public:
double d_e_eccentricity{}; //!< Eccentricity [dimensionless]
double d_Cus{}; //!< Amplitude of the Sine Harmonic Correction Term to the Argument of Latitude [rad]
double d_sqrt_A{}; //!< Square Root of the Semi-Major Axis [sqrt(m)]
int32_t d_Toe{}; //!< Ephemeris data reference time of week (Ref. 20.3.3.4.3 IS-GPS-200K) [s]
int32_t d_Toc{}; //!< clock data reference time (Ref. 20.3.3.3.3.1 IS-GPS-200K) [s]
int32_t d_Toe{}; //!< Ephemeris data reference time of week (Ref. 20.3.3.4.3 IS-GPS-200L) [s]
int32_t d_Toc{}; //!< clock data reference time (Ref. 20.3.3.3.3.1 IS-GPS-200L) [s]
double d_Cic{}; //!< Amplitude of the Cosine Harmonic Correction Term to the Angle of Inclination [rad]
double d_OMEGA0{}; //!< Longitude of Ascending Node of Orbit Plane at Weekly Epoch [semi-circles]
double d_Cis{}; //!< Amplitude of the Sine Harmonic Correction Term to the Angle of Inclination [rad]
@ -84,7 +84,7 @@ public:
int32_t i_code_on_L2{}; //!< If 1, P code ON in L2; if 2, C/A code ON in L2;
int32_t i_GPS_week{}; //!< GPS week number, aka WN [week]
bool b_L2_P_data_flag{}; //!< When true, indicates that the NAV data stream was commanded OFF on the P-code of the L2 channel
int32_t i_SV_accuracy{}; //!< User Range Accuracy (URA) index of the SV (reference paragraph 6.2.1) for the standard positioning service user (Ref 20.3.3.3.1.3 IS-GPS-200K)
int32_t i_SV_accuracy{}; //!< User Range Accuracy (URA) index of the SV (reference paragraph 6.2.1) for the standard positioning service user (Ref 20.3.3.3.1.3 IS-GPS-200L)
int32_t i_SV_health{};
double d_TGD{}; //!< Estimated Group Delay Differential: L1-L2 correction term only for the benefit of "L1 P(Y)" or "L2 P(Y)" s users [s]
int32_t d_IODC{}; //!< Issue of Data, Clock
@ -155,8 +155,8 @@ public:
archive& make_nvp("d_e_eccentricity", d_e_eccentricity); //!< Eccentricity [dimensionless]
archive& make_nvp("d_Cus", d_Cus); //!< Amplitude of the Sine Harmonic Correction Term to the Argument of Latitude [rad]
archive& make_nvp("d_sqrt_A", d_sqrt_A); //!< Square Root of the Semi-Major Axis [sqrt(m)]
archive& make_nvp("d_Toe", d_Toe); //!< Ephemeris data reference time of week (Ref. 20.3.3.4.3 IS-GPS-200K) [s]
archive& make_nvp("d_Toc", d_Toc); //!< clock data reference time (Ref. 20.3.3.3.3.1 IS-GPS-200K) [s]
archive& make_nvp("d_Toe", d_Toe); //!< Ephemeris data reference time of week (Ref. 20.3.3.4.3 IS-GPS-200L) [s]
archive& make_nvp("d_Toc", d_Toc); //!< clock data reference time (Ref. 20.3.3.3.3.1 IS-GPS-200L) [s]
archive& make_nvp("d_Cic", d_Cic); //!< Amplitude of the Cosine Harmonic Correction Term to the Angle of Inclination [rad]
archive& make_nvp("d_OMEGA0", d_OMEGA0); //!< Longitude of Ascending Node of Orbit Plane at Weekly Epoch [semi-circles]
archive& make_nvp("d_Cis", d_Cis); //!< Amplitude of the Sine Harmonic Correction Term to the Angle of Inclination [rad]
@ -168,7 +168,7 @@ public:
archive& make_nvp("i_code_on_L2", i_code_on_L2); //!< If 1, P code ON in L2; if 2, C/A code ON in L2;
archive& make_nvp("i_GPS_week", i_GPS_week); //!< GPS week number, aka WN [week]
archive& make_nvp("b_L2_P_data_flag", b_L2_P_data_flag); //!< When true, indicates that the NAV data stream was commanded OFF on the P-code of the L2 channel
archive& make_nvp("i_SV_accuracy", i_SV_accuracy); //!< User Range Accuracy (URA) index of the SV (reference paragraph 6.2.1) for the standard positioning service user (Ref 20.3.3.3.1.3 IS-GPS-200K)
archive& make_nvp("i_SV_accuracy", i_SV_accuracy); //!< User Range Accuracy (URA) index of the SV (reference paragraph 6.2.1) for the standard positioning service user (Ref 20.3.3.3.1.3 IS-GPS-200L)
archive& make_nvp("i_SV_health", i_SV_health);
archive& make_nvp("d_TGD", d_TGD); //!< Estimated Group Delay Differential: L1-L2 correction term only for the benefit of "L1 P(Y)" or "L2 P(Y)" s users [s]
archive& make_nvp("d_IODC", d_IODC); //!< Issue of Data, Clock
@ -191,7 +191,7 @@ private:
/*
* Accounts for the beginning or end of week crossover
*
* See paragraph 20.3.3.3.3.1 (IS-GPS-200K)
* See paragraph 20.3.3.3.3.1 (IS-GPS-200L)
* \param[in] - time in seconds
* \param[out] - corrected time, in seconds
*/

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

@ -28,9 +28,9 @@
/*!
* \brief This class is a storage for the GPS IONOSPHERIC data as described in IS-GPS-200K
* \brief This class is a storage for the GPS IONOSPHERIC data as described in IS-GPS-200L
*
* See https://www.gps.gov/technical/icwg/IS-GPS-200K.pdf Appendix II
* See https://www.gps.gov/technical/icwg/IS-GPS-200L.pdf Appendix II
*/
class Gps_Iono
{

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

@ -1,9 +1,9 @@
/*!
* \file gps_navigation_message.cc
* \brief Implementation of a GPS NAV Data message decoder as described in IS-GPS-200K
* \brief Implementation of a GPS NAV Data message decoder as described in IS-GPS-200L
* \author Javier Arribas, 2011. jarribas(at)cttc.es
*
* See https://www.gps.gov/technical/icwg/IS-GPS-200K.pdf Appendix II
* See https://www.gps.gov/technical/icwg/IS-GPS-200L.pdf Appendix II
*
*
* -----------------------------------------------------------------------------
@ -135,7 +135,7 @@ int32_t Gps_Navigation_Message::subframe_decoder(char* subframe)
switch (subframe_ID)
{
// --- Decode the sub-frame id -----------------------------------------
// ICD (IS-GPS-200K Appendix II). https://www.gps.gov/technical/icwg/IS-GPS-200K.pdf
// ICD (IS-GPS-200L Appendix II). https://www.gps.gov/technical/icwg/IS-GPS-200L.pdf
case 1:
// --- It is subframe 1 -------------------------------------
// Compute the time of week (TOW) of the first sub-frames in the array ====
@ -233,7 +233,7 @@ int32_t Gps_Navigation_Message::subframe_decoder(char* subframe)
b_antispoofing_flag = read_navigation_bool(subframe_bits, ANTI_SPOOFING_FLAG);
SV_data_ID = static_cast<int32_t>(read_navigation_unsigned(subframe_bits, SV_DATA_ID));
SV_page = static_cast<int32_t>(read_navigation_unsigned(subframe_bits, SV_PAGE));
if (SV_page > 24 && SV_page < 33) // Page 4 (from Table 20-V. Data IDs and SV IDs in Subframes 4 and 5, IS-GPS-200K, page 110)
if (SV_page > 24 && SV_page < 33) // Page 4 (from Table 20-V. Data IDs and SV IDs in Subframes 4 and 5, IS-GPS-200L, page 110)
{
//! \TODO read almanac
if (SV_data_ID != 0)
@ -241,12 +241,12 @@ int32_t Gps_Navigation_Message::subframe_decoder(char* subframe)
}
}
if (SV_page == 52) // Page 13 (from Table 20-V. Data IDs and SV IDs in Subframes 4 and 5, IS-GPS-200K, page 110)
if (SV_page == 52) // Page 13 (from Table 20-V. Data IDs and SV IDs in Subframes 4 and 5, IS-GPS-200L, page 110)
{
//! \TODO read Estimated Range Deviation (ERD) values
}
if (SV_page == 56) // Page 18 (from Table 20-V. Data IDs and SV IDs in Subframes 4 and 5, IS-GPS-200K, page 110)
if (SV_page == 56) // Page 18 (from Table 20-V. Data IDs and SV IDs in Subframes 4 and 5, IS-GPS-200L, page 110)
{
// Page 18 - Ionospheric and UTC data
d_alpha0 = static_cast<double>(read_navigation_signed(subframe_bits, ALPHA_0));
@ -284,7 +284,7 @@ int32_t Gps_Navigation_Message::subframe_decoder(char* subframe)
// Reserved
}
if (SV_page == 63) // Page 25 (from Table 20-V. Data IDs and SV IDs in Subframes 4 and 5, IS-GPS-200K, page 110)
if (SV_page == 63) // Page 25 (from Table 20-V. Data IDs and SV IDs in Subframes 4 and 5, IS-GPS-200L, page 110)
{
// Page 25 Anti-Spoofing, SV config and almanac health (PRN: 25-32)
//! \TODO Read Anti-Spoofing, SV config
@ -317,7 +317,7 @@ int32_t Gps_Navigation_Message::subframe_decoder(char* subframe)
{
}
}
if (SV_page_5 == 51) // Page 25 (from Table 20-V. Data IDs and SV IDs in Subframes 4 and 5, IS-GPS-200K, page 110)
if (SV_page_5 == 51) // Page 25 (from Table 20-V. Data IDs and SV IDs in Subframes 4 and 5, IS-GPS-200L, page 110)
{
i_Toa = static_cast<int32_t>(read_navigation_unsigned(subframe_bits, T_OA));
i_Toa = i_Toa * T_OA_LSB;
@ -411,7 +411,7 @@ double Gps_Navigation_Message::utc_time(const double gpstime_corrected) const
/* 20.3.3.5.2.4c
* Whenever the effectivity time of the leap second event, as indicated by the
* WNLSF and DN values, is in the "past" (relative to the user's current time),
* and the user<EFBFBD>s current time does not fall in the time span as given above
* and the user's current time does not fall in the time span as given above
* in 20.3.3.5.2.4b,*/
Delta_t_UTC = d_DeltaT_LSF + d_A0 + d_A1 * (gpstime_corrected - d_t_OT + 604800 * static_cast<double>((i_GPS_week - i_WN_T)));
t_utc_daytime = fmod(gpstime_corrected - Delta_t_UTC, 86400);

18
src/core/system_parameters/gps_navigation_message.h
View File

@ -38,9 +38,9 @@
/*!
* \brief This class decodes a GPS NAV Data message as described in IS-GPS-200K
* \brief This class decodes a GPS NAV Data message as described in IS-GPS-200L
*
* See https://www.gps.gov/technical/icwg/IS-GPS-200K.pdf Appendix II
* See https://www.gps.gov/technical/icwg/IS-GPS-200L.pdf Appendix II
*/
class Gps_Navigation_Message
{
@ -72,7 +72,7 @@ public:
/*!
* \brief Computes the Coordinated Universal Time (UTC) and
* returns it in [s] (IS-GPS-200K, 20.3.3.5.2.4)
* returns it in [s] (IS-GPS-200L, 20.3.3.5.2.4)
*/
double utc_time(const double gpstime_corrected) const;
@ -162,8 +162,8 @@ private:
double d_Cus{}; // Amplitude of the Sine Harmonic Correction Term to the Argument of Latitude [rad]
double d_sqrt_A{}; // Square Root of the Semi-Major Axis [sqrt(m)]
// broadcast orbit 3
int32_t d_Toe{}; // Ephemeris data reference time of week (Ref. 20.3.3.4.3 IS-GPS-200K) [s]
int32_t d_Toc{}; // clock data reference time (Ref. 20.3.3.3.3.1 IS-GPS-200K) [s]
int32_t d_Toe{}; // Ephemeris data reference time of week (Ref. 20.3.3.4.3 IS-GPS-200L) [s]
int32_t d_Toc{}; // clock data reference time (Ref. 20.3.3.3.3.1 IS-GPS-200L) [s]
double d_Cic{}; // Amplitude of the Cosine Harmonic Correction Term to the Angle of Inclination [rad]
double d_OMEGA0{}; // Longitude of Ascending Node of Orbit Plane at Weekly Epoch [semi-circles]
double d_Cis{}; // Amplitude of the Sine Harmonic Correction Term to the Angle of Inclination [rad]
@ -178,7 +178,7 @@ private:
int32_t i_GPS_week{}; // GPS week number, aka WN [week]
bool b_L2_P_data_flag{}; // When true, indicates that the NAV data stream was commanded OFF on the P-code of the L2 channel
// broadcast orbit 6
int32_t i_SV_accuracy{}; // User Range Accuracy (URA) index of the SV (reference paragraph 6.2.1) for the standard positioning service user (Ref 20.3.3.3.1.3 IS-GPS-200K)
int32_t i_SV_accuracy{}; // User Range Accuracy (URA) index of the SV (reference paragraph 6.2.1) for the standard positioning service user (Ref 20.3.3.3.1.3 IS-GPS-200L)
int32_t i_SV_health{};
double d_TGD{}; // Estimated Group Delay Differential: L1-L2 correction term only for the benefit of "L1 P(Y)" or "L2 P(Y)" s users [s]
int32_t d_IODC{}; // Issue of Data, Clock
@ -226,10 +226,10 @@ private:
double d_beta3{}; // Coefficient 3 of a cubic equation representing the period of the model [s(semi-circle)^3]
// UTC parameters
double d_A0{}; // Constant of a model that relates GPS and UTC time (ref. 20.3.3.5.2.4 IS-GPS-200K) [s]
double d_A1{}; // 1st order term of a model that relates GPS and UTC time (ref. 20.3.3.5.2.4 IS-GPS-200K) [s/s]
double d_A0{}; // Constant of a model that relates GPS and UTC time (ref. 20.3.3.5.2.4 IS-GPS-200L) [s]
double d_A1{}; // 1st order term of a model that relates GPS and UTC time (ref. 20.3.3.5.2.4 IS-GPS-200L) [s/s]
int32_t d_t_OT{}; // Reference time for UTC data (reference 20.3.4.5 and 20.3.3.5.2.4 IS-GPS-200K) [s]
int32_t d_t_OT{}; // Reference time for UTC data (reference 20.3.4.5 and 20.3.3.5.2.4 IS-GPS-200L) [s]
int32_t i_WN_T{}; // UTC reference week number [weeks]
int32_t d_DeltaT_LS{}; // delta time due to leap seconds [s]. Number of leap seconds since 6-Jan-1980 as transmitted by the GPS almanac.
int32_t i_WN_LSF{}; // Week number at the end of which the leap second becomes effective [weeks]

12
src/core/system_parameters/gps_utc_model.h
View File

@ -28,9 +28,9 @@
/*!
* \brief This class is a storage for the GPS UTC MODEL data as described in IS-GPS-200K
* \brief This class is a storage for the GPS UTC MODEL data as described in IS-GPS-200L
*
* See https://www.gps.gov/technical/icwg/IS-GPS-200K.pdf Appendix II
* See https://www.gps.gov/technical/icwg/IS-GPS-200L.pdf Appendix II
*/
class Gps_Utc_Model
{
@ -41,10 +41,10 @@ public:
Gps_Utc_Model() = default;
// UTC parameters
double d_A0{}; //!< Constant of a model that relates GPS and UTC time (ref. 20.3.3.5.2.4 IS-GPS-200K) [s]
double d_A1{}; //!< 1st order term of a model that relates GPS and UTC time (ref. 20.3.3.5.2.4 IS-GPS-200K) [s/s]
double d_A2{}; //!< 2nd order term of a model that relates GPS and UTC time (ref. 20.3.3.5.2.4 IS-GPS-200K) [s/s]
int32_t d_t_OT{}; //!< Reference time for UTC data (reference 20.3.4.5 and 20.3.3.5.2.4 IS-GPS-200K) [s]
double d_A0{}; //!< Constant of a model that relates GPS and UTC time (ref. 20.3.3.5.2.4 IS-GPS-200L) [s]
double d_A1{}; //!< 1st order term of a model that relates GPS and UTC time (ref. 20.3.3.5.2.4 IS-GPS-200L) [s/s]
double d_A2{}; //!< 2nd order term of a model that relates GPS and UTC time (ref. 20.3.3.5.2.4 IS-GPS-200L) [s/s]
int32_t d_t_OT{}; //!< Reference time for UTC data (reference 20.3.4.5 and 20.3.3.5.2.4 IS-GPS-200L) [s]
int32_t i_WN_T{}; //!< UTC reference week number [weeks]
int32_t d_DeltaT_LS{}; //!< delta time due to leap seconds [s]. Number of leap seconds since 6-Jan-1980 as transmitted by the GPS almanac.
int32_t i_WN_LSF{}; //!< Week number at the end of which the leap second becomes effective [weeks]

11
src/main/CMakeLists.txt
View File

@ -12,17 +12,6 @@ else()
add_executable(gnss-sdr main.cc)
endif()
if(${FILESYSTEM_FOUND})
target_compile_definitions(gnss-sdr PRIVATE -DHAS_STD_FILESYSTEM=1)
if(${find_experimental})
target_compile_definitions(gnss-sdr PRIVATE -DHAS_STD_FILESYSTEM_EXPERIMENTAL=1)
endif()
target_link_libraries(gnss-sdr PRIVATE std::filesystem)
else()
target_link_libraries(gnss-sdr PRIVATE Boost::filesystem Boost::system)
endif()
target_link_libraries(gnss-sdr
PRIVATE
algorithms_libs

22
src/main/main.cc
View File

@ -28,6 +28,7 @@
#include "concurrent_map.h"
#include "concurrent_queue.h"
#include "control_thread.h"
#include "gnss_sdr_filesystem.h"
#include "gnss_sdr_make_unique.h"
#include "gps_acq_assist.h"
#include <boost/exception/diagnostic_information.hpp> // for diagnostic_information
@ -46,27 +47,6 @@
#include <cuda_runtime.h>
#endif
// 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 create_directories, exists
#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
#if GFLAGS_OLD_NAMESPACE
namespace gflags
{

122
src/tests/CMakeLists.txt
View File

@ -333,6 +333,9 @@ if(ENABLE_UNIT_TESTING_EXTRA OR ENABLE_SYSTEM_TESTING_EXTRA OR ENABLE_FPGA)
endif()
include(GNUInstallDirs)
find_program(Patch_EXECUTABLE NAME patch PATHS ENV PATH)
if(NOT Patch_EXECUTABLE)
message(FATAL_ERROR "The patch command is not found. It is required to build GPSTk. Please check your OS documentation and install the patch command.")
endif()
set(GPSTK_PATCH_COMMAND
cd ${CMAKE_BINARY_DIR}/thirdparty/gpstk-${GNSSSDR_GPSTK_LOCAL_VERSION} &&
${Patch_EXECUTABLE} ${CMAKE_BINARY_DIR}/thirdparty/gpstk-${GNSSSDR_GPSTK_LOCAL_VERSION}/CMakeLists.txt < ${CMAKE_SOURCE_DIR}/src/tests/data/gpstk_static.patch
@ -480,15 +483,6 @@ if(ENABLE_UNIT_TESTING)
else()
add_executable(run_tests ${CMAKE_CURRENT_SOURCE_DIR}/test_main.cc)
endif()
if(${FILESYSTEM_FOUND})
target_compile_definitions(run_tests PRIVATE -DHAS_STD_FILESYSTEM=1)
if(${find_experimental})
target_compile_definitions(run_tests PRIVATE -DHAS_STD_FILESYSTEM_EXPERIMENTAL=1)
endif()
target_link_libraries(run_tests PRIVATE std::filesystem)
else()
target_link_libraries(run_tests PRIVATE Boost::filesystem Boost::system)
endif()
target_link_libraries(run_tests
PRIVATE
@ -533,11 +527,6 @@ if(ENABLE_UNIT_TESTING)
PRIVATE -DGNURADIO_USES_STD_POINTERS=1
)
endif()
if(GNURADIO_FFT_USES_TEMPLATES)
target_compile_definitions(run_tests
PUBLIC -DGNURADIO_FFT_USES_TEMPLATES=1
)
endif()
if(ENABLE_UNIT_TESTING_EXTRA)
target_link_libraries(run_tests PRIVATE Gpstk::gpstk)
if(GPSTK_OLDER_THAN_8)
@ -617,15 +606,28 @@ if(ENABLE_FPGA)
else()
add_executable(gps_l1_ca_dll_pll_tracking_test_fpga ${GPS_L1_CA_DLL_PLL_TRACKING_TEST_FPGA_SOURCES})
endif()
if(${FILESYSTEM_FOUND})
target_compile_definitions(gps_l1_ca_dll_pll_tracking_test_fpga PRIVATE -DHAS_STD_FILESYSTEM=1)
if(${find_experimental})
target_compile_definitions(gps_l1_ca_dll_pll_tracking_test_fpga PRIVATE -DHAS_STD_FILESYSTEM_EXPERIMENTAL=1)
endif()
target_link_libraries(gps_l1_ca_dll_pll_tracking_test_fpga PRIVATE std::filesystem)
if(USE_GENERIC_LAMBDAS)
set(has_generic_lambdas HAS_GENERIC_LAMBDA=1)
set(no_has_generic_lambdas HAS_GENERIC_LAMBDA=0)
target_compile_definitions(gps_l1_ca_dll_pll_tracking_test_fpga
PRIVATE
"$<$<COMPILE_FEATURES:cxx_generic_lambdas>:${has_generic_lambdas}>"
"$<$<NOT:$<COMPILE_FEATURES:cxx_generic_lambdas>>:${no_has_generic_lambdas}>"
)
else()
target_link_libraries(gps_l1_ca_dll_pll_tracking_test_fpga PRIVATE Boost::filesystem Boost::system)
target_compile_definitions(gps_l1_ca_dll_pll_tracking_test_fpga
PRIVATE
-DHAS_GENERIC_LAMBDA=0
)
endif()
if(USE_BOOST_BIND_PLACEHOLDERS)
target_compile_definitions(gps_l1_ca_dll_pll_tracking_test_fpga
PRIVATE
-DUSE_BOOST_BIND_PLACEHOLDERS=1
)
endif()
target_link_libraries(gps_l1_ca_dll_pll_tracking_test_fpga
PRIVATE
Armadillo::armadillo
@ -678,18 +680,8 @@ function(add_system_test executable)
else()
add_executable(${executable} ${SYSTEM_TEST_SOURCES})
endif()
if(${FILESYSTEM_FOUND})
target_compile_definitions(${executable} PRIVATE -DHAS_STD_FILESYSTEM=1)
if(${find_experimental})
target_compile_definitions(${executable} PRIVATE -DHAS_STD_FILESYSTEM_EXPERIMENTAL=1)
endif()
target_link_libraries(${executable} PRIVATE std::filesystem)
else()
target_link_libraries(${executable} PRIVATE Boost::filesystem Boost::system)
endif()
target_include_directories(${executable}
PRIVATE ${OPT_INCLUDES_} ${CMAKE_SOURCE_DIR}/src/algorithms/libs
PRIVATE ${OPT_INCLUDES_}
INTERFACE ${CMAKE_SOURCE_DIR}/src/tests/common-files
)
target_link_libraries(${executable} PRIVATE ${OPT_LIBS_} algorithms_libs)
@ -805,15 +797,7 @@ if(NOT ENABLE_PACKAGING AND NOT ENABLE_FPGA)
else()
add_executable(flowgraph_test ${FLOWGRAPH_TEST_SOURCES})
endif()
if(${FILESYSTEM_FOUND})
target_compile_definitions(flowgraph_test PRIVATE -DHAS_STD_FILESYSTEM=1)
if(${find_experimental})
target_compile_definitions(flowgraph_test PRIVATE -DHAS_STD_FILESYSTEM_EXPERIMENTAL=1)
endif()
target_link_libraries(flowgraph_test PRIVATE std::filesystem)
else()
target_link_libraries(flowgraph_test PRIVATE Boost::filesystem Boost::system)
endif()
target_link_libraries(flowgraph_test
PRIVATE
Boost::thread
@ -860,15 +844,7 @@ if(NOT ENABLE_PACKAGING AND NOT ENABLE_FPGA)
else()
add_executable(gnss_block_test ${GNSS_BLOCK_TEST_SOURCES})
endif()
if(${FILESYSTEM_FOUND})
target_compile_definitions(gnss_block_test PRIVATE -DHAS_STD_FILESYSTEM=1)
if(${find_experimental})
target_compile_definitions(gnss_block_test PRIVATE -DHAS_STD_FILESYSTEM_EXPERIMENTAL=1)
endif()
target_link_libraries(gnss_block_test PRIVATE std::filesystem)
else()
target_link_libraries(gnss_block_test PRIVATE Boost::filesystem Boost::system)
endif()
target_link_libraries(gnss_block_test
PRIVATE
Boost::thread
@ -916,15 +892,7 @@ if(NOT ENABLE_PACKAGING AND NOT ENABLE_FPGA)
else()
add_executable(gnuradio_block_test ${GNURADIO_BLOCK_TEST_SOURCES})
endif()
if(${FILESYSTEM_FOUND})
target_compile_definitions(gnuradio_block_test PRIVATE -DHAS_STD_FILESYSTEM=1)
if(${find_experimental})
target_compile_definitions(gnuradio_block_test PRIVATE -DHAS_STD_FILESYSTEM_EXPERIMENTAL=1)
endif()
target_link_libraries(gnuradio_block_test PRIVATE std::filesystem)
else()
target_link_libraries(gnuradio_block_test PRIVATE Boost::filesystem Boost::system)
endif()
target_link_libraries(gnuradio_block_test
PRIVATE
Boost::thread
@ -961,18 +929,9 @@ else()
add_executable(matio_test ${MATIO_TEST_SOURCES})
endif()
if(${FILESYSTEM_FOUND})
target_compile_definitions(matio_test PRIVATE -DHAS_STD_FILESYSTEM=1)
if(${find_experimental})
target_compile_definitions(matio_test PRIVATE -DHAS_STD_FILESYSTEM_EXPERIMENTAL=1)
endif()
target_link_libraries(matio_test PRIVATE std::filesystem)
else()
target_link_libraries(matio_test PRIVATE Boost::filesystem Boost::system)
endif()
target_link_libraries(matio_test
PRIVATE
algorithms_libs
Gflags::gflags
Glog::glog
GTest::GTest
@ -1003,12 +962,7 @@ if(NOT ENABLE_PACKAGING AND NOT ENABLE_FPGA)
else()
add_executable(acq_test ${ACQ_TEST_SOURCES})
endif()
if(${FILESYSTEM_FOUND})
target_compile_definitions(acq_test PRIVATE -DHAS_STD_FILESYSTEM=1)
target_link_libraries(acq_test PRIVATE std::filesystem)
else()
target_link_libraries(acq_test PRIVATE Boost::filesystem Boost::system)
endif()
target_link_libraries(acq_test
PRIVATE
Boost::thread
@ -1082,15 +1036,6 @@ if(NOT ENABLE_PACKAGING AND NOT ENABLE_FPGA)
else()
add_executable(trk_test ${TRKTEST_SOURCES})
endif()
if(${FILESYSTEM_FOUND})
target_compile_definitions(trk_test PRIVATE -DHAS_STD_FILESYSTEM=1)
if(${find_experimental})
target_compile_definitions(trk_test PRIVATE -DHAS_STD_FILESYSTEM_EXPERIMENTAL=1)
endif()
target_link_libraries(trk_test PRIVATE std::filesystem)
else()
target_link_libraries(trk_test PRIVATE Boost::filesystem Boost::system)
endif()
target_link_libraries(trk_test
PRIVATE
@ -1150,15 +1095,6 @@ if(NOT ENABLE_PACKAGING AND NOT ENABLE_FPGA)
else()
add_executable(control_thread_test ${CONTROL_THREAD_TEST_SOURCES})
endif()
if(${FILESYSTEM_FOUND})
target_compile_definitions(control_thread_test PRIVATE -DHAS_STD_FILESYSTEM=1)
if(${find_experimental})
target_compile_definitions(control_thread_test PRIVATE -DHAS_STD_FILESYSTEM_EXPERIMENTAL=1)
endif()
target_link_libraries(control_thread_test PRIVATE std::filesystem)
else()
target_link_libraries(control_thread_test PRIVATE Boost::filesystem Boost::system)
endif()
target_link_libraries(control_thread_test
PRIVATE

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

@ -25,6 +25,7 @@
#include "control_thread.h"
#include "file_configuration.h"
#include "geofunctions.h"
#include "gnss_sdr_filesystem.h"
#include "gnss_sdr_flags.h"
#include "gnuplot_i.h"
#include "in_memory_configuration.h"
@ -46,14 +47,6 @@
#include <numeric>
#include <thread>
#if HAS_STD_FILESYSTEM
#include <filesystem>
namespace fs = std::filesystem;
#else
#include <boost/filesystem.hpp>
namespace fs = boost::filesystem;
#endif
#if GFLAGS_OLD_NAMESPACE
namespace gflags
{

Some files were not shown because too many files have changed in this diff Show More