Multi-Hackers / SocketModem

A library for talking to Multi-Tech's Cellular SocketModem Devices.

Dependents:   M2X_dev axeda_wrapper_dev MTS_M2x_Example1 MTS_Cellular_Connect_Example ... more

wifi/Wifi.cpp@130:5a8af68a46ec, 2014-01-02 (annotated)

Committer:
jengbrecht
Date:
Thu Jan 02 21:46:57 2014 +0000
Revision:
130:5a8af68a46ec
Parent:
127:526003734633
Child:
131:da8f0e1c264a
Child:
134:50e2616ac755
In Wifi made reset more robust!

Who changed what in which revision?

UserRevisionLine numberNew contents of line
jengbrecht 69:f3e696bbb0d5 1 #include "Wifi.h"
jengbrecht 93:aa7a48e65974 2 #include <string>
jengbrecht 69:f3e696bbb0d5 3
jengbrecht 69:f3e696bbb0d5 4 Wifi* Wifi::instance = NULL;
jengbrecht 69:f3e696bbb0d5 5
jengbrecht 69:f3e696bbb0d5 6 Wifi* Wifi::getInstance()
jengbrecht 69:f3e696bbb0d5 7 {
jengbrecht 69:f3e696bbb0d5 8 if(instance == NULL) {
jengbrecht 69:f3e696bbb0d5 9 instance = new Wifi(NULL);
jengbrecht 69:f3e696bbb0d5 10 }
jengbrecht 69:f3e696bbb0d5 11 return instance;
jengbrecht 69:f3e696bbb0d5 12 }
jengbrecht 69:f3e696bbb0d5 13
jengbrecht 69:f3e696bbb0d5 14 bool Wifi::init(MTSBufferedIO* io)
jengbrecht 69:f3e696bbb0d5 15 {
jengbrecht 69:f3e696bbb0d5 16 if (io == NULL) {
jengbrecht 69:f3e696bbb0d5 17 return false;
jengbrecht 69:f3e696bbb0d5 18 }
jengbrecht 69:f3e696bbb0d5 19 instance->io = io;
jengbrecht 130:5a8af68a46ec 20
jengbrecht 127:526003734633 21 //Check initial state of command mode
jengbrecht 127:526003734633 22 std::string response = sendCommand("", 1000, ">");
jengbrecht 127:526003734633 23 if(response.find(">") != string::npos) {
jengbrecht 127:526003734633 24 cmdOn = true;
jengbrecht 127:526003734633 25 }
jengbrecht 127:526003734633 26
jengbrecht 94:1baa587e89ae 27 //Set device into command mode
jengbrecht 94:1baa587e89ae 28 if (!setCmdMode(true)) {
jengbrecht 94:1baa587e89ae 29 return false;
jengbrecht 94:1baa587e89ae 30 }
jengbrecht 94:1baa587e89ae 31
jengbrecht 94:1baa587e89ae 32 //Set device to non-echo mode
jengbrecht 94:1baa587e89ae 33 if (sendBasicCommand("set uart mode 1", 1000) != SUCCESS) {
jengbrecht 94:1baa587e89ae 34 printf("[ERROR] Failed to set to non-echo mode\n\r");
jengbrecht 94:1baa587e89ae 35 return false;
jengbrecht 74:9f87bd22c222 36 }
jengbrecht 94:1baa587e89ae 37
jengbrecht 94:1baa587e89ae 38 //Set device to manual infrastructure mode
jengbrecht 94:1baa587e89ae 39 if (sendBasicCommand("set wlan join 0", 1000) != SUCCESS) {
jengbrecht 94:1baa587e89ae 40 printf("[ERROR] Failed to set join mode\n\r");
jengbrecht 94:1baa587e89ae 41 return false;
jengbrecht 94:1baa587e89ae 42 }
jengbrecht 94:1baa587e89ae 43
jengbrecht 94:1baa587e89ae 44 //Set device to channel auto-scanning mode
jengbrecht 94:1baa587e89ae 45 if (sendBasicCommand("set wlan channel 0", 1000) != SUCCESS) {
jengbrecht 94:1baa587e89ae 46 printf("[ERROR] Failed to set auto-scanning mode\n\r");
jengbrecht 94:1baa587e89ae 47 return false;
jengbrecht 94:1baa587e89ae 48 }
jengbrecht 94:1baa587e89ae 49
jengbrecht 94:1baa587e89ae 50 //Set device so no data is transmitted immediately following a socket connection
jengbrecht 94:1baa587e89ae 51 if (sendBasicCommand("set comm remote 0", 1000) != SUCCESS) {
jengbrecht 94:1baa587e89ae 52 printf("[ERROR] Failed to set remote transmit mode\n\r");
jengbrecht 94:1baa587e89ae 53 return false;
jengbrecht 94:1baa587e89ae 54 }
jengbrecht 106:358972176b89 55
jengbrecht 106:358972176b89 56 //Set device into DHCP mode by default
jengbrecht 106:358972176b89 57 if (sendBasicCommand("set ip dhcp 1", 1000) != SUCCESS) {
jengbrecht 106:358972176b89 58 printf("[ERROR] Failed to set to default DHCP mode\n\r");
jengbrecht 106:358972176b89 59 return false;
jengbrecht 106:358972176b89 60 }
jengbrecht 106:358972176b89 61
jengbrecht 94:1baa587e89ae 62 return true;
jengbrecht 69:f3e696bbb0d5 63 }
jengbrecht 69:f3e696bbb0d5 64
jengbrecht 69:f3e696bbb0d5 65 Wifi::Wifi(MTSBufferedIO* io)
jengbrecht 69:f3e696bbb0d5 66 : io(io)
jengbrecht 69:f3e696bbb0d5 67 , wifiConnected(false)
jengbrecht 79:f356009dbc12 68 , _ssid("")
jengbrecht 69:f3e696bbb0d5 69 , mode(TCP)
jengbrecht 69:f3e696bbb0d5 70 , socketOpened(false)
jengbrecht 69:f3e696bbb0d5 71 , socketCloseable(true)
jengbrecht 69:f3e696bbb0d5 72 , local_port(0)
jengbrecht 106:358972176b89 73 , local_address("")
jengbrecht 69:f3e696bbb0d5 74 , host_port(0)
jengbrecht 79:f356009dbc12 75 , cmdOn(false)
jengbrecht 69:f3e696bbb0d5 76 {
jengbrecht 69:f3e696bbb0d5 77
jengbrecht 69:f3e696bbb0d5 78 }
jengbrecht 69:f3e696bbb0d5 79
jengbrecht 69:f3e696bbb0d5 80 Wifi::~Wifi()
jengbrecht 69:f3e696bbb0d5 81 {
jengbrecht 69:f3e696bbb0d5 82 }
jengbrecht 69:f3e696bbb0d5 83
jengbrecht 69:f3e696bbb0d5 84 bool Wifi::connect()
jengbrecht 69:f3e696bbb0d5 85 {
jengbrecht 69:f3e696bbb0d5 86 //Check if socket is open
jengbrecht 69:f3e696bbb0d5 87 if(socketOpened) {
jengbrecht 69:f3e696bbb0d5 88 return true;
jengbrecht 69:f3e696bbb0d5 89 }
jengbrecht 69:f3e696bbb0d5 90
jengbrecht 69:f3e696bbb0d5 91 //Run Test first to validate a good state
jengbrecht 69:f3e696bbb0d5 92 if(isConnected()) {
jengbrecht 69:f3e696bbb0d5 93 return true;
jengbrecht 69:f3e696bbb0d5 94 }
jengbrecht 69:f3e696bbb0d5 95
jengbrecht 93:aa7a48e65974 96 if (_ssid.size() == 0) {
jengbrecht 93:aa7a48e65974 97 printf("[ERROR] No SSID has been set\n\r");
jengbrecht 93:aa7a48e65974 98 return false;
jengbrecht 93:aa7a48e65974 99 }
jengbrecht 93:aa7a48e65974 100
jengbrecht 98:dbeac735109d 101 if(!setCmdMode(true)) {
jengbrecht 98:dbeac735109d 102 return false;
jengbrecht 93:aa7a48e65974 103 }
jengbrecht 93:aa7a48e65974 104
jengbrecht 69:f3e696bbb0d5 105 //Possibly add a scan command here and look for the network....
jengbrecht 69:f3e696bbb0d5 106
jengbrecht 69:f3e696bbb0d5 107 //join my_network
jengbrecht 69:f3e696bbb0d5 108 printf("[DEBUG] Making SSID Connection Attempt. SSID[%s]\r\n", _ssid.c_str());
jengbrecht 93:aa7a48e65974 109 std::string result = sendCommand("join " + _ssid, 15000, "Listen");
jengbrecht 93:aa7a48e65974 110 //printf("Connect Status: %s\n\r", result.c_str());
jengbrecht 69:f3e696bbb0d5 111
jengbrecht 93:aa7a48e65974 112 //Check whether connection was successful
jengbrecht 93:aa7a48e65974 113 if(result.find("Associated!") != string::npos) {
jengbrecht 106:358972176b89 114 if(result.find("Static") == string::npos) {
jengbrecht 106:358972176b89 115 int start = result.find("IP=");
jengbrecht 106:358972176b89 116 int stop = result.find(":", start);
jengbrecht 106:358972176b89 117 local_address = result.substr(start + 3, stop - start - 3);
jengbrecht 106:358972176b89 118 }
jengbrecht 93:aa7a48e65974 119 printf("[INFO] WiFi Connection Established: IP[%s]\r\n", local_address.c_str());
jengbrecht 93:aa7a48e65974 120 wifiConnected = true;
jengbrecht 106:358972176b89 121
jengbrecht 103:da58d27c15d7 122 //Report Signal Strength of new connection
jengbrecht 103:da58d27c15d7 123 wait(1); //Needed for signal strength to be available
jengbrecht 103:da58d27c15d7 124 int rssi = getSignalStrength();
jengbrecht 103:da58d27c15d7 125 printf("[DEBUG] Signal strength (dBm): %d\r\n", rssi);
jengbrecht 93:aa7a48e65974 126 } else {
jengbrecht 93:aa7a48e65974 127 wifiConnected = false;
jengbrecht 93:aa7a48e65974 128 }
jengbrecht 69:f3e696bbb0d5 129
jengbrecht 69:f3e696bbb0d5 130 return wifiConnected;
jengbrecht 69:f3e696bbb0d5 131 }
jengbrecht 69:f3e696bbb0d5 132
jengbrecht 69:f3e696bbb0d5 133 void Wifi::disconnect()
jengbrecht 69:f3e696bbb0d5 134 {
jengbrecht 79:f356009dbc12 135 printf("[DEBUG] Disconnecting from network\r\n");
jengbrecht 79:f356009dbc12 136
jengbrecht 79:f356009dbc12 137 if(socketOpened) {
jengbrecht 79:f356009dbc12 138 close();
jengbrecht 79:f356009dbc12 139 }
jengbrecht 79:f356009dbc12 140
jengbrecht 98:dbeac735109d 141 if(!setCmdMode(true)) {
jengbrecht 98:dbeac735109d 142 printf("[ERROR] Failed in disconnecting from network. Continuing ...\r\n");
jengbrecht 79:f356009dbc12 143 }
jengbrecht 79:f356009dbc12 144
jengbrecht 100:9d96b4391151 145 std::string response = sendCommand("leave", 10000, "<4.00>");
jengbrecht 100:9d96b4391151 146 response = sendCommand("show net", 5000, "Links");
jengbrecht 100:9d96b4391151 147 //printf("Response: %s\n\r", response.c_str());
jengbrecht 100:9d96b4391151 148 if (response.find("Assoc=FAIL") != string::npos) {
jengbrecht 79:f356009dbc12 149 printf("[DEBUG] Successfully disconnected from network\r\n");
jengbrecht 79:f356009dbc12 150 } else {
jengbrecht 79:f356009dbc12 151 printf("[ERROR] Failed in disconnecting from network. Continuing ...\r\n");
jengbrecht 79:f356009dbc12 152 }
jengbrecht 79:f356009dbc12 153
jengbrecht 79:f356009dbc12 154 wifiConnected = false;
jengbrecht 69:f3e696bbb0d5 155 }
jengbrecht 69:f3e696bbb0d5 156
jengbrecht 69:f3e696bbb0d5 157 bool Wifi::isConnected()
jengbrecht 69:f3e696bbb0d5 158 {
jengbrecht 79:f356009dbc12 159 //1) Check if SSID was set
jengbrecht 79:f356009dbc12 160 if(_ssid.size() == 0) {
jengbrecht 79:f356009dbc12 161 printf("[DEBUG] SSID is not set\r\n");
jengbrecht 79:f356009dbc12 162 return false;
jengbrecht 79:f356009dbc12 163 }
jengbrecht 79:f356009dbc12 164
jengbrecht 79:f356009dbc12 165 //1) Check that we do not have a live connection up
jengbrecht 117:e59a616ffe16 166 if(isOpen()) {
jengbrecht 79:f356009dbc12 167 printf("[DEBUG] Socket is opened\r\n");
jengbrecht 79:f356009dbc12 168 return true;
jengbrecht 79:f356009dbc12 169 }
jengbrecht 79:f356009dbc12 170
jengbrecht 98:dbeac735109d 171 //Check command mode.
jengbrecht 98:dbeac735109d 172 if(!setCmdMode(true)) {
jengbrecht 98:dbeac735109d 173 return false;
jengbrecht 98:dbeac735109d 174 }
jengbrecht 98:dbeac735109d 175
jengbrecht 79:f356009dbc12 176 //2) Query the wifi module
jengbrecht 79:f356009dbc12 177 wifiConnected = false;
jengbrecht 93:aa7a48e65974 178 std::string result = sendCommand("show net", 5000, "Links");
jengbrecht 93:aa7a48e65974 179 //printf("netResult: %s\n\r", result);
jengbrecht 93:aa7a48e65974 180 if(result.find("Assoc=OK") != std::string::npos) {
jengbrecht 79:f356009dbc12 181 wifiConnected = true;
jengbrecht 79:f356009dbc12 182 }
jengbrecht 79:f356009dbc12 183
jengbrecht 79:f356009dbc12 184 return wifiConnected;
jengbrecht 69:f3e696bbb0d5 185 }
jengbrecht 69:f3e696bbb0d5 186
jengbrecht 69:f3e696bbb0d5 187 bool Wifi::bind(unsigned int port)
jengbrecht 69:f3e696bbb0d5 188 {
jengbrecht 94:1baa587e89ae 189 if(socketOpened) {
jengbrecht 94:1baa587e89ae 190 printf("[ERROR] socket is open. Can not set local port\r\n");
jengbrecht 94:1baa587e89ae 191 return false;
jengbrecht 94:1baa587e89ae 192 }
jengbrecht 94:1baa587e89ae 193 if(port > 65535) {
jengbrecht 94:1baa587e89ae 194 printf("[ERROR] port out of range (0-65535)\r\n");
jengbrecht 94:1baa587e89ae 195 return false;
jengbrecht 94:1baa587e89ae 196 }
jengbrecht 94:1baa587e89ae 197 local_port = port;
jengbrecht 69:f3e696bbb0d5 198 return true;
jengbrecht 69:f3e696bbb0d5 199 }
jengbrecht 69:f3e696bbb0d5 200
jengbrecht 69:f3e696bbb0d5 201 bool Wifi::open(const std::string& address, unsigned int port, Mode mode)
jengbrecht 69:f3e696bbb0d5 202 {
jengbrecht 95:4fdf968b5b37 203 char buffer[256] = {0};
jengbrecht 95:4fdf968b5b37 204 printf("[DEBUG] Attempting to Open Socket\r\n");
jengbrecht 95:4fdf968b5b37 205
jengbrecht 95:4fdf968b5b37 206 //1) Check that we do not have a live connection up
jengbrecht 95:4fdf968b5b37 207 if(socketOpened) {
jengbrecht 95:4fdf968b5b37 208 //Check that the address, port, and mode match
jengbrecht 95:4fdf968b5b37 209 if(host_address != address || host_port != port || this->mode != mode) {
jengbrecht 95:4fdf968b5b37 210 if(this->mode == TCP) {
jengbrecht 95:4fdf968b5b37 211 printf("[ERROR] TCP socket already opened (%s:%d)\r\n", host_address.c_str(), host_port);
jengbrecht 95:4fdf968b5b37 212 } else {
jengbrecht 95:4fdf968b5b37 213 printf("[ERROR] UDP socket already opened (%s:%d)\r\n", host_address.c_str(), host_port);
jengbrecht 95:4fdf968b5b37 214 }
jengbrecht 95:4fdf968b5b37 215 return false;
jengbrecht 95:4fdf968b5b37 216 }
jengbrecht 95:4fdf968b5b37 217
jengbrecht 95:4fdf968b5b37 218 printf("[DEBUG] Socket already opened\r\n");
jengbrecht 95:4fdf968b5b37 219 return true;
jengbrecht 95:4fdf968b5b37 220 }
jengbrecht 95:4fdf968b5b37 221
jengbrecht 95:4fdf968b5b37 222 //2) Check Parameters
jengbrecht 95:4fdf968b5b37 223 if(port > 65535) {
jengbrecht 95:4fdf968b5b37 224 printf("[ERROR] port out of range (0-65535)\r\n");
jengbrecht 95:4fdf968b5b37 225 return false;
jengbrecht 95:4fdf968b5b37 226 }
jengbrecht 95:4fdf968b5b37 227
jengbrecht 95:4fdf968b5b37 228
jengbrecht 95:4fdf968b5b37 229 //3) Check Wifi network connection
jengbrecht 95:4fdf968b5b37 230 if(!isConnected()) {
jengbrecht 95:4fdf968b5b37 231 printf("[ERROR] Wifi network not connected. Attempting to connect\r\n");
jengbrecht 95:4fdf968b5b37 232 if(!connect()) {
jengbrecht 95:4fdf968b5b37 233 printf("[ERROR] Wifi network connection failed\r\n");
jengbrecht 95:4fdf968b5b37 234 return false;
jengbrecht 95:4fdf968b5b37 235 } else {
jengbrecht 95:4fdf968b5b37 236 printf("[DEBUG] Wifi connection established\r\n");
jengbrecht 95:4fdf968b5b37 237 }
jengbrecht 95:4fdf968b5b37 238 }
jengbrecht 95:4fdf968b5b37 239
jengbrecht 95:4fdf968b5b37 240 //Check command mode
jengbrecht 98:dbeac735109d 241 if(!setCmdMode(true)) {
jengbrecht 98:dbeac735109d 242 return false;
jengbrecht 95:4fdf968b5b37 243 }
jengbrecht 95:4fdf968b5b37 244
jengbrecht 95:4fdf968b5b37 245 //Set Local Port
jengbrecht 95:4fdf968b5b37 246 if(local_port != 0) {
jengbrecht 95:4fdf968b5b37 247 //Attempt to set local port
jengbrecht 95:4fdf968b5b37 248 sprintf(buffer, "set ip localport %d", local_port);
jengbrecht 95:4fdf968b5b37 249 Code code = sendBasicCommand(buffer, 1000);
jengbrecht 95:4fdf968b5b37 250 if(code != SUCCESS) {
jengbrecht 95:4fdf968b5b37 251 printf("[WARNING] Unable to set local port (%d) [%d]. Continuing...\r\n", local_port, (int) code);
jengbrecht 95:4fdf968b5b37 252 }
jengbrecht 95:4fdf968b5b37 253 }
jengbrecht 95:4fdf968b5b37 254
jengbrecht 95:4fdf968b5b37 255 //Set TCP/UDP parameters
jengbrecht 95:4fdf968b5b37 256 sprintf(buffer, "set ip remote %d", port);
jengbrecht 95:4fdf968b5b37 257 if(sendBasicCommand(buffer, 1000) == SUCCESS) {
jengbrecht 95:4fdf968b5b37 258 host_port = port;
jengbrecht 95:4fdf968b5b37 259 } else {
jengbrecht 95:4fdf968b5b37 260 printf("[ERROR] Host port could not be set\r\n");
jengbrecht 95:4fdf968b5b37 261 }
jengbrecht 95:4fdf968b5b37 262
jengbrecht 95:4fdf968b5b37 263 if(sendBasicCommand("set ip host " + address, 1000) == SUCCESS) {
jengbrecht 95:4fdf968b5b37 264 host_address = address;
jengbrecht 95:4fdf968b5b37 265 } else {
jengbrecht 95:4fdf968b5b37 266 printf("[ERROR] Host address could not be set\r\n");
jengbrecht 95:4fdf968b5b37 267 }
jengbrecht 95:4fdf968b5b37 268
jengbrecht 100:9d96b4391151 269 if(sendBasicCommand("set ip protocol 8", 1000) != SUCCESS) {
jengbrecht 100:9d96b4391151 270 printf("[ERROR] Failed to set TCP mode\r\n");
jengbrecht 95:4fdf968b5b37 271 }
jengbrecht 95:4fdf968b5b37 272
jengbrecht 95:4fdf968b5b37 273 // Try and Connect
jengbrecht 95:4fdf968b5b37 274 std::string sMode;
jengbrecht 95:4fdf968b5b37 275 std::string sOpenSocketCmd;
jengbrecht 95:4fdf968b5b37 276 if(mode == TCP) {
jengbrecht 95:4fdf968b5b37 277 sOpenSocketCmd = "open";
jengbrecht 95:4fdf968b5b37 278 sMode = "TCP";
jengbrecht 95:4fdf968b5b37 279 } else {
jengbrecht 100:9d96b4391151 280 //TODO
jengbrecht 100:9d96b4391151 281 //sOpenSocketCmd = "AT#OUDP";
jengbrecht 100:9d96b4391151 282 //sMode = "UDP";
jengbrecht 95:4fdf968b5b37 283 }
jengbrecht 100:9d96b4391151 284 string response = sendCommand(sOpenSocketCmd, 10000, "OPEN");
jengbrecht 95:4fdf968b5b37 285 if (response.find("OPEN") != string::npos) {
jengbrecht 95:4fdf968b5b37 286 printf("[INFO] Opened %s Socket [%s:%d]\r\n", sMode.c_str(), address.c_str(), port);
jengbrecht 95:4fdf968b5b37 287 socketOpened = true;
jengbrecht 100:9d96b4391151 288 cmdOn = false;
jengbrecht 95:4fdf968b5b37 289 } else {
jengbrecht 95:4fdf968b5b37 290 printf("[WARNING] Unable to open %s Socket [%s:%d]\r\n", sMode.c_str(), address.c_str(), port);
jengbrecht 95:4fdf968b5b37 291 socketOpened = false;
jengbrecht 95:4fdf968b5b37 292 }
jengbrecht 95:4fdf968b5b37 293
jengbrecht 95:4fdf968b5b37 294 return socketOpened;
jengbrecht 69:f3e696bbb0d5 295 }
jengbrecht 69:f3e696bbb0d5 296
jengbrecht 69:f3e696bbb0d5 297 bool Wifi::isOpen()
jengbrecht 69:f3e696bbb0d5 298 {
jengbrecht 122:5f95f81a8b03 299 if(io->readable()) {
jengbrecht 122:5f95f81a8b03 300 printf("[DEBUG] Assuming open, data available to read.\n\r");
jengbrecht 122:5f95f81a8b03 301 return true;
jengbrecht 122:5f95f81a8b03 302 }
jengbrecht 114:cd34b1d64360 303 if(!setCmdMode(true)) {
jengbrecht 114:cd34b1d64360 304 printf("[ERROR] Failed to properly check if TCP connection is open.\r\n");
jengbrecht 114:cd34b1d64360 305 return socketOpened;
jengbrecht 114:cd34b1d64360 306 }
jengbrecht 114:cd34b1d64360 307 std::string response = sendCommand("show connection", 2000, "\n");
jengbrecht 114:cd34b1d64360 308 int start = response.find("f");
jengbrecht 114:cd34b1d64360 309 if(start != string::npos && response.size() >= (start + 3)) {
jengbrecht 114:cd34b1d64360 310 if(response[start + 3] == '1') {
jengbrecht 114:cd34b1d64360 311 socketOpened = true;
jengbrecht 114:cd34b1d64360 312 } else {
jengbrecht 114:cd34b1d64360 313 socketOpened = false;
jengbrecht 114:cd34b1d64360 314 }
jengbrecht 114:cd34b1d64360 315 } else {
jengbrecht 114:cd34b1d64360 316 printf("[WARNING] Trouble checking TCP Connection status.\n\r");
jengbrecht 114:cd34b1d64360 317 }
jengbrecht 95:4fdf968b5b37 318 return socketOpened;
jengbrecht 69:f3e696bbb0d5 319 }
jengbrecht 69:f3e696bbb0d5 320
jengbrecht 69:f3e696bbb0d5 321 bool Wifi::close()
jengbrecht 69:f3e696bbb0d5 322 {
jengbrecht 114:cd34b1d64360 323 wait(1);
jengbrecht 95:4fdf968b5b37 324 if(io == NULL) {
jengbrecht 95:4fdf968b5b37 325 printf("[ERROR] MTSBufferedIO not set\r\n");
jengbrecht 95:4fdf968b5b37 326 return false;
jengbrecht 95:4fdf968b5b37 327 }
jengbrecht 95:4fdf968b5b37 328
jengbrecht 95:4fdf968b5b37 329 if(!socketOpened) {
jengbrecht 95:4fdf968b5b37 330 printf("[WARNING] Socket close() called, but socket was not open\r\n");
jengbrecht 95:4fdf968b5b37 331 return true;
jengbrecht 95:4fdf968b5b37 332 }
jengbrecht 95:4fdf968b5b37 333
jengbrecht 98:dbeac735109d 334 if(!setCmdMode(true)) {
jengbrecht 98:dbeac735109d 335 printf("[ERROR] Failed to close socket\r\n");
jengbrecht 98:dbeac735109d 336 return false;
jengbrecht 95:4fdf968b5b37 337 }
jengbrecht 95:4fdf968b5b37 338
jengbrecht 114:cd34b1d64360 339 if(isOpen()) {
jengbrecht 114:cd34b1d64360 340 std::string response = sendCommand("close", 3000, "CLOS");
jengbrecht 114:cd34b1d64360 341 if(response.find("CLOS") == string::npos) {
jengbrecht 114:cd34b1d64360 342 printf("[WARNING] Failed to successfully close socket...\r\n");
jengbrecht 114:cd34b1d64360 343 return false;
jengbrecht 114:cd34b1d64360 344 }
jengbrecht 95:4fdf968b5b37 345 }
jengbrecht 121:5a7fba896c98 346
jengbrecht 119:544578fd290c 347 wait(1); //Wait so the subsequent isOpen calls return correctly.
jengbrecht 113:7238f9b8db17 348 io->rxClear();
jengbrecht 113:7238f9b8db17 349 io->txClear();
jengbrecht 114:cd34b1d64360 350
jengbrecht 69:f3e696bbb0d5 351 return true;
jengbrecht 69:f3e696bbb0d5 352 }
jengbrecht 69:f3e696bbb0d5 353
jengbrecht 69:f3e696bbb0d5 354 int Wifi::read(char* data, int max, int timeout)
jengbrecht 69:f3e696bbb0d5 355 {
jengbrecht 98:dbeac735109d 356 if(io == NULL) {
jengbrecht 98:dbeac735109d 357 printf("[ERROR] MTSBufferedIO not set\r\n");
jengbrecht 98:dbeac735109d 358 return -1;
jengbrecht 98:dbeac735109d 359 }
jengbrecht 98:dbeac735109d 360
jengbrecht 98:dbeac735109d 361 //Check that nothing is in the rx buffer
jengbrecht 98:dbeac735109d 362 if(!socketOpened && !io->readable()) {
jengbrecht 98:dbeac735109d 363 printf("[ERROR] Socket is not open\r\n");
jengbrecht 98:dbeac735109d 364 return -1;
jengbrecht 98:dbeac735109d 365 }
jengbrecht 98:dbeac735109d 366
jengbrecht 98:dbeac735109d 367 //Check for data mode
jengbrecht 98:dbeac735109d 368 if(!setCmdMode(false)) {
jengbrecht 98:dbeac735109d 369 printf("[ERROR] Failed to read data due to mode\r\n");
jengbrecht 98:dbeac735109d 370 return -1;
jengbrecht 98:dbeac735109d 371 }
jengbrecht 98:dbeac735109d 372
jengbrecht 98:dbeac735109d 373 int bytesRead = 0;
jengbrecht 98:dbeac735109d 374
jengbrecht 98:dbeac735109d 375 if(timeout >= 0) {
jengbrecht 98:dbeac735109d 376 bytesRead = io->read(data, max, static_cast<unsigned int>(timeout));
jengbrecht 98:dbeac735109d 377 } else {
jengbrecht 98:dbeac735109d 378 bytesRead = io->read(data, max);
jengbrecht 98:dbeac735109d 379 }
jengbrecht 98:dbeac735109d 380
jengbrecht 98:dbeac735109d 381 return bytesRead;
jengbrecht 69:f3e696bbb0d5 382 }
jengbrecht 69:f3e696bbb0d5 383
jengbrecht 69:f3e696bbb0d5 384 int Wifi::write(const char* data, int length, int timeout)
jengbrecht 69:f3e696bbb0d5 385 {
jengbrecht 98:dbeac735109d 386 if(io == NULL) {
jengbrecht 98:dbeac735109d 387 printf("[ERROR] MTSBufferedIO not set\r\n");
jengbrecht 98:dbeac735109d 388 return -1;
jengbrecht 98:dbeac735109d 389 }
jengbrecht 98:dbeac735109d 390
jengbrecht 98:dbeac735109d 391 if(!socketOpened) {
jengbrecht 98:dbeac735109d 392 printf("[ERROR] Socket is not open\r\n");
jengbrecht 98:dbeac735109d 393 return -1;
jengbrecht 98:dbeac735109d 394 }
jengbrecht 98:dbeac735109d 395
jengbrecht 98:dbeac735109d 396 //Check for data mode
jengbrecht 98:dbeac735109d 397 if(!setCmdMode(false)) {
jengbrecht 98:dbeac735109d 398 printf("[ERROR] Failed to write data due to mode\r\n");
jengbrecht 98:dbeac735109d 399 return -1;
jengbrecht 98:dbeac735109d 400 }
jengbrecht 98:dbeac735109d 401
jengbrecht 98:dbeac735109d 402 int bytesWritten = 0;
jengbrecht 103:da58d27c15d7 403
jengbrecht 98:dbeac735109d 404 if(timeout >= 0) {
jengbrecht 100:9d96b4391151 405 bytesWritten = io->write(data, length, static_cast<unsigned int>(timeout));
jengbrecht 98:dbeac735109d 406 } else {
jengbrecht 100:9d96b4391151 407 bytesWritten = io->write(data, length);
jengbrecht 98:dbeac735109d 408 }
jengbrecht 103:da58d27c15d7 409
jengbrecht 98:dbeac735109d 410 return bytesWritten;
jengbrecht 69:f3e696bbb0d5 411 }
jengbrecht 69:f3e696bbb0d5 412
jengbrecht 69:f3e696bbb0d5 413 unsigned int Wifi::readable()
jengbrecht 69:f3e696bbb0d5 414 {
jengbrecht 69:f3e696bbb0d5 415 if(io == NULL) {
jengbrecht 69:f3e696bbb0d5 416 printf("[ERROR] MTSBufferedIO not set\r\n");
jengbrecht 69:f3e696bbb0d5 417 return 0;
jengbrecht 69:f3e696bbb0d5 418 }
jengbrecht 69:f3e696bbb0d5 419 if(!socketOpened) {
jengbrecht 69:f3e696bbb0d5 420 printf("[ERROR] Socket is not open\r\n");
jengbrecht 69:f3e696bbb0d5 421 return 0;
jengbrecht 69:f3e696bbb0d5 422 }
jengbrecht 69:f3e696bbb0d5 423 return io->readable();
jengbrecht 69:f3e696bbb0d5 424 }
jengbrecht 69:f3e696bbb0d5 425
jengbrecht 69:f3e696bbb0d5 426 unsigned int Wifi::writeable()
jengbrecht 69:f3e696bbb0d5 427 {
jengbrecht 69:f3e696bbb0d5 428 if(io == NULL) {
jengbrecht 69:f3e696bbb0d5 429 printf("[ERROR] MTSBufferedIO not set\r\n");
jengbrecht 69:f3e696bbb0d5 430 return 0;
jengbrecht 69:f3e696bbb0d5 431 }
jengbrecht 69:f3e696bbb0d5 432 if(!socketOpened) {
jengbrecht 69:f3e696bbb0d5 433 printf("[ERROR] Socket is not open\r\n");
jengbrecht 69:f3e696bbb0d5 434 return 0;
jengbrecht 69:f3e696bbb0d5 435 }
jengbrecht 69:f3e696bbb0d5 436
jengbrecht 69:f3e696bbb0d5 437 return io->writeable();
jengbrecht 69:f3e696bbb0d5 438 }
jengbrecht 69:f3e696bbb0d5 439
jengbrecht 69:f3e696bbb0d5 440 void Wifi::reset()
jengbrecht 69:f3e696bbb0d5 441 {
jengbrecht 121:5a7fba896c98 442 sendCommand("reboot", 2000);
jengbrecht 121:5a7fba896c98 443 wifiConnected = false;
jengbrecht 121:5a7fba896c98 444 _ssid = "";
jengbrecht 121:5a7fba896c98 445 mode = TCP;
jengbrecht 121:5a7fba896c98 446 socketOpened = false;
jengbrecht 121:5a7fba896c98 447 socketCloseable = true;
jengbrecht 121:5a7fba896c98 448 local_port = 0;
jengbrecht 121:5a7fba896c98 449 local_address = "";
jengbrecht 121:5a7fba896c98 450 host_port = 0;
jengbrecht 121:5a7fba896c98 451 cmdOn = false;
jengbrecht 121:5a7fba896c98 452 wait(10);
jengbrecht 130:5a8af68a46ec 453 if(!init(io)) {
jengbrecht 130:5a8af68a46ec 454 printf("[ERROR] Failed to reinitialize after reset.\n\r");
jengbrecht 130:5a8af68a46ec 455 }
jengbrecht 69:f3e696bbb0d5 456 }
jengbrecht 69:f3e696bbb0d5 457
jengbrecht 106:358972176b89 458 Code Wifi::setDeviceIP(std::string address)
jengbrecht 106:358972176b89 459 {
jengbrecht 108:554585370b4a 460 //Check for command mode
jengbrecht 108:554585370b4a 461 if(!setCmdMode(true)) {
jengbrecht 108:554585370b4a 462 printf("[ERROR] Failed to set IP due to mode issue\r\n");
jengbrecht 108:554585370b4a 463 return FAILURE;
jengbrecht 108:554585370b4a 464 }
jengbrecht 113:7238f9b8db17 465
jengbrecht 106:358972176b89 466 //Set to DHCP mode
jengbrecht 106:358972176b89 467 if(address.compare("DHCP") == 0) {
jengbrecht 106:358972176b89 468 return sendBasicCommand("set ip dhcp 1", 1000);
jengbrecht 106:358972176b89 469 }
jengbrecht 106:358972176b89 470
jengbrecht 106:358972176b89 471 //Set to static mode and set address
jengbrecht 106:358972176b89 472 Code code = sendBasicCommand("set ip address " + address, 1000);
jengbrecht 106:358972176b89 473 if(code != SUCCESS) {
jengbrecht 106:358972176b89 474 return code;
jengbrecht 106:358972176b89 475 }
jengbrecht 106:358972176b89 476 code = sendBasicCommand("set ip dhcp 0", 1000);
jengbrecht 106:358972176b89 477 if(code != SUCCESS) {
jengbrecht 106:358972176b89 478 return code;
jengbrecht 106:358972176b89 479 }
jengbrecht 106:358972176b89 480 local_address = address;
jengbrecht 106:358972176b89 481 return SUCCESS;
jengbrecht 106:358972176b89 482 }
jengbrecht 106:358972176b89 483
jengbrecht 106:358972176b89 484 std::string Wifi::getDeviceIP()
jengbrecht 106:358972176b89 485 {
jengbrecht 106:358972176b89 486 return local_address;
jengbrecht 106:358972176b89 487 }
jengbrecht 106:358972176b89 488
jengbrecht 103:da58d27c15d7 489 Code Wifi::setNetwork(const std::string& ssid, SecurityType type, const std::string& key)
jengbrecht 69:f3e696bbb0d5 490 {
jengbrecht 98:dbeac735109d 491 //Check the command mode
jengbrecht 98:dbeac735109d 492 if(!setCmdMode(true)) {
jengbrecht 98:dbeac735109d 493 return FAILURE;
jengbrecht 98:dbeac735109d 494 }
jengbrecht 98:dbeac735109d 495
sgodinez 73:bb5bbca971ae 496 Code code;
jengbrecht 69:f3e696bbb0d5 497
jengbrecht 69:f3e696bbb0d5 498 //Set the appropraite SSID
jengbrecht 69:f3e696bbb0d5 499 code = sendBasicCommand("set wlan ssid " + ssid, 1000);
sgodinez 73:bb5bbca971ae 500 if (code != SUCCESS) {
jengbrecht 69:f3e696bbb0d5 501 return code;
jengbrecht 69:f3e696bbb0d5 502 }
jengbrecht 69:f3e696bbb0d5 503
jengbrecht 69:f3e696bbb0d5 504 //Set the security key
jengbrecht 69:f3e696bbb0d5 505 if (type == WEP64 || type == WEP128) {
jengbrecht 69:f3e696bbb0d5 506 //Set the WEP key if using WEP encryption
jengbrecht 69:f3e696bbb0d5 507 code = sendBasicCommand("set wlan key " + key, 1000);
sgodinez 73:bb5bbca971ae 508 if (code != SUCCESS) {
jengbrecht 69:f3e696bbb0d5 509 return code;
jengbrecht 69:f3e696bbb0d5 510 }
jengbrecht 69:f3e696bbb0d5 511 } else if (type == WPA || type == WPA2) {
jengbrecht 69:f3e696bbb0d5 512 //Set the WPA key if using WPA encryption
jengbrecht 69:f3e696bbb0d5 513 code = sendBasicCommand("set wlan phrase " + key, 1000);
sgodinez 73:bb5bbca971ae 514 if (code != SUCCESS) {
jengbrecht 69:f3e696bbb0d5 515 return code;
jengbrecht 69:f3e696bbb0d5 516 }
jengbrecht 69:f3e696bbb0d5 517 }
jengbrecht 69:f3e696bbb0d5 518
jengbrecht 69:f3e696bbb0d5 519 _ssid = ssid;
sgodinez 73:bb5bbca971ae 520 return SUCCESS;
jengbrecht 69:f3e696bbb0d5 521 }
jengbrecht 69:f3e696bbb0d5 522
jengbrecht 94:1baa587e89ae 523 Code Wifi::setDNS(const std::string& dnsName)
jengbrecht 94:1baa587e89ae 524 {
jengbrecht 98:dbeac735109d 525 //Check the command mode
jengbrecht 98:dbeac735109d 526 if(!setCmdMode(true)) {
jengbrecht 98:dbeac735109d 527 return FAILURE;
jengbrecht 98:dbeac735109d 528 }
jengbrecht 98:dbeac735109d 529
jengbrecht 94:1baa587e89ae 530 return sendBasicCommand("set dns name " + dnsName, 1000);
jengbrecht 94:1baa587e89ae 531 }
jengbrecht 94:1baa587e89ae 532
jengbrecht 69:f3e696bbb0d5 533 int Wifi::getSignalStrength()
jengbrecht 69:f3e696bbb0d5 534 {
jengbrecht 103:da58d27c15d7 535 //Signal strength does not report correctly if not connected
jengbrecht 103:da58d27c15d7 536 if(!wifiConnected) {
jengbrecht 103:da58d27c15d7 537 printf("[ERROR] Could not get RSSI, Wifi network not connected.\n\r");
jengbrecht 103:da58d27c15d7 538 return 99;
jengbrecht 103:da58d27c15d7 539 }
jengbrecht 103:da58d27c15d7 540
jengbrecht 98:dbeac735109d 541 //Check the command mode
jengbrecht 98:dbeac735109d 542 if(!setCmdMode(true)) {
jengbrecht 98:dbeac735109d 543 printf("[ERROR] Could not get RSSI\n\r");
jengbrecht 103:da58d27c15d7 544 return 99;
jengbrecht 98:dbeac735109d 545 }
jengbrecht 98:dbeac735109d 546
jengbrecht 93:aa7a48e65974 547 string response = sendCommand("show rssi", 2000, "dBm");
jengbrecht 74:9f87bd22c222 548 if (response.find("RSSI") == string::npos) {
jengbrecht 98:dbeac735109d 549 printf("[ERROR] Could not get RSSI\n\r");
jengbrecht 103:da58d27c15d7 550 return 99;
jengbrecht 74:9f87bd22c222 551 }
jengbrecht 74:9f87bd22c222 552 int start = response.find('(');
jengbrecht 74:9f87bd22c222 553 int stop = response.find(')', start);
jengbrecht 74:9f87bd22c222 554 string signal = response.substr(start + 1, stop - start - 1);
jengbrecht 74:9f87bd22c222 555 int value;
jengbrecht 74:9f87bd22c222 556 sscanf(signal.c_str(), "%d", &value);
jengbrecht 74:9f87bd22c222 557 return value;
jengbrecht 69:f3e696bbb0d5 558 }
jengbrecht 69:f3e696bbb0d5 559
jengbrecht 95:4fdf968b5b37 560 bool Wifi::ping(const std::string& address)
jengbrecht 95:4fdf968b5b37 561 {
jengbrecht 98:dbeac735109d 562 //Check the command mode
jengbrecht 98:dbeac735109d 563 if(!setCmdMode(true)) {
jengbrecht 98:dbeac735109d 564 printf("[ERROR] Could not send ping command\n\r");
jengbrecht 98:dbeac735109d 565 return false;
jengbrecht 98:dbeac735109d 566 }
jengbrecht 98:dbeac735109d 567
jengbrecht 95:4fdf968b5b37 568 std::string response;
jengbrecht 95:4fdf968b5b37 569 for (int i = 0; i < PINGNUM; i++) {
jengbrecht 95:4fdf968b5b37 570 response = sendCommand("ping " + address, PINGDELAY * 1000, "reply");
jengbrecht 95:4fdf968b5b37 571 if (response.find("reply") != std::string::npos) {
jengbrecht 95:4fdf968b5b37 572 return true;
jengbrecht 95:4fdf968b5b37 573 }
jengbrecht 95:4fdf968b5b37 574 }
jengbrecht 95:4fdf968b5b37 575 return false;
jengbrecht 95:4fdf968b5b37 576 }
jengbrecht 95:4fdf968b5b37 577
jengbrecht 79:f356009dbc12 578 bool Wifi::setCmdMode(bool on)
jengbrecht 74:9f87bd22c222 579 {
jengbrecht 79:f356009dbc12 580 if (on) {
jengbrecht 79:f356009dbc12 581 if (cmdOn) {
jengbrecht 79:f356009dbc12 582 return true;
jengbrecht 79:f356009dbc12 583 }
jengbrecht 79:f356009dbc12 584 wait(.5);
jengbrecht 93:aa7a48e65974 585 std::string response = sendCommand("$$", 2000, "CMD", '$');
jengbrecht 79:f356009dbc12 586 if (response.find("CMD") != string::npos) {
jengbrecht 79:f356009dbc12 587 cmdOn = true;
jengbrecht 113:7238f9b8db17 588 wait(.5);
jengbrecht 79:f356009dbc12 589 return true;
jengbrecht 79:f356009dbc12 590 }
jengbrecht 98:dbeac735109d 591 printf("[ERROR] Failed to enter command mode\n\r");
jengbrecht 79:f356009dbc12 592 return false;
jengbrecht 79:f356009dbc12 593 } else {
jengbrecht 79:f356009dbc12 594 if (!cmdOn) {
jengbrecht 79:f356009dbc12 595 return true;
jengbrecht 79:f356009dbc12 596 }
jengbrecht 93:aa7a48e65974 597 std::string response = sendCommand("exit", 2000, "EXIT");
jengbrecht 79:f356009dbc12 598 if (response.find("EXIT") != string::npos) {
jengbrecht 79:f356009dbc12 599 cmdOn = false;
jengbrecht 79:f356009dbc12 600 return true;
jengbrecht 79:f356009dbc12 601 }
jengbrecht 98:dbeac735109d 602 printf("[ERROR] Failed to exit command mode\n\r");
jengbrecht 79:f356009dbc12 603 return false;
jengbrecht 74:9f87bd22c222 604 }
jengbrecht 74:9f87bd22c222 605 }
jengbrecht 69:f3e696bbb0d5 606
sgodinez 73:bb5bbca971ae 607 Code Wifi::sendBasicCommand(string command, int timeoutMillis, char esc)
jengbrecht 69:f3e696bbb0d5 608 {
jengbrecht 69:f3e696bbb0d5 609 if(socketOpened) {
jengbrecht 69:f3e696bbb0d5 610 printf("[ERROR] socket is open. Can not send AT commands\r\n");
sgodinez 73:bb5bbca971ae 611 return ERROR;
jengbrecht 69:f3e696bbb0d5 612 }
jengbrecht 69:f3e696bbb0d5 613
jengbrecht 93:aa7a48e65974 614 string response = sendCommand(command, timeoutMillis, "AOK", esc);
jengbrecht 69:f3e696bbb0d5 615 //printf("Response: %s\n\r", response.c_str());
jengbrecht 69:f3e696bbb0d5 616 if (response.size() == 0) {
sgodinez 73:bb5bbca971ae 617 return NO_RESPONSE;
jengbrecht 69:f3e696bbb0d5 618 } else if (response.find("AOK") != string::npos) {
sgodinez 73:bb5bbca971ae 619 return SUCCESS;
jengbrecht 69:f3e696bbb0d5 620 } else if (response.find("ERR") != string::npos) {
sgodinez 73:bb5bbca971ae 621 return ERROR;
jengbrecht 69:f3e696bbb0d5 622 } else {
sgodinez 73:bb5bbca971ae 623 return FAILURE;
jengbrecht 69:f3e696bbb0d5 624 }
jengbrecht 69:f3e696bbb0d5 625 }
jengbrecht 69:f3e696bbb0d5 626
jengbrecht 93:aa7a48e65974 627 string Wifi::sendCommand(string command, int timeoutMillis, std::string response, char esc)
jengbrecht 69:f3e696bbb0d5 628 {
jengbrecht 69:f3e696bbb0d5 629 if(io == NULL) {
jengbrecht 69:f3e696bbb0d5 630 printf("[ERROR] MTSBufferedIO not set\r\n");
jengbrecht 69:f3e696bbb0d5 631 return "";
jengbrecht 69:f3e696bbb0d5 632 }
jengbrecht 106:358972176b89 633 //if(socketOpened && command.compare("$$") != 0 && command.compare("exit") != 0 && command.compare("close") != 0) {
jengbrecht 106:358972176b89 634 // printf("[ERROR] socket is open. Can not send AT commands\r\n");
jengbrecht 106:358972176b89 635 // return "";
jengbrecht 106:358972176b89 636 //}
jengbrecht 69:f3e696bbb0d5 637
jengbrecht 69:f3e696bbb0d5 638 io->rxClear();
jengbrecht 69:f3e696bbb0d5 639 io->txClear();
jengbrecht 69:f3e696bbb0d5 640 std::string result;
jengbrecht 79:f356009dbc12 641
sgodinez 73:bb5bbca971ae 642 //Attempt to write command
sgodinez 73:bb5bbca971ae 643 if(io->write(command.data(), command.size(), timeoutMillis) != command.size()) {
sgodinez 73:bb5bbca971ae 644 //Failed to write command
sgodinez 73:bb5bbca971ae 645 printf("[ERROR] failed to send command to radio within %d milliseconds\r\n", timeoutMillis);
sgodinez 73:bb5bbca971ae 646 return "";
sgodinez 73:bb5bbca971ae 647 }
jengbrecht 79:f356009dbc12 648
sgodinez 73:bb5bbca971ae 649 //Send Escape Character
sgodinez 73:bb5bbca971ae 650 if (esc != 0x00) {
sgodinez 73:bb5bbca971ae 651 if(io->write(esc, timeoutMillis) != 1) {
sgodinez 73:bb5bbca971ae 652 printf("[ERROR] failed to send '%c' to radio within %d milliseconds\r\n", esc, timeoutMillis);
sgodinez 73:bb5bbca971ae 653 return "";
sgodinez 73:bb5bbca971ae 654 }
sgodinez 73:bb5bbca971ae 655 }
sgodinez 73:bb5bbca971ae 656
jengbrecht 69:f3e696bbb0d5 657 int timer = 0;
sgodinez 73:bb5bbca971ae 658 size_t previous = 0;
jengbrecht 69:f3e696bbb0d5 659 char tmp[256];
jengbrecht 69:f3e696bbb0d5 660 tmp[255] = 0;
jengbrecht 69:f3e696bbb0d5 661 bool done = false;
jengbrecht 69:f3e696bbb0d5 662 do {
jengbrecht 93:aa7a48e65974 663 wait(.2);
jengbrecht 93:aa7a48e65974 664 timer = timer + 200;
sgodinez 73:bb5bbca971ae 665 previous = result.size();
jengbrecht 93:aa7a48e65974 666 int size = io->read(tmp, 255, 0); //1 less than allocated
jengbrecht 69:f3e696bbb0d5 667 if(size > 0) {
jengbrecht 69:f3e696bbb0d5 668 result.append(tmp, size);
jengbrecht 93:aa7a48e65974 669 if (response.size() != 0) {
jengbrecht 93:aa7a48e65974 670 if (result.find(response) != string::npos) {
jengbrecht 93:aa7a48e65974 671 return result;
jengbrecht 93:aa7a48e65974 672 }
jengbrecht 93:aa7a48e65974 673 } else {
jengbrecht 93:aa7a48e65974 674 done = (result.size() == previous);
jengbrecht 69:f3e696bbb0d5 675 }
jengbrecht 69:f3e696bbb0d5 676 }
jengbrecht 69:f3e696bbb0d5 677 if(timer >= timeoutMillis) {
jengbrecht 127:526003734633 678 if(!(command.compare("reboot") == 0 || command.compare("") == 0)) {
jengbrecht 121:5a7fba896c98 679 printf("[WARNING] sendCommand [%s] timed out after %d milliseconds\r\n", command.c_str(), timeoutMillis);
jengbrecht 121:5a7fba896c98 680 }
jengbrecht 69:f3e696bbb0d5 681 done = true;
jengbrecht 69:f3e696bbb0d5 682 }
jengbrecht 69:f3e696bbb0d5 683 } while (!done);
jengbrecht 79:f356009dbc12 684
jengbrecht 93:aa7a48e65974 685 //printf("Result: %s\n\r", result.c_str());
jengbrecht 69:f3e696bbb0d5 686 return result;
jengbrecht 69:f3e696bbb0d5 687 }