summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--host/examples/tx_waveforms.cpp89
-rw-r--r--host/include/uhd/usrp/dboard_iface.hpp8
-rw-r--r--host/include/uhd/usrp/simple_usrp.hpp5
-rw-r--r--host/lib/transport/convert_types_impl.hpp95
-rw-r--r--host/lib/usrp/dboard/db_basic_and_lf.cpp8
-rw-r--r--host/lib/usrp/simple_usrp.cpp8
-rw-r--r--host/lib/usrp/usrp2/dboard_iface.cpp20
-rw-r--r--host/test/convert_types_test.cpp139
8 files changed, 279 insertions, 93 deletions
diff --git a/host/examples/tx_waveforms.cpp b/host/examples/tx_waveforms.cpp
index e9cf210bb..9886000b1 100644
--- a/host/examples/tx_waveforms.cpp
+++ b/host/examples/tx_waveforms.cpp
@@ -20,19 +20,41 @@
#include <uhd/usrp/simple_usrp.hpp>
#include <boost/program_options.hpp>
#include <boost/thread/thread_time.hpp> //system time
+#include <boost/math/special_functions/round.hpp>
#include <boost/format.hpp>
+#include <boost/function.hpp>
#include <iostream>
#include <complex>
#include <cmath>
namespace po = boost::program_options;
+/***********************************************************************
+ * Waveform generators
+ **********************************************************************/
+float gen_const(float){
+ return 1;
+}
+
+float gen_square(float x){
+ return float((std::fmod(x, 1) < float(0.5))? 0 : 1);
+}
+
+float gen_ramp(float x){
+ return std::fmod(x, 1)*2 - 1;
+}
+
+float gen_sine(float x){
+ static const float two_pi = 2*std::acos(float(-1));
+ return std::sin(x*two_pi);
+}
+
int UHD_SAFE_MAIN(int argc, char *argv[]){
uhd::set_thread_priority_safe();
//variables to be set by po
std::string args, wave_type;
- size_t total_duration, amspb;
+ size_t total_duration, spb;
double rate, freq, wave_freq;
float ampl, gain;
@@ -42,7 +64,7 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
("help", "help message")
("args", po::value<std::string>(&args)->default_value(""), "simple uhd device address args")
("duration", po::value<size_t>(&total_duration)->default_value(3), "number of seconds to transmit")
- ("amspb", po::value<size_t>(&amspb)->default_value(10000), "approximate mimimum samples per buffer")
+ ("spb", po::value<size_t>(&spb)->default_value(10000), "samples per buffer")
("rate", po::value<double>(&rate)->default_value(100e6/16), "rate of outgoing samples")
("freq", po::value<double>(&freq)->default_value(0), "rf center frequency in Hz")
("ampl", po::value<float>(&ampl)->default_value(float(0.3)), "amplitude of the waveform")
@@ -88,33 +110,24 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
}
//error when the waveform is not possible to generate
- if (std::abs(wave_freq)/sdev->get_tx_rate() < 0.5/amspb){
- throw std::runtime_error("wave freq/tx rate too small");
- }
if (std::abs(wave_freq) > sdev->get_tx_rate()/2){
throw std::runtime_error("wave freq out of Nyquist zone");
}
- //fill a buffer with one period worth of samples
- std::vector<float> period(size_t(sdev->get_tx_rate()/std::abs(wave_freq)));
- std::cout << boost::format("Samples per waveform period: %d") % period.size() << std::endl;
- for (size_t n = 0; n < period.size(); n++){
- if (wave_type == "CONST") period[n] = ampl;
- else if (wave_type == "SQUARE") period[n] = (n > period.size()/2)? ampl : 0;
- else if (wave_type == "RAMP") period[n] = float((n/double(period.size()-1)) * 2*ampl - ampl);
- else if (wave_type == "SINE") period[n] = ampl*float(std::sin(2*M_PI*n/double(period.size())));
- else throw std::runtime_error("unknown waveform type: " + wave_type);
- }
-
- //allocate data to send (fill with several periods worth of IQ samples)
- const size_t periods_per_buff = std::max<size_t>(1, amspb/period.size());
- std::vector<std::complex<float> > buff(period.size()*periods_per_buff);
- std::cout << boost::format("Samples per send buffer: %d") % buff.size() << std::endl;
- const size_t i_ahead = (wave_freq > 0)? period.size()/4 : 0;
- const size_t q_ahead = (wave_freq < 0)? period.size()/4 : 0;
- for (size_t n = 0; n < buff.size(); n++) buff[n] = std::complex<float>(
- period[(n+i_ahead)%period.size()], period[(n+q_ahead)%period.size()] //I,Q
- );
+ //store the generator function for the selected waveform
+ boost::function<float(float)> wave_gen;
+ if (wave_type == "CONST") wave_gen = &gen_const;
+ else if (wave_type == "SQUARE") wave_gen = &gen_square;
+ else if (wave_type == "RAMP") wave_gen = &gen_ramp;
+ else if (wave_type == "SINE") wave_gen = &gen_sine;
+ else throw std::runtime_error("unknown waveform type: " + wave_type);
+
+ //allocate the buffer and precalculate values
+ std::vector<std::complex<float> > buff(spb);
+ const float cps = float(wave_freq/sdev->get_tx_rate());
+ const float i_off = (wave_freq > 0)? float(0.25) : 0;
+ const float q_off = (wave_freq < 0)? float(0.25) : 0;
+ float theta = 0;
//setup the metadata flags
uhd::tx_metadata_t md;
@@ -123,11 +136,27 @@ int UHD_SAFE_MAIN(int argc, char *argv[]){
//send the data in multiple packets
boost::system_time end_time(boost::get_system_time() + boost::posix_time::seconds(total_duration));
- while(end_time > boost::get_system_time()) dev->send(
- &buff.front(), buff.size(), md,
- uhd::io_type_t::COMPLEX_FLOAT32,
- uhd::device::SEND_MODE_FULL_BUFF
- );
+ while(end_time > boost::get_system_time()){
+
+ //fill the buffer with the waveform
+ for (size_t n = 0; n < buff.size(); n++){
+ buff[n] = std::complex<float>(
+ ampl*wave_gen(i_off + theta),
+ ampl*wave_gen(q_off + theta)
+ );
+ theta += cps;
+ }
+
+ //bring the theta back into range [0, 1)
+ theta = std::fmod(theta, 1);
+
+ //send the entire contents of the buffer
+ dev->send(
+ &buff.front(), buff.size(), md,
+ uhd::io_type_t::COMPLEX_FLOAT32,
+ uhd::device::SEND_MODE_FULL_BUFF
+ );
+ }
//send a mini EOB packet
md.start_of_burst = false;
diff --git a/host/include/uhd/usrp/dboard_iface.hpp b/host/include/uhd/usrp/dboard_iface.hpp
index e776ecc42..c7db244f2 100644
--- a/host/include/uhd/usrp/dboard_iface.hpp
+++ b/host/include/uhd/usrp/dboard_iface.hpp
@@ -148,6 +148,14 @@ public:
virtual void write_gpio(unit_t unit, boost::uint16_t value) = 0;
/*!
+ * Setup the GPIO debug mux.
+ *
+ * \param unit which unit rx or tx
+ * \param which which debug: 0, 1
+ */
+ virtual void set_gpio_debug(unit_t unit, int which) = 0;
+
+ /*!
* Read daughterboard GPIO pin values.
*
* \param unit which unit rx or tx
diff --git a/host/include/uhd/usrp/simple_usrp.hpp b/host/include/uhd/usrp/simple_usrp.hpp
index 4da63c929..08b9c01ea 100644
--- a/host/include/uhd/usrp/simple_usrp.hpp
+++ b/host/include/uhd/usrp/simple_usrp.hpp
@@ -25,6 +25,7 @@
#include <uhd/types/clock_config.hpp>
#include <uhd/types/tune_result.hpp>
#include <uhd/usrp/subdev_spec.hpp>
+#include <uhd/usrp/dboard_iface.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/utility.hpp>
#include <vector>
@@ -136,6 +137,8 @@ public:
*/
virtual float read_rssi(void) = 0;
+ virtual dboard_iface::sptr get_rx_dboard_iface(void) = 0;
+
/*******************************************************************
* TX methods
******************************************************************/
@@ -159,6 +162,8 @@ public:
virtual std::vector<std::string> get_tx_antennas(void) = 0;
virtual bool get_tx_lo_locked(void) = 0;
+
+ virtual dboard_iface::sptr get_tx_dboard_iface(void) = 0;
};
}}
diff --git a/host/lib/transport/convert_types_impl.hpp b/host/lib/transport/convert_types_impl.hpp
index 5958b08cb..fdc859883 100644
--- a/host/lib/transport/convert_types_impl.hpp
+++ b/host/lib/transport/convert_types_impl.hpp
@@ -28,6 +28,10 @@
#define USE_EMMINTRIN_H //use sse2 intrinsics
#endif
+#if defined(USE_EMMINTRIN_H)
+ #include <emmintrin.h>
+#endif
+
/***********************************************************************
* Typedefs
**********************************************************************/
@@ -72,7 +76,7 @@ static UHD_INLINE void item32_to_sc16_bswap(
}
/***********************************************************************
- * Convert complex float buffer to items32
+ * Convert complex float buffer to items32 (no swap)
**********************************************************************/
static const float shorts_per_float = float(32767);
@@ -82,6 +86,41 @@ static UHD_INLINE item32_t fc32_to_item32(fc32_t num){
return (item32_t(real) << 16) | (item32_t(imag) << 0);
}
+////////////////////////////////////
+// none-swap
+////////////////////////////////////
+#if defined(USE_EMMINTRIN_H)
+static UHD_INLINE void fc32_to_item32_nswap(
+ const fc32_t *input, item32_t *output, size_t nsamps
+){
+ __m128 scalar = _mm_set_ps1(shorts_per_float);
+
+ //convert blocks of samples with intrinsics
+ size_t i = 0; for (; i < (nsamps & ~0x3); i+=4){
+ //load from input
+ __m128 tmplo = _mm_loadu_ps(reinterpret_cast<const float *>(input+i+0));
+ __m128 tmphi = _mm_loadu_ps(reinterpret_cast<const float *>(input+i+2));
+
+ //convert and scale
+ __m128i tmpilo = _mm_cvtps_epi32(_mm_mul_ps(tmplo, scalar));
+ __m128i tmpihi = _mm_cvtps_epi32(_mm_mul_ps(tmphi, scalar));
+
+ //pack + swap 16-bit pairs
+ __m128i tmpi = _mm_packs_epi32(tmpilo, tmpihi);
+ tmpi = _mm_shufflelo_epi16(tmpi, _MM_SHUFFLE(2, 3, 0, 1));
+ tmpi = _mm_shufflehi_epi16(tmpi, _MM_SHUFFLE(2, 3, 0, 1));
+
+ //store to output
+ _mm_storeu_si128(reinterpret_cast<__m128i *>(output+i), tmpi);
+ }
+
+ //convert remainder
+ for (; i < nsamps; i++){
+ output[i] = fc32_to_item32(input[i]);
+ }
+}
+
+#else
static UHD_INLINE void fc32_to_item32_nswap(
const fc32_t *input, item32_t *output, size_t nsamps
){
@@ -90,9 +129,12 @@ static UHD_INLINE void fc32_to_item32_nswap(
}
}
-#if defined(USE_EMMINTRIN_H)
-#include <emmintrin.h>
+#endif
+////////////////////////////////////
+// byte-swap
+////////////////////////////////////
+#if defined(USE_EMMINTRIN_H)
static UHD_INLINE void fc32_to_item32_bswap(
const fc32_t *input, item32_t *output, size_t nsamps
){
@@ -108,7 +150,7 @@ static UHD_INLINE void fc32_to_item32_bswap(
__m128i tmpilo = _mm_cvtps_epi32(_mm_mul_ps(tmplo, scalar));
__m128i tmpihi = _mm_cvtps_epi32(_mm_mul_ps(tmphi, scalar));
- //pack + byteswap -> byteswap 32 bit words
+ //pack + byteswap -> byteswap 16 bit words
__m128i tmpi = _mm_packs_epi32(tmpilo, tmpihi);
tmpi = _mm_or_si128(_mm_srli_epi16(tmpi, 8), _mm_slli_epi16(tmpi, 8));
@@ -145,6 +187,43 @@ static UHD_INLINE fc32_t item32_to_fc32(item32_t item){
);
}
+////////////////////////////////////
+// none-swap
+////////////////////////////////////
+#if defined(USE_EMMINTRIN_H)
+static UHD_INLINE void item32_to_fc32_nswap(
+ const item32_t *input, fc32_t *output, size_t nsamps
+){
+ __m128 scalar = _mm_set_ps1(floats_per_short/(1 << 16));
+ __m128i zeroi = _mm_setzero_si128();
+
+ //convert blocks of samples with intrinsics
+ size_t i = 0; for (; i < (nsamps & ~0x3); i+=4){
+ //load from input
+ __m128i tmpi = _mm_loadu_si128(reinterpret_cast<const __m128i *>(input+i));
+
+ //unpack + swap 16-bit pairs
+ tmpi = _mm_shufflelo_epi16(tmpi, _MM_SHUFFLE(2, 3, 0, 1));
+ tmpi = _mm_shufflehi_epi16(tmpi, _MM_SHUFFLE(2, 3, 0, 1));
+ __m128i tmpilo = _mm_unpacklo_epi16(zeroi, tmpi); //value in upper 16 bits
+ __m128i tmpihi = _mm_unpackhi_epi16(zeroi, tmpi);
+
+ //convert and scale
+ __m128 tmplo = _mm_mul_ps(_mm_cvtepi32_ps(tmpilo), scalar);
+ __m128 tmphi = _mm_mul_ps(_mm_cvtepi32_ps(tmpihi), scalar);
+
+ //store to output
+ _mm_storeu_ps(reinterpret_cast<float *>(output+i+0), tmplo);
+ _mm_storeu_ps(reinterpret_cast<float *>(output+i+2), tmphi);
+ }
+
+ //convert remainder
+ for (; i < nsamps; i++){
+ output[i] = item32_to_fc32(input[i]);
+ }
+}
+
+#else
static UHD_INLINE void item32_to_fc32_nswap(
const item32_t *input, fc32_t *output, size_t nsamps
){
@@ -152,10 +231,12 @@ static UHD_INLINE void item32_to_fc32_nswap(
output[i] = item32_to_fc32(input[i]);
}
}
+#endif
+////////////////////////////////////
+// byte-swap
+////////////////////////////////////
#if defined(USE_EMMINTRIN_H)
-#include <emmintrin.h>
-
static UHD_INLINE void item32_to_fc32_bswap(
const item32_t *input, fc32_t *output, size_t nsamps
){
@@ -167,7 +248,7 @@ static UHD_INLINE void item32_to_fc32_bswap(
//load from input
__m128i tmpi = _mm_loadu_si128(reinterpret_cast<const __m128i *>(input+i));
- //byteswap + unpack -> byteswap 32 bit words
+ //byteswap + unpack -> byteswap 16 bit words
tmpi = _mm_or_si128(_mm_srli_epi16(tmpi, 8), _mm_slli_epi16(tmpi, 8));
__m128i tmpilo = _mm_unpacklo_epi16(zeroi, tmpi); //value in upper 16 bits
__m128i tmpihi = _mm_unpackhi_epi16(zeroi, tmpi);
diff --git a/host/lib/usrp/dboard/db_basic_and_lf.cpp b/host/lib/usrp/dboard/db_basic_and_lf.cpp
index f8236d598..0b6e4a75a 100644
--- a/host/lib/usrp/dboard/db_basic_and_lf.cpp
+++ b/host/lib/usrp/dboard/db_basic_and_lf.cpp
@@ -170,8 +170,8 @@ void basic_rx::rx_set(const wax::obj &key_, const wax::obj &val){
return;
case SUBDEV_PROP_ANTENNA:
- UHD_ASSERT_THROW(val.as<std::string>() == std::string(""));
- return;
+ if (val.as<std::string>().empty()) return;
+ throw std::runtime_error("no selectable antennas on this board");
case SUBDEV_PROP_FREQ:
return; // it wont do you much good, but you can set it
@@ -259,8 +259,8 @@ void basic_tx::tx_set(const wax::obj &key_, const wax::obj &val){
return;
case SUBDEV_PROP_ANTENNA:
- UHD_ASSERT_THROW(val.as<std::string>() == std::string(""));
- return;
+ if (val.as<std::string>().empty()) return;
+ throw std::runtime_error("no selectable antennas on this board");
case SUBDEV_PROP_FREQ:
return; // it wont do you much good, but you can set it
diff --git a/host/lib/usrp/simple_usrp.cpp b/host/lib/usrp/simple_usrp.cpp
index 60b25a647..e573d0fc0 100644
--- a/host/lib/usrp/simple_usrp.cpp
+++ b/host/lib/usrp/simple_usrp.cpp
@@ -168,6 +168,10 @@ public:
return _rx_subdev()[SUBDEV_PROP_RSSI].as<float>();
}
+ dboard_iface::sptr get_rx_dboard_iface(void){
+ return _rx_dboard()[DBOARD_PROP_DBOARD_IFACE].as<dboard_iface::sptr>();
+ }
+
/*******************************************************************
* TX methods
******************************************************************/
@@ -232,6 +236,10 @@ public:
return _tx_subdev()[SUBDEV_PROP_LO_LOCKED].as<bool>();
}
+ dboard_iface::sptr get_tx_dboard_iface(void){
+ return _tx_dboard()[DBOARD_PROP_DBOARD_IFACE].as<dboard_iface::sptr>();
+ }
+
private:
device::sptr _dev;
wax::obj _mboard(void){
diff --git a/host/lib/usrp/usrp2/dboard_iface.cpp b/host/lib/usrp/usrp2/dboard_iface.cpp
index 8bded1ea3..f6d2b718a 100644
--- a/host/lib/usrp/usrp2/dboard_iface.cpp
+++ b/host/lib/usrp/usrp2/dboard_iface.cpp
@@ -51,6 +51,7 @@ public:
void set_atr_reg(unit_t, atr_reg_t, boost::uint16_t);
void set_gpio_ddr(unit_t, boost::uint16_t);
void write_gpio(unit_t, boost::uint16_t);
+ void set_gpio_debug(unit_t, int);
boost::uint16_t read_gpio(unit_t);
void write_i2c(boost::uint8_t, const byte_vector_t &);
@@ -219,6 +220,25 @@ void usrp2_dboard_iface::set_atr_reg(unit_t unit, atr_reg_t atr, boost::uint16_t
_iface->poke16(unit_to_atr_to_addr[unit][atr], value);
}
+void usrp2_dboard_iface::set_gpio_debug(unit_t unit, int which){
+ this->set_gpio_ddr(unit, 0xffff); //all outputs
+
+ //calculate the new selection mux setting
+ boost::uint32_t new_sels = 0x0;
+ int sel = (which == 0)?
+ U2_FLAG_GPIO_SEL_DEBUG_0:
+ U2_FLAG_GPIO_SEL_DEBUG_1;
+ for(size_t i = 0; i < 16; i++){
+ new_sels |= sel << (i*2);
+ }
+
+ //write the selection mux value to register
+ switch(unit){
+ case UNIT_RX: _iface->poke32(U2_REG_GPIO_RX_SEL, new_sels); return;
+ case UNIT_TX: _iface->poke32(U2_REG_GPIO_TX_SEL, new_sels); return;
+ }
+}
+
/***********************************************************************
* SPI
**********************************************************************/
diff --git a/host/test/convert_types_test.cpp b/host/test/convert_types_test.cpp
index 1587be57f..d132a708b 100644
--- a/host/test/convert_types_test.cpp
+++ b/host/test/convert_types_test.cpp
@@ -17,109 +17,144 @@
#include <uhd/transport/convert_types.hpp>
#include <boost/test/unit_test.hpp>
+#include <boost/foreach.hpp>
#include <boost/cstdint.hpp>
+#include <boost/asio/buffer.hpp>
#include <complex>
+#include <vector>
+#include <cstdlib>
using namespace uhd;
-template <typename host_type, typename dev_type, size_t nsamps>
-void loopback(
+//typedefs for complex types
+typedef std::complex<boost::uint16_t> sc16_t;
+typedef std::complex<float> fc32_t;
+
+//extract pointer to POD since using &vector.front() throws in MSVC
+template <typename T> void * pod2ptr(T &pod){
+ return boost::asio::buffer_cast<void *>(boost::asio::buffer(pod));
+}
+template <typename T> const void * pod2ptr(const T &pod){
+ return boost::asio::buffer_cast<const void *>(boost::asio::buffer(pod));
+}
+
+/***********************************************************************
+ * Loopback runner:
+ * convert input buffer into intermediate buffer
+ * convert intermediate buffer into output buffer
+ **********************************************************************/
+template <typename Range> static void loopback(
+ size_t nsamps,
const io_type_t &io_type,
const otw_type_t &otw_type,
- const host_type *input,
- host_type *output
+ const Range &input,
+ Range &output
){
- dev_type dev[nsamps];
+ //item32 is largest device type
+ std::vector<boost::uint32_t> dev(nsamps);
//convert to dev type
transport::convert_io_type_to_otw_type(
- input, io_type,
- dev, otw_type,
+ pod2ptr(input), io_type,
+ pod2ptr(dev), otw_type,
nsamps
);
//convert back to host type
transport::convert_otw_type_to_io_type(
- dev, otw_type,
- output, io_type,
+ pod2ptr(dev), otw_type,
+ pod2ptr(output), io_type,
nsamps
);
}
-typedef std::complex<boost::uint16_t> sc16_t;
+/***********************************************************************
+ * Test short conversion
+ **********************************************************************/
+static void test_convert_types_sc16(
+ size_t nsamps,
+ const io_type_t &io_type,
+ const otw_type_t &otw_type
+){
+ //fill the input samples
+ std::vector<sc16_t> input(nsamps), output(nsamps);
+ BOOST_FOREACH(sc16_t &in, input) in = sc16_t(
+ std::rand()-(RAND_MAX/2),
+ std::rand()-(RAND_MAX/2)
+ );
-BOOST_AUTO_TEST_CASE(test_convert_types_be_sc16){
- sc16_t in_sc16[] = {
- sc16_t(0, -1234), sc16_t(4321, 1234),
- sc16_t(9876, -4567), sc16_t(8912, 0)
- }, out_sc16[4];
+ //run the loopback and test
+ loopback(nsamps, io_type, otw_type, input, output);
+ BOOST_CHECK_EQUAL_COLLECTIONS(input.begin(), input.end(), output.begin(), output.end());
+}
+BOOST_AUTO_TEST_CASE(test_convert_types_be_sc16){
io_type_t io_type(io_type_t::COMPLEX_INT16);
otw_type_t otw_type;
otw_type.byteorder = otw_type_t::BO_BIG_ENDIAN;
otw_type.width = 16;
- loopback<sc16_t, boost::uint32_t, 4>(io_type, otw_type, in_sc16, out_sc16);
- BOOST_CHECK_EQUAL_COLLECTIONS(in_sc16, in_sc16+4, out_sc16, out_sc16+4);
+ //try various lengths to test edge cases
+ for (size_t nsamps = 0; nsamps < 16; nsamps++){
+ test_convert_types_sc16(nsamps, io_type, otw_type);
+ }
}
BOOST_AUTO_TEST_CASE(test_convert_types_le_sc16){
- sc16_t in_sc16[] = {
- sc16_t(0, -1234), sc16_t(4321, 1234),
- sc16_t(9876, -4567), sc16_t(8912, 0)
- }, out_sc16[4];
-
io_type_t io_type(io_type_t::COMPLEX_INT16);
otw_type_t otw_type;
otw_type.byteorder = otw_type_t::BO_LITTLE_ENDIAN;
otw_type.width = 16;
- loopback<sc16_t, boost::uint32_t, 4>(io_type, otw_type, in_sc16, out_sc16);
- BOOST_CHECK_EQUAL_COLLECTIONS(in_sc16, in_sc16+4, out_sc16, out_sc16+4);
+ //try various lengths to test edge cases
+ for (size_t nsamps = 0; nsamps < 16; nsamps++){
+ test_convert_types_sc16(nsamps, io_type, otw_type);
+ }
}
-typedef std::complex<float> fc32_t;
-
-#define BOOST_CHECK_CLOSE_COMPLEX(a1, a2, p) \
- BOOST_CHECK_CLOSE(a1.real(), a2.real(), p); \
- BOOST_CHECK_CLOSE(a1.imag(), a2.imag(), p);
+/***********************************************************************
+ * Test float conversion
+ **********************************************************************/
+static void test_convert_types_fc32(
+ size_t nsamps,
+ const io_type_t &io_type,
+ const otw_type_t &otw_type
+){
+ //fill the input samples
+ std::vector<fc32_t> input(nsamps), output(nsamps);
+ BOOST_FOREACH(fc32_t &in, input) in = fc32_t(
+ (std::rand()/float(RAND_MAX/2)) - 1,
+ (std::rand()/float(RAND_MAX/2)) - 1
+ );
-static const float tolerance = float(0.1);
+ //run the loopback and test
+ loopback(nsamps, io_type, otw_type, input, output);
+ for (size_t i = 0; i < nsamps; i++){
+ BOOST_CHECK_CLOSE_FRACTION(input[i].real(), output[i].real(), float(0.01));
+ BOOST_CHECK_CLOSE_FRACTION(input[i].imag(), output[i].imag(), float(0.01));
+ }
+}
BOOST_AUTO_TEST_CASE(test_convert_types_be_fc32){
- fc32_t in_fc32[] = {
- fc32_t(float(0), float(-0.2)), fc32_t(float(0.03), float(-0.16)),
- fc32_t(float(1.0), float(.45)), fc32_t(float(0.09), float(0))
- }, out_fc32[4];
-
io_type_t io_type(io_type_t::COMPLEX_FLOAT32);
otw_type_t otw_type;
otw_type.byteorder = otw_type_t::BO_BIG_ENDIAN;
otw_type.width = 16;
- loopback<fc32_t, boost::uint32_t, 4>(io_type, otw_type, in_fc32, out_fc32);
-
- BOOST_CHECK_CLOSE_COMPLEX(in_fc32[0], out_fc32[0], tolerance);
- BOOST_CHECK_CLOSE_COMPLEX(in_fc32[1], out_fc32[1], tolerance);
- BOOST_CHECK_CLOSE_COMPLEX(in_fc32[2], out_fc32[2], tolerance);
- BOOST_CHECK_CLOSE_COMPLEX(in_fc32[3], out_fc32[3], tolerance);
+ //try various lengths to test edge cases
+ for (size_t nsamps = 0; nsamps < 16; nsamps++){
+ test_convert_types_fc32(nsamps, io_type, otw_type);
+ }
}
BOOST_AUTO_TEST_CASE(test_convert_types_le_fc32){
- fc32_t in_fc32[] = {
- fc32_t(float(0), float(-0.2)), fc32_t(float(0.03), float(-0.16)),
- fc32_t(float(1.0), float(.45)), fc32_t(float(0.09), float(0))
- }, out_fc32[4];
-
io_type_t io_type(io_type_t::COMPLEX_FLOAT32);
otw_type_t otw_type;
otw_type.byteorder = otw_type_t::BO_LITTLE_ENDIAN;
otw_type.width = 16;
- loopback<fc32_t, boost::uint32_t, 4>(io_type, otw_type, in_fc32, out_fc32);
-
- BOOST_CHECK_CLOSE_COMPLEX(in_fc32[0], out_fc32[0], tolerance);
- BOOST_CHECK_CLOSE_COMPLEX(in_fc32[1], out_fc32[1], tolerance);
- BOOST_CHECK_CLOSE_COMPLEX(in_fc32[2], out_fc32[2], tolerance);
- BOOST_CHECK_CLOSE_COMPLEX(in_fc32[3], out_fc32[3], tolerance);
+ //try various lengths to test edge cases
+ for (size_t nsamps = 0; nsamps < 16; nsamps++){
+ test_convert_types_fc32(nsamps, io_type, otw_type);
+ }
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-16 13:42:34 +0000