psk31beacon.c

Go to the documentation of this file.

// Hardware specific configuration.
#include <18f252.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 <stdlib.h>
#include <string.h>

// 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 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.

typedef boolean bool_t;

typedef signed int8 int8_t;

typedef unsigned int8 uint8_t;

typedef signed int16 int16_t;

typedef unsigned int16 uint16_t;

typedef signed int32 int32_t;

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 names to the hardware pins.

#define IO_FLASH_CS PIN_A0

#define IO_CUT_DOWN PIN_A1

#define IO_BALLAST_PUMP PIN_A2

#define IO_PS0 PIN_A3
#define IO_UPDATE PIN_A5

#define IO_CS PIN_B0
#define IO_PA PIN_B2
#define IO_GPS_PWR PIN_B3
#define IO_LED PIN_B4

#define IO_PS1 PIN_C0
#define IO_OSK PIN_C2

// Serial port enable RCSTA
#bit SPEN = 0xfab.7

bool_t cutDownIsActivate();

typedef enum 
{
    DDS_MODE_POWERDOWN,

    DDS_MODE_APRS,

    DDS_MODE_PSK31,

    DDS_MODE_HF_APRS
} DDS_MODE;

void ddsInit();
void ddsPhase (bool_t phase);
void ddsSetOutputScale (uint16_t scale);
void ddsSetAmplitude (uint8_t amplitude);
inline void ddsPTT (bool_t state);
void ddsSetFreq (uint32_t freq);
void ddsSetFTW (uint32_t ftw);
void ddsSetMode (DDS_MODE mode);

void flashErase();
uint8_t flashGetByte ();
uint8_t flashReadElectronicSignature();
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);
uint8_t flashReadES();

typedef enum  
{
    GPS_NO_FIX,

    GPS_2D_FIX,

    GPS_3D_FIX
} GPS_FIX_TYPE;

typedef struct 
{
    bool_t updateFlag;

    uint8_t month;

    uint8_t day;

    uint8_t hours;

    uint8_t minutes;

    uint8_t seconds;

    uint16_t year;

    int32_t latitude;

    int32_t longitude;

    int32_t altitudeCM;

    int32_t altitudeFeet;

    uint16_t vSpeed;

    uint16_t hSpeed;

    uint16_t heading;

    uint16_t dop;

    uint16_t status;

    uint8_t trackedSats;

    uint8_t visibleSats;
} GPSPOSITION_STRUCT;

GPSPOSITION_STRUCT gpsPosition;

void gpsInit();
bool_t gpsIsReady();
GPS_FIX_TYPE gpsGetFixType();
int32_t gpsGetPeakAltitude();
void gpsPowerOn();
void gpsPowerOff();
bool_t gpsSetup();
void gpsUpdate();

int16_t lm92GetTemp();

typedef enum  
{
    LOG_BOOTED = 0xb4,

    LOG_COORD = 0xa5,

    LOG_TEMPERATURE_1 = 0x96,

    LOG_VOLTAGE = 0x87,

    LOG_TEMPERATURE_2 = 0x78,

    LOG_PUMP = 0x69
} LOG_TYPE;

void logInit();
uint32_t logGetAddress();
void logSetDisableFlag (bool_t disableFlag);
void logType (LOG_TYPE type);
void logUint8 (uint8_t value);
void logInt16 (int16_t value);
void logInt32 (int32_t value);

bool_t psk31CreateDataPacket();
void psk31Init();
void psk31TimeUpdate();
void psk31TxPacket(uint8_t minutes);
void psk31TxByte (uint8_t value);
void psk31TxNull ();
void psk31TxString (char *string, uint8_t length);

bool_t serialHasData();
void serialInit();
uint8_t serialRead();
void serialUpdate();

uint16_t sysCRC16(uint8_t *buffer, uint8_t length, uint16_t crc);
inline void sysPAOutput (bool_t state);

// Constants for time duty cycle in method timeSetDutyCycle
#define TIME_DUTYCYCLE_0 0
#define TIME_DUTYCYCLE_20 2
#define TIME_DUTYCYCLE_70 7

// Constants for the time base mode in method timeSetMode
typedef enum 
{
    TIME_MODE_APRS,
    TIME_MODE_PSK31,
    TIME_MODE_HF_APRS
} TIME_MODE;

uint8_t timeGetTicks();
void timeInit();
uint8_t timeGetHours();
uint8_t timeGetMinutes();
void timeSetDutyCycle (uint8_t dutyCycle);
void timeSetMode (TIME_MODE mode);
void timeUpdate();

// Modes for the packet state machine.
typedef enum 
{
    TNC_BOOT_MESSAGE,
    TNC_STATUS,
    TNC_GGA,
    TNC_RMC
} TNC_PACKET_TYPE;

void tncInit();
bool_t tncIsFree();
void tncTimeUpdate();
void tncTxByte (uint8_t value);
void tncTxPacket(TNC_PACKET_TYPE tncPacketType);


#define BALLAST_3D_FIX_COUNT 10

#define BALLAST_HOLD_ALTITUDE 30500l

enum BALLAST_MODE
{
    WAIT_ACTIVATION,

    CONTROL_ALTITUDE,

    PUMP_RUN,

    PUMP_RUN_DELAY
};

uint16_t ballastPumpCount;

uint8_t ballast3DFixCount;

uint8_t ballastTimeCount;

BALLAST_MODE ballastMode;

bool_t ballastState;

uint16_t ballastGetPumpCount()
{
    return ballastPumpCount;
}

void ballastInit()
{
    ballastPumpCount = 0;
    ballastTimeCount = 0;
    ballast3DFixCount = 0;
    ballastState = true;
    ballastMode = WAIT_ACTIVATION;
}

void ballastSetState (bool_t state)
{
    ballastState = state;
}

void ballastLogEvent (bool_t state)
{
    logType (LOG_PUMP);
    logUint8 ((state ? 0x01 : 0x00));
    logUint8 (gpsPosition.hours);
    logUint8 (gpsPosition.minutes);
    logUint8 (gpsPosition.seconds);
    logInt32 (gpsPosition.altitudeCM);
}

void ballastCheck()
{
    if (!ballastState)
    {
        ballast3DFixCount = 0;
        return;
    } // END if

    if (gpsGetFixType() == GPS_3D_FIX)
    {
        if (ballast3DFixCount < BALLAST_3D_FIX_COUNT)
            ++ballast3DFixCount;
    } else
        ballast3DFixCount = 0;

    // State machine that controls the ballast pump operation.
    switch (ballastMode)
    {
        case WAIT_ACTIVATION:
            if (ballast3DFixCount == BALLAST_3D_FIX_COUNT)
                if (gpsPosition.altitudeFeet > BALLAST_HOLD_ALTITUDE)
                {
                    ++ballastPumpCount;
                    ballastMode = CONTROL_ALTITUDE;
                } // END if

            // If we aren't at altitude after 90 minutes, enable the ballast pump.
            if (timeGetHours() == 1 && timeGetMinutes() == 30)
            {
                ++ballastPumpCount;
                ballastMode = CONTROL_ALTITUDE;
            }

            break;

        case CONTROL_ALTITUDE:
            if (ballast3DFixCount == BALLAST_3D_FIX_COUNT)
                if (gpsPosition.altitudeFeet < BALLAST_HOLD_ALTITUDE)
                {
                    output_high (IO_BALLAST_PUMP);
                    
                    ballastLogEvent (true);

                    ballastTimeCount = 0;

                    ballastMode = PUMP_RUN;
                } // END if
            break;

        case PUMP_RUN:
            if (++ballastTimeCount == 5)
            {
                output_low (IO_BALLAST_PUMP);

                ballastLogEvent (false);

                ++ballastPumpCount;

                ballastTimeCount = 0;
                ballastMode = PUMP_RUN_DELAY;
            } // END if

            break;

        case PUMP_RUN_DELAY:
            if (++ballastTimeCount == 60)
                ballastMode = CONTROL_ALTITUDE;
            break;
    } // END switch
}


