/*! * \file main.cc * \brief Main file of the GNSS-SDR program. * \author Carlos Aviles, 2010. carlos.avilesr(at)googlemail.com * * It sets up the logging system, creates a ControlThread object, * makes it run, and releases memory back when the main thread has ended. * * ------------------------------------------------------------------------- * * Copyright (C) 2010-2015 (see AUTHORS file for a list of contributors) * * GNSS-SDR is a software defined Global Navigation * Satellite Systems receiver * * This file is part of GNSS-SDR. * * GNSS-SDR is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * GNSS-SDR is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with GNSS-SDR. If not, see . * * ------------------------------------------------------------------------- */ #ifndef GNSS_SDR_VERSION #define GNSS_SDR_VERSION "0.0.6" #endif #ifndef GOOGLE_STRIP_LOG #define GOOGLE_STRIP_LOG 0 #endif #include #include #include #include #include #include #include #include #include #include #include #include "control_thread.h" #include "concurrent_queue.h" #include "concurrent_map.h" #include "gps_ephemeris.h" #include "gps_cnav_ephemeris.h" #include "gps_almanac.h" #include "gps_iono.h" #include "gps_cnav_iono.h" #include "gps_utc_model.h" #include "galileo_ephemeris.h" #include "galileo_almanac.h" #include "galileo_iono.h" #include "galileo_utc_model.h" #include "sbas_telemetry_data.h" #include "sbas_ionospheric_correction.h" #include "sbas_satellite_correction.h" #include "sbas_ephemeris.h" #include "sbas_time.h" #if CUDA_GPU_ACCEL // For the CUDA runtime routines (prefixed with "cuda_") #include #endif using google::LogMessage; DECLARE_string(log_dir); /*! * \todo make this queue generic for all the GNSS systems (javi) */ /* * Concurrent queues that communicates the Telemetry Decoder * to the Observables modules */ // For GPS NAVIGATION (L1) concurrent_queue global_gps_ephemeris_queue; concurrent_queue global_gps_iono_queue; concurrent_queue global_gps_utc_model_queue; concurrent_queue global_gps_almanac_queue; concurrent_queue global_gps_acq_assist_queue; concurrent_queue global_gps_ref_location_queue; concurrent_queue global_gps_ref_time_queue; concurrent_map global_gps_ephemeris_map; concurrent_map global_gps_iono_map; concurrent_map global_gps_utc_model_map; concurrent_map global_gps_almanac_map; concurrent_map global_gps_acq_assist_map; concurrent_map global_gps_ref_time_map; concurrent_map global_gps_ref_location_map; // For GPS NAVIGATION (L2) concurrent_queue global_gps_cnav_ephemeris_queue; concurrent_map global_gps_cnav_ephemeris_map; concurrent_queue global_gps_cnav_iono_queue; concurrent_map global_gps_cnav_iono_map; // For GALILEO NAVIGATION concurrent_queue global_galileo_ephemeris_queue; concurrent_queue global_galileo_iono_queue; concurrent_queue global_galileo_utc_model_queue; concurrent_queue global_galileo_almanac_queue; concurrent_map global_galileo_ephemeris_map; concurrent_map global_galileo_iono_map; concurrent_map global_galileo_utc_model_map; concurrent_map global_galileo_almanac_map; // For SBAS CORRECTIONS concurrent_queue global_sbas_raw_msg_queue; concurrent_queue global_sbas_iono_queue; concurrent_queue global_sbas_sat_corr_queue; concurrent_queue global_sbas_ephemeris_queue; concurrent_map global_sbas_iono_map; concurrent_map global_sbas_sat_corr_map; concurrent_map global_sbas_ephemeris_map; int main(int argc, char** argv) { const std::string intro_help( std::string("\nGNSS-SDR is an Open Source GNSS Software Defined Receiver\n") + "Copyright (C) 2010-2015 (see AUTHORS file for a list of contributors)\n" + "This program comes with ABSOLUTELY NO WARRANTY;\n" + "See COPYING file to see a copy of the General Public License\n \n"); const std::string gnss_sdr_version(GNSS_SDR_VERSION); google::SetUsageMessage(intro_help); google::SetVersionString(gnss_sdr_version); google::ParseCommandLineFlags(&argc, &argv, true); std::cout << "Initializing GNSS-SDR v" << gnss_sdr_version << " ... Please wait." << std::endl; #if CUDA_GPU_ACCEL // Reset the device // cudaDeviceReset causes the driver to clean up all state. While // not mandatory in normal operation, it is good practice. It is also // needed to ensure correct operation when the application is being // profiled. Calling cudaDeviceReset causes all profile data to be // flushed before the application exits cudaDeviceReset(); std::cout << "Reset CUDA device done " << std::endl; #endif if(GOOGLE_STRIP_LOG == 0) { google::InitGoogleLogging(argv[0]); if (FLAGS_log_dir.empty()) { std::cout << "Logging will be done at " << boost::filesystem::temp_directory_path() << std::endl << "Use gnss-sdr --log_dir=/path/to/log to change that." << std::endl; } else { const boost::filesystem::path p (FLAGS_log_dir); if (!boost::filesystem::exists(p)) { std::cout << "The path " << FLAGS_log_dir << " does not exist, attempting to create it." << std::endl; boost::system::error_code ec; boost::filesystem::create_directory(p, ec); if(ec != 0) { std::cout << "Could not create the " << FLAGS_log_dir << " folder. GNSS-SDR program ended." << std::endl; google::ShutDownCommandLineFlags(); std::exit(0); } } std::cout << "Logging with be done at " << FLAGS_log_dir << std::endl; } } std::unique_ptr control_thread(new ControlThread()); // record startup time struct timeval tv; gettimeofday(&tv, NULL); long long int begin = tv.tv_sec * 1000000 + tv.tv_usec; try { control_thread->run(); } catch( boost::exception & e ) { LOG(FATAL) << "Boost exception: " << boost::diagnostic_information(e); } catch(std::exception const& ex) { LOG(FATAL) << "STD exception: " << ex.what(); } catch(...) { LOG(INFO) << "Unexpected catch"; } // report the elapsed time gettimeofday(&tv, NULL); long long int end = tv.tv_sec * 1000000 + tv.tv_usec; std::cout << "Total GNSS-SDR run time " << (static_cast(end - begin)) / 1000000.0 << " [seconds]" << std::endl; google::ShutDownCommandLineFlags(); std::cout << "GNSS-SDR program ended." << std::endl; }