GPS.c

Go to the documentation of this file.

#include "GPS.h"


//*****************************************************************************
//
// Init GPS commands global cont variables
//
//*****************************************************************************


const unsigned char g_pcConfigureNmeaMessage[] = {0xA0, 0xA1, 0x00, 0x09, 0x08, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08, 0x0D, 0x0A};

const unsigned char g_pcConfigureMessageType[] = {0xA0, 0xA1, 0x00, 0x03, 0x09, 0x01, 0x00, 0x08, 0x0D, 0x0A};

const unsigned char g_pcConfigureSystemPowerMode[] = {0xA0, 0xA1, 0x00, 0x03, 0x0C, 0x01, 0x00, 0x0C, 0x0D, 0x0A};

const unsigned char g_pcConfigureSystemPositionRate[] = {0xA0, 0xA1, 0x00, 0x03, 0x0E, 0x10, 0x00, 0x0F, 0x0D, 0x0A};

const unsigned char g_pcConfigureSystemRestart[] = {0xA0, 0xA1, 0x00, 0x0F, 0x01, 0x01, 0xD6, 0x07, 0x0C, 0x12, 0x08, 0x32, 0x29, 0xC4, 0x09, 0x70, 0x30, 0x64, 0x00, 0x35, 0x0D, 0x0A};
 
const unsigned char g_pcConfigureSerialPort[] = {0xA0, 0xA1, 0x00, 0x04, 0x05, 0x00, 0x05, 0x00, 0x05, 0x0D, 0x0A};


//*****************************************************************************
//
// Globale variables
//
//*****************************************************************************

tGPS_state g_eGPSstate;

tGPS_state g_eGPSnextState;

tDateTime g_GPSdeadline = 0;

tGPSInfoArray g_GPSInfoArray;

tDinamicArray g_GPS_CommandQueue;

tpfGPSHttpPostCallbackFunction g_pfOnCallbackGPRShttpPost = NULL;

char* g_pcGPSResponseBuffer = NULL;

char* g_pcGPSResponseBufferEnd = NULL;

char g_nmeaPacket[PACKET_SIZE] = {'\0'};

tGPSInfo g_GPSInfoGpsPacket = {'\0'};   

tBoolean g_GPS_GPGGApart = 0;

tBoolean g_GPS_GPRMCpart = 0;


//*****************************************************************************
//
// Function definations
//
//*****************************************************************************

void GPS_executeGPS(void)
{
    if (g_eGPSstate < GPS_Inizialized){
        
        GPS_setupGPS();
    }   
    
    else if ( g_eGPSstate == GPS_InitError){
        
        // lid 2.3 pin led
        Ports_setPort2Pin(LED_NUMBER_3);
        
        _disable_interrupts();
        // stop cpu
        _bis_SR_register(LPM4_bits);    
    }
    
    else if ( g_eGPSstate == GPS_Inizialized){
        
        tNMEA_messages test;
        // start parsing the nmea sentences
        test = GPS_NMEAProcess(g_nmeaPacket);
                
        if(test == NMEA_GPGGA){
                    
            GPS_ProcessGPGGA(g_nmeaPacket, &g_GPSInfoGpsPacket);
            g_GPS_GPGGApart = 1;
        }
                
        else if(test == NMEA_GPRMC){
                    
            g_GPS_GPRMCpart = 1;
        }
                
        if(g_GPS_GPGGApart && g_GPS_GPRMCpart){
                    
            g_GPS_GPGGApart = 0;
            g_GPS_GPRMCpart = 0;
            // put the received packet into the queue
            GPSpacket_pushGPSInfoArray(&g_GPSInfoArray, &g_GPSInfoGpsPacket);
            GPS_clearGPSInfoPacket(&g_GPSInfoGpsPacket);
            
        }
        
        // if we have any data in the queue make an attempt to post through GPRS
        if(g_GPSInfoArray.uiIdx){
            
            if(g_pfOnCallbackGPRShttpPost){
                
                g_pfOnCallbackGPRShttpPost("host", "3010", "url", (char*)GPSpacket_getGPSInfoArray(&g_GPSInfoArray), sizeof(tGPSInfo) * g_GPSInfoArray.uiCurrentSize);
            }
            
        }
        
    }
}


