Revision 0:b27750bf16d6, committed 2015-12-19

Comitter:

DeWayneDennis

Date:

Sat Dec 19 21:57:28 2015 +0000

Commit message:

Final Code 12/19/2015

Changed in this revision

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/GPRS.cpp	Sat Dec 19 21:57:28 2015 +0000
@@ -0,0 +1,522 @@
+/*
+  GPRS.cpp
+  2014 Copyright (c) Seeed Technology Inc.  All right reserved.
+
+  Author:lawliet zou(lawliet.zou@gmail.com)
+  2014-2-24
+
+  This library 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 library 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 library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#include "mbed.h"
+#include "GPRS.h"
+#include "GSMLibrary.h"
+
+GPRS* GPRS::inst;
+char* numbers[100];
+FILE *fpNum;
+int number_index = 0;
+char phone_number[12];
+
+GPRS::GPRS(PinName tx, PinName rx, int baudRate, const char* apn, const char* userName, const char* passWord) : Modem(tx,rx,baudRate)
+{
+    inst = this;
+    _apn = apn;
+    _userName = userName;
+    _passWord = passWord;
+    socketID = -1;
+}
+
+bool GPRS::preInit()
+{
+    //send AT command a couple of times
+    for(int i = 0; i < 2; i++) {
+        sendCmd("AT\r\n");
+        //set time to update from tower
+        //sendCmd("AT+CLTS=1\r\n");
+    }
+    return checkSIMStatus();
+}
+// added by Noah Milam
+void GPRS::start_server()
+{     
+     sendCmdResp("AT+CGATT?\r\n");
+     
+     sendCmdResp("AT+CIPSERVER=1,1234\r\n");
+     listen_server();
+}
+void GPRS::listen_server()
+{
+    gprs_response();
+}
+    
+void GPRS::send_SMS(char* number, char* data)
+{
+    printf("sending text message to: %s\r\n", number);
+    sendCmdAndWaitForResp("AT+CMGF=1\r\n","OK",DEFAULT_TIMEOUT,CMD);
+    wait(2);
+     //printf("\032\n");
+    char cmd[64];
+    snprintf(cmd,sizeof(cmd),"AT+CMGS=\"+%s\"\r\n",number);
+    printf(">>>>%s",cmd);
+    sendCmdAndWaitForResp(cmd,">",DEFAULT_TIMEOUT,CMD);
+    printf("sent at cmgf\n");
+    wait(2);
+    //printf("032");
+    sendCmd(data); // sends the address 
+    sendCmd("\x1a");  // this is like pressing control - z to end the send command
+    wait(10);  // giving the send enough time to do its thing
+    printf("should have been received");
+}
+
+char* GPRS::read_SMS()
+{
+ wait(1);
+    sendCmd("AT+CMGF=1\r\n"); // sms mode
+    wait(2);
+    sendCmd("AT+CMGD=1\r\n"); // delete the frist message so incoming message is spot 1
+    wait(1);
+    wait_for_sms();
+    wait(10);  
+    sendCmd("AT+CMGR=1\r\n");
+    storeResp();
+    return get_server_IP();
+}
+
+// end of what Noah Milam added
+bool GPRS::checkSIMStatus(void)
+{
+    printf("Checking SIM Status...\r\n");
+    char gprsBuffer[32];
+    int count = 0;
+    
+    while(count < 3) {
+        cleanBuffer(gprsBuffer,32);
+        sendCmd("AT+CPIN?\r\n");
+        readBuffer(gprsBuffer,32,DEFAULT_TIMEOUT);
+        if((NULL != strstr(gprsBuffer,"+CPIN: READY"))) {
+            break;
+        }
+        printf("SIM Not Ready..Try Again--%s--\r\n", gprsBuffer);
+        count++;
+        wait(1);
+    }
+    if(count == 3) {
+        return false;
+    }
+    printf("SIM Status GOOD!\r\n");
+    
+    //get the phone number
+    char resp[96];
+    printf(">>>>AT+CNUM\r\n");
+    sendCmd("AT+CNUM\r\n");
+    cleanBuffer(resp,96);
+    readBuffer(resp,96,DEFAULT_TIMEOUT);
+    if(NULL != strstr(resp,"+CNUM:")) {
+        printf("Response: -%s-", resp);
+        const char *p1 = strstr(resp, ",\"")+2;
+        const char *p2 = strstr(p1, "\"");
+        size_t len = p2-p1;
+        phoneNumber = (char*)malloc(sizeof(char)*(len+1));
+        strncpy(phoneNumber, p1, len);
+        phoneNumber[len] = '\0'; 
+    }
+    else{
+        printf("Response: -%s-", resp);
+        return false;    
+    }
+    return true;
+    
+}
+char* GPRS::getCellTime(){
+    return cellTime;  
+}
+void GPRS::setCellTime(){
+    //what time is it
+    char resp[96];
+    printf(">>>AT+CCLK?\r\n");
+    sendCmd("AT+CCLK?\r\n");
+    readBuffer(resp,96,(DEFAULT_TIMEOUT/2));
+    if(NULL != strstr(resp,"+CCLK")) { //ALREADY CONNECT or CONNECT OK
+        const char *p1 = strstr(resp, ",")+1;
+        const char *p2 = strstr(p1, "-");
+        size_t len = p2-p1;
+        cellTime = (char*)malloc(sizeof(char)*(len+1));
+        strncpy(cellTime, p1, len);
+        cellTime[len] = '\0';
+    }
+    else{
+        printf("Time is (error): %s\r\n", resp);  
+    }
+}
+bool GPRS::join()
+{
+    char cmd[64];
+    char ipAddr[32];
+    char resp[96];
+    
+    printf(">>>>AT+CREG?\r\n");
+    sendCmd("AT+CREG?\r\n");
+    cleanBuffer(resp,96);
+    readBuffer(resp,96,DEFAULT_TIMEOUT);
+    if(NULL != strstr(resp,"+CREG: 0,1")) {
+        printf("Response: -%s-", resp);
+    }
+    else{
+        printf("Response: -%s-", resp);
+        return false;       
+    }
+    
+    //check if need to attach the device
+    printf(">>>>AT+CGATT?\r\n");
+    sendCmd("AT+CGATT?\r\n");
+    cleanBuffer(resp,96);
+    readBuffer(resp,96,DEFAULT_TIMEOUT);
+    if(NULL != strstr(resp,"+CGATT: 1")) {
+        printf("Response: -%s-", resp);
+    }
+    else{
+        printf("Response: -%s-", resp);
+        return false;    
+    }
+    //check the signal quality
+    printf(">>>>AT+CSQ?\r\n");
+    sendCmd("AT+CSQ?\r\n");
+    cleanBuffer(resp,96);
+    readBuffer(resp,96,DEFAULT_TIMEOUT);
+    printf("Response: -%s-", resp);
+    
+    //close any existing connections
+    printf(">>>>AT+CIPSHUT\r\n");
+    sendCmd("AT+CIPSHUT\r\n");
+    cleanBuffer(resp,96);
+    readBuffer(resp,96,DEFAULT_TIMEOUT);
+    if(NULL != strstr(resp,"OK")) {
+    }
+    else{
+        return false;    
+    }
+    //check the ip Status
+    printf(">>>>AT+CIPSTATUS\r\n");
+    sendCmd("AT+CIPSTATUS\r\n");
+    cleanBuffer(resp,96);
+    readBuffer(resp,96,DEFAULT_TIMEOUT);
+    if(NULL != strstr(resp,"GPRSACT")) {
+        //Get local IP address
+        printf(">>>>AT+CIFSR\r\n");
+        sendCmd("AT+CIFSR\r\n");
+        readBuffer(ipAddr,32,2);
+        printf(">>>>AT+CIFSR returns: %s\r\n", ipAddr);
+        if(NULL != strstr(ipAddr,".")) {
+            _ip = str_to_ip(ipAddr+12);
+            if(_ip != 0) {
+                return true;
+            }
+        }
+    }
+    else if(NULL != strstr(resp,"INITIAL")){
+        printf("Response: -%s-", resp);
+        
+    }
+    else if(NULL != strstr(resp,"CONNECT OK")){
+        printf("Response: -%s-", resp);
+        
+    }
+    else if(NULL != strstr(resp,"START")){
+        
+        //Get local IP address
+        printf(">>>>AT+CIFSR\r\n");
+        sendCmd("AT+CIFSR\r\n");
+        readBuffer(ipAddr,32,2);
+        printf(">>>>AT+CIFSR returns: %s\r\n", ipAddr);
+        if(NULL != strstr(ipAddr,".")) {
+            _ip = str_to_ip(ipAddr+12);
+            if(_ip != 0) {
+                return true;
+            }
+        }
+    }
+    else{
+        printf("Response: -%s-", resp);
+        return false;    
+    }
+    
+    //single connection
+    printf(">>>>AT+CIPMUX=0\r\n");
+    sendCmd("AT+CIPMUX=0\r\n");
+    cleanBuffer(resp,96);
+    readBuffer(resp,96,DEFAULT_TIMEOUT);
+    if(NULL != strstr(resp,"OK")) {
+        printf("Response: -%s-", resp);
+    }
+    else{
+        printf("Response: -%s-", resp);
+        return false;    
+    }
+    
+    //set APN
+    snprintf(cmd,sizeof(cmd),"AT+CSTT=\"%s\",\"%s\",\"%s\"\r\n",_apn,_userName,_passWord);
+    printf(">>>>%s",cmd);
+    //sendCmdAndWaitForResp(cmd, "OK", DEFAULT_TIMEOUT,CMD);
+    sendCmd(cmd);
+    cleanBuffer(resp,96);
+    readBuffer(resp,96,DEFAULT_TIMEOUT);
+    if(NULL != strstr(resp,"OK")) {
+        printf("Response: -%s-", resp);
+    }
+    else{
+        printf("Response: -%s-", resp);
+        return false;    
+    }
+    //Brings up wireless connection
+    printf(">>>>AT+CIICR\r\n");
+    sendCmd("AT+CIICR\r\n");
+    cleanBuffer(resp,96);
+    readBuffer(resp,96,DEFAULT_TIMEOUT*3);
+    if(NULL != strstr(resp,"OK")) {
+        printf("Response: -%s-", resp);
+    }
+    else{
+        printf("Response: -%s-", resp);
+        return false;    
+    }
+    
+    //Get local IP address
+    printf(">>>>AT+CIFSR\r\n");
+    sendCmd("AT+CIFSR\r\n");
+    readBuffer(ipAddr,32,2);
+    printf(">>>>AT+CIFSR returns: %s\r\n", ipAddr);
+    if(NULL != strstr(ipAddr,".")) {
+        _ip = str_to_ip(ipAddr+12);
+        if(_ip != 0) {
+            return true;
+        }
+    }
+        printf(">>>>AT+CIPQSEND=1\r\n");
+        sendCmd("AT+CIPQSEND=1\r\n");
+        cleanBuffer(resp,96);
+        readBuffer(resp,96,DEFAULT_TIMEOUT);
+        if(NULL != strstr(resp,"OK")) {
+            printf("Response: -%s-", resp);
+        }
+        else{
+            printf("Response: -%s-", resp);
+            return false;    
+        }
+    return false;
+}
+
+bool GPRS::setProtocol(int socket, Protocol p)
+{
+    if (socket < 0 || socket > MAX_SOCK_NUM-1) {
+        return false;
+    }
+    //ToDo: setProtocol
+    return true;
+}
+
+bool GPRS::connect(int socket, Protocol ptl,const char * host, int port, int timeout)
+{
+    char cmd[64];
+    char resp[96];
+    if (socket < 0 || socket > MAX_SOCK_NUM-1) {
+        return false;
+    }
+    if(ptl == TCP) {
+        sprintf(cmd, "AT+CIPSTART=\"TCP\",\"%s\",\"%d\"\r\n", host, port);
+    } else if(ptl == UDP) {
+        sprintf(cmd, "AT+CIPSTART=%d,\"UDP\",\"%s\",%d\r\n",socket, host, port);
+    } else {
+        return false;
+    }
+
+    printf("CONNECT: %s", cmd);
+    sendCmd(cmd);
+    cleanBuffer(resp,96);
+    readBuffer(resp,96,DEFAULT_TIMEOUT);
+    if(NULL != strstr(resp,"CONNECT")) { //ALREADY CONNECT or CONNECT OK
+        printf("SUCCESS: %s\r\n", resp);
+        
+        return true;
+    }
+    printf("FAILURE: %s\r\n", resp);
+    return false;//ERROR
+}
+
+bool GPRS::gethostbyname(const char* host, uint32_t* ip)
+{
+    uint32_t addr = str_to_ip(host);
+    char buf[17];
+    snprintf(buf, sizeof(buf), "%d.%d.%d.%d", (addr>>24)&0xff, (addr>>16)&0xff, (addr>>8)&0xff, addr&0xff);
+    if (strcmp(buf, host) == 0) {
+        *ip = addr;
+        return true;
+    }
+    return false;
+}
+
+bool GPRS::disconnect()
+{
+    char resp[96];
+    printf(">>>AT+CIPSHUT\r\n");
+    sendCmd("AT+CIPSHUT\r\n");
+    readBuffer(resp,96,DEFAULT_TIMEOUT);
+    if(NULL != strstr(resp,"SHUT OK")) { //ALREADY CONNECT or CONNECT OK
+        printf("Response: %s\r\n", resp);
+    }
+    else{
+        printf("Response: %s\r\n", resp);
+        return false;    
+    }
+    return true;
+}
+
+bool GPRS::is_connected(int socket)
+{
+    char cmd[16];
+    char resp[96];
+    snprintf(cmd,16,"AT+CIPSTATUS\r\n");
+    sendCmd(cmd);
+    readBuffer(resp,sizeof(resp),DEFAULT_TIMEOUT);
+    if(NULL != strstr(resp,"CONNECT OK")) {
+        printf("Response -%s-\r\n", resp);
+        return true;
+    } else {
+        printf("Fail Response -%s-\r\n", resp);
+        return false;
+    }
+}
+
+void GPRS::reset()
+{
+}
+
+bool GPRS::close(int socket)
+{
+    char cmd[16];
+    char resp[16];
+
+    if (socket < 0 || socket > MAX_SOCK_NUM-1) {
+        return false;
+    }
+    // if not connected, return
+    if (is_connected(socket) == false) {
+        return true;
+    }
+    snprintf(cmd, sizeof(cmd),"AT+CIPCLOSE=%d\r\n",socket);
+    snprintf(resp,sizeof(resp),"%d, CLOSE OK",socket);
+    if(0 != sendCmdAndWaitForResp(cmd, resp, DEFAULT_TIMEOUT,CMD)) {
+        return false;
+    }
+    return true;
+}
+
+bool GPRS::readable(void)
+{
+    return readable();
+}
+
+int GPRS::wait_readable(int socket, int wait_time)
+{
+    if (socket < 0 || socket > MAX_SOCK_NUM-1) {
+        return -1;
+    }
+    char resp[16];
+    snprintf(resp,sizeof(resp),"\r\n\r\n+RECEIVE,%d",socket);//"+RECEIVE:<socketID>,<length>"
+    int len = strlen(resp);
+
+    if(false == respCmp(resp,len,wait_time)) {
+        return -1;
+    }
+    char c = readByte();//','
+    char dataLen[4];
+    int i = 0;
+    c = readByte();
+    while((c >= '0') && (c <= '9')) {
+        dataLen[i++] = c;
+        c = readByte();
+    }
+    c = readByte();//'\n'
+    len = atoi(dataLen);
+    return len;
+}
+
+int GPRS::wait_writeable(int socket, int req_size)
+{
+    if (socket < 0 || socket > MAX_SOCK_NUM-1) {
+        return -1;
+    }
+    return req_size>256?256:req_size+1;
+}
+
+int GPRS::send(int socket, const char * str, int len)
+{
+    if (socket < 0 || socket > MAX_SOCK_NUM-1) {
+        return -1;
+    }
+    char cmd[32];
+    if(len > 0){
+        //printf("Sending data: %s\r\n", str);
+        snprintf(cmd,sizeof(cmd),"AT+CIPSEND\r\n");
+        if(0 != sendCmdAndWaitForResp(cmd,">",1,CMD)) {
+            printf("Couldn't send data!!");
+            return false;
+        }
+        sendCmd(str);
+        serialModem.putc((char)0x1a);
+        
+    }
+    return len;
+}
+
+int GPRS::recv(int socket, char* buf, int len)
+{
+    if (socket < 0 || socket > MAX_SOCK_NUM-1) {
+        return -1;
+    }
+    cleanBuffer(buf,len);
+    readBuffer(buf,len,DEFAULT_TIMEOUT/2);
+    return len;
+    //return strlen(buf);
+}
+
+int GPRS::new_socket()
+{
+    socketID = 0; //we only support one socket.
+    return socketID; 
+}
+
+uint16_t GPRS::new_port()
+{
+    uint16_t port = rand();
+    port |= 49152;
+    return port;
+}
+
+uint32_t GPRS::str_to_ip(const char* str)
+{
+    uint32_t ip = 0;
+    char* p = (char*)str;
+    for(int i = 0; i < 4; i++) {
+        ip |= atoi(p);
+        p = strchr(p, '.');
+        if (p == NULL) {
+            break;
+        }
+        ip <<= 8;
+        p++;
+    }
+    return ip;
+}
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/GPRS.h	Sat Dec 19 21:57:28 2015 +0000
@@ -0,0 +1,170 @@
+/*
+  GPRS.h
+  2014 Copyright (c) Seeed Technology Inc.  All right reserved.
+
+  Author:lawliet zou(lawliet.zou@gmail.com)
+  2014-2-24
+
+  This library 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 library 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 library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#ifndef __GPRS_H__
+#define __GPRS_H__
+
+#include "mbed.h"
+#include "modem.h"
+
+#define DEFAULT_WAIT_RESP_TIMEOUT 500
+#define MAX_SOCK_NUM 7 //(0~6)
+#define FIELD_BOX 0
+enum Protocol {
+    CLOSED = 0,
+    TCP    = 1,
+    UDP    = 2,
+};
+
+/** The GPRS class
+ *
+ */
+class GPRS: public Modem
+{
+
+public:
+    /**	Constructor
+     *	@param tx mbed pin to use for tx line of Serial interface
+     * 	@param rx mbed pin to use for rx line of Serial interface
+     * 	@param baudRate serial communicate baud rate
+     * 	@param apn name of the gateway for GPRS to connect to the network
+     * 	@param userName apn's username, usually is NULL
+     * 	@param passWord apn's password, usually is NULL
+     */
+    GPRS(PinName tx, PinName rx, int baudRate, const char* apn, const char* userName = NULL, const char *passWord = NULL);
+
+    /** Get instance of GPRS class
+     */
+    static GPRS* getInstance() {
+        return inst;
+    };
+
+    /**	Connect the GPRS module to the network.
+     * 	@return true if connected, false otherwise
+     */
+    bool join(void);
+	// added by Noah Milam
+	void start_server();
+	void send_SMS(char*, char*);
+	char* read_SMS();
+	void listen_server();
+	
+	// end of what Noah Milam added
+    /** Disconnect the GPRS module from the network
+     * 	@returns true if successful
+     */
+    bool disconnect(void);
+    
+    /** Close a tcp connection
+     * 	@returns true if successful
+     */
+    bool close(int socket);
+
+    /** Open a tcp/udp connection with the specified host on the specified port
+     * 	@param socket an endpoint of an inter-process communication flow of GPRS module,for SIM900 module, it is in [0,6]
+     * 	@param ptl protocol for socket, TCP/UDP can be choosen
+     * 	@param host host (can be either an ip address or a name. If a name is provided, a dns request will be established)
+     * 	@param port port
+     * 	@param timeout wait seconds till connected
+     * 	@returns true if successful
+     */
+    bool connect(int socket, Protocol ptl, const char * host, int port, int timeout = DEFAULT_TIMEOUT);
+
+    /** Set the protocol (UDP or TCP)
+     * 	@param socket socket
+     * 	@param p protocol
+     * 	@returns true if successful
+     */
+    bool setProtocol(int socket, Protocol p);
+
+    /** Reset the GPRS module
+     */
+    void reset();
+
+    /**	Check if GPRS module is readable or not
+     *	@returns true if readable
+     */
+    bool readable(void);
+
+    /**	Wait a few time to check if GPRS module is readable or not
+     *	@param socket socket
+     *	@param wait_time time of waiting
+     */
+    int wait_readable(int socket, int wait_time);
+
+    /**	Wait a few time to check if GPRS module is writeable or not
+     *	@param socket socket
+     *	@param wait_time time of waiting
+     */
+    int wait_writeable(int socket, int req_size);
+
+    /** Check if a tcp link is active
+     * 	@returns true if successful
+     */
+    bool is_connected(int socket);
+
+    /** Send data to socket
+     *	@param socket socket
+     *	@param str string to be sent
+     * 	@param len string length
+     * 	@returns return bytes that actually been send
+     */
+    int send(int socket, const char * str, int len);
+
+    /** Read data from socket
+     * 	@param socket socket
+     *	@param buf buffer that will store the data read from socket
+     *	@param len string length need to read from socket
+     *	@returns bytes that actually read
+     */
+    int recv(int socket, char* buf, int len);
+
+    /** Convert the host to ip
+     *  @param host host ip string, ex. 10.11.12.13
+     *  @param ip long int ip address, ex. 0x11223344
+     *  @returns true if successful
+     */
+    bool gethostbyname(const char* host, uint32_t* ip);
+	
+	/** get the cell tower time */
+	char* getCellTime();
+	/** set the cell time */
+	void setCellTime();
+    int new_socket();
+    uint16_t new_port();
+    uint32_t _ip;
+    char *phoneNumber;
+    char* cellTime;
+	bool preInit();
+protected:
+
+    
+    bool checkSIMStatus(void);
+    uint32_t str_to_ip(const char* str);
+    static GPRS* inst;
+    int socketID;
+    const char* _apn;
+    const char* _userName;
+    const char* _passWord;
+};
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/modem/modem.cpp	Sat Dec 19 21:57:28 2015 +0000
@@ -0,0 +1,250 @@
+/*
+  modem.cpp
+  2014 Copyright (c) Seeed Technology Inc.  All right reserved.
+
+  Author:lawliet zou(lawliet.zou@gmail.com)
+  2014-2-24
+
+  This library 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 library 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 library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#include "modem.h"
+//Serial pc(USBTX,USBRX);
+extern SDFileSystem sd; //MOSI, MISO, SCLK, SSEL. Tested on K64F, correct pins.
+AnalogIn LM35(PTB2);
+// added by Noah Milam
+void Modem::gprs_response()
+{
+    printf("\nlistening for client\n");
+    char buffer[100];
+    int count = 0;
+   
+    mkdir("/sd/mydir", 0777); // makes directory if needed
+    FILE *fp = fopen("/sd/mydir/chemData.csv", "w"); // creats new file to write
+    fprintf(fp,"phone Number,chem data, latitude,longitude\n"); // writes in a header for the table
+    fclose(fp); // closes file
+    
+    while(1)
+    { if(serialModem.readable()) {
+             
+            while(serialModem.readable()) {
+                char c = serialModem.getc();
+                buffer[count++] = c;
+                //pc.puts(&c);
+                if(count == 64) break;
+            }
+            
+            if(buffer[0] != '\0'){
+                buffer[count] = '\0';
+                FILE *fp = fopen("/sd/mydir/chemicalData.csv", "a"); // opens file to append it
+                fprintf(fp,"%s\n",buffer);//writes to file
+                fclose(fp); // closes file
+            
+                printf("%s \n",buffer); 
+                for(int i = 0; i < count+2; i++) {
+                    buffer[i] = NULL;
+                }
+            }
+            count = 0;
+        }
+    }
+}
+
+void Modem::wait_for_sms(){
+    printf("waiting for message\n");
+    while(1){
+        if(serialModem.readable()){
+            return;
+        }    
+    }
+}
+void Modem::get_message(){
+    char tempStr[30];
+    int count= 0;
+    int line_count = 0;
+    for(int i= 0;i < strlen(IPAdd);i++){
+            if(line_count == 3){
+                tempStr[count++] = IPAdd[i];    
+            }
+            if(IPAdd[i] == '\n'){
+                line_count++;
+            }
+    } 
+    tempStr[count - 2] = '\0';
+    count++;
+    strncpy(IPAdd, tempStr, count);
+   printf("IP Addr > %s \n", IPAdd);
+   printf("text size > %d\n",strlen(IPAdd));
+ } 
+void Modem::storeResp(){
+    char buffer[100];
+     int count = 0;
+     timeCnt.start();
+     while(timeCnt.read() < 5)
+     {  
+       while(serialModem.readable()) {
+            char c = serialModem.getc();
+                buffer[count++] = c;
+        }
+    }
+    timeCnt.stop();
+    timeCnt.reset();
+    buffer[count] = '\0';
+
+     strncpy(IPAdd, buffer, count);
+    printf("original>> %s",IPAdd);
+   printf("size of text > %d",strlen(IPAdd));
+    count = 0;
+    get_message();
+}   
+
+char* Modem::get_server_IP(){
+    return IPAdd;
+}
+//end added by Noah Milam
+char Modem::readByte(void)
+{
+    return serialModem.getc();
+}
+
+bool Modem::readable()
+{
+    return serialModem.readable();
+}
+
+int Modem::readBuffer(char *buffer,int count, unsigned int timeOut)
+{
+    int i = 0;
+    timeCnt.start();
+    while(1) {
+        while (serialModem.readable()) {
+            char c = serialModem.getc();
+            buffer[i++] = c;
+            if(i >= count)break;
+        }
+        if(i >= count)break;
+        if(timeCnt.read() > timeOut) {
+            timeCnt.stop();
+            timeCnt.reset();
+            break;
+        }
+    }
+    return 0;
+}
+
+void Modem::cleanBuffer(char *buffer, int count)
+{
+    for(int i=0; i < count; i++) {
+        buffer[i] = '\0';
+    }
+}
+
+void Modem::sendCmd(const char* cmd)
+{
+    serialModem.puts(cmd);
+}
+void Modem::sendCmdResp(const char* cmd)
+{
+    serialModem.puts(cmd);
+    getResp();
+}
+void Modem::getResp()
+{
+   char buffer[1000];
+     int count = 0;
+     timeCnt.start();
+     while(timeCnt.read() < 5)
+     { while(serialModem.readable()) {
+            char c = serialModem.getc();
+            buffer[count++] = c;
+            }
+        }
+       timeCnt.stop();
+       timeCnt.reset();
+       buffer[count] = '\0';
+       printf("Response:--%s--\r\n",buffer);
+        for(int i = 0; i < count+2; i++) {
+                buffer[i] = NULL;
+            }
+            count = 0;
+}
+
+
+void Modem::sendATTest(void)
+{
+    sendCmdAndWaitForResp("AT\r\n","OK",DEFAULT_TIMEOUT,CMD);
+}
+
+bool Modem::respCmp(const char *resp, unsigned int len, unsigned int timeout)
+{
+    int sum=0;
+    timeCnt.start();
+
+    while(1) {
+        if(serialModem.readable()) {
+            char c = serialModem.getc();
+            sum = (c==resp[sum]) ? sum+1 : 0;
+            if(sum == len)break;
+        }
+        if(timeCnt.read() > timeout) {
+            timeCnt.stop();
+            timeCnt.reset();
+            return false;
+        }
+    }
+    timeCnt.stop();
+    timeCnt.reset();
+
+    return true;
+}
+
+int Modem::waitForResp(const char *resp, unsigned int timeout,DataType type)
+{
+    int len = strlen(resp);
+    int sum=0;
+    timeCnt.start();
+
+    while(1) {
+        if(serialModem.readable()) {
+            char c = serialModem.getc();         
+            sum = (c==resp[sum]) ? sum+1 : 0;
+            if(sum == len)break;
+        }
+        if(timeCnt.read() > timeout) {
+            timeCnt.stop();
+            timeCnt.reset();
+            return -1;
+        }
+    }
+    
+    timeCnt.stop();
+    timeCnt.reset();
+    
+    if(type == CMD) {
+        while(serialModem.readable()) {
+            char c = serialModem.getc();
+        }
+        
+    }
+    return 0;
+}
+
+int Modem::sendCmdAndWaitForResp(const char* data, const char *resp, unsigned timeout,DataType type)
+{
+    sendCmd(data);
+    int response = waitForResp(resp,timeout,type);
+    printf("Response: --%s--\r\n", resp);
+    return response;
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/modem/modem.h	Sat Dec 19 21:57:28 2015 +0000
@@ -0,0 +1,137 @@
+/*
+  modem.h
+  2014 Copyright (c) Seeed Technology Inc.  All right reserved.
+
+  Author:lawliet zou(lawliet.zou@gmail.com)
+  2014-2-24
+
+  This library 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 library 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 library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#ifndef __MODEM_H__
+#define __MODEM_H__
+
+#include "mbed.h"
+#include "SDFileSystem.h"
+#define DEFAULT_TIMEOUT 1
+
+enum DataType {
+    CMD		= 0,
+    DATA	= 1,
+};
+
+/** Modem class.
+ *  Used for Modem communication. attention that Modem module communicate with MCU in serial protocol
+ */
+class Modem
+{
+
+public:
+    /**	Create Modem Instance
+     *  @param tx	uart transmit pin to communicate with Modem
+     *  @param rx	uart receive pin to communicate with Modem
+     *  @param baudRate	baud rate of uart communication
+     */
+    Modem(PinName tx, PinName rx, int baudRate) : serialModem(tx, rx) {
+        serialModem.baud(baudRate);
+    };
+    // added by Noah Milam
+    char IPAdd[100];
+    void sendCmdResp(const char*);
+	void getResp();
+	void gprs_response();
+	void storeResp();
+	void wait_for_sms();
+	void get_message();
+	char* get_server_IP();
+	//
+	Serial serialModem;
+protected:
+    /** Power on Modem
+     */
+    void preInit(void);
+
+    /** check serialModem is readable or not
+     *	@returns
+     *		true on readable
+     *		false on not readable
+     */
+    bool readable();
+
+    /** read one byte from serialModem
+     *	@returns
+     *		one byte read from serialModem
+     */
+    char readByte(void);
+
+    /** read from Modem module and save to buffer array
+     *  @param  buffer	buffer array to save what read from Modem module
+     *  @param  count 	the maximal bytes number read from Modem module
+     *  @param  timeOut	time to wait for reading from Modem module
+     *  @returns
+     *      0 on success
+     *      -1 on error
+     */
+    int readBuffer(char* buffer,int count, unsigned int timeOut);
+
+
+    /** clean Buffer
+     *	@param buffer	buffer to clean
+     *	@param count	number of bytes to clean
+     */
+    void cleanBuffer(char* buffer, int count);
+
+    /** send AT command to Modem module
+     *  @param cmd	command array which will be send to GPRS module
+     */
+    void sendCmd(const char* cmd);
+
+    /**send "AT" to Modem module
+     */
+    void sendATTest(void);
+
+    /**	compare the response from GPRS module with a string
+     *	@param resp	buffer to be compared
+     *	@param len length that will be compared
+     *	@param timeout	waiting seconds till timeout
+     */
+    bool respCmp(const char *resp, unsigned int len, unsigned int timeout);
+
+    /** check Modem module response before time out
+     *  @param  *resp   correct response which Modem module will return
+     *  @param  *timeout    waiting seconds till timeout
+     *  @returns
+     *      0 on success
+     *      -1 on error
+     */
+    int waitForResp(const char *resp, unsigned int timeout,DataType type);
+
+    /** send AT command to GPRS module and wait for correct response
+     *  @param  *cmd 	AT command which will be send to GPRS module
+     *  @param  *resp   correct response which GPRS module will return
+     *  @param  *timeout 	waiting seconds till timeout
+     *  @returns
+     *      0 on success
+     *      -1 on error
+     */
+    int sendCmdAndWaitForResp(const char* data, const char *resp, unsigned timeout,DataType type);
+
+    Timer timeCnt;
+
+private:
+
+};
+
+#endif