Alcatel-Lucent IoT Development / MTS-Cellular

Fix for UIP read of DLE escape character.

Dependents:   mtsas

Fork of MTS-Cellular by MultiTech

Cellular/EasyIP.cpp@32:7d5581159bed, 2014-07-15 (annotated)

Committer:
Vanger
Date:
Tue Jul 15 20:37:08 2014 +0000
Revision:
32:7d5581159bed
Parent:
31:529db15abda7
Child:
33:3b6f3904dde0
Set EasyIP to initialize with AT+IFC=2,2 command to enable flow control, under EasyIP.cpp; All tests under dotests() passed, library should be complete.

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