examples: Whitespace and other cleanup

8 files changed, 174 insertions, 196 deletions

diff --git a/host/examples/benchmark_rate.cpp b/host/examples/benchmark_rate.cpp
index 03d8f3477..aa2489325 100644
--- a/host/examples/benchmark_rate.cpp
+++ b/host/examples/benchmark_rate.cpp
@@ -287,6 +287,5 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
 
     //finished
     std::cout << std::endl << "Done!" << std::endl << std::endl;
-   
     return EXIT_SUCCESS;
 }
diff --git a/host/examples/rx_samples_to_file.cpp b/host/examples/rx_samples_to_file.cpp
index fa3c21114..930e92125 100644
--- a/host/examples/rx_samples_to_file.cpp
+++ b/host/examples/rx_samples_to_file.cpp
@@ -56,7 +56,7 @@ template<typename samp_type> void recv_to_file(
     std::vector<samp_type> buff(samps_per_buff);
     std::ofstream outfile;
     if (not null)
-		outfile.open(file.c_str(), std::ofstream::binary);
+        outfile.open(file.c_str(), std::ofstream::binary);
     bool overflow_message = true;
 
     //setup streaming
@@ -78,8 +78,8 @@ template<typename samp_type> void recv_to_file(
     typedef std::map<size_t,size_t> SizeMap;
     SizeMap mapSizes;
 
-    while(not stop_signal_called and (num_requested_samples != num_total_samps or num_requested_samples == 0)){
-		boost::system_time now = boost::get_system_time();
+    while(not stop_signal_called and (num_requested_samples != num_total_samps or num_requested_samples == 0)) {
+        boost::system_time now = boost::get_system_time();
 
         size_t num_rx_samps = rx_stream->recv(&buff.front(), buff.size(), md, 3.0, enable_size_map);
 
@@ -88,7 +88,7 @@ template<typename samp_type> void recv_to_file(
             break;
         }
         if (md.error_code == uhd::rx_metadata_t::ERROR_CODE_OVERFLOW){
-            if (overflow_message){
+            if (overflow_message) {
                 overflow_message = false;
                 std::cerr << boost::format(
                     "Got an overflow indication. Please consider the following:\n"
@@ -110,99 +110,99 @@ template<typename samp_type> void recv_to_file(
                 throw std::runtime_error(error);
         }
 
-        if (enable_size_map){
-			SizeMap::iterator it = mapSizes.find(num_rx_samps);
-			if (it == mapSizes.end())
-				mapSizes[num_rx_samps] = 0;
-			mapSizes[num_rx_samps] += 1;
-		}
+        if (enable_size_map) {
+            SizeMap::iterator it = mapSizes.find(num_rx_samps);
+            if (it == mapSizes.end())
+                mapSizes[num_rx_samps] = 0;
+            mapSizes[num_rx_samps] += 1;
+        }
 
         num_total_samps += num_rx_samps;
 
-		if (outfile.is_open())
-			outfile.write((const char*)&buff.front(), num_rx_samps*sizeof(samp_type));
-
-		if (bw_summary){
-			last_update_samps += num_rx_samps;
-			boost::posix_time::time_duration update_diff = now - last_update;
-			if (update_diff.ticks() > boost::posix_time::time_duration::ticks_per_second()) {
-				double t = (double)update_diff.ticks() / (double)boost::posix_time::time_duration::ticks_per_second();
-				double r = (double)last_update_samps / t;
-				std::cout << boost::format("\t%f Msps") % (r/1e6) << std::endl;
-				last_update_samps = 0;
-				last_update = now;
-			}
-		}
+        if (outfile.is_open())
+            outfile.write((const char*)&buff.front(), num_rx_samps*sizeof(samp_type));
+
+        if (bw_summary) {
+            last_update_samps += num_rx_samps;
+            boost::posix_time::time_duration update_diff = now - last_update;
+            if (update_diff.ticks() > boost::posix_time::time_duration::ticks_per_second()) {
+                double t = (double)update_diff.ticks() / (double)boost::posix_time::time_duration::ticks_per_second();
+                double r = (double)last_update_samps / t;
+                std::cout << boost::format("\t%f Msps") % (r/1e6) << std::endl;
+                last_update_samps = 0;
+                last_update = now;
+            }
+        }
 
         ticks_diff = now - start;
-		if (ticks_requested > 0){
-			if ((unsigned long long)ticks_diff.ticks() > ticks_requested)
-				break;
-		}
+        if (ticks_requested > 0){
+            if ((unsigned long long)ticks_diff.ticks() > ticks_requested)
+                break;
+        }
     }
 
     stream_cmd.stream_mode = uhd::stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS;
     rx_stream->issue_stream_cmd(stream_cmd);
 
     if (outfile.is_open())
-		outfile.close();
-
-    if (stats){
-		std::cout << std::endl;
-
-		double t = (double)ticks_diff.ticks() / (double)boost::posix_time::time_duration::ticks_per_second();
-		std::cout << boost::format("Received %d samples in %f seconds") % num_total_samps % t << std::endl;
-		double r = (double)num_total_samps / t;
-		std::cout << boost::format("%f Msps") % (r/1e6) << std::endl;
-
-		if (enable_size_map) {
-			std::cout << std::endl;
-			std::cout << "Packet size map (bytes: count)" << std::endl;
-			for (SizeMap::iterator it = mapSizes.begin(); it != mapSizes.end(); it++)
-				std::cout << it->first << ":\t" << it->second << std::endl;
-		}
-	}
+        outfile.close();
+
+    if (stats) {
+        std::cout << std::endl;
+
+        double t = (double)ticks_diff.ticks() / (double)boost::posix_time::time_duration::ticks_per_second();
+        std::cout << boost::format("Received %d samples in %f seconds") % num_total_samps % t << std::endl;
+        double r = (double)num_total_samps / t;
+        std::cout << boost::format("%f Msps") % (r/1e6) << std::endl;
+
+        if (enable_size_map) {
+            std::cout << std::endl;
+            std::cout << "Packet size map (bytes: count)" << std::endl;
+            for (SizeMap::iterator it = mapSizes.begin(); it != mapSizes.end(); it++)
+                std::cout << it->first << ":\t" << it->second << std::endl;
+        }
+    }
 }
 
 typedef boost::function<uhd::sensor_value_t (const std::string&)> get_sensor_fn_t;
 
 bool check_locked_sensor(std::vector<std::string> sensor_names, const char* sensor_name, get_sensor_fn_t get_sensor_fn, double setup_time){
-	if (std::find(sensor_names.begin(), sensor_names.end(), sensor_name) == sensor_names.end())
-		return false;
-
-	boost::system_time start = boost::get_system_time();
-	boost::system_time first_lock_time;
-
-	std::cout << boost::format("Waiting for \"%s\": ") % sensor_name;
-	std::cout.flush();
-
-	while (true){
-		if ((not first_lock_time.is_not_a_date_time()) and
-			(boost::get_system_time() > (first_lock_time + boost::posix_time::seconds(setup_time))))
-		{
-			std::cout << " locked." << std::endl;
-			break;
-		}
-		if (get_sensor_fn(sensor_name).to_bool()){
-			if (first_lock_time.is_not_a_date_time())
-				first_lock_time = boost::get_system_time();
-			std::cout << "+";
-			std::cout.flush();
-		}
-		else{
-			first_lock_time = boost::system_time();	//reset to 'not a date time'
-
-			if (boost::get_system_time() > (start + boost::posix_time::seconds(setup_time))){
-				std::cout << std::endl;
-				throw std::runtime_error(str(boost::format("timed out waiting for consecutive locks on sensor \"%s\"") % sensor_name));
-			}
-			std::cout << "_";
-			std::cout.flush();
-		}
-		boost::this_thread::sleep(boost::posix_time::milliseconds(100));
-	}
-	std::cout << std::endl;
-	return true;
+    if (std::find(sensor_names.begin(), sensor_names.end(), sensor_name) == sensor_names.end())
+        return false;
+
+    boost::system_time start = boost::get_system_time();
+    boost::system_time first_lock_time;
+
+    std::cout << boost::format("Waiting for \"%s\": ") % sensor_name;
+    std::cout.flush();
+
+    while (true) {
+        if ((not first_lock_time.is_not_a_date_time()) and
+                (boost::get_system_time() > (first_lock_time + boost::posix_time::seconds(setup_time))))
+        {
+            std::cout << " locked." << std::endl;
+            break;
+        }
+        if (get_sensor_fn(sensor_name).to_bool()){
+            if (first_lock_time.is_not_a_date_time())
+                first_lock_time = boost::get_system_time();
+            std::cout << "+";
+            std::cout.flush();
+        }
+        else {
+            first_lock_time = boost::system_time();	//reset to 'not a date time'
+
+            if (boost::get_system_time() > (start + boost::posix_time::seconds(setup_time))){
+                std::cout << std::endl;
+                throw std::runtime_error(str(boost::format("timed out waiting for consecutive locks on sensor \"%s\"") % sensor_name));
+            }
+            std::cout << "_";
+            std::cout.flush();
+        }
+        boost::this_thread::sleep(boost::posix_time::milliseconds(100));
+    }
+    std::cout << std::endl;
+    return true;
 }
 
 int UHD_SAFE_MAIN(int argc, char *argv[]){
@@ -246,8 +246,12 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
     po::notify(vm);
 
     //print the help message
-    if (vm.count("help")){
+    if (vm.count("help")) {
         std::cout << boost::format("UHD RX samples to file %s") % desc << std::endl;
+        std::cout
+            << std::endl
+            << "This application streams data from a single channel of a USRP device to a file.\n"
+            << std::endl;
         return ~0;
     }
 
@@ -258,7 +262,7 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
     bool continue_on_bad_packet = vm.count("continue") > 0;
 
     if (enable_size_map)
-		std::cout << "Packet size tracking enabled - will only recv one packet at a time!" << std::endl;
+        std::cout << "Packet size tracking enabled - will only recv one packet at a time!" << std::endl;
 
     //create a usrp device
     std::cout << std::endl;
@@ -283,23 +287,23 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
     std::cout << boost::format("Actual RX Rate: %f Msps...") % (usrp->get_rx_rate()/1e6) << std::endl << std::endl;
 
     //set the center frequency
-    if (vm.count("freq")){	//with default of 0.0 this will always be true
-		std::cout << boost::format("Setting RX Freq: %f MHz...") % (freq/1e6) << std::endl;
+    if (vm.count("freq")) { //with default of 0.0 this will always be true
+        std::cout << boost::format("Setting RX Freq: %f MHz...") % (freq/1e6) << std::endl;
         uhd::tune_request_t tune_request(freq);
         if(vm.count("int-n")) tune_request.args = uhd::device_addr_t("mode_n=integer");
-		usrp->set_rx_freq(tune_request);
-		std::cout << boost::format("Actual RX Freq: %f MHz...") % (usrp->get_rx_freq()/1e6) << std::endl << std::endl;
-	}
+        usrp->set_rx_freq(tune_request);
+        std::cout << boost::format("Actual RX Freq: %f MHz...") % (usrp->get_rx_freq()/1e6) << std::endl << std::endl;
+    }
 
     //set the rf gain
-    if (vm.count("gain")){
+    if (vm.count("gain")) {
         std::cout << boost::format("Setting RX Gain: %f dB...") % gain << std::endl;
         usrp->set_rx_gain(gain);
         std::cout << boost::format("Actual RX Gain: %f dB...") % usrp->get_rx_gain() << std::endl << std::endl;
     }
 
     //set the IF filter bandwidth
-    if (vm.count("bw")){
+    if (vm.count("bw")) {
         std::cout << boost::format("Setting RX Bandwidth: %f MHz...") % bw << std::endl;
         usrp->set_rx_bandwidth(bw);
         std::cout << boost::format("Actual RX Bandwidth: %f MHz...") % usrp->get_rx_bandwidth() << std::endl << std::endl;
@@ -312,12 +316,12 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
 
     //check Ref and LO Lock detect
     if (not vm.count("skip-lo")){
-		check_locked_sensor(usrp->get_rx_sensor_names(0), "lo_locked", boost::bind(&uhd::usrp::multi_usrp::get_rx_sensor, usrp, _1, 0), setup_time);
-		if (ref == "mimo")
-			check_locked_sensor(usrp->get_mboard_sensor_names(0), "mimo_locked", boost::bind(&uhd::usrp::multi_usrp::get_mboard_sensor, usrp, _1, 0), setup_time);
-		if (ref == "external")
-			check_locked_sensor(usrp->get_mboard_sensor_names(0), "ref_locked", boost::bind(&uhd::usrp::multi_usrp::get_mboard_sensor, usrp, _1, 0), setup_time);
-	}
+        check_locked_sensor(usrp->get_rx_sensor_names(0), "lo_locked", boost::bind(&uhd::usrp::multi_usrp::get_rx_sensor, usrp, _1, 0), setup_time);
+        if (ref == "mimo")
+            check_locked_sensor(usrp->get_mboard_sensor_names(0), "mimo_locked", boost::bind(&uhd::usrp::multi_usrp::get_mboard_sensor, usrp, _1, 0), setup_time);
+        if (ref == "external")
+            check_locked_sensor(usrp->get_mboard_sensor_names(0), "ref_locked", boost::bind(&uhd::usrp::multi_usrp::get_mboard_sensor, usrp, _1, 0), setup_time);
+    }
 
     if (total_num_samps == 0){
         std::signal(SIGINT, &sig_int_handler);
@@ -325,7 +329,7 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
     }
 
 #define recv_to_file_args(format) \
-	(usrp, format, wirefmt, file, spb, total_num_samps, total_time, bw_summary, stats, null, enable_size_map, continue_on_bad_packet)
+    (usrp, format, wirefmt, file, spb, total_num_samps, total_time, bw_summary, stats, null, enable_size_map, continue_on_bad_packet)
     //recv to file
     if (type == "double") recv_to_file<std::complex<double> >recv_to_file_args("fc64");
     else if (type == "float") recv_to_file<std::complex<float> >recv_to_file_args("fc32");
diff --git a/host/examples/rx_timed_samples.cpp b/host/examples/rx_timed_samples.cpp
index 30535907f..20abd92fe 100644
--- a/host/examples/rx_timed_samples.cpp
+++ b/host/examples/rx_timed_samples.cpp
@@ -48,7 +48,6 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
         ("rate", po::value<double>(&rate)->default_value(100e6/16), "rate of incoming samples")
         ("dilv", "specify to disable inner-loop verbose")
         ("channels", po::value<std::string>(&channel_list)->default_value("0"), "which channel(s) to use (specify \"0\", \"1\", \"0,1\", etc)")
-    
     ;
     po::variables_map vm;
     po::store(po::parse_command_line(argc, argv, desc), vm);
diff --git a/host/examples/test_pps_input.cpp b/host/examples/test_pps_input.cpp
index 889c98a45..3e6c4ba9d 100644
--- a/host/examples/test_pps_input.cpp
+++ b/host/examples/test_pps_input.cpp
@@ -47,6 +47,11 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
     //print the help message
     if (vm.count("help")){
         std::cout << boost::format("UHD Test PPS Input %s") % desc << std::endl;
+        std::cout
+                << std::endl
+                << "Tests if the PPS input signal is working. Will throw an error if not."
+                << std::endl
+                << std::endl;
         return ~0;
     }
 
diff --git a/host/examples/tx_bursts.cpp b/host/examples/tx_bursts.cpp
index fec89a0e4..bb71d4581 100644
--- a/host/examples/tx_bursts.cpp
+++ b/host/examples/tx_bursts.cpp
@@ -148,7 +148,6 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
             size_t num_tx_samps = tx_stream->send(
                 buffs, samps_to_send, md, timeout
             );
-                
             //do not use time spec for subsequent packets
             md.has_time_spec = false;
             md.start_of_burst = false;
diff --git a/host/examples/tx_waveforms.cpp b/host/examples/tx_waveforms.cpp
index a233cecb1..73bcb13ac 100644
--- a/host/examples/tx_waveforms.cpp
+++ b/host/examples/tx_waveforms.cpp
@@ -15,6 +15,7 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 //
 
+#include "wavetable.hpp"
 #include <uhd/utils/thread_priority.hpp>
 #include <uhd/utils/safe_main.hpp>
 #include <uhd/utils/static.hpp>
@@ -28,9 +29,7 @@
 #include <boost/lexical_cast.hpp>
 #include <boost/algorithm/string.hpp>
 #include <iostream>
-#include <complex>
 #include <csignal>
-#include <cmath>
 
 namespace po = boost::program_options;
 
@@ -41,52 +40,6 @@ static bool stop_signal_called = false;
 void sig_int_handler(int){stop_signal_called = true;}
 
 /***********************************************************************
- * Waveform generators
- **********************************************************************/
-static const size_t wave_table_len = 8192;
-
-class wave_table_class{
-public:
-    wave_table_class(const std::string &wave_type, const float ampl):
-        _wave_table(wave_table_len)
-    {
-        //compute real wave table with 1.0 amplitude
-        std::vector<double> real_wave_table(wave_table_len);
-        if (wave_type == "CONST"){
-            for (size_t i = 0; i < wave_table_len; i++)
-                real_wave_table[i] = 1.0;
-        }
-        else if (wave_type == "SQUARE"){
-            for (size_t i = 0; i < wave_table_len; i++)
-                real_wave_table[i] = (i < wave_table_len/2)? 0.0 : 1.0;
-        }
-        else if (wave_type == "RAMP"){
-            for (size_t i = 0; i < wave_table_len; i++)
-                real_wave_table[i] = 2.0*i/(wave_table_len-1) - 1.0;
-        }
-        else if (wave_type == "SINE"){
-            static const double tau = 2*std::acos(-1.0);
-            for (size_t i = 0; i < wave_table_len; i++)
-                real_wave_table[i] = std::sin((tau*i)/wave_table_len);
-        }
-        else throw std::runtime_error("unknown waveform type: " + wave_type);
-
-        //compute i and q pairs with 90% offset and scale to amplitude
-        for (size_t i = 0; i < wave_table_len; i++){
-            const size_t q = (i+(3*wave_table_len)/4)%wave_table_len;
-            _wave_table[i] = std::complex<float>(ampl*real_wave_table[i], ampl*real_wave_table[q]);
-        }
-    }
-
-    inline std::complex<float> operator()(const size_t index) const{
-        return _wave_table[index % wave_table_len];
-    }
-
-private:
-    std::vector<std::complex<float> > _wave_table;
-};
-
-/***********************************************************************
  * Main function
  **********************************************************************/
 int UHD_SAFE_MAIN(int argc, char *argv[]){
diff --git a/host/examples/txrx_loopback_to_file.cpp b/host/examples/txrx_loopback_to_file.cpp
index a62ccd7b2..5cc238aa9 100644
--- a/host/examples/txrx_loopback_to_file.cpp
+++ b/host/examples/txrx_loopback_to_file.cpp
@@ -15,6 +15,7 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 //
 
+#include "wavetable.hpp"
 #include <uhd/types/tune_request.hpp>
 #include <uhd/utils/thread_priority.hpp>
 #include <uhd/utils/safe_main.hpp>
@@ -30,9 +31,7 @@
 #include <boost/algorithm/string.hpp>
 #include <iostream>
 #include <fstream>
-#include <complex>
 #include <csignal>
-#include <cmath>
 
 namespace po = boost::program_options;
 
@@ -43,52 +42,6 @@ static bool stop_signal_called = false;
 void sig_int_handler(int){stop_signal_called = true;}
 
 /***********************************************************************
- * Waveform generators
- **********************************************************************/
-static const size_t wave_table_len = 8192;
-
-class wave_table_class{
-public:
-    wave_table_class(const std::string &wave_type, const float ampl):
-        _wave_table(wave_table_len)
-    {
-        //compute real wave table with 1.0 amplitude
-        std::vector<double> real_wave_table(wave_table_len);
-        if (wave_type == "CONST"){
-            for (size_t i = 0; i < wave_table_len; i++)
-                real_wave_table[i] = 1.0;
-        }
-        else if (wave_type == "SQUARE"){
-            for (size_t i = 0; i < wave_table_len; i++)
-                real_wave_table[i] = (i < wave_table_len/2)? 0.0 : 1.0;
-        }
-        else if (wave_type == "RAMP"){
-            for (size_t i = 0; i < wave_table_len; i++)
-                real_wave_table[i] = 2.0*i/(wave_table_len-1) - 1.0;
-        }
-        else if (wave_type == "SINE"){
-            static const double tau = 2*std::acos(-1.0);
-            for (size_t i = 0; i < wave_table_len; i++)
-                real_wave_table[i] = std::sin((tau*i)/wave_table_len);
-        }
-        else throw std::runtime_error("unknown waveform type: " + wave_type);
-
-        //compute i and q pairs with 90% offset and scale to amplitude
-        for (size_t i = 0; i < wave_table_len; i++){
-            const size_t q = (i+(3*wave_table_len)/4)%wave_table_len;
-            _wave_table[i] = std::complex<float>(ampl*real_wave_table[i], ampl*real_wave_table[q]);
-        }
-    }
-
-    inline std::complex<float> operator()(const size_t index) const{
-        return _wave_table[index % wave_table_len];
-    }
-
-private:
-    std::vector<std::complex<float> > _wave_table;
-};
-
-/***********************************************************************
  * transmit_worker function
  * A function to be used as a boost::thread_group thread for transmitting
  **********************************************************************/
diff --git a/host/examples/wavetable.hpp b/host/examples/wavetable.hpp
new file mode 100644
index 000000000..d7ffc8406
--- /dev/null
+++ b/host/examples/wavetable.hpp
@@ -0,0 +1,66 @@
+//
+// Copyright 2010-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
+// 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 <string>
+#include <cmath>
+#include <complex>
+#include <vector>
+#include <stdexcept>
+
+static const size_t wave_table_len = 8192;
+
+class wave_table_class{
+public:
+    wave_table_class(const std::string &wave_type, const float ampl):
+        _wave_table(wave_table_len)
+    {
+        //compute real wave table with 1.0 amplitude
+        std::vector<double> real_wave_table(wave_table_len);
+        if (wave_type == "CONST"){
+            for (size_t i = 0; i < wave_table_len; i++)
+                real_wave_table[i] = 1.0;
+        }
+        else if (wave_type == "SQUARE"){
+            for (size_t i = 0; i < wave_table_len; i++)
+                real_wave_table[i] = (i < wave_table_len/2)? 0.0 : 1.0;
+        }
+        else if (wave_type == "RAMP"){
+            for (size_t i = 0; i < wave_table_len; i++)
+                real_wave_table[i] = 2.0*i/(wave_table_len-1) - 1.0;
+        }
+        else if (wave_type == "SINE"){
+            static const double tau = 2*std::acos(-1.0);
+            for (size_t i = 0; i < wave_table_len; i++)
+                real_wave_table[i] = std::sin((tau*i)/wave_table_len);
+        }
+        else throw std::runtime_error("unknown waveform type: " + wave_type);
+
+        //compute i and q pairs with 90% offset and scale to amplitude
+        for (size_t i = 0; i < wave_table_len; i++){
+            const size_t q = (i+(3*wave_table_len)/4)%wave_table_len;
+            _wave_table[i] = std::complex<float>(ampl*real_wave_table[i], ampl*real_wave_table[q]);
+        }
+    }
+
+    inline std::complex<float> operator()(const size_t index) const{
+        return _wave_table[index % wave_table_len];
+    }
+
+private:
+    std::vector<std::complex<float> > _wave_table;
+};
+