int UHD_SAFE_MAIN(int argc, char *argv[]){ uhd::set_thread_priority_safe(); //variables to be set by po std::string args; //setup the program options po::options_description desc("Allowed options"); desc.add_options() ("help", "help message") ("args", po::value<std::string>(&args)->default_value(""), "single uhd device address args") ; 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("UHD Test Timed Commands %s") % desc << std::endl; return ~0; } //create a usrp device std::cout << std::endl; std::cout << boost::format("Creating the usrp device with: %s...") % args << std::endl; uhd::usrp::multi_usrp::sptr usrp = uhd::usrp::multi_usrp::make(args); std::cout << boost::format("Using Device: %s") % usrp->get_pp_string() << std::endl; //check if timed commands are supported std::cout << std::endl; std::cout << "Testing support for timed commands on this hardware... " << std::flush; try{ usrp->set_command_time(uhd::time_spec_t(0.0)); usrp->clear_command_time(); } catch (const std::exception &e){ std::cout << "fail" << std::endl; std::cerr << "Got exception: " << e.what() << std::endl; std::cerr << "Timed commands are not supported on this hardware." << std::endl; return ~0; } std::cout << "pass" << std::endl; //readback time really fast, time diff is small std::cout << std::endl; std::cout << "Perform fast readback of registers:" << std::endl; uhd::time_spec_t total_time; for (size_t i = 0; i < 100; i++){ const uhd::time_spec_t t0 = usrp->get_time_now(); const uhd::time_spec_t t1 = usrp->get_time_now(); total_time += (t1-t0); } std::cout << boost::format( "Difference between paired reads: %f us" ) % (total_time.get_real_secs()/100*1e6) << std::endl; //use a timed command to start a stream at a specific time //this is not the right way start streaming at time x, //but it should approximate it within control RTT/2 //setup streaming std::cout << std::endl; std::cout << "About to start streaming using timed command:" << std::endl; //create a receive streamer uhd::stream_args_t stream_args("fc32"); //complex floats uhd::rx_streamer::sptr rx_stream = usrp->get_rx_stream(stream_args); uhd::stream_cmd_t stream_cmd(uhd::stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_DONE); stream_cmd.num_samps = 100; stream_cmd.stream_now = true; const uhd::time_spec_t stream_time = usrp->get_time_now() + uhd::time_spec_t(0.1); usrp->set_command_time(stream_time); rx_stream->issue_stream_cmd(stream_cmd); usrp->clear_command_time(); //meta-data will be filled in by recv() uhd::rx_metadata_t md; //allocate buffer to receive with samples std::vector<std::complex<float> > buff(stream_cmd.num_samps); const size_t num_rx_samps = rx_stream->recv(&buff.front(), buff.size(), md, 1.0); if (md.error_code != uhd::rx_metadata_t::ERROR_CODE_NONE){ throw std::runtime_error(str(boost::format( "Unexpected error code 0x%x" ) % md.error_code)); } std::cout << boost::format( "Received packet: %u samples, %u full secs, %f frac secs" ) % num_rx_samps % md.time_spec.get_full_secs() % md.time_spec.get_frac_secs() << std::endl; std::cout << boost::format( "Stream time was: %u full secs, %f frac secs" ) % stream_time.get_full_secs() % stream_time.get_frac_secs() << std::endl; std::cout << boost::format( "Difference between stream time and first packet: %f us" ) % ((md.time_spec-stream_time).get_real_secs()/100*1e6) << std::endl; //finished std::cout << std::endl << "Done!" << std::endl << std::endl; return EXIT_SUCCESS; }
int UHD_SAFE_MAIN(int argc, char *argv[]){ uhd::set_thread_priority_safe(); //variables to be set by po std::string args, file, ant, subdev, ref; size_t total_num_samps; double rate, freq, gain, bw; std::string addr, port; //setup the program options po::options_description desc("Allowed options"); desc.add_options() ("help", "help message") ("args", po::value<std::string>(&args)->default_value(""), "multi uhd device address args") ("nsamps", po::value<size_t>(&total_num_samps)->default_value(1000), "total number of samples to receive") ("rate", po::value<double>(&rate)->default_value(100e6/16), "rate of incoming samples") ("freq", po::value<double>(&freq)->default_value(0), "rf center frequency in Hz") ("gain", po::value<double>(&gain)->default_value(0), "gain for the RF chain") ("ant", po::value<std::string>(&ant), "daughterboard antenna selection") ("subdev", po::value<std::string>(&subdev), "daughterboard subdevice specification") ("bw", po::value<double>(&bw), "daughterboard IF filter bandwidth in Hz") ("port", po::value<std::string>(&port)->default_value("7124"), "server udp port") ("addr", po::value<std::string>(&addr)->default_value("192.168.1.10"), "resolvable server address") ("ref", po::value<std::string>(&ref)->default_value("internal"), "waveform type (internal, external, mimo)") ; 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("UHD RX to UDP %s") % desc << std::endl; return ~0; } //create a usrp device std::cout << std::endl; std::cout << boost::format("Creating the usrp device with: %s...") % args << std::endl; uhd::usrp::multi_usrp::sptr usrp = uhd::usrp::multi_usrp::make(args); std::cout << boost::format("Using Device: %s") % usrp->get_pp_string() << std::endl; //Lock mboard clocks usrp->set_clock_source(ref); //set the rx sample rate std::cout << boost::format("Setting RX Rate: %f Msps...") % (rate/1e6) << std::endl; usrp->set_rx_rate(rate); std::cout << boost::format("Actual RX Rate: %f Msps...") % (usrp->get_rx_rate()/1e6) << std::endl << std::endl; //set the rx center frequency std::cout << boost::format("Setting RX Freq: %f Mhz...") % (freq/1e6) << std::endl; usrp->set_rx_freq(freq); std::cout << boost::format("Actual RX Freq: %f Mhz...") % (usrp->get_rx_freq()/1e6) << std::endl << std::endl; //set the rx rf gain std::cout << boost::format("Setting RX Gain: %f dB...") % gain << std::endl; usrp->set_rx_gain(gain); std::cout << boost::format("Actual RX Gain: %f dB...") % usrp->get_rx_gain() << std::endl << std::endl; //set the IF filter bandwidth if (vm.count("bw")){ std::cout << boost::format("Setting RX Bandwidth: %f MHz...") % bw << std::endl; usrp->set_rx_bandwidth(bw); std::cout << boost::format("Actual RX Bandwidth: %f MHz...") % usrp->get_rx_bandwidth() << std::endl << std::endl; } //set the antenna if (vm.count("ant")) usrp->set_rx_antenna(ant); boost::this_thread::sleep(boost::posix_time::seconds(1)); //allow for some setup time //Check Ref and LO Lock detect std::vector<std::string> sensor_names; sensor_names = usrp->get_rx_sensor_names(0); if (std::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); std::cout << boost::format("Checking RX: %s ...") % lo_locked.to_pp_string() << std::endl; UHD_ASSERT_THROW(lo_locked.to_bool()); } sensor_names = usrp->get_mboard_sensor_names(0); if ((ref == "mimo") and (std::find(sensor_names.begin(), sensor_names.end(), "mimo_locked") != sensor_names.end())) { uhd::sensor_value_t mimo_locked = usrp->get_mboard_sensor("mimo_locked",0); std::cout << boost::format("Checking RX: %s ...") % mimo_locked.to_pp_string() << std::endl; UHD_ASSERT_THROW(mimo_locked.to_bool()); } if ((ref == "external") and (std::find(sensor_names.begin(), sensor_names.end(), "ref_locked") != sensor_names.end())) { uhd::sensor_value_t ref_locked = usrp->get_mboard_sensor("ref_locked",0); std::cout << boost::format("Checking RX: %s ...") % ref_locked.to_pp_string() << std::endl; UHD_ASSERT_THROW(ref_locked.to_bool()); } //create a receive streamer uhd::stream_args_t stream_args("fc32"); //complex floats uhd::rx_streamer::sptr rx_stream = usrp->get_rx_stream(stream_args); //setup streaming uhd::stream_cmd_t stream_cmd(uhd::stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_DONE); stream_cmd.num_samps = total_num_samps; stream_cmd.stream_now = true; usrp->issue_stream_cmd(stream_cmd); //loop until total number of samples reached size_t num_acc_samps = 0; //number of accumulated samples uhd::rx_metadata_t md; std::vector<std::complex<float> > buff(rx_stream->get_max_num_samps()); uhd::transport::udp_simple::sptr udp_xport = uhd::transport::udp_simple::make_connected(addr, port); while(num_acc_samps < total_num_samps){ size_t num_rx_samps = rx_stream->recv( &buff.front(), buff.size(), md ); //handle the error codes switch(md.error_code){ case uhd::rx_metadata_t::ERROR_CODE_NONE: break; case uhd::rx_metadata_t::ERROR_CODE_TIMEOUT: if (num_acc_samps == 0) continue; std::cout << boost::format( "Got timeout before all samples received, possible packet loss, exiting loop..." ) << std::endl; goto done_loop; default: std::cout << boost::format( "Got error code 0x%x, exiting loop..." ) % md.error_code << std::endl; goto done_loop; } //send complex single precision floating point samples over udp udp_xport->send(boost::asio::buffer(buff, num_rx_samps*sizeof(buff.front()))); num_acc_samps += num_rx_samps; } done_loop: //finished std::cout << std::endl << "Done!" << std::endl << std::endl; return 0; }
/*********************************************************************** * recv_to_file function **********************************************************************/ template<typename samp_type> void recv_to_file( uhd::usrp::multi_usrp::sptr usrp, const std::string &cpu_format, const std::string &wire_format, const std::string &file, size_t samps_per_buff, int num_requested_samples, float settling_time, std::vector<size_t> rx_channel_nums ) { int num_total_samps = 0; //create a receive streamer uhd::stream_args_t stream_args(cpu_format,wire_format); stream_args.channels = rx_channel_nums; uhd::rx_streamer::sptr rx_stream = usrp->get_rx_stream(stream_args); uhd::rx_metadata_t md; std::vector<samp_type> buff(samps_per_buff); std::ofstream outfile(file.c_str(), std::ofstream::binary); bool overflow_message = true; float timeout = settling_time + 0.1; //expected settling time + padding for first recv //setup streaming uhd::stream_cmd_t stream_cmd((num_requested_samples == 0)? uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS: uhd::stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_DONE ); stream_cmd.num_samps = num_requested_samples; stream_cmd.stream_now = false; stream_cmd.time_spec = uhd::time_spec_t(settling_time); rx_stream->issue_stream_cmd(stream_cmd); while(not stop_signal_called and (num_requested_samples != num_total_samps or num_requested_samples == 0)) { size_t num_rx_samps = rx_stream->recv(&buff.front(), buff.size(), md, timeout); timeout = 0.1; //small timeout for subsequent recv if (md.error_code == uhd::rx_metadata_t::ERROR_CODE_TIMEOUT) { std::cout << boost::format("Timeout while streaming") << std::endl; break; } if (md.error_code == uhd::rx_metadata_t::ERROR_CODE_OVERFLOW) { if (overflow_message) { overflow_message = false; std::cerr << boost::format( "Got an overflow indication. Please consider the following:\n" " Your write medium must sustain a rate of %fMB/s.\n" " Dropped samples will not be written to the file.\n" " Please modify this example for your purposes.\n" " This message will not appear again.\n" ) % (usrp->get_rx_rate()*sizeof(samp_type)/1e6); } continue; } if (md.error_code != uhd::rx_metadata_t::ERROR_CODE_NONE) { throw std::runtime_error(str(boost::format( "Receiver error %s" ) % md.strerror())); } num_total_samps += num_rx_samps; outfile.write((const char*)&buff.front(), num_rx_samps*sizeof(samp_type)); } outfile.close(); }
int UHD_SAFE_MAIN(int argc, char *argv[]){ uhd::set_thread_priority_safe(); //variables to be set by po std::string args; std::string wire; double seconds_in_future; size_t total_num_samps; double rate; std::string channel_list; //setup the program options po::options_description desc("Allowed options"); desc.add_options() ("help", "help message") ("args", po::value<std::string>(&args)->default_value(""), "single uhd device address args") ("wire", po::value<std::string>(&wire)->default_value(""), "the over the wire type, sc16, sc8, etc") ("secs", po::value<double>(&seconds_in_future)->default_value(1.5), "number of seconds in the future to receive") ("nsamps", po::value<size_t>(&total_num_samps)->default_value(10000), "total number of samples to receive") ("rate", po::value<double>(&rate)->default_value(100e6/16), "rate of incoming samples") ("dilv", "specify to disable inner-loop verbose") ("channels", po::value<std::string>(&channel_list)->default_value("0"), "which channel(s) to use (specify \"0\", \"1\", \"0,1\", etc)") ; 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("UHD RX Timed Samples %s") % desc << std::endl; return ~0; } bool verbose = vm.count("dilv") == 0; //create a usrp device std::cout << std::endl; std::cout << boost::format("Creating the usrp device with: %s...") % args << std::endl; uhd::usrp::multi_usrp::sptr usrp = uhd::usrp::multi_usrp::make(args); std::cout << boost::format("Using Device: %s") % usrp->get_pp_string() << std::endl; //detect which channels to use std::vector<std::string> channel_strings; std::vector<size_t> channel_nums; boost::split(channel_strings, channel_list, boost::is_any_of("\"',")); for(size_t ch = 0; ch < channel_strings.size(); ch++){ size_t chan = boost::lexical_cast<int>(channel_strings[ch]); if(chan >= usrp->get_tx_num_channels() or chan >= usrp->get_rx_num_channels()){ throw std::runtime_error("Invalid channel(s) specified."); } else channel_nums.push_back(boost::lexical_cast<int>(channel_strings[ch])); } //set the rx sample rate std::cout << boost::format("Setting RX Rate: %f Msps...") % (rate/1e6) << std::endl; usrp->set_rx_rate(rate); std::cout << boost::format("Actual RX Rate: %f Msps...") % (usrp->get_rx_rate()/1e6) << std::endl << std::endl; std::cout << boost::format("Setting device timestamp to 0...") << std::endl; usrp->set_time_now(uhd::time_spec_t(0.0)); //create a receive streamer uhd::stream_args_t stream_args("fc32", wire); //complex floats stream_args.channels = channel_nums; uhd::rx_streamer::sptr rx_stream = usrp->get_rx_stream(stream_args); //setup streaming std::cout << std::endl; std::cout << boost::format( "Begin streaming %u samples, %f seconds in the future..." ) % total_num_samps % seconds_in_future << std::endl; uhd::stream_cmd_t stream_cmd(uhd::stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_DONE); stream_cmd.num_samps = total_num_samps; stream_cmd.stream_now = false; stream_cmd.time_spec = uhd::time_spec_t(seconds_in_future); rx_stream->issue_stream_cmd(stream_cmd); //meta-data will be filled in by recv() uhd::rx_metadata_t md; //allocate buffer to receive with samples std::vector<std::complex<float> > buff(rx_stream->get_max_num_samps()); std::vector<void *> buffs; for (size_t ch = 0; ch < rx_stream->get_num_channels(); ch++) buffs.push_back(&buff.front()); //same buffer for each channel //the first call to recv() will block this many seconds before receiving double timeout = seconds_in_future + 0.1; //timeout (delay before receive + padding) size_t num_acc_samps = 0; //number of accumulated samples while(num_acc_samps < total_num_samps){ //receive a single packet size_t num_rx_samps = rx_stream->recv( buffs, buff.size(), md, timeout, true ); //use a small timeout for subsequent packets timeout = 0.1; //handle the error code if (md.error_code == uhd::rx_metadata_t::ERROR_CODE_TIMEOUT) break; if (md.error_code != uhd::rx_metadata_t::ERROR_CODE_NONE){ throw std::runtime_error(str(boost::format( "Receiver error %s" ) % md.strerror())); } if(verbose) std::cout << boost::format( "Received packet: %u samples, %u full secs, %f frac secs" ) % num_rx_samps % md.time_spec.get_full_secs() % md.time_spec.get_frac_secs() << std::endl; num_acc_samps += num_rx_samps; } if (num_acc_samps < total_num_samps) std::cerr << "Receive timeout before all samples received..." << std::endl; //finished std::cout << std::endl << "Done!" << std::endl << std::endl; return EXIT_SUCCESS; }
template<typename samp_type> void recv_to_file( uhd::usrp::multi_usrp::sptr usrp, const std::string &cpu_format, const std::string &wire_format, const std::string &file, size_t samps_per_buff, unsigned long long num_requested_samples, double time_requested = 0.0, bool bw_summary = false, bool stats = false, bool null = false, bool enable_size_map = false, bool continue_on_bad_packet = false ){ unsigned long long num_total_samps = 0; //create a receive streamer uhd::stream_args_t stream_args(cpu_format,wire_format); uhd::rx_streamer::sptr rx_stream = usrp->get_rx_stream(stream_args); uhd::rx_metadata_t md; std::vector<samp_type> buff(samps_per_buff); std::ofstream outfile; if (not null) outfile.open(file.c_str(), std::ofstream::binary); bool overflow_message = true; //setup streaming uhd::stream_cmd_t stream_cmd((num_requested_samples == 0)? uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS: uhd::stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_DONE ); stream_cmd.num_samps = num_requested_samples; stream_cmd.stream_now = true; stream_cmd.time_spec = uhd::time_spec_t(); rx_stream->issue_stream_cmd(stream_cmd); boost::system_time start = boost::get_system_time(); unsigned long long ticks_requested = (long)(time_requested * (double)boost::posix_time::time_duration::ticks_per_second()); boost::posix_time::time_duration ticks_diff; boost::system_time last_update = start; unsigned long long last_update_samps = 0; typedef std::map<size_t,size_t> SizeMap; SizeMap mapSizes; while(not stop_signal_called and (num_requested_samples != num_total_samps or num_requested_samples == 0)) { boost::system_time now = boost::get_system_time(); size_t num_rx_samps = rx_stream->recv(&buff.front(), buff.size(), md, 3.0, enable_size_map); if (md.error_code == uhd::rx_metadata_t::ERROR_CODE_TIMEOUT) { std::cout << boost::format("Timeout while streaming") << std::endl; break; } if (md.error_code == uhd::rx_metadata_t::ERROR_CODE_OVERFLOW){ if (overflow_message) { overflow_message = false; std::cerr << boost::format( "Got an overflow indication. Please consider the following:\n" " Your write medium must sustain a rate of %fMB/s.\n" " Dropped samples will not be written to the file.\n" " Please modify this example for your purposes.\n" " This message will not appear again.\n" ) % (usrp->get_rx_rate()*sizeof(samp_type)/1e6); } continue; } if (md.error_code != uhd::rx_metadata_t::ERROR_CODE_NONE){ std::string error = str(boost::format("Receiver error: %s") % md.strerror()); if (continue_on_bad_packet){ std::cerr << error << std::endl; continue; } else throw std::runtime_error(error); } if (enable_size_map) { SizeMap::iterator it = mapSizes.find(num_rx_samps); if (it == mapSizes.end()) mapSizes[num_rx_samps] = 0; mapSizes[num_rx_samps] += 1; } num_total_samps += num_rx_samps; if (outfile.is_open()) outfile.write((const char*)&buff.front(), num_rx_samps*sizeof(samp_type)); if (bw_summary) { last_update_samps += num_rx_samps; boost::posix_time::time_duration update_diff = now - last_update; if (update_diff.ticks() > boost::posix_time::time_duration::ticks_per_second()) { double t = (double)update_diff.ticks() / (double)boost::posix_time::time_duration::ticks_per_second(); double r = (double)last_update_samps / t; std::cout << boost::format("\t%f Msps") % (r/1e6) << std::endl; last_update_samps = 0; last_update = now; } } ticks_diff = now - start; if (ticks_requested > 0){ if ((unsigned long long)ticks_diff.ticks() > ticks_requested) break; } } stream_cmd.stream_mode = uhd::stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS; rx_stream->issue_stream_cmd(stream_cmd); if (outfile.is_open()) outfile.close(); if (stats) { std::cout << std::endl; double t = (double)ticks_diff.ticks() / (double)boost::posix_time::time_duration::ticks_per_second(); std::cout << boost::format("Received %d samples in %f seconds") % num_total_samps % t << std::endl; double r = (double)num_total_samps / t; std::cout << boost::format("%f Msps") % (r/1e6) << std::endl; if (enable_size_map) { std::cout << std::endl; std::cout << "Packet size map (bytes: count)" << std::endl; for (SizeMap::iterator it = mapSizes.begin(); it != mapSizes.end(); it++) std::cout << it->first << ":\t" << it->second << std::endl; } } }
int UHD_SAFE_MAIN(int argc, char *argv[]){ uhd::set_thread_priority_safe(); std::string args, tx_file, rx_file, type, ref, wire_format, cpu_format; size_t samples_per_buff; double rate, freq, tx_gain, rx_gain, rx_bw, delay, lo_off; rx_bw = RX_BW; rx_gain = RX_GAIN; wire_format = WIRE_FORMAT; cpu_format = CPU_FORMAT; rate = SAMP_RATE; args = ARGS; ref = REF_CLOCK; freq = CENT_FREQ; tx_gain = TX_GAIN; samples_per_buff = SAMPLES_PER_BUFFER; tx_file = TX_FILENAME; rx_file = RX_FILENAME; //------------------INIT TX------------------ //Set the scheduling priority on the current thread. Same as set_thread_priority but does not throw on failure. std::cout << boost::format("Creating the usrp device with: %s...") % args << std::endl; uhd::usrp::multi_usrp::sptr usrp = uhd::usrp::multi_usrp::make(args); //Make the usrp by calling the constructor with param the args usrp->set_clock_source(ref); //Set the clock source for the usrp device. This sets the source for a 10 MHz reference clock. Typical options for source: internal, external, MIMO. std::cout << boost::format("Setting TX Rate: %f Msps...") % (rate/1e6) << std::endl; usrp->set_tx_rate(rate); //Set the sample rate std::cout << boost::format("Actual TX Rate: %f Msps...") % (usrp->get_tx_rate()/1e6) << std::endl << std::endl; std::cout << boost::format("Setting TX Freq: %f MHz...") % (freq/1e6) << std::endl; //Set up tuning frequency uhd::tune_request_t tune_request; tune_request = uhd::tune_request_t(freq); //Generate the tune request usrp->set_tx_freq(tune_request); //Tune to CENT_FREQ std::cout << boost::format("Actual TX Freq: %f MHz...") % (usrp->get_tx_freq()/1e6) << std::endl << std::endl; //PRINT Actual CENT_FREQ std::cout << boost::format("Setting TX Gain: %f dB...") % tx_gain << std::endl; usrp->set_tx_gain(tx_gain); //Set the tx_gain std::cout << boost::format("Actual TX Gain: %f dB...") % usrp->get_tx_gain() << std::endl << std::endl; //------------------CHECK STUFF------------------ //Check Ref and LO Lock detect std::vector<std::string> sensor_names; sensor_names = usrp->get_tx_sensor_names(0); if (std::find(sensor_names.begin(), sensor_names.end(), "lo_locked") != sensor_names.end()) { uhd::sensor_value_t lo_locked = usrp->get_tx_sensor("lo_locked",0); std::cout << boost::format("Checking TX: %s ...") % lo_locked.to_pp_string() << std::endl; UHD_ASSERT_THROW(lo_locked.to_bool()); } //------------------INIT TX STREAM------------------ //create a transmit streamer uhd::stream_args_t stream_args(cpu_format, wire_format); //Call the constructor of the class stream_args_t and generate the stream_args object with inputs the cpu_format and wire_format (this is the format per sample) uhd::tx_streamer::sptr tx_stream = usrp->get_tx_stream(stream_args); //Generate a tx_streamer object named tx_stream using the usrp->get_tx_stream(stream_args). Remember, usrp is already initialized //Setup tx_metadata uhd::tx_metadata_t tx_md; //TX metadata structure for describing received IF data. Includes time specification, and start and stop burst flags. The send routines will convert the metadata to IF data headers. tx_md.start_of_burst = false; //Set start of burst to true for the first packet in the chain. ? tx_md.end_of_burst = false; //------------------LOAD DATA AND TX------------------ std::vector<std::complex<float> > tx_buff(samples_per_buff); std::ifstream infile(tx_file.c_str(), std::ifstream::binary); if(!infile.good()){ std::cout << "IN File error\n"; return 0; } //loop until the entire file has been read int i = 0; for (int i = 0; i < samples_per_buff; ++i){ infile.read((char*)&tx_buff.at(i), tx_buff.size()*sizeof(std::complex<float>)); // std::cout << tx_buff.at(i) << ' '; } tx_stream->send(&tx_buff.front(), samples_per_buff, tx_md); infile.close(); //Close the file pointer //------------------INIT RX------------------ //IS THIS NECESSARY? //always select the subdevice first, the channel mapping affects the other settings //usrp->set_rx_subdev_spec(subdev); std::cout << boost::format("Setting RX Rate: %f Msps...") % (rate/1e6) << std::endl; usrp->set_rx_rate(rate); std::cout << boost::format("Actual RX Rate: %f Msps...") % (usrp->get_rx_rate()/1e6) << std::endl << std::endl; //set the center frequency std::cout << boost::format("Setting RX Freq: %f MHz...") % (freq/1e6) << std::endl; usrp->set_rx_freq(tune_request); std::cout << boost::format("Actual RX Freq: %f MHz...") % (usrp->get_rx_freq()/1e6) << std::endl << std::endl; std::cout << boost::format("Setting RX Gain: %f dB...") % rx_gain << std::endl; usrp->set_rx_gain(rx_gain); std::cout << boost::format("Actual RX Gain: %f dB...") % usrp->get_rx_gain() << std::endl << std::endl; boost::this_thread::sleep(boost::posix_time::seconds(1)); //allow 1sec setup time //------------------CHECK STUFF------------------ //Always check for locked sensor check_locked_sensor(usrp->get_rx_sensor_names(0), "lo_locked", boost::bind(&uhd::usrp::multi_usrp::get_rx_sensor, usrp, _1, 0), 1); //------------------INIT RX STREAM--------------- //create a receive streamer with the same args as TX uhd::rx_streamer::sptr rx_stream = usrp->get_rx_stream(stream_args); uhd::rx_metadata_t rx_md; std::vector<std::complex<float> > rx_buff(samples_per_buff); std::ofstream outfile; outfile.open(rx_file.c_str(), std::ofstream::binary); if(!outfile.good()){ std::cout << "OUT File error\n"; return 0; } //If RX_CONT == 1 enable continuoys sampling else just sent some packets and done uhd::stream_cmd_t stream_cmd((RX_CONT == 1)? uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS: uhd::stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_DONE ); stream_cmd.num_samps = samples_per_buff; //You might have a problem here... stream_cmd.stream_now = true; //Start streaming ASAP stream_cmd.time_spec = uhd::time_spec_t(); //Setup the time to the USRP time (Why??) rx_stream->issue_stream_cmd(stream_cmd); //Issue a stream command to the usrp device. This tells the usrp to send samples into the host. See the documentation for stream_cmd_t for more info. size_t num_rx_samps = rx_stream->recv(&rx_buff.front(), rx_buff.size(), rx_md, 10.0, false); // Receive buffers containing samples described by the metadata. std::cout << "Samples received in a single shot: " << num_rx_samps << std::endl; if (outfile.is_open()){ outfile.write((const char*)&rx_buff.front(), num_rx_samps*sizeof(std::complex<float>)-1); } return EXIT_SUCCESS; }
int UHD_SAFE_MAIN(int argc, char *argv[]){ // Set priority of the main thread int which = PRIO_PROCESS; id_t pid; int priority = -20; int ret; pid = getpid(); ret = setpriority(which, pid, priority); if(ret!=0){ std::cout << "Main priority went wrong: " << ret << std::endl ;} //Seting priority in the processor to run faster -> run with sudo if (!(uhd::set_thread_priority_safe(1,true))) { std::cout << "Problem setting thread priority" << std::endl; return 1; }; //variables to be set by po -> Set when initializing the rx program size_t total_num_samps; double rx_rate, freq, LOoffset; bool use_external_10MHz; double scaling_8bits; std::string filename; float gain; bool realTime; uhd::device_addr_t dev_addr; uhd::usrp::multi_usrp::sptr dev; uhd::tune_result_t tr; uhd::stream_args_t stream_args; uhd::rx_streamer::sptr rx_stream; //setup the program options-> Passing it from terminal with boost library po::options_description desc("Allowed options"); desc.add_options() ("help", "help message") ("nsamps", po::value<size_t>(&total_num_samps)->default_value(27840), "total number of samples to receive") ("rxrate", po::value<double>(&rx_rate)->default_value(100e6/4), "rate of incoming samples") ("freq", po::value<double>(&freq)->default_value(5.5e9), "rf center frequency in Hz") ("LOoffset", po::value<double>(&LOoffset)->default_value(10e6), "Offset between main LO and center frequency") ("10MHz",po::value<bool>(&use_external_10MHz)->default_value(false), "external 10MHz on 'REF CLOCK' connector (true=1=yes)") ("filename",po::value<std::string>(&filename)->default_value("data_from_usrp.dat"), "output filename") ("gain",po::value<float>(&gain)->default_value(15), "set the receiver gain") ("8bits_scaling",po::value<double>(&scaling_8bits)->default_value(0.0), "input scaling (invers) when 8bits is used, set to zero to get 16bits") ("realTime",po::value<bool>(&realTime)->default_value(true), "receives in loop and compares with synch sequence") ; //Variables stored in boost objects 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("rx %s") % desc << std::endl; return ~0; } ///////////Set device variables to read data//////////////// dev_addr["addr0"]="192.168.10.2"; dev = uhd::usrp::multi_usrp::make(dev_addr);//Create the device //receiving format stream_args.cpu_format="sc16"; if (scaling_8bits==0.0) { stream_args.otw_format="sc16"; } else { stream_args.otw_format="sc8"; std::stringstream temp_ss; temp_ss << scaling_8bits; stream_args.args["peak"]=temp_ss.str(); }; rx_stream=dev->get_rx_stream(stream_args); //set/get the streamer values to the device uhd::clock_config_t my_clock_config; if (use_external_10MHz) { my_clock_config.ref_source=uhd::clock_config_t::REF_SMA; }; /////////////////Create an USRP device//////////////////////// std::cout << std::endl; dev->set_rx_rate(rx_rate); bool is_xcvr2450=false; uhd::dict<std::string, std::string> rx_info; rx_info=dev->get_usrp_rx_info(0); if (rx_info.has_key("rx_subdev_name")) { std::string str=rx_info.get("rx_subdev_name"); uint temp=str.find("XCVR2450"); if (temp<str.length()) { is_xcvr2450=true; }; }; if (is_xcvr2450) { dev->set_tx_antenna("J2"); dev->set_rx_antenna("J1"); if (LOoffset>=9e6) { dev->set_rx_bandwidth(3.96e+07); }; }; std::cout << "rx_rate=" << rx_rate << std::endl; std::cout << "freq=" << freq << std::endl; std::cout << "gain=" << gain << std::endl; std::cout << "LOoffset="<<LOoffset <<std::endl; uhd::tune_request_t trq(freq,LOoffset); tr=dev->set_rx_freq(trq); dev->set_rx_gain(gain); std::cout << "tr=" << tr.actual_rf_freq << std::endl; if (use_external_10MHz) { dev->set_clock_config(my_clock_config); // PZ usleep(1e6); // Wait for the 10MHz to lock }; size_t buffer_size=1000; // Select buffer USRP and detection size. <25.000 int nStorage=2*total_num_samps; // Size of the buffer for the processing part dev->set_time_now(uhd::time_spec_t(0.0)); std::cout << boost::format("Setting device timestamp to 0...") << std::endl; // Initialisation uhd::stream_cmd_t stream_cmd(uhd::stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_DONE); //USRP parameters stream_cmd.num_samps = buffer_size; stream_cmd.stream_now = true; stream_cmd.stream_mode=uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS; dev->issue_stream_cmd(stream_cmd); //////////////////////////////////Read data to buff_short and do processing//////////// //Launch threads sem_init(&usrpReady, 0,0); sem_init(&detectionReady, 0,0); std::thread usrpT(usrpGetData, rx_stream, dev, buffer_size); std::thread detectionT(detection, buffer_size, nStorage); std::thread processT(processing, nStorage); // Set highest priiority for usrpT sched_param sch; int policy; pthread_getschedparam(usrpT.native_handle(), &policy, &sch); sch.sched_priority = 99; if(pthread_setschedparam(usrpT.native_handle(), SCHED_FIFO, &sch)) { std::cout << "Failed to setschedparam: " << std::strerror(errno) << '\n'; } std::cout << "Priority set"<< std::endl; usrpT.join(); detectionT.join(); processT.join(); //finished std::cout << std::endl << "Done receiving!" << std::endl << std::endl; return 0; }
int UHD_SAFE_MAIN(int argc, char *argv[]){ //Seting priority in the processor to run faster -> run with sudo if (!(uhd::set_thread_priority_safe(1,true))) { std::cout << "Problem setting thread priority" << std::endl; return 1; }; //variables to be set by po -> Set when initializing the rx program //double seconds_in_future=0.01; size_t total_num_samps; double rx_rate, freq, LOoffset; bool use_external_10MHz; double scaling_8bits; std::string filename; float gain; bool realTime; uhd::device_addr_t dev_addr; uhd::usrp::multi_usrp::sptr dev; uhd::tune_result_t tr; uhd::stream_args_t stream_args; uhd::rx_streamer::sptr rx_stream; //setup the program options-> Passing it from terminal with boost library po::options_description desc("Allowed options"); desc.add_options() ("help", "help message") ("nsamps", po::value<size_t>(&total_num_samps)->default_value(1000), "total number of samples to receive") ("rxrate", po::value<double>(&rx_rate)->default_value(100e6/4), "rate of incoming samples") ("freq", po::value<double>(&freq)->default_value(0), "rf center frequency in Hz") ("LOoffset", po::value<double>(&LOoffset)->default_value(0), "Offset between main LO and center frequency") ("10MHz",po::value<bool>(&use_external_10MHz)->default_value(false), "external 10MHz on 'REF CLOCK' connector (true=1=yes)") // ("PPS",po::value<bool>(&trigger_with_pps)->default_value(false), "trigger reception with 'PPS IN' connector (true=1=yes)") ("filename",po::value<std::string>(&filename)->default_value("data_from_usrp.dat"), "output filename") ("gain",po::value<float>(&gain)->default_value(0), "set the receiver gain") ("8bits_scaling",po::value<double>(&scaling_8bits)->default_value(0.0), "input scaling (invers) when 8bits is used, set to zero to get 16bits") ///////////////////////////// ("realTime",po::value<bool>(&realTime)->default_value(false), "receives in loop and compares with synch sequence") ; //Variables stored in boost objects 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("rx %s") % desc << std::endl; return ~0; } ///////////Set device variables to read data//////////////// dev_addr["addr0"]="192.168.10.2"; dev = uhd::usrp::multi_usrp::make(dev_addr);//Create the device //receiving format stream_args.cpu_format="sc16"; if (scaling_8bits==0.0) { stream_args.otw_format="sc16"; } else { stream_args.otw_format="sc8"; std::stringstream temp_ss; temp_ss << scaling_8bits; stream_args.args["peak"]=temp_ss.str(); }; rx_stream=dev->get_rx_stream(stream_args); //set/get the streamer values to the device uhd::clock_config_t my_clock_config; /* if (trigger_with_pps) { my_clock_config.pps_source=uhd::clock_config_t::PPS_SMA; }; */ if (use_external_10MHz) { my_clock_config.ref_source=uhd::clock_config_t::REF_SMA; }; /////////////////Create an USRP device//////////////////////// std::cout << std::endl; //uhd::device::sptr udev = dev->get_device(); dev->set_rx_rate(rx_rate); bool is_xcvr2450=false; uhd::dict<std::string, std::string> rx_info; rx_info=dev->get_usrp_rx_info(0); if (rx_info.has_key("rx_subdev_name")) { std::string str=rx_info.get("rx_subdev_name"); uint temp=str.find("XCVR2450"); if (temp<str.length()) { is_xcvr2450=true; }; }; if (is_xcvr2450) { dev->set_tx_antenna("J2"); dev->set_rx_antenna("J1"); //uhd::meta_range_t range=dev->get_tx_bandwidth_range(); if (LOoffset>=9e6) { dev->set_rx_bandwidth(3.96e+07); }; }; std::cout << "rx_rate=" << rx_rate << std::endl; std::cout << "freq=" << freq << std::endl; std::cout << "gain=" << gain << std::endl; uhd::tune_request_t trq(freq,LOoffset); //dev->set_rx_bandwidth(36e6); tr=dev->set_rx_freq(trq); dev->set_rx_gain(gain); std::cout << "tr=" << tr.actual_rf_freq << std::endl; /* double target_rf_freq; double actual_rf_freq; double target_dsp_freq; double actual_dsp_freq; */ // //dev->set_tx_antenna("J2"); //dev->set_rx_antenna("J1"); if (use_external_10MHz) { dev->set_clock_config(my_clock_config); // PZ usleep(1e6); // Wait for the 10MHz to lock }; size_t buffer_size=1000; // Select buffer size short *buff_short, *storage_short; //Always read short buffers storage_short=new short[2*total_num_samps]; // Create storage for the entire received signal to be saved on disk (2* for handling complex). buff_short=new short[2*buffer_size]; // Create storage for a single buffer /*if (trigger_with_pps) { dev->set_time_next_pps(uhd::time_spec_t(0.0)); usleep(1e6); } */ //else { dev->set_time_now(uhd::time_spec_t(0.0)); //}; std::cout << boost::format("Setting device timestamp to 0...") << std::endl; //setup streaming //std::cout << std::endl; //std::cout << boost::format("Begin streaming %u samples, %d seconds in the future...") // % total_num_samps % seconds_in_future << std::endl; //////////////////////////////////Read data to buff_short and do processing//////////// uhd::stream_cmd_t stream_cmd(uhd::stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_DONE); if (realTime == false){ //Reads just one time the USRP rx dev and process data stream_cmd.num_samps = buffer_size; stream_cmd.stream_now = true; stream_cmd.stream_mode=uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS; //stream_cmd.time_spec = uhd::time_spec_t(seconds_in_future); dev->issue_stream_cmd(stream_cmd); size_t num_rx_samps=0; size_t num_rx_samps_latest_call; uhd::rx_metadata_t md; //keep reading until everything is read while (num_rx_samps<total_num_samps) { num_rx_samps_latest_call=0; while (num_rx_samps_latest_call==0) { num_rx_samps_latest_call= rx_stream->recv(&buff_short[0],buffer_size, md, 3.0); }; if (num_rx_samps_latest_call!=buffer_size) { std::cerr << "I expect the buffer size to be always the same!\n"; std::cout<<"Read only:"<<num_rx_samps_latest_call<<"\n"; std::cout<<"Buffer:"<<buffer_size<<"\n"; exit(1); //May be changed->don't want program to crash when data is not available }; /* Process the just received buffer -> Put all toghether in one buffer*/ int i1=2*num_rx_samps; int i2=0; while ((i1<(int) (2*total_num_samps)) && (i2<2*((int) buffer_size))) { storage_short[i1]=buff_short[i2]; i1++; i2++; }; num_rx_samps=num_rx_samps+num_rx_samps_latest_call; std::cout << "num_rx_samps=" << num_rx_samps << std::endl; }; // Save output to disc //Computes total power: double P=powerTotArray( storage_short, 2*total_num_samps); std::cout << "\nTotal power=" << P <<"\n"; //Computes power in the output of 25 filters: int num_filt=25; double shiftindex = 0.04;//how big the shift between the filters is (equidistantial) double *power_band; power_band=new double[num_filt]; double *buff_double; buff_double=new double[2*buffer_size]; for(int ii=0;ii<(int)(2*buffer_size);ii++){ buff_double[ii]=(double)buff_short[ii]; }; powerOfFreqBands(buff_double, 2*buffer_size, shiftindex, power_band,num_filt); for(int ii=0; ii< num_filt; ii++){ DispVal(power_band[ii]); }; std::ofstream s1(filename.c_str(), std::ios::binary); s1.write((char *) storage_short,4*total_num_samps); s1.flush(); //PZ s1.close(); //PZ //Process the received data with MATLAB from written file //finished reading std::cout << std::endl << "Done reading->Data to MATLAB!" << std::endl << std::endl; }else{ //////////REAL TIME IMPLEMENTATION//////////////////////////////////////////////////////////////////// //Reads in loop untill it finds someone is trying to transmit -> Power detection and training sequence match/////////////////////////////////////////////////////////////////////////////////////////// std::cout << "Stop the transmitter by pressing ctrl-c\n"; size_t num_rx_samps_latest_call; size_t num_rx_samps; uhd::rx_metadata_t md; int num_filt=25; double shiftindex = 0.04;//how big the shift between the filters is (equidistantial) double *power_band; power_band=new double[num_filt]; double *total_bandPower; total_bandPower=new double[num_filt]; //Cycle to read continuously data num_rx_samps=0; // std::cout<<"buffer:"<<buffer_size<<"\n"; for(int ii=0;ii<num_filt;ii++){ total_bandPower[ii]=0.0; } int loop_count=0; int size_all=100; total_num_samps= 4000; double * all[total_num_samps]; for(int ii=0;ii<size_all;ii++){ all[ii]= new double[2*(int)(total_num_samps)]; } while(loop_count<size_all){ //DispVal(loop_count); stream_cmd.num_samps = buffer_size; stream_cmd.stream_now = true; stream_cmd.stream_mode=uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS; //stream_cmd.time_spec = uhd::time_spec_t(seconds_in_future); dev->issue_stream_cmd(stream_cmd); while (num_rx_samps<total_num_samps) { num_rx_samps_latest_call=0; while (num_rx_samps_latest_call==0) { num_rx_samps_latest_call= rx_stream->recv(&buff_short[0],buffer_size, md, 3.0); }; if (num_rx_samps_latest_call!=buffer_size) { std::cerr << "I expect the buffer size to be always the same!\n"; std::cout<<"Read only:"<<num_rx_samps_latest_call<<"\n"; std::cout<<"Buffer:"<<buffer_size<<"\n"; exit(1); //May be changed->don't want program to crash when data is not available }; /* Process the just received buffer -> Put all toghether in one buffer*/ int i1=2*num_rx_samps; int i2=0; while ((i1<(int) (2*total_num_samps)) && (i2<2*((int) buffer_size))) { all[loop_count][i1]=(double)buff_short[i2]; i1++; i2++; }; num_rx_samps=num_rx_samps+num_rx_samps_latest_call; //std::cout << "num_rx_samps=" << num_rx_samps << std::endl; }; stream_cmd.stream_now = false; stream_cmd.stream_mode=uhd::stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS; //stream_cmd.time_spec = uhd::time_spec_t(seconds_in_future); dev->issue_stream_cmd(stream_cmd); powerOfFreqBands( all[loop_count], total_num_samps, shiftindex, power_band, num_filt); for(int ii=0;ii<num_filt+1;ii++){ total_bandPower[ii]=total_bandPower[ii]+power_band[ii]/size_all; } if(loop_count==99){ loop_count=0; for(int ii=0;ii<num_filt+1;ii++){ double shift=shiftindex*ii; std::cout << "power: " << power_band[ii] << " at w0: " << shift << std::endl; } std::cout<<"-------------------------------------\n"; }else{ loop_count++; } num_rx_samps=0; } }; //finished std::cout << std::endl << "Done receiving!" << std::endl << std::endl; return 0; }
/******************************************************************************* * Main function ******************************************************************************/ int UHD_SAFE_MAIN(int argc, char *argv[]){ uhd::set_thread_priority_safe(); /** Constant Decalartions *************************************************/ const INT32U time = DURATION*(SAMPRATE/SPB); /** Variable Declarations *************************************************/ // (circular) receive buffers std::vector< CINT16 > ch0_rxbuff(time*SPB); // Ch 0 is RX2-A std::vector< CINT16 > ch1_rxbuff(time*SPB); // Ch 1 is RX2-B // Vector of pointers to sectons of rx_buff std::vector< std::vector< CINT16 *> > rxbuffs(time*2, std::vector< CINT16 *>(2)); // Holds the number of received samples returned by rx_stream->recv() INT16U num_rx_samps; // Counters INT16U i = 0,j = 0,k = 0; // Generic counters INT32U write_ctr = 0; // Counts loops through main while() /** Variable Initializations **********************************************/ // Initialise rxbuffs (Vector of pointers) for(i = 0; i < time; i++){ rxbuffs[i][0] = &ch0_rxbuff.front() + SPB * i; rxbuffs[i][1] = &ch1_rxbuff.front() + SPB * i; } /** Main code *************************************************************/ // set USRP Rx params uhd::usrp::multi_usrp::sptr usrp_rx = uhd::usrp::multi_usrp::make(std::string("")); // create a usrp device uhd::tune_request_t tune_request(CARRIERFREQ); // validate tune request usrp_rx->set_master_clock_rate(CLOCKRATE); // set clock rate usrp_rx->set_clock_source(std::string("internal")); // lock mboard clocks // usrp_rx->set_time_source("external"); // Use external reference clock usrp_rx->set_rx_subdev_spec(std::string("A:A A:B")); // select the subdevice usrp_rx->set_rx_rate(SAMPRATE,0); // set the sample rate (Ch 0) usrp_rx->set_rx_rate(SAMPRATE,1); // set the sample rate (Ch 1) usrp_rx->set_rx_freq(tune_request,0); // set the center frequency (Ch 0) usrp_rx->set_rx_freq(tune_request,1); // set the center frequency (Ch 1) usrp_rx->set_rx_gain(RXGAIN,0); // set the rf gain (Ch 0) usrp_rx->set_rx_gain(RXGAIN,1); // set the rf gain (Ch 1) usrp_rx->set_rx_antenna(std::string("TX/RX"),0); // set the antenna (Ch 0) usrp_rx->set_rx_antenna(std::string("TX/RX"),1); // set the antenna (Ch 1) boost::this_thread::sleep(boost::posix_time::seconds(1.0)); // allow for some setup time // check Ref and LO Lock detect for Rx check_locked_sensor(usrp_rx->get_rx_sensor_names(0), "lo_locked", boost::bind(&uhd::usrp::multi_usrp::get_rx_sensor, usrp_rx, _1, 0), 1.0); // create a receive streamer uhd::stream_args_t stream_args_rx("sc16", "sc16"); stream_args_rx.channels = boost::assign::list_of(0)(1); uhd::rx_streamer::sptr rx_stream = usrp_rx->get_rx_stream(stream_args_rx); uhd::rx_metadata_t md_rx; // report stuff to user (things which may differ from what was requested) std::cout << boost::format("Actual RX Rate: %f Msps...") % (usrp_rx->get_rx_rate()/1e6) << std::endl; // set sigint so user can terminate via Ctrl-C std::signal(SIGINT, &sig_int_handler); std::cout << boost::format("Recording RX CH 0 and CH 1 for %i seconds") % DURATION << std::endl << std::endl; std::cout << "Press Enter to start recording..." << std::endl << std::endl; // Wait for "ENTER" key to be pressed while(std::cin.get() != '\n'){} std::cout << "Press Ctrl + C to stop recording..." << std::endl; // setup receive streaming uhd::stream_cmd_t stream_cmd(uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS); stream_cmd.stream_now = false; stream_cmd.time_spec = uhd::time_spec_t(0.25)+usrp_rx->get_time_now(); // tell USRP to start streaming 0.25 seconds in the future rx_stream->issue_stream_cmd(stream_cmd); // grab initial block of received samples from USRP with nice long timeout (gets discarded) num_rx_samps = rx_stream->recv(rxbuffs[0], SPB, md_rx, 3.0); while(not stop_signal_called){ // grab block of received samples from USRP num_rx_samps = rx_stream->recv(rxbuffs[write_ctr], SPB, md_rx); // Increment counter write_ctr++; // Check if full time has passed if(write_ctr == time){ break; }else{} // Report progress to terminal std::cout << boost::format("\r\t%2i Percent Complete ") % (write_ctr*100/time) << std::flush; } /** while(not stop_signal_called) *************************************/ // Report progress to terminal std::cout << "\r\tdone! " << std::endl << std::endl; if(stop_signal_called){ std::cout << std::endl << "Writing partial buffers to file (this may take awhile)..." << std::endl; }else{ // Write buffers to file std::cout << "Writing buffers to file (this may take awhile)..." << std::endl; } std::cout << " Channel 0 (RX2-A)..." << std::flush; writebuff("./RX2-A.dat", &ch0_rxbuff.front(), write_ctr*SPB); std::cout << "done!" << std::endl; std::cout << " Channel 1 (RX2-B)..." << std::flush; writebuff("./RX2-B.dat", &ch1_rxbuff.front(), write_ctr*SPB); std::cout << "done!" << std::endl; return EXIT_SUCCESS; } /** main() ****************************************************************/
int UHD_SAFE_MAIN(int argc, char *argv[]){ if (uhd::set_thread_priority_safe(1,true)) { std::cout << "set priority went well " << std::endl; }; #if 0 int portno=30000; //int s=socket(AF_INET,SOCK_STREAM,0); struct sockaddr_in server; struct hostent *hp; struct in_addr ipv4addr; inet_pton(AF_INET, "127.0.0.1", &ipv4addr); bzero((char *)&server, sizeof (server)); hp = gethostbyaddr(&ipv4addr,sizeof(ipv4addr), AF_INET); bcopy(hp->h_addr, (char *)&server.sin_addr, hp->h_length); server.sin_family = hp->h_addrtype; server.sin_port = htons(portno); int s = socket(hp->h_addrtype, SOCK_STREAM, 0); if (s < 0) std::cerr << "ERROR opening socket"; connect(s, (struct sockaddr *)&server, sizeof(server)); usleep(1003); char buffer[6]; usleep(1e6); buffer[0]=65; buffer[1]=66; buffer[2]=67; buffer[3]=68; buffer[4]=10; buffer[5]=0; short nb[5]; nb[0]=htons(23); nb[1]=htons(-24); nb[2]=htons(77); nb[3]=htons(-18); nb[4]=htons(-33); std::cout << "strlen=" << strlen(buffer) << "\n"; for (int i1=0;i1<10;i1++) { std::cout << "buffer[" << i1 << "]=" << (unsigned int)buffer[i1] << "\n"; }; //int n = write(s,buffer,strlen(buffer)); int n = write(s,nb,sizeof(nb)); std::cout << "n=" << n << "\n"; if (n < 0) std::cerr << "ERROR writing to socket"; close(s); usleep(100e6); #endif //variables to be set by po std::string args; double seconds_in_future; size_t total_num_samps, total_num_repeats; int send_to_listener; double rate, freq_tx, freq_rx; float gain; std::string filename_rx, filename_tx; uhd::tx_streamer::sptr tx_stream; uhd::rx_streamer::sptr rx_stream; uhd::device_addr_t dev_addr; uhd::usrp::multi_usrp::sptr dev; uhd::stream_args_t stream_args; //setup the program options po::options_description desc("Allowed options"); desc.add_options() ("help", "help message") ("args", po::value<std::string>(&args)->default_value(""), "simple uhd device address args") ("secs", po::value<double>(&seconds_in_future)->default_value(0.5), "number of seconds in the future to transmit") ("nsamps", po::value<size_t>(&total_num_samps)->default_value(1000), "Total number of samples to transmit and receive") ("nrep", po::value<size_t>(&total_num_repeats)->default_value(1), "Total number of repeats") ("rate", po::value<double>(&rate)->default_value(100e6/8), "rate of outgoing and ingoing samples") ("freq_rx", po::value<double>(&freq_rx)->default_value(20e6), "receive center frequency in Hz") ("freq_tx", po::value<double>(&freq_tx)->default_value(20e6), "transmit center frequency in Hz") ("filename_tx",po::value<std::string>(&filename_tx)->default_value("data_to_usrp.dat"), "tx filename") ("filename_rx",po::value<std::string>(&filename_rx)->default_value("data_from_usrp.dat"), "rx filename") ("gain",po::value<float>(&gain)->default_value(0), "gain of transmitter") ("n",po::value<int>(&send_to_listener)->default_value(0), "Every n:th received buffer is sent to a client listening on port 3000. ") ; po::variables_map vm; po::store(po::parse_command_line(argc, argv, desc), vm); po::notify(vm); if (vm.count("help")){ std::cout << boost::format("rxtx_bidirectional %s") % desc << std::endl; return ~0; } int s; if (send_to_listener>0) { struct sockaddr_in server; struct hostent *hp; struct in_addr ipv4addr; int portno=30000; inet_pton(AF_INET, "127.0.0.1", &ipv4addr); bzero((char *)&server, sizeof (server)); hp = gethostbyaddr(&ipv4addr,sizeof(ipv4addr), AF_INET); bcopy(hp->h_addr, (char *)&server.sin_addr, hp->h_length); server.sin_family = hp->h_addrtype; server.sin_port = htons(portno); s = socket(hp->h_addrtype, SOCK_STREAM, 0); if (s < 0) std::cerr << "ERROR opening socket"; connect(s, (struct sockaddr *)&server, sizeof(server)); } ; int process_buffer_size=9000; // Buffer size in processing int tx_ahead_buffers=3; // Number of buffers transmitted before starting // to receive. signal_processing sp(total_num_samps,total_num_repeats,send_to_listener,s, process_buffer_size,filename_rx,filename_tx); std::complex<int16_t> *process_buffer_tx; process_buffer_tx = new std::complex<int16_t>[process_buffer_size]; std::complex<int16_t> *process_buffer_rx; process_buffer_rx = new std::complex<int16_t>[process_buffer_size]; /* Create buffer storage for trailing zeros */ std::complex<int16_t> *buffer_zeros; buffer_zeros = new std::complex<int16_t>[process_buffer_size](); //create a usrp device and streamer dev_addr["addr0"]="192.168.10.2"; dev = uhd::usrp::multi_usrp::make(dev_addr); dev->set_clock_source("internal"); dev->set_time_now(uhd::time_spec_t(0.0), 0); // Internal variables uhd::clock_config_t my_clock_config; uhd::tune_result_t tr; uhd::tune_request_t trq_rx(freq_rx,0); //std::min(tx_rate,10e6)); tr=dev->set_rx_freq(trq_rx,0); uhd::tune_request_t trq_tx(freq_tx,0); //std::min(tx_rate,10e6)); tr=dev->set_tx_freq(trq_tx,0); uhd::dict<std::string, std::string> tx_info; tx_info=dev->get_usrp_tx_info(0); dev->set_tx_gain(gain); std::cout << tr.to_pp_string() << "\n"; stream_args.cpu_format="sc16"; tx_stream=dev->get_tx_stream(stream_args); rx_stream=dev->get_rx_stream(stream_args); //set properties on the device dev->set_tx_rate(rate); dev->set_rx_rate(rate); std::cout << boost::format("Actual TX Rate: %f Msps...") % (dev->get_tx_rate()/1e6) << std::endl; std::cout << boost::format("Actual RX Rate: %f Msps...") % (dev->get_rx_rate()/1e6) << std::endl; std::cout << boost::format("Setting device timestamp to 0...") << std::endl; uhd::tx_metadata_t md; dev->set_time_now(uhd::time_spec_t(0.0)); uhd::rx_metadata_t md_rx; //uhd::stream_cmd_t // stream_cmd(uhd::stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_DONE); uhd::stream_cmd_t stream_cmd(uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS); stream_cmd.num_samps = total_num_samps; stream_cmd.stream_now = false; stream_cmd.time_spec = uhd::time_spec_t(seconds_in_future); rx_stream->issue_stream_cmd(stream_cmd); md.start_of_burst = true; md.end_of_burst = false; md.has_time_spec = true; md.time_spec = uhd::time_spec_t(seconds_in_future); for (int i1=tx_ahead_buffers;i1>0;i1--) { tx_stream->send(buffer_zeros, process_buffer_size , md); md.start_of_burst = false; md.has_time_spec = false; }; md.start_of_burst = false; int return_value=1; while (return_value!=0) { rx_stream->recv(process_buffer_rx, process_buffer_size, md_rx, seconds_in_future+1); return_value=sp.process_buffers(process_buffer_rx, process_buffer_tx); tx_stream->send(process_buffer_tx, process_buffer_size , md); }; md.end_of_burst = true; tx_stream->send(buffer_zeros, process_buffer_size , md); //finished std::cout << std::endl << "Done!" << std::endl << std::endl; return 0; }
int UHD_SAFE_MAIN(int argc, char *argv[]){ uhd::set_thread_priority_safe(); //variables to be set by po std::string args, file, type, ant, subdev; size_t total_num_samps, spb; double rate, freq, gain, bw; //setup the program options po::options_description desc("Allowed options"); desc.add_options() ("help", "help message") ("args", po::value<std::string>(&args)->default_value("addr0=192.168.10.2"), "multi uhd device address args") ("file", po::value<std::string>(&file)->default_value("usrp_samples.dat"), "name of the file to write binary samples to") ("type", po::value<std::string>(&type)->default_value("float"), "sample type: double, float, or short") ("nsamps", po::value<size_t>(&total_num_samps)->default_value(0), "total number of samples to receive") ("spb", po::value<size_t>(&spb)->default_value(10000), "samples per buffer") ("rate", po::value<double>(&rate)->default_value(1e4), "rate of incoming samples") ("freq", po::value<double>(&freq)->default_value(920e6), "RF center frequency in Hz") ("gain", po::value<double>(&gain)->default_value(0), "gain for the RF chain") ("ant", po::value<std::string>(&ant)->default_value("TX/RX"), "daughterboard antenna selection") ("subdev", po::value<std::string>(&subdev), "daughterboard subdevice specification") ("bw", po::value<double>(&bw), "daughterboard IF filter bandwidth in Hz") ; 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("UHD RX samples to file %s") % desc << std::endl; return ~0; } printf("George's modified Demo version of RX_Samples_to_file.\n\rNote that this version sets up the device but doesn't write to disk.\n\r\n\r"); //create a usrp device std::cout << std::endl; std::cout << boost::format("Creating the usrp device with: %s...") % args << std::endl; uhd::usrp::multi_usrp::sptr usrp = uhd::usrp::multi_usrp::make(args); //always select the subdevice first, the channel mapping affects the other settings if (vm.count("subdev")) usrp->set_rx_subdev_spec(subdev); std::cout << boost::format("Using Device: %s") % usrp->get_pp_string() << std::endl; //set the sample rate if (not vm.count("rate")){ std::cerr << "Please specify the sample rate with --rate" << std::endl; return ~0; } std::cout << boost::format("Setting RX Rate: %f Msps...") % (rate/1e6) << std::endl; usrp->set_rx_rate(rate); std::cout << boost::format("Actual RX Rate: %f Msps...") % (usrp->get_rx_rate()/1e6) << std::endl << std::endl; //set the center frequency if (not vm.count("freq")){ std::cerr << "Please specify the center frequency with --freq" << std::endl; return ~0; } std::cout << boost::format("Setting RX Freq: %f MHz...") % (freq/1e6) << std::endl; usrp->set_rx_freq(freq); std::cout << boost::format("Actual RX Freq: %f MHz...") % (usrp->get_rx_freq()/1e6) << std::endl << std::endl; //set the rf gain if (vm.count("gain")){ std::cout << boost::format("Setting RX Gain: %f dB...") % gain << std::endl; usrp->set_rx_gain(gain); std::cout << boost::format("Actual RX Gain: %f dB...") % usrp->get_rx_gain() << std::endl << std::endl; } //set the IF filter bandwidth if (vm.count("bw")){ std::cout << boost::format("Setting RX Bandwidth: %f MHz...") % bw << std::endl; usrp->set_rx_bandwidth(bw); std::cout << boost::format("Actual RX Bandwidth: %f MHz...") % usrp->get_rx_bandwidth() << std::endl << std::endl; } //set the antenna if (vm.count("ant")) usrp->set_rx_antenna(ant); boost::this_thread::sleep(boost::posix_time::seconds(1)); //allow for some setup time //setup streaming uhd::stream_cmd_t stream_cmd((total_num_samps == 0)? uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS: uhd::stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_DONE ); stream_cmd.num_samps = total_num_samps; stream_cmd.stream_now = true; usrp->issue_stream_cmd(stream_cmd); if (total_num_samps == 0){ std::signal(SIGINT, &sig_int_handler); std::cout << "Press Ctrl + C to stop streaming..." << std::endl; } //recv to file if (type == "double") recv_to_file<std::complex<double> >(usrp, uhd::io_type_t::COMPLEX_FLOAT64, file, spb); else if (type == "float") recv_to_file<std::complex<float> >(usrp, uhd::io_type_t::COMPLEX_FLOAT32, file, spb); else if (type == "short") recv_to_file<std::complex<short> >(usrp, uhd::io_type_t::COMPLEX_INT16, file, spb); //else throw std::runtime_error("Unknown type " + type); boost::this_thread::sleep(boost::posix_time::seconds(1)); //allow for some setup time printf("turning off streaming...\n\r"); //turn off streaming stream_cmd.stream_now = false; stream_cmd.stream_mode = uhd::stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS; usrp->issue_stream_cmd(stream_cmd); //finished std::cout << std::endl << "Done!" << std::endl << std::endl; return 0; }
void storeDataX(uhd::rx_streamer::sptr rx_stream, uhd::usrp::multi_usrp::sptr dev, size_t buffer_size, uint nDetect){ // Create storage for a single buffer from USRP short *buff_short; buff_short=new short[2*buffer_size]; short *storage_short; storage_short=new short [2*nDetect]; uhd::stream_cmd_t stream_cmd(uhd::stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_DONE); std::cout << "Stop the transmitter by pressing ctrl-c \n"; stream_cmd.num_samps = buffer_size; stream_cmd.stream_now = true; stream_cmd.stream_mode=uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS; dev->issue_stream_cmd(stream_cmd); uhd::rx_metadata_t md; size_t n_rx_samps=0; int n_rx_last; while (1){ n_rx_samps=0; // Fill the storage buffer loop while (n_rx_samps<nDetect){ n_rx_last=0; // Fill buff_short while (n_rx_last==0) { n_rx_last=rx_stream->recv(&buff_short[0], buffer_size, md, 3.0); //std::this_thread::yield(); }; sec_count++; // Check if no overflow if (n_rx_last!=(int)buffer_size) { std::cerr << "I expect the buffer size to be always the same!\n"; std::cout<<"Read only:"<<n_rx_last<<"\n"; std::cout<<"Buffer:"<<buffer_size<<"\n"; exit(1); }; // Fill storage int i1=2*n_rx_samps; int i2=0; while ((i1<(int) (2*nDetect)) && (i2<2*((int) buffer_size))){ storage_short[i1]=buff_short[i2]; i1++; i2++; }; //storage_short=buff_short; n_rx_samps=n_rx_samps+n_rx_last; //std::cout << "n_rx_samps=" << n_rx_samps << std::endl; }//storage_short now full mtxQ.lock(); bufferQ.push(buff_short); mtxQ.unlock(); //delete buff_short; buff_short=new short [2*buffer_size]; // Change memory cell used //usleep(1000000/4); sem_post( &isReady); // Gives the start to detection part }//end while 1 }
//set program_options int UHD_SAFE_MAIN (int argc, char *argv[]) { uhd::set_thread_priority_safe(); std::string args; size_t total_samples,number_bins,num_acc_samps; double bw,rate, freq, gain; po::options_description desc("allowed options"); desc.add_options() ("args",po::value<std::string>(&args)->default_value(""),"multi uhd device address args") ("help","help message") ("nsamps",po::value<size_t> (&total_samples)->default_value(0),"Total number of samples to receive, zero for continous mode") ("rate", po::value<double>(&rate)->default_value(2e6), "rate of incoming samples") ("freq",po::value<double>(&freq)->default_value(400e6),"rf center frequency in Hz") ("gain",po::value<double>(&gain)->default_value(0),"gain for the RF chain") ("number_bins",po::value<size_t>(&number_bins)->default_value(1024),"number of FFT points") ("bw", po::value<double>(&bw), "daughterboard IF filter bandwidth in Hz") ; po::variables_map vm; po::store(po::parse_command_line(argc,argv,desc),vm); po::notify(vm); if (vm.count("help")) {//if std::cout<< boost::format("UHD RX timed Samples %s") % desc <<std::endl; return ~0; }//if //create usrp device std::cout<<std::endl; std::cout<<boost::format("setting RX Rate: %f Msps...") % args <<std::endl; uhd::usrp::multi_usrp::sptr usrp =uhd::usrp::multi_usrp::make(args); std::cout<<boost::format("Using Device: %s ") % usrp->get_pp_string()<<std::endl; //set bandwidth if (vm.count("bw")){ std::cout << boost::format("Setting RX Bandwidth: %f MHz...") % bw << std::endl; usrp->set_rx_bandwidth(bw); std::cout << boost::format("Actual RX Bandwidth: %f MHz...") % usrp->get_rx_bandwidth() << std::endl << std::endl; } //set the sample rate std::cout << boost::format("setting RX Rate: %f Msps...") % (rate/1e6) <<std::endl<<std::endl; usrp->set_rx_rate(rate); std::cout<<boost::format("actual RX rate: %f Msps...") % (usrp->get_rx_rate()/1e6) <<std::endl<<std::endl; //set the rx center frequency std::cout << boost::format("Setting RX Freq: %f Mhz...") % (freq/1e6) << std::endl; usrp->set_rx_freq(freq); std::cout << boost::format("Actual RX Freq: %f Mhz...") % (usrp->get_rx_freq()/1e6) << std::endl << std::endl; //create a receiver streamer uhd::stream_args_t stream_args("fc32"); uhd::rx_streamer::sptr rx_streamer =usrp-> get_rx_stream(stream_args); //rm// set up streaming ...0 means continues uhd::stream_cmd_t stream_cmd((total_samples==0)? uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS: uhd::stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_DONE); stream_cmd.num_samps =total_samples; stream_cmd.stream_now = true; stream_cmd.time_spec =uhd::time_spec_t(); usrp->issue_stream_cmd(stream_cmd); size_t num_rx_samps =0; //initialize number of received samples uhd::rx_metadata_t md; std::vector<std::complex<float> > buff(number_bins); std::vector<std::complex<float> > out_buff(number_bins); //initialize fft plan fftwf_complex *in = (fftwf_complex*)&buff.front(); //allocate array in fftwf_complex *out = (fftwf_complex*)&out_buff.front(); //allocate array out fftwf_plan f; f =fftwf_plan_dft_1d(number_bins,in, out, FFTW_FORWARD,FFTW_ESTIMATE); while(not stop_signal_called and (num_acc_samps < total_samples or total_samples == 0)) { size_t num_rx_samps = rx_streamer->recv( &buff.front(), buff.size(), md, 3.0); std::cout <<" current buffer size: "<< buff.size()<<std::endl<<std::endl; //handle the error codes switch(md.error_code){ case uhd::rx_metadata_t::ERROR_CODE_NONE: break; case uhd::rx_metadata_t::ERROR_CODE_TIMEOUT: if (num_acc_samps == 0) continue; std::cout << boost::format( "Got timeout before all samples received, possible packet loss, exiting loop..." ) << std::endl; goto done_loop; default: std::cout << boost::format( "Got error code 0x%x, exiting loop..." ) % md.error_code << std::endl; goto done_loop; } std::cout<<"performing fft to samples at frequency"<<usrp->get_rx_freq()<<std::endl; fftwf_execute(f); num_acc_samps = num_rx_samps +1; std::cout<<"number of accumulated samples"<<num_acc_samps<<std::endl<<std::endl; std::cout <<"nubmer of rx samples: "<<num_rx_samps <<std::endl<<std::endl; float energy = find_energy(out_buff); std::cout<<"the energy for incoming samples: " <<energy; // print_data(out_buff); } done_loop: fftwf_destroy_plan(f); std::cout<<std::endl<<"done"; return 0; }
int UHD_SAFE_MAIN(int argc, char *argv[]){ if (!(uhd::set_thread_priority_safe(1,true))) { std::cout << "Problem setting thread priority" << std::endl; return 1; }; //variables to be set by po //double seconds_in_future=0.01; size_t total_num_samps; double rx_rate, freq, LOoffset; bool use_external_10MHz; double scaling_8bits; std::string filename; float gain; uhd::device_addr_t dev_addr; uhd::usrp::multi_usrp::sptr dev; uhd::tune_result_t tr; uhd::stream_args_t stream_args; uhd::rx_streamer::sptr rx_stream; //setup the program options po::options_description desc("Allowed options"); desc.add_options() ("help", "help message") ("nsamps", po::value<size_t>(&total_num_samps)->default_value(1000), "total number of samples to receive") ("rxrate", po::value<double>(&rx_rate)->default_value(100e6/4), "rate of incoming samples") ("freq", po::value<double>(&freq)->default_value(0), "rf center frequency in Hz") ("LOoffset", po::value<double>(&LOoffset)->default_value(0), "Offset between main LO and center frequency") ("10MHz",po::value<bool>(&use_external_10MHz)->default_value(false), "external 10MHz on 'REF CLOCK' connector (true=1=yes)") // ("PPS",po::value<bool>(&trigger_with_pps)->default_value(false), "trigger reception with 'PPS IN' connector (true=1=yes)") ("filename",po::value<std::string>(&filename)->default_value("data_from_usrp.dat"), "output filename") ("gain",po::value<float>(&gain)->default_value(0), "set the receiver gain") ("8bits_scaling",po::value<double>(&scaling_8bits)->default_value(0.0), "input scaling (invers) when 8bits is used, set to zero to get 16bits") ; po::variables_map vm; po::store(po::parse_command_line(argc, argv, desc), vm); po::notify(vm); dev_addr["addr0"]="192.168.10.2"; //dev_addr["addr0"]="192.168.10.2"; dev = uhd::usrp::multi_usrp::make(dev_addr); stream_args.cpu_format="sc16"; if (scaling_8bits==0.0) { stream_args.otw_format="sc16"; } else { stream_args.otw_format="sc8"; std::stringstream temp_ss; temp_ss << scaling_8bits; stream_args.args["peak"]=temp_ss.str(); }; rx_stream=dev->get_rx_stream(stream_args); uhd::clock_config_t my_clock_config; #if 0 if (trigger_with_pps) { my_clock_config.pps_source=uhd::clock_config_t::PPS_SMA; }; #endif if (use_external_10MHz) { my_clock_config.ref_source=uhd::clock_config_t::REF_SMA; }; //print the help message if (vm.count("help")){ std::cout << boost::format("UHD RX Timed Samples %s") % desc << std::endl; return ~0; } //create a usrp device std::cout << std::endl; uhd::device::sptr udev = dev->get_device(); dev->set_rx_rate(rx_rate); bool is_xcvr2450=false; uhd::dict<std::string, std::string> rx_info; rx_info=dev->get_usrp_rx_info(0); if (rx_info.has_key("rx_subdev_name")) { std::string str=rx_info.get("rx_subdev_name"); uint temp=str.find("XCVR2450"); if (temp<str.length()) { is_xcvr2450=true; }; }; if (is_xcvr2450) { dev->set_tx_antenna("J2"); dev->set_rx_antenna("J1"); //uhd::meta_range_t range=dev->get_tx_bandwidth_range(); if (LOoffset>=9e6) { dev->set_rx_bandwidth(3.96e+07); }; }; std::cout << "rx_rate=" << rx_rate << std::endl; std::cout << "freq=" << freq << std::endl; std::cout << "gain=" << gain << std::endl; uhd::tune_request_t trq(freq,LOoffset); //dev->set_rx_bandwidth(36e6); tr=dev->set_rx_freq(trq); dev->set_rx_gain(gain); std::cout << "tr=" << tr.actual_rf_freq << std::endl; /* double target_rf_freq; double actual_rf_freq; double target_dsp_freq; double actual_dsp_freq; */ // //dev->set_tx_antenna("J2"); //dev->set_rx_antenna("J1"); if (use_external_10MHz) { dev->set_clock_config(my_clock_config); // PZ usleep(1e6); // Wait for the 10MHz to lock }; size_t buffer_size=1000; // Select buffer size short *buff_short, *storage_short; storage_short=new short[2*total_num_samps]; // Create storage for the // entire received signal to be saved on disk. buff_short=new short[2*buffer_size]; // Create storage for a single // buffer /*if (trigger_with_pps) { dev->set_time_next_pps(uhd::time_spec_t(0.0)); usleep(1e6); } */ //else { dev->set_time_now(uhd::time_spec_t(0.0)); //}; std::cout << boost::format("Setting device timestamp to 0...") << std::endl; //setup streaming //std::cout << std::endl; //std::cout << boost::format("Begin streaming %u samples, %d seconds in the future...") // % total_num_samps % seconds_in_future << std::endl; uhd::stream_cmd_t stream_cmd(uhd::stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_DONE); stream_cmd.num_samps = buffer_size; stream_cmd.stream_now = true; stream_cmd.stream_mode=uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS; //stream_cmd.time_spec = uhd::time_spec_t(seconds_in_future); dev->issue_stream_cmd(stream_cmd); size_t num_rx_samps=0; size_t num_rx_samps_latest_call; uhd::rx_metadata_t md; while (num_rx_samps<total_num_samps) { num_rx_samps_latest_call=0; while (num_rx_samps_latest_call==0) { num_rx_samps_latest_call= rx_stream->recv(&buff_short[0],buffer_size, md, 3.0); }; if (num_rx_samps_latest_call!=buffer_size) { std::cerr << "I expect the buffer size to be always the same!"; exit(1); }; /* Process the just received buffer */ int i1=2*num_rx_samps; int i2=0; while ((i1<(int) (2*total_num_samps)) && (i2<2*((int) buffer_size))) { storage_short[i1]=buff_short[i2]; i1++; i2++; }; num_rx_samps=num_rx_samps+num_rx_samps_latest_call; std::cout << "num_rx_samps=" << num_rx_samps << std::endl; }; //finished std::cout << std::endl << "Done!" << std::endl << std::endl; // Save output to disc //std::ofstream s1(filename.c_str(), std::ios::binary); //s1.write((char *) storage_short,4*total_num_samps); //s1.flush(); //PZ //s1.close(); //PZ //Process the received data short tp = powerTotArray( storage_short, 2*total_num_samps); std::cout << "Total power" << tp << "\nDone!\n"; std::complex<short> * comp_rec=(std::complex<short> *) storage_short; return 0; }
int UHD_SAFE_MAIN(int argc, char *argv[]) { uhd::set_thread_priority_safe(); //variables to be set by po std::string args; size_t nsamps; double rate; double rtt; size_t nruns; //setup the program options po::options_description desc("Allowed options"); desc.add_options() ("help", "help message") ("args", po::value<std::string>(&args)->default_value(""), "single uhd device address args") ("nsamps", po::value<size_t>(&nsamps)->default_value(100), "number of samples per run") ("nruns", po::value<size_t>(&nruns)->default_value(1000), "number of tests to perform") ("rtt", po::value<double>(&rtt)->default_value(0.001), "delay between receive and transmit (seconds)") ("rate", po::value<double>(&rate)->default_value(100e6/4), "sample rate for receive and transmit (sps)") ("verbose", "specify to enable inner-loop verbose") ; 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("UHD - Latency Test %s") % desc << std::endl; std::cout << " Latency test receives a packet at time t,\n" " and tries to send a packet at time t + rtt,\n" " where rtt is the round trip time sample time\n" " from device to host and back to the device.\n" << std::endl; return ~0; } bool verbose = vm.count("verbose") != 0; //create a usrp device std::cout << std::endl; //std::cout << boost::format("Creating the usrp device with: %s...") % args << std::endl; uhd::usrp::multi_usrp::sptr usrp = uhd::usrp::multi_usrp::make(args); //std::cout << boost::format("Using Device: %s") % usrp->get_pp_string() << std::endl; usrp->set_time_now(uhd::time_spec_t(0.0)); //set the tx sample rate usrp->set_tx_rate(rate); std::cout << boost::format("Actual TX Rate: %f Msps...") % (usrp->get_tx_rate()/1e6) << std::endl; //set the rx sample rate usrp->set_rx_rate(rate); std::cout << boost::format("Actual RX Rate: %f Msps...") % (usrp->get_rx_rate()/1e6) << std::endl; //allocate a buffer to use std::vector<std::complex<float> > buffer(nsamps); //create RX and TX streamers uhd::stream_args_t stream_args("fc32"); //complex floats uhd::rx_streamer::sptr rx_stream = usrp->get_rx_stream(stream_args); uhd::tx_streamer::sptr tx_stream = usrp->get_tx_stream(stream_args); //initialize result counts int time_error = 0; int ack = 0; int underflow = 0; int other = 0; for(size_t nrun = 0; nrun < nruns; nrun++) { /*************************************************************** * Issue a stream command some time in the near future **************************************************************/ uhd::stream_cmd_t stream_cmd(uhd::stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_DONE); stream_cmd.num_samps = buffer.size(); stream_cmd.stream_now = false; stream_cmd.time_spec = usrp->get_time_now() + uhd::time_spec_t(0.01); usrp->issue_stream_cmd(stream_cmd); /*************************************************************** * Receive the requested packet **************************************************************/ uhd::rx_metadata_t rx_md; size_t num_rx_samps = rx_stream->recv( &buffer.front(), buffer.size(), rx_md ); if(verbose) std::cout << boost::format("Got packet: %u samples, %u full secs, %f frac secs") % num_rx_samps % rx_md.time_spec.get_full_secs() % rx_md.time_spec.get_frac_secs() << std::endl; /*************************************************************** * Transmit a packet with delta time after received packet **************************************************************/ uhd::tx_metadata_t tx_md; tx_md.start_of_burst = true; tx_md.end_of_burst = true; tx_md.has_time_spec = true; tx_md.time_spec = rx_md.time_spec + uhd::time_spec_t(rtt); size_t num_tx_samps = tx_stream->send( &buffer.front(), buffer.size(), tx_md ); if(verbose) std::cout << boost::format("Sent %d samples") % num_tx_samps << std::endl; /*************************************************************** * Check the async messages for result **************************************************************/ uhd::async_metadata_t async_md; if (not usrp->get_device()->recv_async_msg(async_md)) { std::cout << boost::format("failed:\n Async message recv timed out.\n") << std::endl; continue; } switch(async_md.event_code) { case uhd::async_metadata_t::EVENT_CODE_TIME_ERROR: time_error++; break; case uhd::async_metadata_t::EVENT_CODE_BURST_ACK: ack++; break; case uhd::async_metadata_t::EVENT_CODE_UNDERFLOW: underflow++; break; default: std::cerr << boost::format( "failed:\n Got unexpected event code 0x%x.\n" ) % async_md.event_code << std::endl; other++; break; } } /*************************************************************** * Print the summary **************************************************************/ std::cout << boost::format("\nACK %d, UNDERFLOW %d, TIME_ERR %d, other %d") % ack % underflow % time_error % other << std::endl; return 0; }
//This is the main sample receiving thread (private) void *usrp_receiver_thread (void *param) { uhd::rx_metadata_t md; std::vector<std::complex<float> > buff(MAX_USRP_RX_BUFFER); int old_state, old_type; QUEUE_BUFFER_ENTRY *item; pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,&old_state); pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS,&old_type); //Setup the samples streaming uhd::stream_cmd_t stream_cmd(uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS); stream_cmd.num_samps = 0; stream_cmd.stream_now = true; usrp.sdev->issue_stream_cmd(stream_cmd); std::cerr << "Starting the USRP receiver thread cycle" << std::endl; //TIME BENCHMARKING struct timeval *tod, *tod1; tod = (timeval *) malloc(sizeof(*tod)); tod1 = (timeval *) malloc(sizeof(*tod1)); int elapsed_usec = 0, diff_usec = 0; long int recv_samps = 0; gettimeofday(tod, NULL); while (1){ size_t num_rx_samps = usrp.dev->recv( &buff.front(), buff.size(), md, uhd::io_type_t::COMPLEX_FLOAT32, uhd::device::RECV_MODE_ONE_PACKET ); recv_samps += num_rx_samps; //std::cerr << boost::format("%s: received from USRP %d samples\n") % __FUNCTION__, num_rx_samps << std::endl; //TIME BECHMARKING gettimeofday(tod1, NULL); //std::cerr << boost::format("After recv: %d (SAMPS: %d)|\n") % (tod1->tv_usec - tod->tv_usec) % num_rx_samps; //handle the error codes switch(md.error_code){ case uhd::rx_metadata_t::ERROR_CODE_NONE: break; case uhd::rx_metadata_t::ERROR_CODE_TIMEOUT: std::cerr << boost::format( "Got timeout before all samples received, possible packet loss, exiting loop..." ) << std::endl; goto done_loop; case uhd::rx_metadata_t::ERROR_CODE_OVERFLOW: /* * Let the progranm continue. * In current version, overflows will be detected by "OOO's" at stderr * More elegant management will come in official version. * std::cerr << boost::format( "Internal USRP receiver buffer overflow, exiting loop..." ) << std::endl; goto done_loop; */ break; default: std::cerr << boost::format( "Got error code 0x%x, exiting loop..." ) % md.error_code << std::endl; goto done_loop; } //ENQUEUE The buffer pthread_mutex_lock(&RECEIVER_CYCLE_lock); bool do_add_queue = RECEIVER_CYCLE; pthread_mutex_unlock(&RECEIVER_CYCLE_lock); if (! do_add_queue) continue; //Copy of the buffer in a NEW allocated buffer std::vector<std::complex<float> > *buff2 = new std::vector<std::complex<float> >(buff); //If there is space in queue if (rx_queue_length < MAX_QUEUE) { //Add container to queue item = (QUEUE_BUFFER_ENTRY *) malloc(sizeof(*item)); item->data = buff2; //std::cerr << boost::format("Add to queue: len %d") % rx_queue_length << std::endl; pthread_mutex_lock(&rx_queue_lock); TAILQ_INSERT_TAIL(&rx_samples_iq_stream, item, entries); rx_queue_length++; pthread_mutex_unlock(&rx_queue_lock); } else { //else discard the rx buffer... std::cerr << boost::format("RX queue is full: rx buffer not forwarded!") << std::endl; } //TIME BENCHMARKING /* long int prev_usec=tod->tv_usec; gettimeofday(tod, NULL); elapsed_usec += ((diff_usec = tod->tv_usec - prev_usec) > 0 ? diff_usec : diff_usec + 1000000); std::cerr << boost::format("Actual receiving rate (MSPS): %f") % (recv_samps * 1.0 / elapsed_usec) << std::endl; */ } done_loop: std::cerr << "Exiting USRP receiver thread" << std::endl; return 0; }
void recv_to_file(uhd::rx_streamer::sptr rx_stream, const std::string& file, const size_t samps_per_buff, const double rx_rate, const unsigned long long num_requested_samples, double time_requested = 0.0, bool bw_summary = false, bool stats = false, bool enable_size_map = false, bool continue_on_bad_packet = false) { unsigned long long num_total_samps = 0; uhd::rx_metadata_t md; std::vector<samp_type> buff(samps_per_buff); std::ofstream outfile; if (not file.empty()) { outfile.open(file.c_str(), std::ofstream::binary); } bool overflow_message = true; // setup streaming uhd::stream_cmd_t stream_cmd((num_requested_samples == 0) ? uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS : uhd::stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_DONE); stream_cmd.num_samps = size_t(num_requested_samples); stream_cmd.stream_now = true; stream_cmd.time_spec = uhd::time_spec_t(); std::cout << "Issuing stream cmd" << std::endl; rx_stream->issue_stream_cmd(stream_cmd); const auto start_time = std::chrono::steady_clock::now(); const auto stop_time = start_time + std::chrono::milliseconds(int64_t(1000 * time_requested)); // Track time and samps between updating the BW summary auto last_update = start_time; unsigned long long last_update_samps = 0; typedef std::map<size_t, size_t> SizeMap; SizeMap mapSizes; // Run this loop until either time expired (if a duration was given), until // the requested number of samples were collected (if such a number was // given), or until Ctrl-C was pressed. while (not stop_signal_called and (num_requested_samples != num_total_samps or num_requested_samples == 0) and (time_requested == 0.0 or std::chrono::steady_clock::now() <= stop_time)) { const auto now = std::chrono::steady_clock::now(); size_t num_rx_samps = rx_stream->recv(&buff.front(), buff.size(), md, 3.0, enable_size_map); if (md.error_code == uhd::rx_metadata_t::ERROR_CODE_TIMEOUT) { std::cout << boost::format("Timeout while streaming") << std::endl; break; } if (md.error_code == uhd::rx_metadata_t::ERROR_CODE_OVERFLOW) { if (overflow_message) { overflow_message = false; std::cerr << boost::format( "Got an overflow indication. Please consider the following:\n" " Your write medium must sustain a rate of %fMB/s.\n" " Dropped samples will not be written to the file.\n" " Please modify this example for your purposes.\n" " This message will not appear again.\n") % (rx_rate * sizeof(samp_type) / 1e6); } continue; } if (md.error_code != uhd::rx_metadata_t::ERROR_CODE_NONE) { std::string error = str(boost::format("Receiver error: %s") % md.strerror()); if (continue_on_bad_packet) { std::cerr << error << std::endl; continue; } else throw std::runtime_error(error); } if (enable_size_map) { SizeMap::iterator it = mapSizes.find(num_rx_samps); if (it == mapSizes.end()) mapSizes[num_rx_samps] = 0; mapSizes[num_rx_samps] += 1; } num_total_samps += num_rx_samps; if (outfile.is_open()) { outfile.write((const char*)&buff.front(), num_rx_samps * sizeof(samp_type)); } if (bw_summary) { last_update_samps += num_rx_samps; const auto time_since_last_update = now - last_update; if (time_since_last_update > std::chrono::seconds(UPDATE_INTERVAL)) { const double time_since_last_update_s = std::chrono::duration<double>(time_since_last_update).count(); const double rate = double(last_update_samps) / time_since_last_update_s; std::cout << "\t" << (rate / 1e6) << " MSps" << std::endl; last_update_samps = 0; last_update = now; } } } const auto actual_stop_time = std::chrono::steady_clock::now(); stream_cmd.stream_mode = uhd::stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS; std::cout << "Issuing stop stream cmd" << std::endl; rx_stream->issue_stream_cmd(stream_cmd); // Run recv until nothing is left int num_post_samps = 0; do { num_post_samps = rx_stream->recv(&buff.front(), buff.size(), md, 3.0); } while (num_post_samps and md.error_code == uhd::rx_metadata_t::ERROR_CODE_NONE); if (outfile.is_open()) outfile.close(); if (stats) { std::cout << std::endl; const double actual_duration_seconds = std::chrono::duration<float>(actual_stop_time - start_time).count(); std::cout << boost::format("Received %d samples in %f seconds") % num_total_samps % actual_duration_seconds << std::endl; const double rate = (double)num_total_samps / actual_duration_seconds; std::cout << (rate / 1e6) << " MSps" << std::endl; if (enable_size_map) { std::cout << std::endl; std::cout << "Packet size map (bytes: count)" << std::endl; for (SizeMap::iterator it = mapSizes.begin(); it != mapSizes.end(); it++) std::cout << it->first << ":\t" << it->second << std::endl; } } }
int UHD_SAFE_MAIN(int argc, char *argv[]) { // Set priority of the main thread int which = PRIO_PROCESS; id_t pid; int priority = -19; int ret; pid = getpid(); ret = setpriority(which, pid, priority); if(ret!=0) { std::cout << "Main priority went wrong: " << ret << std::endl ; } //Seting priority in the processor to run faster -> run with sudo if (!(uhd::set_thread_priority_safe(1,true))) { std::cout << "Problem setting thread priority" << std::endl; return 1; }; if (!(uhd::set_thread_priority_safe(1,true))) { std::cout << "Problem setting thread priority" << std::endl; return 1; }; //variables to be set by po //double seconds_in_future=0.01; size_t total_num_samps; double rx_rate, freq, LOoffset; bool use_external_10MHz; bool realTime; double scaling_8bits; std::string filename; float gain; uhd::device_addr_t dev_addr; uhd::usrp::multi_usrp::sptr dev; uhd::tune_result_t tr; uhd::stream_args_t stream_args; uhd::rx_streamer::sptr rx_stream; //setup the program options po::options_description desc("Allowed options"); desc.add_options() ("help", "help message") ("nsamps", po::value<size_t>(&total_num_samps)->default_value(150000), "total number of samples to receive") ("rxrate", po::value<double>(&rx_rate)->default_value(100e6/4), "rate of incoming samples") ("freq", po::value<double>(&freq)->default_value(70e6), "rf center frequency in Hz") ("LOoffset", po::value<double>(&LOoffset)->default_value(0), "Offset between main LO and center frequency") ("10MHz",po::value<bool>(&use_external_10MHz)->default_value(false), "external 10MHz on 'REF CLOCK' connector (true=1=yes)") // ("PPS",po::value<bool>(&trigger_with_pps)->default_value(false), "trigger reception with 'PPS IN' connector (true=1=yes)") ("filename",po::value<std::string>(&filename)->default_value("data_from_usrp.dat"), "output filename") ("gain",po::value<float>(&gain)->default_value(5), "set the receiver gain (0-15)") ("8bits_scaling",po::value<double>(&scaling_8bits)->default_value(0.0), "input scaling (invers) when 8bits is used, set to zero to get 16bits") ("realTime",po::value<bool>(&realTime)->default_value(true), "receives in loop and compares with synch sequence") ; 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("rx %s") % desc << std::endl; return ~0; } dev_addr["addr0"]="192.168.10.2"; //dev_addr["addr0"]="192.168.10.2"; dev = uhd::usrp::multi_usrp::make(dev_addr); //dev->set_rx_subdev_spec(uhd::usrp::subdev_spec_t("A:A"), 0); // 60GHz stream_args.cpu_format="sc16"; if (scaling_8bits==0.0) { stream_args.otw_format="sc16"; } else { stream_args.otw_format="sc8"; std::stringstream temp_ss; temp_ss << scaling_8bits; stream_args.args["peak"]=temp_ss.str(); }; rx_stream=dev->get_rx_stream(stream_args); uhd::clock_config_t my_clock_config; if (use_external_10MHz) { my_clock_config.ref_source=uhd::clock_config_t::REF_SMA; }; //print the help message if (vm.count("help")) { std::cout << boost::format("UHD RX Timed Samples %s") % desc << std::endl; return ~0; } //create a usrp device std::cout << std::endl; uhd::device::sptr udev = dev->get_device(); dev->set_rx_rate(rx_rate); uhd::tune_request_t trq(freq,LOoffset); tr=dev->set_rx_freq(trq); uhd::usrp::dboard_iface::sptr db_iface; db_iface=dev->get_tx_dboard_iface(0); board_60GHz_RX my_60GHz_RX(db_iface); // 60GHz my_60GHz_RX.set_gain(gain); // 60GHz if (use_external_10MHz) { dev->set_clock_config(my_clock_config); usleep(1e6); // Wait for the 10MHz to lock }; size_t buffer_size=1000; // Select buffer size int nStorage=2*total_num_samps; dev->set_time_now(uhd::time_spec_t(0.0)); std::cout << boost::format("Setting device timestamp to 0...") << std::endl; // % total_num_samps % seconds_in_future << std::endl; uhd::stream_cmd_t stream_cmd(uhd::stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_DONE); stream_cmd.num_samps = buffer_size; stream_cmd.stream_now = true; stream_cmd.stream_mode=uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS; dev->issue_stream_cmd(stream_cmd); //////////////////////////////////Read data to buff_short and do processing//////////// //Launch threads sem_init(&usrpReady, 0,0); sem_init(&detectionReady, 0,0); std::thread usrpT(usrpGetData, rx_stream, dev, buffer_size, &my_60GHz_RX); std::thread detectionT(detection, buffer_size, nStorage); // Set highest priority for usrpT sched_param sch; int policy; pthread_getschedparam(usrpT.native_handle(), &policy, &sch); sch.sched_priority = 99; if(pthread_setschedparam(usrpT.native_handle(), SCHED_FIFO, &sch)) { std::cout << "Failed to setschedparam: " << std::strerror(errno) << '\n'; } // pthread_getschedparam(detectionT.native_handle(), &policy, &sch); // sch.sched_priority = 99; // if(pthread_setschedparam(detectionT.native_handle(), SCHED_FIFO, &sch)) { // std::cout << "Failed to setschedparam: " << std::strerror(errno) << '\n'; // } std::cout << "Priority set"<< std::endl; usrpT.join(); detectionT.join(); //finished std::cout << std::endl << "Done!" << std::endl << std::endl; return 0; }
void BlindOFDM_UHDDevice::run(){ if(is_sending){ int num_tx_samps=0; while(is_sending){ //cout << "Send PACKET at time " << tx_timestamp << endl; tx_md.start_of_burst = true; tx_md.end_of_burst = true; tx_md.has_time_spec = true; tx_md.time_spec = uhd::time_spec_t(tx_timestamp); if(time()>tx_timestamp){ cout << "WRONG TX TIMESTAMP!!!!!!!!!!!!!!!!" << endl; //break; while(time()>tx_timestamp) tx_timestamp=tx_timestamp+time_gap; } num_tx_samps=tx_stream->send(&tx_buff(0), tx_buff.size(), tx_md, tx_timestamp+tx_buff.size()/tx_rate); if(tx_buff2!=tx_buff){ tx_buff=tx_buff2; } tx_timestamp=tx_timestamp+time_gap; tx_md.start_of_burst = false; tx_md.end_of_burst = true; tx_md.has_time_spec = false; tx_stream->send("", 0, tx_md); has_sent=true; } has_sent=false; } if(is_receiving){ //uhd::rx_metadata_t rx_md; uhd::stream_args_t stream_args("fc64"); uhd::rx_streamer::sptr rx_stream = usrp->get_rx_stream(stream_args); cvec rx_buff2; int num_rx_samps=0; int lost_samples=500; //Receiving mode uhd::stream_cmd_t stream_cmd(uhd::stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_DONE); //allocate buffer with data to receive while(is_receiving){ if(rx_buff_size!=rx_buff.size()){ rx_buff_size=rx_buff.size(); rx_buff2.set_size(lost_samples+rx_buff_size); rx_buff2.zeros(); stream_cmd.num_samps = rx_buff2.size(); stream_cmd.stream_now = false; } //cout << "Receive PACKET at time " << timestamp << endl; timestamp=timestamp+time_gap; if((previous_correction!=correction)&&(abs(previous_correction-correction)*rx_rate>1)){ timestamp=timestamp+correction; previous_correction=correction; } if(time()>timestamp){ cout << "WRONG RX TIMESTAMP!!!!!!!!!!!!!!!!" << endl; //break; while(time()>timestamp) timestamp=timestamp+time_gap; } stream_cmd.time_spec = uhd::time_spec_t(timestamp-lost_samples/rx_rate); usrp->issue_stream_cmd(stream_cmd); num_rx_samps=rx_stream->recv(&rx_buff2(0), rx_buff2.size(), rx_md, timestamp-lost_samples/rx_rate,false); rx_buff=rx_buff2.get(lost_samples,lost_samples+rx_buff_size-1); } } }
int UHD_SAFE_MAIN(int argc, char *argv[]){ uhd::set_thread_priority_safe(); //variables to be set by po std::string args, file; size_t total_num_samps; double rate, freq, gain; //setup the program options po::options_description desc("Allowed options"); desc.add_options() ("help", "help message") ("args", po::value<std::string>(&args)->default_value(""), "multi uhd device address args") ("file", po::value<std::string>(&file)->default_value("out.16sc.dat"), "name of the file to write binary samples to") ("nsamps", po::value<size_t>(&total_num_samps)->default_value(1000), "total number of samples to receive") ("rate", po::value<double>(&rate)->default_value(100e6/16), "rate of incoming samples") ("freq", po::value<double>(&freq)->default_value(0), "rf center frequency in Hz") ("gain", po::value<double>(&gain)->default_value(0), "gain for the RF chain") ; 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("UHD RX samples to file %s") % desc << std::endl; return ~0; } //create a usrp device std::cout << std::endl; std::cout << boost::format("Creating the usrp device with: %s...") % args << std::endl; uhd::usrp::multi_usrp::sptr usrp = uhd::usrp::multi_usrp::make(args); std::cout << boost::format("Using Device: %s") % usrp->get_pp_string() << std::endl; //set the rx sample rate std::cout << boost::format("Setting RX Rate: %f Msps...") % (rate/1e6) << std::endl; usrp->set_rx_rate(rate); std::cout << boost::format("Actual RX Rate: %f Msps...") % (usrp->get_rx_rate()/1e6) << std::endl << std::endl; //set the rx center frequency std::cout << boost::format("Setting RX Freq: %f Mhz...") % (freq/1e6) << std::endl; usrp->set_rx_freq(freq); std::cout << boost::format("Actual RX Freq: %f Mhz...") % (usrp->get_rx_freq()/1e6) << std::endl << std::endl; //set the rx rf gain std::cout << boost::format("Setting RX Gain: %f dB...") % gain << std::endl; usrp->set_rx_gain(gain); std::cout << boost::format("Actual RX Gain: %f dB...") % usrp->get_rx_gain() << std::endl << std::endl; boost::this_thread::sleep(boost::posix_time::seconds(1)); //allow for some setup time std::cout << "LO Locked = " << usrp->get_rx_lo_locked() << std::endl; //setup streaming uhd::stream_cmd_t stream_cmd(uhd::stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_DONE); stream_cmd.num_samps = total_num_samps; stream_cmd.stream_now = true; usrp->issue_stream_cmd(stream_cmd); //loop until total number of samples reached size_t num_acc_samps = 0; //number of accumulated samples uhd::rx_metadata_t md; std::vector<std::complex<short> > buff(usrp->get_device()->get_max_recv_samps_per_packet()); std::ofstream outfile(file.c_str(), std::ofstream::binary); while(num_acc_samps < total_num_samps){ size_t num_rx_samps = usrp->get_device()->recv( &buff.front(), buff.size(), md, uhd::io_type_t::COMPLEX_INT16, uhd::device::RECV_MODE_ONE_PACKET ); //handle the error codes switch(md.error_code){ case uhd::rx_metadata_t::ERROR_CODE_NONE: break; case uhd::rx_metadata_t::ERROR_CODE_TIMEOUT: if (num_acc_samps == 0) continue; std::cout << boost::format( "Got timeout before all samples received, possible packet loss, exiting loop..." ) << std::endl; goto done_loop; default: std::cout << boost::format( "Got error code 0x%x, exiting loop..." ) % md.error_code << std::endl; goto done_loop; } //write complex short integer samples to the binary file outfile.write((const char*)&buff[0], num_rx_samps * sizeof(std::complex<short>)); num_acc_samps += num_rx_samps; } done_loop: outfile.close(); //finished std::cout << std::endl << "Done!" << std::endl << std::endl; return 0; }
int UHD_SAFE_MAIN(int argc, char *argv[]){ if (!(uhd::set_thread_priority_safe(1,true))) { std::cout << "Problem setting thread priority" << std::endl; return 1; }; //variables to be set by po //double seconds_in_future=0.01; size_t total_num_samps; double rx_rate, freq, LOoffset, rf_freq, clock_freq; bool use_external_10MHz; double scaling_8bits; std::string filename; float gain; std::string dev_addr_str; uhd::device_addr_t dev_addr; uhd::usrp::multi_usrp::sptr dev; uhd::tune_result_t tr; uhd::stream_args_t stream_args; uhd::rx_streamer::sptr rx_stream; //setup the program options po::options_description desc("Allowed options"); desc.add_options() ("help", "help message") ("nsamps", po::value<size_t>(&total_num_samps)->default_value(1000), "total number of samples to receive") ("rxrate", po::value<double>(&rx_rate)->default_value(100e6/4), "rate of incoming samples") ("rf_freq", po::value<double>(&rf_freq)->default_value(60e9), "rf center frequency in Hz of 60GHz RX board") ("freq", po::value<double>(&freq)->default_value(60e9), "center frequency at input of basic daughterboard") ("LOoffset", po::value<double>(&LOoffset)->default_value(0), "Offset between main LO and center frequency") ("10MHz",po::value<bool>(&use_external_10MHz)->default_value(false), "external 10MHz on 'REF CLOCK' connector (true=1=yes)") // ("PPS",po::value<bool>(&trigger_with_pps)->default_value(false), "trigger reception with 'PPS IN' connector (true=1=yes)") ("filename",po::value<std::string>(&filename)->default_value("data_from_usrp.dat"), "output filename") ("gain",po::value<float>(&gain)->default_value(0), "set the receiver gain (0-15)") ("8bits_scaling",po::value<double>(&scaling_8bits)->default_value(0.0), "input scaling (invers) when 8bits is used, set to zero to get 16bits") ("dev_addr",po::value<std::string>(&dev_addr_str)->default_value("192.168.10.2"), "IP address of USRP") ("clock_freq", po::value<double>(&clock_freq)->default_value(285.714), "Clock frequency of CLK board") ; po::variables_map vm; po::store(po::parse_command_line(argc, argv, desc), vm); po::notify(vm); dev_addr["addr0"]=dev_addr_str; dev = uhd::usrp::multi_usrp::make(dev_addr); //create a usrp device std::cout << std::endl; uhd::device::sptr udev = dev->get_device(); dev->set_rx_rate(rx_rate); uhd::tune_request_t trq(freq,LOoffset); tr=dev->set_rx_freq(trq); uhd::usrp::dboard_iface::sptr db_iface; db_iface=dev->get_tx_dboard_iface(0); board_60GHz_RX my_60GHz_RX(db_iface,clock_freq); // 60GHz my_60GHz_RX.set_gain(gain); // 60GHz if (rf_freq!=64e9) { my_60GHz_RX.set_freq(rf_freq); // 60GHz }; uhd::clock_config_t my_clock_config; if (use_external_10MHz) { dev->set_clock_config(my_clock_config); usleep(1e6); // Wait for the 10MHz to lock }; if (scaling_8bits<0) { stream_args.cpu_format="sc16"; stream_args.otw_format="sc16"; rx_stream=dev->get_rx_stream(stream_args); std::complex<int16_t> *d_buffer_rx; uhd::stream_cmd_t stream_cmd(uhd::stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_DONE); uint32_t buffer_size=rx_stream->get_max_num_samps(); stream_cmd.num_samps = buffer_size; stream_cmd.stream_now = true; stream_cmd.stream_mode=uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS; std::cout << "buffer_size=" << buffer_size << "\n"; d_buffer_rx = new std::complex<int16_t>[buffer_size]; rx_stream->issue_stream_cmd(stream_cmd); uhd::rx_metadata_t md; size_t num_rx_samps_latest_call=0; while (num_rx_samps_latest_call==0) { num_rx_samps_latest_call= rx_stream->recv(&d_buffer_rx[0],buffer_size, md, 3.0); }; double max_value=0.0; double new_value; for (uint32_t i2=10;i2<num_rx_samps_latest_call;i2++){ new_value=abs(d_buffer_rx[i2]); if (new_value>max_value) { max_value=new_value; }; }; std::cout << "max_value=" << max_value << "\n"; scaling_8bits=max_value*3.0518e-05*abs(scaling_8bits); if (scaling_8bits<0.0039062) scaling_8bits=0.0039062; std::cout << "scaling_8bits=" << scaling_8bits << "\n"; }; stream_args.cpu_format="sc16"; if (scaling_8bits==0.0) { stream_args.otw_format="sc16"; } else { stream_args.otw_format="sc8"; std::stringstream temp_ss; temp_ss << scaling_8bits; stream_args.args["peak"]=temp_ss.str(); }; rx_stream=dev->get_rx_stream(stream_args); if (use_external_10MHz) { my_clock_config.ref_source=uhd::clock_config_t::REF_SMA; }; //print the help message if (vm.count("help")){ std::cout << boost::format("rx_60GHz %s") % desc << std::endl; return ~0; } size_t buffer_size=1000; // Select buffer size short *buff_short, *storage_short; storage_short=new short[2*total_num_samps]; // Create storage for the // entire received signal to be saved on disk. buff_short=new short[2*buffer_size]; // Create storage for a single // buffer // dev->set_time_now(uhd::time_spec_t(0.0)); //std::cout << boost::format("Setting device timestamp to 0...") << std::endl; uhd::stream_cmd_t stream_cmd(uhd::stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_DONE); stream_cmd.num_samps = total_num_samps; //buffer_size; stream_cmd.stream_now = true; dev->issue_stream_cmd(stream_cmd); size_t num_rx_samps=0; size_t num_rx_samps_latest_call; uhd::rx_metadata_t md; while (num_rx_samps<total_num_samps) { num_rx_samps_latest_call=0; while (num_rx_samps_latest_call==0) { num_rx_samps_latest_call= rx_stream->recv(&buff_short[0],buffer_size, md, 3.0); }; stream_cmd.stream_mode=uhd::stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS; dev->issue_stream_cmd(stream_cmd); /* Process the just received buffer */ int i1=2*num_rx_samps; int i2=0; while ((i1<(int) (2*total_num_samps)) && (i2<2*((int) num_rx_samps_latest_call ))) { storage_short[i1]=buff_short[i2]; i1++; i2++; }; num_rx_samps=num_rx_samps+num_rx_samps_latest_call; }; //finished std::cout << std::endl << "Done!" << std::endl << std::endl; // Save output to disc std::ofstream s1(filename.c_str(), std::ios::binary); s1.write((char *) storage_short,4*total_num_samps); s1.flush(); //PZ s1.close(); //PZ return 0; }