// //========================================================================= // void view1090Init(void) { // Allocate the various buffers used by Modes if ( NULL == (Modes.icao_cache = (uint32_t *) malloc(sizeof(uint32_t) * MODES_ICAO_CACHE_LEN * 2))) { 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); // 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; } // Prepare error correction tables modesInitErrorInfo(); }
// //========================================================================= // void ppup1090Init(void) { int iErr; // Allocate the various buffers used by Modes if ( NULL == (Modes.icao_cache = (uint32_t *) malloc(sizeof(uint32_t) * MODES_ICAO_CACHE_LEN * 2))) { 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); // 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; } // Prepare error correction tables modesInitErrorInfo(); // Setup the uploader - read the user paramaters from the coaa.h header file coaa1090.fUserLat = MODES_USER_LATITUDE_DFLT; coaa1090.fUserLon = MODES_USER_LONGITUDE_DFLT; strcpy(coaa1090.strAuthCode,STR(USER_AUTHCODE)); strcpy(coaa1090.strRegNo, STR(USER_REGNO)); strcpy(coaa1090.strVersion, MODES_DUMP1090_VERSION); if ((iErr = initCOAA (coaa1090))) { fprintf(stderr, "Error 0x%X initialising uploader\n", iErr); exit(1); } }
// //========================================================================= // 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;} // 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(); }