fa5462868a208773cf73e6606dbb748224f74d32
[rtl-433.git] / src / rtl_test.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 #include <math.h>
25
26 #ifdef __APPLE__
27 #include <sys/time.h>
28 #else
29 #include <time.h>
30 #endif
31
32 #ifndef _WIN32
33 #include <unistd.h>
34 #else
35 #include <Windows.h>
36 #include "getopt/getopt.h"
37 #endif
38
39 #include "rtl-sdr.h"
40
41 #define DEFAULT_SAMPLE_RATE             2048000
42 #define DEFAULT_ASYNC_BUF_NUMBER        32
43 #define DEFAULT_BUF_LENGTH              (16 * 16384)
44 #define MINIMAL_BUF_LENGTH              512
45 #define MAXIMAL_BUF_LENGTH              (256 * 16384)
46
47 #define MHZ(x)  ((x)*1000*1000)
48
49 #define PPM_DURATION                    10
50
51 static int do_exit = 0;
52 static rtlsdr_dev_t *dev = NULL;
53
54 static int ppm_benchmark = 0;
55 static int64_t ppm_count = 0L;
56 static int64_t ppm_total = 0L;
57
58 #ifndef _WIN32
59 static struct timespec ppm_start;
60 static struct timespec ppm_recent;
61 static struct timespec ppm_now;
62 #endif
63
64 #ifdef __APPLE__
65 static struct timeval tv;
66 #endif
67
68 void usage(void)
69 {
70         fprintf(stderr,
71                 "rtl_test, a benchmark tool for RTL2832 based DVB-T receivers\n\n"
72                 "Usage:\n"
73                 "\t[-s samplerate (default: 2048000 Hz)]\n"
74                 "\t[-d device_index (default: 0)]\n"
75                 "\t[-t enable Elonics E4000 tuner benchmark]\n"
76                 #ifndef _WIN32
77                 "\t[-p enable PPM error measurement]\n"
78                 #endif
79                 "\t[-b output_block_size (default: 16 * 16384)]\n"
80                 "\t[-S force sync output (default: async)]\n");
81         exit(1);
82 }
83
84 #ifdef _WIN32
85 BOOL WINAPI
86 sighandler(int signum)
87 {
88         if (CTRL_C_EVENT == signum) {
89                 fprintf(stderr, "Signal caught, exiting!\n");
90                 do_exit = 1;
91                 rtlsdr_cancel_async(dev);
92                 return TRUE;
93         }
94         return FALSE;
95 }
96 #else
97 static void sighandler(int signum)
98 {
99         fprintf(stderr, "Signal caught, exiting!\n");
100         do_exit = 1;
101         rtlsdr_cancel_async(dev);
102 }
103 #endif
104
105 uint8_t bcnt, uninit = 1;
106
107 static void rtlsdr_callback(unsigned char *buf, uint32_t len, void *ctx)
108 {
109         uint32_t i, lost = 0;
110         int64_t ns;
111
112         if (uninit) {
113                 bcnt = buf[0];
114                 uninit = 0;
115         }
116
117         for (i = 0; i < len; i++) {
118                 if(bcnt != buf[i]) {
119                         lost += (buf[i] > bcnt) ? (buf[i] - bcnt) : (bcnt - buf[i]);
120                         bcnt = buf[i];
121                 }
122
123                 bcnt++;
124         }
125
126         if (lost)
127                 printf("lost at least %d bytes\n", lost);
128
129         if (!ppm_benchmark) {
130                 return;
131         }
132         ppm_count += (int64_t)len;
133 #ifndef _WIN32
134         #ifndef __APPLE__
135         clock_gettime(CLOCK_REALTIME, &ppm_now);
136         #else
137         gettimeofday(&tv, NULL);
138         ppm_now.tv_sec = tv.tv_sec;
139         ppm_now.tv_nsec = tv.tv_usec*1000;
140         #endif
141         if (ppm_now.tv_sec - ppm_recent.tv_sec > PPM_DURATION) {
142                 ns = 1000000000L * (int64_t)(ppm_now.tv_sec - ppm_recent.tv_sec);
143                 ns += (int64_t)(ppm_now.tv_nsec - ppm_recent.tv_nsec);
144                 printf("real sample rate: %i\n",
145                 (int)((1000000000L * ppm_count / 2L) / ns));
146                 #ifndef __APPLE__
147                 clock_gettime(CLOCK_REALTIME, &ppm_recent);
148                 #else
149                 gettimeofday(&tv, NULL);
150                 ppm_recent.tv_sec = tv.tv_sec;
151                 ppm_recent.tv_nsec = tv.tv_usec*1000;
152                 #endif
153                 ppm_total += ppm_count / 2L;
154                 ppm_count = 0L;
155         }
156 #endif
157 }
158
159 void e4k_benchmark(void)
160 {
161         uint32_t freq, gap_start = 0, gap_end = 0;
162         uint32_t range_start = 0, range_end = 0;
163
164         fprintf(stderr, "Benchmarking E4000 PLL...\n");
165
166         /* find tuner range start */
167         for (freq = MHZ(70); freq > MHZ(1); freq -= MHZ(1)) {
168                 if (rtlsdr_set_center_freq(dev, freq) < 0) {
169                         range_start = freq;
170                         break;
171                 }
172         }
173
174         /* find tuner range end */
175         for (freq = MHZ(2000); freq < MHZ(2300UL); freq += MHZ(1)) {
176                 if (rtlsdr_set_center_freq(dev, freq) < 0) {
177                         range_end = freq;
178                         break;
179                 }
180         }
181
182         /* find start of L-band gap */
183         for (freq = MHZ(1000); freq < MHZ(1300); freq += MHZ(1)) {
184                 if (rtlsdr_set_center_freq(dev, freq) < 0) {
185                         gap_start = freq;
186                         break;
187                 }
188         }
189
190         /* find end of L-band gap */
191         for (freq = MHZ(1300); freq > MHZ(1000); freq -= MHZ(1)) {
192                 if (rtlsdr_set_center_freq(dev, freq) < 0) {
193                         gap_end = freq;
194                         break;
195                 }
196         }
197
198         fprintf(stderr, "E4K range: %i to %i MHz\n",
199                 range_start/MHZ(1) + 1, range_end/MHZ(1) - 1);
200
201         fprintf(stderr, "E4K L-band gap: %i to %i MHz\n",
202                 gap_start/MHZ(1), gap_end/MHZ(1));
203 }
204
205 int main(int argc, char **argv)
206 {
207 #ifndef _WIN32
208         struct sigaction sigact;
209 #endif
210         int n_read;
211         int r, opt;
212         int i, tuner_benchmark = 0;
213         int sync_mode = 0;
214         uint8_t *buffer;
215         uint32_t dev_index = 0;
216         uint32_t samp_rate = DEFAULT_SAMPLE_RATE;
217         uint32_t out_block_size = DEFAULT_BUF_LENGTH;
218         int device_count;
219         int count;
220         int gains[100];
221         int real_rate;
222         int64_t ns;
223
224         while ((opt = getopt(argc, argv, "d:s:b:tpS::")) != -1) {
225                 switch (opt) {
226                 case 'd':
227                         dev_index = atoi(optarg);
228                         break;
229                 case 's':
230                         samp_rate = (uint32_t)atof(optarg);
231                         break;
232                 case 'b':
233                         out_block_size = (uint32_t)atof(optarg);
234                         break;
235                 case 't':
236                         tuner_benchmark = 1;
237                         break;
238                 case 'p':
239                         ppm_benchmark = PPM_DURATION;
240                         break;
241                 case 'S':
242                         sync_mode = 1;
243                         break;
244                 default:
245                         usage();
246                         break;
247                 }
248         }
249
250         if(out_block_size < MINIMAL_BUF_LENGTH ||
251            out_block_size > MAXIMAL_BUF_LENGTH ){
252                 fprintf(stderr,
253                         "Output block size wrong value, falling back to default\n");
254                 fprintf(stderr,
255                         "Minimal length: %u\n", MINIMAL_BUF_LENGTH);
256                 fprintf(stderr,
257                         "Maximal length: %u\n", MAXIMAL_BUF_LENGTH);
258                 out_block_size = DEFAULT_BUF_LENGTH;
259         }
260
261         buffer = malloc(out_block_size * sizeof(uint8_t));
262
263         device_count = rtlsdr_get_device_count();
264         if (!device_count) {
265                 fprintf(stderr, "No supported devices found.\n");
266                 exit(1);
267         }
268
269         fprintf(stderr, "Found %d device(s):\n", device_count);
270         for (i = 0; i < device_count; i++)
271                 fprintf(stderr, "  %d:  %s\n", i, rtlsdr_get_device_name(i));
272         fprintf(stderr, "\n");
273
274         fprintf(stderr, "Using device %d: %s\n",
275                 dev_index,
276                 rtlsdr_get_device_name(dev_index));
277
278         r = rtlsdr_open(&dev, dev_index);
279         if (r < 0) {
280                 fprintf(stderr, "Failed to open rtlsdr device #%d.\n", dev_index);
281                 exit(1);
282         }
283 #ifndef _WIN32
284         sigact.sa_handler = sighandler;
285         sigemptyset(&sigact.sa_mask);
286         sigact.sa_flags = 0;
287         sigaction(SIGINT, &sigact, NULL);
288         sigaction(SIGTERM, &sigact, NULL);
289         sigaction(SIGQUIT, &sigact, NULL);
290         sigaction(SIGPIPE, &sigact, NULL);
291 #else
292         SetConsoleCtrlHandler( (PHANDLER_ROUTINE) sighandler, TRUE );
293 #endif
294         count = rtlsdr_get_tuner_gains(dev, NULL);
295         fprintf(stderr, "Supported gain values (%d): ", count);
296
297         count = rtlsdr_get_tuner_gains(dev, gains);
298         for (i = 0; i < count; i++)
299                 fprintf(stderr, "%.1f ", gains[i] / 10.0);
300         fprintf(stderr, "\n");
301
302         /* Set the sample rate */
303         r = rtlsdr_set_sample_rate(dev, samp_rate);
304         if (r < 0)
305                 fprintf(stderr, "WARNING: Failed to set sample rate.\n");
306
307         if (tuner_benchmark) {
308                 if (rtlsdr_get_tuner_type(dev) == RTLSDR_TUNER_E4000)
309                         e4k_benchmark();
310                 else
311                         fprintf(stderr, "No E4000 tuner found, aborting.\n");
312
313                 goto exit;
314         }
315
316         /* Enable test mode */
317         r = rtlsdr_set_testmode(dev, 1);
318
319         /* Reset endpoint before we start reading from it (mandatory) */
320         r = rtlsdr_reset_buffer(dev);
321         if (r < 0)
322                 fprintf(stderr, "WARNING: Failed to reset buffers.\n");
323
324         if (ppm_benchmark && !sync_mode) {
325                 fprintf(stderr, "Reporting PPM error measurement every %i seconds...\n", ppm_benchmark);
326                 fprintf(stderr, "Press ^C after a few minutes.\n");
327 #ifdef __APPLE__
328                 gettimeofday(&tv, NULL);
329                 ppm_recent.tv_sec = tv.tv_sec;
330                 ppm_recent.tv_nsec = tv.tv_usec*1000;
331                 ppm_start.tv_sec = tv.tv_sec;
332                 ppm_start.tv_nsec = tv.tv_usec*1000;
333 #elif __unix__
334                 clock_gettime(CLOCK_REALTIME, &ppm_recent);
335                 clock_gettime(CLOCK_REALTIME, &ppm_start);
336 #endif
337         }
338
339         if (sync_mode) {
340                 fprintf(stderr, "Reading samples in sync mode...\n");
341                 while (!do_exit) {
342                         r = rtlsdr_read_sync(dev, buffer, out_block_size, &n_read);
343                         if (r < 0) {
344                                 fprintf(stderr, "WARNING: sync read failed.\n");
345                                 break;
346                         }
347
348                         if ((uint32_t)n_read < out_block_size) {
349                                 fprintf(stderr, "Short read, samples lost, exiting!\n");
350                                 break;
351                         }
352                 }
353         } else {
354                 fprintf(stderr, "Reading samples in async mode...\n");
355                 r = rtlsdr_read_async(dev, rtlsdr_callback, NULL,
356                                       DEFAULT_ASYNC_BUF_NUMBER, out_block_size);
357         }
358
359         if (do_exit) {
360                 fprintf(stderr, "\nUser cancel, exiting...\n");
361                 if (ppm_benchmark) {
362 #ifndef _WIN32
363                         ns = 1000000000L * (int64_t)(ppm_recent.tv_sec - ppm_start.tv_sec);
364                         ns += (int64_t)(ppm_recent.tv_nsec - ppm_start.tv_nsec);
365                         real_rate = (int)(ppm_total * 1000000000L / ns);
366                         printf("Cumulative PPM error: %i\n",
367                         (int)round((double)(1000000 * (real_rate - (int)samp_rate)) / (double)samp_rate));
368 #endif
369                 }
370         }
371         else
372                 fprintf(stderr, "\nLibrary error %d, exiting...\n", r);
373
374 exit:
375         rtlsdr_close(dev);
376         free (buffer);
377
378         return r >= 0 ? r : -r;
379 }