/WaspGPRS.cpp

Large files files are truncated, but you can click here to view the full file

/*
 *  Copyright (C) 2009 Libelium Comunicaciones Distribuidas S.L.
 *  http://www.libelium.com
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU Lesser General Public License as published by
 *  the Free Software Foundation, either version 2.1 of the License, or
 *  (at your option) any later version.
   
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU Lesser General Public License for more details.
  
 *  You should have received a copy of the GNU Lesser General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 *  Version:		0.13
 *  Design:		David Gascón
 *  Implementation:	Alberto Bielsa, David Cuartielles
 */
  

#ifndef __WPROGRAM_H__
//  #include <WProgram.h>
  #include "WaspClasses.h"
#endif
#include "WaspGPRSconstants.h"
// Constructors ////////////////////////////////////////////////////////////////

WaspGPRS::WaspGPRS()
{
	_baudRate=XBEE_RATE;
	_pwrMode=GPRS_ON;
	_uart=1;
	not_ready=1;
}


// Private Methods /////////////////////////////////////////////////////////////

/* setPattern(pattern) - sets pattern to use in sending and receiving messages
 *
 * This function sets pattern to use in sending and receiving messages
 *
 * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
 *
 * Returns '1' on success and '0' if error
*/
uint8_t WaspGPRS::setPattern(const char* pattern)
{
	char command[25];
	char aux='"';
	uint8_t answer=0;
	
	flag &= ~(GPRS_ERROR_PATTERN);
	
	sprintf(command,"%s%c%s%c",AT_GPRS_PATTERN,aux,pattern,aux);
	
	answer=sendATCommand(command,AT_GPRS_PATTERN_R);
	switch(answer)
	{
		case	0	:	flag |= GPRS_ERROR_PATTERN;
					return 0;
					break;
		case	2	:	flag |= GPRS_ERROR_PATTERN;
					return 0;
					break;
	}
	if(flag & GPRS_ERROR_PATTERN) return 0;
	return 1;
}

/* setConnectionTimer() - sets GPRS connection time out
 *
 * This function sets GPRS connection time out
 *
 * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
 *
 * Returns '1' on success and '0' if error
*/
uint8_t WaspGPRS::setConnectionTimer()
{
	char command[25];
	char aux='"';
	uint8_t answer=0;
	
	flag &= ~(GPRS_ERROR_TIMER);
	
	sprintf(command,"%s0,120,2,120",AT_GPRS_CNX_TIMER);
	
	answer=sendATCommand(command,AT_GPRS_CNX_TIMER_R);
	switch(answer)
	{
		case	0	:	flag |= GPRS_ERROR_TIMER;
					return 0;
					break;
		case	2	:	flag |= GPRS_ERROR_TIMER;
					return 0;
					break;
	}
	if(flag & GPRS_ERROR_TIMER) return 0;
	return 1;
}


/* checkGPRS() - checks if GPRS connection is OK
 *
 * This function checks if GPRS connection is OK
 *
 * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
 *
 * Returns '1' on success and '0' if error
*/
uint8_t WaspGPRS::checkGPRS()
{
	char command[25];
	char aux='"';
	uint8_t answer=0;
	
	flag &= ~(GPRS_ERROR_CHECK);
		
	answer=sendATCommand(AT_GPRS_CHECK,AT_GPRS_CHECK_R);
	switch(answer)
	{
		case	0	:	flag |= GPRS_ERROR_CHECK;
					return 0;
					break;
		case	2	:	flag |= GPRS_ERROR_CHECK;
					return 0;
					break;
	}
	if(flag & GPRS_ERROR_CHECK) return 0;
	return 1;
}


/* setConnectionProfile() - sets GPRS connection profile
 *
 * This function sets GPRS connection profile
 *
 * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
 *
 * Returns '1' on success and '0' if error
*/
uint8_t WaspGPRS::setConnectionProfile()
{
	char command[25];
	char aux='"';
	uint8_t answer=0;
	
	flag &= ~(GPRS_ERROR_PROFILE);
		
	answer=sendATCommand(AT_GPRS_CNX_PROFILE,AT_GPRS_CNX_PROFILE_R);
	switch(answer)
	{
		case	0	:	flag |= GPRS_ERROR_PROFILE;
					return 0;
					break;
		case	2	:	flag |= GPRS_ERROR_PROFILE;
					return 0;
					break;
	}
	if(flag & GPRS_ERROR_PROFILE) return 0;
	return 1;
}

/* setFlowControl() - sets GPRS flow control
 *
 * This function sets GPRS flow control
 *
 * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
 *
 * Returns '1' on success and '0' if error
*/
uint8_t WaspGPRS::setFlowControl()
{
	char command[25];
	char aux='"';
	uint8_t answer=0;
	
	flag &= ~(GPRS_ERROR_SMTP);
		
	answer=sendATCommand(AT_GPRS_K3,AT_GPRS_K3_R);
	switch(answer)
	{
		case	0	:	flag |= GPRS_ERROR_SMTP;
					return 0;
					break;
		case	2	:	flag |= GPRS_ERROR_SMTP;
					return 0;
					break;
	}
	if(flag & GPRS_ERROR_SMTP) return 0;
	return 1;
}


/* writeData(data,start) - writes data to send
 *
 * This function writes data to send
 *
 * Returns '1' on success and '0' if error
*/
uint8_t WaspGPRS::writeData(const char* data)
{
	char command[GPRS_MAX_DATA+15];
	
	sprintf(command,"%s%c%c%s",data,'\r','\n',GPRS_PATTERN);
	printString(command,PORT_USED);
}


/* parse_GSM(data) - parses GSM string and specifies if it is a call or an sms
 *
 * This function writes data to send
 *
 * Returns '0' on GSM incoming call, '1' on GSM incoming SMS, '2' if error
*/
uint8_t WaspGPRS::parse_GSM(char* data)
{
	uint8_t a=0;
	char cmp[5];
	
	while( (data[a]!='+') && (a<=45) ){
		a++;
	}
	a++;
	for(int b=0;b<4;b++)
	{
		cmp[b]=data[a];
		a++;
	}
	cmp[4]='\0';
	if(!strcmp(cmp,"CLIP")) return 0;
	if(!strcmp(cmp,"CMTI")) return 1;
	return 2;
}

/* setEmailParams(smtp_server, port, to) - sets the email parameters
 *
 * This function sets the email parameters
 *
 * Returns '1' on success and '0' if error
*/
uint8_t WaspGPRS::setEmailParams(char* smtp_server, uint16_t port, char* to)
{
	char command[100];
	char aux='"';
	uint8_t answer=0;
	
	sprintf(command,"%s%c%s%c,%u,%c%s%c",AT_SMTP_PARAM,aux,smtp_server,aux,port,aux,to,aux);
	answer=sendATCommand(command,AT_SMTP_PARAM_R);
	switch(answer)
	{
		case	0	:	flag |= GPRS_ERROR_SMTP;
					return 0;
					break;
		case	2	:	flag |= GPRS_ERROR_SMTP;
					return 0;
					break;
	}
	if(flag & GPRS_ERROR_SMTP) return 0;
	return 1;
}

/* setEmailPwd(user, pwd) - sets the email user and password
 *
 * This function sets the email user and password
 *
 * Returns '1' on success and '0' if error
*/
uint8_t WaspGPRS::setEmailPwd(char* user, char* pwd)
{
	char command[100];
	char aux='"';
	uint8_t answer=0;
	
	sprintf(command,"%s%c%s%c,%c%s%c",AT_SMTP_PWD,aux,user,aux,aux,pwd,aux);
	answer=sendATCommand(command,AT_SMTP_PWD_R);
	switch(answer)
	{
		case	0	:	flag |= GPRS_ERROR_SMTP;
					return 0;
					break;
		case	2	:	flag |= GPRS_ERROR_SMTP;
					return 0;
					break;
	}
	if(flag & GPRS_ERROR_SMTP) return 0;
	return 1;
}

