aboutsummaryrefslogtreecommitdiffstats
path: root/host/examples/gpio.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'host/examples/gpio.cpp')
-rw-r--r--host/examples/gpio.cpp654
1 files changed, 368 insertions, 286 deletions
diff --git a/host/examples/gpio.cpp b/host/examples/gpio.cpp
index 417234881..730cf905f 100644
--- a/host/examples/gpio.cpp
+++ b/host/examples/gpio.cpp
@@ -8,12 +8,12 @@
// Example for GPIO testing and bit banging.
//
-// This example was originally designed to test the 11 bit wide front panel
+// This example was originally designed to test the 12 bit wide front panel
// GPIO on the X300 series and has since been adapted to work with any GPIO
// bank on any USRP and provide optional bit banging. Please excuse the
// clutter. Also, there is no current way to detect the width of the
// specified GPIO bank, so the user must specify the width with the --bits
-// flag if more than 11 bits.
+// flag if more than 12 bits.
//
// GPIO Testing:
// For testing, GPIO bits are set as follows:
@@ -72,13 +72,13 @@
#include <uhd/usrp/multi_usrp.hpp>
#include <uhd/utils/safe_main.hpp>
#include <uhd/utils/thread.hpp>
-#include <stdint.h>
-#include <stdlib.h>
#include <boost/format.hpp>
#include <boost/program_options.hpp>
#include <boost/tokenizer.hpp>
#include <chrono>
#include <csignal>
+#include <cstdint>
+#include <cstdlib>
#include <iostream>
#include <thread>
@@ -87,11 +87,11 @@ static const std::string GPIO_DEFAULT_OTW_FORMAT = "sc16";
static const double GPIO_DEFAULT_RX_RATE = 500e3;
static const double GPIO_DEFAULT_TX_RATE = 500e3;
static const double GPIO_DEFAULT_DWELL_TIME = 2.0;
-static const std::string GPIO_DEFAULT_GPIO = "FP0";
-static const size_t GPIO_DEFAULT_NUM_BITS = 11;
+static const size_t GPIO_DEFAULT_NUM_BITS = 12;
static const std::string GPIO_DEFAULT_CTRL = "0x0"; // all as user controlled
static const std::string GPIO_DEFAULT_DDR = "0x0"; // all as inputs
static const std::string GPIO_DEFAULT_OUT = "0x0";
+constexpr size_t GPIO_MIN_NUM_BITS = 5;
static inline uint32_t GPIO_BIT(const size_t x)
{
@@ -131,7 +131,7 @@ void output_reg_values(const std::string& bank,
for (const auto& attr : attrs) {
const uint32_t gpio_bits = uint32_t(usrp->get_gpio_attr(bank, attr));
std::cout << (boost::format("%10s:%s") % attr
- % to_bit_string(gpio_bits, num_bits))
+ % to_bit_string(gpio_bits, num_bits))
<< std::endl;
}
@@ -150,15 +150,207 @@ void output_reg_values(const std::string& bank,
}
}
+
+bool check_rb_values(const uint32_t rb,
+ uint32_t expected,
+ const uint32_t num_bits,
+ const uint32_t loopback_num_bits)
+{
+ if (loopback_num_bits) {
+ const uint32_t lb_mask = (1 << loopback_num_bits) - 1;
+ expected |= ((expected & lb_mask) << GPIO_MIN_NUM_BITS);
+ }
+ if ((rb & expected) != expected) {
+ std::cout << "fail:" << std::endl;
+ for (size_t bit = 0; bit < num_bits; bit++) {
+ if ((expected & GPIO_BIT(bit)) && ((rb & GPIO_BIT(bit)) == 0)) {
+ std::cout << "Bit " << bit << " should be set, but is not. ";
+ if (loopback_num_bits && bit >= GPIO_MIN_NUM_BITS) {
+ std::cout << "Are GPIO pins correctly looped back?";
+ }
+ std::cout << std::endl;
+ }
+ }
+ return false;
+ }
+ std::cout << "pass:" << std::endl;
+ return true;
+}
+
+
+void run_bitbang_test(uhd::usrp::multi_usrp::sptr usrp,
+ const std::string gpio_bank,
+ const std::string port,
+ const uint32_t ddr,
+ const uint32_t out,
+ const uint32_t mask,
+ const uint32_t num_bits,
+ const std::chrono::milliseconds dwell_time)
+{
+ // Set all pins to "GPIO", and DDR/OUT to whatever the user requested
+ usrp->set_gpio_attr(gpio_bank, "CTRL", 0, mask);
+ usrp->set_gpio_attr(gpio_bank, "DDR", ddr, mask);
+ usrp->set_gpio_attr(gpio_bank, "OUT", out, mask);
+
+ // print out initial state of GPIO
+ std::cout << "\nConfigured GPIO values:" << std::endl;
+ output_reg_values(gpio_bank, port, usrp, num_bits);
+ std::cout << std::endl;
+ std::signal(SIGINT, &sig_int_handler);
+
+ while (not stop_signal_called) {
+ // dwell and continuously read back GPIO values
+ auto stop_time = std::chrono::steady_clock::now() + dwell_time;
+ while (not stop_signal_called and std::chrono::steady_clock::now() < stop_time) {
+ std::cout << "\rREADBACK: "
+ << to_bit_string(
+ usrp->get_gpio_attr(gpio_bank, "READBACK"), num_bits);
+ std::this_thread::sleep_for(std::chrono::milliseconds(10));
+ }
+ std::cout << std::endl;
+ }
+}
+
+
+struct stream_helper_type
+{
+ stream_helper_type(uhd::usrp::multi_usrp::sptr usrp,
+ double rx_rate,
+ double tx_rate,
+ const std::string& cpu,
+ const std::string& otw,
+ const std::chrono::milliseconds dwell_time)
+ : rx_args(cpu, otw), tx_args(cpu, otw), dwell_time(dwell_time)
+ {
+ rx_cmd.stream_now = true;
+
+ if (usrp->get_rx_num_channels()) {
+ rx_stream = usrp->get_rx_stream(rx_args);
+ usrp->set_rx_rate(rx_rate);
+ }
+ if (usrp->get_tx_num_channels()) {
+ tx_stream = usrp->get_tx_stream(tx_args);
+ usrp->set_tx_rate(tx_rate);
+ }
+
+ const size_t rx_spp = rx_stream ? rx_stream->get_max_num_samps() : 0;
+ const size_t tx_spp = tx_stream ? tx_stream->get_max_num_samps() : 0;
+ nsamps_per_buff = std::max(rx_spp, tx_spp);
+
+ if (rx_stream) {
+ rx_buff.resize(nsamps_per_buff * uhd::convert::get_bytes_per_item(cpu));
+ for (size_t ch = 0; ch < rx_stream->get_num_channels(); ch++) {
+ rx_buffs.push_back(&rx_buff.front()); // same buffer for each channel
+ }
+ }
+ if (tx_stream) {
+ tx_buff.resize(nsamps_per_buff * uhd::convert::get_bytes_per_item(cpu));
+ for (size_t ch = 0; ch < tx_stream->get_num_channels(); ch++)
+ tx_buffs.push_back(&tx_buff.front()); // same buffer for each channel
+ }
+
+ tx_md.has_time_spec = false;
+ tx_md.start_of_burst = true;
+ }
+
+ void start_stream(bool tx, bool rx)
+ {
+ if (tx && rx) {
+ rx_cmd.stream_mode = uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS;
+ rx_stream->issue_stream_cmd(rx_cmd);
+ tx_md.start_of_burst = true;
+ tx_md.end_of_burst = false;
+ auto stop_time = std::chrono::steady_clock::now() + dwell_time;
+ while (
+ not stop_signal_called and std::chrono::steady_clock::now() < stop_time) {
+ try {
+ tx_stream->send(tx_buffs, nsamps_per_buff, tx_md, timeout);
+ tx_md.start_of_burst = false;
+ rx_stream->recv(rx_buffs, nsamps_per_buff, rx_md, timeout);
+ } catch (...) {
+ }
+ }
+ return;
+ }
+
+ if (tx) {
+ auto stop_time = std::chrono::steady_clock::now() + dwell_time;
+ tx_md.start_of_burst = true;
+ tx_md.end_of_burst = false;
+ while (
+ not stop_signal_called and std::chrono::steady_clock::now() < stop_time) {
+ try {
+ tx_stream->send(tx_buffs, nsamps_per_buff, tx_md, timeout);
+ tx_md.start_of_burst = false;
+ } catch (...) {
+ }
+ }
+ }
+
+ if (rx) {
+ rx_cmd.stream_mode = uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS;
+ rx_stream->issue_stream_cmd(rx_cmd);
+ auto stop_time = std::chrono::steady_clock::now() + dwell_time;
+ while (
+ not stop_signal_called and std::chrono::steady_clock::now() < stop_time) {
+ try {
+ rx_stream->recv(rx_buffs, nsamps_per_buff, rx_md, timeout);
+ } catch (...) {
+ }
+ }
+ }
+ }
+
+ void stop_stream(bool tx, bool rx)
+ {
+ if (tx) {
+ tx_md.end_of_burst = true;
+ try {
+ tx_stream->send(tx_buffs, nsamps_per_buff, tx_md, timeout);
+ } catch (...) {
+ }
+ }
+ if (rx) {
+ rx_stream->issue_stream_cmd(uhd::stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS);
+ // clear out any data left in the rx stream
+ try {
+ rx_stream->recv(rx_buffs, nsamps_per_buff, rx_md, timeout);
+ } catch (...) {
+ }
+ }
+ }
+
+ uhd::stream_args_t rx_args;
+ uhd::stream_args_t tx_args;
+ uhd::rx_streamer::sptr rx_stream;
+ uhd::tx_streamer::sptr tx_stream;
+ uhd::stream_cmd_t rx_cmd{uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS};
+
+ size_t nsamps_per_buff;
+ std::vector<char> rx_buff;
+ std::vector<char> tx_buff;
+ std::vector<void*> rx_buffs, tx_buffs;
+
+ uhd::rx_metadata_t rx_md;
+ uhd::tx_metadata_t tx_md;
+
+ double timeout = 0.01;
+
+ const std::chrono::milliseconds dwell_time;
+};
+
+
int UHD_SAFE_MAIN(int argc, char* argv[])
{
// variables to be set by po
std::string args;
std::string cpu, otw;
double rx_rate, tx_rate, dwell;
- std::string gpio;
+ // This is the argument for set_gpio_attr(), not the connector name:
+ std::string gpio_bank;
std::string port;
size_t num_bits;
+ uint32_t loopback_num_bits = 0;
std::string src_str;
std::string ctrl_str;
std::string ddr_str;
@@ -175,16 +367,17 @@ int UHD_SAFE_MAIN(int argc, char* argv[])
("tx_subdev_spec", po::value<std::string>(&tx_subdev_spec)->default_value(""), "A:0, B:0, or A:0 B:0")
("rx_subdev_spec", po::value<std::string>(&rx_subdev_spec)->default_value(""), "A:0, B:0, or A:0 B:0")
("repeat", "repeat loop until Ctrl-C is pressed")
- ("list-banks", "print list of banks before running tests")
+ ("list_banks", "print list of banks before running tests")
("cpu", po::value<std::string>(&cpu)->default_value(GPIO_DEFAULT_CPU_FORMAT), "cpu data format")
("otw", po::value<std::string>(&otw)->default_value(GPIO_DEFAULT_OTW_FORMAT), "over the wire data format")
("rx_rate", po::value<double>(&rx_rate)->default_value(GPIO_DEFAULT_RX_RATE), "rx sample rate")
("tx_rate", po::value<double>(&tx_rate)->default_value(GPIO_DEFAULT_TX_RATE), "tx sample rate")
("dwell", po::value<double>(&dwell)->default_value(GPIO_DEFAULT_DWELL_TIME), "dwell time in seconds for each test case")
- ("bank", po::value<std::string>(&gpio)->default_value(GPIO_DEFAULT_GPIO), "name of gpio bank")
- ("port", po::value<std::string>(&port)->default_value(""), "name of gpio port. If not specified, defaults to the GPIO bank")
+ ("bank", po::value<std::string>(&gpio_bank)->default_value(""), "name of gpio bank (defaults to first bank in list)")
+ ("port", po::value<std::string>(&port)->default_value(""), "name of gpio port (source bank). If not specified, defaults to the first bank")
("bits", po::value<size_t>(&num_bits)->default_value(GPIO_DEFAULT_NUM_BITS), "number of bits in gpio bank")
("bitbang", "single test case where user sets values for CTRL, DDR, and OUT registers")
+ ("check_loopback", "check that lower half of pins is looped back onto upper half")
("src", po::value<std::string>(&src_str), "GPIO SRC reg value")
("ddr", po::value<std::string>(&ddr_str)->default_value(GPIO_DEFAULT_DDR), "GPIO DDR reg value")
("out", po::value<std::string>(&out_str)->default_value(GPIO_DEFAULT_OUT), "GPIO OUT reg value")
@@ -194,48 +387,74 @@ int UHD_SAFE_MAIN(int argc, char* argv[])
po::store(po::parse_command_line(argc, argv, desc), vm);
po::notify(vm);
+ /*** Sanity-check arguments **********************************************/
// print the help message
if (vm.count("help")) {
- std::cout << boost::format("gpio %s") % desc << std::endl;
- return ~0;
+ std::cout << "gpio " << desc << std::endl;
+ return EXIT_SUCCESS;
+ }
+ if (vm.count("check_loopback")) {
+ // For a proper test, we need at least 5 pins (4xATR + 1xGPIO). That
+ // means we also want at *most* 5 pins to be looped back for this test.
+ if (num_bits <= GPIO_MIN_NUM_BITS) {
+ loopback_num_bits = 0;
+ } else {
+ loopback_num_bits = std::min(GPIO_MIN_NUM_BITS, num_bits - GPIO_MIN_NUM_BITS);
+ }
+ std::cout << "Checking external GPIO loopback! Expecting the following external "
+ "connections: "
+ << std::endl;
+ for (size_t gpio = 0; gpio + loopback_num_bits < num_bits; ++gpio) {
+ std::cout << "GPIO " << gpio << " --> " << gpio + loopback_num_bits
+ << std::endl;
+ }
}
+ const auto dwell_time = std::chrono::milliseconds(static_cast<int64_t>(dwell * 1000));
+
+ /*** Set up USRP device and GPIO banks ************************************/
+ std::cout << std::endl;
+ std::cout << "Creating the usrp device with: " << args << "..." << std::endl;
+ auto usrp = uhd::usrp::multi_usrp::make(args);
+ std::cout << "Using Device: " << usrp->get_pp_string() << std::endl;
// Handle if the port is unspecified
if (port.empty()) {
- port = gpio;
+ port = usrp->get_gpio_src_banks(0).front();
}
+ if (gpio_bank.empty()) {
+ gpio_bank = usrp->get_gpio_banks(0).front();
+ }
+ std::cout << "Using GPIO connector: " << port << std::endl;
- // 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;
-
- if (vm.count("list-banks")) {
+ if (vm.count("list_banks")) {
std::cout << "Available GPIO banks: " << std::endl;
auto banks = usrp->get_gpio_banks(0);
for (auto& bank : banks) {
std::cout << "* " << bank << std::endl;
}
}
- std::cout << "Using GPIO bank: " << gpio << std::endl;
-
+ std::cout << "Using GPIO bank: " << gpio_bank << std::endl;
// subdev spec
if (!tx_subdev_spec.empty())
usrp->set_tx_subdev_spec(tx_subdev_spec);
if (!rx_subdev_spec.empty())
usrp->set_rx_subdev_spec(rx_subdev_spec);
- std::cout << boost::format(" rx_subdev_spec: %s")
- % usrp->get_rx_subdev_spec(0).to_string()
+ std::cout << " rx_subdev_spec: " << usrp->get_rx_subdev_spec(0).to_string()
<< std::endl;
- std::cout << boost::format(" tx_subdev_spec: %s")
- % usrp->get_tx_subdev_spec(0).to_string()
+ std::cout << " tx_subdev_spec: " << usrp->get_tx_subdev_spec(0).to_string()
<< std::endl;
+ // set GPIO driver source
+ if (vm.count("src")) {
+ std::vector<std::string> gpio_src;
+ typedef boost::char_separator<char> separator;
+ boost::tokenizer<separator> tokens(src_str, separator(" "));
+ std::copy(tokens.begin(), tokens.end(), std::back_inserter(gpio_src));
+ usrp->set_gpio_src(port, gpio_src);
+ }
// print out initial unconfigured state of GPIO
std::cout << "Initial GPIO values:" << std::endl;
- output_reg_values(gpio, port, usrp, num_bits);
+ output_reg_values(gpio_bank, port, usrp, num_bits);
// configure GPIO registers
uint32_t ddr = strtoul(ddr_str.c_str(), NULL, 0);
@@ -247,299 +466,162 @@ int UHD_SAFE_MAIN(int argc, char* argv[])
uint32_t atr_duplex = 0;
uint32_t mask = (1 << num_bits) - 1;
- if (!vm.count("bitbang")) {
- // set up GPIO outputs:
- // GPIO[0] = ATR output 1 at idle
- ctrl |= GPIO_BIT(0);
- atr_idle |= GPIO_BIT(0);
- ddr |= GPIO_BIT(0);
-
- // GPIO[1] = ATR output 1 during RX
- ctrl |= GPIO_BIT(1);
- ddr |= GPIO_BIT(1);
- atr_rx |= GPIO_BIT(1);
-
- // GPIO[2] = ATR output 1 during TX
- ctrl |= GPIO_BIT(2);
- ddr |= GPIO_BIT(2);
- atr_tx |= GPIO_BIT(2);
-
- // GPIO[3] = ATR output 1 during full duplex
- ctrl |= GPIO_BIT(3);
- ddr |= GPIO_BIT(3);
- atr_duplex |= GPIO_BIT(3);
-
- // GPIO[4] = output
- ddr |= GPIO_BIT(4);
+ // The bitbang test is its own thing
+ if (vm.count("bitbang")) {
+ run_bitbang_test(usrp, gpio_bank, port, ddr, out, mask, num_bits, dwell_time);
+ return EXIT_SUCCESS;
}
- // set GPIO driver source
- if (vm.count("src")) {
- std::vector<std::string> gpio_src;
- typedef boost::char_separator<char> separator;
- boost::tokenizer<separator> tokens(src_str, separator(" "));
- std::copy(tokens.begin(), tokens.end(), std::back_inserter(gpio_src));
- usrp->set_gpio_src(port, gpio_src);
- }
+ // set up GPIO outputs:
+ // GPIO[0] = ATR output 1 at idle
+ ctrl |= GPIO_BIT(0);
+ atr_idle |= GPIO_BIT(0);
+ ddr |= GPIO_BIT(0);
+
+ // GPIO[1] = ATR output 1 during RX
+ ctrl |= GPIO_BIT(1);
+ ddr |= GPIO_BIT(1);
+ atr_rx |= GPIO_BIT(1);
+
+ // GPIO[2] = ATR output 1 during TX
+ ctrl |= GPIO_BIT(2);
+ ddr |= GPIO_BIT(2);
+ atr_tx |= GPIO_BIT(2);
+
+ // GPIO[3] = ATR output 1 during full duplex
+ ctrl |= GPIO_BIT(3);
+ ddr |= GPIO_BIT(3);
+ atr_duplex |= GPIO_BIT(3);
+
+ // GPIO[4] = output
+ ddr |= GPIO_BIT(4);
// set data direction register (DDR)
- usrp->set_gpio_attr(gpio, "DDR", ddr, mask);
+ usrp->set_gpio_attr(gpio_bank, "DDR", ddr, mask);
// set control register
- usrp->set_gpio_attr(gpio, "CTRL", ctrl, mask);
+ usrp->set_gpio_attr(gpio_bank, "CTRL", ctrl, mask);
// set output values (OUT)
- usrp->set_gpio_attr(gpio, "OUT", out, mask);
+ usrp->set_gpio_attr(gpio_bank, "OUT", out, mask);
// set ATR registers
- usrp->set_gpio_attr(gpio, "ATR_0X", atr_idle, mask);
- usrp->set_gpio_attr(gpio, "ATR_RX", atr_rx, mask);
- usrp->set_gpio_attr(gpio, "ATR_TX", atr_tx, mask);
- usrp->set_gpio_attr(gpio, "ATR_XX", atr_duplex, mask);
+ usrp->set_gpio_attr(gpio_bank, "ATR_0X", atr_idle, mask);
+ usrp->set_gpio_attr(gpio_bank, "ATR_RX", atr_rx, mask);
+ usrp->set_gpio_attr(gpio_bank, "ATR_TX", atr_tx, mask);
+ usrp->set_gpio_attr(gpio_bank, "ATR_XX", atr_duplex, mask);
// print out initial state of FP GPIO
std::cout << "\nConfigured GPIO values:" << std::endl;
- output_reg_values(gpio, port, usrp, num_bits);
+ output_reg_values(gpio_bank, port, usrp, num_bits);
std::cout << std::endl;
// set up streams
- uhd::stream_args_t rx_args(cpu, otw);
- uhd::stream_args_t tx_args(cpu, otw);
- uhd::rx_streamer::sptr rx_stream;
- uhd::tx_streamer::sptr tx_stream;
- uhd::stream_cmd_t rx_cmd(uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS);
- rx_cmd.stream_now = true;
- if (usrp->get_rx_num_channels()) {
- rx_stream = usrp->get_rx_stream(rx_args);
- usrp->set_rx_rate(rx_rate);
- }
- if (usrp->get_tx_num_channels()) {
- tx_stream = usrp->get_tx_stream(tx_args);
- usrp->set_tx_rate(tx_rate);
- }
-
- // set up buffers for tx and rx
- const size_t rx_spp = rx_stream ? rx_stream->get_max_num_samps() : 0;
- const size_t tx_spp = tx_stream ? tx_stream->get_max_num_samps() : 0;
- const size_t nsamps_per_buff = std::max(rx_spp, tx_spp);
- std::vector<char> rx_buff(nsamps_per_buff * uhd::convert::get_bytes_per_item(cpu));
- std::vector<char> tx_buff(nsamps_per_buff * uhd::convert::get_bytes_per_item(cpu));
- std::vector<void*> rx_buffs, tx_buffs;
- if (rx_stream) {
- for (size_t ch = 0; ch < rx_stream->get_num_channels(); ch++) {
- rx_buffs.push_back(&rx_buff.front()); // same buffer for each channel
- }
- }
- if (tx_stream) {
- for (size_t ch = 0; ch < tx_stream->get_num_channels(); ch++)
- tx_buffs.push_back(&tx_buff.front()); // same buffer for each channel
- }
-
- uhd::rx_metadata_t rx_md;
- uhd::tx_metadata_t tx_md;
- tx_md.has_time_spec = false;
- tx_md.start_of_burst = true;
- double timeout = 0.01;
- auto dwell_time = std::chrono::milliseconds(static_cast<int64_t>(dwell * 1000));
+ stream_helper_type stream_helper(usrp, rx_rate, tx_rate, cpu, otw, dwell_time);
- int loop = 0;
- uint32_t rb, expected;
+ int loop = 0;
+ int failures = 0;
+ bool tests_failed = false;
// register signal handler
std::signal(SIGINT, &sig_int_handler);
- if (!vm.count("bitbang")) {
- // Test the mask parameter of the multi_usrp::set_gpio_attr API
- // We only need to test once with no dwell time
- std::cout << "\nTesting mask..." << std::flush;
- // send a value of all 1's to the DDR with a mask for only upper most bit
- usrp->set_gpio_attr(gpio, "DDR", ~0, GPIO_BIT(num_bits - 1));
- // upper most bit should now be 1, but all the other bits should be unchanged
- rb = usrp->get_gpio_attr(gpio, "DDR") & mask;
- expected = ddr | GPIO_BIT(num_bits - 1);
- if (rb == expected)
- std::cout << "pass:" << std::endl;
- else
- std::cout << "fail:" << std::endl;
- output_reg_values(gpio, port, usrp, num_bits);
- // restore DDR value
- usrp->set_gpio_attr(gpio, "DDR", ddr, mask);
- }
-
+ // Test the mask parameter of the multi_usrp::set_gpio_attr API
+ // We only need to test once with no dwell time
+ std::cout << "\nTesting mask..." << std::flush;
+ // send a value of all 1's to the DDR with a mask for only upper most bit
+ usrp->set_gpio_attr(gpio_bank, "DDR", ~0, GPIO_BIT(num_bits - 1));
+ // upper most bit should now be 1, but all the other bits should be unchanged
+ failures += int(!check_rb_values(usrp->get_gpio_attr(gpio_bank, "DDR") & mask,
+ ddr | GPIO_BIT(num_bits - 1),
+ num_bits, 0));
+ output_reg_values(gpio_bank, port, usrp, num_bits);
+ // restore DDR value
+ usrp->set_gpio_attr(gpio_bank, "DDR", ddr, mask);
+
+ /*************************************************************************/
+ /* Setup complete, start running test */
+ /*************************************************************************/
while (not stop_signal_called) {
- int failures = 0;
-
if (vm.count("repeat"))
std::cout << "Press Ctrl + C to quit..." << std::endl;
- if (vm.count("bitbang")) {
- // dwell and continuously read back GPIO values
- auto stop_time = std::chrono::steady_clock::now() + dwell_time;
- while (
- not stop_signal_called and std::chrono::steady_clock::now() < stop_time) {
- rb = usrp->get_gpio_attr(gpio, "READBACK");
- std::cout << "\rREADBACK: " << to_bit_string(rb, num_bits);
- std::this_thread::sleep_for(std::chrono::milliseconds(10));
- }
- std::cout << std::endl;
- } else {
- // test user controlled GPIO and ATR idle by setting bit 4 high for 1 second
- std::cout << "\nTesting user controlled GPIO and ATR idle output..."
- << std::flush;
- usrp->set_gpio_attr(gpio, "OUT", GPIO_BIT(4), GPIO_BIT(4));
- auto stop_time = std::chrono::steady_clock::now() + dwell_time;
- while (
- not stop_signal_called and std::chrono::steady_clock::now() < stop_time) {
- std::this_thread::sleep_for(std::chrono::milliseconds(100));
- }
- rb = usrp->get_gpio_attr(gpio, "READBACK");
- expected = GPIO_BIT(4) | GPIO_BIT(0);
- if ((rb & expected) != expected) {
- ++failures;
- std::cout << "fail:" << std::endl;
- if ((rb & GPIO_BIT(0)) == 0)
- std::cout << "Bit 0 should be set, but is not" << std::endl;
- if ((rb & GPIO_BIT(4)) == 0)
- std::cout << "Bit 4 should be set, but is not" << std::endl;
- } else {
- std::cout << "pass:" << std::endl;
- }
- output_reg_values(gpio, port, usrp, num_bits);
- usrp->set_gpio_attr(gpio, "OUT", 0, GPIO_BIT(4));
- if (stop_signal_called)
- break;
-
- if (rx_stream) {
- // test ATR RX by receiving for 1 second
- std::cout << "\nTesting ATR RX output..." << std::flush;
- rx_cmd.stream_mode = uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS;
- rx_stream->issue_stream_cmd(rx_cmd);
- stop_time = std::chrono::steady_clock::now() + dwell_time;
- while (not stop_signal_called
- and std::chrono::steady_clock::now() < stop_time) {
- try {
- rx_stream->recv(rx_buffs, nsamps_per_buff, rx_md, timeout);
- } catch (...) {
- }
- }
- rb = usrp->get_gpio_attr(gpio, "READBACK");
- expected = GPIO_BIT(1);
- if ((rb & expected) != expected) {
- ++failures;
- std::cout << "fail:" << std::endl;
- std::cout << "Bit 1 should be set, but is not" << std::endl;
- } else {
- std::cout << "pass:" << std::endl;
- }
- output_reg_values(gpio, port, usrp, num_bits);
- rx_stream->issue_stream_cmd(
- uhd::stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS);
- // clear out any data left in the rx stream
- try {
- rx_stream->recv(rx_buffs, nsamps_per_buff, rx_md, timeout);
- } catch (...) {
- }
- }
- if (stop_signal_called)
- break;
-
- if (tx_stream) {
- // test ATR TX by transmitting for 1 second
- std::cout << "\nTesting ATR TX output..." << std::flush;
- stop_time = std::chrono::steady_clock::now() + dwell_time;
- tx_md.start_of_burst = true;
- tx_md.end_of_burst = false;
- while (not stop_signal_called
- and std::chrono::steady_clock::now() < stop_time) {
- try {
- tx_stream->send(tx_buffs, nsamps_per_buff, tx_md, timeout);
- tx_md.start_of_burst = false;
- } catch (...) {
- }
- }
- rb = usrp->get_gpio_attr(gpio, "READBACK");
- expected = GPIO_BIT(2);
- if ((rb & expected) != expected) {
- ++failures;
- std::cout << "fail:" << std::endl;
- std::cout << "Bit 2 should be set, but is not" << std::endl;
- } else {
- std::cout << "pass:" << std::endl;
- }
- output_reg_values(gpio, port, usrp, num_bits);
- tx_md.end_of_burst = true;
- try {
- tx_stream->send(tx_buffs, nsamps_per_buff, tx_md, timeout);
- } catch (...) {
- }
- }
- if (stop_signal_called)
- break;
-
- if (rx_stream and tx_stream) {
- // test ATR full duplex by transmitting and receiving
- std::cout << "\nTesting ATR full duplex output..." << std::flush;
- rx_cmd.stream_mode = uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS;
- rx_stream->issue_stream_cmd(rx_cmd);
- tx_md.start_of_burst = true;
- tx_md.end_of_burst = false;
- stop_time = std::chrono::steady_clock::now() + dwell_time;
- while (not stop_signal_called
- and std::chrono::steady_clock::now() < stop_time) {
- try {
- tx_stream->send(tx_buffs, nsamps_per_buff, tx_md, timeout);
- tx_md.start_of_burst = false;
- rx_stream->recv(rx_buffs, nsamps_per_buff, rx_md, timeout);
- } catch (...) {
- }
- }
-
- // Read GPIO
- rb = usrp->get_gpio_attr(gpio, "READBACK");
+ /*** Test 1: User-controlled GPIO + ATR idle *************************/
+ std::cout << "\nTesting user controlled GPIO and ATR idle output..."
+ << std::flush;
+ usrp->set_gpio_attr(gpio_bank, "OUT", GPIO_BIT(4), GPIO_BIT(4));
+ auto stop_time = std::chrono::steady_clock::now() + dwell_time;
+ while (not stop_signal_called and std::chrono::steady_clock::now() < stop_time) {
+ std::this_thread::sleep_for(std::chrono::milliseconds(100));
+ }
+ failures += int(!check_rb_values(usrp->get_gpio_attr(gpio_bank, "READBACK"),
+ GPIO_BIT(4) | GPIO_BIT(0),
+ num_bits, loopback_num_bits));
+ output_reg_values(gpio_bank, port, usrp, num_bits);
+ usrp->set_gpio_attr(gpio_bank, "OUT", 0, GPIO_BIT(4));
+ if (stop_signal_called)
+ break;
- // Stop streaming
- rx_stream->issue_stream_cmd(
- uhd::stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS);
- tx_md.end_of_burst = true;
- try {
- tx_stream->send(tx_buffs, nsamps_per_buff, tx_md, timeout);
- } catch (...) {
- }
+ /*** Test 2: ATR RX **************************************************/
+ if (stream_helper.rx_stream) {
+ // test ATR RX by receiving for 1 second
+ std::cout << "\nTesting ATR RX output..." << std::flush;
+ stream_helper.start_stream(false, true);
+ failures += int(!check_rb_values(usrp->get_gpio_attr(gpio_bank, "READBACK"),
+ GPIO_BIT(1),
+ num_bits, loopback_num_bits));
+ output_reg_values(gpio_bank, port, usrp, num_bits);
+ stream_helper.stop_stream(false, true);
+ }
+ if (stop_signal_called)
+ break;
- // clear out any data left in the rx stream
- try {
- rx_stream->recv(rx_buffs, nsamps_per_buff, rx_md, timeout);
- } catch (...) {
- }
+ /*** Test 3: ATR TX **************************************************/
+ if (stream_helper.tx_stream) {
+ // test ATR TX by transmitting for 1 second
+ std::cout << "\nTesting ATR TX output..." << std::flush;
+ stream_helper.start_stream(true, false);
+ failures += int(!check_rb_values(usrp->get_gpio_attr(gpio_bank, "READBACK"),
+ GPIO_BIT(2),
+ num_bits, loopback_num_bits));
+ output_reg_values(gpio_bank, port, usrp, num_bits);
+ stream_helper.stop_stream(true, false);
+ }
+ if (stop_signal_called)
+ break;
- // Analyze results
- expected = GPIO_BIT(3);
- if ((rb & expected) != expected) {
- ++failures;
- std::cout << "fail:" << std::endl;
- std::cout << "Bit 3 should be set, but is not" << std::endl;
- } else {
- std::cout << "pass:" << std::endl;
- }
- output_reg_values(gpio, port, usrp, num_bits);
- }
+ /*** Test 4: ATR FDX *************************************************/
+ if (stream_helper.rx_stream and stream_helper.tx_stream) {
+ // test ATR full duplex by transmitting and receiving
+ std::cout << "\nTesting ATR full duplex output..." << std::flush;
+ stream_helper.start_stream(true, true);
+ failures += int(!check_rb_values(usrp->get_gpio_attr(gpio_bank, "READBACK"),
+ GPIO_BIT(3),
+ num_bits, loopback_num_bits));
+ stream_helper.stop_stream(true, true);
+ output_reg_values(gpio_bank, port, usrp, num_bits);
+ }
- std::cout << std::endl;
- if (failures)
- std::cout << failures << " tests failed" << std::endl;
- else
- std::cout << "All tests passed!" << std::endl;
+ std::cout << std::endl;
+ if (failures) {
+ tests_failed = true;
+ std::cout << failures << " tests failed" << std::endl;
+ } else {
+ std::cout << "All tests passed!" << std::endl;
}
- if (!vm.count("repeat"))
+ if (!vm.count("repeat")) {
break;
+ }
+ failures = 0;
- if (not stop_signal_called)
- std::cout << (boost::format("\nLoop %d completed") % ++loop) << std::endl;
+ if (not stop_signal_called) {
+ std::cout << "\nLoop " << ++loop << " completed" << std::endl;
+ }
}
// finished
std::cout << std::endl << "Done!" << std::endl << std::endl;
- return EXIT_SUCCESS;
+ return int(tests_failed);
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-26 05:35:18 +0000