bladerf: formatting/consistency fixes

gr3.7
Ryan Tucker 5 years ago committed by Dimitri Stolnikov
parent ed4dda192b
commit 399db91385
  1. 769
      lib/bladerf/bladerf_common.cc
  2. 215
      lib/bladerf/bladerf_sink_c.cc
  3. 263
      lib/bladerf/bladerf_source_c.cc

File diff suppressed because it is too large Load Diff

@ -45,9 +45,9 @@
//#define DEBUG_BLADERF_SINK
#ifdef DEBUG_BLADERF_SINK
# define DBG(input) std::cerr << _pfx << input << std::endl
#define DBG(input) std::cerr << _pfx << input << std::endl
#else
# define DBG(input)
#define DBG(input)
#endif
using namespace boost::assign;
@ -56,9 +56,9 @@ using namespace boost::assign;
* Create a new instance of bladerf_sink_c and return
* a boost shared_ptr. This is effectively the public constructor.
*/
bladerf_sink_c_sptr make_bladerf_sink_c (const std::string &args)
bladerf_sink_c_sptr make_bladerf_sink_c(const std::string &args)
{
return gnuradio::get_initial_sptr(new bladerf_sink_c (args));
return gnuradio::get_initial_sptr(new bladerf_sink_c(args));
}
/*
@ -70,18 +70,18 @@ bladerf_sink_c_sptr make_bladerf_sink_c (const std::string &args)
* are connected to this block. In this case, we accept either
* 1 or 2 inputs.
*/
static const int MIN_IN = 1; // mininum number of input streams
static const int MAX_IN = 2; // maximum number of input streams
static const int MIN_OUT = 0; // minimum number of output streams
static const int MAX_OUT = 0; // maximum number of output streams
static const int MIN_IN = 1; // mininum number of input streams
static const int MAX_IN = 2; // maximum number of input streams
static const int MIN_OUT = 0; // minimum number of output streams
static const int MAX_OUT = 0; // maximum number of output streams
/*
* The private constructor
*/
bladerf_sink_c::bladerf_sink_c (const std::string &args)
: gr::sync_block ("bladerf_sink_c",
gr::io_signature::make (MIN_IN, MAX_IN, sizeof (gr_complex)),
gr::io_signature::make (MIN_OUT, MAX_OUT, sizeof (gr_complex)))
bladerf_sink_c::bladerf_sink_c(const std::string &args)
:gr::sync_block("bladerf_sink_c",
gr::io_signature::make(MIN_IN, MAX_IN, sizeof(gr_complex)),
gr::io_signature::make(MIN_OUT, MAX_OUT, sizeof(gr_complex)))
{
dict_t dict = params_to_dict(args);
@ -104,8 +104,8 @@ bool bladerf_sink_c::stop()
int bladerf_sink_c::transmit_with_tags(int noutput_items)
{
int status;
int count = 0;
int status = 0;
// For a long burst, we may be transmitting the burst contents over
// multiple work calls, so we'll just be sending the entire buffer
@ -114,7 +114,7 @@ int bladerf_sink_c::transmit_with_tags(int noutput_items)
int end_idx = (noutput_items - 1);
struct bladerf_metadata meta;
std::vector<gr::tag_t> tags;
std::vector < gr::tag_t > tags;
int16_t zeros[8] = { 0 };
@ -135,29 +135,30 @@ int bladerf_sink_c::transmit_with_tags(int noutput_items)
DBG("TX'ing " << noutput_items << " samples in within a burst...");
return bladerf_sync_tx(_dev.get(),
static_cast<void *>(_conv_buf),
static_cast < void *>(_conv_buf),
noutput_items, &meta, _stream_timeout_ms);
} else {
std::cerr << _pfx << "Dropping " << noutput_items
<< " samples not in a burst." << std::endl;
std::cerr << _pfx
<< "Dropping " << noutput_items << " samples not in a burst."
<< std::endl;
}
}
BOOST_FOREACH( gr::tag_t tag, tags) {
BOOST_FOREACH(gr::tag_t tag, tags) {
// Upon seeing an SOB tag, update our offset. We'll TX the start of the
// burst when we see an EOB or at the end of this function - whichever
// occurs first.
if (pmt::symbol_to_string(tag.key) == "tx_sob") {
if (_in_burst) {
std::cerr << ("Got SOB while already within a burst");
std::cerr << ("Got SOB while already within a burst") << std::endl;
return BLADERF_ERR_INVAL;
} else {
start_idx = static_cast<int>(tag.offset - nitems_read(0));
start_idx = static_cast < int >(tag.offset - nitems_read(0));
DBG("Got SOB " << start_idx << " samples into work payload");
meta.flags |= (BLADERF_META_FLAG_TX_NOW | BLADERF_META_FLAG_TX_BURST_START);
meta.flags |=
(BLADERF_META_FLAG_TX_NOW | BLADERF_META_FLAG_TX_BURST_START);
_in_burst = true;
}
@ -166,12 +167,11 @@ int bladerf_sink_c::transmit_with_tags(int noutput_items)
std::cerr << _pfx << "Got EOB while not in burst" << std::endl;
return BLADERF_ERR_INVAL;
}
// Upon seeing an EOB, transmit what we have and reset our state
end_idx = static_cast<int>(tag.offset - nitems_read(0));
end_idx = static_cast < int >(tag.offset - nitems_read(0));
DBG("Got EOB " << end_idx << " samples into work payload");
if ( (start_idx == INVALID_IDX) || (start_idx > end_idx) ) {
if ((start_idx == INVALID_IDX) || (start_idx > end_idx)) {
DBG("Buffer indicies are in an invalid state!");
return BLADERF_ERR_INVAL;
}
@ -181,7 +181,7 @@ int bladerf_sink_c::transmit_with_tags(int noutput_items)
DBG("TXing @ EOB [" << start_idx << ":" << end_idx << "]");
status = bladerf_sync_tx(_dev.get(),
static_cast<void *>(&_conv_buf[2*start_idx]),
static_cast < void *>(&_conv_buf[2 * start_idx]),
count, &meta, _stream_timeout_ms);
if (status != 0) {
return status;
@ -199,10 +199,9 @@ int bladerf_sink_c::transmit_with_tags(int noutput_items)
meta.flags |= BLADERF_META_FLAG_TX_BURST_END;
status = bladerf_sync_tx(_dev.get(),
static_cast<void *>(zeros),
static_cast < void *>(zeros),
4, &meta, _stream_timeout_ms);
/* Reset our state */
start_idx = INVALID_IDX;
end_idx = (noutput_items - 1);
@ -218,25 +217,25 @@ int bladerf_sink_c::transmit_with_tags(int noutput_items)
// We had a start of burst with no end yet - transmit those samples
if (_in_burst) {
count = end_idx - start_idx + 1;
count = end_idx - start_idx + 1;
DBG("TXing SOB [" << start_idx << ":" << end_idx << "]");
DBG("TXing SOB [" << start_idx << ":" << end_idx << "]");
status = bladerf_sync_tx(_dev.get(),
static_cast<void *>(&_conv_buf[2*start_idx]),
count, &meta, _stream_timeout_ms);
status = bladerf_sync_tx(_dev.get(),
static_cast < void *>(&_conv_buf[2 * start_idx]),
count, &meta, _stream_timeout_ms);
}
return status;
}
int bladerf_sink_c::work( int noutput_items,
gr_vector_const_void_star &input_items,
gr_vector_void_star &output_items )
int bladerf_sink_c::work(int noutput_items,
gr_vector_const_void_star &input_items,
gr_vector_void_star &output_items)
{
const gr_complex *in = (const gr_complex *) input_items[0];
const float scaling = 2000.0f;
int ret;
int status;
if (noutput_items > _conv_buf_size) {
void *tmp;
@ -244,36 +243,37 @@ int bladerf_sink_c::work( int noutput_items,
_conv_buf_size = noutput_items;
tmp = realloc(_conv_buf, _conv_buf_size * 2 * sizeof(int16_t));
if (tmp == NULL) {
throw std::runtime_error( std::string(__FUNCTION__) +
"Failed to realloc _conv_buf" );
throw std::runtime_error(_pfx + "Failed to realloc _conv_buf");
} else {
DBG("Resized _conv_buf to " << _conv_buf_size << " samples");
}
_conv_buf = static_cast<int16_t*>(tmp);
_conv_buf = static_cast < int16_t * >(tmp);
}
/* Convert floating point samples into fixed point */
volk_32f_s32f_convert_16i(_conv_buf, (float*)in, scaling, 2 * noutput_items);
volk_32f_s32f_convert_16i(_conv_buf, (float *) in, scaling,
2 * noutput_items);
if (_use_metadata) {
ret = transmit_with_tags(noutput_items);
status = transmit_with_tags(noutput_items);
} else {
ret = bladerf_sync_tx(_dev.get(), static_cast<void *>(_conv_buf),
noutput_items, NULL, _stream_timeout_ms);
status = bladerf_sync_tx(_dev.get(), static_cast < void *>(_conv_buf),
noutput_items, NULL, _stream_timeout_ms);
}
if ( ret != 0 ) {
std::cerr << _pfx << "bladerf_sync_tx error: "
<< bladerf_strerror(ret) << std::endl;
if (status != 0) {
std::cerr << _pfx
<< "bladerf_sync_tx error: " << bladerf_strerror(status)
<< std::endl;
_consecutive_failures++;
if ( _consecutive_failures >= MAX_CONSECUTIVE_FAILURES ) {
noutput_items = WORK_DONE;
std::cerr << _pfx
<< "Consecutive error limit hit. Shutting down."
<< std::endl;
if (_consecutive_failures >= MAX_CONSECUTIVE_FAILURES) {
noutput_items = WORK_DONE;
std::cerr << _pfx
<< "Consecutive error limit hit. Shutting down."
<< std::endl;
}
} else {
_consecutive_failures = 0;
@ -282,8 +282,7 @@ int bladerf_sink_c::work( int noutput_items,
return noutput_items;
}
std::vector<std::string> bladerf_sink_c::get_devices()
std::vector < std::string > bladerf_sink_c::get_devices()
{
return bladerf_common::devices();
}
@ -323,66 +322,68 @@ double bladerf_sink_c::get_center_freq(size_t chan)
return bladerf_common::get_center_freq(BLADERF_CHANNEL_TX(chan));
}
double bladerf_sink_c::set_freq_corr( double ppm, size_t chan )
double bladerf_sink_c::set_freq_corr(double ppm, size_t chan)
{
/* TODO: Write the VCTCXO with a correction value (also changes RX ppm value!) */
return get_freq_corr( BLADERF_CHANNEL_TX(chan) );
return get_freq_corr(BLADERF_CHANNEL_TX(chan));
}
double bladerf_sink_c::get_freq_corr( size_t chan )
double bladerf_sink_c::get_freq_corr(size_t chan)
{
/* TODO: Return back the frequency correction in ppm */
return 0;
}
std::vector<std::string> bladerf_sink_c::get_gain_names( size_t chan )
std::vector < std::string > bladerf_sink_c::get_gain_names(size_t chan)
{
return bladerf_common::get_gain_names(BLADERF_CHANNEL_TX(chan));
}
osmosdr::gain_range_t bladerf_sink_c::get_gain_range( size_t chan )
osmosdr::gain_range_t bladerf_sink_c::get_gain_range(size_t chan)
{
return bladerf_common::get_gain_range(BLADERF_CHANNEL_TX(chan));
}
osmosdr::gain_range_t bladerf_sink_c::get_gain_range( const std::string & name, size_t chan )
osmosdr::gain_range_t bladerf_sink_c::get_gain_range(const std::string &name,
size_t chan)
{
return bladerf_common::get_gain_range(name, BLADERF_CHANNEL_TX(chan));
}
bool bladerf_sink_c::set_gain_mode( bool automatic, size_t chan )
bool bladerf_sink_c::set_gain_mode(bool automatic, size_t chan)
{
return bladerf_common::set_gain_mode(automatic, BLADERF_CHANNEL_TX(chan));
}
bool bladerf_sink_c::get_gain_mode( size_t chan )
bool bladerf_sink_c::get_gain_mode(size_t chan)
{
return bladerf_common::get_gain_mode(BLADERF_CHANNEL_TX(chan));
}
double bladerf_sink_c::set_gain( double gain, size_t chan )
double bladerf_sink_c::set_gain(double gain, size_t chan)
{
return bladerf_common::set_gain(gain, BLADERF_CHANNEL_TX(chan));
}
double bladerf_sink_c::set_gain( double gain, const std::string & name, size_t chan)
double bladerf_sink_c::set_gain(double gain, const std::string &name,
size_t chan)
{
return bladerf_common::set_gain(gain, name, BLADERF_CHANNEL_TX(chan));
}
double bladerf_sink_c::get_gain( size_t chan )
double bladerf_sink_c::get_gain(size_t chan)
{
return bladerf_common::get_gain(BLADERF_CHANNEL_TX(chan));
}
double bladerf_sink_c::get_gain( const std::string & name, size_t chan )
double bladerf_sink_c::get_gain(const std::string &name, size_t chan)
{
return bladerf_common::get_gain(name, BLADERF_CHANNEL_TX(chan));
}
std::vector< std::string > bladerf_sink_c::get_antennas( size_t chan )
std::vector < std::string > bladerf_sink_c::get_antennas(size_t chan)
{
std::vector< std::string > antennas;
std::vector < std::string > antennas;
antennas += "TX0";
@ -393,83 +394,87 @@ std::vector< std::string > bladerf_sink_c::get_antennas( size_t chan )
return antennas;
}
std::string bladerf_sink_c::set_antenna( const std::string & antenna, size_t chan )
std::string bladerf_sink_c::set_antenna(const std::string &antenna,
size_t chan)
{
return get_antenna( BLADERF_CHANNEL_TX(chan) );
return get_antenna(BLADERF_CHANNEL_TX(chan));
}
std::string bladerf_sink_c::get_antenna( size_t chan )
std::string bladerf_sink_c::get_antenna(size_t chan)
{
/* We only have a single transmit antenna here */
// TODO: the above is a lie
return "TX0";
}
void bladerf_sink_c::set_dc_offset( const std::complex<double> &offset, size_t chan )
void bladerf_sink_c::set_dc_offset(const std::complex < double > &offset,
size_t chan)
{
int ret = 0;
int status;
ret = bladerf_common::set_dc_offset(BLADERF_TX, offset, chan);
status = bladerf_common::set_dc_offset(BLADERF_TX, offset, chan);
if( ret ) {
throw std::runtime_error( std::string(__FUNCTION__) + " " +
"could not set dc offset: " +
std::string(bladerf_strerror(ret)) );
if (status != 0) {
throw std::runtime_error(_pfx + "could not set dc offset: " +
bladerf_strerror(status));
}
}
void bladerf_sink_c::set_iq_balance( const std::complex<double> &balance, size_t chan )
void bladerf_sink_c::set_iq_balance(const std::complex < double > &balance,
size_t chan)
{
int ret = 0;
int status;
ret = bladerf_common::set_iq_balance(BLADERF_TX, balance, chan);
status = bladerf_common::set_iq_balance(BLADERF_TX, balance, chan);
if( ret ) {
throw std::runtime_error( std::string(__FUNCTION__) + " " +
"could not set iq balance: " +
std::string(bladerf_strerror(ret)) );
if (status != 0) {
throw std::runtime_error(_pfx + "could not set iq balance: " +
bladerf_strerror(status));
}
}
double bladerf_sink_c::set_bandwidth( double bandwidth, size_t chan )
double bladerf_sink_c::set_bandwidth(double bandwidth, size_t chan)
{
int ret;
int status;
uint32_t actual;
if ( bandwidth == 0.0 ) /* bandwidth of 0 means automatic filter selection */
bandwidth = get_sample_rate() * 0.75; /* select narrower filters to prevent aliasing */
if (bandwidth == 0.0) {
/* bandwidth of 0 means automatic filter selection */
/* select narrower filters to prevent aliasing */
bandwidth = get_sample_rate() * 0.75;
}
ret = bladerf_set_bandwidth( _dev.get(), BLADERF_TX, (uint32_t)bandwidth, &actual );
if( ret ) {
throw std::runtime_error( std::string(__FUNCTION__) + " " +
"could not set bandwidth:" +
std::string(bladerf_strerror(ret)) );
status = bladerf_set_bandwidth(_dev.get(), BLADERF_TX, (uint32_t) bandwidth,
&actual);
if (status != 0) {
throw std::runtime_error(_pfx + "could not set bandwidth:" +
bladerf_strerror(status));
}
return get_bandwidth();
}
double bladerf_sink_c::get_bandwidth( size_t chan )
double bladerf_sink_c::get_bandwidth(size_t chan)
{
int status;
uint32_t bandwidth;
int ret;
ret = bladerf_get_bandwidth( _dev.get(), BLADERF_TX, &bandwidth );
if( ret ) {
throw std::runtime_error( std::string(__FUNCTION__) + " " +
"could not get bandwidth: " +
std::string(bladerf_strerror(ret)) );
status = bladerf_get_bandwidth(_dev.get(), BLADERF_TX, &bandwidth);
if (status != 0) {
throw std::runtime_error(_pfx + "could not get bandwidth: " +
bladerf_strerror(status));
}
return (double)bandwidth;
return (double) bandwidth;
}
osmosdr::freq_range_t bladerf_sink_c::get_bandwidth_range( size_t chan )
osmosdr::freq_range_t bladerf_sink_c::get_bandwidth_range(size_t chan)
{
return filter_bandwidths();
}
void bladerf_sink_c::set_clock_source(const std::string &source, const size_t mboard)
void bladerf_sink_c::set_clock_source(const std::string &source,
const size_t mboard)
{
bladerf_common::set_clock_source(source, mboard);
}
@ -479,7 +484,7 @@ std::string bladerf_sink_c::get_clock_source(const size_t mboard)
return bladerf_common::get_clock_source(mboard);
}
std::vector<std::string> bladerf_sink_c::get_clock_sources(const size_t mboard)
std::vector < std::string > bladerf_sink_c::get_clock_sources(const size_t mboard)
{
return bladerf_common::get_clock_sources(mboard);
}

@ -48,9 +48,9 @@ using namespace boost::assign;
* Create a new instance of bladerf_source_c and return
* a boost shared_ptr. This is effectively the public constructor.
*/
bladerf_source_c_sptr make_bladerf_source_c (const std::string &args)
bladerf_source_c_sptr make_bladerf_source_c(const std::string &args)
{
return gnuradio::get_initial_sptr(new bladerf_source_c (args));
return gnuradio::get_initial_sptr(new bladerf_source_c(args));
}
/*
@ -62,20 +62,20 @@ bladerf_source_c_sptr make_bladerf_source_c (const std::string &args)
* are connected to this block. In this case, we accept either
* 1 or 2 outputs.
*/
static const int MIN_IN = 0; // mininum number of input streams
static const int MAX_IN = 0; // maximum number of input streams
static const int MIN_OUT = 1; // minimum number of output streams
static const int MAX_OUT = 2; // maximum number of output streams
static const int MIN_IN = 0; // mininum number of input streams
static const int MAX_IN = 0; // maximum number of input streams
static const int MIN_OUT = 1; // minimum number of output streams
static const int MAX_OUT = 2; // maximum number of output streams
/*
* The private constructor
*/
bladerf_source_c::bladerf_source_c (const std::string &args)
: gr::sync_block ("bladerf_source_c",
gr::io_signature::make (MIN_IN, MAX_IN, sizeof (gr_complex)),
gr::io_signature::make (MIN_OUT, MAX_OUT, sizeof (gr_complex)))
bladerf_source_c::bladerf_source_c(const std::string &args)
:gr::sync_block("bladerf_source_c",
gr::io_signature::make(MIN_IN, MAX_IN, sizeof(gr_complex)),
gr::io_signature::make(MIN_OUT, MAX_OUT, sizeof(gr_complex)))
{
int ret;
int status;
std::string device_name;
struct bladerf_version fpga_version;
@ -83,36 +83,46 @@ bladerf_source_c::bladerf_source_c (const std::string &args)
init(dict, BLADERF_RX);
if (dict.count("sampling"))
{
if (dict.count("sampling")) {
std::string sampling = dict["sampling"];
std::cerr << _pfx << "Setting bladerf sampling to " << sampling << std::endl;
if( sampling == "internal") {
ret = bladerf_set_sampling( _dev.get(), BLADERF_SAMPLING_INTERNAL );
if ( ret != 0 )
std::cerr << _pfx << "Problem while setting sampling mode:"
<< bladerf_strerror(ret) << std::endl;
} else if( sampling == "external" ) {
ret = bladerf_set_sampling( _dev.get(), BLADERF_SAMPLING_EXTERNAL );
if ( ret != 0 )
std::cerr << _pfx << "Problem while setting sampling mode:"
<< bladerf_strerror(ret) << std::endl;
std::cerr << _pfx
<< "Setting bladerf sampling to " << sampling
<< std::endl;
if (sampling == "internal") {
status = bladerf_set_sampling(_dev.get(), BLADERF_SAMPLING_INTERNAL);
if (status != 0) {
std::cerr << _pfx
<< "Problem while setting sampling mode: "
<< bladerf_strerror(status)
<< std::endl;
}
} else if (sampling == "external") {
status = bladerf_set_sampling(_dev.get(), BLADERF_SAMPLING_EXTERNAL);
if (status != 0) {
std::cerr << _pfx
<< "Problem while setting sampling mode: "
<< bladerf_strerror(status)
<< std::endl;
}
} else {
std::cerr << _pfx << "Invalid sampling mode " << sampling << std::endl;
std::cerr << _pfx << "Invalid sampling mode " << sampling << std::endl;
}
}
/* Warn user about using an old FPGA version, as we no longer strip off the
* markers that were pressent in the pre-v0.0.1 FPGA */
if (bladerf_fpga_version( _dev.get(), &fpga_version ) != 0) {
if (bladerf_fpga_version(_dev.get(), &fpga_version) != 0) {
std::cerr << _pfx << "Failed to get FPGA version" << std::endl;
} else if ( fpga_version.major <= 0 &&
fpga_version.minor <= 0 &&
fpga_version.patch < 1 ) {
} else if (fpga_version.major <= 0 &&
fpga_version.minor <= 0 && fpga_version.patch < 1) {
std::cerr << _pfx << "Warning: FPGA version v0.0.1 or later is required. "
<< "Using an earlier FPGA version will result in misinterpeted samples. "
std::cerr << _pfx
<< "Warning: FPGA version v0.0.1 or later is required. Using an "
<< "earlier FPGA version will result in misinterpeted samples."
<< std::endl;
}
}
@ -127,12 +137,12 @@ bool bladerf_source_c::stop()
return bladerf_common::stop(BLADERF_RX);
}
int bladerf_source_c::work( int noutput_items,
gr_vector_const_void_star &input_items,
gr_vector_void_star &output_items )
int bladerf_source_c::work(int noutput_items,
gr_vector_const_void_star &input_items,
gr_vector_void_star &output_items)
{
int ret;
const float scaling = 2048.0f;
int status;
gr_complex *out = static_cast<gr_complex *>(output_items[0]);
struct bladerf_metadata meta;
struct bladerf_metadata *meta_ptr = NULL;
@ -143,11 +153,10 @@ int bladerf_source_c::work( int noutput_items,
_conv_buf_size = noutput_items;
tmp = realloc(_conv_buf, _conv_buf_size * 2 * sizeof(int16_t));
if (tmp == NULL) {
throw std::runtime_error( std::string(__FUNCTION__) +
"Failed to realloc _conv_buf" );
throw std::runtime_error(_pfx + "Failed to realloc _conv_buf");
}
_conv_buf = static_cast<int16_t*>(tmp);
_conv_buf = static_cast<int16_t *>(tmp);
}
if (_use_metadata) {
@ -157,31 +166,33 @@ int bladerf_source_c::work( int noutput_items,
}
/* Grab all the samples into the temporary buffer */
ret = bladerf_sync_rx(_dev.get(), static_cast<void *>(_conv_buf),
noutput_items, meta_ptr, _stream_timeout_ms);
if ( ret != 0 ) {
std::cerr << _pfx << "bladerf_sync_rx error: "
<< bladerf_strerror(ret) << std::endl;
status = bladerf_sync_rx(_dev.get(), static_cast<void *>(_conv_buf),
noutput_items, meta_ptr, _stream_timeout_ms);
if (status != 0) {
std::cerr << _pfx
<< "bladerf_sync_rx error: " << bladerf_strerror(status)
<< std::endl;
_consecutive_failures++;
if ( _consecutive_failures >= MAX_CONSECUTIVE_FAILURES ) {
std::cerr << _pfx
<< "Consecutive error limit hit. Shutting down."
<< std::endl;
return WORK_DONE;
if (_consecutive_failures >= MAX_CONSECUTIVE_FAILURES) {
std::cerr << _pfx
<< "Consecutive error limit hit. Shutting down."
<< std::endl;
return WORK_DONE;
}
} else {
_consecutive_failures = 0;
_consecutive_failures = 0;
}
/* Convert them from fixed to floating point */
volk_16i_s32f_convert_32f((float*)out, _conv_buf, scaling, 2*noutput_items);
volk_16i_s32f_convert_32f((float *) out, _conv_buf, scaling,
2 * noutput_items);
return noutput_items;
}
std::vector<std::string> bladerf_source_c::get_devices()
std::vector < std::string > bladerf_source_c::get_devices()
{
return bladerf_common::devices();
}
@ -196,14 +207,14 @@ osmosdr::meta_range_t bladerf_source_c::get_sample_rates()
return sample_rates();
}
double bladerf_source_c::set_sample_rate( double rate )
double bladerf_source_c::set_sample_rate(double rate)
{
return bladerf_common::set_sample_rate( BLADERF_RX, rate);
return bladerf_common::set_sample_rate(BLADERF_RX, rate);
}
double bladerf_source_c::get_sample_rate()
{
return bladerf_common::get_sample_rate( BLADERF_RX );
return bladerf_common::get_sample_rate(BLADERF_RX);
}
osmosdr::freq_range_t bladerf_source_c::get_freq_range(size_t chan)
@ -221,66 +232,68 @@ double bladerf_source_c::get_center_freq(size_t chan)
return bladerf_common::get_center_freq(BLADERF_CHANNEL_RX(chan));
}
double bladerf_source_c::set_freq_corr( double ppm, size_t chan )
double bladerf_source_c::set_freq_corr(double ppm, size_t chan)
{
/* TODO: Write the VCTCXO with a correction value (also changes TX ppm value!) */
return get_freq_corr( BLADERF_CHANNEL_RX(chan) );
return get_freq_corr(BLADERF_CHANNEL_RX(chan));
}
double bladerf_source_c::get_freq_corr( size_t chan )
double bladerf_source_c::get_freq_corr(size_t chan)
{
/* TODO: Return back the frequency correction in ppm */
return 0;
}
std::vector<std::string> bladerf_source_c::get_gain_names( size_t chan )
std::vector < std::string > bladerf_source_c::get_gain_names(size_t chan)
{
return bladerf_common::get_gain_names(BLADERF_CHANNEL_RX(chan));
}
osmosdr::gain_range_t bladerf_source_c::get_gain_range( size_t chan )
osmosdr::gain_range_t bladerf_source_c::get_gain_range(size_t chan)
{
return bladerf_common::get_gain_range(BLADERF_CHANNEL_RX(chan));
}
osmosdr::gain_range_t bladerf_source_c::get_gain_range( const std::string & name, size_t chan )
osmosdr::gain_range_t bladerf_source_c::get_gain_range(const std::string &name,
size_t chan)
{
return bladerf_common::get_gain_range(name, BLADERF_CHANNEL_RX(chan));
}
bool bladerf_source_c::set_gain_mode( bool automatic, size_t chan )
bool bladerf_source_c::set_gain_mode(bool automatic, size_t chan)
{
return bladerf_common::set_gain_mode(automatic, BLADERF_CHANNEL_RX(chan));
}
bool bladerf_source_c::get_gain_mode( size_t chan )
bool bladerf_source_c::get_gain_mode(size_t chan)
{
return bladerf_common::get_gain_mode(BLADERF_CHANNEL_RX(chan));
}
double bladerf_source_c::set_gain( double gain, size_t chan )
double bladerf_source_c::set_gain(double gain, size_t chan)
{
return bladerf_common::set_gain(gain, BLADERF_CHANNEL_RX(chan));
}
double bladerf_source_c::set_gain( double gain, const std::string & name, size_t chan)
double bladerf_source_c::set_gain(double gain, const std::string &name,
size_t chan)
{
return bladerf_common::set_gain(gain, name, BLADERF_CHANNEL_RX(chan));
}
double bladerf_source_c::get_gain( size_t chan )
double bladerf_source_c::get_gain(size_t chan)
{
return bladerf_common::get_gain(BLADERF_CHANNEL_RX(chan));
}
double bladerf_source_c::get_gain( const std::string & name, size_t chan )
double bladerf_source_c::get_gain(const std::string &name, size_t chan)
{
return bladerf_common::get_gain(name, BLADERF_CHANNEL_RX(chan));
}
std::vector< std::string > bladerf_source_c::get_antennas( size_t chan )
std::vector < std::string > bladerf_source_c::get_antennas(size_t chan)
{
std::vector< std::string > antennas;
std::vector < std::string > antennas;
antennas += "RX0";
@ -291,109 +304,121 @@ std::vector< std::string > bladerf_source_c::get_antennas( size_t chan )
return antennas;
}
std::string bladerf_source_c::set_antenna( const std::string & antenna, size_t chan )
std::string bladerf_source_c::set_antenna(const std::string &antenna,
size_t chan)
{
return get_antenna( BLADERF_CHANNEL_RX(chan) );
return get_antenna(BLADERF_CHANNEL_RX(chan));
}
std::string bladerf_source_c::get_antenna( size_t chan )
std::string bladerf_source_c::get_antenna(size_t chan)
{
/* We only have a single receive antenna here */
// TODO: this is a lie
return "RX0";
}
void bladerf_source_c::set_dc_offset_mode( int mode, size_t chan )
void bladerf_source_c::set_dc_offset_mode(int mode, size_t chan)
{
if ( osmosdr::source::DCOffsetOff == mode ) {
if (osmosdr::source::DCOffsetOff == mode) {
//_src->set_auto_dc_offset( false, chan );
/* reset to default for off-state */
set_dc_offset(std::complex < double >(0.0, 0.0), chan);
} else if (osmosdr::source::DCOffsetManual == mode) {
/* disable auto mode, but keep correcting with last known values */
//_src->set_auto_dc_offset( false, chan );
set_dc_offset( std::complex<double>(0.0, 0.0), chan ); /* reset to default for off-state */
} else if ( osmosdr::source::DCOffsetManual == mode ) {
//_src->set_auto_dc_offset( false, chan ); /* disable auto mode, but keep correcting with last known values */
} else if ( osmosdr::source::DCOffsetAutomatic == mode ) {
} else if (osmosdr::source::DCOffsetAutomatic == mode) {
//_src->set_auto_dc_offset( true, chan );
std::cerr << "Automatic DC correction mode is not implemented." << std::endl;
std::cerr << _pfx
<< "Automatic DC correction mode is not implemented."
<< std::endl;
}
}
void bladerf_source_c::set_dc_offset( const std::complex<double> &offset, size_t chan )
void bladerf_source_c::set_dc_offset(const std::complex < double > &offset,
size_t chan)
{
int ret = 0;
int status;
ret = bladerf_common::set_dc_offset(BLADERF_RX, offset, chan);
status = bladerf_common::set_dc_offset(BLADERF_RX, offset, chan);
if( ret ) {
throw std::runtime_error( std::string(__FUNCTION__) + " " +
"could not set dc offset: " +
std::string(bladerf_strerror(ret)) );
if (status != 0) {
throw std::runtime_error(_pfx + "could not set dc offset: " +
bladerf_strerror(status));
}
}
void bladerf_source_c::set_iq_balance_mode( int mode, size_t chan )
void bladerf_source_c::set_iq_balance_mode(int mode, size_t chan)
{
if ( osmosdr::source::IQBalanceOff == mode ) {
if (osmosdr::source::IQBalanceOff == mode) {
//_src->set_auto_iq_balance( false, chan );
/* reset to default for off-state */
set_iq_balance(std::complex < double >(0.0, 0.0), chan);
} else if (osmosdr::source::IQBalanceManual == mode) {
/* disable auto mode, but keep correcting with last known values */
//_src->set_auto_iq_balance( false, chan );
set_iq_balance( std::complex<double>(0.0, 0.0), chan ); /* reset to default for off-state */
} else if ( osmosdr::source::IQBalanceManual == mode ) {
//_src->set_auto_iq_balance( false, chan ); /* disable auto mode, but keep correcting with last known values */
} else if ( osmosdr::source::IQBalanceAutomatic == mode ) {
} else if (osmosdr::source::IQBalanceAutomatic == mode) {
//_src->set_auto_iq_balance( true, chan );
std::cerr << "Automatic IQ correction mode is not implemented." << std::endl;
std::cerr << _pfx
<< "Automatic IQ correction mode is not implemented."
<< std::endl;
}
}
void bladerf_source_c::set_iq_balance( const std::complex<double> &balance, size_t chan )
void bladerf_source_c::set_iq_balance(const std::complex < double > &balance,
size_t chan)
{
int ret = 0;
int status;
ret = bladerf_common::set_iq_balance(BLADERF_RX, balance, chan);
status = bladerf_common::set_iq_balance(BLADERF_RX, balance, chan);
if( ret ) {
throw std::runtime_error( std::string(__FUNCTION__) + " " +
"could not set iq balance: " +
std::string(bladerf_strerror(ret)) );
if (status != 0) {
throw std::runtime_error(_pfx + "could not set iq balance: " +
bladerf_strerror(status));
}
}
double bladerf_source_c::set_bandwidth( double bandwidth, size_t chan )
double bladerf_source_c::set_bandwidth(double bandwidth, size_t chan)
{
int ret;
int status;
uint32_t actual;
if ( bandwidth == 0.0 ) /* bandwidth of 0 means automatic filter selection */
bandwidth = get_sample_rate() * 0.75; /* select narrower filters to prevent aliasing */
if (bandwidth == 0.0) {
/* bandwidth of 0 means automatic filter selection */
/* select narrower filters to prevent aliasing */
bandwidth = get_sample_rate() * 0.75;
}
ret = bladerf_set_bandwidth( _dev.get(), BLADERF_RX, (uint32_t)bandwidth, &actual );
if( ret ) {
throw std::runtime_error( std::string(__FUNCTION__) + " " +
"could not set bandwidth: " +
std::string(bladerf_strerror(ret)) );
status = bladerf_set_bandwidth(_dev.get(), BLADERF_RX, (uint32_t) bandwidth,
&actual);
if (status != 0) {
throw std::runtime_error(_pfx + "could not set bandwidth: " +
bladerf_strerror(status));
}
return get_bandwidth();
}
double bladerf_source_c::get_bandwidth( size_t chan )
double bladerf_source_c::get_bandwidth(size_t chan)
{
int status;
uint32_t bandwidth;
int ret;
ret = bladerf_get_bandwidth( _dev.get(), BLADERF_RX, &bandwidth );
if( ret ) {
throw std::runtime_error( std::string(__FUNCTION__) + " " +
"could not get bandwidth:" +
std::string(bladerf_strerror(ret)) );
status = bladerf_get_bandwidth(_dev.get(), BLADERF_RX, &bandwidth);
if (status != 0) {
throw std::runtime_error(_pfx + "could not get bandwidth: " +
bladerf_strerror(status));
}
return (double)bandwidth;
return (double) bandwidth;
}
osmosdr::freq_range_t bladerf_source_c::get_bandwidth_range( size_t chan )
osmosdr::freq_range_t bladerf_source_c::get_bandwidth_range(size_t chan)
{
return filter_bandwidths();
}
void bladerf_source_c::set_clock_source(const std::string &source, const size_t mboard)
void bladerf_source_c::set_clock_source(const std::string &source,
const size_t mboard)
{
bladerf_common::set_clock_source(source, mboard);
}
@ -403,7 +428,7 @@ std::string bladerf_source_c::get_clock_source(const size_t mboard)
return bladerf_common::get_clock_source(mboard);
}
std::vector<std::string> bladerf_source_c::get_clock_sources(const size_t mboard)
std::vector < std::string > bladerf_source_c::get_clock_sources(const size_t mboard)
{
return bladerf_common::get_clock_sources(mboard);
}

Loading…
Cancel
Save