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; }