Hey Leo, I haven't seen anyone respond yet and I recently needed to develop a TX RFNoC example of my own. I worked off the rfnoc_rx_to_file.cpp example. Far from perfect, but it gets the job done (transmits data). The main changes are: - copied send_from_file function from tx_samples_from_file.cpp example to handle the streaming of data from the input file - reversed the order that blocks are connected in the graph->connect() function. Now connects optional arg block -> radio. Was radio -> optional arg block. - uses tx_stream instead of rx_stream. Just add this cpp file to the CMake file in the host/examples dir to build it then try it out. I ran it with: build/examples$ ./rfnoc_tx_from_file --block-id DUC_0 --block-args output_rate=200e6,input_rate=5e6 --duration 5 --file usrp_samples.dat
Hope that helps, Ryan -- Ryan L. Marlow R L Marlow Consulting LLC rlmarlow.com
// // Copyright 2014-2016 Ettus Research LLC // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. // #include <uhd/types/tune_request.hpp> #include <uhd/types/sensors.hpp> #include <uhd/utils/thread_priority.hpp> #include <uhd/utils/safe_main.hpp> #include <uhd/device3.hpp> #include <uhd/rfnoc/radio_ctrl.hpp> #include <uhd/rfnoc/source_block_ctrl_base.hpp> #include <uhd/exception.hpp> #include <boost/program_options.hpp> #include <boost/format.hpp> #include <boost/thread.hpp> #include <iostream> #include <fstream> #include <csignal> #include <complex> namespace po = boost::program_options; static bool stop_signal_called = false; void sig_int_handler(int){stop_signal_called = true;} typedef boost::function<uhd::sensor_value_t (const std::string&)> get_sensor_fn_t; bool check_locked_sensor(std::vector<std::string> sensor_names, const char* sensor_name, get_sensor_fn_t get_sensor_fn, double setup_time){ if (std::find(sensor_names.begin(), sensor_names.end(), sensor_name) == sensor_names.end()) return false; boost::system_time start = boost::get_system_time(); boost::system_time first_lock_time; std::cout << boost::format("Waiting for \"%s\": ") % sensor_name; std::cout.flush(); while (true) { if ((not first_lock_time.is_not_a_date_time()) and (boost::get_system_time() > (first_lock_time + boost::posix_time::seconds(setup_time)))) { std::cout << " locked." << std::endl; break; } if (get_sensor_fn(sensor_name).to_bool()){ if (first_lock_time.is_not_a_date_time()) first_lock_time = boost::get_system_time(); std::cout << "+"; std::cout.flush(); } else { first_lock_time = boost::system_time(); //reset to 'not a date time' if (boost::get_system_time() > (start + boost::posix_time::seconds(setup_time))){ std::cout << std::endl; throw std::runtime_error(str(boost::format("timed out waiting for consecutive locks on sensor \"%s\"") % sensor_name)); } std::cout << "_"; std::cout.flush(); } boost::this_thread::sleep(boost::posix_time::milliseconds(100)); } std::cout << std::endl; return true; } template<typename samp_type> void send_from_file( uhd::tx_streamer::sptr tx_stream, const std::string &file, size_t samps_per_buff ){ uhd::tx_metadata_t md; md.start_of_burst = false; md.end_of_burst = false; std::vector<samp_type> buff(samps_per_buff); std::ifstream infile(file.c_str(), std::ifstream::binary); //loop until the entire file has been read while(not md.end_of_burst and not stop_signal_called){ infile.read((char*)&buff.front(), buff.size()*sizeof(samp_type)); size_t num_tx_samps = size_t(infile.gcount()/sizeof(samp_type)); md.end_of_burst = infile.eof(); tx_stream->send(&buff.front(), num_tx_samps, md); } infile.close(); } int UHD_SAFE_MAIN(int argc, char *argv[]){ uhd::set_thread_priority_safe(); //variables to be set by po std::string args, file, format, ant, subdev, ref, wirefmt, streamargs, radio_args, block_id, block_args; size_t total_num_samps, spb, radio_id, radio_chan; double rate, freq, gain, bw, total_time, setup_time; //setup the program options po::options_description desc("Allowed options"); desc.add_options() ("help", "help message") ("file", po::value<std::string>(&file)->default_value("usrp_samples.dat"), "name of the file to write binary samples to") ("format", po::value<std::string>(&format)->default_value("sc16"), "File sample format: sc16, fc32, or fc64") ("duration", po::value<double>(&total_time)->default_value(0), "total number of seconds to receive") ("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") ("streamargs", po::value<std::string>(&streamargs)->default_value(""), "stream args") ("progress", "periodically display short-term bandwidth") ("stats", "show average bandwidth on exit") ("sizemap", "track packet size and display breakdown on exit") ("null", "run without writing to file") ("continue", "don't abort on a bad packet") ("args", po::value<std::string>(&args)->default_value(""), "USRP device address args") ("setup", po::value<double>(&setup_time)->default_value(1.0), "seconds of setup time") ("radio-id", po::value<size_t>(&radio_id)->default_value(0), "Radio ID to use (0 or 1).") ("radio-chan", po::value<size_t>(&radio_chan)->default_value(0), "Radio channel") ("radio-args", po::value<std::string>(&radio_args), "Radio channel") ("rate", po::value<double>(&rate)->default_value(1e6), "RX rate of the radio block") ("freq", po::value<double>(&freq)->default_value(0.0), "RF center frequency in Hz") ("gain", po::value<double>(&gain), "gain for the RF chain") ("ant", po::value<std::string>(&ant), "antenna selection") ("bw", po::value<double>(&bw), "analog frontend filter bandwidth in Hz") ("ref", po::value<std::string>(&ref), "reference source (internal, external, mimo)") ("skip-lo", "skip checking LO lock status") ("int-n", "tune USRP with integer-N tuning") ("block-id", po::value<std::string>(&block_id)->default_value(""), "If block ID is specified, this block is inserted between radio and host.") ("block-args", po::value<std::string>(&block_args)->default_value(""), "These args are passed straight to the block.") ; 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/RFNoC TX samples from file %s") % desc << std::endl; std::cout << std::endl << "This application streams data from a file on the host to a single channel of a USRP.\n" << std::endl; return ~0; } bool bw_summary = vm.count("progress") > 0; bool stats = vm.count("stats") > 0; if (vm.count("null") > 0) { file = ""; } bool enable_size_map = vm.count("sizemap") > 0; bool continue_on_bad_packet = vm.count("continue") > 0; if (enable_size_map) { std::cout << "Packet size tracking enabled - will only recv one packet at a time!" << std::endl; } if (format != "sc16" and format != "fc32" and format != "fc64") { std::cout << "Invalid sample format: " << format << std::endl; return EXIT_FAILURE; } /************************************************************************ * Create device and block controls ***********************************************************************/ std::cout << std::endl; std::cout << boost::format("Creating the USRP device with: %s...") % args << std::endl; uhd::device3::sptr usrp = uhd::device3::make(args); // Create handle for radio object uhd::rfnoc::block_id_t radio_ctrl_id(0, "Radio", radio_id); // This next line will fail if the radio is not actually available uhd::rfnoc::radio_ctrl::sptr radio_ctrl = usrp->get_block_ctrl< uhd::rfnoc::radio_ctrl >(radio_ctrl_id); std::cout << "Using radio " << radio_id << ", channel " << radio_chan << std::endl; /************************************************************************ * Set up radio ***********************************************************************/ radio_ctrl->set_args(radio_args); if (vm.count("ref")) { std::cout << "TODO -- Need to implement API call to set clock source." << std::endl; //Lock mboard clocks TODO //usrp->set_clock_source(ref); } //set the sample rate if (rate <= 0.0){ std::cerr << "Please specify a valid sample rate" << std::endl; return EXIT_FAILURE; } std::cout << boost::format("Setting RX Rate: %f Msps...") % (rate/1e6) << std::endl; radio_ctrl->set_rate(rate); std::cout << boost::format("Actual RX Rate: %f Msps...") % (radio_ctrl->get_rate()/1e6) << std::endl << std::endl; //set the center frequency if (vm.count("freq")) { std::cout << boost::format("Setting RX Freq: %f MHz...") % (freq/1e6) << std::endl; uhd::tune_request_t tune_request(freq); if (vm.count("int-n")) { //tune_request.args = uhd::device_addr_t("mode_n=integer"); TODO } radio_ctrl->set_rx_frequency(freq, radio_chan); std::cout << boost::format("Actual RX Freq: %f MHz...") % (radio_ctrl->get_rx_frequency(radio_chan)/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; radio_ctrl->set_rx_gain(gain, radio_chan); std::cout << boost::format("Actual RX Gain: %f dB...") % radio_ctrl->get_rx_gain(radio_chan) << std::endl << std::endl; } //set the IF filter bandwidth if (vm.count("bw")) { //std::cout << boost::format("Setting RX Bandwidth: %f MHz...") % (bw/1e6) << std::endl; //radio_ctrl->set_rx_bandwidth(bw, radio_chan); // TODO //std::cout << boost::format("Actual RX Bandwidth: %f MHz...") % (radio_ctrl->get_rx_bandwidth(radio_chan)/1e6) << std::endl << std::endl; } //set the antenna if (vm.count("ant")) { radio_ctrl->set_rx_antenna(ant, radio_chan); } boost::this_thread::sleep(boost::posix_time::milliseconds(long(setup_time*1000))); //allow for some setup time //check Ref and LO Lock detect if (not vm.count("skip-lo")){ // TODO //check_locked_sensor(usrp->get_rx_sensor_names(0), "lo_locked", boost::bind(&uhd::usrp::multi_usrp::get_rx_sensor, usrp, _1, radio_id), setup_time); //if (ref == "external") //check_locked_sensor(usrp->get_mboard_sensor_names(0), "ref_locked", boost::bind(&uhd::usrp::multi_usrp::get_mboard_sensor, usrp, _1, radio_id), setup_time); } size_t spp = radio_ctrl->get_arg<int>("spp"); /************************************************************************ * Set up streaming ***********************************************************************/ uhd::device_addr_t streamer_args(streamargs); uhd::rfnoc::graph::sptr tx_graph = usrp->create_graph("rfnoc_tx_from_file"); usrp->clear(); // Set the stream args on the radio: if (block_id.empty()) { // If no extra block is required, connect to the radio: streamer_args["block_id"] = radio_ctrl_id.to_string(); streamer_args["block_port"] = str(boost::format("%d") % radio_chan); } else { // Otherwise, see if the requested block exists and connect it to the radio: if (not usrp->has_block(block_id)) { std::cout << "Block does not exist on current device: " << block_id << std::endl; return EXIT_FAILURE; } uhd::rfnoc::source_block_ctrl_base::sptr blk_ctrl = usrp->get_block_ctrl<uhd::rfnoc::source_block_ctrl_base>(block_id); if (not block_args.empty()) { // Set the block args on the other block: blk_ctrl->set_args(uhd::device_addr_t(block_args)); } // Connect: std::cout << "Connecting " << radio_ctrl_id << " ==> " << blk_ctrl->get_block_id() << std::endl; tx_graph->connect(blk_ctrl->get_block_id(), uhd::rfnoc::ANY_PORT, radio_ctrl_id, radio_chan); streamer_args["block_id"] = blk_ctrl->get_block_id().to_string(); spp = blk_ctrl->get_args().cast<size_t>("spp", spp); } //create a tx streamer std::cout << "Samples per packet: " << spp << std::endl; uhd::stream_args_t stream_args(format, "sc16"); // We should read the wire format from the blocks stream_args.args = streamer_args; stream_args.args["spp"] = boost::lexical_cast<std::string>(spp); std::cout << "Using streamer args: " << stream_args.args.to_string() << std::endl; uhd::tx_streamer::sptr tx_stream = usrp->get_tx_stream(stream_args); if (total_num_samps == 0) { std::signal(SIGINT, &sig_int_handler); std::cout << "Press Ctrl + C to stop streaming..." << std::endl; } #define send_from_file_args() \ (tx_stream, file, spb) //send from file if (format == "fc64")send_from_file<std::complex<double> >send_from_file_args(); else if (format == "fc32")send_from_file<std::complex<float> >send_from_file_args(); else if (format == "sc16")send_from_file<std::complex<short> >send_from_file_args(); else throw std::runtime_error("Unknown data format: " + format); //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
