Created a common usrp dsp utils to handle register word calculations.

(also switched to boost endian define to avoid c compiler check)

5 files changed, 127 insertions, 58 deletions

diff --git a/host/lib/transport/convert_types.cpp b/host/lib/transport/convert_types.cpp
index 43503025a..374479eee 100644
--- a/host/lib/transport/convert_types.cpp
+++ b/host/lib/transport/convert_types.cpp
@@ -20,6 +20,7 @@
 #include <uhd/utils/assert.hpp>
 #include <boost/asio.hpp> //endianness conversion
 #include <boost/cstdint.hpp>
+#include <boost/detail/endian.hpp>
 #include <complex>
 
 using namespace uhd;
@@ -44,7 +45,7 @@ static const float floats_per_short = float(1.0/shorts_per_float);
 }
 
 // set a boolean flag that indicates the endianess
-#ifdef HAVE_BIG_ENDIAN
+#ifdef BOOST_BIG_ENDIAN
 static const bool is_big_endian = true;
 #else
 static const bool is_big_endian = false;
diff --git a/host/lib/transport/gen_vrt.py b/host/lib/transport/gen_vrt.py
index 1417240ab..3279ae225 100755
--- a/host/lib/transport/gen_vrt.py
+++ b/host/lib/transport/gen_vrt.py
@@ -33,10 +33,11 @@ TMPL_TEXT = """
 
 \#include <uhd/transport/vrt.hpp>
 \#include <uhd/utils/byteswap.hpp>
+\#include <boost/detail/endian.hpp>
 \#include <stdexcept>
 
 //define the endian macros to convert integers
-\#ifdef HAVE_BIG_ENDIAN
+\#ifdef BOOST_BIG_ENDIAN
     \#define BE_MACRO(x) (x)
     \#define LE_MACRO(x) uhd::byteswap(x)
 \#else
diff --git a/host/lib/usrp/CMakeLists.txt b/host/lib/usrp/CMakeLists.txt
index 39a72ab37..3e12c087e 100644
--- a/host/lib/usrp/CMakeLists.txt
+++ b/host/lib/usrp/CMakeLists.txt
@@ -22,6 +22,7 @@ LIBUHD_APPEND_SOURCES(
     ${CMAKE_SOURCE_DIR}/lib/usrp/dboard_eeprom.cpp
     ${CMAKE_SOURCE_DIR}/lib/usrp/dboard_id.cpp
     ${CMAKE_SOURCE_DIR}/lib/usrp/dboard_manager.cpp
+    ${CMAKE_SOURCE_DIR}/lib/usrp/dsp_utils.hpp
     ${CMAKE_SOURCE_DIR}/lib/usrp/simple_usrp.cpp
     ${CMAKE_SOURCE_DIR}/lib/usrp/tune_helper.cpp
 )
diff --git a/host/lib/usrp/dsp_utils.hpp b/host/lib/usrp/dsp_utils.hpp
new file mode 100644
index 000000000..8a6afb292
--- /dev/null
+++ b/host/lib/usrp/dsp_utils.hpp
@@ -0,0 +1,115 @@
+//
+// Copyright 2010 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/>.
+//
+
+#ifndef INCLUDED_LIBUHD_USRP_DSP_UTILS_HPP
+#define INCLUDED_LIBUHD_USRP_DSP_UTILS_HPP
+
+#include <uhd/config.hpp>
+#include <uhd/utils/assert.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/math/special_functions/round.hpp>
+
+namespace uhd{ namespace usrp{
+
+namespace dsp_type1{
+
+    template <class T> T ceil_log2(T num){
+        return std::ceil(std::log(num)/std::log(T(2)));
+    }
+
+    /*!
+     * Calculate the cordic word from the frequency and clock rate.
+     * The frequency will be set to the actual (possible) frequency.
+     *
+     * \param freq the requested frequency in Hz
+     * \param codec_rate the dsp codec rate in Hz
+     * \param the 32-bit cordic control word
+     */
+    static inline boost::uint32_t calc_cordic_word_and_update(
+        double &freq,
+        double codec_rate
+    ){
+        UHD_ASSERT_THROW(std::abs(freq) < codec_rate/2.0);
+        static const double scale_factor = std::pow(2.0, 32);
+
+        //calculate the freq register word
+        boost::uint32_t freq_word = boost::math::iround((freq / codec_rate) * scale_factor);
+
+        //update the actual frequency
+        freq = (double(freq_word) / scale_factor) * codec_rate;
+
+        return freq_word;
+    }
+
+    /*!
+     * Calculate the CIC filter word from the rate.
+     * Check if requested decim/interp rate is:
+     *      multiple of 4, enable two halfband filters
+     *      multiple of 2, enable one halfband filter
+     *      handle remainder in CIC
+     *
+     * \param rate the requested rate in Sps
+     * \return the 32-bit cic filter control word
+     */
+    template <typename dsp_rate_type>
+    static inline boost::uint32_t calc_cic_filter_word(dsp_rate_type rate){
+        int hb0 = 0, hb1 = 0;
+        if (not (rate & 0x1)){
+            hb0 = 1;
+            rate /= 2;
+        }
+        if (not (rate & 0x1)){
+            hb1 = 1;
+            rate /= 2;
+        }
+        return (hb1 << 9) | (hb0 << 8) | (rate & 0xff);
+    }
+
+    /*!
+     * Calculate the IQ scale factor word from I and Q components.
+     * \param i the I component
+     * \param q the Q component
+     * \return the 32-bit scale factor control word
+     */
+    static inline boost::uint32_t calc_iq_scale_word(
+        boost::int16_t i,
+        boost::int16_t q
+    ){
+        return (boost::uint16_t(i) << 16) | (boost::uint16_t(q) << 0);
+    }
+
+    /*!
+     * Calculate the IQ scale factor word from the rate.
+     * \param rate the requested rate in Sps
+     * \return the 32-bit scale factor control word
+     */
+    template <typename dsp_rate_type>
+    static inline boost::uint32_t calc_iq_scale_word(dsp_rate_type rate){
+        // Calculate CIC interpolation (i.e., without halfband interpolators)
+        dsp_rate_type tmp_rate = calc_cic_filter_word(rate) & 0xff;
+
+        // Calculate closest multiplier constant to reverse gain absent scale multipliers
+        double rate_cubed = std::pow(double(tmp_rate), 3);
+        boost::int16_t scale = boost::math::iround((4096*std::pow(2, ceil_log2(rate_cubed)))/(1.65*rate_cubed));
+        return calc_iq_scale_word(scale, scale);
+    }
+
+} //namespace dsp_type1
+
+}} //namespace
+
+#endif /* INCLUDED_LIBUHD_USRP_DSP_UTILS_HPP */
diff --git a/host/lib/usrp/usrp2/dsp_impl.cpp b/host/lib/usrp/usrp2/dsp_impl.cpp
index 330638cb1..367cde2e1 100644
--- a/host/lib/usrp/usrp2/dsp_impl.cpp
+++ b/host/lib/usrp/usrp2/dsp_impl.cpp
@@ -17,12 +17,10 @@
 
 #include "usrp2_impl.hpp"
 #include "usrp2_regs.hpp"
+#include "../dsp_utils.hpp"
 #include <uhd/usrp/dsp_props.hpp>
-#include <uhd/utils/assert.hpp>
-#include <boost/format.hpp>
 #include <boost/bind.hpp>
 #include <boost/assign/list_of.hpp>
-#include <boost/math/special_functions/round.hpp>
 
 using namespace uhd;
 using namespace uhd::usrp;
@@ -30,49 +28,9 @@ using namespace uhd::usrp;
 static const size_t default_decim = 16;
 static const size_t default_interp = 16;
 
-#define rint boost::math::iround
-
-template <class T> T log2(T num){
-    return std::log(num)/std::log(T(2));
-}
-
 /***********************************************************************
  * DDC Helper Methods
  **********************************************************************/
-static boost::uint32_t calculate_freq_word_and_update_actual_freq(double &freq, double clock_freq){
-    UHD_ASSERT_THROW(std::abs(freq) < clock_freq/2.0);
-    static const double scale_factor = std::pow(2.0, 32);
-
-    //calculate the freq register word
-    boost::uint32_t freq_word = rint((freq / clock_freq) * scale_factor);
-
-    //update the actual frequency
-    freq = (double(freq_word) / scale_factor) * clock_freq;
-
-    return freq_word;
-}
-
-// Check if requested decim/interp rate is:
-//      multiple of 4, enable two halfband filters
-//      multiple of 2, enable one halfband filter
-//      handle remainder in CIC
-static boost::uint32_t calculate_cic_word(size_t rate){
-    int hb0 = 0, hb1 = 0;
-    if (not (rate & 0x1)){
-        hb0 = 1;
-        rate /= 2;
-    }
-    if (not (rate & 0x1)){
-        hb1 = 1;
-        rate /= 2;
-    }
-    return (hb1 << 9) | (hb0 << 8) | (rate & 0xff);
-}
-
-static boost::uint32_t calculate_iq_scale_word(boost::int16_t i, boost::int16_t q){
-    return (boost::uint16_t(i) << 16) | (boost::uint16_t(q) << 0);
-}
-
 template <class rate_t> static rate_t
 pick_closest_rate(double exact_rate, const std::vector<rate_t> &rates){
     rate_t closest_match = rates.at(0);
@@ -130,7 +88,7 @@ void usrp2_impl::ddc_set(const wax::obj &key, const wax::obj &val){
     case DSP_PROP_FREQ_SHIFT:{
             double new_freq = val.as<double>();
             _iface->poke32(U2_REG_DSP_RX_FREQ,
-                calculate_freq_word_and_update_actual_freq(new_freq, get_master_clock_freq())
+                dsp_type1::calc_cordic_word_and_update(new_freq, get_master_clock_freq())
             );
             _ddc_freq = new_freq; //shadow
         }
@@ -141,12 +99,12 @@ void usrp2_impl::ddc_set(const wax::obj &key, const wax::obj &val){
             _ddc_decim = pick_closest_rate(extact_rate, _allowed_decim_and_interp_rates);
 
             //set the decimation
-            _iface->poke32(U2_REG_DSP_RX_DECIM_RATE, calculate_cic_word(_ddc_decim));
+            _iface->poke32(U2_REG_DSP_RX_DECIM_RATE, dsp_type1::calc_cic_filter_word(_ddc_decim));
 
             //set the scaling
             static const boost::int16_t default_rx_scale_iq = 1024;
             _iface->poke32(U2_REG_DSP_RX_SCALE_IQ,
-                calculate_iq_scale_word(default_rx_scale_iq, default_rx_scale_iq)
+                dsp_type1::calc_iq_scale_word(default_rx_scale_iq, default_rx_scale_iq)
             );
         }
         return;
@@ -205,7 +163,7 @@ void usrp2_impl::duc_set(const wax::obj &key, const wax::obj &val){
     case DSP_PROP_FREQ_SHIFT:{
             double new_freq = val.as<double>();
             _iface->poke32(U2_REG_DSP_TX_FREQ,
-                calculate_freq_word_and_update_actual_freq(new_freq, get_master_clock_freq())
+                dsp_type1::calc_cordic_word_and_update(new_freq, get_master_clock_freq())
             );
             _duc_freq = new_freq; //shadow
         }
@@ -215,18 +173,11 @@ void usrp2_impl::duc_set(const wax::obj &key, const wax::obj &val){
             double extact_rate = get_master_clock_freq()/val.as<double>();
             _duc_interp = pick_closest_rate(extact_rate, _allowed_decim_and_interp_rates);
 
-            // Calculate CIC interpolation (i.e., without halfband interpolators)
-            size_t tmp_interp = calculate_cic_word(_duc_interp) & 0xff;
-
-            // Calculate closest multiplier constant to reverse gain absent scale multipliers
-            double interp_cubed = std::pow(double(tmp_interp), 3);
-            boost::int16_t scale = rint((4096*std::pow(2, ceil(log2(interp_cubed))))/(1.65*interp_cubed));
-
             //set the interpolation
-            _iface->poke32(U2_REG_DSP_TX_INTERP_RATE, calculate_cic_word(_duc_interp));
+            _iface->poke32(U2_REG_DSP_TX_INTERP_RATE, dsp_type1::calc_cic_filter_word(_duc_interp));
 
             //set the scaling
-            _iface->poke32(U2_REG_DSP_TX_SCALE_IQ, calculate_iq_scale_word(scale, scale));
+            _iface->poke32(U2_REG_DSP_TX_SCALE_IQ, dsp_type1::calc_iq_scale_word(_duc_interp));
         }
         return;