diff --git a/targets/ARCH/COMMON/common_lib.h b/targets/ARCH/COMMON/common_lib.h
index be69a7027a77e863bfa75f2cb5ed3b576ca30b2d..129705c2295d75fc2efb29b875639692edc11034 100644
--- a/targets/ARCH/COMMON/common_lib.h
+++ b/targets/ARCH/COMMON/common_lib.h
@@ -140,7 +140,9 @@ typedef enum {
//! This tells the underlying hardware to use the internal reference
internal=0,
//! This tells the underlying hardware to use the external reference
- external=1
+ external=1,
+ //! This tells the underlying hardware to use the gpsdo reference
+ gpsdo=2
} clock_source_t;
/*! \brief RF frontend parameters set by application */
diff --git a/targets/ARCH/USRP/USERSPACE/LIB/usrp_lib.cpp b/targets/ARCH/USRP/USERSPACE/LIB/usrp_lib.cpp
index df91796049332360b9265b4f7b982108d1319568..a4400ee056149d8978a59a6e4aa207d0085b3d79 100644
--- a/targets/ARCH/USRP/USERSPACE/LIB/usrp_lib.cpp
+++ b/targets/ARCH/USRP/USERSPACE/LIB/usrp_lib.cpp
@@ -33,6 +33,8 @@
#include <uhd/version.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/algorithm/string.hpp>
+#include <boost/thread.hpp>
+#include <boost/format.hpp>
#include <iostream>
#include <complex>
#include <fstream>
@@ -92,12 +94,181 @@ typedef struct {
int num_seq_errors;
int64_t tx_count;
int64_t rx_count;
+ int wait_for_first_pps;
+ int use_gps;
//! timestamp of RX packet
openair0_timestamp rx_timestamp;
} usrp_state_t;
+//void print_notes(void)
+//{
+ // Helpful notes
+ // std::cout << boost::format("**************************************Helpful Notes on Clock/PPS Selection**************************************\n");
+ // std::cout << boost::format("As you can see, the default 10 MHz Reference and 1 PPS signals are now from the GPSDO.\n");
+ // std::cout << boost::format("If you would like to use the internal reference(TCXO) in other applications, you must configure that explicitly.\n");
+ // std::cout << boost::format("You can no longer select the external SMAs for 10 MHz or 1 PPS signaling.\n");
+ // std::cout << boost::format("****************************************************************************************************************\n");
+//}
+
+static int sync_to_gps(openair0_device *device)
+{
+ uhd::set_thread_priority_safe();
+
+ //std::string args;
+
+ //Set up program options
+ //po::options_description desc("Allowed options");
+ //desc.add_options()
+ //("help", "help message")
+ //("args", po::value<std::string>(&args)->default_value(""), "USRP device arguments")
+ //;
+ //po::variables_map vm;
+ //po::store(po::parse_command_line(argc, argv, desc), vm);
+ //po::notify(vm);
+
+ //Print the help message
+ //if (vm.count("help"))
+ //{
+ // std::cout << boost::format("Synchronize USRP to GPS %s") % desc << std::endl;
+ // return EXIT_FAILURE;
+ //}
+
+ //Create a USRP device
+ //std::cout << boost::format("\nCreating the USRP device with: %s...\n") % args;
+ //uhd::usrp::multi_usrp::sptr usrp = uhd::usrp::multi_usrp::make(args);
+ //std::cout << boost::format("Using Device: %s\n") % usrp->get_pp_string();
+
+ usrp_state_t *s = (usrp_state_t*)device->priv;
+
+ try
+ {
+ size_t num_mboards = s->usrp->get_num_mboards();
+ size_t num_gps_locked = 0;
+ for (size_t mboard = 0; mboard < num_mboards; mboard++)
+ {
+ std::cout << "Synchronizing mboard " << mboard << ": " << s->usrp->get_mboard_name(mboard) << std::endl;
+
+ //Set references to GPSDO
+ s->usrp->set_clock_source("gpsdo", mboard);
+ s->usrp->set_time_source("gpsdo", mboard);
+
+ //std::cout << std::endl;
+ //print_notes();
+ //std::cout << std::endl;
+
+ //Check for 10 MHz lock
+ std::vector<std::string> sensor_names = s->usrp->get_mboard_sensor_names(mboard);
+ if(std::find(sensor_names.begin(), sensor_names.end(), "ref_locked") != sensor_names.end())
+ {
+ std::cout << "Waiting for reference lock..." << std::flush;
+ bool ref_locked = false;
+ for (int i = 0; i < 30 and not ref_locked; i++)
+ {
+ ref_locked = s->usrp->get_mboard_sensor("ref_locked", mboard).to_bool();
+ if (not ref_locked)
+ {
+ std::cout << "." << std::flush;
+ boost::this_thread::sleep(boost::posix_time::seconds(1));
+ }
+ }
+ if(ref_locked)
+ {
+ std::cout << "LOCKED" << std::endl;
+ } else {
+ std::cout << "FAILED" << std::endl;
+ std::cout << "Failed to lock to GPSDO 10 MHz Reference. Exiting." << std::endl;
+ exit(EXIT_FAILURE);
+ }
+ }
+ else
+ {
+ std::cout << boost::format("ref_locked sensor not present on this board.\n");
+ }
+
+ //Wait for GPS lock
+ bool gps_locked = s->usrp->get_mboard_sensor("gps_locked", mboard).to_bool();
+ if(gps_locked)
+ {
+ num_gps_locked++;
+ std::cout << boost::format("GPS Locked\n");
+ }
+ else
+ {
+ std::cerr << "WARNING: GPS not locked - time will not be accurate until locked" << std::endl;
+ }
+
+ //Set to GPS time
+ uhd::time_spec_t gps_time = uhd::time_spec_t(time_t(s->usrp->get_mboard_sensor("gps_time", mboard).to_int()));
+ //s->usrp->set_time_next_pps(gps_time+1.0, mboard);
+ s->usrp->set_time_next_pps(uhd::time_spec_t(0.0));
+
+ //Wait for it to apply
+ //The wait is 2 seconds because N-Series has a known issue where
+ //the time at the last PPS does not properly update at the PPS edge
+ //when the time is actually set.
+ boost::this_thread::sleep(boost::posix_time::seconds(2));
+
+ //Check times
+ gps_time = uhd::time_spec_t(time_t(s->usrp->get_mboard_sensor("gps_time", mboard).to_int()));
+ uhd::time_spec_t time_last_pps = s->usrp->get_time_last_pps(mboard);
+ std::cout << "USRP time: " << (boost::format("%0.9f") % time_last_pps.get_real_secs()) << std::endl;
+ std::cout << "GPSDO time: " << (boost::format("%0.9f") % gps_time.get_real_secs()) << std::endl;
+ //if (gps_time.get_real_secs() == time_last_pps.get_real_secs())
+ // std::cout << std::endl << "SUCCESS: USRP time synchronized to GPS time" << std::endl << std::endl;
+ //else
+ // std::cerr << std::endl << "ERROR: Failed to synchronize USRP time to GPS time" << std::endl << std::endl;
+ }
+
+ if (num_gps_locked == num_mboards and num_mboards > 1)
+ {
+ //Check to see if all USRP times are aligned
+ //First, wait for PPS.
+ uhd::time_spec_t time_last_pps = s->usrp->get_time_last_pps();
+ while (time_last_pps == s->usrp->get_time_last_pps())
+ {
+ boost::this_thread::sleep(boost::posix_time::milliseconds(1));
+ }
+
+ //Sleep a little to make sure all devices have seen a PPS edge
+ boost::this_thread::sleep(boost::posix_time::milliseconds(200));
+
+ //Compare times across all mboards
+ bool all_matched = true;
+ uhd::time_spec_t mboard0_time = s->usrp->get_time_last_pps(0);
+ for (size_t mboard = 1; mboard < num_mboards; mboard++)
+ {
+ uhd::time_spec_t mboard_time = s->usrp->get_time_last_pps(mboard);
+ if (mboard_time != mboard0_time)
+ {
+ all_matched = false;
+ std::cerr << (boost::format("ERROR: Times are not aligned: USRP 0=%0.9f, USRP %d=%0.9f")
+ % mboard0_time.get_real_secs()
+ % mboard
+ % mboard_time.get_real_secs()) << std::endl;
+ }
+ }
+ if (all_matched)
+ {
+ std::cout << "SUCCESS: USRP times aligned" << std::endl << std::endl;
+ } else {
+ std::cout << "ERROR: USRP times are not aligned" << std::endl << std::endl;
+ }
+ }
+ }
+ catch (std::exception& e)
+ {
+ std::cout << boost::format("\nError: %s") % e.what();
+ std::cout << boost::format("This could mean that you have not installed the GPSDO correctly.\n\n");
+ std::cout << boost::format("Visit one of these pages if the problem persists:\n");
+ std::cout << boost::format(" * N2X0/E1X0: http://files.ettus.com/manual/page_gpsdo.html");
+ std::cout << boost::format(" * X3X0: http://files.ettus.com/manual/page_gpsdo_x3x0.html\n\n");
+ std::cout << boost::format(" * E3X0: http://files.ettus.com/manual/page_usrp_e3x0.html#e3x0_hw_gps\n\n");
+ exit(EXIT_FAILURE);
+ }
+ return EXIT_SUCCESS;
+}
/*! \brief Called to start the USRP transceiver. Return 0 if OK, < 0 if error
@param device pointer to the device structure specific to the RF hardware target
@@ -106,9 +277,31 @@ static int trx_usrp_start(openair0_device *device) {
usrp_state_t *s = (usrp_state_t*)device->priv;
+
+ // setup GPIO for TDD, GPIO(4) = ATR_RX
+ //set data direction register (DDR) to output
+ s->usrp->set_gpio_attr("FP0", "DDR", 0x1f, 0x1f);
+
+ //set control register to ATR
+ s->usrp->set_gpio_attr("FP0", "CTRL", 0x1f,0x1f);
+
+ //set ATR register
+ s->usrp->set_gpio_attr("FP0", "ATR_RX", 1<<4, 0x1f);
+
// init recv and send streaming
uhd::stream_cmd_t cmd(uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS);
- cmd.time_spec = s->usrp->get_time_now() + uhd::time_spec_t(0.05);
+ LOG_I(PHY,"Time in secs now: %llu \n", s->usrp->get_time_now().to_ticks(s->sample_rate));
+ LOG_I(PHY,"Time in secs last pps: %llu \n", s->usrp->get_time_last_pps().to_ticks(s->sample_rate));
+
+ if (s->use_gps == 1) {
+ s->wait_for_first_pps = 1;
+ cmd.time_spec = s->usrp->get_time_last_pps() + uhd::time_spec_t(1.0);
+ }
+ else {
+ s->wait_for_first_pps = 0;
+ cmd.time_spec = s->usrp->get_time_now() + uhd::time_spec_t(0.05);
+ }
+
cmd.stream_now = false; // start at constant delay
s->rx_stream->issue_stream_cmd(cmd);
@@ -227,9 +420,11 @@ static int trx_usrp_read(openair0_device *device, openair0_timestamp *ptimestamp
while (samples_received != nsamps) {
samples_received += s->rx_stream->recv(buff_tmp[0]+samples_received,
nsamps-samples_received, s->rx_md);
- if (s->rx_md.error_code!=uhd::rx_metadata_t::ERROR_CODE_NONE)
+ if ((s->wait_for_first_pps == 0) && (s->rx_md.error_code!=uhd::rx_metadata_t::ERROR_CODE_NONE))
break;
+ if ((s->wait_for_first_pps == 1) && (samples_received != nsamps)) { printf("sleep...\n");} //usleep(100);
}
+ if (samples_received == nsamps) s->wait_for_first_pps=0;
}
// bring RX data into 12 LSBs for softmodem RX
for (int i=0; i<cc; i++) {
@@ -468,6 +663,10 @@ extern "C" {
int device_init(openair0_device* device, openair0_config_t *openair0_cfg) {
uhd::set_thread_priority_safe(1.0);
usrp_state_t *s = (usrp_state_t*)calloc(sizeof(usrp_state_t),1);
+
+ if (openair0_cfg[0].clock_source==gpsdo)
+ s->use_gps =1;
+
// Initialize USRP device
device->openair0_cfg = openair0_cfg;
@@ -561,10 +760,13 @@ extern "C" {
// set master clock rate and sample rate for tx & rx for streaming
// lock mboard clocks
- if (openair0_cfg[0].clock_source == internal)
- s->usrp->set_clock_source("internal");
- else
+ if (openair0_cfg[0].clock_source == internal){
+ s->usrp->set_clock_source("internal");
+ }
+ else{
s->usrp->set_clock_source("external");
+ s->usrp->set_time_source("external");
+ }
device->type = USRP_B200_DEV;
if ((vers == 3) && (subvers == 9) && (subsubvers>=2)) {
@@ -683,8 +885,6 @@ extern "C" {
for(int i=0; i<s->usrp->get_rx_num_channels() && i<openair0_cfg[0].rx_num_channels; i++)
s->usrp->set_rx_bandwidth(openair0_cfg[0].rx_bw,i);
- s->usrp->set_time_now(uhd::time_spec_t(0.0));
-
for (int i=0; i<openair0_cfg[0].rx_num_channels; i++) {
LOG_I(PHY,"RX Channel %d\n",i);
LOG_I(PHY," Actual RX sample rate: %fMSps...\n",s->usrp->get_rx_rate(i)/1e6);
@@ -726,6 +926,14 @@ extern "C" {
s->tx_forward_nsamps = 90;
if(is_equal(s->sample_rate, (double)7.68e6))
s->tx_forward_nsamps = 50;
+
+ if (s->use_gps == 1) {
+ if (sync_to_gps(device)) {
+ LOG_I(PHY,"USRP fails to sync with GPS...\n");
+ exit(0);
+ }
+ }
+
return 0;
}
}
diff --git a/targets/RT/USER/lte-enb.c b/targets/RT/USER/lte-enb.c
index 5cbe0fe1d4d2bb40bfd20c34512c0413d83234c3..5a2662dc3f5af87a25164100daf38263b99098ba 100644
--- a/targets/RT/USER/lte-enb.c
+++ b/targets/RT/USER/lte-enb.c
@@ -945,7 +945,7 @@ void rx_rf(PHY_VARS_eNB *eNB,int *frame,int *subframe) {
int siglen=fp->samples_per_tti,flags=1;
if (SF_type == SF_S) {
- siglen = fp->dl_symbols_in_S_subframe*(fp->ofdm_symbol_size+fp->nb_prefix_samples0);
+ siglen = (fp->dl_symbols_in_S_subframe+1)*(fp->ofdm_symbol_size+fp->nb_prefix_samples0);
flags=3; // end of burst
}
if ((fp->frame_type == TDD) &&
diff --git a/targets/RT/USER/lte-softmodem.c b/targets/RT/USER/lte-softmodem.c
index a1f3bcb57b209ec28d86b097e9213e5996cd05ed..d680a4246422ff11ff5592911f225cc17abbf4a6 100644
--- a/targets/RT/USER/lte-softmodem.c
+++ b/targets/RT/USER/lte-softmodem.c
@@ -608,9 +608,6 @@ static void get_options (int argc, char **argv) {
// char line[1000];
// int l;
int k,i;//,j,k;
-#if defined(OAI_USRP) || defined(CPRIGW)
- int clock_src;
-#endif
int CC_id;
@@ -639,6 +636,7 @@ static void get_options (int argc, char **argv) {
LONG_OPTION_USIMTEST,
LONG_OPTION_MMAPPED_DMA,
LONG_OPTION_EXTERNAL_CLOCK,
+ LONG_OPTION_GPSDO_CLOCK,
LONG_OPTION_WAIT_FOR_SYNC,
LONG_OPTION_SINGLE_THREAD_DISABLE,
LONG_OPTION_THREADIQ,
@@ -681,6 +679,7 @@ static void get_options (int argc, char **argv) {
{"usim-test", no_argument, NULL, LONG_OPTION_USIMTEST},
{"mmapped-dma", no_argument, NULL, LONG_OPTION_MMAPPED_DMA},
{"external-clock", no_argument, NULL, LONG_OPTION_EXTERNAL_CLOCK},
+ {"gpsdo-clock", no_argument, NULL, LONG_OPTION_GPSDO_CLOCK},
{"wait-for-sync", no_argument, NULL, LONG_OPTION_WAIT_FOR_SYNC},
{"single-thread-disable", no_argument, NULL, LONG_OPTION_SINGLE_THREAD_DISABLE},
{"threadIQ", required_argument, NULL, LONG_OPTION_THREADIQ},
@@ -810,6 +809,10 @@ static void get_options (int argc, char **argv) {
clock_source = external;
break;
+ case LONG_OPTION_GPSDO_CLOCK:
+ clock_source = gpsdo;
+ break;
+
case LONG_OPTION_WAIT_FOR_SYNC:
wait_for_sync = 1;
break;
@@ -1002,24 +1005,6 @@ static void get_options (int argc, char **argv) {
break;
- case 's':
-#if defined(OAI_USRP) || defined(CPRIGW)
-
- clock_src = atoi(optarg);
-
- if (clock_src == 0) {
- // char ref[128] = "internal";
- //strncpy(uhd_ref, ref, strlen(ref)+1);
- } else if (clock_src == 1) {
- //char ref[128] = "external";
- //strncpy(uhd_ref, ref, strlen(ref)+1);
- }
-
-#else
- printf("Note: -s not defined for ExpressMIMO2\n");
-#endif
- break;
-
case 'S':
exit_missed_slots=0;
printf("Skip exit for missed slots\n");