#define CUTDOWN_3D_FIX_COUNT 10

uint8_t cutDownTimer;

uint8_t cutDown3DFixCount;

bool_t cutDownFlag;

bool_t cutDownIsActivate()
{
    return cutDownFlag;
}

void cutDownInit()
{
    cutDownFlag = false;
    cutDownTimer = 0;   
    cutDown3DFixCount = 0;
}

void cutDownActivate()
{
    output_high (IO_CUT_DOWN);
    cutDownTimer = 7;
    cutDownFlag = true;
}

void cutDownCheck()
{
    // Turn off the timer after a period of time.
    if (cutDownTimer != 0)
        if (--cutDownTimer == 0)
            output_low (IO_CUT_DOWN);

    // Once the cut down has fired, we are done with it.
    if (cutDownFlag)
        return;

    // Terminate the flight after 49 hours.  (One hour on the ground, 48 in flight).
    if (timeGetHours() == 49)
        cutDownActivate();

    // We need to see a number of consecutive 3D GPS fixes to use the altitude.
    if (gpsGetFixType() == GPS_3D_FIX)
    {
        if (cutDown3DFixCount < CUTDOWN_3D_FIX_COUNT)
            ++cutDown3DFixCount;
    } else
        cutDown3DFixCount = 0;

    // If we are EAST of 83 degrees WEST latitude, terminate the flight.
    if (cutDown3DFixCount == CUTDOWN_3D_FIX_COUNT)
        if (gpsPosition.longitude > -298800000)
            cutDownActivate();
}


#define DDS_AD9954_CFR1 0x00

#define DDS_AD9954_CFR2 0x01

#define DDS_AD9954_ASF 0x02

#define DDS_AD9954_ARR 0x03

#define DDS_AD9954_FTW0 0x04

#define DDS_AD9954_FTW1 0x06

#define DDS_AD9954_NLSCW 0x07

#define DDS_AD9954_PLSCW 0x08

#define DDS_AD9954_RWCW0 0x07

#define DDS_AD9954_RWCW1 0x08

#define DDS_RAM 0x0b

#define DDS_FREQ_TO_FTW_DIGITS 9

const uint32_t DDS_MULT[DDS_FREQ_TO_FTW_DIGITS] = { 11, 1, 8, 4, 8, 1, 0, 6, 6 };

const uint32_t DDS_DIVISOR[DDS_FREQ_TO_FTW_DIGITS - 1] = { 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000 };

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 - 5.0KHz FM frequency deviation at 50.62Mhz
const uint32_t freqTable[256] = 
{
566175115
,566176488
,566177860
,566179229
,566180597
,566181961
,566183321
,566184676
,566186026
,566187368
,566188704
,566190031
,566191349
,566192658
,566193956
,566195242
,566196517
,566197778
,566199026
,566200260
,566201478
,566202680
,566203866
,566205035
,566206185
,566207317
,566208429
,566209522
,566210593
,566211644
,566212672
,566213677
,566214660
,566215618
,566216552
,566217462
,566218345
,566219203
,566220034
,566220838
,566221615
,566222363
,566223083
,566223774
,566224436
,566225068
,566225670
,566226242
,566226783
,566227292
,566227770
,566228217
,566228631
,566229014
,566229364
,566229681
,566229965
,566230216
,566230434
,566230619
,566230770
,566230888
,566230972
,566231023
,566231040
,566231023
,566230972
,566230888
,566230770
,566230619
,566230434
,566230216
,566229965
,566229681
,566229364
,566229014
,566228631
,566228217
,566227770
,566227292
,566226783
,566226242
,566225670
,566225068
,566224436
,566223774
,566223083
,566222363
,566221615
,566220838
,566220034
,566219203
,566218345
,566217462
,566216552
,566215618
,566214660
,566213677
,566212672
,566211644
,566210593
,566209522
,566208429
,566207317
,566206185
,566205035
,566203866
,566202680
,566201478
,566200260
,566199026
,566197778
,566196517
,566195242
,566193956
,566192658
,566191349
,566190031
,566188704
,566187368
,566186026
,566184676
,566183321
,566181961
,566180597
,566179229
,566177860
,566176488
,566175115
,566173743
,566172371
,566171001
,566169634
,566168270
,566166910
,566165555
,566164205
,566162862
,566161527
,566160200
,566158882
,566157573
,566156275
,566154989
,566153714
,566152453
,566151205
,566149971
,566148753
,566147551
,566146365
,566145196
,566144046
,566142914
,566141802
,566140709
,566139638
,566138587
,566137559
,566136554
,566135571
,566134613
,566133678
,566132769
,566131886
,566131028
,566130197
,566129393
,566128616
,566127868
,566127148
,566126457
,566125795
,566125163
,566124561
,566123989
,566123448
,566122939
,566122460
,566122014
,566121599
,566121217
,566120867
,566120550
,566120266
,566120015
,566119797
,566119612
,566119461
,566119343
,566119259
,566119208
,566119191
,566119208
,566119259
,566119343
,566119461
,566119612
,566119797
,566120015
,566120266
,566120550
,566120867
,566121217
,566121599
,566122014
,566122460
,566122939
,566123448
,566123989
,566124561
,566125163
,566125795
,566126457
,566127148
,566127868
,566128616
,566129393
,566130197
,566131028
,566131886
,566132769
,566133678
,566134613
,566135571
,566136554
,566137559
,566138587
,566139638
,566140709
,566141802
,566142914
,566144046
,566145196
,566146365
,566147551
,566148753
,566149971
,566151205
,566152453
,566153714
,566154989
,566156275
,566157573
,566158882
,566160200
,566161527
,566162862
,566164205
,566165555
,566166910
,566168270
,566169634
,566171001
,566172371
,566173743
};


void ddsInit()
{
    // Set default I/O for the DDS.
    output_high (IO_CS);
    output_low (IO_PS1);
    output_low (IO_PS0);
    output_low (IO_OSK);
    output_low (IO_UPDATE);

    // 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 );    

    // Turn off the output.
    output_low (IO_OSK);

    ddsSetMode (DDS_MODE_POWERDOWN);

    // ASF (Amplitude Scale Factor) to full scale (0x3fff).
    ddsSetOutputScale (0x3fff);

    // ARR (Amplitude Ramp Rate) to 15.5mS for OSK
    output_low (IO_CS);
    spi_write (DDS_AD9954_ARR);

    spi_write (181);
    output_high (IO_CS);

    // CFR2 (Control Function Register No. 2)
    output_low (IO_CS);
    spi_write (0x01);

    spi_write (0x00);     // Unused register bits
    spi_write (0x00);
    spi_write (0xa4);     // 20x reference clock multipler, high VCO range, nominal charge pump current
    output_high (IO_CS);

    // Strobe the part so we apply the updates.
    output_high (IO_UPDATE);
    output_low (IO_UPDATE);
}

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);
}

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); 
}

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);
}

