mirror/rtl-sdr-blog
1
0
Fork 0
mirror of https://github.com/rtlsdrblog/rtl-sdr-blog.git synced 2024-12-27 03:18:30 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

rtl_fm: fix scanning

Browse Source 
Signed-off-by: Steve Markgraf <steve@steve-m.de>
This commit is contained in:
Kyle Keen 2013-08-17 09:49:28 -04:00 committed by Steve Markgraf
parent 8c3a99c8f7
commit c4fcfbb46e
1 changed files with 94 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

127
src/rtl_fm.c
View File

@ -34,6 +34,11 @@
* pad output on hop * pad output on hop
* nearest gain approx * nearest gain approx
* frequency ranges could be stored better * frequency ranges could be stored better
* scaled AM demod amplification
* auto-hop after time limit
* peak detector to tune onto stronger signals
* use slower sample rates (250k) for nbfm
* offset tuning
*/ */
#include <errno.h> #include <errno.h>
@ -66,12 +71,16 @@
#define MAXIMUM_BUF_LENGTH (MAXIMUM_OVERSAMPLE * DEFAULT_BUF_LENGTH) #define MAXIMUM_BUF_LENGTH (MAXIMUM_OVERSAMPLE * DEFAULT_BUF_LENGTH)
#define AUTO_GAIN -100 #define AUTO_GAIN -100
#define FREQUENCIES_LIMIT 1000
static pthread_t demod_thread; static pthread_t demod_thread;
static pthread_mutex_t data_ready; /* locked when no fresh data available */ static pthread_cond_t data_ready; /* shared buffer filled */
static pthread_mutex_t data_write; /* locked when r/w buffer */ static pthread_rwlock_t data_rw; /* lock for shared buffer */
static int do_exit = 0; static pthread_mutex_t data_mutex; /* because conds are dumb */
static volatile int do_exit = 0;
static rtlsdr_dev_t *dev = NULL; static rtlsdr_dev_t *dev = NULL;
static int lcm_post[17] = {1,1,1,3,1,5,3,7,1,9,5,11,3,13,7,15,1}; static int lcm_post[17] = {1,1,1,3,1,5,3,7,1,9,5,11,3,13,7,15,1};
static int ACTUAL_BUF_LENGTH;
static int *atan_lut = NULL; static int *atan_lut = NULL;
static int atan_lut_size = 131072; /* 512 KB */ static int atan_lut_size = 131072; /* 512 KB */
@ -95,7 +104,7 @@ struct fm_state
int signal2_len; int signal2_len;
FILE *file; FILE *file;
int edge; int edge;
uint32_t freqs[1000]; uint32_t freqs[FREQUENCIES_LIMIT];
int freq_len; int freq_len;
int freq_now; int freq_now;
uint32_t sample_rate; uint32_t sample_rate;
@ -145,7 +154,7 @@ void usage(void)
"\t[-C enables DC blocking of output (default: off)]\n" "\t[-C enables DC blocking of output (default: off)]\n"
"\t[-A std/fast/lut choose atan math (default: std)]\n\n" "\t[-A std/fast/lut choose atan math (default: std)]\n\n"
"Produces signed 16 bit ints, use Sox or aplay to hear them.\n" "Produces signed 16 bit ints, use Sox or aplay to hear them.\n"
"\trtl_fm ... - | play -t raw -r 24k -e signed-integer -b 16 -c 1 -V1 -\n" "\trtl_fm ... - | play -t raw -r 24k -es -b 16 -c 1 -V1 -\n"
"\t | aplay -r 24k -f S16_LE -t raw -c 1\n" "\t | aplay -r 24k -f S16_LE -t raw -c 1\n"
"\t -s 22.5k - | multimon -t raw /dev/stdin\n\n"); "\t -s 22.5k - | multimon -t raw /dev/stdin\n\n");
exit(1); exit(1);
@ -158,7 +167,7 @@ sighandler(int signum)
if (CTRL_C_EVENT == signum) { if (CTRL_C_EVENT == signum) {
fprintf(stderr, "Signal caught, exiting!\n"); fprintf(stderr, "Signal caught, exiting!\n");
do_exit = 1; do_exit = 1;
rtlsdr_cancel_async(dev); //rtlsdr_cancel_async(dev);
return TRUE; return TRUE;
} }
return FALSE; return FALSE;
@ -168,10 +177,14 @@ static void sighandler(int signum)
{ {
fprintf(stderr, "Signal caught, exiting!\n"); fprintf(stderr, "Signal caught, exiting!\n");
do_exit = 1; do_exit = 1;
rtlsdr_cancel_async(dev); //rtlsdr_cancel_async(dev);
} }
#endif #endif
/* more cond dumbness */
#define safe_cond_signal(n, m) pthread_mutex_lock(m); pthread_cond_signal(n); pthread_mutex_unlock(m)
#define safe_cond_wait(n, m) pthread_mutex_lock(m); pthread_cond_wait(n, m); pthread_mutex_unlock(m)
void rotate_90(unsigned char *buf, uint32_t len) void rotate_90(unsigned char *buf, uint32_t len)
/* 90 rotation is 1+0j, 0+1j, -1+0j, 0-1j /* 90 rotation is 1+0j, 0+1j, -1+0j, 0-1j
or [0, 1, -3, 2, -4, -5, 7, -6] */ or [0, 1, -3, 2, -4, -5, 7, -6] */
@ -205,8 +218,8 @@ void low_pass(struct fm_state *fm, unsigned char *buf, uint32_t len)
if (fm->prev_index < fm->downsample) { if (fm->prev_index < fm->downsample) {
continue; continue;
} }
fm->signal[i2] = fm->now_r * fm->output_scale; fm->signal[i2] = fm->now_r; // * fm->output_scale;
fm->signal[i2+1] = fm->now_j * fm->output_scale; fm->signal[i2+1] = fm->now_j; // * fm->output_scale;
fm->prev_index = 0; fm->prev_index = 0;
fm->now_r = 0; fm->now_r = 0;
fm->now_j = 0; fm->now_j = 0;
@ -248,8 +261,8 @@ void low_pass_fir(struct fm_state *fm, unsigned char *buf, uint32_t len)
if (fm->prev_index < fm->downsample) { if (fm->prev_index < fm->downsample) {
continue; continue;
} }
fm->signal[i2] = fm->now_r * fm->output_scale; fm->signal[i2] = fm->now_r; //* fm->output_scale;
fm->signal[i2+1] = fm->now_j * fm->output_scale; fm->signal[i2+1] = fm->now_j; //* fm->output_scale;
fm->prev_index = 0; fm->prev_index = 0;
fm->now_r = 0; fm->now_r = 0;
fm->now_j = 0; fm->now_j = 0;
@ -432,7 +445,7 @@ void am_demod(struct fm_state *fm)
//fm->signal2[i/2] = (int16_t)hypot(fm->signal[i], fm->signal[i+1]); //fm->signal2[i/2] = (int16_t)hypot(fm->signal[i], fm->signal[i+1]);
pcm = fm->signal[i] * fm->signal[i]; pcm = fm->signal[i] * fm->signal[i];
pcm += fm->signal[i+1] * fm->signal[i+1]; pcm += fm->signal[i+1] * fm->signal[i+1];
fm->signal2[i/2] = (int16_t)sqrt(pcm); // * fm->output_scale; fm->signal2[i/2] = (int16_t)sqrt(pcm) * fm->output_scale;
} }
fm->signal2_len = fm->signal_len/2; fm->signal2_len = fm->signal_len/2;
// lowpass? (3khz) highpass? (dc) // lowpass? (3khz) highpass? (dc)
@ -443,7 +456,7 @@ void usb_demod(struct fm_state *fm)
int i, pcm; int i, pcm;
for (i = 0; i < (fm->signal_len); i += 2) { for (i = 0; i < (fm->signal_len); i += 2) {
pcm = fm->signal[i] + fm->signal[i+1]; pcm = fm->signal[i] + fm->signal[i+1];
fm->signal2[i/2] = (int16_t)pcm; // * fm->output_scale; fm->signal2[i/2] = (int16_t)pcm * fm->output_scale;
} }
fm->signal2_len = fm->signal_len/2; fm->signal2_len = fm->signal_len/2;
} }
@ -453,7 +466,7 @@ void lsb_demod(struct fm_state *fm)
int i, pcm; int i, pcm;
for (i = 0; i < (fm->signal_len); i += 2) { for (i = 0; i < (fm->signal_len); i += 2) {
pcm = fm->signal[i] - fm->signal[i+1]; pcm = fm->signal[i] - fm->signal[i+1];
fm->signal2[i/2] = (int16_t)pcm; // * fm->output_scale; fm->signal2[i/2] = (int16_t)pcm * fm->output_scale;
} }
fm->signal2_len = fm->signal_len/2; fm->signal2_len = fm->signal_len/2;
} }
@ -545,7 +558,8 @@ static void optimal_settings(struct fm_state *fm, int freq, int hopping)
fm->output_scale = (1<<15) / (128 * fm->downsample); fm->output_scale = (1<<15) / (128 * fm->downsample);
if (fm->output_scale < 1) { if (fm->output_scale < 1) {
fm->output_scale = 1;} fm->output_scale = 1;}
fm->output_scale = 1; if (fm->mode_demod == &fm_demod) {
fm->output_scale = 1;}
/* Set the frequency */ /* Set the frequency */
r = rtlsdr_set_center_freq(dev, (uint32_t)capture_freq); r = rtlsdr_set_center_freq(dev, (uint32_t)capture_freq);
if (hopping) { if (hopping) {
@ -553,7 +567,7 @@ static void optimal_settings(struct fm_state *fm, int freq, int hopping)
fprintf(stderr, "Oversampling input by: %ix.\n", fm->downsample); fprintf(stderr, "Oversampling input by: %ix.\n", fm->downsample);
fprintf(stderr, "Oversampling output by: %ix.\n", fm->post_downsample); fprintf(stderr, "Oversampling output by: %ix.\n", fm->post_downsample);
fprintf(stderr, "Buffer size: %0.2fms\n", fprintf(stderr, "Buffer size: %0.2fms\n",
1000 * 0.5 * lcm_post[fm->post_downsample] * (float)DEFAULT_BUF_LENGTH / (float)capture_rate); 1000 * 0.5 * (float)ACTUAL_BUF_LENGTH / (float)capture_rate);
if (r < 0) { if (r < 0) {
fprintf(stderr, "WARNING: Failed to set center freq.\n");} fprintf(stderr, "WARNING: Failed to set center freq.\n");}
else { else {
@ -574,15 +588,16 @@ static void optimal_settings(struct fm_state *fm, int freq, int hopping)
void full_demod(struct fm_state *fm) void full_demod(struct fm_state *fm)
{ {
int i, sr, freq_next, hop = 0; int i, sr, freq_next, hop = 0;
pthread_rwlock_wrlock(&data_rw);
rotate_90(fm->buf, fm->buf_len); rotate_90(fm->buf, fm->buf_len);
if (fm->fir_enable) { if (fm->fir_enable) {
low_pass_fir(fm, fm->buf, fm->buf_len); low_pass_fir(fm, fm->buf, fm->buf_len);
} else { } else {
low_pass(fm, fm->buf, fm->buf_len); low_pass(fm, fm->buf, fm->buf_len);
} }
pthread_mutex_unlock(&data_write); pthread_rwlock_unlock(&data_rw);
fm->mode_demod(fm); fm->mode_demod(fm);
if (fm->mode_demod == &raw_demod) { if (fm->mode_demod == &raw_demod) {
fwrite(fm->signal2, 2, fm->signal2_len, fm->file); fwrite(fm->signal2, 2, fm->signal2_len, fm->file);
return; return;
} }
@ -625,23 +640,41 @@ static void rtlsdr_callback(unsigned char *buf, uint32_t len, void *ctx)
return;} return;}
if (!ctx) { if (!ctx) {
return;} return;}
pthread_mutex_lock(&data_write); pthread_rwlock_wrlock(&data_rw);
memcpy(fm2->buf, buf, len); memcpy(fm2->buf, buf, len);
fm2->buf_len = len; fm2->buf_len = len;
pthread_mutex_unlock(&data_ready); pthread_rwlock_unlock(&data_rw);
safe_cond_signal(&data_ready, &data_mutex);
/* single threaded uses 25% less CPU? */ /* single threaded uses 25% less CPU? */
/* full_demod(fm2); */ /* full_demod(fm2); */
} }
static void sync_read(unsigned char *buf, uint32_t len, struct fm_state *fm)
{
int r, n_read;
r = rtlsdr_read_sync(dev, buf, len, &n_read);
if (r < 0) {
fprintf(stderr, "WARNING: sync read failed.\n");
return;
}
pthread_rwlock_wrlock(&data_rw);
memcpy(fm->buf, buf, len);
fm->buf_len = len;
pthread_rwlock_unlock(&data_rw);
safe_cond_signal(&data_ready, &data_mutex);
//full_demod(fm);
}
static void *demod_thread_fn(void *arg) static void *demod_thread_fn(void *arg)
{ {
struct fm_state *fm2 = arg; struct fm_state *fm2 = arg;
while (!do_exit) { while (!do_exit) {
pthread_mutex_lock(&data_ready); safe_cond_wait(&data_ready, &data_mutex);
full_demod(fm2); full_demod(fm2);
if (fm2->exit_flag) { if (fm2->exit_flag) {
do_exit = 1; do_exit = 1;
rtlsdr_cancel_async(dev);} //rtlsdr_cancel_async(dev);
}
} }
return 0; return 0;
} }
@ -650,7 +683,7 @@ double atofs(char* f)
/* standard suffixes */ /* standard suffixes */
{ {
char* chop; char* chop;
double suff = 1.0; double suff = 1.0;
chop = malloc((strlen(f)+1)*sizeof(char)); chop = malloc((strlen(f)+1)*sizeof(char));
strncpy(chop, f, strlen(f)-1); strncpy(chop, f, strlen(f)-1);
switch (f[strlen(f)-1]) { switch (f[strlen(f)-1]) {
@ -660,7 +693,7 @@ double atofs(char* f)
suff *= 1e3; suff *= 1e3;
case 'k': case 'k':
suff *= 1e3; suff *= 1e3;
suff *= atof(chop);} suff *= atof(chop);}
free(chop); free(chop);
if (suff != 1.0) { if (suff != 1.0) {
return suff;} return suff;}
@ -680,6 +713,8 @@ void frequency_range(struct fm_state *fm, char *arg)
{ {
fm->freqs[fm->freq_len] = (uint32_t)i; fm->freqs[fm->freq_len] = (uint32_t)i;
fm->freq_len++; fm->freq_len++;
if (fm->freq_len >= FREQUENCIES_LIMIT) {
break;}
} }
stop[-1] = ':'; stop[-1] = ':';
step[-1] = ':'; step[-1] = ':';
@ -725,8 +760,9 @@ int main(int argc, char **argv)
int ppm_error = 0; int ppm_error = 0;
char vendor[256], product[256], serial[256]; char vendor[256], product[256], serial[256];
fm_init(&fm); fm_init(&fm);
pthread_mutex_init(&data_ready, NULL); pthread_cond_init(&data_ready, NULL);
pthread_mutex_init(&data_write, 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:NWMULRDC")) != -1) { while ((opt = getopt(argc, argv, "d:f:g:s:b:l:o:t:r:p:EFA:NWMULRDC")) != -1) {
switch (opt) { switch (opt) {
@ -734,6 +770,8 @@ int main(int argc, char **argv)
dev_index = atoi(optarg); dev_index = atoi(optarg);
break; break;
case 'f': case 'f':
if (fm.freq_len >= FREQUENCIES_LIMIT) {
break;}
if (strchr(optarg, ':')) if (strchr(optarg, ':'))
{frequency_range(&fm, optarg);} {frequency_range(&fm, optarg);}
else else
@ -828,18 +866,28 @@ int main(int argc, char **argv)
exit(1); 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) { if (fm.freq_len > 1) {
fm.terminate_on_squelch = 0; fm.terminate_on_squelch = 0;
} }
if (argc <= optind) { if (argc <= optind) {
//usage();
filename = "-"; filename = "-";
} else { } else {
filename = argv[optind]; filename = argv[optind];
} }
buffer = malloc(lcm_post[fm.post_downsample] * DEFAULT_BUF_LENGTH * sizeof(uint8_t)); 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(); device_count = rtlsdr_get_device_count();
if (!device_count) { if (!device_count) {
@ -875,6 +923,8 @@ int main(int argc, char **argv)
#endif #endif
/* WBFM is special */ /* WBFM is special */
// I really should loop over everything
// but you are more wrong for scanning broadcast FM
if (wb_mode) { if (wb_mode) {
fm.freqs[0] += 16000; fm.freqs[0] += 16000;
} }
@ -921,17 +971,26 @@ int main(int argc, char **argv)
fprintf(stderr, "WARNING: Failed to reset buffers.\n");} fprintf(stderr, "WARNING: Failed to reset buffers.\n");}
pthread_create(&demod_thread, NULL, demod_thread_fn, (void *)(&fm)); pthread_create(&demod_thread, NULL, demod_thread_fn, (void *)(&fm));
rtlsdr_read_async(dev, rtlsdr_callback, (void *)(&fm), /*rtlsdr_read_async(dev, rtlsdr_callback, (void *)(&fm),
DEFAULT_ASYNC_BUF_NUMBER, DEFAULT_ASYNC_BUF_NUMBER,
lcm_post[fm.post_downsample] * DEFAULT_BUF_LENGTH); ACTUAL_BUF_LENGTH);*/
while (!do_exit) {
sync_read(buffer, ACTUAL_BUF_LENGTH, &fm);
}
if (do_exit) { if (do_exit) {
fprintf(stderr, "\nUser cancel, exiting...\n");} fprintf(stderr, "\nUser cancel, exiting...\n");}
else { else {
fprintf(stderr, "\nLibrary error %d, exiting...\n", r);} fprintf(stderr, "\nLibrary error %d, exiting...\n", r);}
rtlsdr_cancel_async(dev);
pthread_mutex_destroy(&data_ready); //rtlsdr_cancel_async(dev);
pthread_mutex_destroy(&data_write); 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) { if (fm.file != stdout) {
fclose(fm.file);} fclose(fm.file);}
@ -940,3 +999,5 @@ int main(int argc, char **argv)
free (buffer); free (buffer);
return r >= 0 ? r : -r; return r >= 0 ? r : -r;
} }
// vim: tabstop=8:softtabstop=8:shiftwidth=8:noexpandtab