aboutsummaryrefslogtreecommitdiffstats
path: root/host
diff options
context:
space:
mode:
Diffstat (limited to 'host')
-rw-r--r--host/examples/test_dboard_coercion.cpp535
-rw-r--r--host/utils/usrp_n2xx_simple_net_burner.cpp495
-rw-r--r--host/utils/usrp_simple_burner_utils.hpp99
3 files changed, 486 insertions, 643 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;
diff --git a/host/utils/usrp_n2xx_simple_net_burner.cpp b/host/utils/usrp_n2xx_simple_net_burner.cpp
index 277e807d9..cecac5588 100644
--- a/host/utils/usrp_n2xx_simple_net_burner.cpp
+++ b/host/utils/usrp_n2xx_simple_net_burner.cpp
@@ -17,13 +17,13 @@
#include <csignal>
#include <iostream>
-#include <map>
#include <fstream>
#include <time.h>
#include <vector>
#include <boost/foreach.hpp>
#include <boost/asio.hpp>
+#include <boost/filesystem.hpp>
#include <boost/program_options.hpp>
#include <boost/assign.hpp>
#include <boost/assign/list_of.hpp>
@@ -32,21 +32,97 @@
#include <boost/filesystem.hpp>
#include <boost/thread/thread.hpp>
-#include "usrp_simple_burner_utils.hpp"
#include <uhd/exception.hpp>
#include <uhd/property_tree.hpp>
#include <uhd/transport/if_addrs.hpp>
#include <uhd/transport/udp_simple.hpp>
+#include <uhd/types/dict.hpp>
#include <uhd/utils/byteswap.hpp>
#include <uhd/utils/images.hpp>
#include <uhd/utils/safe_main.hpp>
#include <uhd/utils/safe_call.hpp>
+namespace fs = boost::filesystem;
namespace po = boost::program_options;
using namespace boost::algorithm;
using namespace uhd;
using namespace uhd::transport;
+#define UDP_FW_UPDATE_PORT 49154
+#define UDP_MAX_XFER_BYTES 1024
+#define UDP_TIMEOUT 3
+#define UDP_POLL_INTERVAL 0.10 //in seconds
+#define USRP2_FW_PROTO_VERSION 7 //should be unused after r6
+#define USRP2_UDP_UPDATE_PORT 49154
+#define FLASH_DATA_PACKET_SIZE 256
+#define FPGA_IMAGE_SIZE_BYTES 1572864
+#define FW_IMAGE_SIZE_BYTES 31744
+#define PROD_FPGA_IMAGE_LOCATION_ADDR 0x00180000
+#define PROD_FW_IMAGE_LOCATION_ADDR 0x00300000
+#define SAFE_FPGA_IMAGE_LOCATION_ADDR 0x00000000
+#define SAFE_FW_IMAGE_LOCATION_ADDR 0x003F0000
+
+typedef enum {
+ UNKNOWN = ' ',
+
+ USRP2_QUERY = 'a',
+ USRP2_ACK = 'A',
+
+ GET_FLASH_INFO_CMD = 'f',
+ GET_FLASH_INFO_ACK = 'F',
+
+ ERASE_FLASH_CMD = 'e',
+ ERASE_FLASH_ACK = 'E',
+
+ CHECK_ERASING_DONE_CMD = 'd',
+ DONE_ERASING_ACK = 'D',
+ NOT_DONE_ERASING_ACK = 'B',
+
+ WRITE_FLASH_CMD = 'w',
+ WRITE_FLASH_ACK = 'W',
+
+ READ_FLASH_CMD = 'r',
+ READ_FLASH_ACK = 'R',
+
+ RESET_USRP_CMD = 's',
+ RESET_USRP_ACK = 'S',
+
+ GET_HW_REV_CMD = 'v',
+ GET_HW_REV_ACK = 'V',
+
+} usrp2_fw_update_id_t;
+
+typedef struct {
+ uint32_t proto_ver;
+ uint32_t id;
+ uint32_t seq;
+ union {
+ uint32_t ip_addr;
+ uint32_t hw_rev;
+ struct {
+ uint32_t flash_addr;
+ uint32_t length;
+ uint8_t data[256];
+ } flash_args;
+ struct {
+ uint32_t sector_size_bytes;
+ uint32_t memory_size_bytes;
+ } flash_info_args;
+ } data;
+} usrp2_fw_update_data_t;
+
+//Mapping revision numbers to filenames
+uhd::dict<boost::uint32_t, std::string> filename_map = boost::assign::map_list_of
+ (0xa, "n200_r3")
+ (0x100a, "n200_r4")
+ (0x10a, "n210_r3")
+ (0x110a, "n210_r4")
+;
+
+boost::uint8_t usrp2_update_data_in_mem[udp_simple::mtu];
+boost::uint8_t fpga_image[FPGA_IMAGE_SIZE_BYTES];
+boost::uint8_t fw_image[FW_IMAGE_SIZE_BYTES];
+
/***********************************************************************
* Signal handlers
**********************************************************************/
@@ -66,59 +142,94 @@ void sig_int_handler(int){
}
}
-//Mapping revision numbers to filenames
-std::map<boost::uint32_t, std::string> filename_map = boost::assign::map_list_of
- (0xa, "n200_r3")
- (0x100a, "n200_r4")
- (0x10a, "n210_r3")
- (0x110a, "n210_r4")
-;
+/***********************************************************************
+ * List all connected USRP N2XX devices
+ **********************************************************************/
+void list_usrps(){
+ udp_simple::sptr udp_bc_transport;
+ const usrp2_fw_update_data_t *update_data_in = reinterpret_cast<const usrp2_fw_update_data_t *>(usrp2_update_data_in_mem);
+ boost::uint32_t hw_rev;
-//Images and image sizes, to be populated as necessary
-boost::uint8_t fpga_image[FPGA_IMAGE_SIZE_BYTES];
-boost::uint8_t fw_image[FW_IMAGE_SIZE_BYTES];
-int fpga_image_size = 0;
-int fw_image_size = 0;
+ usrp2_fw_update_data_t usrp2_ack_pkt = usrp2_fw_update_data_t();
+ usrp2_ack_pkt.proto_ver = htonx<boost::uint32_t>(USRP2_FW_PROTO_VERSION);
+ usrp2_ack_pkt.id = htonx<boost::uint32_t>(USRP2_QUERY);
+
+ std::cout << "Available USRP N2XX devices:" << std::endl;
-//For non-standard images not covered by uhd::find_image_path()
-bool does_image_exist(std::string image_filepath){
+ //Send UDP packets to all broadcast addresses
+ BOOST_FOREACH(const if_addrs_t &if_addrs, get_if_addrs()){
+ //Avoid the loopback device
+ if(if_addrs.inet == boost::asio::ip::address_v4::loopback().to_string()) continue;
+ udp_bc_transport = udp_simple::make_broadcast(if_addrs.bcast, BOOST_STRINGIZE(USRP2_UDP_UPDATE_PORT));
+ udp_bc_transport->send(boost::asio::buffer(&usrp2_ack_pkt, sizeof(usrp2_ack_pkt)));
- std::ifstream ifile((char*)image_filepath.c_str());
- return ifile;
+ size_t len = udp_bc_transport->recv(boost::asio::buffer(usrp2_update_data_in_mem), UDP_TIMEOUT);
+ if(len > offsetof(usrp2_fw_update_data_t, data) and ntohl(update_data_in->id) == USRP2_ACK){
+ usrp2_ack_pkt.id = htonx<boost::uint32_t>(GET_HW_REV_CMD);
+ udp_bc_transport->send(boost::asio::buffer(&usrp2_ack_pkt, sizeof(usrp2_ack_pkt)));
+
+ size_t len = udp_bc_transport->recv(boost::asio::buffer(usrp2_update_data_in_mem), UDP_TIMEOUT);
+ if(len > offsetof(usrp2_fw_update_data_t, data) and ntohl(update_data_in->id) == GET_HW_REV_ACK){
+ hw_rev = ntohl(update_data_in->data.hw_rev);
+ }
+
+ std::cout << boost::format(" * %s (%s)\n") % udp_bc_transport->get_recv_addr() % filename_map[hw_rev];
+ }
+ }
+}
+
+/***********************************************************************
+ * Find USRP N2XX with specified IP address and return type
+ **********************************************************************/
+boost::uint32_t find_usrp(udp_simple::sptr udp_transport){
+ boost::uint32_t hw_rev;
+ bool found_it = false;
+
+ const usrp2_fw_update_data_t *update_data_in = reinterpret_cast<const usrp2_fw_update_data_t *>(usrp2_update_data_in_mem);
+ usrp2_fw_update_data_t hw_info_pkt = usrp2_fw_update_data_t();
+ hw_info_pkt.proto_ver = htonx<boost::uint32_t>(USRP2_FW_PROTO_VERSION);
+ hw_info_pkt.id = htonx<boost::uint32_t>(GET_HW_REV_CMD);
+ udp_transport->send(boost::asio::buffer(&hw_info_pkt, sizeof(hw_info_pkt)));
+
+ //Loop and receive until the timeout
+ size_t len = udp_transport->recv(boost::asio::buffer(usrp2_update_data_in_mem), UDP_TIMEOUT);
+ if(len > offsetof(usrp2_fw_update_data_t, data) and ntohl(update_data_in->id) == GET_HW_REV_ACK){
+ hw_rev = ntohl(update_data_in->data.hw_rev);
+ if(filename_map.has_key(hw_rev)){
+ std::cout << boost::format("Found %s.\n\n") % filename_map[hw_rev];
+ found_it = true;
+ }
+ else throw std::runtime_error("Invalid revision found.");
+ }
+ if(not found_it) throw std::runtime_error("No USRP N2XX found.");
+
+ return hw_rev;
}
/***********************************************************************
* Custom filename validation functions
**********************************************************************/
-void validate_custom_fpga_file(std::string rev_str, std::string fpga_path){
+void validate_custom_fpga_file(std::string rev_str, std::string& fpga_path){
//Check for existence of file
- if(!does_image_exist(fpga_path)) throw std::runtime_error(str(boost::format("No file at specified FPGA path: %s") % fpga_path));
+ if(not fs::exists(fpga_path)) throw std::runtime_error(str(boost::format("No file at specified FPGA path: %s") % fpga_path));
//Check to find rev_str in filename
uhd::fs_path custom_fpga_path(fpga_path);
- if(custom_fpga_path.leaf().find("fw") != std::string::npos){
- throw std::runtime_error(str(boost::format("Invalid FPGA image filename at path: %s\nFilename indicates that this is a firmware image.")
- % fpga_path));
- }
if(custom_fpga_path.leaf().find(rev_str) == std::string::npos){
throw std::runtime_error(str(boost::format("Invalid FPGA image filename at path: %s\nFilename must contain '%s' to be considered valid for this model.")
% fpga_path % rev_str));
}
}
-void validate_custom_fw_file(std::string rev_str, std::string fw_path){
+void validate_custom_fw_file(std::string rev_str, std::string& fw_path){
//Check for existence of file
- if(!does_image_exist(fw_path)) throw std::runtime_error(str(boost::format("No file at specified firmware path: %s") % fw_path));
+ if(not fs::exists(fw_path)) throw std::runtime_error(str(boost::format("No file at specified firmware path: %s") % fw_path));
//Check to find truncated rev_str in filename
uhd::fs_path custom_fw_path(fw_path);
- if(custom_fw_path.leaf().find("fpga") != std::string::npos){
- throw std::runtime_error(str(boost::format("Invalid firmware image filename at path: %s\nFilename indicates that this is an FPGA image.")
- % fw_path));
- }
if(custom_fw_path.leaf().find(erase_tail_copy(rev_str,3)) == std::string::npos){
throw std::runtime_error(str(boost::format("Invalid firmware image filename at path: %s\nFilename must contain '%s' to be considered valid for this model.")
% fw_path % erase_tail_copy(rev_str,3)));
@@ -126,89 +237,91 @@ void validate_custom_fw_file(std::string rev_str, std::string fw_path){
}
/***********************************************************************
- * Grabbing and validating image binaries
+ * Reading and validating image binaries
**********************************************************************/
-int grab_fpga_image(std::string fpga_path){
+int read_fpga_image(std::string& fpga_path){
- //Reading FPGA image from file
- std::ifstream to_read_fpga((char*)fpga_path.c_str(), std::ios::binary);
- to_read_fpga.seekg(0, std::ios::end);
- fpga_image_size = to_read_fpga.tellg();
- to_read_fpga.seekg(0, std::ios::beg);
- char fpga_read[FPGA_IMAGE_SIZE_BYTES];
- to_read_fpga.read(fpga_read,fpga_image_size);
- to_read_fpga.close();
- for(int i = 0; i < fpga_image_size; i++) fpga_image[i] = (boost::uint8_t)fpga_read[i];
-
- //Checking validity of image
+ //Check size of given image
+ std::ifstream fpga_file(fpga_path.c_str(), std::ios::binary);
+ fpga_file.seekg(0, std::ios::end);
+ int fpga_image_size = fpga_file.tellg();
if(fpga_image_size > FPGA_IMAGE_SIZE_BYTES){
- throw std::runtime_error(str(boost::format("FPGA image is too large. %d > %d") % fpga_image_size % FPGA_IMAGE_SIZE_BYTES));
+ throw std::runtime_error(str(boost::format("FPGA image is too large. %d > %d")
+ % fpga_image_size % FPGA_IMAGE_SIZE_BYTES));
}
- //Check sequence of bytes in image
+ //Check sequence of bytes in image before reading
+ boost::uint8_t fpga_test_bytes[63];
+ fpga_file.seekg(0, std::ios::beg);
+ fpga_file.read((char*)fpga_test_bytes,63);
bool is_good = false;
for(int i = 0; i < 63; i++){
- if((boost::uint8_t)fpga_image[i] == 255) continue;
- else if((boost::uint8_t)fpga_image[i] == 170 and
- (boost::uint8_t)fpga_image[i+1] == 153){
+ if(fpga_test_bytes[i] == 255) continue;
+ else if(fpga_test_bytes[i] == 170 and
+ fpga_test_bytes[i+1] == 153){
is_good = true;
break;
}
}
+ if(not is_good) throw std::runtime_error("Not a valid FPGA image.");
- if(!is_good) throw std::runtime_error("Not a valid FPGA image.");
+ //With image validated, read into utility
+ fpga_file.seekg(0, std::ios::beg);
+ fpga_file.read((char*)fpga_image,fpga_image_size);
+ fpga_file.close();
//Return image size
return fpga_image_size;
}
-int grab_fw_image(std::string fw_path){
-
- //Reading firmware image from file
- std::ifstream to_read_fw((char*)fw_path.c_str(), std::ios::binary);
- to_read_fw.seekg(0, std::ios::end);
- fw_image_size = to_read_fw.tellg();
- to_read_fw.seekg(0, std::ios::beg);
- char fw_read[FW_IMAGE_SIZE_BYTES];
- to_read_fw.read(fw_read,fw_image_size);
- to_read_fw.close();
- for(int i = 0; i < fw_image_size; i++) fw_image[i] = (boost::uint8_t)fw_read[i];
+int read_fw_image(std::string& fw_path){
- //Checking validity of image
+ //Check size of given image
+ std::ifstream fw_file(fw_path.c_str(), std::ios::binary);
+ fw_file.seekg(0, std::ios::end);
+ int fw_image_size = fw_file.tellg();
if(fw_image_size > FW_IMAGE_SIZE_BYTES){
- throw std::runtime_error(str(boost::format("Firmware image is too large. %d > %d") % fw_image_size % FW_IMAGE_SIZE_BYTES));
+ throw std::runtime_error(str(boost::format("Firmware image is too large. %d > %d")
+ % fw_image_size % FW_IMAGE_SIZE_BYTES));
}
- //Check first four bytes of image
- for(int i = 0; i < 4; i++) if((boost::uint8_t)fw_image[i] != 11) throw std::runtime_error("Not a valid firmware image.");
+ //Check sequence of bytes in image before reading
+ boost::uint8_t fw_test_bytes[4];
+ fw_file.seekg(0, std::ios::beg);
+ fw_file.read((char*)fw_test_bytes,4);
+ for(int i = 0; i < 4; i++) if(fw_test_bytes[i] != 11) throw std::runtime_error("Not a valid firmware image.");
+
+ //With image validated, read into utility
+ fw_file.seekg(0, std::ios::beg);
+ fw_file.read((char*)fw_image,fw_image_size);
+ fw_file.close();
- //Return image size
return fw_image_size;
}
-boost::uint32_t* get_flash_info(std::string ip_addr){
+boost::uint32_t* get_flash_info(std::string& ip_addr){
boost::uint32_t *flash_info = new boost::uint32_t[2];
- boost::uint8_t usrp2_update_data_in_mem[udp_simple::mtu];
const usrp2_fw_update_data_t *update_data_in = reinterpret_cast<const usrp2_fw_update_data_t *>(usrp2_update_data_in_mem);
udp_simple::sptr udp_transport = udp_simple::make_connected(ip_addr, BOOST_STRINGIZE(USRP2_UDP_UPDATE_PORT));
usrp2_fw_update_data_t get_flash_info_pkt = usrp2_fw_update_data_t();
get_flash_info_pkt.proto_ver = htonx<boost::uint32_t>(USRP2_FW_PROTO_VERSION);
- get_flash_info_pkt.id = htonx<boost::uint32_t>(USRP2_FW_UPDATE_ID_WATS_TEH_FLASH_INFO_LOL);
+ get_flash_info_pkt.id = htonx<boost::uint32_t>(GET_FLASH_INFO_CMD);
udp_transport->send(boost::asio::buffer(&get_flash_info_pkt, sizeof(get_flash_info_pkt)));
//Loop and receive until the timeout
size_t len = udp_transport->recv(boost::asio::buffer(usrp2_update_data_in_mem), UDP_TIMEOUT);
- if(len > offsetof(usrp2_fw_update_data_t, data) and ntohl(update_data_in->id) == USRP2_FW_UPDATE_ID_HERES_TEH_FLASH_INFO_OMG){
+ if(len > offsetof(usrp2_fw_update_data_t, data) and ntohl(update_data_in->id) == GET_FLASH_INFO_ACK){
flash_info[0] = ntohl(update_data_in->data.flash_info_args.sector_size_bytes);
flash_info[1] = ntohl(update_data_in->data.flash_info_args.memory_size_bytes);
}
- else if(ntohl(update_data_in->id) != USRP2_FW_UPDATE_ID_HERES_TEH_FLASH_INFO_OMG){
- throw std::runtime_error(str(boost::format("Received invalid reply %d from device.\n") % ntohl(update_data_in->id)));
+ else if(ntohl(update_data_in->id) != GET_FLASH_INFO_ACK){
+ throw std::runtime_error(str(boost::format("Received invalid reply %d from device.\n")
+ % ntohl(update_data_in->id)));
}
-
+
return flash_info;
}
@@ -218,102 +331,100 @@ boost::uint32_t* get_flash_info(std::string ip_addr){
void erase_image(udp_simple::sptr udp_transport, bool is_fw, boost::uint32_t memory_size){
+ boost::uint32_t image_location_addr = is_fw ? PROD_FW_IMAGE_LOCATION_ADDR
+ : PROD_FPGA_IMAGE_LOCATION_ADDR;
+ boost::uint32_t image_size = is_fw ? FW_IMAGE_SIZE_BYTES
+ : FPGA_IMAGE_SIZE_BYTES;
+
//Making sure this won't attempt to erase past end of device
- if(is_fw){
- if(PROD_FW_IMAGE_LOCATION_ADDR+FW_IMAGE_SIZE_BYTES > memory_size) throw std::runtime_error("Cannot erase past end of device.");
- }
- else{
- if(PROD_FPGA_IMAGE_LOCATION_ADDR+FPGA_IMAGE_SIZE_BYTES > memory_size) throw std::runtime_error("Cannot erase past end of device.");
- }
+ if((image_location_addr+image_size) > memory_size) throw std::runtime_error("Cannot erase past end of device.");
- //Setting up UDP transport
- boost::uint8_t usrp2_update_data_in_mem[udp_simple::mtu];
+ //UDP receive buffer
const usrp2_fw_update_data_t *update_data_in = reinterpret_cast<const usrp2_fw_update_data_t *>(usrp2_update_data_in_mem);
//Setting up UDP packet
usrp2_fw_update_data_t erase_pkt = usrp2_fw_update_data_t();
- erase_pkt.id = htonx<boost::uint32_t>(USRP2_FW_UPDATE_ID_ERASE_TEH_FLASHES_LOL);
+ erase_pkt.id = htonx<boost::uint32_t>(ERASE_FLASH_CMD);
erase_pkt.proto_ver = htonx<boost::uint32_t>(USRP2_FW_PROTO_VERSION);
- if(is_fw){
- erase_pkt.data.flash_args.flash_addr = htonx<boost::uint32_t>(PROD_FW_IMAGE_LOCATION_ADDR);
- erase_pkt.data.flash_args.length = htonx<boost::uint32_t>(FW_IMAGE_SIZE_BYTES);
- }
- else{
- erase_pkt.data.flash_args.flash_addr = htonx<boost::uint32_t>(PROD_FPGA_IMAGE_LOCATION_ADDR);
- erase_pkt.data.flash_args.length = htonx<boost::uint32_t>(FPGA_IMAGE_SIZE_BYTES);
- }
+ erase_pkt.data.flash_args.flash_addr = htonx<boost::uint32_t>(image_location_addr);
+ erase_pkt.data.flash_args.length = htonx<boost::uint32_t>(image_size);
//Begin erasing
udp_transport->send(boost::asio::buffer(&erase_pkt, sizeof(erase_pkt)));
size_t len = udp_transport->recv(boost::asio::buffer(usrp2_update_data_in_mem), UDP_TIMEOUT);
- if(len > offsetof(usrp2_fw_update_data_t, data) and ntohl(update_data_in->id) == USRP2_FW_UPDATE_ID_ERASING_TEH_FLASHES_OMG){
+ if(len > offsetof(usrp2_fw_update_data_t, data) and ntohl(update_data_in->id) == ERASE_FLASH_ACK){
if(is_fw) std::cout << "Erasing firmware image." << std::endl;
else std::cout << "Erasing FPGA image." << std::endl;
}
- else if(ntohl(update_data_in->id) != USRP2_FW_UPDATE_ID_ERASING_TEH_FLASHES_OMG){
- throw std::runtime_error(str(boost::format("Received invalid reply %d from device.\n") % ntohl(update_data_in->id)));
+ else if(ntohl(update_data_in->id) != ERASE_FLASH_ACK){
+ throw std::runtime_error(str(boost::format("Received invalid reply %d from device.\n")
+ % ntohl(update_data_in->id)));
}
//Check for erase completion
- erase_pkt.id = htonx<boost::uint32_t>(USRP2_FW_UPDATE_ID_R_U_DONE_ERASING_LOL);
+ erase_pkt.id = htonx<boost::uint32_t>(CHECK_ERASING_DONE_CMD);
while(true){
udp_transport->send(boost::asio::buffer(&erase_pkt, sizeof(erase_pkt)));
size_t len = udp_transport->recv(boost::asio::buffer(usrp2_update_data_in_mem), UDP_TIMEOUT);
- if(len > offsetof(usrp2_fw_update_data_t, data) and ntohl(update_data_in->id) == USRP2_FW_UPDATE_ID_IM_DONE_ERASING_OMG){
- if(is_fw) std::cout << boost::format(" * Successfully erased %d bytes at %d.\n") % FW_IMAGE_SIZE_BYTES % PROD_FW_IMAGE_LOCATION_ADDR;
- else std::cout << boost::format(" * Successfully erased %d bytes at %d.\n") % FPGA_IMAGE_SIZE_BYTES % PROD_FPGA_IMAGE_LOCATION_ADDR;
+ if(len > offsetof(usrp2_fw_update_data_t, data) and ntohl(update_data_in->id) == DONE_ERASING_ACK){
+ std::cout << boost::format(" * Successfully erased %d bytes at %d.\n")
+ % image_size % image_location_addr;
break;
}
- else if(ntohl(update_data_in->id) != USRP2_FW_UPDATE_ID_NOPE_NOT_DONE_ERASING_OMG){
- throw std::runtime_error(str(boost::format("Received invalid reply %d from device.\n") % ntohl(update_data_in->id)));
+ else if(ntohl(update_data_in->id) != NOT_DONE_ERASING_ACK){
+ throw std::runtime_error(str(boost::format("Received invalid reply %d from device.\n")
+ % ntohl(update_data_in->id)));
}
}
}
void write_image(udp_simple::sptr udp_transport, bool is_fw, boost::uint8_t* image, boost::uint32_t memory_size, int image_size){
- boost::uint32_t current_addr;
- if(is_fw) current_addr = PROD_FW_IMAGE_LOCATION_ADDR;
- else current_addr = PROD_FPGA_IMAGE_LOCATION_ADDR;
+ boost::uint32_t begin_addr = is_fw ? PROD_FW_IMAGE_LOCATION_ADDR
+ : PROD_FPGA_IMAGE_LOCATION_ADDR;
+ boost::uint32_t current_addr = begin_addr;
+ std::string type = is_fw ? "firmware" : "FPGA";
//Making sure this won't attempt to write past end of device
if(current_addr+image_size > memory_size) throw std::runtime_error("Cannot write past end of device.");
- //Setting up UDP transport
- boost::uint8_t usrp2_update_data_in_mem[udp_simple::mtu];
+ //UDP receive buffer
const usrp2_fw_update_data_t *update_data_in = reinterpret_cast<const usrp2_fw_update_data_t *>(usrp2_update_data_in_mem);
//Setting up UDP packet
usrp2_fw_update_data_t write_pkt = usrp2_fw_update_data_t();
- write_pkt.id = htonx<boost::uint32_t>(USRP2_FW_UPDATE_ID_WRITE_TEH_FLASHES_LOL);
+ write_pkt.id = htonx<boost::uint32_t>(WRITE_FLASH_CMD);
write_pkt.proto_ver = htonx<boost::uint32_t>(USRP2_FW_PROTO_VERSION);
write_pkt.data.flash_args.length = htonx<boost::uint32_t>(FLASH_DATA_PACKET_SIZE);
- //Write image
- if(is_fw) std::cout << "Writing firmware image." << std::endl;
- else std::cout << "Writing FPGA image." << std::endl;
-
for(int i = 0; i < ((image_size/FLASH_DATA_PACKET_SIZE)+1); i++){
+ //Print progress
+ std::cout << "\rWriting " << type << " image ("
+ << int((double(current_addr-begin_addr)/double(image_size))*100) << "%)." << std::flush;
+
write_pkt.data.flash_args.flash_addr = htonx<boost::uint32_t>(current_addr);
std::copy(image+(i*FLASH_DATA_PACKET_SIZE), image+((i+1)*FLASH_DATA_PACKET_SIZE), write_pkt.data.flash_args.data);
udp_transport->send(boost::asio::buffer(&write_pkt, sizeof(write_pkt)));
size_t len = udp_transport->recv(boost::asio::buffer(usrp2_update_data_in_mem), UDP_TIMEOUT);
- if(len > offsetof(usrp2_fw_update_data_t, data) and ntohl(update_data_in->id) != USRP2_FW_UPDATE_ID_WROTE_TEH_FLASHES_OMG){
- throw std::runtime_error(str(boost::format("Invalid reply %d from device.") % ntohl(update_data_in->id)));
+ if(len > offsetof(usrp2_fw_update_data_t, data) and ntohl(update_data_in->id) != WRITE_FLASH_ACK){
+ throw std::runtime_error(str(boost::format("Invalid reply %d from device.")
+ % ntohl(update_data_in->id)));
}
current_addr += FLASH_DATA_PACKET_SIZE;
}
+ std::cout << std::flush << "\rWriting " << type << " image (100%)." << std::endl;
std::cout << boost::format(" * Successfully wrote %d bytes.\n") % image_size;
}
void verify_image(udp_simple::sptr udp_transport, bool is_fw, boost::uint8_t* image, boost::uint32_t memory_size, int image_size){
int current_index = 0;
- boost::uint32_t current_addr;
- if(is_fw) current_addr = PROD_FW_IMAGE_LOCATION_ADDR;
- else current_addr = PROD_FPGA_IMAGE_LOCATION_ADDR;
+ boost::uint32_t begin_addr = is_fw ? PROD_FW_IMAGE_LOCATION_ADDR
+ : PROD_FPGA_IMAGE_LOCATION_ADDR;
+ boost::uint32_t current_addr = begin_addr;
+ std::string type = is_fw ? "firmware" : "FPGA";
//Array size needs to be known at runtime, this constant is guaranteed to be larger than any firmware or FPGA image
boost::uint8_t from_usrp[FPGA_IMAGE_SIZE_BYTES];
@@ -321,27 +432,27 @@ void verify_image(udp_simple::sptr udp_transport, bool is_fw, boost::uint8_t* im
//Making sure this won't attempt to read past end of device
if(current_addr+image_size > memory_size) throw std::runtime_error("Cannot read past end of device.");
- //Setting up UDP transport
- boost::uint8_t usrp2_update_data_in_mem[udp_simple::mtu];
+ //UDP receive buffer
const usrp2_fw_update_data_t *update_data_in = reinterpret_cast<const usrp2_fw_update_data_t *>(usrp2_update_data_in_mem);
//Setting up UDP packet
usrp2_fw_update_data_t verify_pkt = usrp2_fw_update_data_t();
- verify_pkt.id = htonx<boost::uint32_t>(USRP2_FW_UPDATE_ID_READ_TEH_FLASHES_LOL);
+ verify_pkt.id = htonx<boost::uint32_t>(READ_FLASH_CMD);
verify_pkt.proto_ver = htonx<boost::uint32_t>(USRP2_FW_PROTO_VERSION);
verify_pkt.data.flash_args.length = htonx<boost::uint32_t>(FLASH_DATA_PACKET_SIZE);
- //Verify image
- if(is_fw) std::cout << "Verifying firmware image." << std::endl;
- else std::cout << "Verifying FPGA image." << std::endl;
-
for(int i = 0; i < ((image_size/FLASH_DATA_PACKET_SIZE)+1); i++){
+ //Print progress
+ std::cout << "\rVerifying " << type << " image ("
+ << int((double(current_addr-begin_addr)/double(image_size))*100) << "%)." << std::flush;
+
verify_pkt.data.flash_args.flash_addr = htonx<boost::uint32_t>(current_addr);
udp_transport->send(boost::asio::buffer(&verify_pkt, sizeof(verify_pkt)));
size_t len = udp_transport->recv(boost::asio::buffer(usrp2_update_data_in_mem), UDP_TIMEOUT);
- if(len > offsetof(usrp2_fw_update_data_t, data) and ntohl(update_data_in->id) != USRP2_FW_UPDATE_ID_KK_READ_TEH_FLASHES_OMG){
- throw std::runtime_error(str(boost::format("Invalid reply %d from device.") % ntohl(update_data_in->id)));
+ if(len > offsetof(usrp2_fw_update_data_t, data) and ntohl(update_data_in->id) != READ_FLASH_ACK){
+ throw std::runtime_error(str(boost::format("Invalid reply %d from device.")
+ % ntohl(update_data_in->id)));
}
for(int j = 0; j < FLASH_DATA_PACKET_SIZE; j++) from_usrp[current_index+j] = update_data_in->data.flash_args.data[j];
@@ -350,27 +461,27 @@ void verify_image(udp_simple::sptr udp_transport, bool is_fw, boost::uint8_t* im
}
for(int i = 0; i < image_size; i++) if(from_usrp[i] != image[i]) throw std::runtime_error("Image write failed.");
+ std::cout << std::flush << "\rVerifying " << type << " image (100%)." << std::endl;
std::cout << " * Successful." << std::endl;
}
void reset_usrp(udp_simple::sptr udp_transport){
//Set up UDP transport
- boost::uint8_t usrp2_update_data_in_mem[udp_simple::mtu];
const usrp2_fw_update_data_t *update_data_in = reinterpret_cast<const usrp2_fw_update_data_t *>(usrp2_update_data_in_mem);
//Set up UDP packet
usrp2_fw_update_data_t reset_pkt = usrp2_fw_update_data_t();
- reset_pkt.id = htonx<boost::uint32_t>(USRP2_FW_UPDATE_ID_RESET_MAH_COMPUTORZ_LOL);
+ reset_pkt.id = htonx<boost::uint32_t>(RESET_USRP_CMD);
reset_pkt.proto_ver = htonx<boost::uint32_t>(USRP2_FW_PROTO_VERSION);
//Reset USRP
udp_transport->send(boost::asio::buffer(&reset_pkt, sizeof(reset_pkt)));
size_t len = udp_transport->recv(boost::asio::buffer(usrp2_update_data_in_mem), UDP_TIMEOUT);
- if(len > offsetof(usrp2_fw_update_data_t, data) and ntohl(update_data_in->id) == USRP2_FW_UPDATE_ID_RESETTIN_TEH_COMPUTORZ_OMG){
+ if(len > offsetof(usrp2_fw_update_data_t, data) and ntohl(update_data_in->id) == RESET_USRP_ACK){
throw std::runtime_error("USRP reset failed."); //There should be no response to this UDP packet
}
- else std::cout << "Resetting USRP." << std::endl;
+ else std::cout << std::endl << "Resetting USRP." << std::endl;
}
int UHD_SAFE_MAIN(int argc, char *argv[]){
@@ -386,125 +497,88 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
("addr", po::value<std::string>(&ip_addr)->default_value("192.168.10.2"), "Specify an IP address.")
("fw", po::value<std::string>(&fw_path), "Specify a filepath for a custom firmware image.")
("fpga", po::value<std::string>(&fpga_path), "Specify a filepath for a custom FPGA image.")
- ("no_fw", "Do not burn a firmware image.")
- ("no_fpga", "Do not burn an FPGA image.")
- ("auto_reboot", "Automatically reboot N2XX without prompting.")
+ ("no-fw", "Do not burn a firmware image.")
+ ("no_fw", "Do not burn a firmware image (DEPRECATED).")
+ ("no-fpga", "Do not burn an FPGA image.")
+ ("no_fpga", "Do not burn an FPGA image (DEPRECATED).")
+ ("auto-reboot", "Automatically reboot N2XX without prompting.")
+ ("auto_reboot", "Automatically reboot N2XX without prompting (DEPRECATED).")
("list", "List available N2XX USRP devices.")
;
po::variables_map vm;
po::store(po::parse_command_line(argc, argv, desc), vm);
po::notify(vm);
- //Apply options
+ //Print help message
if(vm.count("help") > 0){
std::cout << boost::format("N2XX Simple Net Burner\n");
std::cout << boost::format("Automatically detects and burns standard firmware and FPGA images onto USRP N2XX devices.\n");
std::cout << boost::format("Can optionally take user input for custom images.\n\n");
std::cout << desc << std::endl;
- return EXIT_FAILURE;
+ return EXIT_SUCCESS;
}
- bool burn_fpga = (vm.count("no_fpga") == 0);
- bool burn_fw = (vm.count("no_fw") == 0);
+ //List option
+ if(vm.count("list")){
+ list_usrps();
+ return EXIT_SUCCESS;
+ }
+
+ //Process user options
+ bool burn_fpga = (vm.count("no-fpga") == 0) and (vm.count("no_fpga") == 0);
+ bool burn_fw = (vm.count("no-fw") == 0) and (vm.count("no_fw") == 0);
bool use_custom_fpga = (vm.count("fpga") > 0);
bool use_custom_fw = (vm.count("fw") > 0);
- bool list_usrps = (vm.count("list") > 0);
- bool auto_reboot = (vm.count("auto_reboot") > 0);
+ bool auto_reboot = (vm.count("auto-reboot") > 0) or (vm.count("auto_reboot") > 0);
+ int fpga_image_size = 0;
+ int fw_image_size = 0;
- if(!burn_fpga && !burn_fw){
+ if(not burn_fpga && not burn_fw){
std::cout << "No images will be burned." << std::endl;
return EXIT_FAILURE;
}
- if(!burn_fw && use_custom_fw) std::cout << boost::format("Conflicting firmware options presented. Will not burn a firmware image.\n\n");
- if(!burn_fpga && use_custom_fpga) std::cout << boost::format("Conflicting FPGA options presented. Will not burn an FPGA image.\n\n");
-
- //Variables not from options
- boost::uint32_t hw_rev;
- bool found_it = false;
- boost::uint8_t usrp2_update_data_in_mem[udp_simple::mtu];
- const usrp2_fw_update_data_t *update_data_in = reinterpret_cast<const usrp2_fw_update_data_t *>(usrp2_update_data_in_mem);
-
- //List option
- if(list_usrps){
- udp_simple::sptr udp_bc_transport;
- usrp2_fw_update_data_t usrp2_ack_pkt = usrp2_fw_update_data_t();
- usrp2_ack_pkt.proto_ver = htonx<boost::uint32_t>(USRP2_FW_PROTO_VERSION);
- usrp2_ack_pkt.id = htonx<boost::uint32_t>(USRP2_FW_UPDATE_ID_OHAI_LOL);
-
- std::cout << "Available USRP N2XX devices:" << std::endl;
-
- //Send UDP packets to all broadcast addresses
- BOOST_FOREACH(const if_addrs_t &if_addrs, get_if_addrs()){
- //Avoid the loopback device
- if(if_addrs.inet == boost::asio::ip::address_v4::loopback().to_string()) continue;
- udp_bc_transport = udp_simple::make_broadcast(if_addrs.bcast, BOOST_STRINGIZE(USRP2_UDP_UPDATE_PORT));
- udp_bc_transport->send(boost::asio::buffer(&usrp2_ack_pkt, sizeof(usrp2_ack_pkt)));
-
- size_t len = udp_bc_transport->recv(boost::asio::buffer(usrp2_update_data_in_mem), UDP_TIMEOUT);
- if(len > offsetof(usrp2_fw_update_data_t, data) and ntohl(update_data_in->id) == USRP2_FW_UPDATE_ID_OHAI_OMG){
- usrp2_ack_pkt.id = htonx<boost::uint32_t>(USRP2_FW_UPDATE_ID_I_CAN_HAS_HW_REV_LOL);
- udp_bc_transport->send(boost::asio::buffer(&usrp2_ack_pkt, sizeof(usrp2_ack_pkt)));
-
- size_t len = udp_bc_transport->recv(boost::asio::buffer(usrp2_update_data_in_mem), UDP_TIMEOUT);
- if(len > offsetof(usrp2_fw_update_data_t, data) and ntohl(update_data_in->id) == USRP2_FW_UPDATE_ID_HERES_TEH_HW_REV_OMG){
- hw_rev = ntohl(update_data_in->data.hw_rev);
- }
+ //Print deprecation messages if necessary
+ if(vm.count("no_fpga") > 0) std::cout << "WARNING: --no_fpga option is deprecated! Use --no-fpga instead." << std::endl << std::endl;
+ if(vm.count("no_fw") > 0) std::cout << "WARNING: --no_fw option is deprecated! Use --no-fw instead." << std::endl << std::endl;
+ if(vm.count("auto_reboot") > 0) std::cout << "WARNING: --auto_reboot option is deprecated! Use --auto-reboot instead." << std::endl << std::endl;
- std::cout << boost::format(" * %s (%s)\n") % udp_bc_transport->get_recv_addr() % filename_map[hw_rev];
- }
-
- }
- return EXIT_FAILURE;
- }
+ //Find USRP and establish connection
std::cout << boost::format("Searching for USRP N2XX with IP address %s.\n") % ip_addr;
-
- //Address specified
udp_simple::sptr udp_transport = udp_simple::make_connected(ip_addr, BOOST_STRINGIZE(USRP2_UDP_UPDATE_PORT));
- usrp2_fw_update_data_t hw_info_pkt = usrp2_fw_update_data_t();
- hw_info_pkt.proto_ver = htonx<boost::uint32_t>(USRP2_FW_PROTO_VERSION);
- hw_info_pkt.id = htonx<boost::uint32_t>(USRP2_FW_UPDATE_ID_I_CAN_HAS_HW_REV_LOL);
- udp_transport->send(boost::asio::buffer(&hw_info_pkt, sizeof(hw_info_pkt)));
-
- //Loop and receive until the timeout
- size_t len = udp_transport->recv(boost::asio::buffer(usrp2_update_data_in_mem), UDP_TIMEOUT);
- if(len > offsetof(usrp2_fw_update_data_t, data) and ntohl(update_data_in->id) == USRP2_FW_UPDATE_ID_HERES_TEH_HW_REV_OMG){
- hw_rev = ntohl(update_data_in->data.hw_rev);
- if(filename_map.find(hw_rev) != filename_map.end()){
- std::cout << boost::format("Found %s.\n\n") % filename_map[hw_rev];
- found_it = true;
- }
- else throw std::runtime_error("Invalid revision found.");
- }
- if(!found_it) throw std::runtime_error("No USRP N2XX found.");
-
- //Determining default image filenames for validation
- std::string default_fw_filename = str(boost::format("usrp_%s_fw.bin") % erase_tail_copy(filename_map[hw_rev],3));
- std::string default_fpga_filename = str(boost::format("usrp_%s_fpga.bin") % filename_map[hw_rev]);
- std::string default_fw_filepath = "";
- std::string default_fpga_filepath = "";
+ boost::uint32_t hw_rev = find_usrp(udp_transport);
//Check validity of file locations and binaries before attempting burn
std::cout << "Searching for specified images." << std::endl << std::endl;
if(burn_fpga){
- if(!use_custom_fpga) fpga_path = find_image_path(default_fpga_filename);
- else{
- //Replace ~ with home directory
- if(fpga_path.find("~/") == 0) fpga_path.replace(0,1,getenv("HOME"));
+ if(use_custom_fpga){
+ //Expand tilde usage if applicable
+ #ifndef UHD_PLATFORM_WIN32
+ if(fpga_path.find("~/") == 0) fpga_path.replace(0,1,getenv("HOME"));
+ #endif
validate_custom_fpga_file(filename_map[hw_rev], fpga_path);
}
+ else{
+ std::string default_fpga_filename = str(boost::format("usrp_%s_fpga.bin") % filename_map[hw_rev]);
+ fpga_path = find_image_path(default_fpga_filename);
+ }
- grab_fpga_image(fpga_path);
+ fpga_image_size = read_fpga_image(fpga_path);
}
if(burn_fw){
- if(!use_custom_fw) fw_path = find_image_path(default_fw_filename);
- else{
- //Replace ~ with home directory
- if(fw_path.find("~/") == 0) fw_path.replace(0,1,getenv("HOME"));
+ if(use_custom_fw){
+ //Expand tilde usage if applicable
+ #ifndef UHD_PLATFORM_WIN32
+ if(fw_path.find("~/") == 0) fw_path.replace(0,1,getenv("HOME"));
+ #endif
validate_custom_fw_file(filename_map[hw_rev], fw_path);
}
+ else{
+ std::string default_fw_filename = str(boost::format("usrp_%s_fw.bin") % erase_tail_copy(filename_map[hw_rev],3));
+ fw_path = find_image_path(default_fw_filename);
+ }
- grab_fw_image(fw_path);
+ fw_image_size = read_fw_image(fw_path);
}
std::cout << "Will burn the following images:" << std::endl;
@@ -547,7 +621,6 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
std::cout << std::endl; //Formatting
}
if(reset) reset_usrp(udp_transport);
- else return EXIT_SUCCESS;
return EXIT_SUCCESS;
}
diff --git a/host/utils/usrp_simple_burner_utils.hpp b/host/utils/usrp_simple_burner_utils.hpp
deleted file mode 100644
index f386c3620..000000000
--- a/host/utils/usrp_simple_burner_utils.hpp
+++ /dev/null
@@ -1,99 +0,0 @@
-//
-// Copyright 2012 Ettus Research LLC
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program. If not, see <http://www.gnu.org/licenses/>.
-//
-
-#include <iostream>
-#include <math.h>
-#include <stdint.h>
-
-#include <boost/foreach.hpp>
-#include <boost/asio.hpp>
-#include <boost/filesystem.hpp>
-
-#include <uhd/exception.hpp>
-#include <uhd/transport/if_addrs.hpp>
-#include <uhd/transport/udp_simple.hpp>
-#include <uhd/types/device_addr.hpp>
-#include <uhd/utils/msg.hpp>
-
-#define UDP_FW_UPDATE_PORT 49154
-#define UDP_MAX_XFER_BYTES 1024
-#define UDP_TIMEOUT 3
-#define UDP_POLL_INTERVAL 0.10 //in seconds
-#define USRP2_FW_PROTO_VERSION 7 //should be unused after r6
-#define USRP2_UDP_UPDATE_PORT 49154
-#define FLASH_DATA_PACKET_SIZE 256
-#define FPGA_IMAGE_SIZE_BYTES 1572864
-#define FW_IMAGE_SIZE_BYTES 31744
-#define PROD_FPGA_IMAGE_LOCATION_ADDR 0x00180000
-#define PROD_FW_IMAGE_LOCATION_ADDR 0x00300000
-#define SAFE_FPGA_IMAGE_LOCATION_ADDR 0x00000000
-#define SAFE_FW_IMAGE_LOCATION_ADDR 0x003F0000
-
-using namespace uhd;
-using namespace uhd::transport;
-namespace asio = boost::asio;
-
-typedef enum {
- USRP2_FW_UPDATE_ID_WAT = ' ',
-
- USRP2_FW_UPDATE_ID_OHAI_LOL = 'a',
- USRP2_FW_UPDATE_ID_OHAI_OMG = 'A',
-
- USRP2_FW_UPDATE_ID_WATS_TEH_FLASH_INFO_LOL = 'f',
- USRP2_FW_UPDATE_ID_HERES_TEH_FLASH_INFO_OMG = 'F',
-
- USRP2_FW_UPDATE_ID_ERASE_TEH_FLASHES_LOL = 'e',
- USRP2_FW_UPDATE_ID_ERASING_TEH_FLASHES_OMG = 'E',
-
- USRP2_FW_UPDATE_ID_R_U_DONE_ERASING_LOL = 'd',
- USRP2_FW_UPDATE_ID_IM_DONE_ERASING_OMG = 'D',
- USRP2_FW_UPDATE_ID_NOPE_NOT_DONE_ERASING_OMG = 'B',
-
- USRP2_FW_UPDATE_ID_WRITE_TEH_FLASHES_LOL = 'w',
- USRP2_FW_UPDATE_ID_WROTE_TEH_FLASHES_OMG = 'W',
-
- USRP2_FW_UPDATE_ID_READ_TEH_FLASHES_LOL = 'r',
- USRP2_FW_UPDATE_ID_KK_READ_TEH_FLASHES_OMG = 'R',
-
- USRP2_FW_UPDATE_ID_RESET_MAH_COMPUTORZ_LOL = 's',
- USRP2_FW_UPDATE_ID_RESETTIN_TEH_COMPUTORZ_OMG = 'S',
-
- USRP2_FW_UPDATE_ID_I_CAN_HAS_HW_REV_LOL = 'v',
- USRP2_FW_UPDATE_ID_HERES_TEH_HW_REV_OMG = 'V',
-
- USRP2_FW_UPDATE_ID_KTHXBAI = '~'
-
-} usrp2_fw_update_id_t;
-
-typedef struct {
- uint32_t proto_ver;
- uint32_t id;
- uint32_t seq;
- union {
- uint32_t ip_addr;
- uint32_t hw_rev;
- struct {
- uint32_t flash_addr;
- uint32_t length;
- uint8_t data[256];
- } flash_args;
- struct {
- uint32_t sector_size_bytes;
- uint32_t memory_size_bytes;
- } flash_info_args;
- } data;
-} usrp2_fw_update_data_t;
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-15 14:26:00 +0000