void ddsPhase (bool_t phase)
{
    // Set the POW0 (Phase Offset Word 0) to 0 or 180 degrees.
    output_low (IO_CS);
    spi_write (0x05);   

    if (phase) 
    {
        spi_write (0x20);
        spi_write (0x00);
    } else {
        spi_write (0x00);
        spi_write (0x00);
    }

    output_high (IO_CS);

    // Strobe the DDS to write the phase change.
    output_high (IO_UPDATE);
    output_low (IO_UPDATE);
}

inline void ddsPTT (bool_t state)
{
    if (state)
        output_high (IO_OSK);
    else
        output_low (IO_OSK);
}

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);     
}

void ddsSetMode (DDS_MODE 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_APRS:
            // CFR0 (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 (0x02);  // SDIO input only
            spi_write (0x40);  // Power down comparator circuit
            output_high (IO_CS);
            break;
            
        case DDS_MODE_PSK31:
            // CFR0 (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 (0x02);  // SDIO input only
            spi_write (0x40);  // Power down comparator circuit
            output_high (IO_CS);
            break;

        case DDS_MODE_HF_APRS:
            // CFR0 (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 (0x20);  // Enable linear sweep
            spi_write (0x02);  // SDIO input only
            spi_write (0x40);  // Power down comparator circuit
            output_high (IO_CS);

            // NOTE: The sweep rate requires 1/4 of a bit time to transition.
            // 200Hz delta = 2236 counts  (200Hz / 384MHz) * 2 ^ 32
            // SYNC_CLK = 96MHz  1/96MHz * 2236 * 36 = 838uS

            // NLSCW (Negative Linear Sweep Control Word)
            output_low (IO_CS);
            spi_write (DDS_AD9954_NLSCW);

            spi_write (36);    // Falling sweep ramp rate word
            spi_write (0x00);  // Delta frequency tuning word
            spi_write (0x00);
            spi_write (0x00);
            spi_write (0x01); 
            output_high (IO_CS);

            // PLSCW (Positive Linear Sweep Control Word)
            output_low (IO_CS);
            spi_write (DDS_AD9954_PLSCW);

            spi_write (36);    // Falling sweep ramp rate word
            spi_write (0x00);  // Delta frequency tuning word
            spi_write (0x00);
            spi_write (0x00);
            spi_write (0x01); 
            output_high (IO_CS);
            break;
            
    } // END switch
    
    // Strobe the DDS to change the mode.
    output_high (IO_UPDATE);
    output_low (IO_UPDATE);      
}


#define DIAG_BYTES_PER_LINE 32

void diagEraseFlash()
{
    // Confirm we want to erase the flash with the key sequence 'yes' <RETURN>.
    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, "\n\rErasing flash...");

    flashErase();

    fprintf (PC_HOST, "done.\n\r");
}

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, "%03lx ", 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

        // <CR><LF> 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 diagMenu()
{
    // User interface.
    fprintf (PC_HOST, "Options: (e)rase Flash, (r)ead Flash\n\r");
    fprintf (PC_HOST, "         Toggle (L)ED, Toggle RF (P)A, Toggle Ban(d)\n\r");
    fprintf (PC_HOST, "         Toggle (n)ichrome wire, Toggle ballast p(u)mp\n\r");
    fprintf (PC_HOST, "         (t)emperature sensor value\n\r");
    fprintf (PC_HOST, "         (f)requencey down, (F)requency up - 10Hz step\n\r");
    fprintf (PC_HOST, "         (c)hannel down, (C)hannel up - 1KHz step\n\r");
    fprintf (PC_HOST, "         (a)mplitude down, (A)mplitude up - 0.5 dB steps\n\r");
    fprintf (PC_HOST, "         Re(b)oot processor\n\r");
    fprintf (PC_HOST, "         e(x)it engineering mode\n\r");
}

void diagPort()
{
    bool_t diagDoneFlag, ledFlag, paFlag, showSettingsFlag, phaseFlag, cutdownFlag, pumpFlag;
    bool_t lowBandFlag;
    uint8_t command, amplitude;
    int16_t temperature, tcxo;
    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;

    cutdownFlag = false;

    lowBandFlag = true;

    pumpFlag = false;

    // Flag that indicate we should show the current carrier frequency.
    showSettingsFlag = false;

    // Set the initial carrier frequency and amplitude.
    freqHz = 14070450;
    amplitude = 100;
    phaseFlag = false;

    // 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 's':
                fprintf (PC_HOST, "Flash Electronic Signature 0x%02x\n\r", flashReadElectronicSignature());
                break;

            // Toggle the system LED on/off.
            case 'l':
                ledFlag = (ledFlag ? false : true);
                output_bit (IO_LED, ledFlag);
                break;

            // Display the help menu.
            case 'h':
            case 'H':
            case '?':
                diagMenu();
                break;

            case 'r':
                diagReadFlash();
                break;

            // Change the carrier frequency in 100Hz steps.
            case 'f':
                freqHz -= 100;
                ddsSetFreq (freqHz);

                // Display the new frequency.
                showSettingsFlag = true;
                break;

            case 'F':
                freqHz += 100;
                ddsSetFreq (freqHz);

                // Display the new frequency.
                showSettingsFlag = true;
                break;

            // Change the carrier frequency in 10KHz steps.
            case 'c':
                freqHz -= 10000;
                ddsSetFreq (freqHz);

                // Display the new frequency.
                showSettingsFlag = true;
                break;

            case 'C':
                freqHz += 10000;
                ddsSetFreq (freqHz);

                // Display the new frequency.
                showSettingsFlag = true;
                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 'd':
                if (lowBandFlag)
                {
                    lowBandFlag = false;
                    freqHz = 50620000;
                } else {
                    lowBandFlag = true;
                    freqHz = 14070450;
                }   

                // Display the new band setting.
                showSettingsFlag = true; 
                break;
                

            // Toggle the PA on/off.
            case 'p':
                paFlag = (paFlag ? false : true);
                sysPAOutput (paFlag);
                output_bit (IO_OSK, paFlag);

                if (paFlag) 
                {
                    ddsSetMode (DDS_MODE_PSK31);             
                    ddsSetFreq (freqHz);
                    ddsSetAmplitude (amplitude);
                    ddsPhase (phaseFlag);
                } else
                    ddsSetMode (DDS_MODE_POWERDOWN);

                break;

            case 'x':
                diagDoneFlag = true;
                break;

            case 't':
                temperature = lm92GetTemp();
                fprintf (PC_HOST, "%ld.%01ld degF\n\r", temperature / 10, temperature % 10);
                break;

            case 'b':
                disable_interrupts (GLOBAL);
                fprintf (PC_HOST, "rebooting...\n\r\n\r");
                reset_cpu();
                break;

            case '1':
                gpsPowerOn();

                tcxo = 0x0000;

                while (!kbhit(PC_HOST))
                {
                    if (CCP_2 != tcxo)
                    {
                        fprintf (PC_HOST, "%ld %ld\n\r", CCP_2, CCP_2 - tcxo);
                        tcxo = CCP_2;
                    }
                } // END while

                gpsPowerOff();
                break;

            case 'n':
                cutdownFlag = (cutdownFlag ? false : true);
                output_bit (IO_CUT_DOWN, cutdownFlag);
                break;

            case 'u':
                pumpFlag = (pumpFlag ? false : true);
                output_bit (IO_BALLAST_PUMP, pumpFlag);
                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, "%02ld.%06ldMHz ", freqHz / 1000000, freqHz % 1000000);
            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;
}

bool_t flashIsWriteInProgress()
{
    uint8_t status;

    output_low (IO_FLASH_CS);

    // Read Status Register (RDSR) flash command.
    flashSendByte (0x05);

    status = flashGetByte();

    output_high (IO_FLASH_CS);

    return (((status & 0x01) == 0x01) ? true : false);
}

