diff --git a/lib/bladerf/bladerf_common.cc b/lib/bladerf/bladerf_common.cc index ff7f338..f6938ac 100644 --- a/lib/bladerf/bladerf_common.cc +++ b/lib/bladerf/bladerf_common.cc @@ -46,14 +46,14 @@ using namespace boost::assign; boost::mutex bladerf_common::_devs_mutex; -std::list > bladerf_common::_devs; +std::list < boost::weak_ptr < struct bladerf >> bladerf_common::_devs; /* name of system-wide gain * (internal only, doesn't match any libbladeRF gain stage) */ -static const char* SYSTEM_GAIN_NAME = "system"; +static const char *SYSTEM_GAIN_NAME = "system"; -bladerf_common::bladerf_common() : +bladerf_common::bladerf_common(): _conv_buf(NULL), _conv_buf_size(4096), _xb_200_attached(false), @@ -66,17 +66,18 @@ bladerf_common::~bladerf_common() free(_conv_buf); } -bladerf_board_type bladerf_common::get_board_type( struct bladerf *dev ) +bladerf_board_type bladerf_common::get_board_type(struct bladerf *dev) { - std::string boardname = std::string( bladerf_get_board_name(dev) ); + std::string boardname = std::string(bladerf_get_board_name(dev)); - if ( boardname == "bladerf1" ) { + if (boardname == "bladerf1") { return BLADERF_REV_1; - } else if ( boardname == "bladerf2" ) { + } else if (boardname == "bladerf2") { return BLADERF_REV_2; } - std::cerr << _pfx << "board name \"" << boardname << "\" unknown" + std::cerr << _pfx + << "board name \"" << boardname << "\" unknown" << std::endl; return BLADERF_REV_INVALID; } @@ -84,19 +85,18 @@ bladerf_board_type bladerf_common::get_board_type( struct bladerf *dev ) bladerf_sptr bladerf_common::get_cached_device( struct bladerf_devinfo devinfo ) { /* Lock to _devs must be aquired by caller */ - BOOST_FOREACH( boost::weak_ptr dev, _devs ) - { + BOOST_FOREACH(boost::weak_ptr < struct bladerf >dev, _devs) { int status; struct bladerf_devinfo other_devinfo; - status = bladerf_get_devinfo( bladerf_sptr(dev).get(), &other_devinfo ); - if ( status < 0 ) { - throw std::runtime_error( std::string(__FUNCTION__) + - "Failed to get devinfo for cached device: " + - bladerf_strerror(status) ); + status = bladerf_get_devinfo(bladerf_sptr(dev).get(), &other_devinfo); + if (status < 0) { + throw std::runtime_error(std::string(__FUNCTION__) + + "Failed to get devinfo for cached device: " + + bladerf_strerror(status)); } - if ( bladerf_devinfo_matches(&devinfo, &other_devinfo) ) { + if (bladerf_devinfo_matches(&devinfo, &other_devinfo)) { return bladerf_sptr(dev); } } @@ -105,40 +105,40 @@ bladerf_sptr bladerf_common::get_cached_device( struct bladerf_devinfo devinfo ) } /* This is called when a bladerf_sptr hits a refcount of 0 */ -void bladerf_common::close( void* dev ) +void bladerf_common::close(void *dev) { - boost::unique_lock lock(_devs_mutex); - std::list >::iterator it(_devs.begin()); + boost::unique_lock < boost::mutex > lock(_devs_mutex); + std::list < boost::weak_ptr < struct bladerf >>::iterator it(_devs.begin()); /* Prune expired entries from device cache */ - while ( it != _devs.end() ) { - if ( (*it).expired() ) { + while (it != _devs.end()) { + if ((*it).expired()) { it = _devs.erase(it); } else { ++it; } } - bladerf_close( static_cast(dev) ); + bladerf_close(static_cast(dev)); } -bladerf_sptr bladerf_common::open( const std::string &device_name ) +bladerf_sptr bladerf_common::open(const std::string &device_name) { int status; struct bladerf *raw_dev = NULL; struct bladerf_devinfo devinfo; - boost::unique_lock lock(_devs_mutex); + boost::unique_lock < boost::mutex > lock(_devs_mutex); /* Initialize the information used to identify the desired device * to all wildcard (i.e., "any device") values */ - bladerf_init_devinfo( &devinfo ); + bladerf_init_devinfo(&devinfo); /* Populate the devinfo structure from device_name */ - status = bladerf_get_devinfo_from_str( device_name.c_str(), &devinfo ); - if ( status < 0 ) { - throw std::runtime_error( _pfx + "Failed to get devinfo for '" + - device_name + "': " + bladerf_strerror(status) ); + status = bladerf_get_devinfo_from_str(device_name.c_str(), &devinfo); + if (status < 0) { + throw std::runtime_error(_pfx + "Failed to get devinfo for '" + + device_name + "': " + bladerf_strerror(status)); } /* Do we already have this device open? */ @@ -149,87 +149,91 @@ bladerf_sptr bladerf_common::open( const std::string &device_name ) } /* Open the device. */ - status = bladerf_open_with_devinfo( &raw_dev, &devinfo ); - if ( status < 0 ) { - throw std::runtime_error( _pfx + "Failed to open device for '" + - device_name + "': " + bladerf_strerror(status) ); + status = bladerf_open_with_devinfo(&raw_dev, &devinfo); + if (status < 0) { + throw std::runtime_error(_pfx + "Failed to open device for '" + + device_name + "': " + bladerf_strerror(status)); } /* Add the device handle to our cache */ - bladerf_sptr dev = bladerf_sptr( raw_dev, bladerf_common::close ); + bladerf_sptr dev = bladerf_sptr(raw_dev, bladerf_common::close); - _devs.push_back( boost::weak_ptr(dev) ); + _devs.push_back(boost::weak_ptr < struct bladerf >(dev)); return dev; } -void bladerf_common::set_loopback_mode( const std::string &loopback ) +void bladerf_common::set_loopback_mode(const std::string &loopback) { int status; bladerf_loopback mode; - if ( loopback == "bb_txlpf_rxvga2" ) { + if (loopback == "bb_txlpf_rxvga2") { mode = BLADERF_LB_BB_TXLPF_RXVGA2; - } else if ( loopback == "bb_txlpf_rxlpf" ) { + } else if (loopback == "bb_txlpf_rxlpf") { mode = BLADERF_LB_BB_TXLPF_RXLPF; - } else if ( loopback == "bb_txvga1_rxvga2" ) { + } else if (loopback == "bb_txvga1_rxvga2") { mode = BLADERF_LB_BB_TXVGA1_RXVGA2; - } else if ( loopback == "bb_txvga1_rxlpf" ) { + } else if (loopback == "bb_txvga1_rxlpf") { mode = BLADERF_LB_BB_TXVGA1_RXLPF; - } else if ( loopback == "rf_lna1" ) { + } else if (loopback == "rf_lna1") { mode = BLADERF_LB_RF_LNA1; - } else if ( loopback == "rf_lna2" ) { + } else if (loopback == "rf_lna2") { mode = BLADERF_LB_RF_LNA2; - } else if ( loopback == "rf_lna3" ) { + } else if (loopback == "rf_lna3") { mode = BLADERF_LB_RF_LNA3; - } else if ( loopback == "ad9361_bist" ) { + } else if (loopback == "ad9361_bist") { mode = BLADERF_LB_AD9361_BIST; - } else if ( loopback == "none" ) { + } else if (loopback == "none") { mode = BLADERF_LB_NONE; } else { - throw std::runtime_error( _pfx + "Unknown loopback mode: " + loopback ); + throw std::runtime_error(_pfx + "Unknown loopback mode: " + loopback); } - status = bladerf_set_loopback( _dev.get(), mode); - if ( status != 0 ) { + status = bladerf_set_loopback(_dev.get(), mode); + if (status != 0) { // TODO: handle BLADERF_ERR_UNSUPPORTED more gingerly - throw std::runtime_error( _pfx + "Failed to set loopback mode: " + - bladerf_strerror(status) ); + throw std::runtime_error(_pfx + "Failed to set loopback mode: " + + bladerf_strerror(status)); } } -void bladerf_common::set_verbosity( const std::string &verbosity ) +void bladerf_common::set_verbosity(const std::string &verbosity) { bladerf_log_level l; - if ( verbosity == "verbose" ) { + if (verbosity == "verbose") { l = BLADERF_LOG_LEVEL_VERBOSE; - } else if ( verbosity == "debug" ) { + } else if (verbosity == "debug") { l = BLADERF_LOG_LEVEL_DEBUG; - } else if ( verbosity == "info" ) { + } else if (verbosity == "info") { l = BLADERF_LOG_LEVEL_INFO; - } else if ( verbosity == "warning" ) { + } else if (verbosity == "warning") { l = BLADERF_LOG_LEVEL_WARNING; - } else if ( verbosity == "error" ) { + } else if (verbosity == "error") { l = BLADERF_LOG_LEVEL_ERROR; - } else if ( verbosity == "critical" ) { + } else if (verbosity == "critical") { l = BLADERF_LOG_LEVEL_CRITICAL; - } else if ( verbosity == "silent" ) { + } else if (verbosity == "silent") { l = BLADERF_LOG_LEVEL_SILENT; } else { - throw std::runtime_error( _pfx + "Invalid log level: " + verbosity ); + throw std::runtime_error(_pfx + "Invalid log level: " + verbosity); } bladerf_log_set_verbosity(l); } -bool bladerf_common::start( bladerf_direction direction ) +bool bladerf_common::start(bladerf_direction direction) { int status; bladerf_format format; bladerf_channel_layout layout; - format = _use_metadata ? BLADERF_FORMAT_SC16_Q11_META : BLADERF_FORMAT_SC16_Q11; + if (_use_metadata) { + format = BLADERF_FORMAT_SC16_Q11_META; + } else { + format = BLADERF_FORMAT_SC16_Q11; + } switch (direction) { case BLADERF_RX: @@ -239,58 +243,58 @@ bool bladerf_common::start( bladerf_direction direction ) layout = _use_mimo ? BLADERF_TX_X2 : BLADERF_TX_X1; break; default: - throw std::runtime_error( _pfx + "Invalid direction: " + - boost::lexical_cast(direction) ); + throw std::runtime_error(_pfx + "Invalid direction: " + + boost::lexical_cast(direction)); } - status = bladerf_sync_config( _dev.get(), layout, format, - _num_buffers, _samples_per_buffer, - _num_transfers, _stream_timeout_ms ); - if ( status != 0 ) { - throw std::runtime_error( _pfx + "bladerf_sync_config failed: " + - bladerf_strerror(status) ); + status = bladerf_sync_config(_dev.get(), layout, format, + _num_buffers, _samples_per_buffer, + _num_transfers, _stream_timeout_ms); + if (status != 0) { + throw std::runtime_error(_pfx + "bladerf_sync_config failed: " + + bladerf_strerror(status)); } - status = bladerf_enable_module( _dev.get(), direction, true ); - if ( status != 0 ) { - throw std::runtime_error( _pfx + "bladerf_enable_module failed: " + - bladerf_strerror(status) ); + status = bladerf_enable_module(_dev.get(), direction, true); + if (status != 0) { + throw std::runtime_error(_pfx + "bladerf_enable_module failed: " + + bladerf_strerror(status)); } return true; } -bool bladerf_common::stop( bladerf_direction direction ) +bool bladerf_common::stop(bladerf_direction direction) { int status; - status = bladerf_enable_module( _dev.get(), direction, false ); - if ( status != 0 ) { - throw std::runtime_error( _pfx + "bladerf_enable_module failed: " + - bladerf_strerror(status) ); + status = bladerf_enable_module(_dev.get(), direction, false); + if (status != 0) { + throw std::runtime_error(_pfx + "bladerf_enable_module failed: " + + bladerf_strerror(status)); } return true; } -static bool version_greater_or_equal( const struct bladerf_version *version, - unsigned int major, unsigned int minor, - unsigned int patch ) +static bool version_greater_or_equal(const struct bladerf_version *version, + unsigned int major, + unsigned int minor, unsigned int patch) { - if ( version->major > major ) { + if (version->major > major) { return true; - } else if ( (version->major == major) && (version->minor > minor) ) { + } else if ((version->major == major) && (version->minor > minor)) { return true; - } else if ( (version->major == major) && - (version->minor == minor) && - (version->patch >= patch) ) { + } else if ((version->major == major) && + (version->minor == minor) && + (version->patch >= patch)) { return true; } else { return false; } } -void bladerf_common::init( dict_t &dict, bladerf_direction direction ) +void bladerf_common::init(dict_t &dict, bladerf_direction direction) { int status; std::string device_name(""); @@ -300,23 +304,23 @@ void bladerf_common::init( dict_t &dict, bladerf_direction direction ) _pfx = std::string("[bladeRF ") + std::string(type) + std::string("] "); - if ( dict.count("verbosity") ) { - set_verbosity( dict["verbosity"] ); + if (dict.count("verbosity")) { + set_verbosity(dict["verbosity"]); } if (dict.count("bladerf")) { const std::string value = dict["bladerf"]; - if ( value.length() > 0 ) { - if ( value.length() <= 2 ) { + if (value.length() > 0) { + if (value.length() <= 2) { /* If the value is two digits or less, we'll assume the user is * providing an instance number */ unsigned int device_number = 0; try { - device_number = boost::lexical_cast< unsigned int >( value ); - device_name = boost::str(boost::format( "*:instance=%d" ) % device_number); - } catch ( std::exception &ex ) { - throw std::runtime_error( _pfx + "Failed to use '" + value + + device_number = boost::lexical_cast(value); + device_name = boost::str(boost::format("*:instance=%d") % device_number); + } catch (std::exception &ex) { + throw std::runtime_error(_pfx + "Failed to use '" + value + "' as device number: " + ex.what()); } @@ -329,16 +333,16 @@ void bladerf_common::init( dict_t &dict, bladerf_direction direction ) * may just pass whatever the user has provided. */ bladerf_version(&ver); - if ( version_greater_or_equal(&ver, 1, 4, 1) || - value.length() == (BLADERF_SERIAL_LENGTH - 1) ) { + if (version_greater_or_equal(&ver, 1, 4, 1) || + value.length() == (BLADERF_SERIAL_LENGTH - 1)) { device_name = std::string("*:serial=") + value; } else { - throw std::runtime_error( _pfx + - "A full serial number must be supplied " - "with libbladeRF " + - std::string(ver.describe) + - ". libbladeRF >= v1.4.1 supports opening " - "a device via a subset of its serial #." ); + throw std::runtime_error(_pfx + + "A full serial number must be supplied " + "with libbladeRF " + + std::string(ver.describe) + + ". libbladeRF >= v1.4.1 supports opening " + "a device via a subset of its serial #."); } } } @@ -347,63 +351,67 @@ void bladerf_common::init( dict_t &dict, bladerf_direction direction ) try { std::cerr << _pfx << "Opening nuand bladeRF with device identifier string: \"" - << device_name << "\"" << std::endl; + << device_name << "\"" + << std::endl; _dev = open(device_name); - } catch(...) { - throw std::runtime_error( _pfx + "Failed to open bladeRF device " + - device_name ); + } catch (...) { + throw std::runtime_error(_pfx + "Failed to open bladeRF device " + + device_name); } /* Load an FPGA */ - if ( dict.count("fpga") ) { - if ( dict.count("fpga-reload") == 0 && - bladerf_is_fpga_configured( _dev.get() ) == 1 ) { + if (dict.count("fpga")) { + if (dict.count("fpga-reload") == 0 && + bladerf_is_fpga_configured(_dev.get()) == 1) { std::cerr << _pfx << "FPGA is already loaded. Set fpga-reload=1 to force a " - "reload." << std::endl; - + << "reload." + << std::endl; } else { - std::string fpga = dict["fpga"]; - std::cerr << _pfx << "Loading FPGA bitstream " << fpga << "..." + std::cerr << _pfx + << "Loading FPGA bitstream " << fpga << "..." << std::endl; - status = bladerf_load_fpga( _dev.get(), fpga.c_str() ); - if ( status != 0 ) { - std::cerr << _pfx << "bladerf_load_fpga has failed with " - << bladerf_strerror(status) << std::endl; + status = bladerf_load_fpga(_dev.get(), fpga.c_str()); + if (status != 0) { + std::cerr << _pfx + << "bladerf_load_fpga has failed with " + << bladerf_strerror(status) + << std::endl; } else { - std::cerr << _pfx << "The FPGA bitstream was successfully loaded." + std::cerr << _pfx + << "The FPGA bitstream was successfully loaded." << std::endl; } } } - if ( bladerf_is_fpga_configured( _dev.get() ) != 1 ) { - throw std::runtime_error( _pfx + - "The FPGA is not configured! Provide device " - "argument fpga=/path/to/the/bitstream.rbf to " - "load it." ); + if (bladerf_is_fpga_configured(_dev.get()) != 1) { + throw std::runtime_error(_pfx + + "The FPGA is not configured! Provide device " + "argument fpga=/path/to/the/bitstream.rbf to " + "load it."); } - if ( direction == BLADERF_RX ) { - if ( dict.count("loopback") ) { - set_loopback_mode( dict["loopback"] ); + if (direction == BLADERF_RX) { + if (dict.count("loopback")) { + set_loopback_mode(dict["loopback"]); } else { - set_loopback_mode( "none" ); + set_loopback_mode("none"); } - } else if ( direction == BLADERF_TX && dict.count("loopback") ) { - std::cerr << _pfx - << "Warning: 'loopback' has been specified on a bladeRF " - "sink, and will have no effect. This parameter should " - "be specified on the associated bladeRF source." - << std::endl; + } else if (direction == BLADERF_TX && dict.count("loopback")) { + std::cerr << _pfx + << "Warning: 'loopback' has been specified on a bladeRF " + << "sink, and will have no effect. This parameter should " + << "be specified on the associated bladeRF source." + << std::endl; } - if ( dict.count("xb200") ) { + if (dict.count("xb200")) { if (bladerf_expansion_attach(_dev.get(), BLADERF_XB_200)) { std::cerr << _pfx << "Could not attach XB-200" << std::endl; } else { @@ -411,105 +419,112 @@ void bladerf_common::init( dict_t &dict, bladerf_direction direction ) bladerf_xb200_filter filter = BLADERF_XB200_AUTO_1DB; - if ( dict["xb200"] == "custom" ) { + if (dict["xb200"] == "custom") { filter = BLADERF_XB200_CUSTOM; - } else if ( dict["xb200"] == "50M" ) { + } else if (dict["xb200"] == "50M") { filter = BLADERF_XB200_50M; - } else if ( dict["xb200"] == "144M" ) { + } else if (dict["xb200"] == "144M") { filter = BLADERF_XB200_144M; - } else if ( dict["xb200"] == "222M" ) { + } else if (dict["xb200"] == "222M") { filter = BLADERF_XB200_222M; - } else if ( dict["xb200"] == "auto3db" ) { + } else if (dict["xb200"] == "auto3db") { filter = BLADERF_XB200_AUTO_3DB; - } else if ( dict["xb200"] == "auto" ) { + } else if (dict["xb200"] == "auto") { filter = BLADERF_XB200_AUTO_1DB; } else { filter = BLADERF_XB200_AUTO_1DB; } status = bladerf_xb200_set_filterbank(_dev.get(), direction, filter); - if ( status != 0 ) { - std::cerr << _pfx << "Could not set XB-200 filter: " - << bladerf_strerror(status) << std::endl; + if (status != 0) { + std::cerr << _pfx + << "Could not set XB-200 filter: " + << bladerf_strerror(status) + << std::endl; } } } /* Show some info about the device we've opened */ - std::cerr << _pfx; - if ( bladerf_get_serial( _dev.get(), serial ) == 0 ) { + if (bladerf_get_serial(_dev.get(), serial) == 0) { std::string strser(serial); - if ( strser.length() == 32 ) { - strser.replace( 4, 24, "..." ); + if (strser.length() == 32) { + strser.replace(4, 24, "..."); } std::cerr << " Serial # " << strser; } - if ( bladerf_fw_version( _dev.get(), &ver ) == 0 ) { + if (bladerf_fw_version(_dev.get(), &ver) == 0) { std::cerr << " FW v" << ver.major << "." << ver.minor << "." << ver.patch; } - if ( bladerf_fpga_version( _dev.get(), &ver ) == 0 ) { + if (bladerf_fpga_version(_dev.get(), &ver) == 0) { std::cerr << " FPGA v" << ver.major << "." << ver.minor << "." << ver.patch; } std::cerr << std::endl; - if ( dict.count("tamer") ) { - set_clock_source( dict["tamer"] ); - std::cerr << _pfx << "Tamer mode set to '" << get_clock_source() << "'"; + if (dict.count("tamer")) { + set_clock_source(dict["tamer"]); + std::cerr << _pfx + << "Tamer mode set to '" << get_clock_source() << "'" + << std::endl; } - if ( dict.count("smb") ) { - set_smb_frequency( boost::lexical_cast< double >( dict["smb"] ) ); - std::cerr << _pfx << "SMB frequency set to " << get_smb_frequency() << " Hz"; + if (dict.count("smb")) { + set_smb_frequency(boost::lexical_cast(dict["smb"])); + std::cerr << _pfx + << "SMB frequency set to " << get_smb_frequency() << " Hz" + << std::endl; } /* Initialize buffer and sample configuration */ _num_buffers = 0; - if ( dict.count("buffers") ) { - _num_buffers = boost::lexical_cast< size_t >( dict["buffers"] ); + if (dict.count("buffers")) { + _num_buffers = boost::lexical_cast(dict["buffers"]); } _samples_per_buffer = 0; - if ( dict.count("buflen") ) { - _samples_per_buffer = boost::lexical_cast< size_t >( dict["buflen"] ); + if (dict.count("buflen")) { + _samples_per_buffer = boost::lexical_cast(dict["buflen"]); } _num_transfers = 0; - if ( dict.count("transfers") ) { - _num_transfers = boost::lexical_cast< size_t >( dict["transfers"] ); + if (dict.count("transfers")) { + _num_transfers = boost::lexical_cast(dict["transfers"]); } _stream_timeout_ms = 3000; - if ( dict.count("stream_timeout_ms") ) { - _stream_timeout_ms = boost::lexical_cast< unsigned int >( dict["stream_timeout_ms"] ); + if (dict.count("stream_timeout_ms")) { + _stream_timeout_ms = boost::lexical_cast(dict["stream_timeout_ms"]); } _use_metadata = dict.count("enable_metadata") != 0; - _use_mimo = ( dict.count("enable_mimo") != 0 ) && ( get_num_channels(direction) >= 2 ); + _use_mimo = (dict.count("enable_mimo") != 0) && + (get_num_channels(direction) >= 2); /* Require value to be >= 2 so we can ensure we have twice as many * buffers as transfers */ - if ( _num_buffers <= 1 ) { + if (_num_buffers <= 1) { _num_buffers = NUM_BUFFERS; } - if ( 0 == _samples_per_buffer ) { + if (0 == _samples_per_buffer) { _samples_per_buffer = NUM_SAMPLES_PER_BUFFER; } else { - if ( (_samples_per_buffer < 1024) || ((_samples_per_buffer % 1024) != 0) ) { + if ((_samples_per_buffer < 1024) || + (_samples_per_buffer % 1024 != 0)) { /* 0 likely implies the user did not specify this, so don't warn */ - if (_samples_per_buffer != 0 ) { + if (_samples_per_buffer != 0) { std::cerr << _pfx << "Invalid \"buflen\" value. A multiple of 1024 is " - "required. Defaulting to " - << NUM_SAMPLES_PER_BUFFER << std::endl; + << "required. Defaulting to " << NUM_SAMPLES_PER_BUFFER + << std::endl; } _samples_per_buffer = NUM_SAMPLES_PER_BUFFER; @@ -518,43 +533,42 @@ void bladerf_common::init( dict_t &dict, bladerf_direction direction ) /* If the user hasn't specified the desired number of transfers, set it to * min(32, num_buffers / 2) */ - if ( _num_transfers == 0 ) { - _num_transfers = _num_buffers / 2; + if (_num_transfers == 0) { + _num_transfers = _num_buffers / 2; - if (_num_transfers > 32) { - _num_transfers = 32; - } - - } else if ( _num_transfers >= _num_buffers ) { - _num_transfers = _num_buffers - 1; - std::cerr << _pfx - << "Clamping num_tranfers to " << _num_transfers << ". " - "Try using a smaller num_transfers value if timeouts occur." - << std::endl; + if (_num_transfers > 32) { + _num_transfers = 32; + } + } else if (_num_transfers >= _num_buffers) { + _num_transfers = _num_buffers - 1; + std::cerr << _pfx + << "Clamping num_tranfers to " << _num_transfers << ". " + << "Try using a smaller num_transfers value if timeouts occur." + << std::endl; } - _conv_buf = static_cast(malloc(_conv_buf_size * 2 * sizeof(int16_t))); + _conv_buf = static_cast(malloc(_conv_buf_size * 2 * sizeof(int16_t))); - if ( NULL == _conv_buf ) { - throw std::runtime_error( _pfx + "Failed to allocate _conv_buf" ); + if (NULL == _conv_buf) { + throw std::runtime_error(_pfx + "Failed to allocate _conv_buf"); } } -osmosdr::freq_range_t bladerf_common::freq_range( bladerf_channel chan ) +osmosdr::freq_range_t bladerf_common::freq_range(bladerf_channel chan) { int status; struct bladerf_range range; - status = bladerf_get_frequency_range( _dev.get(), chan, &range ); + status = bladerf_get_frequency_range(_dev.get(), chan, &range); - if( status ) { - throw std::runtime_error( _pfx + - "bladerf_get_frequency_range failed: " + - bladerf_strerror(status) ); + if (status != 0) { + throw std::runtime_error(_pfx + + "bladerf_get_frequency_range failed: " + + bladerf_strerror(status)); } else { - return osmosdr::freq_range_t( static_cast(range.min), - static_cast(range.max), - static_cast(range.step) ); + return osmosdr::freq_range_t(static_cast(range.min), + static_cast(range.max), + static_cast(range.step)); }; } @@ -565,23 +579,23 @@ osmosdr::meta_range_t bladerf_common::sample_rates() bladerf_range brf_sample_rates; /* assuming the same for RX & TX */ - status = bladerf_get_sample_rate_range( _dev.get(), BLADERF_CHANNEL_RX(0), - &brf_sample_rates ); - if( status ) { - throw std::runtime_error( _pfx + - "bladerf_get_sample_rate_range failed: " + - bladerf_strerror(status) ); + status = bladerf_get_sample_rate_range(_dev.get(), BLADERF_CHANNEL_RX(0), + &brf_sample_rates); + if (status != 0) { + throw std::runtime_error(_pfx + + "bladerf_get_sample_rate_range failed: " + + bladerf_strerror(status)); } - sample_rates += osmosdr::range_t( brf_sample_rates.min, - brf_sample_rates.max/4.0, - brf_sample_rates.max/16.0 ); - sample_rates += osmosdr::range_t( brf_sample_rates.max/4.0, - brf_sample_rates.max/2.0, - brf_sample_rates.max/8.0 ); - sample_rates += osmosdr::range_t( brf_sample_rates.max/2.0, - brf_sample_rates.max, - brf_sample_rates.max/4.0 ); + sample_rates += osmosdr::range_t(brf_sample_rates.min, + brf_sample_rates.max / 4.0, + brf_sample_rates.max / 16.0); + sample_rates += osmosdr::range_t(brf_sample_rates.max / 4.0, + brf_sample_rates.max / 2.0, + brf_sample_rates.max / 8.0); + sample_rates += osmosdr::range_t(brf_sample_rates.max / 2.0, + brf_sample_rates.max, + brf_sample_rates.max / 4.0); return sample_rates; } @@ -593,12 +607,12 @@ osmosdr::freq_range_t bladerf_common::filter_bandwidths() osmosdr::freq_range_t bandwidths; bladerf_range range; - status = bladerf_get_bandwidth_range( _dev.get(), BLADERF_CHANNEL_RX(0), - &range ); - if( status ) { - throw std::runtime_error( _pfx + - "bladerf_get_bandwidth_range failed: " + - bladerf_strerror(status) ); + status = bladerf_get_bandwidth_range(_dev.get(), BLADERF_CHANNEL_RX(0), + &range); + if (status != 0) { + throw std::runtime_error(_pfx + + "bladerf_get_bandwidth_range failed: " + + bladerf_strerror(status)); } bandwidths += osmosdr::range_t(range.min, range.max, range.step); @@ -606,27 +620,28 @@ osmosdr::freq_range_t bladerf_common::filter_bandwidths() return bandwidths; } -std::vector< std::string > bladerf_common::devices() +std::vector < std::string > bladerf_common::devices() { struct bladerf_devinfo *devices; ssize_t n_devices; - std::vector< std::string > ret; + std::vector < std::string > ret; - n_devices = bladerf_get_device_list( &devices ); + n_devices = bladerf_get_device_list(&devices); - if ( n_devices > 0 ) { - for ( ssize_t i = 0; i < n_devices; i++ ) { + if (n_devices > 0) { + for (ssize_t i = 0; i < n_devices; i++) { std::stringstream s; std::string serial(devices[i].serial); - s << "bladerf=" << devices[i].instance - << ",label='nuand bladeRF"; + s << "bladerf=" << devices[i].instance << ",label='nuand bladeRF"; - if ( serial.length() == 32 ) - serial.replace( 4, 24, "..." ); + if (serial.length() == 32) { + serial.replace(4, 24, "..."); + } - if ( serial.length() ) + if (serial.length()) { s << " SN " << serial; + } s << "'"; @@ -639,7 +654,7 @@ std::vector< std::string > bladerf_common::devices() return ret; } -size_t bladerf_common::get_num_channels( bladerf_direction direction ) +size_t bladerf_common::get_num_channels(bladerf_direction direction) { // TODO: Need to figure out how to deal with output_signature()->max_streams // being stuck at 1 in source_impl.cc @@ -652,8 +667,7 @@ size_t bladerf_common::get_num_channels( bladerf_direction direction ) // return 1; } -double bladerf_common::set_sample_rate( bladerf_direction direction, - double rate ) +double bladerf_common::set_sample_rate(bladerf_direction direction, double rate) { int status; struct bladerf_rational_rate rational_rate, actual; @@ -662,97 +676,94 @@ double bladerf_common::set_sample_rate( bladerf_direction direction, rational_rate.den = 10000; rational_rate.num = (rate - rational_rate.integer) * rational_rate.den; - status = bladerf_set_rational_sample_rate( _dev.get(), direction, - &rational_rate, &actual ); - if ( status ) { - throw std::runtime_error( _pfx + - "Failed to set sample rate:" + - bladerf_strerror(status)); + status = bladerf_set_rational_sample_rate(_dev.get(), direction, + &rational_rate, &actual); + if (status != 0) { + throw std::runtime_error(_pfx + "Failed to set sample rate:" + + bladerf_strerror(status)); } return actual.integer + actual.num / static_cast(actual.den); } -double bladerf_common::get_sample_rate( bladerf_direction direction ) +double bladerf_common::get_sample_rate(bladerf_direction direction) { int status; struct bladerf_rational_rate rate; - status = bladerf_get_rational_sample_rate( _dev.get(), direction, &rate ); - if ( status != 0 ) { - throw std::runtime_error( _pfx + - "Failed to get sample rate:" + - bladerf_strerror(status) ); + status = bladerf_get_rational_sample_rate(_dev.get(), direction, &rate); + if (status != 0) { + throw std::runtime_error(_pfx + "Failed to get sample rate:" + + bladerf_strerror(status)); } return rate.integer + rate.num / static_cast(rate.den); } -osmosdr::freq_range_t bladerf_common::get_freq_range( size_t chan ) +osmosdr::freq_range_t bladerf_common::get_freq_range(size_t chan) { - return freq_range( static_cast(chan) ); + return freq_range(static_cast(chan)); } -double bladerf_common::set_center_freq( double freq, size_t chan ) +double bladerf_common::set_center_freq(double freq, size_t chan) { int status; /* Check frequency range */ - if( freq < get_freq_range( chan ).start() || - freq > get_freq_range( chan ).stop() ) { + if (freq < get_freq_range(chan).start() || + freq > get_freq_range(chan).stop()) { std::cerr << "Failed to set out of bound frequency: " << freq << std::endl; } else { - status = bladerf_set_frequency( _dev.get(), - static_cast(chan), - static_cast(freq) ); - if( status ) { - throw std::runtime_error( _pfx + - "failed to set center frequency " + - boost::lexical_cast(freq) + ": " + - bladerf_strerror(status) ); + status = bladerf_set_frequency(_dev.get(), + static_cast(chan), + static_cast(freq)); + if (status != 0) { + throw std::runtime_error(_pfx + + "failed to set center frequency " + + boost::lexical_cast(freq) + ": " + + bladerf_strerror(status)); } } - return get_center_freq( chan ); + return get_center_freq(chan); } -double bladerf_common::get_center_freq( size_t chan ) +double bladerf_common::get_center_freq(size_t chan) { int status; uint64_t freq; - status = bladerf_get_frequency( _dev.get(), - static_cast(chan), - &freq ); - if( status ) { - throw std::runtime_error( _pfx + - "failed to get center frequency: " + - bladerf_strerror(status) ); + status = bladerf_get_frequency(_dev.get(), + static_cast(chan), + &freq); + if (status != 0) { + throw std::runtime_error(_pfx + "failed to get center frequency: " + + bladerf_strerror(status)); } return static_cast(freq); } -std::vector bladerf_common::get_gain_names( size_t chan ) +std::vector bladerf_common::get_gain_names(size_t chan) { const size_t max_count = 16; - std::vector< std::string > names; + std::vector < std::string > names; char *gain_names[max_count]; int status; names += SYSTEM_GAIN_NAME; - status = bladerf_get_gain_stages( _dev.get(), - static_cast(chan), - (const char**)&gain_names, - max_count ); - if(status < 0) { - throw std::runtime_error( _pfx + - "failed to get gain stages: " + - bladerf_strerror(status) ); + status = bladerf_get_gain_stages(_dev.get(), + static_cast(chan), + (const char **) &gain_names, + max_count); + if (status < 0) { + throw std::runtime_error(_pfx + + "failed to get gain stages: " + + bladerf_strerror(status)); } - for( char **p = gain_names; *p != NULL && **p != '\0'; ++p ) { + for (char **p = gain_names; *p != NULL && **p != '\0'; ++p) { char *tmp = *p; names += std::string(tmp); }; @@ -760,100 +771,100 @@ std::vector bladerf_common::get_gain_names( size_t chan ) return names; } -osmosdr::gain_range_t bladerf_common::get_gain_range( size_t chan ) +osmosdr::gain_range_t bladerf_common::get_gain_range(size_t chan) { /* This is an overall system gain range. */ - return get_gain_range( SYSTEM_GAIN_NAME, chan ); + return get_gain_range(SYSTEM_GAIN_NAME, chan); } -osmosdr::gain_range_t bladerf_common::get_gain_range( const std::string & name, - size_t chan ) +osmosdr::gain_range_t bladerf_common::get_gain_range(const std::string &name, + size_t chan) { int status; struct bladerf_range range; - if( name == SYSTEM_GAIN_NAME ) { - status = bladerf_get_gain_range( _dev.get(), - static_cast(chan), - &range ); + if (name == SYSTEM_GAIN_NAME) { + status = bladerf_get_gain_range(_dev.get(), + static_cast(chan), + &range); } else { - status = bladerf_get_gain_stage_range( _dev.get(), - static_cast(chan), - name.c_str(), &range ); + status = bladerf_get_gain_stage_range(_dev.get(), + static_cast(chan), + name.c_str(), + &range); } - if( status ) { - throw std::runtime_error( _pfx + - "bladerf_get_gain_range " + name + " failed: " + - bladerf_strerror(status) ); + if (status != 0) { + throw std::runtime_error(_pfx + + "bladerf_get_gain_range " + name + + " failed: " + bladerf_strerror(status)); } - return osmosdr::gain_range_t( range.min, range.max, range.step ); + return osmosdr::gain_range_t(range.min, range.max, range.step); } -bool bladerf_common::set_gain_mode( bool automatic, size_t chan ) +bool bladerf_common::set_gain_mode(bool automatic, size_t chan) { int status; bladerf_gain_mode mode = automatic ? BLADERF_GAIN_DEFAULT : BLADERF_GAIN_MGC; - status = bladerf_set_gain_mode( _dev.get(), - static_cast(chan), - mode ); + status = bladerf_set_gain_mode(_dev.get(), + static_cast(chan), + mode); - if( status ) { - throw std::runtime_error( _pfx + - "bladerf_set_gain_mode " + - (automatic ? "automatic" : "manual") + - " failed: " + - bladerf_strerror(status) ); + if (status != 0) { + throw std::runtime_error(_pfx + + "bladerf_set_gain_mode " + + (automatic ? "automatic" : "manual") + + " failed: " + bladerf_strerror(status)); } return get_gain_mode(chan); } -bool bladerf_common::get_gain_mode( size_t chan ) +bool bladerf_common::get_gain_mode(size_t chan) { int status; bladerf_gain_mode gainmode; - status = bladerf_get_gain_mode( _dev.get(), - static_cast(chan), - &gainmode ); + status = bladerf_get_gain_mode(_dev.get(), + static_cast(chan), + &gainmode); - if( status ) { - throw std::runtime_error( _pfx + - "bladerf_get_gain_mode failed: " + - bladerf_strerror(status) ); + if (status != 0) { + throw std::runtime_error(_pfx + "bladerf_get_gain_mode failed: " + + bladerf_strerror(status)); } return (gainmode != BLADERF_GAIN_MGC); } -double bladerf_common::set_gain( double gain, size_t chan ) +double bladerf_common::set_gain(double gain, size_t chan) { - return set_gain( gain, SYSTEM_GAIN_NAME, chan ); + return set_gain(gain, SYSTEM_GAIN_NAME, chan); } -double bladerf_common::set_gain( double gain, const std::string & name, size_t chan ) +double bladerf_common::set_gain(double gain, + const std::string &name, size_t chan) { int status; - if( name == SYSTEM_GAIN_NAME ) { - status = bladerf_set_gain( _dev.get(), - static_cast(chan), - static_cast(gain) ); + if (name == SYSTEM_GAIN_NAME) { + status = bladerf_set_gain(_dev.get(), + static_cast(chan), + static_cast(gain)); } else { - status = bladerf_set_gain_stage( _dev.get(), - static_cast(chan), - name.c_str(), - static_cast(gain) ); + status = bladerf_set_gain_stage(_dev.get(), + static_cast(chan), + name.c_str(), + static_cast(gain)); } /* Check for errors */ - if( status ) { + if (status != 0) { std::string errmsg = _pfx + "could not set " + name + " gain: " + bladerf_strerror(status); - if ( BLADERF_ERR_UNSUPPORTED == status ) { + if (BLADERF_ERR_UNSUPPORTED == status) { // unsupported, but not worth crashing out std::cerr << errmsg << std::endl; } else { @@ -861,42 +872,42 @@ double bladerf_common::set_gain( double gain, const std::string & name, size_t c } } - return get_gain( name, chan ); + return get_gain(name, chan); } -double bladerf_common::get_gain( size_t chan ) +double bladerf_common::get_gain(size_t chan) { - return get_gain( SYSTEM_GAIN_NAME, chan ); + return get_gain(SYSTEM_GAIN_NAME, chan); } -double bladerf_common::get_gain( const std::string & name, size_t chan ) +double bladerf_common::get_gain(const std::string &name, size_t chan) { int status; int g; - if( name == SYSTEM_GAIN_NAME ) { - status = bladerf_get_gain( _dev.get(), - static_cast(chan), - &g ); + if (name == SYSTEM_GAIN_NAME) { + status = bladerf_get_gain(_dev.get(), + static_cast(chan), + &g); } else { - status = bladerf_get_gain_stage( _dev.get(), - static_cast(chan), - name.c_str(), - &g ); + status = bladerf_get_gain_stage(_dev.get(), + static_cast(chan), + name.c_str(), + &g); } /* Check for errors */ - if( status ) { - throw std::runtime_error( _pfx + "could not get " + name + " gain: " + - bladerf_strerror(status) ); + if (status != 0) { + throw std::runtime_error(_pfx + "could not get " + name + " gain: " + + bladerf_strerror(status)); } - return (double)g; + return (double) g; } -int bladerf_common::set_dc_offset( bladerf_direction direction, - const std::complex &offset, - size_t chan ) +int bladerf_common::set_dc_offset(bladerf_direction direction, + const std::complex < double > &offset, + size_t chan) { int ret = 0; int16_t val_i, val_q; @@ -904,65 +915,65 @@ int bladerf_common::set_dc_offset( bladerf_direction direction, val_i = static_cast(offset.real() * DCOFF_SCALE); val_q = static_cast(offset.imag() * DCOFF_SCALE); - ret = bladerf_set_correction( _dev.get(), direction, - BLADERF_CORR_LMS_DCOFF_I, val_i ); - ret |= bladerf_set_correction( _dev.get(), direction, - BLADERF_CORR_LMS_DCOFF_Q, val_q ); + ret = bladerf_set_correction(_dev.get(), direction, + BLADERF_CORR_LMS_DCOFF_I, val_i); + ret |= bladerf_set_correction(_dev.get(), direction, + BLADERF_CORR_LMS_DCOFF_Q, val_q); return ret; } -int bladerf_common::set_iq_balance( bladerf_direction direction, - const std::complex &balance, - size_t chan ) +int bladerf_common::set_iq_balance(bladerf_direction direction, + const std::complex < double > &balance, + size_t chan) { int ret = 0; int16_t val_gain, val_phase; - val_gain = static_cast(balance.real() * GAIN_SCALE); + val_gain = static_cast(balance.real() * GAIN_SCALE); val_phase = static_cast(balance.imag() * PHASE_SCALE); - ret = bladerf_set_correction( _dev.get(), direction, - BLADERF_CORR_FPGA_GAIN, val_gain ); - ret |= bladerf_set_correction( _dev.get(), direction, - BLADERF_CORR_FPGA_PHASE, val_phase ); + ret = bladerf_set_correction(_dev.get(), direction, + BLADERF_CORR_FPGA_GAIN, val_gain); + ret |= bladerf_set_correction(_dev.get(), direction, + BLADERF_CORR_FPGA_PHASE, val_phase); return ret; } -void bladerf_common::set_clock_source( const std::string &source, - const size_t mboard ) +void bladerf_common::set_clock_source(const std::string &source, + const size_t mboard) { int status; bladerf_vctcxo_tamer_mode tamer_mode; - std::vector clock_sources; + std::vector < std::string > clock_sources; int index; tamer_mode = BLADERF_VCTCXO_TAMER_DISABLED; clock_sources = get_clock_sources(mboard); index = std::find(clock_sources.begin(), clock_sources.end(), source) - clock_sources.begin(); - if ( index < static_cast(clock_sources.size()) ) { + if (index < static_cast(clock_sources.size())) { tamer_mode = static_cast(index); } - status = bladerf_set_vctcxo_tamer_mode( _dev.get(), tamer_mode ); - if ( status != 0 ) { + status = bladerf_set_vctcxo_tamer_mode(_dev.get(), tamer_mode); + if (status != 0) { throw std::runtime_error(_pfx + "Failed to set VCTCXO tamer mode: " + bladerf_strerror(status)); } } -std::string bladerf_common::get_clock_source( const size_t mboard ) +std::string bladerf_common::get_clock_source(const size_t mboard) { int status; bladerf_vctcxo_tamer_mode tamer_mode; - std::vector clock_sources; + std::vector < std::string > clock_sources; tamer_mode = BLADERF_VCTCXO_TAMER_INVALID; - status = bladerf_get_vctcxo_tamer_mode( _dev.get(), &tamer_mode ); - if ( status != 0 ) { + status = bladerf_get_vctcxo_tamer_mode(_dev.get(), &tamer_mode); + if (status != 0) { throw std::runtime_error(_pfx + "Failed to get VCTCXO tamer mode: " + bladerf_strerror(status)); } @@ -972,34 +983,35 @@ std::string bladerf_common::get_clock_source( const size_t mboard ) return clock_sources.at(tamer_mode); } -std::vector bladerf_common::get_clock_sources( const size_t mboard ) +std::vector < std::string > bladerf_common::get_clock_sources(const size_t mboard) { - std::vector sources; + std::vector < std::string > sources; // assumes zero-based 1:1 mapping - sources.push_back("internal"); // BLADERF_VCTCXO_TAMER_DISABLED - sources.push_back("external_1pps"); // BLADERF_VCTCXO_TAMER_1_PPS - sources.push_back("external"); // BLADERF_VCTCXO_TAMER_10_MHZ + sources.push_back("internal"); // BLADERF_VCTCXO_TAMER_DISABLED + sources.push_back("external_1pps"); // BLADERF_VCTCXO_TAMER_1_PPS + sources.push_back("external"); // BLADERF_VCTCXO_TAMER_10_MHZ return sources; } -void bladerf_common::set_smb_frequency( double frequency ) +void bladerf_common::set_smb_frequency(double frequency) { int status; uint32_t actual_frequency; actual_frequency = frequency; - status = bladerf_set_smb_frequency( _dev.get(), - static_cast(frequency), - &actual_frequency ); - if ( status != 0 ) { + status = bladerf_set_smb_frequency(_dev.get(), + static_cast(frequency), + &actual_frequency); + if (status != 0) { throw std::runtime_error(_pfx + "Failed to set SMB frequency: " + bladerf_strerror(status)); } - if ( static_cast(frequency) != actual_frequency ) { - std::cerr << _pfx << "Wanted SMB frequency is " << frequency + if (static_cast(frequency) != actual_frequency) { + std::cerr << _pfx + << "Wanted SMB frequency is " << frequency << ", actual is " << actual_frequency << std::endl; } @@ -1010,10 +1022,11 @@ double bladerf_common::get_smb_frequency() int status; unsigned int actual_frequency; - status = bladerf_get_smb_frequency( _dev.get(), &actual_frequency ); - if ( status != 0 ) + status = bladerf_get_smb_frequency(_dev.get(), &actual_frequency); + if (status != 0) { throw std::runtime_error(_pfx + "Failed to get SMB frequency: " + bladerf_strerror(status)); + } return static_cast(actual_frequency); } diff --git a/lib/bladerf/bladerf_sink_c.cc b/lib/bladerf/bladerf_sink_c.cc index 32e664e..5207eb1 100644 --- a/lib/bladerf/bladerf_sink_c.cc +++ b/lib/bladerf/bladerf_sink_c.cc @@ -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 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(_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(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(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(&_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(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(&_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(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(_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 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 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 &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 &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 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); } diff --git a/lib/bladerf/bladerf_source_c.cc b/lib/bladerf/bladerf_source_c.cc index fc15c50..81a34f0 100644 --- a/lib/bladerf/bladerf_source_c.cc +++ b/lib/bladerf/bladerf_source_c.cc @@ -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(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(tmp); + _conv_buf = static_cast(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(_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(_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 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 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 ); - set_dc_offset( std::complex(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 ) { + /* 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 ); + } 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 &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 ); - set_iq_balance( std::complex(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 ) { + /* 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 ); + } 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 &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 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); }