--- /dev/null
+/**
+ * http://ad7zj.net/kd7lmo/aprsbeacon_code.html
+ *
+ * @mainpage Pico Beacon
+ *
+ * @section overview_sec Overview
+ *
+ * The Pico Beacon is an APRS based tracking beacon that operates in the UHF 420-450MHz band. The device utilizes a
+ * Microchip PIC 18F2525 embedded controller, Motorola M12+ GPS engine, and Analog Devices AD9954 DDS. The device is capable
+ * of generating a 1200bps A-FSK and 9600 bps FSK AX.25 compliant APRS (Automatic Position Reporting System) message.
+
+
+ *
+ * @section history_sec Revision History
+ *
+ * @subsection v305 V3.05
+ * 23 Dec 2006, Change include; (1) change printf format width to conform to ANSI standard when new CCS 4.xx compiler released.
+ *
+ *
+ * @subsection v304 V3.04
+ * 10 Jan 2006, Change include; (1) added amplitude control to engineering mode,
+ * (2) corrected number of bytes reported in log,
+ * (3) add engineering command to set high rate position reports (5 seconds), and
+ * (4) corrected size of LOG_COORD block when searching for end of log.
+ *
+ * @subsection v303 V3.03
+ * 15 Sep 2005, Change include; (1) removed AD9954 setting SDIO as input pin,
+ * (2) additional comments and Doxygen tags,
+ * (3) integration and test code calculates DDS FTW,
+ * (4) swapped bus and reference analog input ports (hardware change),
+ * (5) added message that indicates we are reading flash log and reports length,
+ * (6) report bus voltage in 10mV steps, and
+ * (7) change log type enumerated values to XORed nibbles for error detection.
+ *
+ *
+ * @subsection v302 V3.02
+ * 6 Apr 2005, Change include; (1) corrected tracked satellite count in NMEA-0183 $GPGGA message,
+ * (2) Doxygen documentation clean up and additions, and
+ * (3) added integration and test code to baseline.
+ *
+ *
+ * @subsection v301 V3.01
+ * 13 Jan 2005, Renamed project and files to Pico Beacon.
+ *
+ *
+ * @subsection v300 V3.00
+ * 15 Nov 2004, Change include; (1) Micro Beacon extreme hardware changes including integral transmitter,
+ * (2) PIC18F2525 processor,
+ * (3) AD9954 DDS support functions,
+ * (4) added comments and formatting for doxygen,
+ * (5) process GPS data with native Motorola protocol,
+ * (6) generate plain text $GPGGA and $GPRMC messages,
+ * (7) power down GPS 5 hours after lock,
+ * (8) added flight data recorder, and
+ * (9) added diagnostics terminal mode.
+ *
+ *
+ * @subsection v201 V2.01
+ * 30 Jan 2004, Change include; (1) General clean up of in-line documentation, and
+ * (2) changed temperature resolution to 0.1 degrees F.
+ *
+ *
+ * @subsection v200 V2.00
+ * 26 Oct 2002, Change include; (1) Micro Beacon II hardware changes including PIC18F252 processor,
+ * (2) serial EEPROM,
+ * (3) GPS power control,
+ * (4) additional ADC input, and
+ * (5) LM60 temperature sensor.
+ *
+ *
+ * @subsection v101 V1.01
+ * 5 Dec 2001, Change include; (1) Changed startup message, and
+ * (2) applied SEPARATE pragma to several methods for memory usage.
+ *
+ *
+ * @subsection v100 V1.00
+ * 25 Sep 2001, Initial release. Flew ANSR-3 and ANSR-4.
+ *
+
+
+ *
+ *
+ * @section copyright_sec Copyright
+ *
+ * Copyright (c) 2001-2009 Michael Gray, KD7LMO
+
+
+ *
+ *
+ * @section gpl_sec GNU General Public License
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+
+
+ *
+ *
+ * @section design Design Details
+ *
+ * Provides design details on a variety of the components that make up the Pico Beacon.
+ *
+ * @subpage power
+ */
+
+/**
+ * @page power Power Consumption
+ *
+ * Measured DC power consumption.
+ *
+ * 3VDC prime power current
+
+ *
+ * 7mA Held in reset
+
+ * 18mA Processor running, all I/O off
+
+ * 110mA GPS running
+
+ * 120mA GPS running w/antenna
+
+ * 250mA DDS running and GPS w/antenna
+
+ * 420mA DDS running, GPS w/antenna, and PA chain on with no RF
+
+ * 900mA Transmit
+
+ *
+ */
+
+// Hardware specific configuration.
+#include <18f2525.h>
+#device ADC=10
+
+// NOTE: Even though we are using an external clock, we set the HS oscillator mode to
+// make the PIC 18F252 work with our external clock which is a clipped 1V P-P sine wave.
+#fuses HS,NOWDT,NOPROTECT,NOPUT,NOBROWNOUT,NOLVP
+
+// C runtime library definitions.
+#include
+#include
+
+// These compiler directives set the clock, SPI/I2C ports, and I/O configuration.
+
+// TCXO frequency
+#use delay(clock=19200000)
+
+// Engineering and data extracation port.
+#use rs232(baud=57600, xmit=PIN_B7, rcv=PIN_B6, STREAM=PC_HOST)
+
+// GPS engine
+#use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7)
+
+#use i2c (master, scl=PIN_C3, sda=PIN_C4)
+
+#use fast_io(A)
+#use fast_io(B)
+#use fast_io(C)
+
+// We define types that are used for all variables. These are declared
+// because each processor has a different sizes for int and long.
+// The PIC compiler defines int8_t, int16_t, and int32_t.
+
+/// Boolean value { false, true }
+typedef boolean bool_t;
+
+/// Signed 8-bit number in the range -128 through 127.
+typedef signed int8 int8_t;
+
+/// Unsigned 8-bit number in the range 0 through 255.
+typedef unsigned int8 uint8_t;
+
+/// Signed 16-bit number in the range -32768 through 32767.
+typedef signed int16 int16_t;
+
+/// Unsigned 16-bit number in the range 0 through 65535.
+typedef unsigned int16 uint16_t;
+
+/// Signed 32-bit number in the range -2147483648 through 2147483647.
+typedef signed int32 int32_t;
+
+/// Unsigned 32-bit number in the range 0 through 4294967296.
+typedef unsigned int32 uint32_t;
+
+// Function and structure prototypes. These are declared at the start of
+// the file much like a C++ header file.
+
+// Map I/O pin names to hardware pins.
+
+/// Heartbeat LED - Port A2
+#define IO_LED PIN_A2
+
+/// AD9954 DDS Profile Select 0 - Port A3
+#define IO_PS0 PIN_A3
+
+/// UHF amplifier and PA chain - Port A4
+#define IO_PTT PIN_A4
+
+/// AD9954 DDS Update - Port A5
+#define IO_UPDATE PIN_A5
+
+/// AD9954 CS (Chip Select) - Port B0
+#define IO_CS PIN_B0
+
+/// GPS Engine Power - Port B1
+#define IO_GPS_PWR PIN_B1
+
+/// AD9954 DDS Profile Select 1 - Port C0
+#define IO_PS1 PIN_C0
+
+/// AD9954 DDS OSK (Output Shift Key) - Port C2
+#define IO_OSK PIN_C2
+
+/// GPS engine serial transmit pin - Port C6
+#define IO_GPS_TXD PIN_C6
+
+// Public methods, constants, and data structures for each class.
+
+/// Operational modes of the AD9954 DDS for the ddsSetMode function.
+enum DDS_MODE
+{
+ /// Device has not been initialized.
+ DDS_MODE_NOT_INITIALIZED,
+
+ /// Device in lowest power down mode.
+ DDS_MODE_POWERDOWN,
+
+ /// Generate FM modulated audio tones.
+ DDS_MODE_AFSK,
+
+ /// Generate true FSK tones.
+ DDS_MODE_FSK
+};
+
+void ddsInit();
+void ddsSetAmplitude (uint8_t amplitude);
+void ddsSetOutputScale (uint16_t amplitude);
+void ddsSetFSKFreq (uint32_t ftw0, uint32_t ftw1);
+void ddsSetFreq (uint32_t freq);
+void ddsSetFTW (uint32_t ftw);
+void ddsSetMode (DDS_MODE mode);
+
+void flashErase();
+uint8_t flashGetByte ();
+void flashReadBlock(uint32_t address, uint8_t *block, uint16_t length);
+void flashSendByte(uint8_t value);
+void flashSendAddress(uint32_t address);
+void flashWriteBlock(uint32_t address, uint8_t *block, uint8_t length);
+
+/// Type of GPS fix.
+enum GPS_FIX_TYPE
+{
+ /// No GPS FIX
+ GPS_NO_FIX,
+
+ /// 2D (Latitude/Longitude) fix.
+ GPS_2D_FIX,
+
+ /// 3D (Latitude/Longitude/Altitude) fix.
+ GPS_3D_FIX
+};
+
+/// GPS Position information.
+typedef struct
+{
+ /// Flag that indicates the position information has been updated since it was last checked.
+ bool_t updateFlag;
+
+ /// Month in UTC time.
+ uint8_t month;
+
+ /// Day of month in UTC time.
+ uint8_t day;
+
+ /// Hours in UTC time.
+ uint8_t hours;
+
+ /// Minutes in UTC time.
+ uint8_t minutes;
+
+ /// Seconds in UTC time.
+ uint8_t seconds;
+
+ /// Year in UTC time.
+ uint16_t year;
+
+ /// Latitude in milli arc-seconds where + is North, - is South.
+ int32_t latitude;
+
+ /// Longitude in milli arc-seconds where + is East, - is West.
+ int32_t longitude;
+
+ /// Altitude in cm
+ int32_t altitudeCM;
+
+ /// Calculated altitude in feet
+ int32_t altitudeFeet;
+
+ /// 3D speed in cm/second.
+ uint16_t vSpeed;
+
+ /// 2D speed in cm/second.
+ uint16_t hSpeed;
+
+ /// Heading units of 0.1 degrees.
+ uint16_t heading;
+
+ /// DOP (Dilution of Precision)
+ uint16_t dop;
+
+ /// 16-bit number that represents status of GPS engine.
+ uint16_t status;
+
+ /// Number of tracked satellites used in the fix position.
+ uint8_t trackedSats;
+
+ /// Number of visible satellites.
+ uint8_t visibleSats;
+} GPSPOSITION_STRUCT;
+
+void gpsInit();
+bool_t gpsIsReady();
+GPS_FIX_TYPE gpsGetFixType();
+int32_t gpsGetPeakAltitude();
+void gpsPowerOn();
+bool_t gpsSetup();
+void gpsUpdate();
+
+int16_t lm92GetTemp();
+
+/// Define the log record types.
+enum LOG_TYPE
+{
+ /// Time stamp the log was started.
+ LOG_BOOTED = 0xb4,
+
+ /// GPS coordinates.
+ LOG_COORD = 0xa5,
+
+ /// Temperature
+ LOG_TEMPERATURE = 0x96,
+
+ /// Bus voltage.
+ LOG_VOLTAGE = 0x87
+};
+
+void logInit();
+uint32_t logGetAddress();
+void logType (LOG_TYPE type);
+void logUint8 (uint8_t value);
+void logInt16 (int16_t value);
+
+bool_t serialHasData();
+void serialInit();
+uint8_t serialRead();
+void serialUpdate();
+
+uint16_t sysCRC16(uint8_t *buffer, uint8_t length, uint16_t crc);
+void sysInit();
+void sysLogVoltage();
+
+/// 0% duty cycle (LED Off) constant for function timeSetDutyCycle
+#define TIME_DUTYCYCLE_0 0
+
+/// 10% duty cycle constant for function timeSetDutyCycle
+#define TIME_DUTYCYCLE_10 1
+
+/// 70% duty cycle constant for function timeSetDutyCycle
+#define TIME_DUTYCYCLE_70 7
+
+uint8_t timeGetTicks();
+void timeInit();
+void timeSetDutyCycle (uint8_t dutyCycle);
+void timeUpdate();
+
+/// Operational modes of the TNC for the tncSetMode function.
+enum TNC_DATA_MODE
+{
+ /// No operation waiting for setup and configuration.
+ TNC_MODE_STANDBY,
+
+ /// 1200 bps using A-FSK (Audio FSK) tones.
+ TNC_MODE_1200_AFSK,
+
+ /// 9600 bps using true FSK tones.
+ TNC_MODE_9600_FSK
+};
+
+void tncInit();
+bool_t tncIsFree();
+void tncHighRate(bool_t state);
+void tncSetMode (TNC_DATA_MODE dataMode);
+void tnc1200TimerTick();
+void tnc9600TimerTick();
+void tncTxByte (uint8_t value);
+void tncTxPacket(TNC_DATA_MODE dataMode);
+
+/**
+ * @defgroup ADC Analog To Digital Converter
+ *
+ * Control and manage the on board PIC A/D converter.
+ *
+ * @{
+ */
+
+/// Filtered voltages using a single pole, low pass filter.
+uint16_t adcMainBusVolt;
+
+/// PIC ADC Channel number of the reference voltage.
+#define ADC_REF 0
+
+/// PIC ADC Channel number of the main bus voltage.
+#define ADC_MAINBUS 1
+
+/// Input diode drop in units of 0.01 volts.
+#define MAIN_BUS_VOLT_OFFSET 20
+
+/**
+ * Intialize the ADC subsystem.
+ */
+void adcInit()
+{
+ // Setup the ADC.
+ setup_adc_ports(AN0_TO_AN1);
+ setup_adc( ADC_CLOCK_DIV_32 );
+
+ // Zero the ADC filters.
+ adcMainBusVolt = 0;
+}
+
+/**
+ * Filtered main bus voltage in 10mV resolution.
+ *
+ * @return voltage in 10mV steps
+ */
+uint16_t adcGetMainBusVolt()
+{
+ uint32_t volts;
+
+ volts = (uint32_t) (adcMainBusVolt >> 3);
+
+ volts = (volts * 330l) / 1023l;
+
+ return (uint16_t) volts + MAIN_BUS_VOLT_OFFSET;
+}
+
+/**
+ * Get the current ADC value for the main bus voltage.
+ *
+ * @return ADC value in the range 0 to 1023
+ */
+uint16_t adcRawBusVolt()
+{
+ set_adc_channel(ADC_MAINBUS);
+ delay_us(50);
+ return read_adc();
+}
+
+/**
+ * Get the current ADC value for the reference source voltage.
+ *
+ * @return ADC value in the range 0 to 1023
+ */
+uint16_t adcRawRefVolt()
+{
+ set_adc_channel(ADC_REF);
+ delay_us(50);
+ return read_adc();
+}
+
+/**
+ * Read and filter the ADC channels for bus voltages.
+ */
+void adcUpdate(void)
+{
+ // Filter the bus voltage using a single pole low pass filter.
+ set_adc_channel(ADC_MAINBUS);
+ delay_us(50);
+ adcMainBusVolt = read_adc() + adcMainBusVolt - (adcMainBusVolt >> 3);
+}
+
+/** @} */
+
+
+/**
+ * @defgroup diag Diagnostics and Control
+ *
+ * Functions for diagnostics and control of the hardware and flight data recorder.
+ *
+ * @{
+ */
+
+/// Number of bytes per line to display when reading flight data recorder.
+#define DIAG_BYTES_PER_LINE 32
+
+/**
+ * Process the command to erase the data logger flash.
+ */
+void diagEraseFlash()
+{
+ // Confirm we want to erase the flash with the key sequence 'yes' .
+ fprintf (PC_HOST, "Are you sure (yes)? ");
+
+ if (fgetc(PC_HOST) != 'y')
+ return;
+
+ if (fgetc(PC_HOST) != 'e')
+ return;
+
+ if (fgetc(PC_HOST) != 's')
+ return;
+
+ if (fgetc(PC_HOST) != 13)
+ return;
+
+ // User feedback and erase the part.
+ fprintf (PC_HOST, "Erasing flash...");
+
+ flashErase();
+
+ fprintf (PC_HOST, "done.\n\r");
+}
+
+/**
+ * Display the engineering mode menu.
+ */
+void diagMenu()
+{
+ // User interface.
+ fprintf (PC_HOST, "Options: (e)rase Flash, (r)ead Flash\n\r");
+ fprintf (PC_HOST, " Toggle (L)ED\n\r");
+ fprintf (PC_HOST, " (P)TT - Push To Transmit\n\r");
+ fprintf (PC_HOST, " (f)requencey down, (F)requency up - 1KHz step\n\r");
+ fprintf (PC_HOST, " (c)hannel down, (C)hannel up - 25KHz step\n\r");
+ fprintf (PC_HOST, " (a)mplitude down, (A)mplitude up - 0.5 dB steps\n\r");
+ fprintf (PC_HOST, " e(x)it engineering mode\n\r");
+}
+
+/**
+ * Process the command to dump the contents of the data logger flash.
+ */
+void diagReadFlash()
+{
+ bool_t dataFoundFlag, userStopFlag;
+ uint8_t i, buffer[DIAG_BYTES_PER_LINE];
+ uint32_t address;
+
+ // Set the initial conditions to read the flash.
+ address = 0x0000;
+ userStopFlag = false;
+
+ do
+ {
+ // Read each block from the flash device.
+ flashReadBlock (address, buffer, DIAG_BYTES_PER_LINE);
+
+ // This flag will get set if any data byte is not equal to 0xff (erase flash state)
+ dataFoundFlag = false;
+
+ // Display the address.
+ fprintf (PC_HOST, "%08lx ", address);
+
+ // Display each byte in the line.
+ for (i = 0; i < DIAG_BYTES_PER_LINE; ++i)
+ {
+ fprintf (PC_HOST, "%02x", buffer[i]);
+
+ // Set this flag if the cell is not erased.
+ if (buffer[i] != 0xff)
+ dataFoundFlag = true;
+
+ // Any key will abort the transfer.
+ if (kbhit(PC_HOST))
+ userStopFlag = true;
+ } // END for
+
+ // at the end of each line.
+ fprintf (PC_HOST, "\n\r");
+
+ // Advance to the next block of memory.
+ address += DIAG_BYTES_PER_LINE;
+ } while (dataFoundFlag && !userStopFlag);
+
+ // Feedback to let the user know why the transfer stopped.
+ if (userStopFlag)
+ fprintf (PC_HOST, "User aborted download!\n\r");
+}
+
+void diag1PPS()
+{
+ uint16_t timeStamp, lastTimeStamp;
+
+ lastTimeStamp = 0x0000;
+
+ gpsPowerOn();
+
+ for (;;)
+ {
+ timeStamp = CCP_2;
+
+ if (timeStamp != lastTimeStamp)
+ {
+ delay_ms (10);
+
+ timeStamp = CCP_2;
+
+ fprintf (PC_HOST, "%lu %lu\n\r", timeStamp, (timeStamp - lastTimeStamp));
+
+ lastTimeStamp = timeStamp;
+ }
+ }
+}
+
+/**
+ * Process diagnostic commands through the debug RS-232 port.
+ */
+void diagPort()
+{
+ bool_t diagDoneFlag, ledFlag, paFlag, showSettingsFlag;
+ uint8_t command, amplitude;
+ uint32_t freqHz;
+
+ // If the input is low, we aren't connected to the RS-232 device so continue to boot.
+ if (!input(PIN_B6))
+ return;
+
+ fprintf (PC_HOST, "Engineering Mode\n\r");
+ fprintf (PC_HOST, "Application Built %s %s\n\r", __DATE__, __TIME__);
+
+ // Current state of the status LED.
+ ledFlag = false;
+ output_bit (IO_LED, ledFlag);
+
+ // This flag indicates we are ready to leave the diagnostics mode.
+ diagDoneFlag = false;
+
+ // Current state of the PA.
+ paFlag = false;
+
+ // Flag that indicate we should show the current carrier frequency.
+ showSettingsFlag = false;
+
+ // Set the initial carrier frequency and amplitude.
+ freqHz = 445950000;
+ amplitude = 0;
+
+ // Wait for the exit command.
+ while (!diagDoneFlag)
+ {
+ // Wait for the user command.
+ command = fgetc(PC_HOST);
+
+ // Decode and process the key stroke.
+ switch (command)
+ {
+ case 'e':
+ diagEraseFlash();
+ logInit();
+ break;
+
+ case 'l':
+ case 'L':
+ ledFlag = (ledFlag ? false : true);
+ output_bit (IO_LED, ledFlag);
+ break;
+
+ case 'h':
+ case 'H':
+ case '?':
+ diagMenu();
+ break;
+
+ case 'r':
+ diagReadFlash();
+ break;
+
+ case 't':
+ tncHighRate (true);
+ fprintf (PC_HOST, "Set high rate TNC.\n\r");
+ break;
+
+ case 'f':
+ freqHz -= 1000;
+ ddsSetFreq (freqHz);
+
+ // Display the new frequency.
+ showSettingsFlag = true;
+ break;
+
+ case 'F':
+ freqHz += 1000;
+ ddsSetFreq (freqHz);
+
+ // Display the new frequency.
+ showSettingsFlag = true;
+ break;
+
+ case 'c':
+ freqHz -= 25000;
+ ddsSetFreq (freqHz);
+
+ // Display the new frequency.
+ showSettingsFlag = true;
+ break;
+
+ case 'C':
+ freqHz += 25000;
+ ddsSetFreq (freqHz);
+
+ // Display the new frequency.
+ showSettingsFlag = true;
+ break;
+
+ case 'p':
+ case 'P':
+ ddsSetFreq (freqHz);
+
+ paFlag = (paFlag ? false : true);
+ output_bit (IO_PTT, paFlag);
+ output_bit (IO_OSK, paFlag);
+
+ if (paFlag)
+ {
+ ddsSetMode (DDS_MODE_AFSK);
+ ddsSetAmplitude (amplitude);
+ } else
+ ddsSetMode (DDS_MODE_POWERDOWN);
+
+ break;
+
+ case 'a':
+ if (amplitude != 200)
+ {
+ amplitude += 5;
+ ddsSetAmplitude (amplitude);
+
+ // Display the new amplitude.
+ showSettingsFlag = true;
+ }
+ break;
+
+ case 'A':
+ if (amplitude != 0)
+ {
+ amplitude -= 5;
+ ddsSetAmplitude (amplitude);
+
+ // Display the new amplitude.
+ showSettingsFlag = true;
+ }
+ break;
+
+ case 'g':
+ diag1PPS();
+ break;
+
+ case 'x':
+ diagDoneFlag = true;
+ break;
+
+ default:
+ fprintf (PC_HOST, "Invalid command. (H)elp for menu.\n\r");
+ break;
+ } // END switch
+
+ // Display the results of any user requests or commands.
+ if (showSettingsFlag)
+ {
+ showSettingsFlag = false;
+
+ fprintf (PC_HOST, "%03ld.%03ld MHz ", freqHz / 1000000, (freqHz / 1000) % 1000);
+ fprintf (PC_HOST, "%d.%01ddBc\n\r", amplitude / 10, amplitude % 10);
+
+ } // END if
+
+ } // END while
+
+ // Let the user know we are done with this mode.
+ fprintf (PC_HOST, "Exit diagnostic mode.\n\r");
+
+ return;
+}
+
+/** @} */
+
+
+/**
+ * @defgroup DDS AD9954 DDS (Direct Digital Synthesizer)
+ *
+ * Functions to control the Analog Devices AD9954 DDS.
+ *
+ * @{
+ */
+
+/// AD9954 CFR1 - Control functions including RAM, profiles, OSK, sync, sweep, SPI, and power control settings.
+#define DDS_AD9954_CFR1 0x00
+
+/// AD9954 CFR2 - Control functions including sync, PLL multiplier, VCO range, and charge pump current.
+#define DDS_AD9954_CFR2 0x01
+
+/// AD9954 ASF - Auto ramp rate speed control and output scale factor (0x0000 to 0x3fff).
+#define DDS_AD9954_ASF 0x02
+
+/// AD9954 ARR - Amplitude ramp rate for OSK function.
+#define DDS_AD9954_ARR 0x03
+
+/// AD9954 FTW0 - Frequency tuning word 0.
+#define DDS_AD9954_FTW0 0x04
+
+/// AD9954 FTW1 - Frequency tuning word 1
+#define DDS_AD9954_FTW1 0x06
+
+/// AD9954 NLSCW - Negative Linear Sweep Control Word used for spectral shaping in FSK mode
+#define DDS_AD9954_NLSCW 0x07
+
+/// AD9954 PLSCW - Positive Linear Sweep Control Word used for spectral shaping in FSK mode
+#define DDS_AD9954_PLSCW 0x08
+
+/// AD9954 RSCW0 - RAM Segment Control Word 0
+#define DDS_AD9954_RWCW0 0x07
+
+/// AD9954 RSCW0 - RAM Segment Control Word 1
+#define DDS_AD9954_RWCW1 0x08
+
+/// AD9954 RAM segment
+#define DDS_RAM 0x0b
+
+/// Current operational mode.
+DDS_MODE ddsMode;
+
+/// Number of digits in DDS frequency to FTW conversion.
+#define DDS_FREQ_TO_FTW_DIGITS 9
+
+/// Array of multiplication factors used to convert frequency to the FTW.
+const uint32_t DDS_MULT[DDS_FREQ_TO_FTW_DIGITS] = { 11, 7, 7, 3, 4, 8, 4, 9, 1 };
+
+/// Array of divisors used to convert frequency to the FTW.
+const uint32_t DDS_DIVISOR[DDS_FREQ_TO_FTW_DIGITS - 1] = { 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000 };
+
+/// Lookup table to convert dB amplitude scale in 0.5 steps to a linear DDS scale factor.
+const uint16_t DDS_AMP_TO_SCALE[] =
+{
+ 16383, 15467, 14601, 13785, 13013, 12286, 11598, 10949, 10337, 9759, 9213, 8697,
+ 8211, 7752, 7318, 6909, 6522, 6157, 5813, 5488, 5181, 4891, 4617, 4359, 4115, 3885, 3668, 3463,
+ 3269, 3086, 2913, 2750, 2597, 2451, 2314, 2185, 2062, 1947, 1838, 1735, 1638
+};
+
+
+/// Frequency Word List - 4.0KHz FM frequency deviation at 81.15MHz (445.950MHz)
+const uint32_t freqTable[256] =
+{
+ 955418300, 955419456, 955420611, 955421765, 955422916, 955424065, 955425210, 955426351,
+ 955427488, 955428618, 955429743, 955430861, 955431971, 955433073, 955434166, 955435249,
+ 955436322, 955437385, 955438435, 955439474, 955440500, 955441513, 955442511, 955443495,
+ 955444464, 955445417, 955446354, 955447274, 955448176, 955449061, 955449926, 955450773,
+ 955451601, 955452408, 955453194, 955453960, 955454704, 955455426, 955456126, 955456803,
+ 955457457, 955458088, 955458694, 955459276, 955459833, 955460366, 955460873, 955461354,
+ 955461809, 955462238, 955462641, 955463017, 955463366, 955463688, 955463983, 955464250,
+ 955464489, 955464701, 955464884, 955465040, 955465167, 955465266, 955465337, 955465380,
+ 955465394, 955465380, 955465337, 955465266, 955465167, 955465040, 955464884, 955464701,
+ 955464489, 955464250, 955463983, 955463688, 955463366, 955463017, 955462641, 955462238,
+ 955461809, 955461354, 955460873, 955460366, 955459833, 955459276, 955458694, 955458088,
+ 955457457, 955456803, 955456126, 955455426, 955454704, 955453960, 955453194, 955452408,
+ 955451601, 955450773, 955449926, 955449061, 955448176, 955447274, 955446354, 955445417,
+ 955444464, 955443495, 955442511, 955441513, 955440500, 955439474, 955438435, 955437385,
+ 955436322, 955435249, 955434166, 955433073, 955431971, 955430861, 955429743, 955428618,
+ 955427488, 955426351, 955425210, 955424065, 955422916, 955421765, 955420611, 955419456,
+ 955418300, 955417144, 955415989, 955414836, 955413684, 955412535, 955411390, 955410249,
+ 955409113, 955407982, 955406857, 955405740, 955404629, 955403528, 955402435, 955401351,
+ 955400278, 955399216, 955398165, 955397126, 955396100, 955395088, 955394089, 955393105,
+ 955392136, 955391183, 955390246, 955389326, 955388424, 955387540, 955386674, 955385827,
+ 955385000, 955384192, 955383406, 955382640, 955381896, 955381174, 955380474, 955379797,
+ 955379143, 955378513, 955377906, 955377324, 955376767, 955376235, 955375728, 955375246,
+ 955374791, 955374362, 955373959, 955373583, 955373234, 955372912, 955372618, 955372350,
+ 955372111, 955371900, 955371716, 955371560, 955371433, 955371334, 955371263, 955371220,
+ 955371206, 955371220, 955371263, 955371334, 955371433, 955371560, 955371716, 955371900,
+ 955372111, 955372350, 955372618, 955372912, 955373234, 955373583, 955373959, 955374362,
+ 955374791, 955375246, 955375728, 955376235, 955376767, 955377324, 955377906, 955378513,
+ 955379143, 955379797, 955380474, 955381174, 955381896, 955382640, 955383406, 955384192,
+ 955385000, 955385827, 955386674, 955387540, 955388424, 955389326, 955390246, 955391183,
+ 955392136, 955393105, 955394089, 955395088, 955396100, 955397126, 955398165, 955399216,
+ 955400278, 955401351, 955402435, 955403528, 955404629, 955405740, 955406857, 955407982,
+ 955409113, 955410249, 955411390, 955412535, 955413684, 955414836, 955415989, 955417144
+};
+
+/**
+ * Initialize the DDS regsiters and RAM.
+ */
+void ddsInit()
+{
+ // Setup the SPI port for the DDS interface.
+ setup_spi( SPI_MASTER | SPI_L_TO_H | SPI_CLK_DIV_4 | SPI_XMIT_L_TO_H );
+
+ // Set the initial DDS mode. The ddsSetMode function uses this value to make the desired DDS selections.
+ ddsMode = DDS_MODE_NOT_INITIALIZED;
+
+ // Set the DDS operational mode.
+ ddsSetMode (DDS_MODE_POWERDOWN);
+
+ // Set the output to full scale.
+ ddsSetOutputScale (0x3fff);
+
+ // CFR2 (Control Function Register No. 2)
+ output_low (IO_CS);
+ spi_write (DDS_AD9954_CFR2);
+
+ spi_write (0x00); // Unused register bits
+ spi_write (0x00);
+ spi_write (0x9c); // 19x reference clock multipler, high VCO range, nominal charge pump current
+ output_high (IO_CS);
+
+ // ARR (Amplitude Ramp Rate) to 15mS for OSK
+ output_low (IO_CS);
+ spi_write (DDS_AD9954_ARR);
+
+ spi_write (83);
+ output_high (IO_CS);
+
+ // Strobe the part so we apply the updates.
+ output_high (IO_UPDATE);
+ output_low (IO_UPDATE);
+}
+
+/**
+ * Set DDS amplitude value in the range 0 to 16383 where 16383 is full scale. This value is a
+ * linear multiplier and needs to be scale for RF output power in log scale.
+ *
+ * @param scale in the range 0 to 16383
+ */
+void ddsSetOutputScale (uint16_t scale)
+{
+ // Set ASF (Amplitude Scale Factor)
+ output_low (IO_CS);
+ spi_write (DDS_AD9954_ASF);
+
+ spi_write ((scale >> 8) & 0xff);
+ spi_write (scale & 0xff);
+
+ output_high (IO_CS);
+
+ // Strobe the DDS to set the amplitude.
+ output_high (IO_UPDATE);
+ output_low (IO_UPDATE);
+}
+
+/**
+ * Set the DDS amplitude in units of dBc of full scale where 1 is 0.1 dB. For example, a value of 30 is 3dBc
+ * or a value of 85 is 8.5dBc.
+ *
+ * @param amplitude in 0.1 dBc of full scale
+ */
+void ddsSetAmplitude (uint8_t amplitude)
+{
+ // Range limit based on the lookup table size.
+ if (amplitude > 200)
+ return;
+
+ // Set the linear DDS ASF (Amplitude Scale Factor) based on the dB lookup table.
+ ddsSetOutputScale (DDS_AMP_TO_SCALE[amplitude / 5]);
+
+ // Toggle the DDS output low and then high to force it to ramp to the new output level setting.
+ output_low (IO_OSK);
+ delay_ms(25);
+
+ output_high (IO_OSK);
+ delay_ms(25);
+}
+
+/**
+ * Set DDS frequency tuning word. The output frequency is equal to RefClock * (ftw / 2 ^ 32).
+ *
+ * @param ftw Frequency Tuning Word
+ */
+void ddsSetFTW (uint32_t ftw)
+{
+ // Set FTW0 (Frequency Tuning Word 0)
+ output_low (IO_CS);
+ spi_write (DDS_AD9954_FTW0);
+
+ spi_write ((ftw >> 24) & 0xff);
+ spi_write ((ftw >> 16) & 0xff);
+ spi_write ((ftw >> 8) & 0xff);
+ spi_write (ftw & 0xff);
+
+ output_high (IO_CS);
+
+ // Strobe the DDS to set the frequency.
+ output_high (IO_UPDATE);
+ output_low (IO_UPDATE);
+}
+
+/**
+ * Convert frequency in hertz to 32-bit DDS FTW (Frequency Tune Word).
+ *
+ * @param freq frequency in Hertz
+ *
+ */
+void ddsSetFreq(uint32_t freq)
+{
+ uint8_t i;
+ uint32_t ftw;
+
+ // To avoid rounding errors with floating point math, we do a long multiply on the data.
+ ftw = freq * DDS_MULT[0];
+
+ for (i = 0; i < DDS_FREQ_TO_FTW_DIGITS - 1; ++i)
+ ftw += (freq * DDS_MULT[i+1]) / DDS_DIVISOR[i];
+
+ ddsSetFTW (ftw);
+}
+
+/**
+ * Set DDS frequency tuning word for the FSK 0 and 1 values. The output frequency is equal
+ * to RefClock * (ftw / 2 ^ 32).
+ *
+ * @param ftw0 frequency tuning word for the FSK 0 value
+ * @param ftw1 frequency tuning word for the FSK 1 value
+ */
+void ddsSetFSKFreq (uint32_t ftw0, uint32_t ftw1)
+{
+ // Set FTW0 (Frequency Tuning Word 0)
+ output_low (IO_CS);
+ spi_write (DDS_AD9954_FTW0);
+
+ spi_write ((ftw0 >> 24) & 0xff);
+ spi_write ((ftw0 >> 16) & 0xff);
+ spi_write ((ftw0 >> 8) & 0xff);
+ spi_write (ftw0 & 0xff);
+
+ output_high (IO_CS);
+
+ // Set FTW0 (Frequency Tuning Word 1)
+ output_low (IO_CS);
+ spi_write (DDS_AD9954_FTW1);
+
+ spi_write ((ftw1 >> 24) & 0xff);
+ spi_write ((ftw1 >> 16) & 0xff);
+ spi_write ((ftw1 >> 8) & 0xff);
+ spi_write (ftw1 & 0xff);
+
+ output_high (IO_CS);
+
+ // Strobe the DDS to set the frequency.
+ output_high (IO_UPDATE);
+ output_low (IO_UPDATE);
+}
+
+/**
+ * Set the DDS to run in A-FSK, FSK, or PSK31 mode
+ *
+ * @param mode DDS_MODE_APRS, DDS_MODE_PSK31, or DDS_MODE_HF_APRS constant
+ */
+void ddsSetMode (DDS_MODE mode)
+{
+ // Save the current mode.
+ ddsMode = mode;
+
+ switch (mode)
+ {
+ case DDS_MODE_POWERDOWN:
+ // CFR1 (Control Function Register No. 1)
+ output_low (IO_CS);
+ spi_write (DDS_AD9954_CFR1);
+
+ spi_write (0x00);
+ spi_write (0x00);
+ spi_write (0x00);
+ spi_write (0xf0); // Power down all subsystems.
+ output_high (IO_CS);
+ break;
+
+ case DDS_MODE_AFSK:
+ // CFR1 (Control Function Register No. 1)
+ output_low (IO_CS);
+ spi_write (DDS_AD9954_CFR1);
+
+ spi_write (0x03); // OSK Enable and Auto OSK keying
+ spi_write (0x00);
+ spi_write (0x00);
+ spi_write (0x40); // Power down comparator circuit
+ output_high (IO_CS);
+ break;
+
+ case DDS_MODE_FSK:
+ // CFR1 (Control Function Register No. 1)
+ output_low (IO_CS);
+ spi_write (DDS_AD9954_CFR1);
+
+ spi_write (0x03); // Clear RAM Enable, OSK Enable, Auto OSK keying
+ spi_write (0x00);
+ spi_write (0x00);
+ spi_write (0x40); // Power down comparator circuit
+ output_high (IO_CS);
+
+ // NOTE: The sweep rate requires 1/4 of a bit time (26uS) to transition.
+ // 6KHz delta = 70641 counts = (6KHz / 364.8MHz) * 2 ^ 32
+ // SYNC_CLK = 91.2MHz 1/91.2MHz * 70641 * 1/29 = 26.7uS
+
+ // NLSCW (Negative Linear Sweep Control Word)
+ output_low (IO_CS);
+ spi_write (DDS_AD9954_NLSCW);
+
+ spi_write (1); // Falling sweep ramp rate word
+ spi_write (0x00); // Delta frequency tuning word
+ spi_write (0x00);
+ spi_write (0x00);
+ spi_write (250);
+ output_high (IO_CS);
+
+ // PLSCW (Positive Linear Sweep Control Word)
+ output_low (IO_CS);
+ spi_write (DDS_AD9954_PLSCW);
+
+ spi_write (1); // Rising sweep ramp rate word
+ spi_write (0x00); // Delta frequency tuning word
+ spi_write (0x00);
+ spi_write (0x00);
+ spi_write (250);
+ output_high (IO_CS);
+ break;
+ } // END switch
+
+ // Strobe the DDS to change the mode.
+ output_high (IO_UPDATE);
+ output_low (IO_UPDATE);
+}
+
+/** @} */
+
+/**
+ * @defgroup flash Flash Manager
+ *
+ * Functions to control the ST MP25P80 serial flash device.
+ *
+ * @{
+ */
+
+/// Flash Chip Select - Port B3
+#define FLASH_CS PIN_B3
+
+/// Flash Clock - Port B5
+#define FLASH_CLK PIN_B5
+
+/// Flash Data Input - Port B4
+#define FLASH_D PIN_B4
+
+/// Flash Data Output - Port B2
+#define FLASH_Q PIN_B2
+
+/**
+ * Determine if a flash write or erase operation is currently in progress.
+ *
+ * @return true if write/erase in progress
+ */
+bool_t flashIsWriteInProgress()
+{
+ uint8_t status;
+
+ output_low (FLASH_CS);
+
+ // Read Status Register (RDSR) flash command.
+ flashSendByte (0x05);
+
+ status = flashGetByte();
+
+ output_high (FLASH_CS);
+
+ return (((status & 0x01) == 0x01) ? true : false);
+}
+
+/**
+ * Read a block of memory from the flash device.
+ *
+ * @param address of desired location in the range 0x00000 to 0xFFFFF (1MB)
+ * @param block pointer to locate of data block
+ * @param length number of bytes to read
+ */
+void flashReadBlock(uint32_t address, uint8_t *block, uint16_t length)
+{
+ uint16_t i;
+
+ output_low (FLASH_CS);
+
+ // Read Data Byte(s) (READ) flash command.
+ flashSendByte (0x03);
+ flashSendAddress (address);
+
+ for (i = 0; i < length; ++i)
+ *block++ = flashGetByte();
+
+ output_high (FLASH_CS);
+}
+
+/**
+ * Write a block of memory to the flash device.
+ *
+ * @param address of desired location in the range 0x00000 to 0xFFFFF (1MB)
+ * @param block pointer data block to write
+ * @param length number of bytes to write
+ */
+void flashWriteBlock(uint32_t address, uint8_t *block, uint8_t length)
+{
+ uint8_t i;
+
+ output_low (FLASH_CS);
+ // Write Enable (WREN) flash command.
+ flashSendByte (0x06);
+ output_high (FLASH_CS);
+
+ output_low (FLASH_CS);
+ // Page Program (PP) flash command.
+ flashSendByte (0x02);
+ flashSendAddress (address);
+
+ for (i = 0; i < length; ++i)
+ {
+ // Send each byte in the data block.
+ flashSendByte (*block++);
+
+ // Track the address in the flash device.
+ ++address;
+
+ // If we cross a page boundary (a page is 256 bytes) we need to stop and send the address again.
+ if ((address & 0xff) == 0x00)
+ {
+ output_high (FLASH_CS);
+
+ // Write this block of data.
+ while (flashIsWriteInProgress());
+
+ output_low (FLASH_CS);
+ // Write Enable (WREN) flash command.
+ flashSendByte (0x06);
+ output_high (FLASH_CS);
+
+ output_low (FLASH_CS);
+ // Page Program (PP) flash command.
+ flashSendByte (0x02);
+ flashSendAddress (address);
+ } // END if
+ } // END for
+
+ output_high (FLASH_CS);
+
+ // Wait for the final write operation to complete.
+ while (flashIsWriteInProgress());
+}
+
+/**
+ * Erase the entire flash device (all locations set to 0xff).
+ */
+void flashErase()
+{
+ output_low (FLASH_CS);
+ // Write Enable (WREN) flash command.
+ flashSendByte (0x06);
+ output_high (FLASH_CS);
+
+ output_low (FLASH_CS);
+ // Bulk Erase (BE) flash command.
+ flashSendByte (0xc7);
+ output_high (FLASH_CS);
+
+ while (flashIsWriteInProgress());
+}
+
+/**
+ * Read a single byte from the flash device through the serial interface. This function
+ * only controls the clock line. The chip select must be configured before calling
+ * this function.
+ *
+ * @return byte read from device
+ */
+uint8_t flashGetByte()
+{
+ uint8_t i, value;
+
+ value = 0;
+
+ // Bit bang the 8-bits.
+ for (i = 0; i < 8; ++i)
+ {
+ // Data is ready on the rising edge of the clock.
+ output_high (FLASH_CLK);
+
+ // MSB is first, so shift left.
+ value = value << 1;
+
+ if (input (FLASH_Q))
+ value = value | 0x01;
+
+ output_low (FLASH_CLK);
+ } // END for
+
+ return value;
+}
+
+/**
+ * Initialize the flash memory subsystem.
+ */
+void flashInit()
+{
+ // I/O lines to control flash.
+ output_high (FLASH_CS);
+ output_low (FLASH_CLK);
+ output_low (FLASH_D);
+}
+
+/**
+ * Write a single byte to the flash device through the serial interface. This function
+ * only controls the clock line. The chip select must be configured before calling
+ * this function.
+ *
+ * @param value byte to write to device
+ */
+void flashSendByte(uint8_t value)
+{
+ uint8_t i;
+
+ // Bit bang the 8-bits.
+ for (i = 0; i < 8; ++i)
+ {
+ // Drive the data input pin.
+ if ((value & 0x80) == 0x80)
+ output_high (FLASH_D);
+ else
+ output_low (FLASH_D);
+
+ // MSB is first, so shift leeft.
+ value = value << 1;
+
+ // Data is accepted on the rising edge of the clock.
+ output_high (FLASH_CLK);
+ output_low (FLASH_CLK);
+ } // END for
+}
+
+/**
+ * Write the 24-bit address to the flash device through the serial interface. This function
+ * only controls the clock line. The chip select must be configured before calling
+ * this function.
+ *
+ * @param address 24-bit flash device address
+ */
+void flashSendAddress(uint32_t address)
+{
+ uint8_t i;
+
+ // Bit bang the 24-bits.
+ for (i = 0; i < 24; ++i)
+ {
+ // Drive the data input pin.
+ if ((address & 0x800000) == 0x800000)
+ output_high (FLASH_D);
+ else
+ output_low (FLASH_D);
+
+ // MSB is first, so shift left.
+ address = address << 1;
+
+ // Data is accepted on the rising edge of the clock.
+ output_high (FLASH_CLK);
+ output_low (FLASH_CLK);
+ } // END for
+}
+
+/** @} */
+
+/**
+ * @defgroup GPS Motorola M12+ GPS Engine
+ *
+ * Functions to control the Motorola M12+ GPS engine in native binary protocol mode.
+ *
+ * @{
+ */
+
+/// The maximum length of a binary GPS engine message.
+#define GPS_BUFFER_SIZE 50
+
+/// GPS parse engine state machine values.
+enum GPS_PARSE_STATE_MACHINE
+{
+ /// 1st start character '@'
+ GPS_START1,
+
+ /// 2nd start character '@'
+ GPS_START2,
+
+ /// Upper case 'A' - 'Z' message type
+ GPS_COMMAND1,
+
+ /// Lower case 'a' - 'z' message type
+ GPS_COMMAND2,
+
+ /// 0 - xx bytes based on message type 'Aa'
+ GPS_READMESSAGE,
+
+ /// 8-bit checksum
+ GPS_CHECKSUMMESSAGE,
+
+ /// End of message - Carriage Return
+ GPS_EOMCR,
+
+ /// End of message - Line Feed
+ GPS_EOMLF
+};
+
+/// Index into gpsBuffer used to store message data.
+uint8_t gpsIndex;
+
+/// State machine used to parse the GPS message stream.
+GPS_PARSE_STATE_MACHINE gpsParseState;
+
+/// Buffer to store data as it is read from the GPS engine.
+uint8_t gpsBuffer[GPS_BUFFER_SIZE];
+
+/// Peak altitude detected while GPS is in 3D fix mode.
+int32_t gpsPeakAltitude;
+
+/// Checksum used to verify binary message from GPS engine.
+uint8_t gpsChecksum;
+
+/// Last verified GPS message received.
+GPSPOSITION_STRUCT gpsPosition;
+
+/**
+ * Get the type of fix.
+ *
+ * @return gps fix type enumeration
+ */
+GPS_FIX_TYPE gpsGetFixType()
+{
+ // The upper 3-bits determine the fix type.
+ switch (gpsPosition.status & 0xe000)
+ {
+ case 0xe000:
+ return GPS_3D_FIX;
+
+ case 0xc000:
+ return GPS_2D_FIX;
+
+ default:
+ return GPS_NO_FIX;
+ } // END switch
+}
+
+/**
+ * Peak altitude detected while GPS is in 3D fix mode since the system was booted.
+ *
+ * @return altitude in feet
+ */
+int32_t gpsGetPeakAltitude()
+{
+ return gpsPeakAltitude;
+}
+
+/**
+ * Initialize the GPS subsystem.
+ */
+void gpsInit()
+{
+ // Initial parse state.
+ gpsParseState = GPS_START1;
+
+ // Assume we start at sea level.
+ gpsPeakAltitude = 0;
+
+ // Clear the structure that stores the position message.
+ memset (&gpsPosition, 0, sizeof(GPSPOSITION_STRUCT));
+
+ // Setup the timers used to measure the 1-PPS time period.
+ setup_timer_3(T3_INTERNAL | T3_DIV_BY_1);
+ setup_ccp2 (CCP_CAPTURE_RE | CCP_USE_TIMER3);
+}
+
+/**
+ * Determine if new GPS message is ready to process. This function is a one shot and
+ * typically returns true once a second for each GPS position fix.
+ *
+ * @return true if new message available; otherwise false
+ */
+bool_t gpsIsReady()
+{
+ if (gpsPosition.updateFlag)
+ {
+ gpsPosition.updateFlag = false;
+ return true;
+ } // END if
+
+ return false;
+}
+
+/**
+ * Calculate NMEA-0183 message checksum of buffer that is length bytes long.
+ *
+ * @param buffer pointer to data buffer.
+ * @param length number of bytes in buffer.
+ *
+ * @return checksum of buffer
+ */
+uint8_t gpsNMEAChecksum (uint8_t *buffer, uint8_t length)
+{
+ uint8_t i, checksum;
+
+ checksum = 0;
+
+ for (i = 0; i < length; ++i)
+ checksum ^= buffer[i];
+
+ return checksum;
+}
+
+/**
+ * Verify the GPS engine is sending the @@Hb position report message. If not,
+ * configure the GPS engine to send the desired report.
+ *
+ * @return true if GPS engine operation; otherwise false
+ */
+bool_t gpsSetup()
+{
+ uint8_t startTime, retryCount;
+
+ // We wait 10 seconds for the GPS engine to respond to our message request.
+ startTime = timeGetTicks();
+ retryCount = 0;
+
+ while (++retryCount < 10)
+ {
+ // Read the serial FIFO and process the GPS messages.
+ gpsUpdate();
+
+ // If a GPS data set is available, then GPS is operational.
+ if (gpsIsReady())
+ {
+ timeSetDutyCycle (TIME_DUTYCYCLE_10);
+ return true;
+ }
+
+ if (timeGetTicks() > startTime)
+ {
+ puts ("@@Hb\001\053\015\012");
+ startTime += 10;
+ } // END if
+
+ } // END while
+
+ return false;
+}
+
+/**
+ * Parse the Motorola @@Hb (Short position/message) report.
+ */
+void gpsParsePositionMessage()
+{
+ // Convert the binary stream into data elements. We will scale to the desired units
+ // as the values are used.
+ gpsPosition.updateFlag = true;
+
+ gpsPosition.month = gpsBuffer[0];
+ gpsPosition.day = gpsBuffer[1];
+ gpsPosition.year = ((uint16_t) gpsBuffer[2] << 8) | gpsBuffer[3];
+ gpsPosition.hours = gpsBuffer[4];
+ gpsPosition.minutes = gpsBuffer[5];
+ gpsPosition.seconds = gpsBuffer[6];
+ gpsPosition.latitude = ((int32) gpsBuffer[11] << 24) | ((int32) gpsBuffer[12] << 16) | ((int32) gpsBuffer[13] << 8) | (int32) gpsBuffer[14];
+ gpsPosition.longitude = ((int32) gpsBuffer[15] << 24) | ((int32) gpsBuffer[16] << 16) | ((int32) gpsBuffer[17] << 8) | gpsBuffer[18];
+ gpsPosition.altitudeCM = ((int32) gpsBuffer[19] << 24) | ((int32) gpsBuffer[20] << 16) | ((int32) gpsBuffer[21] << 8) | gpsBuffer[22];
+ gpsPosition.altitudeFeet = gpsPosition.altitudeCM * 100l / 3048l;
+ gpsPosition.vSpeed = ((uint16_t) gpsBuffer[27] << 8) | gpsBuffer[28];
+ gpsPosition.hSpeed = ((uint16_t) gpsBuffer[29] << 8) | gpsBuffer[30];
+ gpsPosition.heading = ((uint16_t) gpsBuffer[31] << 8) | gpsBuffer[32];
+ gpsPosition.dop = ((uint16_t) gpsBuffer[33] << 8) | gpsBuffer[34];
+ gpsPosition.visibleSats = gpsBuffer[35];
+ gpsPosition.trackedSats = gpsBuffer[36];
+ gpsPosition.status = ((uint16_t) gpsBuffer[37] << 8) | gpsBuffer[38];
+
+ // Update the peak altitude if we have a valid 3D fix.
+ if (gpsGetFixType() == GPS_3D_FIX)
+ if (gpsPosition.altitudeFeet > gpsPeakAltitude)
+ gpsPeakAltitude = gpsPosition.altitudeFeet;
+}
+
+/**
+ * Turn on the GPS engine power and serial interface.
+ */
+void gpsPowerOn()
+{
+ // 3.0 VDC LDO control line.
+ output_high (IO_GPS_PWR);
+
+ // Enable the UART and the transmit line.
+#asm
+ bsf 0xFAB.7
+#endasm
+}
+
+/**
+ * Turn off the GPS engine power and serial interface.
+ */
+void gpsPowerOff()
+{
+ // Disable the UART and the transmit line.
+#asm
+ bcf 0xFAB.7
+#endasm
+
+ // 3.0 VDC LDO control line.
+ output_low (IO_GPS_PWR);
+}
+
+/**
+ * Read the serial FIFO and process complete GPS messages.
+ */
+void gpsUpdate()
+{
+ uint8_t value;
+
+ // This state machine handles each characters as it is read from the GPS serial port.
+ // We are looking for the GPS mesage @@Hb ... C
+ while (serialHasData())
+ {
+ // Get the character value.
+ value = serialRead();
+
+ // Process based on the state machine.
+ switch (gpsParseState)
+ {
+ case GPS_START1:
+ if (value == '@')
+ gpsParseState = GPS_START2;
+ break;
+
+ case GPS_START2:
+ if (value == '@')
+ gpsParseState = GPS_COMMAND1;
+ else
+ gpsParseState = GPS_START1;
+ break;
+
+ case GPS_COMMAND1:
+ if (value == 'H')
+ gpsParseState = GPS_COMMAND2;
+ else
+ gpsParseState = GPS_START1;
+ break;
+
+ case GPS_COMMAND2:
+ if (value == 'b')
+ {
+ gpsParseState = GPS_READMESSAGE;
+ gpsIndex = 0;
+ gpsChecksum = 0;
+ gpsChecksum ^= 'H';
+ gpsChecksum ^= 'b';
+ } else
+ gpsParseState = GPS_START1;
+ break;
+
+ case GPS_READMESSAGE:
+ gpsChecksum ^= value;
+ gpsBuffer[gpsIndex++] = value;
+
+ if (gpsIndex == 47)
+ gpsParseState = GPS_CHECKSUMMESSAGE;
+
+ break;
+
+ case GPS_CHECKSUMMESSAGE:
+ if (gpsChecksum == value)
+ gpsParseState = GPS_EOMCR;
+ else
+ gpsParseState = GPS_START1;
+ break;
+
+ case GPS_EOMCR:
+ if (value == 13)
+ gpsParseState = GPS_EOMLF;
+ else
+ gpsParseState = GPS_START1;
+ break;
+
+ case GPS_EOMLF:
+ // Once we have the last character, convert the binary message to something usable.
+ if (value == 10)
+ gpsParsePositionMessage();
+
+ gpsParseState = GPS_START1;
+ break;
+ } // END switch
+ } // END while
+}
+
+/** @} */
+
+
+/**
+ * @defgroup log Flight Data Recorder
+ *
+ * Functions to manage and control the flight data recorder
+ *
+ * @{
+ */
+
+/// Number of bytes to buffer before writing to flash memory.
+#define LOG_WRITE_BUFFER_SIZE 40
+
+/// Last used address in flash memory.
+uint32_t logAddress;
+
+/// Temporary buffer that holds data before it is written to flash device.
+uint8_t logBuffer[LOG_WRITE_BUFFER_SIZE];
+
+/// Current index into log buffer.
+uint8_t logIndex;
+
+/**
+ * Last used address in flash memory. This location is where the next log data will
+ * be written.
+ *
+ * @return 24-bit flash memory address
+ */
+uint32_t logGetAddress()
+{
+ return logAddress;
+}
+
+/**
+ * Write the contents of the temporary log buffer to the flash device. If the buffer
+ * is empty, nothing is done.
+ */
+void logFlush()
+{
+ // We only need to write if there is data.
+ if (logIndex != 0)
+ {
+ flashWriteBlock (logAddress, logBuffer, logIndex);
+ logAddress += logIndex;
+ logIndex = 0;
+ } // END if
+}
+
+/**
+ * Prepare the flight data recorder for logging.
+ */
+void logInit()
+{
+ uint8_t buffer[8];
+ bool_t endFound;
+
+ fprintf (PC_HOST, "Searching for end of flash log...");
+
+ logAddress = 0x0000;
+ endFound = false;
+
+ // Read each logged data block from flash to determine how long it is.
+ do
+ {
+ // Read the data log entry type.
+ flashReadBlock (logAddress, buffer, 1);
+
+ // Based on the log entry type, we'll skip over the data contained in the entry.
+ switch (buffer[0])
+ {
+ case LOG_BOOTED:
+ logAddress += 7;
+ break;
+
+ case LOG_COORD:
+ logAddress += 26;
+ break;
+
+ case LOG_TEMPERATURE:
+ logAddress += 3;
+ break;
+
+ case LOG_VOLTAGE:
+ logAddress += 5;
+ break;
+
+ case 0xff:
+ endFound = true;
+ break;
+
+ default:
+ ++logAddress;
+ } // END switch
+ } while (logAddress < 0x100000 && !endFound);
+
+ fprintf (PC_HOST, "done. Log contains %ld bytes.\n\r", logAddress);
+
+ logIndex = 0;
+}
+
+/**
+ * Start a entry in the data log.
+ *
+ * @param type of log entry, i.e. LOG_BOOTED, LOG_COORD, etc.
+ */
+void logType (LOG_TYPE type)
+{
+ // Only add the new entry if there is space.
+ if (logAddress >= 0x100000)
+ return;
+
+ // Write the old entry first.
+ logFlush();
+
+ // Save the type and set the log buffer pointer.
+ logBuffer[0] = type;
+ logIndex = 1;
+}
+
+/**
+ * Save an unsigned, 8-bit value in the log.
+ *
+ * @param value unsigned, 8-bit value
+ */
+void logUint8 (uint8_t value)
+{
+ logBuffer[logIndex++] = value;
+}
+
+/**
+ * Save a signed, 16-bit value in the log.
+ *
+ * @param value signed, 16-bit value
+ */
+void logInt16 (int16_t value)
+{
+ logBuffer[logIndex++] = (value >> 8) & 0xff;
+ logBuffer[logIndex++] = value & 0xff;
+}
+
+/**
+ * Save an unsigned, 16-bit value in the log.
+ *
+ * @param value unsigned, 16-bit value
+ */
+void logUint16 (uint16_t value)
+{
+ logBuffer[logIndex++] = (value >> 8) & 0xff;
+ logBuffer[logIndex++] = value & 0xff;
+}
+
+/**
+ * Save a signed, 32-bit value in the log.
+ *
+ * @param value signed, 32-bit value
+ */
+void logInt32 (int32_t value)
+{
+ logBuffer[logIndex++] = (value >> 24) & 0xff;
+ logBuffer[logIndex++] = (value >> 16) & 0xff;
+ logBuffer[logIndex++] = (value >> 8) & 0xff;
+ logBuffer[logIndex++] = value & 0xff;
+}
+
+/** @} */
+
+/**
+ * @defgroup LM92 LM92 temperature sensor
+ *
+ * Read and control the National Semiconductor LM92 I2C temperature sensor
+ *
+ * @{
+ */
+
+/**
+ * Read the LM92 temperature value in 0.1 degrees F.
+ *
+ * @return 0.1 degrees F
+ */
+int16_t lm92GetTemp()
+{
+ int16_t value;
+ int32_t temp;
+
+ // Set the SDA and SCL to input pins to control the LM92.
+ set_tris_c (0x9a);
+
+ // Read the temperature register value.
+ i2c_start();
+ i2c_write(0x97);
+ value = ((int16_t) i2c_read() << 8);
+ value = value | ((int16_t) i2c_read() & 0x00f8);
+ i2c_stop();
+
+ // Set the SDA and SCL back to outputs for use with the AD9954 because we share common clock pins.
+ set_tris_c (0x82);
+
+ // LM92 register 0.0625degC/bit 9 10 9
+ // ------------- * -------------- * - * -- = -- + 320
+ // 8 5 64
+
+ // Convert to degrees F.
+ temp = (int32_t) value;
+ temp = ((temp * 9l) / 64l) + 320;
+
+ return (int16_t) temp;
+}
+
+/** @} */
+
+
+/**
+ * @defgroup serial Serial Port FIFO
+ *
+ * FIFO for the built-in serial port.
+ *
+ * @{
+ */
+
+/// Size of serial port FIFO in bytes. It must be a power of 2, i.e. 2, 4, 8, 16, etc.
+#define SERIAL_BUFFER_SIZE 64
+
+/// Mask to wrap around at end of circular buffer. (SERIAL_BUFFER_SIZE - 1)
+#define SERIAL_BUFFER_MASK 0x3f
+
+/// Index to the next free location in the buffer.
+uint8_t serialHead;
+
+/// Index to the next oldest data in the buffer.
+uint8_t serialTail;
+
+/// Circular buffer (FIFO) to hold serial data.
+uint8_t serialBuffer[SERIAL_BUFFER_SIZE];
+
+/**
+ * Determine if the FIFO contains data.
+ *
+ * @return true if data present; otherwise false
+ */
+bool_t serialHasData()
+{
+ if (serialHead == serialTail)
+ return false;
+
+ return true;
+}
+
+/**
+ * Initialize the serial processor.
+ */
+void serialInit()
+{
+ serialHead = 0;
+ serialTail = 0;
+}
+
+/**
+ * Get the oldest character from the FIFO.
+ *
+ * @return oldest character; 0 if FIFO is empty
+ */
+uint8_t serialRead()
+{
+ uint8_t value;
+
+ // Make sure we have something to return.
+ if (serialHead == serialTail)
+ return 0;
+
+ // Save the value.
+ value = serialBuffer[serialTail];
+
+ // Update the pointer.
+ serialTail = (serialTail + 1) & SERIAL_BUFFER_MASK;
+
+ return value;
+}
+
+/**
+ * Read and store any characters in the PIC serial port in a FIFO.
+ */
+void serialUpdate()
+{
+ // If there isn't a character in the PIC buffer, just leave.
+ while (kbhit())
+ {
+ // Save the value in the FIFO.
+ serialBuffer[serialHead] = getc();
+
+ // Move the pointer to the next open space.
+ serialHead = (serialHead + 1) & SERIAL_BUFFER_MASK;
+ }
+}
+
+/** @} */
+
+/**
+ * @defgroup sys System Library Functions
+ *
+ * Generic system functions similiar to the run-time C library.
+ *
+ * @{
+ */
+
+/**
+ * Calculate the CRC-16 CCITT of buffer that is length bytes long.
+ * The crc parameter allow the calculation on the CRC on multiple buffers.
+ *
+ * @param buffer Pointer to data buffer.
+ * @param length number of bytes in data buffer
+ * @param crc starting value
+ *
+ * @return CRC-16 of buffer[0 .. length]
+ */
+uint16_t sysCRC16(uint8_t *buffer, uint8_t length, uint16_t crc)
+{
+ uint8_t i, bit, value;
+
+ for (i = 0; i < length; ++i)
+ {
+ value = buffer[i];
+
+ for (bit = 0; bit < 8; ++bit)
+ {
+ crc ^= (value & 0x01);
+ crc = ( crc & 0x01 ) ? ( crc >> 1 ) ^ 0x8408 : ( crc >> 1 );
+ value = value >> 1;
+ } // END for
+ } // END for
+
+ return crc ^ 0xffff;
+}
+
+/**
+ * Initialize the system library and global resources.
+ */
+void sysInit()
+{
+ gpsPowerOff ();
+ output_high (IO_LED);
+
+ output_high (IO_CS);
+ output_low (IO_PS1);
+ output_low (IO_PS0);
+ output_low (IO_OSK);
+ output_low (IO_UPDATE);
+ output_low (IO_PTT);
+ output_low (IO_GPS_TXD);
+
+ // Configure the port direction (input/output).
+ set_tris_a (0xc3);
+ set_tris_b (0x44);
+ set_tris_c (0x82);
+
+ // Display a startup message during boot.
+ fprintf (PC_HOST, "System booted.\n\r");
+}
+
+/**
+ * Log the current GPS position.
+ */
+void sysLogGPSData()
+{
+ // Log the data.
+ logType (LOG_COORD);
+ logUint8 (gpsPosition.hours);
+ logUint8 (gpsPosition.minutes);
+ logUint8 (gpsPosition.seconds);
+ logInt32 (gpsPosition.latitude);
+ logInt32 (gpsPosition.longitude);
+ logInt32 (gpsPosition.altitudeCM);
+
+ logUint16 (gpsPosition.vSpeed);
+ logUint16 (gpsPosition.hSpeed);
+ logUint16 (gpsPosition.heading);
+
+ logUint16 (gpsPosition.status);
+
+ logUint8 ((uint8_t) (gpsPosition.dop & 0xff));
+ logUint8 ((uint8_t) ((gpsPosition.visibleSats << 4) | gpsPosition.trackedSats));
+}
+
+/**
+ * Log the ADC values of the bus and reference voltage values.
+ */
+void sysLogVoltage()
+{
+ logType (LOG_VOLTAGE);
+ logUint16 (adcRawBusVolt());
+ logUint16 (adcRawRefVolt());
+}
+
+/** @} */
+
+/**
+ * @defgroup rtc Real Time Interrupt tick
+ *
+ * Manage the built-in real time interrupt. The interrupt clock PRI is 104uS (9600 bps).
+ *
+ * @{
+ */
+
+/// A counter that ticks every 100mS.
+uint8_t timeTicks;
+
+/// Counts the number of 104uS interrupts for a 100mS time period.
+uint16_t timeInterruptCount;
+
+/// Counts the number of 100mS time periods in 1 second.
+uint8_t time100ms;
+
+/// System time in seconds.
+uint8_t timeSeconds;
+
+/// System time in minutes.
+uint8_t timeMinutes;
+
+/// System time in hours.
+uint8_t timeHours;
+
+/// Desired LED duty cycle 0 to 9 where 0 = 0% and 9 = 90%.
+uint8_t timeDutyCycle;
+
+/// Current value of the timer 1 compare register used to generate 104uS interrupt rate (9600bps).
+uint16_t timeCompare;
+
+/// 16-bit NCO where the upper 8-bits are used to index into the frequency generation table.
+uint16_t timeNCO;
+
+/// Audio tone NCO update step (phase).
+uint16_t timeNCOFreq;
+
+/// Counter used to deciminate down from the 104uS to 833uS interrupt rate. (9600 to 1200 baud)
+uint8_t timeLowRateCount;
+
+/// Current TNC mode (standby, 1200bps A-FSK, or 9600bps FSK)
+TNC_DATA_MODE tncDataMode;
+
+/// Flag set true once per second.
+bool_t timeUpdateFlag;
+
+/// Flag that indicate the flight time should run.
+bool_t timeRunFlag;
+
+/// The change in the CCP_1 register for each 104uS (9600bps) interrupt period.
+#define TIME_RATE 125
+
+/**
+ * Running 8-bit counter that ticks every 100mS.
+ *
+ * @return 100mS time tick
+ */
+uint8_t timeGetTicks()
+{
+ return timeTicks;
+}
+
+/**
+ * Initialize the real-time clock.
+ */
+void timeInit()
+{
+ timeTicks = 0;
+ timeInterruptCount = 0;
+ time100mS = 0;
+ timeSeconds = 0;
+ timeMinutes = 0;
+ timeHours = 0;
+ timeDutyCycle = TIME_DUTYCYCLE_70;
+ timeCompare = TIME_RATE;
+ timeUpdateFlag = false;
+ timeNCO = 0x00;
+ timeLowRateCount = 0;
+ timeNCOFreq = 0x2000;
+ tncDataMode = TNC_MODE_STANDBY;
+ timeRunFlag = false;
+
+ // Configure CCP1 to interrupt at 1mS for PSK31 or 833uS for 1200 baud APRS
+ CCP_1 = TIME_RATE;
+ set_timer1(timeCompare);
+ setup_ccp1( CCP_COMPARE_INT );
+ setup_timer_1( T1_INTERNAL | T1_DIV_BY_4 );
+}
+
+/**
+ * Function return true once a second based on real-time clock.
+ *
+ * @return true on one second tick; otherwise false
+ */
+bool_t timeIsUpdate()
+{
+ if (timeUpdateFlag)
+ {
+ timeUpdateFlag = false;
+ return true;
+ } // END if
+
+ return false;
+}
+
+/**
+ * Set the blink duty cycle of the heartbeat LED. The LED blinks at a 1Hz rate.
+ *
+ * @param dutyCycle TIME_DUTYCYCLE_xx constant
+ */
+void timeSetDutyCycle (uint8_t dutyCycle)
+{
+ timeDutyCycle = dutyCycle;
+}
+
+/**
+ * Set a flag to indicate the flight time should run. This flag is typically set when the payload
+ * lifts off.
+ */
+void timeSetRunFlag()
+{
+ timeRunFlag = true;
+}
+
+#INT_CCP1
+/**
+ * Timer interrupt handler called every 104uS (9600 times/second).
+ */
+void timeUpdate()
+{
+ // Setup the next interrupt for the operational mode.
+ timeCompare += TIME_RATE;
+ CCP_1 = timeCompare;
+
+ switch (tncDataMode)
+ {
+ case TNC_MODE_STANDBY:
+ break;
+
+ case TNC_MODE_1200_AFSK:
+ ddsSetFTW (freqTable[timeNCO >> 8]);
+
+ timeNCO += timeNCOFreq;
+
+ if (++timeLowRateCount == 8)
+ {
+ timeLowRateCount = 0;
+ tnc1200TimerTick();
+ } // END if
+ break;
+
+ case TNC_MODE_9600_FSK:
+ tnc9600TimerTick();
+ break;
+ } // END switch
+
+ // Read the GPS serial port and save any incoming characters.
+ serialUpdate();
+
+ // Count the number of milliseconds required for the tenth second counter.
+ if (++timeInterruptCount == 960)
+ {
+ timeInterruptCount = 0;
+
+ // This timer just ticks every 100mS and is used for general timing.
+ ++timeTicks;
+
+ // Roll the counter over every second.
+ if (++time100mS == 10)
+ {
+ time100mS = 0;
+
+ // We set this flag true every second.
+ timeUpdateFlag = true;
+
+ // Maintain a Real Time Clock.
+ if (timeRunFlag)
+ if (++timeSeconds == 60)
+ {
+ timeSeconds = 0;
+
+ if (++timeMinutes == 60)
+ {
+ timeMinutes = 0;
+ ++timeHours;
+ } // END if timeMinutes
+ } // END if timeSeconds
+ } // END if time100mS
+
+ // Flash the status LED at timeDutyCycle % per second. We use the duty cycle for mode feedback.
+ if (time100mS >= timeDutyCycle)
+ output_low (IO_LED);
+ else
+ output_high (IO_LED);
+ } // END if
+}
+
+/** @} */
+
+/**
+ * @defgroup tnc TNC (Terminal Node Controller)
+ *
+ * Functions that provide a subset of the TNC functions.
+ *
+ * @{
+ */
+
+/// The number of start flag bytes to send before the packet message. (360bits * 1200bps = 300mS)
+#define TNC_TX_DELAY 45
+
+/// The size of the TNC output buffer.
+#define TNC_BUFFER_SIZE 80
+
+/// States that define the current mode of the 1200 bps (A-FSK) state machine.
+enum TNC_TX_1200BPS_STATE
+{
+ /// Stand by state ready to accept new message.
+ TNC_TX_READY,
+
+ /// 0x7E bit stream pattern used to define start of APRS message.
+ TNC_TX_SYNC,
+
+ /// Transmit the AX.25 header that contains the source/destination call signs, APRS path, and flags.
+ TNC_TX_HEADER,
+
+ /// Transmit the message data.
+ TNC_TX_DATA,
+
+ /// Transmit the end flag sequence.
+ TNC_TX_END
+};
+
+/// Enumeration of the messages we can transmit.
+enum TNC_MESSAGE_TYPE
+{
+ /// Startup message that contains software version information.
+ TNC_BOOT_MESSAGE,
+
+ /// Plain text status message.
+ TNC_STATUS,
+
+ /// Message that contains GPS NMEA-0183 $GPGGA message.
+ TNC_GGA,
+
+ /// Message that contains GPS NMEA-0183 $GPRMC message.
+ TNC_RMC
+};
+
+/// AX.25 compliant packet header that contains destination, station call sign, and path.
+/// 0x76 for SSID-11, 0x78 for SSID-12
+uint8_t TNC_AX25_HEADER[30] = {
+ 'A' << 1, 'P' << 1, 'R' << 1, 'S' << 1, ' ' << 1, ' ' << 1, 0x60, \
+ 'K' << 1, 'D' << 1, '7' << 1, 'L' << 1, 'M' << 1, 'O' << 1, 0x76, \
+ 'G' << 1, 'A' << 1, 'T' << 1, 'E' << 1, ' ' << 1, ' ' << 1, 0x60, \
+ 'W' << 1, 'I' << 1, 'D' << 1, 'E' << 1, '3' << 1, ' ' << 1, 0x67, \
+ 0x03, 0xf0 };
+
+
+/// The next bit to transmit.
+uint8_t tncTxBit;
+
+/// Current mode of the 1200 bps state machine.
+TNC_TX_1200BPS_STATE tncMode;
+
+/// Counter for each bit (0 - 7) that we are going to transmit.
+uint8_t tncBitCount;
+
+/// A shift register that holds the data byte as we bit shift it for transmit.
+uint8_t tncShift;
+
+/// Index into the APRS header and data array for each byte as we transmit it.
+uint8_t tncIndex;
+
+/// The number of bytes in the message portion of the AX.25 message.
+uint8_t tncLength;
+
+/// A copy of the last 5 bits we've transmitted to determine if we need to bit stuff on the next bit.
+uint8_t tncBitStuff;
+
+/// Pointer to TNC buffer as we save each byte during message preparation.
+uint8_t *tncBufferPnt;
+
+/// The type of message to tranmit in the next packet.
+TNC_MESSAGE_TYPE tncPacketType;
+
+/// Buffer to hold the message portion of the AX.25 packet as we prepare it.
+uint8_t tncBuffer[TNC_BUFFER_SIZE];
+
+/// Flag that indicates we want to transmit every 5 seconds.
+bool_t tncHighRateFlag;
+
+/**
+ * Initialize the TNC internal variables.
+ */
+void tncInit()
+{
+ tncTxBit = 0;
+ tncMode = TNC_TX_READY;
+ tncPacketType = TNC_BOOT_MESSAGE;
+ tncHighRateFlag = false;
+}
+
+/**
+ * Determine if the hardware if ready to transmit a 1200 baud packet.
+ *
+ * @return true if ready; otherwise false
+ */
+bool_t tncIsFree()
+{
+ if (tncMode == TNC_TX_READY)
+ return true;
+
+ return false;
+}
+
+void tncHighRate(bool_t state)
+{
+ tncHighRateFlag = state;
+}
+
+/**
+ * Configure the TNC for the desired data mode.
+ *
+ * @param dataMode enumerated type that specifies 1200bps A-FSK or 9600bps FSK
+ */
+void tncSetMode(TNC_DATA_MODE dataMode)
+{
+ switch (dataMode)
+ {
+ case TNC_MODE_1200_AFSK:
+ ddsSetMode (DDS_MODE_AFSK);
+ break;
+
+ case TNC_MODE_9600_FSK:
+ ddsSetMode (DDS_MODE_FSK);
+
+ // FSK tones at 445.947 and 445.953 MHz
+ ddsSetFSKFreq (955382980, 955453621);
+ break;
+ } // END switch
+
+ tncDataMode = dataMode;
+}
+
+/**
+ * Determine if the seconds value timeSeconds is a valid time slot to transmit
+ * a message. Time seconds is in UTC.
+ *
+ * @param timeSeconds UTC time in seconds
+ *
+ * @return true if valid time slot; otherwise false
+ */
+bool_t tncIsTimeSlot (uint8_t timeSeconds)
+{
+ if (tncHighRateFlag)
+ {
+ if ((timeSeconds % 5) == 0)
+ return true;
+
+ return false;
+ } // END if
+
+ switch (timeSeconds)
+ {
+ case 0:
+ case 15:
+ case 30:
+ case 45:
+ return true;
+
+ default:
+ return false;
+ } // END switch
+}
+
+/**
+ * Method that is called every 833uS to transmit the 1200bps A-FSK data stream.
+ * The provides the pre and postamble as well as the bit stuffed data stream.
+ */
+void tnc1200TimerTick()
+{
+ // Set the A-FSK frequency.
+ if (tncTxBit == 0x00)
+ timeNCOFreq = 0x2000;
+ else
+ timeNCOFreq = 0x3aab;
+
+ switch (tncMode)
+ {
+ case TNC_TX_READY:
+ // Generate a test signal alteranting between high and low tones.
+ tncTxBit = (tncTxBit == 0 ? 1 : 0);
+ break;
+
+ case TNC_TX_SYNC:
+ // The variable tncShift contains the lastest data byte.
+ // NRZI enocde the data stream.
+ if ((tncShift & 0x01) == 0x00)
+ if (tncTxBit == 0)
+ tncTxBit = 1;
+ else
+ tncTxBit = 0;
+
+ // When the flag is done, determine if we need to send more or data.
+ if (++tncBitCount == 8)
+ {
+ tncBitCount = 0;
+ tncShift = 0x7e;
+
+ // Once we transmit x mS of flags, send the data.
+ // txDelay bytes * 8 bits/byte * 833uS/bit = x mS
+ if (++tncIndex == TNC_TX_DELAY)
+ {
+ tncIndex = 0;
+ tncShift = TNC_AX25_HEADER[0];
+ tncBitStuff = 0;
+ tncMode = TNC_TX_HEADER;
+ } // END if
+ } else
+ tncShift = tncShift >> 1;
+ break;
+
+ case TNC_TX_HEADER:
+ // Determine if we have sent 5 ones in a row, if we have send a zero.
+ if (tncBitStuff == 0x1f)
+ {
+ if (tncTxBit == 0)
+ tncTxBit = 1;
+ else
+ tncTxBit = 0;
+
+ tncBitStuff = 0x00;
+ return;
+ } // END if
+
+ // The variable tncShift contains the lastest data byte.
+ // NRZI enocde the data stream.
+ if ((tncShift & 0x01) == 0x00)
+ if (tncTxBit == 0)
+ tncTxBit = 1;
+ else
+ tncTxBit = 0;
+
+ // Save the data stream so we can determine if bit stuffing is
+ // required on the next bit time.
+ tncBitStuff = ((tncBitStuff << 1) | (tncShift & 0x01)) & 0x1f;
+
+ // If all the bits were shifted, get the next byte.
+ if (++tncBitCount == 8)
+ {
+ tncBitCount = 0;
+
+ // After the header is sent, then send the data.
+ if (++tncIndex == sizeof(TNC_AX25_HEADER))
+ {
+ tncIndex = 0;
+ tncShift = tncBuffer[0];
+ tncMode = TNC_TX_DATA;
+ } else
+ tncShift = TNC_AX25_HEADER[tncIndex];
+
+ } else
+ tncShift = tncShift >> 1;
+
+ break;
+
+ case TNC_TX_DATA:
+ // Determine if we have sent 5 ones in a row, if we have send a zero.
+ if (tncBitStuff == 0x1f)
+ {
+ if (tncTxBit == 0)
+ tncTxBit = 1;
+ else
+ tncTxBit = 0;
+
+ tncBitStuff = 0x00;
+ return;
+ } // END if
+
+ // The variable tncShift contains the lastest data byte.
+ // NRZI enocde the data stream.
+ if ((tncShift & 0x01) == 0x00)
+ if (tncTxBit == 0)
+ tncTxBit = 1;
+ else
+ tncTxBit = 0;
+
+ // Save the data stream so we can determine if bit stuffing is
+ // required on the next bit time.
+ tncBitStuff = ((tncBitStuff << 1) | (tncShift & 0x01)) & 0x1f;
+
+ // If all the bits were shifted, get the next byte.
+ if (++tncBitCount == 8)
+ {
+ tncBitCount = 0;
+
+ // If everything was sent, transmit closing flags.
+ if (++tncIndex == tncLength)
+ {
+ tncIndex = 0;
+ tncShift = 0x7e;
+ tncMode = TNC_TX_END;
+ } else
+ tncShift = tncBuffer[tncIndex];
+
+ } else
+ tncShift = tncShift >> 1;
+
+ break;
+
+ case TNC_TX_END:
+ // The variable tncShift contains the lastest data byte.
+ // NRZI enocde the data stream.
+ if ((tncShift & 0x01) == 0x00)
+ if (tncTxBit == 0)
+ tncTxBit = 1;
+ else
+ tncTxBit = 0;
+
+ // If all the bits were shifted, get the next one.
+ if (++tncBitCount == 8)
+ {
+ tncBitCount = 0;
+ tncShift = 0x7e;
+
+ // Transmit two closing flags.
+ if (++tncIndex == 2)
+ {
+ tncMode = TNC_TX_READY;
+
+ // Tell the TNC time interrupt to stop generating the frequency words.
+ tncDataMode = TNC_MODE_STANDBY;
+
+ // Key off the DDS.
+ output_low (IO_OSK);
+ output_low (IO_PTT);
+ ddsSetMode (DDS_MODE_POWERDOWN);
+
+ return;
+ } // END if
+ } else
+ tncShift = tncShift >> 1;
+
+ break;
+ } // END switch
+}
+
+/**
+ * Method that is called every 104uS to transmit the 9600bps FSK data stream.
+ */
+void tnc9600TimerTick()
+{
+
+}
+
+/**
+ * Write character to the TNC buffer. Maintain the pointer
+ * and length to the buffer. The pointer tncBufferPnt and tncLength
+ * must be set before calling this function for the first time.
+ *
+ * @param character to save to telemetry buffer
+ */
+void tncTxByte (uint8_t character)
+{
+ *tncBufferPnt++ = character;
+ ++tncLength;
+}
+
+/**
+ * Generate the GPS NMEA standard UTC time stamp. Data is written through the tncTxByte
+ * callback function.
+ */
+void tncNMEATime()
+{
+ // UTC of position fix.
+ printf (tncTxByte, "%02d%02d%02d,", gpsPosition.hours, gpsPosition.minutes, gpsPosition.seconds);
+}
+
+/**
+ * Generate the GPS NMEA standard latitude/longitude fix. Data is written through the tncTxByte
+ * callback function.
+ */
+void tncNMEAFix()
+{
+ uint8_t dirChar;
+ uint32_t coord, coordMin;
+
+ // Latitude value.
+ coord = gpsPosition.latitude;
+
+ if (gpsPosition.latitude < 0)
+ {
+ coord = gpsPosition.latitude * -1;
+ dirChar = 'S';
+ } else {
+ coord = gpsPosition.latitude;
+ dirChar = 'N';
+ }
+
+ coordMin = (coord % 3600000) / 6;
+ printf (tncTxByte, "%02ld%02ld.%04ld,%c,", (uint32_t) (coord / 3600000), (uint32_t) (coordMin / 10000), (uint32_t) (coordMin % 10000), dirChar);
+
+
+ // Longitude value.
+ if (gpsPosition.longitude < 0)
+ {
+ coord = gpsPosition.longitude * - 1;
+ dirChar = 'W';
+ } else {
+ coord = gpsPosition.longitude;
+ dirChar = 'E';
+ }
+
+ coordMin = (coord % 3600000) / 6;
+ printf (tncTxByte, "%03ld%02ld.%04ld,%c,", (uint32_t) (coord / 3600000), (uint32_t) (coordMin / 10000), (uint32_t) (coordMin % 10000), dirChar);
+
+}
+
+/**
+ * Generate the GPS NMEA-0183 $GPGGA packet. Data is written through the tncTxByte
+ * callback function.
+ */
+void tncGPGGAPacket()
+{
+ // Generate the GPGGA message.
+ printf (tncTxByte, "$GPGGA,");
+
+ // Standard NMEA time.
+ tncNMEATime();
+
+ // Standard NMEA-0183 latitude/longitude.
+ tncNMEAFix();
+
+ // GPS status where 0: not available, 1: available
+ if (gpsGetFixType() != GPS_NO_FIX)
+ printf (tncTxByte, "1,");
+ else
+ printf (tncTxByte, "0,");
+
+ // Number of visible birds.
+ printf (tncTxByte, "%02d,", gpsPosition.trackedSats);
+
+ // DOP
+ printf (tncTxByte, "%ld.%01ld,", gpsPosition.dop / 10, gpsPosition.dop % 10);
+
+ // Altitude in meters.
+ printf (tncTxByte, "%ld.%02ld,M,,M,,", (int32_t) (gpsPosition.altitudeCM / 100l), (int32_t) (gpsPosition.altitudeCM % 100));
+
+ // Checksum, we add 1 to skip over the $ character.
+ printf (tncTxByte, "*%02X", gpsNMEAChecksum(tncBuffer + 1, tncLength - 1));
+}
+
+/**
+ * Generate the GPS NMEA-0183 $GPRMC packet. Data is written through the tncTxByte
+ * callback function.
+ */
+void tncGPRMCPacket()
+{
+ uint32_t temp;
+
+ // Generate the GPRMC message.
+ printf (tncTxByte, "$GPRMC,");
+
+ // Standard NMEA time.
+ tncNMEATime();
+
+ // GPS status.
+ if (gpsGetFixType() != GPS_NO_FIX)
+ printf (tncTxByte, "A,");
+ else
+ printf (tncTxByte, "V,");
+
+ // Standard NMEA-0183 latitude/longitude.
+ tncNMEAFix();
+
+ // Speed knots and heading.
+ temp = (int32_t) gpsPosition.hSpeed * 75000 / 385826;
+ printf (tncTxByte, "%ld.%ld,%ld.%ld,", (int16_t) (temp / 10), (int16_t) (temp % 10), gpsPosition.heading / 10, gpsPosition.heading % 10);
+
+ // Date
+ printf (tncTxByte, "%02d%02d%02ld,,", gpsPosition.day, gpsPosition.month, gpsPosition.year % 100);
+
+ // Checksum, skip over the $ character.
+ printf (tncTxByte, "*%02X", gpsNMEAChecksum(tncBuffer + 1, tncLength - 1));
+}
+
+/**
+ * Generate the plain text status packet. Data is written through the tncTxByte
+ * callback function.
+ */
+void tncStatusPacket(int16_t temperature)
+{
+ uint16_t voltage;
+
+ // Plain text telemetry.
+ printf (tncTxByte, ">ANSR ");
+
+ // Display the flight time.
+ printf (tncTxByte, "%02U:%02U:%02U ", timeHours, timeMinutes, timeSeconds);
+
+ // Altitude in feet.
+ printf (tncTxByte, "%ld' ", gpsPosition.altitudeFeet);
+
+ // Peak altitude in feet.
+ printf (tncTxByte, "%ld'pk ", gpsGetPeakAltitude());
+
+ // GPS hdop or pdop
+ printf (tncTxByte, "%lu.%lu", gpsPosition.dop / 10, gpsPosition.dop % 10);
+
+ // The text 'pdop' for a 3D fix, 'hdop' for a 2D fix, and 'dop' for no fix.
+ switch (gpsGetFixType())
+ {
+ case GPS_NO_FIX:
+ printf (tncTxByte, "dop ");
+ break;
+
+ case GPS_2D_FIX:
+ printf (tncTxByte, "hdop ");
+ break;
+
+
+ case GPS_3D_FIX:
+ printf (tncTxByte, "pdop ");
+ break;
+ } // END switch
+
+ // Number of satellites in the solution.
+ printf (tncTxByte, "%utrk ", gpsPosition.trackedSats);
+
+ // Display main bus voltage.
+ voltage = adcGetMainBusVolt();
+ printf (tncTxByte, "%lu.%02luvdc ", voltage / 100, voltage % 100);
+
+ // Display internal temperature.
+ printf (tncTxByte, "%ld.%01ldF ", temperature / 10, abs(temperature % 10));
+
+ // Print web address link.
+ printf (tncTxByte, "www.kd7lmo.net");
+}
+
+/**
+ * Prepare an AX.25 data packet. Each time this method is called, it automatically
+ * rotates through 1 of 3 messages.
+ *
+ * @param dataMode enumerated type that specifies 1200bps A-FSK or 9600bps FSK
+ */
+void tncTxPacket(TNC_DATA_MODE dataMode)
+{
+ int16_t temperature;
+ uint16_t crc;
+
+ // Only transmit if there is not another message in progress.
+ if (tncMode != TNC_TX_READY)
+ return;
+
+ // Log the battery and reference voltage before we start the RF chain.
+ sysLogVoltage();
+
+ // We need to read the temperature sensor before we setup the DDS since they share a common clock pin.
+ temperature = lm92GetTemp();
+
+ // Log the system temperature every time we transmit a packet.
+ logType (LOG_TEMPERATURE);
+ logInt16 (temperature);
+
+ // Configure the DDS for the desired operational.
+ tncSetMode (dataMode);
+
+ // Set a pointer to our TNC output buffer.
+ tncBufferPnt = tncBuffer;
+
+ // Set the message length counter.
+ tncLength = 0;
+
+ // Determine the contents of the packet.
+ switch (tncPacketType)
+ {
+ case TNC_BOOT_MESSAGE:
+ printf (tncTxByte, ">ANSR Pico Beacon - V3.05");
+
+ // Select the next packet we will generate.
+ tncPacketType = TNC_STATUS;
+ break;
+
+ case TNC_STATUS:
+ tncStatusPacket(temperature);
+
+ // Select the next packet we will generate.
+ tncPacketType = TNC_GGA;
+ break;
+
+ case TNC_GGA:
+ tncGPGGAPacket();
+
+ // Select the next packet we will generate.
+ tncPacketType = TNC_RMC;
+ break;
+
+ case TNC_RMC:
+ tncGPRMCPacket();
+
+ // Select the next packet we will generate.
+ tncPacketType = TNC_STATUS;
+ break;
+ }
+
+ // Add the end of message character.
+ printf (tncTxByte, "\015");
+
+ // Calculate the CRC for the header and message.
+ crc = sysCRC16(TNC_AX25_HEADER, sizeof(TNC_AX25_HEADER), 0xffff);
+ crc = sysCRC16(tncBuffer, tncLength, crc ^ 0xffff);
+
+ // Save the CRC in the message.
+ *tncBufferPnt++ = crc & 0xff;
+ *tncBufferPnt = (crc >> 8) & 0xff;
+
+ // Update the length to include the CRC bytes.
+ tncLength += 2;
+
+ // Prepare the variables that are used in the real-time clock interrupt.
+ tncBitCount = 0;
+ tncShift = 0x7e;
+ tncTxBit = 0;
+ tncIndex = 0;
+ tncMode = TNC_TX_SYNC;
+
+ // Turn on the PA chain.
+ output_high (IO_PTT);
+
+ // Wait for the PA chain to power up.
+ delay_ms (10);
+
+ // Key the DDS.
+ output_high (IO_OSK);
+
+ // Log the battery and reference voltage just after we key the transmitter.
+ sysLogVoltage();
+}
+
+/** @} */
+
+uint32_t counter;
+
+uint8_t bitIndex;
+uint8_t streamIndex;
+uint8_t value;
+
+uint8_t bitStream[] = { 0x10, 0x20, 0x30 };
+
+void init()
+{
+ counter = 0;
+ bitIndex = 0;
+ streamIndex = 0;
+ value = bitStream[0];
+}
+
+void test()
+{
+ counter += 0x10622d;
+
+ CCP_1 = (uint16_t) ((counter >> 16) & 0xffff);
+
+ if ((value & 0x80) == 0x80)
+ setup_ccp1 (CCP_COMPARE_SET_ON_MATCH);
+ else
+ setup_ccp1 (CCP_COMPARE_CLR_ON_MATCH);
+
+ if (++bitIndex == 8)
+ {
+ bitIndex = 0;
+
+ if (++streamIndex == sizeof(bitStream))
+ {
+ streamIndex = 0;
+ }
+
+ value = bitStream[streamIndex];
+ } else
+ value = value << 1;
+}
+
+// This is where we go after reset.
+void main()
+{
+ uint8_t i, utcSeconds, lockLostCounter;
+
+test();
+
+ // Configure the basic systems.
+ sysInit();
+
+ // Wait for the power converter chains to stabilize.
+ delay_ms (100);
+
+ // Setup the subsystems.
+ adcInit();
+ flashInit();
+ gpsInit();
+ logInit();
+ timeInit();
+ serialInit();
+ tncInit();
+
+ // Program the DDS.
+ ddsInit();
+
+ // Turn off the LED after everything is configured.
+ output_low (IO_LED);
+
+ // Check for the diagnostics plug, otherwise we'll continue to boot.
+ diagPort();
+
+ // Setup our interrupts.
+ enable_interrupts(GLOBAL);
+ enable_interrupts(INT_CCP1);
+
+ // Turn on the GPS engine.
+ gpsPowerOn();
+
+ // Allow the GPS engine to boot.
+ delay_ms (250);
+
+ // Initialize the GPS engine.
+ while (!gpsSetup());
+
+ // Charge the ADC filters.
+ for (i = 0; i < 32; ++i)
+ adcUpdate();
+
+ // Log startup event.
+ logType (LOG_BOOTED);
+ logUint8 (gpsPosition.month);
+ logUint8 (gpsPosition.day);
+ logUint8 (gpsPosition.year & 0xff);
+
+ logUint8 (gpsPosition.hours);
+ logUint8 (gpsPosition.minutes);
+ logUint8 (gpsPosition.seconds);
+
+ // Transmit software version packet on start up.
+ tncTxPacket(TNC_MODE_1200_AFSK);
+
+ // Counters to send packets if the GPS time stamp is not available.
+ lockLostCounter = 5;
+ utcSeconds = 55;
+
+ // This is the main loop that process GPS data and waits for the once per second timer tick.
+ for (;;)
+ {
+ // Read the GPS engine serial port FIFO and process the GPS data.
+ gpsUpdate();
+
+ if (gpsIsReady())
+ {
+ // Start the flight timer when we get a valid 3D fix.
+ if (gpsGetFixType() == GPS_3D_FIX)
+ timeSetRunFlag();
+
+ // Generate our packets based on the GPS time.
+ if (tncIsTimeSlot(gpsPosition.seconds))
+ tncTxPacket(TNC_MODE_1200_AFSK);
+
+ // Sync the internal clock to GPS UTC time.
+ utcSeconds = gpsPosition.seconds;
+
+ // This counter is reset every time we receive the GPS message.
+ lockLostCounter = 0;
+
+ // Log the data to flash.
+ sysLogGPSData();
+ } // END if gpsIsReady
+
+ // Processing that occurs once a second.
+ if (timeIsUpdate())
+ {
+ // We maintain the UTC time in seconds if we shut off the GPS engine or it fails.
+ if (++utcSeconds == 60)
+ utcSeconds = 0;
+
+ // If we loose information for more than 5 seconds,
+ // we will determine when to send a packet based on internal time.
+ if (lockLostCounter == 5)
+ {
+ if (tncIsTimeSlot(utcSeconds))
+ tncTxPacket(TNC_MODE_1200_AFSK);
+ } else
+ ++lockLostCounter;
+
+ // Update the ADC filters.
+ adcUpdate();
+
+ if (timeHours == 5 && timeMinutes == 0 && timeSeconds == 0)
+ gpsPowerOff();
+
+ } // END if timeIsUpdate
+
+ } // END for
+}
+
+
+
projects / fw / altos / commitdiff