In this post and one other post, I mentioned two issues I am having related to N310 streaming:
1. With STREAM_MODE_NUM_SAMPS_AND_DONE, sometimes I get a timeout prior to receiving the requested number of samples (this is the issue identified in this post). This may be simply dependent upon the number of samples requested. 2. With STREAM_MODE_START_CONTINUOUS, I get errors with repeated captures such that after several successful captures, I eventually get a streaming timeout and all subsequent captures fail. So, turns out that this issue is bigger for me than I realized. I had a bunch of trouble yesterday while doing some research experimentation. I had selected to go with X310 devices rather than N310 devices because of their relative maturity. Today, I confirmed that my issues yesterday with the X310 are the same as I previously mentioned for the N310 (#2 above). So, perhaps it is an issue with UHD-3.13 (I did not check any other branch). I modified the Ettus "txrx_loopback_to_file.cpp" code to include a "for loop of 50 iterations" and changed the streaming mode to be continuous. The modified source is included as an attachment (a 'diff' of my code to the original with show the minor changes I made). I attached a console log of the output messages when run with my X310 which shows both the command line parameters I used as well as the resulting errors. Note that everything is going as expected through Iteration 5, but starting at Iteration 6, there is no end-of-burst (EOB) and starting at Iteration 8, a timeout occurs prior to receiving any samples. Please let me know if you have any questions. This is a pretty big issue for me and will prevent me from using 3.13 until addressed. Rob On Fri, Aug 24, 2018 at 2:46 PM Rob Kossler <rkoss...@nd.edu> wrote: > Hi, > This post is perhaps a continuation of a previous post "Problems with MPM > 3.13 on N310", but I wanted to change the subject to reflect this current > issue. > > The issue is an Rx streaming timeout. It can be easily duplicated with a > stock Ettus example. Below you will find the console log which includes > the command line parameters. Note the following: > > - I requested 31250 samples > - There is a error "Timeout while streaming" indicated at the end > - The final file size of 119340 indicates that 29835 samples were > received > - I do not have any reason to believe that the specific command line > arguments below are needed to duplicate the issue. I just didn't bother to > try other ones. > > In the other thread, I mentioned that my Rx timeout issue had gone away > after switching to streaming mode STREAM_MODE_NUM_SAMPS_AND_DONE. However, > the issue below occurs when using that mode so it will be a problem for me. > > Let me know if you have any questions. > > Rob > > > irisheyes9@irisheyes9-Z240-SFF:/media/SSD_RAID/multi_pol$ > txrx_loopback_to_file --tx-args="addr=192.168.61.2" > --rx-args="addr=192.168.61.2" --nsamps=31250 --tx-rate=31.25e6 > --rx-rate=31.25e6 --tx-channels=0,1 --rx-channels=2,3 --tx-freq=2500e6 > --rx-freq=2500e6 > > Creating the transmit usrp device with: addr=192.168.61.2... > [INFO] [UHD] linux; GNU C++ version 5.4.0 20160609; Boost_105800; > UHD_3.13.0.2-0-g0ddc19e5 > [INFO] [MPMD] Initializing 1 device(s) in parallel with args: > mgmt_addr=192.168.61.2,type=n3xx,product=n310,serial=315A34B,claimed=False,addr=192.168.61.2 > [INFO] [MPM.PeriphManager] init() called with device args > `mgmt_addr=192.168.61.2,product=n310'. > [INFO] [0/DmaFIFO_0] Initializing block control (NOC ID: > 0xF1F0D00000000004) > [INFO] [0/DmaFIFO_0] BIST passed (Throughput: 1320 MB/s) > [INFO] [0/DmaFIFO_0] BIST passed (Throughput: 1336 MB/s) > [INFO] [0/DmaFIFO_0] BIST passed (Throughput: 1331 MB/s) > [INFO] [0/DmaFIFO_0] BIST passed (Throughput: 1349 MB/s) > [INFO] [0/Radio_0] Initializing block control (NOC ID: 0x12AD100000011312) > [INFO] [0/Radio_1] Initializing block control (NOC ID: 0x12AD100000011312) > [INFO] [0/DDC_0] Initializing block control (NOC ID: 0xDDC0000000000000) > [INFO] [0/DDC_1] Initializing block control (NOC ID: 0xDDC0000000000000) > [INFO] [0/DUC_0] Initializing block control (NOC ID: 0xD0C0000000000002) > [INFO] [0/DUC_1] Initializing block control (NOC ID: 0xD0C0000000000002) > > Creating the receive usrp device with: addr=192.168.61.2... > Using TX Device: Single USRP: > Device: N300-Series Device > Mboard 0: ni-n3xx-315A34B > RX Channel: 0 > RX DSP: 0 > RX Dboard: A > RX Subdev: Magnesium > RX Channel: 1 > RX DSP: 1 > RX Dboard: A > RX Subdev: Magnesium > RX Channel: 2 > RX DSP: 0 > RX Dboard: B > RX Subdev: Magnesium > RX Channel: 3 > RX DSP: 1 > RX Dboard: B > RX Subdev: Magnesium > TX Channel: 0 > TX DSP: 0 > TX Dboard: A > TX Subdev: Magnesium > TX Channel: 1 > TX DSP: 1 > TX Dboard: A > TX Subdev: Magnesium > TX Channel: 2 > TX DSP: 0 > TX Dboard: B > TX Subdev: Magnesium > TX Channel: 3 > TX DSP: 1 > TX Dboard: B > TX Subdev: Magnesium > > Using RX Device: Single USRP: > Device: N300-Series Device > Mboard 0: ni-n3xx-315A34B > RX Channel: 0 > RX DSP: 0 > RX Dboard: A > RX Subdev: Magnesium > RX Channel: 1 > RX DSP: 1 > RX Dboard: A > RX Subdev: Magnesium > RX Channel: 2 > RX DSP: 0 > RX Dboard: B > RX Subdev: Magnesium > RX Channel: 3 > RX DSP: 1 > RX Dboard: B > RX Subdev: Magnesium > TX Channel: 0 > TX DSP: 0 > TX Dboard: A > TX Subdev: Magnesium > TX Channel: 1 > TX DSP: 1 > TX Dboard: A > TX Subdev: Magnesium > TX Channel: 2 > TX DSP: 0 > TX Dboard: B > TX Subdev: Magnesium > TX Channel: 3 > TX DSP: 1 > TX Dboard: B > TX Subdev: Magnesium > > Setting TX Rate: 31.250000 Msps... > Actual TX Rate: 31.250000 Msps... > > Setting RX Rate: 31.250000 Msps... > Actual RX Rate: 31.250000 Msps... > > Configuring TX Channel 0 > Setting TX Freq: 2500.000000 MHz... > Actual TX Freq: 2500.000000 MHz... > > Configuring TX Channel 1 > Setting TX Freq: 2500.000000 MHz... > Actual TX Freq: 2500.000000 MHz... > > Configuring RX Channel 2 > Setting RX Freq: 2500.000000 MHz... > Actual RX Freq: 2500.000000 MHz... > > Configuring RX Channel 3 > Setting RX Freq: 2500.000000 MHz... > Actual RX Freq: 2500.000000 MHz... > > Checking TX: all_los: locked ... > Checking RX: all_los: locked ... > Setting device timestamp to 0... > Timeout while streaming > > Done! > > irisheyes9@irisheyes9-Z240-SFF:/media/SSD_RAID/multi_pol$ ls -l *.dat > -rw-rw-r-- 1 irisheyes9 irisheyes9 119340 Aug 24 14:33 usrp_samples.00.dat > -rw-rw-r-- 1 irisheyes9 irisheyes9 119340 Aug 24 14:33 usrp_samples.01.dat > irisheyes9@irisheyes9-Z240-SFF:/media/SSD_RAID/multi_pol$ > >
txrx_loopback_to_file_repeat --tx-args="addr=192.168.42.2" --rx-args="addr=192.168.42.2" --nsamps=25000000 --tx-rate=25e6 --rx-rate=25e6 --tx-channels=0,1 --rx-channels=0,1 --tx-freq=2500e6 --rx-freq=2500e6 --file=/media/ramfolder/usrp_samples Creating the transmit usrp device with: addr=192.168.42.2... [INFO] [UHD] linux; GNU C++ version 5.4.0 20160609; Boost_105800; UHD_3.13.0.2-1-g78745bda [INFO] [X300] X300 initialization sequence... [INFO] [X300] Maximum frame size: 8000 bytes. [INFO] [X300] Radio 1x clock: 200 MHz [INFO] [0/DmaFIFO_0] Initializing block control (NOC ID: 0xF1F0D00000000000) [INFO] [0/DmaFIFO_0] BIST passed (Throughput: 1292 MB/s) [INFO] [0/DmaFIFO_0] BIST passed (Throughput: 1324 MB/s) [INFO] [0/Radio_0] Initializing block control (NOC ID: 0x12AD100000000001) [INFO] [0/Radio_1] Initializing block control (NOC ID: 0x12AD100000000001) [INFO] [0/DDC_0] Initializing block control (NOC ID: 0xDDC0000000000000) [INFO] [0/DDC_1] Initializing block control (NOC ID: 0xDDC0000000000000) [INFO] [0/DUC_0] Initializing block control (NOC ID: 0xD0C0000000000000) [INFO] [0/DUC_1] Initializing block control (NOC ID: 0xD0C0000000000000) Creating the receive usrp device with: addr=192.168.42.2... Using TX Device: Single USRP: Device: X-Series Device Mboard 0: X310 RX Channel: 0 RX DSP: 0 RX Dboard: A RX Subdev: UBX RX RX Channel: 1 RX DSP: 0 RX Dboard: B RX Subdev: UBX RX TX Channel: 0 TX DSP: 0 TX Dboard: A TX Subdev: UBX TX TX Channel: 1 TX DSP: 0 TX Dboard: B TX Subdev: UBX TX Using RX Device: Single USRP: Device: X-Series Device Mboard 0: X310 RX Channel: 0 RX DSP: 0 RX Dboard: A RX Subdev: UBX RX RX Channel: 1 RX DSP: 0 RX Dboard: B RX Subdev: UBX RX TX Channel: 0 TX DSP: 0 TX Dboard: A TX Subdev: UBX TX TX Channel: 1 TX DSP: 0 TX Dboard: B TX Subdev: UBX TX Setting TX Rate: 25.000000 Msps... Actual TX Rate: 25.000000 Msps... Setting RX Rate: 25.000000 Msps... Actual RX Rate: 25.000000 Msps... Configuring TX Channel 0 Setting TX Freq: 2500.000000 MHz... [INFO] [CAL] Calibration data loaded: /home/irisheyes1/.uhd/cal/tx_iq_cal_v0.2_30B6D27.csv [INFO] [CAL] Calibration data loaded: /home/irisheyes1/.uhd/cal/tx_dc_cal_v0.2_30B6D27.csv Actual TX Freq: 2500.000000 MHz... Configuring TX Channel 1 Setting TX Freq: 2500.000000 MHz... [INFO] [CAL] Calibration data loaded: /home/irisheyes1/.uhd/cal/tx_iq_cal_v0.2_30B6D34.csv [INFO] [CAL] Calibration data loaded: /home/irisheyes1/.uhd/cal/tx_dc_cal_v0.2_30B6D34.csv Actual TX Freq: 2500.000000 MHz... Configuring RX Channel 0 Setting RX Freq: 2500.000000 MHz... [INFO] [CAL] Calibration data loaded: /home/irisheyes1/.uhd/cal/rx_iq_cal_v0.2_30B6D27.csv Actual RX Freq: 2500.000000 MHz... Configuring RX Channel 1 Setting RX Freq: 2500.000000 MHz... [INFO] [CAL] Calibration data loaded: /home/irisheyes1/.uhd/cal/rx_iq_cal_v0.2_30B6D34.csv Actual RX Freq: 2500.000000 MHz... Checking TX: TXLO: locked ... Checking RX: RXLO: locked ... Setting device timestamp to 0... Iteration 0 at time 0.212296 Num samples received: 25009880 Flush samps received: 5154; EOB: 1; ERR: 0 Iteration 1 at time 1.43477 Num samples received: 25009880 Flush samps received: 3476; EOB: 1; ERR: 0 Iteration 2 at time 2.65718 Num samples received: 25009880 Flush samps received: 4264; EOB: 1; ERR: 0 Iteration 3 at time 3.88041 Num samples received: 25009880 Flush samps received: 3555; EOB: 1; ERR: 0 Iteration 4 at time 5.10372 Num samples received: 25009880 Flush samps received: 4970; EOB: 1; ERR: 0 Iteration 5 at time 6.32643 Num samples received: 25009880 Flush samps received: 4603; EOB: 1; ERR: 0 Iteration 6 at time 7.54844 Num samples received: 25009880 Flush samps received: 3992; EOB: 0; ERR: 0 Flush samps received: 0; EOB: 0; ERR: 1 Iteration 7 at time 8.97127 Num samples received: 25009880 Flush samps received: 3992; EOB: 0; ERR: 0 Flush samps received: 0; EOB: 0; ERR: 1 Iteration 8 at time 10.3942 Timeout while streaming Num samples received: 0 Iteration 9 at time 10.7047 Timeout while streaming Num samples received: 0 Iteration 10 at time 11.0151 Timeout while streaming Num samples received: 0 Iteration 11 at time 11.3256 Timeout while streaming Num samples received: 0 Iteration 12 at time 11.636 Timeout while streaming Num samples received: 0 Iteration 13 at time 11.9464 Timeout while streaming Num samples received: 0 Iteration 14 at time 12.2569 Timeout while streaming Num samples received: 0 Iteration 15 at time 12.5674 ^C
// // Copyright 2010-2012,2014-2015 Ettus Research LLC // Copyright 2018 Ettus Research, a National Instruments Company // // SPDX-License-Identifier: GPL-3.0-or-later // #include "wavetable.hpp" #include <uhd/types/tune_request.hpp> #include <uhd/utils/thread.hpp> #include <uhd/utils/safe_main.hpp> #include <uhd/utils/static.hpp> #include <uhd/usrp/multi_usrp.hpp> #include <uhd/exception.hpp> #include <boost/thread/thread.hpp> #include <boost/program_options.hpp> #include <boost/math/special_functions/round.hpp> #include <boost/format.hpp> #include <boost/algorithm/string.hpp> #include <boost/filesystem.hpp> #include <iostream> #include <fstream> #include <csignal> namespace po = boost::program_options; /*********************************************************************** * Signal handlers **********************************************************************/ static bool stop_signal_called = false; void sig_int_handler(int){stop_signal_called = true;} /*********************************************************************** * Utilities **********************************************************************/ //! Change to filename, e.g. from usrp_samples.dat to usrp_samples.00.dat, // but only if multiple names are to be generated. std::string generate_out_filename(const std::string &base_fn, size_t n_names, size_t this_name) { if (n_names == 1) { return base_fn; } boost::filesystem::path base_fn_fp(base_fn); base_fn_fp.replace_extension( boost::filesystem::path( str(boost::format("%02d%s") % this_name % base_fn_fp.extension().string()) ) ); return base_fn_fp.string(); } /*********************************************************************** * transmit_worker function * A function to be used as a boost::thread_group thread for transmitting **********************************************************************/ void transmit_worker( std::vector<std::complex<float> > buff, wave_table_class wave_table, uhd::tx_streamer::sptr tx_streamer, uhd::tx_metadata_t metadata, size_t step, size_t index, int num_channels ){ std::vector<std::complex<float> *> buffs(num_channels, &buff.front()); //send data until the signal handler gets called while(not stop_signal_called){ //fill the buffer with the waveform for (size_t n = 0; n < buff.size(); n++){ buff[n] = wave_table(index += step); } //send the entire contents of the buffer tx_streamer->send(buffs, buff.size(), metadata); metadata.start_of_burst = false; metadata.has_time_spec = false; } //send a mini EOB packet metadata.end_of_burst = true; tx_streamer->send("", 0, metadata); } /*********************************************************************** * 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, double 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); for (int i=0; i<50; i++) { // Prepare buffers for received samples and metadata uhd::rx_metadata_t md; std::vector <std::vector< samp_type > > buffs( rx_channel_nums.size(), std::vector< samp_type >(samps_per_buff) ); //create a vector of pointers to point to each of the channel buffers std::vector<samp_type *> buff_ptrs; for (size_t i = 0; i < buffs.size(); i++) { buff_ptrs.push_back(&buffs[i].front()); } // Create one ofstream object per channel // (use shared_ptr because ofstream is non-copyable) std::vector<boost::shared_ptr<std::ofstream> > outfiles; for (size_t i = 0; i < buffs.size(); i++) { const std::string this_filename = generate_out_filename(file, buffs.size(), i); outfiles.push_back(boost::shared_ptr<std::ofstream>(new std::ofstream(this_filename.c_str(), std::ofstream::binary))); } UHD_ASSERT_THROW(outfiles.size() == buffs.size()); UHD_ASSERT_THROW(buffs.size() == rx_channel_nums.size()); bool overflow_message = true; double timeout = settling_time + 0.1f; //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 = usrp->get_time_now() + uhd::time_spec_t(settling_time); rx_stream->issue_stream_cmd(stream_cmd); std::cout << "Iteration " << i << " at time " << stream_cmd.time_spec.get_real_secs() << std::endl; 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_ptrs, samps_per_buff, md, timeout); timeout = 0.1f; //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; for (size_t i = 0; i < outfiles.size(); i++) { outfiles[i]->write((const char*) buff_ptrs[i], num_rx_samps*sizeof(samp_type)); } } // Shut down receiver stream_cmd.stream_mode = uhd::stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS; rx_stream->issue_stream_cmd(stream_cmd); std::cout << " Num samples received: " << num_total_samps << std::endl; while (not md.end_of_burst and md.error_code==uhd::rx_metadata_t::ERROR_CODE_NONE) { size_t n = rx_stream->recv(buff_ptrs, samps_per_buff, md, 0.1); std::cout << " Flush samps received: " << n << "; EOB: " << md.end_of_burst << "; ERR: " << md.error_code << std::endl; } // Close files for (size_t i = 0; i < outfiles.size(); i++) { outfiles[i]->close(); } stop_signal_called = false; num_total_samps = 0; boost::this_thread::sleep(boost::posix_time::milliseconds(10)); } } /*********************************************************************** * Main function **********************************************************************/ int UHD_SAFE_MAIN(int argc, char *argv[]){ uhd::set_thread_priority_safe(); //transmit variables to be set by po std::string tx_args, wave_type, tx_ant, tx_subdev, ref, otw, tx_channels; double tx_rate, tx_freq, tx_gain, wave_freq, tx_bw; float ampl; //receive variables to be set by po std::string rx_args, file, type, rx_ant, rx_subdev, rx_channels; size_t total_num_samps, spb; double rx_rate, rx_freq, rx_gain, rx_bw; double settling; //setup the program options po::options_description desc("Allowed options"); desc.add_options() ("help", "help message") ("tx-args", po::value<std::string>(&tx_args)->default_value(""), "uhd transmit device address args") ("rx-args", po::value<std::string>(&rx_args)->default_value(""), "uhd receive 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("short"), "sample type in file: double, float, or short") ("nsamps", po::value<size_t>(&total_num_samps)->default_value(0), "total number of samples to receive") ("settling", po::value<double>(&settling)->default_value(double(0.2)), "settling time (seconds) before receiving") ("spb", po::value<size_t>(&spb)->default_value(0), "samples per buffer, 0 for default") ("tx-rate", po::value<double>(&tx_rate), "rate of transmit outgoing samples") ("rx-rate", po::value<double>(&rx_rate), "rate of receive incoming samples") ("tx-freq", po::value<double>(&tx_freq), "transmit RF center frequency in Hz") ("rx-freq", po::value<double>(&rx_freq), "receive RF center frequency in Hz") ("ampl", po::value<float>(&l)->default_value(float(0.3)), "amplitude of the waveform [0 to 0.7]") ("tx-gain", po::value<double>(&tx_gain), "gain for the transmit RF chain") ("rx-gain", po::value<double>(&rx_gain), "gain for the receive RF chain") ("tx-ant", po::value<std::string>(&tx_ant), "transmit antenna selection") ("rx-ant", po::value<std::string>(&rx_ant), "receive antenna selection") ("tx-subdev", po::value<std::string>(&tx_subdev), "transmit subdevice specification") ("rx-subdev", po::value<std::string>(&rx_subdev), "receive subdevice specification") ("tx-bw", po::value<double>(&tx_bw), "analog transmit filter bandwidth in Hz") ("rx-bw", po::value<double>(&rx_bw), "analog receive filter bandwidth in Hz") ("wave-type", po::value<std::string>(&wave_type)->default_value("CONST"), "waveform type (CONST, SQUARE, RAMP, SINE)") ("wave-freq", po::value<double>(&wave_freq)->default_value(0), "waveform frequency in Hz") ("ref", po::value<std::string>(&ref)->default_value("internal"), "clock reference (internal, external, mimo)") ("otw", po::value<std::string>(&otw)->default_value("sc16"), "specify the over-the-wire sample mode") ("tx-channels", po::value<std::string>(&tx_channels)->default_value("0"), "which TX channel(s) to use (specify \"0\", \"1\", \"0,1\", etc)") ("rx-channels", po::value<std::string>(&rx_channels)->default_value("0"), "which RX channel(s) to use (specify \"0\", \"1\", \"0,1\", etc)") ("tx-int-n", "tune USRP TX with integer-N tuning") ("rx-int-n", "tune USRP RX with integer-N tuning") ; 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 TXRX Loopback to File %s") % desc << std::endl; return ~0; } //create a usrp device std::cout << std::endl; std::cout << boost::format("Creating the transmit usrp device with: %s...") % tx_args << std::endl; uhd::usrp::multi_usrp::sptr tx_usrp = uhd::usrp::multi_usrp::make(tx_args); std::cout << std::endl; std::cout << boost::format("Creating the receive usrp device with: %s...") % rx_args << std::endl; uhd::usrp::multi_usrp::sptr rx_usrp = uhd::usrp::multi_usrp::make(rx_args); //always select the subdevice first, the channel mapping affects the other settings if (vm.count("tx-subdev")) tx_usrp->set_tx_subdev_spec(tx_subdev); if (vm.count("rx-subdev")) rx_usrp->set_rx_subdev_spec(rx_subdev); //detect which channels to use std::vector<std::string> tx_channel_strings; std::vector<size_t> tx_channel_nums; boost::split(tx_channel_strings, tx_channels, boost::is_any_of("\"',")); for(size_t ch = 0; ch < tx_channel_strings.size(); ch++){ size_t chan = std::stoi(tx_channel_strings[ch]); if(chan >= tx_usrp->get_tx_num_channels()){ throw std::runtime_error("Invalid TX channel(s) specified."); } else tx_channel_nums.push_back(std::stoi(tx_channel_strings[ch])); } std::vector<std::string> rx_channel_strings; std::vector<size_t> rx_channel_nums; boost::split(rx_channel_strings, rx_channels, boost::is_any_of("\"',")); for(size_t ch = 0; ch < rx_channel_strings.size(); ch++){ size_t chan = std::stoi(rx_channel_strings[ch]); if(chan >= rx_usrp->get_rx_num_channels()){ throw std::runtime_error("Invalid RX channel(s) specified."); } else rx_channel_nums.push_back(std::stoi(rx_channel_strings[ch])); } //Lock mboard clocks tx_usrp->set_clock_source(ref); rx_usrp->set_clock_source(ref); std::cout << boost::format("Using TX Device: %s") % tx_usrp->get_pp_string() << std::endl; std::cout << boost::format("Using RX Device: %s") % rx_usrp->get_pp_string() << std::endl; //set the transmit sample rate if (not vm.count("tx-rate")){ std::cerr << "Please specify the transmit sample rate with --tx-rate" << std::endl; return ~0; } std::cout << boost::format("Setting TX Rate: %f Msps...") % (tx_rate/1e6) << std::endl; tx_usrp->set_tx_rate(tx_rate); std::cout << boost::format("Actual TX Rate: %f Msps...") % (tx_usrp->get_tx_rate()/1e6) << std::endl << std::endl; //set the receive sample rate if (not vm.count("rx-rate")){ std::cerr << "Please specify the sample rate with --rx-rate" << std::endl; return ~0; } std::cout << boost::format("Setting RX Rate: %f Msps...") % (rx_rate/1e6) << std::endl; rx_usrp->set_rx_rate(rx_rate); std::cout << boost::format("Actual RX Rate: %f Msps...") % (rx_usrp->get_rx_rate()/1e6) << std::endl << std::endl; //set the transmit center frequency if (not vm.count("tx-freq")){ std::cerr << "Please specify the transmit center frequency with --tx-freq" << std::endl; return ~0; } for(size_t ch = 0; ch < tx_channel_nums.size(); ch++) { size_t channel = tx_channel_nums[ch]; if (tx_channel_nums.size() > 1) { std::cout << "Configuring TX Channel " << channel << std::endl; } std::cout << boost::format("Setting TX Freq: %f MHz...") % (tx_freq/1e6) << std::endl; uhd::tune_request_t tx_tune_request(tx_freq); if(vm.count("tx-int-n")) tx_tune_request.args = uhd::device_addr_t("mode_n=integer"); tx_usrp->set_tx_freq(tx_tune_request, channel); std::cout << boost::format("Actual TX Freq: %f MHz...") % (tx_usrp->get_tx_freq(channel)/1e6) << std::endl << std::endl; //set the rf gain if (vm.count("tx-gain")){ std::cout << boost::format("Setting TX Gain: %f dB...") % tx_gain << std::endl; tx_usrp->set_tx_gain(tx_gain, channel); std::cout << boost::format("Actual TX Gain: %f dB...") % tx_usrp->get_tx_gain(channel) << std::endl << std::endl; } //set the analog frontend filter bandwidth if (vm.count("tx-bw")){ std::cout << boost::format("Setting TX Bandwidth: %f MHz...") % tx_bw << std::endl; tx_usrp->set_tx_bandwidth(tx_bw, channel); std::cout << boost::format("Actual TX Bandwidth: %f MHz...") % tx_usrp->get_tx_bandwidth(channel) << std::endl << std::endl; } //set the antenna if (vm.count("tx-ant")) tx_usrp->set_tx_antenna(tx_ant, channel); } for(size_t ch = 0; ch < rx_channel_nums.size(); ch++) { size_t channel = rx_channel_nums[ch]; if (rx_channel_nums.size() > 1) { std::cout << "Configuring RX Channel " << channel << std::endl; } //set the receive center frequency if (not vm.count("rx-freq")){ std::cerr << "Please specify the center frequency with --rx-freq" << std::endl; return ~0; } std::cout << boost::format("Setting RX Freq: %f MHz...") % (rx_freq/1e6) << std::endl; uhd::tune_request_t rx_tune_request(rx_freq); if(vm.count("rx-int-n")) rx_tune_request.args = uhd::device_addr_t("mode_n=integer"); rx_usrp->set_rx_freq(rx_tune_request, channel); std::cout << boost::format("Actual RX Freq: %f MHz...") % (rx_usrp->get_rx_freq(channel)/1e6) << std::endl << std::endl; //set the receive rf gain if (vm.count("rx-gain")){ std::cout << boost::format("Setting RX Gain: %f dB...") % rx_gain << std::endl; rx_usrp->set_rx_gain(rx_gain, channel); std::cout << boost::format("Actual RX Gain: %f dB...") % rx_usrp->get_rx_gain(channel) << std::endl << std::endl; } //set the receive analog frontend filter bandwidth if (vm.count("rx-bw")){ std::cout << boost::format("Setting RX Bandwidth: %f MHz...") % (rx_bw/1e6) << std::endl; rx_usrp->set_rx_bandwidth(rx_bw, channel); std::cout << boost::format("Actual RX Bandwidth: %f MHz...") % (rx_usrp->get_rx_bandwidth(channel)/1e6) << std::endl << std::endl; } } //set the receive antenna if (vm.count("ant")) rx_usrp->set_rx_antenna(rx_ant); //for the const wave, set the wave freq for small samples per period if (wave_freq == 0 and wave_type == "CONST"){ wave_freq = tx_usrp->get_tx_rate()/2; } //error when the waveform is not possible to generate if (std::abs(wave_freq) > tx_usrp->get_tx_rate()/2){ throw std::runtime_error("wave freq out of Nyquist zone"); } if (tx_usrp->get_tx_rate()/std::abs(wave_freq) > wave_table_len/2){ throw std::runtime_error("wave freq too small for table"); } //pre-compute the waveform values const wave_table_class wave_table(wave_type, ampl); const size_t step = boost::math::iround(wave_freq/tx_usrp->get_tx_rate() * wave_table_len); size_t index = 0; //create a transmit streamer //linearly map channels (index0 = channel0, index1 = channel1, ...) uhd::stream_args_t stream_args("fc32", otw); stream_args.channels = tx_channel_nums; uhd::tx_streamer::sptr tx_stream = tx_usrp->get_tx_stream(stream_args); //allocate a buffer which we re-use for each channel if (spb == 0) spb = tx_stream->get_max_num_samps()*10; std::vector<std::complex<float> > buff(spb); int num_channels = tx_channel_nums.size(); //setup the metadata flags uhd::tx_metadata_t md; md.start_of_burst = true; md.end_of_burst = false; md.has_time_spec = true; md.time_spec = uhd::time_spec_t(0.5); //give us 0.5 seconds to fill the tx buffers //Check Ref and LO Lock detect std::vector<std::string> tx_sensor_names, rx_sensor_names; tx_sensor_names = tx_usrp->get_tx_sensor_names(0); if (std::find(tx_sensor_names.begin(), tx_sensor_names.end(), "lo_locked") != tx_sensor_names.end()) { uhd::sensor_value_t lo_locked = tx_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()); } rx_sensor_names = rx_usrp->get_rx_sensor_names(0); if (std::find(rx_sensor_names.begin(), rx_sensor_names.end(), "lo_locked") != rx_sensor_names.end()) { uhd::sensor_value_t lo_locked = rx_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()); } tx_sensor_names = tx_usrp->get_mboard_sensor_names(0); if ((ref == "mimo") and (std::find(tx_sensor_names.begin(), tx_sensor_names.end(), "mimo_locked") != tx_sensor_names.end())) { uhd::sensor_value_t mimo_locked = tx_usrp->get_mboard_sensor("mimo_locked",0); std::cout << boost::format("Checking TX: %s ...") % mimo_locked.to_pp_string() << std::endl; UHD_ASSERT_THROW(mimo_locked.to_bool()); } if ((ref == "external") and (std::find(tx_sensor_names.begin(), tx_sensor_names.end(), "ref_locked") != tx_sensor_names.end())) { uhd::sensor_value_t ref_locked = tx_usrp->get_mboard_sensor("ref_locked",0); std::cout << boost::format("Checking TX: %s ...") % ref_locked.to_pp_string() << std::endl; UHD_ASSERT_THROW(ref_locked.to_bool()); } rx_sensor_names = rx_usrp->get_mboard_sensor_names(0); if ((ref == "mimo") and (std::find(rx_sensor_names.begin(), rx_sensor_names.end(), "mimo_locked") != rx_sensor_names.end())) { uhd::sensor_value_t mimo_locked = rx_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(rx_sensor_names.begin(), rx_sensor_names.end(), "ref_locked") != rx_sensor_names.end())) { uhd::sensor_value_t ref_locked = rx_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()); } if (total_num_samps == 0){ std::signal(SIGINT, &sig_int_handler); std::cout << "Press Ctrl + C to stop streaming..." << std::endl; } //reset usrp time to prepare for transmit/receive std::cout << boost::format("Setting device timestamp to 0...") << std::endl; tx_usrp->set_time_now(uhd::time_spec_t(0.0)); //start transmit worker thread boost::thread_group transmit_thread; transmit_thread.create_thread(boost::bind(&transmit_worker, buff, wave_table, tx_stream, md, step, index, num_channels)); //recv to file if (type == "double") recv_to_file<std::complex<double> >(rx_usrp, "fc64", otw, file, spb, total_num_samps, settling, rx_channel_nums); else if (type == "float") recv_to_file<std::complex<float> >(rx_usrp, "fc32", otw, file, spb, total_num_samps, settling, rx_channel_nums); else if (type == "short") recv_to_file<std::complex<short> >(rx_usrp, "sc16", otw, file, spb, total_num_samps, settling, rx_channel_nums); else { //clean up transmit worker stop_signal_called = true; transmit_thread.join_all(); throw std::runtime_error("Unknown type " + type); } //clean up transmit worker stop_signal_called = true; transmit_thread.join_all(); //finished std::cout << std::endl << "Done!" << std::endl << std::endl; return EXIT_SUCCESS; }
_______________________________________________ USRP-users mailing list USRP-users@lists.ettus.com http://lists.ettus.com/mailman/listinfo/usrp-users_lists.ettus.com