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; }
/* See libbladeRF's dc_cal_table.c for the packed table data format */ int calibrate_dc_gen_tbl(struct cli_state *s, bladerf_module module, const char *filename, unsigned int f_low, unsigned f_inc, unsigned int f_high) { int retval, status; size_t off; struct bladerf_lms_dc_cals lms_dc_cals; unsigned int f; struct settings settings; bladerf_loopback loopback_backup; struct bladerf_image *image = NULL; const uint16_t magic = HOST_TO_LE16(0x1ab1); const uint32_t reserved = HOST_TO_LE32(0x00000000); const uint32_t tbl_version = HOST_TO_LE32(0x00000001); const size_t lms_data_size = 10; /* 10 uint8_t register values */ const uint32_t n_frequencies = (f_high - f_low) / f_inc + 1; const uint32_t n_frequencies_le = HOST_TO_LE32(n_frequencies); const size_t entry_size = sizeof(uint32_t) + /* Frequency */ 2 * sizeof(int16_t); /* DC I and Q valus */ const size_t table_size = n_frequencies * entry_size; const size_t data_size = sizeof(magic) + sizeof(reserved) + sizeof(tbl_version) + sizeof(n_frequencies_le) + lms_data_size + table_size; assert(data_size <= UINT_MAX); status = backup_and_update_settings(s->dev, module, &settings); if (status != 0) { return status; } status = bladerf_get_loopback(s->dev, &loopback_backup); if (status != 0) { return status; } status = bladerf_lms_get_dc_cals(s->dev, &lms_dc_cals); if (status != 0) { goto out; } if (module == BLADERF_MODULE_RX) { image = bladerf_alloc_image(BLADERF_IMAGE_TYPE_RX_DC_CAL, 0xffffffff, (unsigned int) data_size); } else { image = bladerf_alloc_image(BLADERF_IMAGE_TYPE_TX_DC_CAL, 0xffffffff, (unsigned int) data_size); } if (image == NULL) { status = BLADERF_ERR_MEM; goto out; } status = bladerf_get_serial(s->dev, image->serial); if (status != 0) { goto out; } if (module == BLADERF_MODULE_RX) { status = bladerf_set_loopback(s->dev, BLADERF_LB_NONE); if (status != 0) { goto out; } } off = 0; memcpy(&image->data[off], &magic, sizeof(magic)); off += sizeof(magic); memcpy(&image->data[off], &reserved, sizeof(reserved)); off += sizeof(reserved); memcpy(&image->data[off], &tbl_version, sizeof(tbl_version)); off += sizeof(tbl_version); memcpy(&image->data[off], &n_frequencies_le, sizeof(n_frequencies_le)); off += sizeof(n_frequencies_le); image->data[off++] = (uint8_t)lms_dc_cals.lpf_tuning; image->data[off++] = (uint8_t)lms_dc_cals.tx_lpf_i; image->data[off++] = (uint8_t)lms_dc_cals.tx_lpf_q; image->data[off++] = (uint8_t)lms_dc_cals.rx_lpf_i; image->data[off++] = (uint8_t)lms_dc_cals.rx_lpf_q; image->data[off++] = (uint8_t)lms_dc_cals.dc_ref; image->data[off++] = (uint8_t)lms_dc_cals.rxvga2a_i; image->data[off++] = (uint8_t)lms_dc_cals.rxvga2a_q; image->data[off++] = (uint8_t)lms_dc_cals.rxvga2b_i; image->data[off++] = (uint8_t)lms_dc_cals.rxvga2b_q; putchar('\n'); for (f = f_low; f <= f_high; f += f_inc) { const uint32_t frequency = HOST_TO_LE32((uint32_t)f); int16_t dc_i, dc_q; printf(" Calibrating @ %u Hz...", f); status = bladerf_set_frequency(s->dev, module, f); if (status != 0) { goto out; } if (module == BLADERF_MODULE_RX) { int16_t error_i, error_q; status = calibrate_dc_rx(s, &dc_i, &dc_q, &error_i, &error_q); printf(" I=%-4d (avg: %-4d), Q=%-4d (avg: %-4d)\r", dc_i, error_i, dc_q, error_q); } else { float error_i, error_q; status = calibrate_dc_tx(s, &dc_i, &dc_q, &error_i, &error_q); printf(" I=%-4d (avg: %3.3f), Q=%-4d (avg: %3.3f)\r", dc_i, error_i, dc_q, error_q); } if (status != 0) { goto out; } fflush(stdout); dc_i = HOST_TO_LE16(dc_i); dc_q = HOST_TO_LE16(dc_q); memcpy(&image->data[off], &frequency, sizeof(frequency)); off += sizeof(frequency); memcpy(&image->data[off], &dc_i, sizeof(dc_i)); off += sizeof(dc_i); memcpy(&image->data[off], &dc_q, sizeof(dc_q)); off += sizeof(dc_q); } status = bladerf_image_write(image, filename); printf("\n Done.\n\n"); out: retval = status; if (module == BLADERF_MODULE_RX) { status = bladerf_set_loopback(s->dev, loopback_backup); retval = first_error(retval, status); } status = bladerf_enable_module(s->dev, BLADERF_MODULE_RX, false); retval = first_error(retval, status); status = restore_settings(s->dev, module, &settings); retval = first_error(retval, status); bladerf_free_image(image); return retval; }
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; }
static int run(struct bladerf *dev, struct app_params *p, int16_t *samples, const struct test_case *t) { int status, status_out; struct bladerf_metadata meta; uint64_t timestamp; unsigned int gap; uint32_t counter; uint64_t tscount_diff; unsigned int i; bool suppress_overrun_msg = false; unsigned int overruns = 0; bool prev_iter_overrun = false; /* Clear out metadata and request that we just received any available * samples, with the timestamp filled in for us */ memset(&meta, 0, sizeof(meta)); meta.flags = BLADERF_META_FLAG_RX_NOW; status = enable_counter_mode(dev, true); if (status != 0) { goto out; } status = perform_sync_init(dev, BLADERF_MODULE_RX, 0, p); if (status != 0) { goto out; } /* Initial read to get a starting timestamp, and counter value */ gap = get_gap(p, t); status = bladerf_sync_rx(dev, samples, gap, &meta, p->timeout_ms); if (status != 0) { fprintf(stderr, "Intial RX failed: %s\n", bladerf_strerror(status)); goto out; } counter = extract_counter_val((uint8_t*) samples); timestamp = meta.timestamp; assert(timestamp >= (uint64_t) counter); tscount_diff = timestamp - (uint64_t) counter; if (t->gap != 0) { printf("\nTest Case: Read size=%"PRIu64" samples, %u iterations\n", t->gap, t->iterations); } else { printf("\nTest Case: Random read size, %u iterations\n", t->iterations); } printf("--------------------------------------------------------\n"); assert((timestamp - tscount_diff) <= UINT32_MAX); status = check_data(samples, &meta, UINT64_MAX, (uint32_t) (timestamp - tscount_diff), meta.actual_count, &suppress_overrun_msg); if (status == DETECTED_OVERRUN) { overruns++; status = 0; } printf("Timestamp-counter diff: %"PRIu64"\n", tscount_diff); printf("Initial timestamp: 0x%016"PRIx64"\n", meta.timestamp); printf("Intital counter value: 0x%08"PRIx32"\n", counter); printf("Initial status: 0x%08"PRIu32"\n", meta.status); for (i = 0; i < t->iterations && status == 0; i++) { timestamp = meta.timestamp + gap; gap = get_gap(p, t); status = bladerf_sync_rx(dev, samples, gap, &meta, p->timeout_ms); if (status != 0) { fprintf(stderr, "RX %u failed: %s\n", i, bladerf_strerror(status)); goto out; } /* If an overrun occured on the previous iteration, we don't know what * the timestamp will actually be on this iteration. */ if (prev_iter_overrun) { timestamp = meta.timestamp; } status = check_data(samples, &meta, timestamp, (uint32_t) (timestamp - tscount_diff), gap, &suppress_overrun_msg); if (status == DETECTED_OVERRUN) { overruns++; status = 0; prev_iter_overrun = true; } } if (status != 0) { printf("Test failed due to errors.\n"); } else if (overruns != 0) { printf("Test failed due to %u overruns.\n", overruns); status = -1; } else { printf("Test passed.\n"); } out: status_out = bladerf_enable_module(dev, BLADERF_MODULE_RX, false); if (status_out != 0) { fprintf(stderr, "Failed to disable RX module: %s\n", bladerf_strerror(status)); } status = first_error(status, status_out); status_out = enable_counter_mode(dev, false); status = first_error(status, status_out); return status; }
/* See libbladeRF's dc_cal_table.c for the packed table data format */ int calibrate_dc_gen_tbl(struct cli_state *s, bladerf_module module, const char *filename, unsigned int f_low, unsigned f_inc, unsigned int f_high) { int retval, status; size_t off; struct bladerf_lms_dc_cals lms_dc_cals; unsigned int f; struct settings settings; bladerf_loopback loopback_backup; struct bladerf_image *image = NULL; FILE *write_check; const uint16_t magic = HOST_TO_LE16(0x1ab1); const uint32_t reserved = HOST_TO_LE32(0x00000000); const uint32_t tbl_version = HOST_TO_LE32(0x00000001); const size_t lms_data_size = 10; /* 10 uint8_t register values */ const uint32_t n_frequencies = (f_high - f_low) / f_inc + 1; const uint32_t n_frequencies_le = HOST_TO_LE32(n_frequencies); const size_t entry_size = sizeof(uint32_t) + /* Frequency */ 2 * sizeof(int16_t); /* DC I and Q valus */ const size_t table_size = n_frequencies * entry_size; const size_t data_size = sizeof(magic) + sizeof(reserved) + sizeof(tbl_version) + sizeof(n_frequencies_le) + lms_data_size + table_size; assert(data_size <= UINT_MAX); /* This operation may take a bit of time, so let's make sure we * actually have write access before kicking things off. Note that * access is checked later when the file is actually written. */ write_check = fopen(filename, "wb"); if (write_check == NULL) { if (errno == EACCES) { return BLADERF_ERR_PERMISSION; } else { return BLADERF_ERR_IO; } } else { fclose(write_check); /* Not much we care to do if this fails. Throw away the return value * to make this explicit to our static analysis tools */ (void) remove(filename); } status = backup_and_update_settings(s->dev, module, &settings); if (status != 0) { return status; } status = bladerf_get_loopback(s->dev, &loopback_backup); if (status != 0) { return status; } status = bladerf_lms_get_dc_cals(s->dev, &lms_dc_cals); if (status != 0) { goto out; } if (module == BLADERF_MODULE_RX) { image = bladerf_alloc_image(BLADERF_IMAGE_TYPE_RX_DC_CAL, 0xffffffff, (unsigned int) data_size); } else { image = bladerf_alloc_image(BLADERF_IMAGE_TYPE_TX_DC_CAL, 0xffffffff, (unsigned int) data_size); } if (image == NULL) { status = BLADERF_ERR_MEM; goto out; } status = bladerf_get_serial(s->dev, image->serial); if (status != 0) { goto out; } if (module == BLADERF_MODULE_RX) { status = bladerf_set_loopback(s->dev, BLADERF_LB_NONE); if (status != 0) { goto out; } } off = 0; memcpy(&image->data[off], &magic, sizeof(magic)); off += sizeof(magic); memcpy(&image->data[off], &reserved, sizeof(reserved)); off += sizeof(reserved); memcpy(&image->data[off], &tbl_version, sizeof(tbl_version)); off += sizeof(tbl_version); memcpy(&image->data[off], &n_frequencies_le, sizeof(n_frequencies_le)); off += sizeof(n_frequencies_le); image->data[off++] = (uint8_t)lms_dc_cals.lpf_tuning; image->data[off++] = (uint8_t)lms_dc_cals.tx_lpf_i; image->data[off++] = (uint8_t)lms_dc_cals.tx_lpf_q; image->data[off++] = (uint8_t)lms_dc_cals.rx_lpf_i; image->data[off++] = (uint8_t)lms_dc_cals.rx_lpf_q; image->data[off++] = (uint8_t)lms_dc_cals.dc_ref; image->data[off++] = (uint8_t)lms_dc_cals.rxvga2a_i; image->data[off++] = (uint8_t)lms_dc_cals.rxvga2a_q; image->data[off++] = (uint8_t)lms_dc_cals.rxvga2b_i; image->data[off++] = (uint8_t)lms_dc_cals.rxvga2b_q; putchar('\n'); for (f = f_low; f <= f_high; f += f_inc) { const uint32_t frequency = HOST_TO_LE32((uint32_t)f); int16_t dc_i, dc_q; printf(" Calibrating @ %u Hz...", f); status = bladerf_set_frequency(s->dev, module, f); if (status != 0) { goto out; } if (module == BLADERF_MODULE_RX) { int16_t error_i, error_q; status = calibrate_dc_rx(s, &dc_i, &dc_q, &error_i, &error_q); printf(" I=%-4d (avg: %-4d), Q=%-4d (avg: %-4d)\r", dc_i, error_i, dc_q, error_q); } else { float error_i, error_q; status = calibrate_dc_tx(s, &dc_i, &dc_q, &error_i, &error_q); printf(" I=%-4d (avg: %3.3f), Q=%-4d (avg: %3.3f)\r", dc_i, error_i, dc_q, error_q); } if (status != 0) { goto out; } fflush(stdout); dc_i = HOST_TO_LE16(dc_i); dc_q = HOST_TO_LE16(dc_q); memcpy(&image->data[off], &frequency, sizeof(frequency)); off += sizeof(frequency); memcpy(&image->data[off], &dc_i, sizeof(dc_i)); off += sizeof(dc_i); memcpy(&image->data[off], &dc_q, sizeof(dc_q)); off += sizeof(dc_q); } status = bladerf_image_write(image, filename); printf("\n Done.\n\n"); out: retval = status; if (module == BLADERF_MODULE_RX) { status = bladerf_set_loopback(s->dev, loopback_backup); retval = first_error(retval, status); } status = bladerf_enable_module(s->dev, BLADERF_MODULE_RX, false); retval = first_error(retval, status); status = restore_settings(s->dev, module, &settings); retval = first_error(retval, status); bladerf_free_image(image); return retval; }
static int run(struct bladerf *dev, struct app_params *p, const struct test_case *t) { int status, status_out, status_wait; unsigned int samples_left; size_t i; struct bladerf_metadata meta; int16_t *samples, *buf; samples = calloc(2 * sizeof(int16_t), t->burst_len + 2); if (samples == NULL) { perror("malloc"); return BLADERF_ERR_MEM; } /* Leave the last two samples zero */ for (i = 0; i < (2 * t->burst_len); i += 2) { samples[i] = samples[i + 1] = MAGNITUDE; } memset(&meta, 0, sizeof(meta)); status = perform_sync_init(dev, BLADERF_MODULE_TX, t->buf_len, p); if (status != 0) { goto out; } status = bladerf_get_timestamp(dev, BLADERF_MODULE_TX, &meta.timestamp); if (status != 0) { fprintf(stderr, "Failed to get timestamp: %s\n", bladerf_strerror(status)); goto out; } else { printf("Initial timestamp: 0x%016"PRIx64"\n", meta.timestamp); } meta.timestamp += 200000; for (i = 0; i < t->iterations && status == 0; i++) { meta.flags = BLADERF_META_FLAG_TX_BURST_START; samples_left = t->burst_len + 2; buf = samples; printf("Sending burst @ %llu\n", (unsigned long long) meta.timestamp); while (samples_left && status == 0) { unsigned int to_send = uint_min(p->buf_size, samples_left); if (to_send == samples_left) { meta.flags |= BLADERF_META_FLAG_TX_BURST_END; } else { meta.flags &= ~BLADERF_META_FLAG_TX_BURST_END; } status = bladerf_sync_tx(dev, buf, to_send, &meta, 10000); //p->timeout_ms); if (status != 0) { fprintf(stderr, "TX failed @ iteration (%u) %s\n", (unsigned int )i, bladerf_strerror(status)); } meta.flags &= ~BLADERF_META_FLAG_TX_BURST_START; samples_left -= to_send; buf += 2 * to_send; } meta.timestamp += (t->burst_len + t->gap_len - 2); } printf("Waiting for samples to finish...\n"); fflush(stdout); /* Wait for samples to be transmitted before shutting down the TX module */ status_wait = wait_for_timestamp(dev, BLADERF_MODULE_TX, meta.timestamp - t->gap_len + 2, 3000); if (status_wait != 0) { status = first_error(status, status_wait); fprintf(stderr, "Failed to wait for TX to finish: %s\n", bladerf_strerror(status_wait)); } out: status_out = bladerf_enable_module(dev, BLADERF_MODULE_TX, false); if (status_out != 0) { fprintf(stderr, "Failed to disable TX module: %s\n", bladerf_strerror(status)); } else { printf("Done waiting.\n"); fflush(stdout); } status = first_error(status, status_out); free(samples); return status; }