diff --git a/host/libraries/libbladeRF_test/CMakeLists.txt b/host/libraries/libbladeRF_test/CMakeLists.txt index 87aa3e4a..723b05d9 100644 --- a/host/libraries/libbladeRF_test/CMakeLists.txt +++ b/host/libraries/libbladeRF_test/CMakeLists.txt @@ -11,6 +11,7 @@ add_subdirectory(test_open) add_subdirectory(test_peripheral_timing) add_subdirectory(test_repeater) add_subdirectory(test_quick_retune) +add_subdirectory(test_repeated_stream) add_subdirectory(test_rx_discont) add_subdirectory(test_scheduled_retune) add_subdirectory(test_sync) diff --git a/host/libraries/libbladeRF_test/test_repeated_stream/CMakeLists.txt b/host/libraries/libbladeRF_test/test_repeated_stream/CMakeLists.txt new file mode 100644 index 00000000..34c9c97e --- /dev/null +++ b/host/libraries/libbladeRF_test/test_repeated_stream/CMakeLists.txt @@ -0,0 +1,29 @@ +cmake_minimum_required(VERSION 2.8) +project(libbladeRF_test_repeated_stream C) + +set(INCLUDES + ${libbladeRF_SOURCE_DIR}/include + ${BLADERF_HOST_COMMON_INCLUDE_DIRS} +) + +set(SRC + src/main.c + ${BLADERF_HOST_COMMON_SOURCE_DIR}/conversions.c + ${BLADERF_HOST_COMMON_SOURCE_DIR}/devcfg.c +) + +set(LIBS libbladerf_shared) + +if(MSVC) + find_package(LibPThreadsWin32 REQUIRED) + set(INCLUDES ${INCLUDES} ${LIBPTHREADSWIN32_INCLUDE_DIRS} ${MSVC_C99_INCLUDES}) + set(LIBS ${LIBS} ${LIBPTHREADSWIN32_LIBRARIES}) + set(SRC ${SRC} ${BLADERF_HOST_COMMON_SOURCE_DIR}/windows/getopt_long.c) +else(MSVC) + find_package(Threads REQUIRED) + set(LIBS ${LIBS} ${CMAKE_THREAD_LIBS_INIT}) +endif(MSVC) + +include_directories(${INCLUDES}) +add_executable(libbladeRF_test_repeated_stream ${SRC}) +target_link_libraries(libbladeRF_test_repeated_stream ${LIBS}) diff --git a/host/libraries/libbladeRF_test/test_repeated_stream/src/main.c b/host/libraries/libbladeRF_test/test_repeated_stream/src/main.c new file mode 100644 index 00000000..f287c064 --- /dev/null +++ b/host/libraries/libbladeRF_test/test_repeated_stream/src/main.c @@ -0,0 +1,295 @@ +/* + * This file is part of the bladeRF project: + * http://www.github.com/nuand/bladeRF + * + * Copyright (C) 2015 Nuand LLC + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +/* This program repeatedly starts, runs, and stops RX/TX streams. */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "devcfg.h" +#include "conversions.h" +#include "minmax.h" + + +#define OPTIONS DEVCFG_OPTIONS_BASE "r:S:" + +const char help_prefix[] = +"Repeated stream test - Repeatedly start, run, and stop streams\n" +"Usage: libbladeRF_test_repeated_stream [options]\n\n" +" --rx Run a receive stream.\n" +" --tx Run a transmit stream.\n" +" -r, --repeat Number of repetitions. Default: 1000\n" +" -S, --samples Number of samples to process per iteration.\n" +" Default: 1000000\n"; + +#define OPTION_REPEAT 'r' +#define OPTION_NUM_SAMPLES 'S' +#define OPTION_RX 0xa0 +#define OPTION_TX 0xa1 + + +const struct option app_options[] = { + { "repeat", required_argument, 0, OPTION_REPEAT }, + { "samples", required_argument, 0, OPTION_NUM_SAMPLES }, + { "rx", no_argument, 0, OPTION_RX }, + { "tx", no_argument, 0, OPTION_TX }, + { 0, 0, 0, 0 }, +}; + +struct app_params { + struct bladerf *device; + struct devcfg cfg; + unsigned int repeat; + unsigned int num_samples; + bool rx; + bool tx; +}; + +static int handle_app_args(int argc, char *argv[], + const struct option *options, struct app_params *p) +{ + int c; + bool ok; + + optind = 1; + + while ((c = getopt_long(argc, argv, OPTIONS, options, NULL)) != -1) { + switch (c) { + case OPTION_REPEAT: + p->repeat = str2uint(optarg, 1, UINT_MAX, &ok); + if (!ok) { + fprintf(stderr, "Invalid repeat count: %s\n", optarg); + return -1; + } + break; + + case OPTION_NUM_SAMPLES: + p->num_samples = + (unsigned int) str2double(optarg, 1, UINT_MAX, &ok); + + if (!ok) { + fprintf(stderr, "Invalid sample count: %s\n", optarg); + return -1; + } + break; + + case OPTION_RX: + p->rx = true; + break; + + case OPTION_TX: + p->tx = true; + break; + } + } + + if (!p->rx && !p->tx) { + fprintf(stderr, "Error: --rx or --tx must be specified.\n"); + return -1; + } + + return 0; +} + +void * rx_task(void *arg) +{ + const struct app_params *p = (const struct app_params *) arg; + unsigned int samples_left; + unsigned int to_rx; + unsigned int iteration; + int status = 0; + + int16_t *samples = malloc(2 * sizeof(int16_t) * p->cfg.samples_per_buffer); + if (!samples) { + perror("malloc"); + goto out; + } + + for (iteration = 0; iteration < p->repeat; iteration++) { + status = devcfg_perform_sync_config(p->device, + BLADERF_MODULE_RX, + BLADERF_FORMAT_SC16_Q11, + &p->cfg, true); + if (status != 0) { + goto out; + } + + samples_left = p->num_samples; + + while (samples_left != 0) { + to_rx = uint_min(samples_left, p->cfg.samples_per_buffer); + status = bladerf_sync_rx(p->device, samples, to_rx, + NULL, 2 * p->cfg.sync_timeout_ms); + + if (status != 0) { + fprintf(stderr, "bladerf_sync_rx failed with: %s\n", + bladerf_strerror(status)); + goto out; + } + + samples_left -= to_rx; + } + + bladerf_enable_module(p->device, BLADERF_MODULE_RX, false); + printf("RX iteration %u complete.\r\n", iteration + 1 ); + } + +out: + free(samples); + return NULL; +} + +void * tx_task(void *arg) +{ + const struct app_params *p = (const struct app_params *) arg; + unsigned int samples_left; + unsigned int to_tx; + unsigned int iteration; + int status = 0; + + int16_t *samples = calloc(p->cfg.samples_per_buffer, 2 * sizeof(int16_t)); + if (!samples) { + perror("malloc"); + goto out; + } + + for (iteration = 0; iteration < p->repeat; iteration++) { + status = devcfg_perform_sync_config(p->device, + BLADERF_MODULE_TX, + BLADERF_FORMAT_SC16_Q11, + &p->cfg, true); + if (status != 0) { + goto out; + } + + samples_left = p->num_samples; + + while (samples_left != 0) { + to_tx = uint_min(samples_left, p->cfg.samples_per_buffer); + status = bladerf_sync_tx(p->device, samples, to_tx, + NULL, 2 * p->cfg.sync_timeout_ms); + + if (status != 0) { + fprintf(stderr, "bladerf_sync_tx failed with: %s\n", + bladerf_strerror(status)); + goto out; + } + + samples_left -= to_tx; + } + + bladerf_enable_module(p->device, BLADERF_MODULE_TX, false); + printf("TX iteration %u complete.\r\n", iteration + 1 ); + } + +out: + free(samples); + return NULL; +} + +int main(int argc, char *argv[]) +{ + int status = EXIT_FAILURE; + struct option *options = NULL; + struct app_params params; + pthread_t rx_thread; + pthread_t tx_thread; + + params.rx = false; + params.tx = false; + params.repeat = 1000; + params.num_samples = 1000000; + params.device = NULL; + + devcfg_init(¶ms.cfg); + + options = devcfg_get_long_options(app_options); + if (options == NULL) { + fprintf(stderr, "Failed to initialize options array!\n"); + return EXIT_FAILURE; + } + + status = devcfg_handle_args(argc, argv, OPTIONS, options, ¶ms.cfg); + if (status < 0) { + goto out; + } else if (status == 1) { + status = 0; + devcfg_print_common_help(help_prefix); + putchar('\n'); + goto out; + } + + status = handle_app_args(argc, argv, options, ¶ms); + if (status != 0) { + goto out; + } + + status = bladerf_open(¶ms.device, params.cfg.device_specifier); + if (status != 0) { + fprintf(stderr, "Unable to open device: %s\n", bladerf_strerror(status)); + goto out; + } + + status = devcfg_apply(params.device, ¶ms.cfg); + if (status != 0) { + goto out; + } + + if (params.rx) { + status = pthread_create(&rx_thread, NULL, rx_task, ¶ms); + if (status != 0) { + fprintf(stderr, "Failed to launch RX thread: %s\n", strerror(status)); + params.rx = false; + } + } + + if (params.tx) { + status = pthread_create(&tx_thread, NULL, tx_task, ¶ms); + if (status != 0) { + fprintf(stderr, "Failed to launch TX thread: %s\n", strerror(status)); + params.tx = false; + } + } + + if (params.rx) { + pthread_join(rx_thread, NULL); + } + + if (params.tx) { + pthread_join(tx_thread, NULL); + } + +out: + bladerf_close(params.device); + free(options); + return status; +}