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@138:a233b9775f93, 2014-01-04 (annotated)

Committer:
jengbrecht
Date:
Sat Jan 04 00:55:16 2014 +0000
Revision:
138:a233b9775f93
Parent:
136:0937dce3630b
Child:
141:571e0ef6c8dc
Added the ability on open call within Wifi to except a URL in addition to an IP address.

Who changed what in which revision?

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