aboutsummaryrefslogtreecommitdiffstats
path: root/host/lib
diff options
context:
space:
mode:
Diffstat (limited to 'host/lib')
-rw-r--r--host/lib/transport/CMakeLists.txt6
-rw-r--r--host/lib/transport/convert_types.cpp152
-rwxr-xr-xhost/lib/transport/gen_convert_types.py189
-rwxr-xr-xhost/lib/transport/gen_vrt.py3
-rw-r--r--host/lib/usrp/CMakeLists.txt1
-rw-r--r--host/lib/usrp/dsp_utils.hpp114
-rw-r--r--host/lib/usrp/usrp2/dsp_impl.cpp63
7 files changed, 318 insertions, 210 deletions
diff --git a/host/lib/transport/CMakeLists.txt b/host/lib/transport/CMakeLists.txt
index a74f7d527..872865d6c 100644
--- a/host/lib/transport/CMakeLists.txt
+++ b/host/lib/transport/CMakeLists.txt
@@ -44,8 +44,12 @@ LIBUHD_PYTHON_GEN_SOURCE(
${CMAKE_BINARY_DIR}/lib/transport/vrt.cpp
)
+LIBUHD_PYTHON_GEN_SOURCE(
+ ${CMAKE_SOURCE_DIR}/lib/transport/gen_convert_types.py
+ ${CMAKE_BINARY_DIR}/lib/transport/convert_types.cpp
+)
+
LIBUHD_APPEND_SOURCES(
- ${CMAKE_SOURCE_DIR}/lib/transport/convert_types.cpp
${CMAKE_SOURCE_DIR}/lib/transport/if_addrs.cpp
${CMAKE_SOURCE_DIR}/lib/transport/udp_simple.cpp
${CMAKE_SOURCE_DIR}/lib/transport/udp_zero_copy_asio.cpp
diff --git a/host/lib/transport/convert_types.cpp b/host/lib/transport/convert_types.cpp
deleted file mode 100644
index 43503025a..000000000
--- a/host/lib/transport/convert_types.cpp
+++ /dev/null
@@ -1,152 +0,0 @@
-//
-// 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/>.
-//
-
-#include <uhd/config.hpp>
-#include <uhd/transport/convert_types.hpp>
-#include <uhd/utils/assert.hpp>
-#include <boost/asio.hpp> //endianness conversion
-#include <boost/cstdint.hpp>
-#include <complex>
-
-using namespace uhd;
-
-/***********************************************************************
- * Constants
- **********************************************************************/
-typedef std::complex<float> fc32_t;
-
-static const float shorts_per_float = float(1 << 15);
-static const float floats_per_short = float(1.0/shorts_per_float);
-
-#define unrolled_loop(__inst, __len){ \
- size_t __i = 0; \
- for(; __i < (__len & ~0x3); __i+= 4){ \
- __inst(__i+0); __inst(__i+1); \
- __inst(__i+2); __inst(__i+3); \
- } \
- for(; __i < __len; __i++){ \
- __inst(__i); \
- } \
-}
-
-// set a boolean flag that indicates the endianess
-#ifdef HAVE_BIG_ENDIAN
-static const bool is_big_endian = true;
-#else
-static const bool is_big_endian = false;
-#endif
-
-static UHD_INLINE void host_floats_to_usrp2_items(
- boost::uint32_t *usrp2_items,
- const fc32_t *host_floats,
- size_t num_samps
-){
- #define host_floats_to_usrp2_items_i(i){ \
- boost::uint16_t real = boost::int16_t(host_floats[i].real()*shorts_per_float); \
- boost::uint16_t imag = boost::int16_t(host_floats[i].imag()*shorts_per_float); \
- usrp2_items[i] = htonl((real << 16) | (imag << 0)); \
- }
- unrolled_loop(host_floats_to_usrp2_items_i, num_samps);
-}
-
-static UHD_INLINE void usrp2_items_to_host_floats(
- fc32_t *host_floats,
- const boost::uint32_t *usrp2_items,
- size_t num_samps
-){
- #define usrp2_items_to_host_floats_i(i){ \
- boost::uint32_t item = ntohl(usrp2_items[i]); \
- boost::int16_t real = boost::uint16_t(item >> 16); \
- boost::int16_t imag = boost::uint16_t(item >> 0); \
- host_floats[i] = fc32_t(float(real*floats_per_short), float(imag*floats_per_short)); \
- }
- unrolled_loop(usrp2_items_to_host_floats_i, num_samps);
-}
-
-static UHD_INLINE void host_items_to_usrp2_items(
- boost::uint32_t *usrp2_items,
- const boost::uint32_t *host_items,
- size_t num_samps
-){
- #define host_items_to_usrp2_items_i(i) usrp2_items[i] = htonl(host_items[i])
- if (is_big_endian){
- std::memcpy(usrp2_items, host_items, num_samps*sizeof(boost::uint32_t));
- }
- else{
- unrolled_loop(host_items_to_usrp2_items_i, num_samps);
- }
-}
-
-static UHD_INLINE void usrp2_items_to_host_items(
- boost::uint32_t *host_items,
- const boost::uint32_t *usrp2_items,
- size_t num_samps
-){
- #define usrp2_items_to_host_items_i(i) host_items[i] = ntohl(usrp2_items[i])
- if (is_big_endian){
- std::memcpy(host_items, usrp2_items, num_samps*sizeof(boost::uint32_t));
- }
- else{
- unrolled_loop(usrp2_items_to_host_items_i, num_samps);
- }
-}
-
-void transport::convert_io_type_to_otw_type(
- const void *io_buff, const io_type_t &io_type,
- void *otw_buff, const otw_type_t &otw_type,
- size_t num_samps
-){
- //all we handle for now:
- UHD_ASSERT_THROW(otw_type.width == 16 and otw_type.byteorder == otw_type_t::BO_BIG_ENDIAN);
-
- switch(io_type.tid){
- case io_type_t::COMPLEX_FLOAT32:
- host_floats_to_usrp2_items((boost::uint32_t *)otw_buff, (const fc32_t*)io_buff, num_samps);
- return;
- case io_type_t::COMPLEX_INT16:
- host_items_to_usrp2_items((boost::uint32_t *)otw_buff, (const boost::uint32_t*)io_buff, num_samps);
- return;
- case io_type_t::CUSTOM_TYPE:
- std::memcpy(otw_buff, io_buff, num_samps*io_type.size);
- return;
- default:
- throw std::runtime_error(str(boost::format("convert_types: cannot handle type \"%c\"") % io_type.tid));
- }
-}
-
-void transport::convert_otw_type_to_io_type(
- const void *otw_buff, const otw_type_t &otw_type,
- void *io_buff, const io_type_t &io_type,
- size_t num_samps
-){
- //all we handle for now:
- UHD_ASSERT_THROW(otw_type.width == 16 and otw_type.byteorder == otw_type_t::BO_BIG_ENDIAN);
-
- switch(io_type.tid){
- case io_type_t::COMPLEX_FLOAT32:
- usrp2_items_to_host_floats((fc32_t*)io_buff, (const boost::uint32_t *)otw_buff, num_samps);
- return;
- case io_type_t::COMPLEX_INT16:
- usrp2_items_to_host_items((boost::uint32_t*)io_buff, (const boost::uint32_t *)otw_buff, num_samps);
- return;
- case io_type_t::CUSTOM_TYPE:
- std::memcpy(io_buff, otw_buff, num_samps*io_type.size);
- return;
- default:
- throw std::runtime_error(str(boost::format("convert_types: cannot handle type \"%c\"") % io_type.tid));
- }
-}
diff --git a/host/lib/transport/gen_convert_types.py b/host/lib/transport/gen_convert_types.py
new file mode 100755
index 000000000..1b6b71e00
--- /dev/null
+++ b/host/lib/transport/gen_convert_types.py
@@ -0,0 +1,189 @@
+#!/usr/bin/env python
+#
+# 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/>.
+#
+
+TMPL_TEXT = """
+#import time
+/***********************************************************************
+ * This file was generated by $file on $time.strftime("%c")
+ **********************************************************************/
+
+\#include <uhd/config.hpp>
+\#include <uhd/transport/convert_types.hpp>
+\#include <uhd/utils/byteswap.hpp>
+\#include <boost/cstdint.hpp>
+\#include <boost/detail/endian.hpp>
+\#include <stdexcept>
+\#include <complex>
+
+//define the endian macros to convert integers
+\#ifdef BOOST_BIG_ENDIAN
+ \#define BE_MACRO(x) x
+ \#define LE_MACRO(x) uhd::byteswap(x)
+ static const bool is_big_endian = true;
+\#else
+ \#define BE_MACRO(x) uhd::byteswap(x)
+ \#define LE_MACRO(x) x
+ static const bool is_big_endian = false;
+\#endif
+
+using namespace uhd;
+
+/***********************************************************************
+ * Constants
+ **********************************************************************/
+typedef std::complex<float> fc32_t;
+typedef std::complex<boost::int16_t> sc16_t;
+typedef boost::uint32_t item32_t;
+
+static const float shorts_per_float = float(32767);
+static const float floats_per_short = float(1.0/shorts_per_float);
+
+/***********************************************************************
+ * Single-sample converters
+ **********************************************************************/
+template<typename outptr_type, typename inptr_type>
+static UHD_INLINE outptr_type conv_ptr(inptr_type inptr){
+ return reinterpret_cast<outptr_type>(inptr);
+}
+
+static UHD_INLINE item32_t sc16_to_item32(sc16_t num){
+ return *conv_ptr<item32_t*>(&num);
+}
+
+static UHD_INLINE sc16_t item32_to_sc16(item32_t item){
+ return *conv_ptr<sc16_t*>(&item);
+}
+
+static UHD_INLINE item32_t fc32_to_item32(fc32_t num){
+ return sc16_to_item32(sc16_t(
+ boost::int16_t(num.real()*shorts_per_float),
+ boost::int16_t(num.imag()*shorts_per_float)
+ ));
+}
+
+static UHD_INLINE fc32_t item32_to_fc32(item32_t item){
+ sc16_t num = item32_to_sc16(item); return fc32_t(
+ float(num.real()*floats_per_short),
+ float(num.imag()*floats_per_short)
+ );
+}
+
+/***********************************************************************
+ * Sample-buffer converters
+ **********************************************************************/
+UHD_INLINE boost::uint8_t get_pred(
+ const io_type_t &io_type,
+ const otw_type_t &otw_type
+){
+ boost::uint8_t pred = 0;
+
+ switch(otw_type.byteorder){
+ case otw_type_t::BO_BIG_ENDIAN: pred |= $ph.be_p; break;
+ case otw_type_t::BO_LITTLE_ENDIAN: pred |= $ph.le_p; break;
+ ##let the compiler determine the native byte order (we could use python sys.byteorder)
+ case otw_type_t::BO_NATIVE: pred |= (is_big_endian)? $ph.be_p : $ph.le_p; break;
+ default: throw std::runtime_error("unhandled byteorder type");
+ }
+
+ switch(otw_type.width){
+ case 16: pred |= $ph.w16_p; break;
+ default: throw std::runtime_error("unhandled bit width");
+ }
+
+ switch(io_type.tid){
+ case io_type_t::COMPLEX_INT16: pred |= $ph.sc16_p; break;
+ case io_type_t::COMPLEX_FLOAT32: pred |= $ph.fc32_p; break;
+ default: throw std::runtime_error("unhandled io type id");
+ }
+
+ return pred;
+}
+
+void transport::convert_io_type_to_otw_type(
+ const void *io_buff, const io_type_t &io_type,
+ void *otw_buff, const otw_type_t &otw_type,
+ size_t num_samps
+){
+ switch(get_pred(io_type, otw_type)){
+ #for $pred in range(4)
+ case $pred:
+ #set $out_type = $ph.get_dev_type($pred)
+ #set $in_type = $ph.get_host_type($pred)
+ #set $converter = $in_type+"_to_"+$out_type
+ #set $xe_macro = $ph.get_xe_macro($pred)
+ for (size_t i = 0; i < num_samps; i++){
+ (($(out_type)_t *)otw_buff)[i] = $(xe_macro)($(converter)(((const $(in_type)_t *)io_buff)[i]));
+ }
+ break;
+ #end for
+ }
+}
+
+void transport::convert_otw_type_to_io_type(
+ const void *otw_buff, const otw_type_t &otw_type,
+ void *io_buff, const io_type_t &io_type,
+ size_t num_samps
+){
+ switch(get_pred(io_type, otw_type)){
+ #for $pred in range(4)
+ case $pred:
+ #set $out_type = $ph.get_host_type($pred)
+ #set $in_type = $ph.get_dev_type($pred)
+ #set $converter = $in_type+"_to_"+$out_type
+ #set $xe_macro = $ph.get_xe_macro($pred)
+ for (size_t i = 0; i < num_samps; i++){
+ (($(out_type)_t *)io_buff)[i] = $(converter)($(xe_macro)(((const $(in_type)_t *)otw_buff)[i]));
+ }
+ break;
+ #end for
+ }
+}
+
+"""
+
+def parse_tmpl(_tmpl_text, **kwargs):
+ from Cheetah.Template import Template
+ return str(Template(_tmpl_text, kwargs))
+
+class ph:
+ be_p = 0b00001
+ le_p = 0b00000
+ w16_p = 0b00000
+ sc16_p = 0b00010
+ fc32_p = 0b00000
+
+ @staticmethod
+ def get_xe_macro(pred):
+ if (pred & ph.be_p) == ph.be_p: return 'BE_MACRO'
+ if (pred & ph.le_p) == ph.le_p: return 'LE_MACRO'
+ raise NotImplementedError
+
+ @staticmethod
+ def get_dev_type(pred):
+ if (pred & ph.w16_p) == ph.w16_p: return 'item32'
+ raise NotImplementedError
+
+ @staticmethod
+ def get_host_type(pred):
+ if (pred & ph.sc16_p) == ph.sc16_p: return 'sc16'
+ if (pred & ph.fc32_p) == ph.fc32_p: return 'fc32'
+ raise NotImplementedError
+
+if __name__ == '__main__':
+ import sys
+ open(sys.argv[1], 'w').write(parse_tmpl(TMPL_TEXT, file=__file__, ph=ph))
diff --git a/host/lib/transport/gen_vrt.py b/host/lib/transport/gen_vrt.py
index 6cac2ae08..6cdd6645d 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..cfe5375f8
--- /dev/null
+++ b/host/lib/usrp/dsp_utils.hpp
@@ -0,0 +1,114 @@
+//
+// 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 of the scalar
+ * \param q the Q component of the scalar
+ * \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::uint32_t(i) << 16) | (boost::uint32_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;
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-15 12:01:41 +0000