Improvements to test_dboard_coercion utility

* Code cleanliness work, removed significant amount of duplicate code
* Improved output for clarity
* Added B2x0 support
* Added channel selection
* Added options to select frequency and gain deltas

1 files changed, 202 insertions, 333 deletions

diff --git a/host/examples/test_dboard_coercion.cpp b/host/examples/test_dboard_coercion.cpp
index 86c59d9d7..e23390506 100644
--- a/host/examples/test_dboard_coercion.cpp
+++ b/host/examples/test_dboard_coercion.cpp
@@ -1,5 +1,5 @@
 //
-// Copyright 2012 Ettus Research LLC
+// Copyright 2012,2014 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
@@ -24,81 +24,95 @@
 #include <boost/math/special_functions/round.hpp>
 #include <iostream>
 #include <complex>
+#include <utility>
 #include <vector>
 
+#define SAMP_RATE 1e6
+
 namespace po = boost::program_options;
 
+typedef std::pair<double, double> double_pair; //BOOST_FOREACH doesn't like commas
+typedef std::vector<std::pair<double, double> > pair_vector;
+
 /************************************************************************
  * Misc functions
 ************************************************************************/
 
-std::string return_MHz_string(double freq){
+std::string MHz_str(double freq){
     std::string nice_string = std::string(str(boost::format("%5.2f MHz") % (freq / 1e6)));
     return nice_string;
 }
 
-std::string return_USRP_config_string(uhd::usrp::multi_usrp::sptr usrp, bool test_tx, bool test_rx){
-    uhd::dict<std::string, std::string> tx_info = usrp->get_usrp_tx_info();
-    uhd::dict<std::string, std::string> rx_info = usrp->get_usrp_rx_info();
+std::string return_usrp_config_string(uhd::usrp::multi_usrp::sptr usrp, int chan, bool test_tx, bool test_rx, bool is_b2xx){
+    uhd::dict<std::string, std::string> tx_info = usrp->get_usrp_tx_info(chan);
+    uhd::dict<std::string, std::string> rx_info = usrp->get_usrp_rx_info(chan);
     std::string info_string;
     std::string mboard_id, mboard_serial;
     std::string tx_serial, tx_subdev_name, tx_subdev_spec;
     std::string rx_serial, rx_subdev_name, rx_subdev_spec;
 
     mboard_id = tx_info.get("mboard_id");
-    if(tx_info.get("mboard_serial") != "") mboard_serial = tx_info.get("mboard_serial");
-    else mboard_serial = "no serial";
+    if(tx_info.get("mboard_serial") == "") mboard_serial = "no serial";
+    else mboard_serial = tx_info.get("mboard_serial");
 
-    info_string = std::string(str(boost::format("Motherboard: %s (%s)\n") % mboard_id % mboard_serial));
+    info_string = str(boost::format("Motherboard: %s (%s)\n") % mboard_id % mboard_serial);
 
     if(test_tx){
-        if(tx_info.get("tx_serial") != "") tx_serial = tx_info.get("tx_serial");
-        else tx_serial = "no serial";
+        if(tx_info.get("tx_serial") == "") tx_serial = "no serial";
+        else tx_serial = tx_info.get("tx_serial");
         tx_subdev_name = tx_info.get("tx_subdev_name");
         tx_subdev_spec = tx_info.get("tx_subdev_spec");
 
-        info_string += std::string(str(boost::format("TX: %s (%s, %s)") % tx_subdev_name % tx_serial % tx_subdev_spec));
+        info_string += is_b2xx ? str(boost::format("TX: %s (%s)")
+                                 % tx_subdev_name % tx_subdev_spec)
+                               : str(boost::format("TX: %s (%s, %s)")
+                                 % tx_subdev_name % tx_serial % tx_subdev_spec);
     }
     if(test_tx and test_rx) info_string += "\n";
     if(test_rx){
-        if(rx_info.get("rx_serial") != "") rx_serial = rx_info.get("rx_serial");
-        else rx_serial = "no serial";
+        if(rx_info.get("rx_serial") == "") rx_serial = "no serial";
+        else rx_serial = rx_info.get("rx_serial");
         rx_subdev_name = rx_info.get("rx_subdev_name");
         rx_subdev_spec = rx_info.get("rx_subdev_spec");
 
-        info_string += std::string(str(boost::format("RX: %s (%s, %s)") % rx_subdev_name % rx_serial % rx_subdev_spec));
+        info_string += is_b2xx ? str(boost::format("RX: %s (%s)")
+                                 % rx_subdev_name % rx_subdev_spec)
+                               : str(boost::format("RX: %s (%s, %s)")
+                                 % rx_subdev_name % rx_serial % rx_subdev_spec);
     }
 
     return info_string;
 }
 
-/************************************************************************
- * TX Frequency/Gain Coercion
-************************************************************************/
+std::string coercion_test(uhd::usrp::multi_usrp::sptr usrp, std::string type, int chan,
+                          bool test_gain, double freq_step, double gain_step, bool verbose){
 
-std::string tx_test(uhd::usrp::multi_usrp::sptr usrp, bool test_gain, bool verbose){
+    //Getting USRP info
+    uhd::dict<std::string, std::string> usrp_info = (type == "TX") ? usrp->get_usrp_tx_info(chan)
+                                                                   : usrp->get_usrp_rx_info(chan);
+    std::string subdev_name = (type == "TX") ? usrp_info.get("tx_subdev_name")
+                                             : usrp_info.get("rx_subdev_name");
+    std::string subdev_spec = (type == "TX") ? usrp_info.get("tx_subdev_spec")
+                                             : usrp_info.get("rx_subdev_spec");
 
     //Establish frequency range
-
     std::vector<double> freqs;
-    std::vector<double> xcvr_freqs;
+    std::vector<double> xcvr_freqs; //XCVR2450 has two ranges
+    uhd::freq_range_t freq_ranges  = (type == "TX") ? usrp->get_fe_tx_freq_range(chan)
+                                                    : usrp->get_fe_rx_freq_range(chan);
+
+    std::cout << boost::format("\nTesting %s coercion...") % type << std::endl;
 
-    BOOST_FOREACH(const uhd::range_t &range, usrp->get_fe_tx_freq_range()){
+    BOOST_FOREACH(const uhd::range_t &range, freq_ranges){
         double freq_begin = range.start();
         double freq_end = range.stop();
-        double freq_step;
 
-        if(usrp->get_usrp_tx_info().get("tx_subdev_name") == "XCVR2450 TX"){
+        if(subdev_name.find("XCVR2450") == 0){
             xcvr_freqs.push_back(freq_begin);
             xcvr_freqs.push_back(freq_end);
         }
 
-        if(freq_end - freq_begin > 1000e6) freq_step = 100e6;
-        else if(freq_end - freq_begin < 300e6) freq_step = 10e6;
-        else freq_step = 50e6;
-
         double current_freq = freq_begin;
-
         while(current_freq < freq_end){
             freqs.push_back(current_freq);
             current_freq += freq_step;
@@ -109,55 +123,66 @@ std::string tx_test(uhd::usrp::multi_usrp::sptr usrp, bool test_gain, bool verbo
     std::vector<double> gains;
 
     if(test_gain){
-
         //Establish gain range
+        uhd::gain_range_t gain_range = (type == "TX") ? usrp->get_tx_gain_range(chan)
+                                                      : usrp->get_rx_gain_range(chan);
 
-        double gain_begin = usrp->get_tx_gain_range().start();
+        double gain_begin = gain_range.start();
+        //Start gain at 0 if range begins negative
         if(gain_begin < 0.0) gain_begin = 0.0;
-        double gain_end = usrp->get_tx_gain_range().stop();
+
+        double gain_end = gain_range.stop();
 
         double current_gain = gain_begin;
         while(current_gain < gain_end){
             gains.push_back(current_gain);
-            current_gain++;
+            current_gain += gain_step;
         }
         gains.push_back(gain_end);
-
     }
 
     //Establish error-storing variables
-
     std::vector<double> bad_tune_freqs;
     std::vector<double> no_lock_freqs;
-    std::vector< std::vector< double > > bad_gain_vals;
-    std::vector<std::string> dboard_sensor_names = usrp->get_tx_sensor_names();
+    pair_vector bad_gain_vals;
+
+    //Sensor names
+    std::vector<std::string> dboard_sensor_names = (type == "TX") ? usrp->get_tx_sensor_names(chan)
+                                                                  : usrp->get_rx_sensor_names(chan);
     std::vector<std::string> mboard_sensor_names = usrp->get_mboard_sensor_names();
+
     bool has_sensor = (std::find(dboard_sensor_names.begin(), dboard_sensor_names.end(), "lo_locked")) != dboard_sensor_names.end();
 
-    for(std::vector<double>::iterator f = freqs.begin(); f != freqs.end(); ++f){
+    BOOST_FOREACH(double freq, freqs){
 
         //Testing for successful frequency tune
+        if(type == "TX") usrp->set_tx_freq(freq,chan);
+        else usrp->set_rx_freq(freq,chan);
 
-        usrp->set_tx_freq(*f);
         boost::this_thread::sleep(boost::posix_time::microseconds(long(1000)));
+        double actual_freq = (type == "TX") ? usrp->get_tx_freq(chan)
+                                            : usrp->get_rx_freq(chan);
 
-        double actual_freq = usrp->get_tx_freq();
-
-        if(*f == 0.0){
+        if(freq == 0.0){
             if(floor(actual_freq + 0.5) == 0.0){
-                if(verbose) std::cout << boost::format("\nTX frequency successfully tuned to %s.") % return_MHz_string(*f) << std::endl;
+                if(verbose) std::cout << boost::format("\n%s frequency successfully tuned to %s.")
+                                         % type % MHz_str(freq) << std::endl;
             }
             else{
-                if(verbose) std::cout << boost::format("\nTX frequency tuned to %s instead of %s.") % return_MHz_string(actual_freq) % return_MHz_string(*f) << std::endl;
+                if(verbose) std::cout << boost::format("\n%s frequency tuned to %s instead of %s.")
+                                         % type % MHz_str(actual_freq) % MHz_str(freq) << std::endl;
+                bad_tune_freqs.push_back(freq);
             }
         }
         else{
-            if((*f / actual_freq > 0.9999) and (*f / actual_freq < 1.0001)){
-                if(verbose) std::cout << boost::format("\nTX frequency successfully tuned to %s.") % return_MHz_string(*f) << std::endl;
+            if((freq / actual_freq > 0.9999) and (freq / actual_freq < 1.0001)){
+                if(verbose) std::cout << boost::format("\n%s frequency successfully tuned to %s.")
+                                         % type % MHz_str(freq) << std::endl;
             }
             else{
-                if(verbose) std::cout << boost::format("\nTX frequency tuned to %s instead of %s.") % return_MHz_string(actual_freq) % return_MHz_string(*f) << std::endl;
-                bad_tune_freqs.push_back(*f);
+                if(verbose) std::cout << boost::format("\n%s frequency tuned to %s instead of %s.")
+                                         % type % MHz_str(actual_freq) % MHz_str(freq) << std::endl;
+                bad_tune_freqs.push_back(freq);
             }
         }
 
@@ -173,11 +198,13 @@ std::string tx_test(uhd::usrp::multi_usrp::sptr usrp, bool test_gain, bool verbo
                 }
             }
             if(is_locked){
-                if(verbose) std::cout << boost::format("LO successfully locked at TX frequency %s.") % return_MHz_string(*f) << std::endl;
+                if(verbose) std::cout << boost::format("LO successfully locked at %s frequency %s.")
+                                         % type % MHz_str(freq) << std::endl;
             }
             else{
-                if(verbose) std::cout << boost::format("LO did not successfully lock at TX frequency %s.") % return_MHz_string(*f) << std::endl;
-                no_lock_freqs.push_back(*f);
+                if(verbose) std::cout << boost::format("LO did not successfully lock at %s frequency %s.")
+                                         % type % MHz_str(freq) << std::endl;
+                no_lock_freqs.push_back(freq);
             }
         }
 
@@ -185,275 +212,101 @@ std::string tx_test(uhd::usrp::multi_usrp::sptr usrp, bool test_gain, bool verbo
 
             //Testing for successful gain tune
 
-            for(std::vector<double>::iterator g = gains.begin(); g != gains.end(); ++g){
-                usrp->set_tx_gain(*g);
+            BOOST_FOREACH(double gain, gains){
+                if(type == "TX") usrp->set_tx_gain(gain,chan);
+                else usrp->set_rx_gain(gain,chan);
+
                 boost::this_thread::sleep(boost::posix_time::microseconds(1000));
 
-                double actual_gain = usrp->get_tx_gain();
+                double actual_gain = (type == "TX") ? usrp->get_tx_gain(chan)
+                                                    : usrp->get_rx_gain(chan);
 
-                if(*g == 0.0){
+                if(gain == 0.0){
                     if(actual_gain == 0.0){
-                        if(verbose) std::cout << boost::format("TX gain successfully set to %5.2f at TX frequency %s.") % *g % return_MHz_string(*f) << std::endl;
+                        if(verbose) std::cout << boost::format("Gain successfully set to %5.2f at %s frequency %s.")
+                                                 % gain % type % MHz_str(freq) << std::endl;
                     }
                     else{
-                        if(verbose) std::cout << boost::format("TX gain set to %5.2f instead of %5.2f at TX frequency %s.") % actual_gain % *g % return_MHz_string(*f) << std::endl;
-                        std::vector<double> bad_gain_freq;
-                        bad_gain_freq.push_back(*f);
-                        bad_gain_freq.push_back(*g);
-                        bad_gain_vals.push_back(bad_gain_freq);
+                        if(verbose) std::cout << boost::format("Gain set to %5.2f instead of %5.2f at %s frequency %s.")
+                                                 % actual_gain % gain % type % MHz_str(freq) << std::endl;
+                        bad_gain_vals.push_back(std::make_pair(freq, gain));
                     }
                 }
                 else{
-                    if((*g / actual_gain) > 0.9 and (*g / actual_gain) < 1.1){
-                        if(verbose) std::cout << boost::format("TX gain successfully set to %5.2f at TX frequency %s.") % *g % return_MHz_string(*f) << std::endl;
+                    if((gain / actual_gain) > 0.9999 and (gain / actual_gain) < 1.0001){
+                        if(verbose) std::cout << boost::format("Gain successfully set to %5.2f at %s frequency %s.")
+                                                 % gain % type % MHz_str(freq) << std::endl;
                     }
                     else{
-                        if(verbose) std::cout << boost::format("TX gain set to %5.2f instead of %5.2f at TX frequency %s.") % actual_gain % *g % return_MHz_string(*f) << std::endl;
-                        std::vector<double> bad_gain_freq;
-                        bad_gain_freq.push_back(*f);
-                        bad_gain_freq.push_back(*g);
-                        bad_gain_vals.push_back(bad_gain_freq);
+                        if(verbose) std::cout << boost::format("Gain set to %5.2f instead of %5.2f at %s frequency %s.")
+                                                 % actual_gain % gain % type % MHz_str(freq) << std::endl;
+                        bad_gain_vals.push_back(std::make_pair(freq, gain));
                     }
                 }
             }
         }
     }
 
-    std::string tx_results = "TX Summary:\n";
-    if(usrp->get_usrp_tx_info().get("tx_subdev_name") == "XCVR2450 TX"){
-        tx_results += std::string(str(boost::format("Frequency Range: %s - %s, %s - %s\n") % return_MHz_string(xcvr_freqs.at(0)) % return_MHz_string(xcvr_freqs.at(1)) %
-            return_MHz_string(xcvr_freqs.at(2)) % return_MHz_string(xcvr_freqs.at(3))));
+    std::string results = str(boost::format("%s Summary:\n") % type);
+    if(subdev_name.find("XCVR2450") == 0){
+        results += str(boost::format("Frequency Range: %s - %s, %s - %s\n")
+                       % MHz_str(xcvr_freqs[0]) % MHz_str(xcvr_freqs[1])
+                       % MHz_str(xcvr_freqs[2]) % MHz_str(xcvr_freqs[3]));
+    }
+    else results += str(boost::format("Frequency Range: %s - %s (Step: %s)\n")
+                        % MHz_str(freqs.front()) % MHz_str(freqs.back()) % MHz_str(freq_step));
+    if(test_gain) results += str(boost::format("Gain Range:%5.2f - %5.2f (Step:%5.2f)\n")
+                             % gains.front() % gains.back() % gain_step);
+
+    if(bad_tune_freqs.empty()) results += "USRP successfully tuned to all frequencies.";
+    else if(bad_tune_freqs.size() > 10 and not verbose){
+        //If tuning fails at many values, don't print them all
+        results += str(boost::format("USRP did not successfully tune at %d frequencies.")
+                       % bad_tune_freqs.size());
     }
-    else tx_results += std::string(str(boost::format("Frequency Range: %s - %s\n") % return_MHz_string(freqs.front()) % return_MHz_string(freqs.back())));
-    if(test_gain) tx_results += std::string(str(boost::format("Gain Range: %5.2f - %5.2f\n") % gains.front() % gains.back()));
-
-    if(bad_tune_freqs.empty()) tx_results += "USRP successfully tuned to all frequencies.";
     else{
-        tx_results += "USRP did not successfully tune to the following frequencies: ";
-        for(std::vector<double>::iterator i = bad_tune_freqs.begin(); i != bad_tune_freqs.end(); ++i){
-            if(i != bad_tune_freqs.begin()) tx_results += ", ";
-            tx_results += return_MHz_string(*i);
+        results += "USRP did not successfully tune to the following frequencies: ";
+        BOOST_FOREACH(double bad_freq, bad_tune_freqs){
+            if(bad_freq != *bad_tune_freqs.begin()) results += ", ";
+            results += MHz_str(bad_freq);
         }
     }
     if(has_sensor){
 
-        tx_results += "\n";
-        if(no_lock_freqs.empty()) tx_results += "LO successfully locked at all frequencies.";
-        else{
-            tx_results += "LO did not lock at the following frequencies: ";
-            for(std::vector<double>::iterator i = no_lock_freqs.begin(); i != no_lock_freqs.end(); ++i){
-                if(i != no_lock_freqs.begin()) tx_results += ", ";
-                tx_results += return_MHz_string(*i);
-            }
+        results += "\n";
+        if(no_lock_freqs.empty()) results += "LO successfully locked at all frequencies.";
+        else if(no_lock_freqs.size() > 10 and not verbose){
+            //If locking fails at many values, don't print them all
+            results += str(boost::format("USRP did not successfully lock at %d frequencies.")
+                           % no_lock_freqs.size());
         }
-    }
-    if(test_gain){
-        tx_results += "\n";
-        if(bad_gain_vals.empty()) tx_results += "USRP successfully set all specified gain values at all frequencies.";
         else{
-            tx_results += "USRP did not successfully set gain under the following circumstances:";
-            for(std::vector< std::vector<double> >::iterator i = bad_gain_vals.begin(); i != bad_gain_vals.end(); ++i){
-                std::vector<double> bad_pair = *i;
-                double bad_freq = bad_pair.front();
-                double bad_gain = bad_pair.back();
-                tx_results += std::string(str(boost::format("\nFrequency: %s, Gain: %5.2f") % return_MHz_string(bad_freq) % bad_gain));
+            results += "LO did not lock at the following frequencies: ";
+            BOOST_FOREACH(double bad_freq, no_lock_freqs){
+                if(bad_freq != *no_lock_freqs.begin()) results += ", ";
+                results += MHz_str(bad_freq);
             }
         }
     }
-
-    return tx_results;
-}
-
-/************************************************************************
- * RX Frequency/Gain Coercion
-************************************************************************/
-
-std::string rx_test(uhd::usrp::multi_usrp::sptr usrp, bool test_gain, bool verbose){
-
-    //Establish frequency range
-
-    std::vector<double> freqs;
-    std::vector<double> xcvr_freqs;
-
-    BOOST_FOREACH(const uhd::range_t &range, usrp->get_fe_rx_freq_range()){
-        double freq_begin = range.start();
-        double freq_end = range.stop();
-
-        if(usrp->get_usrp_rx_info().get("rx_subdev_name") == "XCVR2450 RX"){
-            xcvr_freqs.push_back(freq_begin);
-            xcvr_freqs.push_back(freq_end);
-        }
-
-        double freq_step;
-
-        if(freq_end - freq_begin > 1000e6) freq_step = 100e6;
-        else if(freq_end - freq_begin < 300e6) freq_step = 10e6;
-        else freq_step = 50e6;
-
-        double current_freq = freq_begin;
-
-        while(current_freq < freq_end){
-            freqs.push_back(current_freq);
-            current_freq += freq_step;
-        }
-    }
-
-    std::vector<double> gains;
-
     if(test_gain){
-
-        //Establish gain range
-
-        double gain_begin = usrp->get_rx_gain_range().start();
-        if(gain_begin < 0.0) gain_begin = 0.0;
-        double gain_end = usrp->get_rx_gain_range().stop();
-
-        double current_gain = gain_begin;
-        while(current_gain < gain_end){
-            gains.push_back(current_gain);
-            current_gain++;
-        }
-        gains.push_back(gain_end);
-
-    }
-
-    //Establish error-storing variables
-
-    std::vector<double> bad_tune_freqs;
-    std::vector<double> no_lock_freqs;
-    std::vector< std::vector< double > > bad_gain_vals;
-    std::vector<std::string> dboard_sensor_names = usrp->get_rx_sensor_names();
-    std::vector<std::string> mboard_sensor_names = usrp->get_mboard_sensor_names();
-    bool has_sensor = (std::find(dboard_sensor_names.begin(), dboard_sensor_names.end(), "lo_locked")) != dboard_sensor_names.end();
-
-    for(std::vector<double>::iterator f = freqs.begin(); f != freqs.end(); ++f){
-
-        //Testing for successful frequency tune
-
-        usrp->set_rx_freq(*f);
-        boost::this_thread::sleep(boost::posix_time::microseconds(long(1000)));
-
-        double actual_freq = usrp->get_rx_freq();
-
-        if(*f == 0.0){
-            if(floor(actual_freq + 0.5) == 0.0){
-                if(verbose) std::cout << boost::format("\nRX frequency successfully tuned to %s.") % return_MHz_string(*f) << std::endl;
-            }
-            else{
-                if(verbose) std::cout << boost::format("\nRX frequency tuned to %s instead of %s.") % return_MHz_string(actual_freq) % return_MHz_string(*f) << std::endl;
-            }
+        results += "\n";
+        if(bad_gain_vals.empty()) results += "USRP successfully set all specified gain values at all frequencies.";
+        else if(bad_gain_vals.size() > 10 and not verbose){
+            //If gain fails at many values, don't print them all
+            results += str(boost::format("USRP did not successfully set gain at %d values.")
+                           % bad_gain_vals.size());
         }
         else{
-            if((*f / actual_freq > 0.9999) and (*f / actual_freq < 1.0001)){
-                if(verbose) std::cout << boost::format("\nRX frequency successfully tuned to %s.") % return_MHz_string(*f) << std::endl;
-            }
-            else{
-                if(verbose) std::cout << boost::format("\nRX frequency tuned to %s instead of %s.") % return_MHz_string(actual_freq) % return_MHz_string(*f) << std::endl;
-                bad_tune_freqs.push_back(*f);
-            }
-        }
-
-        //Testing for successful lock
-
-        if(has_sensor){
-            bool is_locked = false;
-            for(int i = 0; i < 1000; i++){
-                boost::this_thread::sleep(boost::posix_time::microseconds(1000));
-                if(usrp->get_rx_sensor("lo_locked",0).to_bool()){
-                    is_locked = true;
-                    break;
-                }
-            }
-            if(is_locked){
-                if(verbose) std::cout << boost::format("LO successfully locked at RX frequency %s.") % return_MHz_string(*f) << std::endl;
-            }
-            else{
-                if(verbose) std::cout << boost::format("LO did not successfully lock at RX frequency %s.") % return_MHz_string(*f) << std::endl;
-                no_lock_freqs.push_back(*f);
-            }
-        }
-
-        if(test_gain){
-
-            //Testing for successful gain tune
-
-            for(std::vector<double>::iterator g = gains.begin(); g != gains.end(); ++g){
-                usrp->set_rx_gain(*g);
-                boost::this_thread::sleep(boost::posix_time::microseconds(1000));
-
-                double actual_gain = usrp->get_rx_gain();
-
-                if(*g == 0.0){
-                    if(actual_gain == 0.0){
-                        if(verbose) std::cout << boost::format("RX gain successfully set to %5.2f at RX frequency %s.") % *g % return_MHz_string(*f) << std::endl;
-                    }
-                    else{
-                        if(verbose) std::cout << boost::format("RX gain set to %5.2f instead of %5.2f at RX frequency %s.") % actual_gain % *g % return_MHz_string(*f) << std::endl;
-                        std::vector<double> bad_gain_freq;
-                        bad_gain_freq.push_back(*f);
-                        bad_gain_freq.push_back(*g);
-                        bad_gain_vals.push_back(bad_gain_freq);
-                    }
-                }
-                else{
-                    if((*g / actual_gain) > 0.9 and (*g / actual_gain) < 1.1){
-                        if(verbose) std::cout << boost::format("RX gain successfully set to %5.2f at RX frequency %s.") % *g % return_MHz_string(*f) << std::endl;
-                    }
-                    else{
-                        if(verbose) std::cout << boost::format("RX gain set to %5.2f instead of %5.2f at RX frequency %s.") % actual_gain % *g % return_MHz_string(*f) << std::endl;
-                        std::vector<double> bad_gain_freq;
-                        bad_gain_freq.push_back(*f);
-                        bad_gain_freq.push_back(*g);
-                        bad_gain_vals.push_back(bad_gain_freq);
-                    }
-                }
-            }
-        }
-    }
-
-    std::string rx_results = "RX Summary:\n";
-    if(usrp->get_usrp_rx_info().get("rx_subdev_name") == "XCVR2450 RX"){
-        rx_results += std::string(str(boost::format("Frequency Range: %s - %s, %s - %s\n") % return_MHz_string(xcvr_freqs.at(0)) % return_MHz_string(xcvr_freqs.at(1)) %
-            return_MHz_string(xcvr_freqs.at(2)) % return_MHz_string(xcvr_freqs.at(3))));
-    }
-    else rx_results += std::string(str(boost::format("Frequency Range: %s - %s\n") % return_MHz_string(freqs.front()) % return_MHz_string(freqs.back())));
-    if(test_gain) rx_results += std::string(str(boost::format("Gain Range: %5.2f - %5.2f\n") % gains.front() % gains.back()));
-
-    if(bad_tune_freqs.empty()) rx_results += "USRP successfully tuned to all frequencies.";
-    else{
-        rx_results += "USRP did not successfully tune to the following frequencies: ";
-        for(std::vector<double>::iterator i = bad_tune_freqs.begin(); i != bad_tune_freqs.end(); ++i){
-            if(i != bad_tune_freqs.begin()) rx_results += ", ";
-            rx_results += return_MHz_string(*i);
-        }
-    }
-    if(has_sensor){
-
-        rx_results += "\n";
-        if(no_lock_freqs.empty()) rx_results += "LO successfully locked at all frequencies.";
-        else{
-            rx_results += "LO did not successfully lock at the following frequencies: ";
-            for(std::vector<double>::iterator i = no_lock_freqs.begin(); i != no_lock_freqs.end(); ++i){
-                if( i != no_lock_freqs.begin()) rx_results += ", ";
-                rx_results += return_MHz_string(*i);
-            }
-        }
-    }
-    if(test_gain){
-        rx_results += "\n";
-        if(bad_gain_vals.empty()) rx_results += "USRP successfully set all specified gain values at all frequencies.";
-        else{
-            rx_results += "USRP did not successfully set gain under the following circumstances:";
-            for(std::vector< std::vector<double> >::iterator i = bad_gain_vals.begin(); i != bad_gain_vals.end(); ++i){
-                std::vector<double> bad_pair = *i;
-                double bad_freq = bad_pair.front();
-                double bad_gain = bad_pair.back();
-                rx_results += std::string(str(boost::format("\nFrequency: %s, Gain: %5.2f") % return_MHz_string(bad_freq) % bad_gain));
+            results += "USRP did not successfully set gain under the following circumstances:";
+            BOOST_FOREACH(double_pair bad_pair, bad_gain_vals){
+                double bad_freq = bad_pair.first;
+                double bad_gain = bad_pair.second;
+                results += str(boost::format("\nFrequency: %s, Gain: %5.2f") % MHz_str(bad_freq) % bad_gain);
             }
         }
     }
 
-    return rx_results;
+    return results;
 }
 
 /************************************************************************
@@ -463,8 +316,9 @@ std::string rx_test(uhd::usrp::multi_usrp::sptr usrp, bool test_gain, bool verbo
 int UHD_SAFE_MAIN(int argc, char *argv[]){
 
     //Variables
+    int chan;
     std::string args;
-    double gain_step;
+    double freq_step, gain_step;
     std::string ref;
     std::string tx_results;
     std::string rx_results;
@@ -475,34 +329,20 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
     desc.add_options()
         ("help", "help message")
         ("args", po::value<std::string>(&args)->default_value(""), "Specify the UHD device")
-        ("gain_step", po::value<double>(&gain_step)->default_value(1.0), "Specify the delta between gain scans")
+        ("chan", po::value<int>(&chan)->default_value(0), "Specify multi_usrp channel")
+        ("freq-step", po::value<double>(&freq_step)->default_value(100e6), "Specify the delta between frequency scans")
+        ("gain-step", po::value<double>(&gain_step)->default_value(1.0), "Specify the delta between gain scans")
         ("tx", "Specify to test TX frequency and gain coercion")
         ("rx", "Specify to test RX frequency and gain coercion")
         ("ref", po::value<std::string>(&ref)->default_value("internal"), "Waveform type: internal, external, or mimo")
-        ("no_tx_gain", "Do not test TX gain")
-        ("no_rx_gain", "Do not test RX gain")
+        ("no-tx-gain", "Do not test TX gain")
+        ("no-rx-gain", "Do not test RX gain")
         ("verbose", "Output every frequency and gain check instead of just final summary")
     ;
     po::variables_map vm;
     po::store(po::parse_command_line(argc, argv, desc), vm);
     po::notify(vm);
 
-    //Create a USRP device
-    std::cout << std::endl;
-    uhd::device_addrs_t device_addrs = uhd::device::find(args);
-    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 << std::endl << boost::format("Using Device: %s") % usrp->get_pp_string() << std::endl;
-    usrp->set_tx_rate(1e6);
-    usrp->set_rx_rate(1e6);
-
-    //Boolean variables based on command line input
-    bool test_tx = vm.count("tx") > 0;
-    bool test_rx = vm.count("rx") > 0;
-    bool test_tx_gain = !(vm.count("no_tx_gain") > 0) and (usrp->get_tx_gain_range().stop() > 0);
-    bool test_rx_gain = !(vm.count("no_rx_gain") > 0) and (usrp->get_rx_gain_range().stop() > 0);
-    bool verbose = vm.count("verbose") > 0;
-
     //Help messages, errors
     if(vm.count("help") > 0){
         std::cout << "UHD Daughterboard Coercion Test\n"
@@ -510,42 +350,72 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
                      "make sure that they can successfully tune to all\n"
                      "frequencies and gains in their advertised ranges.\n\n";
         std::cout << desc << std::endl;
-        return ~0;
-    }
-
-    if(ref != "internal" and ref != "external" and ref != "mimo"){
-        std::cout << desc << std::endl;
-        std::cout << "REF must equal internal, external, or mimo." << std::endl;
-        return ~0;
+        return EXIT_SUCCESS;
     }
 
     if(vm.count("tx") + vm.count("rx") == 0){
         std::cout << desc << std::endl;
         std::cout << "Specify --tx to test for TX frequency coercion\n"
                      "Specify --rx to test for RX frequency coercion\n";
-        return ~0;
+        return EXIT_FAILURE;
     }
 
-    if(test_rx and usrp->get_usrp_rx_info().get("rx_id") == "Basic RX (0x0001)"){
-        std::cout << desc << std::endl;
-        std::cout << "This test does not work with the Basic RX daughterboard." << std::endl;
-        return ~0;
-    }
-    else if(test_rx and usrp->get_usrp_rx_info().get("rx_id") == "Unknown (0xffff)"){
+    //Create a USRP device
+    std::cout << std::endl;
+    uhd::device_addrs_t device_addrs = uhd::device::find(args);
+    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 << std::endl << boost::format("Using Device: %s") % usrp->get_pp_string() << std::endl;
+    usrp->set_tx_rate(SAMP_RATE);
+    usrp->set_rx_rate(SAMP_RATE);
+
+    //Boolean variables based on command line input
+    bool test_tx = vm.count("tx") > 0;
+    bool test_rx = vm.count("rx") > 0;
+    bool test_tx_gain = !(vm.count("no-tx-gain") > 0) and (usrp->get_tx_gain_range().stop() > 0);
+    bool test_rx_gain = !(vm.count("no-rx-gain") > 0) and (usrp->get_rx_gain_range().stop() > 0);
+    bool verbose = vm.count("verbose") > 0;
+
+    if(ref != "internal" and ref != "external" and ref != "mimo"){
         std::cout << desc << std::endl;
-        std::cout << "This daughterboard is unrecognized, or there is no RX daughterboard." << std::endl;
-        return ~0;
+        std::cout << "REF must equal internal, external, or mimo." << std::endl;
+        return EXIT_FAILURE;
     }
 
-    if(test_tx and usrp->get_usrp_tx_info().get("tx_id") == "Basic TX (0x0000)"){
-        std::cout << desc << std::endl;
-        std::cout << "This test does not work with the Basic TX daughterboard." << std::endl;
-        return ~0;
+    //Use TX mboard ID to determine if this is a B2xx, will still return value if there is no TX
+    std::string tx_mboard_id = usrp->get_usrp_tx_info(chan).get("mboard_id");
+    bool is_b2xx = (tx_mboard_id == "B200" or tx_mboard_id == "B210");
+
+    //Don't perform daughterboard validity checks for B200/B210
+    if((not is_b2xx) and test_tx){
+        std::string tx_dboard_name = usrp->get_usrp_tx_info(chan).get("tx_id");
+        if(tx_dboard_name == "Basic TX (0x0000)" or tx_dboard_name == "LF TX (0x000e)"){
+            std::cout << desc << std::endl;
+            std::cout << boost::format("This test does not work with the %s daughterboard.")
+                         % tx_dboard_name << std::endl;
+            return EXIT_FAILURE;
+        }
+        else if(tx_dboard_name == "Unknown (0xffff)"){
+            std::cout << desc << std::endl;
+            std::cout << "This daughterboard is unrecognized, or there is no TX daughterboard." << std::endl;
+            return EXIT_FAILURE;
+        }
     }
-    else if(test_tx and usrp->get_usrp_tx_info().get("tx_id") == "Unknown (0xffff)"){
-        std::cout << desc << std::endl;
-        std::cout << "This daughterboard is unrecognized, or there is no TX daughterboard." << std::endl;
-        return ~0;
+
+    //Don't perform daughterboard validity checks for B200/B210
+    if((not is_b2xx) and test_rx){
+        std::string rx_dboard_name = usrp->get_usrp_rx_info(chan).get("rx_id");
+        if(rx_dboard_name == "Basic RX (0x0001)" or rx_dboard_name == "LF RX (0x000f)"){
+            std::cout << desc << std::endl;
+            std::cout << boost::format("This test does not work with the %s daughterboard.")
+                         % rx_dboard_name << std::endl;
+            return EXIT_FAILURE;
+        }
+        else if(rx_dboard_name == "Unknown (0xffff)"){
+            std::cout << desc << std::endl;
+            std::cout << "This daughterboard is unrecognized, or there is no RX daughterboard." << std::endl;
+            return EXIT_FAILURE;
+        }
     }
 
     //Setting clock source
@@ -563,12 +433,11 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
         std::cout << boost::format("Checking REF lock: %s ...") % ref_locked.to_pp_string() << std::endl;
         UHD_ASSERT_THROW(ref_locked.to_bool());
     }
-    usrp_config = return_USRP_config_string(usrp, test_tx, test_rx);
-    if(test_tx) tx_results = tx_test(usrp, test_tx_gain, verbose);
-    if(test_rx) rx_results = rx_test(usrp, test_rx_gain, verbose);
+    usrp_config = return_usrp_config_string(usrp, chan, test_tx, test_rx, is_b2xx);
+    if(test_tx) tx_results = coercion_test(usrp, "TX", chan, test_tx_gain, freq_step, gain_step, verbose);
+    if(test_rx) rx_results = coercion_test(usrp, "RX", chan, test_rx_gain, freq_step, gain_step, verbose);
 
-    if(verbose) std::cout << std::endl;
-    std::cout << usrp_config << std::endl << std::endl;
+    std::cout << std::endl << usrp_config << std::endl << std::endl;
     if(test_tx) std::cout << tx_results << std::endl;
     if(test_tx and test_rx) std::cout << std::endl;
     if(test_rx) std::cout << rx_results << std::endl;