GPRS.c

Go to the documentation of this file.

#include "GPRS.h"


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


tGPRS_state g_eGPRSstate;

tGPRS_state g_eGPRSnextState;

tDateTime g_GPRSdeadline = 0;

char* g_pcGPRSResponseBuffer = NULL;

char* g_pcGPRSResponseBufferEnd = NULL;

tDinamicArray g_GPRS_CommandQueue = {NULL};

char g_pcPinCommand[15];

char g_pcBearerCommand[100];

char g_pcUsernameCommand[50];

char g_pcPasswordCommand[50];

char g_pcCreateConnectionCommand[255];

char g_pcFileCommand[1024];

char* g_pcHost;

char* g_pcPort;

char* g_pcURL;

char* g_pcData;

unsigned int g_uiDataLength;

tBoolean g_iShouldDisconnect;

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


void GPRS_initGPRS(void)
{
    g_pcGPRSResponseBuffer = (char*)calloc('\0', sizeof(char)* GPRS_RESPONSE_BUFFER_SIZE);
    GPRS_clearResponseBuffer();
    GPRS_initCommandQueue(&g_GPRS_CommandQueue);
    GPRS_addCommand( AT_COMMAND_AT, 1 * SECOND );
    sprintf( g_pcPinCommand, "AT+CPIN=%s\r\n", PIN );
    sprintf( g_pcBearerCommand, "AT+WIPBR=2,6,11,\"%s\"\r\n", "vitamax.internet.vodafone.net" );
    sprintf( g_pcUsernameCommand, "AT+WIPBR=2,6,0,\"%s\"\r\n", "" );
    sprintf( g_pcPasswordCommand, "AT+WIPBR=2,6,1,\"%s\"\r\n", "" );
    g_pcHost = g_pcPort = g_pcURL = g_pcData = 0;
    g_iShouldDisconnect = 0;
    UART2_setAppendResponseCallbackFunction(&GPRS_appendResponse);
    GPS_setGPShttpPostCallbackFunction(&GPRS_httpPost);
    GPRS_setState(GPRS_Uninitialized);
}


void GPRS_executeGPRS(void)
{
    switch(g_eGPRSstate){
        
        case GPRS_Waiting:
        
            if (GPRS_isDeadlinePassed()) {
                
                GPRS_setState(g_eGPRSnextState);
            }   
            
        break;
        
        case GPRS_Uninitialized:
        
            GPRS_setState( GPRS_EscapeToCommandMode );
            GPRS_addCommand( AT_COMMAND_SWITCH_TO_AT_MODE, 0 * SECOND );
            
        break;
        
        case GPRS_EscapeToCommandMode:
        
            GPRS_setState( GPRS_RestartGSM );
            GPRS_addCommand( AT_COMMAND_RESTART, 0 * SECOND );
            GPRS_wait( 1 * SECOND, g_eGPRSstate );
        
        break;
        
        case GPRS_EscapeFromDataMode:
        
            GPRS_setState( GPRS_WIPClose );
            GPRS_addCommand( AT_COMMAND_CLOSE_TCP_SOCKET, 0 * SECOND );
            
        break;
        
        case GPRS_ConnectedToBearer:
        
            if ( g_iShouldDisconnect ) {
                GPRS_setState( GPRS_DisconnectingFromBearer );
                GPRS_addCommand( AT_COMMAND_CLOSE_BEARER, 0 * SECOND );

                g_iShouldDisconnect = 0;
            }
        
        break;
        
        default:
        
            GPRS_processCommand();
    }
    
    GPRS_processResponse();
}


void GPRS_processCommand(void)
{
    if(g_GPRS_CommandQueue.uiSize){
         
        tCommandInstance* pTmpCommandInstance = (tCommandInstance*) g_GPRS_CommandQueue.pArray[ 0 ];
        
        UART2_write(pTmpCommandInstance->pcCommand, strlen(pTmpCommandInstance->pcCommand));
        if(pTmpCommandInstance->sWaitingDuration){
            
            GPRS_wait(pTmpCommandInstance->sWaitingDuration, g_eGPRSstate);
            
        }
        
        // kozvetetten a pArray 0. eleme is felszabadul szoval nem lesz memory lake 
        free(pTmpCommandInstance);
        Dinamic_Array_Delete(&g_GPRS_CommandQueue, 0);
        
    }
}


