MightyPork
/
rtl-sdr
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

rtl_adsb: 16 bit magnitudes

Browse Source 
Signed-off-by: Steve Markgraf <steve@steve-m.de>
master
Kyle Keen 12 years ago committed by Steve Markgraf
parent b656896f66
commit c6a731a0dc
1 changed files with 49 additions and 43 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 92
      src/rtl_adsb.c

92
src/rtl_adsb.c
Unescape View File

@ -54,16 +54,19 @@
#define DEFAULT_BUF_LENGTH (16 * 16384)
#define AUTO_GAIN -100
#define MESSAGEGO 253
#define OVERWRITE 254
#define BADSAMPLE 255
static pthread_t demod_thread;
static sem_t data_ready;
static volatile int do_exit = 0;
static rtlsdr_dev_t *dev = NULL;
/* look up table, could be made smaller */
uint8_t pyth[129][129];
uint16_t squares[256];
/* todo, bundle these up in a struct */
uint8_t *buffer;
uint8_t *buffer; /* also abused for uint16_t */
int verbose_output = 0;
int short_output = 0;
double quality = 1.0;
@ -141,17 +144,7 @@ void display(int *frame, int len)
fprintf(file, "--------------\n");
}
void pyth_precompute(void)
{
int x, y;
double scale = 1.408 ; /* use the full 8 bits */
for (x=0; x<129; x++) {
for (y=0; y<129; y++) {
pyth[x][y] = (uint8_t)round(scale * sqrt(x*x + y*y));
}}
}
inline uint8_t abs8(uint8_t x)
int abs8(int x)
/* do not subtract 128 from the raw iq, this handles it */
{
if (x >= 128) {
@ -159,18 +152,31 @@ inline uint8_t abs8(uint8_t x)
return 128 - x;
}
void squares_precompute(void)
/* equiv to abs(x-128) ^ 2 */
{
int i, j;
// todo, check if this LUT is actually any faster
for (i=0; i<256; i++) {
j = abs8(i);
squares[i] = (uint16_t)(j*j);
}
}
int magnitute(uint8_t *buf, int len)
/* takes i/q, changes buf in place, returns new len */
/* takes i/q, changes buf in place (16 bit), returns new len (16 bit) */
{
int i;
uint16_t *m;
for (i=0; i<len; i+=2) {
buf[i/2] = pyth[abs8(buf[i])][abs8(buf[i+1])];
m = (uint16_t*)(&buf[i]);
*m = squares[buf[i]] + squares[buf[i+1]];
}
return len/2;
}
inline uint8_t single_manchester(uint8_t a, uint8_t b, uint8_t c, uint8_t d)
/* takes 4 consecutive real samples, return 0 or 1, 255 on error */
inline uint16_t single_manchester(uint16_t a, uint16_t b, uint16_t c, uint16_t d)
/* takes 4 consecutive real samples, return 0 or 1, BADSAMPLE on error */
{
int bit, bit_p;
bit_p = a > b;
@ -181,9 +187,9 @@ inline uint8_t single_manchester(uint8_t a, uint8_t b, uint8_t c, uint8_t d)
if (quality == 0.5) {
if ( bit && bit_p && b > c) {
return 255;}
return BADSAMPLE;}
if (!bit && !bit_p && b < c) {
return 255;}
return BADSAMPLE;}
return bit;
}
@ -196,7 +202,7 @@ inline uint8_t single_manchester(uint8_t a, uint8_t b, uint8_t c, uint8_t d)
return 0;}
if (!bit && !bit_p && c < b) {
return 0;}
return 255;
return BADSAMPLE;
}
if ( bit && bit_p && c > b && d < a) {
@ -207,36 +213,36 @@ inline uint8_t single_manchester(uint8_t a, uint8_t b, uint8_t c, uint8_t d)
return 0;}
if (!bit && !bit_p && c < b && d > a) {
return 0;}
return 255;
return BADSAMPLE;
}
inline uint8_t min8(uint8_t a, uint8_t b)
inline uint16_t min16(uint16_t a, uint16_t b)
{
return a<b ? a : b;
}
inline uint8_t max8(uint8_t a, uint8_t b)
inline uint16_t max16(uint16_t a, uint16_t b)
{
return a>b ? a : b;
}
inline int preamble(uint8_t *buf, int len, int i)
inline int preamble(uint16_t *buf, int i)
/* returns 0/1 for preamble at index i */
{
int i2;
uint8_t low = 0;
uint8_t high = 255;
uint16_t low = 0;
uint16_t high = 65535;
for (i2=0; i2<preamble_len; i2++) {
switch (i2) {
case 0:
case 2:
case 7:
case 9:
//high = min8(high, buf[i+i2]);
//high = min16(high, buf[i+i2]);
high = buf[i+i2];
break;
default:
//low = max8(low, buf[i+i2]);
//low = max16(low, buf[i+i2]);
low = buf[i+i2];
break;
}
@ -246,24 +252,24 @@ inline int preamble(uint8_t *buf, int len, int i)
return 1;
}
void manchester(uint8_t *buf, int len)
/* overwrites magnitude buffer with valid bits (255 on errors) */
void manchester(uint16_t *buf, int len)
/* overwrites magnitude buffer with valid bits (BADSAMPLE on errors) */
{
/* a and b hold old values to verify local manchester */
uint8_t a=0, b=0;
uint8_t bit;
uint16_t a=0, b=0;
uint16_t bit;
int i, i2, start, errors;
// todo, allow wrap across buffers
i = 0;
while (i < len) {
/* find preamble */
for ( ; i < (len - preamble_len); i++) {
if (!preamble(buf, len, i)) {
if (!preamble(buf, i)) {
continue;}
a = buf[i];
b = buf[i+1];
for (i2=0; i2<preamble_len; i2++) {
buf[i+i2] = 253;}
buf[i+i2] = MESSAGEGO;}
i += preamble_len;
break;
}
@ -274,25 +280,25 @@ void manchester(uint8_t *buf, int len)
bit = single_manchester(a, b, buf[i], buf[i+1]);
a = buf[i];
b = buf[i+1];
if (bit == 255) {
if (bit == BADSAMPLE) {
errors += 1;
if (errors > allowed_errors) {
buf[i2] = 255;
buf[i2] = BADSAMPLE;
break;
} else {
bit = a > b;
/* these don't have to match the bit */
a = 0;
b = 255;
b = 65535;
}
}
buf[i] = buf[i+1] = 254; /* to be overwritten */
buf[i] = buf[i+1] = OVERWRITE;
buf[i2] = bit;
}
}
}
void messages(uint8_t *buf, int len)
void messages(uint16_t *buf, int len)
{
int i, i2, start, preamble_found;
int data_i, index, shift, frame_len;
@ -343,8 +349,8 @@ static void *demod_thread_fn(void *arg)
while (!do_exit) {
sem_wait(&data_ready);
len = magnitute(buffer, DEFAULT_BUF_LENGTH);
manchester(buffer, len);
messages(buffer, len);
manchester((uint16_t*)buffer, len);
messages((uint16_t*)buffer, len);
}
rtlsdr_cancel_async(dev);
return 0;
@ -363,7 +369,7 @@ int main(int argc, char **argv)
int ppm_error = 0;
char vendor[256], product[256], serial[256];
sem_init(&data_ready, 0, 0);
pyth_precompute();
squares_precompute();
while ((opt = getopt(argc, argv, "d:g:p:e:Q:VS")) != -1)
{

Write Preview
Loading…
Cancel
Save