+static void tncCompressInt(uint8_t *dest, int32_t value, int len) {
+ int i;
+ for (i = len - 1; i >= 0; i--) {
+ dest[i] = (uint8_t) (value % 91 + 33);
+ value /= 91;
+ }
+}
+
+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_value = 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
+ " %d"
+ , ao_gps_locked(),
+ ao_num_sats(),
+ battery/10,
+ battery % 10
+#ifdef AO_SENSE_DROGUE
+ , apogee/10,
+ apogee%10
+#endif
+#ifdef AO_SENSE_MAIN
+ , main_value/10,
+ main_value%10
+#endif
+ , ao_serial_number
+ );
+#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 (uint32_t) (((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(int32_t ix)
+{
+ uint32_t result;
+ uint32_t frac = fixed23_one;
+ uint32_t x;
+
+ /* Bounds check for sanity */
+ if (ix <= 0)
+ return 0;
+
+ x = (uint32_t) ix;
+
+ 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 int32_t
+ao_aprs_encode_altitude(int meters)
+{
+ return (int32_t) fixed23_floor(fixed23_mul(ao_fixed_log2(meters) + APRS_LOG_CONVERT, APRS_LOG_BASE) + fixed23_half);
+}
+