void flashReadBlock(uint32_t address, uint8_t *block, uint16_t length)
{
    uint16_t i;
    
    output_low (IO_FLASH_CS);

    // Read Data Byte(s) (READ) flash command.
    flashSendByte (0x03);
    flashSendAddress (address);
    
    for (i = 0; i < length; ++i)
        *block++ = flashGetByte();
    
    output_high (IO_FLASH_CS);
}

void flashWriteBlock(uint32_t address, uint8_t *block, uint8_t length)
{
    uint8_t i;

    output_low (IO_FLASH_CS);
    // Write Enable (WREN) flash command.
    flashSendByte (0x06);
    output_high (IO_FLASH_CS);
    
    output_low (IO_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 (IO_FLASH_CS);

            // Write this block of data.
            while (flashIsWriteInProgress());

            output_low (IO_FLASH_CS);
            // Write Enable (WREN) flash command.
            flashSendByte (0x06);
            output_high (IO_FLASH_CS);

            output_low (IO_FLASH_CS);
            // Page Program (PP) flash command.
            flashSendByte (0x02);
            flashSendAddress (address);
        } // END if
    } // END for    

    output_high (IO_FLASH_CS);

    // Wait for the final write operation to complete.
    while (flashIsWriteInProgress());
}

void flashErase()
{
    output_low (IO_FLASH_CS);

    // Write Enable (WREN) flash command.
    flashSendByte (0x06);
    output_high (IO_FLASH_CS);
    
    output_low (IO_FLASH_CS);
    // Bulk Erase (BE) flash command.
    flashSendByte (0xc7);

    output_high (IO_FLASH_CS);

    while (flashIsWriteInProgress());
}

uint8_t flashReadElectronicSignature()
{
    uint8_t electronicSignature;

    output_low (IO_FLASH_CS);
    flashSendByte (0xab);
    flashSendByte (0x00);
    flashSendByte (0x00);
    flashSendByte (0x00);

    electronicSignature = flashGetByte();

    output_high (IO_FLASH_CS);

    return electronicSignature;
}

uint8_t flashGetByte()
{
    return spi_read(0x00);
}

void flashInit()
{
    // I/O lines to control flash.
    output_high (IO_FLASH_CS);
}

void flashSendByte(uint8_t value)
{
    spi_write (value);
}

void flashSendAddress(uint32_t address)
{
    spi_write ((address >> 16) & 0xff);
    spi_write ((address >> 8) & 0xff);
    spi_write (address & 0xff);
}


#define GPS_BUFFER_SIZE 50

enum GPS_PARSE_STATE_MACHINE 
{
    GPS_START1,

    GPS_START2,

    GPS_COMMAND1,

    GPS_COMMAND2,

    GPS_READMESSAGE,

    GPS_CHECKSUMMESSAGE,

    GPS_EOMCR,

    GPS_EOMLF
};

uint8_t gpsIndex;

GPS_PARSE_STATE_MACHINE gpsParseState;

uint8_t gpsBuffer[GPS_BUFFER_SIZE]; 

int32_t gpsPeakAltitude;

uint8_t gpsChecksum;

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
}

int32_t gpsGetPeakAltitude()
{
    return gpsPeakAltitude;
}

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));

    // Capture CCP2 on the rising edge of the GPS 1-PPS signal.
    setup_ccp2 (CCP_CAPTURE_RE);
}

bool_t gpsIsReady()
{
    if (gpsPosition.updateFlag) 
    {
        gpsPosition.updateFlag = false;
        return true;
    } // END if

    return false;
}

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;
}

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_20);
            return true;
        }

        if (timeGetTicks() > startTime) 
        {
            puts ("@@Hb\001\053\015\012");
            startTime += 10;
        } // END if
            
    } // END while

    return false;
}

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;
}

void gpsPowerOn()
{
    // 3.0 VDC LDO control line.
    output_high (IO_GPS_PWR);

    // Enable the UART and the transmit line.
    SPEN = true;
}

void gpsPowerOff()
{
    // Disable the UART and the transmit line.
    SPEN = false;

    // 3.0 VDC LDO control line.
    output_low (IO_GPS_PWR);
}

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<CR><LF>
    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
}


#define LOG_WRITE_BUFFER_SIZE 255

uint32_t logAddress;

uint8_t logBuffer[LOG_WRITE_BUFFER_SIZE];

uint8_t logIndex;

bool_t logDisableFlag;

uint32_t logGetAddress()
{
    return logAddress;
}

void logFlush()
{
    if (logDisableFlag)
        return;

    // We only need to write if there is data.
    if (logIndex != 0) 
    {
        flashWriteBlock (logAddress, logBuffer, logIndex);
        logAddress += logIndex;
        logIndex = 0;
    } // END if
}

void logInit()
{
    uint8_t buffer[8];
    bool_t endFound;

    // Flag that disable writes to flash.
    logDisableFlag = false;

    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_1:
            case LOG_TEMPERATURE_2:
                logAddress += 3;
                break;

            case LOG_VOLTAGE:
                logAddress += 5;
                break;

            case LOG_PUMP:
                logAddress += 9;
                break;

            case 0xff:
                endFound = true;
                break;

            default:
                ++logAddress;
        } // END switch
    } while (logAddress < 0x100000 && !endFound);

    fprintf (PC_HOST, "done.\n\rLog contains %ld bytes.\n\r", logAddress);

    logIndex = 0;
}

void logSetDisableFlag (bool_t disableFlag)
{
    logDisableFlag = disableFlag;
}

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[logIndex++] = type;
}

void logUint8 (uint8_t value)
{
    logBuffer[logIndex++] = value;
}

void logInt16 (int16_t value)
{
    logBuffer[logIndex++] = (value >> 8) & 0xff;
    logBuffer[logIndex++] = value & 0xff;
}

void logUint16 (uint16_t value)
{
    logBuffer[logIndex++] = (value >> 8) & 0xff;
    logBuffer[logIndex++] = value & 0xff;
}

void logInt32 (int32_t value)
{
    logBuffer[logIndex++] = (value >> 24) & 0xff;
    logBuffer[logIndex++] = (value >> 16) & 0xff;
    logBuffer[logIndex++] = (value >> 8) & 0xff;
    logBuffer[logIndex++] = value & 0xff;
}

#use i2c (master, scl=PIN_B5, sda=PIN_B1)

int16_t lm92GetTemp()
{
    int16_t value;
    int32_t temp;

    // 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();

    //  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;
}

