unsigned int test_samplerate(struct bladerf *dev,
struct app_params *p, bool quiet)
{
unsigned int failures = 0;
PRINT("%s: Sweeping RX sample rates...\n", __FUNCTION__);
failures += sweep_samplerate(dev, BLADERF_MODULE_RX, quiet);
PRINT("%s: Applying random RX sample rates...\n", __FUNCTION__);
failures += random_samplerates(dev, p, BLADERF_MODULE_RX, quiet);
PRINT("%s: Applying random RX rational sample rates...\n",
__FUNCTION__);
failures += random_rational_samplerates(dev, p, BLADERF_MODULE_RX, quiet);
PRINT("%s: Sweeping TX sample rates...\n",
__FUNCTION__);
failures += sweep_samplerate(dev, BLADERF_MODULE_TX, quiet);
PRINT("%s: Applying random TX sample rates...\n",
__FUNCTION__);
failures += random_samplerates(dev, p, BLADERF_MODULE_TX, quiet);
PRINT("%s: Applying random TX rational sample rates...\n",
__FUNCTION__);
failures += random_rational_samplerates(dev, p, BLADERF_MODULE_TX, quiet);
/* Restore the device back to a sane default sample rate, as not to
* interfere with later tests */
failures += set_and_check(dev, BLADERF_MODULE_RX, DEFAULT_SAMPLERATE);
failures += set_and_check(dev, BLADERF_MODULE_TX, DEFAULT_SAMPLERATE);
return failures;
}
static inline int test_module(struct bladerf *dev, bladerf_module m)
{
int status;
unsigned int failures = 0;
status = set_and_check(dev, m, BLADERF_LPF_NORMAL);
if (status != 0) {
failures++;
}
status = set_and_check(dev, m, BLADERF_LPF_BYPASSED);
if (status != 0) {
failures++;
}
status = set_and_check(dev, m, BLADERF_LPF_DISABLED);
if (status != 0) {
failures++;
}
status = set_and_check(dev, m, BLADERF_LPF_NORMAL);
if (status != 0) {
failures++;
}
return failures;
}
static int sweep_samplerate(struct bladerf *dev, bladerf_module m, bool quiet)
{
int status;
unsigned int rate;
const unsigned int inc = 10000;
unsigned int n;
unsigned int failures = 0;
for (rate = BLADERF_SAMPLERATE_MIN, n = 0;
rate <= BLADERF_SAMPLERATE_REC_MAX;
rate += inc, n++) {
status = set_and_check(dev, m, rate);
if (status != 0) {
failures++;
} else if (n % 50 == 0) {
PRINT("\r Sample rate currently set to %-10u Hz...", rate);
fflush(stdout);
}
}
PRINT("\n");
fflush(stdout);
return failures;
}
static int random_samplerates(struct bladerf *dev,
struct app_params *p,
bladerf_module m, bool quiet)
{
int status;
unsigned int i, n;
const unsigned int interations = 2500;
unsigned int rate;
unsigned failures = 0;
for (i = n = 0; i < interations; i++, n++) {
const unsigned int mod =
BLADERF_SAMPLERATE_REC_MAX - BLADERF_SAMPLERATE_MIN + 1;
randval_update(&p->randval_state);
rate = BLADERF_SAMPLERATE_MIN + (p->randval_state % mod);
assert(rate <= BLADERF_SAMPLERATE_REC_MAX);
status = set_and_check(dev, m, rate);
if (status != 0) {
failures++;
} else if (n % 50 == 0) {
PRINT("\r Sample rate currently set to %-10u Hz...", rate);
fflush(stdout);
}
}
PRINT("\n");
fflush(stdout);
return failures;
}
static int random_tuning(struct bladerf *dev, struct app_params *p,
bladerf_module m, unsigned int min, bool quiet)
{
int status = 0;
unsigned int i, n;
const unsigned int num_iterations = 2500;
unsigned int freq;
unsigned int failures = 0;
for (i = n = 0; i < num_iterations; i++, n++) {
randval_update(&p->randval_state);
freq = min + (p->randval_state % BLADERF_FREQUENCY_MAX);
if (freq < min) {
freq = BLADERF_FREQUENCY_MIN;
} else if (freq > BLADERF_FREQUENCY_MAX) {
freq = BLADERF_FREQUENCY_MAX;
}
status = set_and_check(dev, m, freq);
if (status != 0) {
failures++;
} else if (n % 50 == 0) {
PRINT("\r Currently tuned to %-10u Hz...", freq);
fflush(stdout);
}
}
PRINT("\n");
fflush(stdout);
return failures;
}
static unsigned int random_bandwidths(struct bladerf *dev, bladerf_module m,
struct app_params *p)
{
int status;
unsigned int bw, i;
unsigned int failures = 0;
const unsigned int iterations = 1500;
for (i = 0; i < iterations; i++) {
randval_update(&p->randval_state);
bw = BLADERF_BANDWIDTH_MIN + (p->randval_state % BLADERF_BANDWIDTH_MAX);
if (bw < BLADERF_BANDWIDTH_MIN) {
bw = BLADERF_BANDWIDTH_MIN;
} else if (bw > BLADERF_BANDWIDTH_MAX) {
bw = BLADERF_BANDWIDTH_MAX;
}
status = set_and_check(dev, m, bw);
if (status != 0) {
failures++;
}
}
return failures;
}
int
main (int argc, char **argv)
{
char *license = "http://creativecommons.org/licenses/by-nd/2.0/";
char *response;
int status;
(void) argc;
(void) argv;
printf
("Warning: this test will overwrite system-wide defaults if run."
"To stop hit control-C (Control-Break on Windows). You have 3 seconds."
"\n\n");
fflush (stdout);
/* BREAKS_WINDOWS */
sleep (3);
set_and_check(license, license);
set_and_check("", NULL);
return 0;
}
static unsigned int sweep_bandwidths(struct bladerf *dev, bladerf_module m)
{
int status;
unsigned int b;
const unsigned int inc = 250000;
unsigned int failures = 0;
for (b = BLADERF_BANDWIDTH_MIN; b < BLADERF_BANDWIDTH_MAX; b += inc) {
status = set_and_check(dev, m, b);
if (status != 0) {
failures++;
}
}
return failures;
}
static unsigned int freq_sweep(struct bladerf *dev, bladerf_module m,
unsigned int min, bool quiet)
{
int status;
unsigned int freq, n;
const unsigned int inc = 2500000;
unsigned int failures = 0;
for (freq = min, n = 0; freq <= BLADERF_FREQUENCY_MAX; freq += inc, n++) {
status = set_and_check(dev, m, freq);
if (status != 0) {
failures++;
} else if (n % 50 == 0) {
PRINT("\r Currently tuned to %-10u Hz...", freq);
fflush(stdout);
}
}
PRINT("\n");
fflush(stdout);
return failures;
}
