// tz gain function
//
// should probably have option for verbose mode and possibly return actual gain
//
void set_tuner_gain(struct dongle_state *d )
{
/* Set the tuner gain */
if (d->gain == AUTO_GAIN) {
verbose_auto_gain(d->dev);
} else {
d->gain = nearest_gain(d->dev, d->gain);
verbose_gain_set(d->dev, d->gain);
}
}
int main(int argc, char **argv)
{
#ifndef _WIN32
struct sigaction sigact;
#endif
struct fm_state fm;
char *filename = NULL;
int n_read, r, opt, wb_mode = 0;
int i, gain = AUTO_GAIN; // tenths of a dB
uint8_t *buffer;
uint32_t dev_index = 0;
int device_count;
int ppm_error = 0;
char vendor[256], product[256], serial[256];
fm_init(&fm);
pthread_cond_init(&data_ready, NULL);
pthread_rwlock_init(&data_rw, NULL);
pthread_mutex_init(&data_mutex, NULL);
while ((opt = getopt(argc, argv, "d:f:g:s:b:l:o:t:r:p:EFA:NWMULRDCh")) != -1) {
switch (opt) {
case 'd':
dev_index = atoi(optarg);
break;
case 'f':
if (fm.freq_len >= FREQUENCIES_LIMIT) {
break;}
if (strchr(optarg, ':'))
{frequency_range(&fm, optarg);}
else
{
fm.freqs[fm.freq_len] = (uint32_t)atofs(optarg);
fm.freq_len++;
}
break;
case 'g':
gain = (int)(atof(optarg) * 10);
break;
case 'l':
fm.squelch_level = (int)atof(optarg);
break;
case 's':
fm.sample_rate = (uint32_t)atofs(optarg);
break;
case 'r':
fm.output_rate = (int)atofs(optarg);
break;
case 'o':
fm.post_downsample = (int)atof(optarg);
if (fm.post_downsample < 1 || fm.post_downsample > MAXIMUM_OVERSAMPLE) {
fprintf(stderr, "Oversample must be between 1 and %i\n", MAXIMUM_OVERSAMPLE);}
break;
case 't':
fm.conseq_squelch = (int)atof(optarg);
if (fm.conseq_squelch < 0) {
fm.conseq_squelch = -fm.conseq_squelch;
fm.terminate_on_squelch = 1;
}
break;
case 'p':
ppm_error = atoi(optarg);
break;
case 'E':
fm.edge = 1;
break;
case 'F':
fm.fir_enable = 1;
break;
case 'A':
if (strcmp("std", optarg) == 0) {
fm.custom_atan = 0;}
if (strcmp("fast", optarg) == 0) {
fm.custom_atan = 1;}
if (strcmp("lut", optarg) == 0) {
atan_lut_init();
fm.custom_atan = 2;}
break;
case 'D':
fm.deemph = 1;
break;
case 'C':
fm.dc_block = 1;
break;
case 'N':
fm.mode_demod = &fm_demod;
break;
case 'W':
wb_mode = 1;
fm.mode_demod = &fm_demod;
fm.sample_rate = 170000;
fm.output_rate = 32000;
fm.custom_atan = 1;
fm.post_downsample = 4;
fm.deemph = 1;
fm.squelch_level = 0;
break;
case 'M':
fm.mode_demod = &am_demod;
break;
case 'U':
fm.mode_demod = &usb_demod;
break;
case 'L':
fm.mode_demod = &lsb_demod;
break;
case 'R':
fm.mode_demod = &raw_demod;
break;
case 'h':
default:
usage();
break;
}
}
/* quadruple sample_rate to limit to Δθ to ±π/2 */
fm.sample_rate *= fm.post_downsample;
if (fm.freq_len == 0) {
fprintf(stderr, "Please specify a frequency.\n");
exit(1);
}
if (fm.freq_len >= FREQUENCIES_LIMIT) {
fprintf(stderr, "Too many channels, maximum %i.\n", FREQUENCIES_LIMIT);
exit(1);
}
if (fm.freq_len > 1 && fm.squelch_level == 0) {
fprintf(stderr, "Please specify a squelch level. Required for scanning multiple frequencies.\n");
exit(1);
}
if (fm.freq_len > 1) {
fm.terminate_on_squelch = 0;
}
if (argc <= optind) {
filename = "-";
} else {
filename = argv[optind];
}
ACTUAL_BUF_LENGTH = lcm_post[fm.post_downsample] * DEFAULT_BUF_LENGTH;
buffer = malloc(ACTUAL_BUF_LENGTH * 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));
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
/* WBFM is special */
// I really should loop over everything
// but you are more wrong for scanning broadcast FM
if (wb_mode) {
fm.freqs[0] += 16000;
}
if (fm.deemph) {
fm.deemph_a = (int)round(1.0/((1.0-exp(-1.0/(fm.output_rate * 75e-6)))));
}
optimal_settings(&fm, 0, 0);
build_fir(&fm);
/* Set the tuner gain */
if (gain == AUTO_GAIN) {
r = rtlsdr_set_tuner_gain_mode(dev, 0);
} else {
r = rtlsdr_set_tuner_gain_mode(dev, 1);
gain = nearest_gain(gain);
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);
}
r = rtlsdr_set_freq_correction(dev, ppm_error);
if (strcmp(filename, "-") == 0) { /* Write samples to stdout */
fm.file = stdout;
#ifdef _WIN32
_setmode(_fileno(fm.file), _O_BINARY);
#endif
} else {
fm.file = fopen(filename, "wb");
if (!fm.file) {
fprintf(stderr, "Failed to open %s\n", filename);
exit(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");}
pthread_create(&demod_thread, NULL, demod_thread_fn, (void *)(&fm));
/*rtlsdr_read_async(dev, rtlsdr_callback, (void *)(&fm),
DEFAULT_ASYNC_BUF_NUMBER,
ACTUAL_BUF_LENGTH);*/
while (!do_exit) {
sync_read(buffer, ACTUAL_BUF_LENGTH, &fm);
}
while (!do_exit) {
sync_read(buffer, ACTUAL_BUF_LENGTH, &fm);
}
if (do_exit) {
fprintf(stderr, "\nUser cancel, exiting...\n");}
else {
fprintf(stderr, "\nLibrary error %d, exiting...\n", r);}
//rtlsdr_cancel_async(dev);
safe_cond_signal(&data_ready, &data_mutex);
pthread_join(demod_thread, NULL);
pthread_cond_destroy(&data_ready);
pthread_rwlock_destroy(&data_rw);
pthread_mutex_destroy(&data_mutex);
if (fm.file != stdout) {
fclose(fm.file);}
rtlsdr_close(dev);
free (buffer);
return r >= 0 ? r : -r;
}
int main(int argc, char **argv)
{
#ifndef _WIN32
struct sigaction sigact;
#endif
char *filename = NULL;
int n_read;
int r, opt;
int gain = 0;
int ppm_error = 0;
int sync_mode = 0;
FILE *file;
uint8_t *buffer;
int dev_index = 0;
int dev_given = 0;
uint32_t frequency = 100000000;
uint32_t bandwidth = DEFAULT_BANDWIDTH;
uint32_t samp_rate = DEFAULT_SAMPLE_RATE;
uint32_t out_block_size = DEFAULT_BUF_LENGTH;
while ((opt = getopt(argc, argv, "d:f:g:s:w:b:n:p:S")) != -1) {
switch (opt) {
case 'd':
dev_index = verbose_device_search(optarg);
dev_given = 1;
break;
case 'f':
frequency = (uint32_t)atofs(optarg);
break;
case 'g':
gain = (int)(atof(optarg) * 10); /* tenths of a dB */
break;
case 's':
samp_rate = (uint32_t)atofs(optarg);
break;
case 'w':
bandwidth = (uint32_t)atofs(optarg);
break;
case 'p':
ppm_error = atoi(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));
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
/* Set the sample rate */
verbose_set_sample_rate(dev, samp_rate);
/* Set the tuner bandwidth */
verbose_set_bandwidth(dev, bandwidth);
/* Set the frequency */
verbose_set_frequency(dev, frequency);
if (0 == gain) {
/* Enable automatic gain */
verbose_auto_gain(dev);
} else {
/* Enable manual gain */
gain = nearest_gain(dev, gain);
verbose_gain_set(dev, gain);
}
verbose_ppm_set(dev, ppm_error);
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) */
verbose_reset_buffer(dev);
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,
0, 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);
out:
return r >= 0 ? r : -r;
}
int main(int argc, char **argv)
{
struct sigaction sigact;
char *filename = NULL;
int r, opt;
int i, gain = AUTO_GAIN; /* tenths of a dB */
int dev_index = 0;
int dev_given = 0;
int ppm_error = 0;
int custom_ppm = 0;
int left_freq = 161975000;
int right_freq = 162025000;
int sample_rate = 12000;
int output_rate = 48000;
int dongle_freq, dongle_rate, delta;
int edge = 0;
pthread_cond_init(&ready, NULL);
pthread_mutex_init(&ready_m, NULL);
while ((opt = getopt(argc, argv, "l:r:s:o:EODd:g:p:h")) != -1)
{
switch (opt) {
case 'l':
left_freq = (int)atofs(optarg);
break;
case 'r':
right_freq = (int)atofs(optarg);
break;
case 's':
sample_rate = (int)atofs(optarg);
break;
case 'o':
output_rate = (int)atofs(optarg);
break;
case 'E':
edge = !edge;
break;
case 'D':
dc_filter = !dc_filter;
break;
case 'O':
oversample = !oversample;
break;
case 'd':
dev_index = verbose_device_search(optarg);
dev_given = 1;
break;
case 'g':
gain = (int)(atof(optarg) * 10);
break;
case 'p':
ppm_error = atoi(optarg);
custom_ppm = 1;
break;
case 'h':
default:
usage();
return 2;
}
}
if (argc <= optind) {
filename = "-";
} else {
filename = argv[optind];
}
if (left_freq > right_freq) {
usage();
return 2;
}
/* precompute rates */
dongle_freq = left_freq/2 + right_freq/2;
if (edge) {
dongle_freq -= sample_rate/2;}
delta = right_freq - left_freq;
if (delta > 1.2e6) {
fprintf(stderr, "Frequencies may be at most 1.2MHz apart.");
exit(1);
}
if (delta < 0) {
fprintf(stderr, "Left channel must be lower than right channel.");
exit(1);
}
i = (int)log2(2.4e6 / delta);
dongle_rate = delta * (1<<i);
both.rate_in = dongle_rate;
both.rate_out = delta * 2;
i = (int)log2(both.rate_in/both.rate_out);
both.downsample_passes = i;
both.downsample = 1 << i;
left.rate_in = both.rate_out;
i = (int)log2(left.rate_in / sample_rate);
left.downsample_passes = i;
left.downsample = 1 << i;
left.rate_out = left.rate_in / left.downsample;
right.rate_in = left.rate_in;
right.rate_out = left.rate_out;
right.downsample = left.downsample;
right.downsample_passes = left.downsample_passes;
if (left.rate_out > output_rate) {
fprintf(stderr, "Channel bandwidth too high or output bandwidth too low.");
exit(1);
}
stereo.rate = output_rate;
if (edge) {
fprintf(stderr, "Edge tuning enabled.\n");
} else {
fprintf(stderr, "Edge tuning disabled.\n");
}
if (dc_filter) {
fprintf(stderr, "DC filter enabled.\n");
} else {
fprintf(stderr, "DC filter disabled.\n");
}
fprintf(stderr, "Buffer size: %0.2f mS\n", 1000 * (double)DEFAULT_BUF_LENGTH / (double)dongle_rate);
fprintf(stderr, "Downsample factor: %i\n", both.downsample * left.downsample);
fprintf(stderr, "Low pass: %i Hz\n", left.rate_out);
fprintf(stderr, "Output: %i Hz\n", output_rate);
/* precompute lengths */
both.len_in = DEFAULT_BUF_LENGTH;
both.len_out = both.len_in / both.downsample;
left.len_in = both.len_out;
right.len_in = both.len_out;
left.len_out = left.len_in / left.downsample;
right.len_out = right.len_in / right.downsample;
left_demod.buf_len = left.len_out;
left_demod.result_len = left_demod.buf_len / 2;
right_demod.buf_len = left_demod.buf_len;
right_demod.result_len = left_demod.result_len;
stereo.bl_len = (int)((long)(DEFAULT_BUF_LENGTH/2) * (long)output_rate / (long)dongle_rate);
stereo.br_len = stereo.bl_len;
stereo.result_len = stereo.br_len * 2;
stereo.rate = output_rate;
if (!dev_given) {
dev_index = verbose_device_search("0");
}
if (dev_index < 0) {
exit(1);
}
downsample_init(&both);
downsample_init(&left);
downsample_init(&right);
demod_init(&left_demod);
demod_init(&right_demod);
stereo_init(&stereo);
r = rtlsdr_open(&dev, (uint32_t)dev_index);
if (r < 0) {
fprintf(stderr, "Failed to open rtlsdr device #%d.\n", dev_index);
exit(1);
}
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);
if (strcmp(filename, "-") == 0) { /* Write samples to stdout */
file = stdout;
setvbuf(stdout, NULL, _IONBF, 0);
} else {
file = fopen(filename, "wb");
if (!file) {
fprintf(stderr, "Failed to open %s\n", filename);
exit(1);
}
}
/* Set the tuner gain */
if (gain == AUTO_GAIN) {
verbose_auto_gain(dev);
} else {
gain = nearest_gain(dev, gain);
verbose_gain_set(dev, gain);
}
if (!custom_ppm) {
verbose_ppm_eeprom(dev, &ppm_error);
}
verbose_ppm_set(dev, ppm_error);
//r = rtlsdr_set_agc_mode(dev, 1);
/* Set the tuner frequency */
verbose_set_frequency(dev, dongle_freq);
/* Set the sample rate */
verbose_set_sample_rate(dev, dongle_rate);
/* Reset endpoint before we start reading from it (mandatory) */
verbose_reset_buffer(dev);
pthread_create(&demod_thread, NULL, demod_thread_fn, (void *)(NULL));
rtlsdr_read_async(dev, rtlsdr_callback, (void *)(NULL),
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);
safe_cond_signal(&ready, &ready_m);
pthread_cond_destroy(&ready);
pthread_mutex_destroy(&ready_m);
if (file != stdout) {
fclose(file);}
rtlsdr_close(dev);
return r >= 0 ? r : -r;
}
// main program
int main (int argc, char **argv)
{
// command-line options
int verbose = 1;
int ppm_error = 0;
int gain = 0;
float rx_resamp_rate;
float bandwidth = 800e3f;
int r, n_read;
uint32_t frequency = 100000000;
uint32_t samp_rate = DEFAULT_SAMPLE_RATE;
uint32_t out_block_size = DEFAULT_BUF_LENGTH;
uint8_t *buffer;
complex float *buffer_norm;
int dev_index = 0;
int dev_given = 0;
struct sigaction sigact;
normalizer_t *norm;
float kf = 0.1f; // modulation factor
liquid_freqdem_type type = LIQUID_FREQDEM_DELAYCONJ;
//
int d;
while ((d = getopt(argc,argv,"hf:b:B:G:p:s:")) != EOF) {
switch (d) {
case 'h': usage(); return 0;
case 'f': frequency = atof(optarg); break;
case 'b': bandwidth = atof(optarg); break;
case 'B': out_block_size = (uint32_t)atof(optarg); break;
case 'G': gain = (int)(atof(optarg) * 10); break;
case 'p': ppm_error = atoi(optarg); break;
case 's': samp_rate = (uint32_t)atofs(optarg); break;
case 'd':
dev_index = verbose_device_search(optarg);
dev_given = 1;
break;
default: usage(); return 1;
}
}
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);
}
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);
/* Set the sample rate */
verbose_set_sample_rate(dev, samp_rate);
/* Set the frequency */
verbose_set_frequency(dev, frequency);
if (0 == gain) {
/* Enable automatic gain */
verbose_auto_gain(dev);
} else {
/* Enable manual gain */
gain = nearest_gain(dev, gain);
verbose_gain_set(dev, gain);
}
verbose_ppm_set(dev, ppm_error);
rx_resamp_rate = bandwidth/samp_rate;
printf("frequency : %10.4f [MHz]\n", frequency*1e-6f);
printf("bandwidth : %10.4f [kHz]\n", bandwidth*1e-3f);
printf("sample rate : %10.4f kHz = %10.4f kHz * %8.6f\n",
samp_rate * 1e-3f,
bandwidth * 1e-3f,
1.0f / rx_resamp_rate);
printf("verbosity : %s\n", (verbose?"enabled":"disabled"));
unsigned int i,j;
// add arbitrary resampling component
msresamp_crcf resamp = msresamp_crcf_create(rx_resamp_rate, 60.0f);
assert(resamp);
//allocate recv buffer
buffer = malloc(out_block_size * sizeof(uint8_t));
assert(buffer);
buffer_norm = malloc(out_block_size * sizeof(complex float));
assert(buffer_norm);
// create buffer for arbitrary resamper output
int b_len = ((int)(out_block_size * rx_resamp_rate) + 64) >> 1;
complex float buffer_resamp[b_len];
int16_t buffer_demod[b_len];
debug("resamp_buffer_len: %d\n", b_len);
norm = normalizer_create();
verbose_reset_buffer(dev);
freqdem dem = freqdem_create(kf,type);
while (!do_exit) {
// grab data from device
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;
}
// push data through arbitrary resampler and give to frame synchronizer
// TODO : apply bandwidth-dependent gain
for (i=0; i<n_read/2; i++) {
// grab sample from usrp buffer
buffer_norm[i] = normalizer_normalize(norm, *((uint16_t*)buffer+i));
}
// push through resampler (one at a time)
unsigned int nw;
float demod;
msresamp_crcf_execute(resamp, buffer_norm, n_read/2, buffer_resamp, &nw);
for(j=0;j<nw;j++)
{
freqdem_demodulate(dem, buffer_resamp[j], &demod);
buffer_demod[j] = to_int16(demod);
}
if (fwrite(buffer_demod, 2, nw, stdout) != (size_t)nw) {
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;
}
// destroy objects
freqdem_destroy(dem);
normalizer_destroy(&norm);
msresamp_crcf_destroy(resamp);
rtlsdr_close(dev);
free (buffer);
return 0;
}
// main program
int main (int argc, char **argv)
{
// command-line options
int verbose = 1;
int ppm_error = 0;
int gain = 0;
unsigned int nfft = 64;
float offset = -65.0f;
float scale = 5.0f;
float fft_rate = 10.0f;
float rx_resamp_rate;
float bandwidth = 800e3f;
unsigned int logsize = 4096;
char filename[256] = "rtl_asgram.dat";
int r, n_read;
uint32_t frequency = 100000000;
uint32_t samp_rate = DEFAULT_SAMPLE_RATE;
uint32_t out_block_size = DEFAULT_BUF_LENGTH;
uint8_t *buffer;
int dev_index = 0;
int dev_given = 0;
struct sigaction sigact;
normalizer_t *norm;
//
int d;
while ((d = getopt(argc,argv,"hf:b:B:G:n:p:s:o:r:L:F:")) != EOF) {
switch (d) {
case 'h':
usage();
return 0;
case 'f':
frequency = atof(optarg);
break;
case 'b':
bandwidth = atof(optarg);
break;
case 'B':
out_block_size = (uint32_t)atof(optarg);
break;
case 'G':
gain = (int)(atof(optarg) * 10);
break;
case 'n':
nfft = atoi(optarg);
break;
case 'o':
offset = atof(optarg);
break;
case 'p':
ppm_error = atoi(optarg);
break;
case 's':
samp_rate = (uint32_t)atofs(optarg);
break;
case 'r':
fft_rate = atof(optarg);
break;
case 'L':
logsize = atoi(optarg);
break;
case 'F':
strncpy(filename,optarg,255);
break;
case 'd':
dev_index = verbose_device_search(optarg);
dev_given = 1;
break;
default:
usage();
return 1;
}
}
// validate parameters
if (fft_rate <= 0.0f || fft_rate > 100.0f) {
fprintf(stderr,"error: %s, fft rate must be in (0, 100) Hz\n", argv[0]);
exit(1);
}
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);
}
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);
/* Set the sample rate */
verbose_set_sample_rate(dev, samp_rate);
/* Set the frequency */
verbose_set_frequency(dev, frequency);
if (0 == gain) {
/* Enable automatic gain */
verbose_auto_gain(dev);
} else {
/* Enable manual gain */
gain = nearest_gain(dev, gain);
verbose_gain_set(dev, gain);
}
verbose_ppm_set(dev, ppm_error);
rx_resamp_rate = bandwidth/samp_rate;
printf("frequency : %10.4f [MHz]\n", frequency*1e-6f);
printf("bandwidth : %10.4f [kHz]\n", bandwidth*1e-3f);
printf("sample rate : %10.4f kHz = %10.4f kHz * %8.6f\n",
samp_rate * 1e-3f,
bandwidth * 1e-3f,
1.0f / rx_resamp_rate);
printf("verbosity : %s\n", (verbose?"enabled":"disabled"));
unsigned int i;
// add arbitrary resampling component
msresamp_crcf resamp = msresamp_crcf_create(rx_resamp_rate, 60.0f);
assert(resamp);
// create buffer for sample logging
windowcf log = windowcf_create(logsize);
// create ASCII spectrogram object
float maxval;
float maxfreq;
char ascii[nfft+1];
ascii[nfft] = '\0'; // append null character to end of string
asgram q = asgram_create(nfft);
asgram_set_scale(q, offset, scale);
// assemble footer
unsigned int footer_len = nfft + 16;
char footer[footer_len+1];
for (i=0; i<footer_len; i++)
footer[i] = ' ';
footer[1] = '[';
footer[nfft/2 + 3] = '+';
footer[nfft + 4] = ']';
sprintf(&footer[nfft+6], "%8.3f MHz", frequency*1e-6f);
unsigned int msdelay = 1000 / fft_rate;
// create/initialize Hamming window
float w[nfft];
for (i=0; i<nfft; i++)
w[i] = hamming(i,nfft);
//allocate recv buffer
buffer = malloc(out_block_size * sizeof(uint8_t));
assert(buffer);
// create buffer for arbitrary resamper output
int b_len = ((int)(out_block_size * rx_resamp_rate) + 64) >> 1;
complex float buffer_resamp[b_len];
debug("resamp_buffer_len: %d", b_len);
// timer to control asgram output
timer t1 = timer_create();
timer_tic(t1);
norm = normalizer_create();
verbose_reset_buffer(dev);
while (!do_exit) {
// grab data from device
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;
}
// push data through arbitrary resampler and give to frame synchronizer
// TODO : apply bandwidth-dependent gain
for (i=0; i<n_read/2; i++) {
// grab sample from usrp buffer
complex float rtlsdr_sample = normalizer_normalize(norm, *((uint16_t*)buffer+i));
// push through resampler (one at a time)
unsigned int nw;
msresamp_crcf_execute(resamp, &rtlsdr_sample, 1, buffer_resamp, &nw);
// push resulting samples into asgram object
asgram_push(q, buffer_resamp, nw);
// write samples to log
windowcf_write(log, buffer_resamp, nw);
}
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;
if (timer_toc(t1) > msdelay*1e-3f) {
// reset timer
timer_tic(t1);
// run the spectrogram
asgram_execute(q, ascii, &maxval, &maxfreq);
// print the spectrogram
printf(" > %s < pk%5.1fdB [%5.2f]\n", ascii, maxval, maxfreq);
printf("%s\r", footer);
fflush(stdout);
}
}
// try to write samples to file
FILE * fid = fopen(filename,"w");
if (fid != NULL) {
// write header
fprintf(fid, "# %s : auto-generated file\n", filename);
fprintf(fid, "#\n");
fprintf(fid, "# num_samples : %u\n", logsize);
fprintf(fid, "# frequency : %12.8f MHz\n", frequency*1e-6f);
fprintf(fid, "# bandwidth : %12.8f kHz\n", bandwidth*1e-3f);
// save results to file
complex float * rc; // read pointer
windowcf_read(log, &rc);
for (i=0; i<logsize; i++)
fprintf(fid, "%12.4e %12.4e\n", crealf(rc[i]), cimagf(rc[i]));
// close it up
fclose(fid);
printf("results written to '%s'\n", filename);
} else {
fprintf(stderr,"error: %s, could not open '%s' for writing\n", argv[0], filename);
}
// destroy objects
normalizer_destroy(&norm);
msresamp_crcf_destroy(resamp);
windowcf_destroy(log);
asgram_destroy(q);
timer_destroy(t1);
rtlsdr_close(dev);
free (buffer);
return 0;
}
int main(int argc, char **argv)
{
#ifndef _WIN32
struct sigaction sigact;
#endif
char *filename = NULL;
int i, length, n_read, r, opt, wb_mode = 0;
int f_set = 0;
int gain = AUTO_GAIN; // tenths of a dB
uint8_t *buffer;
uint32_t dev_index = 0;
int device_count;
int ppm_error = 0;
int interval = 10;
int fft_threads = 1;
int smoothing = 0;
int single = 0;
double crop = 0.0;
char vendor[256], product[256], serial[256];
char *freq_optarg;
time_t next_tick;
time_t time_now;
time_t exit_time = 0;
char t_str[50];
struct tm *cal_time;
double (*window_fn)(int, int) = rectangle;
freq_optarg = "";
while ((opt = getopt(argc, argv, "f:i:s:t:d:g:p:e:w:c:1Fh")) != -1) {
switch (opt) {
case 'f': // lower:upper:bin_size
freq_optarg = strdup(optarg);
f_set = 1;
break;
case 'd':
dev_index = atoi(optarg);
break;
case 'g':
gain = (int)(atof(optarg) * 10);
break;
case 'c':
crop = atofp(optarg);
break;
case 'i':
interval = (int)round(atoft(optarg));
break;
case 'e':
exit_time = (time_t)((int)round(atoft(optarg)));
break;
case 's':
if (strcmp("avg", optarg) == 0) {
smoothing = 0;}
if (strcmp("iir", optarg) == 0) {
smoothing = 1;}
break;
case 'w':
if (strcmp("rectangle", optarg) == 0) {
window_fn = rectangle;}
if (strcmp("hamming", optarg) == 0) {
window_fn = hamming;}
if (strcmp("blackman", optarg) == 0) {
window_fn = blackman;}
if (strcmp("blackman-harris", optarg) == 0) {
window_fn = blackman_harris;}
if (strcmp("hann-poisson", optarg) == 0) {
window_fn = hann_poisson;}
if (strcmp("youssef", optarg) == 0) {
window_fn = youssef;}
if (strcmp("kaiser", optarg) == 0) {
window_fn = kaiser;}
if (strcmp("bartlett", optarg) == 0) {
window_fn = bartlett;}
break;
case 't':
fft_threads = atoi(optarg);
break;
case 'p':
ppm_error = atoi(optarg);
break;
case '1':
single = 1;
break;
case 'F':
boxcar = 0;
break;
case 'h':
default:
usage();
break;
}
}
if (!f_set) {
fprintf(stderr, "No frequency range provided.\n");
exit(1);
}
if ((crop < 0.0) || (crop > 1.0)) {
fprintf(stderr, "Crop value outside of 0 to 1.\n");
exit(1);
}
frequency_range(freq_optarg, crop);
if (tune_count == 0) {
usage();}
if (argc <= optind) {
filename = "-";
} else {
filename = argv[optind];
}
if (interval < 1) {
interval = 1;}
fprintf(stderr, "Reporting every %i seconds\n", interval);
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);
}
#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 tuner gain */
if (gain == AUTO_GAIN) {
r = rtlsdr_set_tuner_gain_mode(dev, 0);
} else {
r = rtlsdr_set_tuner_gain_mode(dev, 1);
gain = nearest_gain(gain);
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);
}
r = rtlsdr_set_freq_correction(dev, ppm_error);
if (strcmp(filename, "-") == 0) { /* Write log to stdout */
file = stdout;
#ifdef _WIN32
// Is this necessary? Output is ascii.
_setmode(_fileno(file), _O_BINARY);
#endif
} else {
file = fopen(filename, "wb");
if (!file) {
fprintf(stderr, "Failed to open %s\n", filename);
exit(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");}
/* actually do stuff */
rtlsdr_set_sample_rate(dev, (uint32_t)tunes[0].rate);
sine_table(tunes[0].bin_e);
next_tick = time(NULL) + interval;
if (exit_time) {
exit_time = time(NULL) + exit_time;}
fft_buf = malloc(tunes[0].buf_len * sizeof(int16_t));
length = 1 << tunes[0].bin_e;
window_coefs = malloc(length * sizeof(int));
for (i=0; i<length; i++) {
window_coefs[i] = (int)(256*window_fn(i, length));
}
while (!do_exit) {
scanner();
time_now = time(NULL);
if (time_now < next_tick) {
continue;}
// time, Hz low, Hz high, Hz step, samples, dbm, dbm, ...
cal_time = localtime(&time_now);
strftime(t_str, 50, "%Y-%m-%d, %H:%M:%S", cal_time);
for (i=0; i<tune_count; i++) {
fprintf(file, "%s, ", t_str);
csv_dbm(&tunes[i]);
}
fflush(file);
while (time(NULL) >= next_tick) {
next_tick += interval;}
if (single) {
do_exit = 1;}
if (exit_time && time(NULL) >= exit_time) {
do_exit = 1;}
}
/* clean up */
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(fft_buf);
free(window_coefs);
//for (i=0; i<tune_count; i++) {
// free(tunes[i].avg);
// free(tunes[i].buf8);
//}
return r >= 0 ? r : -r;
}