const uint16_t PSK31_VARICODE[] = 
{
    0xAAC0, // ASCII =   0  1010101011
    0xB6C0, // ASCII =   1  1011011011
    0xBB40, // ASCII =   2  1011101101
    0xDDC0, // ASCII =   3  1101110111
    0xBAC0, // ASCII =   4  1011101011
    0xD7C0, // ASCII =   5  1101011111
    0xBBC0, // ASCII =   6  1011101111
    0xBF40, // ASCII =   7  1011111101
    0xBFC0, // ASCII =   8  1011111111
    0xEF00, // ASCII =   9  11101111
    0xE800, // ASCII =  10  11101
    0xDBC0, // ASCII =  11  1101101111
    0xB740, // ASCII =  12  1011011101
    0xF800, // ASCII =  13  11111
    0xDD40, // ASCII =  14  1101110101
    0xEAC0, // ASCII =  15  1110101011
    0xBDC0, // ASCII =  16  1011110111
    0xBD40, // ASCII =  17  1011110101
    0xEB40, // ASCII =  18  1110101101
    0xEBC0, // ASCII =  19  1110101111
    0xD6C0, // ASCII =  20  1101011011
    0xDAC0, // ASCII =  21  1101101011
    0xDB40, // ASCII =  22  1101101101
    0xD5C0, // ASCII =  23  1101010111
    0xDEC0, // ASCII =  24  1101111011
    0xDF40, // ASCII =  25  1101111101
    0xEDC0, // ASCII =  26  1110110111
    0xD540, // ASCII =  27  1101010101
    0xD740, // ASCII =  28  1101011101
    0xEEC0, // ASCII =  29  1110111011
    0xBEC0, // ASCII =  30  1011111011
    0xDFC0, // ASCII =  31  1101111111
    0x8000, // ASCII = ' '  1
    0xFF80, // ASCII = '!'  111111111
    0xAF80, // ASCII = '"'  101011111
    0xFA80, // ASCII = '#'  111110101
    0xED80, // ASCII = '$'  111011011
    0xB540, // ASCII = '%'  1011010101
    0xAEC0, // ASCII = '&'  1010111011
    0xBF80, // ASCII = '''  101111111
    0xFB00, // ASCII = '('  11111011
    0xF700, // ASCII = ')'  11110111
    0xB780, // ASCII = '*'  101101111
    0xEF80, // ASCII = '+'  111011111
    0xEA00, // ASCII = ','  1110101
    0xD400, // ASCII = '-'  110101
    0xAE00, // ASCII = '.'  1010111
    0xD780, // ASCII = '/'  110101111
    0xB700, // ASCII = '0'  10110111
    0xBD00, // ASCII = '1'  10111101
    0xED00, // ASCII = '2'  11101101
    0xFF00, // ASCII = '3'  11111111
    0xBB80, // ASCII = '4'  101110111
    0xAD80, // ASCII = '5'  101011011
    0xB580, // ASCII = '6'  101101011
    0xD680, // ASCII = '7'  110101101
    0xD580, // ASCII = '8'  110101011
    0xDB80, // ASCII = '9'  110110111
    0xF500, // ASCII = ':'  11110101
    0xDE80, // ASCII = ';'  110111101
    0xF680, // ASCII = '<'  111101101
    0xAA00, // ASCII = '='  1010101
    0xEB80, // ASCII = '>'  111010111
    0xABC0, // ASCII = '?'  1010101111
    0xAF40, // ASCII = '@'  1010111101
    0xFA00, // ASCII = 'A'  1111101
    0xEB00, // ASCII = 'B'  11101011
    0xAD00, // ASCII = 'C'  10101101
    0xB500, // ASCII = 'D'  10110101
    0xEE00, // ASCII = 'E'  1110111
    0xDB00, // ASCII = 'F'  11011011
    0xFD00, // ASCII = 'G'  11111101
    0xAA80, // ASCII = 'H'  101010101
    0xFE00, // ASCII = 'I'  1111111
    0xFE80, // ASCII = 'J'  111111101
    0xBE80, // ASCII = 'K'  101111101
    0xD700, // ASCII = 'L'  11010111
    0xBB00, // ASCII = 'M'  10111011
    0xDD00, // ASCII = 'N'  11011101
    0xAB00, // ASCII = 'O'  10101011
    0xD500, // ASCII = 'P'  11010101
    0xEE80, // ASCII = 'Q'  111011101
    0xAF00, // ASCII = 'R'  10101111
    0xDE00, // ASCII = 'S'  1101111
    0xDA00, // ASCII = 'T'  1101101
    0xAB80, // ASCII = 'U'  101010111
    0xDA80, // ASCII = 'V'  110110101
    0xAE80, // ASCII = 'W'  101011101
    0xBA80, // ASCII = 'X'  101110101
    0xBD80, // ASCII = 'Y'  101111011
    0xAB40, // ASCII = 'Z'  1010101101
    0xFB80, // ASCII = '['  1111101110
    0xF780, // ASCII = '\'  111101111
    0xFD80, // ASCII = ']'  111111011
    0xAFC0, // ASCII = '^'  1010111111
    0xB680, // ASCII = '_'  101101101
    0xB7C0, // ASCII = '`'  1011011111
    0xB000, // ASCII = 'a'  1011
    0xBE00, // ASCII = 'b'  1011111
    0xBC00, // ASCII = 'c'  101111
    0xB400, // ASCII = 'd'  101101
    0xC000, // ASCII = 'e'  11
    0xF400, // ASCII = 'f'  111101
    0xB600, // ASCII = 'g'  1011011
    0xAC00, // ASCII = 'h'  101011
    0xD000, // ASCII = 'i'  1101
    0xF580, // ASCII = 'j'  111101011
    0xBF00, // ASCII = 'k'  10111111
    0xD800, // ASCII = 'l'  11011
    0xEC00, // ASCII = 'm'  111011
    0xF000, // ASCII = 'n'  1111
    0xE000, // ASCII = 'o'  111
    0xFC00, // ASCII = 'p'  111111
    0xDF80, // ASCII = 'q'  110111111
    0xA800, // ASCII = 'r'  10101
    0xB800, // ASCII = 's'  10111
    0xA000, // ASCII = 't'  101
    0xDC00, // ASCII = 'u'  110111
    0xF600, // ASCII = 'v'  1111011
    0xD600, // ASCII = 'w'  1101011
    0xDF00, // ASCII = 'x'  11011111
    0xBA00, // ASCII = 'y'  1011101
    0xEA80, // ASCII = 'z'  111010101
    0xADC0, // ASCII = '{'  1010110111
    0xDD80, // ASCII = '|'  110111011
    0xAD40, // ASCII = '}'  1010110101
    0xB5C0, // ASCII = '~'  1011010111
    0xED40  // ASCII = 127  1110110101
};

#define PSK_MAX_PACKET 160

enum PSK_MODE
{
    PSK_WAIT_MSG,

    PSK_TX_SYNC,

    PSK_TX_MESSAGE,

    PSK_TX_END
};

#define PSK31_TIMESLOT 0

#define PSK_SYNC_LENGTH 32

#define PSK_END_LENGTH 8

const uint32_t PSK31_FREQ_LIST[] = { 14070450, 14070450, 14070450 };
const uint16_t PSK31_AMP_LIST[] = { 105, 105, 105 };

uint8_t pskCount;

uint16_t pskData;

bool_t pskPhase;

char pskBuffer[PSK_MAX_PACKET];

PSK_MODE pskMode;

uint8_t pskLastBits;

uint8_t pskIndex;

bool_t pskMessageDoneFlag;