void GPRS_processResponse(void)
{
    static unsigned char ucAttempt = 0;
    
    switch ( g_eGPRSstate ) {
        // init gprs module
        case GPRS_RestartGSM :
        
            if ( strstr( g_pcGPRSResponseBuffer, "OK" ) ) {
                GPRS_clearResponseBuffer();
                GPRS_setState( GPRS_EchoOff );
                GPRS_addCommand( AT_COMMAND_ECHO_OFF, 0 * SECOND );
            }
            
        break;
        
        case GPRS_EchoOff :
        
            if ( strstr( g_pcGPRSResponseBuffer, "OK" ) ) {
                GPRS_clearResponseBuffer();
                GPRS_setState( GPRS_ErrorOn );
                GPRS_addCommand( AT_COMMAND_ENABLE_ERROR_MESSAGES, 0 * SECOND );
            }
            
        break;
        
        case GPRS_ErrorOn :
        
            if ( strstr( g_pcGPRSResponseBuffer, "OK" ) ) {
                GPRS_clearResponseBuffer();
                GPRS_setState( GPRS_AddPin );
                GPRS_addCommand( g_pcPinCommand, 0 * SECOND );
            }
            
        break;
        
        case GPRS_AddPin :
        
            if ( strstr( g_pcGPRSResponseBuffer, "OK" ) ) {
                GPRS_clearResponseBuffer();
                GPRS_setState( GPRS_OpenGSM );
                GPRS_addCommand( AT_COMMAND_START_WIP_PACKET, 0 * SECOND );
            }
            
        break;
        
        case GPRS_OpenGSM :
        
            if ( strstr( g_pcGPRSResponseBuffer, "OK" ) ) {
                GPRS_clearResponseBuffer();
                GPRS_setState( GPRS_ChangeCharSet );
                GPRS_addCommand( AT_COMMAND_SELECT_CHARACTERSET, 0 * SECOND );
            }
            
        break;
        
        case GPRS_ChangeCharSet :
        
            if ( strstr( g_pcGPRSResponseBuffer, "OK" ) ) {
                GPRS_clearResponseBuffer();
                GPRS_setState( GPRS_Initialized );
            }
            
        break;
        // at this point the GPRS module is ready to connect to the bearer
        // the program can be here in two case:
        //                                      - gprs module is inizialized after starting and waiting for the first connection
        //                                      - we were connected but GPRS_disconectFromTheBearer has been called
        case GPRS_Initialized :
        // do nothing until someone wants to connecting to the the bearer
        break;
        // start connecting to the bearer, call GPRS_connectTotheBearer function
        case GPRS_OpenGPRS :
        
            if ( strstr( g_pcGPRSResponseBuffer, "OK" ) ) {
                GPRS_clearResponseBuffer();
                GPRS_setState( GPRS_OpenBearer );
                GPRS_addCommand( AT_COMMAND_OPEN_BEARER, 0 * SECOND );
            }
            
        break;
        
        case GPRS_OpenBearer :
        
            if ( strstr( g_pcGPRSResponseBuffer, "OK" ) ) {
                GPRS_clearResponseBuffer();
                GPRS_setState( GPRS_SetConnectionPoint );
                GPRS_addCommand( g_pcBearerCommand, 0 * SECOND );
            }
            
        break;
        
        case GPRS_SetConnectionPoint :
        
            if ( strstr( g_pcGPRSResponseBuffer, "OK" ) ) {
                GPRS_clearResponseBuffer();
                GPRS_setState( GPRS_AddUsername );
                GPRS_addCommand( g_pcUsernameCommand, 0 * SECOND );
            }
            
        break;
        
        case GPRS_AddUsername :
        
            if ( strstr( g_pcGPRSResponseBuffer, "OK" ) ) {
                GPRS_clearResponseBuffer();
                GPRS_setState( GPRS_AddPassword );
                GPRS_addCommand( g_pcPasswordCommand, 0 * SECOND );
            }
            
        break;
        
        case GPRS_AddPassword :
        
            if ( strstr( g_pcGPRSResponseBuffer, "OK" ) ) {
                GPRS_clearResponseBuffer();
                GPRS_setState( GPRS_ConnectToBearer );
                GPRS_addCommand( AT_COMMAND_START_BEARER, 0 * SECOND );
                // 30 is the number of the attempts of reconection to the bearer
                ucAttempt = 30;
            }
            
        break;
        
        case GPRS_ConnectToBearer :
        
            // if during the connection everything went well 
            if ( strstr( g_pcGPRSResponseBuffer, "OK" ) ) {
                GPRS_clearResponseBuffer();
                //  retrive the number of the connection attempts
                ucAttempt = 30;
                GPRS_setState( GPRS_ConnectedToBearer );
            }
            // if failed to connect to the bearer
            if ( strstr( g_pcGPRSResponseBuffer, "ERROR" ) ) {
                GPRS_clearResponseBuffer();
                // try until ucAttempt number didn't reached zero
                if ( --ucAttempt > 0 ) {
                    GPRS_wait( 2 * SECOND, g_eGPRSstate );
                    // send again the start command
                    GPRS_addCommand( AT_COMMAND_START_BEARER, 0 * SECOND );
                // if we don't have any attempt left
                } else {
                    GPRS_setState( GPRS_CloseGPRS );
                    GPRS_addCommand( AT_COMMAND_CLOSE_IP_STACK, 0 * SECOND );
                    // TODO ezt a hibat lekezelni
                }
            }
            
        break;
        
        // we're connected to the bearer
        // the program can be here in two case:
        //                                   - we have just connected to the bearer at very first time
        //                                   - tcp/ip stack is closed by WIPCLOSE at command
        case GPRS_ConnectedToBearer :
        // waiting to post something, call GPRS_HTTPPost function
        break;
        // start posting
        case GPRS_WIPCreate :
        
            if ( strstr( g_pcGPRSResponseBuffer, "+WIPREADY:" ) ) {
                GPRS_clearResponseBuffer();
                //  retrive the number of the connection attempts
                ucAttempt = 30;
                GPRS_setState( GPRS_WIPData );
                GPRS_addCommand( AT_COMMAND_OPEN_TCP_SOCKET, 0 * SECOND );
            }
            if ( strstr( g_pcGPRSResponseBuffer, "ERROR" ) ) {
                
                GPRS_clearResponseBuffer();
                
                if ( --ucAttempt > 0 ) {
                    GPRS_wait( 2 * SECOND, g_eGPRSstate );
                    // send again the g_pcCreateConnectionCommand command (this command has been set by the GPRS_HTTPPost function)
                    GPRS_addCommand( g_pcCreateConnectionCommand, 0 * SECOND );
                } 
                // if we have don't have more attempt left, close the stack 
                else {
                    GPRS_setState( GPRS_WIPClose );
                    GPRS_addCommand( AT_COMMAND_CLOSE_TCP_SOCKET, 0 * SECOND );
                    // TODO ezt a hibat lekezelni
                }
            }
        break;
        
        case GPRS_WIPData :
        
            if ( strstr( g_pcGPRSResponseBuffer, "CONNECT" ) ) {
                
                GPRS_clearResponseBuffer();
                GPRS_setState( GPRS_SendingData );
                sprintf( g_pcFileCommand, 
                        "POST %s HTTP/1.1\r\nHost: %s\r\nAccept: text/html\r\nConnection: close\r\nContent-Length: %d\r\nContent-Type: application/x-www-form-urlencoded\r\n\r\n", 
                        g_pcURL, g_pcHost, strlen( g_pcData ) );
                GPRS_addCommand( g_pcFileCommand, 1 * SECOND ); 
                
            }
            if ( strstr( g_pcGPRSResponseBuffer, "ERROR" ) ) {
                
                // if any error occures during posting close the stack and go back to the GPRS_ConnectedToBearer state
                GPRS_clearResponseBuffer();
                GPRS_setState( GPRS_EscapeFromDataMode );
                GPRS_addCommand( AT_COMMAND_SWITCH_TO_AT_MODE, 1 * SECOND );
            }
        break;
        
        case GPRS_SendingData:
        
            GPRS_clearResponseBuffer();
            GPRS_setState( GPRS_Connected );
            // g_pcData contains the inforamtion we want to post and we past to the GPRS_HTTPPost function
            UART2_write(g_pcData, g_uiDataLength);
        
        case GPRS_Connected :
        
            if ( strchr( g_pcGPRSResponseBuffer, GPRS_ETX_CHAR ) && strstr( g_pcGPRSResponseBuffer, "SHUTDOWN" ) ) {

                GPRS_clearResponseBuffer();
                // close the tcp/ip stack and go back to the GPRS_ConnectedToBearer state
                GPRS_setState( GPRS_EscapeFromDataMode );
                GPRS_addCommand( AT_COMMAND_SWITCH_TO_AT_MODE, 1 * SECOND );
            }

        break;
        
        case GPRS_WIPClose :
        
            if ( strstr( g_pcGPRSResponseBuffer, "OK" ) ) {
                // after this the tcp/ip stack is closed 
                // go back to the GPRS_ConnectedToBearer state
                GPRS_clearResponseBuffer();
                GPRS_setState( GPRS_ConnectedToBearer );
            }
            
        break;
        // we can reached this point only that case if GPRS_disconnectFromTheBearer function is has been called explicitly
        case GPRS_DisconnectingFromBearer :
        
            if ( strstr( g_pcGPRSResponseBuffer, "OK" ) ) {
                GPRS_setState( GPRS_CloseGPRS );
                GPRS_addCommand( AT_COMMAND_CLOSE_IP_STACK, 0 * SECOND );
            }
        break;
        
        case GPRS_CloseGPRS :
        
            if ( strstr( g_pcGPRSResponseBuffer, "OK" ) ) {
                GPRS_setState( GPRS_Initialized );
            }
            
        break;
    }
}


