int rtlsdr_nearest_gain(rtlsdr_dev_t *dev, int target_gain) { int i, r, err1, err2, count, nearest; int* gains; r = rtlsdr_set_tuner_gain_mode(dev, 1); if (r < 0) { fprintf(stderr, "WARNING: Failed to enable manual gain.\n"); return r; } count = rtlsdr_get_tuner_gains(dev, NULL); if (count <= 0) { return 0; } gains = malloc(sizeof(int) * count); count = rtlsdr_get_tuner_gains(dev, gains); nearest = gains[0]; for (i=0; i<count; i++) { err1 = abs(target_gain - nearest); err2 = abs(target_gain - gains[i]); if (err2 < err1) { nearest = gains[i]; } } free(gains); return nearest; }
static int set_gain_by_index(rtlsdr_dev_t *_dev, unsigned int index) { int res = 0; int* gains; int count = rtlsdr_get_tuner_gains(_dev, NULL); if (count > 0 && (unsigned int)count > index) { gains = malloc(sizeof(int) * count); count = rtlsdr_get_tuner_gains(_dev, gains); res = rtlsdr_set_tuner_gain(_dev, gains[index]); free(gains); } return res; }
static int set_gain_by_perc(rtlsdr_dev_t *_dev, unsigned int percent) { int res = 0; int* gains; int count = rtlsdr_get_tuner_gains(_dev, NULL); unsigned int index = (percent * count) / 100; if (index < 0) index = 0; if (index >= (unsigned int) count) index = count - 1; gains = malloc(sizeof(int) * count); count = rtlsdr_get_tuner_gains(_dev, gains); res = rtlsdr_set_tuner_gain(_dev, gains[index]); free(gains); return res; }
int nearest_gain(int target_gain) { int i, err1, err2, count, close_gain; int* gains; count = rtlsdr_get_tuner_gains(dev, NULL); if (count <= 0) { return 0; } gains = malloc(sizeof(int) * count); count = rtlsdr_get_tuner_gains(dev, gains); close_gain = gains[0]; for (i=0; i<count; i++) { err1 = abs(target_gain - close_gain); err2 = abs(target_gain - gains[i]); if (err2 < err1) { close_gain = gains[i]; } } free(gains); return close_gain; }
void modesInitRTLSDR(void) { int j; int device_count; char vendor[256], product[256], serial[256]; device_count = rtlsdr_get_device_count(); if (!device_count) { fprintf(stderr, "[dvbt][e]No supported RTLSDR devices found.\n"); exit(1); } fprintf(stderr, "[dvbt][i]Found %d device(s):\n", device_count); for (j = 0; j < device_count; j++) { rtlsdr_get_device_usb_strings(j, vendor, product, serial); fprintf(stderr, "[dvbt][i]%d: %s, %s, SN: %s %s\n", j, vendor, product, serial, (j == Modes.dev_index) ? "(currently selected)" : ""); } if (rtlsdr_open(&Modes.dev, Modes.dev_index) < 0) { fprintf(stderr, "[dvbt][e]Error opening the RTLSDR device: %s\n", strerror(errno)); exit(1); } /* Set gain, frequency, sample rate, and reset the device. */ rtlsdr_set_tuner_gain_mode(Modes.dev, (Modes.gain == MODES_AUTO_GAIN) ? 0 : 1); if (Modes.gain != MODES_AUTO_GAIN) { if (Modes.gain == MODES_MAX_GAIN) { /* Find the maximum gain available. */ int numgains; int gains[100]; numgains = rtlsdr_get_tuner_gains(Modes.dev, gains); Modes.gain = gains[numgains-1]; fprintf(stderr, "[dvbt][i]Max available gain is: %.2f\n", Modes.gain/10.0); } rtlsdr_set_tuner_gain(Modes.dev, Modes.gain); fprintf(stderr, "[dvbt][i]Setting gain to: %.2f\n", Modes.gain/10.0); } else { fprintf(stderr, "[dvbt][i]Using automatic gain control.\n"); } if( Modes.ppm_error != 0) { fprintf(stderr, "[dvbt][i]Setting ppm error to: %d\n", Modes.ppm_error); } rtlsdr_set_freq_correction(Modes.dev, Modes.ppm_error); if (Modes.enable_agc) rtlsdr_set_agc_mode(Modes.dev, 1); rtlsdr_set_center_freq(Modes.dev, Modes.freq); rtlsdr_set_sample_rate(Modes.dev, MODES_DEFAULT_RATE); rtlsdr_reset_buffer(Modes.dev); fprintf(stderr, "[dvbt][i]Gain reported by device: %.2f\n", rtlsdr_get_tuner_gain(Modes.dev)/10.0); }
int main(int argc, char **argv) { #ifndef _WIN32 struct sigaction sigact; #endif int n_read, r, opt, i; int sync_mode = 0; uint8_t *buffer; int dev_index = 0; int dev_given = 0; uint32_t out_block_size = DEFAULT_BUF_LENGTH; int count; int gains[100]; while ((opt = getopt(argc, argv, "d:s:b:tp::Sh")) != -1) { switch (opt) { case 'd': dev_index = verbose_device_search(optarg); dev_given = 1; break; case 's': samp_rate = (uint32_t)atof(optarg); break; case 'b': out_block_size = (uint32_t)atof(optarg); break; case 't': test_mode = TUNER_BENCHMARK; break; case 'p': test_mode = PPM_BENCHMARK; if (optarg) ppm_duration = atoi(optarg); break; case 'S': sync_mode = 1; break; case 'h': default: usage(); break; } } if(out_block_size < MINIMAL_BUF_LENGTH || out_block_size > MAXIMAL_BUF_LENGTH ){ fprintf(stderr, "Output block size wrong value, falling back to default\n"); fprintf(stderr, "Minimal length: %u\n", MINIMAL_BUF_LENGTH); fprintf(stderr, "Maximal length: %u\n", MAXIMAL_BUF_LENGTH); out_block_size = DEFAULT_BUF_LENGTH; } buffer = malloc(out_block_size * sizeof(uint8_t)); if (!dev_given) { dev_index = verbose_device_search("0"); } if (dev_index < 0) { exit(1); } r = rtlsdr_open(&dev, (uint32_t)dev_index); if (r < 0) { fprintf(stderr, "Failed to open rtlsdr device #%d.\n", dev_index); exit(1); } #ifndef _WIN32 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); #else SetConsoleCtrlHandler( (PHANDLER_ROUTINE) sighandler, TRUE ); #endif count = rtlsdr_get_tuner_gains(dev, NULL); fprintf(stderr, "Supported gain values (%d): ", count); count = rtlsdr_get_tuner_gains(dev, gains); for (i = 0; i < count; i++) fprintf(stderr, "%.1f ", gains[i] / 10.0); fprintf(stderr, "\n"); /* Set the sample rate */ verbose_set_sample_rate(dev, samp_rate); if (test_mode == TUNER_BENCHMARK) { tuner_benchmark(); goto exit; } /* Enable test mode */ r = rtlsdr_set_testmode(dev, 1); /* Reset endpoint before we start reading from it (mandatory) */ verbose_reset_buffer(dev); if ((test_mode == PPM_BENCHMARK) && !sync_mode) { fprintf(stderr, "Reporting PPM error measurement every %i seconds...\n", ppm_duration); fprintf(stderr, "Press ^C after a few minutes.\n"); } if (test_mode == NO_BENCHMARK) { fprintf(stderr, "\nInfo: This tool will continuously" " read from the device, and report if\n" "samples get lost. If you observe no " "further output, everything is fine.\n\n"); } if (sync_mode) { fprintf(stderr, "Reading samples in sync mode...\n"); fprintf(stderr, "(Samples are being lost but not reported.)\n"); while (!do_exit) { r = rtlsdr_read_sync(dev, buffer, out_block_size, &n_read); if (r < 0) { fprintf(stderr, "WARNING: sync read failed.\n"); break; } if ((uint32_t)n_read < out_block_size) { fprintf(stderr, "Short read, samples lost, exiting!\n"); break; } underrun_test(buffer, n_read, 1); } } else { fprintf(stderr, "Reading samples in async mode...\n"); r = rtlsdr_read_async(dev, rtlsdr_callback, NULL, 0, out_block_size); } if (do_exit) { fprintf(stderr, "\nUser cancel, exiting...\n"); fprintf(stderr, "Samples per million lost (minimum): %i\n", (int)(1000000L * dropped_samples / total_samples)); } else fprintf(stderr, "\nLibrary error %d, exiting...\n", r); exit: rtlsdr_close(dev); free (buffer); return r >= 0 ? r : -r; }
// // =============================== RTLSDR handling ========================== // int modesInitRTLSDR(void) { int j; int device_count, dev_index = 0; char vendor[256], product[256], serial[256]; if (Modes.dev_name) { if ( (dev_index = verbose_device_search(Modes.dev_name)) < 0 ) return -1; } device_count = rtlsdr_get_device_count(); if (!device_count) { fprintf(stderr, "No supported RTLSDR devices found.\n"); return -1; } fprintf(stderr, "Found %d device(s):\n", device_count); for (j = 0; j < device_count; j++) { rtlsdr_get_device_usb_strings(j, vendor, product, serial); fprintf(stderr, "%d: %s, %s, SN: %s %s\n", j, vendor, product, serial, (j == dev_index) ? "(currently selected)" : ""); } if (rtlsdr_open(&Modes.dev, dev_index) < 0) { fprintf(stderr, "Error opening the RTLSDR device: %s\n", strerror(errno)); return -1; } // Set gain, frequency, sample rate, and reset the device rtlsdr_set_tuner_gain_mode(Modes.dev, (Modes.gain == MODES_AUTO_GAIN) ? 0 : 1); if (Modes.gain != MODES_AUTO_GAIN) { int *gains; int numgains; numgains = rtlsdr_get_tuner_gains(Modes.dev, NULL); if (numgains <= 0) { fprintf(stderr, "Error getting tuner gains\n"); return -1; } gains = malloc(numgains * sizeof(int)); if (rtlsdr_get_tuner_gains(Modes.dev, gains) != numgains) { fprintf(stderr, "Error getting tuner gains\n"); free(gains); return -1; } if (Modes.gain == MODES_MAX_GAIN) { int highest = -1; int i; for (i = 0; i < numgains; ++i) { if (gains[i] > highest) highest = gains[i]; } Modes.gain = highest; fprintf(stderr, "Max available gain is: %.2f dB\n", Modes.gain/10.0); } else { int closest = -1; int i; for (i = 0; i < numgains; ++i) { if (closest == -1 || abs(gains[i] - Modes.gain) < abs(closest - Modes.gain)) closest = gains[i]; } if (closest != Modes.gain) { Modes.gain = closest; fprintf(stderr, "Closest available gain: %.2f dB\n", Modes.gain/10.0); } } free(gains); fprintf(stderr, "Setting gain to: %.2f dB\n", Modes.gain/10.0); if (rtlsdr_set_tuner_gain(Modes.dev, Modes.gain) < 0) { fprintf(stderr, "Error setting tuner gains\n"); return -1; } } else { fprintf(stderr, "Using automatic gain control.\n"); } rtlsdr_set_freq_correction(Modes.dev, Modes.ppm_error); if (Modes.enable_agc) rtlsdr_set_agc_mode(Modes.dev, 1); rtlsdr_set_center_freq(Modes.dev, Modes.freq); rtlsdr_set_sample_rate(Modes.dev, (unsigned)Modes.sample_rate); rtlsdr_reset_buffer(Modes.dev); fprintf(stderr, "Gain reported by device: %.2f dB\n", rtlsdr_get_tuner_gain(Modes.dev)/10.0); return 0; }
void dabStick::setupDevice (int32_t rateIn, int32_t rateOut) { int r; int16_t deviceIndex; int16_t i; // libraryLoaded = false; workerHandle = NULL; d_filter = NULL; _I_Buffer = NULL; open = false; statusLabel -> setText ("setting up"); #ifdef __MINGW32__ Handle = LoadLibrary ((wchar_t *)L"rtlsdr.dll"); #else Handle = dlopen ("librtlsdr.so", RTLD_NOW); #endif if (Handle == NULL) { fprintf (stderr, "Failed to open rtlsdr.dll\n"); statusLabel -> setText ("no rtlsdr lib"); return; } libraryLoaded = true; fprintf (stderr, "rtlsdr is loaded\n"); if (!load_rtlFunctions ()) { statusLabel -> setText ("load failed"); goto err; } // vfoFrequency is the VFO frequency vfoFrequency = KHz (94700); // just a dummy vfoOffset = 0; deviceCount = (this -> rtlsdr_get_device_count) (); if (deviceCount == 0) { statusLabel -> setText ("no device"); fprintf (stderr, "No devices found\n"); goto err; } deviceIndex = 0; // default if (deviceCount > 1) { dongleSelector = new dongleSelect (); for (deviceIndex = 0; deviceIndex < deviceCount; deviceIndex ++) { dongleSelector -> addtoDongleList (rtlsdr_get_device_name (deviceIndex)); } deviceIndex = dongleSelector -> QDialog::exec (); delete dongleSelector; } // // OK, now open the hardware r = this -> rtlsdr_open (&device, deviceIndex); if (r < 0) { fprintf (stderr, "Opening dabstick failed\n"); statusLabel -> setText ("opening failed"); goto err; } open = true; r = (this -> rtlsdr_set_sample_rate) (device, rateIn); if (r < 0) { fprintf (stderr, "Setting samplerate failed\n"); statusLabel -> setText ("samplerate"); goto err; } gainsCount = rtlsdr_get_tuner_gains (device, NULL); fprintf(stderr, "Supported gain values (%d): ", gainsCount); gains = new int [gainsCount]; gainsCount = rtlsdr_get_tuner_gains (device, gains); for (i = 0; i < gainsCount; i++) fprintf(stderr, "%.1f ", gains [i] / 10.0); rtlsdr_set_tuner_gain_mode (device, 1); rtlsdr_set_tuner_gain (device, gains [gainsCount / 2]); gainSlider -> setMaximum (gainsCount); gainSlider -> setValue (8); _I_Buffer = new RingBuffer<uint8_t>(1024 * 1024); workerHandle = NULL; d_filter = new DecimatingFIR (rateIn / rateOut * 5 - 1, - rateOut / 2, rateOut / 2, rateIn, rateIn / rateOut); connect (gainSlider, SIGNAL (valueChanged (int)), this, SLOT (setExternalGain (int))); connect (f_correction, SIGNAL (valueChanged (int)), this, SLOT (setCorrection (int))); connect (khzOffset, SIGNAL (valueChanged (int)), this, SLOT (setKhzOffset (int))); connect (hzOffset, SIGNAL (valueChanged (int)), this, SLOT (setHzOffset (int))); connect (rateSelector, SIGNAL (activated (const QString &)), this, SLOT (set_rateSelector (const QString &))); connect (checkAgc, SIGNAL (stateChanged (int)), this, SLOT (setAgc (int))); if (dabSettings != NULL) { dabSettings -> beginGroup ("dabStick"); int k = dabSettings -> value ("dab_externalGain", 24). toInt (); gainSlider -> setValue (k); k = dabSettings -> value ("dab_correction", 0). toInt (); f_correction -> setValue (k); k = dabSettings -> value ("dab_khzOffset", 0). toInt (); khzOffset -> setValue (k); k = dabSettings -> value ("dab_hzOffset", 0). toInt (); hzOffset -> setValue (k); dabSettings -> endGroup (); } statusLabel -> setText ("Loaded"); return; err: if (open) rtlsdr_close (device); #ifdef __MINGW32__ FreeLibrary (Handle); #else dlclose (Handle); #endif libraryLoaded = false; open = false; return; }
// // Our wrapper is a simple classs dabStick::dabStick (QSettings *s, bool *success) { int16_t deviceCount; int32_t r; int16_t deviceIndex; int16_t i; QString temp; int k; dabstickSettings = s; *success = false; // just the default this -> myFrame = new QFrame (NULL); setupUi (this -> myFrame); this -> myFrame -> show (); inputRate = 2048000; libraryLoaded = false; open = false; _I_Buffer = NULL; workerHandle = NULL; lastFrequency = KHz (94700); // just a dummy this -> sampleCounter= 0; this -> vfoOffset = 0; gains = NULL; #ifdef __MINGW32__ const char *libraryString = "rtlsdr.dll"; Handle = LoadLibrary ((wchar_t *)L"rtlsdr.dll"); #else const char *libraryString = "librtlsdr.so"; Handle = dlopen ("librtlsdr.so", RTLD_NOW); #endif if (Handle == NULL) { fprintf (stderr, "failed to open %s\n", libraryString); return; } libraryLoaded = true; if (!load_rtlFunctions ()) goto err; // // Ok, from here we have the library functions accessible deviceCount = this -> rtlsdr_get_device_count (); if (deviceCount == 0) { fprintf (stderr, "No devices found\n"); return; } deviceIndex = 0; // default if (deviceCount > 1) { dongleSelector = new dongleSelect (); for (deviceIndex = 0; deviceIndex < deviceCount; deviceIndex ++) { dongleSelector -> addtoDongleList (rtlsdr_get_device_name (deviceIndex)); } deviceIndex = dongleSelector -> QDialog::exec (); delete dongleSelector; } // // OK, now open the hardware r = this -> rtlsdr_open (&device, deviceIndex); if (r < 0) { fprintf (stderr, "Opening dabstick failed\n"); *success = false; return; } open = true; r = this -> rtlsdr_set_sample_rate (device, inputRate); if (r < 0) { fprintf (stderr, "Setting samplerate failed\n"); *success = false; return; } r = this -> rtlsdr_get_sample_rate (device); fprintf (stderr, "samplerate set to %d\n", r); gainsCount = rtlsdr_get_tuner_gains (device, NULL); fprintf(stderr, "Supported gain values (%d): ", gainsCount); gains = new int [gainsCount]; gainsCount = rtlsdr_get_tuner_gains (device, gains); for (i = gainsCount; i > 0; i--) { fprintf(stderr, "%.1f ", gains [i - 1] / 10.0); combo_gain -> addItem (QString::number (gains [i - 1])); } rtlsdr_set_tuner_gain_mode (device, 1); rtlsdr_set_tuner_gain (device, gains [gainsCount / 2]); _I_Buffer = new RingBuffer<uint8_t>(1024 * 1024); dabstickSettings -> beginGroup ("dabstickSettings"); temp = dabstickSettings -> value ("externalGain", "10"). toString (); k = combo_gain -> findText (temp); if (k != -1) { combo_gain -> setCurrentIndex (k); rtlsdr_set_tuner_gain (device, temp. toInt ()); } temp = dabstickSettings -> value ("autogain", "autogain off"). toString (); rtlsdr_set_tuner_gain_mode (device, temp == "autogain off" ? 0 : 1); f_correction -> setValue (dabstickSettings -> value ("f_correction", 0). toInt ()); KhzOffset -> setValue (dabstickSettings -> value ("KhzOffset", 0). toInt ()); dabstickSettings -> endGroup (); set_fCorrection (f_correction -> value ()); set_KhzOffset (KhzOffset -> value ()); connect (combo_gain, SIGNAL (activated (const QString &)), this, SLOT (setExternalGain (const QString &))); connect (combo_autogain, SIGNAL (activated (const QString &)), this, SLOT (set_autogain (const QString &))); connect (f_correction, SIGNAL (valueChanged (int)), this, SLOT (set_fCorrection (int))); connect (KhzOffset, SIGNAL (valueChanged (int)), this, SLOT (set_KhzOffset (int))); *success = true; return; err: if (open) this -> rtlsdr_close (device); #ifdef __MINGW32__ FreeLibrary (Handle); #else dlclose (Handle); #endif libraryLoaded = false; open = false; *success = false; return; }
static int do_sdr_decode(struct dab_state_t* dab, int frequency, int gain) { struct sigaction sigact; uint32_t dev_index = 0; int32_t device_count; int i,r; char vendor[256], product[256], serial[256]; uint32_t samp_rate = 2048000; memset(&sdr,0,sizeof(struct sdr_state_t)); sdr.frequency = frequency; //fprintf(stderr,"%i\n",sdr.frequency); /*--------------------------------------------------- Looking for device and open connection ----------------------------------------------------*/ device_count = rtlsdr_get_device_count(); if (!device_count) { fprintf(stderr, "No supported devices found.\n"); exit(1); } fprintf(stderr, "Found %d device(s):\n", device_count); for (i = 0; i < device_count; i++) { rtlsdr_get_device_usb_strings(i, vendor, product, serial); fprintf(stderr, " %d: %s, %s, SN: %s\n", i, vendor, product, serial); } fprintf(stderr, "\n"); fprintf(stderr, "Using device %d: %s\n",dev_index, rtlsdr_get_device_name(dev_index)); r = rtlsdr_open(&dev, dev_index); if (r < 0) { fprintf(stderr, "Failed to open rtlsdr device #%d.\n", dev_index); exit(1); } int gains[100]; int count = rtlsdr_get_tuner_gains(dev, gains); fprintf(stderr, "Supported gain values (%d): ", count); for (i = 0; i < count; i++) fprintf(stderr, "%.1f ", gains[i] / 10.0); fprintf(stderr, "\n"); /*------------------------------------------------- Set Frequency & Sample Rate --------------------------------------------------*/ /* Set the sample rate */ r = rtlsdr_set_sample_rate(dev, samp_rate); if (r < 0) fprintf(stderr, "WARNING: Failed to set sample rate.\n"); /* Set the frequency */ r = rtlsdr_set_center_freq(dev, sdr.frequency); if (r < 0) fprintf(stderr, "WARNING: Failed to set center freq.\n"); else fprintf(stderr, "Tuned to %u Hz.\n", sdr.frequency); /*------------------------------------------------ Setting gain -------------------------------------------------*/ if (gain == AUTO_GAIN) { r = rtlsdr_set_tuner_gain_mode(dev, 0); } else { r = rtlsdr_set_tuner_gain_mode(dev, 1); r = rtlsdr_set_tuner_gain(dev, gain); } if (r != 0) { fprintf(stderr, "WARNING: Failed to set tuner gain.\n"); } else if (gain == AUTO_GAIN) { fprintf(stderr, "Tuner gain set to automatic.\n"); } else { fprintf(stderr, "Tuner gain set to %0.2f dB.\n", gain/10.0); } /*----------------------------------------------- / Reset endpoint (mandatory) ------------------------------------------------*/ r = rtlsdr_reset_buffer(dev); /*----------------------------------------------- / Signal handler ------------------------------------------------*/ 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); /*----------------------------------------------- / start demod thread & rtl read -----------------------------------------------*/ fprintf(stderr,"Waiting for sync...\n"); sdr_init(&sdr); //dab_fic_parser_init(&sinfo); //dab_analyzer_init(&ana); pthread_create(&demod_thread, NULL, demod_thread_fn, (void *)(dab)); rtlsdr_read_async(dev, rtlsdr_callback, (void *)(&sdr), DEFAULT_ASYNC_BUF_NUMBER, DEFAULT_BUF_LENGTH); if (do_exit) { fprintf(stderr, "\nUser cancel, exiting...\n");} else { fprintf(stderr, "\nLibrary error %d, exiting...\n", r);} rtlsdr_cancel_async(dev); //dab_demod_close(&dab); rtlsdr_close(dev); return 1; }
int main(int argc, char **argv) { #ifndef _WIN32 struct sigaction sigact; #endif int n_read; int r, opt; int i, tuner_benchmark = 0; int sync_mode = 0; uint8_t *buffer; uint32_t dev_index = 0; uint32_t samp_rate = DEFAULT_SAMPLE_RATE; uint32_t out_block_size = DEFAULT_BUF_LENGTH; int device_count; int count; int gains[100]; int real_rate; int64_t ns; while ((opt = getopt(argc, argv, "d:s:b:tpS::")) != -1) { switch (opt) { case 'd': dev_index = atoi(optarg); break; case 's': samp_rate = (uint32_t)atof(optarg); break; case 'b': out_block_size = (uint32_t)atof(optarg); break; case 't': tuner_benchmark = 1; break; case 'p': ppm_benchmark = PPM_DURATION; break; case 'S': sync_mode = 1; break; default: usage(); break; } } if(out_block_size < MINIMAL_BUF_LENGTH || out_block_size > MAXIMAL_BUF_LENGTH ){ fprintf(stderr, "Output block size wrong value, falling back to default\n"); fprintf(stderr, "Minimal length: %u\n", MINIMAL_BUF_LENGTH); fprintf(stderr, "Maximal length: %u\n", MAXIMAL_BUF_LENGTH); out_block_size = DEFAULT_BUF_LENGTH; } buffer = malloc(out_block_size * sizeof(uint8_t)); device_count = rtlsdr_get_device_count(); if (!device_count) { fprintf(stderr, "No supported devices found.\n"); exit(1); } fprintf(stderr, "Found %d device(s):\n", device_count); for (i = 0; i < device_count; i++) fprintf(stderr, " %d: %s\n", i, rtlsdr_get_device_name(i)); fprintf(stderr, "\n"); fprintf(stderr, "Using device %d: %s\n", dev_index, rtlsdr_get_device_name(dev_index)); r = rtlsdr_open(&dev, dev_index); if (r < 0) { fprintf(stderr, "Failed to open rtlsdr device #%d.\n", dev_index); exit(1); } #ifndef _WIN32 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); #else SetConsoleCtrlHandler( (PHANDLER_ROUTINE) sighandler, TRUE ); #endif count = rtlsdr_get_tuner_gains(dev, NULL); fprintf(stderr, "Supported gain values (%d): ", count); count = rtlsdr_get_tuner_gains(dev, gains); for (i = 0; i < count; i++) fprintf(stderr, "%.1f ", gains[i] / 10.0); fprintf(stderr, "\n"); /* Set the sample rate */ r = rtlsdr_set_sample_rate(dev, samp_rate); if (r < 0) fprintf(stderr, "WARNING: Failed to set sample rate.\n"); if (tuner_benchmark) { if (rtlsdr_get_tuner_type(dev) == RTLSDR_TUNER_E4000) e4k_benchmark(); else fprintf(stderr, "No E4000 tuner found, aborting.\n"); goto exit; } /* Enable test mode */ r = rtlsdr_set_testmode(dev, 1); /* Reset endpoint before we start reading from it (mandatory) */ r = rtlsdr_reset_buffer(dev); if (r < 0) fprintf(stderr, "WARNING: Failed to reset buffers.\n"); if (ppm_benchmark && !sync_mode) { fprintf(stderr, "Reporting PPM error measurement every %i seconds...\n", ppm_benchmark); fprintf(stderr, "Press ^C after a few minutes.\n"); #ifdef __APPLE__ gettimeofday(&tv, NULL); ppm_recent.tv_sec = tv.tv_sec; ppm_recent.tv_nsec = tv.tv_usec*1000; ppm_start.tv_sec = tv.tv_sec; ppm_start.tv_nsec = tv.tv_usec*1000; #elif __unix__ clock_gettime(CLOCK_REALTIME, &ppm_recent); clock_gettime(CLOCK_REALTIME, &ppm_start); #endif } if (!ppm_benchmark) { fprintf(stderr, "\nInfo: This tool will continuously" " read from the device, and report if\n" "samples get lost. If you observe no " "further output, everything is fine.\n\n"); } if (sync_mode) { fprintf(stderr, "Reading samples in sync mode...\n"); while (!do_exit) { r = rtlsdr_read_sync(dev, buffer, out_block_size, &n_read); if (r < 0) { fprintf(stderr, "WARNING: sync read failed.\n"); break; } if ((uint32_t)n_read < out_block_size) { fprintf(stderr, "Short read, samples lost, exiting!\n"); break; } } } else { fprintf(stderr, "Reading samples in async mode...\n"); r = rtlsdr_read_async(dev, rtlsdr_callback, NULL, DEFAULT_ASYNC_BUF_NUMBER, out_block_size); } if (do_exit) { fprintf(stderr, "\nUser cancel, exiting...\n"); if (ppm_benchmark) { #ifndef _WIN32 ns = 1000000000L * (int64_t)(ppm_recent.tv_sec - ppm_start.tv_sec); ns += (int64_t)(ppm_recent.tv_nsec - ppm_start.tv_nsec); real_rate = (int)(ppm_total * 1000000000L / ns); printf("Cumulative PPM error: %i\n", (int)round((double)(1000000 * (real_rate - (int)samp_rate)) / (double)samp_rate)); #endif } } else fprintf(stderr, "\nLibrary error %d, exiting...\n", r); exit: rtlsdr_close(dev); free (buffer); return r >= 0 ? r : -r; }
static int do_sdr_decode(struct dab_state_t* dab, int frequency, int gain) { struct sigaction sigact; uint32_t dev_index = 0; int32_t device_count; int i,r; char vendor[256], product[256], serial[256]; uint32_t samp_rate = 2048000; memset(&sdr,0,sizeof(struct sdr_state_t)); sdr.frequency = frequency; //fprintf(stderr,"%i\n",sdr.frequency); /*--------------------------------------------------- Looking for device and open connection ----------------------------------------------------*/ if (dab->device_type == DAB_DEVICE_RTLSDR) { sdr.convert_unsigned = 1; device_count = rtlsdr_get_device_count(); if (!device_count) { fprintf(stderr, "No supported devices found.\n"); exit(1); } fprintf(stderr, "Found %d device(s):\n", device_count); for (i = 0; i < device_count; i++) { rtlsdr_get_device_usb_strings(i, vendor, product, serial); fprintf(stderr, " %d: %s, %s, SN: %s\n", i, vendor, product, serial); } fprintf(stderr, "\n"); fprintf(stderr, "Using device %d: %s\n",dev_index, rtlsdr_get_device_name(dev_index)); r = rtlsdr_open(&dev, dev_index); if (r < 0) { fprintf(stderr, "Failed to open rtlsdr device #%d.\n", dev_index); exit(1); } int gains[100]; int count = rtlsdr_get_tuner_gains(dev, gains); fprintf(stderr, "Supported gain values (%d): ", count); for (i = 0; i < count; i++) fprintf(stderr, "%.1f ", gains[i] / 10.0); fprintf(stderr, "\n"); } else if (dab->device_type == DAB_DEVICE_HACKRF) { sdr.convert_unsigned = 0; r = hackrf_init(); if( r != HACKRF_SUCCESS ) { hackrf_err("hackrf_init() failed", r); return EXIT_FAILURE; } const char* serial_number = nullptr; r = hackrf_open_by_serial(serial_number, &hackrf); if( r != HACKRF_SUCCESS ) { hackrf_err("hackrf_open() failed", r); return EXIT_FAILURE; } } else { r = -1; return EXIT_FAILURE; } /*------------------------------------------------- Set Frequency & Sample Rate --------------------------------------------------*/ if (dab->device_type == DAB_DEVICE_RTLSDR) { /* Set the sample rate */ r = rtlsdr_set_sample_rate(dev, samp_rate); if (r < 0) fprintf(stderr, "WARNING: Failed to set sample rate.\n"); /* Set the frequency */ r = rtlsdr_set_center_freq(dev, sdr.frequency); if (r < 0) fprintf(stderr, "WARNING: Failed to set center freq.\n"); else fprintf(stderr, "Tuned to %u Hz.\n", sdr.frequency); /*------------------------------------------------ Setting gain -------------------------------------------------*/ if (gain == AUTO_GAIN) { r = rtlsdr_set_tuner_gain_mode(dev, 0); } else { r = rtlsdr_set_tuner_gain_mode(dev, 1); r = rtlsdr_set_tuner_gain(dev, gain); } if (r != 0) { fprintf(stderr, "WARNING: Failed to set tuner gain.\n"); } else if (gain == AUTO_GAIN) { fprintf(stderr, "Tuner gain set to automatic.\n"); } else { fprintf(stderr, "Tuner gain set to %0.2f dB.\n", gain/10.0); } /*----------------------------------------------- / Reset endpoint (mandatory) ------------------------------------------------*/ r = rtlsdr_reset_buffer(dev); } else if (dab->device_type == DAB_DEVICE_HACKRF) { int sample_rate_hz = samp_rate; fprintf(stderr, "call hackrf_sample_rate_set(%u Hz/%.03f MHz)\n", sample_rate_hz, (sample_rate_hz/1e6)); int r = hackrf_set_sample_rate_manual(hackrf, sample_rate_hz, 1); if( r != HACKRF_SUCCESS ) { hackrf_err("hackrf_sample_rate_set() failed", r); return EXIT_FAILURE; } /* possible settings 1.75/2.5/3.5/5/5.5/6/7/8/9/10/12/14/15/20/24/28 */ int baseband_filter_bw_hz = 2500000; fprintf(stderr, "call hackrf_baseband_filter_bandwidth_set(%d Hz/%.03f MHz)\n", baseband_filter_bw_hz, ((float)baseband_filter_bw_hz/1e6)); r = hackrf_set_baseband_filter_bandwidth(hackrf, baseband_filter_bw_hz); if( r != HACKRF_SUCCESS ) { hackrf_err("hackrf_baseband_filter_bandwidth_set()", r); return EXIT_FAILURE; } r = hackrf_set_vga_gain(hackrf, hackrf_vga_gain); r |= hackrf_set_lna_gain(hackrf, hackrf_lna_gain); if( r != HACKRF_SUCCESS ) { hackrf_err("hackrf_vga gain/lna gain", r); return EXIT_FAILURE; } r = hackrf_set_freq(hackrf, sdr.frequency); if( r != HACKRF_SUCCESS ) { hackrf_err("hackrf_set_freq()", r); return EXIT_FAILURE; } } /*----------------------------------------------- / Signal handler ------------------------------------------------*/ 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); /*----------------------------------------------- / start demod thread & rtl read -----------------------------------------------*/ fprintf(stderr,"Waiting for sync...\n"); sdr_init(&sdr); //dab_fic_parser_init(&sinfo); //dab_analyzer_init(&ana); pthread_create(&demod_thread, NULL, demod_thread_fn, (void *)(dab)); if (dab->device_type == DAB_DEVICE_RTLSDR) { rtlsdr_read_async(dev, rtlsdr_callback, (void *)(&sdr), DEFAULT_ASYNC_BUF_NUMBER, DEFAULT_BUF_LENGTH); } else if (dab->device_type == DAB_DEVICE_HACKRF) { r = hackrf_start_rx(hackrf, hackrf_callback, (void *)(&sdr)); if( r != HACKRF_SUCCESS ) { hackrf_err("hackrf_start_x()", r); return EXIT_FAILURE; } while( ((r=hackrf_is_streaming(hackrf)) == HACKRF_TRUE) && (do_exit == false) ) { sleep(1); fprintf(stderr, "samples: low: %02.2f%%, saturating: %02.2f%%\n", num_low_power * 100.0 / DEFAULT_BUF_LENGTH, num_saturated * 100.0 / DEFAULT_BUF_LENGTH); } hackrf_err("hackrf_is_streaming", r); } if (do_exit) { fprintf(stderr, "\nUser cancel, exiting...\n");} else { fprintf(stderr, "\nLibrary error %d, exiting...\n", r);} if (dab->device_type == DAB_DEVICE_RTLSDR) { rtlsdr_cancel_async(dev); //dab_demod_close(&dab); rtlsdr_close(dev); } else if (dab->device_type == DAB_DEVICE_HACKRF) { if (hackrf != NULL) { r = hackrf_stop_rx(hackrf); if( r != HACKRF_SUCCESS ) { hackrf_err("hackrf_stop_rx() failed", r); } else { fprintf(stderr, "hackrf_stop_rx() done\n"); } r = hackrf_close(hackrf); if( r != HACKRF_SUCCESS ) { hackrf_err("hackrf_close() failed", r); } else { fprintf(stderr, "hackrf_close() done\n"); } } hackrf_exit(); } return 1; }