/* setEmailDestination(destination) - sets the email destination
 *
 * This function sets the email destination
 *
 * Returns '1' on success and '0' if error
*/
uint8_t WaspGPRS::setEmailDestination(char* destination)
{
	char command[50];
	char aux='"';
	uint8_t answer=0;
	
	sprintf(command,"%s%c%s%c",AT_SMTP_TO,aux,destination,aux);
	answer=sendATCommand(command,AT_SMTP_TO_R);
	switch(answer)
	{
		case	0	:	flag |= GPRS_ERROR_SMTP;
					return 0;
					break;
		case	2	:	flag |= GPRS_ERROR_SMTP;
					return 0;
					break;
	}
	if(flag & GPRS_ERROR_SMTP) return 0;
	return 1;
}

/* setEmailSubject(subject) - sets the email subject
 *
 * This function sets the email subject
 *
 * Returns '1' on success and '0' if error
*/
uint8_t WaspGPRS::setEmailSubject(char* subject)
{
	char command[50];
	char aux='"';
	uint8_t answer=0;
	
	sprintf(command,"%s%c%s%c",AT_SMTP_SUBJECT,aux,subject,aux);
	answer=sendATCommand(command,AT_SMTP_SUBJECT_R);
	switch(answer)
	{
		case	0	:	flag |= GPRS_ERROR_SMTP;
					return 0;
					break;
		case	2	:	flag |= GPRS_ERROR_SMTP;
					return 0;
					break;
	}
	if(flag & GPRS_ERROR_SMTP) return 0;
	return 1;
}


// AT Comands ///////////////////////////////////////////////////////////////////

byte WaspGPRS::sendATCommand(char* ATcommand, char* expectedAnswer) {
    return sendATCommand(ATcommand, expectedAnswer, 0);
}
  
byte WaspGPRS::sendATCommand(char* ATcommand, char* expectedAnswer, int sendOnce) {
  // command style: +CMGS=0736584317
  // this means, we gotta add the "AT"

    sprintf(theCommand, "AT%s", ATcommand);
    return sendCommand(theCommand, "\r\n", expectedAnswer, sendOnce);
}

byte WaspGPRS::sendCommand(char* theText, int endOfCommand, char* expectedAnswer) {
    return sendCommand(theText, endOfCommand, expectedAnswer, 0);
}

byte WaspGPRS::sendCommand(char* theText, int endOfCommand, char* expectedAnswer, int MAX_TIMEOUT, int sendOnce) {
    sprintf(theEnd, "%c", endOfCommand);
    return sendCommand(theText, theEnd, expectedAnswer, MAX_TIMEOUT, sendOnce);
}

byte WaspGPRS::sendCommand(char* theText, int endOfCommand, char* expectedAnswer, int sendOnce) {
    sprintf(theEnd, "%c", endOfCommand);
    return sendCommand(theText, theEnd, expectedAnswer, sendOnce);
}

byte WaspGPRS::sendCommand(char* theText, char endOfCommand, char* expectedAnswer) {
    return sendCommand(theText, (int) endOfCommand, expectedAnswer, 0);
}

byte WaspGPRS::sendCommand(char* theText, char endOfCommand, char* expectedAnswer, int MAX_TIMEOUT) {
    return sendCommand(theText, (int) endOfCommand, expectedAnswer, MAX_TIMEOUT, 0);
}

byte WaspGPRS::sendCommand(char* theText, char endOfCommand, char* expectedAnswer, int MAX_TIMEOUT, int sendOnce) {
    return sendCommand(theText, (int) endOfCommand, expectedAnswer, MAX_TIMEOUT, sendOnce);
}

byte WaspGPRS::sendCommand(char* theText, char* endOfCommand, char* expectedAnswer) {
    return sendCommand(theText, endOfCommand, expectedAnswer, DEFAULT_TIMEOUT, 0);
}

byte WaspGPRS::sendCommand(char* theText, char* endOfCommand, char* expectedAnswer, int sendOnce) {
    return sendCommand(theText, endOfCommand, expectedAnswer, DEFAULT_TIMEOUT, sendOnce);
}

byte WaspGPRS::sendCommand(char* theText, char* endOfCommand, char* expectedAnswer, int MAX_TIMEOUT, int sendOnce) {
    int timeout = 0;

    for (int i = 0; i < 100; i++) received[i] = ' ';

    int length=sprintf(theCommand, "%s%s", theText,endOfCommand);
    

  // try sending the command
  // wait for serial response
    timeout = 0;
    serialFlush(PORT_USED);
    while(!serialAvailable(PORT_USED) && timeout < MAX_TIMEOUT) {
        if (!sendOnce || !timeout) {
            printString(theCommand,PORT_USED);
            USB.print('T');
        }
        delay(DELAY_ON_SEND);
        timeout++;
    };

    int answer= waitForData( expectedAnswer, MAX_TIMEOUT, timeout, 0);
    
    return answer;
}


byte WaspGPRS::waitForData(char* expectedAnswer, int MAX_TIMEOUT, int timeout, int seconds) {

	for (int i = 0; i < 100; i++) received[i] = ' ';

	char command[50];
	int theLength = 0;
	int it=0;
	bool theSame=false;
	bool errorAnswer=false;
	int inbyte=0;
	byte countLetters = 0;
	char* errorCommand="ERROR";
	uint8_t errorLength=5;
	
	uint8_t first=1;
	uint8_t match=0;
    
	while( expectedAnswer[theLength]!='\0' ) theLength++;
		
	// if there is a heating time, then wait to see if you got
	// any data from the serial port
	while (seconds >0) {
		delay(1000);
		seconds--;
	}
		
	while(timeout < MAX_TIMEOUT) {
		while(!serialAvailable(PORT_USED) && timeout < MAX_TIMEOUT) {
			timeout++;
			delay(1000);
		}
		USB.print('y');
		while( serialAvailable(PORT_USED) && !match )
		{
			USB.print('z');
			if( first )
			{
				for(it=0;it<theLength;it++)
				{
					received[it]=serialRead(PORT_USED);
					delay(20);
				}
				USB.print(received);
				first=0;
			}
			it=0;
			
			if( serialAvailable(PORT_USED) )
			{
				theSame=true;
				for(it=0; it<theLength ; it++)
				{
					if(received[it]!=expectedAnswer[it]){
						theSame= false;
						break;
					}
				}
				if( theSame ){
					match=1;
					return 1;
				}
				else
				{
					for(it=0; it<theLength-1 ; it++)
					{
						received[it]=received[it+1];
					}
					received[it]=serialRead(PORT_USED);
					delay(20);
				}
			}
		}
	}
	if( match ) return 1;
	else return 0;
}

uint16_t WaspGPRS::waitForData(char* data, char* expectedAnswer)
{
	uint16_t i=0;
	for (i = 0; i < 100; i++) received[i] = ' ';

	int theLength = 0;
	int it=0;
	bool theSame=false;
	
	uint8_t first=1;
	uint8_t match=0;
	i=0;
    
	while( expectedAnswer[theLength]!='\0' ) theLength++;
	
	while( !match && data[i]!='\0' )
	{
		if( first )
		{
			for(it=0;it<theLength;it++)
			{
				received[it]=data[i];
				i++;

			}
			first=0;
		}
		it=0;
		theSame=true;
		for(it=0; it<theLength ; it++)
		{
			if(received[it]!=expectedAnswer[it]){
				theSame= false;
				break;
			}
		}
		if( theSame ) match=1;
		else
		{
			for(it=0; it<theLength-1 ; it++)
			{
				received[it]=received[it+1];
			}
			received[it]=data[i];
			i++;
		}
	}
	
	if( !match ) i=0;
	return i;
}

