File content as of revision 10:32d5604accfd:

#include "gsmqueue.h"
#include "mbed.h"
/* queue.cpp
 * Contains functions to read from the DMA buffer in a queue fashion
 */
extern Serial pc;

char buffer[BUFFER_LENGTH];
char* queueHead;


//Initialize variables 
void queueInit()
{
    //The buffer is initialized in init.cpp
    queueHead = QUEUETAIL;
}

//Find an occurrence of the given string in the buffer.
//Only advance queueHead until a matching string is found.
//The given string terminates in NULL (\0)
bool findInQueue(char* str)
{
    //Check that string to find is not empty
    if (*str == NULL) return false;
    
    while (queueHead != QUEUETAIL)
    {
        //Does the character match the begin char?
        if (*queueHead == *str){
            //Check the remaining characters
            char* sPos = str + 1;
            char* qPos = 0;
            for (qPos = incrementIndex(queueHead); qPos != QUEUETAIL; qPos = incrementIndex(qPos)){
                //Compare the next char
                if (*qPos == *sPos)
                {
                    ++sPos; //Increment index (prefix incrementation).
                    if (*sPos == NULL)   //If finished, update queueHead, return true.
                    {
                        queueHead = incrementIndex(qPos);
                        return true;
                    }
                }
                else    //Not equal, so exit for loop and try again at a different location
                    break;
            }
        }
        //Increment queue index for next iteration
        queueHead = incrementIndex(queueHead);
    }
    //We never finished, so return false
    return false;
}

//Increment queue index by 1
char* incrementIndex(char* pointerToIncrement)
{
    if((pointerToIncrement + 1) < (buffer + BUFFER_LENGTH))
        return (pointerToIncrement + 1);
    else
        return buffer;
}

//clear queue
void flushQueue()
{
    queueHead = QUEUETAIL;   
}

//$debug - print queue elements
void printQueue()
{
    char* qPos = queueHead;
    pc.printf("Queue:");
    while (qPos != QUEUETAIL)
    {
        //Print the current character
        if (*qPos == '\n')
            pc.printf("\\n");
        else if (*qPos == '\r')
            pc.printf("\\r");
        else    
            pc.printf("%C",*qPos);
        
        
        //Increment index
        qPos = incrementIndex(qPos);
    }
    pc.printf("\n\r");
}

//Parse through characters until first integer is found
//Advance qHead until you reach the next non-numeric character
//Does not read negative integers; returns -1 if unsuccessful
int parseInt()
{
    char* qPos = queueHead;
    //Advance to first numeric character
    while (!isNumeric(qPos))
    {
        qPos = incrementIndex(qPos);
        if (qPos == QUEUETAIL) return -1;
    }
    
    //Continue until first non-numeric character
    int val = 0;
    while (qPos != QUEUETAIL && isNumeric(qPos))
    {
        val *= 10;
        val += (int)(qPos - '0');
        qPos = incrementIndex(qPos);
    }
    return val;
}

//Returns true if the character is numeric
bool isNumeric(char* qPos)
{
    return ('0' < *qPos && *qPos < '9');
}
    
//Reset the GSM DMA idle bit to 0
void resetGSMIdleBit()
{
    UART_S1_REG(UART3) &= ~UART_S1_IDLE_MASK;
}

//Get the GSM DMA idle bit (if 1, indicates we already received a response)
bool getGSMIdleBit()
{
    return (UART_S1_IDLE_MASK & UART_S1_REG(UART3)) >> UART_S1_IDLE_SHIFT;
}