void GPS_setupGPS(void)
{
    // number of reconections   
    static unsigned char ucAttempt = ATTEMPT_NUMBER;
    
    switch(g_eGPSstate){
        
        case GPS_Uninizialized:
            GPS_setState(GPS_SendCommand);
        break;
        
        case GPS_SendCommand:
            GPS_sendCommand();
            GPS_setState(GPS_CommandSent);
        break;
        
        case GPS_CommandSent:
            if(GPS_isCommandSent()){    
                GPS_setState(GPS_StarWaitingForTheAnswer);
            }
            // do nothing until the command has not been sent completely
        break;

        case GPS_StarWaitingForTheAnswer:
            GPS_setDeadline(SECOND);
            GPS_setState(GPS_WaitingForTheAnswer);
        break;
    
        case GPS_WaitingForTheAnswer:
            if(strstr(g_pcGPSResponseBuffer, "ACK")){
                if(GPS_isCommandAvaiable()){
                    // reset the number of attempts
                    ucAttempt = ATTEMPT_NUMBER;
                    GPS_clearResponseBuffer();
                    GPS_goToNextCommand();
                    GPS_setState(GPS_SendCommand);
                }
                // if all command have already sent
                else{           
                    
                    GPS_clearResponseBuffer();          
                    GPS_setState(GPS_Inizialized);
                }
            }
            else if(GPS_isDeadlinePassed() || strstr(g_pcGPSResponseBuffer, "NACK")){
                if(--ucAttempt){
                    
                    GPS_clearResponseBuffer();
                    // if at least one more attepmpt is remained sent the current command again
                    GPS_setState(GPS_SendCommand);
                    
                }
                else{
                
                    GPS_setState(GPS_InitError);
                }
            }   // else if
        break;
    }           // switch
}


void GPS_setGPShttpPostCallbackFunction(tpfGPSHttpPostCallbackFunction pfCallbackGPRShttpPost)
{
    g_pfOnCallbackGPRShttpPost = pfCallbackGPRShttpPost;
}


void GPS_initGPS(void)
{
    g_pcGPSResponseBuffer = (char*)calloc('\0', sizeof(char)* GPS_RESPONSE_BUFFER_SIZE);
    GPS_clearResponseBuffer();
    Dinamic_Array_Init(&g_GPS_CommandQueue);
    GPS_addCommand(g_pcConfigureSystemRestart);
    GPS_addCommand(g_pcConfigureSerialPort);
    GPS_addCommand(g_pcConfigureSystemPowerMode);
    GPS_addCommand(g_pcConfigureMessageType);
    GPS_addCommand(g_pcConfigureSystemPositionRate);
    GPS_addCommand(g_pcConfigureNmeaMessage);
    // set current state
    GPS_setState(GPS_Uninizialized);
    GPSpacket_initGPSInfoArray(&g_GPSInfoArray);
    // set GPS_appendResponse for UART_read function as a callback function
    UART1_setAppendResponseCallbackFunction(&GPS_appendResponse);
}


tBoolean GPS_isResponseBufferFull(void)
{
    return ((strlen(g_pcGPSResponseBuffer) == (GPS_RESPONSE_BUFFER_SIZE-1)) ? 1: 0);
}


void GPS_clearResponseBuffer(void)
{
    g_pcGPSResponseBufferEnd = g_pcGPSResponseBuffer;
    *g_pcGPSResponseBufferEnd = 0;
}


tBoolean GPS_isCommandSent(void)
{
    return (UART1_isWritingDone()); 
}


void GPS_setDeadline(unsigned int uiDeadline)
{
    tDateTime Now;
    Time_getCurrentDateTime(&Now);
    g_GPSdeadline = Now + uiDeadline; 
}


tBoolean GPS_isDeadlinePassed(void)
{
    tDateTime Now;
    Time_getCurrentDateTime(&Now);
    return ((Now > g_GPSdeadline )? 1 : 0);
}


void GPS_setState(tGPS_state newState)
{
    g_eGPSstate = newState;
}


void GPS_setNextState(tGPS_state newState)
{
    g_eGPSnextState = newState;
}


tGPS_state GPS_getGPSstate(void)
{
    return g_eGPSstate;
}