uint8_t WaspGPRS::sendDataFTP(char* file, char* path, uint8_t id)
{
	char command[100];
	char aux='"';
	long previous=0;
	uint8_t answer=0;
	uint8_t end=0;
	uint32_t i,j=0;
			
	sprintf(command,"AT%s%c,,%c%c,%c%s%c,0%c%c", AT_FTP_SEND, id, aux, aux, aux, file, aux, '\r', '\n');
	printString(command,PORT_USED);
	previous=millis();
	while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<10000) );
	delay(10);
	answer=waitForData("CONNECT",20,0,0);
	if(answer!=1) return 0;
		
	serialFlush(PORT_USED);
		
	Utils.strExplode(path,'/');
	while( path[i]!='\0' )
	{
		if( path[i]== '/' ) j++;
		i++;
	}
	i=0;
	
	SD.ON();
	
	while( j>0 )
	{
		if(!SD.cd(Utils.arguments[i])){
			SD.OFF();
			return 0;
		}
		i++;
		j--;
	}
	i=0;
	j=0;
	while( !end )
	{
		printString(SD.cat(file,250*i,250),PORT_USED);
		while( SD.buffer[j]!='\0' ) j++;
		if( j<249 ) end=1;
		i++;
		j=0;
	}
	printString(GPRS_PATTERN,PORT_USED);
		
	SD.OFF();
	
	previous=millis();
	while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<10000) );
	delay(10);
	answer=waitForData("OK",20,0,0);
	if(answer!=1) return 0;
	
	return 1;	
}


uint8_t WaspGPRS::readDataFTP(char* file, char* path, uint8_t id)
{
	char command[50];
	char aux='"';
	long previous=0;
	uint8_t answer=0;
	uint8_t end=0;
	int i,j=0;
	uint8_t timeout=0;
	uint8_t MAX_TIMEOUT=10;
	char* aux2;
	uint16_t length=0;
			
	sprintf(command,"AT%s%c,,%c%c,%c%s%c,0%c%c", AT_FTP_RECV, id, aux, aux, aux, file, aux, '\r', '\n');
	printString(command,PORT_USED);
	previous=millis();
	while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<10000) );
	delay(10);
	answer=waitForData("CONNECT",30,0,0);
	if(answer!=1){
		free(aux2);
		aux2=NULL; 
		return 0;
	}
	
	delay(20);
	while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<10000) );
		
	aux2 = (char*) calloc(MAX_SIZE_FTP,sizeof(char));
	if( aux2==NULL ) return 0;
		
	serialRead(PORT_USED);
	serialRead(PORT_USED);
	previous=millis();
	i=0;
	while( millis()-previous<5000 )
	{
		while( serialAvailable(PORT_USED) && i<MAX_SIZE_FTP )
		{
			aux2[i]=serialRead(PORT_USED);
			i++;
			previous=millis();
		}
	}
	if( i>=MAX_SIZE_FTP ) aux2[i-1]='\0';
	else aux2[i]='\0';

	length=waitForData(aux2,GPRS_PATTERN);
	if( !length ) length=i;
	else
	{
		j=Utils.sizeOf(GPRS_PATTERN);
		length-=j;
	}
	
	i=0;
	j=0;
	
	Utils.strExplode(path,'/');
	while( path[i]!='\0' )
	{
		if( path[i]== '/' ) j++;
		i++;
	}
	i=0;
	
	SD.ON();
	
	while( j>0 )
	{
		if(!SD.cd(Utils.arguments[i])){
			SD.OFF();
			free(aux2);
			aux2=NULL; 
			return 0;
		}
		i++;
		j--;
	}
	SD.create(Utils.arguments[i]);
	
	if(!SD.append(Utils.arguments[i],aux2,length)){
		SD.OFF();
		free(aux2);
		aux2=NULL; 
		return 0;
	}
	
	SD.ls();
		
	SD.OFF();
	
	free(aux2);
	aux2=NULL;
	return 1;	
}

/* getIfReady() - gets if GPRS module is ready or not
 *
 * This function gets if GPRS module is ready or not
 *
 * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
 *
 * Returns nothing. It changes the value of 'not_ready'
*/
void	WaspGPRS::getIfReady()
{
	char command[20];
	char aux='"';
	uint8_t answer=0;
	long previous=0;
	
	printString(AT_COMMAND,PORT_USED);
	printByte('\r',PORT_USED);
	printByte('\n',PORT_USED);
/*	while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<3000) );*/
	delay(10);
	answer=waitForData("OK",2,0,0);
	if(answer==1) not_ready=0;
	else not_ready=1;
}


// Public Methods //////////////////////////////////////////////////////////////

/* ON(void) - opens UART1 and powers the GPRS module
 *
 * It opens UART1 and powers the GPRS module
 *
 * Returns nothing
*/
void WaspGPRS::ON()
{
	close();
	disableInterrupts(HAI_INT);
	disableInterrupts(LAI_INT);
	if( !RTC.isON ) RTC.setMode(RTC_ON, RTC_I2C_MODE);
//	delay(2000);
	setMode(GPRS_ON);
	begin();
	delay(1000);
}


/* begin(void) - initialize GPRS module
 *
 * This function powers up the GPRS module and open Serial Port at velocity selected by the user
 * By default, it will be at 38400bps
 *
 * Returns nothing
*/
void WaspGPRS::begin()
{
	_baudRate=GPRS_RATE;
	Utils.setMuxGPRS();
	beginSerial(_baudRate,_uart);
}


/* close(void) - closes UART used by GPRS module
 *
 * This function closes UART used by GPRS module
 *
 * Returns nothing
*/
void WaspGPRS::close()
{
	closeSerial(_uart);
	Utils.setMux(MUX_TO_LOW,MUX_TO_LOW);
}

/* OFF(void) - closes UART1 and powers off the GPRS module
 *
 * This function closes UART1 and powers off the GPRS module
 *
 * Returns nothing
*/
void WaspGPRS::OFF()
{
        setMode(GPRS_HIBERNATE);
	close();
	if( RTC.isON==2 ){
		PWR.closeI2C();
		RTC.setMode(RTC_OFF, RTC_I2C_MODE);
	}
}


/* setMode(uint8_t) - Sets GPRS Power Mode
 *
 * This function selects the active power mode among: ON, SLEEP/HIBERNATE and OFF
 * It does not close the serial port, only sends the proper command to GPRS module
 *
 * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
 *
 * Returns '1' on success and '0' if error
*/
uint8_t WaspGPRS::setMode(uint8_t pwrMode)
{
	_pwrMode=pwrMode;
	flag &= ~(GPRS_ERROR_POWER);
	uint8_t answer=0;
    
	switch(_pwrMode)
	{
		case    GPRS_ON  	:	pinMode(GPRS_PW, OUTPUT);
						digitalWrite(GPRS_PW, HIGH);
						delay(2500);
						digitalWrite(GPRS_PW, LOW);
						delay(500);
						answer=1;
						break;

		case    GPRS_HIBERNATE 	:	answer=sendATCommand(POWER_HIBERNATE,POWER_R);
						switch(answer)
						{
							case	0	:	flag |= GPRS_ERROR_POWER;
										break;
							case	2	:	flag |= GPRS_ERROR_POWER;
										break;
						}
						break;

		case	GPRS_SLEEP	:	answer=sendATCommand(POWER_SLEEP,POWER_R);
						switch(answer)
						{
							case	0	:	flag |= GPRS_ERROR_POWER;
										break;
							case	2	:	flag |= GPRS_ERROR_POWER;
										break;
						}
						break;

	}
	return answer;
}


/* getMode(void) - Gets GPRS Power Mode
 *
 * This function gets the actual GPRS Power Mode. Possible values are ON, SLEEP/HIBERNATE and OFF
 *
 * Returns the power mode
*/
uint8_t	WaspGPRS::getMode()
{
	return	_pwrMode;
}


