Skip to content
Permalink
Branch: master
Find file Copy path
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
1745 lines (1385 sloc) 45.3 KB
/**
* This file is part of the bladeRF project:
* http://www.github.com/nuand/bladeRF
*
* Copyright (c) 2015 Nuand LLC
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
* This program 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 Affero General Public License for more details.
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <inttypes.h>
#include <limits.h>
#define _USE_MATH_DEFINES /* Required for MSVC */
#include <math.h>
#include <libbladeRF.h>
#include "dc_calibration.h"
#include "conversions.h"
struct complexf {
float i;
float q;
};
struct gain_mode {
bladerf_lna_gain lna_gain;
int rxvga1, rxvga2;
};
/*******************************************************************************
* Debug items
******************************************************************************/
/* Enable this to print diagnostic and debug information */
//#define ENABLE_DC_CALIBRATION_DEBUG
//#define ENABLE_DC_CALIBRATION_VERBOSE
#ifndef PR_DBG
# ifdef ENABLE_DC_CALIBRATION_DEBUG
# define PR_DBG(...) fprintf(stderr, " " __VA_ARGS__)
# else
# define PR_DBG(...) do {} while (0)
# endif
#endif
#ifndef PR_VERBOSE
# ifdef ENABLE_DC_CALIBRATION_VERBOSE
# define PR_VERBOSE(...) fprintf(stderr, " " __VA_ARGS__)
# else
# define PR_VERBOSE(...) do {} while (0)
# endif
#endif
/*******************************************************************************
* Debug routines for saving samples
******************************************************************************/
//#define ENABLE_SAVE_SC16Q11
#ifdef ENABLE_SAVE_SC16Q11
static void save_sc16q11(const char *name, int16_t *samples, unsigned int count)
{
FILE *out = fopen(name, "wb");
if (!out) {
return;
}
fwrite(samples, 2 * sizeof(samples[0]), count, out);
fclose(out);
}
#else
# define save_sc16q11(name, samples, count) do {} while (0)
#endif
//#define ENABLE_SAVE_COMPLEXF
#ifdef ENABLE_SAVE_COMPLEXF
static void save_complexf(const char *name, struct complexf *samples,
unsigned int count)
{
unsigned int n;
FILE *out = fopen(name, "wb");
if (!out) {
return;
}
for (n = 0; n < count; n++) {
fwrite(&samples[n].i, sizeof(samples[n].i), 1, out);
fwrite(&samples[n].q, sizeof(samples[n].q), 1, out);
}
fclose(out);
}
#else
# define save_complexf(name, samples, count) do {} while (0)
#endif
/*******************************************************************************
* LMS6002D DC offset calibration
******************************************************************************/
/* We've found that running samples through the LMS6 tends to be required
* for the TX LPF calibration to converge */
static inline int tx_lpf_dummy_tx(struct bladerf *dev)
{
int status;
int retval = 0;
struct bladerf_metadata meta;
int16_t zero_sample[] = { 0, 0 };
bladerf_loopback loopback_backup;
struct bladerf_rational_rate sample_rate_backup;
memset(&meta, 0, sizeof(meta));
status = bladerf_get_loopback(dev, &loopback_backup);
if (status != 0) {
return status;
}
status = bladerf_get_rational_sample_rate(dev, BLADERF_MODULE_TX,
&sample_rate_backup);
if (status != 0) {
return status;
}
status = bladerf_set_loopback(dev, BLADERF_LB_BB_TXVGA1_RXVGA2);
if (status != 0) {
goto out;
}
status = bladerf_set_sample_rate(dev, BLADERF_MODULE_TX, 3000000, NULL);
if (status != 0) {
goto out;
}
status = bladerf_sync_config(dev, BLADERF_MODULE_TX,
BLADERF_FORMAT_SC16_Q11_META,
64, 16384, 16, 1000);
if (status != 0) {
goto out;
}
status = bladerf_enable_module(dev, BLADERF_MODULE_TX, true);
if (status != 0) {
goto out;
}
meta.flags = BLADERF_META_FLAG_TX_BURST_START |
BLADERF_META_FLAG_TX_BURST_END |
BLADERF_META_FLAG_TX_NOW;
status = bladerf_sync_tx(dev, zero_sample, 1, &meta, 2000);
if (status != 0) {
goto out;
}
out:
status = bladerf_enable_module(dev, BLADERF_MODULE_TX, false);
if (status != 0 && retval == 0) {
retval = status;
}
status = bladerf_set_rational_sample_rate(dev, BLADERF_MODULE_TX,
&sample_rate_backup, NULL);
if (status != 0 && retval == 0) {
retval = status;
}
status = bladerf_set_loopback(dev, loopback_backup);
if (status != 0 && retval == 0) {
retval = status;
}
return retval;
}
static int cal_tx_lpf(struct bladerf *dev)
{
int status;
status = tx_lpf_dummy_tx(dev);
if (status == 0) {
status = bladerf_calibrate_dc(dev, BLADERF_DC_CAL_TX_LPF);
}
return status;
}
int dc_calibration_lms6(struct bladerf *dev, const char *module_str)
{
int status;
bladerf_cal_module module;
if (!strcasecmp(module_str, "all")) {
status = bladerf_calibrate_dc(dev, BLADERF_DC_CAL_LPF_TUNING);
if (status != 0) {
return status;
}
status = cal_tx_lpf(dev);
if (status != 0) {
return status;
}
status = bladerf_calibrate_dc(dev, BLADERF_DC_CAL_RX_LPF);
if (status != 0) {
return status;
}
status = bladerf_calibrate_dc(dev, BLADERF_DC_CAL_RXVGA2);
} else {
module = str_to_bladerf_cal_module(module_str);
if (module == BLADERF_DC_CAL_INVALID) {
return BLADERF_ERR_INVAL;
}
if (module == BLADERF_DC_CAL_TX_LPF) {
status = cal_tx_lpf(dev);
} else {
status = bladerf_calibrate_dc(dev, module);
}
}
return status;
}
/*******************************************************************************
* Shared utility routines
******************************************************************************/
/* Round float to int16_t */
static inline int16_t float_to_int16(float val)
{
if ((val - 0.5) <= INT16_MIN) {
return INT16_MIN;
}
if ((val + 0.5) >= INT16_MAX) {
return INT16_MAX;
}
return val >= 0 ? (int16_t)(val + 0.5) : (int16_t)(val - 0.5);
}
/* Convert ms to samples */
#define MS_TO_SAMPLES(ms_, rate_) (\
(unsigned int) (ms_ * ((uint64_t) rate_) / 1000) \
)
/* RX samples, retrying if the machine is struggling to keep up. */
static int rx_samples(struct bladerf *dev, int16_t *samples,
unsigned int count, uint64_t *ts, uint64_t ts_inc)
{
int status = 0;
struct bladerf_metadata meta;
int retry = 0;
const int max_retries = 10;
bool overrun = true;
memset(&meta, 0, sizeof(meta));
meta.timestamp = *ts;
while (status == 0 && overrun && retry < max_retries) {
meta.timestamp = *ts;
status = bladerf_sync_rx(dev, samples, count, &meta, 2000);
if (status == BLADERF_ERR_TIME_PAST) {
status = bladerf_get_timestamp(dev, BLADERF_MODULE_RX, ts);
if (status != 0) {
return status;
} else {
*ts += 20 * ts_inc;
retry++;
status = 0;
}
} else if (status == 0) {
overrun = (meta.flags & BLADERF_META_STATUS_OVERRUN) != 0;
if (overrun) {
*ts += count + ts_inc;
retry++;
}
} else {
return status;
}
}
if (retry >= max_retries) {
status = BLADERF_ERR_IO;
} else if (status == 0) {
*ts += count + ts_inc;
}
return status;
}
/*******************************************************************************
* RX DC offset calibration
******************************************************************************/
#define RX_CAL_RATE (3000000)
#define RX_CAL_BW (1500000)
#define RX_CAL_TS_INC (MS_TO_SAMPLES(15, RX_CAL_RATE))
#define RX_CAL_COUNT (MS_TO_SAMPLES(5, RX_CAL_RATE))
#define RX_CAL_MAX_SWEEP_LEN (2 * 2048 / 32) /* -2048 : 32 : 2048 */
struct rx_cal {
struct bladerf *dev;
int16_t *samples;
unsigned int num_samples;
int16_t *corr_sweep;
uint64_t ts;
uint64_t tx_freq;
};
struct rx_cal_backup {
struct bladerf_rational_rate rational_sample_rate;
unsigned int bandwidth;
uint64_t tx_freq;
};
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;
}
static int set_rx_cal_backup(struct bladerf *dev, struct rx_cal_backup *b)
{
int status;
int retval = 0;
status = bladerf_set_rational_sample_rate(dev, BLADERF_MODULE_RX,
&b->rational_sample_rate, NULL);
if (status != 0 && retval == 0) {
retval = status;
}
status = bladerf_set_bandwidth(dev, BLADERF_MODULE_RX, b->bandwidth, NULL);
if (status != 0 && retval == 0) {
retval = status;
}
status = bladerf_set_frequency(dev, BLADERF_MODULE_TX, b->tx_freq);
if (status != 0 && retval == 0) {
retval = status;
}
return retval;
}
/* Ensure TX >= 1 MHz away from the RX frequency to avoid any potential
* artifacts from the PLLs interfering with one another */
static int rx_cal_update_frequency(struct rx_cal *cal, uint64_t rx_freq)
{
int status = 0;
uint64_t f_diff;
if (rx_freq < cal->tx_freq) {
f_diff = cal->tx_freq - rx_freq;
} else {
f_diff = rx_freq - cal->tx_freq;
}
PR_DBG("Set F_RX = %u\n", rx_freq);
PR_DBG("F_diff(RX, TX) = %u\n", f_diff);
if (f_diff < 1000000) {
if (rx_freq >= (BLADERF_FREQUENCY_MIN + 1000000)) {
cal->tx_freq = rx_freq - 1000000;
} else {
cal->tx_freq = rx_freq + 1000000;
}
status = bladerf_set_frequency(cal->dev, BLADERF_MODULE_TX,
cal->tx_freq);
if (status != 0) {
return status;
}
PR_DBG("Adjusted TX frequency: %u\n", cal->tx_freq);
}
status = bladerf_set_frequency(cal->dev, BLADERF_MODULE_RX, rx_freq);
if (status != 0) {
return status;
}
cal->ts += RX_CAL_TS_INC;
return status;
}
static inline void sample_mean(int16_t *samples, size_t count,
float *mean_i, float *mean_q)
{
int64_t accum_i = 0;
int64_t accum_q = 0;
size_t n;
if (count == 0) {
assert(!"Invalid count (0) provided to sample_mean()");
*mean_i = 0;
*mean_q = 0;
return;
}
for (n = 0; n < (2 * count); n += 2) {
accum_i += samples[n];
accum_q += samples[n + 1];
}
*mean_i = ((float) accum_i) / count;
*mean_q = ((float) accum_q) / count;
}
static inline int set_rx_dc_corr(struct bladerf *dev, int16_t i, int16_t q)
{
int status;
status = bladerf_set_correction(dev, BLADERF_MODULE_RX,
BLADERF_CORR_LMS_DCOFF_I, i);
if (status != 0) {
return status;
}
status = bladerf_set_correction(dev, BLADERF_MODULE_RX,
BLADERF_CORR_LMS_DCOFF_Q, q);
return status;
}
/* Get the mean for one of the coarse estimate points. If it seems that this
* value might be (or close) causing us to clamp, adjust it and retry */
static int rx_cal_coarse_means(struct rx_cal *cal, int16_t *corr_value,
float *mean_i, float *mean_q)
{
int status;
const int16_t mean_limit_high = 2000;
const int16_t mean_limit_low = -mean_limit_high;
const int16_t corr_limit = 128;
bool retry = false;
do {
status = set_rx_dc_corr(cal->dev, *corr_value, *corr_value);
if (status != 0) {
return status;
}
status = rx_samples(cal->dev, cal->samples, cal->num_samples,
&cal->ts, RX_CAL_TS_INC);
if (status != 0) {
return status;
}
sample_mean(cal->samples, cal->num_samples, mean_i, mean_q);
if (*mean_i > mean_limit_high || *mean_q > mean_limit_high ||
*mean_i < mean_limit_low || *mean_q < mean_limit_low ) {
if (*corr_value < 0) {
retry = (*corr_value <= -corr_limit);
} else {
retry = (*corr_value >= corr_limit);
}
if (retry) {
PR_DBG("Coarse estimate point Corr=%4d yields extreme means: "
"(%4f, %4f). Retrying...\n",
*corr_value, *mean_i, *mean_q);
*corr_value = *corr_value / 2;
}
} else {
retry = false;
}
} while (retry);
if (retry) {
PR_DBG("Non-ideal values are being used.\n");
}
return 0;
}
/* Estimate the DC correction values that yield zero DC offset via a linear
* approximation */
static int rx_cal_coarse_estimate(struct rx_cal *cal,
int16_t *i_est, int16_t *q_est)
{
int status;
int16_t x1 = -2048;
int16_t x2 = 2048;
float y1i, y1q, y2i, y2q;
float mi, mq;
float bi, bq;
float i_guess, q_guess;
status = rx_cal_coarse_means(cal, &x1, &y1i, &y1q);
if (status != 0) {
*i_est = 0;
*q_est = 0;
return status;
}
PR_VERBOSE("Means for x1=%d: y1i=%f, y1q=%f\n", x1, y1i, y1q);
status = rx_cal_coarse_means(cal, &x2, &y2i, &y2q);
if (status != 0) {
*i_est = 0;
*q_est = 0;
return status;
}
PR_VERBOSE("Means for x2: y2i=%f, y2q=%f\n", y2i, y2q);
mi = (y2i - y1i) / (x2 - x1);
mq = (y2q - y1q) / (x2 - x1);
bi = y1i - mi * x1;
bq = y1q - mq * x1;
PR_VERBOSE("mi=%f, bi=%f, mq=%f, bq=%f\n", mi, bi, mq, bq);
i_guess = -bi/mi + 0.5f;
if (i_guess < -2048) {
i_guess = -2048;
} else if (i_guess > 2048) {
i_guess = 2048;
}
q_guess = -bq/mq + 0.5f;
if (q_guess < -2048) {
q_guess = -2048;
} else if (q_guess > 2048) {
q_guess = 2048;
}
*i_est = (int16_t) i_guess;
*q_est = (int16_t) q_guess;
PR_DBG("Coarse estimate: I=%d, Q=%d\n", *i_est, *q_est);
return 0;
}
static void init_rx_cal_sweep(int16_t *corr, unsigned int *sweep_len,
int16_t i_est, int16_t q_est)
{
unsigned int actual_len = 0;
unsigned int i;
int16_t sweep_min, sweep_max, sweep_val;
/* LMS6002D RX DC calibrations have a limited range. libbladeRF throws away
* the lower 5 bits. */
const int16_t sweep_inc = 32;
const int16_t min_est = (i_est < q_est) ? i_est : q_est;
const int16_t max_est = (i_est > q_est) ? i_est : q_est;
sweep_min = min_est - 12 * 32;
if (sweep_min < -2048) {
sweep_min = -2048;
}
sweep_max = max_est + 12 * 32;
if (sweep_max > 2048) {
sweep_max = 2048;
}
/* Given that these lower bits are thrown away, it can be confusing to
* see that values change in their LSBs that don't matter. Therefore,
* we'll adjust to muliples of sweep_inc */
sweep_min = (sweep_min / 32) * 32;
sweep_max = (sweep_max / 32) * 32;
PR_DBG("Sweeping [%d : %d : %d]\n", sweep_min, sweep_inc, sweep_max);
sweep_val = sweep_min;
for (i = 0; sweep_val < sweep_max && i < RX_CAL_MAX_SWEEP_LEN; i++) {
corr[i] = sweep_val;
sweep_val += sweep_inc;
actual_len++;
}
*sweep_len = actual_len;
}
static int save_gains(struct rx_cal *cal, struct gain_mode *gain) {
int status;
status = bladerf_get_lna_gain(cal->dev, &gain->lna_gain);
if (status != 0) {
return status;
}
status = bladerf_get_rxvga1(cal->dev, &gain->rxvga1);
if (status != 0) {
return status;
}
status = bladerf_get_rxvga2(cal->dev, &gain->rxvga2);
if (status != 0) {
return status;
}
return status;
}
static int load_gains(struct rx_cal *cal, struct gain_mode *gain) {
int status;
status = bladerf_set_lna_gain(cal->dev, gain->lna_gain);
if (status != 0) {
return status;
}
status = bladerf_set_rxvga1(cal->dev, gain->rxvga1);
if (status != 0) {
return status;
}
status = bladerf_set_rxvga2(cal->dev, gain->rxvga2);
if (status != 0) {
return status;
}
return status;
}
static int rx_cal_dc_off(struct rx_cal *cal, struct gain_mode *gains,
int16_t *dc_i, int16_t *dc_q)
{
int status = BLADERF_ERR_UNEXPECTED;
float mean_i, mean_q;
status = load_gains(cal, gains);
if (status != 0) {
return status;
}
status = rx_samples(cal->dev, cal->samples, cal->num_samples,
&cal->ts, RX_CAL_TS_INC);
if (status != 0) {
return status;
}
sample_mean(cal->samples, cal->num_samples, &mean_i, &mean_q);
*dc_i = float_to_int16(mean_i);
*dc_q = float_to_int16(mean_q);
return 0;
}
static int rx_cal_sweep(struct rx_cal *cal,
int16_t *corr, unsigned int sweep_len,
int16_t *result_i, int16_t *result_q,
float *error_i, float *error_q)
{
int status = BLADERF_ERR_UNEXPECTED;
unsigned int n;
int16_t min_corr_i = 0;
int16_t min_corr_q = 0;
float mean_i, mean_q;
float min_val_i, min_val_q;
min_val_i = min_val_q = 2048;
for (n = 0; n < sweep_len; n++) {
status = set_rx_dc_corr(cal->dev, corr[n], corr[n]);
if (status != 0) {
return status;
}
status = rx_samples(cal->dev, cal->samples, cal->num_samples,
&cal->ts, RX_CAL_TS_INC);
if (status != 0) {
return status;
}
sample_mean(cal->samples, cal->num_samples, &mean_i, &mean_q);
PR_VERBOSE(" Corr=%4d, Mean_I=%4.2f, Mean_Q=%4.2f\n",
corr[n], mean_i, mean_q);
/* Not using fabs() to avoid adding a -lm dependency */
if (mean_i < 0) {
mean_i = -mean_i;
}
if (mean_q < 0) {
mean_q = -mean_q;
}
if (mean_i < min_val_i) {
min_val_i = mean_i;
min_corr_i = corr[n];
}
if (mean_q < min_val_q) {
min_val_q = mean_q;
min_corr_q = corr[n];
}
}
*result_i = min_corr_i;
*result_q = min_corr_q;
*error_i = min_val_i;
*error_q = min_val_q;
return 0;
}
static int perform_rx_cal(struct rx_cal *cal, struct dc_calibration_params *p)
{
int status;
int16_t i_est, q_est;
unsigned int sweep_len = RX_CAL_MAX_SWEEP_LEN;
struct gain_mode saved_gains;
struct gain_mode agc_gains[] = {
{ .lna_gain = BLADERF_LNA_GAIN_MAX, .rxvga1 = 30, .rxvga2 = 15 }, /* AGC Max Gain */
{ .lna_gain = BLADERF_LNA_GAIN_MID, .rxvga1 = 30, .rxvga2 = 0 }, /* AGC Mid Gain */
{ .lna_gain = BLADERF_LNA_GAIN_MID, .rxvga1 = 12, .rxvga2 = 0 } /* AGC Min Gain */
};
status = rx_cal_update_frequency(cal, p->frequency);
if (status != 0) {
return status;
}
/* Get an initial guess at our correction values */
status = rx_cal_coarse_estimate(cal, &i_est, &q_est);
if (status != 0) {
return status;
}
/* Perform a finer sweep of correction values */
init_rx_cal_sweep(cal->corr_sweep, &sweep_len, i_est, q_est);
/* Advance our timestmap just to account for any time we may have lost */
cal->ts += RX_CAL_TS_INC;
status = rx_cal_sweep(cal, cal->corr_sweep, sweep_len,
&p->corr_i, &p->corr_q,
&p->error_i, &p->error_q);
if (status != 0) {
return status;
}
/* Apply the nominal correction values */
status = set_rx_dc_corr(cal->dev, p->corr_i, p->corr_q);
if (status != 0) {
return status;
}
bladerf_fpga_size fpga_size;
status = bladerf_get_fpga_size(cal->dev, &fpga_size);
if (status != 0) {
return status;
}
if (fpga_size != BLADERF_FPGA_40KLE &&
fpga_size != BLADERF_FPGA_115KLE) {
return 0;
}
/* Measure DC correction for AGC */
status = save_gains(cal, &saved_gains);
if (status != 0) {
return status;
}
status = rx_cal_dc_off(cal, &agc_gains[2], &p->min_dc_i, &p->min_dc_q);
if (status != 0) {
return status;
}
status = rx_cal_dc_off(cal, &agc_gains[1], &p->mid_dc_i, &p->mid_dc_q);
if (status != 0) {
return status;
}
status = rx_cal_dc_off(cal, &agc_gains[0], &p->max_dc_i, &p->max_dc_q);
if (status != 0) {
return status;
}
status = load_gains(cal, &saved_gains);
return status;
}
static int rx_cal_init_state(struct bladerf *dev,
const struct rx_cal_backup *backup,
struct rx_cal *state)
{
int status;
state->dev = dev;
state->num_samples = RX_CAL_COUNT;
state->samples = malloc(2 * sizeof(state->samples[0]) * RX_CAL_COUNT);
if (state->samples == NULL) {
return BLADERF_ERR_MEM;
}
state->corr_sweep = malloc(sizeof(state->corr_sweep[0]) * RX_CAL_MAX_SWEEP_LEN);
if (state->corr_sweep == NULL) {
return BLADERF_ERR_MEM;
}
state->tx_freq = backup->tx_freq;
status = bladerf_get_timestamp(dev, BLADERF_MODULE_RX, &state->ts);
if (status != 0) {
return status;
}
/* Schedule first RX well into the future */
state->ts += 20 * RX_CAL_TS_INC;
return status;
}
static int rx_cal_init(struct bladerf *dev)
{
int status;
status = bladerf_set_sample_rate(dev, BLADERF_MODULE_RX, RX_CAL_RATE, NULL);
if (status != 0) {
return status;
}
status = bladerf_set_bandwidth(dev, BLADERF_MODULE_RX, RX_CAL_BW, NULL);
if (status != 0) {
return status;
}
status = bladerf_sync_config(dev, BLADERF_MODULE_RX,
BLADERF_FORMAT_SC16_Q11_META,
64, 16384, 16, 1000);
if (status != 0) {
return status;
}
status = bladerf_enable_module(dev, BLADERF_MODULE_RX, true);
if (status != 0) {
return status;
}
return status;
}
int dc_calibration_rx(struct bladerf *dev,
struct dc_calibration_params *params,
size_t params_count, bool print_status)
{
int status = 0;
int retval = 0;
struct rx_cal state;
struct rx_cal_backup backup;
size_t i;
memset(&state, 0, sizeof(state));
status = get_rx_cal_backup(dev, &backup);
if (status != 0) {
return status;
}
status = rx_cal_init(dev);
if (status != 0) {
goto out;
}
status = rx_cal_init_state(dev, &backup, &state);
if (status != 0) {
goto out;
}
for (i = 0; i < params_count && status == 0; i++) {
status = perform_rx_cal(&state, &params[i]);
if (status == 0 && print_status) {
# ifdef DEBUG_DC_CALIBRATION
const char sol = '\n';
const char eol = '\n';
# else
const char sol = '\r';
const char eol = '\0';
# endif
printf("%cCalibrated @ %10" PRIu64 " Hz: I=%4d (Error: %4.2f), "
"Q=%4d (Error: %4.2f) ",
sol,
params[i].frequency,
params[i].corr_i, params[i].error_i,
params[i].corr_q, params[i].error_q);
printf("DC-LUT: Max (I=%3d, Q=%3d) Mid (I=%3d, Q=%3d)"
" Min (I=%3d, Q=%3d)%c",
params[i].max_dc_i, params[i].max_dc_q, params[i].mid_dc_i, params[i].mid_dc_q,
params[i].min_dc_i, params[i].min_dc_q, eol);
fflush(stdout);
}
}
if (print_status) {
putchar('\n');
}
out:
free(state.samples);
free(state.corr_sweep);
retval = status;
status = bladerf_enable_module(dev, BLADERF_MODULE_RX, false);
if (status != 0 && retval == 0) {
retval = status;
}
status = set_rx_cal_backup(dev, &backup);
if (status != 0 && retval == 0) {
retval = status;
}
return retval;
}
/*******************************************************************************
* TX DC offset calibration
******************************************************************************/
#define TX_CAL_RATE (4000000)
#define TX_CAL_RX_BW (3000000)
#define TX_CAL_RX_LNA (BLADERF_LNA_GAIN_MAX)
#define TX_CAL_RX_VGA1 (25)
#define TX_CAL_RX_VGA2 (0)
#define TX_CAL_TX_BW (1500000)
#define TX_CAL_TS_INC (MS_TO_SAMPLES(15, TX_CAL_RATE))
#define TX_CAL_COUNT (MS_TO_SAMPLES(5, TX_CAL_RATE))
#define TX_CAL_CORR_SWEEP_LEN (4096 / 16) /* -2048:16:2048 */
#define TX_CAL_DEFAULT_LB (BLADERF_LB_RF_LNA1)
struct tx_cal_backup {
uint64_t rx_freq;
struct bladerf_rational_rate rx_sample_rate;
unsigned int rx_bandwidth;
bladerf_lna_gain rx_lna;
int rx_vga1;
int rx_vga2;
struct bladerf_rational_rate tx_sample_rate;
unsigned int tx_bandwidth;
bladerf_loopback loopback;
};
struct tx_cal {
struct bladerf *dev;
int16_t *samples; /* Raw samples */
unsigned int num_samples; /* Number of raw samples */
struct complexf *filt; /* Filter state */
struct complexf *filt_out; /* Filter output */
struct complexf *post_mix; /* Post-filter, mixed to baseband */
int16_t *sweep; /* Correction sweep */
float *mag; /* Magnitude results from sweep */
uint64_t ts; /* Timestamp */
bladerf_loopback loopback; /* Current loopback mode */
bool rx_low; /* RX tuned lower than TX */
};
/* Filter used to isolate contribution of TX LO leakage in received
* signal. 15th order Equiripple FIR with Fs=4e6, Fpass=1, Fstop=1e6
*/
static const float tx_cal_filt[] = {
0.000327949366768f, 0.002460188536582f, 0.009842382390924f,
0.027274728394777f, 0.057835200476419f, 0.098632713294830f,
0.139062540460741f, 0.164562494987592f, 0.164562494987592f,
0.139062540460741f, 0.098632713294830f, 0.057835200476419f,
0.027274728394777f, 0.009842382390924f, 0.002460188536582f,
0.000327949366768f,
};
static const unsigned int tx_cal_filt_num_taps =
(sizeof(tx_cal_filt) / sizeof(tx_cal_filt[0]));
static inline int set_tx_dc_corr(struct bladerf *dev, int16_t i, int16_t q)
{
int status;
status = bladerf_set_correction(dev, BLADERF_MODULE_TX,
BLADERF_CORR_LMS_DCOFF_I, i);
if (status != 0) {
return status;
}
status = bladerf_set_correction(dev, BLADERF_MODULE_TX,
BLADERF_CORR_LMS_DCOFF_Q, q);
return status;
}
static int get_tx_cal_backup(struct bladerf *dev, struct tx_cal_backup *b)
{
int status;
status = bladerf_get_frequency(dev, BLADERF_MODULE_RX, &b->rx_freq);
if (status != 0) {
return status;
}
status = bladerf_get_rational_sample_rate(dev, BLADERF_MODULE_RX,
&b->rx_sample_rate);
if (status != 0) {
return status;
}
status = bladerf_get_bandwidth(dev, BLADERF_MODULE_RX, &b->rx_bandwidth);
if (status != 0) {
return status;
}
status = bladerf_get_lna_gain(dev, &b->rx_lna);
if (status != 0) {
return status;
}
status = bladerf_get_rxvga1(dev, &b->rx_vga1);
if (status != 0) {
return status;
}
status = bladerf_get_rxvga2(dev, &b->rx_vga2);
if (status != 0) {
return status;
}
status = bladerf_get_rational_sample_rate(dev, BLADERF_MODULE_TX,
&b->tx_sample_rate);
if (status != 0) {
return status;
}
status = bladerf_get_loopback(dev, &b->loopback);
return status;
}
static int set_tx_cal_backup(struct bladerf *dev, struct tx_cal_backup *b)
{
int status;
int retval = 0;
status = bladerf_set_loopback(dev, b->loopback);
if (status != 0 && retval == 0) {
retval = status;
}
status = bladerf_set_frequency(dev, BLADERF_MODULE_RX, b->rx_freq);
if (status != 0 && retval == 0) {
retval = status;
}
status = bladerf_set_rational_sample_rate(dev, BLADERF_MODULE_RX,
&b->rx_sample_rate, NULL);
if (status != 0 && retval == 0) {
retval = status;
}
status = bladerf_set_bandwidth(dev, BLADERF_MODULE_RX,
b->rx_bandwidth, NULL);
if (status != 0 && retval == 0) {
retval = status;
}
status = bladerf_set_lna_gain(dev, b->rx_lna);
if (status != 0 && retval == 0) {
retval = status;
}
status = bladerf_set_rxvga1(dev, b->rx_vga1);
if (status != 0 && retval == 0) {
retval = status;
}
status = bladerf_set_rxvga2(dev, b->rx_vga2);
if (status != 0 && retval == 0) {
retval = status;
}
status = bladerf_set_rational_sample_rate(dev, BLADERF_MODULE_TX,
&b->tx_sample_rate, NULL);
if (status != 0 && retval == 0) {
retval = status;
}
return retval;
}
static int tx_cal_update_frequency(struct tx_cal *state, uint64_t freq)
{
int status;
bladerf_loopback lb;
uint64_t rx_freq;
status = bladerf_set_frequency(state->dev, BLADERF_MODULE_TX, freq);
if (status != 0) {
return status;
}
rx_freq = freq - 1000000;
if (rx_freq < BLADERF_FREQUENCY_MIN) {
rx_freq = freq + 1000000;
state->rx_low = false;
} else {
state->rx_low = true;
}
status = bladerf_set_frequency(state->dev, BLADERF_MODULE_RX, rx_freq);
if (status != 0) {
return status;
}
if (freq < 1500000000) {
lb = BLADERF_LB_RF_LNA1;
PR_DBG("Switching to RF LNA1 loopback.\n");
} else {
lb = BLADERF_LB_RF_LNA2;
PR_DBG("Switching to RF LNA2 loopback.\n");
}
if (state->loopback != lb) {
status = bladerf_set_loopback(state->dev, lb);
if (status == 0) {
state->loopback = lb;
}
}
return status;
}
static int apply_tx_cal_settings(struct bladerf *dev)
{
int status;
status = bladerf_set_sample_rate(dev, BLADERF_MODULE_RX, TX_CAL_RATE, NULL);
if (status != 0) {
return status;
}
status = bladerf_set_bandwidth(dev, BLADERF_MODULE_RX, TX_CAL_RX_BW, NULL);
if (status != 0) {
return status;
}
status = bladerf_set_lna_gain(dev, TX_CAL_RX_LNA);
if (status != 0) {
return status;
}
status = bladerf_set_rxvga1(dev, TX_CAL_RX_VGA1);
if (status != 0) {
return status;
}
status = bladerf_set_rxvga2(dev, TX_CAL_RX_VGA2);
if (status != 0) {
return status;
}
status = bladerf_set_sample_rate(dev, BLADERF_MODULE_TX, TX_CAL_RATE, NULL);
if (status != 0) {
return status;
}
status = bladerf_set_loopback(dev, TX_CAL_DEFAULT_LB);
if (status != 0) {
return status;
}
return status;
}
/* We just need to flush some zeros through the system to hole the DAC at
* 0+0j and remain there while letting it underrun. This alleviates the
* need to worry about continuously TX'ing zeros. */
static int tx_cal_tx_init(struct bladerf *dev)
{
int status;
int16_t zero_sample[] = { 0, 0 };
struct bladerf_metadata meta;
memset(&meta, 0, sizeof(meta));
status = bladerf_sync_config(dev, BLADERF_MODULE_TX,
BLADERF_FORMAT_SC16_Q11_META,
4, 16384, 2, 1000);
if (status != 0) {
return status;
}
status = bladerf_enable_module(dev, BLADERF_MODULE_TX, true);
if (status != 0) {
return status;
}
meta.flags = BLADERF_META_FLAG_TX_BURST_START |
BLADERF_META_FLAG_TX_BURST_END |
BLADERF_META_FLAG_TX_NOW;
status = bladerf_sync_tx(dev, &zero_sample, 1, &meta, 2000);
return status;
}
static int tx_cal_rx_init(struct bladerf *dev)
{
int status;
status = bladerf_sync_config(dev, BLADERF_MODULE_RX,
BLADERF_FORMAT_SC16_Q11_META,
64, 16384, 32, 1000);
if (status != 0) {
return status;
}
status = bladerf_enable_module(dev, BLADERF_MODULE_RX, true);
return status;
}
static void tx_cal_state_deinit(struct tx_cal *cal)
{
free(cal->sweep);
free(cal->mag);
free(cal->samples);
free(cal->filt);
free(cal->filt_out);
free(cal->post_mix);
}
/* This should be called immediately preceding the cal routines */
static int tx_cal_state_init(struct bladerf *dev, struct tx_cal *cal)
{
int status;
cal->dev = dev;
cal->num_samples = TX_CAL_COUNT;
cal->loopback = TX_CAL_DEFAULT_LB;
/* Interleaved SC16 Q11 samples */
cal->samples = malloc(2 * sizeof(cal->samples[0]) * cal->num_samples);
if (cal->samples == NULL) {
return BLADERF_ERR_MEM;
}
/* Filter state */
cal->filt = malloc(2 * sizeof(cal->filt[0]) * tx_cal_filt_num_taps);
if (cal->filt == NULL) {
return BLADERF_ERR_MEM;
}
/* Filter output */
cal->filt_out = malloc(sizeof(cal->filt_out[0]) * cal->num_samples);
if (cal->filt_out == NULL) {
return BLADERF_ERR_MEM;
}
/* Post-mix */
cal->post_mix = malloc(sizeof(cal->post_mix[0]) * cal->num_samples);
if (cal->post_mix == NULL) {
return BLADERF_ERR_MEM;
}
/* Correction sweep and results */
cal->sweep = malloc(sizeof(cal->sweep[0]) * TX_CAL_CORR_SWEEP_LEN);
if (cal->sweep == NULL) {
return BLADERF_ERR_MEM;
}
cal->mag = malloc(sizeof(cal->mag[0]) * TX_CAL_CORR_SWEEP_LEN);
if (cal->mag == NULL) {
return BLADERF_ERR_MEM;
}
/* Set initial RX in the future */
status = bladerf_get_timestamp(cal->dev, BLADERF_MODULE_RX, &cal->ts);
if (status == 0) {
cal->ts += 20 * TX_CAL_TS_INC;
}
return status;
}
/* Filter samples
* Input: state->post_mix
* Output: state->filt_out
*/
static void tx_cal_filter(struct tx_cal *state)
{
unsigned int n, m;
struct complexf *ins1, *ins2;
struct complexf *curr; /* Current filter state */
const struct complexf *filt_end = &state->filt[2 * tx_cal_filt_num_taps];
/* Reset filter state */
ins1 = &state->filt[0];
ins2 = &state->filt[tx_cal_filt_num_taps];
memset(state->filt, 0, 2 * sizeof(state->filt[0]) * tx_cal_filt_num_taps);
for (n = 0; n < state->num_samples; n++) {
/* Insert sample */
*ins1 = *ins2 = state->post_mix[n];
/* Convolve */
state->filt_out[n].i = 0;
state->filt_out[n].q = 0;
curr = ins2;
for (m = 0; m < tx_cal_filt_num_taps; m++, curr--) {
state->filt_out[n].i += tx_cal_filt[m] * curr->i;
state->filt_out[n].q += tx_cal_filt[m] * curr->q;
}
/* Update insertion points */
ins2++;
if (ins2 == filt_end) {
ins1 = &state->filt[0];
ins2 = &state->filt[tx_cal_filt_num_taps];
} else {
ins1++;
}
}
}
/* Deinterleave, scale, and mix with an -Fs/4 tone to shift TX DC offset out at
* Fs/4 to baseband.
* Input: state->samples
* Output: state->post_mix
*/
static void tx_cal_mix(struct tx_cal *state)
{
unsigned int n, m;
int mix_state;
float scaled_i, scaled_q;
/* Mix with -Fs/4 if RX is tuned "lower" than TX, and Fs/4 otherwise */
const int mix_state_inc = state->rx_low ? 1 : -1;
mix_state = 0;
for (n = 0, m = 0; n < (2 * state->num_samples); n += 2, m++) {
scaled_i = state->samples[n] / 2048.0f;
scaled_q = state->samples[n+1] / 2048.0f;
switch (mix_state) {
case 0:
state->post_mix[m].i = scaled_i;
state->post_mix[m].q = scaled_q;
break;
case 1:
state->post_mix[m].i = scaled_q;
state->post_mix[m].q = -scaled_i;
break;
case 2:
state->post_mix[m].i = -scaled_i;
state->post_mix[m].q = -scaled_q;
break;
case 3:
state->post_mix[m].i = -scaled_q;
state->post_mix[m].q = scaled_i;
break;
}
mix_state = (mix_state + mix_state_inc) & 0x3;
}
}
static int tx_cal_avg_magnitude(struct tx_cal *state, float *avg_mag)
{
int status;
const unsigned int start = (tx_cal_filt_num_taps + 1) / 2;
unsigned int n;
float accum;
/* Fetch samples at the current settings */
status = rx_samples(state->dev, state->samples, state->num_samples,
&state->ts, TX_CAL_TS_INC);
if (status != 0) {
return status;
}
/* Deinterleave & mix TX's DC offset contribution to baseband */
tx_cal_mix(state);
/* Filter out everything other than the TX DC offset's contribution */
tx_cal_filter(state);
/* Compute the power (magnitude^2 to alleviate need for square root).
* We skip samples here to account for the group delay of the filter;
* the initial samples will be ramping up. */
accum = 0;
for (n = start; n < state->num_samples; n++) {
const struct complexf *s = &state->filt_out[n];
const float m = (float) sqrt(s->i * s->i + s->q * s->q);
accum += m;
}
*avg_mag = (accum / (state->num_samples - start));
/* Scale this back up to DAC/ADC counts, just for convenience */
*avg_mag *= 2048.0;
return status;
}
/* Apply the correction value and read the TX DC offset magnitude */
static int tx_cal_measure_correction(struct tx_cal *state,
bladerf_correction c,
int16_t value, float *mag)
{
int status;
status = bladerf_set_correction(state->dev, BLADERF_MODULE_TX, c, value);
if (status != 0) {
return status;
}
state->ts += TX_CAL_TS_INC;
status = tx_cal_avg_magnitude(state, mag);
if (status == 0) {
PR_VERBOSE(" Corr=%5d, Avg_magnitude=%f\n", value, *mag);
}
return status;
}
static int tx_cal_get_corr(struct tx_cal *state, bool i_ch,
int16_t *corr_value, float *error_value)
{
int status;
unsigned int n;
int16_t corr;
float mag[4];
float m1, m2, b1, b2;
int16_t range_min, range_max;
int16_t min_corr;
float min_mag;
const int16_t x[4] = { -1800, -1000, 1000, 1800 };
const bladerf_correction corr_module =
i_ch ? BLADERF_CORR_LMS_DCOFF_I : BLADERF_CORR_LMS_DCOFF_Q;
PR_DBG("Getting coarse estimate for %c\n", i_ch ? 'I' : 'Q');
for (n = 0; n < 4; n++) {
status = tx_cal_measure_correction(state, corr_module, x[n], &mag[n]);
if (status != 0) {
return status;
}
}
m1 = (mag[1] - mag[0]) / (x[1] - x[0]);
b1 = mag[0] - m1 * x[0];
m2 = (mag[3] - mag[2]) / (x[3] - x[2]);
b2 = mag[2] - m2 * x[2];
PR_VERBOSE(" m1=%3.8f, b1=%3.8f, m2=%3.8f, b=%3.8f\n", m1, b1, m2, b2);
if (m1 < 0 && m2 > 0) {
const int16_t tmp = (int16_t)((b2 - b1) / (m1 - m2) + 0.5);
const int16_t corr_est = (tmp / 16) * 16;
/* Number of points to sweep on either side of our estimate */
const unsigned int n_sweep = 10;
PR_VERBOSE(" corr_est=%d\n", corr_est);
range_min = corr_est - 16 * n_sweep;
if (range_min < -2048) {
range_min = -2048;
}
range_max = corr_est + 16 * n_sweep;
if (range_max > 2048) {
range_max = 2048;
}
} else {
/* The frequency and gain combination have yielded a set of
* points that do not form intersecting lines. This may be indicative
* of a case where the LMS6 DC bias settings can't pull the DC offset
* to a zero-crossing. We'll just do a slow, full scan to find
* a minimum */
PR_VERBOSE(" Could not compute estimate. Performing full sweep.\n");
range_min = -2048;
range_max = 2048;
}
PR_DBG("Performing correction value sweep: [%-5d : 16 :%5d]\n",
range_min, range_max);
min_corr = 0;
min_mag = 2048;
for (n = 0, corr = range_min;
corr <= range_max && n < TX_CAL_CORR_SWEEP_LEN;
n++, corr += 16) {
float tmp;
status = tx_cal_measure_correction(state, corr_module, corr, &tmp);
if (status != 0) {
return status;
}
if (tmp < 0) {
tmp = -tmp;
}
if (tmp < min_mag) {
min_corr = corr;
min_mag = tmp;
}
}
/* Leave the device set to the minimum */
status = bladerf_set_correction(state->dev, BLADERF_MODULE_TX,
corr_module, min_corr);
if (status == 0) {
*corr_value = min_corr;
*error_value = min_mag;
}
return status;
}
static int perform_tx_cal(struct tx_cal *state, struct dc_calibration_params *p)
{
int status = 0;
status = tx_cal_update_frequency(state, p->frequency);
if (status != 0) {
return status;
}
state->ts += TX_CAL_TS_INC;
/* Perform I calibration */
status = tx_cal_get_corr(state, true, &p->corr_i, &p->error_i);
if (status != 0) {
return status;
}
/* Perform Q calibration */
status = tx_cal_get_corr(state, false, &p->corr_q, &p->error_q);
if (status != 0) {
return status;
}
/* Re-do I calibration to try to further fine-tune result */
status = tx_cal_get_corr(state, true, &p->corr_i, &p->error_i);
if (status != 0) {
return status;
}
/* Apply the resulting nominal values */
status = set_tx_dc_corr(state->dev, p->corr_i, p->corr_q);
return status;
}
int dc_calibration_tx(struct bladerf *dev,
struct dc_calibration_params *params,
size_t num_params, bool print_status)
{
int status = 0;
int retval = 0;
struct tx_cal_backup backup;
struct tx_cal state;
size_t i;
memset(&state, 0, sizeof(state));
/* Backup the device state prior to making changes */
status = get_tx_cal_backup(dev, &backup);
if (status != 0) {
return status;
}
/* Configure the device for our TX cal operation */
status = apply_tx_cal_settings(dev);
if (status != 0) {
goto out;
}
/* Enable TX and run zero samples through the device */
status = tx_cal_tx_init(dev);
if (status != 0) {
goto out;
}
/* Enable RX */
status = tx_cal_rx_init(dev);
if (status != 0) {
goto out;
}
/* Initialize calibration state information and resources */
status = tx_cal_state_init(dev, &state);
if (status != 0) {
goto out;
}
for (i = 0; i < num_params && status == 0; i++) {
status = perform_tx_cal(&state, &params[i]);
if (status == 0 && print_status) {
# ifdef DEBUG_DC_CALIBRATION
const char sol = '\n';
const char eol = '\n';
# else
const char sol = '\r';
const char eol = '\0';
# endif
printf("%cCalibrated @ %10" PRIu64 " Hz: "
"I=%4d (Error: %4.2f), "
"Q=%4d (Error: %4.2f) %c",
sol,
params[i].frequency,
params[i].corr_i, params[i].error_i,
params[i].corr_q, params[i].error_q,
eol);
fflush(stdout);
}
}
if (print_status) {
putchar('\n');
}
out:
retval = status;
status = bladerf_enable_module(dev, BLADERF_MODULE_RX, false);
if (status != 0 && retval == 0) {
retval = status;
}
status = bladerf_enable_module(dev, BLADERF_MODULE_TX, false);
if (status != 0 && retval == 0) {
retval = status;
}
tx_cal_state_deinit(&state);
status = set_tx_cal_backup(dev, &backup);
if (status != 0 && retval == 0) {
retval = status;
}
return retval;
}
int dc_calibration(struct bladerf *dev, bladerf_module module,
struct dc_calibration_params *params,
size_t num_params, bool show_status)
{
int status;
switch (module) {
case BLADERF_MODULE_RX:
status = dc_calibration_rx(dev, params, num_params, show_status);
break;
case BLADERF_MODULE_TX:
status = dc_calibration_tx(dev, params, num_params, show_status);
break;
default:
status = BLADERF_ERR_INVAL;
}
return status;
}
You can’t perform that action at this time.