/***********************************************************************
* RX Hammer
**********************************************************************/
void rx_hammer(uhd::usrp::multi_usrp::sptr usrp, const std::string &rx_cpu, const std::string &rx_otw){
uhd::set_thread_priority_safe();
//create a receive streamer
uhd::stream_args_t stream_args(rx_cpu, rx_otw);
for (size_t ch = 0; ch < usrp->get_num_mboards(); ch++) //linear channel mapping
stream_args.channels.push_back(ch);
uhd::rx_streamer::sptr rx_stream = usrp->get_rx_stream(stream_args);
//print pre-test summary
std::cout << boost::format(
"Testing receive rate %f Msps"
) % (usrp->get_rx_rate()/1e6) << std::endl;
//setup variables and allocate buffer
uhd::rx_metadata_t md;
const size_t max_samps_per_packet = rx_stream->get_max_num_samps();
std::vector<char> buff(max_samps_per_packet*uhd::convert::get_bytes_per_item(rx_cpu));
std::vector<void *> buffs;
for (size_t ch = 0; ch < stream_args.channels.size(); ch++)
buffs.push_back(&buff.front()); //same buffer for each channel
bool had_an_overflow = false;
uhd::time_spec_t last_time;
const double rate = usrp->get_rx_rate();
double timeout = 1;
uhd::stream_cmd_t cmd(uhd::stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_DONE);
cmd.time_spec = usrp->get_time_now() + uhd::time_spec_t(0.05);
cmd.stream_now = (buffs.size() == 1);
srand( time(NULL) );
while (not boost::this_thread::interruption_requested()){
cmd.num_samps = rand() % 100000;
usrp->issue_stream_cmd(cmd);
num_rx_samps += rx_stream->recv(buffs, max_samps_per_packet, md, timeout, true);
//handle the error codes
switch(md.error_code){
case uhd::rx_metadata_t::ERROR_CODE_NONE:
if (had_an_overflow){
had_an_overflow = false;
num_dropped_samps += boost::math::iround((md.time_spec - last_time).get_real_secs()*rate);
}
break;
case uhd::rx_metadata_t::ERROR_CODE_OVERFLOW:
had_an_overflow = true;
last_time = md.time_spec;
num_overflows++;
break;
default:
std::cerr << "Error code: " << md.error_code << std::endl;
std::cerr << "Unexpected error on recv, continuing..." << std::endl;
break;
}
}
}
bool check_clock_lock(uhd::usrp::multi_usrp::sptr usrp) {
std::cout << std::endl << "Checking USRP devices for lock." << std::endl;
bool all_locked = true;
for(size_t ch = 0; ch < usrp->get_num_mboards(); ch++){
std::string ref_locked = usrp->get_mboard_sensor("ref_locked",ch).value;
if(ref_locked != "true") all_locked = false;
}
if(not all_locked) std::cout << std::endl << "ERROR: USRP not locked to clock." << std::endl;
return all_locked;
}
/***********************************************************************
* TX Hammer
**********************************************************************/
void tx_hammer(uhd::usrp::multi_usrp::sptr usrp, const std::string &tx_cpu, const std::string &tx_otw){
uhd::set_thread_priority_safe();
//create a transmit streamer
uhd::stream_args_t stream_args(tx_cpu, tx_otw);
for (size_t ch = 0; ch < usrp->get_num_mboards(); ch++) //linear channel mapping
stream_args.channels.push_back(ch);
uhd::tx_streamer::sptr tx_stream = usrp->get_tx_stream(stream_args);
uhd::tx_metadata_t md;
std::vector<std::complex<float> > buff(10000);
//print pre-test summary
std::cout << boost::format(
"Testing transmit rate %f Msps"
) % (usrp->get_tx_rate()/1e6) << std::endl;
//setup variables and allocate buffer
std::srand( time(NULL) );
while(not boost::this_thread::interruption_requested()){
size_t total_num_samps = rand() % 100000;
size_t num_acc_samps = 0;
float timeout = 1;
usrp->set_time_now(uhd::time_spec_t(0.0));
while(num_acc_samps < total_num_samps){
//send a single packet
num_tx_samps += tx_stream->send(&buff, tx_stream->get_max_num_samps(), md, timeout);
num_acc_samps += std::min(total_num_samps-num_acc_samps, tx_stream->get_max_num_samps());
}
//send a mini EOB packet
md.end_of_burst = true;
tx_stream->send("", 0, md);
}
}