/* check(void) - Checks if GPRS is connected to the network
 *
 * This function checks if GPRS module is connected to the network. If not, it has no sense working with GPRS.
 *
 * It sends a command to GPRS module DEFAULT_TIMEOUT times. If GPRS module does not connect within these tries, function
 * exits.
 *
 * Returns '1' when connected and '0' if not
*/
uint8_t WaspGPRS::check()
{
	char byte;
	uint8_t timeout=1;///DEFAULT_TIMEOUT;
	char command[11];
	uint8_t answer=0;
	
	while(timeout)
	{
		sprintf(command,"%s%c%c","AT+CREG?",'\r','\n');
		serialFlush(PORT_USED);
		printString(command,PORT_USED);
		answer=waitForData("+CREG: 0,1",1,0,0);
		switch(answer){
			case	0:	break;
			case	1:	connected = 1;
                                        return 1;
					break;
			case 	2:	break;
		}
//		delay(1000);
		USB.print('x');
		printString(command,PORT_USED);
		answer=waitForData("+CREG: 0,5",1,0,0);
		switch(answer){
			case	0:	break;
                        case	1:	connected = 1;
                                        return 1;
			                break;
			case 	2:	break;
		}
		delay(100);
		timeout--;
	}
        connected = 0;
	return 0;	
}


/* setPIN(const char* pin) - sets PIN to the SIM
 *
 * This function sets the specified PIN to the SIM
 *
 * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
 *
 * Returns '1' on success and '0' if error
*/
uint8_t	WaspGPRS::setPIN(const char* pin)
{
	char command[20];
	flag &= ~(GPRS_ERROR_PIN);
	char aux='"';
	uint8_t answer=0;

	sprintf(command,"%s%c%s%c",AT_PIN,aux,pin,aux);
	answer=sendATCommand(command,AT_PIN_R,SEND_ONCE);
	switch(answer)
	{
		case	0	:	flag |= GPRS_ERROR_PIN;
					break;
		case	2	:	flag |= GPRS_ERROR_PIN;
					break;
	}
	if(flag & GPRS_ERROR_PIN) return 0;
	return 1;
}


/* setInfoIncomingCall() - set the info shown when an incoming call is received
 *
 * This function sets the info shown when an incoming call is received
 *
 * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
 *
 * Returns '1' on success and '0' if error
 */
uint8_t	WaspGPRS::setInfoIncomingCall()
{
	char command[20];
	flag &= ~(GPRS_ERROR_CALLINFO);
	uint8_t answer=0;

	answer=sendATCommand(AT_ID_INCALL,AT_ID_INCALL_R,SEND_ONCE);
	switch(answer)
	{
		case	0	:	flag |= GPRS_ERROR_CALLINFO;
					break;
		case	2	:	flag |= GPRS_ERROR_CALLINFO;
					break;
	}
	if(flag & GPRS_ERROR_CALLINFO) return 0;
	return 1;
}


/* setInfoIncomingSMS() - set the info shown when an incoming SMS is received
 *
 * This function sets the info shown when an incoming SMS is received
 *
 * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
 *
 * Returns '1' on success and '0' if error
 */
uint8_t WaspGPRS::setInfoIncomingSMS()
{
	char command[20];
	flag &= ~(GPRS_ERROR_SMSINFO);
	uint8_t answer=0;

	answer=sendATCommand(AT_SMS_INFO,AT_SMS_INFO_R,SEND_ONCE);
	switch(answer)
	{
		case	0	:	flag |= GPRS_ERROR_SMSINFO;
					break;
		case	2	:	flag |= GPRS_ERROR_CALLINFO;
					break;
	}
	if(flag & GPRS_ERROR_SMSINFO) return 0;
	return 1;
}


/* setTextModeSMS() - set the text mode to the sms
 *
 * This function sets the text mode to the sms
 *
 * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
 *
 * Returns '1' on success and '0' if error
 */
uint8_t WaspGPRS::setTextModeSMS()
{
	char command[20];
	flag &= ~(GPRS_ERROR_SMS);
	uint8_t answer=0;

	answer=sendATCommand(AT_SMS_MODE,AT_SMS_MODE_R);
	switch(answer)
	{
		case	0	:	flag |= GPRS_ERROR_SMS;
					return 0;
					break;
		case	2	:	flag |= GPRS_ERROR_SMS;
					return 0;
					break;
	}
	if(flag & GPRS_ERROR_SMS) return 0;
	return 1;
}


/* makeCall(const char*) - makes a call to the seleted telephone number
 *
 * This function makes a call to the given telephone number.
 *
 * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
 *
 * Returns '1' on success and '0' if error
*/
uint8_t WaspGPRS::makeCall(const char* tlfNumber)
{
	char	command[30];
	flag &= ~(GPRS_ERROR_CALL);
	uint8_t answer=0;

	sprintf(command,"%s%s;",AT_CALL,tlfNumber);
	answer=sendATCommand(command,AT_CALL_R,SEND_ONCE);
	switch(answer)
	{
		case	0	:	flag |= GPRS_ERROR_CALL;
					break;
		case	2	:	flag |= GPRS_ERROR_CALL;
					break;
	}
	if(flag & GPRS_ERROR_CALL) return 0;
	return 1;
	
}


/* makelostCall(const char* , uint8_t) - makes a lost call to the seleted telephone number
 *
 * This function makes a call to the given telephone number and its duration is specified by the other input.
 * After 'timeCall' seconds, hang the call up.
 *
 * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
 *
 * Returns '1' on success and '0' if error
*/
uint8_t WaspGPRS::makeLostCall(const char* tlfNumber, uint8_t timeCall)
{
	char	command[25];
	flag &= ~(GPRS_ERROR_CALL);
	uint8_t answer=0;

	sprintf(command,"%s%s;",AT_CALL,tlfNumber);
	answer=sendATCommand(command,AT_CALL_R,SEND_ONCE);
	switch(answer)
	{
		case	0	:	flag |= GPRS_ERROR_CALL;
					break;
		case	1	:	for(int a=0; a<timeCall ; a++) delay(1000);
					hangUp();
					break;
		case	2	:	flag |= GPRS_ERROR_CALL;
					break;
	}
	if(flag & GPRS_ERROR_CALL) return 0;
	return 1;
}


/* hangUp(void) - hangs the call up
 *
 * This function hangs all the active calls up.
 *
 * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
 *
 * Returns '1' on success and '0' if error
*/
uint8_t WaspGPRS::hangUp()
{
	uint8_t answer=0;
	flag &= ~(GPRS_ERROR_HANG);
	
	answer=sendATCommand(AT_HANG,AT_HANG_R,SEND_ONCE);
	switch(answer)
	{
		case	0	:	flag |= GPRS_ERROR_HANG;
					break;
		case	2	:	flag |= GPRS_ERROR_HANG;
					break;
	}
	if(flag & GPRS_ERROR_HANG) return 0;
	return 1;
}


/* sendSMS(const char*, const char*) - sends an SMS to the specified number
 *
 * This function sends an SMS to the specified number.
 *
 * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
 *
 * Returns '1' on success and '0' if error
*/
uint8_t WaspGPRS::sendSMS(const char* smsText, const char* tlfNumber)
{
	flag &= ~(GPRS_ERROR_SMS);
	flag &= ~(GPRS_ERROR_SMS);
	char command[25];
	char aux='"';
	uint8_t answer=0;

	sprintf(command,"%s%c%s%c",AT_SMS,aux,tlfNumber,aux);
	
	//setTextModeSMS();
	answer=sendATCommand(command,AT_SMS_R);
	switch(answer)
	{
		case	0	:	flag |= GPRS_ERROR_SMS;
					return 0;
					break;
		case	2	:	flag |= GPRS_ERROR_SMS;
					return 0;
					break;
	}
	
	answer=sendCommand((char*)smsText,0x1A,AT_SMS_TEXT_R,20,SEND_ONCE);
	switch(answer)
	{
		case	0	:	flag |= GPRS_ERROR_SMS;
					return 0;
					break;
		case	2	:	flag |= GPRS_ERROR_SMS;
					return 0;
					break;
	}
	
	if(flag & GPRS_ERROR_SMS) return 0;
	return 1;
}


