git.gag.com Git - fw/altos/blob - src/drivers/ao_aprs.c

   1 /**
   2  * http://ad7zj.net/kd7lmo/aprsbeacon_code.html
   3  *
   4  * @mainpage Pico Beacon
   5  *
   6  * @section overview_sec Overview
   7  *
   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.
  11
  12
  13  *
  14  * @section history_sec Revision History
  15  *
  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.
  18  *
  19  *
  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.
  25  *
  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.
  34  *
  35  *
  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.
  40  *
  41  *
  42  * @subsection v301 V3.01
  43  * 13 Jan 2005, Renamed project and files to Pico Beacon.
  44  *
  45  *
  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.
  56  *
  57  *
  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.
  61  *
  62  *
  63  * @subsection v200 V2.00
  64  * 26 Oct 2002, Change include; (1) Micro Beacon II hardware changes including PIC18F252 processor,
  65  *                                     (2) serial EEPROM,
  66  *                                     (3) GPS power control,
  67  *                                     (4) additional ADC input, and
  68  *                                     (5) LM60 temperature sensor.
  69  *
  70  *
  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.
  74  *
  75  *
  76  * @subsection v100 V1.00
  77  * 25 Sep 2001, Initial release.  Flew ANSR-3 and ANSR-4.
  78  *
  79
  80
  81  *
  82  *
  83  * @section copyright_sec Copyright
  84  *
  85  * Copyright (c) 2001-2009 Michael Gray, KD7LMO
  86
  87
  88  *
  89  *
  90  * @section gpl_sec GNU General Public License
  91  *
  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.
  96  *
  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.
 101  *
 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
 105  *
 106
 107
 108  *
 109  *
 110  * @section design Design Details
 111  *
 112  * Provides design details on a variety of the components that make up the Pico Beacon.
 113  *
 114  *  @subpage power
 115  */
 116
 117 /**
 118  *  @page power Power Consumption
 119  *
 120  *  Measured DC power consumption.
 121  *
 122  *  3VDC prime power current
 123
 124  *
 125  *    7mA Held in reset
 126
 127  *   18mA Processor running, all I/O off
 128
 129  *  110mA GPS running
 130
 131  *  120mA GPS running w/antenna
 132
 133  *  250mA DDS running and GPS w/antenna
 134
 135  *  420mA DDS running, GPS w/antenna, and PA chain on with no RF
 136
 137  *  900mA Transmit
 138
 139  *
 140  */
 141
 142 #ifndef AO_APRS_TEST
 143 #include <ao.h>
 144 #endif
 145
 146 #include <ao_aprs.h>
 147
 148 typedef int bool_t;
 149 typedef int32_t int32;
 150 #define false 0
 151 #define true 1
 152
 153 // Public methods, constants, and data structures for each class.
 154
 155 void ddsInit();
 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);
 161
 162 uint16_t sysCRC16(uint8_t *buffer, uint8_t length, uint16_t crc);
 163
 164 void timeInit();
 165 void timeSetDutyCycle (uint8_t dutyCycle);
 166 void timeUpdate();
 167
 168 void tncInit();
 169 void tnc1200TimerTick();
 170 void tncTxByte (uint8_t value);
 171 void tncTxPacket(void);
 172
 173 /** @} */
 174
 175 /**
 176  *  @defgroup sys System Library Functions
 177  *
 178  *  Generic system functions similiar to the run-time C library.
 179  *
 180  *  @{
 181  */
 182
 183 /**
 184  *    Calculate the CRC-16 CCITT of buffer that is length bytes long.
 185  *    The crc parameter allow the calculation on the CRC on multiple buffers.
 186  *
 187  *    @param buffer Pointer to data buffer.
 188  *    @param length number of bytes in data buffer
 189  *    @param crc starting value
 190  *
 191  *    @return CRC-16 of buffer[0 .. length]
 192  */
 193 uint16_t sysCRC16(uint8_t *buffer, uint8_t length, uint16_t crc)
 194 {
 195     uint8_t i, bit, value;
 196
 197     for (i = 0; i < length; ++i)
 198     {
 199         value = buffer[i];
 200
 201         for (bit = 0; bit < 8; ++bit)
 202         {
 203             crc ^= (value & 0x01);
 204             crc = ( crc & 0x01 ) ? ( crc >> 1 ) ^ 0x8408 : ( crc >> 1 );
 205             value = value >> 1;
 206         } // END for
 207     } // END for
 208
 209     return crc ^ 0xffff;
 210 }
 211
 212 /** @} */
 213
 214 /**
 215  *  @defgroup rtc Real Time Interrupt tick
 216  *
 217  *  Manage the built-in real time interrupt.  The interrupt clock PRI is 104uS (9600 bps).
 218  *
 219  *  @{
 220  */
 221
 222 /// 16-bit NCO where the upper 8-bits are used to index into the frequency generation table.
 223 uint16_t timeNCO;
 224
 225 /// Audio tone NCO update step (phase).
 226 uint16_t timeNCOFreq;
 227
 228 /// Counter used to deciminate down from the 104uS to 833uS interrupt rate.  (9600 to 1200 baud)
 229 uint8_t timeLowRateCount;
 230
 231 /**
 232  *   Initialize the real-time clock.
 233  */
 234 void timeInit()
 235 {
 236     timeNCO = 0x00;
 237     timeLowRateCount = 0;
 238     timeNCOFreq = 0x2000;
 239 }
 240
 241 /** @} */
 242
 243 /**
 244  *  @defgroup tnc TNC (Terminal Node Controller)
 245  *
 246  *  Functions that provide a subset of the TNC functions.
 247  *
 248  *  @{
 249  */
 250
 251 /// The number of start flag bytes to send before the packet message.  (360bits * 1200bps = 300mS)
 252 #define TNC_TX_DELAY 45
 253
 254 /// The size of the TNC output buffer.
 255 #define TNC_BUFFER_SIZE 80
 256
 257 /// States that define the current mode of the 1200 bps (A-FSK) state machine.
 258 typedef enum
 259 {
 260     /// Stand by state ready to accept new message.
 261     TNC_TX_READY,
 262
 263     /// 0x7E bit stream pattern used to define start of APRS message.
 264     TNC_TX_SYNC,
 265
 266     /// Transmit the AX.25 header that contains the source/destination call signs, APRS path, and flags.
 267     TNC_TX_HEADER,
 268
 269     /// Transmit the message data.
 270     TNC_TX_DATA,
 271
 272     /// Transmit the end flag sequence.
 273     TNC_TX_END
 274 } TNC_TX_1200BPS_STATE;
 275
 276 /// AX.25 compliant packet header that contains destination, station call sign, and path.
 277 /// 0x76 for SSID-11, 0x78 for SSID-12
 278 uint8_t TNC_AX25_HEADER[30] = {
 279     'A' << 1, 'P' << 1, 'R' << 1, 'S' << 1, ' ' << 1, ' ' << 1, 0x60, \
 280     'K' << 1, 'D' << 1, '7' << 1, 'S' << 1, 'Q' << 1, 'G' << 1, 0x76, \
 281     'G' << 1, 'A' << 1, 'T' << 1, 'E' << 1, ' ' << 1, ' ' << 1, 0x60, \
 282     'W' << 1, 'I' << 1, 'D' << 1, 'E' << 1, '3' << 1, ' ' << 1, 0x67, \
 283     0x03, 0xf0 };
 284
 285 /// The next bit to transmit.
 286 uint8_t tncTxBit;
 287
 288 /// Current mode of the 1200 bps state machine.
 289 TNC_TX_1200BPS_STATE tncMode;
 290
 291 /// Counter for each bit (0 - 7) that we are going to transmit.
 292 uint8_t tncBitCount;
 293
 294 /// A shift register that holds the data byte as we bit shift it for transmit.
 295 uint8_t tncShift;
 296
 297 /// Index into the APRS header and data array for each byte as we transmit it.
 298 uint8_t tncIndex;
 299
 300 /// The number of bytes in the message portion of the AX.25 message.
 301 uint8_t tncLength;
 302
 303 /// A copy of the last 5 bits we've transmitted to determine if we need to bit stuff on the next bit.
 304 uint8_t tncBitStuff;
 305
 306 /// Pointer to TNC buffer as we save each byte during message preparation.
 307 uint8_t *tncBufferPnt;
 308
 309 /// Buffer to hold the message portion of the AX.25 packet as we prepare it.
 310 uint8_t tncBuffer[TNC_BUFFER_SIZE];
 311
 312 /**
 313  *   Initialize the TNC internal variables.
 314  */
 315 void tncInit()
 316 {
 317     tncTxBit = 0;
 318     tncMode = TNC_TX_READY;
 319 }
 320
 321 /**
 322  *   Method that is called every 833uS to transmit the 1200bps A-FSK data stream.
 323  *   The provides the pre and postamble as well as the bit stuffed data stream.
 324  */
 325 void tnc1200TimerTick()
 326 {
 327     // Set the A-FSK frequency.
 328     if (tncTxBit == 0x00)
 329         timeNCOFreq = 0x2000;
 330     else
 331         timeNCOFreq = 0x3aab;
 332
 333     switch (tncMode)
 334     {
 335         case TNC_TX_READY:
 336             // Generate a test signal alteranting between high and low tones.
 337             tncTxBit = (tncTxBit == 0 ? 1 : 0);
 338             break;
 339
 340         case TNC_TX_SYNC:
 341             // The variable tncShift contains the lastest data byte.
 342             // NRZI enocde the data stream.
 343             if ((tncShift & 0x01) == 0x00) {
 344                 if (tncTxBit == 0)
 345                     tncTxBit = 1;
 346                 else
 347                     tncTxBit = 0;
 348             }
 349
 350             // When the flag is done, determine if we need to send more or data.
 351             if (++tncBitCount == 8)
 352             {
 353                 tncBitCount = 0;
 354                 tncShift = 0x7e;
 355
 356                 // Once we transmit x mS of flags, send the data.
 357                 // txDelay bytes * 8 bits/byte * 833uS/bit = x mS
 358                 if (++tncIndex == TNC_TX_DELAY)
 359                 {
 360                     tncIndex = 0;
 361                     tncShift = TNC_AX25_HEADER[0];
 362                     tncBitStuff = 0;
 363                     tncMode = TNC_TX_HEADER;
 364                 } // END if
 365             } else
 366                 tncShift = tncShift >> 1;
 367             break;
 368
 369         case TNC_TX_HEADER:
 370             // Determine if we have sent 5 ones in a row, if we have send a zero.
 371             if (tncBitStuff == 0x1f)
 372             {
 373                 if (tncTxBit == 0)
 374                     tncTxBit = 1;
 375                 else
 376                     tncTxBit = 0;
 377
 378                 tncBitStuff = 0x00;
 379                 return;
 380             }    // END if
 381
 382             // The variable tncShift contains the lastest data byte.
 383             // NRZI enocde the data stream.
 384             if ((tncShift & 0x01) == 0x00) {
 385                 if (tncTxBit == 0)
 386                     tncTxBit = 1;
 387                 else
 388                     tncTxBit = 0;
 389             }
 390
 391             // Save the data stream so we can determine if bit stuffing is
 392             // required on the next bit time.
 393             tncBitStuff = ((tncBitStuff << 1) | (tncShift & 0x01)) & 0x1f;
 394
 395             // If all the bits were shifted, get the next byte.
 396             if (++tncBitCount == 8)
 397             {
 398                 tncBitCount = 0;
 399
 400                 // After the header is sent, then send the data.
 401                 if (++tncIndex == sizeof(TNC_AX25_HEADER))
 402                 {
 403                     tncIndex = 0;
 404                     tncShift = tncBuffer[0];
 405                     tncMode = TNC_TX_DATA;
 406                 } else
 407                     tncShift = TNC_AX25_HEADER[tncIndex];
 408
 409             } else
 410                 tncShift = tncShift >> 1;
 411
 412             break;
 413
 414         case TNC_TX_DATA:
 415             // Determine if we have sent 5 ones in a row, if we have send a zero.
 416             if (tncBitStuff == 0x1f)
 417             {
 418                 if (tncTxBit == 0)
 419                     tncTxBit = 1;
 420                 else
 421                     tncTxBit = 0;
 422
 423                 tncBitStuff = 0x00;
 424                 return;
 425             }    // END if
 426
 427             // The variable tncShift contains the lastest data byte.
 428             // NRZI enocde the data stream.
 429             if ((tncShift & 0x01) == 0x00) {
 430                 if (tncTxBit == 0)
 431                     tncTxBit = 1;
 432                 else
 433                     tncTxBit = 0;
 434             }
 435
 436             // Save the data stream so we can determine if bit stuffing is
 437             // required on the next bit time.
 438             tncBitStuff = ((tncBitStuff << 1) | (tncShift & 0x01)) & 0x1f;
 439
 440             // If all the bits were shifted, get the next byte.
 441             if (++tncBitCount == 8)
 442             {
 443                 tncBitCount = 0;
 444
 445                 // If everything was sent, transmit closing flags.
 446                 if (++tncIndex == tncLength)
 447                 {
 448                     tncIndex = 0;
 449                     tncShift = 0x7e;
 450                     tncMode = TNC_TX_END;
 451                 } else
 452                     tncShift = tncBuffer[tncIndex];
 453
 454             } else
 455                 tncShift = tncShift >> 1;
 456
 457             break;
 458
 459         case TNC_TX_END:
 460             // The variable tncShift contains the lastest data byte.
 461             // NRZI enocde the data stream.
 462             if ((tncShift & 0x01) == 0x00) {
 463                 if (tncTxBit == 0)
 464                     tncTxBit = 1;
 465                 else
 466                     tncTxBit = 0;
 467             }
 468
 469             // If all the bits were shifted, get the next one.
 470             if (++tncBitCount == 8)
 471             {
 472                 tncBitCount = 0;
 473                 tncShift = 0x7e;
 474
 475                 // Transmit two closing flags.
 476                 if (++tncIndex == 2)
 477                 {
 478                     tncMode = TNC_TX_READY;
 479
 480                     return;
 481                 } // END if
 482             } else
 483                 tncShift = tncShift >> 1;
 484
 485             break;
 486     } // END switch
 487 }
 488
 489 /**
 490  *   Generate the plain text position packet. Data is written through the tncTxByte
 491  *   callback function
 492  */
 493 void tncPositionPacket(void)
 494 {
 495     int32_t     latitude = 45.4694766 * 10000000;
 496     int32_t     longitude = -122.7376250 * 10000000;
 497     uint32_t    altitude = 10000;
 498     uint16_t    lat_deg;
 499     uint16_t    lon_deg;
 500     uint16_t    lat_min;
 501     uint16_t    lat_frac;
 502     uint16_t    lon_min;
 503     uint16_t    lon_frac;
 504     int         c;
 505
 506     char        lat_sign = 'N', lon_sign = 'E';
 507
 508     if (latitude < 0) {
 509         lat_sign = 'S';
 510         latitude = -latitude;
 511     }
 512
 513     if (longitude < 0) {
 514         lon_sign = 'W';
 515         longitude = -longitude;
 516     }
 517
 518     lat_deg = latitude / 10000000;
 519     latitude -= lat_deg * 10000000;
 520     latitude *= 60;
 521     lat_min = latitude / 10000000;
 522     latitude -= lat_min * 10000000;
 523     lat_frac = (latitude + 50000) / 100000;
 524
 525     lon_deg = longitude / 10000000;
 526     longitude -= lon_deg * 10000000;
 527     longitude *= 60;
 528     lon_min = longitude / 10000000;
 529     longitude -= lon_min * 10000000;
 530     lon_frac = (longitude + 50000) / 100000;
 531
 532     c = sprintf ((char *) tncBufferPnt, "=%02u%02u.%02u%c\\%03u%02u.%02u%cO /A=%06u\015",
 533                 lat_deg, lat_min, lat_frac, lat_sign,
 534                 lon_deg, lon_min, lon_frac, lon_sign,
 535                 altitude * 100 / 3048);
 536     tncBufferPnt += c;
 537     tncLength += c;
 538 }
 539
 540 static int16_t
 541 tncFill(uint8_t *buf, int16_t len)
 542 {
 543     int16_t     l = 0;
 544     uint8_t     b;
 545     uint8_t     bit;
 546
 547     while (tncMode != TNC_TX_READY && l < len) {
 548         b = 0;
 549         for (bit = 0; bit < 8; bit++) {
 550             b = b << 1 | (timeNCO >> 15);
 551             timeNCO += timeNCOFreq;
 552         }
 553         *buf++ = b;
 554         l++;
 555         tnc1200TimerTick();
 556     }
 557     if (tncMode == TNC_TX_READY)
 558         l = -l;
 559     return l;
 560 }
 561
 562 /**
 563  *    Prepare an AX.25 data packet.  Each time this method is called, it automatically
 564  *    rotates through 1 of 3 messages.
 565  *
 566  *    @param dataMode enumerated type that specifies 1200bps A-FSK or 9600bps FSK
 567  */
 568 void tncTxPacket(void)
 569 {
 570     uint16_t crc;
 571
 572     // Set a pointer to our TNC output buffer.
 573     tncBufferPnt = tncBuffer;
 574
 575     // Set the message length counter.
 576     tncLength = 0;
 577
 578     tncPositionPacket();
 579
 580     // Calculate the CRC for the header and message.
 581     crc = sysCRC16(TNC_AX25_HEADER, sizeof(TNC_AX25_HEADER), 0xffff);
 582     crc = sysCRC16(tncBuffer, tncLength, crc ^ 0xffff);
 583
 584     // Save the CRC in the message.
 585     *tncBufferPnt++ = crc & 0xff;
 586     *tncBufferPnt = (crc >> 8) & 0xff;
 587
 588     // Update the length to include the CRC bytes.
 589     tncLength += 2;
 590
 591     // Prepare the variables that are used in the real-time clock interrupt.
 592     tncBitCount = 0;
 593     tncShift = 0x7e;
 594     tncTxBit = 0;
 595     tncIndex = 0;
 596     tncMode = TNC_TX_SYNC;
 597
 598     timeInit();
 599
 600     ao_radio_send_lots(tncFill);
 601 }
 602
 603 /** @} */