int print_frequency(struct cli_state *state, int argc, char **argv)
{
/* Usage: print frequency [<rx|tx>] */
int rv = CLI_RET_OK;
int status;
unsigned int freq;
bladerf_module module = BLADERF_MODULE_RX;
if( argc == 3 ) {
/* Parse module */
bool ok;
module = get_module( argv[2], &ok );
if( !ok ) {
invalid_module(state, argv[0], argv[2]);
rv = CLI_RET_INVPARAM;
}
} else if( argc != 2 ) {
/* Assume both RX & TX if not specified */
rv = CLI_RET_NARGS;
}
if( rv == CLI_RET_OK ) {
if( argc == 2 || module == BLADERF_MODULE_RX ) {
status = bladerf_get_frequency( state->dev, BLADERF_MODULE_RX, &freq );
if (status < 0) {
state->last_lib_error = status;
rv = CLI_RET_LIBBLADERF;
} else {
printf( "\n" );
printf( " RX Frequency: %10uHz\n", freq );
if( argc == 3 ) {
printf( "\n" );
}
}
}
if( argc == 2 || module == BLADERF_MODULE_TX ) {
status = bladerf_get_frequency( state->dev, BLADERF_MODULE_TX, &freq );
if (status < 0) {
state->last_lib_error = status;
rv = CLI_RET_LIBBLADERF;
} else {
if( argc == 3 ) {
printf( "\n" );
}
printf( " TX Frequency: %10uHz\n", freq );
printf( "\n" );
}
}
}
return rv;
}
static int set_and_check(struct bladerf *dev, bladerf_module m,
unsigned int freq)
{
int status;
unsigned int readback;
status = bladerf_set_frequency(dev, m, freq);
if (status != 0) {
PR_ERROR("Failed to set frequency: %u Hz: %s\n", freq,
bladerf_strerror(status));
return status;
}
status = bladerf_get_frequency(dev, m, &readback);
if (status != 0) {
PR_ERROR("Failed to get frequency: %s\n",
bladerf_strerror(status));
return status;
}
if (!freq_match(freq, readback)) {
PR_ERROR("Frequency (%u) != Readback value (%u)\n",
freq, readback);
return -1;
}
return status;
}
static inline int backup_and_update_settings(struct bladerf *dev,
bladerf_module module,
struct settings *settings)
{
int status;
status = bladerf_get_bandwidth(dev, module, &settings->bandwidth);
if (status != 0) {
return status;
}
status = bladerf_get_frequency(dev, module, &settings->frequency);
if (status != 0) {
return status;
}
status = bladerf_get_rational_sample_rate(dev, module,
&settings->samplerate);
if (status != 0) {
return status;
}
status = bladerf_set_bandwidth(dev, module, CAL_BANDWIDTH, NULL);
if (status != 0) {
return status;
}
status = bladerf_set_sample_rate(dev, module, CAL_SAMPLERATE, NULL);
return status;
}
double rf_blade_set_tx_freq(void *h, double freq)
{
rf_blade_handler_t *handler = (rf_blade_handler_t*) h;
uint32_t f_int = (uint32_t) round(freq);
int status = bladerf_set_frequency(handler->dev, BLADERF_MODULE_TX, f_int);
if (status != 0) {
fprintf(stderr, "Failed to set samplerate = %u: %s\n",
(uint32_t) freq, bladerf_strerror(status));
return -1;
}
f_int=0;
bladerf_get_frequency(handler->dev, BLADERF_MODULE_TX, &f_int);
printf("set TX frequency to %u\n", f_int);
return freq;
}
//! This gets called whenever a parameter is reconfigured
void BladeRfTxComponent::parameterHasChanged(std::string name)
{
try
{
if(name == "frequency") {
// Set center frequency
uint32_t actualValue;
int ret = bladerf_set_frequency(device_, BLADERF_MODULE_TX, frequency_x);
if (ret != 0) {
throw IrisException("Failed to set center frequency!");
}
bladerf_get_frequency(device_, BLADERF_MODULE_TX, &actualValue);
LOG(LINFO) << "Actual Tx center frequency is: " << actualValue << " Hz";
} else if(name == "rate") {
uint32_t actualValue;
int ret = bladerf_set_sample_rate(device_, BLADERF_MODULE_TX, (uint32_t)rate_x, &actualValue);
if (ret != 0) {
throw IrisException("Failed to set sample rate!");
}
LOG(LINFO) << "Actual Tx sample rate is: " << actualValue << " Hz";
} else if(name == "vga1gain") {
if (bladerf_set_txvga1(device_, vga1Gain_x) != 0) {
throw IrisException("Failed to set VGA1 gain!");
}
int actualGain;
bladerf_get_txvga1(device_, &actualGain);
LOG(LINFO) << "Actual VGA1 gain is " << actualGain << " dB";
} else if(name == "vga2gain") {
if (bladerf_set_txvga2(device_, vga2Gain_x) != 0) {
throw IrisException("Failed to set VGA2 gain!");
}
int actualGain;
bladerf_get_txvga2(device_, &actualGain);
LOG(LINFO) << "Actual VGA2 gain is " << actualGain << " dB";
}
}
catch(std::exception &e)
{
throw IrisException(e.what());
}
}
static int get_rx_cal_backup(struct bladerf *dev, struct rx_cal_backup *b)
{
int status;
status = bladerf_get_rational_sample_rate(dev, BLADERF_MODULE_RX,
&b->rational_sample_rate);
if (status != 0) {
return status;
}
status = bladerf_get_bandwidth(dev, BLADERF_MODULE_RX, &b->bandwidth);
if (status != 0) {
return status;
}
status = bladerf_get_frequency(dev, BLADERF_MODULE_TX, &b->tx_freq);
if (status != 0) {
return status;
}
return status;
}
int calibrate_dc_tx(struct cli_state *s,
int16_t *dc_i, int16_t *dc_q,
float *error_i, float *error_q)
{
int retval, status;
unsigned int rx_freq, tx_freq;
int16_t *rx_samples = NULL;
struct cal_tx_task tx_task;
struct point p0, p1, p2, p3;
struct point result;
status = bladerf_get_frequency(s->dev, BLADERF_MODULE_RX, &rx_freq);
if (status != 0) {
return status;
}
status = bladerf_get_frequency(s->dev, BLADERF_MODULE_TX, &tx_freq);
if (status != 0) {
return status;
}
rx_samples = (int16_t*) malloc(CAL_BUF_LEN * 2 * sizeof(rx_samples[0]));
if (rx_samples == NULL) {
return BLADERF_ERR_MEM;
}
status = init_tx_task(s, &tx_task);
if (status != 0) {
goto out;
}
status = bladerf_set_frequency(s->dev, BLADERF_MODULE_TX,
rx_freq + (CAL_SAMPLERATE / 4));
if (status != 0) {
goto out;
}
if (tx_freq < UPPER_BAND) {
status = bladerf_set_loopback(s->dev, BLADERF_LB_RF_LNA1);
} else {
status = bladerf_set_loopback(s->dev, BLADERF_LB_RF_LNA2);
}
if (status != 0) {
goto out;
}
/* Ensure old samples are flushed */
status = bladerf_enable_module(s->dev, BLADERF_MODULE_RX, false);
if (status != 0) {
goto out;
}
status = bladerf_enable_module(s->dev, BLADERF_MODULE_TX, false);
if (status != 0) {
goto out;
}
status = bladerf_sync_config(s->dev, BLADERF_MODULE_RX,
BLADERF_FORMAT_SC16_Q11,
CAL_NUM_BUFS, CAL_BUF_LEN,
CAL_NUM_XFERS, CAL_TIMEOUT);
if (status != 0) {
goto out;
}
status = bladerf_sync_config(s->dev, BLADERF_MODULE_TX,
BLADERF_FORMAT_SC16_Q11,
CAL_NUM_BUFS, CAL_BUF_LEN,
CAL_NUM_XFERS, CAL_TIMEOUT);
if (status != 0) {
goto out;
}
status = bladerf_enable_module(s->dev, BLADERF_MODULE_RX, true);
if (status != 0) {
goto out;
}
status = bladerf_enable_module(s->dev, BLADERF_MODULE_TX, true);
if (status != 0) {
goto out;
}
status = start_tx_task(&tx_task);
if (status != 0) {
goto out;
}
/* Sample the results of 4 points, which should yield 2 intersecting lines,
* for 4 different DC offset settings of the I channel */
p0.x = -2048;
p1.x = -512;
p2.x = 512;
p3.x = 2048;
status = rx_avg_magnitude(s->dev, rx_samples, (int16_t) p0.x, 0, &p0.y);
if (status != 0) {
goto out;
}
status = rx_avg_magnitude(s->dev, rx_samples, (int16_t) p1.x, 0, &p1.y);
if (status != 0) {
goto out;
}
status = rx_avg_magnitude(s->dev, rx_samples, (int16_t) p2.x, 0, &p2.y);
if (status != 0) {
goto out;
}
status = rx_avg_magnitude(s->dev, rx_samples, (int16_t) p3.x, 0, &p3.y);
if (status != 0) {
goto out;
}
status = intersection(s, &p0, &p1, &p2, &p3, &result);
if (status != 0) {
goto out;
}
if (result.x < CAL_DC_MIN || result.x > CAL_DC_MAX) {
cli_err(s, "Error", "Obtained out-of-range TX I DC cal value (%f).\n",
result.x);
status = BLADERF_ERR_UNEXPECTED;
goto out;
}
*dc_i = (int16_t) (result.x + 0.5);
*error_i = result.y;
status = set_tx_dc(s->dev, *dc_i, 0);
if (status != 0) {
goto out;
}
/* Repeat for the Q channel */
status = rx_avg_magnitude(s->dev, rx_samples, *dc_i, (int16_t) p0.x, &p0.y);
if (status != 0) {
goto out;
}
status = rx_avg_magnitude(s->dev, rx_samples, *dc_i, (int16_t) p1.x, &p1.y);
if (status != 0) {
goto out;
}
status = rx_avg_magnitude(s->dev, rx_samples, *dc_i, (int16_t) p2.x, &p2.y);
if (status != 0) {
goto out;
}
status = rx_avg_magnitude(s->dev, rx_samples, *dc_i, (int16_t) p3.x, &p3.y);
if (status != 0) {
goto out;
}
status = intersection(s, &p0, &p1, &p2, &p3, &result);
if (status != 0) {
goto out;
}
*dc_q = (int16_t) (result.x + 0.5);
*error_q = result.y;
status = set_tx_dc(s->dev, *dc_i, *dc_q);
out:
retval = status;
status = stop_tx_task(&tx_task);
retval = first_error(retval, status);
free(rx_samples);
free(tx_task.samples);
status = bladerf_enable_module(s->dev, BLADERF_MODULE_TX, false);
retval = first_error(retval, status);
/* Restore RX frequency */
status = bladerf_set_frequency(s->dev, BLADERF_MODULE_TX, tx_freq);
retval = first_error(retval, status);
return retval;
}
//! Do any initialization required
void BladeRfTxComponent::initialize()
{
// Set up the input DataBuffer
inBuf_ = castToType< complex<float> >(inputBuffers.at(0));
// Initialize raw sample vector to some multiple of block size
rawSampleBuffer_.data.resize(128 * BLADERF_SAMPLE_BLOCK_SIZE);
// Set up the BladeRF
try
{
// Create the device
LOG(LINFO) << "Trying to open device " << deviceName_x;
int ret = bladerf_open(&device_, deviceName_x.c_str());
if (ret != 0) {
throw IrisException("Failed to open bladeRF device!");
}
// Check whether FPGA is configured yet
if (bladerf_is_fpga_configured(device_) != 1 ) {
// try to load FPGA image
if (not fpgaImage_x.empty()) {
ret = bladerf_load_fpga(device_, fpgaImage_x.c_str());
if (ret != 0) {
throw IrisException("Failed to load FPGA to bladeRF!");
} else {
LOG(LINFO) << "FPGA image successfully loaded.";
}
} else {
throw IrisException("BladeRF FPGA is not configured and no FPGA image given!");
}
}
// Print some information about device
struct bladerf_version version;
if (bladerf_fw_version(device_, &version) == 0) {
LOG(LINFO) << "Using FW " << version.describe;
}
if (bladerf_fpga_version(device_, &version) == 0) {
LOG(LINFO) << "Using FPGA " << version.describe;
}
if (bladerf_is_fpga_configured(device_) != 1 ) {
throw IrisException("BladeRF FPGA is not configured!");
}
// setting up sync config
ret = bladerf_sync_config(device_,
BLADERF_MODULE_TX,
BLADERF_FORMAT_SC16_Q11,
BLADERF_DEFAULT_STREAM_BUFFERS,
BLADERF_DEFAULT_STREAM_SAMPLES,
BLADERF_DEFAULT_STREAM_XFERS,
BLADERF_SYNC_TIMEOUT_MS);
if (ret != 0) {
throw IrisException("Couldn't enable BladeRF Tx sync handle!");
LOG(LERROR) << bladerf_strerror(ret);
}
// Turn on transmitter
ret = bladerf_enable_module(device_, BLADERF_MODULE_TX, true);
if ( ret != 0 ) {
throw IrisException("Couldn't enable BladeRF Tx module!");
}
// Set sample rate
uint32_t actualValue;
ret = bladerf_set_sample_rate(device_, BLADERF_MODULE_TX, (uint32_t)rate_x, &actualValue);
if (ret != 0) {
throw IrisException("Failed to set sample rate!");
}
LOG(LINFO) << "Actual Tx sample rate is: " << actualValue << " Hz";
// Set center frequency
ret = bladerf_set_frequency(device_, BLADERF_MODULE_TX, frequency_x);
if (ret != 0) {
throw IrisException("Failed to set center frequency!");
}
bladerf_get_frequency(device_, BLADERF_MODULE_TX, &actualValue);
LOG(LINFO) << "Actual Tx center frequency is: " << actualValue << " Hz";
// Set bandwidth
ret = bladerf_set_bandwidth(device_, BLADERF_MODULE_TX, bw_x, &actualValue);
if (ret != 0) {
throw IrisException("Failed to set receive bandwidth!");
}
LOG(LINFO) << "Actual Tx bandwidth is " << actualValue << " Hz";
// Set VGA1 gain
int actualGain;
ret = bladerf_set_txvga1(device_, vga1Gain_x);
if (ret != 0) {
throw IrisException("Failed to set VGA1 gain!");
}
bladerf_get_txvga1(device_, &actualGain);
LOG(LINFO) << "Actual VGA1 gain is " << actualGain << " dB";
// Set VGA2 gain
ret = bladerf_set_txvga2(device_, vga2Gain_x);
if (ret != 0) {
throw IrisException("Failed to set VGA2 gain!");
}
bladerf_get_txvga2(device_, &actualGain);
LOG(LINFO) << "Actual VGA2 gain is " << actualGain << " dB";
}
catch(const boost::exception &e)
{
throw IrisException(boost::diagnostic_information(e));
}
catch(std::exception& e)
{
throw IrisException(e.what());
}
}
