GPRS.cpp

00001 /*
00002   GPRS.cpp
00003   2014 Copyright (c) Seeed Technology Inc.  All right reserved.
00004 
00005   Author:lawliet zou(lawliet.zou@gmail.com)
00006   2014-2-24
00007 
00008   This library is free software; you can redistribute it and/or
00009   modify it under the terms of the GNU Lesser General Public
00010   License as published by the Free Software Foundation; either
00011   version 2.1 of the License, or (at your option) any later version.
00012 
00013   This library is distributed in the hope that it will be useful,
00014   but WITHOUT ANY WARRANTY; without even the implied warranty of
00015   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00016   Lesser General Public License for more details.
00017 
00018   You should have received a copy of the GNU Lesser General Public
00019   License along with this library; if not, write to the Free Software
00020   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
00021 */
00022 
00023 #include "mbed.h"
00024 #include "GPRS.h"
00025 
00026 GPRS* GPRS::inst;
00027 
00028 GPRS::GPRS(PinName tx, PinName rx, int baudRate, const char* apn, const char* userName, const char* passWord) : Modem(tx,rx,baudRate)
00029 {
00030     inst = this;
00031     _apn = apn;
00032     _userName = userName;
00033     _passWord = passWord;
00034     socketID = -1;
00035 }
00036 
00037 bool GPRS::preInit()
00038 {
00039     for(int i = 0; i < 2; i++) {
00040         sendCmd("AT\r\n");
00041         wait(1);
00042     }
00043     return checkSIMStatus();
00044 }
00045 // added by Noah Milam
00046 void GPRS::start_server()
00047 {     
00048      sendCmdResp("AT+CGATT?\r\n");
00049      
00050      sendCmdResp("AT+CIPSERVER=1,\"1234\"\r\n");
00051      wait_for_sms();
00052      store_response();
00053      listen_server();
00054 }
00055 void GPRS::listen_server()
00056 {
00057     gprs_response();
00058 }
00059     
00060 void GPRS::send_SMS(char* IPAdress)
00061 {
00062     printf("sending at command\n");
00063     sendCmdAndWaitForResp("AT+CMGF=1\r\n","OK",DEFAULT_TIMEOUT,CMD);
00064     wait(2);
00065      //printf("\032\n");
00066     sendCmdAndWaitForResp("AT+CMGS=\"+14358306480\"\r\n",">",DEFAULT_TIMEOUT,CMD);
00067     printf("sent at cmgf\n");
00068     wait(2);
00069     //printf("032");
00070     sendCmd(IPAdress); // sends the address 
00071     sendCmd("\x1a");  // this is like pressing control - z to end the send command
00072     wait(10);  // giving the send enough time to do its thing
00073     printf("should have been received");
00074 }
00075 
00076 void GPRS::read_SMS()
00077 {
00078  wait(1);
00079     sendCmd("AT+CMGF=1\r\n");
00080     wait(2);
00081     sendCmd("AT+CMGL=\"ALL\"\r\n");
00082     store_response();    
00083 }
00084 
00085 // end of what Noah Milam added
00086 bool GPRS::checkSIMStatus(void)
00087 {
00088     char gprsBuffer[32];
00089     int count = 0;
00090     cleanBuffer(gprsBuffer,32);
00091     while(count < 3) {
00092         sendCmd("AT+CPIN?\r\n");
00093         readBuffer(gprsBuffer,32,DEFAULT_TIMEOUT);
00094         if((NULL != strstr(gprsBuffer,"+CPIN: READY"))) {
00095             break;
00096         }
00097         count++;
00098         wait(1);
00099     }
00100     if(count == 3) {
00101         return false;
00102     }
00103     return true;
00104 }
00105 
00106 bool GPRS::join()
00107 {
00108     char cmd[64];
00109     char ipAddr[32];
00110     //Select multiple connection
00111     sendCmdAndWaitForResp("AT+CIPMUX=1\r\n","OK",DEFAULT_TIMEOUT,CMD);
00112 
00113     //set APN
00114     snprintf(cmd,sizeof(cmd),"AT+CSTT=\"%s\",\"%s\",\"%s\"\r\n",_apn,_userName,_passWord);
00115     sendCmdAndWaitForResp(cmd, "OK", DEFAULT_TIMEOUT,CMD);
00116 
00117     //Brings up wireless connection
00118     sendCmdAndWaitForResp("AT+CIICR\r\n","OK",DEFAULT_TIMEOUT,CMD);
00119 
00120     //Get local IP address
00121     sendCmd("AT+CIFSR\r\n");
00122     readBuffer(ipAddr,32,2);
00123 
00124     if(NULL != strstr(ipAddr,"AT+CIFSR")) {
00125         _ip = str_to_ip(ipAddr+12);
00126         if(_ip != 0) {
00127             return true;
00128         }
00129     }
00130     return false;
00131 }
00132 
00133 bool GPRS::setProtocol(int socket, Protocol p)
00134 {
00135     if (socket < 0 || socket > MAX_SOCK_NUM-1) {
00136         return false;
00137     }
00138     //ToDo: setProtocol
00139     return true;
00140 }
00141 
00142 bool GPRS::connect(int socket, Protocol ptl,const char * host, int port, int timeout)
00143 {
00144     char cmd[64];
00145     char resp[96];
00146     if (socket < 0 || socket > MAX_SOCK_NUM-1) {
00147         return false;
00148     }
00149     if(ptl == TCP) {
00150         sprintf(cmd, "AT+CIPSTART=%d,\"TCP\",\"%s\",%d\r\n",socket, host, port);
00151     } else if(ptl == UDP) {
00152         sprintf(cmd, "AT+CIPSTART=%d,\"UDP\",\"%s\",%d\r\n",socket, host, port);
00153     } else {
00154         return false;
00155     }
00156     sendCmd(cmd);
00157     readBuffer(resp,96,2*DEFAULT_TIMEOUT);
00158     if(NULL != strstr(resp,"CONNECT")) { //ALREADY CONNECT or CONNECT OK
00159         return true;
00160     }
00161     return false;//ERROR
00162 }
00163 
00164 bool GPRS::gethostbyname(const char* host, uint32_t* ip)
00165 {
00166     uint32_t addr = str_to_ip(host);
00167     char buf[17];
00168     snprintf(buf, sizeof(buf), "%d.%d.%d.%d", (addr>>24)&0xff, (addr>>16)&0xff, (addr>>8)&0xff, addr&0xff);
00169     if (strcmp(buf, host) == 0) {
00170         *ip = addr;
00171         return true;
00172     }
00173     return false;
00174 }
00175 
00176 bool GPRS::disconnect()
00177 {
00178     sendCmd("AT+CIPSHUT\r\n");
00179     return true;
00180 }
00181 
00182 bool GPRS::is_connected(int socket)
00183 {
00184     char cmd[16];
00185     char resp[96];
00186     snprintf(cmd,16,"AT+CIPSTATUS=%d\r\n",socket);
00187     sendCmd(cmd);
00188     readBuffer(resp,sizeof(resp),DEFAULT_TIMEOUT);
00189     if(NULL != strstr(resp,"CONNECTED")) {
00190         //+CIPSTATUS: 1,0,"TCP","216.52.233.120","80","CONNECTED"
00191         return true;
00192     } else {
00193         //+CIPSTATUS: 1,0,"TCP","216.52.233.120","80","CLOSED"
00194         //+CIPSTATUS: 0,,"","","","INITIAL"
00195         return false;
00196     }
00197 }
00198 
00199 void GPRS::reset()
00200 {
00201 
00202 }
00203 
00204 bool GPRS::close(int socket)
00205 {
00206     char cmd[16];
00207     char resp[16];
00208 
00209     if (socket < 0 || socket > MAX_SOCK_NUM-1) {
00210         return false;
00211     }
00212     // if not connected, return
00213     if (is_connected(socket) == false) {
00214         return true;
00215     }
00216     snprintf(cmd, sizeof(cmd),"AT+CIPCLOSE=%d\r\n",socket);
00217     snprintf(resp,sizeof(resp),"%d, CLOSE OK",socket);
00218     if(0 != sendCmdAndWaitForResp(cmd, resp, DEFAULT_TIMEOUT,CMD)) {
00219         return false;
00220     }
00221     return true;
00222 }
00223 
00224 bool GPRS::readable(void)
00225 {
00226     return readable();
00227 }
00228 
00229 int GPRS::wait_readable(int socket, int wait_time)
00230 {
00231     if (socket < 0 || socket > MAX_SOCK_NUM-1) {
00232         return -1;
00233     }
00234     char resp[16];
00235     snprintf(resp,sizeof(resp),"\r\n\r\n+RECEIVE,%d",socket);//"+RECEIVE:<socketID>,<length>"
00236     int len = strlen(resp);
00237 
00238     if(false == respCmp(resp,len,wait_time)) {
00239         return -1;
00240     }
00241     char c = readByte();//','
00242     char dataLen[4];
00243     int i = 0;
00244     c = readByte();
00245     while((c >= '0') && (c <= '9')) {
00246         dataLen[i++] = c;
00247         c = readByte();
00248     }
00249     c = readByte();//'\n'
00250     len = atoi(dataLen);
00251     return len;
00252 }
00253 
00254 int GPRS::wait_writeable(int socket, int req_size)
00255 {
00256     if (socket < 0 || socket > MAX_SOCK_NUM-1) {
00257         return -1;
00258     }
00259     return req_size>256?256:req_size+1;
00260 }
00261 
00262 int GPRS::send(int socket, const char * str, int len)
00263 {
00264     if (socket < 0 || socket > MAX_SOCK_NUM-1) {
00265         return -1;
00266     }
00267     char cmd[32];
00268     wait(1);
00269     if(len > 0){
00270         snprintf(cmd,sizeof(cmd),"AT+CIPSEND=%d\r\n",socket);
00271         if(0 != sendCmdAndWaitForResp(cmd,">",2,CMD)) {
00272             return false;
00273         }
00274         sendCmd(str);
00275         serialModem.putc((char)0x1a);
00276     }
00277     return len;
00278 }
00279 
00280 int GPRS::recv(int socket, char* buf, int len)
00281 {
00282     if (socket < 0 || socket > MAX_SOCK_NUM-1) {
00283         return -1;
00284     }
00285     cleanBuffer(buf,len);
00286     readBuffer(buf,len,DEFAULT_TIMEOUT/2);
00287     return len;
00288     //return strlen(buf);
00289 }
00290 
00291 int GPRS::new_socket()
00292 {
00293     socketID = 0; //we only support one socket.
00294     return socketID; 
00295 }
00296 
00297 uint16_t GPRS::new_port()
00298 {
00299     uint16_t port = rand();
00300     port |= 49152;
00301     return port;
00302 }
00303 
00304 uint32_t GPRS::str_to_ip(const char* str)
00305 {
00306     uint32_t ip = 0;
00307     char* p = (char*)str;
00308     for(int i = 0; i < 4; i++) {
00309         ip |= atoi(p);
00310         p = strchr(p, '.');
00311         if (p == NULL) {
00312             break;
00313         }
00314         ip <<= 8;
00315         p++;
00316     }
00317     return ip;
00318 }