src/rtl_adsb.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  * Copyright (C) 2012 by Hoernchen <la@tfc-server.de>
   5  * Copyright (C) 2012 by Kyle Keen <keenerd@gmail.com>
   6  * Copyright (C) 2012 by Youssef Touil <youssef@sdrsharp.com>
   7  * Copyright (C) 2012 by Ian Gilmour <ian@sdrsharp.com>
   8  *
   9  * This program is free software: you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation, either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21  */
  22
  23
  24 #include <errno.h>
  25 #include <signal.h>
  26 #include <string.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <math.h>
  30
  31 #ifndef _WIN32
  32 #include <unistd.h>
  33 #else
  34 #include <Windows.h>
  35 #include <fcntl.h>
  36 #include <io.h>
  37 #include "getopt/getopt.h"
  38 #endif
  39
  40 #include <semaphore.h>
  41 #include <pthread.h>
  42 #include <libusb.h>
  43
  44 #include "rtl-sdr.h"
  45
  46 #ifdef _WIN32
  47 #define sleep Sleep
  48 #define round(x) (x > 0.0 ? floor(x + 0.5): ceil(x - 0.5))
  49 #endif
  50
  51 #define ADSB_RATE                       2000000
  52 #define ADSB_FREQ                       1090000000
  53 #define DEFAULT_ASYNC_BUF_NUMBER        12
  54 #define DEFAULT_BUF_LENGTH              (16 * 16384)
  55 #define AUTO_GAIN                       -100
  56
  57 static pthread_t demod_thread;
  58 static sem_t data_ready;
  59 static volatile int do_exit = 0;
  60 static rtlsdr_dev_t *dev = NULL;
  61
  62 /* look up table, could be made smaller */
  63 uint8_t pyth[129][129];
  64
  65 /* todo, bundle these up in a struct */
  66 uint8_t *buffer;
  67 int verbose_output = 0;
  68 int short_output = 0;
  69 double quality = 1.0;
  70 int allowed_errors = 5;
  71 FILE *file;
  72 int adsb_frame[14];
  73 #define preamble_len            16
  74 #define long_frame              112
  75 #define short_frame             56
  76
  77 void usage(void)
  78 {
  79         fprintf(stderr,
  80                 "rtl_adsb, a simple ADS-B decoder\n\n"
  81                 "Use:\trtl_adsb [-R] [-g gain] [-p ppm] [output file]\n"
  82                 "\t[-d device_index (default: 0)]\n"
  83                 "\t[-V verbove output (default: off)]\n"
  84                 "\t[-S show short frames (default: off)]\n"
  85                 "\t[-Q quality (0: no sanity checks, 0.5: half bit, 1: one bit (default), 2: two bits)]\n"
  86                 "\t[-e allowed_errors (default: 5)]\n"
  87                 "\t[-g tuner_gain (default: automatic)]\n"
  88                 "\t[-p ppm_error (default: 0)]\n"
  89                 "\tfilename (a '-' dumps samples to stdout)\n"
  90                 "\t (omitting the filename also uses stdout)\n\n"
  91                 "Streaming with netcat:\n"
  92                 "\trtl_adsb | netcat -lp 8080\n"
  93                 "\twhile true; do rtl_adsb | nc -lp 8080; done\n"
  94                 "Streaming with socat:\n"
  95                 "\trtl_adsb | socat -u - TCP4:sdrsharp.com:47806\n"
  96                 "\n");
  97         exit(1);
  98 }
  99
 100 #ifdef _WIN32
 101 BOOL WINAPI
 102 sighandler(int signum)
 103 {
 104         if (CTRL_C_EVENT == signum) {
 105                 fprintf(stderr, "Signal caught, exiting!\n");
 106                 do_exit = 1;
 107                 rtlsdr_cancel_async(dev);
 108                 return TRUE;
 109         }
 110         return FALSE;
 111 }
 112 #else
 113 static void sighandler(int signum)
 114 {
 115         fprintf(stderr, "Signal caught, exiting!\n");
 116         do_exit = 1;
 117         rtlsdr_cancel_async(dev);
 118 }
 119 #endif
 120
 121 void display(int *frame, int len)
 122 {
 123         int i, df;
 124         if (!short_output && len <= short_frame) {
 125                 return;}
 126         df = (frame[0] >> 3) & 0x1f;
 127         if (quality == 0.0 && !(df==11 || df==17 || df==18 || df==19)) {
 128                 return;}
 129         fprintf(file, "*");
 130         for (i=0; i<((len+7)/8); i++) {
 131                 fprintf(file, "%02x", frame[i]);}
 132         fprintf(file, ";\r\n");
 133         if (!verbose_output) {
 134                 return;}
 135         fprintf(file, "DF=%i CA=%i\n", df, frame[0] & 0x07);
 136         fprintf(file, "ICAO Address=%06x\n", frame[1] << 16 | frame[2] << 8 | frame[3]);
 137         if (len <= short_frame) {
 138                 return;}
 139         fprintf(file, "PI=0x%06x\n",  frame[11] << 16 | frame[12] << 8 | frame[13]);
 140         fprintf(file, "Type Code=%i S.Type/Ant.=%x\n", (frame[4] >> 3) & 0x1f, frame[4] & 0x07);
 141         fprintf(file, "--------------\n");
 142 }
 143
 144 void pyth_precompute(void)
 145 {
 146         int x, y;
 147         double scale = 1.408 ;  /* use the full 8 bits */
 148         for (x=0; x<129; x++) {
 149         for (y=0; y<129; y++) {
 150                 pyth[x][y] = (uint8_t)round(scale * sqrt(x*x + y*y));
 151         }}
 152 }
 153
 154 inline uint8_t abs8(uint8_t x)
 155 /* do not subtract 128 from the raw iq, this handles it */
 156 {
 157         if (x >= 128) {
 158                 return x - 128;}
 159         return 128 - x;
 160 }
 161
 162 int magnitute(uint8_t *buf, int len)
 163 /* takes i/q, changes buf in place, returns new len */
 164 {
 165         int i;
 166         for (i=0; i<len; i+=2) {
 167                 buf[i/2] = pyth[abs8(buf[i])][abs8(buf[i+1])];
 168         }
 169         return len/2;
 170 }
 171
 172 inline uint8_t single_manchester(uint8_t a, uint8_t b, uint8_t c, uint8_t d)
 173 /* takes 4 consecutive real samples, return 0 or 1, 255 on error */
 174 {
 175         int bit, bit_p;
 176         bit_p = a > b;
 177         bit   = c > d;
 178
 179         if (quality == 0.0) {
 180                 return bit;}
 181
 182         if (quality == 0.5) {
 183                 if ( bit &&  bit_p && b > c) {
 184                         return 255;}
 185                 if (!bit && !bit_p && b < c) {
 186                         return 255;}
 187                 return bit;
 188         }
 189
 190         if (quality == 1.0) {
 191                 if ( bit &&  bit_p && c > b) {
 192                         return 1;}
 193                 if ( bit && !bit_p && d < b) {
 194                         return 1;}
 195                 if (!bit &&  bit_p && d > b) {
 196                         return 0;}
 197                 if (!bit && !bit_p && c < b) {
 198                         return 0;}
 199                 return 255;
 200         }
 201
 202         if ( bit &&  bit_p && c > b && d < a) {
 203                 return 1;}
 204         if ( bit && !bit_p && c > a && d < b) {
 205                 return 1;}
 206         if (!bit &&  bit_p && c < a && d > b) {
 207                 return 0;}
 208         if (!bit && !bit_p && c < b && d > a) {
 209                 return 0;}
 210         return 255;
 211 }
 212
 213 inline uint8_t min8(uint8_t a, uint8_t b)
 214 {
 215         return a<b ? a : b;
 216 }
 217
 218 inline uint8_t max8(uint8_t a, uint8_t b)
 219 {
 220         return a>b ? a : b;
 221 }
 222
 223 inline int preamble(uint8_t *buf, int len, int i)
 224 /* returns 0/1 for preamble at index i */
 225 {
 226         int i2;
 227         uint8_t low  = 0;
 228         uint8_t high = 255;
 229         for (i2=0; i2<preamble_len; i2++) {
 230                 switch (i2) {
 231                         case 0:
 232                         case 2:
 233                         case 7:
 234                         case 9:
 235                                 //high = min8(high, buf[i+i2]);
 236                                 high = buf[i+i2];
 237                                 break;
 238                         default:
 239                                 //low  = max8(low,  buf[i+i2]);
 240                                 low = buf[i+i2];
 241                                 break;
 242                 }
 243                 if (high <= low) {
 244                         return 0;}
 245         }
 246         return 1;
 247 }
 248
 249 void manchester(uint8_t *buf, int len)
 250 /* overwrites magnitude buffer with valid bits (255 on errors) */
 251 {
 252         /* a and b hold old values to verify local manchester */
 253         uint8_t a=0, b=0;
 254         uint8_t bit;
 255         int i, i2, start, errors;
 256         // todo, allow wrap across buffers
 257         i = 0;
 258         while (i < len) {
 259                 /* find preamble */
 260                 for ( ; i < (len - preamble_len); i++) {
 261                         if (!preamble(buf, len, i)) {
 262                                 continue;}
 263                         a = buf[i];
 264                         b = buf[i+1];
 265                         for (i2=0; i2<preamble_len; i2++) {
 266                                 buf[i+i2] = 253;}
 267                         i += preamble_len;
 268                         break;
 269                 }
 270                 i2 = start = i;
 271                 errors = 0;
 272                 /* mark bits until encoding breaks */
 273                 for ( ; i < len; i+=2, i2++) {
 274                         bit = single_manchester(a, b, buf[i], buf[i+1]);
 275                         a = buf[i];
 276                         b = buf[i+1];
 277                         if (bit == 255) {
 278                                 errors += 1;
 279                                 if (errors > allowed_errors) {
 280                                         buf[i2] = 255;
 281                                         break;
 282                                 } else {
 283                                         bit = a > b;
 284                                         /* these don't have to match the bit */
 285                                         a = 0;
 286                                         b = 255;
 287                                 }
 288                         }
 289                         buf[i] = buf[i+1] = 254;  /* to be overwritten */
 290                         buf[i2] = bit;
 291                 }
 292         }
 293 }
 294
 295 void messages(uint8_t *buf, int len)
 296 {
 297         int i, i2, start, preamble_found;
 298         int data_i, index, shift, frame_len;
 299         // todo, allow wrap across buffers
 300         for (i=0; i<len; i++) {
 301                 if (buf[i] > 1) {
 302                         continue;}
 303                 frame_len = long_frame;
 304                 data_i = 0;
 305                 for (index=0; index<14; index++) {
 306                         adsb_frame[index] = 0;}
 307                 for(; i<len && buf[i]<=1 && data_i<frame_len; i++, data_i++) {
 308                         if (buf[i]) {
 309                                 index = data_i / 8;
 310                                 shift = 7 - (data_i % 8);
 311                                 adsb_frame[index] |= (uint8_t)(1<<shift);
 312                         }
 313                         if (data_i == 7) {
 314                                 if (adsb_frame[0] == 0) {
 315                                     break;}
 316                                 if (adsb_frame[0] & 0x80) {
 317                                         frame_len = long_frame;}
 318                                 else {
 319                                         frame_len = short_frame;}
 320                         }
 321                 }
 322                 if (data_i < (frame_len-1)) {
 323                         continue;}
 324                 display(adsb_frame, frame_len);
 325                 fflush(file);
 326         }
 327 }
 328
 329 static void rtlsdr_callback(unsigned char *buf, uint32_t len, void *ctx)
 330 {
 331         int dr_val;
 332         if (do_exit) {
 333                 return;}
 334         memcpy(buffer, buf, len);
 335         sem_getvalue(&data_ready, &dr_val);
 336         if (dr_val <= 0) {
 337                 sem_post(&data_ready);}
 338 }
 339
 340 static void *demod_thread_fn(void *arg)
 341 {
 342         int len;
 343         while (!do_exit) {
 344                 sem_wait(&data_ready);
 345                 len = magnitute(buffer, DEFAULT_BUF_LENGTH);
 346                 manchester(buffer, len);
 347                 messages(buffer, len);
 348         }
 349         rtlsdr_cancel_async(dev);
 350         return 0;
 351 }
 352
 353 int main(int argc, char **argv)
 354 {
 355 #ifndef _WIN32
 356         struct sigaction sigact;
 357 #endif
 358         char *filename = NULL;
 359         int n_read, r, opt;
 360         int i, gain = AUTO_GAIN; /* tenths of a dB */
 361         uint32_t dev_index = 0;
 362         int device_count;
 363         int ppm_error = 0;
 364         char vendor[256], product[256], serial[256];
 365         sem_init(&data_ready, 0, 0);
 366         pyth_precompute();
 367
 368         while ((opt = getopt(argc, argv, "d:g:p:e:Q:VS")) != -1)
 369         {
 370                 switch (opt) {
 371                 case 'd':
 372                         dev_index = atoi(optarg);
 373                         break;
 374                 case 'g':
 375                         gain = (int)(atof(optarg) * 10);
 376                         break;
 377                 case 'p':
 378                         ppm_error = atoi(optarg);
 379                         break;
 380                 case 'V':
 381                         verbose_output = 1;
 382                         break;
 383                 case 'S':
 384                         short_output = 1;
 385                         break;
 386                 case 'e':
 387                         allowed_errors = atoi(optarg);
 388                         break;
 389                 case 'Q':
 390                         quality = atof(optarg);
 391                         break;
 392                 default:
 393                         usage();
 394                         return 0;
 395                 }
 396         }
 397
 398         if (argc <= optind) {
 399                 filename = "-";
 400         } else {
 401                 filename = argv[optind];
 402         }
 403
 404         buffer = malloc(DEFAULT_BUF_LENGTH * sizeof(uint8_t));
 405
 406         device_count = rtlsdr_get_device_count();
 407         if (!device_count) {
 408                 fprintf(stderr, "No supported devices found.\n");
 409                 exit(1);
 410         }
 411
 412         fprintf(stderr, "Found %d device(s):\n", device_count);
 413         for (i = 0; i < device_count; i++) {
 414                 rtlsdr_get_device_usb_strings(i, vendor, product, serial);
 415                 fprintf(stderr, "  %d:  %s, %s, SN: %s\n", i, vendor, product, serial);
 416         }
 417         fprintf(stderr, "\n");
 418
 419         fprintf(stderr, "Using device %d: %s\n",
 420                 dev_index, rtlsdr_get_device_name(dev_index));
 421
 422         r = rtlsdr_open(&dev, dev_index);
 423         if (r < 0) {
 424                 fprintf(stderr, "Failed to open rtlsdr device #%d.\n", dev_index);
 425                 exit(1);
 426         }
 427 #ifndef _WIN32
 428         sigact.sa_handler = sighandler;
 429         sigemptyset(&sigact.sa_mask);
 430         sigact.sa_flags = 0;
 431         sigaction(SIGINT, &sigact, NULL);
 432         sigaction(SIGTERM, &sigact, NULL);
 433         sigaction(SIGQUIT, &sigact, NULL);
 434         sigaction(SIGPIPE, &sigact, NULL);
 435 #else
 436         SetConsoleCtrlHandler( (PHANDLER_ROUTINE) sighandler, TRUE );
 437 #endif
 438
 439         if (strcmp(filename, "-") == 0) { /* Write samples to stdout */
 440                 file = stdout;
 441                 setvbuf(stdout, NULL, _IONBF, 0);
 442 #ifdef _WIN32
 443                 _setmode(_fileno(file), _O_BINARY);
 444 #endif
 445         } else {
 446                 file = fopen(filename, "wb");
 447                 if (!file) {
 448                         fprintf(stderr, "Failed to open %s\n", filename);
 449                         exit(1);
 450                 }
 451         }
 452
 453         /* Set the tuner gain */
 454         if (gain == AUTO_GAIN) {
 455                 r = rtlsdr_set_tuner_gain_mode(dev, 0);
 456         } else {
 457                 r = rtlsdr_set_tuner_gain_mode(dev, 1);
 458                 r = rtlsdr_set_tuner_gain(dev, gain);
 459         }
 460         if (r != 0) {
 461                 fprintf(stderr, "WARNING: Failed to set tuner gain.\n");
 462         } else if (gain == AUTO_GAIN) {
 463                 fprintf(stderr, "Tuner gain set to automatic.\n");
 464         } else {
 465                 fprintf(stderr, "Tuner gain set to %0.2f dB.\n", gain/10.0);
 466         }
 467
 468         r = rtlsdr_set_freq_correction(dev, ppm_error);
 469         r = rtlsdr_set_agc_mode(dev, 1);
 470
 471         /* Set the tuner frequency */
 472         r = rtlsdr_set_center_freq(dev, ADSB_FREQ);
 473         if (r < 0) {
 474                 fprintf(stderr, "WARNING: Failed to set center freq.\n");}
 475         else {
 476                 fprintf(stderr, "Tuned to %u Hz.\n", ADSB_FREQ);}
 477
 478         /* Set the sample rate */
 479         fprintf(stderr, "Sampling at %u Hz.\n", ADSB_RATE);
 480         r = rtlsdr_set_sample_rate(dev, ADSB_RATE);
 481         if (r < 0) {
 482                 fprintf(stderr, "WARNING: Failed to set sample rate.\n");}
 483
 484         /* Reset endpoint before we start reading from it (mandatory) */
 485         r = rtlsdr_reset_buffer(dev);
 486         if (r < 0) {
 487                 fprintf(stderr, "WARNING: Failed to reset buffers.\n");}
 488
 489         /* flush old junk */
 490         sleep(1);
 491         rtlsdr_read_sync(dev, NULL, 4096, NULL);
 492
 493         pthread_create(&demod_thread, NULL, demod_thread_fn, (void *)(NULL));
 494         rtlsdr_read_async(dev, rtlsdr_callback, (void *)(NULL),
 495                               DEFAULT_ASYNC_BUF_NUMBER,
 496                               DEFAULT_BUF_LENGTH);
 497
 498
 499         if (do_exit) {
 500                 fprintf(stderr, "\nUser cancel, exiting...\n");}
 501         else {
 502                 fprintf(stderr, "\nLibrary error %d, exiting...\n", r);}
 503         rtlsdr_cancel_async(dev);
 504
 505         if (file != stdout) {
 506                 fclose(file);}
 507
 508         rtlsdr_close(dev);
 509         free(buffer);
 510         return r >= 0 ? r : -r;
 511 }
 512