void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
struct bladerf *dev;
bladerf_cal_module mod;
int ret, freq, actual;
long long *ip;
int *m_ptr, *freq_ptr;
if (nrhs < 2)
return;
ip = (long long *)mxGetPr(prhs[0]);
m_ptr = (int *)mxGetPr(prhs[1]);
dev = (struct bladerf *)*ip;
mod = (bladerf_module)(*m_ptr);
freq = (int)(*freq_ptr);
ret = bladerf_calibrate_dc(dev, mod);
if (nlhs >= 1) {
plhs[0] = mxCreateNumericMatrix(1,1,mxINT64_CLASS,mxREAL);
ip = (long long *)mxGetData(plhs[0]);
*ip = ret;
}
}
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;
}
int calibrate_dc(struct cli_state *s, unsigned int ops)
{
int retval = 0;
int status = BLADERF_ERR_UNEXPECTED;
struct settings rx_settings, tx_settings;
bladerf_loopback loopback;
int16_t dc_i, dc_q;
if (IS_RX_CAL(ops)) {
status = backup_and_update_settings(s->dev, BLADERF_MODULE_RX,
&rx_settings);
if (status != 0) {
s->last_lib_error = status;
return CLI_RET_LIBBLADERF;
}
}
if (IS_TX_CAL(ops)) {
status = backup_and_update_settings(s->dev, BLADERF_MODULE_TX,
&tx_settings);
if (status != 0) {
s->last_lib_error = status;
return CLI_RET_LIBBLADERF;
}
}
status = bladerf_get_loopback(s->dev, &loopback);
if (status != 0) {
s->last_lib_error = status;
return CLI_RET_LIBBLADERF;
}
if (IS_RX_CAL(ops)) {
status = set_rx_dc(s->dev, 0, 0);
if (status != 0) {
goto error;
}
status = bladerf_enable_module(s->dev, BLADERF_MODULE_RX, true);
if (status != 0) {
goto error;
}
}
if (IS_TX_CAL(ops)) {
status = bladerf_enable_module(s->dev, BLADERF_MODULE_RX, true);
if (status != 0) {
goto error;
}
status = bladerf_set_loopback(s->dev, BLADERF_LB_BB_TXVGA1_RXVGA2);
if (status != 0) {
goto error;
}
status = bladerf_enable_module(s->dev, BLADERF_MODULE_TX, true);
if (status != 0) {
goto error;
}
status = dummy_tx(s->dev);
if (status != 0) {
goto error;
}
status = bladerf_enable_module(s->dev, BLADERF_MODULE_TX, false);
if (status != 0) {
goto error;
}
}
status = bladerf_set_loopback(s->dev, BLADERF_LB_NONE);
if (status != 0) {
goto error;
}
putchar('\n');
if (IS_CAL(CAL_DC_LMS_TUNING, ops)) {
printf(" Calibrating LMS LPF tuning module...\n");
status = bladerf_calibrate_dc(s->dev, BLADERF_DC_CAL_LPF_TUNING);
if (status != 0) {
goto error;
} else {
struct bladerf_lms_dc_cals dc_cals;
status = bladerf_lms_get_dc_cals(s->dev, &dc_cals);
if (status != 0) {
goto error;
}
printf(" LPF tuning module: %d\n\n", dc_cals.lpf_tuning);
}
}
if (IS_CAL(CAL_DC_LMS_TXLPF, ops)) {
printf(" Calibrating LMS TX LPF modules...\n");
status = bladerf_calibrate_dc(s->dev, BLADERF_DC_CAL_TX_LPF);
if (status != 0) {
goto error;
} else {
struct bladerf_lms_dc_cals dc_cals;
status = bladerf_lms_get_dc_cals(s->dev, &dc_cals);
if (status != 0) {
goto error;
}
printf(" TX LPF I filter: %d\n", dc_cals.tx_lpf_i);
printf(" TX LPF Q filter: %d\n\n", dc_cals.tx_lpf_q);
}
}
if (IS_CAL(CAL_DC_LMS_RXLPF, ops)) {
printf(" Calibrating LMS RX LPF modules...\n");
status = bladerf_calibrate_dc(s->dev, BLADERF_DC_CAL_RX_LPF);
if (status != 0) {
goto error;
} else {
struct bladerf_lms_dc_cals dc_cals;
status = bladerf_lms_get_dc_cals(s->dev, &dc_cals);
if (status != 0) {
goto error;
}
printf(" RX LPF I filter: %d\n", dc_cals.rx_lpf_i);
printf(" RX LPF Q filter: %d\n\n", dc_cals.rx_lpf_q);
}
}
if (IS_CAL(CAL_DC_LMS_RXVGA2, ops)) {
printf(" Calibrating LMS RXVGA2 modules...\n");
status = bladerf_calibrate_dc(s->dev, BLADERF_DC_CAL_RXVGA2);
if (status != 0) {
goto error;
} else {
struct bladerf_lms_dc_cals dc_cals;
status = bladerf_lms_get_dc_cals(s->dev, &dc_cals);
if (status != 0) {
goto error;
}
printf(" RX VGA2 DC reference module: %d\n", dc_cals.dc_ref);
printf(" RX VGA2 stage 1, I channel: %d\n", dc_cals.rxvga2a_i);
printf(" RX VGA2 stage 1, Q channel: %d\n", dc_cals.rxvga2a_q);
printf(" RX VGA2 stage 2, I channel: %d\n", dc_cals.rxvga2b_i);
printf(" RX VGA2 stage 2, Q channel: %d\n\n", dc_cals.rxvga2b_q);
}
}
if (IS_CAL(CAL_DC_AUTO_RX, ops)) {
int16_t avg_i, avg_q;
status = calibrate_dc_rx(s, &dc_i, &dc_q, &avg_i, &avg_q);
if (status != 0) {
goto error;
} else {
printf(" RX DC I Setting = %d, error ~= %d\n", dc_i, avg_i);
printf(" RX DC Q Setting = %d, error ~= %d\n\n", dc_q, avg_q);
}
}
if (IS_CAL(CAL_DC_AUTO_TX, ops)) {
float error_i, error_q;
status = calibrate_dc_tx(s, &dc_i, &dc_q, &error_i, &error_q);
if (status != 0) {
goto error;
} else {
printf(" TX DC I Setting = %d, error ~= %f\n", dc_i, error_i);
printf(" TX DC Q Setting = %d, error ~= %f\n\n", dc_q, error_q);
}
}
error:
retval = status;
if (IS_RX_CAL(ops)) {
status = restore_settings(s->dev, BLADERF_MODULE_RX, &rx_settings);
retval = first_error(retval, status);
}
if (IS_TX_CAL(ops)) {
status = restore_settings(s->dev, BLADERF_MODULE_TX, &tx_settings);
retval = first_error(retval, status);
}
status = bladerf_enable_module(s->dev, BLADERF_MODULE_RX, false);
retval = first_error(retval, status);
status = bladerf_enable_module(s->dev, BLADERF_MODULE_TX, false);
retval = first_error(retval, status);
status = bladerf_set_loopback(s->dev, loopback);
retval = first_error(retval, status);
if (retval != 0) {
s->last_lib_error = retval;
retval = CLI_RET_LIBBLADERF;
}
return retval;
}
