mirror of
https://github.com/saymrwulf/uhd.git
synced 2026-05-16 21:10:10 +00:00
5c6c179689
Mboard eeprom map class can parse the setting (4 byte float). The clock control will try to set the eeprom rate if present, otherwise or under failure condition, it sets the default. Updated docs, example, and provided helpful verbose. I would prefer that users burn the desired rate to the eeprom (and they may too).
126 lines
4.8 KiB
C++
126 lines
4.8 KiB
C++
//
|
|
// Copyright 2010-2011 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/utils/thread_priority.hpp>
|
|
#include <uhd/utils/safe_main.hpp>
|
|
#include <uhd/usrp/multi_usrp.hpp>
|
|
#include <boost/program_options.hpp>
|
|
#include <boost/format.hpp>
|
|
#include <iostream>
|
|
#include <complex>
|
|
|
|
namespace po = boost::program_options;
|
|
|
|
int UHD_SAFE_MAIN(int argc, char *argv[]){
|
|
uhd::set_thread_priority_safe();
|
|
|
|
//variables to be set by po
|
|
std::string args;
|
|
double seconds_in_future;
|
|
size_t total_num_samps;
|
|
double rate;
|
|
|
|
//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")
|
|
("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")
|
|
;
|
|
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;
|
|
|
|
//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));
|
|
|
|
//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);
|
|
usrp->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(usrp->get_device()->get_max_recv_samps_per_packet());
|
|
|
|
//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 = usrp->get_device()->recv(
|
|
&buff.front(), buff.size(), md,
|
|
uhd::io_type_t::COMPLEX_FLOAT32,
|
|
uhd::device::RECV_MODE_ONE_PACKET, timeout
|
|
);
|
|
|
|
//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(
|
|
"Unexpected error code 0x%x"
|
|
) % md.error_code));
|
|
}
|
|
|
|
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 0;
|
|
}
|