2 * http://ad7zj.net/kd7lmo/aprsbeacon_code.html
4 * @mainpage Pico Beacon
6 * @section overview_sec Overview
8 * The Pico Beacon is an APRS based tracking beacon that operates in the UHF 420-450MHz band. The device utilizes a
9 * Microchip PIC 18F2525 embedded controller, Motorola M12+ GPS engine, and Analog Devices AD9954 DDS. The device is capable
10 * of generating a 1200bps A-FSK and 9600 bps FSK AX.25 compliant APRS (Automatic Position Reporting System) message.
14 * @section history_sec Revision History
16 * @subsection v305 V3.05
17 * 23 Dec 2006, Change include; (1) change printf format width to conform to ANSI standard when new CCS 4.xx compiler released.
20 * @subsection v304 V3.04
21 * 10 Jan 2006, Change include; (1) added amplitude control to engineering mode,
22 * (2) corrected number of bytes reported in log,
23 * (3) add engineering command to set high rate position reports (5 seconds), and
24 * (4) corrected size of LOG_COORD block when searching for end of log.
26 * @subsection v303 V3.03
27 * 15 Sep 2005, Change include; (1) removed AD9954 setting SDIO as input pin,
28 * (2) additional comments and Doxygen tags,
29 * (3) integration and test code calculates DDS FTW,
30 * (4) swapped bus and reference analog input ports (hardware change),
31 * (5) added message that indicates we are reading flash log and reports length,
32 * (6) report bus voltage in 10mV steps, and
33 * (7) change log type enumerated values to XORed nibbles for error detection.
36 * @subsection v302 V3.02
37 * 6 Apr 2005, Change include; (1) corrected tracked satellite count in NMEA-0183 $GPGGA message,
38 * (2) Doxygen documentation clean up and additions, and
39 * (3) added integration and test code to baseline.
42 * @subsection v301 V3.01
43 * 13 Jan 2005, Renamed project and files to Pico Beacon.
46 * @subsection v300 V3.00
47 * 15 Nov 2004, Change include; (1) Micro Beacon extreme hardware changes including integral transmitter,
48 * (2) PIC18F2525 processor,
49 * (3) AD9954 DDS support functions,
50 * (4) added comments and formatting for doxygen,
51 * (5) process GPS data with native Motorola protocol,
52 * (6) generate plain text $GPGGA and $GPRMC messages,
53 * (7) power down GPS 5 hours after lock,
54 * (8) added flight data recorder, and
55 * (9) added diagnostics terminal mode.
58 * @subsection v201 V2.01
59 * 30 Jan 2004, Change include; (1) General clean up of in-line documentation, and
60 * (2) changed temperature resolution to 0.1 degrees F.
63 * @subsection v200 V2.00
64 * 26 Oct 2002, Change include; (1) Micro Beacon II hardware changes including PIC18F252 processor,
66 * (3) GPS power control,
67 * (4) additional ADC input, and
68 * (5) LM60 temperature sensor.
71 * @subsection v101 V1.01
72 * 5 Dec 2001, Change include; (1) Changed startup message, and
73 * (2) applied SEPARATE pragma to several methods for memory usage.
76 * @subsection v100 V1.00
77 * 25 Sep 2001, Initial release. Flew ANSR-3 and ANSR-4.
83 * @section copyright_sec Copyright
85 * Copyright (c) 2001-2009 Michael Gray, KD7LMO
90 * @section gpl_sec GNU General Public License
92 * This program is free software; you can redistribute it and/or modify
93 * it under the terms of the GNU General Public License as published by
94 * the Free Software Foundation; either version 2 of the License, or
95 * (at your option) any later version.
97 * This program is distributed in the hope that it will be useful,
98 * but WITHOUT ANY WARRANTY; without even the implied warranty of
99 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
100 * GNU General Public License for more details.
102 * You should have received a copy of the GNU General Public License
103 * along with this program; if not, write to the Free Software
104 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
110 * @section design Design Details
112 * Provides design details on a variety of the components that make up the Pico Beacon.
118 * @page power Power Consumption
120 * Measured DC power consumption.
122 * 3VDC prime power current
127 * 18mA Processor running, all I/O off
131 * 120mA GPS running w/antenna
133 * 250mA DDS running and GPS w/antenna
135 * 420mA DDS running, GPS w/antenna, and PA chain on with no RF
146 #error HAS_APRS not set
152 // Public methods, constants, and data structures for each class.
154 static void timeInit(void);
156 static void tncInit(void);
157 static void tnc1200TimerTick(void);
162 * @defgroup sys System Library Functions
164 * Generic system functions similiar to the run-time C library.
170 * Calculate the CRC-16 CCITT of buffer that is length bytes long.
171 * The crc parameter allow the calculation on the CRC on multiple buffers.
173 * @param buffer Pointer to data buffer.
174 * @param length number of bytes in data buffer
175 * @param crc starting value
177 * @return CRC-16 of buffer[0 .. length]
179 static uint16_t sysCRC16(const uint8_t *buffer, uint8_t length, uint16_t crc)
181 uint8_t i, bit, value;
183 for (i = 0; i < length; ++i)
187 for (bit = 0; bit < 8; ++bit)
189 crc = (uint16_t) (crc ^ (value & 0x01));
190 crc = ( crc & 0x01 ) ? ( crc >> 1 ) ^ 0x8408 : ( crc >> 1 );
201 * @defgroup rtc Real Time Interrupt tick
203 * Manage the built-in real time interrupt. The interrupt clock PRI is 104uS (9600 bps).
208 /// 16-bit NCO where the upper 8-bits are used to index into the frequency generation table.
209 static uint16_t timeNCO;
211 /// Audio tone NCO update step (phase).
212 static uint16_t timeNCOFreq;
215 * Initialize the real-time clock.
217 static void timeInit()
220 timeNCOFreq = 0x2000;
226 * @defgroup tnc TNC (Terminal Node Controller)
228 * Functions that provide a subset of the TNC functions.
233 /// The number of start flag bytes to send before the packet message. (360bits * 1200bps = 300mS)
234 #define TNC_TX_DELAY 45
236 /// The size of the TNC output buffer.
237 #define TNC_BUFFER_SIZE 48
239 /// States that define the current mode of the 1200 bps (A-FSK) state machine.
242 /// Stand by state ready to accept new message.
245 /// 0x7E bit stream pattern used to define start of APRS message.
248 /// Transmit the AX.25 header that contains the source/destination call signs, APRS path, and flags.
251 /// Transmit the message data.
254 /// Transmit the end flag sequence.
256 } TNC_TX_1200BPS_STATE;
258 /// AX.25 compliant packet header that contains destination, station call sign, and path.
259 /// 0x76 for SSID-11, 0x78 for SSID-12
260 static uint8_t TNC_AX25_HEADER[] = {
261 'A' << 1, 'P' << 1, 'A' << 1, 'M' << 1, ' ' << 1, ' ' << 1, 0x60,
262 'N' << 1, '0' << 1, 'C' << 1, 'A' << 1, 'L' << 1, 'L' << 1, 0x78,
263 'W' << 1, 'I' << 1, 'D' << 1, 'E' << 1, '2' << 1, ' ' << 1, 0x65,
266 #define TNC_CALLSIGN_OFF 7
267 #define TNC_CALLSIGN_LEN 6
268 #define TNC_SSID_OFF 13
276 for (i = 0; i < TNC_CALLSIGN_LEN; i++) {
277 if (!ao_config.callsign[i])
279 TNC_AX25_HEADER[TNC_CALLSIGN_OFF + i] = ao_config.callsign[i] << 1;
281 for (; i < TNC_CALLSIGN_LEN; i++)
282 TNC_AX25_HEADER[TNC_CALLSIGN_OFF + i] = ' ' << 1;
284 /* Fill in the SSID with the low digit of the serial number */
285 TNC_AX25_HEADER[TNC_SSID_OFF] = (uint8_t) (0x60 | ((ao_config.aprs_ssid & 0xf) << 1));
289 /// The next bit to transmit.
290 static uint8_t tncTxBit;
292 /// Current mode of the 1200 bps state machine.
293 static TNC_TX_1200BPS_STATE tncMode;
295 /// Counter for each bit (0 - 7) that we are going to transmit.
296 static uint8_t tncBitCount;
298 /// A shift register that holds the data byte as we bit shift it for transmit.
299 static uint8_t tncShift;
301 /// Index into the APRS header and data array for each byte as we transmit it.
302 static uint8_t tncIndex;
304 /// The number of bytes in the message portion of the AX.25 message.
305 static uint8_t tncLength;
307 /// A copy of the last 5 bits we've transmitted to determine if we need to bit stuff on the next bit.
308 static uint8_t tncBitStuff;
310 /// Buffer to hold the message portion of the AX.25 packet as we prepare it.
311 static uint8_t tncBuffer[TNC_BUFFER_SIZE];
313 #pragma GCC diagnostic ignored "-Wformat-overflow="
315 * Initialize the TNC internal variables.
317 static void tncInit()
320 tncMode = TNC_TX_READY;
324 * Method that is called every 833uS to transmit the 1200bps A-FSK data stream.
325 * The provides the pre and postamble as well as the bit stuffed data stream.
327 static void tnc1200TimerTick()
329 // Set the A-FSK frequency.
330 if (tncTxBit == 0x00)
331 timeNCOFreq = 0x2000;
333 timeNCOFreq = 0x3aab;
338 // Generate a test signal alteranting between high and low tones.
339 tncTxBit = (tncTxBit == 0 ? 1 : 0);
343 // The variable tncShift contains the lastest data byte.
344 // NRZI enocde the data stream.
345 if ((tncShift & 0x01) == 0x00) {
352 // When the flag is done, determine if we need to send more or data.
353 if (++tncBitCount == 8)
358 // Once we transmit x mS of flags, send the data.
359 // txDelay bytes * 8 bits/byte * 833uS/bit = x mS
360 if (++tncIndex == TNC_TX_DELAY)
363 tncShift = TNC_AX25_HEADER[0];
365 tncMode = TNC_TX_HEADER;
368 tncShift = tncShift >> 1;
372 // Determine if we have sent 5 ones in a row, if we have send a zero.
373 if (tncBitStuff == 0x1f)
384 // The variable tncShift contains the lastest data byte.
385 // NRZI enocde the data stream.
386 if ((tncShift & 0x01) == 0x00) {
393 // Save the data stream so we can determine if bit stuffing is
394 // required on the next bit time.
395 tncBitStuff = ((tncBitStuff << 1) | (tncShift & 0x01)) & 0x1f;
397 // If all the bits were shifted, get the next byte.
398 if (++tncBitCount == 8)
402 // After the header is sent, then send the data.
403 if (++tncIndex == sizeof(TNC_AX25_HEADER))
406 tncShift = tncBuffer[0];
407 tncMode = TNC_TX_DATA;
409 tncShift = TNC_AX25_HEADER[tncIndex];
412 tncShift = tncShift >> 1;
417 // Determine if we have sent 5 ones in a row, if we have send a zero.
418 if (tncBitStuff == 0x1f)
429 // The variable tncShift contains the lastest data byte.
430 // NRZI enocde the data stream.
431 if ((tncShift & 0x01) == 0x00) {
438 // Save the data stream so we can determine if bit stuffing is
439 // required on the next bit time.
440 tncBitStuff = ((tncBitStuff << 1) | (tncShift & 0x01)) & 0x1f;
442 // If all the bits were shifted, get the next byte.
443 if (++tncBitCount == 8)
447 // If everything was sent, transmit closing flags.
448 if (++tncIndex == tncLength)
452 tncMode = TNC_TX_END;
454 tncShift = tncBuffer[tncIndex];
457 tncShift = tncShift >> 1;
462 // The variable tncShift contains the lastest data byte.
463 // NRZI enocde the data stream.
464 if ((tncShift & 0x01) == 0x00) {
471 // If all the bits were shifted, get the next one.
472 if (++tncBitCount == 8)
477 // Transmit two closing flags.
480 tncMode = TNC_TX_READY;
485 tncShift = tncShift >> 1;
491 static void tncCompressInt(uint8_t *dest, int32_t value, int len) {
493 for (i = len - 1; i >= 0; i--) {
494 dest[i] = (uint8_t) (value % 91 + 33);
499 static int ao_num_sats(void)
504 for (i = 0; i < ao_gps_tracking_data.channels; i++) {
505 if (ao_gps_tracking_data.sats[i].svid)
511 static char ao_gps_locked(void)
513 if (ao_gps_data.flags & AO_GPS_VALID)
519 static int tncComment(uint8_t *buf)
522 struct ao_data packet;
524 ao_arch_critical(ao_data_get(&packet););
526 int16_t battery = ao_battery_decivolt(packet.adc.v_batt);
527 #ifdef AO_SENSE_DROGUE
528 int16_t apogee = ao_ignite_decivolt(AO_SENSE_DROGUE(&packet));
531 int16_t main_value = ao_ignite_decivolt(AO_SENSE_MAIN(&packet));
534 return sprintf((char *) buf,
536 #ifdef AO_SENSE_DROGUE
547 #ifdef AO_SENSE_DROGUE
558 return sprintf((char *) buf,
566 * APRS use a log encoding of altitude with a base of 1.002, such that
568 * feet = 1.002 ** encoded_altitude
570 * meters = (1.002 ** encoded_altitude) * 0.3048
572 * log2(meters) = log2(1.002 ** encoded_altitude) + log2(0.3048)
574 * log2(meters) = encoded_altitude * log2(1.002) + log2(0.3048)
576 * encoded_altitude = (log2(meters) - log2(0.3048)) / log2(1.002)
578 * encoded_altitude = (log2(meters) + log2(1/0.3048)) * (1/log2(1.002))
580 * We need 9 bits of mantissa to hold 1/log2(1.002) (~ 347), which leaves us
581 * 23 bits of fraction. That turns out to be *just* enough to avoid any
582 * errors in the result (cool, huh?).
585 #define fixed23_int(x) ((uint32_t) ((x) << 23))
586 #define fixed23_one fixed23_int(1)
587 #define fixed23_two fixed23_int(2)
588 #define fixed23_half (fixed23_one >> 1)
589 #define fixed23_floor(x) ((x) >> 23)
590 #define fixed23_real(x) ((uint32_t) ((x) * fixed23_one + 0.5))
592 static inline uint64_t
593 fixed23_mul(uint32_t x, uint32_t y)
595 return ((uint64_t) x * y + fixed23_half) >> 23;
599 * Use 30 fraction bits for the altitude. We need two bits at the
600 * top as we need to handle x, where 0 <= x < 4. We don't
601 * need 30 bits, but it's actually easier this way as we normalize
602 * the incoming value to 1 <= x < 2, and having the integer portion
603 * way up high means we don't have to deal with shifting in both
604 * directions to cover from 0 to 2**30-1.
607 #define fixed30_int(x) ((uint32_t) ((x) << 30))
608 #define fixed30_one fixed30_int(1)
609 #define fixed30_half (fixed30_one >> 1)
610 #define fixed30_two fixed30_int(2)
612 static inline uint32_t
613 fixed30_mul(uint32_t x, uint32_t y)
615 return (uint32_t) (((uint64_t) x * y + fixed30_half) >> 30);
619 * Fixed point log2. Takes integer argument, returns
620 * fixed point result with 23 bits of fraction
624 ao_fixed_log2(int32_t ix)
627 uint32_t frac = fixed23_one;
630 /* Bounds check for sanity */
636 if (x >= fixed30_one)
640 * Normalize and compute integer log portion
642 * This makes 1 <= x < 2, and computes result to be
643 * the integer portion of the log2 of x
646 for (result = fixed23_int(30); x < fixed30_one; result -= fixed23_one, x <<= 1)
650 * Given x, find y and n such that:
652 * x = y * 2**n 1 <= y < 2
658 * Now, repeatedly square y to find find z and m such that:
660 * z = y ** (2**m) 2 <= z < 4
662 * This is possible because 1 <= y < 2
664 * lb(y) = lb(z) / 2**m
670 * = 2**-m + 2**-m * lb(z/2)
672 * Note that if 2 <= z < 4, then 1 <= (z/2) < 2, so we can
673 * iterate to find lb(z/2)
675 * In this implementation, we don't care about the 'm' value,
676 * instead we only care about 2**-m, which we store in 'frac'
679 while (frac != 0 && x != fixed30_one) {
680 /* Repeatedly square x until 2 <= x < 4 */
681 while (x < fixed30_two) {
682 x = fixed30_mul(x, x);
684 /* Divide the fractional result bit by 2 */
688 /* Add in this result bit */
691 /* Make 1 <= x < 2 again and iterate */
697 #define APRS_LOG_CONVERT fixed23_real(1.714065192056127)
698 #define APRS_LOG_BASE fixed23_real(346.920048461100941)
701 ao_aprs_encode_altitude(int meters)
703 return (int32_t) fixed23_floor(fixed23_mul(ao_fixed_log2(meters) + APRS_LOG_CONVERT, APRS_LOG_BASE) + fixed23_half);
707 * Generate the plain text position packet.
709 static uint8_t tncPositionPacket(void)
711 static int32_t latitude;
712 static int32_t longitude;
713 static int32_t altitude;
716 if (ao_gps_data.flags & AO_GPS_VALID) {
717 latitude = ao_gps_data.latitude;
718 longitude = ao_gps_data.longitude;
719 altitude = AO_TELEMETRY_LOCATION_ALTITUDE(&ao_gps_data);
727 #define AO_APRS_FORMAT_COMPRESSED 0
728 #define AO_APRS_FORMAT_UNCOMPRESSED 1
729 switch (AO_APRS_FORMAT_COMPRESSED) {
731 switch (ao_config.aprs_format) {
733 case AO_APRS_FORMAT_COMPRESSED:
736 int32_t lat, lon, alt;
740 /* Symbol table ID */
743 lat = (int32_t) (((int64_t) 380926 * (900000000 - latitude)) / 10000000);
744 lon = (int32_t) (((int64_t) 190463 * (1800000000 + longitude)) / 10000000);
746 alt = ao_aprs_encode_altitude(altitude);
748 tncCompressInt(buf, lat, 4);
750 tncCompressInt(buf, lon, 4);
756 tncCompressInt(buf, alt, 2);
759 *buf++ = 33 + ((1 << 5) | (2 << 3));
763 case AO_APRS_FORMAT_UNCOMPRESSED:
765 char lat_sign = 'N', lon_sign = 'E';
766 int32_t lat = latitude;
767 int32_t lon = longitude;
768 int32_t alt = altitude;
786 /* Round latitude and longitude by 0.005 minutes */
791 if (lon > 1800000000)
794 lat_deg = (uint16_t) (lat / 10000000);
795 lat -= lat_deg * 10000000;
797 lat_min = (uint16_t) (lat / 10000000);
798 lat -= lat_min * 10000000;
799 lat_frac = (uint16_t) (lat / 100000);
801 lon_deg = (uint16_t) (lon / 10000000);
802 lon -= lon_deg * 10000000;
804 lon_min = (uint16_t) (lon / 10000000);
805 lon -= lon_min * 10000000;
806 lon_frac = (uint16_t) (lon / 100000);
808 /* Convert from meters to feet */
809 alt = (alt * 328 + 50) / 100;
811 buf += sprintf((char *) tncBuffer, "!%02u%02u.%02u%c/%03u%02u.%02u%c'/A=%06lu ",
812 lat_deg, lat_min, lat_frac, lat_sign,
813 lon_deg, lon_min, lon_frac, lon_sign,
819 buf += tncComment(buf);
821 return (uint8_t) (buf - tncBuffer);
825 tncFill(uint8_t *buf, int16_t len)
831 while (tncMode != TNC_TX_READY && l < len) {
833 for (bit = 0; bit < 8; bit++) {
834 b = (uint8_t) (b << 1 | (timeNCO >> 15));
835 timeNCO += timeNCOFreq;
841 if (tncMode == TNC_TX_READY)
847 * Prepare an AX.25 data packet. Each time this method is called, it automatically
848 * rotates through 1 of 3 messages.
850 * @param dataMode enumerated type that specifies 1200bps A-FSK or 9600bps FSK
852 void ao_aprs_send(void)
860 tncLength = tncPositionPacket();
862 // Calculate the CRC for the header and message.
863 crc = sysCRC16(TNC_AX25_HEADER, sizeof(TNC_AX25_HEADER), 0xffff);
864 crc = sysCRC16(tncBuffer, tncLength, crc ^ 0xffff);
866 // Save the CRC in the message.
867 tncBuffer[tncLength++] = (uint8_t) (crc & 0xff);
868 tncBuffer[tncLength++] = (uint8_t) ((crc >> 8) & 0xff);
870 // Prepare the variables that are used in the real-time clock interrupt.
875 tncMode = TNC_TX_SYNC;
877 ao_radio_send_aprs(tncFill);