bool_t psk31CreateDataPacket()
{
    int32_t temp;
    int16_t temperature;
    uint32_t coord, coordMin;

    // Record the temperature pre-transmit.
    temperature = lm92GetTemp();

    if (temperature == 0x13f)
        temperature = lm92GetTemp();

    logType (LOG_TEMPERATURE_1);
    logInt16 (temperature);

    // Line 1 - Header
    printf (psk31TxByte, "\n\n\nBalloon QSL www.kd7lmo.net\n");
    
    // Line 2 - Data with units.
    printf (psk31TxByte, "%02d%02dutc ", gpsPosition.hours, gpsPosition.minutes);

    // Altitude in feet.
    if (gpsPosition.altitudeFeet > 1000)
        printf (psk31TxByte, "%ld,", gpsPosition.altitudeFeet / 1000);

    printf (psk31TxByte, "%03ldft ", gpsPosition.altitudeFeet % 1000);

    // Latitude value.
    coord = gpsPosition.latitude;

    if (gpsPosition.latitude < 0) 
    {
        coord = gpsPosition.latitude * -1;
        printf (psk31TxByte, "S");
    } else {
        coord = gpsPosition.latitude;
        printf (psk31TxByte, "N");
    }

    coordMin = (coord % 3600000) / 600;
    printf (psk31TxByte, "%02ldd%02ld.%02ldm ", (uint32_t) (coord / 3600000), (uint32_t) (coordMin / 100), (uint32_t) (coordMin % 100));

    // Longitude value.
    if (gpsPosition.longitude < 0) 
    {
        coord = gpsPosition.longitude * - 1;
        printf (psk31TxByte, "W");
    } else {
        coord = gpsPosition.longitude;
        printf (psk31TxByte, "E");
    }

    coordMin = (coord % 3600000) / 600;
    printf (psk31TxByte, "%03ldd%02ld.%02ldm ", (uint32_t) (coord / 3600000), (uint32_t) (coordMin / 100), (uint32_t) (coordMin % 100));

    // Speed MPH and heading.
    temp = (int32_t) gpsPosition.hSpeed * 500 / 22352;

    printf (psk31TxByte, "%ldmph@%ldd ", temp, gpsPosition.heading / 10);

    printf (psk31TxByte, "%ld.%lddop ", gpsPosition.dop / 10, gpsPosition.dop % 10);

    printf (psk31TxByte, "%ld.%ldF ", temperature / 10, abs(temperature % 10));

    printf (psk31TxByte, "%ldp ", ballastGetPumpCount());

    if (cutDownIsActivate())
        printf (psk31TxByte, "*");

    printf (psk31TxByte, "\n");

    // Line 3 - Header / ident
    printf (psk31TxByte, "QSL www.kd7lmo.net de AC7ZT\n");

    // End of message line feeds.
    printf (psk31TxByte, "\n\n\n");

    // NULL terminate the string.
    psk31TxNull();
    
    return true;
}

void psk31Init()
{
    pskCount = 0;
    pskData = 0x0000;
    pskIndex = 0;
    pskMode = PSK_WAIT_MSG;
    pskPhase = false;
    pskLastBits = 0x00;
    pskMessageDoneFlag = false;
}

bool_t psk31IsFree()
{
    if (pskMode == PSK_WAIT_MSG)
        return true;

    return false;
}

void psk31TimeUpdate()
{
    // If we are waiting for a message, just return.
    if (pskMode == PSK_WAIT_MSG)
        return;

    // If our next bit is 0 (zero), ramp down the carrier.
    if (pskCount == 15)
        if ((pskData & 0x8000) == 0x0000)
            output_low (IO_OSK);

    // Every 32mS process the next bit.
    if (++pskCount == 32) 
    {
        pskCount = 0;

        switch (pskMode) {
            case PSK_TX_SYNC:
                // Just toggle the phase during the sync sequence.
                if (pskPhase)
                    pskPhase = false;
                else
                    pskPhase = true;

                ddsPhase (pskPhase);

                // After we send the start sequence, send the message.
                if (--pskIndex == 0) 
                {
                    pskMode = PSK_TX_MESSAGE;
                    pskIndex = 1;
                    pskData = PSK31_VARICODE[pskBuffer[0]];
                    pskLastBits = 0x0f;
                } // END if

                // Ramp the carrier back on.
                output_high (IO_OSK);

                break;

            case PSK_TX_MESSAGE:
                // Keep track of the last 4 bits we transmitted.
                pskLastBits = (pskLastBits << 1) & 0x0f;

                // If the data bit is a zero, toggle the phase.
                if ((pskData & 0x8000) == 0x0000) 
                {
                    if (pskPhase)
                        pskPhase = false;
                    else
                        pskPhase = true;

                    ddsPhase (pskPhase);
                } else
                    pskLastBits |= 0x01;

                // Shift to the next bit.
                pskData = pskData << 1;

                // If the last 2 bits we sent were 0, then get the next byte.
                if ((pskLastBits & 0x0c) == 0x00)
                    // Stop when we find the NULL character.
                    if (pskBuffer[pskIndex] == 0) 
                    {
                        pskIndex = PSK_END_LENGTH;
                        pskMode = PSK_TX_END;
                        pskData = 0x0000;
                    } else {
                        // Get the next character in the buffer.
                        pskData = PSK31_VARICODE[pskBuffer[pskIndex++]];

                        // Reset the last bits shift register.
                        pskLastBits = 0x0f;
                    } // END if-else

                output_high (IO_OSK);
            
                break;

            case PSK_TX_END:
                // Just toggle the phase during the end sequence.
                if (pskPhase)
                    pskPhase = false;
                else
                    pskPhase = true;

                ddsPhase (pskPhase);

                if (--pskIndex == 0) 
                {
                    // Turn off the carrier.
                    output_low (IO_OSK);

                    // Turn off the PA.
                    sysPAOutput (false);

                    ddsSetMode (DDS_MODE_POWERDOWN);

                    pskMessageDoneFlag = true;

                    // We are ready for a new mesasge.
                    pskMode = PSK_WAIT_MSG;

                    // Enable access to the flash that shares the DDS SPI port.
                    logSetDisableFlag (false);
                } else
                    output_high (IO_OSK);

                break;
        } // END switch
    } // END if
}

void psk31TxPacket(uint8_t minutes)
{
    // We can't create a packet if one is already in progress.
    if (pskMode != PSK_WAIT_MSG || !tncIsFree())
        return;

    // Only transmit every 6 minutes
    if ((minutes % 6) != 0)
        return;

    // Disable access to the flash that shares the SPI port.
    logSetDisableFlag (true);

    // Set the pointer to the start of the buffer.
    pskIndex = 0;
        
    // If the packet generations fails, display a warning message.
    if (!psk31CreateDataPacket()) 
    {
        pskIndex = 0;
        printf (psk31TxByte, "Ballooon QSL www.kd7lmo.net * Unable to generate telemetry\n\n");
        psk31TxNull();
    }
    
    // Select the PSK-31 real-time clock mode.
    timeSetMode (TIME_MODE_PSK31);
    
    // Configure the DDS for PSK-31 mode.
    ddsSetMode (DDS_MODE_PSK31);
    
    // Set the DDS frequency based on the time schedule that repeats every 6 minutes.
    ddsSetFreq (PSK31_FREQ_LIST[minutes % 3]);
    ddsSetAmplitude (PSK31_AMP_LIST[minutes % 3]);
    
    // Turn on the PA.
    sysPAOutput (true);

    // Prepare the variables that are used in the real-time clock interrupt.
    pskIndex = PSK_SYNC_LENGTH;
    pskCount = 0;
    pskData = 0x0000;
    pskMode = PSK_TX_SYNC;
}

void psk31TxByte (uint8_t value)
{
    if (pskIndex == PSK_MAX_PACKET)
        return;

    pskBuffer[pskIndex++] = value;
}

void psk31TxString (char *string, uint8_t length)
{
    while (length-- != 0)
        psk31TxByte (*string++);
}

void psk31TxNull ()
{
    psk31TxByte (0x00);
}

bool_t psk31IsMessageDone()
{
    if (pskMessageDoneFlag)
    {
        pskMessageDoneFlag = false;
        return true;
    }

    return false;
}


#define SERIAL_BUFFER_SIZE 64

#define SERIAL_BUFFER_MASK 0x3f

uint8_t serialHead;

uint8_t serialTail;

uint8_t serialBuffer[SERIAL_BUFFER_SIZE];

bool_t serialHasData()
{
    if (serialHead == serialTail)
        return false;

    return true;
}

