src/rtl_sdr.c

   1 /*
   2  * rtl-sdr, turns your Realtek RTL2832 based DVB dongle into a SDR receiver
   3  * Copyright (C) 2012 by Steve Markgraf <steve@steve-m.de>
   4  *
   5  * This program is free software: you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation, either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include <errno.h>
  20 #include <signal.h>
  21 #include <string.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24
  25 #ifndef _WIN32
  26 #include <unistd.h>
  27 #else
  28 #include <Windows.h>
  29 #include <io.h>
  30 #include <fcntl.h>
  31 #include "getopt/getopt.h"
  32 #endif
  33
  34 #include "rtl-sdr.h"
  35
  36 #define DEFAULT_SAMPLE_RATE             2048000
  37 #define DEFAULT_ASYNC_BUF_NUMBER        32
  38 #define DEFAULT_BUF_LENGTH              (16 * 16384)
  39 #define MINIMAL_BUF_LENGTH              512
  40 #define MAXIMAL_BUF_LENGTH              (256 * 16384)
  41
  42 static int do_exit = 0;
  43 static uint32_t bytes_to_read = 0;
  44 static rtlsdr_dev_t *dev = NULL;
  45
  46 void usage(void)
  47 {
  48         fprintf(stderr,
  49                 "rtl_sdr, an I/Q recorder for RTL2832 based DVB-T receivers\n\n"
  50                 "Usage:\t -f frequency_to_tune_to [Hz]\n"
  51                 "\t[-s samplerate (default: 2048000 Hz)]\n"
  52                 "\t[-d device_index (default: 0)]\n"
  53                 "\t[-g gain (default: 0 for auto)]\n"
  54                 "\t[-b output_block_size (default: 16 * 16384)]\n"
  55                 "\t[-n number of samples to read (default: 0, infinite)]\n"
  56                 "\t[-S force sync output (default: async)]\n"
  57                 "\tfilename (a '-' dumps samples to stdout)\n\n");
  58         exit(1);
  59 }
  60
  61 #ifdef _WIN32
  62 BOOL WINAPI
  63 sighandler(int signum)
  64 {
  65         if (CTRL_C_EVENT == signum) {
  66                 fprintf(stderr, "Signal caught, exiting!\n");
  67                 do_exit = 1;
  68                 rtlsdr_cancel_async(dev);
  69                 return TRUE;
  70         }
  71         return FALSE;
  72 }
  73 #else
  74 static void sighandler(int signum)
  75 {
  76         fprintf(stderr, "Signal caught, exiting!\n");
  77         do_exit = 1;
  78         rtlsdr_cancel_async(dev);
  79 }
  80 #endif
  81
  82 static void rtlsdr_callback(unsigned char *buf, uint32_t len, void *ctx)
  83 {
  84         if (ctx) {
  85                 if (do_exit)
  86                         return;
  87
  88                 if ((bytes_to_read > 0) && (bytes_to_read < len)) {
  89                         len = bytes_to_read;
  90                         do_exit = 1;
  91                         rtlsdr_cancel_async(dev);
  92                 }
  93
  94                 if (fwrite(buf, 1, len, (FILE*)ctx) != len) {
  95                         fprintf(stderr, "Short write, samples lost, exiting!\n");
  96                         rtlsdr_cancel_async(dev);
  97                 }
  98
  99                 if (bytes_to_read > 0)
 100                         bytes_to_read -= len;
 101         }
 102 }
 103
 104 int main(int argc, char **argv)
 105 {
 106 #ifndef _WIN32
 107         struct sigaction sigact;
 108 #endif
 109         char *filename = NULL;
 110         int n_read;
 111         int r, opt;
 112         int i, gain = 0;
 113         int sync_mode = 0;
 114         FILE *file;
 115         uint8_t *buffer;
 116         uint32_t dev_index = 0;
 117         uint32_t frequency = 100000000;
 118         uint32_t samp_rate = DEFAULT_SAMPLE_RATE;
 119         uint32_t out_block_size = DEFAULT_BUF_LENGTH;
 120         int device_count;
 121         char vendor[256], product[256], serial[256];
 122
 123         while ((opt = getopt(argc, argv, "d:f:g:s:b:n:S::")) != -1) {
 124                 switch (opt) {
 125                 case 'd':
 126                         dev_index = atoi(optarg);
 127                         break;
 128                 case 'f':
 129                         frequency = (uint32_t)atof(optarg);
 130                         break;
 131                 case 'g':
 132                         gain = (int)(atof(optarg) * 10); /* tenths of a dB */
 133                         break;
 134                 case 's':
 135                         samp_rate = (uint32_t)atof(optarg);
 136                         break;
 137                 case 'b':
 138                         out_block_size = (uint32_t)atof(optarg);
 139                         break;
 140                 case 'n':
 141                         bytes_to_read = (uint32_t)atof(optarg) * 2;
 142                         break;
 143                 case 'S':
 144                         sync_mode = 1;
 145                         break;
 146                 default:
 147                         usage();
 148                         break;
 149                 }
 150         }
 151
 152         if (argc <= optind) {
 153                 usage();
 154         } else {
 155                 filename = argv[optind];
 156         }
 157
 158         if(out_block_size < MINIMAL_BUF_LENGTH ||
 159            out_block_size > MAXIMAL_BUF_LENGTH ){
 160                 fprintf(stderr,
 161                         "Output block size wrong value, falling back to default\n");
 162                 fprintf(stderr,
 163                         "Minimal length: %u\n", MINIMAL_BUF_LENGTH);
 164                 fprintf(stderr,
 165                         "Maximal length: %u\n", MAXIMAL_BUF_LENGTH);
 166                 out_block_size = DEFAULT_BUF_LENGTH;
 167         }
 168
 169         buffer = malloc(out_block_size * sizeof(uint8_t));
 170
 171         device_count = rtlsdr_get_device_count();
 172         if (!device_count) {
 173                 fprintf(stderr, "No supported devices found.\n");
 174                 exit(1);
 175         }
 176
 177         fprintf(stderr, "Found %d device(s):\n", device_count);
 178         for (i = 0; i < device_count; i++) {
 179                 rtlsdr_get_device_usb_strings(i, vendor, product, serial);
 180                 fprintf(stderr, "  %d:  %s, %s, SN: %s\n", i, vendor, product, serial);
 181         }
 182         fprintf(stderr, "\n");
 183
 184         fprintf(stderr, "Using device %d: %s\n",
 185                 dev_index, rtlsdr_get_device_name(dev_index));
 186
 187         r = rtlsdr_open(&dev, dev_index);
 188         if (r < 0) {
 189                 fprintf(stderr, "Failed to open rtlsdr device #%d.\n", dev_index);
 190                 exit(1);
 191         }
 192 #ifndef _WIN32
 193         sigact.sa_handler = sighandler;
 194         sigemptyset(&sigact.sa_mask);
 195         sigact.sa_flags = 0;
 196         sigaction(SIGINT, &sigact, NULL);
 197         sigaction(SIGTERM, &sigact, NULL);
 198         sigaction(SIGQUIT, &sigact, NULL);
 199         sigaction(SIGPIPE, &sigact, NULL);
 200 #else
 201         SetConsoleCtrlHandler( (PHANDLER_ROUTINE) sighandler, TRUE );
 202 #endif
 203         /* Set the sample rate */
 204         r = rtlsdr_set_sample_rate(dev, samp_rate);
 205         if (r < 0)
 206                 fprintf(stderr, "WARNING: Failed to set sample rate.\n");
 207
 208         /* Set the frequency */
 209         r = rtlsdr_set_center_freq(dev, frequency);
 210         if (r < 0)
 211                 fprintf(stderr, "WARNING: Failed to set center freq.\n");
 212         else
 213                 fprintf(stderr, "Tuned to %u Hz.\n", frequency);
 214
 215         if (0 == gain) {
 216                  /* Enable automatic gain */
 217                 r = rtlsdr_set_tuner_gain_mode(dev, 0);
 218                 if (r < 0)
 219                         fprintf(stderr, "WARNING: Failed to enable automatic gain.\n");
 220         } else {
 221                 /* Enable manual gain */
 222                 r = rtlsdr_set_tuner_gain_mode(dev, 1);
 223                 if (r < 0)
 224                         fprintf(stderr, "WARNING: Failed to enable manual gain.\n");
 225
 226                 /* Set the tuner gain */
 227                 r = rtlsdr_set_tuner_gain(dev, gain);
 228                 if (r < 0)
 229                         fprintf(stderr, "WARNING: Failed to set tuner gain.\n");
 230                 else
 231                         fprintf(stderr, "Tuner gain set to %f dB.\n", gain/10.0);
 232         }
 233
 234         if(strcmp(filename, "-") == 0) { /* Write samples to stdout */
 235                 file = stdout;
 236 #ifdef _WIN32
 237                 _setmode(_fileno(stdin), _O_BINARY);
 238 #endif
 239         } else {
 240                 file = fopen(filename, "wb");
 241                 if (!file) {
 242                         fprintf(stderr, "Failed to open %s\n", filename);
 243                         goto out;
 244                 }
 245         }
 246
 247         /* Reset endpoint before we start reading from it (mandatory) */
 248         r = rtlsdr_reset_buffer(dev);
 249         if (r < 0)
 250                 fprintf(stderr, "WARNING: Failed to reset buffers.\n");
 251
 252         if (sync_mode) {
 253                 fprintf(stderr, "Reading samples in sync mode...\n");
 254                 while (!do_exit) {
 255                         r = rtlsdr_read_sync(dev, buffer, out_block_size, &n_read);
 256                         if (r < 0) {
 257                                 fprintf(stderr, "WARNING: sync read failed.\n");
 258                                 break;
 259                         }
 260
 261                         if ((bytes_to_read > 0) && (bytes_to_read < (uint32_t)n_read)) {
 262                                 n_read = bytes_to_read;
 263                                 do_exit = 1;
 264                         }
 265
 266                         if (fwrite(buffer, 1, n_read, file) != (size_t)n_read) {
 267                                 fprintf(stderr, "Short write, samples lost, exiting!\n");
 268                                 break;
 269                         }
 270
 271                         if ((uint32_t)n_read < out_block_size) {
 272                                 fprintf(stderr, "Short read, samples lost, exiting!\n");
 273                                 break;
 274                         }
 275
 276                         if (bytes_to_read > 0)
 277                                 bytes_to_read -= n_read;
 278                 }
 279         } else {
 280                 fprintf(stderr, "Reading samples in async mode...\n");
 281                 r = rtlsdr_read_async(dev, rtlsdr_callback, (void *)file,
 282                                       DEFAULT_ASYNC_BUF_NUMBER, out_block_size);
 283         }
 284
 285         if (do_exit)
 286                 fprintf(stderr, "\nUser cancel, exiting...\n");
 287         else
 288                 fprintf(stderr, "\nLibrary error %d, exiting...\n", r);
 289
 290         if (file != stdout)
 291                 fclose(file);
 292
 293         rtlsdr_close(dev);
 294         free (buffer);
 295 out:
 296         return r >= 0 ? r : -r;
 297 }