From b76ebdb856b20a8078c6386bc20e79aa0d8db741 Mon Sep 17 00:00:00 2001 From: "Matthias P. Braendli" Date: Mon, 18 Jun 2018 15:57:26 +0200 Subject: Rework GPSDO fix check Accelerate startup, take advantage of new UHD sensor, fix startup issue. --- src/output/SDR.cpp | 14 +++- src/output/SDRDevice.h | 11 +-- src/output/UHD.cpp | 8 ++- src/output/USRPTime.cpp | 183 ++++++++++++++++++++++++++---------------------- src/output/USRPTime.h | 23 ++++-- 5 files changed, 142 insertions(+), 97 deletions(-) (limited to 'src/output') diff --git a/src/output/SDR.cpp b/src/output/SDR.cpp index 7c1b585..9be9aa2 100644 --- a/src/output/SDR.cpp +++ b/src/output/SDR.cpp @@ -78,6 +78,8 @@ SDR::SDR(SDRDeviceConfig& config, std::shared_ptr device) : RC_ADD_PARAMETER(underruns, "Counter of number of underruns"); RC_ADD_PARAMETER(latepackets, "Counter of number of late packets"); RC_ADD_PARAMETER(frames, "Counter of number of frames modulated"); + RC_ADD_PARAMETER(gpsdo_num_sv, "Number of Satellite Vehicles tracked by GPSDO"); + RC_ADD_PARAMETER(gpsdo_holdover, "1 if the GPSDO is in holdover, 0 if it is using gnss"); } SDR::~SDR() @@ -381,7 +383,9 @@ void SDR::set_parameter(const string& parameter, const string& value) } else if (parameter == "underruns" or parameter == "latepackets" or - parameter == "frames") { + parameter == "frames" or + parameter == "gpsdo_num_sv" or + parameter == "gpsdo_holdover") { throw ParameterError("Parameter " + parameter + " is read-only."); } else { @@ -426,6 +430,14 @@ const string SDR::get_parameter(const string& parameter) const ss << stat.num_frames_modulated; } } + else if (parameter == "gpsdo_num_sv") { + const auto stat = m_device->get_run_statistics(); + ss << stat.gpsdo_num_sv; + } + else if (parameter == "gpsdo_holdover") { + const auto stat = m_device->get_run_statistics(); + ss << (stat.gpsdo_holdover ? 1 : 0); + } else { ss << "Parameter '" << parameter << "' is not exported by controllable " << get_rc_name(); diff --git a/src/output/SDRDevice.h b/src/output/SDRDevice.h index bd1a518..9e052b0 100644 --- a/src/output/SDRDevice.h +++ b/src/output/SDRDevice.h @@ -106,10 +106,13 @@ struct FrameData { class SDRDevice { public: struct RunStatistics { - size_t num_underruns; - size_t num_late_packets; - size_t num_overruns; - size_t num_frames_modulated; + size_t num_underruns = 0; + size_t num_late_packets = 0; + size_t num_overruns = 0; + size_t num_frames_modulated = 0; + + int gpsdo_num_sv = 0; + bool gpsdo_holdover = false; }; virtual void tune(double lo_offset, double frequency) = 0; diff --git a/src/output/UHD.cpp b/src/output/UHD.cpp index 711e218..e4b578e 100644 --- a/src/output/UHD.cpp +++ b/src/output/UHD.cpp @@ -362,6 +362,12 @@ SDRDevice::RunStatistics UHD::get_run_statistics(void) const rs.num_overruns = num_overflows; rs.num_late_packets = num_late_packets; rs.num_frames_modulated = num_frames_modulated; + + if (m_device_time) { + const auto gpsdo_stat = m_device_time->get_gnss_stats(); + rs.gpsdo_holdover = gpsdo_stat.holdover; + rs.gpsdo_num_sv = gpsdo_stat.num_sv; + } return rs; } @@ -433,7 +439,7 @@ bool UHD::is_clk_source_ok(void) const } if (m_device_time) { - ok |= m_device_time->verify_time(); + ok &= m_device_time->verify_time(); } return ok; diff --git a/src/output/USRPTime.cpp b/src/output/USRPTime.cpp index 39b0e5a..232fa58 100644 --- a/src/output/USRPTime.cpp +++ b/src/output/USRPTime.cpp @@ -39,64 +39,6 @@ namespace Output { using namespace std; - -// Check function for GPS TIMELOCK sensor from the ODR LEA-M8F board GPSDO -static bool check_gps_timelock(uhd::usrp::multi_usrp::sptr& usrp) -{ - try { - const string sensor_value = - usrp->get_mboard_sensor("gps_timelock", 0).to_pp_string(); - - if (sensor_value.find("TIME LOCKED") == string::npos) { - - const string gngga = - usrp->get_mboard_sensor("gps_gngga", 0).to_pp_string(); - - std::stringstream ss(gngga); - std::string item; - std::vector elems; - while (std::getline(ss, item, ',')) { - elems.push_back(item); - } - - const auto num_svs = (elems.size() >= 7) ? elems[7] : "?"; - - etiLog.level(info) << "OutputUHD: " << num_svs << " SVs," - " gps_timelock " << sensor_value; - return false; - } - - return true; - } - catch (const uhd::exception &e) { - etiLog.level(warn) << "OutputUHD: no gps_timelock sensor: " << - e.what(); - return false; - } -} - -// Check function for GPS LOCKED sensor from the Ettus GPSDO -static bool check_gps_locked(uhd::usrp::multi_usrp::sptr& usrp) -{ - try { - const uhd::sensor_value_t sensor_value( - usrp->get_mboard_sensor("gps_locked", 0)); - if (not sensor_value.to_bool()) { - etiLog.level(warn) << "OutputUHD: gps_locked " << - sensor_value.to_pp_string(); - return false; - } - - return true; - } - catch (const uhd::exception &e) { - etiLog.level(warn) << "OutputUHD: no gps_locked sensor" << - e.what(); - return false; - } -} - - USRPTime::USRPTime( uhd::usrp::multi_usrp::sptr usrp, SDRDeviceConfig& conf) : @@ -104,26 +46,6 @@ USRPTime::USRPTime( m_conf(conf), time_last_check(timepoint_t::clock::now()) { - - if (m_conf.pps_src == "gpsdo") { - using namespace std::chrono; - auto now = system_clock::now(); - auto expiry = now + seconds(m_conf.maxGPSHoldoverTime); - auto checkfunc = gpsdo_is_ettus() ? check_gps_locked : check_gps_timelock; - while (now < expiry) { - if (checkfunc(m_usrp)) { - break; - } - - now = system_clock::now(); - this_thread::sleep_for(seconds(2)); - } - - if (not checkfunc(m_usrp)) { - throw runtime_error("GPSDO did not lock during startup"); - } - } - if (m_conf.pps_src == "none") { if (m_conf.enableSync) { etiLog.level(warn) << @@ -133,8 +55,18 @@ USRPTime::USRPTime( set_usrp_time_from_localtime(); } - else if (m_conf.pps_src == "pps" or m_conf.pps_src == "gpsdo") { - set_usrp_time_from_pps(); + else if (m_conf.pps_src == "pps") { + // let verify_time handle time setup + } + else if (m_conf.pps_src == "gpsdo") { + if (gpsdo_is_ettus() ? check_gps_locked() : check_gps_timelock()) { + set_usrp_time_from_pps(); + gps_state = gps_state_e::monitor_fix; + num_checks_without_gps_fix = 0; + } + else { + // let verify_time handle time setup + } } else { throw std::runtime_error("USRPTime not implemented yet: " + @@ -193,6 +125,11 @@ bool USRPTime::verify_time() throw logic_error("End of USRPTime::verify_time() reached"); } +gnss_stats_t USRPTime::get_gnss_stats(void) const +{ + return gnss_stats; +} + void USRPTime::check_gps() { timepoint_t time_now = timepoint_t::clock::now(); @@ -224,11 +161,11 @@ void USRPTime::check_gps() // time, it has to be done in a separate thread. if (gpsdo_is_ettus()) { gps_fix_future = std::async(std::launch::async, - std::bind(check_gps_locked, m_usrp) ); + std::bind(&USRPTime::check_gps_locked, this) ); } else { gps_fix_future = std::async(std::launch::async, - std::bind(check_gps_timelock, m_usrp) ); + std::bind(&USRPTime::check_gps_timelock, this) ); } } } @@ -239,11 +176,15 @@ bool USRPTime::gpsfix_needs_check() const if (m_conf.refclk_src == "internal") { return false; } - else if (m_conf.refclk_src == "gpsdo") { + else if (gps_state == gps_state_e::monitor_fix and + (m_conf.refclk_src == "gpsdo" or + m_conf.refclk_src == "gpsdo-ettus")) { return (m_conf.maxGPSHoldoverTime != 0); } - else if (m_conf.refclk_src == "gpsdo-ettus") { - return (m_conf.maxGPSHoldoverTime != 0); + else if (gps_state == gps_state_e::bootup and + (m_conf.refclk_src == "gpsdo" or + m_conf.refclk_src == "gpsdo-ettus")) { + return true; } else { return false; @@ -308,6 +249,78 @@ void USRPTime::set_usrp_time_from_pps() } } + +// Check functionality of GPS sensors applicable to the ODR LEA-M8F board GPSDO +bool USRPTime::check_gps_timelock() +{ + bool locked = false; + + try { + const string sensor_value = + m_usrp->get_mboard_sensor("gps_timelock", 0).to_pp_string(); + + const string gngga = + m_usrp->get_mboard_sensor("gps_gngga", 0).to_pp_string(); + + std::stringstream ss(gngga); + std::string item; + std::vector elems; + while (std::getline(ss, item, ',')) { + elems.push_back(item); + } + + const auto num_svs = (elems.size() > 7) ? elems[7] : "0"; + gnss_stats.num_sv = std::stoi(num_svs); + + locked = (sensor_value.find("TIME LOCKED") != string::npos); + } + catch (const uhd::exception &e) { + etiLog.level(warn) << "OutputUHD: no gps_timelock sensor: " << + e.what(); + } + + // LEA-M8F-patched UHD 3.12.0 has this additional sensor, that can + // be used to distinguish holdover operation. Previous versions + // did a config reset at startup to ensure we would not startup while + // in holdover. + try { + const string disc_src = + m_usrp->get_mboard_sensor("gps_discsrc", 0).to_pp_string(); + + locked &= (disc_src.find("gnss") != string::npos); + } + catch (const uhd::exception &e) { + etiLog.level(warn) << "OutputUHD: no gps_timelock sensor: " << + e.what(); + } + + gnss_stats.holdover = not locked; + + return locked; +} + +// Check function for GPS LOCKED sensor from the Ettus GPSDO +bool USRPTime::check_gps_locked() +{ + try { + const uhd::sensor_value_t sensor_value( + m_usrp->get_mboard_sensor("gps_locked", 0)); + if (not sensor_value.to_bool()) { + etiLog.level(warn) << "OutputUHD: gps_locked " << + sensor_value.to_pp_string(); + return false; + } + + return true; + } + catch (const uhd::exception &e) { + etiLog.level(warn) << "OutputUHD: no gps_locked sensor" << + e.what(); + return false; + } +} + + } // namespace Output #endif // HAVE_OUTPUT_UHD diff --git a/src/output/USRPTime.h b/src/output/USRPTime.h index 51ca800..bc862fd 100644 --- a/src/output/USRPTime.h +++ b/src/output/USRPTime.h @@ -2,7 +2,7 @@ Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Her Majesty the Queen in Right of Canada (Communications Research Center Canada) - Copyright (C) 2017 + Copyright (C) 2018 Matthias P. Braendli, matthias.braendli@mpb.li http://opendigitalradio.org @@ -54,16 +54,24 @@ DESCRIPTION: namespace Output { +struct gnss_stats_t { + int num_sv = 0; // Number of Satellite Vehicles used + bool holdover = false; // True if LEA-M8F uses its internal time reference +}; + class USRPTime { public: USRPTime( uhd::usrp::multi_usrp::sptr usrp, SDRDeviceConfig& conf); // Verifies the GPSDO state, that the device time is ok. - // Returns true if all ok. + // Returns true if all ok. Needs to be called so the device + // time gets properly set. // Should be called more often than the gps_fix_check_interval bool verify_time(void); + gnss_stats_t get_gnss_stats(void) const; + // Wait time in seconds to get fix static const int initial_gps_fix_wait = 180; @@ -72,10 +80,8 @@ class USRPTime { private: enum class gps_state_e { - /* At startup, the LEA-M8F GPSDO gets issued a hotstart request to - * make sure we will not sync time on a PPS edge that is generated - * while the GPSDO is in holdover. In the bootup state, we wait for - * the first PPS after hotstart, and then sync time. + /* In the bootup state, we wait for correct time lock and + * the first PPS, and then sync time. */ bootup, @@ -93,6 +99,8 @@ class USRPTime { gps_state_e gps_state = gps_state_e::bootup; int num_checks_without_gps_fix = 1; + gnss_stats_t gnss_stats; + using timepoint_t = std::chrono::time_point; timepoint_t time_last_check; @@ -107,6 +115,9 @@ class USRPTime { void set_usrp_time_from_localtime(void); void set_usrp_time_from_pps(void); + + bool check_gps_timelock(void); + bool check_gps_locked(void); }; } // namespace Output -- cgit v1.2.3