903f93f530
A few minor additions and bug fixes as detailed below 1) Additional command line option "--net-buffer <n>" to specify the TCP output buffer size. Default is n=0, which is 64Kb. Specify a value of n to increase the buffer size according to Size = 64Kb * 2^n, so an n of 1 = 128Kb, n=2 is 256Kb etc. n is limited to 7, so the max size is 8Mb. This option may assist if you have a high number of aircraft being received, and an unreliable network connection, or if the receiving end can be busy for an extended time. 2) Bug fix in ppup1090 which prevented the uploading of valid ModeA/Squawk codes 3) Bug fix per Markus Grab's commit.
767 lines
33 KiB
C
767 lines
33 KiB
C
// dump1090, a Mode S messages decoder for RTLSDR devices.
|
|
//
|
|
// Copyright (C) 2012 by Salvatore Sanfilippo <antirez@gmail.com>
|
|
//
|
|
// All rights reserved.
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without
|
|
// modification, are permitted provided that the following conditions are
|
|
// met:
|
|
//
|
|
// * Redistributions of source code must retain the above copyright
|
|
// notice, this list of conditions and the following disclaimer.
|
|
//
|
|
// * Redistributions in binary form must reproduce the above copyright
|
|
// notice, this list of conditions and the following disclaimer in the
|
|
// documentation and/or other materials provided with the distribution.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
// HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
//
|
|
#include "coaa.h"
|
|
#include "dump1090.h"
|
|
//
|
|
// ============================= Utility functions ==========================
|
|
//
|
|
void sigintHandler(int dummy) {
|
|
MODES_NOTUSED(dummy);
|
|
signal(SIGINT, SIG_DFL); // reset signal handler - bit extra safety
|
|
Modes.exit = 1; // Signal to threads that we are done
|
|
}
|
|
//
|
|
// =============================== Terminal handling ========================
|
|
//
|
|
#ifndef _WIN32
|
|
// Get the number of rows after the terminal changes size.
|
|
int getTermRows() {
|
|
struct winsize w;
|
|
ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);
|
|
return (w.ws_row);
|
|
}
|
|
|
|
// Handle resizing terminal
|
|
void sigWinchCallback() {
|
|
signal(SIGWINCH, SIG_IGN);
|
|
Modes.interactive_rows = getTermRows();
|
|
interactiveShowData();
|
|
signal(SIGWINCH, sigWinchCallback);
|
|
}
|
|
#else
|
|
int getTermRows() { return MODES_INTERACTIVE_ROWS;}
|
|
#endif
|
|
//
|
|
// =============================== Initialization ===========================
|
|
//
|
|
void modesInitConfig(void) {
|
|
// Default everything to zero/NULL
|
|
memset(&Modes, 0, sizeof(Modes));
|
|
|
|
// Now initialise things that should not be 0/NULL to their defaults
|
|
Modes.gain = MODES_MAX_GAIN;
|
|
Modes.freq = MODES_DEFAULT_FREQ;
|
|
Modes.check_crc = 1;
|
|
Modes.net_heartbeat_rate = MODES_NET_HEARTBEAT_RATE;
|
|
Modes.net_output_sbs_port = MODES_NET_OUTPUT_SBS_PORT;
|
|
Modes.net_output_raw_port = MODES_NET_OUTPUT_RAW_PORT;
|
|
Modes.net_input_raw_port = MODES_NET_INPUT_RAW_PORT;
|
|
Modes.net_output_beast_port = MODES_NET_OUTPUT_BEAST_PORT;
|
|
Modes.net_input_beast_port = MODES_NET_INPUT_BEAST_PORT;
|
|
Modes.net_http_port = MODES_NET_HTTP_PORT;
|
|
Modes.interactive_rows = getTermRows();
|
|
Modes.interactive_delete_ttl = MODES_INTERACTIVE_DELETE_TTL;
|
|
Modes.interactive_display_ttl = MODES_INTERACTIVE_DISPLAY_TTL;
|
|
Modes.fUserLat = MODES_USER_LATITUDE_DFLT;
|
|
Modes.fUserLon = MODES_USER_LONGITUDE_DFLT;
|
|
}
|
|
//
|
|
//=========================================================================
|
|
//
|
|
void modesInit(void) {
|
|
int i, q;
|
|
|
|
pthread_mutex_init(&Modes.data_mutex,NULL);
|
|
pthread_cond_init(&Modes.data_cond,NULL);
|
|
|
|
// Allocate the various buffers used by Modes
|
|
if ( ((Modes.icao_cache = (uint32_t *) malloc(sizeof(uint32_t) * MODES_ICAO_CACHE_LEN * 2) ) == NULL) ||
|
|
((Modes.pFileData = (uint16_t *) malloc(MODES_ASYNC_BUF_SIZE) ) == NULL) ||
|
|
((Modes.magnitude = (uint16_t *) malloc(MODES_ASYNC_BUF_SIZE+MODES_PREAMBLE_SIZE+MODES_LONG_MSG_SIZE) ) == NULL) ||
|
|
((Modes.maglut = (uint16_t *) malloc(sizeof(uint16_t) * 256 * 256) ) == NULL) ||
|
|
((Modes.beastOut = (char *) malloc(MODES_RAWOUT_BUF_SIZE) ) == NULL) ||
|
|
((Modes.rawOut = (char *) malloc(MODES_RAWOUT_BUF_SIZE) ) == NULL) )
|
|
{
|
|
fprintf(stderr, "Out of memory allocating data buffer.\n");
|
|
exit(1);
|
|
}
|
|
|
|
// Clear the buffers that have just been allocated, just in-case
|
|
memset(Modes.icao_cache, 0, sizeof(uint32_t) * MODES_ICAO_CACHE_LEN * 2);
|
|
memset(Modes.pFileData,127, MODES_ASYNC_BUF_SIZE);
|
|
memset(Modes.magnitude, 0, MODES_ASYNC_BUF_SIZE+MODES_PREAMBLE_SIZE+MODES_LONG_MSG_SIZE);
|
|
|
|
// Validate the users Lat/Lon home location inputs
|
|
if ( (Modes.fUserLat > 90.0) // Latitude must be -90 to +90
|
|
|| (Modes.fUserLat < -90.0) // and
|
|
|| (Modes.fUserLon > 360.0) // Longitude must be -180 to +360
|
|
|| (Modes.fUserLon < -180.0) ) {
|
|
Modes.fUserLat = Modes.fUserLon = 0.0;
|
|
} else if (Modes.fUserLon > 180.0) { // If Longitude is +180 to +360, make it -180 to 0
|
|
Modes.fUserLon -= 360.0;
|
|
}
|
|
// If both Lat and Lon are 0.0 then the users location is either invalid/not-set, or (s)he's in the
|
|
// Atlantic ocean off the west coast of Africa. This is unlikely to be correct.
|
|
// Set the user LatLon valid flag only if either Lat or Lon are non zero. Note the Greenwich meridian
|
|
// is at 0.0 Lon,so we must check for either fLat or fLon being non zero not both.
|
|
// Testing the flag at runtime will be much quicker than ((fLon != 0.0) || (fLat != 0.0))
|
|
Modes.bUserFlags &= ~MODES_USER_LATLON_VALID;
|
|
if ((Modes.fUserLat != 0.0) || (Modes.fUserLon != 0.0)) {
|
|
Modes.bUserFlags |= MODES_USER_LATLON_VALID;
|
|
}
|
|
|
|
// Limit the maximum requested raw output size to less than one Ethernet Block
|
|
if (Modes.net_output_raw_size > (MODES_RAWOUT_BUF_FLUSH))
|
|
{Modes.net_output_raw_size = MODES_RAWOUT_BUF_FLUSH;}
|
|
if (Modes.net_output_raw_rate > (MODES_RAWOUT_BUF_RATE))
|
|
{Modes.net_output_raw_rate = MODES_RAWOUT_BUF_RATE;}
|
|
if (Modes.net_sndbuf_size > (MODES_NET_SNDBUF_MAX))
|
|
{Modes.net_sndbuf_size = MODES_NET_SNDBUF_MAX;}
|
|
|
|
// Initialise the Block Timers to something half sensible
|
|
ftime(&Modes.stSystemTimeBlk);
|
|
for (i = 0; i < MODES_ASYNC_BUF_NUMBER; i++)
|
|
{Modes.stSystemTimeRTL[i] = Modes.stSystemTimeBlk;}
|
|
|
|
// Each I and Q value varies from 0 to 255, which represents a range from -1 to +1. To get from the
|
|
// unsigned (0-255) range you therefore subtract 127 (or 128 or 127.5) from each I and Q, giving you
|
|
// a range from -127 to +128 (or -128 to +127, or -127.5 to +127.5)..
|
|
//
|
|
// To decode the AM signal, you need the magnitude of the waveform, which is given by sqrt((I^2)+(Q^2))
|
|
// The most this could be is if I&Q are both 128 (or 127 or 127.5), so you could end up with a magnitude
|
|
// of 181.019 (or 179.605, or 180.312)
|
|
//
|
|
// However, in reality the magnitude of the signal should never exceed the range -1 to +1, because the
|
|
// values are I = rCos(w) and Q = rSin(w). Therefore the integer computed magnitude should (can?) never
|
|
// exceed 128 (or 127, or 127.5 or whatever)
|
|
//
|
|
// If we scale up the results so that they range from 0 to 65535 (16 bits) then we need to multiply
|
|
// by 511.99, (or 516.02 or 514). antirez's original code multiplies by 360, presumably because he's
|
|
// assuming the maximim calculated amplitude is 181.019, and (181.019 * 360) = 65166.
|
|
//
|
|
// So lets see if we can improve things by subtracting 127.5, Well in integer arithmatic we can't
|
|
// subtract half, so, we'll double everything up and subtract one, and then compensate for the doubling
|
|
// in the multiplier at the end.
|
|
//
|
|
// If we do this we can never have I or Q equal to 0 - they can only be as small as +/- 1.
|
|
// This gives us a minimum magnitude of root 2 (0.707), so the dynamic range becomes (1.414-255). This
|
|
// also affects our scaling value, which is now 65535/(255 - 1.414), or 258.433254
|
|
//
|
|
// The sums then become mag = 258.433254 * (sqrt((I*2-255)^2 + (Q*2-255)^2) - 1.414)
|
|
// or mag = (258.433254 * sqrt((I*2-255)^2 + (Q*2-255)^2)) - 365.4798
|
|
//
|
|
// We also need to clip mag just incaes any rogue I/Q values somehow do have a magnitude greater than 255.
|
|
//
|
|
|
|
for (i = 0; i <= 255; i++) {
|
|
for (q = 0; q <= 255; q++) {
|
|
int mag, mag_i, mag_q;
|
|
|
|
mag_i = (i * 2) - 255;
|
|
mag_q = (q * 2) - 255;
|
|
|
|
mag = (int) round((sqrt((mag_i*mag_i)+(mag_q*mag_q)) * 258.433254) - 365.4798);
|
|
|
|
Modes.maglut[(i*256)+q] = (uint16_t) ((mag < 65535) ? mag : 65535);
|
|
}
|
|
}
|
|
|
|
// Prepare error correction tables
|
|
modesInitErrorInfo();
|
|
}
|
|
//
|
|
// =============================== RTLSDR handling ==========================
|
|
//
|
|
void modesInitRTLSDR(void) {
|
|
int j;
|
|
int device_count;
|
|
char vendor[256], product[256], serial[256];
|
|
|
|
device_count = rtlsdr_get_device_count();
|
|
if (!device_count) {
|
|
fprintf(stderr, "No supported RTLSDR devices found.\n");
|
|
exit(1);
|
|
}
|
|
|
|
fprintf(stderr, "Found %d device(s):\n", device_count);
|
|
for (j = 0; j < device_count; j++) {
|
|
rtlsdr_get_device_usb_strings(j, vendor, product, serial);
|
|
fprintf(stderr, "%d: %s, %s, SN: %s %s\n", j, vendor, product, serial,
|
|
(j == Modes.dev_index) ? "(currently selected)" : "");
|
|
}
|
|
|
|
if (rtlsdr_open(&Modes.dev, Modes.dev_index) < 0) {
|
|
fprintf(stderr, "Error opening the RTLSDR device: %s\n",
|
|
strerror(errno));
|
|
exit(1);
|
|
}
|
|
|
|
// Set gain, frequency, sample rate, and reset the device
|
|
rtlsdr_set_tuner_gain_mode(Modes.dev,
|
|
(Modes.gain == MODES_AUTO_GAIN) ? 0 : 1);
|
|
if (Modes.gain != MODES_AUTO_GAIN) {
|
|
if (Modes.gain == MODES_MAX_GAIN) {
|
|
// Find the maximum gain available
|
|
int numgains;
|
|
int gains[100];
|
|
|
|
numgains = rtlsdr_get_tuner_gains(Modes.dev, gains);
|
|
Modes.gain = gains[numgains-1];
|
|
fprintf(stderr, "Max available gain is: %.2f\n", Modes.gain/10.0);
|
|
}
|
|
rtlsdr_set_tuner_gain(Modes.dev, Modes.gain);
|
|
fprintf(stderr, "Setting gain to: %.2f\n", Modes.gain/10.0);
|
|
} else {
|
|
fprintf(stderr, "Using automatic gain control.\n");
|
|
}
|
|
rtlsdr_set_freq_correction(Modes.dev, Modes.ppm_error);
|
|
if (Modes.enable_agc) rtlsdr_set_agc_mode(Modes.dev, 1);
|
|
rtlsdr_set_center_freq(Modes.dev, Modes.freq);
|
|
rtlsdr_set_sample_rate(Modes.dev, MODES_DEFAULT_RATE);
|
|
rtlsdr_reset_buffer(Modes.dev);
|
|
fprintf(stderr, "Gain reported by device: %.2f\n",
|
|
rtlsdr_get_tuner_gain(Modes.dev)/10.0);
|
|
}
|
|
//
|
|
//=========================================================================
|
|
//
|
|
// We use a thread reading data in background, while the main thread
|
|
// handles decoding and visualization of data to the user.
|
|
//
|
|
// The reading thread calls the RTLSDR API to read data asynchronously, and
|
|
// uses a callback to populate the data buffer.
|
|
//
|
|
// A Mutex is used to avoid races with the decoding thread.
|
|
//
|
|
void rtlsdrCallback(unsigned char *buf, uint32_t len, void *ctx) {
|
|
|
|
MODES_NOTUSED(ctx);
|
|
|
|
// Lock the data buffer variables before accessing them
|
|
pthread_mutex_lock(&Modes.data_mutex);
|
|
|
|
Modes.iDataIn &= (MODES_ASYNC_BUF_NUMBER-1); // Just incase!!!
|
|
|
|
// Get the system time for this block
|
|
ftime(&Modes.stSystemTimeRTL[Modes.iDataIn]);
|
|
|
|
if (len > MODES_ASYNC_BUF_SIZE) {len = MODES_ASYNC_BUF_SIZE;}
|
|
|
|
// Queue the new data
|
|
Modes.pData[Modes.iDataIn] = (uint16_t *) buf;
|
|
Modes.iDataIn = (MODES_ASYNC_BUF_NUMBER-1) & (Modes.iDataIn + 1);
|
|
Modes.iDataReady = (MODES_ASYNC_BUF_NUMBER-1) & (Modes.iDataIn - Modes.iDataOut);
|
|
|
|
if (Modes.iDataReady == 0) {
|
|
// Ooooops. We've just received the MODES_ASYNC_BUF_NUMBER'th outstanding buffer
|
|
// This means that RTLSDR is currently overwriting the MODES_ASYNC_BUF_NUMBER+1
|
|
// buffer, but we havent yet processed it, so we're going to lose it. There
|
|
// isn't much we can do to recover the lost data, but we can correct things to
|
|
// avoid any additional problems.
|
|
Modes.iDataOut = (MODES_ASYNC_BUF_NUMBER-1) & (Modes.iDataOut+1);
|
|
Modes.iDataReady = (MODES_ASYNC_BUF_NUMBER-1);
|
|
Modes.iDataLost++;
|
|
}
|
|
|
|
// Signal to the other thread that new data is ready, and unlock
|
|
pthread_cond_signal(&Modes.data_cond);
|
|
pthread_mutex_unlock(&Modes.data_mutex);
|
|
}
|
|
//
|
|
//=========================================================================
|
|
//
|
|
// This is used when --ifile is specified in order to read data from file
|
|
// instead of using an RTLSDR device
|
|
//
|
|
void readDataFromFile(void) {
|
|
pthread_mutex_lock(&Modes.data_mutex);
|
|
while(Modes.exit == 0) {
|
|
ssize_t nread, toread;
|
|
unsigned char *p;
|
|
|
|
if (Modes.iDataReady) {
|
|
pthread_cond_wait(&Modes.data_cond, &Modes.data_mutex);
|
|
continue;
|
|
}
|
|
|
|
if (Modes.interactive) {
|
|
// When --ifile and --interactive are used together, slow down
|
|
// playing at the natural rate of the RTLSDR received.
|
|
pthread_mutex_unlock(&Modes.data_mutex);
|
|
usleep(64000);
|
|
pthread_mutex_lock(&Modes.data_mutex);
|
|
}
|
|
|
|
toread = MODES_ASYNC_BUF_SIZE;
|
|
p = (unsigned char *) Modes.pFileData;
|
|
while(toread) {
|
|
nread = read(Modes.fd, p, toread);
|
|
if (nread <= 0) {
|
|
Modes.exit = 1; // Signal the other threads to exit.
|
|
break;
|
|
}
|
|
p += nread;
|
|
toread -= nread;
|
|
}
|
|
if (toread) {
|
|
// Not enough data on file to fill the buffer? Pad with no signal.
|
|
memset(p,127,toread);
|
|
}
|
|
|
|
Modes.iDataIn &= (MODES_ASYNC_BUF_NUMBER-1); // Just incase!!!
|
|
|
|
// Get the system time for this block
|
|
ftime(&Modes.stSystemTimeRTL[Modes.iDataIn]);
|
|
|
|
// Queue the new data
|
|
Modes.pData[Modes.iDataIn] = Modes.pFileData;
|
|
Modes.iDataIn = (MODES_ASYNC_BUF_NUMBER-1) & (Modes.iDataIn + 1);
|
|
Modes.iDataReady = (MODES_ASYNC_BUF_NUMBER-1) & (Modes.iDataIn - Modes.iDataOut);
|
|
|
|
// Signal to the other thread that new data is ready
|
|
pthread_cond_signal(&Modes.data_cond);
|
|
}
|
|
}
|
|
//
|
|
//=========================================================================
|
|
//
|
|
// We read data using a thread, so the main thread only handles decoding
|
|
// without caring about data acquisition
|
|
//
|
|
void *readerThreadEntryPoint(void *arg) {
|
|
MODES_NOTUSED(arg);
|
|
|
|
if (Modes.filename == NULL) {
|
|
rtlsdr_read_async(Modes.dev, rtlsdrCallback, NULL,
|
|
MODES_ASYNC_BUF_NUMBER,
|
|
MODES_ASYNC_BUF_SIZE);
|
|
} else {
|
|
readDataFromFile();
|
|
}
|
|
// Signal to the other thread that new data is ready - dummy really so threads don't mutually lock
|
|
pthread_cond_signal(&Modes.data_cond);
|
|
pthread_mutex_unlock(&Modes.data_mutex);
|
|
#ifndef _WIN32
|
|
pthread_exit(NULL);
|
|
#else
|
|
return NULL;
|
|
#endif
|
|
}
|
|
//
|
|
// ============================== Snip mode =================================
|
|
//
|
|
// Get raw IQ samples and filter everything is < than the specified level
|
|
// for more than 256 samples in order to reduce example file size
|
|
//
|
|
void snipMode(int level) {
|
|
int i, q;
|
|
uint64_t c = 0;
|
|
|
|
while ((i = getchar()) != EOF && (q = getchar()) != EOF) {
|
|
if (abs(i-127) < level && abs(q-127) < level) {
|
|
c++;
|
|
if (c > MODES_PREAMBLE_SIZE) continue;
|
|
} else {
|
|
c = 0;
|
|
}
|
|
putchar(i);
|
|
putchar(q);
|
|
}
|
|
}
|
|
//
|
|
// ================================ Main ====================================
|
|
//
|
|
void showHelp(void) {
|
|
printf(
|
|
"-----------------------------------------------------------------------------\n"
|
|
"| dump1090 ModeS Receiver Ver : " MODES_DUMP1090_VERSION " |\n"
|
|
"-----------------------------------------------------------------------------\n"
|
|
"--device-index <index> Select RTL device (default: 0)\n"
|
|
"--gain <db> Set gain (default: max gain. Use -100 for auto-gain)\n"
|
|
"--enable-agc Enable the Automatic Gain Control (default: off)\n"
|
|
"--freq <hz> Set frequency (default: 1090 Mhz)\n"
|
|
"--ifile <filename> Read data from file (use '-' for stdin)\n"
|
|
"--interactive Interactive mode refreshing data on screen\n"
|
|
"--interactive-rows <num> Max number of rows in interactive mode (default: 15)\n"
|
|
"--interactive-ttl <sec> Remove from list if idle for <sec> (default: 60)\n"
|
|
"--interactive-rtl1090 Display flight table in RTL1090 format\n"
|
|
"--raw Show only messages hex values\n"
|
|
"--net Enable networking\n"
|
|
"--modeac Enable decoding of SSR Modes 3/A & 3/C\n"
|
|
"--net-beast TCP raw output in Beast binary format\n"
|
|
"--net-only Enable just networking, no RTL device or file used\n"
|
|
"--net-http-port <port> HTTP server port (default: 8080)\n"
|
|
"--net-ri-port <port> TCP raw input listen port (default: 30001)\n"
|
|
"--net-ro-port <port> TCP raw output listen port (default: 30002)\n"
|
|
"--net-sbs-port <port> TCP BaseStation output listen port (default: 30003)\n"
|
|
"--net-bi-port <port> TCP Beast input listen port (default: 30004)\n"
|
|
"--net-bo-port <port> TCP Beast output listen port (default: 30005)\n"
|
|
"--net-ro-size <size> TCP raw output minimum size (default: 0)\n"
|
|
"--net-ro-rate <rate> TCP raw output memory flush rate (default: 0)\n"
|
|
"--net-heartbeat <rate> TCP heartbeat rate in seconds (default: 60 sec)\n"
|
|
"--net-buffer <n> TCP buffer size 64Kb * (2^n) (default: n=0, 64Kb)\n"
|
|
"--lat <latitude> Reference/receiver latitude for surface posn (opt)\n"
|
|
"--lon <longitude> Reference/receiver longitude for surface posn (opt)\n"
|
|
"--fix Enable single-bits error correction using CRC\n"
|
|
"--no-fix Disable single-bits error correction using CRC\n"
|
|
"--no-crc-check Disable messages with broken CRC (discouraged)\n"
|
|
"--phase-enhance Enable phase enhancement\n"
|
|
"--aggressive More CPU for more messages (two bits fixes, ...)\n"
|
|
"--mlat display raw messages in Beast ascii mode\n"
|
|
"--stats With --ifile print stats at exit. No other output\n"
|
|
"--onlyaddr Show only ICAO addresses (testing purposes)\n"
|
|
"--metric Use metric units (meters, km/h, ...)\n"
|
|
"--snip <level> Strip IQ file removing samples < level\n"
|
|
"--debug <flags> Debug mode (verbose), see README for details\n"
|
|
"--quiet Disable output to stdout. Use for daemon applications\n"
|
|
"--ppm <error> Set receiver error in parts per million (default 0)\n"
|
|
"--help Show this help\n"
|
|
"\n"
|
|
"Debug mode flags: d = Log frames decoded with errors\n"
|
|
" D = Log frames decoded with zero errors\n"
|
|
" c = Log frames with bad CRC\n"
|
|
" C = Log frames with good CRC\n"
|
|
" p = Log frames with bad preamble\n"
|
|
" n = Log network debugging info\n"
|
|
" j = Log frames to frames.js, loadable by debug.html\n"
|
|
);
|
|
}
|
|
|
|
#ifdef _WIN32
|
|
void showCopyright(void) {
|
|
uint64_t llTime = time(NULL) + 1;
|
|
|
|
printf(
|
|
"-----------------------------------------------------------------------------\n"
|
|
"| dump1090 ModeS Receiver Ver : " MODES_DUMP1090_VERSION " |\n"
|
|
"-----------------------------------------------------------------------------\n"
|
|
"\n"
|
|
" Copyright (C) 2012 by Salvatore Sanfilippo <antirez@gmail.com>\n"
|
|
" Copyright (C) 2014 by Malcolm Robb <support@attavionics.com>\n"
|
|
"\n"
|
|
" All rights reserved.\n"
|
|
"\n"
|
|
" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n"
|
|
" ""AS IS"" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n"
|
|
" LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n"
|
|
" A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n"
|
|
" HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n"
|
|
" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n"
|
|
" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n"
|
|
" DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n"
|
|
" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n"
|
|
" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n"
|
|
" OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n"
|
|
"\n"
|
|
" For further details refer to <https://github.com/MalcolmRobb/dump1090>\n"
|
|
"\n"
|
|
);
|
|
|
|
// delay for 1 second to give the user a chance to read the copyright
|
|
while (llTime >= time(NULL)) {}
|
|
}
|
|
#endif
|
|
//
|
|
//=========================================================================
|
|
//
|
|
// This function is called a few times every second by main in order to
|
|
// perform tasks we need to do continuously, like accepting new clients
|
|
// from the net, refreshing the screen in interactive mode, and so forth
|
|
//
|
|
void backgroundTasks(void) {
|
|
if (Modes.net) {
|
|
modesReadFromClients();
|
|
}
|
|
|
|
// If Modes.aircrafts is not NULL, remove any stale aircraft
|
|
if (Modes.aircrafts) {
|
|
interactiveRemoveStaleAircrafts();
|
|
}
|
|
|
|
// Refresh screen when in interactive mode
|
|
if (Modes.interactive) {
|
|
interactiveShowData();
|
|
}
|
|
}
|
|
//
|
|
//=========================================================================
|
|
//
|
|
int main(int argc, char **argv) {
|
|
int j;
|
|
|
|
// Set sane defaults
|
|
modesInitConfig();
|
|
signal(SIGINT, sigintHandler); // Define Ctrl/C handler (exit program)
|
|
|
|
// Parse the command line options
|
|
for (j = 1; j < argc; j++) {
|
|
int more = j+1 < argc; // There are more arguments
|
|
|
|
if (!strcmp(argv[j],"--device-index") && more) {
|
|
Modes.dev_index = atoi(argv[++j]);
|
|
} else if (!strcmp(argv[j],"--gain") && more) {
|
|
Modes.gain = (int) atof(argv[++j])*10; // Gain is in tens of DBs
|
|
} else if (!strcmp(argv[j],"--enable-agc")) {
|
|
Modes.enable_agc++;
|
|
} else if (!strcmp(argv[j],"--freq") && more) {
|
|
Modes.freq = (int) strtoll(argv[++j],NULL,10);
|
|
} else if (!strcmp(argv[j],"--ifile") && more) {
|
|
Modes.filename = strdup(argv[++j]);
|
|
} else if (!strcmp(argv[j],"--fix")) {
|
|
Modes.nfix_crc = 1;
|
|
} else if (!strcmp(argv[j],"--no-fix")) {
|
|
Modes.nfix_crc = 0;
|
|
} else if (!strcmp(argv[j],"--no-crc-check")) {
|
|
Modes.check_crc = 0;
|
|
} else if (!strcmp(argv[j],"--phase-enhance")) {
|
|
Modes.phase_enhance = 1;
|
|
} else if (!strcmp(argv[j],"--raw")) {
|
|
Modes.raw = 1;
|
|
} else if (!strcmp(argv[j],"--net")) {
|
|
Modes.net = 1;
|
|
} else if (!strcmp(argv[j],"--modeac")) {
|
|
Modes.mode_ac = 1;
|
|
} else if (!strcmp(argv[j],"--net-beast")) {
|
|
Modes.beast = 1;
|
|
} else if (!strcmp(argv[j],"--net-only")) {
|
|
Modes.net = 1;
|
|
Modes.net_only = 1;
|
|
} else if (!strcmp(argv[j],"--net-heartbeat") && more) {
|
|
Modes.net_heartbeat_rate = atoi(argv[++j]) * 15;
|
|
} else if (!strcmp(argv[j],"--net-ro-size") && more) {
|
|
Modes.net_output_raw_size = atoi(argv[++j]);
|
|
} else if (!strcmp(argv[j],"--net-ro-rate") && more) {
|
|
Modes.net_output_raw_rate = atoi(argv[++j]);
|
|
} else if (!strcmp(argv[j],"--net-ro-port") && more) {
|
|
if (Modes.beast) // Required for legacy backward compatibility
|
|
{Modes.net_output_beast_port = atoi(argv[++j]);;}
|
|
else
|
|
{Modes.net_output_raw_port = atoi(argv[++j]);}
|
|
} else if (!strcmp(argv[j],"--net-ri-port") && more) {
|
|
Modes.net_input_raw_port = atoi(argv[++j]);
|
|
} else if (!strcmp(argv[j],"--net-bo-port") && more) {
|
|
Modes.net_output_beast_port = atoi(argv[++j]);
|
|
} else if (!strcmp(argv[j],"--net-bi-port") && more) {
|
|
Modes.net_input_beast_port = atoi(argv[++j]);
|
|
} else if (!strcmp(argv[j],"--net-http-port") && more) {
|
|
Modes.net_http_port = atoi(argv[++j]);
|
|
} else if (!strcmp(argv[j],"--net-sbs-port") && more) {
|
|
Modes.net_output_sbs_port = atoi(argv[++j]);
|
|
} else if (!strcmp(argv[j],"--net-buffer") && more) {
|
|
Modes.net_sndbuf_size = atoi(argv[++j]);
|
|
} else if (!strcmp(argv[j],"--onlyaddr")) {
|
|
Modes.onlyaddr = 1;
|
|
} else if (!strcmp(argv[j],"--metric")) {
|
|
Modes.metric = 1;
|
|
} else if (!strcmp(argv[j],"--aggressive")) {
|
|
Modes.nfix_crc = MODES_MAX_BITERRORS;
|
|
} else if (!strcmp(argv[j],"--interactive")) {
|
|
Modes.interactive = 1;
|
|
} else if (!strcmp(argv[j],"--interactive-rows") && more) {
|
|
Modes.interactive_rows = atoi(argv[++j]);
|
|
} else if (!strcmp(argv[j],"--interactive-ttl") && more) {
|
|
Modes.interactive_display_ttl = atoi(argv[++j]);
|
|
} else if (!strcmp(argv[j],"--lat") && more) {
|
|
Modes.fUserLat = atof(argv[++j]);
|
|
} else if (!strcmp(argv[j],"--lon") && more) {
|
|
Modes.fUserLon = atof(argv[++j]);
|
|
} else if (!strcmp(argv[j],"--debug") && more) {
|
|
char *f = argv[++j];
|
|
while(*f) {
|
|
switch(*f) {
|
|
case 'D': Modes.debug |= MODES_DEBUG_DEMOD; break;
|
|
case 'd': Modes.debug |= MODES_DEBUG_DEMODERR; break;
|
|
case 'C': Modes.debug |= MODES_DEBUG_GOODCRC; break;
|
|
case 'c': Modes.debug |= MODES_DEBUG_BADCRC; break;
|
|
case 'p': Modes.debug |= MODES_DEBUG_NOPREAMBLE; break;
|
|
case 'n': Modes.debug |= MODES_DEBUG_NET; break;
|
|
case 'j': Modes.debug |= MODES_DEBUG_JS; break;
|
|
default:
|
|
fprintf(stderr, "Unknown debugging flag: %c\n", *f);
|
|
exit(1);
|
|
break;
|
|
}
|
|
f++;
|
|
}
|
|
} else if (!strcmp(argv[j],"--stats")) {
|
|
Modes.stats = 1;
|
|
} else if (!strcmp(argv[j],"--snip") && more) {
|
|
snipMode(atoi(argv[++j]));
|
|
exit(0);
|
|
} else if (!strcmp(argv[j],"--help")) {
|
|
showHelp();
|
|
exit(0);
|
|
} else if (!strcmp(argv[j],"--ppm") && more) {
|
|
Modes.ppm_error = atoi(argv[++j]);
|
|
} else if (!strcmp(argv[j],"--quiet")) {
|
|
Modes.quiet = 1;
|
|
} else if (!strcmp(argv[j],"--mlat")) {
|
|
Modes.mlat = 1;
|
|
} else if (!strcmp(argv[j],"--interactive-rtl1090")) {
|
|
Modes.interactive = 1;
|
|
Modes.interactive_rtl1090 = 1;
|
|
} else {
|
|
fprintf(stderr,
|
|
"Unknown or not enough arguments for option '%s'.\n\n",
|
|
argv[j]);
|
|
showHelp();
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
#ifdef _WIN32
|
|
// Try to comply with the Copyright license conditions for binary distribution
|
|
if (!Modes.quiet) {showCopyright();}
|
|
#endif
|
|
|
|
#ifndef _WIN32
|
|
// Setup for SIGWINCH for handling lines
|
|
if (Modes.interactive) {signal(SIGWINCH, sigWinchCallback);}
|
|
#endif
|
|
|
|
// Initialization
|
|
modesInit();
|
|
|
|
if (Modes.net_only) {
|
|
fprintf(stderr,"Net-only mode, no RTL device or file open.\n");
|
|
} else if (Modes.filename == NULL) {
|
|
modesInitRTLSDR();
|
|
} else {
|
|
if (Modes.filename[0] == '-' && Modes.filename[1] == '\0') {
|
|
Modes.fd = STDIN_FILENO;
|
|
} else if ((Modes.fd = open(Modes.filename,O_RDONLY)) == -1) {
|
|
perror("Opening data file");
|
|
exit(1);
|
|
}
|
|
}
|
|
if (Modes.net) modesInitNet();
|
|
|
|
// If the user specifies --net-only, just run in order to serve network
|
|
// clients without reading data from the RTL device
|
|
while (Modes.net_only) {
|
|
if (Modes.exit) exit(0); // If we exit net_only nothing further in main()
|
|
backgroundTasks();
|
|
usleep(100000);
|
|
}
|
|
|
|
// Create the thread that will read the data from the device.
|
|
pthread_create(&Modes.reader_thread, NULL, readerThreadEntryPoint, NULL);
|
|
pthread_mutex_lock(&Modes.data_mutex);
|
|
|
|
while (Modes.exit == 0) {
|
|
|
|
if (Modes.iDataReady == 0) {
|
|
pthread_cond_wait(&Modes.data_cond,&Modes.data_mutex); // This unlocks Modes.data_mutex, and waits for Modes.data_cond
|
|
continue; // Once (Modes.data_cond) occurs, it locks Modes.data_mutex
|
|
}
|
|
|
|
// Modes.data_mutex is Locked, and (Modes.iDataReady != 0)
|
|
if (Modes.iDataReady) { // Check we have new data, just in case!!
|
|
|
|
Modes.iDataOut &= (MODES_ASYNC_BUF_NUMBER-1); // Just incase
|
|
|
|
// Translate the next lot of I/Q samples into Modes.magnitude
|
|
computeMagnitudeVector(Modes.pData[Modes.iDataOut]);
|
|
|
|
Modes.stSystemTimeBlk = Modes.stSystemTimeRTL[Modes.iDataOut];
|
|
|
|
// Update the input buffer pointer queue
|
|
Modes.iDataOut = (MODES_ASYNC_BUF_NUMBER-1) & (Modes.iDataOut + 1);
|
|
Modes.iDataReady = (MODES_ASYNC_BUF_NUMBER-1) & (Modes.iDataIn - Modes.iDataOut);
|
|
|
|
// If we lost some blocks, correct the timestamp
|
|
if (Modes.iDataLost) {
|
|
Modes.timestampBlk += (MODES_ASYNC_BUF_SAMPLES * 6 * Modes.iDataLost);
|
|
Modes.iDataLost = 0;
|
|
}
|
|
|
|
// It's safe to release the lock now
|
|
pthread_cond_signal (&Modes.data_cond);
|
|
pthread_mutex_unlock(&Modes.data_mutex);
|
|
|
|
// Process data after releasing the lock, so that the capturing
|
|
// thread can read data while we perform computationally expensive
|
|
// stuff at the same time.
|
|
detectModeS(Modes.magnitude, MODES_ASYNC_BUF_SAMPLES);
|
|
|
|
// Update the timestamp ready for the next block
|
|
Modes.timestampBlk += (MODES_ASYNC_BUF_SAMPLES*6);
|
|
|
|
} else {
|
|
pthread_cond_signal (&Modes.data_cond);
|
|
pthread_mutex_unlock(&Modes.data_mutex);
|
|
}
|
|
|
|
backgroundTasks();
|
|
pthread_mutex_lock(&Modes.data_mutex);
|
|
}
|
|
|
|
// If --stats were given, print statistics
|
|
if (Modes.stats) {
|
|
printf("\n\n");
|
|
if (Modes.interactive)
|
|
interactiveShowData();
|
|
printf("%d ModeA/C detected\n", Modes.stat_ModeAC);
|
|
printf("%d valid Mode-S preambles\n", Modes.stat_valid_preamble);
|
|
printf("%d DF-?? fields corrected for length\n", Modes.stat_DF_Len_Corrected);
|
|
printf("%d DF-?? fields corrected for type\n", Modes.stat_DF_Type_Corrected);
|
|
printf("%d demodulated with 0 errors\n", Modes.stat_demodulated0);
|
|
printf("%d demodulated with 1 error\n", Modes.stat_demodulated1);
|
|
printf("%d demodulated with 2 errors\n", Modes.stat_demodulated2);
|
|
printf("%d demodulated with > 2 errors\n", Modes.stat_demodulated3);
|
|
printf("%d with good crc\n", Modes.stat_goodcrc);
|
|
printf("%d with bad crc\n", Modes.stat_badcrc);
|
|
printf("%d errors corrected\n", Modes.stat_fixed);
|
|
for (j = 0; j < MODES_MAX_BITERRORS; j++) {
|
|
printf(" %d with %d bit %s\n", Modes.stat_bit_fix[j], j+1, (j==0)?"error":"errors");
|
|
}
|
|
if (Modes.phase_enhance) {
|
|
printf("%d phase enhancement attempts\n", Modes.stat_out_of_phase);
|
|
printf("%d phase enhanced demodulated with 0 errors\n", Modes.stat_ph_demodulated0);
|
|
printf("%d phase enhanced demodulated with 1 error\n", Modes.stat_ph_demodulated1);
|
|
printf("%d phase enhanced demodulated with 2 errors\n", Modes.stat_ph_demodulated2);
|
|
printf("%d phase enhanced demodulated with > 2 errors\n", Modes.stat_ph_demodulated3);
|
|
printf("%d phase enhanced with good crc\n", Modes.stat_ph_goodcrc);
|
|
printf("%d phase enhanced with bad crc\n", Modes.stat_ph_badcrc);
|
|
printf("%d phase enhanced errors corrected\n", Modes.stat_ph_fixed);
|
|
for (j = 0; j < MODES_MAX_BITERRORS; j++) {
|
|
printf(" %d with %d bit %s\n", Modes.stat_ph_bit_fix[j], j+1, (j==0)?"error":"errors");
|
|
}
|
|
}
|
|
printf("%d total usable messages\n", Modes.stat_goodcrc + Modes.stat_ph_goodcrc + Modes.stat_fixed + Modes.stat_ph_fixed);
|
|
}
|
|
|
|
if (Modes.filename == NULL) {
|
|
rtlsdr_cancel_async(Modes.dev); // Cancel rtlsdr_read_async will cause data input thread to terminate cleanly
|
|
rtlsdr_close(Modes.dev);
|
|
}
|
|
pthread_cond_destroy(&Modes.data_cond); // Thread cleanup
|
|
pthread_mutex_destroy(&Modes.data_mutex);
|
|
pthread_join(Modes.reader_thread,NULL); // Wait on reader thread exit
|
|
#ifndef _WIN32
|
|
pthread_exit(0);
|
|
#else
|
|
return (0);
|
|
#endif
|
|
}
|
|
//
|
|
//=========================================================================
|
|
//
|