WaspmoteAPI: WaspGPRS.cpp Source File

00001 /*
00002  *  Copyright (C) 2009 Libelium Comunicaciones Distribuidas S.L.
00003  *  http://www.libelium.com
00004  *
00005  *  This program is free software: you can redistribute it and/or modify
00006  *  it under the terms of the GNU Lesser General Public License as published by
00007  *  the Free Software Foundation, either version 2.1 of the License, or
00008  *  (at your option) any later version.
00009    
00010  *  This program is distributed in the hope that it will be useful,
00011  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
00012  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00013  *  GNU Lesser General Public License for more details.
00014   
00015  *  You should have received a copy of the GNU Lesser General Public License
00016  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
00017  *
00018  *  Version:            0.6
00019  *  Design:             David Gascón
00020  *  Implementation:     Alberto Bielsa, David Cuartielles
00021  */
00022   
00023 
00024 #ifndef __WPROGRAM_H__
00025 //  #include <WProgram.h>
00026   #include <WaspClasses.h>
00027 #endif
00028 
00029 // Constructors ////////////////////////////////////////////////////////////////
00030 
00031 WaspGPRS::WaspGPRS()
00032 {
00033         _baudRate=XBEE_RATE;
00034         _pwrMode=GPRS_ON;
00035         _uart=1;
00036         not_ready=1;
00037 }
00038 
00039 
00040 // Private Methods /////////////////////////////////////////////////////////////
00041 
00042 /* setPattern(pattern) - sets pattern to use in sending and receiving messages
00043  *
00044  * This function sets pattern to use in sending and receiving messages
00045  *
00046  * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
00047  *
00048  * Returns '1' on success and '0' if error
00049 */
00050 uint8_t WaspGPRS::setPattern(const char* pattern)
00051 {
00052         char command[25];
00053         char aux='"';
00054         uint8_t answer=0;
00055         
00056         flag &= ~(GPRS_ERROR_PATTERN);
00057         
00058         sprintf(command,"%s%c%s%c",AT_GPRS_PATTERN,aux,pattern,aux);
00059         
00060         answer=sendATCommand(command,AT_GPRS_PATTERN_R);
00061         switch(answer)
00062         {
00063                 case    0       :       flag |= GPRS_ERROR_PATTERN;
00064                                         return 0;
00065                                         break;
00066                 case    2       :       flag |= GPRS_ERROR_PATTERN;
00067                                         return 0;
00068                                         break;
00069         }
00070         if(flag) return 0;
00071         return 1;
00072 }
00073 
00074 /* setConnectionTimer() - sets GPRS connection time out
00075  *
00076  * This function sets GPRS connection time out
00077  *
00078  * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
00079  *
00080  * Returns '1' on success and '0' if error
00081 */
00082 uint8_t WaspGPRS::setConnectionTimer()
00083 {
00084         char command[25];
00085         char aux='"';
00086         uint8_t answer=0;
00087         
00088         flag &= ~(GPRS_ERROR_TIMER);
00089         
00090         sprintf(command,"%s0,120,2,120",AT_GPRS_CNX_TIMER);
00091         
00092         answer=sendATCommand(command,AT_GPRS_CNX_TIMER_R);
00093         switch(answer)
00094         {
00095                 case    0       :       flag |= GPRS_ERROR_TIMER;
00096                                         return 0;
00097                                         break;
00098                 case    2       :       flag |= GPRS_ERROR_TIMER;
00099                                         return 0;
00100                                         break;
00101         }
00102         if(flag) return 0;
00103         return 1;
00104 }
00105 
00106 
00107 /* checkGPRS() - checks if GPRS connection is OK
00108  *
00109  * This function checks if GPRS connection is OK
00110  *
00111  * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
00112  *
00113  * Returns '1' on success and '0' if error
00114 */
00115 uint8_t WaspGPRS::checkGPRS()
00116 {
00117         char command[25];
00118         char aux='"';
00119         uint8_t answer=0;
00120         
00121         flag &= ~(GPRS_ERROR_CHECK);
00122                 
00123         answer=sendATCommand(AT_GPRS_CHECK,AT_GPRS_CHECK_R);
00124         switch(answer)
00125         {
00126                 case    0       :       flag |= GPRS_ERROR_CHECK;
00127                                         return 0;
00128                                         break;
00129                 case    2       :       flag |= GPRS_ERROR_CHECK;
00130                                         return 0;
00131                                         break;
00132         }
00133         if(flag) return 0;
00134         return 1;
00135 }
00136 
00137 
00138 /* setConnectionProfile() - sets GPRS connection profile
00139  *
00140  * This function sets GPRS connection profile
00141  *
00142  * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
00143  *
00144  * Returns '1' on success and '0' if error
00145 */
00146 uint8_t WaspGPRS::setConnectionProfile()
00147 {
00148         char command[25];
00149         char aux='"';
00150         uint8_t answer=0;
00151         
00152         flag &= ~(GPRS_ERROR_PROFILE);
00153                 
00154         answer=sendATCommand(AT_GPRS_CNX_PROFILE,AT_GPRS_CNX_PROFILE_R);
00155         switch(answer)
00156         {
00157                 case    0       :       flag |= GPRS_ERROR_PROFILE;
00158                                         return 0;
00159                                         break;
00160                 case    2       :       flag |= GPRS_ERROR_PROFILE;
00161                                         return 0;
00162                                         break;
00163         }
00164         if(flag) return 0;
00165         return 1;
00166 }
00167 
00168 /* setFlowControl() - sets GPRS flow control
00169  *
00170  * This function sets GPRS flow control
00171  *
00172  * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
00173  *
00174  * Returns '1' on success and '0' if error
00175 */
00176 uint8_t WaspGPRS::setFlowControl()
00177 {
00178         char command[25];
00179         char aux='"';
00180         uint8_t answer=0;
00181         
00182         flag &= ~(GPRS_ERROR_PROFILE);
00183                 
00184         answer=sendATCommand(AT_GPRS_K3,AT_GPRS_K3_R);
00185         switch(answer)
00186         {
00187                 case    0       :       flag |= GPRS_ERROR_SMTP;
00188                                         return 0;
00189                                         break;
00190                 case    2       :       flag |= GPRS_ERROR_SMTP;
00191                                         return 0;
00192                                         break;
00193         }
00194         if(flag) return 0;
00195         return 1;
00196 }
00197 
00198 
00199 /* writeData(data,start) - writes data to send
00200  *
00201  * This function writes data to send
00202  *
00203  * Returns '1' on success and '0' if error
00204 */
00205 uint8_t WaspGPRS::writeData(const char* data)
00206 {
00207         char command[GPRS_MAX_DATA+15];
00208         
00209         sprintf(command,"%s%c%c%s",data,'\r','\n',GPRS_PATTERN);
00210         printString(command,PORT_USED);
00211 }
00212 
00213 
00214 /* parse_GSM(data) - parses GSM string and specifies if it is a call or an sms
00215  *
00216  * This function writes data to send
00217  *
00218  * Returns '0' on GSM incoming call, '1' on GSM incoming SMS, '2' if error
00219 */
00220 uint8_t WaspGPRS::parse_GSM(char* data)
00221 {
00222         uint8_t a=0;
00223         char cmp[5];
00224         
00225         while( (data[a]!='+') && (a<=45) ){
00226                 a++;
00227         }
00228         a++;
00229         for(int b=0;b<4;b++)
00230         {
00231                 cmp[b]=data[a];
00232                 a++;
00233         }
00234         cmp[4]='\0';
00235         if(!strcmp(cmp,"CLIP")) return 0;
00236         if(!strcmp(cmp,"CMTI")) return 1;
00237         return 2;
00238 }
00239 
00240 /* setEmailParams(smtp_server, port, to) - sets the email parameters
00241  *
00242  * This function sets the email parameters
00243  *
00244  * Returns '1' on success and '0' if error
00245 */
00246 uint8_t WaspGPRS::setEmailParams(char* smtp_server, uint16_t port, char* to)
00247 {
00248         char command[100];
00249         char aux='"';
00250         uint8_t answer=0;
00251         
00252         sprintf(command,"%s%c%s%c,%u,%c%s%c",AT_SMTP_PARAM,aux,smtp_server,aux,port,aux,to,aux);
00253         answer=sendATCommand(command,AT_SMTP_PARAM_R);
00254         switch(answer)
00255         {
00256                 case    0       :       flag |= GPRS_ERROR_SMTP;
00257                                         return 0;
00258                                         break;
00259                 case    2       :       flag |= GPRS_ERROR_SMTP;
00260                                         return 0;
00261                                         break;
00262         }
00263         if(flag) return 0;
00264         return 1;
00265 }
00266 
00267 /* setEmailPwd(user, pwd) - sets the email user and password
00268  *
00269  * This function sets the email user and password
00270  *
00271  * Returns '1' on success and '0' if error
00272 */
00273 uint8_t WaspGPRS::setEmailPwd(char* user, char* pwd)
00274 {
00275         char command[100];
00276         char aux='"';
00277         uint8_t answer=0;
00278         
00279         sprintf(command,"%s%c%s%c,%c%s%c",AT_SMTP_PWD,aux,user,aux,aux,pwd,aux);
00280         answer=sendATCommand(command,AT_SMTP_PWD_R);
00281         switch(answer)
00282         {
00283                 case    0       :       flag |= GPRS_ERROR_SMTP;
00284                                         return 0;
00285                                         break;
00286                 case    2       :       flag |= GPRS_ERROR_SMTP;
00287                                         return 0;
00288                                         break;
00289         }
00290         if(flag) return 0;
00291         return 1;
00292 }
00293 
00294 /* setEmailDestination(destination) - sets the email destination
00295  *
00296  * This function sets the email destination
00297  *
00298  * Returns '1' on success and '0' if error
00299 */
00300 uint8_t WaspGPRS::setEmailDestination(char* destination)
00301 {
00302         char command[50];
00303         char aux='"';
00304         uint8_t answer=0;
00305         
00306         sprintf(command,"%s%c%s%c",AT_SMTP_TO,aux,destination,aux);
00307         answer=sendATCommand(command,AT_SMTP_TO_R);
00308         switch(answer)
00309         {
00310                 case    0       :       flag |= GPRS_ERROR_SMTP;
00311                                         return 0;
00312                                         break;
00313                 case    2       :       flag |= GPRS_ERROR_SMTP;
00314                                         return 0;
00315                                         break;
00316         }
00317         if(flag) return 0;
00318         return 1;
00319 }
00320 
00321 /* setEmailSubject(subject) - sets the email subject
00322  *
00323  * This function sets the email subject
00324  *
00325  * Returns '1' on success and '0' if error
00326 */
00327 uint8_t WaspGPRS::setEmailSubject(char* subject)
00328 {
00329         char command[50];
00330         char aux='"';
00331         uint8_t answer=0;
00332         
00333         sprintf(command,"%s%c%s%c",AT_SMTP_SUBJECT,aux,subject,aux);
00334         answer=sendATCommand(command,AT_SMTP_SUBJECT_R);
00335         switch(answer)
00336         {
00337                 case    0       :       flag |= GPRS_ERROR_SMTP;
00338                                         return 0;
00339                                         break;
00340                 case    2       :       flag |= GPRS_ERROR_SMTP;
00341                                         return 0;
00342                                         break;
00343         }
00344         if(flag) return 0;
00345         return 1;
00346 }
00347 
00348 
00349 // AT Comands ///////////////////////////////////////////////////////////////////
00350 
00351 byte WaspGPRS::sendATCommand(char* ATcommand, char* expectedAnswer) {
00352     return sendATCommand(ATcommand, expectedAnswer, 0);
00353 }
00354   
00355 byte WaspGPRS::sendATCommand(char* ATcommand, char* expectedAnswer, int sendOnce) {
00356   // command style: +CMGS=0736584317
00357   // this means, we gotta add the "AT"
00358 
00359     sprintf(theCommand, "AT%s", ATcommand);
00360     return sendCommand(theCommand, "\r\n", expectedAnswer, sendOnce);
00361 }
00362 
00363 byte WaspGPRS::sendCommand(char* theText, int endOfCommand, char* expectedAnswer) {
00364     return sendCommand(theText, endOfCommand, expectedAnswer, 0);
00365 }
00366 
00367 byte WaspGPRS::sendCommand(char* theText, int endOfCommand, char* expectedAnswer, int MAX_TIMEOUT, int sendOnce) {
00368     sprintf(theEnd, "%c", endOfCommand);
00369     return sendCommand(theText, theEnd, expectedAnswer, MAX_TIMEOUT, sendOnce);
00370 }
00371 
00372 byte WaspGPRS::sendCommand(char* theText, int endOfCommand, char* expectedAnswer, int sendOnce) {
00373     sprintf(theEnd, "%c", endOfCommand);
00374     return sendCommand(theText, theEnd, expectedAnswer, sendOnce);
00375 }
00376 
00377 byte WaspGPRS::sendCommand(char* theText, char endOfCommand, char* expectedAnswer) {
00378     return sendCommand(theText, (int) endOfCommand, expectedAnswer, 0);
00379 }
00380 
00381 byte WaspGPRS::sendCommand(char* theText, char endOfCommand, char* expectedAnswer, int MAX_TIMEOUT) {
00382     return sendCommand(theText, (int) endOfCommand, expectedAnswer, MAX_TIMEOUT, 0);
00383 }
00384 
00385 byte WaspGPRS::sendCommand(char* theText, char endOfCommand, char* expectedAnswer, int MAX_TIMEOUT, int sendOnce) {
00386     return sendCommand(theText, (int) endOfCommand, expectedAnswer, MAX_TIMEOUT, sendOnce);
00387 }
00388 
00389 byte WaspGPRS::sendCommand(char* theText, char* endOfCommand, char* expectedAnswer) {
00390     return sendCommand(theText, endOfCommand, expectedAnswer, DEFAULT_TIMEOUT, 0);
00391 }
00392 
00393 byte WaspGPRS::sendCommand(char* theText, char* endOfCommand, char* expectedAnswer, int sendOnce) {
00394     return sendCommand(theText, endOfCommand, expectedAnswer, DEFAULT_TIMEOUT, sendOnce);
00395 }
00396 
00397 byte WaspGPRS::sendCommand(char* theText, char* endOfCommand, char* expectedAnswer, int MAX_TIMEOUT, int sendOnce) {
00398     int timeout = 0;
00399 
00400     for (int i = 0; i < 100; i++) received[i] = ' ';
00401 
00402     int length=sprintf(theCommand, "%s%s", theText,endOfCommand);
00403     
00404 
00405   // try sending the command
00406   // wait for serial response
00407     timeout = 0;
00408     serialFlush(PORT_USED);
00409     while(!serialAvailable(PORT_USED) && timeout < MAX_TIMEOUT) {
00410         if (!sendOnce || !timeout) {
00411             printString(theCommand,PORT_USED);
00412         }
00413         delay(DELAY_ON_SEND);
00414         timeout++;
00415     };
00416 
00417     int answer= waitForData( expectedAnswer, MAX_TIMEOUT, timeout, 0);
00418 
00419     return answer;
00420 }
00421 
00422 
00423 byte WaspGPRS::waitForData(char* expectedAnswer, int MAX_TIMEOUT, int timeout, int seconds) {
00424 
00425         for (int i = 0; i < 100; i++) received[i] = ' ';
00426 
00427         char command[50];
00428         int theLength = 0;
00429         int it=0;
00430         bool theSame=false;
00431         bool errorAnswer=false;
00432         int inbyte=0;
00433         byte countLetters = 0;
00434         char* errorCommand="ERROR";
00435         uint8_t errorLength=5;
00436         
00437         uint8_t first=1;
00438         uint8_t match=0;
00439     
00440         while( expectedAnswer[theLength]!='\0' ) theLength++;
00441                 
00442         // if there is a heating time, then wait to see if you got
00443         // any data from the serial port
00444         while (seconds >0) {
00445                 delay(1000);
00446                 seconds--;
00447         }
00448                 
00449         while(timeout < MAX_TIMEOUT) {
00450                 while(!serialAvailable(PORT_USED) && timeout < MAX_TIMEOUT) {
00451                         timeout++;
00452                         delay(1000);
00453                 }
00454                 
00455                 while( serialAvailable(PORT_USED) && !match )
00456                 {
00457                         if( first )
00458                         {
00459                                 for(it=0;it<theLength;it++)
00460                                 {
00461                                         received[it]=serialRead(PORT_USED);
00462                                 }
00463                                 first=0;
00464                         }
00465                         it=0;
00466                         
00467                         if( serialAvailable(PORT_USED) )
00468                         {
00469                                 theSame=true;
00470                                 for(it=0; it<theLength ; it++)
00471                                 {
00472                                         if(received[it]!=expectedAnswer[it]){
00473                                                 theSame= false;
00474                                                 break;
00475                                         }
00476                                 }
00477                                 if( theSame ){
00478                                         match=1;
00479                                         return 1;
00480                                 }
00481                                 else
00482                                 {
00483                                         for(it=0; it<theLength-1 ; it++)
00484                                         {
00485                                                 received[it]=received[it+1];
00486                                         }
00487                                         received[it]=serialRead(PORT_USED);
00488                                 }
00489                         }
00490                 }
00491         }
00492         if( match ) return 1;
00493         else return 0;
00494 }
00495 
00496 uint16_t WaspGPRS::waitForData(char* data, char* expectedAnswer)
00497 {
00498         uint16_t i=0;
00499         for (i = 0; i < 100; i++) received[i] = ' ';
00500 
00501         int theLength = 0;
00502         int it=0;
00503         bool theSame=false;
00504         
00505         uint8_t first=1;
00506         uint8_t match=0;
00507         i=0;
00508     
00509         while( expectedAnswer[theLength]!='\0' ) theLength++;
00510         
00511         while( !match && data[i]!='\0' )
00512         {
00513                 if( first )
00514                 {
00515                         for(it=0;it<theLength;it++)
00516                         {
00517                                 received[it]=data[i];
00518                                 i++;
00519 
00520                         }
00521                         first=0;
00522                 }
00523                 it=0;
00524                 theSame=true;
00525                 for(it=0; it<theLength ; it++)
00526                 {
00527                         if(received[it]!=expectedAnswer[it]){
00528                                 theSame= false;
00529                                 break;
00530                         }
00531                 }
00532                 if( theSame ) match=1;
00533                 else
00534                 {
00535                         for(it=0; it<theLength-1 ; it++)
00536                         {
00537                                 received[it]=received[it+1];
00538                         }
00539                         received[it]=data[i];
00540                         i++;
00541                 }
00542         }
00543         
00544         if( !match ) i=0;
00545         return i;
00546 }
00547 
00548 uint8_t WaspGPRS::sendDataFTP(char* file, char* path, uint8_t id)
00549 {
00550         char command[50];
00551         char aux='"';
00552         long previous=0;
00553         uint8_t answer=0;
00554         uint8_t end=0;
00555         uint32_t i,j=0;
00556                 
00557         sprintf(command,"AT%s%c,,%c%c,%c%s%c,0%c%c", AT_FTP_SEND, id, aux, aux, aux, file, aux, '\r', '\n');
00558         printString(command,PORT_USED);
00559         previous=millis();
00560         while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<10000) );
00561         delay(10);
00562         answer=waitForData("CONNECT",20,0,0);
00563         if(answer!=1) return 0;
00564                 
00565         serialFlush(PORT_USED);
00566         
00567         SD.begin();
00568         SD.setMode(SD_ON);
00569         SD.init();
00570         Utils.strExplode(path,'/');
00571         while( path[i]!='\0' )
00572         {
00573                 if( path[i]== '/' ) j++;
00574                 i++;
00575         }
00576         i=0;
00577         while( j>0 )
00578         {
00579                 if(!SD.cd(Utils.arguments[i])) return 0;
00580                 i++;
00581                 j--;
00582         }
00583         i=0;
00584         j=0;
00585         while( !end )
00586         {
00587                 printString(SD.cat(file,250*i,250),PORT_USED);
00588                 while( SD.buffer[j]!='\0' ) j++;
00589                 if( j<249 ) end=1;
00590                 i++;
00591                 j=0;
00592         }
00593         printString(GPRS_PATTERN,PORT_USED);
00594         
00595         SD.close();
00596         SD.setMode(SD_OFF);
00597         
00598         previous=millis();
00599         while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<10000) );
00600         delay(10);
00601         answer=waitForData("OK",20,0,0);
00602         if(answer!=1) return 0;
00603         
00604         return 1;       
00605 }
00606 
00607 
00608 uint8_t WaspGPRS::readDataFTP(char* file, char* path, uint8_t id)
00609 {
00610         char command[50];
00611         char aux='"';
00612         long previous=0;
00613         uint8_t answer=0;
00614         uint8_t end=0;
00615         int i,j=0;
00616         uint8_t timeout=0;
00617         uint8_t MAX_TIMEOUT=10;
00618         char* aux2;
00619         uint16_t length=0;
00620                 
00621         sprintf(command,"AT%s%c,,%c%c,%c%s%c,0%c%c", AT_FTP_RECV, id, aux, aux, aux, file, aux, '\r', '\n');
00622         printString(command,PORT_USED);
00623         previous=millis();
00624         while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<10000) );
00625         delay(10);
00626         answer=waitForData("CONNECT",30,0,0);
00627         if(answer!=1){
00628                 free(aux2);
00629                 aux2=NULL; 
00630                 return 0;
00631         }
00632         
00633         delay(20);
00634         while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<10000) );
00635         
00636         aux2 = (char*) calloc(MAX_SIZE_FTP,sizeof(char));
00637         if( aux2==NULL ) return 0;
00638         
00639         serialRead(PORT_USED);
00640         serialRead(PORT_USED);
00641         previous=millis();
00642         i=0;
00643         while( millis()-previous<5000 )
00644         {
00645                 while( serialAvailable(PORT_USED) && i<MAX_SIZE_FTP )
00646                 {
00647                         aux2[i]=serialRead(PORT_USED);
00648                         i++;
00649                         previous=millis();
00650                 }
00651         }
00652         if( i>=MAX_SIZE_FTP ) aux2[i-1]='\0';
00653         else aux2[i]='\0';
00654 
00655         length=waitForData(aux2,GPRS_PATTERN);
00656         if( !length ) length=i;
00657         else
00658         {
00659                 j=Utils.sizeOf(GPRS_PATTERN);
00660                 length-=j;
00661         }
00662         
00663         i=0;
00664         j=0;
00665         SD.begin();
00666         SD.setMode(SD_ON);
00667         SD.init();
00668         Utils.strExplode(path,'/');
00669         while( path[i]!='\0' )
00670         {
00671                 if( path[i]== '/' ) j++;
00672                 i++;
00673         }
00674         i=0;
00675         while( j>0 )
00676         {
00677                 if(!SD.cd(Utils.arguments[i])){
00678                         SD.close();
00679                         SD.setMode(SD_OFF);
00680                         free(aux2);
00681                         aux2=NULL; 
00682                         return 0;
00683                 }
00684                 i++;
00685                 j--;
00686         }
00687         SD.create(Utils.arguments[i]);
00688         
00689         if(!SD.append(Utils.arguments[i],aux2,length)){
00690                 SD.close();
00691                 SD.setMode(SD_OFF);
00692                 free(aux2);
00693                 aux2=NULL; 
00694                 return 0;
00695         }
00696         
00697         SD.ls();
00698         
00699         SD.close();
00700         SD.setMode(SD_OFF);
00701         
00702         free(aux2);
00703         aux2=NULL;
00704         return 1;       
00705 }
00706 
00707 /* getIfReady() - gets if GPRS module is ready or not
00708  *
00709  * This function gets if GPRS module is ready or not
00710  *
00711  * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
00712  *
00713  * Returns nothing. It changes the value of 'not_ready'
00714 */
00715 void    WaspGPRS::getIfReady()
00716 {
00717         char command[20];
00718         char aux='"';
00719         uint8_t answer=0;
00720         long previous=0;
00721         
00722         printString(AT_COMMAND,PORT_USED);
00723         printByte('\r',PORT_USED);
00724         printByte('\n',PORT_USED);
00725 /*      while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<3000) );*/
00726         delay(10);
00727         answer=waitForData("OK",2,0,0);
00728         if(answer==1) not_ready=0;
00729         else not_ready=1;
00730 }
00731 
00732 
00733 // Public Methods //////////////////////////////////////////////////////////////
00734 
00735 /* ON(void) - opens UART1 and powers the GPRS module
00736  *
00737  * It opens UART1 and powers the GPRS module
00738  *
00739  * Returns nothing
00740 */
00741 void WaspGPRS::ON()
00742 {
00743         begin();
00744         setMode(GPRS_ON);
00745 }
00746 
00747 
00748 /* begin(void) - initialize GPRS module
00749  *
00750  * This function powers up the GPRS module and open Serial Port at velocity selected by the user
00751  * By default, it will be at 38400bps
00752  *
00753  * Returns nothing
00754 */
00755 void WaspGPRS::begin()
00756 {
00757         _baudRate=GPRS_RATE;
00758         Utils.setMuxGPRS();
00759         beginSerial(_baudRate,_uart);
00760 }
00761 
00762 
00763 /* close(void) - closes UART used by GPRS module
00764  *
00765  * This function closes UART used by GPRS module
00766  *
00767  * Returns nothing
00768 */
00769 void WaspGPRS::close()
00770 {
00771         closeSerial(_uart);
00772         Utils.setMux(MUX_TO_LOW,MUX_TO_LOW);
00773 }
00774 
00775 /* OFF(void) - closes UART1 and powers off the GPRS module
00776  *
00777  * This function closes UART1 and powers off the GPRS module
00778  *
00779  * Returns nothing
00780 */
00781 void WaspGPRS::OFF()
00782 {
00783         close();
00784         setMode(GPRS_HIBERNATE);
00785 }
00786 
00787 
00788 /* setMode(uint8_t) - Sets GPRS Power Mode
00789  *
00790  * This function selects the active power mode among: ON, SLEEP/HIBERNATE and OFF
00791  * It does not close the serial port, only sends the proper command to GPRS module
00792  *
00793  * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
00794  *
00795  * Returns '1' on success and '0' if error
00796 */
00797 uint8_t WaspGPRS::setMode(uint8_t pwrMode)
00798 {
00799         _pwrMode=pwrMode;
00800         flag &= ~(GPRS_ERROR_POWER);
00801         uint8_t answer=0;
00802     
00803         switch(_pwrMode)
00804         {
00805                 case    GPRS_ON         :       pinMode(GPRS_PW, OUTPUT);
00806                                                 digitalWrite(GPRS_PW, HIGH);
00807                                                 delay(2000);
00808                                                 digitalWrite(GPRS_PW, LOW);
00809                                                 delay(500);
00810 /*                                              while(not_ready) getIfReady();*/
00811                                                 answer=1;
00812                                                 break;
00813 
00814                 case    GPRS_HIBERNATE  :       answer=sendATCommand(POWER_HIBERNATE,POWER_R);
00815                                                 switch(answer)
00816                                                 {
00817                                                         case    0       :       flag |= GPRS_ERROR_POWER;
00818                                                                                 break;
00819                                                         case    2       :       flag |= GPRS_ERROR_POWER;
00820                                                                                 break;
00821                                                 }
00822                                                 break;
00823 
00824                 case    GPRS_SLEEP      :       answer=sendATCommand(POWER_SLEEP,POWER_R);
00825                                                 switch(answer)
00826                                                 {
00827                                                         case    0       :       flag |= GPRS_ERROR_POWER;
00828                                                                                 break;
00829                                                         case    2       :       flag |= GPRS_ERROR_POWER;
00830                                                                                 break;
00831                                                 }
00832                                                 break;
00833 
00834         }
00835         return answer;
00836 }
00837 
00838 
00839 /* getMode(void) - Gets GPRS Power Mode
00840  *
00841  * This function gets the actual GPRS Power Mode. Possible values are ON, SLEEP/HIBERNATE and OFF
00842  *
00843  * Returns the power mode
00844 */
00845 uint8_t WaspGPRS::getMode()
00846 {
00847         return  _pwrMode;
00848 }
00849 
00850 
00851 /* check(void) - Checks if GPRS is connected to the network
00852  *
00853  * This function checks if GPRS module is connected to the network. If not, it has no sense working with GPRS.
00854  *
00855  * It sends a command to GPRS module DEFAULT_TIMEOUT times. If GPRS module does not connect within these tries, function
00856  * exits.
00857  *
00858  * Returns '1' when connected and '0' if not
00859 */
00860 uint8_t WaspGPRS::check()
00861 {
00862         char byte;
00863         uint8_t timeout=DEFAULT_TIMEOUT;
00864         char command[10];
00865         uint8_t answer=0;
00866         
00867         while(timeout)
00868         {
00869                 sprintf(command,"%s%c%c","AT+CREG?",'\r','\n');
00870                 printString(command,PORT_USED);
00871                 answer=waitForData("+CREG: 0,1",1,0,0);
00872                 switch(answer){
00873                         case    0:      break;
00874                         case    1:      return 1;
00875                                         break;
00876                         case    2:      break;
00877                 }
00878                 printString(command,PORT_USED);
00879                 answer=waitForData("+CREG: 0,5",1,0,0);
00880                 switch(answer){
00881                         case    0:      break;
00882                         case    1:      return 1;
00883                         break;
00884                         case    2:      break;
00885                 }
00886                 delay(100);
00887                 timeout--;
00888         }
00889         return 0;       
00890 }
00891 
00892 
00893 /* setPIN(const char* pin) - sets PIN to the SIM
00894  *
00895  * This function sets the specified PIN to the SIM
00896  *
00897  * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
00898  *
00899  * Returns '1' on success and '0' if error
00900 */
00901 uint8_t WaspGPRS::setPIN(const char* pin)
00902 {
00903         char command[20];
00904         flag &= ~(GPRS_ERROR_PIN);
00905         char aux='"';
00906         uint8_t answer=0;
00907 
00908         sprintf(command,"%s%c%s%c",AT_PIN,aux,pin,aux);
00909         answer=sendATCommand(command,AT_PIN_R,SEND_ONCE);
00910         switch(answer)
00911         {
00912                 case    0       :       flag |= GPRS_ERROR_PIN;
00913                                         break;
00914                 case    2       :       flag |= GPRS_ERROR_PIN;
00915                                         break;
00916         }
00917         if(flag) return 0;
00918         return 1;
00919 }
00920 
00921 
00922 /* setInfoIncomingCall() - set the info shown when an incoming call is received
00923  *
00924  * This function sets the info shown when an incoming call is received
00925  *
00926  * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
00927  *
00928  * Returns '1' on success and '0' if error
00929  */
00930 uint8_t WaspGPRS::setInfoIncomingCall()
00931 {
00932         char command[20];
00933         flag &= ~(GPRS_ERROR_CALLINFO);
00934         uint8_t answer=0;
00935 
00936         answer=sendATCommand(AT_ID_INCALL,AT_ID_INCALL_R,SEND_ONCE);
00937         switch(answer)
00938         {
00939                 case    0       :       flag |= GPRS_ERROR_CALLINFO;
00940                                         break;
00941                 case    2       :       flag |= GPRS_ERROR_CALLINFO;
00942                                         break;
00943         }
00944         if(flag) return 0;
00945         return 1;
00946 }
00947 
00948 
00949 /* setInfoIncomingSMS() - set the info shown when an incoming SMS is received
00950  *
00951  * This function sets the info shown when an incoming SMS is received
00952  *
00953  * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
00954  *
00955  * Returns '1' on success and '0' if error
00956  */
00957 uint8_t WaspGPRS::setInfoIncomingSMS()
00958 {
00959         char command[20];
00960         flag &= ~(GPRS_ERROR_SMSINFO);
00961         uint8_t answer=0;
00962 
00963         answer=sendATCommand(AT_SMS_INFO,AT_SMS_INFO_R,SEND_ONCE);
00964         switch(answer)
00965         {
00966                 case    0       :       flag |= GPRS_ERROR_SMSINFO;
00967                                         break;
00968                 case    2       :       flag |= GPRS_ERROR_CALLINFO;
00969                                         break;
00970         }
00971         if(flag) return 0;
00972         return 1;
00973 }
00974 
00975 
00976 /* setTextModeSMS() - set the text mode to the sms
00977  *
00978  * This function sets the text mode to the sms
00979  *
00980  * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
00981  *
00982  * Returns '1' on success and '0' if error
00983  */
00984 uint8_t WaspGPRS::setTextModeSMS()
00985 {
00986         char command[20];
00987         flag &= ~(GPRS_ERROR_SMS);
00988         uint8_t answer=0;
00989 
00990         answer=sendATCommand(AT_SMS_MODE,AT_SMS_MODE_R);
00991         switch(answer)
00992         {
00993                 case    0       :       flag |= GPRS_ERROR_SMS;
00994                                         return 0;
00995                                         break;
00996                 case    2       :       flag |= GPRS_ERROR_SMS;
00997                                         return 0;
00998                                         break;
00999         }
01000         if(flag) return 0;
01001         return 1;
01002 }
01003 
01004 
01005 /* makeCall(const char*) - makes a call to the seleted telephone number
01006  *
01007  * This function makes a call to the given telephone number.
01008  *
01009  * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
01010  *
01011  * Returns '1' on success and '0' if error
01012 */
01013 uint8_t WaspGPRS::makeCall(const char* tlfNumber)
01014 {
01015         char    command[30];
01016         flag &= ~(GPRS_ERROR_CALL);
01017         uint8_t answer=0;
01018 
01019         sprintf(command,"%s%s;",AT_CALL,tlfNumber);
01020         answer=sendATCommand(command,AT_CALL_R,SEND_ONCE);
01021         switch(answer)
01022         {
01023                 case    0       :       flag |= GPRS_ERROR_CALL;
01024                                         break;
01025                 case    2       :       flag |= GPRS_ERROR_CALL;
01026                                         break;
01027         }
01028         if(flag) return 0;
01029         return 1;
01030         
01031 }
01032 
01033 
01034 /* makelostCall(const char* , uint8_t) - makes a lost call to the seleted telephone number
01035  *
01036  * This function makes a call to the given telephone number and its duration is specified by the other input.
01037  * After 'timeCall' seconds, hang the call up.
01038  *
01039  * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
01040  *
01041  * Returns '1' on success and '0' if error
01042 */
01043 uint8_t WaspGPRS::makeLostCall(const char* tlfNumber, uint8_t timeCall)
01044 {
01045         char    command[25];
01046         flag &= ~(GPRS_ERROR_CALL);
01047         uint8_t answer=0;
01048 
01049         sprintf(command,"%s%s;",AT_CALL,tlfNumber);
01050         answer=sendATCommand(command,AT_CALL_R,SEND_ONCE);
01051         switch(answer)
01052         {
01053                 case    0       :       flag |= GPRS_ERROR_CALL;
01054                                         break;
01055                 case    1       :       for(int a=0; a<timeCall ; a++) delay(1000);
01056                                         hangUp();
01057                                         break;
01058                 case    2       :       flag |= GPRS_ERROR_CALL;
01059                                         break;
01060         }
01061         if(flag) return 0;
01062         return 1;
01063 }
01064 
01065 
01066 /* hangUp(void) - hangs the call up
01067  *
01068  * This function hangs all the active calls up.
01069  *
01070  * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
01071  *
01072  * Returns '1' on success and '0' if error
01073 */
01074 uint8_t WaspGPRS::hangUp()
01075 {
01076         uint8_t answer=0;
01077         flag &= ~(GPRS_ERROR_HANG);
01078         
01079         answer=sendATCommand(AT_HANG,AT_HANG_R,SEND_ONCE);
01080         switch(answer)
01081         {
01082                 case    0       :       flag |= GPRS_ERROR_HANG;
01083                                         break;
01084                 case    2       :       flag |= GPRS_ERROR_HANG;
01085                                         break;
01086         }
01087         if(flag) return 0;
01088         return 1;
01089 }
01090 
01091 
01092 /* sendSMS(const char*, const char*) - sends an SMS to the specified number
01093  *
01094  * This function sends an SMS to the specified number.
01095  *
01096  * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
01097  *
01098  * Returns '1' on success and '0' if error
01099 */
01100 uint8_t WaspGPRS::sendSMS(const char* smsText, const char* tlfNumber)
01101 {
01102         flag &= ~(GPRS_ERROR_SMS);
01103         flag &= ~(GPRS_ERROR_SMS);
01104         char command[25];
01105         char aux='"';
01106         uint8_t answer=0;
01107 
01108         sprintf(command,"%s%c%s%c",AT_SMS,aux,tlfNumber,aux);
01109 
01110         
01111         //setTextModeSMS();
01112         answer=sendATCommand(command,AT_SMS_R);
01113         switch(answer)
01114         {
01115                 case    0       :       flag |= GPRS_ERROR_SMS;
01116                                         return 0;
01117                                         break;
01118                 case    2       :       flag |= GPRS_ERROR_SMS;
01119                                         return 0;
01120                                         break;
01121         }
01122         
01123         answer=sendCommand((char*)smsText,0x1A,AT_SMS_TEXT_R,20,SEND_ONCE);
01124         switch(answer)
01125         {
01126                 case    0       :       flag |= GPRS_ERROR_SMS;
01127                                         return 0;
01128                                         break;
01129                 case    2       :       flag |= GPRS_ERROR_SMS;
01130                                         return 0;
01131                                         break;
01132         }
01133         
01134         if(flag)        return 0;
01135         return 1;
01136 }
01137 
01138 
01139 /* readCall() - set in 'tlfIN' variable the tlf number of the incoming call
01140  *
01141  * This function sets in 'tlfIN' variable the tlf number of the incoming call
01142  *
01143  * This function should be executed only inside 'manageIncomingData' function.
01144  *
01145  * 'data' must contains the tlfn number, something like that: aaaa"+34666999888"aaa
01146  *
01147  * Returns '1' on success and '0' if error
01148 */
01149 uint8_t WaspGPRS::readCall(char* data)
01150 {
01151         uint8_t a=0;
01152         uint8_t b=0;
01153 
01154         tlfIN[0]='\0';
01155         while( (data[a]!='"') && (a<45) )
01156         {
01157                 a++;
01158         }
01159         a++;
01160         if(a>=45) return 0;
01161         while( (data[a]!='"') && (a<45)  && (b<15) )
01162         {
01163                 tlfIN[b]=data[a];
01164                 a++;
01165                 b++;
01166         }
01167         if( b>=15 ) tlfIN[b-1]='\0';
01168         else tlfIN[b]='\0';
01169         return 1;
01170 }
01171 
01172 
01173 /* readSMS() - set in 'tlfIN' and 'sms' variables the tlf number and text of the incoming SMS
01174  *
01175  * This function sets in 'tlfIN' and 'sms' variables the tlf number and text of the incoming SMS
01176  *
01177  * This function should be executed only inside 'manageIncomingData' function.
01178  *
01179  * Returns '1' on success and '0' if error
01180 */
01181 uint8_t WaspGPRS::readSMS(char* data)
01182 {
01183         uint8_t a=0,b=0,c=0;
01184         char command[30];
01185         uint8_t byteIN[200];
01186         long previous=0;
01187         uint8_t counter=0;
01188         
01189         tlfIN[0]='\0';
01190         sms[0]='\0';
01191         sms_index[0]='\0';
01192         while( (data[a]!=',') && (a<45) ) a++;
01193         a++;
01194         if(a>=45) return 0;
01195         while( data[a]!=13 )
01196         {
01197                 sms_index[b]=data[a];
01198                 a++;
01199                 b++;
01200         }
01201         sms_index[b]='\0';
01202         sprintf(command,"AT%s%s\r\n",AT_SMS_READ,sms_index);
01203         printString(command,PORT_USED);
01204         while(!serialAvailable(PORT_USED));
01205         previous=millis();
01206         a=0;
01207         while( (millis()-previous) < 2000 )
01208         {
01209                 while( serialAvailable(PORT_USED) && (millis()-previous) < 2000 )
01210                 {
01211                         byteIN[a]=serialRead(PORT_USED);
01212                         a++;
01213                 }
01214         }
01215         a=0;
01216         while( counter <3 )
01217         {
01218                 while( (byteIN[a]!='"') && (a<200) )
01219                 {
01220                         a++;
01221                 }
01222                 a++;
01223                 counter++;
01224         }
01225         if(a>=200) return 0;
01226         counter=0;
01227         while( (byteIN[a]!='"') && (a<200) && (c<15) )
01228         {
01229                 tlfIN[c]=byteIN[a];
01230                 a++;
01231                 c++;
01232         }
01233         if( c>=15 ) tlfIN[c-1]='\0';
01234         else tlfIN[c]='\0';
01235         while( counter < 5 )
01236         {
01237                 while( (byteIN[a]!='"') && (a<200) )
01238                 {
01239                         a++;
01240                 }
01241                 a++;
01242                 counter++;
01243         }
01244         if(a>=200) return 0;
01245         a++;
01246         a++;
01247         b=0;
01248         while( (byteIN[a]!=13) && (a<200) && (b<100) )
01249         {
01250                 sms[b]=byteIN[a];
01251                 b++;
01252                 a++;
01253         }
01254         if(a>=200) return 0;
01255         if( b>=100 )sms[b-1]='\0';
01256         else sms[b]='\0';
01257         return 1;
01258 }
01259 
01260 
01261 /* manageIncomingData() - manage incoming data from serial port, executing proper functions to store received data
01262  *
01263  * This function manages incoming data from serial port, executing proper functions to store received data
01264  *
01265  * Returns '1' on success and '0' if error
01266 */
01267 uint8_t WaspGPRS::manageIncomingGSMData()
01268 {
01269         char byteIN[100];
01270         uint8_t a=0;
01271         long previous=0;
01272         uint8_t answer=0;
01273         
01274         while(a<100){
01275                 byteIN[a]=0;
01276                 a++;
01277         }
01278         a=0;
01279         
01280         serialFlush(PORT_USED);
01281         previous=millis();
01282         while(!serialAvailable(PORT_USED) && (millis()-previous)<20000);
01283         previous=millis();
01284         while( (millis()-previous) < 2000 )
01285         {
01286                 while( serialAvailable(PORT_USED) && (millis()-previous) < 2000 )
01287                 {
01288                         byteIN[a]=serialRead(PORT_USED);
01289                         a++;
01290                 }
01291         }
01292         answer=parse_GSM(byteIN);
01293         switch( answer ){
01294                 case    0:      readCall(byteIN);
01295                                 break;
01296                 case    1:      readSMS(byteIN);
01297                                 break;
01298         }
01299         if(answer==2) return 0;
01300         return 1;
01301 }
01302 
01303 
01304 /* configureGPRS() - configures GPRS connection with login, password and some other parameters
01305  *
01306  * This function creates a GPRS connection with the carrier server to get access to the internet
01307  *
01308  * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
01309  *
01310  * Returns '1' on success and '0' if error
01311 */
01312 uint8_t WaspGPRS::configureGPRS()
01313 {
01314         char command[100];
01315         char aux='"';
01316         uint8_t answer=0;
01317         
01318         flag &= ~(GPRS_ERROR_CONF);
01319 
01320         sprintf(command,"%s0,%c%s%c,%c%s%c,%c%s%c,%c%s%c,%c%s%c",AT_GPRS_CONN_CFG,aux,
01321                 AT_GPRS,aux,aux,AT_GPRS_APN,aux,aux,AT_GPRS_LOGIN,aux,aux,AT_GPRS_PASSW,aux,aux,AT_GPRS_IP,aux);
01322         
01323         answer=sendATCommand(command,AT_GPRS_CONN_CFG_R);
01324         switch(answer)
01325         {
01326                 case    0       :       flag |= GPRS_ERROR_CONF;
01327                                         return 0;
01328                                         break;
01329                 case    2       :       flag |= GPRS_ERROR_CONF;
01330                                         return 0;
01331                                         break;
01332         }
01333         
01334         if(!setConnectionTimer()) return 0;
01335         
01336         if(!setConnectionProfile()) return 0;
01337         
01338         if(!checkGPRS()) return 0;
01339 
01340         if(!setPattern(GPRS_PATTERN)) return 0;
01341         
01342         if(flag) return 0;
01343         return 1;
01344 }
01345 
01346 
01347 /* createSocket(ip, port) - creates a TCP/IP connection to the specified IP and PORT
01348  *
01349  * This function creates a TCP/IP connection to the specified IP and PORT
01350  *
01351  * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
01352  *
01353  * It stores in 'socket_ID' the TCP session ID assigned to the last call to create a socket
01354  *
01355  * Returns '1' on success and '0' if error
01356 */
01357 uint8_t WaspGPRS::createSocket(const char* ip,const char* port, uint8_t mode)
01358 {
01359         char command[40];
01360         char aux='"';
01361         uint8_t answer=0;
01362         uint8_t byteIN=0;
01363         long previous=0;
01364         uint8_t counter=0;
01365         
01366         flag &= ~(GPRS_ERROR_SOCKET);
01367         
01368         switch(mode){
01369                 case GPRS_CLIENT:
01370                         sprintf(command,"%s0,%u,%c%s%c,%s%c%c",AT_GPRS_TCP_CFG,mode,aux,ip,aux,port,'\r','\n');
01371                         break;
01372                 case GPRS_SERVER:
01373                         sprintf(command,"%s0,%u,%s%c%c",AT_GPRS_TCP_CFG,mode,port,'\r','\n');
01374                         break;
01375         }
01376 
01377         
01378         while( counter<3 )
01379         {
01380                 serialFlush(PORT_USED);
01381                 printString(command,PORT_USED);
01382                 while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<3000) );
01383                 delay(10);
01384                 answer=waitForData("+KTCPCFG:",20,0,0);
01385                 if(answer==1) break;
01386                 counter++;
01387         }
01388         
01389         if(answer!=1) return 0;
01390         serialRead(PORT_USED);
01391         delay(30);
01392         socket_ID=serialRead(PORT_USED);
01393         delay(50);
01394         answer=0;
01395         counter=0;
01396         while( counter<3 )
01397         {
01398                 serialFlush(PORT_USED);
01399                 printString(AT_GPRS_TCP_CNX,PORT_USED);
01400                 printByte(socket_ID,PORT_USED);
01401                 printByte('\r',PORT_USED);
01402                 printByte('\n',PORT_USED);
01403                 while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<3000) );
01404                 delay(10);
01405                 answer=waitForData("OK",20,0,10);
01406                 if(answer==1) break;
01407                 counter++;
01408                 
01409         }
01410         if(answer!=1) return 0;
01411         return 1;
01412 }
01413 
01414 /* readURL(url) - access to the specified URL and stores the info read in 'data_URL' variable
01415  *
01416  * This function access to the specified URL and stores the info read in 'data_URL' variable
01417  *
01418  * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
01419  *
01420  * It stores in 'socket_ID' the TCP session ID assigned to the last call to create a socket
01421  *
01422  * Returns '1' on success and '0' if error
01423 */
01424 uint8_t WaspGPRS::readURL(const char* url)
01425 {
01426         char command[30];
01427         char* data=",20";
01428         uint8_t answer=0;
01429         long previous=0;
01430         uint8_t byteIN=0;
01431         uint8_t a=0;
01432         
01433         if(!configureGPRS()) return 0;
01434         
01435         if(!createSocket(url,"80",GPRS_CLIENT)) return 0;
01436         
01437         serialFlush(PORT_USED);
01438         sprintf(command,"%s%c%c","GET / HTTP/1.0",'\r','\n');
01439         if(!sendData(command,socket_ID)){
01440                 closeSocket(socket_ID);
01441                 return 0;
01442         }
01443                 
01444         waitForData("+KTCP_DATA:",20,0,0);
01445         if(readData(socket_ID,GPRS_DATA_LENGTH)<0){
01446                 closeSocket(socket_ID);
01447                 return 0;
01448         }
01449         
01450         while(!closeSocket(socket_ID)) closeSocket(socket_ID);
01451         
01452         return 1;
01453 }
01454 
01455 
01456 /* sendData(data,socket) - sends 'data' to the specified 'socket'
01457  *
01458  * This function sends 'data' to the specified 'socket'
01459  *
01460  * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
01461  *
01462  * It gets from 'socket_ID' the TCP session ID assigned to the last call of creating a socket
01463  *
01464  * Returns '1' on success and '0' if error
01465 */
01466 uint8_t WaspGPRS::sendData(const char* data, uint8_t socket)
01467 {
01468         char command[30];
01469         uint8_t answer=0;
01470         long previous=0;
01471         uint8_t byteIN=0;
01472         uint8_t counter=0;
01473         
01474         while(data[counter]!='\0') counter++;
01475         counter+=2;
01476         serialFlush(PORT_USED);
01477         sprintf(command,"%s%c,%u%c%c",AT_GPRS_TCP_SND,socket,counter,'\r','\n');
01478         printString(command,PORT_USED);
01479         previous=millis();
01480         while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<3000) );
01481         delay(10);
01482         answer=waitForData("CONNECT",20,0,0);
01483         if(answer!=1) return 0;
01484         answer=0;
01485         counter=0;
01486         while( (counter<3) && (answer!=1) )
01487         {
01488                 serialFlush(PORT_USED);
01489                 delay(20);
01490                 writeData(data);
01491                 previous=millis();
01492                 while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<3000) );
01493                 delay(10);
01494                 answer=waitForData("OK",20,0,0);
01495         }
01496         if(answer!=1) return 0;
01497         return 1;
01498 }
01499 
01500 
01501 /* readData(socket,data_length) - reads data of 'data_length' size from socket ID 'socket'
01502  *
01503  * This function reads data of 'data_length' size from socket ID 'socket'
01504  *
01505  * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
01506  *
01507  * It stores in 'socket_ID' the TCP session ID assigned to the last call to create a socket
01508  *
01509  * Returns '1' on success, '-1' if error and '0' if more data is available
01510 */
01511 int8_t WaspGPRS::readData(uint8_t socket, const char* data_length)
01512 {
01513         char command[30];
01514         uint8_t answer=0;
01515         long previous=0;
01516         uint8_t a=0;
01517         uint8_t byteIN=0;
01518         uint8_t aux[10];
01519         
01520         sprintf(command,"%s%u,%s%c%c",AT_GPRS_TCP_RCV,socket-'0',data_length,'\r','\n');
01521         serialFlush(PORT_USED);
01522         delay(50);
01523         printString(command,PORT_USED);
01524         while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<10000) );
01525         delay(10);
01526         answer=waitForData("CONNECT",20,0,0);
01527         if(answer!=1) return -1;
01528         serialRead(PORT_USED);
01529         serialRead(PORT_USED);
01530         while(a<GPRS_DATA_LENGTH_U)
01531         {
01532                 aux[0]=serialRead(PORT_USED);
01533                 if(aux[0]=='E'){
01534                         aux[1]=serialRead(PORT_USED);
01535                         if(aux[1]=='N'){
01536                                 aux[2]=serialRead(PORT_USED);
01537                                 if(aux[2]=='D'){
01538                                         aux[3]=serialRead(PORT_USED);
01539                                         if(aux[3]=='M'){
01540                                                 aux[4]=serialRead(PORT_USED);
01541                                                 if(aux[4]=='E'){
01542                                                         aux[5]=serialRead(PORT_USED);
01543                                                         if(aux[5]=='S'){
01544                                                                 answer=1;
01545                                                                 break;
01546                                                         }
01547                                                         else{
01548                                                                 data_URL[a]=aux[0];
01549                                                                 data_URL[a+1]=aux[1];
01550                                                                 data_URL[a+2]=aux[2];
01551                                                                 data_URL[a+3]=aux[3];
01552                                                                 data_URL[a+4]=aux[4];
01553                                                                 data_URL[a+5]=aux[5];
01554                                                                 a+=6;
01555                                                         }
01556                                                 }
01557                                                 else{
01558                                                         data_URL[a]=aux[0];
01559                                                         data_URL[a+1]=aux[1];
01560                                                         data_URL[a+2]=aux[2];
01561                                                         data_URL[a+3]=aux[3];
01562                                                         data_URL[a+4]=aux[4];
01563                                                         a+=5;
01564                                                 }
01565                                         }
01566                                         else{
01567                                                 data_URL[a]=aux[0];
01568                                                 data_URL[a+1]=aux[1];
01569                                                 data_URL[a+2]=aux[2];
01570                                                 data_URL[a+3]=aux[3];
01571                                                 a+=4;
01572                                         }
01573                                 }
01574                                 else{
01575                                         data_URL[a]=aux[0];
01576                                         data_URL[a+1]=aux[1];
01577                                         data_URL[a+2]=aux[2];
01578                                         a+=3;
01579                                 }
01580                         }
01581                         else{
01582                                 data_URL[a]=aux[0];
01583                                 data_URL[a+1]=aux[1];
01584                                 a+=2;
01585                         }       
01586                 }
01587                 else{
01588                         data_URL[a]=aux[0];
01589                         a++;
01590                 }
01591         }
01592         
01593                 
01594         data_read+=a;
01595         if(answer && a<(GPRS_DATA_LENGTH_U-10)) return 1;
01596         if(answer && a>=(GPRS_DATA_LENGTH_U-10)) return 0;
01597         return -1;
01598 }
01599 
01600 
01601 /* closeSocket(socket) - closes the socket specified by 'socket'
01602  *
01603  * This function closes the socket specified by 'socket'
01604  *
01605  * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
01606  *
01607  * Returns '1' on success and '0' if error
01608 */
01609 uint8_t WaspGPRS::closeSocket(uint8_t socket)
01610 {
01611         char command[30];
01612         long previous=0;
01613         uint8_t answer=0;
01614         uint8_t byteIN=0;
01615         
01616         setInfoIncomingCall();
01617         flag &= ~(GPRS_ERROR_CLOSE);
01618         sprintf(command,"%s%u,0",AT_GPRS_TCP_CLOSE,socket-'0');
01619 
01620         answer=sendATCommand(command,AT_GPRS_TCP_CLOSE_R);
01621         switch(answer)
01622         {
01623                 case    0       :       flag |= GPRS_ERROR_CLOSE;
01624                                         break;
01625                 case    2       :       flag |= GPRS_ERROR_CLOSE;
01626                                         break;
01627         }
01628         if(flag) return 0;
01629         return 1;
01630 }
01631 
01632 
01633 /* getCellInfo() - gets the information from the cell where the module is connected
01634  *
01635  * This function gets the information from the cell where the module is connected
01636  *
01637  * It stores in 'RSSI' and 'cellID' variables the information from the cell
01638  *
01639  * It modifies 'flag' if expected answer is not received after sending a command to GPRS module
01640  *
01641  * Returns '1' on success and '0' if error
01642 */
01643 uint8_t WaspGPRS::getCellInfo()
01644 {
01645         char command[30];
01646         uint8_t byteIN[200];
01647         long previous=millis();
01648         uint8_t counter=0;
01649         uint8_t a,b,c=0;
01650         
01651         serialFlush(PORT_USED);
01652         sprintf(command,"AT%s\r\n",AT_GPRS_CELLID);
01653         printString(command,PORT_USED);
01654         while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<3000) );
01655         previous=millis();
01656         a=0;
01657         while( (millis()-previous) < 2000 )
01658         {
01659                 while( serialAvailable(PORT_USED) && (millis()-previous) < 2000 && (a<200) )
01660                 {
01661                         byteIN[a]=serialRead(PORT_USED);
01662                         a++;
01663                 }
01664         }
01665         a=0;
01666         while( counter < 5 )
01667         {
01668                 while( (byteIN[a]!=',') && (a<200) )
01669                 {
01670                         a++;
01671                 }
01672                 a++;
01673                 counter++;
01674         }
01675         if(a>=200) return 0;
01676         counter=0;
01677         while( (byteIN[a]!=',') && (a<200) )
01678         {
01679                 cellID[c]=byteIN[a];
01680                 a++;
01681                 c++;
01682         }
01683         a++;
01684         while( (byteIN[a]!=',') && (a<200) )
01685         {
01686                 RSSI[b]=byteIN[a];
01687                 delay(10);
01688                 b++;
01689                 a++;
01690         }
01691         return 1;
01692 }
01693 
01694 
01695 /* sendCommand(ATcommand, ATcommand_R) - sends any command to GPRS module
01696  *
01697  * This function sends any command to GPRS module
01698  *
01699  * It stores in 'answer_command' variable the answer returned by the GPRS module
01700  *
01701  * Returns '1' on success and '0' if error
01702 */
01703 uint8_t WaspGPRS::sendCommand(char* ATcommand)
01704 {
01705         char command[30];
01706         uint8_t timeout=0;
01707         uint8_t i=0;
01708         
01709         sprintf(command, "AT%s%c%c", ATcommand,'\r','\n');
01710 
01711         serialFlush(PORT_USED);
01712         while(!serialAvailable(PORT_USED)) {
01713                 printString(command,PORT_USED);
01714                 delay(DELAY_ON_SEND);
01715         }
01716         
01717         while( timeout < 5 )
01718         {
01719                 while(!serialAvailable(PORT_USED) && timeout < 5) {
01720                         timeout++;
01721                         delay(1000);
01722                 }
01723                 while(serialAvailable(PORT_USED) && timeout < 5){
01724                         answer_command[i] = serialRead(PORT_USED);
01725                         delay(20);
01726                         i++;
01727                         timeout=0;
01728                 }
01729         }
01730         answer_command[i]='\0';
01731         if( i<5 ) return 0;
01732         return 1;
01733 }
01734 
01735 /* sendMail() - sends an email
01736  *
01737  * This function sends an email
01738  *
01739  * Returns '1' on success and '0' if error
01740 */
01741 uint8_t WaspGPRS::sendMail(char* from, char* to, char* subject, char* body, char* user, char* passw, char* smtp_server, uint16_t port)
01742 {
01743         uint8_t counter=0;
01744         char command[30];
01745         long previous=0;
01746         uint8_t answer=0;
01747         
01748         if(!setFlowControl()) return 0;
01749                 
01750         if(!configureGPRS()) return 0;
01751                 
01752         if(!setEmailParams(smtp_server, port, from)) return 0;
01753                 
01754         if(!setEmailPwd(user, passw)) return 0;
01755                 
01756         if(!setEmailDestination(to)) return 0;
01757                 
01758         if(!setEmailSubject(subject)) return 0;
01759                 
01760         while( body[counter]!='\0' ) counter++;
01761         counter+=2;
01762         
01763         serialFlush(PORT_USED);
01764         sprintf(command,"AT%s1,%u%c%c",AT_SMTP_SEND,counter,'\r','\n');
01765         printString(command,PORT_USED);
01766         previous=millis();
01767         while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<10000) );
01768         delay(10);
01769         answer=waitForData("CONNECT",20,0,0);
01770         if(answer!=1) return 0;
01771         
01772         printString(body,PORT_USED);
01773         printByte('\r',PORT_USED);
01774         printByte('\n',PORT_USED);
01775         
01776         previous=millis();
01777         while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<10000) );
01778         delay(10);
01779         answer=waitForData("OK",20,0,0);
01780         if(answer!=1) return 0;
01781         
01782         
01783         return 1;
01784 
01785 }
01786 
01787 /* readMail() - reads an email
01788  *
01789  * This function reads an email
01790  *
01791  * Returns '1' on success and '0' if error
01792 */
01793 uint8_t WaspGPRS::readMail(char* user, char* passw, char* pop3_server, uint16_t port)
01794 {
01795         char command[70];
01796         long previous=0;
01797         uint8_t answer=0;
01798         char aux='"';
01799         uint16_t index=0;
01800         uint16_t i=0;
01801         uint8_t end=0;
01802         char* aux2;
01803         uint8_t j=0;
01804         
01805         if(!setFlowControl()) return 0;
01806                 
01807         if(!configureGPRS()) return 0;
01808         
01809         // Connect to POP3 Server
01810         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');
01811         printString(command,PORT_USED);
01812         previous=millis();
01813         while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<10000) );
01814         delay(10);
01815         answer=waitForData("OK",20,0,0);
01816         if(answer!=1) return 0;
01817         
01818         
01819         // Get the index
01820         printString(AT_POP3_LIST,PORT_USED);
01821         printByte('\r',PORT_USED);
01822         printByte('\n',PORT_USED);
01823         previous=millis();
01824         while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<10000) );
01825         delay(10);
01826         answer=waitForData("+KPOPLIST:",20,0,0);
01827         if(answer!=1) return 0;
01828         i=0;
01829         while( serialRead(PORT_USED)!=':' );
01830         serialRead(PORT_USED);
01831         index=serialRead(PORT_USED);
01832         serialFlush(PORT_USED);
01833                 
01834         // Read the email
01835         printString(AT_POP3_READ,PORT_USED);
01836         printByte(index,PORT_USED);
01837         printByte('\r',PORT_USED);
01838         printByte('\n',PORT_USED);
01839         previous=millis();
01840         while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<10000) );
01841         
01842         aux2 = (char*) calloc(MAX_SIZE_POP3,sizeof(char));
01843         if( aux2==NULL ) return 0;
01844         
01845         previous=millis();
01846         i=0;
01847         while( millis()-previous<5000 )
01848         {
01849                 while( serialAvailable(PORT_USED) && i<MAX_SIZE_POP3 )
01850                 {
01851                         aux2[i]=serialRead(PORT_USED);
01852                         i++;
01853                         previous=millis();
01854                 }
01855         }
01856         if( i>=MAX_SIZE_POP3 ) aux2[i-1]='\0';
01857         else aux2[i]='\0';
01858         
01859         
01860         i=0;
01861         j=0;
01862         i=waitForData(aux2,"Return-path: <");
01863         
01864         emailAddress[j]=aux2[i];
01865         while( emailAddress[j]!='>' && i!=0 )
01866         {
01867                 i++;
01868                 j++;
01869                 emailAddress[j]=aux2[i];
01870                 if(j>=30) break;
01871         }
01872         emailAddress[j]='\0';
01873         
01874         
01875         i=0;
01876         j=0;
01877         i=waitForData(aux2,"ubject: ");
01878         
01879         subject[j]=aux2[i];
01880         while( subject[j]!='\r' && i!=0 )
01881         {
01882                 i++;
01883                 j++;
01884                 subject[j]=aux2[i];
01885                 if(j>=30) break;
01886         }
01887         subject[j]='\0';
01888         i=0;
01889         j=0;
01890         
01891         i=waitForData(aux2,"*/*");
01892         while( j<=GPRS_MAX_DATA && !end && i!=0 )
01893         {
01894                 body[j]=aux2[i];
01895                 if( body[j]=='*' )
01896                 {
01897                         j++;
01898                         i++;
01899                         body[j]=aux2[i];
01900                         if( body[j]=='/' )
01901                         {
01902                                 j++;
01903                                 i++;
01904                                 body[j]=aux2[i];
01905                                 if( body[j]=='*' )
01906                                 {
01907                                         j++;
01908                                         i++;
01909                                         body[j]='\0';
01910                                         end=1;
01911                                 }
01912                         }
01913                 }
01914                 j++;
01915                 i++;
01916         }
01917         body[j-1]='\0';
01918         i=0;
01919         
01920         free(aux2);
01921         aux2=NULL;
01922         return 1;
01923 }
01924 
01925 
01926 /* uploadFile() - uploads a file to a FTP server
01927  *
01928  * This function uploads a file to a FTP server
01929  *
01930  * Returns '1' on success and '0' if error
01931 */
01932 uint8_t WaspGPRS::uploadFile(char* file, char* path, char* user, char* passw, char* ftp_server, uint8_t ftp_port)
01933 {
01934         char command[70];
01935         long previous=0;
01936         uint8_t answer=0;
01937         char aux='"';
01938         uint16_t index=0;
01939         uint16_t i=0;
01940         uint8_t end=0;
01941         char* aux2;
01942         uint8_t j=0;
01943         uint8_t id=0;
01944         
01945         if(!setFlowControl()) return 0;
01946                         
01947         if(!configureGPRS()) return 0;
01948                 
01949         // Connect to FTP Server
01950         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');
01951         printString(command,PORT_USED);
01952         previous=millis();
01953         while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<10000) );
01954         delay(10);
01955         answer=waitForData("+KFTPCFG: ",20,0,0);
01956         if(answer!=1) return 0;
01957                 
01958         id=serialRead(PORT_USED);
01959         
01960         if( !sendDataFTP(file, path,id) ) return 0;
01961         
01962         return 1;
01963 }
01964 
01965 
01966 /* uploadFile() - uploads a file to a FTP server
01967  *
01968  * This function uploads a file to a FTP server
01969  *
01970  * Returns '1' on success and '0' if error
01971 */
01972 uint8_t WaspGPRS::downloadFile(char* file, char* path, char* user, char* passw, char* ftp_server, uint8_t ftp_port)
01973 {
01974         char command[70];
01975         long previous=0;
01976         uint8_t answer=0;
01977         char aux='"';
01978         uint16_t index=0;
01979         uint16_t i=0;
01980         uint8_t end=0;
01981         char* aux2;
01982         uint8_t j=0;
01983         uint8_t id=0;
01984         
01985         if(!setFlowControl()) return 0;
01986                         
01987         if(!configureGPRS()) return 0;
01988                 
01989         // Connect to FTP Server
01990         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');
01991         printString(command,PORT_USED);
01992         previous=millis();
01993         while( (!serialAvailable(PORT_USED)) && ((millis()-previous)<10000) );
01994         delay(10);
01995         answer=waitForData("+KFTPCFG: ",20,0,0);
01996         if(answer!=1) return 0;
01997                 
01998         id=serialRead(PORT_USED);
01999         
02000         if( !readDataFTP(file, path, id) ) return 0;
02001         
02002         return 1;
02003 }
02004 
02005 
02006 
02007 // Preinstantiate Objects //////////////////////////////////////////////////////
02008 
02009 WaspGPRS GPRS = WaspGPRS();
02010