/* readCall() - set in 'tlfIN' variable the tlf number of the incoming call
 *
 * This function sets in 'tlfIN' variable the tlf number of the incoming call
 *
 * This function should be executed only inside 'manageIncomingData' function.
 *
 * 'data' must contains the tlfn number, something like that: aaaa"+34666999888"aaa
 *
 * Returns '1' on success and '0' if error
*/
uint8_t	WaspGPRS::readCall(char* data)
{
	uint8_t a=0;
	uint8_t b=0;

        tlfIN[0]='\0';
	while( (data[a]!='"') && (a<45) )
	{
		a++;
	}
	a++;
	if(a>=45) return 0;
	while( (data[a]!='"') && (a<45)  && (b<15) )
	{
		tlfIN[b]=data[a];
		a++;
		b++;
	}
        if( b>=15 ) tlfIN[b-1]='\0';
        else tlfIN[b]='\0';
	return 1;
}


/* readSMS() - set in 'tlfIN' and 'sms' variables the tlf number and text of the incoming SMS
 *
 * This function sets in 'tlfIN' and 'sms' variables the tlf number and text of the incoming SMS
 *
 * This function should be executed only inside 'manageIncomingData' function.
 *
 * Returns '1' on success and '0' if error
*/
uint8_t WaspGPRS::readSMS(char* data)
{
	uint8_t a=0,b=0,c=0;
	char command[30];
	uint8_t byteIN[200];
	long previous=0;
	uint8_t counter=0;
	
        tlfIN[0]='\0';
        sms[0]='\0';
        sms_index[0]='\0';
	while( (data[a]!=',') && (a<45) ) a++;
	a++;
	if(a>=45) return 0;
	while( data[a]!=13 )
	{
		sms_index[b]=data[a];
		a++;
		b++;
	}
	sms_index[b]='\0';
	sprintf(command,"AT%s%s\r\n",AT_SMS_READ,sms_index);
	printString(command,PORT_USED);
	while(!serialAvailable(PORT_USED));
	previous=millis();
	a=0;
	while( (millis()-previous) < 2000 )
	{
		while( serialAvailable(PORT_USED) && (millis()-previous) < 2000 )
		{
			byteIN[a]=serialRead(PORT_USED);
			a++;
		}
	}
	a=0;
	while( counter <3 )
	{
		while( (byteIN[a]!='"') && (a<200) )
		{
			a++;
		}
		a++;
		counter++;
	}
	if(a>=200) return 0;
	counter=0;
	while( (byteIN[a]!='"') && (a<200) && (c<15) )
	{
		tlfIN[c]=byteIN[a];
		a++;
		c++;
	}
        if( c>=15 ) tlfIN[c-1]='\0';
        else tlfIN[c]='\0';
	while( counter < 5 )
	{
		while( (byteIN[a]!='"') && (a<200) )
		{
			a++;
		}
		a++;
		counter++;
	}
	if(a>=200) return 0;
	a++;
	a++;
	b=0;
	while( (byteIN[a]!=13) && (a<200) && (b<100) )
	{
		sms[b]=byteIN[a];
		b++;
		a++;
	}
	if(a>=200) return 0;
        if( b>=100 )sms[b-1]='\0';
        else sms[b]='\0';
	return 1;
}


/* manageIncomingData() - manage incoming data from serial port, executing proper functions to store received data
 *
 * This function manages incoming data from serial port, executing proper functions to store received data
 *
 * Returns '1' on success and '0' if error
*/
uint8_t	WaspGPRS::manageIncomingGSMData()
{
	char byteIN[100];
	uint8_t a=0;
	long previous=0;
	uint8_t answer=0;
	
	while(a<100){
		byteIN[a]=0;
		a++;
	}
	a=0;
	
	serialFlush(PORT_USED);
	previous=millis();
	while(!serialAvailable(PORT_USED) && (millis()-previous)<20000);
	previous=millis();
	while( (millis()-previous) < 2000 )
	{
		while( serialAvailable(PORT_USED) && (millis()-previous) < 2000 )
		{
			byteIN[a]=serialRead(PORT_USED);
			a++;
		}
	}
	answer=parse_GSM(byteIN);
	switch( answer ){
		case	0:	readCall(byteIN);
				break;
		case	1:	readSMS(byteIN);
				break;
	}
	if(answer==2) return 0;
	return 1;
}


/* configureGPRS() - configures GPRS connection with login, password and some other parameters
 *
 * This function creates a GPRS connection with the carrier server to get access to the internet
 *
 * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
 *
 * Returns '1' on success and '0' if error
*/
uint8_t WaspGPRS::configureGPRS()
{
	char command[100];
	char aux='"';
	uint8_t answer=0;
	
	flag &= ~(GPRS_ERROR_CONF);

	sprintf(command,"%s0,%c%s%c,%c%s%c,%c%s%c,%c%s%c,%c%s%c",AT_GPRS_CONN_CFG,aux,
		AT_GPRS,aux,aux,AT_GPRS_APN,aux,aux,AT_GPRS_LOGIN,aux,aux,AT_GPRS_PASSW,aux,aux,AT_GPRS_IP,aux);
	
	answer=sendATCommand(command,AT_GPRS_CONN_CFG_R);
	switch(answer)
	{
		case	0	:	flag |= GPRS_ERROR_CONF;
					return 0;
					break;
		case	2	:	flag |= GPRS_ERROR_CONF;
					return 0;
					break;
	}
	
	if(!setConnectionTimer()) return 0;
	
	if(!setConnectionProfile()) return 0;
	
	if(!checkGPRS()) return 0;
	
	if(!setPattern(GPRS_PATTERN)) return 0;
	
	if(flag & GPRS_ERROR_CONF) return 0;
	return 1;
}


/* createSocket(ip, port) - creates a TCP/IP connection to the specified IP and PORT
 *
 * This function creates a TCP/IP connection to the specified IP and PORT
 *
 * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
 *
 * It stores in 'socket_ID' the TCP session ID assigned to the last call to create a socket
 *
 * Returns '1' on success and '0' if error
*/
uint8_t WaspGPRS::createSocket(const char* ip,const char* port, uint8_t mode)
{
	char command[40];
	char aux='"';
	uint8_t answer=0;
	uint8_t byteIN=0;
	long previous=0;
	uint8_t counter=0;
        uint8_t i=0;

	
	flag &= ~(GPRS_ERROR_SOCKET);
	
	switch(mode){
		case GPRS_CLIENT:
			sprintf(command,"%s0,%u,%c%s%c,%s%c%c",AT_GPRS_TCP_CFG,mode,aux,ip,aux,port,'\r','\n');
			break;
		case GPRS_SERVER:
			sprintf(command,"%s0,%u,%s%c%c",AT_GPRS_TCP_CFG,mode,port,'\r','\n');
			break;
	}

	
	while( counter<3 )
	{
		serialFlush(PORT_USED);
		printString(command,PORT_USED);
		while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<3000) );
		delay(10);
		answer=waitForData("+KTCPCFG:",20,0,0);
		if(answer==1) break;
		counter++;
	}
	
	if(answer!=1) return 0;
	serialRead(PORT_USED);
	delay(30);
        i=0;
        while(i<4){
            socket_ID[i]=0;
            i++;
        }
        i=0;
        while( socket_ID[i]!='\r' && i<4 && serialAvailable(PORT_USED) ){
            socket_ID[i]=serialRead(PORT_USED);
            i++;
        }
	delay(50);
	answer=0;
	counter=0;
	while( counter<3 )
	{
		serialFlush(PORT_USED);
		printString(AT_GPRS_TCP_CNX,PORT_USED);
                i=0;
                while( socket_ID[i]!='\r' ){
		  printByte(socket_ID[i],PORT_USED);
                  i++;
                }
		printByte('\r',PORT_USED);
		printByte('\n',PORT_USED);
		while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<3000) );
		delay(10);
		answer=waitForData("OK",20,0,10);
		if(answer==1) break;
		counter++;
		
	}
	if(answer!=1) return 0;
	return 1;
}

