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@131:da8f0e1c264a, 2014-01-03 (annotated)

Committer:
sam_grove
Date:
Fri Jan 03 05:00:54 2014 +0000
Revision:
131:da8f0e1c264a
Parent:
130:5a8af68a46ec
Child:
132:165b3a1084bd
Added DBG to wifi.cpp, implement reset in init() so hardware boots the same way each time as if reset IO pin was present. Loop until echo is off by response. All these changes seem to fix the rouge data after disconnect caused by module ERR: Net IF

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