void glut_keyboard( unsigned char key, int x, int y ) { switch(key) { case 'q': frequency -= 1e6; int r = rtlsdr_set_center_freq(dev, frequency); if (r < 0) fprintf(stderr, "WARNING: Failed to set center freq.\n"); else fprintf(stderr, "\rTuned to %f MHz.", frequency/1e6); sprintf(strFreq,"%4.0f",frequency/1e6); break; case 'w': frequency += 1e6; r = rtlsdr_set_center_freq(dev, frequency); if (r < 0) fprintf(stderr, "WARNING: Failed to set center freq.\n"); else fprintf(stderr, "\rTuned to %f MHz.", frequency/1e6); sprintf(strFreq,"%4.0f",frequency/1e6); break; case 'a': pwr_diff *= .5; fprintf(stderr, "\rpwr_diff reset to %.4f", pwr_diff); break; case 'z': pwr_diff *= 2.; fprintf(stderr, "\rpwr_diff reset to %.4f", pwr_diff); break; case 27: // Escape key fprintf(stderr, "\nbye\n"); exit(0); break; } }
// // // Note that selecting a new rate implies // restarting the program void dabStick::set_rateSelector (const QString &s) { int32_t newRate = s. toInt (); int32_t r; if (outputRate == newRate) return; outputRate = newRate; inputRate = getInputRate (outputRate); if (workerHandle == NULL) { r = rtlsdr_set_sample_rate (device, inputRate); (void)rtlsdr_set_center_freq (device, vfoFrequency + vfoOffset); } else { // we stop the transmission!!! stopReader (); r = rtlsdr_set_sample_rate (device, inputRate); r = rtlsdr_reset_buffer (device); rtlsdr_set_center_freq (device, vfoFrequency + vfoOffset); } (void)r; delete d_filter; d_filter = new DecimatingFIR (inputRate / outputRate * 5 - 1, - outputRate / 2, outputRate / 2, inputRate, inputRate / outputRate); emit set_changeRate (outputRate); }
static void *demod_thread_fn(void *arg) { struct dab_state_t *dab = arg; struct sdr_state_t *sdr = dab->device_state; int i,j; while (!do_exit) { sem_wait(&data_ready); int ok = sdr_demod(&dab->tfs[dab->tfidx], sdr); if (ok) { dab_process_frame(dab); } //dab_fic_parser(dab->fib,&sinfo,&ana); // calculate error rates //dab_analyzer_calculate_error_rates(&ana,dab); int prev_freq = sdr->frequency; if (abs(sdr->coarse_freq_shift)>1) { if (sdr->coarse_freq_shift<0) sdr->frequency = sdr->frequency -1000; else sdr->frequency = sdr->frequency +1000; rtlsdr_set_center_freq(dev,sdr->frequency); } if (abs(sdr->coarse_freq_shift) ==1) { if (sdr->coarse_freq_shift<0) sdr->frequency = sdr->frequency -rand() % 1000; else sdr->frequency = sdr->frequency +rand() % 1000; rtlsdr_set_center_freq(dev,sdr->frequency); //fprintf(stderr,"new center freq : %i\n",rtlsdr_get_center_freq(dev)); } if (abs(sdr->coarse_freq_shift)<1 && (abs(sdr->fine_freq_shift) > 50)) { sdr->frequency = sdr->frequency + (sdr->fine_freq_shift/3); rtlsdr_set_center_freq(dev,sdr->frequency); //fprintf(stderr,"ffs : %f\n",sdr->fine_freq_shift); } //if (sdr->frequency != prev_freq) { // fprintf(stderr,"Adjusting centre-frequency to %dHz\n",sdr->frequency); //} ccount += 1; if (ccount == 10) { ccount = 0; //print_status(dab); } } return 0; }
static void *demod_thread_fn(void *arg) { dab_state *dab = arg; while (!do_exit) { sem_wait(&data_ready); dab_demod(dab); dab_fic_parser(dab->fib,&sinfo,&ana); // calculate error rates dab_analyzer_calculate_error_rates(&ana,dab); if (abs(dab->coarse_freq_shift)>1) { if (dab->coarse_freq_shift<0) dab->frequency = dab->frequency -1000; else dab->frequency = dab->frequency +1000; rtlsdr_set_center_freq(dev,dab->frequency); } if (abs(dab->coarse_freq_shift) ==1) { if (dab->coarse_freq_shift<0) dab->frequency = dab->frequency -rand() % 1000; else dab->frequency = dab->frequency +rand() % 1000; rtlsdr_set_center_freq(dev,dab->frequency); //fprintf(stderr,"new center freq : %i\n",rtlsdr_get_center_freq(dev)); } if (abs(dab->coarse_freq_shift)<1 && (abs(dab->fine_freq_shift) > 50)) { dab->frequency = dab->frequency + (dab->fine_freq_shift/3); rtlsdr_set_center_freq(dev,dab->frequency); //fprintf(stderr,"ffs : %f\n",dab->fine_freq_shift); } ccount += 1; if (ccount == 10) { ccount = 0; print_status(dab); } } return 0; }
void CRtlSdr::setFrequency(uint freq) { if (!power) return; int ret = rtlsdr_set_center_freq(dongle.dev, freq); if (ret<0) qDebug() << "Frequency not set to " << freq << "\n"; }
void retune(rtlsdr_dev_t *d, int freq) { uint8_t dump[BUFFER_DUMP]; int n_read; // // NB: time scan pass // struct timeval stop, start; // // // Record start time // gettimeofday(&start, NULL); rtlsdr_set_center_freq(d, (uint32_t)freq); /* wait for settling and flush buffer */ usleep(5000); rtlsdr_read_sync(d, &dump, BUFFER_DUMP, &n_read); if (n_read != BUFFER_DUMP) { fprintf(stderr, "Error: bad retune.\n");} // // Compute scan time // gettimeofday(&stop, NULL); // // long startTime = start.tv_sec * 1000000 + start.tv_usec; // long stopTime = stop.tv_sec * 1000000 + stop.tv_usec; // printf("Retune took %ld micros\n", stopTime - startTime); }
static void optimal_settings(struct fm_state *fm, int freq, int hopping) { int r, capture_freq, capture_rate; fm->downsample = (1000000 / fm->sample_rate) + 1; fm->freq_now = freq; capture_rate = fm->downsample * fm->sample_rate; capture_freq = fm->freqs[freq] + capture_rate/4; capture_freq += fm->edge * fm->sample_rate / 2; fm->output_scale = (1<<15) / (128 * fm->downsample); if (fm->output_scale < 1) { fm->output_scale = 1;} fm->output_scale = 1; /* Set the frequency */ r = rtlsdr_set_center_freq(dev, (uint32_t)capture_freq); if (hopping) { return;} fprintf(stderr, "Oversampling input by: %ix.\n", fm->downsample); fprintf(stderr, "Oversampling output by: %ix.\n", fm->post_downsample); fprintf(stderr, "Buffer size: %0.2fms\n", 1000 * 0.5 * (float)DEFAULT_BUF_LENGTH / (float)capture_rate); if (r < 0) { fprintf(stderr, "WARNING: Failed to set center freq.\n");} else { fprintf(stderr, "Tuned to %u Hz.\n", capture_freq);} /* Set the sample rate */ fprintf(stderr, "Sampling at %u Hz.\n", capture_rate); r = rtlsdr_set_sample_rate(dev, (uint32_t)capture_rate); if (r < 0) { fprintf(stderr, "WARNING: Failed to set sample rate.\n");} }
void e4k_benchmark(void) { uint32_t freq, gap_start = 0, gap_end = 0; uint32_t range_start = 0, range_end = 0; fprintf(stderr, "Benchmarking E4000 PLL...\n"); /* find tuner range start */ for (freq = MHZ(70); freq > MHZ(1); freq -= MHZ(1)) { if (rtlsdr_set_center_freq(dev, freq) < 0) { range_start = freq; break; } } /* find tuner range end */ for (freq = MHZ(2000); freq < MHZ(2300UL); freq += MHZ(1)) { if (rtlsdr_set_center_freq(dev, freq) < 0) { range_end = freq; break; } } /* find start of L-band gap */ for (freq = MHZ(1000); freq < MHZ(1300); freq += MHZ(1)) { if (rtlsdr_set_center_freq(dev, freq) < 0) { gap_start = freq; break; } } /* find end of L-band gap */ for (freq = MHZ(1300); freq > MHZ(1000); freq -= MHZ(1)) { if (rtlsdr_set_center_freq(dev, freq) < 0) { gap_end = freq; break; } } fprintf(stderr, "E4K range: %i to %i MHz\n", range_start/MHZ(1) + 1, range_end/MHZ(1) - 1); fprintf(stderr, "E4K L-band gap: %i to %i MHz\n", gap_start/MHZ(1), gap_end/MHZ(1)); }
static void *dongle_f(void *arg) { struct dongle_struct *ds = arg; rtlsdr_dev_t *dev = NULL; fprintf(stderr, "Initializing %d\n", ds->id); #ifdef PURKKA1 CHECK1(rtlsdr_open(&dev, (ds->id + 1) % 3)); #define trigger_id 2 #else CHECK1(rtlsdr_open(&dev, ds->id)); #define trigger_id 0 #endif ds->dev = dev; CHECK1(rtlsdr_set_sample_rate(dev, samprate)); CHECK1(rtlsdr_set_dithering(dev, 0)); CHECK1(rtlsdr_set_center_freq(dev, frequency)); CHECK1(rtlsdr_set_tuner_gain_mode(dev, 1)); CHECK1(rtlsdr_set_tuner_gain(dev, gain)); CHECK1(rtlsdr_reset_buffer(dev)); fprintf(stderr, "Initialized %d\n", ds->id); donglesok++; for(;;) { int task; pthread_mutex_lock(&dongle_m); if(dongle_task == DONGLE_EXIT) break; sem_post(&dongle_sem); pthread_cond_wait(&dongle_c, &dongle_m); task = dongle_task; pthread_mutex_unlock(&dongle_m); if(task == DONGLE_READ) { int ret; int blocksize = ds->blocksize, n_read = 0; n_read = 0; errno = 0; CHECK2(ret = rtlsdr_read_sync(dev, ds->buffer, blocksize, &n_read)); if(ret < 0) { } else if(n_read < blocksize) { fprintf(stderr, "Short read %d: %d/%d\n", ds->id, n_read, blocksize); } else if(coherent_debug) { fprintf(stderr, "Read %d\n", ds->id); } } else if(task == DONGLE_EXIT) break; } donglesok--; err: fprintf(stderr, "Exiting %d\n", ds->id); if(dev) CHECK2(rtlsdr_close(dev)); sem_post(&dongle_sem); return NULL; }
// // The external world sets a virtual VFO frequency // The real VFO frequency can be influences by an externally // set vfoOffset void dabStick::setVFOFrequency (int32_t f) { if (!open || !libraryLoaded) return; vfoFrequency = f; (void)rtlsdr_set_center_freq (device, f + vfoOffset); //fprintf (stderr, "request to set on %d, offset = %d, actual set to %d\n", // f, vfoOffset, (int32_t)rtlsdr_get_center_freq (device)); }
void retune(rtlsdr_dev_t *d, int freq) { uint8_t dump[BUFFER_DUMP]; int n_read; rtlsdr_set_center_freq(d, (uint32_t)freq); /* wait for settling and flush buffer */ usleep(5000); rtlsdr_read_sync(d, &dump, BUFFER_DUMP, &n_read); if (n_read != BUFFER_DUMP) { fprintf(stderr, "Error: bad retune.\n");} }
int rtlsdr_verbose_set_frequency(rtlsdr_dev_t *dev, uint32_t frequency) { int r; r = rtlsdr_set_center_freq(dev, frequency); if (r < 0) { fprintf(stderr, "WARNING: Failed to set center freq.\n"); } else { fprintf(stderr, "Tuned to %u Hz.\n", frequency); } return r; }
static void set_center_freq(struct dab_state_t *dab, long frequency) { if (dab->device_type == DAB_DEVICE_RTLSDR) { rtlsdr_set_center_freq(dev, frequency); } else if (dab->device_type == DAB_DEVICE_HACKRF) { hackrf_set_freq(hackrf, frequency); } else { abort(); } }
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 rtl_set_center_freq(rtl r, uint32_t center_freq) { int status; status = rtlsdr_set_center_freq(r->device, center_freq); if (status < 0) { ERROR("Failed to set center frequency.\n"); } else { DEBUG("Tuned to %u Hz.\n", center_freq); } return status; }
bool dabStick::restartReader (void) { int32_t r; if (!open ||!libraryLoaded) return false; if (workerHandle != NULL) // running already return true; r = rtlsdr_reset_buffer (device); if (r < 0) return false; rtlsdr_set_center_freq (device, vfoFrequency + vfoOffset); workerHandle = new dll_driver (this); return true; }
// Initilizes and Opens the RTL Dongle void Init_Device(int mode) { int r; int i = 0; int gain = 496; //496;//0;//125;//386; /* { 0, 9, 14, 27, 37, 77, 87, 125, 144, 157, 166, 197, 207, 229, 254, 280, 297, 328, 338, 364, 372, 386, 402, 421, 434, 439, 445, 480, 496 }; */ uint32_t dev_index = 0; uint32_t frequency = (d1.freq + d1.freqcorr) * 1e6; //1433170000;//1420400000;//1409246000;//1407630000;//34000000;//1420400000;//1421550000;//99500000;//100000000; uint32_t samp_rate = 2.4 * 1e6 + 0.5; //1400000;//2400000;//DEFAULT_SAMPLE_RATE; int device_count; char vendor[256], product[256], serial[256]; d1.dongle = 1; if (mode) { /* Set the frequency */ r = rtlsdr_set_center_freq(dev, frequency); if (r < 0) fprintf(stderr, "WARNING: Failed to set center freq.\n"); else if (d1.printout) printf("Tuned to %u Hz.\n", frequency); return; } device_count = rtlsdr_get_device_count(); if (!device_count) { fprintf(stderr, "No supported devices found.\n"); exit(1); } if (d1.printout) printf("Found %d device(s):\n", device_count); for (i = 0; i < device_count; i++) { rtlsdr_get_device_usb_strings(i, vendor, product, serial); if (d1.printout) printf(" %d: %s, %s, SN: %s\n", i, vendor, product, serial); } if (d1.printout) printf("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); } /* 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, frequency); if (r < 0) fprintf(stderr, "WARNING: Failed to set center freq.\n"); else if (d1.printout) printf("Tuned to %u Hz.\n", frequency); if (0 == gain) { /* Enable automatic gain */ r = rtlsdr_set_tuner_gain_mode(dev, 0); if (r < 0) fprintf(stderr, "WARNING: Failed to enable automatic gain.\n"); } else { /* Enable manual gain */ r = rtlsdr_set_tuner_gain_mode(dev, 1); if (r < 0) fprintf(stderr, "WARNING: Failed to enable manual gain.\n"); /* Set the tuner gain */// doesn't set gain to gain value - uses R828_Arry[0] = (R828_Arry[0] & 0xF0) | 0x0F;//0x06;//gLNA;//lna_index r = rtlsdr_set_tuner_gain(dev, gain); if (r < 0) fprintf(stderr, "WARNING: Failed to set tuner gain.\n"); } r = rtlsdr_reset_buffer(dev); // printf("Reset Status: %u \n", r); }
int main(int argc, char **argv) { // setup window glut_init(argc,argv); /// // init radio /// int 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); uint32_t dev_index = 0; fprintf(stderr, "Using device %d: %s\n", dev_index, rtlsdr_get_device_name(dev_index)); int r = rtlsdr_open(&dev, dev_index); if (r < 0) { fprintf(stderr, "Failed to open rtlsdr device #%d.\n", dev_index); exit(1); } /* Set the sample rate */ uint32_t samp_rate = DEFAULT_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 */ frequency = 100000000; if(argv[1]) frequency = (uint32_t)atof(argv[1]) * (uint32_t)1e6; if(frequency < 1e6) { fprintf(stderr, "WARNING: Center frequency should be in range, setting to 100MHz\n"); frequency = 100000000; } r = rtlsdr_set_center_freq(dev, frequency); if (r < 0) fprintf(stderr, "WARNING: Failed to set center freq.\n"); else fprintf(stderr, "Tuned to %f MHz.\n", frequency/1e6); sprintf(strFreq,"%4.0f",frequency/1e6); /* Set the gain */ int gain = 0; if(argv[2]) gain = atoi(argv[2]); if (!gain) { /* Enable automatic gain */ r = rtlsdr_set_tuner_gain_mode(dev, 0); if (r < 0) fprintf(stderr, "WARNING: Failed to enable automatic gain.\n"); } else { /* Enable manual gain */ r = rtlsdr_set_tuner_gain_mode(dev, 1); if (r < 0) fprintf(stderr, "WARNING: Failed to enable manual gain.\n"); /* Set the tuner gain */ r = rtlsdr_set_tuner_gain(dev, gain); if (r < 0) { fprintf(stderr, "WARNING: Failed to set tuner gain.\n"); fprintf(stderr, "Valid values for e4000 are: -10, 15, 40, 65, 90, 115, 140, 165, 190, 215, 240, 290, 340, 420, 430, 450, 470, 490\n"); fprintf(stderr, "Valid values for r820t are: 9, 14, 27, 37, 77, 87, 125, 144, 157, 166, 197, 207, 229, 254, 280, 297,\n\t328, 338, 364, 372, 386, 402, 421, 434, 439, 445, 480, 496\n"); fprintf(stderr, "Gain values are in tenths of dB, e.g. 115 means 11.5 dB.\n"); } else fprintf(stderr, "Tuner gain set to %f dB.\n", gain/10.0); } /* 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"); /// // setup fftw /// uint32_t out_block_size = DEFAULT_BUF_LENGTH; buffer = malloc(out_block_size * sizeof(uint8_t)); fftw_in = fftw_malloc ( sizeof ( fftw_complex ) * out_block_size/2 ); fftw_out = fftw_malloc ( sizeof ( fftw_complex ) * out_block_size/2 ); // put the plan on FFTW_MEASURE to calculate the optimal fft plan (takes a few seconds). // If performance of FFTW_ESTIMATE is good enough use that one //fftw_p = fftw_plan_dft_1d ( out_block_size/2, fftw_in, fftw_out, FFTW_FORWARD, FFTW_MEASURE ); fftw_p = fftw_plan_dft_1d ( out_block_size/2, fftw_in, fftw_out, FFTW_FORWARD, FFTW_ESTIMATE ); /* start reading samples */ fprintf(stderr, "Update frequency is %.2fHz.\n",((double)DEFAULT_SAMPLE_RATE / (double)DEFAULT_BUF_LENGTH)); fprintf(stderr, "Press [q,w] to change frequency, [a,z] to adjust waterfall color sensitivity, ESC to quit.\n"); pwr_max = 0.0f; pwr_diff = 1.0f; glutTimerFunc(0,readData,0); glutMainLoop(); return 0; }
void *dab2eti::demod_thread_fn(void *arg) { struct dab_state_t *dab = (dab_state_t *)arg; struct sdr_state_t *sdr = (sdr_state_t *)dab->device_state; while (!do_exit) { sem_wait(&data_ready); int ok = sdr_demod(&dab->tfs[dab->tfidx], sdr); if (ok) { dab_process_frame(dab); } //dab_fic_parser(dab->fib,&sinfo,&ana); // calculate error rates //dab_analyzer_calculate_error_rates(&ana,dab); // if the user changed the frequency if(new_frequency){ sdr->frequency = frequency; new_frequency = false; } // if the user changed the gain if(new_gain){ int r; 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); } new_gain = false; } // automatic fine tuning if (abs(sdr->coarse_freq_shift)>1) { if (sdr->coarse_freq_shift<0) sdr->frequency = sdr->frequency -1000; else sdr->frequency = sdr->frequency +1000; rtlsdr_set_center_freq(dev,sdr->frequency); } if (abs(sdr->coarse_freq_shift) ==1) { if (sdr->coarse_freq_shift<0) sdr->frequency = sdr->frequency -rand() % 1000; else sdr->frequency = sdr->frequency +rand() % 1000; rtlsdr_set_center_freq(dev,sdr->frequency); //fprintf(stderr,"new center freq : %i\n",rtlsdr_get_center_freq(dev)); } if (abs(sdr->coarse_freq_shift)<1 && (abs(sdr->fine_freq_shift) > 50)) { sdr->frequency = sdr->frequency + (sdr->fine_freq_shift/3); rtlsdr_set_center_freq(dev,sdr->frequency); //fprintf(stderr,"ffs : %f\n",sdr->fine_freq_shift); } //if (sdr->frequency != prev_freq) { // fprintf(stderr,"Adjusting centre-frequency to %dHz\n",sdr->frequency); //} ccount += 1; if (ccount == 10) { ccount = 0; //print_status(dab); } } return 0; }
void tuner_benchmark(void) { uint32_t current = max_step(0); uint32_t band_start = 0; uint32_t low_bound = 0, high_bound = 0; char buf[20]; enum { FIND_START, REFINE_START, FIND_END, REFINE_END } state; fprintf(stderr, "Testing tuner range. This may take a couple of minutes..\n"); /* Scan for tuneable frequencies coarsely. When we find something, * do a binary search to narrow down the exact edge of the band. * * This can potentially miss bands or band gaps that are smaller than max_step(freq) * but it is a lot faster than exhaustively scanning everything. */ /* handle bands starting at 0Hz */ if (rtlsdr_set_center_freq(dev, 0) < 0) state = FIND_START; else { band_start = 0; report_band_start(band_start); state = FIND_END; } while (current < 3e9 && !do_exit) { switch (state) { case FIND_START: /* scanning for the start of a new band */ if (rtlsdr_set_center_freq(dev, current) < 0) { /* still looking for a band */ low_bound = current; current += max_step(current); } else { /* new band, starting somewhere at or before current */ /* low_bound < start <= current, refine it */ high_bound = current; state = REFINE_START; } break; case REFINE_START: /* refining the start of a band */ /* low_bound < bandstart <= high_bound */ if (rtlsdr_set_center_freq(dev, current) == 0) { /* current is inside the band */ /* low_bound < bandstart <= current */ if (current - low_bound <= min_step(current)) { /* close enough. Say the band starts at current and go looking for the end of it. */ band_start = current; report_band_start(band_start); low_bound = current; state = FIND_END; } else { /* try halfway between low_bound and current */ high_bound = current; current = (current + low_bound) / 2; } } else { /* current is outside the band */ /* current < bandstart <= high_bound */ if (high_bound - current <= min_step(current)) { /* close enough. Say the band starts at high_bound and go looking for the end of it. */ current = low_bound = band_start = high_bound; report_band_start(band_start); state = FIND_END; } else { /* try halfway betwen current and high_bound */ low_bound = current; current = (current + high_bound) / 2; } } break; case FIND_END: /* scanning for the end of the current band */ if (rtlsdr_set_center_freq(dev, current) == 0) { /* still looking for the end of the band */ low_bound = current; current += max_step(current); } else { /* ran off the end of the band somewhere before current */ /* low_bound <= bandend < current, refine it */ high_bound = current; state = REFINE_END; } break; case REFINE_END: /* refining the end of a band */ /* low_bound <= bandend < high_bound */ if (rtlsdr_set_center_freq(dev, current) < 0) { /* current is outside the band */ /* low_bound <= bandend < current */ if (current - low_bound <= min_step(current)) { /* close enough. Say the band ends at low_bound and go looking for another band. */ report_band(band_start, low_bound); low_bound = current; state = FIND_START; } else { /* try halfway between low_bound and current */ high_bound = current; current = (current + low_bound) / 2; } } else { /* current is inside the band */ /* current <= bandend < high_bound */ if (high_bound - current <= min_step(current)) { /* close enough. Say the band ends at current and go looking for another band. */ report_band(band_start, current); current = low_bound = high_bound; state = FIND_START; } else { /* try halfway betwen current and high_bound */ low_bound = current; current = (current + high_bound) / 2; } } break; } } if (state == FIND_END) report_band(band_start, current); else if (state == REFINE_END) report_band(band_start, low_bound); }
void tune_sdr(struct rtlsdrstruct* sdr, uint32_t freq, struct liquidobjects* dsp) { rtlsdr_set_center_freq(sdr->device, freq); dsp->centerfreq = freq; }
int main(int argc, char **argv) { #ifndef _WIN32 struct sigaction sigact; #endif char *filename = NULL; int n_read; int r, opt; int i, gain = 0; int sync_mode = 0; FILE *file; uint8_t *buffer; uint32_t dev_index = 0; uint32_t udp_port = 6666; uint32_t frequency = 100000000; uint32_t samp_rate = DEFAULT_SAMPLE_RATE; uint32_t out_block_size = DEFAULT_BUF_LENGTH; int device_count; char vendor[256], product[256], serial[256]; while ((opt = getopt(argc, argv, "d:p:f:g:s:b:n:S::")) != -1) { switch (opt) { case 'd': dev_index = atoi(optarg); break; case 'p': udp_port = atoi(optarg); break; case 'f': frequency = (uint32_t)atof(optarg); break; case 'g': gain = (int)(atof(optarg) * 10); /* tenths of a dB */ break; case 's': samp_rate = (uint32_t)atof(optarg); break; case 'b': out_block_size = (uint32_t)atof(optarg); break; case 'n': bytes_to_read = (uint32_t)atof(optarg) * 2; break; case 'S': sync_mode = 1; break; default: usage(); break; } } if (argc <= optind) { usage(); } else { filename = argv[optind]; } 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++) { 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)); //-------------------------------------------------- fd = socket(AF_INET,SOCK_DGRAM,0); if(fd==-1) { perror("socket"); exit(-1); } fprintf(stderr, "create socket OK!\n"); //create an send address addr.sin_family = AF_INET; addr.sin_port = htons(udp_port); addr.sin_addr.s_addr=inet_addr("127.0.0.1"); fprintf(stderr, "127.0.0.1:%u\n", udp_port); //-------------------------------------------------- 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 /* 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, frequency); if (r < 0) fprintf(stderr, "WARNING: Failed to set center freq.\n"); else fprintf(stderr, "Tuned to %u Hz.\n", frequency); if (0 == gain) { /* Enable automatic gain */ r = rtlsdr_set_tuner_gain_mode(dev, 0); if (r < 0) fprintf(stderr, "WARNING: Failed to enable automatic gain.\n"); } else { /* Enable manual gain */ r = rtlsdr_set_tuner_gain_mode(dev, 1); if (r < 0) fprintf(stderr, "WARNING: Failed to enable manual gain.\n"); /* Set the tuner gain */ r = rtlsdr_set_tuner_gain(dev, gain); if (r < 0) fprintf(stderr, "WARNING: Failed to set tuner gain.\n"); else fprintf(stderr, "Tuner gain set to %f dB.\n", gain/10.0); } if(strcmp(filename, "-") == 0) { /* Write samples to stdout */ file = stdout; #ifdef _WIN32 _setmode(_fileno(stdin), _O_BINARY); #endif } else { file = fopen(filename, "wb"); if (!file) { fprintf(stderr, "Failed to open %s\n", filename); goto out; } } /* 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 (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 ((bytes_to_read > 0) && (bytes_to_read < (uint32_t)n_read)) { n_read = bytes_to_read; do_exit = 1; } if (fwrite(buffer, 1, n_read, file) != (size_t)n_read) { fprintf(stderr, "Short write, samples lost, exiting!\n"); break; } if ((uint32_t)n_read < out_block_size) { fprintf(stderr, "Short read, samples lost, exiting!\n"); break; } if (bytes_to_read > 0) bytes_to_read -= n_read; } } else { fprintf(stderr, "Reading samples in async mode...\n"); r = rtlsdr_read_async(dev, rtlsdr_callback, (void *)file, DEFAULT_ASYNC_BUF_NUMBER, out_block_size); } if (do_exit) fprintf(stderr, "\nUser cancel, exiting...\n"); else fprintf(stderr, "\nLibrary error %d, exiting...\n", r); if (file != stdout) fclose(file); rtlsdr_close(dev); free (buffer); close(fd); out: return r >= 0 ? r : -r; }
int main(int argc, char** argv) { uint32_t opt; int32_t rtl_result; int32_t rtl_count; char rtl_vendor[256], rtl_product[256], rtl_serial[256]; initrx_options(); initDecoder_options(); /* RX buffer allocation */ rx_state.iSamples=malloc(sizeof(float)*SIGNAL_LENGHT*SIGNAL_SAMPLE_RATE); rx_state.qSamples=malloc(sizeof(float)*SIGNAL_LENGHT*SIGNAL_SAMPLE_RATE); /* Stop condition setup */ rx_state.exit_flag = false; rx_state.decode_flag = false; uint32_t nLoop = 0; if (argc <= 1) usage(); while ((opt = getopt(argc, argv, "f:c:l:g:a:o:p:u:d:n:i:H:Q:S")) != -1) { switch (opt) { case 'f': // Frequency rx_options.dialfreq = (uint32_t)atofs(optarg); break; case 'c': // Callsign sprintf(dec_options.rcall, "%.12s", optarg); break; case 'l': // Locator / Grid sprintf(dec_options.rloc, "%.6s", optarg); break; case 'g': // Small signal amplifier gain rx_options.gain = atoi(optarg); if (rx_options.gain < 0) rx_options.gain = 0; if (rx_options.gain > 49) rx_options.gain = 49; rx_options.gain *= 10; break; case 'a': // Auto gain rx_options.autogain = atoi(optarg); if (rx_options.autogain < 0) rx_options.autogain = 0; if (rx_options.autogain > 1) rx_options.autogain = 1; break; case 'o': // Fine frequency correction rx_options.shift = atoi(optarg); break; case 'p': rx_options.ppm = atoi(optarg); break; case 'u': // Upconverter frequency rx_options.upconverter = (uint32_t)atofs(optarg); break; case 'd': // Direct Sampling rx_options.directsampling = (uint32_t)atofs(optarg); break; case 'n': // Stop after n iterations rx_options.maxloop = (uint32_t)atofs(optarg); break; case 'i': // Select the device to use rx_options.device = (uint32_t)atofs(optarg); break; case 'H': // Decoder option, use a hastable dec_options.usehashtable = 1; break; case 'Q': // Decoder option, faster dec_options.quickmode = 1; break; case 'S': // Decoder option, single pass mode (same as original wsprd) dec_options.subtraction = 0; dec_options.npasses = 1; break; default: usage(); break; } } if (rx_options.dialfreq == 0) { fprintf(stderr, "Please specify a dial frequency.\n"); fprintf(stderr, " --help for usage...\n"); exit(1); } if (dec_options.rcall[0] == 0) { fprintf(stderr, "Please specify your callsign.\n"); fprintf(stderr, " --help for usage...\n"); exit(1); } if (dec_options.rloc[0] == 0) { fprintf(stderr, "Please specify your locator.\n"); fprintf(stderr, " --help for usage...\n"); exit(1); } /* Calcule shift offset */ rx_options.realfreq = rx_options.dialfreq + rx_options.shift + rx_options.upconverter; /* Store the frequency used for the decoder */ dec_options.freq = rx_options.dialfreq; /* If something goes wrong... */ signal(SIGINT, &sigint_callback_handler); signal(SIGTERM, &sigint_callback_handler); signal(SIGILL, &sigint_callback_handler); signal(SIGFPE, &sigint_callback_handler); signal(SIGSEGV, &sigint_callback_handler); signal(SIGABRT, &sigint_callback_handler); /* Init & parameter the device */ rtl_count = rtlsdr_get_device_count(); if (!rtl_count) { fprintf(stderr, "No supported devices found\n"); return EXIT_FAILURE; } fprintf(stderr, "Found %d device(s):\n", rtl_count); for (uint32_t i=0; i<rtl_count; i++) { rtlsdr_get_device_usb_strings(i, rtl_vendor, rtl_product, rtl_serial); fprintf(stderr, " %d: %s, %s, SN: %s\n", i, rtl_vendor, rtl_product, rtl_serial); } fprintf(stderr, "\nUsing device %d: %s\n", rx_options.device, rtlsdr_get_device_name(rx_options.device)); rtl_result = rtlsdr_open(&rtl_device, rx_options.device); if (rtl_result < 0) { fprintf(stderr, "ERROR: Failed to open rtlsdr device #%d.\n", rx_options.device); return EXIT_FAILURE; } if (rx_options.directsampling) { rtl_result = rtlsdr_set_direct_sampling(rtl_device, rx_options.directsampling); if (rtl_result < 0) { fprintf(stderr, "ERROR: Failed to set direct sampling\n"); rtlsdr_close(rtl_device); return EXIT_FAILURE; } } rtl_result = rtlsdr_set_sample_rate(rtl_device, SAMPLING_RATE); if (rtl_result < 0) { fprintf(stderr, "ERROR: Failed to set sample rate\n"); rtlsdr_close(rtl_device); return EXIT_FAILURE; } rtl_result = rtlsdr_set_tuner_gain_mode(rtl_device, 1); if (rtl_result < 0) { fprintf(stderr, "ERROR: Failed to enable manual gain\n"); rtlsdr_close(rtl_device); return EXIT_FAILURE; } if (rx_options.autogain) { rtl_result = rtlsdr_set_tuner_gain_mode(rtl_device, 0); if (rtl_result != 0) { fprintf(stderr, "ERROR: Failed to set tuner gain\n"); rtlsdr_close(rtl_device); return EXIT_FAILURE; } } else { rtl_result = rtlsdr_set_tuner_gain(rtl_device, rx_options.gain); if (rtl_result != 0) { fprintf(stderr, "ERROR: Failed to set tuner gain\n"); rtlsdr_close(rtl_device); return EXIT_FAILURE; } } if (rx_options.ppm != 0) { rtl_result = rtlsdr_set_freq_correction(rtl_device, rx_options.ppm); if (rtl_result < 0) { fprintf(stderr, "ERROR: Failed to set ppm error\n"); rtlsdr_close(rtl_device); return EXIT_FAILURE; } } rtl_result = rtlsdr_set_center_freq(rtl_device, rx_options.realfreq + FS4_RATE + 1500); if (rtl_result < 0) { fprintf(stderr, "ERROR: Failed to set frequency\n"); rtlsdr_close(rtl_device); return EXIT_FAILURE; } rtl_result = rtlsdr_reset_buffer(rtl_device); if (rtl_result < 0) { fprintf(stderr, "ERROR: Failed to reset buffers.\n"); rtlsdr_close(rtl_device); return EXIT_FAILURE; } /* Print used parameter */ time_t rawtime; time ( &rawtime ); struct tm *gtm = gmtime(&rawtime); printf("\nStarting rtlsdr-wsprd (%04d-%02d-%02d, %02d:%02dz) -- Version 0.2\n", gtm->tm_year + 1900, gtm->tm_mon + 1, gtm->tm_mday, gtm->tm_hour, gtm->tm_min); printf(" Callsign : %s\n", dec_options.rcall); printf(" Locator : %s\n", dec_options.rloc); printf(" Dial freq. : %d Hz\n", rx_options.dialfreq); printf(" Real freq. : %d Hz\n", rx_options.realfreq); printf(" PPM factor : %d\n", rx_options.ppm); if(rx_options.autogain) printf(" Auto gain : enable\n"); else printf(" Gain : %d dB\n", rx_options.gain/10); /* Time alignment stuff */ struct timeval lTime; gettimeofday(&lTime, NULL); uint32_t sec = lTime.tv_sec % 120; uint32_t usec = sec * 1000000 + lTime.tv_usec; uint32_t uwait = 120000000 - usec; printf("Wait for time sync (start in %d sec)\n\n", uwait/1000000); /* Prepare a low priority param for the decoder thread */ struct sched_param param; pthread_attr_init(&dec.tattr); pthread_attr_setschedpolicy(&dec.tattr, SCHED_RR); pthread_attr_getschedparam(&dec.tattr, ¶m); param.sched_priority = 90; // = sched_get_priority_min(); pthread_attr_setschedparam(&dec.tattr, ¶m); /* Create a thread and stuff for separate decoding Info : https://computing.llnl.gov/tutorials/pthreads/ */ pthread_rwlock_init(&dec.rw, NULL); pthread_cond_init(&dec.ready_cond, NULL); pthread_mutex_init(&dec.ready_mutex, NULL); pthread_create(&dongle.thread, NULL, rtlsdr_rx, NULL); pthread_create(&dec.thread, &dec.tattr, wsprDecoder, NULL); /* Main loop : Wait, read, decode */ while (!rx_state.exit_flag && !(rx_options.maxloop && (nLoop >= rx_options.maxloop))) { /* Wait for time Sync on 2 mins */ gettimeofday(&lTime, NULL); sec = lTime.tv_sec % 120; usec = sec * 1000000 + lTime.tv_usec; uwait = 120000000 - usec + 10000; // Adding 10ms, to be sure to reach this next minute usleep(uwait); //printf("SYNC! RX started\n"); /* Use the Store the date at the begin of the frame */ time ( &rawtime ); gtm = gmtime(&rawtime); sprintf(rx_options.date,"%02d%02d%02d", gtm->tm_year - 100, gtm->tm_mon + 1, gtm->tm_mday); sprintf(rx_options.uttime,"%02d%02d", gtm->tm_hour, gtm->tm_min); /* Start to store the samples */ initSampleStorage(); while( (rx_state.exit_flag == false) && (rx_state.iqIndex < (SIGNAL_LENGHT * SIGNAL_SAMPLE_RATE) ) ) { usleep(250000); } nLoop++; } /* Stop the RX and free the blocking function */ rtlsdr_cancel_async(rtl_device); /* Close the RTL device */ rtlsdr_close(rtl_device); printf("Bye!\n"); /* Wait the thread join (send a signal before to terminate the job) */ pthread_mutex_lock(&dec.ready_mutex); pthread_cond_signal(&dec.ready_cond); pthread_mutex_unlock(&dec.ready_mutex); pthread_join(dec.thread, NULL); pthread_join(dongle.thread, NULL); /* Destroy the lock/cond/thread */ pthread_rwlock_destroy(&dec.rw); pthread_cond_destroy(&dec.ready_cond); pthread_mutex_destroy(&dec.ready_mutex); pthread_exit(NULL); return EXIT_SUCCESS; }
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[]) { int rv; async_started = 0; quit_please = 0; buffers_received = 0; signal(SIGINT, sighandler); printf("Opening output file...\n"); outf = fopen("rtlsdr_out.bin", "w"); if(outf == NULL) { printf("Error opening output file: %d.\nExiting.\n", errno); return 1; } rv = rtlsdr_get_device_count(); if(rv == 0) { printf("No RTL-SDR devices found, exiting.\n"); return 2; } printf("Found %d device(s).\n", rv); printf("Opening the first, '%s'...\n", rtlsdr_get_device_name(0)); rv = rtlsdr_open(&rtlsdr, 0); if(rv != 0) { printf("Error opening device: %d\nExiting.\n", rv); return 3; } printf("Setting frequency to 315MHz...\n"); rv = rtlsdr_set_center_freq(rtlsdr, 315000000); if(rv != 0) { printf("Error setting frequency: %d\nExiting.\n", rv); return 4; } printf("Frequency set to %uHz.\n", rtlsdr_get_center_freq(rtlsdr)); printf("Setting gain mode to automatic.\n"); rv = rtlsdr_set_tuner_gain_mode(rtlsdr, 0); if(rv != 0) { printf("Error setting gain mode: %d\nExiting.\n", rv); return 5; } printf("Gain currently set to %d.\n", rtlsdr_get_tuner_gain(rtlsdr)); printf("Setting sample rate to 240kHz...\n"); rv = rtlsdr_set_sample_rate(rtlsdr, 240000); if(rv != 0) { printf("Error setting sample rate: %d\nExiting.\n", rv); return 6; } printf("Sample rate set to %u.\n", rtlsdr_get_sample_rate(rtlsdr)); printf("Setting AGC on...\n"); rv = rtlsdr_set_agc_mode(rtlsdr, 1); if(rv != 0) { printf("Error setting AGC: %d\nExiting.\n", rv); return 7; } printf("Clearing buffer and streaming data...\n"); rv = rtlsdr_reset_buffer(rtlsdr); if(rv != 0) { printf("Error clearing buffer: %d\nExiting.\n", rv); return 8; } async_started = 1; rv = rtlsdr_read_async(rtlsdr, read_callback, NULL, 0, 0); if(rv != 0) { printf("Error setting up async streaming: %d\nExiting.\n", rv); return 9; } rtlsdr_cancel_async(rtlsdr); rtlsdr_close(rtlsdr); return 0; }
int main(int argc, char **argv) { #ifndef _WIN32 struct sigaction sigact; #endif char *out_filename = NULL; char *in_filename = NULL; FILE *in_file; int n_read; int r = 0, opt; int i, gain = 0; int sync_mode = 0; int ppm_error = 0; struct dm_state* demod; uint32_t dev_index = 0; int frequency_current = 0; uint32_t out_block_size = DEFAULT_BUF_LENGTH; int device_count; char vendor[256], product[256], serial[256]; int have_opt_R = 0; setbuf(stdout, NULL); setbuf(stderr, NULL); demod = malloc(sizeof (struct dm_state)); memset(demod, 0, sizeof (struct dm_state)); /* initialize tables */ baseband_init(); r_device devices[] = { #define DECL(name) name, DEVICES #undef DECL }; num_r_devices = sizeof(devices)/sizeof(*devices); demod->level_limit = DEFAULT_LEVEL_LIMIT; while ((opt = getopt(argc, argv, "x:z:p:DtaAqm:r:l:d:f:g:s:b:n:SR:F:C:T:UW")) != -1) { switch (opt) { case 'd': dev_index = atoi(optarg); break; case 'f': if (frequencies < MAX_PROTOCOLS) frequency[frequencies++] = (uint32_t) atof(optarg); else fprintf(stderr, "Max number of frequencies reached %d\n", MAX_PROTOCOLS); break; case 'g': gain = (int) (atof(optarg) * 10); /* tenths of a dB */ break; case 'p': ppm_error = atoi(optarg); break; case 's': samp_rate = (uint32_t) atof(optarg); break; case 'b': out_block_size = (uint32_t) atof(optarg); break; case 'l': demod->level_limit = (uint32_t) atof(optarg); break; case 'n': bytes_to_read = (uint32_t) atof(optarg) * 2; break; case 'a': demod->analyze = 1; break; case 'A': demod->analyze_pulses = 1; break; case 'r': in_filename = optarg; break; case 't': demod->signal_grabber = 1; break; case 'm': demod->debug_mode = atoi(optarg); break; case 'S': sync_mode = 1; break; case 'D': debug_output++; break; case 'z': override_short = atoi(optarg); break; case 'x': override_long = atoi(optarg); break; case 'R': if (!have_opt_R) { for (i = 0; i < num_r_devices; i++) { devices[i].disabled = 1; } have_opt_R = 1; } i = atoi(optarg); if (i > num_r_devices) { fprintf(stderr, "Remote device number specified larger than number of devices\n\n"); usage(devices); } devices[i - 1].disabled = 0; break; case 'q': quiet_mode = 1; break; case 'F': if (strcmp(optarg, "json") == 0) { add_json_output(); } else if (strcmp(optarg, "csv") == 0) { add_csv_output(determine_csv_fields(devices, num_r_devices)); } else if (strcmp(optarg, "kv") == 0) { add_kv_output(); } else { fprintf(stderr, "Invalid output format %s\n", optarg); usage(devices); } break; case 'C': if (strcmp(optarg, "native") == 0) { conversion_mode = CONVERT_NATIVE; } else if (strcmp(optarg, "si") == 0) { conversion_mode = CONVERT_SI; } else if (strcmp(optarg, "customary") == 0) { conversion_mode = CONVERT_CUSTOMARY; } else { fprintf(stderr, "Invalid conversion mode %s\n", optarg); usage(devices); } break; case 'U': #if !defined(__MINGW32__) utc_mode = setenv("TZ", "UTC", 1); if(utc_mode != 0) fprintf(stderr, "Unable to set TZ to UTC; error code: %d\n", utc_mode); #endif break; case 'W': overwrite_mode = 1; break; case 'T': time(&stop_time); duration = atoi(optarg); if (duration < 1) { fprintf(stderr, "Duration '%s' was not positive integer; will continue indefinitely\n", optarg); } else { stop_time += duration; } break; default: usage(devices); break; } } if (argc <= optind - 1) { usage(devices); } else { out_filename = argv[optind]; } if (!output_handler) { add_kv_output(); } for (i = 0; i < num_r_devices; i++) { if (!devices[i].disabled) { register_protocol(demod, &devices[i]); if(devices[i].modulation >= FSK_DEMOD_MIN_VAL) { demod->enable_FM_demod = 1; } } } 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; } if (!in_filename) { device_count = rtlsdr_get_device_count(); if (!device_count) { fprintf(stderr, "No supported devices found.\n"); if (!in_filename) exit(1); } if (!quiet_mode) { 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); } #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 /* Set the sample rate */ r = rtlsdr_set_sample_rate(dev, samp_rate); if (r < 0) fprintf(stderr, "WARNING: Failed to set sample rate.\n"); else fprintf(stderr, "Sample rate set to %d.\n", rtlsdr_get_sample_rate(dev)); // Unfortunately, doesn't return real rate fprintf(stderr, "Bit detection level set to %d.\n", demod->level_limit); if (0 == gain) { /* Enable automatic gain */ r = rtlsdr_set_tuner_gain_mode(dev, 0); if (r < 0) fprintf(stderr, "WARNING: Failed to enable automatic gain.\n"); else fprintf(stderr, "Tuner gain set to Auto.\n"); } else { /* Enable manual gain */ r = rtlsdr_set_tuner_gain_mode(dev, 1); if (r < 0) fprintf(stderr, "WARNING: Failed to enable manual gain.\n"); /* Set the tuner gain */ r = rtlsdr_set_tuner_gain(dev, gain); if (r < 0) fprintf(stderr, "WARNING: Failed to set tuner gain.\n"); else fprintf(stderr, "Tuner gain set to %f dB.\n", gain / 10.0); } r = rtlsdr_set_freq_correction(dev, ppm_error); } if (out_filename) { if (strcmp(out_filename, "-") == 0) { /* Write samples to stdout */ demod->out_file = stdout; #ifdef _WIN32 _setmode(_fileno(stdin), _O_BINARY); #endif } else { if (access(out_filename, F_OK) == 0 && !overwrite_mode) { fprintf(stderr, "Output file %s already exists, exiting\n", out_filename); goto out; } demod->out_file = fopen(out_filename, "wb"); if (!demod->out_file) { fprintf(stderr, "Failed to open %s\n", out_filename); goto out; } } } if (demod->signal_grabber) demod->sg_buf = malloc(SIGNAL_GRABBER_BUFFER); if (in_filename) { int i = 0; unsigned char test_mode_buf[DEFAULT_BUF_LENGTH]; float test_mode_float_buf[DEFAULT_BUF_LENGTH]; if (strcmp(in_filename, "-") == 0) { /* read samples from stdin */ in_file = stdin; in_filename = "<stdin>"; } else { in_file = fopen(in_filename, "rb"); if (!in_file) { fprintf(stderr, "Opening file: %s failed!\n", in_filename); goto out; } } fprintf(stderr, "Test mode active. Reading samples from file: %s\n", in_filename); // Essential information (not quiet) if (!quiet_mode) { fprintf(stderr, "Input format: %s\n", (demod->debug_mode == 3) ? "cf32" : "uint8"); } sample_file_pos = 0.0; int n_read, cf32_tmp; do { if (demod->debug_mode == 3) { n_read = fread(test_mode_float_buf, sizeof(float), 131072, in_file); for(int n = 0; n < n_read; n++) { cf32_tmp = test_mode_float_buf[n]*127 + 127; if (cf32_tmp < 0) cf32_tmp = 0; else if (cf32_tmp > 255) cf32_tmp = 255; test_mode_buf[n] = (uint8_t)cf32_tmp; } } else { n_read = fread(test_mode_buf, 1, 131072, in_file); } if (n_read == 0) break; // rtlsdr_callback() will Segmentation Fault with len=0 rtlsdr_callback(test_mode_buf, n_read, demod); i++; sample_file_pos = (float)i * n_read / samp_rate; } while (n_read != 0); // Call a last time with cleared samples to ensure EOP detection memset(test_mode_buf, 128, DEFAULT_BUF_LENGTH); // 128 is 0 in unsigned data rtlsdr_callback(test_mode_buf, 131072, demod); // Why the magic value 131072? //Always classify a signal at the end of the file classify_signal(); if (!quiet_mode) { fprintf(stderr, "Test mode file issued %d packets\n", i); } exit(0); } /* 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 (sync_mode) { if (!demod->out_file) { fprintf(stderr, "Specify an output file for sync mode.\n"); exit(0); } fprintf(stderr, "Reading samples in sync mode...\n"); uint8_t *buffer = malloc(out_block_size * sizeof (uint8_t)); time_t timestamp; 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 ((bytes_to_read > 0) && (bytes_to_read < (uint32_t) n_read)) { n_read = bytes_to_read; do_exit = 1; } if (fwrite(buffer, 1, n_read, demod->out_file) != (size_t) n_read) { fprintf(stderr, "Short write, samples lost, exiting!\n"); break; } if ((uint32_t) n_read < out_block_size) { fprintf(stderr, "Short read, samples lost, exiting!\n"); break; } if (duration > 0) { time(×tamp); if (timestamp >= stop_time) { do_exit = 1; fprintf(stderr, "Time expired, exiting!\n"); } } if (bytes_to_read > 0) bytes_to_read -= n_read; } free(buffer); } else { if (frequencies == 0) { frequency[0] = DEFAULT_FREQUENCY; frequencies = 1; } else { time(&rawtime_old); } if (!quiet_mode) { fprintf(stderr, "Reading samples in async mode...\n"); } while (!do_exit) { /* Set the frequency */ r = rtlsdr_set_center_freq(dev, frequency[frequency_current]); if (r < 0) fprintf(stderr, "WARNING: Failed to set center freq.\n"); else fprintf(stderr, "Tuned to %u Hz.\n", rtlsdr_get_center_freq(dev)); r = rtlsdr_read_async(dev, rtlsdr_callback, (void *) demod, DEFAULT_ASYNC_BUF_NUMBER, out_block_size); do_exit_async = 0; frequency_current++; if (frequency_current > frequencies - 1) frequency_current = 0; } } if (do_exit) fprintf(stderr, "\nUser cancel, exiting...\n"); else fprintf(stderr, "\nLibrary error %d, exiting...\n", r); if (demod->out_file && (demod->out_file != stdout)) fclose(demod->out_file); for (i = 0; i < demod->r_dev_num; i++) free(demod->r_devs[i]); if (demod->signal_grabber) free(demod->sg_buf); free(demod); rtlsdr_close(dev); out: for (output_handler_t *output = output_handler; output; output = output->next) { if (output->aux_free) { output->aux_free(output->aux); } } 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; }
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; }
// tz this is where gain and frequency are set // // static void *controller_thread_fn(void *arg) { // from original comments: // thoughts for multiple dongles // might be no good using a controller thread if retune/rate blocks // int i; struct controller_state *s = arg; static int latency_timer = 0; // tz - note that in optimal_settings the actual frequency in s-> is used to set the dongle.freq // then the dongle.freq what gets sent to the device. // // optimal_settings_new(s->freqs[0], demod.rate_in); // tz - we have temporarily abandoned these options but here is where you would set them // // if (dongle.direct_sampling) { // verbose_direct_sampling(dongle.dev, 1);} // if (dongle.offset_tuning) { // verbose_offset_tuning(dongle.dev);} /* Set the frequency */ verbose_set_frequency(dongle.dev, dongle.freq); sprintf(errmesg, "Oversampling input by: %ix.\n", demod.downsample); post(errmesg,0); sprintf(errmesg, "Oversampling output by: %ix.\n", demod.post_downsample); post(errmesg,0); sprintf(errmesg, "Buffer size: %0.2fms\n", 1000 * 0.5 * (float)ACTUAL_BUF_LENGTH / (float)dongle.rate); post(errmesg,0); /* Set the sample rate */ verbose_set_sample_rate(dongle.dev, dongle.rate); sprintf(errmesg, "Output at %u Hz.\n", demod.rate_in/demod.post_downsample); post(errmesg,0); need_to_reset_circ_buffer = 1; // tz - this will cause read buffer to reset while (!do_exit) { //usleep(100000); //post("in controller thread", 0); safe_cond_wait(&s->hop, &s->hop_m); // tz it might be possible to set 'mode' here - using the same init // sequence as with restarting the radio if(need_to_set_freq) { need_to_set_freq = 0; optimal_settings_new(new_freq, demod.rate_in); rtlsdr_set_center_freq(dongle.dev, dongle.freq); //sprintf(errmesg, "setting frequency to %d", new_freq); //post(errmesg, 0); // need_to_reset_circ_buffer = 1; // not sure if we need to do this here too... // post("hello..."); } if(need_to_set_gain) { need_to_set_gain = 0; dongle.gain = new_gain; sprintf(errmesg, "setting gain to %d", new_gain); post(errmesg, 0); set_tuner_gain(&dongle); } if(need_to_reset_circ_buffer) { need_to_reset_circ_buffer = 0; latency_timer = circ_buf_latency_factor + 1; circ_index_write = 0; post("reseting circular buffer write index", 0); } // After latency timer counts down to 1, reset the read index too // timer cound represents number of vectors (determined by latency factor) if(latency_timer > 0) { if(latency_timer == 1) { post("reseting circular buffer read index", 0); circ_index_read = 0; } latency_timer--; } } return 0; }
int main (int argc, char **argv) { 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; int gain = AUTO_GAIN; dab_state dab; if (argc > 1) { dab.frequency = atoi(argv[1]); } else { //dab.frequency = 220352000; dab.frequency = 222064000; } //fprintf(stderr,"%i\n",dab.frequency); fprintf(stderr,"\n"); fprintf(stderr,"rtldab %s \n",VERSION); fprintf(stderr,"build: %s %s\n", __DATE__,__TIME__); fprintf(stderr,"\n"); fprintf(stderr," _____ _______ _ _____ ____ \n"); fprintf(stderr," | __ \\__ __| | | __ \\ /\\ | _ \\ \n"); fprintf(stderr," | |__) | | | | | | | | | / \\ | |_) |\n"); fprintf(stderr," | _ / | | | | | | | |/ /\\ \\ | _ < \n"); fprintf(stderr," | | \\ \\ | | | |____| |__| / ____ \\| |_) |\n"); fprintf(stderr," |_| \\_\\ |_| |______|_____/_/ \\_\\____/ \n"); fprintf(stderr,"\n"); fprintf(stderr,"\n\nrtl-dab Copyright (C) 2012 David May \n"); fprintf(stderr,"This program comes with ABSOLUTELY NO WARRANTY\n"); fprintf(stderr,"This is free software, and you are welcome to\n"); fprintf(stderr,"redistribute it under certain conditions\n\n\n"); fprintf(stderr,"--------------------------------\n"); fprintf(stderr,"Many thanks to the osmocom team!\n"); fprintf(stderr,"--------------------------------\n\n"); /*--------------------------------------------------- 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); } /*------------------------------------------------- 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, dab.frequency); if (r < 0) fprintf(stderr, "WARNING: Failed to set center freq.\n"); else fprintf(stderr, "Tuned to %u Hz.\n", dab.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 -----------------------------------------------*/ dab_demod_init(&dab); 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 *)(&dab), 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; }