/* readURL(url) - access to the specified URL and stores the info read in 'data_URL' variable
 *
 * This function access to the specified URL and stores the info read in 'data_URL' variable
 *
 * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
 *
 * It stores in 'socket_ID' the TCP session ID assigned to the last call to create a socket
 *
 * Returns '1' on success and '0' if error
*/
uint8_t WaspGPRS::readURL(const char* url)
{
	char command[30];
	char* data=",20";
	uint8_t answer=0;
	long previous=0;
	uint8_t byteIN=0;
	uint8_t a=0;
	
	if(!configureGPRS()) return 0;
	
	if(!createSocket(url,"80",GPRS_CLIENT)) return 0;
	
	serialFlush(PORT_USED);
	sprintf(command,"%s%c%c","GET / HTTP/1.0",'\r','\n');
	if(!sendData(command,socket_ID)){
		closeSocket(socket_ID);
		return 0;
	}
		
	waitForData("+KTCP_DATA:",20,0,0);
	if(readData(socket_ID,GPRS_DATA_LENGTH)<0){
		closeSocket(socket_ID);
		return 0;
	}
	
	while(!closeSocket(socket_ID)) closeSocket(socket_ID);
	
	return 1;
}


/* sendData(data,socket) - sends 'data' to the specified 'socket'
 *
 * This function sends 'data' to the specified 'socket'
 *
 * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
 *
 * It gets from 'socket_ID' the TCP session ID assigned to the last call of creating a socket
 *
 * Returns '1' on success and '0' if error
*/
uint8_t WaspGPRS::sendData(const char* data, uint8_t* socket)
{
	char command[30];
	uint8_t answer=0;
	long previous=0;
	uint8_t byteIN=0;
	uint8_t counter=0;
        uint8_t i=0;

	
	while(data[counter]!='\0') counter++;
	counter+=2;
        while(socket[i]!='\r') i++;
        counter+=i-1;
	serialFlush(PORT_USED);
        switch(i)
        {
            case 1: sprintf(command,"%s%c,%u%c%c",AT_GPRS_TCP_SND,socket[0],counter,'\r','\n');
                    break;
            case 2: sprintf(command,"%s%c%c,%u%c%c",AT_GPRS_TCP_SND,socket[0],socket[1],counter,'\r','\n');
                    break;
	    case 3: sprintf(command,"%s%c%c%c,%u%c%c",AT_GPRS_TCP_SND,socket[0],socket[1],socket[2],counter,'\r','\n');
                    break;
        }
       	printString(command,PORT_USED);
	previous=millis();
	while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<3000) );
	delay(10);
	answer=waitForData("CONNECT",20,0,0);
	if(answer!=1) return 0;
	answer=0;
	counter=0;
	while( (counter<3) && (answer!=1) )
	{
		serialFlush(PORT_USED);
		delay(20);
		writeData(data);
		previous=millis();
		while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<3000) );
		delay(10);
		answer=waitForData("OK",20,0,0);
		counter++;
	}
	if(answer!=1) return 0;
	return 1;
}


/* readData(socket,data_length) - reads data of 'data_length' size from socket ID 'socket'
 *
 * This function reads data of 'data_length' size from socket ID 'socket'
 *
 * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
 *
 * It stores in 'socket_ID' the TCP session ID assigned to the last call to create a socket
 *
 * Returns '1' on success, '-1' if error and '0' if more data is available
*/
int8_t WaspGPRS::readData(uint8_t* socket, const char* data_length)
{
	char command[30];
	uint8_t answer=0;
	long previous=0;
	uint8_t a=0;
	uint8_t byteIN=0;
	uint8_t aux[10];
        uint8_t i=0;

        while(socket[i]!='\r') i++;
        
        switch(i)
        {
            case 1: sprintf(command,"%s%c,%s%c%c",AT_GPRS_TCP_RCV,socket[0],data_length,'\r','\n');
            break;
            case 2: sprintf(command,"%s%c%c,%s%c%c",AT_GPRS_TCP_RCV,socket[0],socket[1],data_length,'\r','\n');
            break;
            case 3: sprintf(command,"%s%c%c%c,%s%c%c",AT_GPRS_TCP_RCV,socket[0],socket[1],socket[2],data_length,'\r','\n');
            break;
        }
	
	serialFlush(PORT_USED);
	delay(50);
	printString(command,PORT_USED);
	while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<10000) );
	delay(10);
	answer=waitForData("CONNECT",20,0,0);
	if(answer!=1) return -1;
	serialRead(PORT_USED);
	serialRead(PORT_USED);
        while( a<GPRS_DATA_LENGTH_U && serialAvailable(PORT_USED) )
        {
		aux[0]=serialRead(PORT_USED);
		if(aux[0]=='E'){
			aux[1]=serialRead(PORT_USED);
			if(aux[1]=='N'){
				aux[2]=serialRead(PORT_USED);
				if(aux[2]=='D'){
					aux[3]=serialRead(PORT_USED);
					if(aux[3]=='M'){
						aux[4]=serialRead(PORT_USED);
						if(aux[4]=='E'){
							aux[5]=serialRead(PORT_USED);
							if(aux[5]=='S'){
								answer=1;
								break;
							}
							else{
								data_URL[a]=aux[0];
								data_URL[a+1]=aux[1];
								data_URL[a+2]=aux[2];
								data_URL[a+3]=aux[3];
								data_URL[a+4]=aux[4];
								data_URL[a+5]=aux[5];
								a+=6;
							}
						}
						else{
							data_URL[a]=aux[0];
							data_URL[a+1]=aux[1];
							data_URL[a+2]=aux[2];
							data_URL[a+3]=aux[3];
							data_URL[a+4]=aux[4];
							a+=5;
						}
					}
					else{
						data_URL[a]=aux[0];
						data_URL[a+1]=aux[1];
						data_URL[a+2]=aux[2];
						data_URL[a+3]=aux[3];
						a+=4;
					}
				}
				else{
					data_URL[a]=aux[0];
					data_URL[a+1]=aux[1];
					data_URL[a+2]=aux[2];
					a+=3;
				}
			}
			else{
				data_URL[a]=aux[0];
				data_URL[a+1]=aux[1];
				a+=2;
			}	
		}
		else{
			data_URL[a]=aux[0];
			a++;
		}
	}
	
		
	data_read+=a;
	if(answer && a<(GPRS_DATA_LENGTH_U-10)) return 1;
	if(answer && a>=(GPRS_DATA_LENGTH_U-10)) return 0;
	return -1;
}


