/***********************************************************************
* Tune RX and TX routine
**********************************************************************/
static double tune_rx_and_tx(uhd::usrp::multi_usrp::sptr usrp, const double tx_lo_freq, const double rx_offset)
{
//tune the transmitter with no cordic
uhd::tune_request_t tx_tune_req(tx_lo_freq);
tx_tune_req.dsp_freq_policy = uhd::tune_request_t::POLICY_MANUAL;
tx_tune_req.dsp_freq = 0;
usrp->set_tx_freq(tx_tune_req);
//tune the receiver
double rx_freq = usrp->get_tx_freq() - rx_offset;
double min_fe_rx_freq = usrp->get_fe_rx_freq_range().start();
double max_fe_rx_freq = usrp->get_fe_rx_freq_range().stop();
uhd::tune_request_t rx_tune_req(rx_freq);
rx_tune_req.dsp_freq_policy = uhd::tune_request_t::POLICY_MANUAL;
rx_tune_req.dsp_freq = 0;
if (rx_freq < min_fe_rx_freq)
rx_tune_req.dsp_freq = rx_freq - min_fe_rx_freq;
else if (rx_freq > max_fe_rx_freq)
rx_tune_req.dsp_freq = rx_freq - max_fe_rx_freq;
usrp->set_rx_freq(rx_tune_req);
//wait for the LOs to become locked
boost::this_thread::sleep(boost::posix_time::milliseconds(50));
boost::system_time start = boost::get_system_time();
while (not usrp->get_tx_sensor("lo_locked").to_bool() or not usrp->get_rx_sensor("lo_locked").to_bool())
{
if (boost::get_system_time() > start + boost::posix_time::milliseconds(100))
throw std::runtime_error("timed out waiting for TX and/or RX LO to lock");
}
return usrp->get_tx_freq();
}
/***********************************************************************
* Tune RX and TX routine
**********************************************************************/
static double tune_rx_and_tx(
uhd::usrp::multi_usrp::sptr usrp, const double tx_lo_freq, const double rx_offset)
{
// tune the transmitter with no cordic
uhd::tune_request_t tx_tune_req(tx_lo_freq);
tx_tune_req.dsp_freq_policy = uhd::tune_request_t::POLICY_MANUAL;
tx_tune_req.dsp_freq = 0;
usrp->set_tx_freq(tx_tune_req);
// tune the receiver
double rx_freq = usrp->get_tx_freq() - rx_offset;
double min_fe_rx_freq = usrp->get_fe_rx_freq_range().start();
double max_fe_rx_freq = usrp->get_fe_rx_freq_range().stop();
uhd::tune_request_t rx_tune_req(rx_freq);
rx_tune_req.dsp_freq_policy = uhd::tune_request_t::POLICY_MANUAL;
rx_tune_req.dsp_freq = 0;
if (rx_freq < min_fe_rx_freq)
rx_tune_req.dsp_freq = rx_freq - min_fe_rx_freq;
else if (rx_freq > max_fe_rx_freq)
rx_tune_req.dsp_freq = rx_freq - max_fe_rx_freq;
usrp->set_rx_freq(rx_tune_req);
wait_for_lo_lock(usrp);
return usrp->get_tx_freq();
}
bool uhd_device::setRxFreq(double wFreq)
{
uhd::tune_result_t tr = usrp_dev->set_rx_freq(wFreq);
LOG(INFO) << "\n" << tr.to_pp_string();
rx_freq = usrp_dev->get_rx_freq();
return true;
}
int setup_device(uhd::usrp::multi_usrp::sptr usrp, double rx_gain, double tx_gain, double freq, double rate){
//create a usrp device
std::cout << boost::format("Using Device: %s") % usrp->get_pp_string() << std::endl;
usrp->set_rx_rate(rate);
usrp->set_rx_freq(freq);
usrp->set_rx_gain(rx_gain);
usrp->set_tx_rate(rate);
usrp->set_tx_freq(freq);
usrp->set_tx_gain(tx_gain);
}
void init_usrp() {
cout << "Initial USRP" << endl;
usrp = uhd::usrp::multi_usrp::make(usrp_ip);
usrp->set_rx_rate(rate);
usrp->set_tx_rate(rate);
usrp->set_rx_freq(freq);
usrp->set_tx_freq(freq);
usrp->set_rx_gain(gain);
uhd::meta_range_t rx_range = usrp->get_rx_gain_range();
}
int setupUSRP( uhd::usrp::multi_usrp::sptr& usrp,
const float center_freq,
const float sample_rate,
const int rx_gain,
const char* dev_addr)
{
//Initialize the USRP to the specified address
usrp = uhd::usrp::multi_usrp::make(string(dev_addr));
//Define the clock reference
usrp->set_clock_source(__USRP_CLK_SRC);
//Output some useful information
cout << "Using the following USRP device: " << endl
<< usrp->get_pp_string() << endl;
//Try setting the sample rate. If the rate we get is not the same as the
//requested rate, we will return with a warning to ensure the user is aware
//of the actual sample rate
usrp->set_rx_rate( sample_rate );
if( usrp->get_rx_rate() != sample_rate )
{
ios_base::fmtflags originalFlags = cout.flags();
cout.setf(ios_base::left,ios_base::floatfield);
cout.precision(15);
cout << "WARNING! Requested rate = " << sample_rate << endl
<< "WARNING! Actual rate = " << usrp->get_rx_rate() << endl;
cout.setf(originalFlags);
}
//Try setting the center frequency. Like above, if we get a different
//frequency than the one we're requesting, we will spit out a warning for the
//user
usrp->set_rx_freq( center_freq );
if( usrp->get_rx_freq() != center_freq )
{
ios_base::fmtflags originalFlags = cout.flags();
cout.setf(ios_base::left,ios_base::floatfield);
cout.precision(15);
cout << "WARNING! Requested frequency = " << center_freq << endl
<< "WARNING! Actual frequency = " << usrp->get_rx_freq() << endl;
cout.setf(originalFlags);
}
//Set the RX gain. There really shouldn't be any problems here, but the user
//might request something silly like 50dB of gain when the module can't
//accomodate. So we'll perform a similar check here.
usrp->set_rx_gain( rx_gain );
if( usrp->get_rx_gain() != rx_gain )
{
cout << "WARNING! Requested gain = " << rx_gain << endl
<< "WARNING! Actual gain = " << usrp->get_rx_gain() << endl;
}
//Ensure the LO locked
vector<string> sensor_names;
sensor_names = usrp->get_rx_sensor_names(0);
if( find(sensor_names.begin(), sensor_names.end(), "lo_locked")
!= sensor_names.end() )
{
uhd::sensor_value_t lo_locked = usrp->get_rx_sensor("lo_locked",0);
cout << "Checking RX: " << endl
<< lo_locked.to_pp_string() << endl;
UHD_ASSERT_THROW(lo_locked.to_bool()); //We should probably catch this
}
return 1;
}