void serialInit()
{
    serialHead = 0;
    serialTail = 0;
}

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;
}

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;
    }
}

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));
}

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;
}

inline void sysPAOutput (bool_t state)
{
    if (state)
        output_low (IO_PA);
    else
        output_high (IO_PA);
}


uint8_t timeTicks;

uint16_t timeInterruptCount;

uint8_t time100ms;

uint8_t timeSeconds;

uint8_t timeMinutes;

uint8_t timeHours;

uint8_t timeDutyCycle;

uint16_t timeCompare;

uint16_t timeRate;

bool_t timeUpdateFlag;

bool_t timeRunFlag;

uint16_t timeInterruptCountRollOver;

TIME_MODE timeMode;

#define TIME_RATE_PSK31 4800
#define TIME_RATE_APRS 500
#define TIME_RATE_HF_APRS 16000

#define TIME_ROLLOVER_PSK31 100
#define TIME_ROLLOVER_APRS 960
#define TIME_ROLLOVER_HF_APRS 30

uint8_t timeGetTicks()
{
    return timeTicks;
}

void timeInit()
{
    timeTicks = 0;
    timeInterruptCount = 0;
    time100mS = 0;
    timeSeconds = 0;
    timeMinutes = 0;
    timeHours = 0;
    timeDutyCycle = TIME_DUTYCYCLE_70;
    timeCompare = TIME_RATE_APRS;
    timeUpdateFlag = false;
    timeRate = TIME_RATE_APRS;
    timeRunFlag = false;
    timeUpdateFlag = false;
    timeInterruptCountRollOver = TIME_ROLLOVER_APRS;
    timeMode = TIME_MODE_APRS;
    
    // Configure CCP1 to interrupt at 1mS for PSK31 or 833uS for 1200 baud APRS
    CCP_1 = timeRate;
    set_timer1(timeCompare);
    setup_ccp1( CCP_COMPARE_INT );
    setup_timer_1( T1_INTERNAL | T1_DIV_BY_1 );
}

uint8_t timeGetHours()
{
    return timeHours;
}

uint8_t timeGetMinutes()
{
    return timeMinutes;
}

void timeSetDutyCycle (uint8_t dutyCycle)
{
    timeDutyCycle = dutyCycle;
}

void timeSetRunFlag()
{
    timeRunFlag = true;
}

void timeSetMode (TIME_MODE mode)
{
    // If we are already in the desired mode, we don't need to do anything.
    if (mode == timeMode)
        return;
        
    // Save the new mode.
    timeMode = mode;
    
    // Disable interrupts while we adjust the time information.
    disable_interrupts (INT_CCP1);
    
    switch (timeMode) {
        case TIME_MODE_APRS:
            timeRate = TIME_RATE_APRS;
            timeInterruptCountRollOver = TIME_ROLLOVER_APRS;
            break;
        
        case TIME_MODE_PSK31:
            timeRate = TIME_RATE_PSK31;
            timeInterruptCountRollOver = TIME_ROLLOVER_PSK31;
            break;

        case TIME_MODE_HF_APRS:
            timeRate = TIME_RATE_HF_APRS;
            timeInterruptCountRollOver = TIME_ROLLOVER_HF_APRS;
            break;
    } // END switch
    
    // If the current interrupt count is past the roller over state, move it back.
    // This means we will loose an interrupt period, but we don't really care.
    timeInterruptCount = timeInterruptCount % timeInterruptCountRollOver;
        
    // Restart the interrupts and we are back on-line.
    enable_interrupts (INT_CCP1);
}

// This function gets called every 1mS.
#INT_CCP1
void timeUpdate()
{
    // Pin used to measure CPU load in interrupt.
    output_high (PIN_B1);

    // Setup the next interrupt for the operational mode.
    timeCompare += timeRate;
    CCP_1 = timeCompare;

    // Call the appropriate time routine.
    if (timeMode == TIME_MODE_PSK31)
        psk31TimeUpdate();
    else
        tncTimeUpdate();

    // Read the GPS serial port and save any incoming characters.
    serialUpdate();

    // Count the number of milliseconds required for the tenth second counter.
    if (++timeInterruptCount == timeInterruptCountRollOver) 
    {
        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
                } // END if timeMinutes
        } // 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

    // Pin used to measure CPU load in interrupt.
    output_low (PIN_B1);
}


#define TNC_TX_DELAY 45

#define TNC_TIMESLOT 55

enum TNC_MODE
{
    TNC_TX_READY,

    TNC_TX_SYNC,

    TNC_TX_HEADER,

    TNC_TX_DATA,

    TNC_TX_END
};

// The size of the TNC output buffer.
#define TNC_BUFFER_SIZE 80

// The dwell duration in bits at each idle test tone.
#define TNC_DWELL_TIME 3600

// The packet header.
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 
};

uint8_t tncLastBit;
uint8_t tncPacketType;

TNC_MODE tncMode;

uint8_t tncBitCount;

uint8_t tncShift;

uint8_t tncIndex;

uint8_t tncLength;

uint8_t tncBitStuff;

uint8_t *tncBufferPnt;

uint8_t tncBuffer[TNC_BUFFER_SIZE];

// 1200 baud counter that determine which test signal to generate
uint16_t tncTestCount;

uint16_t timeNCO;

uint16_t timeNCOFreq;

uint8_t timeLowRateCount;

void tncInit()
{
    tncLastBit = 0;
    tncMode = TNC_TX_READY;
    tncTestCount = 0;
    tncPacketType = TNC_BOOT_MESSAGE;
    timeNCO = 0x00;
    timeLowRateCount = 0;
    timeNCOFreq = 0x2000;
}

bool_t tncIsFree()
{
    if (tncMode == TNC_TX_READY)
        return true;

    return false;
}

// This ISR is called when the timer register matches the compare register.
// The interrupt rate is programmed to 833uS or 1 bit time at 1200 baud.
void tncTimeUpdate()
{
    // If we are waiting for a message, just return.
    if (tncMode == TNC_TX_READY)
        return;

    // Set the DDS frequency.
    ddsSetFTW (freqTable[timeNCO >> 8]);
    
    // Adjust the NCO phase.
    timeNCO += timeNCOFreq;
    
    if (++timeLowRateCount == 8) 
    {
        timeLowRateCount = 0;

        // Set the A-FSK frequency.
        if (tncLastBit == 0x00)
            timeNCOFreq = 0x2000;
        else
            timeNCOFreq = 0x3aab;

        switch (tncMode) 
        {
            case TNC_TX_SYNC:
                // The variable tncShift contains the lastest data byte.
                // NRZI enocde the data stream.
                if ((tncShift & 0x01) == 0x00)
                    if (tncLastBit == 0)
                        tncLastBit = 1;
                    else
                        tncLastBit = 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 (tncLastBit == 0)
                        tncLastBit = 1;
                    else
                        tncLastBit = 0;
    
                    tncBitStuff = 0x00;
                    return;
                }    // END if
    
                // The variable tncShift contains the lastest data byte.
                // NRZI enocde the data stream.
                if ((tncShift & 0x01) == 0x00)
                    if (tncLastBit == 0)
                        tncLastBit = 1;
                    else
                        tncLastBit = 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 (tncLastBit == 0)
                        tncLastBit = 1;
                    else
                        tncLastBit = 0;
    
                    tncBitStuff = 0x00;
                    return;
                }    // END if
    
                // The variable tncShift contains the lastest data byte.
                // NRZI enocde the data stream.
                if ((tncShift & 0x01) == 0x00)
                    if (tncLastBit == 0)
                        tncLastBit = 1;
                    else
                        tncLastBit = 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 (tncLastBit == 0)
                        tncLastBit = 1;
                    else
                        tncLastBit = 0;
    
                // If all the bits were shifted, get the next one.
                if (++tncBitCount == 8) 
                {
                    tncBitCount = 0;
                    tncShift = 0x7e;
        
                    // Transmit closing flags.
                    if (++tncIndex == 2) 
                    {
                        // Turn off the DDS and PA (PTT).
                        ddsPTT (false);
                        sysPAOutput (false);
                        ddsSetMode (DDS_MODE_POWERDOWN);

                        tncMode = TNC_TX_READY;

                        // Disable access to the flash that shares the SPI port.
                        logSetDisableFlag (false);
                        return;
                    } // END if
                } else
                    tncShift = tncShift >> 1;
    
                break;
        } // END switch
    } // END if
}