/* closeSocket(socket) - closes the socket specified by 'socket'
 *
 * This function closes the socket specified by 'socket'
 *
 * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
 *
 * Returns '1' on success and '0' if error
*/
uint8_t WaspGPRS::closeSocket(uint8_t* socket)
{
	char command[30];
	long previous=0;
	uint8_t answer=0;
	uint8_t byteIN=0;
        uint8_t i=0;
        
/*        setInfoIncomingCall();*/
        flag &= ~(GPRS_ERROR_CLOSE);
        while(socket[i]!='\r') i++;
        switch(i)
        {
            case 1: sprintf(command,"%s%c,1",AT_GPRS_TCP_CLOSE,socket[0]);
                    break;
            case 2: sprintf(command,"%s%c%c,1",AT_GPRS_TCP_CLOSE,socket[0],socket[1]);
                    break;
            case 3: sprintf(command,"%s%c%c%c,1",AT_GPRS_TCP_CLOSE,socket[0],socket[1],socket[2]);
                    break;
        }
	

	answer=sendATCommand(command,AT_GPRS_TCP_CLOSE_R);
	switch(answer)
	{
		case	0	:	flag |= GPRS_ERROR_CLOSE;
					break;
		case	2	:	flag |= GPRS_ERROR_CLOSE;
					break;
	}
	if(flag & GPRS_ERROR_CLOSE) return 0;
	return 1;
}


/* deleteSocket(socket) - deletes the socket specified by 'socket'
 *
 * This function deletes the socket specified by 'socket'
 *
 * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
 *
 * Returns '1' on success and '0' if error
*/
uint8_t WaspGPRS::deleteSocket(uint8_t* socket)
{
	char command[30];
	long previous=0;
	uint8_t answer=0;
	uint8_t byteIN=0;
        uint8_t i=0;
        
	setInfoIncomingCall();
	flag &= ~(GPRS_ERROR_DELETE);
        while(socket[i]!='\r') i++;
        switch(i)
        {
            case 1: sprintf(command,"%s%c",AT_GPRS_TCP_DEL,socket[0]);
                    break;
            case 2: sprintf(command,"%s%c%c",AT_GPRS_TCP_DEL,socket[0],socket[1]);
                    break;
            case 3: sprintf(command,"%s%c%c%c",AT_GPRS_TCP_DEL,socket[0],socket[1],socket[2]);
                    break;
        }
		
	answer=sendATCommand(command,AT_GPRS_TCP_DEL_R);
	switch(answer)
	{
		case	0	:	flag |= GPRS_ERROR_DELETE;
					break;
		case	2	:	flag |= GPRS_ERROR_DELETE;
					break;
	}
	if(flag & GPRS_ERROR_DELETE) return 0;
	return 1;
}


/* getCellInfo() - gets the information from the cell where the module is connected
 *
 * This function gets the information from the cell where the module is connected
 *
 * It stores in 'RSSI' and 'cellID' variables the information from the cell
 *
 * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
 *
 * Returns '1' on success and '0' if error
*/
uint8_t WaspGPRS::getCellInfo()
{
	char command[30];
	uint8_t byteIN[200];
	long previous=millis();
	uint8_t counter=0;
	uint8_t a,b,c=0;
	
	serialFlush(PORT_USED);
	sprintf(command,"AT%s\r\n",AT_GPRS_CELLID);
	printString(command,PORT_USED);
	while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<3000) );
	previous=millis();
	a=0;
	while( (millis()-previous) < 2000 )
	{
		while( serialAvailable(PORT_USED) && (millis()-previous) < 2000 && (a<200) )
		{
			byteIN[a]=serialRead(PORT_USED);
			a++;
		}
	}
	a=0;
	while( counter < 5 )
	{
		while( (byteIN[a]!=',') && (a<200) )
		{
			a++;
		}
		a++;
		counter++;
	}
	if(a>=200) return 0;
	counter=0;
	while( (byteIN[a]!=',') && (a<200) )
	{
		cellID[c]=byteIN[a];
		a++;
		c++;
	}
	a++;
	while( (byteIN[a]!=',') && (a<200) )
	{
		RSSI[b]=byteIN[a];
		delay(10);
		b++;
		a++;
	}
	return 1;
}


/* sendCommand(ATcommand, ATcommand_R) - sends any command to GPRS module
 *
 * This function sends any command to GPRS module
 *
 * It stores in 'answer_command' variable the answer returned by the GPRS module
 *
 * Returns '1' on success and '0' if error
*/
uint8_t WaspGPRS::sendCommand(char* ATcommand)
{
	char command[30];
	uint8_t timeout=0;
	uint8_t i=0;
	
	answer_command[0]='\0';
	sprintf(command, "AT%s%c%c", ATcommand,'\r','\n');

	serialFlush(PORT_USED);
	USB.print('d');
	while(!serialAvailable(PORT_USED)) {
		printString(command,PORT_USED);
		delay(DELAY_ON_SEND);
		USB.print('e');
	}
	USB.print('a');
	while( timeout < 5 )
	{
		while(!serialAvailable(PORT_USED) && timeout < 5) {
			timeout++;
			delay(1000);
		}
		USB.print('b');
		while(serialAvailable(PORT_USED) && timeout < 5){
			answer_command[i] = serialRead(PORT_USED);
			delay(20);
			i++;
			timeout=0;
			if(i>=199) timeout=5;
		}
		USB.print('c');
	}
	answer_command[i]='\0';
	if( i<5 ) return 0;
	return 1;
}

/* sendMail() - sends an email
 *
 * This function sends an email
 *
 * Returns '1' on success and '0' if error
*/
uint8_t WaspGPRS::sendMail(char* from, char* to, char* subject, char* body, char* user, char* passw, char* smtp_server, uint16_t port)
{
	uint8_t counter=0;
	char command[30];
	long previous=0;
	uint8_t answer=0;
	
	if(!setFlowControl()) return 0;
		
	if(!configureGPRS()) return 0;
		
	if(!setEmailParams(smtp_server, port, from)) return 0;
		
	if(!setEmailPwd(user, passw)) return 0;
		
	if(!setEmailDestination(to)) return 0;
		
	if(!setEmailSubject(subject)) return 0;
		
	while( body[counter]!='\0' ) counter++;
	counter+=2;
	
	serialFlush(PORT_USED);
	sprintf(command,"AT%s1,%u%c%c",AT_SMTP_SEND,counter,'\r','\n');
	printString(command,PORT_USED);
	previous=millis();
	while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<10000) );
	delay(10);
	answer=waitForData("CONNECT",20,0,0);
	if(answer!=1) return 0;
	
	printString(body,PORT_USED);
	printByte('\r',PORT_USED);
	printByte('\n',PORT_USED);
	
	previous=millis();
	while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<10000) );
	delay(10);
	answer=waitForData("OK",20,0,0);
	if(answer!=1) return 0;
	
	
	return 1;

}

