Diff: Cellular/EasyIP.cpp

Revision:

31:529db15abda7

Parent:

30:1326b623919a

Child:

32:7d5581159bed

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Cellular/EasyIP.cpp	Mon Jul 14 21:11:50 2014 +0000
@@ -0,0 +1,780 @@
+// This is a template from UIP.cpp for now, will modify code and implement it as I go
+
+
+
+#include "mbed.h"
+#include "EasyIP.h"
+#include "MTSText.h"
+#include "MTSLog.h"
+#include "CellUtils.h"
+
+
+
+using namespace mts;
+
+bool EasyIP::sendEscapeCommand()
+{
+    //string Cellular::sendCommand(const std::string& command, unsigned int timeoutMillis, char esc)
+    if(io == NULL) {
+        logError("MTSBufferedIO not set");
+        return false;
+    }
+    if(!socketOpened) {
+        logError("Socket is not open. Can not send AT escape sequence (+++)");
+        return false;
+    }
+    
+    if(!socketCloseable) {
+        logError("Socket is not closeable");
+        return false;
+    }
+    
+    io->rxClear();
+    io->txClear();
+    
+    std::string result;
+    unsigned int timeoutMillis = 2000;
+    const int size_cmd = 3;
+    //Attempt to write command
+    wait(1); //Format for +++ command is 1 second wait, send +++, then another second wait
+             //1s wait after command is implemented as a polling function for 2 seconds
+             //Option: Could change wait periods to be longer/shorter (0-255)*50ms
+    if(io->write("+++", size_cmd, timeoutMillis) != size_cmd) {
+        //Failed to write command
+        logError("failed to send command to radio within %d milliseconds", timeoutMillis);
+        return false;
+    }
+    
+    int timer = 0;
+    char tmp[256];
+    tmp[255] = 0;
+    bool done = false;
+    io->read(tmp,255,0);
+    bool exitmode = false;
+    
+    do {
+        wait(0.1);
+        timer += 100;
+        //Make a non-blocking read call by passing timeout of zero
+            int size = io->read(tmp,255,0);    //1 less than allocated (timeout is instant)
+            if(size > 0) {
+                result.append(tmp, size);
+            }
+        if(result.find("OK") != std::string::npos) {
+            exitmode = true;
+            done = true;
+        } else if(result.find("NO CARRIER") != std::string::npos) {
+            exitmode = true;
+            done = true;
+        } else if(result.find("ERROR") != std::string::npos) {
+            exitmode = false;
+            done = true;
+        }
+        if(timer >= timeoutMillis) {
+            logDebug("Escape sequence [+++] timed out after %d milliseconds", timeoutMillis);
+            exitmode = true;
+            done = true;
+        }
+    } while (!done);
+    
+    return exitmode;
+}
+
+bool EasyIP::socketCheck() {
+    bool status = false;
+    std::string socketInfo = "9"; //9 is unrecognized
+    std::vector<std::string> params;
+    
+    if(sendEscapeCommand()) {
+        socketOpened = false;
+        if(sendBasicCommand("AT", 1000) == MTS_SUCCESS) {
+            socketInfo = sendCommand("AT#SS=1", 2000);
+            if(socketInfo.find("OK") != std::string::npos) {
+                //Found valid response
+                params = Text::split(socketInfo, "\r\n");
+                params = Text::split(params[1], ",");
+                socketInfo = params[1];
+                //Check comparison of params[1] to response codes
+            } else {
+                logError("Could not determine socket status[%s]",socketInfo.c_str());
+                socketInfo == "9"; //9 is unrecognized
+            }
+        }
+    } else {
+        status = false; //Return value of socketOpened when checking
+    }
+    //Check socket status query
+    if(socketInfo == "2" || socketInfo == "3" || socketInfo == "1" || socketInfo == "4") {
+        status = true; //2 and 3 are suspended connections
+    } else if(socketInfo == "0" || socketInfo == "5") {
+        status = false; //0 is closed socket, probably won't occur
+    } else {
+        logError("Could not determine socket status");
+        status = false; //anything else is unknown status
+    }
+    
+    if(status) {
+        std::string reconnect = sendCommand("AT#SO=1", 2000);
+        if(reconnect.find("CONNECT") != std::string::npos || reconnect.find("OK") != std::string::npos) {
+        } else {
+            logError("Failed to resume socket connection");
+        }
+    }
+    return status;
+}
+
+EasyIP::EasyIP(Radio type)
+{
+    //Not sure how the construction process is done, 
+    //but assuming it works for both EasyIP and UIP the same way.
+    this->type = type;
+    io = NULL;
+    dcd = NULL;
+    dtr = NULL;
+    resetLine = NULL;
+    echoMode = true;
+    pppConnected = false;
+    socketMode = TCP;
+    socketOpened = false;
+    socketCloseable = true;
+    local_port = 0;
+    local_address = "";
+    host_port = 0;
+}
+
+EasyIP::~EasyIP()
+{
+    //Same reasoning for the destructor as the constructor,
+    //assuming it works for UIP, it will work for EasyIP
+    if (dtr != NULL) {
+        dtr->write(1);
+    }
+    
+    delete dcd;
+    delete dtr;
+    delete resetLine;
+}
+
+//Initializes the MTS IO Buffer
+bool EasyIP::init(MTSBufferedIO* io)
+{
+    if (! Cellular::init(io)) {
+        return false;
+    }
+
+    logDebug("radio type: %s", Cellular::getRadioNames(type).c_str());
+    return true;
+}
+
+bool EasyIP::connect()
+{
+    //Check if APN is not set, if so, connect will not work.
+    if (type == MTSMC_H5_IP || type == MTSMC_H5 || type == MTSMC_G3) {
+        if(apn.size() == 0) {
+            logDebug("APN is not set");
+            return false;
+        }
+    }
+    
+    //Check if socket is open
+    //flag stored in Cellular.h
+    if(socketOpened) {
+        return true;
+    }
+
+    //Check if already connected
+    //by calling the function isConnected() in EasyIP.cpp
+    if(isConnected()) {
+        return true;
+    }
+    //Create an mbed timer object
+    Timer tmr;
+    //Check Registration: AT+CREG? == 0,1
+    //(Does the AT command inside Cellular class)
+    tmr.start();
+    do {
+        Registration registration = getRegistration();
+        if(registration != REGISTERED) {
+            logTrace("Not Registered [%d] ... waiting", (int)registration);
+            wait(1);
+        } else {
+            break;
+        }
+    } while(tmr.read() < 30); 
+    //Check RSSI: AT+CSQ
+    //Does the command inside Cellular
+    tmr.reset();
+    do {
+        int rssi = getSignalStrength();
+        logDebug("Signal strength: %d", rssi);
+        if((rssi == 99) || (rssi == -1)) {
+            logTrace("No Signal ... waiting");
+            wait(1);
+        } else {
+            break;
+        }
+    } while(tmr.read() < 30);
+
+    //Similar to AT#CONNECTIONSTART: Make a PPP connection
+    if (type == MTSMC_H5 || type == MTSMC_G3) {
+        logDebug("Making PPP Connection Attempt. APN[%s]", apn.c_str());
+    } else {
+        logDebug("Making PPP Connection Attempt");
+    }
+    //The main thing going on; Sends the AT command to start a connection
+    //Assuming context is already stored in the modem
+    std::string pppResult = sendCommand("AT#SGACT=1,1", 2000);
+    std::vector<std::string> parts;
+    if(pppResult.find("OK") != std::string::npos) {
+        parts = Text::split(pppResult, "\r\n");
+        if(parts.size() >= 2) {
+            parts = Text::split(parts[1], " ");
+            local_address = parts[1];
+        }
+        logInfo("PPP Connection Established: IP[%s]", local_address.c_str());
+        pppConnected = true;
+
+    } else {
+        pppResult = sendCommand("AT#SGACT?", 2000);
+        if(pppResult.empty() || (pppResult.find("ERROR") != std::string::npos)) {
+            pppConnected = false;
+        } else {
+            if(pppResult.find("1,1") != std::string::npos) {
+                pppConnected = true;
+            } else {
+                pppConnected = false;
+            }
+        }
+    }
+
+    return pppConnected;
+}
+
+void EasyIP::disconnect()
+{
+    //AT#SGACT=1,0: Close a PPP connection
+    logDebug("Closing PPP Connection");    
+    if(socketOpened) {
+        if(!close()) { //Calls another EasyIP function to close socket before disconnect
+            logDebug("Failed to close socket for disconnect");
+            return; //Can't close connection without AT commands
+                    //(and thus need socket closed)
+        }
+    }
+    //Sends AT#SGACT=1,0 command
+    if(sendBasicCommand("AT#SGACT=1,0", 1000) == MTS_SUCCESS) {
+        pppConnected = false;
+        logDebug("Successfully closed PPP Connection");
+    }
+    pppConnected = false; //Cell will drop connection if we go silent
+    return;
+}
+
+bool EasyIP::isConnected()
+{
+    std::string stateString;
+    std::vector<std::string> pieces;
+    //state flags for various connection checks
+    bool signal = false, regist = false, active = false;
+    
+    //1) Check if APN was set if we're on an HSPA radio
+    if (type == MTSMC_H5_IP || type == MTSMC_H5 || type == MTSMC_G3) {
+        if(apn.size() == 0) {
+            logDebug("APN is not set");
+            return false;
+        }
+    }
+    
+    //2) Check that we do not have a live connection up
+    if(socketOpened) {
+        logDebug("Socket is opened");
+        return true;
+    }
+    
+    
+    //3) Query the radio
+    //Check antenna signal
+    std::string reply = sendCommand("AT+CSQ", 500);
+    if(reply.empty() || (reply.find("ERROR") != std::string::npos)) {
+        signal = false;
+    } else {
+        pieces = Text::split(reply, "\r\n");
+        if(pieces.size() >= 2) {
+            pieces = Text::split(pieces[1], " ");
+            if(pieces.size() >= 2) {
+                if((pieces[1].find("0,0") != std::string::npos) || (pieces[1].find("99,99") != std::string::npos)) {
+                    signal = false;
+                } else {
+                    signal = true;
+                }
+            }
+        }
+    }
+    
+    //Check cell tower registration
+    reply = sendCommand("AT+CREG?", 500);
+    if(reply.empty() || (reply.find("ERROR") != std::string::npos)) {
+        regist = false;
+    } else {
+        pieces = Text::split(reply, "\r\n");
+        if(pieces.size() >= 2) {
+            pieces = Text::split(pieces[1], " ");
+            if(pieces.size() >= 2) {
+                if((pieces[1].find("0,1") != std::string::npos) || (pieces[1].find("0,5") != std::string::npos)) {
+                    regist = true; //1 for connected, 5 for roaming connected
+                } else {
+                    regist = false; //Cell tower not registered
+                }
+            }
+        }
+    }
+    
+    //Check active mode (SGACT = 1,1)
+    reply = sendCommand("AT#SGACT?", 500);
+    if(reply.empty() || (reply.find("ERROR") != std::string::npos)) {
+        active = false;
+    } else {
+        pieces = Text::split(reply, "\r\n");
+        if(pieces.size() >= 2) {
+            pieces = Text::split(pieces[1], " ");
+            if(pieces.size() >= 2) {
+                if(pieces[1].find("1,1") != std::string::npos) {
+                    active = true; //1 for an active connection mode
+                } else {
+                    active = false; //0, or unknown value, is an inactive connection mode
+                }
+            }
+        }
+    }
+    //4) Determine radio state
+    if(regist && signal) {
+        if(pppConnected) {
+            if(active) {
+                if(ping()) {
+                    stateString = "CONNECTED";
+                    pppConnected = true;
+                } else {
+                    stateString = "AUTHENTICATING";
+                    pppConnected = true;
+                    return false; //Return false instead of changing pppConnected due to the fact
+                                  //that it is connected to ppp, it just can't ping successfully
+                }
+            } else {
+                stateString = "DISCONNECTING";
+                pppConnected = false;
+            }
+        } else {
+            if(active) {
+                if(ping()) {
+                    pppConnected = true;
+                    logWarning("Internal PPP state tracking differs from radio (DISCONNECTED:CONNECTED)");
+                    stateString = "CONNECTED";
+                } else {
+                    stateString = "CONNECTING";
+                }
+            } else {
+                stateString = "IDLE";
+            }
+        }
+    } else if(regist != signal) {
+        stateString = "CHECKING";
+        pppConnected = false;
+    } else if(!regist && !signal) {
+        stateString = "DISCONNECTED";
+        pppConnected = false;
+    }
+    //Log results if necessary
+    if(stateString != "CONNECTED") {
+        logWarning("Internal PPP state tracking differs from radio (CONNECTED:%s)",stateString.c_str());
+    }
+    return pppConnected;
+}
+
+//Binds the socket to a specific port if able
+bool EasyIP::bind(unsigned int port)
+{
+    if(socketOpened) {
+        logError("socket is open. Can not set local port");
+        return false;
+    }
+    if(port > 65535) {
+        logError("port out of range (0-65535)");
+        return false;
+    }
+    local_port = port;
+    return true;
+}
+
+bool EasyIP::open(const std::string& address, unsigned int port, Mode mode)
+{
+    char sOpenSocketCmd[256] = {0}; //String for AT command
+    std::string sMode = "";
+    int typeSocket = 0;
+    int closeType = 0;
+    
+    //1) Check that we do not have a live connection up
+    if(socketOpened) {
+        //Check that the address, port, and mode match
+        if(host_address != address || host_port != port || socketMode != mode) {
+            if(socketMode == TCP) {
+                logError("TCP socket already opened [%s:%d]", host_address.c_str(), host_port);
+            } else {
+                logError("UDP socket already opened [%s:%d]", host_address.c_str(), host_port);
+            }
+            return false;
+        }
+
+        logDebug("Socket already opened");
+        return true;
+    }
+
+    //2) Check Parameters
+    if(port > 65535) {
+        logError("port out of range (0-65535)");
+        return false;
+    }
+
+    //3) Check PPP connection
+    if(!isConnected()) {
+        logError("PPP not established.  Attempting to connect");
+        if(!connect()) {
+            logError("PPP connection failed");
+            return false;
+        } else {
+            logDebug("PPP connection established");
+        }
+    }
+    //No way to "set" port except on socket call;
+    //Going to need to warn if local_port was not set.
+    if(!local_port) {
+        logDebug("No local port was set: 0");
+    }
+    
+    //4) Set escape sequence to not be transmitted
+    if(sendBasicCommand("AT#SKIPESC=1", 2000) != MTS_SUCCESS) {
+        logWarning("Failed to disable escape sequence transmission on data mode suspension");
+    }
+    
+    if(mode == TCP) {
+        typeSocket = 0;
+        sMode = "TCP";
+    } else {
+        typeSocket = 1;
+        sMode = "UDP";
+    }
+    
+    if(socketCloseable) {
+        closeType = 0;
+    } else {
+        closeType = 255;
+    }
+    //5) Open Socket  
+    sprintf(sOpenSocketCmd, "AT#SD=1,%d,%d,%s,%d,%d,0", typeSocket, port, address.c_str(),closeType , local_port);
+    std::string response = sendCommand(sOpenSocketCmd, 5000);
+    
+    if(response.find("CONNECT") != std::string::npos) {
+        host_address = address;
+        host_port = port;
+        
+        logInfo("Opened %s Socket [%s:%d]", sMode.c_str(), address.c_str(), port);
+        socketOpened = true;
+        socketMode = mode;
+    } else {
+        logWarning("Unable to open %s Socket [%s:%d]", sMode.c_str(), address.c_str(), port);
+        socketOpened = false;
+    }
+    
+    return socketOpened;
+}
+
+bool EasyIP::isOpen()
+{
+    if(io->readable()) {
+        logDebug("Assuming open, data available to read.\n\r");
+        return true;
+    }
+    return socketOpened;
+}
+
+bool EasyIP::close()
+{
+    
+    if(io == NULL) {
+        logError("MTSBufferedIO not set");
+        return false;
+    }
+
+    if(!socketOpened) {
+        logWarning("Socket close() called, but socket was not open");
+        return true;
+    }
+
+    if(!socketCloseable) {
+        logError("Socket is not closeable");
+        return false;
+    }
+    
+    if(!sendEscapeCommand()) {
+        logError("Failed to exit online mode");
+        return false;
+    } else {
+        socketOpened = false;
+    }
+    
+    if(sendBasicCommand("AT#SH=1", 2000) != MTS_SUCCESS) {
+        logDebug("Failed to close socket connection");
+    }
+    
+    Timer tmr;
+    int counter = 0;
+    char tmp[256];
+    tmr.start();
+    do {
+        if(socketOpened == false) {
+            break;
+        }
+        read(tmp, 256, 1000);
+    } while(counter++ < 10);
+
+    io->rxClear();
+    io->txClear();
+
+    return !socketOpened;
+}
+
+int EasyIP::read(char* data, int max, int timeout)
+{
+    if(io == NULL) {
+        logError("MTSBufferedIO not set");
+        return -1;
+    }
+
+    //Check that nothing is in the rx buffer
+    if(!socketOpened && !io->readable()) {
+        logError("Socket is not open");
+        return -1;
+    }
+
+    int bytesRead = 0;
+    
+
+    if(timeout >= 0) {
+        bytesRead = io->read(data, max, static_cast<unsigned int>(timeout));
+    } else {
+        bytesRead = io->read(data, max);
+    }
+    if(bytesRead > 0 && socketCloseable) {
+        //Scan for socket closed message
+        for(size_t i = 0; i < bytesRead; i++) {
+            if(data[i] == 'N') {
+                if(strstr(&data[i], "NO CARRIER")) {
+                    logTrace("Found socket closed message. Checking validity");
+                    //Close socket and Cut Off End of Message
+                    socketOpened = socketCheck(); //Verifies legitimacy of socket disconnect
+                    if(socketOpened) {
+                        logDebug("Socket still open");
+                        continue;
+                    } else {
+                        logDebug("Socket closed");
+                        data[i] = '\0';
+                        bytesRead = i;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    return bytesRead;
+}
+
+int EasyIP::write(const char* data, int length, int timeout)
+{
+    if(io == NULL) {
+        logError("MTSBufferedIO not set");
+        return -1;
+    }
+
+    if(!socketOpened) {
+        logError("Socket is not open");
+        return -1;
+    }
+
+    int bytesWritten = 0;
+    int size = length;
+    int failedWrites = 0;
+    if(timeout >= 0) {
+        Timer tmr;
+        tmr.start();
+        do {
+            int available = io->writeable();
+            if (available > 0) {
+                size = MIN(available, length - bytesWritten);
+                bytesWritten += io->write(&data[bytesWritten], size);
+            } else {
+                wait(0.05);
+            }
+        } while (tmr.read_ms() <= timeout && bytesWritten < length);
+    } else {
+        //If timeout is -1:
+        do {
+            int available = io->writeable();
+            if(available > 0) {
+                size = MIN(available, length - bytesWritten);
+                int currentWritten = io->write(&data[bytesWritten], size);
+                bytesWritten += currentWritten;
+                if(!currentWritten) {
+                    failedWrites++;
+                }
+                if(failedWrites > 10) {
+                    logError("Couldn't write any characters");
+                    return bytesWritten;
+                }
+            } else {
+                wait(0.05);
+            }
+        } while (bytesWritten < length); 
+    }
+    return bytesWritten;
+}
+
+unsigned int EasyIP::readable()
+{
+    if(io == NULL) {
+        logWarning("MTSBufferedIO not set");
+        return 0;
+    }
+    if(!socketOpened && !io->readable()) {
+        logWarning("Socket is not open");
+        return 0;
+    }
+    return io->readable();
+}
+
+unsigned int EasyIP::writeable()
+{
+    if(io == NULL) {
+        logWarning("MTSBufferedIO not set");
+        return 0;
+    }
+    if(!socketOpened) {
+        logWarning("Socket is not open");
+        return 0;
+    }
+
+    return io->writeable();
+}
+
+bool EasyIP::setDeviceIP(std::string address)
+{
+    if (address.compare("DHCP") == 0) {
+        return true;
+    } else {
+        logWarning("Radio does not support static IPs, using DHCP.\n\r");
+        return false;
+    }
+}
+
+Code EasyIP::setApn(const std::string& apn)
+{
+    if (type == MTSMC_H5 || type == MTSMC_G3) {
+         //Set IP,PPP,IPv6
+        Code code = sendBasicCommand("AT+CGDCONT=1,PPP," + apn, 1000);
+        if (code != MTS_SUCCESS) {
+            return code;
+        }
+        this->apn = apn;
+        return code; //This will return MTS_SUCCESS
+    } else {
+        logInfo("CDMA radios don't need an APN");
+        return MTS_SUCCESS;
+    }
+}
+
+void EasyIP::reset()
+{
+    disconnect();
+    if(sendBasicCommand("AT#REBOOT", 10000) != MTS_SUCCESS) {
+        logError("Socket Modem did not accept RESET command\n\r");
+    } else {
+        logWarning("Socket Modem is resetting, allow 30 seconds for it to come back\n\r");
+        return;
+    }
+}
+
+std::string EasyIP::getDeviceIP()
+{
+    return local_address;
+}
+
+//Turns off echo when it receives a 1, turns on when it receives anything else
+Code EasyIP::echo(bool state)
+{
+    Code code;
+    if (state) {
+        code = sendBasicCommand("ATE0", 1000);
+        echoMode = (code == MTS_SUCCESS) ? false : echoMode;
+    } else {
+        code = sendBasicCommand("ATE1", 1000);
+        echoMode = (code == MTS_SUCCESS) ? true : echoMode;
+    }
+    return code;
+}
+
+bool EasyIP::ping(const std::string& address)
+{
+    char buffer[256] = {0};
+    std::vector<std::string> parts;
+    int pingsRec=0;
+    int TTL=0;
+    int Timeout=0;
+    
+    //Format parameters for sending to radio
+    sprintf(buffer, "AT#PING=%s,1,32,%d", address.c_str(), (PINGDELAY*10));
+    
+    for(int pngs=0; pngs<PINGNUM; pngs++) {
+        std::string response = sendCommand(buffer, (PINGDELAY*1010)); //Send 1 ping
+        if(response.empty()) {
+            continue; //Skip current loop if send command fails
+        }
+        if(response.find("ERROR") != std::string::npos) {
+            continue; //Skip current loop if send command fails
+        }
+        parts = Text::split(response, "\r\n");
+        if(parts.size() < 2) {
+            continue;
+        }
+        parts = Text::split(parts[1], ",");
+        if(parts.size() < 4) {
+            continue;
+        }
+        //Parse TTL and Timeout values
+        Timeout = std::atoi(parts[2].c_str());
+        TTL = std::atoi(parts[3].c_str());
+                
+        if((Timeout < 600) && (TTL < 255)) {
+            pingsRec++;
+        }
+    }   //Success if less than 50% packet loss
+        if( ((pingsRec/PINGNUM)>= 0.5) ) {
+            return true;
+        }
+    return false;
+}
+
+//Pass 1 to enable socket closeable
+//Pass 0 to disable socket closeable
+Code EasyIP::setSocketCloseable(bool enabled)
+{
+    if(socketCloseable == enabled) {
+        return MTS_SUCCESS;
+    }
+
+    if(socketOpened) {
+        logError("socket is already opened. Can not set closeable");
+        return MTS_ERROR;
+    }
+
+    socketCloseable = enabled;
+
+    return MTS_SUCCESS;
+}