void GPS_addCommand(const unsigned char* pcCommand)
{
    // TODO kell e mely masolat ?
    Dinamic_Array_Add(&g_GPS_CommandQueue, pcCommand);
}


void GPS_goToNextCommand(void)
{
    Dinamic_Array_Delete(&g_GPS_CommandQueue, 0);   
}


tBoolean GPS_isCommandAvaiable(void)
{
    return ((g_GPS_CommandQueue.uiSize == 0) ? 1 : 0);
}


void GPS_sendCommand(void)
{
    if(g_eGPSstate == GPS_SendCommand){
        GPS_processCommand();
    }
}


void GPS_processCommand(void)
{
    if(g_GPS_CommandQueue.uiSize){
        
        char* pcCommand = (char*) g_GPS_CommandQueue.pArray[ 0 ];
        UART1_write(pcCommand, strlen(pcCommand));
    }
}


void GPS_appendResponse(const char* pcResponse)
{
    unsigned int uiLength = strlen(pcResponse);
    if(uiLength + g_pcGPSResponseBufferEnd < g_pcGPSResponseBuffer + GPS_RESPONSE_BUFFER_SIZE){
        
        strcat(g_pcGPSResponseBufferEnd, pcResponse);
        g_pcGPSResponseBufferEnd += uiLength;
    }
    
    else{
        
        // buffer is full 
    }   
}



tNMEA_messages GPS_NMEAProcess(char* pcNmeaPacket)
{
    // clear nmeapacket
    memset(pcNmeaPacket, '\0', strlen(pcNmeaPacket));
    // no data will send
    tNMEA_messages foundpacket = NMEA_NODATA;
    tBoolean startFlag = 0;
    // if the buffer is empty we don't have to do anything...
    if(g_pcGPSResponseBuffer != g_pcGPSResponseBufferEnd){
        // pharse until the all character in the buffer has been tested.
        while(*g_pcGPSResponseBuffer++){
            if(*g_pcGPSResponseBuffer == '$'){
                startFlag = 1;
                break;
            }
            else{
                continue;
            }
        }
    } 
    unsigned uiAvail = strlen(g_pcGPSResponseBuffer);
    unsigned char i;
    if(startFlag){
        // decrase uiAvail $ character dosen't count...
        for(i = 1; i < (uiAvail - 1); i++){
            if((g_pcGPSResponseBuffer[i] == '\r') && (g_pcGPSResponseBuffer[i+1] == '\n')){
                unsigned char j;
                for(j = 0; j < (i - 1); j++){
                    *pcNmeaPacket++ = g_pcGPSResponseBuffer[j];
                }
                // Add a null termination to the string
                *pcNmeaPacket = 0;
                foundpacket = NMEA_UNKNOWN;
                break;
            }
        }
        if(foundpacket){
            if(!strncmp(pcNmeaPacket, "GPGGA", 5)){
                // if we've found a correct packet we can clear the response buffer
                GPS_clearResponseBuffer();
                foundpacket = NMEA_GPGGA;
            }
            else if(!strncmp(pcNmeaPacket, "GPRMC", 5)){
                // if we've found a correct packet we can clear the response buffer
                GPS_clearResponseBuffer();
                foundpacket = NMEA_GPRMC;
            }
            // default  foundpacket = NMEA_NODATA   
        }
        else if(GPS_isResponseBufferFull()){
            // if we did'nt find packet and the buffer is full
            // we're logjammed, flush entire buffer
            GPS_clearResponseBuffer();
        }
    }
    // return the type of the found pakcet
    // if no packet has found the function will return with NMEA_NODATA
    return foundpacket;
}


void GPS_clearGPSInfoPacket(tGPSInfo* pGPSInfoPacket)
{
    tGPSInfo g_GPSInfoBlank = {0}; 
    *pGPSInfoPacket = g_GPSInfoBlank;
}


