2013-07-20 16:14:20 +00:00
|
|
|
/* -*- c++ -*- */
|
|
|
|
/*
|
2017-06-26 15:16:57 +00:00
|
|
|
* Copyright 2013-2017 Nuand LLC
|
2013-07-20 16:14:20 +00:00
|
|
|
* Copyright 2013 Dimitri Stolnikov <horiz0n@gmx.net>
|
|
|
|
*
|
|
|
|
* GNU Radio is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 3, or (at your option)
|
|
|
|
* any later version.
|
|
|
|
*
|
|
|
|
* GNU Radio is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with GNU Radio; see the file COPYING. If not, write to
|
|
|
|
* the Free Software Foundation, Inc., 51 Franklin Street,
|
|
|
|
* Boston, MA 02110-1301, USA.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* config.h is generated by configure. It contains the results
|
|
|
|
* of probing for features, options etc. It should be the first
|
|
|
|
* file included in your .cc file.
|
|
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
#include "config.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include <string>
|
|
|
|
#include <iomanip>
|
|
|
|
#include <iostream>
|
|
|
|
#include <sstream>
|
|
|
|
|
|
|
|
#include <boost/lexical_cast.hpp>
|
|
|
|
#include <boost/assign.hpp>
|
|
|
|
#include <boost/foreach.hpp>
|
2013-10-19 16:00:38 +00:00
|
|
|
#include <boost/shared_ptr.hpp>
|
2013-07-20 16:14:20 +00:00
|
|
|
|
|
|
|
#include "bladerf_common.h"
|
|
|
|
|
2017-08-09 20:15:08 +00:00
|
|
|
#define NUM_BUFFERS 256
|
2013-10-26 19:59:23 +00:00
|
|
|
#define NUM_SAMPLES_PER_BUFFER (4 * 1024)
|
2017-08-09 20:15:08 +00:00
|
|
|
#define NUM_TRANSFERS 16
|
2013-10-26 19:59:23 +00:00
|
|
|
|
2013-07-20 16:14:20 +00:00
|
|
|
using namespace boost::assign;
|
|
|
|
|
2013-10-19 16:00:38 +00:00
|
|
|
boost::mutex bladerf_common::_devs_mutex;
|
2017-06-28 18:03:29 +00:00
|
|
|
std::list < boost::weak_ptr < struct bladerf >> bladerf_common::_devs;
|
2013-10-19 16:00:38 +00:00
|
|
|
|
2017-06-26 15:15:54 +00:00
|
|
|
/* name of system-wide gain
|
|
|
|
* (internal only, doesn't match any libbladeRF gain stage)
|
|
|
|
*/
|
2017-06-28 18:03:29 +00:00
|
|
|
static const char *SYSTEM_GAIN_NAME = "system";
|
2017-05-26 14:16:33 +00:00
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
bladerf_common::bladerf_common():
|
2014-06-11 08:11:09 +00:00
|
|
|
_conv_buf(NULL),
|
|
|
|
_conv_buf_size(4096),
|
2014-10-26 20:08:42 +00:00
|
|
|
_xb_200_attached(false),
|
|
|
|
_consecutive_failures(0)
|
2014-06-11 08:11:09 +00:00
|
|
|
{
|
|
|
|
}
|
2014-02-16 22:42:32 +00:00
|
|
|
|
|
|
|
bladerf_common::~bladerf_common()
|
|
|
|
{
|
2017-06-27 21:08:17 +00:00
|
|
|
free(_conv_buf);
|
2014-02-16 22:42:32 +00:00
|
|
|
}
|
2013-07-20 16:14:20 +00:00
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
bladerf_board_type bladerf_common::get_board_type(struct bladerf *dev)
|
2017-05-26 20:21:56 +00:00
|
|
|
{
|
2017-07-11 21:34:21 +00:00
|
|
|
if (NULL == dev) {
|
|
|
|
throw std::runtime_error(std::string(__FUNCTION__) + ": " +
|
|
|
|
"null pointer caught: dev");
|
|
|
|
}
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
std::string boardname = std::string(bladerf_get_board_name(dev));
|
2017-05-26 20:21:56 +00:00
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
if (boardname == "bladerf1") {
|
2017-06-27 21:08:17 +00:00
|
|
|
return BLADERF_REV_1;
|
2017-06-28 18:03:29 +00:00
|
|
|
} else if (boardname == "bladerf2") {
|
2017-06-27 21:08:17 +00:00
|
|
|
return BLADERF_REV_2;
|
2017-05-26 20:21:56 +00:00
|
|
|
}
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
std::cerr << _pfx
|
|
|
|
<< "board name \"" << boardname << "\" unknown"
|
2017-06-27 21:08:17 +00:00
|
|
|
<< std::endl;
|
|
|
|
return BLADERF_REV_INVALID;
|
2017-05-26 20:21:56 +00:00
|
|
|
}
|
|
|
|
|
2017-06-27 21:08:17 +00:00
|
|
|
bladerf_sptr bladerf_common::get_cached_device( struct bladerf_devinfo devinfo )
|
2013-10-19 16:00:38 +00:00
|
|
|
{
|
|
|
|
/* Lock to _devs must be aquired by caller */
|
2017-06-28 18:03:29 +00:00
|
|
|
BOOST_FOREACH(boost::weak_ptr < struct bladerf >dev, _devs) {
|
2017-06-27 21:08:17 +00:00
|
|
|
int status;
|
2013-10-19 16:00:38 +00:00
|
|
|
struct bladerf_devinfo other_devinfo;
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
status = bladerf_get_devinfo(bladerf_sptr(dev).get(), &other_devinfo);
|
|
|
|
if (status < 0) {
|
2017-07-11 21:34:21 +00:00
|
|
|
throw std::runtime_error(std::string(__FUNCTION__) + ": " +
|
2017-06-28 18:03:29 +00:00
|
|
|
"Failed to get devinfo for cached device: " +
|
|
|
|
bladerf_strerror(status));
|
2017-06-01 14:40:19 +00:00
|
|
|
}
|
2013-10-19 16:00:38 +00:00
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
if (bladerf_devinfo_matches(&devinfo, &other_devinfo)) {
|
2013-10-19 16:00:38 +00:00
|
|
|
return bladerf_sptr(dev);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return bladerf_sptr();
|
|
|
|
}
|
|
|
|
|
2014-03-07 06:44:17 +00:00
|
|
|
/* This is called when a bladerf_sptr hits a refcount of 0 */
|
2017-06-28 18:03:29 +00:00
|
|
|
void bladerf_common::close(void *dev)
|
2013-10-19 16:00:38 +00:00
|
|
|
{
|
2017-06-28 18:03:29 +00:00
|
|
|
boost::unique_lock < boost::mutex > lock(_devs_mutex);
|
|
|
|
std::list < boost::weak_ptr < struct bladerf >>::iterator it(_devs.begin());
|
2013-10-19 16:00:38 +00:00
|
|
|
|
2014-03-07 06:44:17 +00:00
|
|
|
/* Prune expired entries from device cache */
|
2017-06-28 18:03:29 +00:00
|
|
|
while (it != _devs.end()) {
|
|
|
|
if ((*it).expired()) {
|
2014-03-07 06:44:17 +00:00
|
|
|
it = _devs.erase(it);
|
|
|
|
} else {
|
|
|
|
++it;
|
|
|
|
}
|
|
|
|
}
|
2013-10-19 16:00:38 +00:00
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
bladerf_close(static_cast<struct bladerf *>(dev));
|
2013-10-19 16:00:38 +00:00
|
|
|
}
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
bladerf_sptr bladerf_common::open(const std::string &device_name)
|
2013-10-19 16:00:38 +00:00
|
|
|
{
|
2017-06-27 21:08:17 +00:00
|
|
|
int status;
|
2017-06-01 14:40:19 +00:00
|
|
|
struct bladerf *raw_dev = NULL;
|
2013-10-19 16:00:38 +00:00
|
|
|
struct bladerf_devinfo devinfo;
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
boost::unique_lock < boost::mutex > lock(_devs_mutex);
|
2013-10-19 16:00:38 +00:00
|
|
|
|
2017-06-01 14:40:19 +00:00
|
|
|
/* Initialize the information used to identify the desired device
|
|
|
|
* to all wildcard (i.e., "any device") values */
|
2017-06-28 18:03:29 +00:00
|
|
|
bladerf_init_devinfo(&devinfo);
|
2017-06-01 14:40:19 +00:00
|
|
|
|
|
|
|
/* Populate the devinfo structure from device_name */
|
2017-06-28 18:03:29 +00:00
|
|
|
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));
|
2017-06-01 14:40:19 +00:00
|
|
|
}
|
2013-10-19 16:00:38 +00:00
|
|
|
|
2017-06-01 14:40:19 +00:00
|
|
|
/* Do we already have this device open? */
|
2013-10-19 16:00:38 +00:00
|
|
|
bladerf_sptr cached_dev = get_cached_device(devinfo);
|
|
|
|
|
2017-06-01 14:40:19 +00:00
|
|
|
if (cached_dev) {
|
2013-10-19 16:00:38 +00:00
|
|
|
return cached_dev;
|
2017-06-01 14:40:19 +00:00
|
|
|
}
|
2013-10-19 16:00:38 +00:00
|
|
|
|
2017-06-01 14:40:19 +00:00
|
|
|
/* Open the device. */
|
2017-06-28 18:03:29 +00:00
|
|
|
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));
|
2017-06-01 14:40:19 +00:00
|
|
|
}
|
2013-10-19 16:00:38 +00:00
|
|
|
|
2017-06-01 14:40:19 +00:00
|
|
|
/* Add the device handle to our cache */
|
2017-06-28 18:03:29 +00:00
|
|
|
bladerf_sptr dev = bladerf_sptr(raw_dev, bladerf_common::close);
|
2013-10-19 16:00:38 +00:00
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
_devs.push_back(boost::weak_ptr < struct bladerf >(dev));
|
2013-10-19 16:00:38 +00:00
|
|
|
|
|
|
|
return dev;
|
|
|
|
}
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
void bladerf_common::set_loopback_mode(const std::string &loopback)
|
bladerf: Added 'verbosity' and 'loopback' device parameters
The 'verbosity' parameter may be used to increase or suppress output from
libbladeRF. The available log levels are, in order of decreasing
verbosity are:
verbose, debug, info, warning, critical, silent
The 'loopback' parameter may be used to put the bladeRF into one of the
supported loopback modes. The valid modes are listed below. Their
descriptions may be found in the libbladeRF documentation:
bb_txlpf_rxvga2, bb_txlpf_rxlpf bb_txvga1_rxvga2, bb_txvga1_rxlpf
rf_lna1, rf_lna2, rf_lna3
2014-02-13 20:59:44 +00:00
|
|
|
{
|
2017-06-27 21:08:17 +00:00
|
|
|
int status;
|
|
|
|
bladerf_loopback mode;
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
if (loopback == "bb_txlpf_rxvga2") {
|
2017-06-27 21:08:17 +00:00
|
|
|
mode = BLADERF_LB_BB_TXLPF_RXVGA2;
|
2017-06-28 18:03:29 +00:00
|
|
|
} else if (loopback == "bb_txlpf_rxlpf") {
|
2017-06-27 21:08:17 +00:00
|
|
|
mode = BLADERF_LB_BB_TXLPF_RXLPF;
|
2017-06-28 18:03:29 +00:00
|
|
|
} else if (loopback == "bb_txvga1_rxvga2") {
|
2017-06-27 21:08:17 +00:00
|
|
|
mode = BLADERF_LB_BB_TXVGA1_RXVGA2;
|
2017-06-28 18:03:29 +00:00
|
|
|
} else if (loopback == "bb_txvga1_rxlpf") {
|
2017-06-27 21:08:17 +00:00
|
|
|
mode = BLADERF_LB_BB_TXVGA1_RXLPF;
|
2017-06-28 18:03:29 +00:00
|
|
|
} else if (loopback == "rf_lna1") {
|
2017-06-27 21:08:17 +00:00
|
|
|
mode = BLADERF_LB_RF_LNA1;
|
2017-06-28 18:03:29 +00:00
|
|
|
} else if (loopback == "rf_lna2") {
|
2017-06-27 21:08:17 +00:00
|
|
|
mode = BLADERF_LB_RF_LNA2;
|
2017-06-28 18:03:29 +00:00
|
|
|
} else if (loopback == "rf_lna3") {
|
2017-06-27 21:08:17 +00:00
|
|
|
mode = BLADERF_LB_RF_LNA3;
|
2017-07-20 20:12:49 +00:00
|
|
|
} else if (loopback == "firmware") {
|
|
|
|
mode = BLADERF_LB_FIRMWARE;
|
2017-06-28 18:03:29 +00:00
|
|
|
} else if (loopback == "ad9361_bist") {
|
2017-06-27 21:08:17 +00:00
|
|
|
mode = BLADERF_LB_AD9361_BIST;
|
2017-06-28 18:03:29 +00:00
|
|
|
} else if (loopback == "none") {
|
2017-06-27 21:08:17 +00:00
|
|
|
mode = BLADERF_LB_NONE;
|
|
|
|
} else {
|
2017-06-28 18:03:29 +00:00
|
|
|
throw std::runtime_error(_pfx + "Unknown loopback mode: " + loopback);
|
2017-06-27 21:08:17 +00:00
|
|
|
}
|
bladerf: Added 'verbosity' and 'loopback' device parameters
The 'verbosity' parameter may be used to increase or suppress output from
libbladeRF. The available log levels are, in order of decreasing
verbosity are:
verbose, debug, info, warning, critical, silent
The 'loopback' parameter may be used to put the bladeRF into one of the
supported loopback modes. The valid modes are listed below. Their
descriptions may be found in the libbladeRF documentation:
bb_txlpf_rxvga2, bb_txlpf_rxlpf bb_txvga1_rxvga2, bb_txvga1_rxlpf
rf_lna1, rf_lna2, rf_lna3
2014-02-13 20:59:44 +00:00
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
status = bladerf_set_loopback(_dev.get(), mode);
|
|
|
|
if (status != 0) {
|
2017-06-27 21:08:17 +00:00
|
|
|
// TODO: handle BLADERF_ERR_UNSUPPORTED more gingerly
|
2017-06-28 18:03:29 +00:00
|
|
|
throw std::runtime_error(_pfx + "Failed to set loopback mode: " +
|
|
|
|
bladerf_strerror(status));
|
2017-06-27 21:08:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-20 20:13:03 +00:00
|
|
|
void bladerf_common::set_rx_mux_mode(const std::string &rxmux)
|
|
|
|
{
|
|
|
|
int status;
|
|
|
|
bladerf_rx_mux mode;
|
|
|
|
|
|
|
|
if (rxmux == "baseband") {
|
|
|
|
mode = BLADERF_RX_MUX_BASEBAND;
|
|
|
|
} else if (rxmux == "12bit") {
|
|
|
|
mode = BLADERF_RX_MUX_12BIT_COUNTER;
|
|
|
|
} else if (rxmux == "32bit") {
|
|
|
|
mode = BLADERF_RX_MUX_32BIT_COUNTER;
|
|
|
|
} else if (rxmux == "digital") {
|
|
|
|
mode = BLADERF_RX_MUX_DIGITAL_LOOPBACK;
|
|
|
|
} else {
|
|
|
|
throw std::runtime_error(_pfx + "Unknown RX mux mode: " + rxmux);
|
|
|
|
}
|
|
|
|
|
|
|
|
status = bladerf_set_rx_mux(_dev.get(), mode);
|
|
|
|
if (status != 0) {
|
|
|
|
// TODO: handle BLADERF_ERR_UNSUPPORTED more gingerly
|
|
|
|
throw std::runtime_error(_pfx + "Failed to set RX mux mode: " +
|
|
|
|
bladerf_strerror(status));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
void bladerf_common::set_verbosity(const std::string &verbosity)
|
2017-06-27 21:08:17 +00:00
|
|
|
{
|
|
|
|
bladerf_log_level l;
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
if (verbosity == "verbose") {
|
2017-06-27 21:08:17 +00:00
|
|
|
l = BLADERF_LOG_LEVEL_VERBOSE;
|
2017-06-28 18:03:29 +00:00
|
|
|
} else if (verbosity == "debug") {
|
2017-06-27 21:08:17 +00:00
|
|
|
l = BLADERF_LOG_LEVEL_DEBUG;
|
2017-06-28 18:03:29 +00:00
|
|
|
} else if (verbosity == "info") {
|
2017-06-27 21:08:17 +00:00
|
|
|
l = BLADERF_LOG_LEVEL_INFO;
|
2017-06-28 18:03:29 +00:00
|
|
|
} else if (verbosity == "warning") {
|
2017-06-27 21:08:17 +00:00
|
|
|
l = BLADERF_LOG_LEVEL_WARNING;
|
2017-06-28 18:03:29 +00:00
|
|
|
} else if (verbosity == "error") {
|
2017-06-27 21:08:17 +00:00
|
|
|
l = BLADERF_LOG_LEVEL_ERROR;
|
2017-06-28 18:03:29 +00:00
|
|
|
} else if (verbosity == "critical") {
|
2017-06-27 21:08:17 +00:00
|
|
|
l = BLADERF_LOG_LEVEL_CRITICAL;
|
2017-06-28 18:03:29 +00:00
|
|
|
} else if (verbosity == "silent") {
|
2017-06-27 21:08:17 +00:00
|
|
|
l = BLADERF_LOG_LEVEL_SILENT;
|
|
|
|
} else {
|
2017-06-28 18:03:29 +00:00
|
|
|
throw std::runtime_error(_pfx + "Invalid log level: " + verbosity);
|
2017-06-27 21:08:17 +00:00
|
|
|
}
|
bladerf: Added 'verbosity' and 'loopback' device parameters
The 'verbosity' parameter may be used to increase or suppress output from
libbladeRF. The available log levels are, in order of decreasing
verbosity are:
verbose, debug, info, warning, critical, silent
The 'loopback' parameter may be used to put the bladeRF into one of the
supported loopback modes. The valid modes are listed below. Their
descriptions may be found in the libbladeRF documentation:
bb_txlpf_rxvga2, bb_txlpf_rxlpf bb_txvga1_rxvga2, bb_txvga1_rxlpf
rf_lna1, rf_lna2, rf_lna3
2014-02-13 20:59:44 +00:00
|
|
|
|
2017-06-27 21:08:17 +00:00
|
|
|
bladerf_log_set_verbosity(l);
|
bladerf: Added 'verbosity' and 'loopback' device parameters
The 'verbosity' parameter may be used to increase or suppress output from
libbladeRF. The available log levels are, in order of decreasing
verbosity are:
verbose, debug, info, warning, critical, silent
The 'loopback' parameter may be used to put the bladeRF into one of the
supported loopback modes. The valid modes are listed below. Their
descriptions may be found in the libbladeRF documentation:
bb_txlpf_rxvga2, bb_txlpf_rxlpf bb_txvga1_rxvga2, bb_txvga1_rxlpf
rf_lna1, rf_lna2, rf_lna3
2014-02-13 20:59:44 +00:00
|
|
|
}
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
bool bladerf_common::start(bladerf_direction direction)
|
2014-02-16 22:42:32 +00:00
|
|
|
{
|
2017-06-27 21:08:17 +00:00
|
|
|
int status;
|
2015-06-22 21:38:03 +00:00
|
|
|
bladerf_format format;
|
2017-05-26 14:16:33 +00:00
|
|
|
bladerf_channel_layout layout;
|
2014-02-16 22:42:32 +00:00
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
if (_use_metadata) {
|
|
|
|
format = BLADERF_FORMAT_SC16_Q11_META;
|
|
|
|
} else {
|
|
|
|
format = BLADERF_FORMAT_SC16_Q11;
|
|
|
|
}
|
2017-05-26 20:21:56 +00:00
|
|
|
|
2017-06-27 19:39:59 +00:00
|
|
|
switch (direction) {
|
|
|
|
case BLADERF_RX:
|
|
|
|
layout = _use_mimo ? BLADERF_RX_X2 : BLADERF_RX_X1;
|
|
|
|
break;
|
|
|
|
case BLADERF_TX:
|
|
|
|
layout = _use_mimo ? BLADERF_TX_X2 : BLADERF_TX_X1;
|
|
|
|
break;
|
|
|
|
default:
|
2017-06-28 18:03:29 +00:00
|
|
|
throw std::runtime_error(_pfx + "Invalid direction: " +
|
|
|
|
boost::lexical_cast<std::string>(direction));
|
2015-06-22 21:38:03 +00:00
|
|
|
}
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
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));
|
2014-02-16 22:42:32 +00:00
|
|
|
}
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
status = bladerf_enable_module(_dev.get(), direction, true);
|
|
|
|
if (status != 0) {
|
|
|
|
throw std::runtime_error(_pfx + "bladerf_enable_module failed: " +
|
|
|
|
bladerf_strerror(status));
|
2014-02-16 22:42:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
bool bladerf_common::stop(bladerf_direction direction)
|
2014-02-16 22:42:32 +00:00
|
|
|
{
|
2017-06-27 21:08:17 +00:00
|
|
|
int status;
|
2014-02-16 22:42:32 +00:00
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
status = bladerf_enable_module(_dev.get(), direction, false);
|
|
|
|
if (status != 0) {
|
|
|
|
throw std::runtime_error(_pfx + "bladerf_enable_module failed: " +
|
|
|
|
bladerf_strerror(status));
|
2014-02-16 22:42:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
static bool version_greater_or_equal(const struct bladerf_version *version,
|
|
|
|
unsigned int major,
|
|
|
|
unsigned int minor, unsigned int patch)
|
2015-07-16 18:03:20 +00:00
|
|
|
{
|
2017-06-28 18:03:29 +00:00
|
|
|
if (version->major > major) {
|
2017-06-27 21:08:17 +00:00
|
|
|
return true;
|
2017-06-28 18:03:29 +00:00
|
|
|
} else if ((version->major == major) && (version->minor > minor)) {
|
2017-06-27 21:08:17 +00:00
|
|
|
return true;
|
2017-06-28 18:03:29 +00:00
|
|
|
} else if ((version->major == major) &&
|
|
|
|
(version->minor == minor) &&
|
|
|
|
(version->patch >= patch)) {
|
2017-06-27 21:08:17 +00:00
|
|
|
return true;
|
|
|
|
} else {
|
|
|
|
return false;
|
|
|
|
}
|
2015-07-16 18:03:20 +00:00
|
|
|
}
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
void bladerf_common::init(dict_t &dict, bladerf_direction direction)
|
2013-10-26 19:59:23 +00:00
|
|
|
{
|
2017-06-27 21:08:17 +00:00
|
|
|
int status;
|
2015-07-16 18:03:20 +00:00
|
|
|
std::string device_name("");
|
2013-10-26 19:59:23 +00:00
|
|
|
struct bladerf_version ver;
|
|
|
|
char serial[BLADERF_SERIAL_LENGTH];
|
2017-06-27 19:39:59 +00:00
|
|
|
const char *type = (direction == BLADERF_TX ? "sink" : "source");
|
2013-10-26 19:59:23 +00:00
|
|
|
|
|
|
|
_pfx = std::string("[bladeRF ") + std::string(type) + std::string("] ");
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
if (dict.count("verbosity")) {
|
|
|
|
set_verbosity(dict["verbosity"]);
|
2017-06-27 21:08:17 +00:00
|
|
|
}
|
2014-05-05 23:30:38 +00:00
|
|
|
|
2017-06-27 21:08:17 +00:00
|
|
|
if (dict.count("bladerf")) {
|
2015-07-16 18:03:20 +00:00
|
|
|
const std::string value = dict["bladerf"];
|
2017-06-28 18:03:29 +00:00
|
|
|
if (value.length() > 0) {
|
|
|
|
if (value.length() <= 2) {
|
2015-07-16 18:03:20 +00:00
|
|
|
/* If the value is two digits or less, we'll assume the user is
|
|
|
|
* providing an instance number */
|
|
|
|
unsigned int device_number = 0;
|
|
|
|
|
|
|
|
try {
|
2017-06-28 18:03:29 +00:00
|
|
|
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 +
|
2015-07-16 18:03:20 +00:00
|
|
|
"' as device number: " + ex.what());
|
|
|
|
}
|
|
|
|
|
|
|
|
} else {
|
|
|
|
/* Otherwise, we'll assume it's a serial number. libbladeRF v1.4.1
|
|
|
|
* supports matching a subset of a serial number. For earlier versions,
|
|
|
|
* we require the entire serial number.
|
|
|
|
*
|
|
|
|
* libbladeRF is responsible for rejecting bad serial numbers, so we
|
|
|
|
* may just pass whatever the user has provided.
|
|
|
|
*/
|
|
|
|
bladerf_version(&ver);
|
2017-06-28 18:03:29 +00:00
|
|
|
if (version_greater_or_equal(&ver, 1, 4, 1) ||
|
|
|
|
value.length() == (BLADERF_SERIAL_LENGTH - 1)) {
|
2015-07-16 18:03:20 +00:00
|
|
|
device_name = std::string("*:serial=") + value;
|
|
|
|
} else {
|
2017-06-28 18:03:29 +00:00
|
|
|
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 #.");
|
2015-07-16 18:03:20 +00:00
|
|
|
}
|
2013-10-26 19:59:23 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
try {
|
2017-06-27 21:08:17 +00:00
|
|
|
std::cerr << _pfx
|
|
|
|
<< "Opening nuand bladeRF with device identifier string: \""
|
2017-06-28 18:03:29 +00:00
|
|
|
<< device_name << "\""
|
|
|
|
<< std::endl;
|
2015-07-16 18:03:20 +00:00
|
|
|
|
2013-10-26 19:59:23 +00:00
|
|
|
_dev = open(device_name);
|
2017-06-28 18:03:29 +00:00
|
|
|
} catch (...) {
|
|
|
|
throw std::runtime_error(_pfx + "Failed to open bladeRF device " +
|
|
|
|
device_name);
|
2013-10-26 19:59:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Load an FPGA */
|
2017-06-28 18:03:29 +00:00
|
|
|
if (dict.count("fpga")) {
|
|
|
|
if (dict.count("fpga-reload") == 0 &&
|
|
|
|
bladerf_is_fpga_configured(_dev.get()) == 1) {
|
2013-10-26 20:26:16 +00:00
|
|
|
|
2017-06-27 21:08:17 +00:00
|
|
|
std::cerr << _pfx
|
|
|
|
<< "FPGA is already loaded. Set fpga-reload=1 to force a "
|
2017-06-28 18:03:29 +00:00
|
|
|
<< "reload."
|
|
|
|
<< std::endl;
|
2013-10-26 20:26:16 +00:00
|
|
|
} else {
|
|
|
|
std::string fpga = dict["fpga"];
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
std::cerr << _pfx
|
|
|
|
<< "Loading FPGA bitstream " << fpga << "..."
|
2017-06-27 21:08:17 +00:00
|
|
|
<< std::endl;
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
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;
|
2017-06-27 21:08:17 +00:00
|
|
|
} else {
|
2017-06-28 18:03:29 +00:00
|
|
|
std::cerr << _pfx
|
|
|
|
<< "The FPGA bitstream was successfully loaded."
|
2017-06-27 21:08:17 +00:00
|
|
|
<< std::endl;
|
|
|
|
}
|
2013-10-26 20:26:16 +00:00
|
|
|
}
|
2013-10-26 19:59:23 +00:00
|
|
|
}
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
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.");
|
2013-10-26 19:59:23 +00:00
|
|
|
}
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
if (direction == BLADERF_RX) {
|
|
|
|
if (dict.count("loopback")) {
|
|
|
|
set_loopback_mode(dict["loopback"]);
|
2017-06-27 21:08:17 +00:00
|
|
|
} else {
|
2017-06-28 18:03:29 +00:00
|
|
|
set_loopback_mode("none");
|
2017-06-27 21:08:17 +00:00
|
|
|
}
|
2017-06-28 18:03:29 +00:00
|
|
|
} else if (direction == BLADERF_TX && dict.count("loopback")) {
|
|
|
|
std::cerr << _pfx
|
|
|
|
<< "Warning: 'loopback' has been specified on a bladeRF "
|
2017-07-20 20:13:03 +00:00
|
|
|
<< "sink, and will have no effect. This parameter should "
|
2017-06-28 18:03:29 +00:00
|
|
|
<< "be specified on the associated bladeRF source."
|
|
|
|
<< std::endl;
|
2014-06-11 08:11:09 +00:00
|
|
|
}
|
2014-05-06 01:58:57 +00:00
|
|
|
|
2017-07-20 20:13:03 +00:00
|
|
|
if (direction == BLADERF_RX) {
|
|
|
|
if (dict.count("rxmux")) {
|
|
|
|
set_rx_mux_mode(dict["rxmux"]);
|
|
|
|
} else {
|
|
|
|
set_rx_mux_mode("baseband");
|
|
|
|
}
|
|
|
|
} else if (direction == BLADERF_TX && dict.count("rxmux")) {
|
|
|
|
std::cerr << _pfx
|
|
|
|
<< "Warning: 'rxmux' has been specified on a bladeRF sink, "
|
|
|
|
<< "and will have no effect."
|
|
|
|
<< std::endl;
|
|
|
|
}
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
if (dict.count("xb200")) {
|
2014-06-11 08:11:09 +00:00
|
|
|
if (bladerf_expansion_attach(_dev.get(), BLADERF_XB_200)) {
|
|
|
|
std::cerr << _pfx << "Could not attach XB-200" << std::endl;
|
|
|
|
} else {
|
|
|
|
_xb_200_attached = true;
|
|
|
|
|
|
|
|
bladerf_xb200_filter filter = BLADERF_XB200_AUTO_1DB;
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
if (dict["xb200"] == "custom") {
|
2014-06-11 08:11:09 +00:00
|
|
|
filter = BLADERF_XB200_CUSTOM;
|
2017-06-28 18:03:29 +00:00
|
|
|
} else if (dict["xb200"] == "50M") {
|
2014-06-11 08:11:09 +00:00
|
|
|
filter = BLADERF_XB200_50M;
|
2017-06-28 18:03:29 +00:00
|
|
|
} else if (dict["xb200"] == "144M") {
|
2014-06-11 08:11:09 +00:00
|
|
|
filter = BLADERF_XB200_144M;
|
2017-06-28 18:03:29 +00:00
|
|
|
} else if (dict["xb200"] == "222M") {
|
2014-06-11 08:11:09 +00:00
|
|
|
filter = BLADERF_XB200_222M;
|
2017-06-28 18:03:29 +00:00
|
|
|
} else if (dict["xb200"] == "auto3db") {
|
2014-06-11 08:11:09 +00:00
|
|
|
filter = BLADERF_XB200_AUTO_3DB;
|
2017-06-28 18:03:29 +00:00
|
|
|
} else if (dict["xb200"] == "auto") {
|
2014-06-11 08:11:09 +00:00
|
|
|
filter = BLADERF_XB200_AUTO_1DB;
|
|
|
|
} else {
|
|
|
|
filter = BLADERF_XB200_AUTO_1DB;
|
|
|
|
}
|
2014-05-06 01:58:57 +00:00
|
|
|
|
2017-06-27 21:08:17 +00:00
|
|
|
status = bladerf_xb200_set_filterbank(_dev.get(), direction, filter);
|
2017-06-28 18:03:29 +00:00
|
|
|
if (status != 0) {
|
|
|
|
std::cerr << _pfx
|
|
|
|
<< "Could not set XB-200 filter: "
|
|
|
|
<< bladerf_strerror(status)
|
|
|
|
<< std::endl;
|
2014-06-11 08:11:09 +00:00
|
|
|
}
|
|
|
|
}
|
2014-05-06 01:58:57 +00:00
|
|
|
}
|
bladerf: Added 'verbosity' and 'loopback' device parameters
The 'verbosity' parameter may be used to increase or suppress output from
libbladeRF. The available log levels are, in order of decreasing
verbosity are:
verbose, debug, info, warning, critical, silent
The 'loopback' parameter may be used to put the bladeRF into one of the
supported loopback modes. The valid modes are listed below. Their
descriptions may be found in the libbladeRF documentation:
bb_txlpf_rxvga2, bb_txlpf_rxlpf bb_txvga1_rxvga2, bb_txvga1_rxlpf
rf_lna1, rf_lna2, rf_lna3
2014-02-13 20:59:44 +00:00
|
|
|
|
2013-10-26 19:59:23 +00:00
|
|
|
/* Show some info about the device we've opened */
|
2017-06-27 21:08:17 +00:00
|
|
|
std::cerr << _pfx;
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
if (bladerf_get_serial(_dev.get(), serial) == 0) {
|
2014-01-11 08:03:28 +00:00
|
|
|
std::string strser(serial);
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
if (strser.length() == 32) {
|
|
|
|
strser.replace(4, 24, "...");
|
2017-06-27 21:08:17 +00:00
|
|
|
}
|
2014-01-11 08:03:28 +00:00
|
|
|
|
2017-06-27 21:08:17 +00:00
|
|
|
std::cerr << " Serial # " << strser;
|
2014-01-11 08:03:28 +00:00
|
|
|
}
|
2013-10-26 19:59:23 +00:00
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
if (bladerf_fw_version(_dev.get(), &ver) == 0) {
|
2013-10-26 19:59:23 +00:00
|
|
|
std::cerr << " FW v" << ver.major << "." << ver.minor << "." << ver.patch;
|
2017-06-27 21:08:17 +00:00
|
|
|
}
|
2013-10-26 19:59:23 +00:00
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
if (bladerf_fpga_version(_dev.get(), &ver) == 0) {
|
2013-10-26 19:59:23 +00:00
|
|
|
std::cerr << " FPGA v" << ver.major << "." << ver.minor << "." << ver.patch;
|
2017-06-27 21:08:17 +00:00
|
|
|
}
|
2013-10-26 19:59:23 +00:00
|
|
|
|
|
|
|
std::cerr << std::endl;
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
if (dict.count("tamer")) {
|
|
|
|
set_clock_source(dict["tamer"]);
|
|
|
|
std::cerr << _pfx
|
|
|
|
<< "Tamer mode set to '" << get_clock_source() << "'"
|
|
|
|
<< std::endl;
|
2016-02-28 16:45:54 +00:00
|
|
|
}
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
if (dict.count("smb")) {
|
|
|
|
set_smb_frequency(boost::lexical_cast<double>(dict["smb"]));
|
|
|
|
std::cerr << _pfx
|
|
|
|
<< "SMB frequency set to " << get_smb_frequency() << " Hz"
|
|
|
|
<< std::endl;
|
2016-02-28 16:45:54 +00:00
|
|
|
}
|
|
|
|
|
2017-07-20 19:03:47 +00:00
|
|
|
/* Specify initial gain mode */
|
|
|
|
if (direction == BLADERF_RX) {
|
|
|
|
if (dict.count("agc")) {
|
|
|
|
set_gain_mode(boost::lexical_cast<bool>(dict["agc"]));
|
|
|
|
std::cerr << _pfx
|
|
|
|
<< "Gain mode set to " << get_gain_mode()
|
|
|
|
<< std::endl;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-10-26 19:59:23 +00:00
|
|
|
/* Initialize buffer and sample configuration */
|
|
|
|
_num_buffers = 0;
|
2017-06-28 18:03:29 +00:00
|
|
|
if (dict.count("buffers")) {
|
|
|
|
_num_buffers = boost::lexical_cast<size_t>(dict["buffers"]);
|
2013-10-26 19:59:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
_samples_per_buffer = 0;
|
2017-06-28 18:03:29 +00:00
|
|
|
if (dict.count("buflen")) {
|
|
|
|
_samples_per_buffer = boost::lexical_cast<size_t>(dict["buflen"]);
|
2013-10-26 19:59:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
_num_transfers = 0;
|
2017-06-28 18:03:29 +00:00
|
|
|
if (dict.count("transfers")) {
|
|
|
|
_num_transfers = boost::lexical_cast<size_t>(dict["transfers"]);
|
2013-10-26 19:59:23 +00:00
|
|
|
}
|
|
|
|
|
2014-02-16 22:42:32 +00:00
|
|
|
_stream_timeout_ms = 3000;
|
2017-06-28 18:03:29 +00:00
|
|
|
if (dict.count("stream_timeout_ms")) {
|
|
|
|
_stream_timeout_ms = boost::lexical_cast<unsigned int>(dict["stream_timeout_ms"]);
|
2014-02-16 22:42:32 +00:00
|
|
|
}
|
|
|
|
|
2015-06-22 21:38:03 +00:00
|
|
|
_use_metadata = dict.count("enable_metadata") != 0;
|
|
|
|
|
2013-10-26 19:59:23 +00:00
|
|
|
/* Require value to be >= 2 so we can ensure we have twice as many
|
|
|
|
* buffers as transfers */
|
2017-06-28 18:03:29 +00:00
|
|
|
if (_num_buffers <= 1) {
|
2013-10-26 19:59:23 +00:00
|
|
|
_num_buffers = NUM_BUFFERS;
|
|
|
|
}
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
if (0 == _samples_per_buffer) {
|
2013-10-26 19:59:23 +00:00
|
|
|
_samples_per_buffer = NUM_SAMPLES_PER_BUFFER;
|
|
|
|
} else {
|
2017-06-28 18:03:29 +00:00
|
|
|
if ((_samples_per_buffer < 1024) ||
|
|
|
|
(_samples_per_buffer % 1024 != 0)) {
|
2013-10-26 19:59:23 +00:00
|
|
|
/* 0 likely implies the user did not specify this, so don't warn */
|
2017-06-28 18:03:29 +00:00
|
|
|
if (_samples_per_buffer != 0) {
|
2017-06-27 21:08:17 +00:00
|
|
|
std::cerr << _pfx
|
|
|
|
<< "Invalid \"buflen\" value. A multiple of 1024 is "
|
2017-06-28 18:03:29 +00:00
|
|
|
<< "required. Defaulting to " << NUM_SAMPLES_PER_BUFFER
|
|
|
|
<< std::endl;
|
2013-10-26 19:59:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
_samples_per_buffer = NUM_SAMPLES_PER_BUFFER;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-10-25 20:23:58 +00:00
|
|
|
/* If the user hasn't specified the desired number of transfers, set it to
|
2017-08-09 20:15:08 +00:00
|
|
|
* min(NUM_TRANSFERS, num_buffers / 2) */
|
2017-06-28 18:03:29 +00:00
|
|
|
if (_num_transfers == 0) {
|
|
|
|
_num_transfers = _num_buffers / 2;
|
2017-06-27 21:08:17 +00:00
|
|
|
|
2017-08-09 20:15:08 +00:00
|
|
|
if (_num_transfers > NUM_TRANSFERS) {
|
|
|
|
_num_transfers = NUM_TRANSFERS;
|
2017-06-28 18:03:29 +00:00
|
|
|
}
|
|
|
|
} 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;
|
2013-10-26 19:59:23 +00:00
|
|
|
}
|
2014-02-16 22:42:32 +00:00
|
|
|
|
2017-08-09 20:15:08 +00:00
|
|
|
std::cerr << _pfx
|
|
|
|
<< "Buffers: " << _num_buffers << ", "
|
|
|
|
<< "Samples per buffer: " << _samples_per_buffer << ", "
|
|
|
|
<< "Transfers: " << _num_transfers
|
|
|
|
<< std::endl;
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
_conv_buf = static_cast<int16_t *>(malloc(_conv_buf_size * 2 * sizeof(int16_t)));
|
2014-02-16 22:42:32 +00:00
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
if (NULL == _conv_buf) {
|
|
|
|
throw std::runtime_error(_pfx + "Failed to allocate _conv_buf");
|
2014-02-16 22:42:32 +00:00
|
|
|
}
|
2013-10-26 19:59:23 +00:00
|
|
|
}
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
osmosdr::freq_range_t bladerf_common::freq_range(bladerf_channel chan)
|
2013-07-20 16:14:20 +00:00
|
|
|
{
|
2017-06-27 21:08:17 +00:00
|
|
|
int status;
|
2017-05-26 20:21:56 +00:00
|
|
|
struct bladerf_range range;
|
2017-05-26 14:16:33 +00:00
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
status = bladerf_get_frequency_range(_dev.get(), chan, &range);
|
2017-05-26 14:16:33 +00:00
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
if (status != 0) {
|
|
|
|
throw std::runtime_error(_pfx +
|
|
|
|
"bladerf_get_frequency_range failed: " +
|
|
|
|
bladerf_strerror(status));
|
2017-05-26 14:16:33 +00:00
|
|
|
} else {
|
2017-06-28 18:03:29 +00:00
|
|
|
return osmosdr::freq_range_t(static_cast<double>(range.min),
|
|
|
|
static_cast<double>(range.max),
|
|
|
|
static_cast<double>(range.step));
|
2017-05-26 14:16:33 +00:00
|
|
|
};
|
2013-07-20 16:14:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
osmosdr::meta_range_t bladerf_common::sample_rates()
|
|
|
|
{
|
2017-06-27 21:08:17 +00:00
|
|
|
int status;
|
2013-07-28 14:35:48 +00:00
|
|
|
osmosdr::meta_range_t sample_rates;
|
2017-05-26 14:16:33 +00:00
|
|
|
bladerf_range brf_sample_rates;
|
2013-07-28 14:35:48 +00:00
|
|
|
|
2013-07-20 16:14:20 +00:00
|
|
|
/* assuming the same for RX & TX */
|
2017-06-28 18:03:29 +00:00
|
|
|
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);
|
2013-07-28 14:35:48 +00:00
|
|
|
|
|
|
|
return sample_rates;
|
2013-07-20 16:14:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
osmosdr::freq_range_t bladerf_common::filter_bandwidths()
|
|
|
|
{
|
|
|
|
/* the same for RX & TX according to the datasheet */
|
2017-06-27 21:08:17 +00:00
|
|
|
int status;
|
2013-07-20 16:14:20 +00:00
|
|
|
osmosdr::freq_range_t bandwidths;
|
2017-05-26 20:21:56 +00:00
|
|
|
bladerf_range range;
|
2017-05-26 14:16:33 +00:00
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
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));
|
2017-05-26 14:16:33 +00:00
|
|
|
}
|
2013-07-20 16:14:20 +00:00
|
|
|
|
2017-05-26 20:21:56 +00:00
|
|
|
bandwidths += osmosdr::range_t(range.min, range.max, range.step);
|
2013-07-20 16:14:20 +00:00
|
|
|
|
|
|
|
return bandwidths;
|
|
|
|
}
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
std::vector < std::string > bladerf_common::devices()
|
2013-07-20 16:14:20 +00:00
|
|
|
{
|
2013-08-27 20:37:08 +00:00
|
|
|
struct bladerf_devinfo *devices;
|
2013-07-20 16:14:20 +00:00
|
|
|
ssize_t n_devices;
|
2017-06-28 18:03:29 +00:00
|
|
|
std::vector < std::string > ret;
|
2013-07-20 16:14:20 +00:00
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
n_devices = bladerf_get_device_list(&devices);
|
2013-07-20 16:14:20 +00:00
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
if (n_devices > 0) {
|
|
|
|
for (ssize_t i = 0; i < n_devices; i++) {
|
2013-07-20 16:14:20 +00:00
|
|
|
std::stringstream s;
|
2013-08-27 20:37:08 +00:00
|
|
|
std::string serial(devices[i].serial);
|
2013-07-20 16:14:20 +00:00
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
s << "bladerf=" << devices[i].instance << ",label='nuand bladeRF";
|
2013-08-27 20:37:08 +00:00
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
if (serial.length() == 32) {
|
|
|
|
serial.replace(4, 24, "...");
|
|
|
|
}
|
2014-01-11 08:03:28 +00:00
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
if (serial.length()) {
|
2013-08-27 20:37:08 +00:00
|
|
|
s << " SN " << serial;
|
2017-06-28 18:03:29 +00:00
|
|
|
}
|
2013-08-27 20:37:08 +00:00
|
|
|
|
|
|
|
s << "'";
|
2013-07-20 16:14:20 +00:00
|
|
|
|
|
|
|
ret.push_back(s.str());
|
|
|
|
}
|
|
|
|
|
2013-08-27 20:37:08 +00:00
|
|
|
bladerf_free_device_list(devices);
|
2013-07-20 16:14:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
double bladerf_common::set_sample_rate(bladerf_direction direction, double rate)
|
2014-01-12 19:25:14 +00:00
|
|
|
{
|
|
|
|
int status;
|
|
|
|
struct bladerf_rational_rate rational_rate, actual;
|
|
|
|
|
2017-06-01 14:40:19 +00:00
|
|
|
rational_rate.integer = static_cast<uint32_t>(rate);
|
2014-01-12 19:25:14 +00:00
|
|
|
rational_rate.den = 10000;
|
|
|
|
rational_rate.num = (rate - rational_rate.integer) * rational_rate.den;
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
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));
|
2014-01-12 19:25:14 +00:00
|
|
|
}
|
|
|
|
|
2017-06-01 14:40:19 +00:00
|
|
|
return actual.integer + actual.num / static_cast<double>(actual.den);
|
2014-01-12 19:25:14 +00:00
|
|
|
}
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
double bladerf_common::get_sample_rate(bladerf_direction direction)
|
2014-01-12 19:25:14 +00:00
|
|
|
{
|
|
|
|
int status;
|
|
|
|
struct bladerf_rational_rate rate;
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
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));
|
2014-01-12 19:25:14 +00:00
|
|
|
}
|
|
|
|
|
2017-06-27 21:08:17 +00:00
|
|
|
return rate.integer + rate.num / static_cast<double>(rate.den);
|
2014-01-12 19:25:14 +00:00
|
|
|
}
|
2014-01-18 19:12:02 +00:00
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
osmosdr::freq_range_t bladerf_common::get_freq_range(size_t chan)
|
2017-05-26 14:16:33 +00:00
|
|
|
{
|
2017-06-28 18:03:29 +00:00
|
|
|
return freq_range(static_cast<bladerf_channel>(chan));
|
2017-05-26 14:16:33 +00:00
|
|
|
}
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
double bladerf_common::set_center_freq(double freq, size_t chan)
|
2017-05-26 14:16:33 +00:00
|
|
|
{
|
2017-06-27 21:08:17 +00:00
|
|
|
int status;
|
2017-05-26 14:16:33 +00:00
|
|
|
|
|
|
|
/* Check frequency range */
|
2017-06-28 18:03:29 +00:00
|
|
|
if (freq < get_freq_range(chan).start() ||
|
|
|
|
freq > get_freq_range(chan).stop()) {
|
2017-05-26 14:16:33 +00:00
|
|
|
std::cerr << "Failed to set out of bound frequency: " << freq << std::endl;
|
|
|
|
} else {
|
2017-06-28 18:03:29 +00:00
|
|
|
status = bladerf_set_frequency(_dev.get(),
|
|
|
|
static_cast<bladerf_channel>(chan),
|
|
|
|
static_cast<uint64_t>(freq));
|
|
|
|
if (status != 0) {
|
|
|
|
throw std::runtime_error(_pfx +
|
|
|
|
"failed to set center frequency " +
|
|
|
|
boost::lexical_cast<std::string>(freq) + ": " +
|
|
|
|
bladerf_strerror(status));
|
2017-05-26 14:16:33 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
return get_center_freq(chan);
|
2017-05-26 14:16:33 +00:00
|
|
|
}
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
double bladerf_common::get_center_freq(size_t chan)
|
2017-05-26 14:16:33 +00:00
|
|
|
{
|
2017-06-27 21:08:17 +00:00
|
|
|
int status;
|
2017-05-26 14:16:33 +00:00
|
|
|
uint64_t freq;
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
status = bladerf_get_frequency(_dev.get(),
|
|
|
|
static_cast<bladerf_channel>(chan),
|
|
|
|
&freq);
|
|
|
|
if (status != 0) {
|
|
|
|
throw std::runtime_error(_pfx + "failed to get center frequency: " +
|
|
|
|
bladerf_strerror(status));
|
2017-05-26 14:16:33 +00:00
|
|
|
}
|
|
|
|
|
2017-06-01 14:40:19 +00:00
|
|
|
return static_cast<double>(freq);
|
2017-05-26 14:16:33 +00:00
|
|
|
}
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
std::vector<std::string> bladerf_common::get_gain_names(size_t chan)
|
2017-05-26 14:16:33 +00:00
|
|
|
{
|
|
|
|
const size_t max_count = 16;
|
2017-06-28 18:03:29 +00:00
|
|
|
std::vector < std::string > names;
|
2017-05-26 14:16:33 +00:00
|
|
|
char *gain_names[max_count];
|
2017-06-28 19:25:37 +00:00
|
|
|
int count;
|
2017-05-26 14:16:33 +00:00
|
|
|
|
|
|
|
names += SYSTEM_GAIN_NAME;
|
|
|
|
|
2017-06-28 19:25:37 +00:00
|
|
|
count = bladerf_get_gain_stages(_dev.get(),
|
|
|
|
static_cast<bladerf_channel>(chan),
|
|
|
|
reinterpret_cast<const char **>(&gain_names),
|
|
|
|
max_count);
|
|
|
|
if (count < 0) {
|
2017-06-28 18:03:29 +00:00
|
|
|
throw std::runtime_error(_pfx +
|
|
|
|
"failed to get gain stages: " +
|
2017-06-28 19:25:37 +00:00
|
|
|
bladerf_strerror(count));
|
2017-05-26 14:16:33 +00:00
|
|
|
}
|
|
|
|
|
2017-06-28 19:25:37 +00:00
|
|
|
for (int i = 0; i < count; ++i) {
|
|
|
|
char *tmp = gain_names[i];
|
2017-05-26 14:16:33 +00:00
|
|
|
names += std::string(tmp);
|
|
|
|
};
|
|
|
|
|
|
|
|
return names;
|
|
|
|
}
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
osmosdr::gain_range_t bladerf_common::get_gain_range(size_t chan)
|
2017-05-26 14:16:33 +00:00
|
|
|
{
|
|
|
|
/* This is an overall system gain range. */
|
2017-06-28 18:03:29 +00:00
|
|
|
return get_gain_range(SYSTEM_GAIN_NAME, chan);
|
2017-05-26 14:16:33 +00:00
|
|
|
}
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
osmosdr::gain_range_t bladerf_common::get_gain_range(const std::string &name,
|
|
|
|
size_t chan)
|
2017-05-26 14:16:33 +00:00
|
|
|
{
|
2017-06-27 21:08:17 +00:00
|
|
|
int status;
|
2017-05-26 20:21:56 +00:00
|
|
|
struct bladerf_range range;
|
2017-05-26 14:16:33 +00:00
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
if (name == SYSTEM_GAIN_NAME) {
|
|
|
|
status = bladerf_get_gain_range(_dev.get(),
|
|
|
|
static_cast<bladerf_channel>(chan),
|
|
|
|
&range);
|
2017-05-26 14:16:33 +00:00
|
|
|
} else {
|
2017-06-28 18:03:29 +00:00
|
|
|
status = bladerf_get_gain_stage_range(_dev.get(),
|
|
|
|
static_cast<bladerf_channel>(chan),
|
|
|
|
name.c_str(),
|
|
|
|
&range);
|
2017-05-26 14:16:33 +00:00
|
|
|
}
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
if (status != 0) {
|
|
|
|
throw std::runtime_error(_pfx +
|
|
|
|
"bladerf_get_gain_range " + name +
|
|
|
|
" failed: " + bladerf_strerror(status));
|
2017-05-26 14:16:33 +00:00
|
|
|
}
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
return osmosdr::gain_range_t(range.min, range.max, range.step);
|
2017-05-26 14:16:33 +00:00
|
|
|
}
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
bool bladerf_common::set_gain_mode(bool automatic, size_t chan)
|
2017-05-26 14:16:33 +00:00
|
|
|
{
|
2017-06-27 21:08:17 +00:00
|
|
|
int status;
|
2017-06-27 18:39:56 +00:00
|
|
|
bladerf_gain_mode mode = automatic ? BLADERF_GAIN_DEFAULT : BLADERF_GAIN_MGC;
|
2017-06-01 21:04:03 +00:00
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
status = bladerf_set_gain_mode(_dev.get(),
|
|
|
|
static_cast<bladerf_channel>(chan),
|
|
|
|
mode);
|
2017-06-01 21:04:03 +00:00
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
if (status != 0) {
|
|
|
|
throw std::runtime_error(_pfx +
|
|
|
|
"bladerf_set_gain_mode " +
|
|
|
|
(automatic ? "automatic" : "manual") +
|
|
|
|
" failed: " + bladerf_strerror(status));
|
2017-06-01 21:04:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return get_gain_mode(chan);
|
2017-05-26 14:16:33 +00:00
|
|
|
}
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
bool bladerf_common::get_gain_mode(size_t chan)
|
2017-05-26 14:16:33 +00:00
|
|
|
{
|
2017-06-27 21:08:17 +00:00
|
|
|
int status;
|
2017-06-01 21:04:03 +00:00
|
|
|
bladerf_gain_mode gainmode;
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
status = bladerf_get_gain_mode(_dev.get(),
|
|
|
|
static_cast<bladerf_channel>(chan),
|
|
|
|
&gainmode);
|
2017-06-01 21:04:03 +00:00
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
if (status != 0) {
|
|
|
|
throw std::runtime_error(_pfx + "bladerf_get_gain_mode failed: " +
|
|
|
|
bladerf_strerror(status));
|
2017-06-01 21:04:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return (gainmode != BLADERF_GAIN_MGC);
|
2017-05-26 14:16:33 +00:00
|
|
|
}
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
double bladerf_common::set_gain(double gain, size_t chan)
|
2017-05-26 14:16:33 +00:00
|
|
|
{
|
2017-06-28 18:03:29 +00:00
|
|
|
return set_gain(gain, SYSTEM_GAIN_NAME, chan);
|
2017-05-26 14:16:33 +00:00
|
|
|
}
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
double bladerf_common::set_gain(double gain,
|
|
|
|
const std::string &name, size_t chan)
|
2017-05-26 14:16:33 +00:00
|
|
|
{
|
2017-06-27 21:08:17 +00:00
|
|
|
int status;
|
2017-05-26 14:16:33 +00:00
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
if (name == SYSTEM_GAIN_NAME) {
|
|
|
|
status = bladerf_set_gain(_dev.get(),
|
|
|
|
static_cast<bladerf_channel>(chan),
|
|
|
|
static_cast<int>(gain));
|
2017-05-26 14:16:33 +00:00
|
|
|
} else {
|
2017-06-28 18:03:29 +00:00
|
|
|
status = bladerf_set_gain_stage(_dev.get(),
|
|
|
|
static_cast<bladerf_channel>(chan),
|
|
|
|
name.c_str(),
|
|
|
|
static_cast<int>(gain));
|
2017-05-26 14:16:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Check for errors */
|
2017-06-28 18:03:29 +00:00
|
|
|
if (status != 0) {
|
2017-06-27 21:08:17 +00:00
|
|
|
std::string errmsg = _pfx + "could not set " + name + " gain: " +
|
|
|
|
bladerf_strerror(status);
|
2017-06-28 18:03:29 +00:00
|
|
|
if (BLADERF_ERR_UNSUPPORTED == status) {
|
2017-05-26 14:16:33 +00:00
|
|
|
// unsupported, but not worth crashing out
|
|
|
|
std::cerr << errmsg << std::endl;
|
|
|
|
} else {
|
|
|
|
throw std::runtime_error(errmsg);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
return get_gain(name, chan);
|
2017-05-26 14:16:33 +00:00
|
|
|
}
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
double bladerf_common::get_gain(size_t chan)
|
2017-05-26 14:16:33 +00:00
|
|
|
{
|
2017-06-28 18:03:29 +00:00
|
|
|
return get_gain(SYSTEM_GAIN_NAME, chan);
|
2017-05-26 14:16:33 +00:00
|
|
|
}
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
double bladerf_common::get_gain(const std::string &name, size_t chan)
|
2017-05-26 14:16:33 +00:00
|
|
|
{
|
2017-06-27 21:08:17 +00:00
|
|
|
int status;
|
2017-05-26 14:16:33 +00:00
|
|
|
int g;
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
if (name == SYSTEM_GAIN_NAME) {
|
|
|
|
status = bladerf_get_gain(_dev.get(),
|
|
|
|
static_cast<bladerf_channel>(chan),
|
|
|
|
&g);
|
2017-05-26 14:16:33 +00:00
|
|
|
} else {
|
2017-06-28 18:03:29 +00:00
|
|
|
status = bladerf_get_gain_stage(_dev.get(),
|
|
|
|
static_cast<bladerf_channel>(chan),
|
|
|
|
name.c_str(),
|
|
|
|
&g);
|
2017-05-26 14:16:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Check for errors */
|
2017-06-28 18:03:29 +00:00
|
|
|
if (status != 0) {
|
|
|
|
throw std::runtime_error(_pfx + "could not get " + name + " gain: " +
|
|
|
|
bladerf_strerror(status));
|
2017-05-26 14:16:33 +00:00
|
|
|
}
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
return (double) g;
|
2017-05-26 14:16:33 +00:00
|
|
|
}
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
int bladerf_common::set_dc_offset(bladerf_direction direction,
|
|
|
|
const std::complex < double > &offset,
|
|
|
|
size_t chan)
|
2014-01-18 19:12:02 +00:00
|
|
|
{
|
2017-06-27 21:08:17 +00:00
|
|
|
int ret = 0;
|
|
|
|
int16_t val_i, val_q;
|
2014-01-18 19:12:02 +00:00
|
|
|
|
2017-06-27 21:08:17 +00:00
|
|
|
val_i = static_cast<int16_t>(offset.real() * DCOFF_SCALE);
|
|
|
|
val_q = static_cast<int16_t>(offset.imag() * DCOFF_SCALE);
|
2014-01-18 19:12:02 +00:00
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
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);
|
2014-01-18 19:12:02 +00:00
|
|
|
|
2017-06-27 21:08:17 +00:00
|
|
|
return ret;
|
2014-01-18 19:12:02 +00:00
|
|
|
}
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
int bladerf_common::set_iq_balance(bladerf_direction direction,
|
|
|
|
const std::complex < double > &balance,
|
|
|
|
size_t chan)
|
2014-01-18 19:12:02 +00:00
|
|
|
{
|
2017-06-27 21:08:17 +00:00
|
|
|
int ret = 0;
|
|
|
|
int16_t val_gain, val_phase;
|
2014-01-18 19:12:02 +00:00
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
val_gain = static_cast<int16_t>(balance.real() * GAIN_SCALE);
|
2017-06-27 21:08:17 +00:00
|
|
|
val_phase = static_cast<int16_t>(balance.imag() * PHASE_SCALE);
|
2014-01-18 19:12:02 +00:00
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
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);
|
2014-01-18 19:12:02 +00:00
|
|
|
|
2017-06-27 21:08:17 +00:00
|
|
|
return ret;
|
2014-01-18 19:12:02 +00:00
|
|
|
}
|
2016-02-28 16:45:54 +00:00
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
void bladerf_common::set_clock_source(const std::string &source,
|
|
|
|
const size_t mboard)
|
2016-02-28 16:45:54 +00:00
|
|
|
{
|
2017-06-27 21:08:17 +00:00
|
|
|
int status;
|
|
|
|
bladerf_vctcxo_tamer_mode tamer_mode;
|
2017-06-28 18:03:29 +00:00
|
|
|
std::vector < std::string > clock_sources;
|
2017-06-27 21:08:17 +00:00
|
|
|
int index;
|
2016-02-28 16:45:54 +00:00
|
|
|
|
2017-06-27 21:08:17 +00:00
|
|
|
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();
|
2016-02-28 16:45:54 +00:00
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
if (index < static_cast<int>(clock_sources.size())) {
|
2016-02-28 16:45:54 +00:00
|
|
|
tamer_mode = static_cast<bladerf_vctcxo_tamer_mode>(index);
|
|
|
|
}
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
status = bladerf_set_vctcxo_tamer_mode(_dev.get(), tamer_mode);
|
|
|
|
if (status != 0) {
|
2016-02-28 16:45:54 +00:00
|
|
|
throw std::runtime_error(_pfx + "Failed to set VCTCXO tamer mode: " +
|
|
|
|
bladerf_strerror(status));
|
2017-06-27 21:08:17 +00:00
|
|
|
}
|
2016-02-28 16:45:54 +00:00
|
|
|
}
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
std::string bladerf_common::get_clock_source(const size_t mboard)
|
2016-02-28 16:45:54 +00:00
|
|
|
{
|
2017-06-27 21:08:17 +00:00
|
|
|
int status;
|
|
|
|
bladerf_vctcxo_tamer_mode tamer_mode;
|
2017-06-28 18:03:29 +00:00
|
|
|
std::vector < std::string > clock_sources;
|
2016-02-28 16:45:54 +00:00
|
|
|
|
2017-06-27 21:08:17 +00:00
|
|
|
tamer_mode = BLADERF_VCTCXO_TAMER_INVALID;
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
status = bladerf_get_vctcxo_tamer_mode(_dev.get(), &tamer_mode);
|
|
|
|
if (status != 0) {
|
2016-02-28 16:45:54 +00:00
|
|
|
throw std::runtime_error(_pfx + "Failed to get VCTCXO tamer mode: " +
|
|
|
|
bladerf_strerror(status));
|
2017-06-27 21:08:17 +00:00
|
|
|
}
|
2016-02-28 16:45:54 +00:00
|
|
|
|
2017-06-27 21:08:17 +00:00
|
|
|
clock_sources = get_clock_sources(mboard);
|
2016-02-28 16:45:54 +00:00
|
|
|
|
|
|
|
return clock_sources.at(tamer_mode);
|
|
|
|
}
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
std::vector < std::string > bladerf_common::get_clock_sources(const size_t mboard)
|
2016-02-28 16:45:54 +00:00
|
|
|
{
|
2017-06-28 18:03:29 +00:00
|
|
|
std::vector < std::string > sources;
|
2016-02-28 16:45:54 +00:00
|
|
|
|
|
|
|
// assumes zero-based 1:1 mapping
|
2017-06-28 18:03:29 +00:00
|
|
|
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
|
2016-02-28 16:45:54 +00:00
|
|
|
|
|
|
|
return sources;
|
|
|
|
}
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
void bladerf_common::set_smb_frequency(double frequency)
|
2016-02-28 16:45:54 +00:00
|
|
|
{
|
2017-06-27 21:08:17 +00:00
|
|
|
int status;
|
|
|
|
uint32_t actual_frequency;
|
|
|
|
actual_frequency = frequency;
|
2016-02-28 16:45:54 +00:00
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
status = bladerf_set_smb_frequency(_dev.get(),
|
|
|
|
static_cast<uint32_t>(frequency),
|
|
|
|
&actual_frequency);
|
|
|
|
if (status != 0) {
|
2016-02-28 16:45:54 +00:00
|
|
|
throw std::runtime_error(_pfx + "Failed to set SMB frequency: " +
|
|
|
|
bladerf_strerror(status));
|
2017-06-27 21:08:17 +00:00
|
|
|
}
|
2016-02-28 16:45:54 +00:00
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
if (static_cast<uint32_t>(frequency) != actual_frequency) {
|
|
|
|
std::cerr << _pfx
|
|
|
|
<< "Wanted SMB frequency is " << frequency
|
2016-02-28 16:45:54 +00:00
|
|
|
<< ", actual is " << actual_frequency
|
|
|
|
<< std::endl;
|
2017-06-27 21:08:17 +00:00
|
|
|
}
|
2016-02-28 16:45:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
double bladerf_common::get_smb_frequency()
|
|
|
|
{
|
2017-06-27 21:08:17 +00:00
|
|
|
int status;
|
2016-02-28 16:45:54 +00:00
|
|
|
unsigned int actual_frequency;
|
|
|
|
|
2017-06-28 18:03:29 +00:00
|
|
|
status = bladerf_get_smb_frequency(_dev.get(), &actual_frequency);
|
|
|
|
if (status != 0) {
|
2016-02-28 16:45:54 +00:00
|
|
|
throw std::runtime_error(_pfx + "Failed to get SMB frequency: " +
|
|
|
|
bladerf_strerror(status));
|
2017-06-28 18:03:29 +00:00
|
|
|
}
|
2016-02-28 16:45:54 +00:00
|
|
|
|
2017-06-01 14:40:19 +00:00
|
|
|
return static_cast<double>(actual_frequency);
|
2016-02-28 16:45:54 +00:00
|
|
|
}
|