wifi.cpp

00001 #include "wifi.h"
00002 
00003 Wifi::Wifi(osPriority priority, int memory) : ESP8266Interface(D8, D2, false), ch_pd(D3, 1), rst(D4, 1)
00004 {
00005     set_credentials("denver", "11111111", NSAPI_SECURITY_WPA_WPA2);
00006     
00007     sender = new TCPSocket::TCPSocket();
00008     receiver = new TCPSocket::TCPSocket();
00009     
00010     sender->open(this);
00011     receiver->open(this);
00012 
00013     wifi_thread = new Thread(priority, memory);
00014 
00015     sendQueue = StrQueue(QUEUESIZE);
00016     recvQueue = StrQueue(QUEUESIZE);
00017 
00018     sendConnected = false;
00019     recvConnected = false;
00020     sendReady = false, recvReady = false;
00021     sendState = 0, recvState = 0;
00022 }
00023 
00024 void Wifi::start()
00025 {
00026 #ifdef DEBUG
00027     Thread::wait(10);
00028     Serial::Serial(USBTX, USBRX).printf("Wifi starting\n");
00029 #endif
00030     wifi_thread.start(callback(this, &Wifi::run));
00031 }
00032 
00033 void Wifi::run()
00034 {
00035     int ret = -1, recvLength;
00036     sender->set_blocking(false);
00037 
00038     Timer sendConnectTimer, sendSocketTimer, recvConnectTimer, recvSocketTimer;
00039 
00040     connectWifi();
00041 
00042     connectSockets();
00043 
00044     while(true) {
00045         //Serial::Serial(USBTX, USBRX).printf("RSSI: %i\n", getRSSI("denver"));
00046 
00047         Thread::wait(DELAY);
00048 
00049         if (!sendConnected) {
00050             if (sendConnectTimer.read_ms() > CONNECTDELAY) {
00051                 sendConnectTimer.stop();
00052                 sendConnectTimer.reset();
00053                 connectSockets();
00054                 if (!sendConnected) {
00055                     sendConnectTimer.start();
00056                 }
00057             } else {
00058                 sendConnectTimer.start();
00059             }
00060         } else {
00061             switch (sendState) {
00062                 case 0:
00063                     if (sendQueue.getChars(ssbuffer, BUFFERSIZE) > 0) {
00064                         sendState = 1;
00065                     } else {
00066                         break;
00067                     }
00068 
00069                 case 1:
00070                     Thread::wait(DELAY);
00071                     ret = sender->send(ssbuffer, BUFFERSIZE);
00072 #ifdef DEBUG
00073                     Thread::wait(DELAY);
00074                     Serial::Serial(USBTX, USBRX).printf("Sender send return code: [%d]\n", ret);
00075 #endif
00076                     if(ret > 0) {
00077                         sendState = 2;
00078                     } else if(ret == -3012) {
00079                         sendState = 0;
00080                         sendConnected = false;
00081                         break;
00082                     } else if(ret == -3001) {
00083                         if(sendSocketTimer.read_ms() > SOCKETTIMEOUT) {
00084                             sendSocketTimer.reset();
00085                             sendSocketTimer.stop();
00086                             sendConnected = false;
00087                         } else {
00088                             sendSocketTimer.start();
00089                         }
00090                         break;
00091                     } else {
00092                         break;
00093                     }
00094 
00095                 case 2:
00096                     strcpy(srbuffer, "");
00097                     Thread::wait(DELAY);
00098                     ret = sender->recv(srbuffer, BUFFERSIZE);
00099 #ifdef DEBUG
00100                     Thread::wait(DELAY);
00101                     Serial::Serial(USBTX, USBRX).printf("Sender recv return code: [%d]\n", ret);
00102 #endif
00103                     if(ret > 0) {
00104                         sendSocketTimer.reset();
00105                         sendSocketTimer.stop();
00106                         if (strcmp(srbuffer, ssbuffer)==0) {
00107                             sendState = 0;
00108                         } else {
00109                             sendState = 1;
00110                         }
00111                     } else if(ret == -3012) {
00112                         sendSocketTimer.reset();
00113                         sendSocketTimer.stop();
00114                         sendConnected = false;
00115                         sendState = 0;
00116                         break;
00117                     } else if(ret == -3001) {
00118                         if(sendSocketTimer.read_ms() > SOCKETTIMEOUT) {
00119                             sendSocketTimer.reset();
00120                             sendSocketTimer.stop();
00121                             sendConnected = false;
00122                         } else {
00123                             sendSocketTimer.start();
00124                         }
00125                         break;
00126                     }
00127                     break;
00128             }
00129         }
00130 
00131         if (!recvConnected) {
00132             if (recvConnectTimer.read_ms() > CONNECTDELAY) {
00133                 recvConnectTimer.stop();
00134                 recvConnectTimer.reset();
00135                 connectSockets();
00136                 if (!recvConnected) {
00137                     recvConnectTimer.start();
00138                 }
00139             } else {
00140                 recvConnectTimer.start();
00141             }
00142         } else {
00143             switch (recvState) {
00144                 case 0:
00145                     strcpy(rbuffer, "");
00146                     Thread::wait(DELAY);
00147                     recvLength = receiver->recv(rbuffer, BUFFERSIZE);
00148                     //receiver->recv(srbuffer, BUFFERSIZE);
00149                     //Thread::wait(DELAY*10);
00150                     //if(strcmp(rbuffer, "10")==0) {
00151                     //printf("Receiver: [%s]\n", rbuffer);
00152                     //}
00153 #ifdef DEBUG
00154                     Thread::wait(DELAY);
00155                     Serial::Serial(USBTX, USBRX).printf("Receiver recv return code: [%d]\n", recvLength);
00156 #endif
00157 
00158                     if(recvLength > 0) {
00159                         recvSocketTimer.reset();
00160                         recvSocketTimer.stop();
00161                         recvState = 1;
00162                     } else if(recvLength == -3012) {
00163                         recvSocketTimer.reset();
00164                         recvSocketTimer.stop();
00165                         recvConnected = false;
00166                         recvState = 0;
00167                         break;
00168                     } else if(recvLength == -3001) {
00169                         if(recvSocketTimer.read_ms() > SOCKETTIMEOUT) {
00170                             recvSocketTimer.reset();
00171                             recvSocketTimer.stop();
00172                             recvConnected = false;
00173                             recvState = 0;
00174                         } else {
00175                             recvSocketTimer.start();
00176                         }
00177                         break;
00178                     } else {
00179                         break;
00180                     }
00181 
00182 
00183                 case 1:
00184                     Thread::wait(DELAY);
00185                     ret = receiver->send(rbuffer, recvLength);
00186 #ifdef DEBUG
00187                     Thread::wait(DELAY);
00188                     Serial::Serial(USBTX, USBRX).printf("Receiver send return code: [%d]\n", ret);
00189 #endif
00190                     if(ret > 0) {
00191                         recvState = 2;
00192                     } else if(ret == -3012) {
00193                         recvState = 0;
00194                         recvConnected = false;
00195                         break;
00196                     } else if(ret == -3001) {
00197                         if(recvSocketTimer.read_ms() > SOCKETTIMEOUT) {
00198                             recvSocketTimer.reset();
00199                             recvSocketTimer.stop();
00200                             recvConnected = false;
00201                         } else {
00202                             recvSocketTimer.start();
00203                         }
00204                         break;
00205                     } else {
00206                         break;
00207                     }
00208 
00209                 case 2:
00210                     if (recvQueue.put(rbuffer, recvLength) > 0) {
00211                         recvState = 0;
00212                         break;
00213                     } else {
00214                         break;
00215                     }
00216             }
00217         }
00218     }
00219 }
00220 
00221 int Wifi::connectWifi()
00222 {
00223     int ret;
00224     while(true) {
00225         Thread::wait(DELAY);
00226 #ifdef DEBUG
00227         Thread::wait(5);
00228         Serial::Serial(USBTX, USBRX).printf("Wifi connecting\n");
00229 #endif
00230         ret = connect();
00231         Thread::wait(DELAY);
00232         Serial::Serial(USBTX, USBRX).printf("Wifi connect ret code: [%d]\n", ret);
00233 
00234         if (ret == 0) {
00235             Thread::wait(DELAY);
00236 #ifdef DEBUG
00237             Thread::wait(DELAY);
00238             Serial::Serial(USBTX, USBRX).printf("Wifi connected\n");
00239 #endif
00240             break;
00241         } else {
00242             Thread::wait(DELAY);
00243 #ifdef DEBUG
00244             Thread::wait(DELAY);
00245             Serial::Serial(USBTX, USBRX).printf("Wifi connect ret code: [%d]\n", ret);
00246 #endif
00247         }
00248     }
00249     Thread::wait(5);
00250     return(1);
00251 }
00252 
00253 int Wifi::connectSockets()
00254 {
00255     int ret;
00256 #ifdef DEBUG
00257     Thread::wait(DELAY);
00258     Serial::Serial(USBTX, USBRX).printf("Sockets connecting\n");
00259 #endif
00260     if(!sendConnected) {
00261         Thread::wait(5);
00262         ret = sender->connect("192.168.173.1", 5001);
00263         Thread::wait(5);
00264 #ifdef DEBUG
00265         Thread::wait(DELAY);
00266         Serial::Serial(USBTX, USBRX).printf("Send connect Ret: [%i]\n", ret);
00267 #endif
00268         if (ret == 0) {
00269             sendConnected = true;
00270             sender->set_blocking(false);
00271         }
00272         //else if (ret == -3012) {connectWifi();}
00273     }
00274 
00275     if(!recvConnected) {
00276         Thread::wait(5);
00277         ret = receiver->connect("192.168.173.1", 5000);
00278         Thread::wait(5);
00279 #ifdef DEBUG
00280         Thread::wait(DELAY);
00281         Serial::Serial(USBTX, USBRX).printf("Receiver connect Ret: [%i]\n", ret);
00282 #endif
00283         if (ret == 0) {
00284             recvConnected = true;
00285             receiver->set_blocking(false);
00286         }
00287     }//else if (ret == -3012) {connectWifi();}
00288     return(0);
00289 }
00290 
00291 int Wifi::send(string message)
00292 {
00293     return(sendQueue.put(message.c_str(), message.length()));
00294 }
00295 
00296 int Wifi::send(char* message)
00297 {
00298     return(sendQueue.put(message, strlen(message)));
00299 }
00300 
00301 union i_to_c {
00302     int i;
00303     char c[4];
00304 };
00305 
00306 int Wifi::send(int message)
00307 {
00308     i_to_c m;
00309     m.i = message;
00310     return(sendQueue.put(m.c, strlen(m.c)));
00311 }
00312 
00313 Message Wifi::recv()
00314 {
00315     Message out;
00316     char str[44];
00317     int ret = recvQueue.get(str, 44);
00318     if(ret > 0) {
00319         out.parse(str);
00320     }
00321     return(out);
00322 }