void GPS_ProcessGPGGA(const char* pcFoundPacket, tGPSInfo* pGPSInfoPacket)
{
    // temporaly buffer to store the part of the packet wants to be converted
    char cpTmpBuffer[20] = {'\0'};
    // index for array is pointed by the pcFoundPacket
    unsigned int i;
    // for the strtod functions
    char* endptr;
    // start parsing just after "GPGA"
    i = 6;
    // an attempt to reject the empty packet
    if(pcFoundPacket[i] == ',' && pcFoundPacket[i+1] == ','){
        return;
    }
    // Increase the value of index in order to the first digit of the hours will be addressed.
    i++;
    // get the hour from the packet
    strncpy(cpTmpBuffer,&pcFoundPacket[i], 2);
    pGPSInfoPacket->currentTime.ucHour = (unsigned char)atoi(cpTmpBuffer);
    // clear the temporaly buffer
    memset(cpTmpBuffer, sizeof(cpTmpBuffer),0);
    // Step forward to the place where the min begins.
    i+=2;
    // get the minute from the packet 
    strncpy(cpTmpBuffer,&pcFoundPacket[i], 2); 
    pGPSInfoPacket->currentTime.ucMin = (unsigned char)atoi(cpTmpBuffer);
    // clear the temporaly buffer
    memset(cpTmpBuffer, sizeof(cpTmpBuffer),0);
    // Step forward to the place where the sec begins.  
    i+=2; 
    // get the sec from the packet 
    strncpy(cpTmpBuffer,&pcFoundPacket[i], 2);    
    pGPSInfoPacket->currentTime.ucSec = (unsigned char)atoi(cpTmpBuffer);
    // clear the temporaly buffer
    memset(cpTmpBuffer, sizeof(cpTmpBuffer),0);
    // Step forward to the place where the msec begins.
    i+=3;   
    // get the msec from the packet     
    strncpy(cpTmpBuffer,&pcFoundPacket[i], 3);    
    pGPSInfoPacket->currentTime.ucSec = atoi(cpTmpBuffer);  
    // clear the temporaly buffer
    memset(cpTmpBuffer, sizeof(cpTmpBuffer),0);                                                      
    // next field: latitude
    while(pcFoundPacket[i++] != ',');
    // get latitude
    pGPSInfoPacket->currentPosition.latitude = strtod(&pcFoundPacket[i], &endptr);
    // Step forward where the latitude indicator begins.
    i++;
    // if the direction is South set the forth bit of the direction variable
    if(pcFoundPacket[i] == 'S'){
        SET_BIT(pGPSInfoPacket->currentPosition.altitudeFractPartAndDir, 3);
    }
    // if the direction is North clear the forth bit of the direction variable
    else{
        CLEAR_BIT(pGPSInfoPacket->currentPosition.altitudeFractPartAndDir, 3);
    }
    // get longitude
    pGPSInfoPacket->currentPosition.longitude = strtod(&pcFoundPacket[i], &endptr);
    // if the direction is West set the fifth bit of the direction variable
    // increase the endptr by one because now it's pointing to the comma
    if(*(endptr+1) == 'W'){
        SET_BIT(pGPSInfoPacket->currentPosition.altitudeFractPartAndDir, 4);
    }
    // if the direction is East clear it
    else{
        CLEAR_BIT(pGPSInfoPacket->currentPosition.altitudeFractPartAndDir, 4);
    }
    // next field: gps gualitiy indicator, we don't need it, so skip it
    while(pcFoundPacket[i++] != ',');
    // next field: satellites used, we don't need it, so skip it
    while(pcFoundPacket[i++] != ',');
    // next field: HDOP, we don't need it, so skip it
    while(pcFoundPacket[i++] != ',');
    // next field: altitude
    while(pcFoundPacket[i++] != ',');
    // now we're pointing to the first figure of the altitude
    i++;
    unsigned char j = 0;
    while(pcFoundPacket[i] != '.'){
        // copy the intiger part of the altitude to the temporaly buffer
        cpTmpBuffer[j++] = pcFoundPacket[i++];
    }
    // get the intiger part of the altitude
    pGPSInfoPacket->currentPosition.altitudeFractPartAndDir = atoi(cpTmpBuffer);
    // clear the temporaly buffer
    memset(cpTmpBuffer, sizeof(cpTmpBuffer),0);
    // now we're pointig the fractional part of the altitude
    i++;
    // get the franctional part of the altitude
    OR(pGPSInfoPacket->currentPosition.altitudeFractPartAndDir, (unsigned char)atoi(&pcFoundPacket[i]));
}