double rf_blade_set_tx_gain(void *h, double gain) { int status; rf_blade_handler_t *handler = (rf_blade_handler_t*) h; status = bladerf_set_txvga2(handler->dev, (int) gain); if (status != 0) { fprintf(stderr, "Failed to set TX VGA2 gain: %s\n", bladerf_strerror(status)); return -1; } return rf_blade_get_tx_gain(h); }
//! This gets called whenever a parameter is reconfigured void BladeRfTxComponent::parameterHasChanged(std::string name) { try { if(name == "frequency") { // Set center frequency uint32_t actualValue; int ret = bladerf_set_frequency(device_, BLADERF_MODULE_TX, frequency_x); if (ret != 0) { throw IrisException("Failed to set center frequency!"); } bladerf_get_frequency(device_, BLADERF_MODULE_TX, &actualValue); LOG(LINFO) << "Actual Tx center frequency is: " << actualValue << " Hz"; } else if(name == "rate") { uint32_t actualValue; int ret = bladerf_set_sample_rate(device_, BLADERF_MODULE_TX, (uint32_t)rate_x, &actualValue); if (ret != 0) { throw IrisException("Failed to set sample rate!"); } LOG(LINFO) << "Actual Tx sample rate is: " << actualValue << " Hz"; } else if(name == "vga1gain") { if (bladerf_set_txvga1(device_, vga1Gain_x) != 0) { throw IrisException("Failed to set VGA1 gain!"); } int actualGain; bladerf_get_txvga1(device_, &actualGain); LOG(LINFO) << "Actual VGA1 gain is " << actualGain << " dB"; } else if(name == "vga2gain") { if (bladerf_set_txvga2(device_, vga2Gain_x) != 0) { throw IrisException("Failed to set VGA2 gain!"); } int actualGain; bladerf_get_txvga2(device_, &actualGain); LOG(LINFO) << "Actual VGA2 gain is " << actualGain << " dB"; } } catch(std::exception &e) { throw IrisException(e.what()); } }
bool Bladerf1Output::applySettings(const BladeRF1OutputSettings& settings, bool force) { bool forwardChange = false; bool suspendOwnThread = false; bool threadWasRunning = false; QList<QString> reverseAPIKeys; // QMutexLocker mutexLocker(&m_mutex); qDebug() << "BladerfOutput::applySettings: m_dev: " << m_dev; if ((m_settings.m_centerFrequency != settings.m_centerFrequency) || force) { reverseAPIKeys.append("centerFrequency"); } if ((m_settings.m_devSampleRate != settings.m_devSampleRate) || force) { reverseAPIKeys.append("devSampleRate"); } if ((m_settings.m_log2Interp != settings.m_log2Interp) || force) { reverseAPIKeys.append("log2Interp"); } if ((m_settings.m_devSampleRate != settings.m_devSampleRate) || (m_settings.m_log2Interp != settings.m_log2Interp) || force) { suspendOwnThread = true; } if (suspendOwnThread) { if (m_bladerfThread) { if (m_bladerfThread->isRunning()) { m_bladerfThread->stopWork(); threadWasRunning = true; } } } if ((m_settings.m_devSampleRate != settings.m_devSampleRate) || (m_settings.m_log2Interp != settings.m_log2Interp) || force) { int fifoSize; if (settings.m_log2Interp >= 5) { fifoSize = DeviceBladeRF1Shared::m_sampleFifoMinSize32; } else { fifoSize = (std::max)( (int) ((settings.m_devSampleRate/(1<<settings.m_log2Interp)) * DeviceBladeRF1Shared::m_sampleFifoLengthInSeconds), DeviceBladeRF1Shared::m_sampleFifoMinSize); } m_sampleSourceFifo.resize(fifoSize); } if ((m_settings.m_devSampleRate != settings.m_devSampleRate) || force) { forwardChange = true; if (m_dev != 0) { unsigned int actualSamplerate; if (bladerf_set_sample_rate(m_dev, BLADERF_MODULE_TX, settings.m_devSampleRate, &actualSamplerate) < 0) { qCritical("BladerfOutput::applySettings: could not set sample rate: %d", settings.m_devSampleRate); } else { qDebug() << "BladerfOutput::applySettings: bladerf_set_sample_rate(BLADERF_MODULE_TX) actual sample rate is " << actualSamplerate; } } } if ((m_settings.m_log2Interp != settings.m_log2Interp) || force) { forwardChange = true; if (m_bladerfThread != 0) { m_bladerfThread->setLog2Interpolation(settings.m_log2Interp); qDebug() << "BladerfOutput::applySettings: set interpolation to " << (1<<settings.m_log2Interp); } } if ((m_settings.m_vga1 != settings.m_vga1) || force) { reverseAPIKeys.append("vga1"); if (m_dev != 0) { if (bladerf_set_txvga1(m_dev, settings.m_vga1) != 0) { qDebug("BladerfOutput::applySettings: bladerf_set_txvga1() failed"); } else { qDebug() << "BladerfOutput::applySettings: VGA1 gain set to " << settings.m_vga1; } } } if ((m_settings.m_vga2 != settings.m_vga2) || force) { reverseAPIKeys.append("vga2"); if(m_dev != 0) { if (bladerf_set_txvga2(m_dev, settings.m_vga2) != 0) { qDebug("BladerfOutput::applySettings:bladerf_set_rxvga2() failed"); } else { qDebug() << "BladerfOutput::applySettings: VGA2 gain set to " << settings.m_vga2; } } } if ((m_settings.m_xb200 != settings.m_xb200) || force) { reverseAPIKeys.append("xb200"); if (m_dev != 0) { bool changeSettings; if (m_deviceAPI->getSourceBuddies().size() > 0) { DeviceSourceAPI *buddy = m_deviceAPI->getSourceBuddies()[0]; if (buddy->getDeviceSourceEngine()->state() == DSPDeviceSourceEngine::StRunning) { // Tx side running changeSettings = false; } else { changeSettings = true; } } else // No Rx open { changeSettings = true; } if (changeSettings) { if (settings.m_xb200) { if (bladerf_expansion_attach(m_dev, BLADERF_XB_200) != 0) { qDebug("BladerfOutput::applySettings: bladerf_expansion_attach(xb200) failed"); } else { qDebug() << "BladerfOutput::applySettings: Attach XB200"; } } else { if (bladerf_expansion_attach(m_dev, BLADERF_XB_NONE) != 0) { qDebug("BladerfOutput::applySettings: bladerf_expansion_attach(none) failed"); } else { qDebug() << "BladerfOutput::applySettings: Detach XB200"; } } m_sharedParams.m_xb200Attached = settings.m_xb200; } } } if ((m_settings.m_xb200Path != settings.m_xb200Path) || force) { reverseAPIKeys.append("xb200Path"); if (m_dev != 0) { if (bladerf_xb200_set_path(m_dev, BLADERF_MODULE_TX, settings.m_xb200Path) != 0) { qDebug("BladerfOutput::applySettings: bladerf_xb200_set_path(BLADERF_MODULE_TX) failed"); } else { qDebug() << "BladerfOutput::applySettings: set xb200 path to " << settings.m_xb200Path; } } } if ((m_settings.m_xb200Filter != settings.m_xb200Filter) || force) { reverseAPIKeys.append("xb200Filter"); if (m_dev != 0) { if (bladerf_xb200_set_filterbank(m_dev, BLADERF_MODULE_TX, settings.m_xb200Filter) != 0) { qDebug("BladerfOutput::applySettings: bladerf_xb200_set_filterbank(BLADERF_MODULE_TX) failed"); } else { qDebug() << "BladerfOutput::applySettings: set xb200 filter to " << settings.m_xb200Filter; } } } if ((m_settings.m_bandwidth != settings.m_bandwidth) || force) { reverseAPIKeys.append("bandwidth"); if (m_dev != 0) { unsigned int actualBandwidth; if (bladerf_set_bandwidth(m_dev, BLADERF_MODULE_TX, settings.m_bandwidth, &actualBandwidth) < 0) { qCritical("BladerfOutput::applySettings: could not set bandwidth: %d", settings.m_bandwidth); } else { qDebug() << "BladerfOutput::applySettings: bladerf_set_bandwidth(BLADERF_MODULE_TX) actual bandwidth is " << actualBandwidth; } } } if (m_settings.m_centerFrequency != settings.m_centerFrequency) { forwardChange = true; } if (m_dev != 0) { if (bladerf_set_frequency( m_dev, BLADERF_MODULE_TX, settings.m_centerFrequency ) != 0) { qDebug("BladerfOutput::applySettings: bladerf_set_frequency(%lld) failed", settings.m_centerFrequency); } } if (threadWasRunning) { m_bladerfThread->startWork(); } if (settings.m_useReverseAPI) { bool fullUpdate = ((m_settings.m_useReverseAPI != settings.m_useReverseAPI) && settings.m_useReverseAPI) || (m_settings.m_reverseAPIAddress != settings.m_reverseAPIAddress) || (m_settings.m_reverseAPIPort != settings.m_reverseAPIPort) || (m_settings.m_reverseAPIDeviceIndex != settings.m_reverseAPIDeviceIndex); webapiReverseSendSettings(reverseAPIKeys, settings, fullUpdate || force); } m_settings = settings; if (forwardChange) { int sampleRate = m_settings.m_devSampleRate/(1<<m_settings.m_log2Interp); DSPSignalNotification *notif = new DSPSignalNotification(sampleRate, m_settings.m_centerFrequency); m_deviceAPI->getDeviceEngineInputMessageQueue()->push(notif); } qDebug() << "BladerfOutput::applySettings: center freq: " << m_settings.m_centerFrequency << " Hz" << " device sample rate: " << m_settings.m_devSampleRate << "S/s" << " baseband sample rate: " << m_settings.m_devSampleRate/(1<<m_settings.m_log2Interp) << "S/s" << " BW: " << m_settings.m_bandwidth << "Hz"; return true; }
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); }
static inline int setup_device(struct test *t) { int status; struct bladerf *dev = t->dev; #if !DISABLE_RX_LOOPBACK status = bladerf_set_loopback(dev, BLADERF_LB_BB_TXVGA1_RXVGA2); if (status != 0) { fprintf(stderr, "Failed to set loopback mode: %s\n", bladerf_strerror(status)); return status; } #endif status = bladerf_set_lna_gain(dev, BLADERF_LNA_GAIN_MAX); if (status != 0) { fprintf(stderr, "Failed to set LNA gain value: %s\n", bladerf_strerror(status)); return status; } status = bladerf_set_rxvga1(dev, 30); if (status != 0) { fprintf(stderr, "Failed to set RXVGA1 value: %s\n", bladerf_strerror(status)); return status; } status = bladerf_set_rxvga2(dev, 10); if (status != 0) { fprintf(stderr, "Failed to set RXVGA2 value: %s\n", bladerf_strerror(status)); return status; } status = bladerf_set_txvga1(dev, -10); if (status != 0) { fprintf(stderr, "Failed to set TXVGA1 value: %s\n", bladerf_strerror(status)); return status; } status = bladerf_set_txvga2(dev, BLADERF_TXVGA2_GAIN_MIN); if (status != 0) { fprintf(stderr, "Failed to set TXVGA2 value: %s\n", bladerf_strerror(status)); return status; } status = bladerf_sync_config(t->dev, BLADERF_MODULE_RX, BLADERF_FORMAT_SC16_Q11_META, t->params->num_buffers, t->params->buf_size, t->params->num_xfers, t->params->timeout_ms); if (status != 0) { fprintf(stderr, "Failed to configure RX stream: %s\n", bladerf_strerror(status)); return status; } status = bladerf_enable_module(t->dev, BLADERF_MODULE_RX, true); if (status != 0) { fprintf(stderr, "Failed to enable RX module: %s\n", bladerf_strerror(status)); return status; } status = bladerf_sync_config(t->dev, BLADERF_MODULE_TX, BLADERF_FORMAT_SC16_Q11_META, t->params->num_buffers, t->params->buf_size, t->params->num_xfers, t->params->timeout_ms); if (status != 0) { fprintf(stderr, "Failed to configure TX stream: %s\n", bladerf_strerror(status)); return status; } status = bladerf_enable_module(t->dev, BLADERF_MODULE_TX, true); if (status != 0) { fprintf(stderr, "Failed to enable RX module: %s\n", bladerf_strerror(status)); return status; } 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[]) { 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); }
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; }
/** * Configure RX/TX module */ static int radio_configure_module(struct bladerf *dev, struct module_config *c) { int status; status = bladerf_set_frequency(dev, c->module, c->frequency); if (status != 0) { fprintf(stderr, "Failed to set frequency = %u: %s\n", c->frequency, bladerf_strerror(status)); return status; } status = bladerf_set_sample_rate(dev, c->module, c->samplerate, NULL); if (status != 0) { fprintf(stderr, "Failed to set samplerate = %u: %s\n", c->samplerate, bladerf_strerror(status)); return status; } status = bladerf_set_bandwidth(dev, c->module, c->bandwidth, NULL); if (status != 0) { fprintf(stderr, "Failed to set bandwidth = %u: %s\n", c->bandwidth, bladerf_strerror(status)); return status; } switch (c->module) { case BLADERF_MODULE_RX: /* Configure the gains of the RX LNA, RX VGA1, and RX VGA2 */ status = bladerf_set_lna_gain(dev, c->rx_lna); if (status != 0) { fprintf(stderr, "Failed to set RX LNA gain: %s\n", bladerf_strerror(status)); return status; } status = bladerf_set_rxvga1(dev, c->vga1); if (status != 0) { fprintf(stderr, "Failed to set RX VGA1 gain: %s\n", bladerf_strerror(status)); return status; } status = bladerf_set_rxvga2(dev, c->vga2); if (status != 0) { fprintf(stderr, "Failed to set RX VGA2 gain: %s\n", bladerf_strerror(status)); return status; } break; case BLADERF_MODULE_TX: /* Configure the TX VGA1 and TX VGA2 gains */ status = bladerf_set_txvga1(dev, c->vga1); if (status != 0) { fprintf(stderr, "Failed to set TX VGA1 gain: %s\n", bladerf_strerror(status)); return status; } status = bladerf_set_txvga2(dev, c->vga2); if (status != 0) { fprintf(stderr, "Failed to set TX VGA2 gain: %s\n", bladerf_strerror(status)); return status; } break; default: status = BLADERF_ERR_INVAL; fprintf(stderr, "%s: Invalid module specified (%d)\n", __FUNCTION__, c->module); } return status; }
//! Do any initialization required void BladeRfTxComponent::initialize() { // Set up the input DataBuffer inBuf_ = castToType< complex<float> >(inputBuffers.at(0)); // Initialize raw sample vector to some multiple of block size rawSampleBuffer_.data.resize(128 * BLADERF_SAMPLE_BLOCK_SIZE); // Set up the BladeRF try { // Create the device LOG(LINFO) << "Trying to open device " << deviceName_x; int ret = bladerf_open(&device_, deviceName_x.c_str()); if (ret != 0) { throw IrisException("Failed to open bladeRF device!"); } // Check whether FPGA is configured yet if (bladerf_is_fpga_configured(device_) != 1 ) { // try to load FPGA image if (not fpgaImage_x.empty()) { ret = bladerf_load_fpga(device_, fpgaImage_x.c_str()); if (ret != 0) { throw IrisException("Failed to load FPGA to bladeRF!"); } else { LOG(LINFO) << "FPGA image successfully loaded."; } } else { throw IrisException("BladeRF FPGA is not configured and no FPGA image given!"); } } // Print some information about device struct bladerf_version version; if (bladerf_fw_version(device_, &version) == 0) { LOG(LINFO) << "Using FW " << version.describe; } if (bladerf_fpga_version(device_, &version) == 0) { LOG(LINFO) << "Using FPGA " << version.describe; } if (bladerf_is_fpga_configured(device_) != 1 ) { throw IrisException("BladeRF FPGA is not configured!"); } // setting up sync config ret = bladerf_sync_config(device_, BLADERF_MODULE_TX, BLADERF_FORMAT_SC16_Q11, BLADERF_DEFAULT_STREAM_BUFFERS, BLADERF_DEFAULT_STREAM_SAMPLES, BLADERF_DEFAULT_STREAM_XFERS, BLADERF_SYNC_TIMEOUT_MS); if (ret != 0) { throw IrisException("Couldn't enable BladeRF Tx sync handle!"); LOG(LERROR) << bladerf_strerror(ret); } // Turn on transmitter ret = bladerf_enable_module(device_, BLADERF_MODULE_TX, true); if ( ret != 0 ) { throw IrisException("Couldn't enable BladeRF Tx module!"); } // Set sample rate uint32_t actualValue; ret = bladerf_set_sample_rate(device_, BLADERF_MODULE_TX, (uint32_t)rate_x, &actualValue); if (ret != 0) { throw IrisException("Failed to set sample rate!"); } LOG(LINFO) << "Actual Tx sample rate is: " << actualValue << " Hz"; // Set center frequency ret = bladerf_set_frequency(device_, BLADERF_MODULE_TX, frequency_x); if (ret != 0) { throw IrisException("Failed to set center frequency!"); } bladerf_get_frequency(device_, BLADERF_MODULE_TX, &actualValue); LOG(LINFO) << "Actual Tx center frequency is: " << actualValue << " Hz"; // Set bandwidth ret = bladerf_set_bandwidth(device_, BLADERF_MODULE_TX, bw_x, &actualValue); if (ret != 0) { throw IrisException("Failed to set receive bandwidth!"); } LOG(LINFO) << "Actual Tx bandwidth is " << actualValue << " Hz"; // Set VGA1 gain int actualGain; ret = bladerf_set_txvga1(device_, vga1Gain_x); if (ret != 0) { throw IrisException("Failed to set VGA1 gain!"); } bladerf_get_txvga1(device_, &actualGain); LOG(LINFO) << "Actual VGA1 gain is " << actualGain << " dB"; // Set VGA2 gain ret = bladerf_set_txvga2(device_, vga2Gain_x); if (ret != 0) { throw IrisException("Failed to set VGA2 gain!"); } bladerf_get_txvga2(device_, &actualGain); LOG(LINFO) << "Actual VGA2 gain is " << actualGain << " dB"; } catch(const boost::exception &e) { throw IrisException(boost::diagnostic_information(e)); } catch(std::exception& e) { throw IrisException(e.what()); } }
static int repeater_handle_key(struct repeater *repeater, char key) { int status = 0; switch (key) { case KEY_DEC_TXVGA1: if (repeater->gain_txvga1 > GAIN_TXVGA1_MIN) { status = bladerf_set_txvga1(repeater->device, --repeater->gain_txvga1); if (status < 0) { repeater->gain_txvga1++; fprintf(stderr, "Failed to increase TXVGA1 gain: %s\r\n", bladerf_strerror(status)); } else { printf("TXVGA1 gain decreased to: %d\r\n", repeater->gain_txvga1); } } break; case KEY_INC_TXVGA1: if (repeater->gain_txvga1 < GAIN_TXVGA1_MAX) { status = bladerf_set_txvga1(repeater->device, ++repeater->gain_txvga1); if (status < 0) { repeater->gain_txvga1--; fprintf(stderr, "Failed to increase TXVGA1 gain: %s\r\n", bladerf_strerror(status)); } else { printf("TXVGA1 gain increased to: %d\r\n", repeater->gain_txvga1); } } break; case KEY_DEC_TXVGA2: if (repeater->gain_txvga2 > GAIN_TXVGA2_MIN) { status = bladerf_set_txvga2(repeater->device, --repeater->gain_txvga2); if (status < 0) { repeater->gain_txvga2++; fprintf(stderr, "Failed to decrease TXVGA2 gain: %s\r\n", bladerf_strerror(status)); } else { printf("TXVGA2 gain decreased to: %d\r\n", repeater->gain_txvga2); } } break; case KEY_INC_TXVGA2: if (repeater->gain_txvga2 < GAIN_TXVGA2_MAX) { status = bladerf_set_txvga2(repeater->device, ++repeater->gain_txvga2); if (status < 0) { repeater->gain_txvga2--; fprintf(stderr, "Failed to increase TXVGA2 gain: %s\r\n", bladerf_strerror(status)); } else { printf("TXVGA2 gain increased to: %d\r\n", repeater->gain_txvga2); } } break; case KEY_DEC_RXVGA1: if (repeater->gain_rxvga1 > GAIN_RXVGA1_MIN) { status = bladerf_set_rxvga1(repeater->device, --repeater->gain_rxvga1); if (status < 0) { repeater->gain_rxvga1++; fprintf(stderr, "Failed to decrease RXVGA1 gain: %s\r\n", bladerf_strerror(status)); } else { printf("RXVGA1 gain decreased to %d\r\n", repeater->gain_rxvga1); } } break; case KEY_INC_RXVGA1: if (repeater->gain_rxvga1 < GAIN_RXVGA1_MAX) { status = bladerf_set_rxvga1(repeater->device, ++repeater->gain_rxvga1); if (status < 0) { repeater->gain_rxvga1--; fprintf(stderr, "Failed to increase RXVGA1 gain: %s\r\n", bladerf_strerror(status)); } else { printf("RXVGA1 gain increased to %d\r\n", repeater->gain_rxvga1); } } break; case KEY_DEC_RXVGA2: if (repeater->gain_rxvga2 > GAIN_RXVGA2_MIN) { status = bladerf_set_rxvga2(repeater->device, --repeater->gain_rxvga2); if (status < 0) { repeater->gain_rxvga2++; fprintf(stderr, "Failed to decrease RXVGA2 gain: %s\r\n", bladerf_strerror(status)); } else { printf("RXVGA2 gain decreased to %d\r\n", repeater->gain_rxvga2); } } break; case KEY_INC_RXVGA2: if (repeater->gain_rxvga2 < GAIN_RXVGA2_MAX) { status = bladerf_set_rxvga2(repeater->device, ++repeater->gain_rxvga2); if (status < 0) { repeater->gain_rxvga2--; fprintf(stderr, "Failed to increase RXVGA2 gain: %s\r\n", bladerf_strerror(status)); } else { printf("RXVGA2 gain increased to %d\r\n", repeater->gain_rxvga2); } } break; case KEY_DEC_LNAGAIN: if (repeater->gain_lna > BLADERF_LNA_GAIN_BYPASS) { status = bladerf_set_lna_gain(repeater->device, --repeater->gain_lna); if (status < 0) { repeater->gain_lna++; fprintf(stderr, "Failed to decrease LNA gain: %s\r\n", bladerf_strerror(status)); } else { printf("LNA gain decreased to %s\r\n", lnagain2str(repeater->gain_lna)); } } break; case KEY_INC_LNAGAIN: if (repeater->gain_lna < BLADERF_LNA_GAIN_MAX) { status = bladerf_set_lna_gain(repeater->device, ++repeater->gain_lna); if (status < 0) { repeater->gain_lna--; fprintf(stderr, "Failed to increase LNA gain: %s\r\n", bladerf_strerror(status)); } else { printf("LNA gain increased to %s\r\n", lnagain2str(repeater->gain_lna)); } } break; case KEY_HELP: repeater_help(); break; default: break; } return status; }