void GPRS_connectToBearer(void)
{
    // do nothing until we are not in the GPRS_Initialized state
    if ( g_eGPRSstate != GPRS_Initialized ) {
        
        return;
    }

    GPRS_setState( GPRS_OpenGPRS );
    GPRS_addCommand( AT_COMMAND_START_IP_STACK, 0 * SECOND );
}


void GPRS_disconnectFromBearer(void)
{
    g_iShouldDisconnect = 1;
}


void GPRS_initCommandQueue(tDinamicArray* pDinamicArray)
{
    Dinamic_Array_Init(pDinamicArray);
}


void GPRS_appendResponse(const char* pcResponse)
{
    unsigned int uiLength = strlen(pcResponse);
    if(uiLength + g_pcGPRSResponseBufferEnd < g_pcGPRSResponseBuffer + GPRS_RESPONSE_BUFFER_SIZE){
        
        strcat(g_pcGPRSResponseBufferEnd, pcResponse);
        g_pcGPRSResponseBufferEnd += uiLength;
    }
    
    else{
        
        // buffer is full 
    }   
}


void GPRS_clearResponseBuffer(void)
{
    g_pcGPRSResponseBufferEnd = g_pcGPRSResponseBuffer;
    *g_pcGPRSResponseBufferEnd = 0;
}


