bladeRF/host/libraries/libbladeRF_test/test_async/main.c
Ryan Thompson ad995b06cc test: test_async exit when TX sample count reached
Previously, the TX test relied on SIG_INT exit. Now it relies on the
the [# samples] argument or the pre-defined samples_left.
2023-09-27 16:38:57 -05:00

316 lines
9 KiB
C

/*
* This file is part of the bladeRF project:
* http://www.github.com/nuand/bladeRF
*
* Copyright (C) 2013 Nuand LLC
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <string.h>
#include <host_config.h>
#include <errno.h>
#include <limits.h>
#include <sys/types.h>
#include <libbladeRF.h>
#ifndef DATA_SOURCE
# define DATA_SOURCE "/dev/urandom"
#endif
static bool shutdown_stream = false;
unsigned int count = 0;
struct test_data
{
void **buffers; /* Transmit buffers */
size_t num_buffers; /* Number of buffers */
size_t samples_per_buffer; /* Number of samples per buffer */
unsigned int idx; /* The next one that needs to go out */
bladerf_module module; /* Direction */
FILE *fout; /* Output file (RX only) */
ssize_t samples_left; /* Number of samples left */
};
int str2int(const char *str, int min, int max, bool *ok)
{
long value;
char *endptr;
errno = 0;
value = strtol(str, &endptr, 0);
if (errno != 0 || value < (long)min || value > (long)max ||
endptr == str || *endptr != '\0') {
if (ok) {
*ok = false;
}
return 0;
}
if (ok) {
*ok = true;
}
return (int)value;
}
void *stream_callback(struct bladerf *dev, struct bladerf_stream *stream,
struct bladerf_metadata *metadata, void *samples,
size_t num_samples, void *user_data)
{
struct test_data *my_data = (struct test_data *)user_data;
count++ ;
if( (count&0xffff) == 0 ) {
fprintf( stderr, "Called 0x%8.8x times\n", count ) ;
}
/* Save off the samples to disk if we are in RX */
if( my_data->module == BLADERF_MODULE_RX ) {
size_t i;
int16_t *sample = (int16_t *)samples ;
for(i = 0; i < num_samples ; i++ ) {
*(sample) &= 0xfff ;
if( (*sample)&0x800 ) *(sample) |= 0xf000 ;
*(sample+1) &= 0xfff ;
if( *(sample+1)&0x800 ) *(sample+1) |= 0xf000 ;
fprintf( my_data->fout, "%d, %d\n", *sample, *(sample+1) );
sample += 2 ;
}
}
my_data->samples_left -= num_samples ;
if( my_data->samples_left <= 0 ) {
shutdown_stream = true ;
}
if (shutdown_stream) {
return NULL;
} else {
void *rv = my_data->buffers[my_data->idx];
my_data->idx = (my_data->idx + 1) % my_data->num_buffers;
return rv ;
}
}
int populate_test_data(struct test_data *test_data)
{
FILE *in;
size_t i;
//ssize_t n_read;
test_data->idx = 0;
in = fopen(DATA_SOURCE, "rb");
if (!in) {
return -1;
} else {
printf( "Populating data\n" );
for(i=0;i<test_data->num_buffers;i++) {
size_t j;
int16_t *buffer = (int16_t *)test_data->buffers[i];
/*
n_read = fread(test_data->buffers[i], sizeof(int16_t) * 2,
test_data->samples_per_buffer, in);
if (n_read != (ssize_t)test_data->samples_per_buffer) {
fprintf(stderr, "Hit partial read while gathering test data\n");
fclose(in);
return -1;
}*/
for(j = 0 ; j < test_data->samples_per_buffer ; j++) {
*buffer = (j % 2048) ;
buffer++;
*buffer = -((int16_t)(j % 2048));
buffer++;
}
}
fclose(in);
return 0;
}
}
void handler(int signal)
{
if (signal == SIGTERM || signal == SIGINT) {
shutdown_stream = true;
printf("Caught signal, canceling transfers\n");
fflush(stdout);
}
}
int main(int argc, char *argv[])
{
int status;
unsigned int actual;
struct bladerf *dev;
struct bladerf_stream *stream;
struct test_data test_data;
bool conv_ok;
if (argc != 4 && argc != 5) {
fprintf(stderr,
"Usage: %s [tx|rx] <samples per buffer> <# buffers> [# samples]\n", argv[0]);
return EXIT_FAILURE;
}
if (strcasecmp(argv[1], "rx") == 0 ) {
test_data.module = BLADERF_MODULE_RX ;
} else if (strcasecmp(argv[1], "tx") == 0 ) {
test_data.module = BLADERF_MODULE_TX;
} else {
fprintf(stderr, "Invalid module: %s\n", argv[1]);
return EXIT_FAILURE;
}
test_data.idx = 0;
test_data.fout = NULL;
test_data.samples_per_buffer = str2int(argv[2], 1, INT_MAX, &conv_ok);
if (!conv_ok) {
fprintf(stderr, "Invalid samples per buffer value: %s\n", argv[2]);
return EXIT_FAILURE;
}
test_data.num_buffers = str2int(argv[3], 1, INT_MAX, &conv_ok);
if (!conv_ok) {
fprintf(stderr, "Invalid # buffers: %s\n", argv[3]);
return EXIT_FAILURE;
}
test_data.samples_left = 20e3;
if(argc == 5) {
test_data.samples_left = str2int(argv[4], 1, INT_MAX, &conv_ok);
if(!conv_ok) {
fprintf(stderr, "Invalid number of samples: %s\n", argv[4]);
return EXIT_FAILURE;
}
}
if (signal(SIGINT, handler) == SIG_ERR ||
signal(SIGTERM, handler) == SIG_ERR) {
fprintf(stderr, "Failed to set up signal handler\n");
return EXIT_FAILURE;
}
status = bladerf_open(&dev, NULL);
if (status < 0) {
fprintf(stderr, "Failed to open device: %s\n", bladerf_strerror(status));
return EXIT_FAILURE;
}
status = bladerf_is_fpga_configured(dev);
if (status < 0) {
fprintf(stderr, "Failed to determine FPGA state: %s\n",
bladerf_strerror(status));
return EXIT_FAILURE;
} else if (status == 0) {
fprintf(stderr, "Error: FPGA is not loaded.\n");
bladerf_close(dev);
return EXIT_FAILURE;
}
status = bladerf_set_frequency(dev, test_data.module, 1000000000);
if (status != 0) {
fprintf(stderr, "Failed to set frequency: %s\n",
bladerf_strerror(status));
bladerf_close(dev);
return EXIT_FAILURE;
}
status = bladerf_set_sample_rate(dev, test_data.module, 4000000, &actual);
if (status != 0) {
fprintf(stderr, "Failed to set sample rate: %s\n",
bladerf_strerror(status));
bladerf_close(dev);
return EXIT_FAILURE;
}
/* Initialize the stream */
status = bladerf_init_stream(
&stream,
dev,
stream_callback,
&test_data.buffers,
test_data.num_buffers,
BLADERF_FORMAT_SC16_Q11,
test_data.samples_per_buffer,
test_data.num_buffers,
&test_data
);
if (status != 0) {
fprintf(stderr, "Failed to init stream: %s\n",
bladerf_strerror(status));
bladerf_close(dev);
return EXIT_FAILURE;
}
/* Populate buffers with test data */
if( test_data.module == BLADERF_MODULE_TX ) {
if (populate_test_data(&test_data) ) {
fprintf(stderr, "Failed to populated test data\n");
bladerf_deinit_stream(stream);
bladerf_close(dev);
return EXIT_FAILURE;
}
} else {
/* Open up file we'll read test data to */
test_data.fout = fopen( "samples.txt", "w" );
if (!test_data.fout) {
fprintf(stderr, "Failed to open samples.txt: %s\n", strerror(errno));
bladerf_deinit_stream(stream);
bladerf_close(dev);
return EXIT_FAILURE;
}
}
status = bladerf_enable_module(dev, test_data.module, true);
if (status < 0) {
fprintf(stderr, "Failed to enable module: %s\n",
bladerf_strerror(status));
bladerf_deinit_stream(stream);
bladerf_close(dev);
return EXIT_FAILURE;
}
status = bladerf_stream(stream, test_data.module);
if (status < 0) {
fprintf(stderr, "Stream error: %s\n", bladerf_strerror(status));
}
status = bladerf_enable_module(dev, test_data.module, false);
if (status < 0) {
fprintf(stderr, "Failed to enable module: %s\n",
bladerf_strerror(status));
}
bladerf_deinit_stream(stream);
bladerf_close(dev);
if (test_data.fout) {
fclose(test_data.fout);
}
return 0;
}