void tncTxByte (uint8_t value)
{
    *tncBufferPnt++ = value;
    ++tncLength;
}

void tncNMEATime()
{
    // UTC of position fix.
    printf (tncTxByte, "%02d%02d%02d,", gpsPosition.hours, gpsPosition.minutes, gpsPosition.seconds);
}

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);
}

void tncStatusPacket()
{
    int16_t temperature;

    // Plain text telemetry.
    printf (tncTxByte, ">Balloon ");
    
    // Display the flight time.
    printf (tncTxByte, "%03U:%02U:%02U ", timeHours, timeMinutes, timeSeconds);
    
    // Altitude in feet.
    printf (tncTxByte, "%ld' ", gpsPosition.altitudeFeet);
    
    // 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);

    // Internal temperature.
    temperature = lm92GetTemp();

    printf (tncTxByte, "%ld.%ldF ", temperature / 10, abs(temperature % 10));
    
    // Print web address link.
    printf (tncTxByte, "QSL www.kd7lmo.net");
}  

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));
}

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));
}

void tncTxPacket(TNC_PACKET_TYPE tncPacketType)
{
    uint16_t crc;

    // Only transmit if there is not another message in progress and PSK 31 isn't using the hardware.
    if (tncMode != TNC_TX_READY || !psk31IsFree())
        return;

    // Disable access to the flash that shares the SPI port.
    logSetDisableFlag (true);

    // 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 PSK-31/APRS Beacon - V1.07");
            break;

        case TNC_STATUS:
            tncStatusPacket();
            break;

        case TNC_GGA:
            tncGPGGAPacket();
            break;

        case TNC_RMC:
            tncGPRMCPacket();
            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;

    // Select the APRS real-time clock mode.
    timeSetMode (TIME_MODE_APRS);
    
    // Configure the DDS for APRS mode.
    ddsSetMode (DDS_MODE_APRS);

    // Set for maximum output level.  Yes, 10.5dBC on the DDS is correct since the PA operates in compression above HF.
    ddsSetAmplitude (105);

    // Prepare the variables that are used in the real-time clock interrupt.
    tncBitCount = 0;
    tncShift = 0x7e;
    tncLastBit = 0;
    tncIndex = 0;
    tncMode = TNC_TX_SYNC;

    // Turn on the DSS and PA (PTT).
    ddsPTT (true);
    sysPAOutput (true);
}

// This is where we go after reset.
void main()
{
    uint8_t utcSeconds, utcMinutes, lockLostCounter;

    // Set the initial output state before we configure the output direction.
    output_low (IO_GPS_PWR);
    output_high (IO_LED);

    output_low (IO_CUT_DOWN);
    output_high (IO_PA);

    // Disable the ADC so we can use PORT A digital I/O.
    setup_adc_ports( NO_ANALOGS );

    // Configure the I/O ports.
    set_tris_a (0x00);
    set_tris_b (0x62);
    set_tris_c (0x92);

    // Setup the subsystems.
    ballastInit();
    cutDownInit();
    gpsInit();
    timeInit();
    psk31Init();
    serialInit();
    tncInit();

    // Wait for the power converter to stabilize and the subsystems to reset.
    delay_ms (400);

    // Program the DDS.
    ddsInit();

    // Finally setup the log.  We do this after the DDS because the SPI port gets set there.
    logInit();

    // Turn off the LED just as we enable the interrupts.
    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.
    output_high (IO_GPS_PWR);

    // Allow the GPS engine to boot.
    delay_ms (100);

    // Initialize the GPS engine.
    while (!gpsSetup());

    // 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);

    // Counter and time to send packets if the GPS engine not available.
    lockLostCounter = 0;
    utcSeconds = gpsPosition.seconds;
    utcMinutes = gpsPosition.minutes;

    // Transmit software version packet on start up.
    tncTxPacket(TNC_BOOT_MESSAGE);

    // This is the main loop where we wait for timer ticks.
    for (;;) 
    {
        // Read the GPS engine serial port FIFO and process the GPS data.
        gpsUpdate();

        if (gpsIsReady()) 
        {
            // Start the flight timer when we get our first valid 3D fix and turn off the status LED.
            if (gpsGetFixType() == GPS_3D_FIX)
            {
                timeSetRunFlag();
                timeSetDutyCycle (TIME_DUTYCYCLE_0);
            } // END if

            // Transmit the packets in the desired time slots.
            switch (gpsPosition.seconds)
            {
                case TNC_TIMESLOT:
                    switch (gpsPosition.minutes % 3)
                    {
                        case 0:
                            tncTxPacket(TNC_STATUS);
                             break;

                        case 1:
                            tncTxPacket(TNC_GGA);
                            break;

                        case 2:
                            tncTxPacket(TNC_RMC);
                            break;
                    } // END switch

                    break;
                
                case PSK31_TIMESLOT:
                    psk31TxPacket(gpsPosition.minutes);
                    break;
            } // END switch

            // Re-sync our internal clock to the UTC.
            utcSeconds = gpsPosition.seconds;

            lockLostCounter = 0;

            // Log the data to flash.
            if ((gpsPosition.seconds % 10) == 0)
                sysLogGPSData();

            // Run the ballast pump as required.
            ballastCheck();

            cutDownCheck();
        } // END if

        // Processing that occurs once a second.
        if (timeUpdateFlag) 
        {
            // We maintain the UTC time in minutes and seconds in case the GPS engine stop operating.
            if (++utcSeconds == 60) 
            {
                utcSeconds = 0;
                
                if (++utcMinutes == 60)
                    utcMinutes = 0;
            } // END if

            // If we loose the GPS for more than 5 seconds, we will determine when to send a packet based on internal time.
            if (lockLostCounter == 5) 
            {
                // Transmit the packets in the desired time slots.
                switch (utcSeconds)
                {
                    case TNC_TIMESLOT:
                        switch (gpsPosition.minutes % 3)
                        {
                            case 0:
                                tncTxPacket(TNC_STATUS);
                                 break;
    
                            case 1:
                                tncTxPacket(TNC_GGA);
                                break;
    
                            case 2:
                                tncTxPacket(TNC_RMC);
                                break;
                        } // END switch

                        break;
                    
                    case PSK31_TIMESLOT:
                        psk31TxPacket(utcMinutes);
                        break;
                } // END switch
            } else
                ++lockLostCounter;

            // Set the flag to indicate we have processed this time period.
            timeUpdateFlag = false;
        } // END if

        if (psk31IsMessageDone())
        {
            // Record the temperature post-transmit.
            logType (LOG_TEMPERATURE_2);
            logInt16 (lm92GetTemp());
        } // END if

    } // END while
}

---