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
149 typedef int32_t int32;
153 // Public methods, constants, and data structures for each class.
156 void ddsSetAmplitude (uint8_t amplitude);
157 void ddsSetOutputScale (uint16_t amplitude);
158 void ddsSetFSKFreq (uint32_t ftw0, uint32_t ftw1);
159 void ddsSetFreq (uint32_t freq);
160 void ddsSetFTW (uint32_t ftw);
162 uint16_t sysCRC16(uint8_t *buffer, uint8_t length, uint16_t crc);
164 uint8_t timeGetTicks();
166 void timeSetDutyCycle (uint8_t dutyCycle);
170 void tnc1200TimerTick();
171 void tncTxByte (uint8_t value);
172 void tncTxPacket(void);
177 * @defgroup sys System Library Functions
179 * Generic system functions similiar to the run-time C library.
185 * Calculate the CRC-16 CCITT of buffer that is length bytes long.
186 * The crc parameter allow the calculation on the CRC on multiple buffers.
188 * @param buffer Pointer to data buffer.
189 * @param length number of bytes in data buffer
190 * @param crc starting value
192 * @return CRC-16 of buffer[0 .. length]
194 uint16_t sysCRC16(uint8_t *buffer, uint8_t length, uint16_t crc)
196 uint8_t i, bit, value;
198 for (i = 0; i < length; ++i)
202 for (bit = 0; bit < 8; ++bit)
204 crc ^= (value & 0x01);
205 crc = ( crc & 0x01 ) ? ( crc >> 1 ) ^ 0x8408 : ( crc >> 1 );
216 * @defgroup rtc Real Time Interrupt tick
218 * Manage the built-in real time interrupt. The interrupt clock PRI is 104uS (9600 bps).
223 /// A counter that ticks every 100mS.
226 /// Counts the number of 104uS interrupts for a 100mS time period.
227 uint16_t timeInterruptCount;
229 /// Counts the number of 100mS time periods in 1 second.
232 /// System time in seconds.
235 /// System time in minutes.
238 /// System time in hours.
241 /// Desired LED duty cycle 0 to 9 where 0 = 0% and 9 = 90%.
242 uint8_t timeDutyCycle;
244 /// Current value of the timer 1 compare register used to generate 104uS interrupt rate (9600bps).
245 uint16_t timeCompare;
247 /// 16-bit NCO where the upper 8-bits are used to index into the frequency generation table.
250 /// Audio tone NCO update step (phase).
251 uint16_t timeNCOFreq;
253 /// Counter used to deciminate down from the 104uS to 833uS interrupt rate. (9600 to 1200 baud)
254 uint8_t timeLowRateCount;
256 /// Flag set true once per second.
257 bool_t timeUpdateFlag;
259 /// Flag that indicate the flight time should run.
262 /// The change in the CCP_1 register for each 104uS (9600bps) interrupt period.
263 #define TIME_RATE 125
266 * Running 8-bit counter that ticks every 100mS.
268 * @return 100mS time tick
270 uint8_t timeGetTicks()
276 * Initialize the real-time clock.
281 timeInterruptCount = 0;
286 timeCompare = TIME_RATE;
287 timeUpdateFlag = false;
289 timeLowRateCount = 0;
290 timeNCOFreq = 0x2000;
295 * Function return true once a second based on real-time clock.
297 * @return true on one second tick; otherwise false
299 bool_t timeIsUpdate()
303 timeUpdateFlag = false;
311 * Set a flag to indicate the flight time should run. This flag is typically set when the payload
314 void timeSetRunFlag()
320 * Timer interrupt handler called every 104uS (9600 times/second).
324 // Setup the next interrupt for the operational mode.
325 timeCompare += TIME_RATE;
327 putchar ((timeNCO >> 8) < 0x80 ? 0xc0 : 0x40);
329 timeNCO += timeNCOFreq;
331 if (++timeLowRateCount == 8)
333 timeLowRateCount = 0;
341 * @defgroup tnc TNC (Terminal Node Controller)
343 * Functions that provide a subset of the TNC functions.
348 /// The number of start flag bytes to send before the packet message. (360bits * 1200bps = 300mS)
349 #define TNC_TX_DELAY 45
351 /// The size of the TNC output buffer.
352 #define TNC_BUFFER_SIZE 80
354 /// States that define the current mode of the 1200 bps (A-FSK) state machine.
357 /// Stand by state ready to accept new message.
360 /// 0x7E bit stream pattern used to define start of APRS message.
363 /// Transmit the AX.25 header that contains the source/destination call signs, APRS path, and flags.
366 /// Transmit the message data.
369 /// Transmit the end flag sequence.
371 } TNC_TX_1200BPS_STATE;
373 /// AX.25 compliant packet header that contains destination, station call sign, and path.
374 /// 0x76 for SSID-11, 0x78 for SSID-12
375 uint8_t TNC_AX25_HEADER[30] = {
376 'A' << 1, 'P' << 1, 'R' << 1, 'S' << 1, ' ' << 1, ' ' << 1, 0x60, \
377 'K' << 1, 'D' << 1, '7' << 1, 'S' << 1, 'Q' << 1, 'G' << 1, 0x76, \
378 'G' << 1, 'A' << 1, 'T' << 1, 'E' << 1, ' ' << 1, ' ' << 1, 0x60, \
379 'W' << 1, 'I' << 1, 'D' << 1, 'E' << 1, '3' << 1, ' ' << 1, 0x67, \
382 /// The next bit to transmit.
385 /// Current mode of the 1200 bps state machine.
386 TNC_TX_1200BPS_STATE tncMode;
388 /// Counter for each bit (0 - 7) that we are going to transmit.
391 /// A shift register that holds the data byte as we bit shift it for transmit.
394 /// Index into the APRS header and data array for each byte as we transmit it.
397 /// The number of bytes in the message portion of the AX.25 message.
400 /// A copy of the last 5 bits we've transmitted to determine if we need to bit stuff on the next bit.
403 /// Pointer to TNC buffer as we save each byte during message preparation.
404 uint8_t *tncBufferPnt;
406 /// Buffer to hold the message portion of the AX.25 packet as we prepare it.
407 uint8_t tncBuffer[TNC_BUFFER_SIZE];
410 * Initialize the TNC internal variables.
415 tncMode = TNC_TX_READY;
419 * Method that is called every 833uS to transmit the 1200bps A-FSK data stream.
420 * The provides the pre and postamble as well as the bit stuffed data stream.
422 void tnc1200TimerTick()
424 // Set the A-FSK frequency.
425 if (tncTxBit == 0x00)
426 timeNCOFreq = 0x2000;
428 timeNCOFreq = 0x3aab;
433 // Generate a test signal alteranting between high and low tones.
434 tncTxBit = (tncTxBit == 0 ? 1 : 0);
438 // The variable tncShift contains the lastest data byte.
439 // NRZI enocde the data stream.
440 if ((tncShift & 0x01) == 0x00) {
447 // When the flag is done, determine if we need to send more or data.
448 if (++tncBitCount == 8)
453 // Once we transmit x mS of flags, send the data.
454 // txDelay bytes * 8 bits/byte * 833uS/bit = x mS
455 if (++tncIndex == TNC_TX_DELAY)
458 tncShift = TNC_AX25_HEADER[0];
460 tncMode = TNC_TX_HEADER;
463 tncShift = tncShift >> 1;
467 // Determine if we have sent 5 ones in a row, if we have send a zero.
468 if (tncBitStuff == 0x1f)
479 // The variable tncShift contains the lastest data byte.
480 // NRZI enocde the data stream.
481 if ((tncShift & 0x01) == 0x00) {
488 // Save the data stream so we can determine if bit stuffing is
489 // required on the next bit time.
490 tncBitStuff = ((tncBitStuff << 1) | (tncShift & 0x01)) & 0x1f;
492 // If all the bits were shifted, get the next byte.
493 if (++tncBitCount == 8)
497 // After the header is sent, then send the data.
498 if (++tncIndex == sizeof(TNC_AX25_HEADER))
501 tncShift = tncBuffer[0];
502 tncMode = TNC_TX_DATA;
504 tncShift = TNC_AX25_HEADER[tncIndex];
507 tncShift = tncShift >> 1;
512 // Determine if we have sent 5 ones in a row, if we have send a zero.
513 if (tncBitStuff == 0x1f)
524 // The variable tncShift contains the lastest data byte.
525 // NRZI enocde the data stream.
526 if ((tncShift & 0x01) == 0x00) {
533 // Save the data stream so we can determine if bit stuffing is
534 // required on the next bit time.
535 tncBitStuff = ((tncBitStuff << 1) | (tncShift & 0x01)) & 0x1f;
537 // If all the bits were shifted, get the next byte.
538 if (++tncBitCount == 8)
542 // If everything was sent, transmit closing flags.
543 if (++tncIndex == tncLength)
547 tncMode = TNC_TX_END;
549 tncShift = tncBuffer[tncIndex];
552 tncShift = tncShift >> 1;
557 // The variable tncShift contains the lastest data byte.
558 // NRZI enocde the data stream.
559 if ((tncShift & 0x01) == 0x00) {
566 // If all the bits were shifted, get the next one.
567 if (++tncBitCount == 8)
572 // Transmit two closing flags.
575 tncMode = TNC_TX_READY;
580 tncShift = tncShift >> 1;
587 * Generate the plain text position packet. Data is written through the tncTxByte
590 void tncPositionPacket(void)
592 int32_t latitude = 45.4694766 * 10000000;
593 int32_t longitude = -122.7376250 * 10000000;
594 uint32_t altitude = 10000;
603 char lat_sign = 'N', lon_sign = 'E';
607 latitude = -latitude;
612 longitude = -longitude;
615 lat_deg = latitude / 10000000;
616 latitude -= lat_deg * 10000000;
618 lat_min = latitude / 10000000;
619 latitude -= lat_min * 10000000;
620 lat_frac = (latitude + 50000) / 100000;
622 lon_deg = longitude / 10000000;
623 longitude -= lon_deg * 10000000;
625 lon_min = longitude / 10000000;
626 longitude -= lon_min * 10000000;
627 lon_frac = (longitude + 50000) / 100000;
629 c = sprintf ((char *) tncBufferPnt, "=%02u%02u.%02u%c\\%03u%02u.%02u%cO /A=%06u\015",
630 lat_deg, lat_min, lat_frac, lat_sign,
631 lon_deg, lon_min, lon_frac, lon_sign,
632 altitude * 100 / 3048);
638 * Prepare an AX.25 data packet. Each time this method is called, it automatically
639 * rotates through 1 of 3 messages.
641 * @param dataMode enumerated type that specifies 1200bps A-FSK or 9600bps FSK
643 void tncTxPacket(void)
647 // Set a pointer to our TNC output buffer.
648 tncBufferPnt = tncBuffer;
650 // Set the message length counter.
655 // Calculate the CRC for the header and message.
656 crc = sysCRC16(TNC_AX25_HEADER, sizeof(TNC_AX25_HEADER), 0xffff);
657 crc = sysCRC16(tncBuffer, tncLength, crc ^ 0xffff);
659 // Save the CRC in the message.
660 *tncBufferPnt++ = crc & 0xff;
661 *tncBufferPnt = (crc >> 8) & 0xff;
663 // Update the length to include the CRC bytes.
666 // Prepare the variables that are used in the real-time clock interrupt.
671 tncMode = TNC_TX_SYNC;
673 // Turn on the PA chain.
674 // output_high (IO_PTT);
676 // Wait for the PA chain to power up.
680 // output_high (IO_OSK);
682 // Log the battery and reference voltage just after we key the transmitter.
684 while (tncMode != TNC_TX_READY)