void GPRS_wait(tDateTime sWaitDuration, tGPRS_state eNextState)
{
        
    Time_getCurrentDateTime( &g_GPRSdeadline );
    g_GPRSdeadline += sWaitDuration;
    g_eGPRSnextState = eNextState;
    g_eGPRSstate = GPRS_Waiting;
}


void GPRS_httpPost( char* pcHost, char* pcPort, char* pcURL, char* pcData, unsigned int uiDataLength)
{
    
    if ( g_eGPRSstate != GPRS_ConnectedToBearer ) {
        
        //  do nothing until we aren't connected    
        return;
    }
    GPRS_setState( GPRS_WIPCreate );
    sprintf( g_pcCreateConnectionCommand, "AT+WIPCREATE=2,1,\"%s\",%s\r\n", pcHost, pcPort );
    GPRS_addCommand( g_pcCreateConnectionCommand, 0 * SECOND );
    // set the globel variables according the function paramters given
    g_pcHost = pcHost;
    g_pcPort = pcPort;
    g_pcURL = pcURL;
    g_pcData = pcData;
    g_uiDataLength = uiDataLength;
}



void GPRS_addCommand(char* pcCommand, tDateTime sTimeoutDuration)
{
    // this memory space set free after the command has been sent in the GPRS_processCommand function
    tCommandInstance* ptCommandInstanceTmp = (tCommandInstance*)malloc(sizeof(tCommandInstance)*1);
    ptCommandInstanceTmp->pcCommand = pcCommand;
    ptCommandInstanceTmp->sWaitingDuration = sTimeoutDuration;
    // put the command into the queue
    Dinamic_Array_Add(&g_GPRS_CommandQueue, ptCommandInstanceTmp);
}


void GPRS_setState(tGPRS_state newState)
{
    g_eGPRSstate = newState;
}


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