summaryrefslogtreecommitdiffstats
path: root/host/examples
diff options
context:
space:
mode:
Diffstat (limited to 'host/examples')
-rw-r--r--host/examples/benchmark_rate.cpp78
-rw-r--r--host/examples/latency_test.cpp6
-rw-r--r--host/examples/network_relay.cpp5
-rw-r--r--host/examples/rx_ascii_art_dft.cpp13
-rw-r--r--host/examples/rx_multi_samples.cpp24
-rw-r--r--host/examples/rx_samples_to_file.cpp211
-rw-r--r--host/examples/rx_samples_to_udp.cpp4
-rw-r--r--host/examples/rx_timed_samples.cpp4
-rw-r--r--host/examples/test_dboard_coercion.cpp2
-rw-r--r--host/examples/test_messages.cpp22
-rw-r--r--host/examples/test_pps_input.cpp10
-rw-r--r--host/examples/test_timed_commands.cpp4
-rw-r--r--host/examples/transport_hammer.cpp49
-rw-r--r--host/examples/tx_bursts.cpp28
-rw-r--r--host/examples/tx_samples_from_file.cpp2
-rw-r--r--host/examples/tx_timed_samples.cpp4
-rw-r--r--host/examples/tx_waveforms.cpp41
-rw-r--r--host/examples/txrx_loopback_to_file.cpp65
18 files changed, 395 insertions, 177 deletions
diff --git a/host/examples/benchmark_rate.cpp b/host/examples/benchmark_rate.cpp
index 8a000f6c3..3b2ab8a1f 100644
--- a/host/examples/benchmark_rate.cpp
+++ b/host/examples/benchmark_rate.cpp
@@ -1,5 +1,5 @@
//
-// Copyright 2011-2012 Ettus Research LLC
+// Copyright 2011-2013 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
@@ -22,9 +22,11 @@
#include <boost/program_options.hpp>
#include <boost/format.hpp>
#include <boost/thread/thread.hpp>
-#include <boost/math/special_functions/round.hpp>
+#include <boost/algorithm/string.hpp>
+#include <boost/lexical_cast.hpp>
#include <iostream>
#include <complex>
+#include <cstdlib>
namespace po = boost::program_options;
@@ -41,26 +43,20 @@ unsigned long long num_seq_errors = 0;
/***********************************************************************
* Benchmark RX Rate
**********************************************************************/
-void benchmark_rx_rate(uhd::usrp::multi_usrp::sptr usrp, const std::string &rx_cpu, const std::string &rx_otw){
+void benchmark_rx_rate(uhd::usrp::multi_usrp::sptr usrp, const std::string &rx_cpu, uhd::rx_streamer::sptr rx_stream){
uhd::set_thread_priority_safe();
- //create a receive streamer
- uhd::stream_args_t stream_args(rx_cpu, rx_otw);
- for (size_t ch = 0; ch < usrp->get_num_mboards(); ch++) //linear channel mapping
- stream_args.channels.push_back(ch);
- uhd::rx_streamer::sptr rx_stream = usrp->get_rx_stream(stream_args);
-
//print pre-test summary
std::cout << boost::format(
- "Testing receive rate %f Msps"
- ) % (usrp->get_rx_rate()/1e6) << std::endl;
+ "Testing receive rate %f Msps on %u channels"
+ ) % (usrp->get_rx_rate()/1e6) % rx_stream->get_num_channels() << std::endl;
//setup variables and allocate buffer
uhd::rx_metadata_t md;
const size_t max_samps_per_packet = rx_stream->get_max_num_samps();
std::vector<char> buff(max_samps_per_packet*uhd::convert::get_bytes_per_item(rx_cpu));
std::vector<void *> buffs;
- for (size_t ch = 0; ch < stream_args.channels.size(); ch++)
+ for (size_t ch = 0; ch < rx_stream->get_num_channels(); ch++)
buffs.push_back(&buff.front()); //same buffer for each channel
bool had_an_overflow = false;
uhd::time_spec_t last_time;
@@ -69,16 +65,16 @@ void benchmark_rx_rate(uhd::usrp::multi_usrp::sptr usrp, const std::string &rx_c
uhd::stream_cmd_t cmd(uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS);
cmd.time_spec = usrp->get_time_now() + uhd::time_spec_t(0.05);
cmd.stream_now = (buffs.size() == 1);
- usrp->issue_stream_cmd(cmd);
+ rx_stream->issue_stream_cmd(cmd);
while (not boost::this_thread::interruption_requested()){
- num_rx_samps += rx_stream->recv(buffs, max_samps_per_packet, md);
+ num_rx_samps += rx_stream->recv(buffs, max_samps_per_packet, md)*rx_stream->get_num_channels();
//handle the error codes
switch(md.error_code){
case uhd::rx_metadata_t::ERROR_CODE_NONE:
if (had_an_overflow){
had_an_overflow = false;
- num_dropped_samps += boost::math::iround((md.time_spec - last_time).get_real_secs()*rate);
+ num_dropped_samps += (md.time_spec - last_time).to_ticks(rate);
}
break;
@@ -95,25 +91,19 @@ void benchmark_rx_rate(uhd::usrp::multi_usrp::sptr usrp, const std::string &rx_c
}
}
- usrp->issue_stream_cmd(uhd::stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS);
+ rx_stream->issue_stream_cmd(uhd::stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS);
}
/***********************************************************************
* Benchmark TX Rate
**********************************************************************/
-void benchmark_tx_rate(uhd::usrp::multi_usrp::sptr usrp, const std::string &tx_cpu, const std::string &tx_otw){
+void benchmark_tx_rate(uhd::usrp::multi_usrp::sptr usrp, const std::string &tx_cpu, uhd::tx_streamer::sptr tx_stream){
uhd::set_thread_priority_safe();
- //create a transmit streamer
- uhd::stream_args_t stream_args(tx_cpu, tx_otw);
- for (size_t ch = 0; ch < usrp->get_num_mboards(); ch++) //linear channel mapping
- stream_args.channels.push_back(ch);
- uhd::tx_streamer::sptr tx_stream = usrp->get_tx_stream(stream_args);
-
//print pre-test summary
std::cout << boost::format(
- "Testing transmit rate %f Msps"
- ) % (usrp->get_tx_rate()/1e6) << std::endl;
+ "Testing transmit rate %f Msps on %u channels"
+ ) % (usrp->get_tx_rate()/1e6) % tx_stream->get_num_channels() << std::endl;
//setup variables and allocate buffer
uhd::tx_metadata_t md;
@@ -121,12 +111,12 @@ void benchmark_tx_rate(uhd::usrp::multi_usrp::sptr usrp, const std::string &tx_c
const size_t max_samps_per_packet = tx_stream->get_max_num_samps();
std::vector<char> buff(max_samps_per_packet*uhd::convert::get_bytes_per_item(tx_cpu));
std::vector<const void *> buffs;
- for (size_t ch = 0; ch < stream_args.channels.size(); ch++)
+ for (size_t ch = 0; ch < tx_stream->get_num_channels(); ch++)
buffs.push_back(&buff.front()); //same buffer for each channel
md.has_time_spec = (buffs.size() != 1);
while (not boost::this_thread::interruption_requested()){
- num_tx_samps += tx_stream->send(buffs, max_samps_per_packet, md);
+ num_tx_samps += tx_stream->send(buffs, max_samps_per_packet, md)*tx_stream->get_num_channels();;
md.has_time_spec = false;
}
@@ -135,13 +125,13 @@ void benchmark_tx_rate(uhd::usrp::multi_usrp::sptr usrp, const std::string &tx_c
tx_stream->send(buffs, 0, md);
}
-void benchmark_tx_rate_async_helper(uhd::usrp::multi_usrp::sptr usrp){
+void benchmark_tx_rate_async_helper(uhd::tx_streamer::sptr tx_stream){
//setup variables and allocate buffer
uhd::async_metadata_t async_md;
while (not boost::this_thread::interruption_requested()){
- if (not usrp->get_device()->recv_async_msg(async_md)) continue;
+ if (not tx_stream->recv_async_msg(async_md)) continue;
//handle the error codes
switch(async_md.event_code){
@@ -179,6 +169,7 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
std::string rx_otw, tx_otw;
std::string rx_cpu, tx_cpu;
std::string mode;
+ std::string channel_list;
//setup the program options
po::options_description desc("Allowed options");
@@ -193,6 +184,7 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
("rx_cpu", po::value<std::string>(&rx_cpu)->default_value("fc32"), "specify the host/cpu sample mode for RX")
("tx_cpu", po::value<std::string>(&tx_cpu)->default_value("fc32"), "specify the host/cpu sample mode for TX")
("mode", po::value<std::string>(&mode)->default_value("none"), "multi-channel sync mode option: none, mimo")
+ ("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);
@@ -228,17 +220,37 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
boost::thread_group thread_group;
+ //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_tx_num_channels()){
+ throw std::runtime_error("Invalid channel(s) specified.");
+ }
+ else channel_nums.push_back(boost::lexical_cast<int>(channel_strings[ch]));
+ }
+
//spawn the receive test thread
if (vm.count("rx_rate")){
usrp->set_rx_rate(rx_rate);
- thread_group.create_thread(boost::bind(&benchmark_rx_rate, usrp, rx_cpu, rx_otw));
+ //create a receive streamer
+ uhd::stream_args_t stream_args(rx_cpu, rx_otw);
+ stream_args.channels = channel_nums;
+ uhd::rx_streamer::sptr rx_stream = usrp->get_rx_stream(stream_args);
+ thread_group.create_thread(boost::bind(&benchmark_rx_rate, usrp, rx_cpu, rx_stream));
}
//spawn the transmit test thread
if (vm.count("tx_rate")){
usrp->set_tx_rate(tx_rate);
- thread_group.create_thread(boost::bind(&benchmark_tx_rate, usrp, tx_cpu, tx_otw));
- thread_group.create_thread(boost::bind(&benchmark_tx_rate_async_helper, usrp));
+ //create a transmit streamer
+ uhd::stream_args_t stream_args(tx_cpu, tx_otw);
+ stream_args.channels = channel_nums;
+ uhd::tx_streamer::sptr tx_stream = usrp->get_tx_stream(stream_args);
+ thread_group.create_thread(boost::bind(&benchmark_tx_rate, usrp, tx_cpu, tx_stream));
+ thread_group.create_thread(boost::bind(&benchmark_tx_rate_async_helper, tx_stream));
}
//sleep for the required duration
@@ -264,5 +276,5 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
//finished
std::cout << std::endl << "Done!" << std::endl << std::endl;
- return 0;
+ return EXIT_SUCCESS;
}
diff --git a/host/examples/latency_test.cpp b/host/examples/latency_test.cpp
index 518d2383a..da06086f9 100644
--- a/host/examples/latency_test.cpp
+++ b/host/examples/latency_test.cpp
@@ -103,7 +103,7 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
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);
+ rx_stream->issue_stream_cmd(stream_cmd);
/***************************************************************
* Receive the requested packet
@@ -133,7 +133,7 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
* Check the async messages for result
**************************************************************/
uhd::async_metadata_t async_md;
- if (not usrp->get_device()->recv_async_msg(async_md)){
+ if (not tx_stream->recv_async_msg(async_md)){
std::cout << boost::format("failed:\n Async message recv timed out.\n") << std::endl;
continue;
}
@@ -164,5 +164,5 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
**************************************************************/
std::cout << boost::format("\nACK %d, UNDERFLOW %d, TIME_ERR %d, other %d")
% ack % underflow % time_error % other << std::endl;
- return 0;
+ return EXIT_SUCCESS;
}
diff --git a/host/examples/network_relay.cpp b/host/examples/network_relay.cpp
index e8f9e667f..bb09296b3 100644
--- a/host/examples/network_relay.cpp
+++ b/host/examples/network_relay.cpp
@@ -24,6 +24,7 @@
#include <iostream>
#include <csignal>
#include <vector>
+#include <cstdlib>
namespace po = boost::program_options;
namespace asio = boost::asio;
@@ -202,7 +203,7 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
<< "Runs a network relay between UHD on one computer and a USRP on the network.\n"
<< "This example is basically for test purposes. Use at your own convenience.\n"
<< std::endl;
- return ~0;
+ return EXIT_FAILURE;
}
{
@@ -223,5 +224,5 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
//finished
std::cout << std::endl << "Done!" << std::endl << std::endl;
- return 0;
+ return EXIT_SUCCESS;
}
diff --git a/host/examples/rx_ascii_art_dft.cpp b/host/examples/rx_ascii_art_dft.cpp
index fe8fb0347..df3256b09 100644
--- a/host/examples/rx_ascii_art_dft.cpp
+++ b/host/examples/rx_ascii_art_dft.cpp
@@ -25,6 +25,7 @@
#include <curses.h>
#include <iostream>
#include <complex>
+#include <cstdlib>
namespace po = boost::program_options;
@@ -63,7 +64,7 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
//print the help message
if (vm.count("help") or not vm.count("rate")){
std::cout << boost::format("UHD RX ASCII Art DFT %s") % desc << std::endl;
- return ~0;
+ return EXIT_FAILURE;
}
//create a usrp device
@@ -82,7 +83,7 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
//set the sample rate
if (not vm.count("rate")){
std::cerr << "Please specify the sample rate with --rate" << std::endl;
- return ~0;
+ return EXIT_FAILURE;
}
std::cout << boost::format("Setting RX Rate: %f Msps...") % (rate/1e6) << std::endl;
usrp->set_rx_rate(rate);
@@ -91,7 +92,7 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
//set the center frequency
if (not vm.count("freq")){
std::cerr << "Please specify the center frequency with --freq" << std::endl;
- return ~0;
+ return EXIT_FAILURE;
}
std::cout << boost::format("Setting RX Freq: %f MHz...") % (freq/1e6) << std::endl;
usrp->set_rx_freq(freq);
@@ -147,7 +148,7 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
//-- Initialize
//------------------------------------------------------------------
initscr(); //curses init
- usrp->issue_stream_cmd(uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS);
+ rx_stream->issue_stream_cmd(uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS);
boost::system_time next_refresh = boost::get_system_time();
//------------------------------------------------------------------
@@ -188,11 +189,11 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
//------------------------------------------------------------------
//-- Cleanup
//------------------------------------------------------------------
- usrp->issue_stream_cmd(uhd::stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS);
+ rx_stream->issue_stream_cmd(uhd::stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS);
endwin(); //curses done
//finished
std::cout << std::endl << "Done!" << std::endl << std::endl;
- return 0;
+ return EXIT_SUCCESS;
}
diff --git a/host/examples/rx_multi_samples.cpp b/host/examples/rx_multi_samples.cpp
index 42ef33d70..9e5970978 100644
--- a/host/examples/rx_multi_samples.cpp
+++ b/host/examples/rx_multi_samples.cpp
@@ -21,6 +21,8 @@
#include <boost/program_options.hpp>
#include <boost/format.hpp>
#include <boost/thread.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/algorithm/string.hpp>
#include <iostream>
#include <complex>
@@ -30,7 +32,7 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
uhd::set_thread_priority_safe();
//variables to be set by po
- std::string args, sync, subdev;
+ std::string args, sync, subdev, channel_list;
double seconds_in_future;
size_t total_num_samps;
double rate;
@@ -46,6 +48,7 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
("sync", po::value<std::string>(&sync)->default_value("now"), "synchronization method: now, pps, mimo")
("subdev", po::value<std::string>(&subdev), "subdev spec (homogeneous across motherboards)")
("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);
@@ -110,11 +113,22 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
boost::this_thread::sleep(boost::posix_time::milliseconds(100));
}
+ //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_rx_num_channels()){
+ throw std::runtime_error("Invalid channel(s) specified.");
+ }
+ else channel_nums.push_back(boost::lexical_cast<int>(channel_strings[ch]));
+ }
+
//create a receive streamer
//linearly map channels (index0 = channel0, index1 = channel1, ...)
uhd::stream_args_t stream_args("fc32"); //complex floats
- for (size_t chan = 0; chan < usrp->get_rx_num_channels(); chan++)
- stream_args.channels.push_back(chan); //linear mapping
+ stream_args.channels = channel_nums;
uhd::rx_streamer::sptr rx_stream = usrp->get_rx_stream(stream_args);
//setup streaming
@@ -126,7 +140,7 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
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); //tells all channels to stream
+ rx_stream->issue_stream_cmd(stream_cmd); //tells all channels to stream
//meta-data will be filled in by recv()
uhd::rx_metadata_t md;
@@ -174,5 +188,5 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
//finished
std::cout << std::endl << "Done!" << std::endl << std::endl;
- return 0;
+ return EXIT_SUCCESS;
}
diff --git a/host/examples/rx_samples_to_file.cpp b/host/examples/rx_samples_to_file.cpp
index 5197bfe69..b0e498125 100644
--- a/host/examples/rx_samples_to_file.cpp
+++ b/host/examples/rx_samples_to_file.cpp
@@ -38,16 +38,24 @@ template<typename samp_type> void recv_to_file(
const std::string &wire_format,
const std::string &file,
size_t samps_per_buff,
- int num_requested_samples
+ 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
){
- int num_total_samps = 0;
+ 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(file.c_str(), std::ofstream::binary);
+ std::ofstream outfile;
+ if (not null)
+ outfile.open(file.c_str(), std::ofstream::binary);
bool overflow_message = true;
//setup streaming
@@ -58,10 +66,21 @@ template<typename samp_type> void recv_to_file(
stream_cmd.num_samps = num_requested_samples;
stream_cmd.stream_now = true;
stream_cmd.time_spec = uhd::time_spec_t();
- usrp->issue_stream_cmd(stream_cmd);
+ 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)){
- size_t num_rx_samps = rx_stream->recv(&buff.front(), buff.size(), md, 3.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;
@@ -81,17 +100,113 @@ template<typename samp_type> void recv_to_file(
continue;
}
if (md.error_code != uhd::rx_metadata_t::ERROR_CODE_NONE){
- throw std::runtime_error(str(boost::format(
+ std::string error = str(boost::format(
"Unexpected error code 0x%x"
- ) % md.error_code));
+ ) % md.error_code);
+
+ 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;
- outfile.write((const char*)&buff.front(), num_rx_samps*sizeof(samp_type));
+ 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;
+ }
}
+
+ if (outfile.is_open())
+ outfile.close();
+
+ if (stats){
+ std::cout << std::endl;
- outfile.close();
+ 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;
+ }
+ }
+}
+
+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;
}
int UHD_SAFE_MAIN(int argc, char *argv[]){
@@ -100,7 +215,7 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
//variables to be set by po
std::string args, file, type, ant, subdev, ref, wirefmt;
size_t total_num_samps, spb;
- double rate, freq, gain, bw;
+ double rate, freq, gain, bw, total_time, setup_time;
//setup the program options
po::options_description desc("Allowed options");
@@ -110,15 +225,23 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
("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: double, float, or short")
("nsamps", po::value<size_t>(&total_num_samps)->default_value(0), "total number of samples to receive")
+ ("time", po::value<double>(&total_time)->default_value(0), "total number of seconds to receive")
("spb", po::value<size_t>(&spb)->default_value(10000), "samples per buffer")
- ("rate", po::value<double>(&rate), "rate of incoming samples")
- ("freq", po::value<double>(&freq), "RF center frequency in Hz")
+ ("rate", po::value<double>(&rate)->default_value(1e6), "rate of incoming samples")
+ ("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), "daughterboard antenna selection")
("subdev", po::value<std::string>(&subdev), "daughterboard subdevice specification")
("bw", po::value<double>(&bw), "daughterboard IF filter bandwidth in Hz")
("ref", po::value<std::string>(&ref)->default_value("internal"), "waveform type (internal, external, mimo)")
("wirefmt", po::value<std::string>(&wirefmt)->default_value("sc16"), "wire format (sc8 or sc16)")
+ ("setup", po::value<double>(&setup_time)->default_value(1.0), "seconds of setup time")
+ ("progress", "show average bandwidth on exit")
+ ("stats", "periodically display short-term bandwidth")
+ ("sizemap", "track packet size and display breakdown on exit")
+ ("null", "run without writing to file")
+ ("continue", "don't abort on a bad packet")
+ ("skip-lo", "skip checking LO lock status")
;
po::variables_map vm;
po::store(po::parse_command_line(argc, argv, desc), vm);
@@ -129,6 +252,15 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
std::cout << boost::format("UHD RX samples to file %s") % desc << std::endl;
return ~0;
}
+
+ bool bw_summary = vm.count("progress") > 0;
+ bool stats = vm.count("stats") > 0;
+ bool null = vm.count("null") > 0;
+ 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;
//create a usrp device
std::cout << std::endl;
@@ -144,8 +276,8 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
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;
+ if (rate <= 0.0){
+ std::cerr << "Please specify a valid sample rate" << std::endl;
return ~0;
}
std::cout << boost::format("Setting RX Rate: %f Msps...") % (rate/1e6) << std::endl;
@@ -153,13 +285,11 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
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;
+ if (vm.count("freq")){ //with default of 0.0 this will always be true
+ 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")){
@@ -178,41 +308,32 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
//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
+ boost::this_thread::sleep(boost::posix_time::seconds(setup_time)); //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());
- }
+ //check Ref and LO Lock detect
+ if (not vm.count("skip-lo")){
+ check_locked_sensor(usrp->get_rx_sensor_names(0), "lo_locked", boost::bind(&uhd::usrp::multi_usrp::get_rx_sensor, usrp, _1, 0), setup_time);
+ if (ref == "mimo")
+ check_locked_sensor(usrp->get_mboard_sensor_names(0), "mimo_locked", boost::bind(&uhd::usrp::multi_usrp::get_mboard_sensor, usrp, _1, 0), 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, 0), setup_time);
+ }
if (total_num_samps == 0){
std::signal(SIGINT, &sig_int_handler);
std::cout << "Press Ctrl + C to stop streaming..." << std::endl;
}
+#define recv_to_file_args(format) \
+ (usrp, format, wirefmt, file, spb, total_num_samps, total_time, bw_summary, stats, null, enable_size_map, continue_on_bad_packet)
//recv to file
- if (type == "double") recv_to_file<std::complex<double> >(usrp, "fc64", wirefmt, file, spb, total_num_samps);
- else if (type == "float") recv_to_file<std::complex<float> >(usrp, "fc32", wirefmt, file, spb, total_num_samps);
- else if (type == "short") recv_to_file<std::complex<short> >(usrp, "sc16", wirefmt, file, spb, total_num_samps);
+ if (type == "double") recv_to_file<std::complex<double> >recv_to_file_args("fc64");
+ else if (type == "float") recv_to_file<std::complex<float> >recv_to_file_args("fc32");
+ else if (type == "short") recv_to_file<std::complex<short> >recv_to_file_args("sc16");
else throw std::runtime_error("Unknown type " + type);
//finished
std::cout << std::endl << "Done!" << std::endl << std::endl;
- return 0;
+ return EXIT_SUCCESS;
}
diff --git a/host/examples/rx_samples_to_udp.cpp b/host/examples/rx_samples_to_udp.cpp
index 2acaa5d8b..0b3c6dce3 100644
--- a/host/examples/rx_samples_to_udp.cpp
+++ b/host/examples/rx_samples_to_udp.cpp
@@ -127,7 +127,7 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
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);
+ rx_stream->issue_stream_cmd(stream_cmd);
//loop until total number of samples reached
size_t num_acc_samps = 0; //number of accumulated samples
@@ -168,5 +168,5 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
//finished
std::cout << std::endl << "Done!" << std::endl << std::endl;
- return 0;
+ return EXIT_SUCCESS;
}
diff --git a/host/examples/rx_timed_samples.cpp b/host/examples/rx_timed_samples.cpp
index 143bceb03..0eea2ffee 100644
--- a/host/examples/rx_timed_samples.cpp
+++ b/host/examples/rx_timed_samples.cpp
@@ -83,7 +83,7 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
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);
+ rx_stream->issue_stream_cmd(stream_cmd);
//meta-data will be filled in by recv()
uhd::rx_metadata_t md;
@@ -124,5 +124,5 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
//finished
std::cout << std::endl << "Done!" << std::endl << std::endl;
- return 0;
+ return EXIT_SUCCESS;
}
diff --git a/host/examples/test_dboard_coercion.cpp b/host/examples/test_dboard_coercion.cpp
index 5b1e9f0e2..cfc745147 100644
--- a/host/examples/test_dboard_coercion.cpp
+++ b/host/examples/test_dboard_coercion.cpp
@@ -573,5 +573,5 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
if(test_tx and test_rx) std::cout << std::endl;
if(test_rx) std::cout << rx_results << std::endl;
- return 0;
+ return EXIT_SUCCESS;
}
diff --git a/host/examples/test_messages.cpp b/host/examples/test_messages.cpp
index afb092092..e39a8bd30 100644
--- a/host/examples/test_messages.cpp
+++ b/host/examples/test_messages.cpp
@@ -46,7 +46,7 @@ bool test_late_command_message(uhd::usrp::multi_usrp::sptr usrp, uhd::rx_streame
stream_cmd.num_samps = rx_stream->get_max_num_samps();
stream_cmd.stream_now = false;
stream_cmd.time_spec = uhd::time_spec_t(100.0); //time in the past
- usrp->issue_stream_cmd(stream_cmd);
+ rx_stream->issue_stream_cmd(stream_cmd);
std::vector<std::complex<float> > buff(rx_stream->get_max_num_samps());
uhd::rx_metadata_t md;
@@ -90,7 +90,7 @@ bool test_broken_chain_message(uhd::usrp::multi_usrp::sptr usrp, uhd::rx_streame
uhd::stream_cmd_t stream_cmd(uhd::stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_MORE);
stream_cmd.stream_now = true;
stream_cmd.num_samps = rx_stream->get_max_num_samps();
- usrp->issue_stream_cmd(stream_cmd);
+ rx_stream->issue_stream_cmd(stream_cmd);
std::vector<std::complex<float> > buff(rx_stream->get_max_num_samps());
uhd::rx_metadata_t md;
@@ -132,7 +132,7 @@ bool test_broken_chain_message(uhd::usrp::multi_usrp::sptr usrp, uhd::rx_streame
* Send a burst of many samples that will fragment internally.
* We expect to get an burst ack async message.
*/
-bool test_burst_ack_message(uhd::usrp::multi_usrp::sptr usrp, uhd::rx_streamer::sptr, uhd::tx_streamer::sptr tx_stream){
+bool test_burst_ack_message(uhd::usrp::multi_usrp::sptr, uhd::rx_streamer::sptr, uhd::tx_streamer::sptr tx_stream){
std::cout << "Test burst ack message... " << std::flush;
uhd::tx_metadata_t md;
@@ -148,7 +148,7 @@ bool test_burst_ack_message(uhd::usrp::multi_usrp::sptr usrp, uhd::rx_streamer::
);
uhd::async_metadata_t async_md;
- if (not usrp->get_device()->recv_async_msg(async_md)){
+ if (not tx_stream->recv_async_msg(async_md)){
std::cout << boost::format(
"failed:\n"
" Async message recv timed out.\n"
@@ -178,7 +178,7 @@ bool test_burst_ack_message(uhd::usrp::multi_usrp::sptr usrp, uhd::rx_streamer::
* Send a start of burst packet with no following end of burst.
* We expect to get an underflow(within a burst) async message.
*/
-bool test_underflow_message(uhd::usrp::multi_usrp::sptr usrp, uhd::rx_streamer::sptr, uhd::tx_streamer::sptr tx_stream){
+bool test_underflow_message(uhd::usrp::multi_usrp::sptr, uhd::rx_streamer::sptr, uhd::tx_streamer::sptr tx_stream){
std::cout << "Test underflow message... " << std::flush;
uhd::tx_metadata_t md;
@@ -189,7 +189,7 @@ bool test_underflow_message(uhd::usrp::multi_usrp::sptr usrp, uhd::rx_streamer::
tx_stream->send("", 0, md);
uhd::async_metadata_t async_md;
- if (not usrp->get_device()->recv_async_msg(async_md, 1)){
+ if (not tx_stream->recv_async_msg(async_md, 1)){
std::cout << boost::format(
"failed:\n"
" Async message recv timed out.\n"
@@ -233,7 +233,7 @@ bool test_time_error_message(uhd::usrp::multi_usrp::sptr usrp, uhd::rx_streamer:
tx_stream->send("", 0, md);
uhd::async_metadata_t async_md;
- if (not usrp->get_device()->recv_async_msg(async_md)){
+ if (not tx_stream->recv_async_msg(async_md)){
std::cout << boost::format(
"failed:\n"
" Async message recv timed out.\n"
@@ -258,9 +258,9 @@ bool test_time_error_message(uhd::usrp::multi_usrp::sptr usrp, uhd::rx_streamer:
}
}
-void flush_async(uhd::usrp::multi_usrp::sptr usrp){
+void flush_async(uhd::tx_streamer::sptr tx_stream){
uhd::async_metadata_t async_md;
- while (usrp->get_device()->recv_async_msg(async_md)){}
+ while (tx_stream->recv_async_msg(async_md)){}
}
void flush_recv(uhd::rx_streamer::sptr rx_stream){
@@ -331,7 +331,7 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
for (size_t n = 0; n < ntests; n++){
std::string key = tests.keys()[std::rand() % tests.size()];
bool pass = tests[key](usrp, rx_stream, tx_stream);
- flush_async(usrp);
+ flush_async(tx_stream);
flush_recv(rx_stream);
//store result
@@ -350,5 +350,5 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
//finished
std::cout << std::endl << "Done!" << std::endl << std::endl;
- return 0;
+ return EXIT_SUCCESS;
}
diff --git a/host/examples/test_pps_input.cpp b/host/examples/test_pps_input.cpp
index 994b7ca87..889c98a45 100644
--- a/host/examples/test_pps_input.cpp
+++ b/host/examples/test_pps_input.cpp
@@ -31,12 +31,14 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
//variables to be set by po
std::string args;
+ std::string time_source;
//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")
+ ("source", po::value<std::string>(&time_source)->default_value(""), "the time source (gpsdo, external) or blank for default")
;
po::variables_map vm;
po::store(po::parse_command_line(argc, argv, desc), vm);
@@ -54,9 +56,15 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
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;
+ //sleep off if gpsdo detected and time next pps already set
+ boost::this_thread::sleep(boost::posix_time::seconds(1));
+
+ //set time source if specified
+ if (not time_source.empty()) usrp->set_time_source(time_source);
+
//set the time at an unknown pps (will throw if no pps)
std::cout << std::endl << "Attempt to detect the PPS and set the time..." << std::endl << std::endl;
usrp->set_time_unknown_pps(uhd::time_spec_t(0.0));
std::cout << std::endl << "Success!" << std::endl << std::endl;
- return 0;
+ return EXIT_SUCCESS;
}
diff --git a/host/examples/test_timed_commands.cpp b/host/examples/test_timed_commands.cpp
index 05a03e601..224961d04 100644
--- a/host/examples/test_timed_commands.cpp
+++ b/host/examples/test_timed_commands.cpp
@@ -97,7 +97,7 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
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);
- usrp->issue_stream_cmd(stream_cmd);
+ rx_stream->issue_stream_cmd(stream_cmd);
usrp->clear_command_time();
//meta-data will be filled in by recv()
@@ -125,5 +125,5 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
//finished
std::cout << std::endl << "Done!" << std::endl << std::endl;
- return 0;
+ return EXIT_SUCCESS;
}
diff --git a/host/examples/transport_hammer.cpp b/host/examples/transport_hammer.cpp
index e32912eaa..a44e81a82 100644
--- a/host/examples/transport_hammer.cpp
+++ b/host/examples/transport_hammer.cpp
@@ -41,15 +41,9 @@ unsigned long long num_seq_errors = 0;
/***********************************************************************
* RX Hammer
**********************************************************************/
-void rx_hammer(uhd::usrp::multi_usrp::sptr usrp, const std::string &rx_cpu, const std::string &rx_otw){
+void rx_hammer(uhd::usrp::multi_usrp::sptr usrp, const std::string &rx_cpu, uhd::rx_streamer::sptr rx_stream){
uhd::set_thread_priority_safe();
- //create a receive streamer
- uhd::stream_args_t stream_args(rx_cpu, rx_otw);
- for (size_t ch = 0; ch < usrp->get_num_mboards(); ch++) //linear channel mapping
- stream_args.channels.push_back(ch);
- uhd::rx_streamer::sptr rx_stream = usrp->get_rx_stream(stream_args);
-
//print pre-test summary
std::cout << boost::format(
"Testing receive rate %f Msps"
@@ -60,7 +54,7 @@ void rx_hammer(uhd::usrp::multi_usrp::sptr usrp, const std::string &rx_cpu, cons
const size_t max_samps_per_packet = rx_stream->get_max_num_samps();
std::vector<char> buff(max_samps_per_packet*uhd::convert::get_bytes_per_item(rx_cpu));
std::vector<void *> buffs;
- for (size_t ch = 0; ch < stream_args.channels.size(); ch++)
+ for (size_t ch = 0; ch < rx_stream->get_num_channels(); ch++)
buffs.push_back(&buff.front()); //same buffer for each channel
bool had_an_overflow = false;
uhd::time_spec_t last_time;
@@ -74,7 +68,7 @@ void rx_hammer(uhd::usrp::multi_usrp::sptr usrp, const std::string &rx_cpu, cons
while (not boost::this_thread::interruption_requested()){
cmd.num_samps = rand() % 100000;
- usrp->issue_stream_cmd(cmd);
+ rx_stream->issue_stream_cmd(cmd);
num_rx_samps += rx_stream->recv(buffs, max_samps_per_packet, md, timeout, true);
//handle the error codes
@@ -103,16 +97,15 @@ void rx_hammer(uhd::usrp::multi_usrp::sptr usrp, const std::string &rx_cpu, cons
/***********************************************************************
* TX Hammer
**********************************************************************/
-void tx_hammer(uhd::usrp::multi_usrp::sptr usrp, const std::string &tx_cpu, const std::string &tx_otw){
+void tx_hammer(uhd::usrp::multi_usrp::sptr usrp, const std::string &tx_cpu, uhd::tx_streamer::sptr tx_stream){
uhd::set_thread_priority_safe();
- //create a transmit streamer
- uhd::stream_args_t stream_args(tx_cpu, tx_otw);
- for (size_t ch = 0; ch < usrp->get_num_mboards(); ch++) //linear channel mapping
- stream_args.channels.push_back(ch);
- uhd::tx_streamer::sptr tx_stream = usrp->get_tx_stream(stream_args);
uhd::tx_metadata_t md;
- std::vector<std::complex<float> > buff(10000);
+ const size_t max_samps_per_packet = tx_stream->get_max_num_samps();
+ std::vector<char> buff(max_samps_per_packet*uhd::convert::get_bytes_per_item(tx_cpu));
+ std::vector<void *> buffs;
+ for (size_t ch = 0; ch < tx_stream->get_num_channels(); ch++)
+ buffs.push_back(&buff.front()); //same buffer for each channel
//print pre-test summary
std::cout << boost::format(
@@ -130,7 +123,7 @@ void tx_hammer(uhd::usrp::multi_usrp::sptr usrp, const std::string &tx_cpu, cons
while(num_acc_samps < total_num_samps){
//send a single packet
- num_tx_samps += tx_stream->send(&buff, tx_stream->get_max_num_samps(), md, timeout);
+ num_tx_samps += tx_stream->send(buffs, max_samps_per_packet, md, timeout);
num_acc_samps += std::min(total_num_samps-num_acc_samps, tx_stream->get_max_num_samps());
}
@@ -140,13 +133,13 @@ void tx_hammer(uhd::usrp::multi_usrp::sptr usrp, const std::string &tx_cpu, cons
}
}
-void tx_hammer_async_helper(uhd::usrp::multi_usrp::sptr usrp){
+void tx_hammer_async_helper(uhd::tx_streamer::sptr tx_stream){
//setup variables and allocate buffer
uhd::async_metadata_t async_md;
while (not boost::this_thread::interruption_requested()){
- if (not usrp->get_device()->recv_async_msg(async_md)) continue;
+ if (not tx_stream->recv_async_msg(async_md)) continue;
//handle the error codes
switch(async_md.event_code){
@@ -239,14 +232,24 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
//spawn the receive test thread
if (vm.count("rx_rate")){
usrp->set_rx_rate(rx_rate);
- thread_group.create_thread(boost::bind(&rx_hammer, usrp, rx_cpu, rx_otw));
+ //create a receive streamer
+ uhd::stream_args_t stream_args(rx_cpu, rx_otw);
+ for (size_t ch = 0; ch < usrp->get_num_mboards(); ch++) //linear channel mapping
+ stream_args.channels.push_back(ch);
+ uhd::rx_streamer::sptr rx_stream = usrp->get_rx_stream(stream_args);
+ thread_group.create_thread(boost::bind(&rx_hammer, usrp, rx_cpu, rx_stream));
}
//spawn the transmit test thread
if (vm.count("tx_rate")){
usrp->set_tx_rate(tx_rate);
- thread_group.create_thread(boost::bind(&tx_hammer, usrp, tx_cpu, tx_otw));
- thread_group.create_thread(boost::bind(&tx_hammer_async_helper, usrp));
+ //create a transmit streamer
+ uhd::stream_args_t stream_args(tx_cpu, tx_otw);
+ for (size_t ch = 0; ch < usrp->get_num_mboards(); ch++) //linear channel mapping
+ stream_args.channels.push_back(ch);
+ uhd::tx_streamer::sptr tx_stream = usrp->get_tx_stream(stream_args);
+ thread_group.create_thread(boost::bind(&tx_hammer, usrp, tx_cpu, tx_stream));
+ thread_group.create_thread(boost::bind(&tx_hammer_async_helper, tx_stream));
}
//sleep for the required duration
@@ -272,5 +275,5 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
//finished
std::cout << std::endl << "Done!" << std::endl << std::endl;
- return 0;
+ return EXIT_SUCCESS;
}
diff --git a/host/examples/tx_bursts.cpp b/host/examples/tx_bursts.cpp
index 4cf5f2fd1..eada1a618 100644
--- a/host/examples/tx_bursts.cpp
+++ b/host/examples/tx_bursts.cpp
@@ -21,6 +21,8 @@
#include <boost/program_options.hpp>
#include <boost/thread/thread.hpp>
#include <boost/format.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/algorithm/string.hpp>
#include <csignal>
#include <iostream>
#include <complex>
@@ -34,7 +36,7 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
uhd::set_thread_priority_safe();
//variables to be set by po
- std::string args;
+ std::string args, channel_list;
double seconds_in_future;
size_t total_num_samps;
double rate;
@@ -57,6 +59,7 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
("freq", po::value<double>(&freq)->default_value(0), "center frequency")
("gain", po::value<double>(&gain)->default_value(0), "gain")
("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);
@@ -77,17 +80,29 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
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()){
+ throw std::runtime_error("Invalid channel(s) specified.");
+ }
+ else channel_nums.push_back(boost::lexical_cast<int>(channel_strings[ch]));
+ }
+
//set the tx sample rate
std::cout << boost::format("Setting TX Rate: %f Msps...") % (rate/1e6) << std::endl;
usrp->set_tx_rate(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;
- for(size_t i=0; i < usrp->get_tx_num_channels(); i++) usrp->set_tx_freq(freq, i);
+ for(size_t i=0; i < channel_nums.size(); i++) usrp->set_tx_freq(freq, channel_nums[i]);
std::cout << boost::format("Actual TX Freq: %f MHz...") % (usrp->get_tx_freq()/1e6) << std::endl << std::endl;
std::cout << boost::format("Setting TX Gain: %f...") % (gain) << std::endl;
- for(size_t i=0; i < usrp->get_tx_num_channels(); i++) usrp->set_tx_gain(gain, i);
+ for(size_t i=0; i < channel_nums.size(); i++) usrp->set_tx_gain(gain, channel_nums[i]);
std::cout << boost::format("Actual TX Gain: %f...") % (usrp->get_tx_gain()) << std::endl << std::endl;
std::cout << boost::format("Setting device timestamp to 0...") << std::endl;
@@ -95,13 +110,14 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
//create a transmit streamer
uhd::stream_args_t stream_args("fc32"); //complex floats
+ stream_args.channels = channel_nums;
uhd::tx_streamer::sptr tx_stream = usrp->get_tx_stream(stream_args);
//allocate buffer with data to send
const size_t spb = tx_stream->get_max_num_samps();
std::vector<std::complex<float> > buff(spb, std::complex<float>(ampl, ampl));
- std::vector<std::complex<float> *> buffs(usrp->get_tx_num_channels(), &buff.front());
+ std::vector<std::complex<float> *> buffs(channel_nums.size(), &buff.front());
std::signal(SIGINT, &sig_int_handler);
if(repeat) std::cout << "Press Ctrl + C to quit..." << std::endl;
@@ -147,7 +163,7 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
uhd::async_metadata_t async_md;
bool got_async_burst_ack = false;
//loop through all messages for the ACK packet (may have underflow messages in queue)
- while (not got_async_burst_ack and usrp->get_device()->recv_async_msg(async_md, seconds_in_future)){
+ while (not got_async_burst_ack and tx_stream->recv_async_msg(async_md, seconds_in_future)){
got_async_burst_ack = (async_md.event_code == uhd::async_metadata_t::EVENT_CODE_BURST_ACK);
}
std::cout << (got_async_burst_ack? "success" : "fail") << std::endl;
@@ -156,5 +172,5 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
//finished
std::cout << std::endl << "Done!" << std::endl << std::endl;
- return 0;
+ return EXIT_SUCCESS;
}
diff --git a/host/examples/tx_samples_from_file.cpp b/host/examples/tx_samples_from_file.cpp
index 04a6a63d4..f9447c25d 100644
--- a/host/examples/tx_samples_from_file.cpp
+++ b/host/examples/tx_samples_from_file.cpp
@@ -192,5 +192,5 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
//finished
std::cout << std::endl << "Done!" << std::endl << std::endl;
- return 0;
+ return EXIT_SUCCESS;
}
diff --git a/host/examples/tx_timed_samples.cpp b/host/examples/tx_timed_samples.cpp
index 3b8cc75d4..2eef80389 100644
--- a/host/examples/tx_timed_samples.cpp
+++ b/host/examples/tx_timed_samples.cpp
@@ -116,7 +116,7 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
uhd::async_metadata_t async_md;
bool got_async_burst_ack = false;
//loop through all messages for the ACK packet (may have underflow messages in queue)
- while (not got_async_burst_ack and usrp->get_device()->recv_async_msg(async_md, timeout)){
+ while (not got_async_burst_ack and tx_stream->recv_async_msg(async_md, timeout)){
got_async_burst_ack = (async_md.event_code == uhd::async_metadata_t::EVENT_CODE_BURST_ACK);
}
std::cout << (got_async_burst_ack? "success" : "fail") << std::endl;
@@ -124,5 +124,5 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
//finished
std::cout << std::endl << "Done!" << std::endl << std::endl;
- return 0;
+ return EXIT_SUCCESS;
}
diff --git a/host/examples/tx_waveforms.cpp b/host/examples/tx_waveforms.cpp
index 3c5eecd65..9474642df 100644
--- a/host/examples/tx_waveforms.cpp
+++ b/host/examples/tx_waveforms.cpp
@@ -25,6 +25,8 @@
#include <boost/foreach.hpp>
#include <boost/format.hpp>
#include <boost/thread.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/algorithm/string.hpp>
#include <iostream>
#include <complex>
#include <csignal>
@@ -91,7 +93,7 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
uhd::set_thread_priority_safe();
//variables to be set by po
- std::string args, wave_type, ant, subdev, ref, otw;
+ std::string args, wave_type, ant, subdev, ref, otw, channel_list;
size_t spb;
double rate, freq, gain, wave_freq, bw;
float ampl;
@@ -113,6 +115,7 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
("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")
+ ("channels", po::value<std::string>(&channel_list)->default_value("0"), "which channels to use (specify \"0\", \"1\", \"0,1\", etc)")
;
po::variables_map vm;
po::store(po::parse_command_line(argc, argv, desc), vm);
@@ -129,6 +132,19 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
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);
+ //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_tx_num_channels()){
+ throw std::runtime_error("Invalid channel(s) specified.");
+ }
+ else channel_nums.push_back(boost::lexical_cast<int>(channel_strings[ch]));
+ }
+
+
//Lock mboard clocks
usrp->set_clock_source(ref);
@@ -152,27 +168,27 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
return ~0;
}
- for(size_t chan = 0; chan < usrp->get_tx_num_channels(); chan++) {
+ for(size_t ch = 0; ch < channel_nums.size(); ch++) {
std::cout << boost::format("Setting TX Freq: %f MHz...") % (freq/1e6) << std::endl;
- usrp->set_tx_freq(freq, chan);
- std::cout << boost::format("Actual TX Freq: %f MHz...") % (usrp->get_tx_freq(chan)/1e6) << std::endl << std::endl;
+ usrp->set_tx_freq(freq, channel_nums[ch]);
+ std::cout << boost::format("Actual TX Freq: %f MHz...") % (usrp->get_tx_freq(channel_nums[ch])/1e6) << std::endl << std::endl;
//set the rf gain
if (vm.count("gain")){
std::cout << boost::format("Setting TX Gain: %f dB...") % gain << std::endl;
- usrp->set_tx_gain(gain, chan);
- std::cout << boost::format("Actual TX Gain: %f dB...") % usrp->get_tx_gain(chan) << std::endl << std::endl;
+ usrp->set_tx_gain(gain, channel_nums[ch]);
+ std::cout << boost::format("Actual TX Gain: %f dB...") % usrp->get_tx_gain(channel_nums[ch]) << std::endl << std::endl;
}
//set the IF filter bandwidth
if (vm.count("bw")){
std::cout << boost::format("Setting TX Bandwidth: %f MHz...") % bw << std::endl;
- usrp->set_tx_bandwidth(bw, chan);
- std::cout << boost::format("Actual TX Bandwidth: %f MHz...") % usrp->get_tx_bandwidth(chan) << std::endl << std::endl;
+ usrp->set_tx_bandwidth(bw, channel_nums[ch]);
+ std::cout << boost::format("Actual TX Bandwidth: %f MHz...") % usrp->get_tx_bandwidth(channel_nums[ch]) << std::endl << std::endl;
}
//set the antenna
- if (vm.count("ant")) usrp->set_tx_antenna(ant, chan);
+ if (vm.count("ant")) usrp->set_tx_antenna(ant, channel_nums[ch]);
}
boost::this_thread::sleep(boost::posix_time::seconds(1)); //allow for some setup time
@@ -198,14 +214,13 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
//create a transmit streamer
//linearly map channels (index0 = channel0, index1 = channel1, ...)
uhd::stream_args_t stream_args("fc32", otw);
- for (size_t chan = 0; chan < usrp->get_tx_num_channels(); chan++)
- stream_args.channels.push_back(chan); //linear mapping
+ stream_args.channels = channel_nums;
uhd::tx_streamer::sptr tx_stream = 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);
- std::vector<std::complex<float> *> buffs(usrp->get_tx_num_channels(), &buff.front());
+ std::vector<std::complex<float> *> buffs(channel_nums.size(), &buff.front());
//setup the metadata flags
uhd::tx_metadata_t md;
@@ -260,5 +275,5 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
//finished
std::cout << std::endl << "Done!" << std::endl << std::endl;
- return 0;
+ return EXIT_SUCCESS;
}
diff --git a/host/examples/txrx_loopback_to_file.cpp b/host/examples/txrx_loopback_to_file.cpp
index 495c9f7e4..666153edb 100644
--- a/host/examples/txrx_loopback_to_file.cpp
+++ b/host/examples/txrx_loopback_to_file.cpp
@@ -25,6 +25,8 @@
#include <boost/math/special_functions/round.hpp>
#include <boost/foreach.hpp>
#include <boost/format.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/algorithm/string.hpp>
#include <iostream>
#include <fstream>
#include <complex>
@@ -130,11 +132,13 @@ template<typename samp_type> void recv_to_file(
const std::string &file,
size_t samps_per_buff,
int num_requested_samples,
- float settling_time
+ 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;
@@ -151,7 +155,7 @@ template<typename samp_type> void recv_to_file(
stream_cmd.num_samps = num_requested_samples;
stream_cmd.stream_now = false;
stream_cmd.time_spec = uhd::time_spec_t(settling_time);
- usrp->issue_stream_cmd(stream_cmd);
+ 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);
@@ -196,12 +200,12 @@ 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;
+ 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;
+ 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;
float settling;
@@ -234,6 +238,8 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
("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)")
;
po::variables_map vm;
po::store(po::parse_command_line(argc, argv, desc), vm);
@@ -253,6 +259,28 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
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);
+ //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 = boost::lexical_cast<int>(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(boost::lexical_cast<int>(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 = boost::lexical_cast<int>(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(boost::lexical_cast<int>(rx_channel_strings[ch]));
+ }
+
//Lock mboard clocks
tx_usrp->set_clock_source(ref);
rx_usrp->set_clock_source(ref);
@@ -288,27 +316,27 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
return ~0;
}
- for(size_t chan = 0; chan < tx_usrp->get_tx_num_channels(); chan++) {
+ for(size_t ch = 0; ch < tx_channel_nums.size(); ch++) {
std::cout << boost::format("Setting TX Freq: %f MHz...") % (tx_freq/1e6) << std::endl;
- tx_usrp->set_tx_freq(tx_freq, chan);
- std::cout << boost::format("Actual TX Freq: %f MHz...") % (tx_usrp->get_tx_freq(chan)/1e6) << std::endl << std::endl;
+ tx_usrp->set_tx_freq(tx_freq, tx_channel_nums[ch]);
+ std::cout << boost::format("Actual TX Freq: %f MHz...") % (tx_usrp->get_tx_freq(tx_channel_nums[ch])/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, chan);
- std::cout << boost::format("Actual TX Gain: %f dB...") % tx_usrp->get_tx_gain(chan) << std::endl << std::endl;
+ tx_usrp->set_tx_gain(tx_gain, tx_channel_nums[ch]);
+ std::cout << boost::format("Actual TX Gain: %f dB...") % tx_usrp->get_tx_gain(tx_channel_nums[ch]) << std::endl << std::endl;
}
//set the IF 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, chan);
- std::cout << boost::format("Actual TX Bandwidth: %f MHz...") % tx_usrp->get_tx_bandwidth(chan) << std::endl << std::endl;
+ tx_usrp->set_tx_bandwidth(tx_bw, tx_channel_nums[ch]);
+ std::cout << boost::format("Actual TX Bandwidth: %f MHz...") % tx_usrp->get_tx_bandwidth(tx_channel_nums[ch]) << std::endl << std::endl;
}
//set the antenna
- if (vm.count("tx-ant")) tx_usrp->set_tx_antenna(tx_ant, chan);
+ if (vm.count("tx-ant")) tx_usrp->set_tx_antenna(tx_ant, tx_channel_nums[ch]);
}
//set the receive center frequency
@@ -358,14 +386,13 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
//create a transmit streamer
//linearly map channels (index0 = channel0, index1 = channel1, ...)
uhd::stream_args_t stream_args("fc32", otw);
- for (size_t chan = 0; chan < tx_usrp->get_tx_num_channels(); chan++)
- stream_args.channels.push_back(chan); //linear mapping
+ 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_usrp->get_tx_num_channels();
+ int num_channels = tx_channel_nums.size();
//setup the metadata flags
uhd::tx_metadata_t md;
@@ -427,9 +454,9 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
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);
- else if (type == "float") recv_to_file<std::complex<float> >(rx_usrp, "fc32", otw, file, spb, total_num_samps, settling);
- else if (type == "short") recv_to_file<std::complex<short> >(rx_usrp, "sc16", otw, file, spb, total_num_samps, settling);
+ 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;
@@ -443,5 +470,5 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
//finished
std::cout << std::endl << "Done!" << std::endl << std::endl;
- return 0;
+ return EXIT_SUCCESS;
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-15 10:38:10 +0000