MultiTech / MTS-Cellular

Cellular library for MTS Socket Modem Arduino Shield devices from Multi-Tech Systems

Dependents:   mtsas mtsas mtsas mtsas

Cellular/EasyIP.cpp@33:3b6f3904dde0, 2014-07-16 (annotated)

Committer:
Vanger
Date:
Wed Jul 16 14:26:10 2014 +0000
Revision:
33:3b6f3904dde0
Parent:
32:7d5581159bed
Child:
35:257eb41405e1
Updating and formatting documentation for EasyIP.h and EasyIP.cpp.; Comment tweak for UIP.h

Who changed what in which revision?

UserRevisionLine numberNew contents of line
Vanger 26:2b769ed8de4f 1 #include "mbed.h"
Vanger 26:2b769ed8de4f 2 #include "EasyIP.h"
Vanger 26:2b769ed8de4f 3 #include "MTSText.h"
Vanger 26:2b769ed8de4f 4 #include "MTSLog.h"
Vanger 26:2b769ed8de4f 5 #include "CellUtils.h"
Vanger 26:2b769ed8de4f 6
Vanger 26:2b769ed8de4f 7 using namespace mts;
Vanger 26:2b769ed8de4f 8
Vanger 30:1326b623919a 9
Vanger 30:1326b623919a 10
Vanger 26:2b769ed8de4f 11 EasyIP::EasyIP(Radio type)
Vanger 26:2b769ed8de4f 12 {
Vanger 26:2b769ed8de4f 13 this->type = type;
Vanger 26:2b769ed8de4f 14 io = NULL;
Vanger 26:2b769ed8de4f 15 dcd = NULL;
Vanger 26:2b769ed8de4f 16 dtr = NULL;
Vanger 26:2b769ed8de4f 17 resetLine = NULL;
Vanger 26:2b769ed8de4f 18 echoMode = true;
Vanger 26:2b769ed8de4f 19 pppConnected = false;
Vanger 26:2b769ed8de4f 20 socketMode = TCP;
Vanger 26:2b769ed8de4f 21 socketOpened = false;
Vanger 26:2b769ed8de4f 22 socketCloseable = true;
Vanger 26:2b769ed8de4f 23 local_port = 0;
Vanger 26:2b769ed8de4f 24 local_address = "";
Vanger 26:2b769ed8de4f 25 host_port = 0;
Vanger 26:2b769ed8de4f 26 }
Vanger 26:2b769ed8de4f 27
Vanger 26:2b769ed8de4f 28 EasyIP::~EasyIP()
Vanger 26:2b769ed8de4f 29 {
Vanger 26:2b769ed8de4f 30 if (dtr != NULL) {
Vanger 26:2b769ed8de4f 31 dtr->write(1);
Vanger 26:2b769ed8de4f 32 }
Vanger 26:2b769ed8de4f 33
Vanger 26:2b769ed8de4f 34 delete dcd;
Vanger 26:2b769ed8de4f 35 delete dtr;
Vanger 26:2b769ed8de4f 36 delete resetLine;
Vanger 26:2b769ed8de4f 37 }
Vanger 26:2b769ed8de4f 38
Vanger 26:2b769ed8de4f 39 //Initializes the MTS IO Buffer
Vanger 26:2b769ed8de4f 40 bool EasyIP::init(MTSBufferedIO* io)
Vanger 26:2b769ed8de4f 41 {
Vanger 26:2b769ed8de4f 42 if (! Cellular::init(io)) {
Vanger 26:2b769ed8de4f 43 return false;
Vanger 26:2b769ed8de4f 44 }
Vanger 26:2b769ed8de4f 45
Vanger 26:2b769ed8de4f 46 logDebug("radio type: %s", Cellular::getRadioNames(type).c_str());
Vanger 32:7d5581159bed 47 //Turns on the HW flow control, equiv. to AT&K
Vanger 32:7d5581159bed 48 if(sendBasicCommand("AT+IFC=2,2", 2000) != MTS_SUCCESS) {
Vanger 32:7d5581159bed 49 logWarning("Failed to set flow control to radio");
Vanger 32:7d5581159bed 50 }
Vanger 26:2b769ed8de4f 51 return true;
Vanger 26:2b769ed8de4f 52 }
Vanger 26:2b769ed8de4f 53
Vanger 26:2b769ed8de4f 54 bool EasyIP::connect()
Vanger 26:2b769ed8de4f 55 {
Vanger 33:3b6f3904dde0 56 //Check if APN is not set, if it is not, connect will not work.
Vanger 29:edc613ed3f2e 57 if (type == MTSMC_H5_IP || type == MTSMC_H5 || type == MTSMC_G3) {
Vanger 29:edc613ed3f2e 58 if(apn.size() == 0) {
Vanger 29:edc613ed3f2e 59 logDebug("APN is not set");
Vanger 29:edc613ed3f2e 60 return false;
Vanger 29:edc613ed3f2e 61 }
Vanger 29:edc613ed3f2e 62 }
Vanger 29:edc613ed3f2e 63
Vanger 26:2b769ed8de4f 64 //Check if socket is open
Vanger 26:2b769ed8de4f 65 //flag stored in Cellular.h
Vanger 26:2b769ed8de4f 66 if(socketOpened) {
Vanger 26:2b769ed8de4f 67 return true;
Vanger 26:2b769ed8de4f 68 }
Vanger 26:2b769ed8de4f 69
Vanger 26:2b769ed8de4f 70 //Check if already connected
Vanger 26:2b769ed8de4f 71 //by calling the function isConnected() in EasyIP.cpp
Vanger 26:2b769ed8de4f 72 if(isConnected()) {
Vanger 26:2b769ed8de4f 73 return true;
Vanger 26:2b769ed8de4f 74 }
Vanger 26:2b769ed8de4f 75 //Create an mbed timer object
Vanger 26:2b769ed8de4f 76 Timer tmr;
Vanger 26:2b769ed8de4f 77 //Check Registration: AT+CREG? == 0,1
Vanger 26:2b769ed8de4f 78 //(Does the AT command inside Cellular class)
Vanger 26:2b769ed8de4f 79 tmr.start();
Vanger 26:2b769ed8de4f 80 do {
Vanger 26:2b769ed8de4f 81 Registration registration = getRegistration();
Vanger 26:2b769ed8de4f 82 if(registration != REGISTERED) {
Vanger 26:2b769ed8de4f 83 logTrace("Not Registered [%d] ... waiting", (int)registration);
Vanger 26:2b769ed8de4f 84 wait(1);
Vanger 26:2b769ed8de4f 85 } else {
Vanger 26:2b769ed8de4f 86 break;
Vanger 26:2b769ed8de4f 87 }
Vanger 30:1326b623919a 88 } while(tmr.read() < 30);
Vanger 26:2b769ed8de4f 89 //Check RSSI: AT+CSQ
Vanger 26:2b769ed8de4f 90 //Does the command inside Cellular
Vanger 26:2b769ed8de4f 91 tmr.reset();
Vanger 26:2b769ed8de4f 92 do {
Vanger 26:2b769ed8de4f 93 int rssi = getSignalStrength();
Vanger 26:2b769ed8de4f 94 logDebug("Signal strength: %d", rssi);
Vanger 30:1326b623919a 95 if((rssi == 99) || (rssi == -1)) {
Vanger 26:2b769ed8de4f 96 logTrace("No Signal ... waiting");
Vanger 26:2b769ed8de4f 97 wait(1);
Vanger 26:2b769ed8de4f 98 } else {
Vanger 26:2b769ed8de4f 99 break;
Vanger 26:2b769ed8de4f 100 }
Vanger 26:2b769ed8de4f 101 } while(tmr.read() < 30);
Vanger 26:2b769ed8de4f 102
Vanger 27:ec44d5a9544f 103 //Similar to AT#CONNECTIONSTART: Make a PPP connection
Vanger 26:2b769ed8de4f 104 if (type == MTSMC_H5 || type == MTSMC_G3) {
Vanger 26:2b769ed8de4f 105 logDebug("Making PPP Connection Attempt. APN[%s]", apn.c_str());
Vanger 26:2b769ed8de4f 106 } else {
Vanger 26:2b769ed8de4f 107 logDebug("Making PPP Connection Attempt");
Vanger 26:2b769ed8de4f 108 }
Vanger 26:2b769ed8de4f 109 //The main thing going on; Sends the AT command to start a connection
Vanger 30:1326b623919a 110 //Assuming context is already stored in the modem
Vanger 30:1326b623919a 111 std::string pppResult = sendCommand("AT#SGACT=1,1", 2000);
Vanger 30:1326b623919a 112 std::vector<std::string> parts;
Vanger 26:2b769ed8de4f 113 if(pppResult.find("OK") != std::string::npos) {
Vanger 30:1326b623919a 114 parts = Text::split(pppResult, "\r\n");
Vanger 26:2b769ed8de4f 115 if(parts.size() >= 2) {
Vanger 26:2b769ed8de4f 116 parts = Text::split(parts[1], " ");
Vanger 26:2b769ed8de4f 117 local_address = parts[1];
Vanger 26:2b769ed8de4f 118 }
Vanger 26:2b769ed8de4f 119 logInfo("PPP Connection Established: IP[%s]", local_address.c_str());
Vanger 26:2b769ed8de4f 120 pppConnected = true;
Vanger 26:2b769ed8de4f 121
Vanger 26:2b769ed8de4f 122 } else {
Vanger 30:1326b623919a 123 pppResult = sendCommand("AT#SGACT?", 2000);
Vanger 30:1326b623919a 124 if(pppResult.empty() || (pppResult.find("ERROR") != std::string::npos)) {
Vanger 30:1326b623919a 125 pppConnected = false;
Vanger 30:1326b623919a 126 } else {
Vanger 30:1326b623919a 127 if(pppResult.find("1,1") != std::string::npos) {
Vanger 30:1326b623919a 128 pppConnected = true;
Vanger 30:1326b623919a 129 } else {
Vanger 30:1326b623919a 130 pppConnected = false;
Vanger 30:1326b623919a 131 }
Vanger 30:1326b623919a 132 }
Vanger 26:2b769ed8de4f 133 }
Vanger 26:2b769ed8de4f 134
Vanger 26:2b769ed8de4f 135 return pppConnected;
Vanger 26:2b769ed8de4f 136 }
Vanger 26:2b769ed8de4f 137
Vanger 26:2b769ed8de4f 138 void EasyIP::disconnect()
Vanger 26:2b769ed8de4f 139 {
Vanger 26:2b769ed8de4f 140 //AT#SGACT=1,0: Close a PPP connection
Vanger 28:f93d7b3f7c2e 141 logDebug("Closing PPP Connection");
Vanger 26:2b769ed8de4f 142 if(socketOpened) {
Vanger 30:1326b623919a 143 if(!close()) { //Calls another EasyIP function to close socket before disconnect
Vanger 30:1326b623919a 144 logDebug("Failed to close socket for disconnect");
Vanger 30:1326b623919a 145 return; //Can't close connection without AT commands
Vanger 30:1326b623919a 146 //(and thus need socket closed)
Vanger 30:1326b623919a 147 }
Vanger 26:2b769ed8de4f 148 }
Vanger 26:2b769ed8de4f 149 //Sends AT#SGACT=1,0 command
Vanger 30:1326b623919a 150 if(sendBasicCommand("AT#SGACT=1,0", 1000) == MTS_SUCCESS) {
Vanger 30:1326b623919a 151 pppConnected = false;
Vanger 30:1326b623919a 152 logDebug("Successfully closed PPP Connection");
Vanger 30:1326b623919a 153 }
Vanger 28:f93d7b3f7c2e 154 pppConnected = false; //Cell will drop connection if we go silent
Vanger 30:1326b623919a 155 return;
Vanger 26:2b769ed8de4f 156 }
Vanger 27:ec44d5a9544f 157
Vanger 26:2b769ed8de4f 158 bool EasyIP::isConnected()
Vanger 26:2b769ed8de4f 159 {
Vanger 29:edc613ed3f2e 160 std::string stateString;
Vanger 29:edc613ed3f2e 161 std::vector<std::string> pieces;
Vanger 30:1326b623919a 162 //state flags for various connection checks
Vanger 30:1326b623919a 163 bool signal = false, regist = false, active = false;
Vanger 26:2b769ed8de4f 164
Vanger 29:edc613ed3f2e 165 //1) Check if APN was set if we're on an HSPA radio
Vanger 29:edc613ed3f2e 166 if (type == MTSMC_H5_IP || type == MTSMC_H5 || type == MTSMC_G3) {
Vanger 29:edc613ed3f2e 167 if(apn.size() == 0) {
Vanger 29:edc613ed3f2e 168 logDebug("APN is not set");
Vanger 29:edc613ed3f2e 169 return false;
Vanger 29:edc613ed3f2e 170 }
Vanger 29:edc613ed3f2e 171 }
Vanger 29:edc613ed3f2e 172
Vanger 29:edc613ed3f2e 173 //2) Check that we do not have a live connection up
Vanger 29:edc613ed3f2e 174 if(socketOpened) {
Vanger 29:edc613ed3f2e 175 logDebug("Socket is opened");
Vanger 29:edc613ed3f2e 176 return true;
Vanger 29:edc613ed3f2e 177 }
Vanger 29:edc613ed3f2e 178
Vanger 30:1326b623919a 179
Vanger 29:edc613ed3f2e 180 //3) Query the radio
Vanger 29:edc613ed3f2e 181 //Check antenna signal
Vanger 30:1326b623919a 182 std::string reply = sendCommand("AT+CSQ", 500);
Vanger 29:edc613ed3f2e 183 if(reply.empty() || (reply.find("ERROR") != std::string::npos)) {
Vanger 29:edc613ed3f2e 184 signal = false;
Vanger 29:edc613ed3f2e 185 } else {
Vanger 29:edc613ed3f2e 186 pieces = Text::split(reply, "\r\n");
Vanger 29:edc613ed3f2e 187 if(pieces.size() >= 2) {
Vanger 29:edc613ed3f2e 188 pieces = Text::split(pieces[1], " ");
Vanger 29:edc613ed3f2e 189 if(pieces.size() >= 2) {
Vanger 29:edc613ed3f2e 190 if((pieces[1].find("0,0") != std::string::npos) || (pieces[1].find("99,99") != std::string::npos)) {
Vanger 29:edc613ed3f2e 191 signal = false;
Vanger 29:edc613ed3f2e 192 } else {
Vanger 29:edc613ed3f2e 193 signal = true;
Vanger 29:edc613ed3f2e 194 }
Vanger 29:edc613ed3f2e 195 }
Vanger 29:edc613ed3f2e 196 }
Vanger 29:edc613ed3f2e 197 }
Vanger 27:ec44d5a9544f 198
Vanger 29:edc613ed3f2e 199 //Check cell tower registration
Vanger 30:1326b623919a 200 reply = sendCommand("AT+CREG?", 500);
Vanger 29:edc613ed3f2e 201 if(reply.empty() || (reply.find("ERROR") != std::string::npos)) {
Vanger 29:edc613ed3f2e 202 regist = false;
Vanger 29:edc613ed3f2e 203 } else {
Vanger 29:edc613ed3f2e 204 pieces = Text::split(reply, "\r\n");
Vanger 29:edc613ed3f2e 205 if(pieces.size() >= 2) {
Vanger 29:edc613ed3f2e 206 pieces = Text::split(pieces[1], " ");
Vanger 29:edc613ed3f2e 207 if(pieces.size() >= 2) {
Vanger 29:edc613ed3f2e 208 if((pieces[1].find("0,1") != std::string::npos) || (pieces[1].find("0,5") != std::string::npos)) {
Vanger 29:edc613ed3f2e 209 regist = true; //1 for connected, 5 for roaming connected
Vanger 29:edc613ed3f2e 210 } else {
Vanger 29:edc613ed3f2e 211 regist = false; //Cell tower not registered
Vanger 29:edc613ed3f2e 212 }
Vanger 29:edc613ed3f2e 213 }
Vanger 29:edc613ed3f2e 214 }
Vanger 29:edc613ed3f2e 215 }
Vanger 27:ec44d5a9544f 216
Vanger 33:3b6f3904dde0 217 //Check active context (SGACT = 1,1)
Vanger 30:1326b623919a 218 reply = sendCommand("AT#SGACT?", 500);
Vanger 29:edc613ed3f2e 219 if(reply.empty() || (reply.find("ERROR") != std::string::npos)) {
Vanger 29:edc613ed3f2e 220 active = false;
Vanger 29:edc613ed3f2e 221 } else {
Vanger 29:edc613ed3f2e 222 pieces = Text::split(reply, "\r\n");
Vanger 29:edc613ed3f2e 223 if(pieces.size() >= 2) {
Vanger 29:edc613ed3f2e 224 pieces = Text::split(pieces[1], " ");
Vanger 29:edc613ed3f2e 225 if(pieces.size() >= 2) {
Vanger 29:edc613ed3f2e 226 if(pieces[1].find("1,1") != std::string::npos) {
Vanger 29:edc613ed3f2e 227 active = true; //1 for an active connection mode
Vanger 29:edc613ed3f2e 228 } else {
Vanger 29:edc613ed3f2e 229 active = false; //0, or unknown value, is an inactive connection mode
Vanger 29:edc613ed3f2e 230 }
Vanger 29:edc613ed3f2e 231 }
Vanger 29:edc613ed3f2e 232 }
Vanger 29:edc613ed3f2e 233 }
Vanger 30:1326b623919a 234 //4) Determine radio state
Vanger 30:1326b623919a 235 if(regist && signal) {
Vanger 29:edc613ed3f2e 236 if(pppConnected) {
Vanger 30:1326b623919a 237 if(active) {
Vanger 30:1326b623919a 238 if(ping()) {
Vanger 30:1326b623919a 239 stateString = "CONNECTED";
Vanger 30:1326b623919a 240 pppConnected = true;
Vanger 29:edc613ed3f2e 241 } else {
Vanger 30:1326b623919a 242 stateString = "AUTHENTICATING";
Vanger 30:1326b623919a 243 pppConnected = true;
Vanger 30:1326b623919a 244 return false; //Return false instead of changing pppConnected due to the fact
Vanger 30:1326b623919a 245 //that it is connected to ppp, it just can't ping successfully
Vanger 29:edc613ed3f2e 246 }
Vanger 30:1326b623919a 247 } else {
Vanger 30:1326b623919a 248 stateString = "DISCONNECTING";
Vanger 30:1326b623919a 249 pppConnected = false;
Vanger 30:1326b623919a 250 }
Vanger 30:1326b623919a 251 } else {
Vanger 30:1326b623919a 252 if(active) {
Vanger 30:1326b623919a 253 if(ping()) {
Vanger 30:1326b623919a 254 pppConnected = true;
Vanger 30:1326b623919a 255 logWarning("Internal PPP state tracking differs from radio (DISCONNECTED:CONNECTED)");
Vanger 30:1326b623919a 256 stateString = "CONNECTED";
Vanger 30:1326b623919a 257 } else {
Vanger 30:1326b623919a 258 stateString = "CONNECTING";
Vanger 30:1326b623919a 259 }
Vanger 30:1326b623919a 260 } else {
Vanger 30:1326b623919a 261 stateString = "IDLE";
Vanger 30:1326b623919a 262 }
Vanger 29:edc613ed3f2e 263 }
Vanger 30:1326b623919a 264 } else if(regist != signal) {
Vanger 30:1326b623919a 265 stateString = "CHECKING";
Vanger 29:edc613ed3f2e 266 pppConnected = false;
Vanger 30:1326b623919a 267 } else if(!regist && !signal) {
Vanger 30:1326b623919a 268 stateString = "DISCONNECTED";
Vanger 30:1326b623919a 269 pppConnected = false;
Vanger 30:1326b623919a 270 }
Vanger 30:1326b623919a 271 //Log results if necessary
Vanger 30:1326b623919a 272 if(stateString != "CONNECTED") {
Vanger 30:1326b623919a 273 logWarning("Internal PPP state tracking differs from radio (CONNECTED:%s)",stateString.c_str());
Vanger 29:edc613ed3f2e 274 }
Vanger 26:2b769ed8de4f 275 return pppConnected;
Vanger 26:2b769ed8de4f 276 }
Vanger 30:1326b623919a 277
Vanger 33:3b6f3904dde0 278 //Resets the radio
Vanger 33:3b6f3904dde0 279 void EasyIP::reset()
Vanger 33:3b6f3904dde0 280 {
Vanger 33:3b6f3904dde0 281 disconnect();
Vanger 33:3b6f3904dde0 282 if(sendBasicCommand("AT#REBOOT", 10000) != MTS_SUCCESS) {
Vanger 33:3b6f3904dde0 283 logError("Socket Modem did not accept RESET command\n\r");
Vanger 33:3b6f3904dde0 284 } else {
Vanger 33:3b6f3904dde0 285 logWarning("Socket Modem is resetting, allow 30 seconds for it to come back\n\r");
Vanger 33:3b6f3904dde0 286 return;
Vanger 33:3b6f3904dde0 287 }
Vanger 33:3b6f3904dde0 288 }
Vanger 33:3b6f3904dde0 289
Vanger 26:2b769ed8de4f 290 //Binds the socket to a specific port if able
Vanger 26:2b769ed8de4f 291 bool EasyIP::bind(unsigned int port)
Vanger 26:2b769ed8de4f 292 {
Vanger 30:1326b623919a 293 if(socketOpened) {
Vanger 30:1326b623919a 294 logError("socket is open. Can not set local port");
Vanger 30:1326b623919a 295 return false;
Vanger 30:1326b623919a 296 }
Vanger 30:1326b623919a 297 if(port > 65535) {
Vanger 30:1326b623919a 298 logError("port out of range (0-65535)");
Vanger 30:1326b623919a 299 return false;
Vanger 30:1326b623919a 300 }
Vanger 30:1326b623919a 301 local_port = port;
Vanger 26:2b769ed8de4f 302 return true;
Vanger 26:2b769ed8de4f 303 }
Vanger 27:ec44d5a9544f 304
Vanger 26:2b769ed8de4f 305 bool EasyIP::open(const std::string& address, unsigned int port, Mode mode)
Vanger 26:2b769ed8de4f 306 {
Vanger 30:1326b623919a 307 char sOpenSocketCmd[256] = {0}; //String for AT command
Vanger 30:1326b623919a 308 std::string sMode = "";
Vanger 31:529db15abda7 309 int typeSocket = 0;
Vanger 31:529db15abda7 310 int closeType = 0;
Vanger 30:1326b623919a 311
Vanger 30:1326b623919a 312 //1) Check that we do not have a live connection up
Vanger 30:1326b623919a 313 if(socketOpened) {
Vanger 30:1326b623919a 314 //Check that the address, port, and mode match
Vanger 30:1326b623919a 315 if(host_address != address || host_port != port || socketMode != mode) {
Vanger 30:1326b623919a 316 if(socketMode == TCP) {
Vanger 30:1326b623919a 317 logError("TCP socket already opened [%s:%d]", host_address.c_str(), host_port);
Vanger 30:1326b623919a 318 } else {
Vanger 30:1326b623919a 319 logError("UDP socket already opened [%s:%d]", host_address.c_str(), host_port);
Vanger 30:1326b623919a 320 }
Vanger 30:1326b623919a 321 return false;
Vanger 30:1326b623919a 322 }
Vanger 30:1326b623919a 323
Vanger 30:1326b623919a 324 logDebug("Socket already opened");
Vanger 30:1326b623919a 325 return true;
Vanger 30:1326b623919a 326 }
Vanger 30:1326b623919a 327
Vanger 30:1326b623919a 328 //2) Check Parameters
Vanger 30:1326b623919a 329 if(port > 65535) {
Vanger 30:1326b623919a 330 logError("port out of range (0-65535)");
Vanger 30:1326b623919a 331 return false;
Vanger 30:1326b623919a 332 }
Vanger 30:1326b623919a 333
Vanger 30:1326b623919a 334 //3) Check PPP connection
Vanger 30:1326b623919a 335 if(!isConnected()) {
Vanger 30:1326b623919a 336 logError("PPP not established. Attempting to connect");
Vanger 30:1326b623919a 337 if(!connect()) {
Vanger 30:1326b623919a 338 logError("PPP connection failed");
Vanger 30:1326b623919a 339 return false;
Vanger 30:1326b623919a 340 } else {
Vanger 30:1326b623919a 341 logDebug("PPP connection established");
Vanger 30:1326b623919a 342 }
Vanger 30:1326b623919a 343 }
Vanger 30:1326b623919a 344 //No way to "set" port except on socket call;
Vanger 30:1326b623919a 345 //Going to need to warn if local_port was not set.
Vanger 30:1326b623919a 346 if(!local_port) {
Vanger 30:1326b623919a 347 logDebug("No local port was set: 0");
Vanger 30:1326b623919a 348 }
Vanger 30:1326b623919a 349
Vanger 30:1326b623919a 350 //4) Set escape sequence to not be transmitted
Vanger 30:1326b623919a 351 if(sendBasicCommand("AT#SKIPESC=1", 2000) != MTS_SUCCESS) {
Vanger 30:1326b623919a 352 logWarning("Failed to disable escape sequence transmission on data mode suspension");
Vanger 30:1326b623919a 353 }
Vanger 30:1326b623919a 354
Vanger 30:1326b623919a 355 if(mode == TCP) {
Vanger 30:1326b623919a 356 typeSocket = 0;
Vanger 30:1326b623919a 357 sMode = "TCP";
Vanger 30:1326b623919a 358 } else {
Vanger 30:1326b623919a 359 typeSocket = 1;
Vanger 30:1326b623919a 360 sMode = "UDP";
Vanger 30:1326b623919a 361 }
Vanger 31:529db15abda7 362
Vanger 31:529db15abda7 363 if(socketCloseable) {
Vanger 31:529db15abda7 364 closeType = 0;
Vanger 31:529db15abda7 365 } else {
Vanger 31:529db15abda7 366 closeType = 255;
Vanger 31:529db15abda7 367 }
Vanger 31:529db15abda7 368 //5) Open Socket
Vanger 31:529db15abda7 369 sprintf(sOpenSocketCmd, "AT#SD=1,%d,%d,%s,%d,%d,0", typeSocket, port, address.c_str(),closeType , local_port);
Vanger 30:1326b623919a 370 std::string response = sendCommand(sOpenSocketCmd, 5000);
Vanger 30:1326b623919a 371
Vanger 30:1326b623919a 372 if(response.find("CONNECT") != std::string::npos) {
Vanger 30:1326b623919a 373 host_address = address;
Vanger 30:1326b623919a 374 host_port = port;
Vanger 30:1326b623919a 375
Vanger 30:1326b623919a 376 logInfo("Opened %s Socket [%s:%d]", sMode.c_str(), address.c_str(), port);
Vanger 30:1326b623919a 377 socketOpened = true;
Vanger 30:1326b623919a 378 socketMode = mode;
Vanger 30:1326b623919a 379 } else {
Vanger 30:1326b623919a 380 logWarning("Unable to open %s Socket [%s:%d]", sMode.c_str(), address.c_str(), port);
Vanger 30:1326b623919a 381 socketOpened = false;
Vanger 30:1326b623919a 382 }
Vanger 30:1326b623919a 383
Vanger 26:2b769ed8de4f 384 return socketOpened;
Vanger 26:2b769ed8de4f 385 }
Vanger 27:ec44d5a9544f 386
Vanger 26:2b769ed8de4f 387 bool EasyIP::isOpen()
Vanger 26:2b769ed8de4f 388 {
Vanger 30:1326b623919a 389 if(io->readable()) {
Vanger 30:1326b623919a 390 logDebug("Assuming open, data available to read.\n\r");
Vanger 30:1326b623919a 391 return true;
Vanger 30:1326b623919a 392 }
Vanger 26:2b769ed8de4f 393 return socketOpened;
Vanger 26:2b769ed8de4f 394 }
Vanger 27:ec44d5a9544f 395
Vanger 26:2b769ed8de4f 396 bool EasyIP::close()
Vanger 26:2b769ed8de4f 397 {
Vanger 26:2b769ed8de4f 398
Vanger 30:1326b623919a 399 if(io == NULL) {
Vanger 30:1326b623919a 400 logError("MTSBufferedIO not set");
Vanger 30:1326b623919a 401 return false;
Vanger 30:1326b623919a 402 }
Vanger 30:1326b623919a 403
Vanger 30:1326b623919a 404 if(!socketOpened) {
Vanger 30:1326b623919a 405 logWarning("Socket close() called, but socket was not open");
Vanger 30:1326b623919a 406 return true;
Vanger 30:1326b623919a 407 }
Vanger 30:1326b623919a 408
Vanger 30:1326b623919a 409 if(!socketCloseable) {
Vanger 30:1326b623919a 410 logError("Socket is not closeable");
Vanger 30:1326b623919a 411 return false;
Vanger 30:1326b623919a 412 }
Vanger 30:1326b623919a 413
Vanger 30:1326b623919a 414 if(!sendEscapeCommand()) {
Vanger 30:1326b623919a 415 logError("Failed to exit online mode");
Vanger 30:1326b623919a 416 return false;
Vanger 30:1326b623919a 417 } else {
Vanger 30:1326b623919a 418 socketOpened = false;
Vanger 30:1326b623919a 419 }
Vanger 30:1326b623919a 420
Vanger 30:1326b623919a 421 if(sendBasicCommand("AT#SH=1", 2000) != MTS_SUCCESS) {
Vanger 30:1326b623919a 422 logDebug("Failed to close socket connection");
Vanger 30:1326b623919a 423 }
Vanger 30:1326b623919a 424
Vanger 30:1326b623919a 425 Timer tmr;
Vanger 30:1326b623919a 426 int counter = 0;
Vanger 30:1326b623919a 427 char tmp[256];
Vanger 30:1326b623919a 428 tmr.start();
Vanger 30:1326b623919a 429 do {
Vanger 30:1326b623919a 430 if(socketOpened == false) {
Vanger 30:1326b623919a 431 break;
Vanger 30:1326b623919a 432 }
Vanger 30:1326b623919a 433 read(tmp, 256, 1000);
Vanger 30:1326b623919a 434 } while(counter++ < 10);
Vanger 30:1326b623919a 435
Vanger 30:1326b623919a 436 io->rxClear();
Vanger 30:1326b623919a 437 io->txClear();
Vanger 30:1326b623919a 438
Vanger 30:1326b623919a 439 return !socketOpened;
Vanger 26:2b769ed8de4f 440 }
Vanger 26:2b769ed8de4f 441
Vanger 26:2b769ed8de4f 442 int EasyIP::read(char* data, int max, int timeout)
Vanger 26:2b769ed8de4f 443 {
Vanger 30:1326b623919a 444 if(io == NULL) {
Vanger 30:1326b623919a 445 logError("MTSBufferedIO not set");
Vanger 30:1326b623919a 446 return -1;
Vanger 30:1326b623919a 447 }
Vanger 30:1326b623919a 448
Vanger 30:1326b623919a 449 //Check that nothing is in the rx buffer
Vanger 30:1326b623919a 450 if(!socketOpened && !io->readable()) {
Vanger 30:1326b623919a 451 logError("Socket is not open");
Vanger 30:1326b623919a 452 return -1;
Vanger 30:1326b623919a 453 }
Vanger 30:1326b623919a 454
Vanger 30:1326b623919a 455 int bytesRead = 0;
Vanger 30:1326b623919a 456
Vanger 30:1326b623919a 457
Vanger 30:1326b623919a 458 if(timeout >= 0) {
Vanger 30:1326b623919a 459 bytesRead = io->read(data, max, static_cast<unsigned int>(timeout));
Vanger 30:1326b623919a 460 } else {
Vanger 30:1326b623919a 461 bytesRead = io->read(data, max);
Vanger 30:1326b623919a 462 }
Vanger 31:529db15abda7 463 if(bytesRead > 0 && socketCloseable) {
Vanger 31:529db15abda7 464 //Scan for socket closed message
Vanger 31:529db15abda7 465 for(size_t i = 0; i < bytesRead; i++) {
Vanger 31:529db15abda7 466 if(data[i] == 'N') {
Vanger 31:529db15abda7 467 if(strstr(&data[i], "NO CARRIER")) {
Vanger 31:529db15abda7 468 logTrace("Found socket closed message. Checking validity");
Vanger 31:529db15abda7 469 //Close socket and Cut Off End of Message
Vanger 31:529db15abda7 470 socketOpened = socketCheck(); //Verifies legitimacy of socket disconnect
Vanger 31:529db15abda7 471 if(socketOpened) {
Vanger 31:529db15abda7 472 logDebug("Socket still open");
Vanger 31:529db15abda7 473 continue;
Vanger 31:529db15abda7 474 } else {
Vanger 31:529db15abda7 475 logDebug("Socket closed");
Vanger 31:529db15abda7 476 data[i] = '\0';
Vanger 31:529db15abda7 477 bytesRead = i;
Vanger 31:529db15abda7 478 break;
Vanger 31:529db15abda7 479 }
Vanger 30:1326b623919a 480 }
Vanger 30:1326b623919a 481 }
Vanger 30:1326b623919a 482 }
Vanger 30:1326b623919a 483 }
Vanger 30:1326b623919a 484 return bytesRead;
Vanger 26:2b769ed8de4f 485 }
Vanger 26:2b769ed8de4f 486
Vanger 26:2b769ed8de4f 487 int EasyIP::write(const char* data, int length, int timeout)
Vanger 26:2b769ed8de4f 488 {
Vanger 30:1326b623919a 489 if(io == NULL) {
Vanger 30:1326b623919a 490 logError("MTSBufferedIO not set");
Vanger 30:1326b623919a 491 return -1;
Vanger 30:1326b623919a 492 }
Vanger 30:1326b623919a 493
Vanger 30:1326b623919a 494 if(!socketOpened) {
Vanger 30:1326b623919a 495 logError("Socket is not open");
Vanger 30:1326b623919a 496 return -1;
Vanger 30:1326b623919a 497 }
Vanger 30:1326b623919a 498
Vanger 30:1326b623919a 499 int bytesWritten = 0;
Vanger 31:529db15abda7 500 int size = length;
Vanger 31:529db15abda7 501 int failedWrites = 0;
Vanger 30:1326b623919a 502 if(timeout >= 0) {
Vanger 30:1326b623919a 503 Timer tmr;
Vanger 30:1326b623919a 504 tmr.start();
Vanger 30:1326b623919a 505 do {
Vanger 30:1326b623919a 506 int available = io->writeable();
Vanger 30:1326b623919a 507 if (available > 0) {
Vanger 31:529db15abda7 508 size = MIN(available, length - bytesWritten);
Vanger 31:529db15abda7 509 bytesWritten += io->write(&data[bytesWritten], size);
Vanger 30:1326b623919a 510 } else {
Vanger 30:1326b623919a 511 wait(0.05);
Vanger 30:1326b623919a 512 }
Vanger 30:1326b623919a 513 } while (tmr.read_ms() <= timeout && bytesWritten < length);
Vanger 30:1326b623919a 514 } else {
Vanger 31:529db15abda7 515 //If timeout is -1:
Vanger 31:529db15abda7 516 do {
Vanger 31:529db15abda7 517 int available = io->writeable();
Vanger 31:529db15abda7 518 if(available > 0) {
Vanger 31:529db15abda7 519 size = MIN(available, length - bytesWritten);
Vanger 31:529db15abda7 520 int currentWritten = io->write(&data[bytesWritten], size);
Vanger 31:529db15abda7 521 bytesWritten += currentWritten;
Vanger 31:529db15abda7 522 if(!currentWritten) {
Vanger 31:529db15abda7 523 failedWrites++;
Vanger 31:529db15abda7 524 }
Vanger 31:529db15abda7 525 if(failedWrites > 10) {
Vanger 31:529db15abda7 526 logError("Couldn't write any characters");
Vanger 31:529db15abda7 527 return bytesWritten;
Vanger 31:529db15abda7 528 }
Vanger 31:529db15abda7 529 } else {
Vanger 31:529db15abda7 530 wait(0.05);
Vanger 30:1326b623919a 531 }
Vanger 31:529db15abda7 532 } while (bytesWritten < length);
Vanger 30:1326b623919a 533 }
Vanger 30:1326b623919a 534 return bytesWritten;
Vanger 26:2b769ed8de4f 535 }
Vanger 26:2b769ed8de4f 536
Vanger 26:2b769ed8de4f 537 unsigned int EasyIP::readable()
Vanger 26:2b769ed8de4f 538 {
Vanger 30:1326b623919a 539 if(io == NULL) {
Vanger 30:1326b623919a 540 logWarning("MTSBufferedIO not set");
Vanger 30:1326b623919a 541 return 0;
Vanger 30:1326b623919a 542 }
Vanger 30:1326b623919a 543 if(!socketOpened && !io->readable()) {
Vanger 30:1326b623919a 544 logWarning("Socket is not open");
Vanger 30:1326b623919a 545 return 0;
Vanger 30:1326b623919a 546 }
Vanger 26:2b769ed8de4f 547 return io->readable();
Vanger 26:2b769ed8de4f 548 }
Vanger 26:2b769ed8de4f 549
Vanger 26:2b769ed8de4f 550 unsigned int EasyIP::writeable()
Vanger 26:2b769ed8de4f 551 {
Vanger 30:1326b623919a 552 if(io == NULL) {
Vanger 30:1326b623919a 553 logWarning("MTSBufferedIO not set");
Vanger 30:1326b623919a 554 return 0;
Vanger 30:1326b623919a 555 }
Vanger 30:1326b623919a 556 if(!socketOpened) {
Vanger 30:1326b623919a 557 logWarning("Socket is not open");
Vanger 30:1326b623919a 558 return 0;
Vanger 30:1326b623919a 559 }
Vanger 26:2b769ed8de4f 560
Vanger 26:2b769ed8de4f 561 return io->writeable();
Vanger 26:2b769ed8de4f 562 }
Vanger 26:2b769ed8de4f 563
Vanger 26:2b769ed8de4f 564 bool EasyIP::setDeviceIP(std::string address)
Vanger 26:2b769ed8de4f 565 {
Vanger 26:2b769ed8de4f 566 if (address.compare("DHCP") == 0) {
Vanger 26:2b769ed8de4f 567 return true;
Vanger 26:2b769ed8de4f 568 } else {
Vanger 26:2b769ed8de4f 569 logWarning("Radio does not support static IPs, using DHCP.\n\r");
Vanger 26:2b769ed8de4f 570 return false;
Vanger 26:2b769ed8de4f 571 }
Vanger 26:2b769ed8de4f 572 }
Vanger 26:2b769ed8de4f 573
Vanger 26:2b769ed8de4f 574 Code EasyIP::setApn(const std::string& apn)
Vanger 26:2b769ed8de4f 575 {
Vanger 26:2b769ed8de4f 576 if (type == MTSMC_H5 || type == MTSMC_G3) {
Vanger 26:2b769ed8de4f 577 //Set IP,PPP,IPv6
Vanger 26:2b769ed8de4f 578 Code code = sendBasicCommand("AT+CGDCONT=1,PPP," + apn, 1000);
Vanger 26:2b769ed8de4f 579 if (code != MTS_SUCCESS) {
Vanger 33:3b6f3904dde0 580 return code; //This will return whatever is not MTS_SUCCESS
Vanger 26:2b769ed8de4f 581 }
Vanger 26:2b769ed8de4f 582 this->apn = apn;
Vanger 26:2b769ed8de4f 583 return code; //This will return MTS_SUCCESS
Vanger 26:2b769ed8de4f 584 } else {
Vanger 26:2b769ed8de4f 585 logInfo("CDMA radios don't need an APN");
Vanger 26:2b769ed8de4f 586 return MTS_SUCCESS;
Vanger 26:2b769ed8de4f 587 }
Vanger 26:2b769ed8de4f 588 }
Vanger 27:ec44d5a9544f 589
Vanger 26:2b769ed8de4f 590 std::string EasyIP::getDeviceIP()
Vanger 26:2b769ed8de4f 591 {
Vanger 26:2b769ed8de4f 592 return local_address;
Vanger 26:2b769ed8de4f 593 }
Vanger 26:2b769ed8de4f 594
Vanger 32:7d5581159bed 595 //Turns off echo when it receives a true, turns on when it receives false
Vanger 26:2b769ed8de4f 596 Code EasyIP::echo(bool state)
Vanger 26:2b769ed8de4f 597 {
Vanger 27:ec44d5a9544f 598 Code code;
Vanger 27:ec44d5a9544f 599 if (state) {
Vanger 27:ec44d5a9544f 600 code = sendBasicCommand("ATE0", 1000);
Vanger 27:ec44d5a9544f 601 echoMode = (code == MTS_SUCCESS) ? false : echoMode;
Vanger 27:ec44d5a9544f 602 } else {
Vanger 27:ec44d5a9544f 603 code = sendBasicCommand("ATE1", 1000);
Vanger 27:ec44d5a9544f 604 echoMode = (code == MTS_SUCCESS) ? true : echoMode;
Vanger 27:ec44d5a9544f 605 }
Vanger 27:ec44d5a9544f 606 return code;
Vanger 26:2b769ed8de4f 607 }
Vanger 26:2b769ed8de4f 608
Vanger 26:2b769ed8de4f 609 bool EasyIP::ping(const std::string& address)
Vanger 26:2b769ed8de4f 610 {
Vanger 26:2b769ed8de4f 611 char buffer[256] = {0};
Vanger 27:ec44d5a9544f 612 std::vector<std::string> parts;
Vanger 27:ec44d5a9544f 613 int pingsRec=0;
Vanger 27:ec44d5a9544f 614 int TTL=0;
Vanger 27:ec44d5a9544f 615 int Timeout=0;
Vanger 27:ec44d5a9544f 616
Vanger 27:ec44d5a9544f 617 //Format parameters for sending to radio
Vanger 30:1326b623919a 618 sprintf(buffer, "AT#PING=%s,1,32,%d", address.c_str(), (PINGDELAY*10));
Vanger 26:2b769ed8de4f 619
Vanger 27:ec44d5a9544f 620 for(int pngs=0; pngs<PINGNUM; pngs++) {
Vanger 30:1326b623919a 621 std::string response = sendCommand(buffer, (PINGDELAY*1010)); //Send 1 ping
Vanger 28:f93d7b3f7c2e 622 if(response.empty()) {
Vanger 28:f93d7b3f7c2e 623 continue; //Skip current loop if send command fails
Vanger 28:f93d7b3f7c2e 624 }
Vanger 28:f93d7b3f7c2e 625 if(response.find("ERROR") != std::string::npos) {
Vanger 28:f93d7b3f7c2e 626 continue; //Skip current loop if send command fails
Vanger 28:f93d7b3f7c2e 627 }
Vanger 27:ec44d5a9544f 628 parts = Text::split(response, "\r\n");
Vanger 28:f93d7b3f7c2e 629 if(parts.size() < 2) {
Vanger 28:f93d7b3f7c2e 630 continue;
Vanger 28:f93d7b3f7c2e 631 }
Vanger 27:ec44d5a9544f 632 parts = Text::split(parts[1], ",");
Vanger 28:f93d7b3f7c2e 633 if(parts.size() < 4) {
Vanger 28:f93d7b3f7c2e 634 continue;
Vanger 28:f93d7b3f7c2e 635 }
Vanger 27:ec44d5a9544f 636 //Parse TTL and Timeout values
Vanger 27:ec44d5a9544f 637 Timeout = std::atoi(parts[2].c_str());
Vanger 27:ec44d5a9544f 638 TTL = std::atoi(parts[3].c_str());
Vanger 27:ec44d5a9544f 639
Vanger 27:ec44d5a9544f 640 if((Timeout < 600) && (TTL < 255)) {
Vanger 27:ec44d5a9544f 641 pingsRec++;
Vanger 27:ec44d5a9544f 642 }
Vanger 27:ec44d5a9544f 643 } //Success if less than 50% packet loss
Vanger 27:ec44d5a9544f 644 if( ((pingsRec/PINGNUM)>= 0.5) ) {
Vanger 27:ec44d5a9544f 645 return true;
Vanger 27:ec44d5a9544f 646 }
Vanger 26:2b769ed8de4f 647 return false;
Vanger 26:2b769ed8de4f 648 }
Vanger 26:2b769ed8de4f 649
Vanger 27:ec44d5a9544f 650 //Pass 1 to enable socket closeable
Vanger 27:ec44d5a9544f 651 //Pass 0 to disable socket closeable
Vanger 26:2b769ed8de4f 652 Code EasyIP::setSocketCloseable(bool enabled)
Vanger 26:2b769ed8de4f 653 {
Vanger 31:529db15abda7 654 if(socketCloseable == enabled) {
Vanger 31:529db15abda7 655 return MTS_SUCCESS;
Vanger 31:529db15abda7 656 }
Vanger 31:529db15abda7 657
Vanger 31:529db15abda7 658 if(socketOpened) {
Vanger 31:529db15abda7 659 logError("socket is already opened. Can not set closeable");
Vanger 31:529db15abda7 660 return MTS_ERROR;
Vanger 31:529db15abda7 661 }
Vanger 31:529db15abda7 662
Vanger 31:529db15abda7 663 socketCloseable = enabled;
Vanger 31:529db15abda7 664
Vanger 26:2b769ed8de4f 665 return MTS_SUCCESS;
Vanger 26:2b769ed8de4f 666 }
Vanger 33:3b6f3904dde0 667
Vanger 33:3b6f3904dde0 668 bool EasyIP::sendEscapeCommand()
Vanger 33:3b6f3904dde0 669 {
Vanger 33:3b6f3904dde0 670 //string Cellular::sendCommand(const std::string& command, unsigned int timeoutMillis, char esc)
Vanger 33:3b6f3904dde0 671 if(io == NULL) {
Vanger 33:3b6f3904dde0 672 logError("MTSBufferedIO not set");
Vanger 33:3b6f3904dde0 673 return false;
Vanger 33:3b6f3904dde0 674 }
Vanger 33:3b6f3904dde0 675 if(!socketOpened) {
Vanger 33:3b6f3904dde0 676 logError("Socket is not open. Can not send AT escape sequence (+++)");
Vanger 33:3b6f3904dde0 677 return false;
Vanger 33:3b6f3904dde0 678 }
Vanger 33:3b6f3904dde0 679
Vanger 33:3b6f3904dde0 680 if(!socketCloseable) {
Vanger 33:3b6f3904dde0 681 logError("Socket is not closeable");
Vanger 33:3b6f3904dde0 682 return false;
Vanger 33:3b6f3904dde0 683 }
Vanger 33:3b6f3904dde0 684
Vanger 33:3b6f3904dde0 685 io->rxClear();
Vanger 33:3b6f3904dde0 686 io->txClear();
Vanger 33:3b6f3904dde0 687
Vanger 33:3b6f3904dde0 688 std::string result;
Vanger 33:3b6f3904dde0 689 unsigned int timeoutMillis = 2000;
Vanger 33:3b6f3904dde0 690 const int size_cmd = 3;
Vanger 33:3b6f3904dde0 691 //Attempt to write command
Vanger 33:3b6f3904dde0 692 wait(1); //Format for +++ command is 1 second wait, send +++, then another second wait
Vanger 33:3b6f3904dde0 693 //1s wait after command is implemented as a polling function for 2 seconds
Vanger 33:3b6f3904dde0 694 //Option: Could change wait periods to be longer/shorter (0-255)*50ms
Vanger 33:3b6f3904dde0 695 if(io->write("+++", size_cmd, timeoutMillis) != size_cmd) {
Vanger 33:3b6f3904dde0 696 //Failed to write command
Vanger 33:3b6f3904dde0 697 logError("failed to send command to radio within %d milliseconds", timeoutMillis);
Vanger 33:3b6f3904dde0 698 return false;
Vanger 33:3b6f3904dde0 699 }
Vanger 33:3b6f3904dde0 700
Vanger 33:3b6f3904dde0 701 int timer = 0;
Vanger 33:3b6f3904dde0 702 char tmp[256];
Vanger 33:3b6f3904dde0 703 tmp[255] = 0;
Vanger 33:3b6f3904dde0 704 bool done = false;
Vanger 33:3b6f3904dde0 705 io->read(tmp,255,0);
Vanger 33:3b6f3904dde0 706 bool exitmode = false;
Vanger 33:3b6f3904dde0 707
Vanger 33:3b6f3904dde0 708 do {
Vanger 33:3b6f3904dde0 709 wait(0.1);
Vanger 33:3b6f3904dde0 710 timer += 100;
Vanger 33:3b6f3904dde0 711 //Make a non-blocking read call by passing timeout of zero
Vanger 33:3b6f3904dde0 712 int size = io->read(tmp,255,0); //1 less than allocated (timeout is instant)
Vanger 33:3b6f3904dde0 713 if(size > 0) {
Vanger 33:3b6f3904dde0 714 result.append(tmp, size);
Vanger 33:3b6f3904dde0 715 }
Vanger 33:3b6f3904dde0 716 if(result.find("OK") != std::string::npos) {
Vanger 33:3b6f3904dde0 717 exitmode = true;
Vanger 33:3b6f3904dde0 718 done = true;
Vanger 33:3b6f3904dde0 719 } else if(result.find("NO CARRIER") != std::string::npos) {
Vanger 33:3b6f3904dde0 720 exitmode = true;
Vanger 33:3b6f3904dde0 721 done = true;
Vanger 33:3b6f3904dde0 722 } else if(result.find("ERROR") != std::string::npos) {
Vanger 33:3b6f3904dde0 723 exitmode = false;
Vanger 33:3b6f3904dde0 724 done = true;
Vanger 33:3b6f3904dde0 725 }
Vanger 33:3b6f3904dde0 726 if(timer >= timeoutMillis) {
Vanger 33:3b6f3904dde0 727 logDebug("Escape sequence [+++] timed out after %d milliseconds", timeoutMillis);
Vanger 33:3b6f3904dde0 728 exitmode = true;
Vanger 33:3b6f3904dde0 729 done = true;
Vanger 33:3b6f3904dde0 730 }
Vanger 33:3b6f3904dde0 731 } while (!done);
Vanger 33:3b6f3904dde0 732
Vanger 33:3b6f3904dde0 733 return exitmode;
Vanger 33:3b6f3904dde0 734 }
Vanger 33:3b6f3904dde0 735
Vanger 33:3b6f3904dde0 736 bool EasyIP::socketCheck() {
Vanger 33:3b6f3904dde0 737 bool status = false;
Vanger 33:3b6f3904dde0 738 std::string socketInfo = "9"; //9 is unrecognized
Vanger 33:3b6f3904dde0 739 std::vector<std::string> params;
Vanger 33:3b6f3904dde0 740
Vanger 33:3b6f3904dde0 741 //Goes from data mode to command mode
Vanger 33:3b6f3904dde0 742 if(sendEscapeCommand()) {
Vanger 33:3b6f3904dde0 743 socketOpened = false;
Vanger 33:3b6f3904dde0 744 if(sendBasicCommand("AT", 1000) == MTS_SUCCESS) {
Vanger 33:3b6f3904dde0 745 socketInfo = sendCommand("AT#SS=1", 2000);
Vanger 33:3b6f3904dde0 746 if(socketInfo.find("OK") != std::string::npos) {
Vanger 33:3b6f3904dde0 747 //Found valid response
Vanger 33:3b6f3904dde0 748 params = Text::split(socketInfo, "\r\n");
Vanger 33:3b6f3904dde0 749 params = Text::split(params[1], ",");
Vanger 33:3b6f3904dde0 750 socketInfo = params[1];
Vanger 33:3b6f3904dde0 751 //Check comparison of params[1] to response codes
Vanger 33:3b6f3904dde0 752 } else {
Vanger 33:3b6f3904dde0 753 logError("Could not determine socket status[%s]",socketInfo.c_str());
Vanger 33:3b6f3904dde0 754 socketInfo == "9"; //9 is unrecognized
Vanger 33:3b6f3904dde0 755 }
Vanger 33:3b6f3904dde0 756 }
Vanger 33:3b6f3904dde0 757 } else {
Vanger 33:3b6f3904dde0 758 status = false; //Return value of socketOpened when checking
Vanger 33:3b6f3904dde0 759 }
Vanger 33:3b6f3904dde0 760
Vanger 33:3b6f3904dde0 761 //Check socket status query
Vanger 33:3b6f3904dde0 762 if(socketInfo == "2" || socketInfo == "3" || socketInfo == "1" || socketInfo == "4") {
Vanger 33:3b6f3904dde0 763 status = true; //2 and 3 are suspended connections
Vanger 33:3b6f3904dde0 764 } else if(socketInfo == "0" || socketInfo == "5") {
Vanger 33:3b6f3904dde0 765 status = false; //0 is closed socket, probably won't occur
Vanger 33:3b6f3904dde0 766 } else {
Vanger 33:3b6f3904dde0 767 logError("Could not determine socket status");
Vanger 33:3b6f3904dde0 768 status = false; //anything else is unknown status
Vanger 33:3b6f3904dde0 769 }
Vanger 33:3b6f3904dde0 770
Vanger 33:3b6f3904dde0 771 //Reconnects to active socket if able
Vanger 33:3b6f3904dde0 772 if(status) {
Vanger 33:3b6f3904dde0 773 std::string reconnect = sendCommand("AT#SO=1", 2000);
Vanger 33:3b6f3904dde0 774 if(reconnect.find("CONNECT") != std::string::npos || reconnect.find("OK") != std::string::npos) {
Vanger 33:3b6f3904dde0 775 } else {
Vanger 33:3b6f3904dde0 776 logError("Failed to resume socket connection");
Vanger 33:3b6f3904dde0 777 }
Vanger 33:3b6f3904dde0 778 }
Vanger 33:3b6f3904dde0 779 return status;
Vanger 33:3b6f3904dde0 780 }