src/rtl_433.c~

   1 /*
   2  * rtl_433, turns your Realtek RTL2832 based DVB dongle into a 433.92MHz generic data receiver
   3  * Copyright (C) 2012 by Benjamin Larsson <benjamin@southpole.se>
   4  *
   5  * Based on rtl_sdr
   6  *
   7  * Copyright (C) 2012 by Steve Markgraf <steve@steve-m.de>
   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 #include "rtl-sdr.h"
  24 #include "rtl_433.h"
  25 #include "rtl_433_devices.h"
  26
  27 static int do_exit = 0;
  28 static int do_exit_async = 0, frequencies = 0, events = 0;
  29 uint32_t frequency[MAX_PROTOCOLS];
  30 time_t rawtime_old;
  31 int flag;
  32 uint32_t samp_rate = DEFAULT_SAMPLE_RATE;
  33 static uint32_t bytes_to_read = 0;
  34 static rtlsdr_dev_t *dev = NULL;
  35 static uint16_t scaled_squares[256];
  36 static int override_short = 0;
  37 static int override_long = 0;
  38 int debug_output = 0;
  39
  40 int debug_callback(uint8_t bb[BITBUF_ROWS][BITBUF_COLS], int16_t bits_per_row[BITBUF_ROWS]) {
  41     int i,j,k;
  42     int rows_used[BITBUF_ROWS];
  43     int col_max = 0;
  44     int row_cnt = 0;
  45
  46     // determine what part of bb[][] has non-zero data to avoid
  47     // outputting lots of empty rows
  48     for (i=0 ; i<BITBUF_ROWS ; i++) {
  49         for (j=BITBUF_COLS - 1 ; j > 0 ; j--) {
  50             if (bb[i][j] != 0)
  51                 break;
  52         }
  53         if (j != 0) {
  54             rows_used[i] = 1;
  55             row_cnt++;
  56             if (j > col_max)
  57                 col_max = j;
  58         } else {
  59             rows_used[i] = 0;
  60         }
  61     }
  62
  63     if (!row_cnt) {
  64         fprintf(stderr, "debug_callback: empty data array\n");
  65         return 0;
  66     }
  67
  68     fprintf(stderr, "\n");
  69     for (i=0 ; i<BITBUF_ROWS ; i++) {
  70         if (!rows_used[i]) {
  71             continue;
  72         }
  73
  74         fprintf(stderr, "[%02d] ",i);
  75         for (j=0 ; j<=col_max ; j++) {
  76             fprintf(stderr, "%02x ", bb[i][j]);
  77         }
  78         fprintf(stderr, ": ");
  79         for (j=0 ; j<=col_max ; j++) {
  80             for (k=7 ; k>=0 ; k--) {
  81                 if (bb[i][j] & 1<<k)
  82                     fprintf(stderr, "1");
  83                 else
  84                     fprintf(stderr, "0");
  85             }
  86             fprintf(stderr, " ");
  87         }
  88         fprintf(stderr, "\n");
  89     }
  90     fprintf(stderr, "\n");
  91
  92     return 0;
  93 }
  94
  95 struct protocol_state {
  96     int (*callback)(uint8_t bits_buffer[BITBUF_ROWS][BITBUF_COLS], int16_t bits_per_row[BITBUF_ROWS]);
  97
  98     /* bits state */
  99     int bits_col_idx;
 100     int bits_row_idx;
 101     int bits_bit_col_idx;
 102     uint8_t bits_buffer[BITBUF_ROWS][BITBUF_COLS];
 103     int16_t bits_per_row[BITBUF_ROWS];
 104     int bit_rows;
 105     unsigned int modulation;
 106
 107     /* demod state */
 108     int pulse_length;
 109     int pulse_count;
 110     int pulse_distance;
 111     int sample_counter;
 112     int start_c;
 113
 114     int packet_present;
 115     int pulse_start;
 116     int real_bits;
 117     int start_bit;
 118     /* pwm limits */
 119     int short_limit;
 120     int long_limit;
 121     int reset_limit;
 122
 123
 124 };
 125
 126 struct dm_state {
 127     FILE *file;
 128     int save_data;
 129     int32_t level_limit;
 130     int32_t decimation_level;
 131     int16_t filter_buffer[MAXIMAL_BUF_LENGTH + FILTER_ORDER];
 132     int16_t* f_buf;
 133     int analyze;
 134     int debug_mode;
 135
 136     /* Signal grabber variables */
 137     int signal_grabber;
 138     int8_t* sg_buf;
 139     int sg_index;
 140     int sg_len;
 141
 142
 143     /* Protocol states */
 144     int r_dev_num;
 145     struct protocol_state *r_devs[MAX_PROTOCOLS];
 146
 147 };
 148
 149 void usage(void) {
 150     fprintf(stderr,
 151             "rtl_433, an ISM band generic data receiver for RTL2832 based DVB-T receivers\n\n"
 152             "Usage:\t[-d device_index (default: 0)]\n"
 153             "\t[-g gain (default: 0 for auto)]\n"
 154             "\t[-a analyze mode, print a textual description of the signal]\n"
 155             "\t[-t signal auto save, use it together with analyze mode (-a -t)\n"
 156             "\t[-l change the detection level used to determine pulses (0-3200) default: %i]\n"
 157             "\t[-f [-f...] receive frequency[s], default: %i Hz]\n"
 158             "\t[-s samplerate (default: %i Hz)]\n"
 159             "\t[-S force sync output (default: async)]\n"
 160             "\t[-r read data from file instead of from a receiver]\n"
 161             "\t[-p ppm_error (default: 0)]\n"
 162             "\t[-r test file name (indata)]\n"
 163             "\t[-m test file mode (0 rtl_sdr data, 1 rtl_433 data)]\n"
 164             "\t[-D print debug info on event\n"
 165             "\t[-z override short value\n"
 166             "\t[-x override long value\n"
 167             "\tfilename (a '-' dumps samples to stdout)\n\n", DEFAULT_LEVEL_LIMIT, DEFAULT_FREQUENCY, DEFAULT_SAMPLE_RATE);
 168     exit(1);
 169 }
 170
 171 #ifdef _WIN32
 172 BOOL WINAPI
 173 sighandler(int signum) {
 174     if (CTRL_C_EVENT == signum) {
 175         fprintf(stderr, "Signal caught, exiting!\n");
 176         do_exit = 1;
 177         rtlsdr_cancel_async(dev);
 178         return TRUE;
 179     }
 180     return FALSE;
 181 }
 182 #else
 183 static void sighandler(int signum) {
 184     if (signum == SIGPIPE) {
 185         signal(SIGPIPE,SIG_IGN);
 186     } else {
 187         fprintf(stderr, "Signal caught, exiting!\n");
 188     }
 189     do_exit = 1;
 190     rtlsdr_cancel_async(dev);
 191 }
 192 #endif
 193
 194 /* precalculate lookup table for envelope detection */
 195 static void calc_squares() {
 196     int i;
 197     for (i = 0; i < 256; i++)
 198         scaled_squares[i] = (128 - i) * (128 - i);
 199 }
 200
 201 /** This will give a noisy envelope of OOK/ASK signals
 202  *  Subtract the bias (-128) and get an envelope estimation
 203  *  The output will be written in the input buffer
 204  *  @returns   pointer to the input buffer
 205  */
 206
 207 static void envelope_detect(unsigned char *buf, uint32_t len, int decimate) {
 208     uint16_t* sample_buffer = (uint16_t*) buf;
 209     unsigned int i;
 210     unsigned op = 0;
 211     unsigned int stride = 1 << decimate;
 212
 213     for (i = 0; i < len / 2; i += stride) {
 214         sample_buffer[op++] = scaled_squares[buf[2 * i ]] + scaled_squares[buf[2 * i + 1]];
 215     }
 216 }
 217
 218 static void demod_reset_bits_packet(struct protocol_state* p) {
 219     memset(p->bits_buffer, 0, BITBUF_ROWS * BITBUF_COLS);
 220     memset(p->bits_per_row, 0, BITBUF_ROWS);
 221     p->bits_col_idx = 0;
 222     p->bits_bit_col_idx = 7;
 223     p->bits_row_idx = 0;
 224     p->bit_rows = 0;
 225 }
 226
 227 static void demod_add_bit(struct protocol_state* p, int bit) {
 228     p->bits_buffer[p->bits_row_idx][p->bits_col_idx] |= bit << p->bits_bit_col_idx;
 229     p->bits_bit_col_idx--;
 230     if (p->bits_bit_col_idx < 0) {
 231         p->bits_bit_col_idx = 7;
 232         p->bits_col_idx++;
 233         if (p->bits_col_idx > BITBUF_COLS - 1) {
 234             p->bits_col_idx = BITBUF_COLS - 1;
 235             //            fprintf(stderr, "p->bits_col_idx>%i!\n", BITBUF_COLS-1);
 236         }
 237     }
 238     p->bits_per_row[p->bit_rows]++;
 239 }
 240
 241 static void demod_next_bits_packet(struct protocol_state* p) {
 242     p->bits_col_idx = 0;
 243     p->bits_row_idx++;
 244     p->bits_bit_col_idx = 7;
 245     if (p->bits_row_idx > BITBUF_ROWS - 1) {
 246         p->bits_row_idx = BITBUF_ROWS - 1;
 247         //fprintf(stderr, "p->bits_row_idx>%i!\n", BITBUF_ROWS-1);
 248     }
 249     p->bit_rows++;
 250     if (p->bit_rows > BITBUF_ROWS - 1)
 251         p->bit_rows -= 1;
 252 }
 253
 254 static void demod_print_bits_packet(struct protocol_state* p) {
 255     int i, j, k;
 256
 257     fprintf(stderr, "\n");
 258     for (i = 0; i < p->bit_rows + 1; i++) {
 259         fprintf(stderr, "[%02d] {%d} ", i, p->bits_per_row[i]);
 260         for (j = 0; j < ((p->bits_per_row[i] + 8) / 8); j++) {
 261             fprintf(stderr, "%02x ", p->bits_buffer[i][j]);
 262         }
 263         fprintf(stderr, ": ");
 264         for (j = 0; j < ((p->bits_per_row[i] + 8) / 8); j++) {
 265             for (k = 7; k >= 0; k--) {
 266                 if (p->bits_buffer[i][j] & 1 << k)
 267                     fprintf(stderr, "1");
 268                 else
 269                     fprintf(stderr, "0");
 270             }
 271             //            fprintf(stderr, "=0x%x ",demod->bits_buffer[i][j]);
 272             fprintf(stderr, " ");
 273         }
 274         fprintf(stderr, "\n");
 275     }
 276     fprintf(stderr, "\n");
 277     return;
 278 }
 279
 280 static void register_protocol(struct dm_state *demod, r_device *t_dev) {
 281     struct protocol_state *p = calloc(1, sizeof (struct protocol_state));
 282     p->short_limit = (float) t_dev->short_limit / ((float) DEFAULT_SAMPLE_RATE / (float) samp_rate);
 283     p->long_limit = (float) t_dev->long_limit / ((float) DEFAULT_SAMPLE_RATE / (float) samp_rate);
 284     p->reset_limit = (float) t_dev->reset_limit / ((float) DEFAULT_SAMPLE_RATE / (float) samp_rate);
 285     p->modulation = t_dev->modulation;
 286     p->callback = t_dev->json_callback;
 287     demod_reset_bits_packet(p);
 288
 289     demod->r_devs[demod->r_dev_num] = p;
 290     demod->r_dev_num++;
 291
 292     fprintf(stderr, "Registering protocol[%02d] %s\n", demod->r_dev_num, t_dev->name);
 293
 294     if (demod->r_dev_num > MAX_PROTOCOLS)
 295         fprintf(stderr, "Max number of protocols reached %d\n", MAX_PROTOCOLS);
 296 }
 297
 298
 299 static unsigned int counter = 0;
 300 static unsigned int print = 1;
 301 static unsigned int print2 = 0;
 302 static unsigned int pulses_found = 0;
 303 static unsigned int prev_pulse_start = 0;
 304 static unsigned int pulse_start = 0;
 305 static unsigned int pulse_end = 0;
 306 static unsigned int pulse_avg = 0;
 307 static unsigned int signal_start = 0;
 308 static unsigned int signal_end = 0;
 309 static unsigned int signal_pulse_data[4000][3] = {
 310     {0}};
 311 static unsigned int signal_pulse_counter = 0;
 312
 313 static void classify_signal() {
 314     unsigned int i, k, max = 0, min = 1000000, t;
 315     unsigned int delta, count_min, count_max, min_new, max_new, p_limit;
 316     unsigned int a[3], b[2], a_cnt[3], a_new[3], b_new[2];
 317     unsigned int signal_distance_data[4000] = {0};
 318     struct protocol_state p = {0};
 319     unsigned int signal_type;
 320
 321     if (!signal_pulse_data[0][0])
 322         return;
 323
 324     for (i = 0; i < 1000; i++) {
 325         if (signal_pulse_data[i][0] > 0) {
 326             //fprintf(stderr, "[%03d] s: %d\t  e:\t %d\t l:%d\n",
 327             //i, signal_pulse_data[i][0], signal_pulse_data[i][1],
 328             //signal_pulse_data[i][2]);
 329             if (signal_pulse_data[i][2] > max)
 330                 max = signal_pulse_data[i][2];
 331             if (signal_pulse_data[i][2] <= min)
 332                 min = signal_pulse_data[i][2];
 333         }
 334     }
 335     t = (max + min) / 2;
 336     //fprintf(stderr, "\n\nMax: %d, Min: %d  t:%d\n", max, min, t);
 337
 338     delta = (max - min)*(max - min);
 339
 340     //TODO use Lloyd-Max quantizer instead
 341     k = 1;
 342     while ((k < 10) && (delta > 0)) {
 343         min_new = 0;
 344         count_min = 0;
 345         max_new = 0;
 346         count_max = 0;
 347
 348         for (i = 0; i < 1000; i++) {
 349             if (signal_pulse_data[i][0] > 0) {
 350                 if (signal_pulse_data[i][2] < t) {
 351                     min_new = min_new + signal_pulse_data[i][2];
 352                     count_min++;
 353                 } else {
 354                     max_new = max_new + signal_pulse_data[i][2];
 355                     count_max++;
 356                 }
 357             }
 358         }
 359         if (count_min != 0 && count_max != 0) {
 360             min_new = min_new / count_min;
 361             max_new = max_new / count_max;
 362         }
 363
 364         delta = (min - min_new)*(min - min_new) + (max - max_new)*(max - max_new);
 365         min = min_new;
 366         max = max_new;
 367         t = (min + max) / 2;
 368
 369         fprintf(stderr, "Iteration %d. t: %d    min: %d (%d)    max: %d (%d)    delta %d\n", k, t, min, count_min, max, count_max, delta);
 370         k++;
 371     }
 372
 373     for (i = 0; i < 1000; i++) {
 374         if (signal_pulse_data[i][0] > 0) {
 375             //fprintf(stderr, "%d\n", signal_pulse_data[i][1]);
 376         }
 377     }
 378     /* 50% decision limit */
 379     if (min != 0 && max / min > 1) {
 380         fprintf(stderr, "Pulse coding: Short pulse length %d - Long pulse length %d\n", min, max);
 381         signal_type = 2;
 382     } else {
 383         fprintf(stderr, "Distance coding: Pulse length %d\n", (min + max) / 2);
 384         signal_type = 1;
 385     }
 386     p_limit = (max + min) / 2;
 387
 388     /* Initial guesses */
 389     a[0] = 1000000;
 390     a[2] = 0;
 391     for (i = 1; i < 1000; i++) {
 392         if (signal_pulse_data[i][0] > 0) {
 393             //               fprintf(stderr, "[%03d] s: %d\t  e:\t %d\t l:%d\t  d:%d\n",
 394             //               i, signal_pulse_data[i][0], signal_pulse_data[i][1],
 395             //               signal_pulse_data[i][2], signal_pulse_data[i][0]-signal_pulse_data[i-1][1]);
 396             signal_distance_data[i - 1] = signal_pulse_data[i][0] - signal_pulse_data[i - 1][1];
 397             if (signal_distance_data[i - 1] > a[2])
 398                 a[2] = signal_distance_data[i - 1];
 399             if (signal_distance_data[i - 1] <= a[0])
 400                 a[0] = signal_distance_data[i - 1];
 401         }
 402     }
 403     min = a[0];
 404     max = a[2];
 405     a[1] = (a[0] + a[2]) / 2;
 406     //    for (i=0 ; i<1 ; i++) {
 407     //        b[i] = (a[i]+a[i+1])/2;
 408     //    }
 409     b[0] = (a[0] + a[1]) / 2;
 410     b[1] = (a[1] + a[2]) / 2;
 411     //     fprintf(stderr, "a[0]: %d\t a[1]: %d\t a[2]: %d\t\n",a[0],a[1],a[2]);
 412     //     fprintf(stderr, "b[0]: %d\t b[1]: %d\n",b[0],b[1]);
 413
 414     k = 1;
 415     delta = 10000000;
 416     while ((k < 10) && (delta > 0)) {
 417         for (i = 0; i < 3; i++) {
 418             a_new[i] = 0;
 419             a_cnt[i] = 0;
 420         }
 421
 422         for (i = 0; i < 1000; i++) {
 423             if (signal_distance_data[i] > 0) {
 424                 if (signal_distance_data[i] < b[0]) {
 425                     a_new[0] += signal_distance_data[i];
 426                     a_cnt[0]++;
 427                 } else if (signal_distance_data[i] < b[1] && signal_distance_data[i] >= b[0]) {
 428                     a_new[1] += signal_distance_data[i];
 429                     a_cnt[1]++;
 430                 } else if (signal_distance_data[i] >= b[1]) {
 431                     a_new[2] += signal_distance_data[i];
 432                     a_cnt[2]++;
 433                 }
 434             }
 435         }
 436
 437         //         fprintf(stderr, "Iteration %d.", k);
 438         delta = 0;
 439         for (i = 0; i < 3; i++) {
 440             if (a_cnt[i])
 441                 a_new[i] /= a_cnt[i];
 442             delta += (a[i] - a_new[i])*(a[i] - a_new[i]);
 443             //             fprintf(stderr, "\ta[%d]: %d (%d)", i, a_new[i], a[i]);
 444             a[i] = a_new[i];
 445         }
 446         //         fprintf(stderr, " delta %d\n", delta);
 447
 448         if (a[0] < min) {
 449             a[0] = min;
 450             //             fprintf(stderr, "Fixing a[0] = %d\n", min);
 451         }
 452         if (a[2] > max) {
 453             a[0] = max;
 454             //             fprintf(stderr, "Fixing a[2] = %d\n", max);
 455         }
 456         //         if (a[1] == 0) {
 457         //             a[1] = (a[2]+a[0])/2;
 458         //             fprintf(stderr, "Fixing a[1] = %d\n", a[1]);
 459         //         }
 460
 461         //         fprintf(stderr, "Iteration %d.", k);
 462         for (i = 0; i < 2; i++) {
 463             //             fprintf(stderr, "\tb[%d]: (%d) ", i, b[i]);
 464             b[i] = (a[i] + a[i + 1]) / 2;
 465             //             fprintf(stderr, "%d  ", b[i]);
 466         }
 467         //         fprintf(stderr, "\n");
 468         k++;
 469     }
 470
 471     if (override_short) {
 472         p_limit = override_short;
 473         a[0] = override_short;
 474     }
 475
 476     if (override_long) {
 477         a[1] = override_long;
 478     }
 479
 480     if (a[1]<a[0]) {
 481         a[1]=a[0]+1;
 482     }
 483
 484     if (a[2]<a[1]*2) {
 485         a[2] = a[1]*2;
 486     }
 487
 488     fprintf(stderr, "\nShort distance: %d, long distance: %d, packet distance: %d\n", a[0], a[1], a[2]);
 489     fprintf(stderr, "\np_limit: %d\n", p_limit);
 490
 491     demod_reset_bits_packet(&p);
 492     if (signal_type == 1) {
 493         for (i = 0; i < 1000; i++) {
 494             if (signal_distance_data[i] > 0) {
 495                 if (signal_distance_data[i] < (a[0] + a[1]) / 2) {
 496                     //                     fprintf(stderr, "0 [%d] %d < %d\n",i, signal_distance_data[i], (a[0]+a[1])/2);
 497                     demod_add_bit(&p, 0);
 498                 } else if ((signal_distance_data[i] > (a[0] + a[1]) / 2) && (signal_distance_data[i] < (a[1] + a[2]) / 2)) {
 499                     //                     fprintf(stderr, "0 [%d] %d > %d\n",i, signal_distance_data[i], (a[0]+a[1])/2);
 500                     demod_add_bit(&p, 1);
 501                 } else if (signal_distance_data[i] > (a[1] + a[2]) / 2) {
 502                     //                     fprintf(stderr, "0 [%d] %d > %d\n",i, signal_distance_data[i], (a[1]+a[2])/2);
 503                     demod_next_bits_packet(&p);
 504                 }
 505
 506             }
 507
 508         }
 509         demod_print_bits_packet(&p);
 510     }
 511     if (signal_type == 2) {
 512         for (i = 0; i < 1000; i++) {
 513             if (signal_pulse_data[i][2] > 0) {
 514                 if (signal_pulse_data[i][2] < p_limit) {
 515                     //                     fprintf(stderr, "0 [%d] %d < %d\n",i, signal_pulse_data[i][2], p_limit);
 516                     demod_add_bit(&p, 0);
 517                 } else {
 518                     //                     fprintf(stderr, "1 [%d] %d > %d\n",i, signal_pulse_data[i][2], p_limit);
 519                     demod_add_bit(&p, 1);
 520                 }
 521                 if ((signal_distance_data[i] >= (a[1] + a[2]) / 2)) {
 522                     //                     fprintf(stderr, "\\n [%d] %d > %d\n",i, signal_distance_data[i], (a[1]+a[2])/2);
 523                     demod_next_bits_packet(&p);
 524                 }
 525
 526
 527             }
 528         }
 529         demod_print_bits_packet(&p);
 530     }
 531
 532     for (i = 0; i < 1000; i++) {
 533         signal_pulse_data[i][0] = 0;
 534         signal_pulse_data[i][1] = 0;
 535         signal_pulse_data[i][2] = 0;
 536         signal_distance_data[i] = 0;
 537     }
 538
 539 };
 540
 541 static void pwm_analyze(struct dm_state *demod, int16_t *buf, uint32_t len) {
 542     unsigned int i;
 543
 544     for (i = 0; i < len; i++) {
 545         if (buf[i] > demod->level_limit) {
 546             if (!signal_start)
 547                 signal_start = counter;
 548             if (print) {
 549                 pulses_found++;
 550                 pulse_start = counter;
 551                 signal_pulse_data[signal_pulse_counter][0] = counter;
 552                 signal_pulse_data[signal_pulse_counter][1] = -1;
 553                 signal_pulse_data[signal_pulse_counter][2] = -1;
 554                 if (debug_output) fprintf(stderr, "pulse_distance %d\n", counter - pulse_end);
 555                 if (debug_output) fprintf(stderr, "pulse_start distance %d\n", pulse_start - prev_pulse_start);
 556                 if (debug_output) fprintf(stderr, "pulse_start[%d] found at sample %d, value = %d\n", pulses_found, counter, buf[i]);
 557                 prev_pulse_start = pulse_start;
 558                 print = 0;
 559                 print2 = 1;
 560             }
 561         }
 562         counter++;
 563         if (buf[i] < demod->level_limit) {
 564             if (print2) {
 565                 pulse_avg += counter - pulse_start;
 566                 if (debug_output) fprintf(stderr, "pulse_end  [%d] found at sample %d, pulse length = %d, pulse avg length = %d\n",
 567                         pulses_found, counter, counter - pulse_start, pulse_avg / pulses_found);
 568                 pulse_end = counter;
 569                 print2 = 0;
 570                 signal_pulse_data[signal_pulse_counter][1] = counter;
 571                 signal_pulse_data[signal_pulse_counter][2] = counter - pulse_start;
 572                 signal_pulse_counter++;
 573                 if (signal_pulse_counter >= 4000) {
 574                     signal_pulse_counter = 0;
 575                     goto err;
 576                 }
 577             }
 578             print = 1;
 579             if (signal_start && (pulse_end + 50000 < counter)) {
 580                 signal_end = counter - 40000;
 581                 fprintf(stderr, "*** signal_start = %d, signal_end = %d\n", signal_start - 10000, signal_end);
 582                 fprintf(stderr, "signal_len = %d,  pulses = %d\n", signal_end - (signal_start - 10000), pulses_found);
 583                 pulses_found = 0;
 584                 classify_signal();
 585
 586                 signal_pulse_counter = 0;
 587                 if (demod->sg_buf) {
 588                     int start_pos, signal_bszie, wlen, wrest = 0, sg_idx, idx;
 589                     char sgf_name[256] = {0};
 590                     FILE *sgfp;
 591
 592                     sprintf(sgf_name, "gfile%03d.data", demod->signal_grabber);
 593                     demod->signal_grabber++;
 594                     signal_bszie = 2 * (signal_end - (signal_start - 10000));
 595                     signal_bszie = (131072 - (signal_bszie % 131072)) + signal_bszie;
 596                     sg_idx = demod->sg_index - demod->sg_len;
 597                     if (sg_idx < 0)
 598                         sg_idx = SIGNAL_GRABBER_BUFFER - demod->sg_len;
 599                     idx = (i - 40000)*2;
 600                     start_pos = sg_idx + idx - signal_bszie;
 601                     fprintf(stderr, "signal_bszie = %d  -      sg_index = %d\n", signal_bszie, demod->sg_index);
 602                     fprintf(stderr, "start_pos    = %d  -   buffer_size = %d\n", start_pos, SIGNAL_GRABBER_BUFFER);
 603                     if (signal_bszie > SIGNAL_GRABBER_BUFFER)
 604                         fprintf(stderr, "Signal bigger then buffer, signal = %d > buffer %d !!\n", signal_bszie, SIGNAL_GRABBER_BUFFER);
 605
 606                     if (start_pos < 0) {
 607                         start_pos = SIGNAL_GRABBER_BUFFER + start_pos;
 608                         fprintf(stderr, "restart_pos = %d\n", start_pos);
 609                     }
 610
 611                     fprintf(stderr, "*** Saving signal to file %s\n", sgf_name);
 612                     sgfp = fopen(sgf_name, "wb");
 613                     if (!sgfp) {
 614                         fprintf(stderr, "Failed to open %s\n", sgf_name);
 615                     }
 616                     wlen = signal_bszie;
 617                     if (start_pos + signal_bszie > SIGNAL_GRABBER_BUFFER) {
 618                         wlen = SIGNAL_GRABBER_BUFFER - start_pos;
 619                         wrest = signal_bszie - wlen;
 620                     }
 621                     fprintf(stderr, "*** Writing data from %d, len %d\n", start_pos, wlen);
 622                     fwrite(&demod->sg_buf[start_pos], 1, wlen, sgfp);
 623
 624                     if (wrest) {
 625                         fprintf(stderr, "*** Writing data from %d, len %d\n", 0, wrest);
 626                         fwrite(&demod->sg_buf[0], 1, wrest, sgfp);
 627                     }
 628
 629                     fclose(sgfp);
 630                 }
 631                 signal_start = 0;
 632             }
 633         }
 634
 635
 636     }
 637     return;
 638
 639 err:
 640     fprintf(stderr, "To many pulses detected, probably bad input data or input parameters\n");
 641     return;
 642 }
 643
 644 /* The distance between pulses decodes into bits */
 645
 646 static void pwm_d_decode(struct dm_state *demod, struct protocol_state* p, int16_t *buf, uint32_t len) {
 647     unsigned int i;
 648
 649     for (i = 0; i < len; i++) {
 650         if (buf[i] > demod->level_limit) {
 651             p->pulse_count = 1;
 652             p->start_c = 1;
 653         }
 654         if (p->pulse_count && (buf[i] < demod->level_limit)) {
 655             p->pulse_length = 0;
 656             p->pulse_distance = 1;
 657             p->sample_counter = 0;
 658             p->pulse_count = 0;
 659         }
 660         if (p->start_c) p->sample_counter++;
 661         if (p->pulse_distance && (buf[i] > demod->level_limit)) {
 662             if (p->sample_counter < p->short_limit) {
 663                 demod_add_bit(p, 0);
 664             } else if (p->sample_counter < p->long_limit) {
 665                 demod_add_bit(p, 1);
 666             } else {
 667                 demod_next_bits_packet(p);
 668                 p->pulse_count = 0;
 669                 p->sample_counter = 0;
 670             }
 671             p->pulse_distance = 0;
 672         }
 673         if (p->sample_counter > p->reset_limit) {
 674             p->start_c = 0;
 675             p->sample_counter = 0;
 676             p->pulse_distance = 0;
 677             if (p->callback)
 678                 events += p->callback(p->bits_buffer, p->bits_per_row);
 679             else
 680                 demod_print_bits_packet(p);
 681
 682             demod_reset_bits_packet(p);
 683         }
 684     }
 685 }
 686
 687 /* The length of pulses decodes into bits */
 688
 689 static void pwm_p_decode(struct dm_state *demod, struct protocol_state* p, int16_t *buf, uint32_t len) {
 690     unsigned int i;
 691
 692     for (i = 0; i < len; i++) {
 693         if (buf[i] > demod->level_limit && !p->start_bit) {
 694             /* start bit detected */
 695             p->start_bit = 1;
 696             p->start_c = 1;
 697             p->sample_counter = 0;
 698             //            fprintf(stderr, "start bit pulse start detected\n");
 699         }
 700
 701         if (!p->real_bits && p->start_bit && (buf[i] < demod->level_limit)) {
 702             /* end of startbit */
 703             p->real_bits = 1;
 704             p->pulse_length = 0;
 705             p->sample_counter = 0;
 706             //            fprintf(stderr, "start bit pulse end detected\n");
 707         }
 708         if (p->start_c) p->sample_counter++;
 709
 710
 711         if (!p->pulse_start && p->real_bits && (buf[i] > demod->level_limit)) {
 712             /* save the pulse start, it will never be zero */
 713             p->pulse_start = p->sample_counter;
 714             //           fprintf(stderr, "real bit pulse start detected\n");
 715
 716         }
 717
 718         if (p->real_bits && p->pulse_start && (buf[i] < demod->level_limit)) {
 719             /* end of pulse */
 720
 721             p->pulse_length = p->sample_counter - p->pulse_start;
 722             //           fprintf(stderr, "real bit pulse end detected %d\n", p->pulse_length);
 723             //           fprintf(stderr, "space duration %d\n", p->sample_counter);
 724
 725             if (p->pulse_length <= p->short_limit) {
 726                 demod_add_bit(p, 1);
 727             } else if (p->pulse_length > p->short_limit) {
 728                 demod_add_bit(p, 0);
 729             }
 730             p->sample_counter = 0;
 731             p->pulse_start = 0;
 732         }
 733
 734         if (p->real_bits && (p->pulse_length > p->long_limit)) {
 735             demod_next_bits_packet(p);
 736
 737             p->start_bit = 0;
 738             p->real_bits = 0;
 739         }
 740
 741         if (p->sample_counter > p->reset_limit) {
 742             p->start_c = 0;
 743             p->sample_counter = 0;
 744             //demod_print_bits_packet(p);
 745             if (p->callback)
 746                 events += p->callback(p->bits_buffer, p->bits_per_row);
 747             else
 748                 demod_print_bits_packet(p);
 749             demod_reset_bits_packet(p);
 750
 751             p->start_bit = 0;
 752             p->real_bits = 0;
 753         }
 754     }
 755 }
 756
 757 /*  Machester Decode for Oregon Scientific Weather Sensors
 758    Decode data streams sent by Oregon Scientific v2.1, and v3 weather sensors.
 759    With manchester encoding, both the pulse width and pulse distance vary.  Clock sync
 760    is recovered from the data stream based on pulse widths and distances exceeding a
 761    minimum threashold (short limit* 1.5).
 762  */
 763 static void manchester_decode(struct dm_state *demod, struct protocol_state* p, int16_t *buf, uint32_t len) {
 764     unsigned int i;
 765
 766         if (p->sample_counter == 0)
 767             p->sample_counter = p->short_limit*2;
 768
 769     for (i=0 ; i<len ; i++) {
 770
 771             if (p->start_c)
 772                     p->sample_counter++; /* For this decode type, sample counter is count since last data bit recorded */
 773
 774         if (!p->pulse_count && (buf[i] > demod->level_limit)) { /* Pulse start (rising edge) */
 775             p->pulse_count = 1;
 776                         if (p->sample_counter  > (p->short_limit + (p->short_limit>>1))) {
 777                            /* Last bit was recorded more than short_limit*1.5 samples ago */
 778                            /* so this pulse start must be a data edge (rising data edge means bit = 0) */
 779                demod_add_bit(p, 0);
 780                            p->sample_counter=1;
 781                            p->start_c++; // start_c counts number of bits received
 782                         }
 783         }
 784         if (p->pulse_count && (buf[i] <= demod->level_limit)) { /* Pulse end (falling edge) */
 785                     if (p->sample_counter > (p->short_limit + (p->short_limit>>1))) {
 786                        /* Last bit was recorded more than "short_limit*1.5" samples ago */
 787                            /* so this pulse end is a data edge (falling data edge means bit = 1) */
 788                demod_add_bit(p, 1);
 789                            p->sample_counter=1;
 790                            p->start_c++;
 791                         }
 792             p->pulse_count = 0;
 793         }
 794
 795         if (p->sample_counter > p->reset_limit) {
 796         //fprintf(stderr, "manchester_decode number of bits received=%d\n",p->start_c);
 797                    if (p->callback)
 798               events+=p->callback(p->bits_buffer, p->bits_per_row);
 799            else
 800               demod_print_bits_packet(p);
 801                         demod_reset_bits_packet(p);
 802                 p->sample_counter = p->short_limit*2;
 803                         p->start_c = 0;
 804         }
 805     }
 806 }
 807
 808 /** Something that might look like a IIR lowpass filter
 809  *
 810  *  [b,a] = butter(1, 0.01) ->  quantizes nicely thus suitable for fixed point
 811  *  Q1.15*Q15.0 = Q16.15
 812  *  Q16.15>>1 = Q15.14
 813  *  Q15.14 + Q15.14 + Q15.14 could possibly overflow to 17.14
 814  *  but the b coeffs are small so it wont happen
 815  *  Q15.14>>14 = Q15.0 \o/
 816  */
 817
 818 static uint16_t lp_xmem[FILTER_ORDER] = {0};
 819
 820 #define F_SCALE 15
 821 #define S_CONST (1<<F_SCALE)
 822 #define FIX(x) ((int)(x*S_CONST))
 823
 824 int a[FILTER_ORDER + 1] = {FIX(1.00000), FIX(0.96907)};
 825 int b[FILTER_ORDER + 1] = {FIX(0.015466), FIX(0.015466)};
 826
 827 static void low_pass_filter(uint16_t *x_buf, int16_t *y_buf, uint32_t len) {
 828     unsigned int i;
 829
 830     /* Calculate first sample */
 831     y_buf[0] = ((a[1] * y_buf[-1] >> 1) + (b[0] * x_buf[0] >> 1) + (b[1] * lp_xmem[0] >> 1)) >> (F_SCALE - 1);
 832     for (i = 1; i < len; i++) {
 833         y_buf[i] = ((a[1] * y_buf[i - 1] >> 1) + (b[0] * x_buf[i] >> 1) + (b[1] * x_buf[i - 1] >> 1)) >> (F_SCALE - 1);
 834     }
 835
 836     /* Save last sample */
 837     memcpy(lp_xmem, &x_buf[len - 1 - FILTER_ORDER], FILTER_ORDER * sizeof (int16_t));
 838     memcpy(&y_buf[-FILTER_ORDER], &y_buf[len - 1 - FILTER_ORDER], FILTER_ORDER * sizeof (int16_t));
 839     //fprintf(stderr, "%d\n", y_buf[0]);
 840 }
 841
 842 static void rtlsdr_callback(unsigned char *buf, uint32_t len, void *ctx) {
 843     struct dm_state *demod = ctx;
 844     uint16_t* sbuf = (uint16_t*) buf;
 845     int i;
 846     if (demod->file || !demod->save_data) {
 847         if (do_exit || do_exit_async)
 848             return;
 849
 850         if ((bytes_to_read > 0) && (bytes_to_read < len)) {
 851             len = bytes_to_read;
 852             do_exit = 1;
 853             rtlsdr_cancel_async(dev);
 854         }
 855
 856         if (demod->signal_grabber) {
 857             //fprintf(stderr, "[%d] sg_index - len %d\n", demod->sg_index, len );
 858             memcpy(&demod->sg_buf[demod->sg_index], buf, len);
 859             demod->sg_len = len;
 860             demod->sg_index += len;
 861             if (demod->sg_index + len > SIGNAL_GRABBER_BUFFER)
 862                 demod->sg_index = 0;
 863         }
 864
 865
 866         if (demod->debug_mode == 0) {
 867             envelope_detect(buf, len, demod->decimation_level);
 868             low_pass_filter(sbuf, demod->f_buf, len >> (demod->decimation_level + 1));
 869         } else if (demod->debug_mode == 1) {
 870             memcpy(demod->f_buf, buf, len);
 871         }
 872         if (demod->analyze) {
 873             pwm_analyze(demod, demod->f_buf, len / 2);
 874         } else {
 875             for (i = 0; i < demod->r_dev_num; i++) {
 876                 switch (demod->r_devs[i]->modulation) {
 877                     case OOK_PWM_D:
 878                         pwm_d_decode(demod, demod->r_devs[i], demod->f_buf, len / 2);
 879                         break;
 880                     case OOK_PWM_P:
 881                         pwm_p_decode(demod, demod->r_devs[i], demod->f_buf, len / 2);
 882                         break;
 883                     case OOK_MANCHESTER:
 884                         manchester_decode(demod, demod->r_devs[i], demod->f_buf, len/2);
 885                         break;
 886                     default:
 887                         fprintf(stderr, "Unknown modulation %d in protocol!\n", demod->r_devs[i]->modulation);
 888                 }
 889             }
 890             fflush(stdout);
 891         }
 892
 893         if (demod->save_data) {
 894             if (fwrite(demod->f_buf, 1, len >> demod->decimation_level, demod->file) != len >> demod->decimation_level) {
 895                 fprintf(stderr, "Short write, samples lost, exiting!\n");
 896                 rtlsdr_cancel_async(dev);
 897             }
 898         }
 899
 900         if (bytes_to_read > 0)
 901             bytes_to_read -= len;
 902
 903         if (frequencies > 1) {
 904             time_t rawtime;
 905             time(&rawtime);
 906             if (difftime(rawtime, rawtime_old) > DEFAULT_HOP_TIME || events >= DEFAULT_HOP_EVENTS) {
 907                 rawtime_old = rawtime;
 908                 events = 0;
 909                 do_exit_async = 1;
 910                 rtlsdr_cancel_async(dev);
 911             }
 912         }
 913     }
 914 }
 915
 916 int main(int argc, char **argv) {
 917 #ifndef _WIN32
 918     struct sigaction sigact;
 919 #endif
 920     char *filename = NULL;
 921     char *test_mode_file = NULL;
 922     FILE *test_mode;
 923     int n_read;
 924     int r, opt;
 925     int i, gain = 0;
 926     int sync_mode = 0;
 927     int ppm_error = 0;
 928     struct dm_state* demod;
 929     uint8_t *buffer;
 930     uint32_t dev_index = 0;
 931     int frequency_current = 0;
 932     uint32_t out_block_size = DEFAULT_BUF_LENGTH;
 933     int device_count;
 934     char vendor[256], product[256], serial[256];
 935
 936     demod = malloc(sizeof (struct dm_state));
 937     memset(demod, 0, sizeof (struct dm_state));
 938
 939     /* initialize tables */
 940     calc_squares();
 941
 942     demod->f_buf = &demod->filter_buffer[FILTER_ORDER];
 943     demod->decimation_level = DEFAULT_DECIMATION_LEVEL;
 944     demod->level_limit = DEFAULT_LEVEL_LIMIT;
 945
 946
 947     while ((opt = getopt(argc, argv, "x:z:p:Dtam:r:c:l:d:f:g:s:b:n:S::")) != -1) {
 948         switch (opt) {
 949             case 'd':
 950                 dev_index = atoi(optarg);
 951                 break;
 952             case 'f':
 953                 if (frequencies < MAX_PROTOCOLS) frequency[frequencies++] = (uint32_t) atof(optarg);
 954                 else fprintf(stderr, "Max number of frequencies reached %d\n", MAX_PROTOCOLS);
 955                 break;
 956             case 'g':
 957                 gain = (int) (atof(optarg) * 10); /* tenths of a dB */
 958                 break;
 959             case 'p':
 960                 ppm_error = atoi(optarg);
 961                 break;
 962             case 's':
 963                 samp_rate = (uint32_t) atof(optarg);
 964                 break;
 965             case 'b':
 966                 out_block_size = (uint32_t) atof(optarg);
 967                 break;
 968             case 'l':
 969                 demod->level_limit = (uint32_t) atof(optarg);
 970                 break;
 971             case 'n':
 972                 bytes_to_read = (uint32_t) atof(optarg) * 2;
 973                 break;
 974             case 'c':
 975                 demod->decimation_level = (uint32_t) atof(optarg);
 976                 break;
 977             case 'a':
 978                 demod->analyze = 1;
 979                 break;
 980             case 'r':
 981                 test_mode_file = optarg;
 982                 break;
 983             case 't':
 984                 demod->signal_grabber = 1;
 985                 break;
 986             case 'm':
 987                 demod->debug_mode = atoi(optarg);
 988                 break;
 989             case 'S':
 990                 sync_mode = 1;
 991                 break;
 992             case 'D':
 993                 debug_output = 1;
 994                 break;
 995             case 'z':
 996                 override_short = atoi(optarg);
 997                 break;
 998             case 'x':
 999                 override_long = atoi(optarg);
1000                 break;
1001             default:
1002                 usage();
1003                 break;
1004         }
1005     }
1006
1007     /* init protocols somewhat ok */
1008     register_protocol(demod, &rubicson);
1009     register_protocol(demod, &prologue);
1010     register_protocol(demod, &silvercrest);
1011     //    register_protocol(demod, &generic_hx2262);
1012     //    register_protocol(demod, &technoline_ws9118);
1013     register_protocol(demod, &elv_em1000);
1014     register_protocol(demod, &elv_ws2000);
1015     register_protocol(demod, &waveman);
1016     register_protocol(demod, &steffen);
1017     register_protocol(demod, &acurite5n1);
1018     register_protocol(demod, &acurite_th);
1019     register_protocol(demod, &acurite_rain_gauge);
1020     register_protocol(demod, &lacrossetx);
1021     register_protocol(demod, &oregon_scientific);
1022     register_protocol(demod, &newkaku);
1023     register_protocol(demod, &alectov1);
1024     register_protocol(demod, &intertechno);
1025     register_protocol(demod, &mebus433);
1026     register_protocol(demod, &wh2);
1027
1028     if (argc <= optind - 1) {
1029         usage();
1030     } else {
1031         filename = argv[optind];
1032     }
1033
1034     if (out_block_size < MINIMAL_BUF_LENGTH ||
1035             out_block_size > MAXIMAL_BUF_LENGTH) {
1036         fprintf(stderr,
1037                 "Output block size wrong value, falling back to default\n");
1038         fprintf(stderr,
1039                 "Minimal length: %u\n", MINIMAL_BUF_LENGTH);
1040         fprintf(stderr,
1041                 "Maximal length: %u\n", MAXIMAL_BUF_LENGTH);
1042         out_block_size = DEFAULT_BUF_LENGTH;
1043     }
1044
1045     buffer = malloc(out_block_size * sizeof (uint8_t));
1046
1047     device_count = rtlsdr_get_device_count();
1048     if (!device_count) {
1049         fprintf(stderr, "No supported devices found.\n");
1050         if (!test_mode_file)
1051             exit(1);
1052     }
1053
1054     fprintf(stderr, "Found %d device(s):\n", device_count);
1055     for (i = 0; i < device_count; i++) {
1056         rtlsdr_get_device_usb_strings(i, vendor, product, serial);
1057         fprintf(stderr, "  %d:  %s, %s, SN: %s\n", i, vendor, product, serial);
1058     }
1059     fprintf(stderr, "\n");
1060
1061     fprintf(stderr, "Using device %d: %s\n",
1062             dev_index, rtlsdr_get_device_name(dev_index));
1063
1064     r = rtlsdr_open(&dev, dev_index);
1065     if (r < 0) {
1066         fprintf(stderr, "Failed to open rtlsdr device #%d.\n", dev_index);
1067         if (!test_mode_file)
1068             exit(1);
1069     }
1070 #ifndef _WIN32
1071     sigact.sa_handler = sighandler;
1072     sigemptyset(&sigact.sa_mask);
1073     sigact.sa_flags = 0;
1074     sigaction(SIGINT, &sigact, NULL);
1075     sigaction(SIGTERM, &sigact, NULL);
1076     sigaction(SIGQUIT, &sigact, NULL);
1077     sigaction(SIGPIPE, &sigact, NULL);
1078 #else
1079     SetConsoleCtrlHandler((PHANDLER_ROUTINE) sighandler, TRUE);
1080 #endif
1081     /* Set the sample rate */
1082     r = rtlsdr_set_sample_rate(dev, samp_rate);
1083     if (r < 0)
1084         fprintf(stderr, "WARNING: Failed to set sample rate.\n");
1085     else
1086         fprintf(stderr, "Sample rate set to %d.\n", rtlsdr_get_sample_rate(dev)); // Unfortunately, doesn't return real rate
1087
1088     fprintf(stderr, "Sample rate decimation set to %d. %d->%d\n", demod->decimation_level, samp_rate, samp_rate >> demod->decimation_level);
1089     fprintf(stderr, "Bit detection level set to %d.\n", demod->level_limit);
1090
1091     if (0 == gain) {
1092         /* Enable automatic gain */
1093         r = rtlsdr_set_tuner_gain_mode(dev, 0);
1094         if (r < 0)
1095             fprintf(stderr, "WARNING: Failed to enable automatic gain.\n");
1096         else
1097             fprintf(stderr, "Tuner gain set to Auto.\n");
1098     } else {
1099         /* Enable manual gain */
1100         r = rtlsdr_set_tuner_gain_mode(dev, 1);
1101         if (r < 0)
1102             fprintf(stderr, "WARNING: Failed to enable manual gain.\n");
1103
1104         /* Set the tuner gain */
1105         r = rtlsdr_set_tuner_gain(dev, gain);
1106         if (r < 0)
1107             fprintf(stderr, "WARNING: Failed to set tuner gain.\n");
1108         else
1109             fprintf(stderr, "Tuner gain set to %f dB.\n", gain / 10.0);
1110     }
1111
1112     r = rtlsdr_set_freq_correction(dev, ppm_error);
1113
1114     demod->save_data = 1;
1115     if (!filename) {
1116         demod->save_data = 0;
1117     } else if (strcmp(filename, "-") == 0) { /* Write samples to stdout */
1118         demod->file = stdout;
1119 #ifdef _WIN32
1120         _setmode(_fileno(stdin), _O_BINARY);
1121 #endif
1122     } else {
1123         demod->file = fopen(filename, "wb");
1124         if (!demod->file) {
1125             fprintf(stderr, "Failed to open %s\n", filename);
1126             goto out;
1127         }
1128     }
1129
1130     if (demod->signal_grabber)
1131         demod->sg_buf = malloc(SIGNAL_GRABBER_BUFFER);
1132
1133     if (test_mode_file) {
1134         int i = 0;
1135         unsigned char test_mode_buf[DEFAULT_BUF_LENGTH];
1136         fprintf(stderr, "Test mode active. Reading samples from file: %s\n", test_mode_file);
1137         test_mode = fopen(test_mode_file, "r");
1138         if (!test_mode) {
1139             fprintf(stderr, "Opening file: %s failed!\n", test_mode_file);
1140             goto out;
1141         }
1142         while (fread(test_mode_buf, 131072, 1, test_mode) != 0) {
1143             rtlsdr_callback(test_mode_buf, 131072, demod);
1144             i++;
1145         }
1146         //Always classify a signal at the end of the file
1147         classify_signal();
1148         fprintf(stderr, "Test mode file issued %d packets\n", i);
1149         fprintf(stderr, "Filter coeffs used:\n");
1150         fprintf(stderr, "a: %d %d\n", a[0], a[1]);
1151         fprintf(stderr, "b: %d %d\n", b[0], b[1]);
1152         exit(0);
1153     }
1154
1155     /* Reset endpoint before we start reading from it (mandatory) */
1156     r = rtlsdr_reset_buffer(dev);
1157     if (r < 0)
1158         fprintf(stderr, "WARNING: Failed to reset buffers.\n");
1159
1160     if (sync_mode) {
1161         fprintf(stderr, "Reading samples in sync mode...\n");
1162         while (!do_exit) {
1163             r = rtlsdr_read_sync(dev, buffer, out_block_size, &n_read);
1164             if (r < 0) {
1165                 fprintf(stderr, "WARNING: sync read failed.\n");
1166                 break;
1167             }
1168
1169             if ((bytes_to_read > 0) && (bytes_to_read < (uint32_t) n_read)) {
1170                 n_read = bytes_to_read;
1171                 do_exit = 1;
1172             }
1173
1174             if (fwrite(buffer, 1, n_read, demod->file) != (size_t) n_read) {
1175                 fprintf(stderr, "Short write, samples lost, exiting!\n");
1176                 break;
1177             }
1178
1179             if ((uint32_t) n_read < out_block_size) {
1180                 fprintf(stderr, "Short read, samples lost, exiting!\n");
1181                 break;
1182             }
1183
1184             if (bytes_to_read > 0)
1185                 bytes_to_read -= n_read;
1186         }
1187     } else {
1188         if (frequencies == 0) {
1189             frequency[0] = DEFAULT_FREQUENCY;
1190             frequencies = 1;
1191         } else {
1192             time(&rawtime_old);
1193         }
1194         fprintf(stderr, "Reading samples in async mode...\n");
1195         while (!do_exit) {
1196             /* Set the frequency */
1197             r = rtlsdr_set_center_freq(dev, frequency[frequency_current]);
1198             if (r < 0)
1199                 fprintf(stderr, "WARNING: Failed to set center freq.\n");
1200             else
1201                 fprintf(stderr, "Tuned to %u Hz.\n", rtlsdr_get_center_freq(dev));
1202             r = rtlsdr_read_async(dev, rtlsdr_callback, (void *) demod,
1203                     DEFAULT_ASYNC_BUF_NUMBER, out_block_size);
1204             do_exit_async = 0;
1205             frequency_current++;
1206             if (frequency_current > frequencies - 1) frequency_current = 0;
1207         }
1208     }
1209
1210     if (do_exit)
1211         fprintf(stderr, "\nUser cancel, exiting...\n");
1212     else
1213         fprintf(stderr, "\nLibrary error %d, exiting...\n", r);
1214
1215     if (demod->file && (demod->file != stdout))
1216         fclose(demod->file);
1217
1218     for (i = 0; i < demod->r_dev_num; i++)
1219         free(demod->r_devs[i]);
1220
1221     if (demod->signal_grabber)
1222         free(demod->sg_buf);
1223
1224     if (demod)
1225         free(demod);
1226
1227     rtlsdr_close(dev);
1228     free(buffer);
1229 out:
1230     return r >= 0 ? r : -r;
1231 }