int enable(struct bladerf* dev, bool enabled)
{
int status;
if(enabled)
printf("%-50s", "Enabling TX... ");
else
printf("%-50s", "Disabling TX... ");
fflush(stdout);
status = bladerf_enable_module(dev, BLADERF_MODULE_TX, enabled);
if(status) {
printf(KRED "Failed: %s" KNRM "\n", bladerf_strerror(status));
bladerf_close(dev);
return 1;
}
printf(KGRN "OK" KNRM "\n");
if(enabled)
printf("%-50s", "Enabling RX... ");
else
printf("%-50s", "Disabling RX... ");
fflush(stdout);
status = bladerf_enable_module(dev, BLADERF_MODULE_RX, enabled);
if(status) {
printf(KRED "Failed: %s" KNRM "\n", bladerf_strerror(status));
bladerf_close(dev);
return 1;
}
printf(KGRN "OK" KNRM "\n");
return 0;
}
int setup_tx_stream(struct bladerf* dev, struct bladerf_stream** stream,
struct bladerf_stream_data* stream_data)
{
int status;
stream_data->next_buffer = 0;
stream_data->module = BLADERF_MODULE_TX;
printf("%-50s", "Initialising TX data stream... ");
fflush(stdout);
status = bladerf_init_stream(stream, dev, stream_cb,
&stream_data->buffers,
stream_data->num_buffers,
BLADERF_FORMAT_SC16_Q12,
stream_data->samples_per_buffer,
stream_data->num_transfers, stream_data);
if(status) {
printf(KRED "Failed: %s" KNRM "\n", bladerf_strerror(status));
bladerf_close(dev);
return 1;
}
fill_tx_buffers(stream_data);
printf(KGRN "OK" KNRM "\n");
return 0;
}
void config_deinit(struct config *config)
{
if (config == NULL) {
pr_dbg("%s: NULL ptr\n", __FUNCTION__);
return;
}
pr_dbg("Deinitializing...\n");
if (config->bladerf_dev != NULL) {
pr_dbg("\tClosing bladerf.\n");
bladerf_close(config->bladerf_dev);
config->bladerf_dev = NULL;
}
if (config->rx_output != NULL) {
fclose(config->rx_output);
config->rx_output = NULL;
}
if (config->tx_input != NULL) {
fclose(config->tx_input);
config->tx_input = NULL;
}
free(config);
}
int main(int argc, char *argv[])
{
int status = -1;
struct bladerf *dev = NULL;
const char *devstr = NULL;
if (argc == 2) {
if (!strcasecmp("-h", argv[1]) || !strcasecmp("--help", argv[1])) {
usage(argv[0]);
return 0;
} else {
devstr = argv[1];
}
} else if (argc > 1) {
usage(argv[0]);
return -1;
}
dev = example_init(devstr);
if (dev) {
printf("Running...\n");
status = sync_rx_example(dev);
printf("Closing the device...\n");
bladerf_close(dev);
}
return status;
}
void Bladerf1Output::closeDevice()
{
int res;
if (m_dev == 0) { // was never open
return;
}
if ((res = bladerf_enable_module(m_dev, BLADERF_MODULE_TX, false)) < 0)
{
qCritical("BladerfOutput::closeDevice: bladerf_enable_module with return code %d", res);
}
if (m_deviceAPI->getSourceBuddies().size() == 0)
{
qDebug("BladerfOutput::closeDevice: closing device since Rx side is not open");
if (m_dev != 0) // close BladeRF
{
bladerf_close(m_dev);
}
}
m_sharedParams.m_dev = 0;
m_dev = 0;
}
static int flash_fw(struct rc_config *rc, struct cli_state *state, int status)
{
if (!status && rc->fw_file) {
if (!state->dev) {
print_error_need_devarg();
status = -1;
} else {
printf("Flashing firmware...\n");
status = bladerf_flash_firmware(state->dev, rc->fw_file);
if (status) {
fprintf(stderr, "Error: failed to flash firmware: %s\n",
bladerf_strerror(status));
} else {
printf("Done.\n");
}
bladerf_device_reset(state->dev);
bladerf_close(state->dev);
state->dev = NULL;
}
}
/* TODO Do we have to fire off some sort of reset after flashing
* the firmware, and before loading the FPGA? */
return status;
}
// Close BladeRF device.
BladeRFSource::~BladeRFSource()
{
if (m_dev) {
bladerf_close(m_dev);
}
m_this = 0;
}
BladeRfTxComponent::~BladeRfTxComponent()
{
if (device_) {
if (bladerf_enable_module(device_, BLADERF_MODULE_TX, false) != 0)
LOG(LERROR) << "Couldn't shutdown BladeRF Tx module!";
bladerf_close(device_);
}
}
PluginInterface::SamplingDevices BladeRF2OutputPlugin::enumSampleSinks()
{
SamplingDevices result;
struct bladerf_devinfo *devinfo = 0;
int count = bladerf_get_device_list(&devinfo);
if (devinfo)
{
for(int i = 0; i < count; i++)
{
struct bladerf *dev;
int status = bladerf_open_with_devinfo(&dev, &devinfo[i]);
if (status == BLADERF_ERR_NODEV)
{
qCritical("Bladerf2OutputPlugin::enumSampleSinks: No device at index %d", i);
continue;
}
else if (status != 0)
{
qCritical("Bladerf2OutputPlugin::enumSampleSinks: Failed to open device at index %d", i);
continue;
}
const char *boardName = bladerf_get_board_name(dev);
if (strcmp(boardName, "bladerf2") == 0)
{
unsigned int nbTxChannels = bladerf_get_channel_count(dev, BLADERF_TX);
for (unsigned int j = 0; j < nbTxChannels; j++)
{
qDebug("Blderf2InputPlugin::enumSampleSinks: device #%d (%s) channel %u", i, devinfo[i].serial, j);
QString displayedName(QString("BladeRF2[%1:%2] %3").arg(devinfo[i].instance).arg(j).arg(devinfo[i].serial));
result.append(SamplingDevice(displayedName,
m_hardwareID,
m_deviceTypeID,
QString(devinfo[i].serial),
i,
PluginInterface::SamplingDevice::PhysicalDevice,
false,
nbTxChannels,
j));
}
}
bladerf_close(dev);
}
bladerf_free_device_list(devinfo); // Valgrind memcheck
}
return result;
}
/* Usage:
* open [device identifier items]
*
* It's a bit silly, but we just merge all the argv items into the
* device identifier string here.
*/
int cmd_open(struct cli_state *state, int argc, char **argv)
{
char *dev_ident = NULL;
size_t dev_ident_len;
int i;
int status;
int ret;
/* Disallow opening of a diffrent device if the current one is doing work */
if (cli_device_in_use(state)) {
return CMD_RET_BUSY;
}
if (state->dev) {
bladerf_close(state->dev);
}
/* We have some device indentifer items */
if (argc > 1) {
dev_ident_len = argc - 2; /* # spaces to place between args */
for (i = 1; i < argc; i++) {
dev_ident_len += strlen(argv[i]);
}
/* Room for '\0' terminator */
dev_ident_len++;
dev_ident = calloc(dev_ident_len, 1);
if (!dev_ident) {
return CMD_RET_MEM;
}
for (i = 1; i < argc; i++) {
strncat(dev_ident, argv[i], (dev_ident_len - 1 - strlen(dev_ident)));
if (i != (argc - 1)) {
dev_ident[strlen(dev_ident)] = ' ';
}
}
printf("Using device string: %s\n", dev_ident);
}
status = bladerf_open(&state->dev, dev_ident);
if (status) {
state->last_lib_error = status;
ret = CMD_RET_LIBBLADERF;
} else {
ret = 0;
}
free(dev_ident);
return ret;
}
void cli_state_destroy(struct cli_state *s)
{
if (s) {
if (s->dev) {
bladerf_close(s->dev);
}
rxtx_data_free(s->rxtx_data);
free(s);
}
}
PluginInterface::SamplingDevices Blderf1InputPlugin::enumSampleSources()
{
SamplingDevices result;
struct bladerf_devinfo *devinfo = 0;
int count = bladerf_get_device_list(&devinfo);
if (devinfo)
{
for(int i = 0; i < count; i++)
{
struct bladerf *dev;
int status = bladerf_open_with_devinfo(&dev, &devinfo[i]);
if (status == BLADERF_ERR_NODEV)
{
qCritical("BlderfInputPlugin::enumSampleSources: No device at index %d", i);
continue;
}
else if (status != 0)
{
qCritical("BlderfInputPlugin::enumSampleSources: Failed to open device at index %d", i);
continue;
}
const char *boardName = bladerf_get_board_name(dev);
if (strcmp(boardName, "bladerf1") == 0)
{
QString displayedName(QString("BladeRF1[%1] %2").arg(devinfo[i].instance).arg(devinfo[i].serial));
result.append(SamplingDevice(displayedName,
m_hardwareID,
m_deviceTypeID,
QString(devinfo[i].serial),
i,
PluginInterface::SamplingDevice::PhysicalDevice,
true,
1,
0));
}
bladerf_close(dev);
}
bladerf_free_device_list(devinfo); // Valgrind memcheck
}
return result;
}
int main(int argc, char *argv[])
{
int status;
struct app_params p;
struct bladerf *dev = NULL;
size_t i;
init_app_params(&p);
status = handle_args(argc, argv, &p);
if (status != 0) {
if (status == 1) {
usage(argv[0]);
status = 0;
}
goto out;
}
status = bladerf_open(&dev, p.device_str);
if (status != 0) {
fprintf(stderr, "Failed to open device: %s\n",
bladerf_strerror(status));
goto out;
}
status = apply_params(dev, &p);
if (status != 0) {
goto out;
}
for (i = 0; i < ARRAY_SIZE(tests); i++) {
if (!strcasecmp(p.test_name, tests[i]->name)) {
status = tests[i]->run(dev, &p);
break;
}
}
if (i >= ARRAY_SIZE(tests)) {
fprintf(stderr, "Unknown test: %s\n", p.test_name);
status = -1;
}
out:
if (dev != NULL) {
bladerf_close(dev);
}
deinit_app_params(&p);
return status;
}
/** [tx_meta_deinit] */
void deinit(struct bladerf *dev, int16_t *samples)
{
printf("\nDeinitalizing device.\n");
/* Disable TX module, shutting down our underlying TX stream */
int status = bladerf_enable_module(dev, BLADERF_MODULE_TX, false);
if (status != 0) {
fprintf(stderr, "Failed to disable TX module: %s\n",
bladerf_strerror(status));
}
/* Deinitialize and free resources */
free(samples);
bladerf_close(dev);
}
static void deinit(struct repeater *repeater)
{
if (repeater->device) {
if (repeater->rx_stream) {
bladerf_deinit_stream(repeater->rx_stream);
}
if (repeater->tx_stream) {
bladerf_deinit_stream(repeater->tx_stream);
}
bladerf_enable_module(repeater->device, BLADERF_MODULE_RX, false);
bladerf_enable_module(repeater->device, BLADERF_MODULE_TX, false);
bladerf_close(repeater->device);
repeater->device = NULL;
}
}
int main(int argc, char *argv[])
{
int status = 0;
struct bladerf *dev = NULL;
struct bladerf_devinfo dev_info;
/* Initialize the information used to identify the desired device
* to all wildcard (i.e., "any device") values */
bladerf_init_devinfo(&dev_info);
/* Request a device with the provided serial number.
* Invalid strings should simply fail to match a device. */
if (argc >= 2) {
fprintf(stdout, "dev_info.serial: %s", dev_info.serial);
strncpy(dev_info.serial, argv[1], sizeof(dev_info.serial) - 1);
}
status = bladerf_open_with_devinfo(&dev, &dev_info);
if (status != 0) {
fprintf(stderr, "Unable to open device: %s\n",
bladerf_strerror(status));
return 1;
}
/* A quick check that this works is to watch LO leakage on a VSA */
status = bladerf_enable_module(dev, BLADERF_MODULE_TX, true);
if (status != 0) {
fprintf(stderr, "Failed to enable TX module: %s\n",
bladerf_strerror(status));
return status;
}
status = example(dev, BLADERF_MODULE_TX);
bladerf_enable_module(dev, BLADERF_MODULE_TX, false);
bladerf_close(dev);
return status;
}
void cli_state_destroy(struct cli_state *s)
{
if (s) {
if (s->rx) {
rxtx_shutdown(s->rx);
rxtx_data_free(s->rx);
s->rx = NULL;
}
if (s->tx) {
rxtx_shutdown(s->tx);
rxtx_data_free(s->tx);
s->tx = NULL;
}
if (s->dev) {
bladerf_close(s->dev);
}
free(s);
}
}
static int flash_fw(struct rc_config *rc, struct cli_state *state, int status)
{
if (!status && rc->fw_file) {
if (!state->dev) {
print_error_need_devarg();
status = -1;
} else {
printf("Flashing firmware...\n");
status = bladerf_flash_firmware(state->dev, rc->fw_file);
if (status) {
fprintf(stderr, "Error: failed to flash firmware: %s\n",
bladerf_strerror(status));
} else {
printf("Done. "
"A power cycle is required for this to take effect.\n");
}
bladerf_close(state->dev);
state->dev = NULL;
}
}
return status;
}
int main(int argc, char *argv[])
{
sim_t s;
char *devstr = NULL;
int c;
int result;
double duration;
datetime_t t0;
if (argc<3)
{
usage();
exit(1);
}
s.opt.navfile[0] = 0;
s.opt.umfile[0] = 0;
s.opt.g0.week = -1;
s.opt.g0.sec = 0.0;
s.opt.iduration = USER_MOTION_SIZE;
s.opt.verb = TRUE;
s.opt.nmeaGGA = FALSE;
s.opt.staticLocationMode = TRUE; // default user motion
s.opt.llh[0] = 35.274016 / R2D;
s.opt.llh[1] = 137.013765 / R2D;
s.opt.llh[2] = 100.0;
while ((result=getopt(argc,argv,"e:u:g:l:t:d:"))!=-1)
{
switch (result)
{
case 'e':
strcpy(s.opt.navfile, optarg);
break;
case 'u':
strcpy(s.opt.umfile, optarg);
s.opt.nmeaGGA = FALSE;
s.opt.staticLocationMode = FALSE;
break;
case 'g':
strcpy(s.opt.umfile, optarg);
s.opt.nmeaGGA = TRUE;
s.opt.staticLocationMode = FALSE;
break;
case 'l':
// Static geodetic coordinates input mode
// Added by [email protected]
s.opt.nmeaGGA = FALSE;
s.opt.staticLocationMode = TRUE;
sscanf(optarg,"%lf,%lf,%lf",&s.opt.llh[0],&s.opt.llh[1],&s.opt.llh[2]);
s.opt.llh[0] /= R2D; // convert to RAD
s.opt.llh[1] /= R2D; // convert to RAD
break;
case 't':
sscanf(optarg, "%d/%d/%d,%d:%d:%lf", &t0.y, &t0.m, &t0.d, &t0.hh, &t0.mm, &t0.sec);
if (t0.y<=1980 || t0.m<1 || t0.m>12 || t0.d<1 || t0.d>31 ||
t0.hh<0 || t0.hh>23 || t0.mm<0 || t0.mm>59 || t0.sec<0.0 || t0.sec>=60.0)
{
printf("ERROR: Invalid date and time.\n");
exit(1);
}
t0.sec = floor(t0.sec);
date2gps(&t0, &s.opt.g0);
break;
case 'd':
duration = atof(optarg);
if (duration<0.0 || duration>((double)USER_MOTION_SIZE)/10.0)
{
printf("ERROR: Invalid duration.\n");
exit(1);
}
s.opt.iduration = (int)(duration*10.0+0.5);
break;
case ':':
case '?':
usage();
exit(1);
default:
break;
}
}
if (s.opt.navfile[0]==0)
{
printf("ERROR: GPS ephemeris file is not specified.\n");
exit(1);
}
if (s.opt.umfile[0]==0 && !s.opt.staticLocationMode)
{
printf("ERROR: User motion file / NMEA GGA stream is not specified.\n");
printf("You may use -l to specify the static location directly.\n");
exit(1);
}
// Initialize simulator
init_sim(&s);
// Allocate TX buffer to hold each block of samples to transmit.
s.tx.buffer = (int16_t *)malloc(SAMPLES_PER_BUFFER * sizeof(int16_t) * 2); // for 16-bit I and Q samples
if (s.tx.buffer == NULL) {
fprintf(stderr, "Failed to allocate TX buffer.\n");
goto out;
}
// Allocate FIFOs to hold 0.1 seconds of I/Q samples each.
s.fifo = (int16_t *)malloc(FIFO_LENGTH * sizeof(int16_t) * 2); // for 16-bit I and Q samples
if (s.fifo == NULL) {
fprintf(stderr, "Failed to allocate I/Q sample buffer.\n");
goto out;
}
// Initializing device.
printf("Opening and initializing device...\n");
s.status = bladerf_open(&s.tx.dev, devstr);
if (s.status != 0) {
fprintf(stderr, "Failed to open device: %s\n", bladerf_strerror(s.status));
goto out;
}
s.status = bladerf_set_frequency(s.tx.dev, BLADERF_MODULE_TX, TX_FREQUENCY);
if (s.status != 0) {
fprintf(stderr, "Faield to set TX frequency: %s\n", bladerf_strerror(s.status));
goto out;
}
else {
printf("TX frequency: %u Hz\n", TX_FREQUENCY);
}
s.status = bladerf_set_sample_rate(s.tx.dev, BLADERF_MODULE_TX, TX_SAMPLERATE, NULL);
if (s.status != 0) {
fprintf(stderr, "Failed to set TX sample rate: %s\n", bladerf_strerror(s.status));
goto out;
}
else {
printf("TX sample rate: %u sps\n", TX_SAMPLERATE);
}
s.status = bladerf_set_bandwidth(s.tx.dev, BLADERF_MODULE_TX, TX_BANDWIDTH, NULL);
if (s.status != 0) {
fprintf(stderr, "Failed to set TX bandwidth: %s\n", bladerf_strerror(s.status));
goto out;
}
else {
printf("TX bandwidth: %u Hz\n", TX_BANDWIDTH);
}
s.status = bladerf_set_txvga1(s.tx.dev, TX_VGA1);
if (s.status != 0) {
fprintf(stderr, "Failed to set TX VGA1 gain: %s\n", bladerf_strerror(s.status));
goto out;
}
else {
printf("TX VGA1 gain: %d dB\n", TX_VGA1);
}
s.status = bladerf_set_txvga2(s.tx.dev, TX_VGA2);
if (s.status != 0) {
fprintf(stderr, "Failed to set TX VGA2 gain: %s\n", bladerf_strerror(s.status));
goto out;
}
else {
printf("TX VGA2 gain: %d dB\n", TX_VGA2);
}
// Start GPS task.
s.status = start_gps_task(&s);
if (s.status < 0) {
fprintf(stderr, "Failed to start GPS task.\n");
goto out;
}
else
printf("Creating GPS task...\n");
// Wait until GPS task is initialized
pthread_mutex_lock(&(s.tx.lock));
while (!s.gps.ready)
pthread_cond_wait(&(s.gps.initialization_done), &(s.tx.lock));
pthread_mutex_unlock(&(s.tx.lock));
// Fillfull the FIFO.
if (is_fifo_write_ready(&s))
pthread_cond_signal(&(s.fifo_write_ready));
// Configure the TX module for use with the synchronous interface.
s.status = bladerf_sync_config(s.tx.dev,
BLADERF_MODULE_TX,
BLADERF_FORMAT_SC16_Q11,
NUM_BUFFERS,
SAMPLES_PER_BUFFER,
NUM_TRANSFERS,
TIMEOUT_MS);
if (s.status != 0) {
fprintf(stderr, "Failed to configure TX sync interface: %s\n", bladerf_strerror(s.status));
goto out;
}
// We must always enable the modules *after* calling bladerf_sync_config().
s.status = bladerf_enable_module(s.tx.dev, BLADERF_MODULE_TX, true);
if (s.status != 0) {
fprintf(stderr, "Failed to enable TX module: %s\n", bladerf_strerror(s.status));
goto out;
}
// Start TX task
s.status = start_tx_task(&s);
if (s.status < 0) {
fprintf(stderr, "Failed to start TX task.\n");
goto out;
}
else
printf("Creating TX task...\n");
// Running...
printf("Running...\n");
printf("Press 'q' to exit.\n");
while (1) {
c = _getch();
if (c=='q')
break;
}
//
// TODO: Cleaning up the threads properly.
//
printf("\nDone!\n");
// Disable TX module, shutting down our underlying TX stream.
s.status = bladerf_enable_module(s.tx.dev, BLADERF_MODULE_TX, false);
if (s.status != 0) {
fprintf(stderr, "Failed to disable TX module: %s\n", bladerf_strerror(s.status));
}
out:
// Free up resources
if (s.tx.buffer != NULL)
free(s.tx.buffer);
if (s.fifo != NULL)
free(s.fifo);
printf("Closing device...\n");
bladerf_close(s.tx.dev);
return(0);
}
int configure_bladerf(struct bladerf** dev, struct bladerf_config* config)
{
unsigned int abw, asr;
int status;
setlocale(LC_NUMERIC, "");
printf("%-50s", "Connecting to device... ");
fflush(stdout);
status = bladerf_open(dev, NULL);
if(status) {
printf(KRED "Failed: %s" KNRM "\n", bladerf_strerror(status));
return 1;
}
printf(KGRN "OK" KNRM "\n");
printf("%-50s", "Checking FPGA status... ");
fflush(stdout);
status = bladerf_is_fpga_configured(*dev);
if(status < 0) {
printf(KRED "Failed: %s" KNRM "\n", bladerf_strerror(status));
bladerf_close(*dev);
return 1;
} else if(status == 0) {
printf(KRED "Failed: FPGA not loaded" KNRM "\n");
bladerf_close(*dev);
return 1;
}
printf(KGRN "OK" KNRM "\n");
printf("%-30s %'13uHz... ", "Tuning TX to:", config->tx_freq);
fflush(stdout);
status = bladerf_set_frequency(*dev, BLADERF_MODULE_TX, config->tx_freq);
if(status) {
printf(KRED "Failed: %s" KNRM "\n", bladerf_strerror(status));
bladerf_close(*dev);
return 1;
}
printf(KGRN "OK" KNRM "\n");
printf("%-30s %'13uHz... ", "Tuning RX to:", config->rx_freq);
fflush(stdout);
status = bladerf_set_frequency(*dev, BLADERF_MODULE_RX, config->rx_freq);
if(status) {
printf(KRED "Failed: %s" KNRM "\n", bladerf_strerror(status));
bladerf_close(*dev);
return 1;
}
printf(KGRN "OK" KNRM "\n");
printf("%-30s %'13uHz... ", "Setting TX bandwidth to:", config->tx_bw);
fflush(stdout);
status = bladerf_set_bandwidth(*dev, BLADERF_MODULE_TX,
config->tx_bw, &abw);
if(status) {
printf(KRED "Failed: %s" KNRM "\n", bladerf_strerror(status));
bladerf_close(*dev);
return 1;
}
printf(KGRN "OK" KNRM "\n");
printf("%-30s %'13uHz\n", "Actual bandwidth:", abw);
if(abw != config->tx_bw) {
printf("Actual bandwidth not equal to desired bandwidth, quitting.\n");
return 1;
}
printf("%-30s %'13uHz... ", "Setting RX bandwidth to:", config->rx_bw);
fflush(stdout);
status = bladerf_set_bandwidth(*dev, BLADERF_MODULE_RX,
config->rx_bw, &abw);
if(status) {
printf(KRED "Failed: %s" KNRM "\n", bladerf_strerror(status));
bladerf_close(*dev);
return 1;
}
printf(KGRN "OK" KNRM "\n");
printf("%-30s %'13uHz\n", "Actual bandwidth:", abw);
if(abw != config->rx_bw) {
printf("Actual bandwidth not equal to desired bandwidth, quitting.\n");
return 1;
}
printf("%-30s %'12usps... ", "Setting TX sampling rate to:",
config->tx_sr);
fflush(stdout);
status = bladerf_set_sample_rate(*dev, BLADERF_MODULE_TX,
config->tx_sr, &asr);
if(status) {
printf(KRED "Failed: %s" KNRM "\n", bladerf_strerror(status));
bladerf_close(*dev);
return 1;
}
printf(KGRN "OK" KNRM "\n");
printf("%-30s %'12usps\n", "Actual sampling rate:", asr);
if(asr != config->tx_sr) {
printf("Actual sampling rate not equal to desired sampling rate, "
"quitting.\n");
return 1;
}
printf("%-30s %'12usps... ", "Setting RX sampling rate to:",
config->rx_sr);
fflush(stdout);
status = bladerf_set_sample_rate(*dev, BLADERF_MODULE_RX,
config->rx_sr, &asr);
if(status) {
printf(KRED "Failed: %s" KNRM "\n", bladerf_strerror(status));
bladerf_close(*dev);
return 1;
}
printf(KGRN "OK" KNRM "\n");
printf("%-30s %'12usps\n", "Actual sampling rate:", asr);
if(asr != config->rx_sr) {
printf("Actual sampling rate not equal to desired sampling rate, "
"quitting.\n");
return 1;
}
printf("%-30s %+13ddB... ", "Setting TXVGA1 gain to:", config->txvga1);
fflush(stdout);
status = bladerf_set_txvga1(*dev, config->txvga1);
if(status) {
printf(KRED "Failed: %s" KNRM "\n", bladerf_strerror(status));
bladerf_close(*dev);
return 1;
}
printf(KGRN "OK" KNRM "\n");
printf("%-30s %+13ddB... ", "Setting TXVGA2 gain to:", config->txvga2);
fflush(stdout);
status = bladerf_set_txvga2(*dev, config->txvga2);
if(status) {
printf(KRED "Failed: %s" KNRM "\n", bladerf_strerror(status));
bladerf_close(*dev);
return 1;
}
printf(KGRN "OK" KNRM "\n");
printf("%-30s %+13ddB... ", "Setting RXVGA1 gain to:", config->rxvga1);
fflush(stdout);
status = bladerf_set_rxvga1(*dev, config->rxvga1);
if(status) {
printf(KRED "Failed: %s" KNRM "\n", bladerf_strerror(status));
bladerf_close(*dev);
return 1;
}
printf(KGRN "OK" KNRM "\n");
printf("%-30s %+13ddB... ", "Setting RXVGA2 gain to:", config->rxvga2);
fflush(stdout);
status = bladerf_set_rxvga2(*dev, config->rxvga2);
if(status) {
printf(KRED "Failed: %s" KNRM "\n", bladerf_strerror(status));
bladerf_close(*dev);
return 1;
}
printf(KGRN "OK" KNRM "\n");
printf("%-30s %15d... ", "Setting LNA gain to:", config->lna);
fflush(stdout);
status = bladerf_set_lna_gain(*dev, config->lna);
if(status) {
printf(KRED "Failed: %s" KNRM "\n", bladerf_strerror(status));
bladerf_close(*dev);
return 1;
}
printf(KGRN "OK" KNRM "\n");
printf("All set up.\n");
return 0;
}
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;
}
if(test_data.module == BLADERF_MODULE_RX && 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;
}
if (!status) {
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;
}
}
if (!status) {
status = bladerf_set_sample_rate(dev, test_data.module, 40000000, &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_Q12,
test_data.samples_per_buffer,
test_data.num_buffers,
&test_data
) ;
/* 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));
}
if (!status) {
/* Start stream and stay there until we kill the stream */
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;
}
static int init_device(struct repeater *repeater, struct repeater_config *config)
{
int status;
unsigned int actual_value;
status = bladerf_open(&repeater->device, config->device_str);
if (!repeater->device) {
fprintf(stderr, "Failed to open %s: %s\n", config->device_str,
bladerf_strerror(status));
return -1;
}
status = bladerf_is_fpga_configured(repeater->device);
if (status < 0) {
fprintf(stderr, "Failed to determine if FPGA is loaded: %s\n",
bladerf_strerror(status));
goto init_device_error;
} else if (status == 0) {
fprintf(stderr, "FPGA is not loaded. Aborting.\n");
status = BLADERF_ERR_NODEV;
goto init_device_error;
}
status = bladerf_set_bandwidth(repeater->device, BLADERF_MODULE_TX,
config->bandwidth, &actual_value);
if (status < 0) {
fprintf(stderr, "Failed to set TX bandwidth: %s\n",
bladerf_strerror(status));
goto init_device_error;
} else {
printf("Actual TX bandwidth: %d Hz\n", actual_value);
}
status = bladerf_set_bandwidth(repeater->device, BLADERF_MODULE_RX,
config->bandwidth, &actual_value);
if (status < 0) {
fprintf(stderr, "Failed to set RX bandwidth: %s\n",
bladerf_strerror(status));
goto init_device_error;
} else {
printf("Actual RX bandwidth: %d Hz\n", actual_value);
}
status = bladerf_set_sample_rate(repeater->device, BLADERF_MODULE_TX,
config->sample_rate, &actual_value);
if (status < 0) {
fprintf(stderr, "Failed to set TX sample rate: %s\n",
bladerf_strerror(status));
goto init_device_error;
} else {
printf("Actual TX sample rate is %d Hz\n", actual_value);
}
status = bladerf_set_sample_rate(repeater->device, BLADERF_MODULE_RX,
config->sample_rate, &actual_value);
if (status < 0) {
fprintf(stderr, "Failed to set RX sample rate: %s\n",
bladerf_strerror(status));
goto init_device_error;
} else {
printf("Actual RX sample rate is %d Hz\n", actual_value);
}
status = bladerf_set_frequency(repeater->device,
BLADERF_MODULE_TX, config->tx_freq);
if (status < 0) {
fprintf(stderr, "Failed to set TX frequency: %s\n",
bladerf_strerror(status));
goto init_device_error;
} else {
printf("Set TX frequency to %d Hz\n", config->tx_freq);
}
status = bladerf_set_frequency(repeater->device,
BLADERF_MODULE_RX, config->rx_freq);
if (status < 0) {
fprintf(stderr, "Failed to set RX frequency: %s\n",
bladerf_strerror(status));
goto init_device_error;
} else {
printf("Set RX frequency to %d Hz\n", config->rx_freq);
}
status = bladerf_enable_module(repeater->device, BLADERF_MODULE_RX, true);
if (status < 0) {
fprintf(stderr, "Failed to enable RX module: %s\n",
bladerf_strerror(status));
goto init_device_error;
} else {
printf("Enabled RX module\n");
}
status = bladerf_enable_module(repeater->device, BLADERF_MODULE_TX, true);
if (status < 0) {
bladerf_enable_module(repeater->device, BLADERF_MODULE_RX, false);
fprintf(stderr, "Failed to enable TX module: %s\n",
bladerf_strerror(status));
goto init_device_error;
} else {
printf("Enabled TX module\n");
}
return status;
init_device_error:
bladerf_close(repeater->device);
repeater->device = NULL;
return status;
}
/* Initialization and stuff
*/
int main(int argc, char **argv)
{
struct bladerf_devinfo *devs;
struct sigaction sigact;
struct devinfo_s device;
int show_help = false;
int n, ret;
char ch;
/* Set up default values, bandwidth and num_transfers
* are automatically calculated later */
device.device_id = DEFAULT_DEVICE_ID;
device.frequency = DEFAULT_FREQUENCY;
device.samplerate = DEFAULT_SAMPLERATE;
device.bandwidth = 0;
device.txvga1 = DEFAULT_TXVGA1;
device.txvga2 = DEFAULT_TXVGA2;
device.buffers.gain = DEFAULT_GAIN;
device.buffers.again = DEFAULT_AGAIN;
device.buffers.num_buffers = DEFAULT_BUFFERS;
device.buffers.num_samples = DEFAULT_SAMPLES;
device.buffers.num_transfers = 0;
device.buffers.pos = 0;
/* Evaluate command line options */
while((ch = getopt(argc, argv, "hd:f:r:b:g:G:a:m:n:s:t:")) != -1)
{
switch(ch)
{
case 'd':
device.device_id = optarg; break;
case 'f':
device.frequency = atoi(optarg); break;
case 'r':
device.samplerate = atoi(optarg); break;
case 'b':
device.bandwidth = atoi(optarg); break;
case 'g':
device.txvga1 = atoi(optarg); break;
case 'G':
device.txvga2 = atoi(optarg); break;
case 'm':
device.buffers.gain = atof(optarg); break;
case 'a':
device.buffers.again = atof(optarg); break;
case 'n':
device.buffers.num_buffers = atoi(optarg); break;
case 's':
device.buffers.num_samples = atoi(optarg); break;
case 't':
device.buffers.num_transfers = atoi(optarg); break;
case 'h':
default:
show_help = true;
}
}
/* Now calculate bandwidth and num_transfers if the user didn't
* configure them manually */
if(device.bandwidth == 0)
device.bandwidth = device.samplerate * 3 / 4;
if(device.buffers.num_transfers == 0)
device.buffers.num_transfers = device.buffers.num_buffers / 2;
if(show_help)
{
usage(argv[0], &device);
return EXIT_FAILURE;
}
argc -= optind;
argv += optind;
/* Allocate the float input buffer */
device.buffers.fbuf =
malloc(device.buffers.num_samples * 2 * sizeof(float));
/* Set up signal handler to enable clean shutdowns */
sigact.sa_handler = sighandler;
sigemptyset(&sigact.sa_mask);
sigact.sa_flags = 0;
sigaction(SIGINT, &sigact, NULL);
sigaction(SIGTERM, &sigact, NULL);
sigaction(SIGQUIT, &sigact, NULL);
sigaction(SIGPIPE, &sigact, NULL);
/* Look for devices attached */
ret = bladerf_get_device_list(&devs);
if(ret < 1)
{
fprintf(stderr, "No devices found.\n");
return EXIT_FAILURE;
}
/* Print some information about all the devices */
for(n = 0; n < ret; n++)
{
fprintf(stderr,
"Serial:\t%s\n"
"USB bus:\t%i\n"
"USB address:\t%i\n"
"Instance:\t%i\n\n",
devs[n].serial,
devs[n].usb_bus,
devs[n].usb_addr,
devs[n].instance
);
}
/* the list is not needed any more */
bladerf_free_device_list(devs);
/* Open a device by given device string
*/
ret = bladerf_open(&device.dev, device.device_id);
if(ret != 0)
{
fprintf(stderr, "Error opening device %s: %s.\n",
device.device_id, bladerf_strerror(ret));
goto out0;
}
else
{
fprintf(stderr, "Device \"%s\" opened successfully.\n",
device.device_id);
}
/* Set the device parameters */
ret = bladerf_set_sample_rate(device.dev,
BLADERF_MODULE_TX, device.samplerate, &device.samplerate);
if(ret != 0)
{
fprintf(stderr, "Error setting sample rate to %i: %s.\n",
device.samplerate, bladerf_strerror(ret));
goto out1;
}
else
{
fprintf(stderr, "Actual sample rate is %i.\n",
device.samplerate);
}
ret = bladerf_set_frequency(device.dev,
BLADERF_MODULE_TX, device.frequency);
if(ret != 0)
{
fprintf(stderr, "Error setting frequency to %iHz: %s.\n",
device.frequency, bladerf_strerror(ret));
goto out1;
}
else
{
fprintf(stderr, "Frequency set to %iHz.\n", device.frequency);
}
ret = bladerf_set_txvga1(device.dev, device.txvga1);
if(ret != 0)
{
fprintf(stderr, "Error setting gain for txvga1: %s.\n",
bladerf_strerror(ret));
goto out1;
}
ret = bladerf_set_txvga2(device.dev, device.txvga2);
if(ret != 0)
{
fprintf(stderr, "Error setting gain for txvga2: %s.\n",
bladerf_strerror(ret));
goto out1;
}
ret = bladerf_set_bandwidth(device.dev,
BLADERF_MODULE_TX, device.bandwidth, &device.bandwidth);
if(ret != 0)
{
fprintf(stderr, "Error setting LPF bandwidth: %s.\n",
bladerf_strerror(ret));
goto out1;
}
else
{
fprintf(stderr, "Bandwidth set to %iHz.\n", device.bandwidth);
}
/* Set up the sample stream */
ret = bladerf_init_stream(&device.stream,
device.dev, stream_callback, &device.buffers.sbuf,
device.buffers.num_buffers, BLADERF_FORMAT_SC16_Q12,
device.buffers.num_samples, device.buffers.num_transfers,
&device.buffers);
if(ret != 0)
{
fprintf(stderr, "Failed setting up stream: %s.\n",
bladerf_strerror(ret));
goto out1;
}
/* Finally enable TX... */
ret = bladerf_enable_module(device.dev, BLADERF_MODULE_TX, true);
if(ret != 0)
{
fprintf(stderr, "Error enabling TX module: %s.\n",
bladerf_strerror(ret));
goto out1;
}
else
{
fprintf(stderr, "Successfully enabled TX module.\n");
}
/* ...and start the stream.
* Execution stops here until stream has finished. */
ret = bladerf_stream(device.stream, BLADERF_MODULE_TX);
if(ret != 0)
{
fprintf(stderr, "Failed starting stream: %s.\n",
bladerf_strerror(ret));
goto out2;
}
/* Cleanup the mess */
out2:
bladerf_deinit_stream(device.stream);
out1:
ret = bladerf_enable_module(device.dev, BLADERF_MODULE_TX, false);
if(ret != 0)
{
fprintf(stderr, "Error disabling TX module: %s.\n",
bladerf_strerror(ret));
}
else
{
fprintf(stderr, "Successfully disabled TX module.\n");
}
bladerf_close(device.dev);
fprintf(stderr, "Device closed.\n");
out0:
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
int status;
struct app_params p;
size_t i;
struct bladerf *dev = NULL;
bladerf_xb expected, attached;
struct stats *stats = NULL;
bool pass = true;
status = get_params(argc, argv, &p);
if (status != 0) {
if (status == 1) {
status = 0;
}
goto out;
}
for (i = 0; i < ARRAY_SIZE(tests); i++) {
if (p.test_name == NULL || !strcasecmp(p.test_name, tests[i]->name)) {
break;
}
}
if (i >= ARRAY_SIZE(tests)) {
fprintf(stderr, "Invalid test: %s\n", p.test_name);
status = -1;
goto out;
}
stats = calloc(ARRAY_SIZE(tests), sizeof(stats[0]));
if (stats == NULL) {
perror("calloc");
status = -1;
goto out;
}
status = bladerf_open(&dev, p.device_str);
if (status != 0) {
fprintf(stderr, "Failed to open device: %s\n",
bladerf_strerror(status));
goto out;
}
if (p.use_xb200) {
expected = BLADERF_XB_200;
status = bladerf_expansion_attach(dev, BLADERF_XB_200);
if (status != 0) {
fprintf(stderr, "Failed to attach XB-200: %s\n",
bladerf_strerror(status));
goto out;
}
} else {
expected = BLADERF_XB_NONE;
}
status = bladerf_expansion_get_attached(dev, &attached);
if (status != 0) {
fprintf(stderr, "Failed to query attached expansion board: %s\n",
bladerf_strerror(status));
goto out;
}
if (expected != attached) {
fprintf(stderr, "Unexpected expansion board readback: %d\n", attached);
status = -1;
goto out;
}
for (i = 0; i < ARRAY_SIZE(tests); i++) {
if (p.test_name == NULL || !strcasecmp(p.test_name, tests[i]->name)) {
p.randval_state = p.randval_seed;
stats[i].ran = true;
stats[i].failures = tests[i]->fn(dev, &p, false);
}
}
puts("\nFailure counts");
puts("--------------------------------------------");
for (i = 0; i < ARRAY_SIZE(tests); i++) {
if (stats[i].ran) {
printf("%16s %u\n", tests[i]->name, stats[i].failures);
}
if (stats[i].failures != 0) {
pass = false;
}
}
puts("");
status = pass ? 0 : -1;
out:
if (dev) {
bladerf_close(dev);
}
free(p.device_str);
free(p.test_name);
free(stats);
return status;
}
int rf_blade_close(void *h)
{
rf_blade_handler_t *handler = (rf_blade_handler_t*) h;
bladerf_close(handler->dev);
return 0;
}
int main(int argc, char** argv) {
int status, threads_waiting = 1, quick;
struct bladerf* dev;
struct bladerf_config* cfg;
struct bladerf_stream* tx_stream;
struct bladerf_stream* rx_stream;
struct bladerf_stream_data* tx_stream_data;
struct bladerf_stream_data* rx_stream_data;
struct bladerf_thread_data* tx_thread_data;
struct bladerf_thread_data* rx_thread_data;
pthread_t tx_thread_pth;
pthread_t rx_thread_pth;
signal(SIGINT, ignore_sigint);
cfg = malloc(sizeof(struct bladerf_config));
tx_stream_data = malloc(sizeof(struct bladerf_stream_data));
rx_stream_data = malloc(sizeof(struct bladerf_stream_data));
tx_thread_data = malloc(sizeof(struct bladerf_thread_data));
rx_thread_data = malloc(sizeof(struct bladerf_thread_data));
cfg->tx_freq = TXFREQ;
cfg->rx_freq = RXFREQ;
cfg->tx_bw = TXBW;
cfg->rx_bw = RXBW;
cfg->tx_sr = TXSR;
cfg->rx_sr = RXSR;
cfg->txvga1 = TXVGA1;
cfg->txvga2 = TXVGA2;
cfg->rxvga1 = RXVGA1;
cfg->rxvga2 = RXVGA2;
cfg->lna = LNA;
if(argc == 2 && argv[1][0] == 'q') {
quick = 1;
} else {
quick = 0;
}
if(!quick) {
if(write_config(cfg)) {
if(cfg) free(cfg);
if(tx_stream_data) free(tx_stream_data);
if(rx_stream_data) free(rx_stream_data);
if(tx_thread_data) free(tx_thread_data);
if(rx_thread_data) free(rx_thread_data);
return 1;
}
if(configure_bladerf(&dev, cfg)) {
if(cfg) free(cfg);
if(tx_stream_data) free(tx_stream_data);
if(rx_stream_data) free(rx_stream_data);
if(tx_thread_data) free(tx_thread_data);
if(rx_thread_data) free(rx_thread_data);
return 1;
}
} else {
status = bladerf_open(&dev, NULL);
if(status) {
return 1;
}
}
tx_stream_data->num_buffers = TX_N_BUFFERS;
tx_stream_data->samples_per_buffer = TX_SAMPLES_PER_BUFFER;
tx_stream_data->samples_left = TX_N_SAMPLES;
tx_stream_data->num_transfers = TX_N_TRANSFERS;
if(setup_tx_stream(dev, &tx_stream, tx_stream_data)) {
if(cfg) free(cfg);
if(tx_stream_data) free(tx_stream_data);
if(rx_stream_data) free(rx_stream_data);
if(tx_thread_data) free(tx_thread_data);
if(rx_thread_data) free(rx_thread_data);
return 1;
}
rx_stream_data->num_buffers = RX_N_BUFFERS;
rx_stream_data->samples_per_buffer = RX_SAMPLES_PER_BUFFER;
rx_stream_data->samples_left = RX_N_SAMPLES;
rx_stream_data->num_transfers = RX_N_TRANSFERS;
if(setup_rx_stream(dev, &rx_stream, rx_stream_data)) {
bladerf_deinit_stream(tx_stream);
if(cfg) free(cfg);
if(tx_stream_data) free(tx_stream_data);
if(rx_stream_data) free(rx_stream_data);
if(tx_thread_data) free(tx_thread_data);
if(rx_thread_data) free(rx_thread_data);
return 1;
}
if(enable(dev, true)) {
enable(dev, false);
bladerf_deinit_stream(rx_stream);
bladerf_deinit_stream(tx_stream);
bladerf_close(dev);
if(cfg) free(cfg);
if(tx_stream_data) free(tx_stream_data);
if(rx_stream_data) free(rx_stream_data);
if(tx_thread_data) free(tx_thread_data);
if(rx_thread_data) free(rx_thread_data);
return 1;
}
tx_thread_data->dev = dev;
tx_thread_data->stream = tx_stream;
tx_thread_data->stream_data = tx_stream_data;
tx_thread_data->waiting = &threads_waiting;
tx_thread_data->rv = 1;
printf("%-50s", "Creating TX thread... ");
status = pthread_create(&tx_thread_pth, NULL, txrx_thread,
tx_thread_data);
if(status) {
printf(KRED "Failed: %s" KNRM "\n", strerror(status));
bladerf_deinit_stream(rx_stream);
bladerf_close(dev);
if(cfg) free(cfg);
if(tx_stream_data) free(tx_stream_data);
if(rx_stream_data) free(rx_stream_data);
if(tx_thread_data) free(tx_thread_data);
if(rx_thread_data) free(rx_thread_data);
return 1;
}
printf(KGRN "OK" KNRM "\n");
usleep(100);
rx_thread_data->dev = dev;
rx_thread_data->stream = rx_stream;
rx_thread_data->stream_data = rx_stream_data;
rx_thread_data->waiting = &threads_waiting;
rx_thread_data->rv = 1;
printf("%-50s", "Creating RX thread... ");
status = pthread_create(&rx_thread_pth, NULL, txrx_thread,
rx_thread_data);
if(status) {
printf(KRED "Failed: %s" KNRM "\n", strerror(status));
bladerf_deinit_stream(rx_stream);
bladerf_deinit_stream(tx_stream);
bladerf_close(dev);
if(cfg) free(cfg);
if(tx_stream_data) free(tx_stream_data);
if(rx_stream_data) free(rx_stream_data);
if(tx_thread_data) free(tx_thread_data);
if(rx_thread_data) free(rx_thread_data);
return 1;
}
printf(KGRN "OK" KNRM "\n");
printf("%-50s", "Starting processing... ");
threads_waiting = 0;
printf(KGRN "OK" KNRM "\n");
printf("%-50s", "Waiting for completion... ");
fflush(stdout);
pthread_join(rx_thread_pth, NULL);
pthread_join(tx_thread_pth, NULL);
printf(KGRN "OK" KNRM "\n");
printf("%-50s", "All done, checking TX results... ");
fflush(stdout);
if(tx_thread_data->rv < 0) {
printf(KRED "Failed: %s" KNRM "\n",
bladerf_strerror(tx_thread_data->rv));
enable(dev, false);
bladerf_deinit_stream(rx_stream);
bladerf_close(dev);
if(cfg) free(cfg);
if(tx_stream_data) free(tx_stream_data);
if(rx_stream_data) free(rx_stream_data);
if(tx_thread_data) free(tx_thread_data);
if(rx_thread_data) free(rx_thread_data);
return 1;
}
printf(KGRN "OK" KNRM "\n");
printf("%-50s", " checking RX results... ");
fflush(stdout);
if(rx_thread_data->rv < 0) {
printf(KRED "Failed: %s" KNRM "\n",
bladerf_strerror(tx_thread_data->rv));
enable(dev, false);
bladerf_deinit_stream(rx_stream);
bladerf_close(dev);
if(cfg) free(cfg);
if(tx_stream_data) free(tx_stream_data);
if(rx_stream_data) free(rx_stream_data);
if(tx_thread_data) free(tx_thread_data);
if(rx_thread_data) free(rx_thread_data);
return 1;
}
printf(KGRN "OK" KNRM "\n");
printf(KGRN "Success!" KNRM "\n");
save_rx_data(rx_stream_data);
enable(dev, false);
printf("%-50s", "Deinitialising stream... ");
fflush(stdout);
bladerf_deinit_stream(rx_stream);
printf(KGRN "OK" KNRM "\n");
printf("%-50s", "Closing device... ");
fflush(stdout);
bladerf_close(dev);
printf(KGRN "OK" KNRM "\n");
printf("%-50s", "Freeing memory... ");
fflush(stdout);
if(cfg) free(cfg);
if(tx_stream_data) free(tx_stream_data);
if(rx_stream_data) free(rx_stream_data);
if(tx_thread_data) free(tx_thread_data);
if(rx_thread_data) free(rx_thread_data);
printf(KGRN "OK" KNRM "\n");
return 0;
}
int bladerf_open_with_devinfo(struct bladerf **opened_device,
struct bladerf_devinfo *devinfo)
{
struct bladerf *dev;
int status;
*opened_device = NULL;
dev = (struct bladerf *)calloc(1, sizeof(struct bladerf));
if (dev == NULL) {
return BLADERF_ERR_MEM;
}
dev->fpga_version.describe = calloc(1, BLADERF_VERSION_STR_MAX + 1);
if (dev->fpga_version.describe == NULL) {
free(dev);
return BLADERF_ERR_MEM;
}
dev->fw_version.describe = calloc(1, BLADERF_VERSION_STR_MAX + 1);
if (dev->fw_version.describe == NULL) {
free((void*)dev->fpga_version.describe);
free(dev);
return BLADERF_ERR_MEM;
}
status = backend_open(dev, devinfo);
if (status != 0) {
free((void*)dev->fw_version.describe);
free((void*)dev->fpga_version.describe);
free(dev);
return status;
}
status = dev->fn->get_device_speed(dev, &dev->usb_speed);
if (status < 0) {
log_debug("Failed to get device speed: %s\n",
bladerf_strerror(status));
goto error;
}
if (dev->usb_speed != BLADERF_DEVICE_SPEED_HIGH &&
dev->usb_speed != BLADERF_DEVICE_SPEED_SUPER) {
log_debug("Unsupported device speed: %d\n", dev->usb_speed);
goto error;
}
/* VCTCXO trim and FPGA size are non-fatal indicators that we've
* trashed the calibration region of flash. If these were made fatal,
* we wouldn't be able to open the device to restore them. */
status = bladerf_get_and_cache_vctcxo_trim(dev);
if (status < 0) {
log_warning("Failed to get VCTCXO trim value: %s\n",
bladerf_strerror(status));
}
status = bladerf_get_and_cache_fpga_size(dev);
if (status < 0) {
log_warning("Failed to get FPGA size %s\n",
bladerf_strerror(status));
}
status = bladerf_is_fpga_configured(dev);
if (status > 0) {
status = bladerf_init_device(dev);
}
error:
if (status < 0) {
bladerf_close(dev);
} else {
*opened_device = dev;
}
return status;
}
/* Usage:
* open [device identifier items]
*
* It's a bit silly, but we just merge all the argv items into the
* device identifier string here.
*/
int cmd_open(struct cli_state *state, int argc, char **argv)
{
char *dev_ident = NULL;
size_t dev_ident_len;
int i;
int status;
int ret;
bool update_required;
if (state->dev) {
bladerf_close(state->dev);
}
/* We have some device indentifer items */
if (argc > 1) {
dev_ident_len = argc - 2; /* # spaces to place between args */
for (i = 1; i < argc; i++) {
dev_ident_len += strlen(argv[i]);
}
/* Room for '\0' terminator */
dev_ident_len++;
dev_ident = calloc(dev_ident_len, 1);
if (!dev_ident) {
return CLI_RET_MEM;
}
for (i = 1; i < argc; i++) {
strncat(dev_ident, argv[i], (dev_ident_len - 1 - strlen(dev_ident)));
if (i != (argc - 1)) {
dev_ident[strlen(dev_ident)] = ' ';
}
}
printf("\n Using device string: %s\n", dev_ident);
}
status = bladerf_open(&state->dev, dev_ident);
update_required = (status == BLADERF_ERR_UPDATE_FPGA) ||
(status == BLADERF_ERR_UPDATE_FW);
if (status) {
if (update_required) {
/* LibbladeRF will print a warning. No need to show an error. */
ret = 0;
} else {
state->last_lib_error = status;
ret = CLI_RET_LIBBLADERF;
}
} else {
ret = 0;
putchar('\n');
}
free(dev_ident);
return ret;
}
int main(int argc, char *argv[])
{
sim_t s;
char *devstr = NULL;
int c;
// Initialize structures
init_sim(&s);
// Allocate TX buffer to hold each block of samples to transmit.
s.tx.buffer = (int16_t *)malloc(SAMPLES_PER_BUFFER * sizeof(int16_t) * 2); // for 16-bit I and Q samples
if (s.tx.buffer == NULL) {
fprintf(stderr, "Failed to allocate TX buffer.\n");
goto out;
}
// Allocate FIFOs to hold 0.1 seconds of I/Q samples each.
s.fifo = (int16_t *)malloc(FIFO_LENGTH * sizeof(int16_t) * 2); // for 16-bit I and Q samples
if (s.fifo == NULL) {
fprintf(stderr, "Failed to allocate I/Q sample buffer.\n");
goto out;
}
// Initializing device.
printf("Opening and initializing device...\n");
s.status = bladerf_open(&s.tx.dev, devstr);
if (s.status != 0) {
fprintf(stderr, "Failed to open device: %s\n", bladerf_strerror(s.status));
goto out;
}
s.status = bladerf_set_frequency(s.tx.dev, BLADERF_MODULE_TX, TX_FREQUENCY);
if (s.status != 0) {
fprintf(stderr, "Faield to set TX frequency: %s\n", bladerf_strerror(s.status));
goto out;
}
else {
printf("TX frequency: %u Hz\n", TX_FREQUENCY);
}
s.status = bladerf_set_sample_rate(s.tx.dev, BLADERF_MODULE_TX, TX_SAMPLERATE, NULL);
if (s.status != 0) {
fprintf(stderr, "Failed to set TX sample rate: %s\n", bladerf_strerror(s.status));
goto out;
}
else {
printf("TX sample rate: %u sps\n", TX_SAMPLERATE);
}
s.status = bladerf_set_bandwidth(s.tx.dev, BLADERF_MODULE_TX, TX_BANDWIDTH, NULL);
if (s.status != 0) {
fprintf(stderr, "Failed to set TX bandwidth: %s\n", bladerf_strerror(s.status));
goto out;
}
else {
printf("TX bandwidth: %u Hz\n", TX_BANDWIDTH);
}
s.status = bladerf_set_txvga1(s.tx.dev, TX_VGA1);
if (s.status != 0) {
fprintf(stderr, "Failed to set TX VGA1 gain: %s\n", bladerf_strerror(s.status));
goto out;
}
else {
printf("TX VGA1 gain: %d dB\n", TX_VGA1);
}
s.status = bladerf_set_txvga2(s.tx.dev, TX_VGA2);
if (s.status != 0) {
fprintf(stderr, "Failed to set TX VGA2 gain: %s\n", bladerf_strerror(s.status));
goto out;
}
else {
printf("TX VGA2 gain: %d dB\n", TX_VGA2);
}
// Start GPS task.
s.status = start_gps_task(&s);
if (s.status < 0) {
fprintf(stderr, "Failed to start GPS task.\n");
goto out;
}
else
printf("Creating GPS task...\n");
// Wait until GPS task is initialized
pthread_mutex_lock(&(s.tx.lock));
while (!s.gps.ready)
pthread_cond_wait(&(s.gps.initialization_done), &(s.tx.lock));
pthread_mutex_unlock(&(s.tx.lock));
// Fillfull the FIFO.
if (is_fifo_write_ready(&s))
pthread_cond_signal(&(s.fifo_write_ready));
// Configure the TX module for use with the synchronous interface.
s.status = bladerf_sync_config(s.tx.dev,
BLADERF_MODULE_TX,
BLADERF_FORMAT_SC16_Q11,
NUM_BUFFERS,
SAMPLES_PER_BUFFER,
NUM_TRANSFERS,
TIMEOUT_MS);
if (s.status != 0) {
fprintf(stderr, "Failed to configure TX sync interface: %s\n", bladerf_strerror(s.status));
goto out;
}
// We must always enable the modules *after* calling bladerf_sync_config().
s.status = bladerf_enable_module(s.tx.dev, BLADERF_MODULE_TX, true);
if (s.status != 0) {
fprintf(stderr, "Failed to enable TX module: %s\n", bladerf_strerror(s.status));
goto out;
}
// Start TX task
s.status = start_tx_task(&s);
if (s.status < 0) {
fprintf(stderr, "Failed to start TX task.\n");
goto out;
}
else
printf("Creating TX task...\n");
// Running...
printf("Running...\n");
printf("Press 'q' to exit.\n");
while (1) {
c = _getch();
if (c=='q')
break;
}
//
// TODO: Cleaning up the threads properly.
//
printf("\nDone!\n");
// Disable TX module, shutting down our underlying TX stream.
s.status = bladerf_enable_module(s.tx.dev, BLADERF_MODULE_TX, false);
if (s.status != 0) {
fprintf(stderr, "Failed to disable TX module: %s\n", bladerf_strerror(s.status));
}
out:
// Free up resources
if (s.tx.buffer != NULL)
free(s.tx.buffer);
if (s.fifo != NULL)
free(s.fifo);
printf("Closing device...\n");
bladerf_close(s.tx.dev);
return(0);
}
/* Usage:
* libbladeRF_example_boilerplate [serial #]
*
* If a serial number is supplied, the program will attempt to open the
* device with the provided serial number.
*
* Otherwise, the first available device will be used.
*/
int main(int argc, char *argv[])
{
int status;
struct channel_config config;
/** [Opening a device] */
struct bladerf *dev = NULL;
struct bladerf_devinfo dev_info;
/* Initialize the information used to identify the desired device
* to all wildcard (i.e., "any device") values */
bladerf_init_devinfo(&dev_info);
/* Request a device with the provided serial number.
* Invalid strings should simply fail to match a device. */
if (argc >= 2) {
strncpy(dev_info.serial, argv[1], sizeof(dev_info.serial) - 1);
}
status = bladerf_open_with_devinfo(&dev, &dev_info);
if (status != 0) {
fprintf(stderr, "Unable to open device: %s\n",
bladerf_strerror(status));
return 1;
}
/** [Opening a device] */
/* Set up RX channel parameters */
config.channel = BLADERF_CHANNEL_RX(0);
config.frequency = 910000000;
config.bandwidth = 2000000;
config.samplerate = 300000;
config.gain = 39;
status = configure_channel(dev, &config);
if (status != 0) {
fprintf(stderr, "Failed to configure RX channel. Exiting.\n");
goto out;
}
/* Set up TX channel parameters */
config.channel = BLADERF_CHANNEL_TX(0);
config.frequency = 918000000;
config.bandwidth = 1500000;
config.samplerate = 250000;
config.gain = -14;
status = configure_channel(dev, &config);
if (status != 0) {
fprintf(stderr, "Failed to configure TX channel. Exiting.\n");
goto out;
}
/* Application code goes here.
*
* Don't forget to call bladerf_enable_module() before attempting to
* transmit or receive samples!
*/
printf("Hello world\n");
out:
bladerf_close(dev);
return status;
}
