X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2Fdrivers%2Fao_aprs.c;h=8a1b6a4df2763e1e74ec9f61a082dc012f0da082;hb=dcaaf51245b44a440ee8590512f71195c30c16ae;hp=96e90f0027f080faa4015d660bcdaab7ecaa85de;hpb=9d812b3db418fd9816731b761a0853eb38f5a265;p=fw%2Faltos diff --git a/src/drivers/ao_aprs.c b/src/drivers/ao_aprs.c index 96e90f00..8a1b6a4d 100644 --- a/src/drivers/ao_aprs.c +++ b/src/drivers/ao_aprs.c @@ -144,7 +144,6 @@ #endif #include -#include // Public methods, constants, and data structures for each class. @@ -488,110 +487,253 @@ static void tncCompressInt(uint8_t *dest, int32_t value, int len) { } } +static int ao_num_sats(void) +{ + int i; + int n = 0; + + for (i = 0; i < ao_gps_tracking_data.channels; i++) { + if (ao_gps_tracking_data.sats[i].svid) + n++; + } + return n; +} + +static char ao_gps_locked(void) +{ + if (ao_gps_data.flags & AO_GPS_VALID) + return 'L'; + else + return 'U'; +} + +static int tncComment(uint8_t *buf) +{ +#if HAS_ADC + struct ao_data packet; + + ao_arch_critical(ao_data_get(&packet);); + + int16_t battery = ao_battery_decivolt(packet.adc.v_batt); +#ifdef AO_SENSE_DROGUE + int16_t apogee = ao_ignite_decivolt(AO_SENSE_DROGUE(&packet)); +#endif +#ifdef AO_SENSE_MAIN + int16_t main = ao_ignite_decivolt(AO_SENSE_MAIN(&packet)); +#endif + + return sprintf((char *) buf, + "%c%d B%d.%d" +#ifdef AO_SENSE_DROGUE + " A%d.%d" +#endif +#ifdef AO_SENSE_MAIN + " M%d.%d" +#endif + , ao_gps_locked(), + ao_num_sats(), + battery/10, + battery % 10 +#ifdef AO_SENSE_DROGUE + , apogee/10, + apogee%10 +#endif +#ifdef AO_SENSE_MAIN + , main/10, + main%10 +#endif + ); +#else + return sprintf((char *) buf, + "%c%d", + ao_gps_locked(), + ao_num_sats()); +#endif +} + +/* + * APRS use a log encoding of altitude with a base of 1.002, such that + * + * feet = 1.002 ** encoded_altitude + * + * meters = (1.002 ** encoded_altitude) * 0.3048 + * + * log2(meters) = log2(1.002 ** encoded_altitude) + log2(0.3048) + * + * log2(meters) = encoded_altitude * log2(1.002) + log2(0.3048) + * + * encoded_altitude = (log2(meters) - log2(0.3048)) / log2(1.002) + * + * encoded_altitude = (log2(meters) + log2(1/0.3048)) * (1/log2(1.002)) + * + * We need 9 bits of mantissa to hold 1/log2(1.002) (~ 347), which leaves us + * 23 bits of fraction. That turns out to be *just* enough to avoid any + * errors in the result (cool, huh?). + */ + +#define fixed23_int(x) ((uint32_t) ((x) << 23)) +#define fixed23_one fixed23_int(1) +#define fixed23_two fixed23_int(2) +#define fixed23_half (fixed23_one >> 1) +#define fixed23_floor(x) ((x) >> 23) +#define fixed23_real(x) ((uint32_t) ((x) * fixed23_one + 0.5)) + +static inline uint64_t +fixed23_mul(uint32_t x, uint32_t y) +{ + return ((uint64_t) x * y + fixed23_half) >> 23; +} + +/* + * Use 30 fraction bits for the altitude. We need two bits at the + * top as we need to handle x, where 0 <= x < 4. We don't + * need 30 bits, but it's actually easier this way as we normalize + * the incoming value to 1 <= x < 2, and having the integer portion + * way up high means we don't have to deal with shifting in both + * directions to cover from 0 to 2**30-1. + */ + +#define fixed30_int(x) ((uint32_t) ((x) << 30)) +#define fixed30_one fixed30_int(1) +#define fixed30_half (fixed30_one >> 1) +#define fixed30_two fixed30_int(2) + +static inline uint32_t +fixed30_mul(uint32_t x, uint32_t y) +{ + return ((uint64_t) x * y + fixed30_half) >> 30; +} + +/* + * Fixed point log2. Takes integer argument, returns + * fixed point result with 23 bits of fraction + */ + +static uint32_t +ao_fixed_log2(uint32_t x) +{ + uint32_t result; + uint32_t frac = fixed23_one; + + /* Bounds check for sanity */ + if (x <= 0) + return 0; + + if (x >= fixed30_one) + return 0xffffffff; + + /* + * Normalize and compute integer log portion + * + * This makes 1 <= x < 2, and computes result to be + * the integer portion of the log2 of x + */ + + for (result = fixed23_int(30); x < fixed30_one; result -= fixed23_one, x <<= 1) + ; + + /* + * Given x, find y and n such that: + * + * x = y * 2**n 1 <= y < 2 + * + * That means: + * + * lb(x) = n + lb(y) + * + * Now, repeatedly square y to find find z and m such that: + * + * z = y ** (2**m) 2 <= z < 4 + * + * This is possible because 1 <= y < 2 + * + * lb(y) = lb(z) / 2**m + * + * (1 + lb(z/2)) + * = ------------- + * 2**m + * + * = 2**-m + 2**-m * lb(z/2) + * + * Note that if 2 <= z < 4, then 1 <= (z/2) < 2, so we can + * iterate to find lb(z/2) + * + * In this implementation, we don't care about the 'm' value, + * instead we only care about 2**-m, which we store in 'frac' + */ + + while (frac != 0 && x != fixed30_one) { + /* Repeatedly square x until 2 <= x < 4 */ + while (x < fixed30_two) { + x = fixed30_mul(x, x); + + /* Divide the fractional result bit by 2 */ + frac >>= 1; + } + + /* Add in this result bit */ + result |= frac; + + /* Make 1 <= x < 2 again and iterate */ + x >>= 1; + } + return result; +} + +#define APRS_LOG_CONVERT fixed23_real(1.714065192056127) +#define APRS_LOG_BASE fixed23_real(346.920048461100941) + +static int +ao_aprs_encode_altitude(int meters) +{ + return fixed23_floor(fixed23_mul(ao_fixed_log2(meters) + APRS_LOG_CONVERT, APRS_LOG_BASE) + fixed23_half); +} + /** * Generate the plain text position packet. */ static int tncPositionPacket(void) { - int32_t latitude = ao_gps_data.latitude; - int32_t longitude = ao_gps_data.longitude; - int32_t altitude = ao_gps_data.altitude; + static int32_t latitude; + static int32_t longitude; + static int32_t altitude; + int32_t lat, lon, alt; uint8_t *buf; - if (altitude < 0) - altitude = 0; - altitude = (altitude * (int32_t) 10000 + (3048/2)) / (int32_t) 3048; - -#if 0 - char lat_sign = 'N', lon_sign = 'E'; - uint16_t lat_deg; - uint16_t lon_deg; - uint16_t lat_min; - uint16_t lat_frac; - uint16_t lon_min; - uint16_t lon_frac; - - if (latitude < 0) { - lat_sign = 'S'; - latitude = -latitude; - } - - if (longitude < 0) { - lon_sign = 'W'; - longitude = -longitude; + if (ao_gps_data.flags & AO_GPS_VALID) { + latitude = ao_gps_data.latitude; + longitude = ao_gps_data.longitude; + altitude = ao_gps_data.altitude; + if (altitude < 0) + altitude = 0; } - /* Round latitude and longitude by 0.005 minutes */ - latitude = latitude + 833; - if (latitude > 900000000) - latitude = 900000000; - longitude = longitude + 833; - if (longitude > 1800000000) - longitude = 1800000000; - - lat_deg = latitude / 10000000; - latitude -= lat_deg * 10000000; - latitude *= 60; - lat_min = latitude / 10000000; - latitude -= lat_min * 10000000; - lat_frac = latitude / 100000; - - lon_deg = longitude / 10000000; - longitude -= lon_deg * 10000000; - longitude *= 60; - lon_min = longitude / 10000000; - longitude -= lon_min * 10000000; - lon_frac = longitude / 100000; - -#if 0 - return sprintf ((char *) tncBuffer, "=%02u%02u.%02u%c\\%03u%02u.%02u%cO /A=%06u\015", - lat_deg, lat_min, lat_frac, lat_sign, - lon_deg, lon_min, lon_frac, lon_sign, - altitude); -#endif - - return sprintf ((char *) tncBuffer, "/%02u%02u%02uh%02u%02u.%02u%c/%03u%02u.%02u%c'/A=%06u\015", - ao_gps_data.hour, - ao_gps_data.minute, - ao_gps_data.second, - lat_deg, lat_min, lat_frac, lat_sign, - lon_deg, lon_min, lon_frac, lon_sign, - altitude); -#endif buf = tncBuffer; -#if APRS_TIME - sprintf ((char *) buf, "/%02u%02u%02uh", - ao_gps_data.hour, - ao_gps_data.minute, - ao_gps_data.second); - buf += 8; -#else *buf++ = '!'; -#endif /* Symbol table ID */ *buf++ = '/'; - latitude = ((uint64_t) 380926 * (900000000 - latitude)) / 10000000; - longitude = ((uint64_t) 190463 * (1800000000 + longitude)) / 10000000; + lat = ((uint64_t) 380926 * (900000000 - latitude)) / 10000000; + lon = ((uint64_t) 190463 * (1800000000 + longitude)) / 10000000; -#define ALTITUDE_LOG_BASE 0.001998002662673f /* log(1.002) */ + alt = ao_aprs_encode_altitude(altitude); - altitude = logf((float) altitude) * (1/ALTITUDE_LOG_BASE); - - tncCompressInt(buf, latitude, 4); + tncCompressInt(buf, lat, 4); buf += 4; - tncCompressInt(buf, longitude, 4); + tncCompressInt(buf, lon, 4); buf += 4; /* Symbol code */ *buf++ = '\''; - tncCompressInt(buf, altitude, 2); + tncCompressInt(buf, alt, 2); buf += 2; *buf++ = 33 + ((1 << 5) | (2 << 3)); - *buf++ = '\0'; + + buf += tncComment(buf); + return buf - tncBuffer; }