/* readMail() - reads an email
 *
 * This function reads an email
 *
 * Returns '1' on success and '0' if error
*/
uint8_t WaspGPRS::readMail(char* user, char* passw, char* pop3_server, uint16_t port)
{
	char command[70];
	long previous=0;
	uint8_t answer=0;
	char aux='"';
	uint16_t index=0;
	uint16_t i=0;
	uint8_t end=0;
	char* aux2;
	uint8_t j=0;
	
	if(!setFlowControl()) return 0;
		
	if(!configureGPRS()) return 0;
	
	// Connect to POP3 Server
	sprintf(command,"AT%s%c%s%c,%u,%c%s%c,%c%s%c%c%c",AT_POP3_PARAM,aux,pop3_server,aux,port,aux,user,aux,aux,passw,aux,'\r','\n');
	printString(command,PORT_USED);
	previous=millis();
	while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<10000) );
	delay(10);
	answer=waitForData("OK",20,0,0);
	if(answer!=1) return 0;
	
	
	// Get the index
	printString(AT_POP3_LIST,PORT_USED);
	printByte('\r',PORT_USED);
	printByte('\n',PORT_USED);
	previous=millis();
	while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<10000) );
	delay(10);
	answer=waitForData("+KPOPLIST:",20,0,0);
	if(answer!=1) return 0;
	i=0;
	while( serialRead(PORT_USED)!=':' );
	serialRead(PORT_USED);
	index=serialRead(PORT_USED);
	serialFlush(PORT_USED);
		
	// Read the email
	printString(AT_POP3_READ,PORT_USED);
	printByte(index,PORT_USED);
	printByte('\r',PORT_USED);
	printByte('\n',PORT_USED);
	previous=millis();
	while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<10000) );
	
	aux2 = (char*) calloc(MAX_SIZE_POP3,sizeof(char));
	if( aux2==NULL ) return 0;
	
	previous=millis();
	i=0;
	while( millis()-previous<5000 )
	{
		while( serialAvailable(PORT_USED) && i<MAX_SIZE_POP3 )
		{
			aux2[i]=serialRead(PORT_USED);
			i++;
			previous=millis();
		}
	}
	if( i>=MAX_SIZE_POP3 ) aux2[i-1]='\0';
	else aux2[i]='\0';
	
	
	i=0;
	j=0;
	i=waitForData(aux2,"Return-path: <");
	
	emailAddress[j]=aux2[i];
	while( emailAddress[j]!='>' && i!=0 )
	{
		i++;
		j++;
		emailAddress[j]=aux2[i];
		if(j>=30) break;
	}
	emailAddress[j]='\0';
	
	
	i=0;
	j=0;
	i=waitForData(aux2,"ubject: ");
	
	subject[j]=aux2[i];
	while( subject[j]!='\r' && i!=0 )
	{
		i++;
		j++;
		subject[j]=aux2[i];
		if(j>=30) break;
	}
	subject[j]='\0';
	i=0;
	j=0;
	
	i=waitForData(aux2,"*/*");
	while( j<=GPRS_MAX_DATA && !end && i!=0 )
	{
		body[j]=aux2[i];
		if( body[j]=='*' )
		{
			j++;
			i++;
			body[j]=aux2[i];
			if( body[j]=='/' )
			{
				j++;
				i++;
				body[j]=aux2[i];
				if( body[j]=='*' )
				{
					j++;
					i++;
					body[j]='\0';
					end=1;
				}
			}
		}
		j++;
		i++;
	}
	body[j-1]='\0';
	i=0;
	
	free(aux2);
	aux2=NULL;
	return 1;
}


/* uploadFile() - uploads a file to a FTP server
 *
 * This function uploads a file to a FTP server
 *
 * Returns '1' on success and '0' if error
*/
uint8_t WaspGPRS::uploadFile(char* file, char* path, char* user, char* passw, char* ftp_server, uint8_t ftp_port)
{
	char command[100];
	long previous=0;
	uint8_t answer=0;
	char aux='"';
	uint16_t index=0;
	uint16_t i=0;
	uint8_t end=0;
	char* aux2;
	uint8_t j=0;
	uint8_t id=0;
	
	if(!setFlowControl()) return 0;
			
	if(!configureGPRS()) return 0;
		
	// Connect to FTP Server
	sprintf(command,"AT%s,%c%s%c,%c%s%c,%c%s%c,%u,1%c%c",AT_FTP_PARAM,aux,ftp_server,aux,aux,user,aux,aux,passw,aux,ftp_port,'\r','\n');
	printString(command,PORT_USED);
	previous=millis();
	while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<10000) );
	delay(10);
	answer=waitForData("+KFTPCFG: ",20,0,0);
	if(answer!=1) return 0;
		
	id=serialRead(PORT_USED);
	
	if( !sendDataFTP(file, path,id) ) return 0;
	
	return 1;
}


/* uploadFile() - uploads a file to a FTP server
 *
 * This function uploads a file to a FTP server
 *
 * Returns '1' on success and '0' if error
*/
uint8_t WaspGPRS::downloadFile(char* file, char* path, char* user, char* passw, char* ftp_server, uint8_t ftp_port)
{
	char command[70];
	long previous=0;
	uint8_t answer=0;
	char aux='"';
	uint16_t index=0;
	uint16_t i=0;
	uint8_t end=0;
	char* aux2;
	uint8_t j=0;
	uint8_t id=0;
	
	if(!setFlowControl()) return 0;
			
	if(!configureGPRS()) return 0;
		
	// Connect to FTP Server
	sprintf(command,"AT%s,%c%s%c,%c%s%c,%c%s%c,%u,1%c%c",AT_FTP_PARAM,aux,ftp_server,aux,aux,user,aux,aux,passw,aux,ftp_port,'\r','\n');
	printString(command,PORT_USED);
	previous=millis();
	while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<10000) );
	delay(10);
	answer=waitForData("+KFTPCFG: ",20,0,0);
	if(answer!=1) return 0;
		
	id=serialRead(PORT_USED);
	
	if( !readDataFTP(file, path, id) ) return 0;
	
	return 1;
}


/* closeFTP() - closes the FTP
 *
 * This function closes the FTP
 *
 * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
 *
 * Returns '1' on success and '0' if error
*/
uint8_t WaspGPRS::closeFTP()
{
	char command[30];
	long previous=0;
	uint8_t answer=0;
	uint8_t byteIN=0;
        uint8_t i=0;
        
        setInfoIncomingCall();
        flag &= ~(GPRS_ERROR_CLOSE);
	sprintf(command,"%s0",AT_FTP_CLOSE);	

	answer=sendATCommand(command,AT_FTP_CLOSE_R);
	switch(answer)
	{
		case	0	:	flag |= GPRS_ERROR_CLOSE;
					break;
		case	2	:	flag |= GPRS_ERROR_CLOSE;
					break;
	}
	if(flag & GPRS_ERROR_CLOSE) return 0;
	return 1;
}


/* reset() - resets the GPRS module
 *
 * This function resets the GPRS module
 *
 * Returns '1' on success and '0' if error
*/
uint8_t	WaspGPRS::reset()
{
	char command[20];
	flag &= ~(GPRS_ERROR_PIN);
	uint8_t answer=0;

	sprintf(command,"%s\r\n",RESET_GPRS);
	answer=sendATCommand(command,RESET_GPRS_R,SEND_ONCE);
	switch(answer)
	{
		case	0	:	flag |= GPRS_ERROR_PIN;
					break;
		case	2	:	flag |= GPRS_ERROR_PIN;
					break;
	}
	if(flag & GPRS_ERROR_PIN) return 0;
	return 1;
}


/* getIMEI() - gets the IMEI from the SIM card
 *
 * This function gets the IMEI from the SIM card. It stores the IMEI into 'IMEI' variable.
 *
 * Returns '1' on success and '0' if error
*/
uint8_t WaspGPRS::getIMEI()
{
	char command[15];
	uint8_t byteIN[20];
	long previous=millis();
	uint8_t a,b=0;
	
	serialFlush(PORT_USED);
	sprintf(command,"%s\r\n",AT_GPRS_IMEI);
	printString(command,PORT_USED);
	while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<3000) );
	previous=millis();
	a=0;
	while( (millis()-previous) < 2000 )
	{
		while( serialAvailable(PORT_USED) && (millis()-previous) < 2000 && (a<20) )
		{
			byteIN[a]=serialRead(PORT_USED);
			a++;
		}
	}
	a=0;

		while( (byteIN[a]!='\r') && (byteIN[a]!='\n') && (a<20) )
		{
			a++;
		}
		if(a>=20) return 0;
		a++;

	if(a>=20) return 0;

	b=0;
	while( (byteIN[a]!='\r') && (a<20) )
	{
		IMEI[b]=byteIN[a];
		a++;
		b++;
	}
	IMEI[b]='\0';
	if(b<=10) return 0;
	return 1;
}


/* getIMSI() - gets the IMSI from the SIM card
 *
 * This function gets the IMSI from the SIM card. It stores the IMSI into 'IMSI' variable.
 *
 * Returns '1' on success and '0' if error
*/
uint8_t WaspGPRS::getIMSI()
{
	char command[15];
	uint8_t byteIN[20];
	long previous=millis();
	uint8_t a,b=0;
	
	serialFlush(PORT_USED);
	sprintf(command,"%s\r\n",AT_GPRS_IMSI);
	printString(co…