ESP8266.cpp

00001 /**
00002  * @file ESP8266.cpp
00003  * @brief The implementation of class ESP8266.
00004  * @author Wu Pengfei<pengfei.wu@itead.cc>
00005  * @date 2015.02
00006  *
00007  * @par Copyright:
00008  * Copyright (c) 2015 ITEAD Intelligent Systems Co., Ltd. \n\n
00009  * This program is free software; you can redistribute it and/or
00010  * modify it under the terms of the GNU General Public License as
00011  * published by the Free Software Foundation; either version 2 of
00012  * the License, or (at your option) any later version. \n\n
00013  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
00014  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
00015  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
00016  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
00017  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
00018  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
00019  * THE SOFTWARE.
00020  */
00021 #include "ESP8266_HardSer.h"
00022 //#include <avr/pgmspace.h>
00023 #ifdef ESP8266_USE_SOFTWARE_SERIAL
00024 ESP8266::ESP8266(SoftwareSerial &uart): m_puart(&uart)
00025 {
00026     m_onData = NULL;
00027     m_onDataPtr = NULL;
00028 }
00029 #else
00030 ESP8266::ESP8266(HardwareSerial &uart): m_puart(&uart)
00031 {
00032     m_onData = NULL;
00033     m_onDataPtr = NULL;
00034 }
00035 #endif
00036 
00037 bool ESP8266::kick(void)
00038 {
00039     LOG_ENTER;
00040     return eAT();
00041 }
00042 
00043 bool ESP8266::restart(void)
00044 {
00045     LOG_ENTER;
00046     unsigned long start;
00047     if (eATRST()) {
00048         //delay(2000);
00049         wait_ms(2000);
00050         //start = millis();
00051         start = g_Timer.read_ms();
00052         while (g_Timer.read_ms() - start < 3000) {
00053             if (eAT()) {
00054                 //delay(1500); /* Waiting for stable */
00055                 wait_ms(1500);
00056                 return true;
00057             }
00058             //delay(100);
00059             wait_ms(100);
00060         }
00061     }
00062     return false;
00063 }
00064 
00065 String ESP8266::getVersion(void)
00066 {
00067     LOG_ENTER;
00068     String version;
00069     eATGMR(version);
00070     return version;
00071 }
00072 
00073 bool ESP8266::setEcho(uint8_t mode)
00074 {
00075     LOG_ENTER;
00076     return eATE(mode);
00077 }
00078 
00079 bool ESP8266::restore(void)
00080 {
00081     LOG_ENTER;
00082     return eATRESTORE();
00083 }
00084 
00085 bool ESP8266::setUart(uint32_t baudrate,uint8_t pattern)
00086 {
00087     LOG_ENTER;
00088     return eATSETUART(baudrate,pattern);
00089 }
00090 
00091 bool ESP8266::deepSleep(uint32_t time)
00092 {
00093     LOG_ENTER;
00094     return eATGSLP(time);
00095 }
00096 
00097 bool ESP8266::setOprToStation(uint8_t pattern1,uint8_t pattern2)
00098 {
00099     LOG_ENTER;
00100     uint8_t mode;
00101     if (!qATCWMODE(&mode,pattern1)) {
00102         return false;
00103     }
00104     if (mode == 1) {
00105         return true;
00106     } else {
00107         if (sATCWMODE(1,pattern2)) {
00108             return true;
00109         } else {
00110             return false;
00111         }
00112     }
00113 }
00114 
00115 String ESP8266::getWifiModeList(void)
00116 {
00117     LOG_ENTER;
00118     String list;
00119     eATCWMODE(list);
00120     return list;
00121 }
00122 
00123 bool ESP8266::setOprToSoftAP(uint8_t pattern1,uint8_t pattern2)
00124 {
00125     LOG_ENTER;
00126     uint8_t mode;
00127     if (!qATCWMODE(&mode,pattern1)) {
00128         return false;
00129     }
00130     if (mode == 2) {
00131         return true;
00132     } else {
00133         if (sATCWMODE(2,pattern2) ) {
00134             return true;
00135         } else {
00136             return false;
00137         }
00138     }
00139 }
00140 
00141 bool ESP8266::setOprToStationSoftAP(uint8_t pattern1,uint8_t pattern2)
00142 {
00143     LOG_ENTER;
00144     uint8_t mode;
00145     if (!qATCWMODE(&mode,pattern1)) {
00146         return false;
00147     }
00148     if (mode == 3) {
00149         return true;
00150     } else {
00151         if (sATCWMODE(3,pattern2) ) {
00152             return true;
00153         } else {
00154             return false;
00155         }
00156     }
00157 }
00158 
00159 uint8_t ESP8266::getOprMode(uint8_t pattern1)
00160 {
00161     LOG_ENTER;
00162     uint8_t mode;
00163     if (!qATCWMODE(&mode,pattern1)) {
00164         return 0;
00165     } else {
00166         return mode;
00167     }
00168 }
00169 
00170 String ESP8266::getNowConecAp(uint8_t pattern)
00171 {
00172     LOG_ENTER;
00173     String ssid;
00174     qATCWJAP(ssid,pattern);
00175     return ssid;
00176 }
00177 
00178 String ESP8266::getAPList(void)
00179 {
00180     LOG_ENTER;
00181     String list;
00182     eATCWLAP(list);
00183     return list;
00184 }
00185 
00186 bool ESP8266::joinAP(String ssid, String pwd,uint8_t pattern)
00187 {
00188     LOG_ENTER;
00189     return sATCWJAP(ssid, pwd,pattern);
00190 }
00191 
00192 bool ESP8266::leaveAP(void)
00193 {
00194     LOG_ENTER;
00195     return eATCWQAP();
00196 }
00197 
00198 String ESP8266::getSoftAPParam(uint8_t pattern)
00199 {
00200     LOG_ENTER;
00201     String list;
00202     qATCWSAP(list,pattern);
00203     return list;
00204 }
00205 
00206 bool ESP8266::setSoftAPParam(String ssid, String pwd, uint8_t chl, uint8_t ecn,uint8_t pattern)
00207 {
00208     LOG_ENTER;
00209     return sATCWSAP(ssid, pwd, chl, ecn,pattern);
00210 }
00211 
00212 String ESP8266::getJoinedDeviceIP(void)
00213 {
00214     LOG_ENTER;
00215     String list;
00216     eATCWLIF(list);
00217     return list;
00218 }
00219 
00220 String ESP8266::getDHCP(uint8_t pattern)
00221 {
00222     LOG_ENTER;
00223     String dhcp;
00224     qATCWDHCP(dhcp,pattern);
00225     return dhcp;
00226 }
00227 
00228 bool ESP8266::setDHCP(uint8_t mode, uint8_t en, uint8_t pattern)
00229 {
00230     LOG_ENTER;
00231     return sATCWDHCP(mode, en, pattern);
00232 }
00233 
00234 bool ESP8266::setAutoConnect(uint8_t en)
00235 {
00236     LOG_ENTER;
00237     return eATCWAUTOCONN(en);
00238 }
00239 
00240 String ESP8266::getStationMac(uint8_t pattern)
00241 {
00242     LOG_ENTER;
00243     String mac;
00244     qATCIPSTAMAC(mac,pattern);
00245     return mac;
00246 }
00247 
00248 bool ESP8266::setStationMac(String mac,uint8_t pattern)
00249 {
00250     LOG_ENTER;
00251     return eATCIPSTAMAC(mac,pattern);
00252 }
00253 
00254 String ESP8266::getStationIp(uint8_t pattern)
00255 {
00256     LOG_ENTER;
00257     String ip;
00258     qATCIPSTAIP(ip,pattern);
00259     return ip;
00260 }
00261 
00262 bool ESP8266::setStationIp(String ip,String gateway,String netmask,uint8_t pattern)
00263 {
00264     LOG_ENTER;
00265     return eATCIPSTAIP(ip,gateway,netmask,pattern);
00266 }
00267 
00268 String ESP8266::getAPIp(uint8_t pattern)
00269 {
00270     LOG_ENTER;
00271     String ip;
00272     qATCIPAP(ip,pattern);
00273     return ip;
00274 }
00275 
00276 bool ESP8266::setAPIp(String ip,uint8_t pattern)
00277 {
00278     LOG_ENTER;
00279     return eATCIPAP(ip,pattern);
00280 }
00281 
00282 bool ESP8266::startSmartConfig(uint8_t type)
00283 {
00284     LOG_ENTER;
00285     return eCWSTARTSMART(type);
00286 }
00287 
00288 bool ESP8266::stopSmartConfig(void)
00289 {
00290     LOG_ENTER;
00291     return eCWSTOPSMART();
00292 }
00293 
00294 
00295 String ESP8266::getIPStatus(void)
00296 {
00297     LOG_ENTER;
00298     String list;
00299     eATCIPSTATUS(list);
00300     return list;
00301 }
00302 
00303 String ESP8266::getLocalIP(void)
00304 {
00305     LOG_ENTER;
00306     String list;
00307     eATCIFSR(list);
00308     return list;
00309 }
00310 
00311 bool ESP8266::enableMUX(void)
00312 {
00313     LOG_ENTER;
00314     return sATCIPMUX(1);
00315 }
00316 
00317 bool ESP8266::disableMUX(void)
00318 {
00319     LOG_ENTER;
00320     return sATCIPMUX(0);
00321 }
00322 
00323 bool ESP8266::createTCP(String addr, uint32_t port)
00324 {
00325     LOG_ENTER;
00326     return sATCIPSTARTSingle("TCP", addr, port);
00327 }
00328 
00329 bool ESP8266::releaseTCP(void)
00330 {
00331     LOG_ENTER;
00332     return eATCIPCLOSESingle();
00333 }
00334 
00335 bool ESP8266::registerUDP(String addr, uint32_t port)
00336 {
00337     LOG_ENTER;
00338     return sATCIPSTARTSingle("UDP", addr, port);
00339 }
00340 
00341 bool ESP8266::unregisterUDP(void)
00342 {
00343     LOG_ENTER;
00344     return eATCIPCLOSESingle();
00345 }
00346 
00347 bool ESP8266::createTCP(uint8_t mux_id, String addr, uint32_t port)
00348 {
00349     LOG_ENTER;
00350     return sATCIPSTARTMultiple(mux_id, "TCP", addr, port);
00351 }
00352 
00353 bool ESP8266::releaseTCP(uint8_t mux_id)
00354 {
00355     LOG_ENTER;
00356     return sATCIPCLOSEMulitple(mux_id);
00357 }
00358 
00359 bool ESP8266::registerUDP(uint8_t mux_id, String addr, uint32_t port)
00360 {
00361     LOG_ENTER;
00362     return sATCIPSTARTMultiple(mux_id, "UDP", addr, port);
00363 }
00364 
00365 bool ESP8266::unregisterUDP(uint8_t mux_id)
00366 {
00367     LOG_ENTER;
00368     return sATCIPCLOSEMulitple(mux_id);
00369 }
00370 
00371 bool ESP8266::setTCPServerTimeout(uint32_t timeout)
00372 {
00373     LOG_ENTER;
00374     return sATCIPSTO(timeout);
00375 }
00376 
00377 bool ESP8266::startTCPServer(uint32_t port)
00378 {
00379     LOG_ENTER;
00380     if (sATCIPSERVER(1, port)) {
00381         return true;
00382     }
00383     return false;
00384 }
00385 
00386 bool ESP8266::stopTCPServer(void)
00387 {
00388     LOG_ENTER;
00389     sATCIPSERVER(0);
00390     restart();
00391     return false;
00392 }
00393 
00394 bool ESP8266::setCIPMODE(uint8_t mode)
00395 {
00396     LOG_ENTER;
00397     return sATCIPMODE(mode);
00398 }
00399 
00400 bool ESP8266::saveTransLink (uint8_t mode,String ip,uint32_t port)
00401 {
00402     LOG_ENTER;
00403     return eATSAVETRANSLINK(mode,ip,port);
00404 }
00405 
00406 bool ESP8266::setPing(String ip)
00407 {
00408     LOG_ENTER;
00409     return eATPING(ip);
00410 }
00411 
00412 
00413 bool ESP8266::startServer(uint32_t port)
00414 {
00415     LOG_ENTER;
00416     return startTCPServer(port);
00417 }
00418 
00419 bool ESP8266::stopServer(void)
00420 {
00421     LOG_ENTER;
00422     return stopTCPServer();
00423 }
00424 
00425 bool ESP8266::send(const uint8_t *buffer, uint32_t len)
00426 {
00427     LOG_ENTER;
00428     return sATCIPSENDSingle(buffer, len);
00429 }
00430 
00431 bool ESP8266::sendFromFlash(uint8_t mux_id, const uint8_t *buffer, uint32_t len)
00432 {
00433     LOG_ENTER;
00434     return sATCIPSENDMultipleFromFlash(mux_id, buffer, len);
00435 }
00436 
00437 bool ESP8266::sendFromFlash(const uint8_t *buffer, uint32_t len)
00438 {
00439     LOG_ENTER;
00440     return sATCIPSENDSingleFromFlash(buffer, len);
00441 }
00442 
00443 bool ESP8266::send(uint8_t mux_id, const uint8_t *buffer, uint32_t len)
00444 {
00445     LOG_ENTER;
00446     return sATCIPSENDMultiple(mux_id, buffer, len);
00447 }
00448 
00449 void ESP8266::run()
00450 {
00451     LOG_ENTER;
00452     rx_empty();
00453 }
00454 
00455 /*----------------------------------------------------------------------------*/
00456 /* +IPD,<id>,<len>:<data> */
00457 /* +IPD,<len>:<data> */
00458 
00459 uint32_t ESP8266::checkIPD(String& data)
00460 {
00461     //Serial.print("### check: ");
00462     //Serial.println(data);
00463     LOG_ENTER;
00464     int32_t index_PIPDcomma = -1;
00465     int32_t index_colon = -1; /* : */
00466     int32_t index_comma = -1; /* , */
00467     int32_t len = -1;
00468     int8_t id = -1;
00469     {
00470         // Just for easier diffing
00471         index_PIPDcomma = data.indexOf("+IPD,");
00472         if (index_PIPDcomma != -1) {
00473             index_colon = data.indexOf(':', index_PIPDcomma + 5);
00474             if (index_colon != -1) {
00475                 index_comma = data.indexOf(',', index_PIPDcomma + 5);
00476                 /* +IPD,id,len:data */
00477                 if (index_comma != -1 && index_comma < index_colon) {
00478                     id = data.substring(index_PIPDcomma + 5, index_comma).toInt();
00479                     if (id < 0 || id > 4) {
00480                         return 0;
00481                     }
00482                     len = data.substring(index_comma + 1, index_colon).toInt();
00483                     if (len <= 0) {
00484                         return 0;
00485                     }
00486                 } else { /* +IPD,len:data */
00487                     len = data.substring(index_PIPDcomma + 5, index_colon).toInt();
00488                     if (len <= 0) {
00489                         return 0;
00490                     }
00491                 }
00492                 if (m_onData) {
00493                     m_onData(id, len, m_onDataPtr);
00494                 }
00495                 return len;
00496             }
00497         }
00498     }
00499     return 0;
00500 }
00501 
00502 void ESP8266::rx_empty(void)
00503 {
00504     LOG_ENTER;
00505     String data;
00506     char a;
00507     unsigned long start = g_Timer.read_ms();
00508     while (g_Timer.read_ms() - start < 10) {
00509         if (m_puart->readable()) {
00510             a = m_puart->getc();
00511             if(a == '\0') continue;
00512             data += a;
00513             if (checkIPD(data)) {
00514                 data = "";
00515             }
00516             start = g_Timer.read_ms();
00517         }
00518     }
00519 }
00520 
00521 String ESP8266::recvString(String target, uint32_t timeout)
00522 {
00523     LOG_ENTER;
00524     String data;
00525     char a;
00526     unsigned long start = g_Timer.read_ms();
00527     while (g_Timer.read_ms() - start < timeout) {
00528         while(m_puart->readable() > 0) {
00529             a = m_puart->getc();
00530             ESP8266_LOG("a=0x%02X ", a);
00531             if(a == '\0') continue;
00532             data += a;
00533             if (data.indexOf(target) != -1) {
00534                 ESP8266_LOG("\r\ndata = %s\r\n", data.c_str());
00535                 return data;
00536             } else if (checkIPD(data)) {
00537                 data = "";
00538             }
00539         }
00540     }
00541     ESP8266_LOG("\r\n");
00542     ESP8266_LOG("data1 = %s\r\n", data.c_str());
00543     return data;
00544 }
00545 
00546 String ESP8266::recvString(String target1, String target2, uint32_t timeout)
00547 {
00548     LOG_ENTER;
00549     String data;
00550     char a;
00551     unsigned long start = g_Timer.read_ms();
00552     while (g_Timer.read_ms() - start < timeout) {
00553         while(m_puart->readable() > 0) {
00554             a = m_puart->getc();
00555             ESP8266_LOG("a=0x%02x ", a);
00556             if(a == '\0') continue;
00557             data += a;
00558             if (data.indexOf(target1) != -1) {
00559                 ESP8266_LOG("\r\ndata2 = %s\r\n", data.c_str());
00560                 return data;
00561             } else if (data.indexOf(target2) != -1) {
00562                 ESP8266_LOG("\r\ndata3 = %s\r\n", data.c_str());
00563                 return data;
00564             } else if (checkIPD(data)) {
00565                 data = "";
00566             }
00567         }
00568     }
00569     ESP8266_LOG("\r\ndata4 = %s\r\n", data.c_str());
00570     return data;
00571 }
00572 
00573 String ESP8266::recvString(String target1, String target2, String target3, uint32_t timeout)
00574 {
00575     LOG_ENTER;
00576     String data;
00577     char a;
00578     unsigned long start = g_Timer.read_ms();
00579     while (g_Timer.read_ms() - start < timeout) {
00580         while(m_puart->readable() > 0) {
00581             a = m_puart->getc();
00582             ESP8266_LOG("a=0x%02x ", a);
00583             if(a == '\0') continue;
00584             data += a;
00585 
00586             if (data.indexOf(target1) != -1) {
00587                 ESP8266_LOG("\r\ndata5 = %s\r\n", data.c_str());
00588                 return data;
00589             } else if (data.indexOf(target2) != -1) {
00590                 ESP8266_LOG("\r\ndata6 = %s\r\n", data.c_str());
00591                 return data;
00592             } else if (data.indexOf(target3) != -1) {
00593                 ESP8266_LOG("\r\ndata7 = %s\r\n", data.c_str());
00594                 return data;
00595             } else if (checkIPD(data)) {
00596                 data = "";
00597             }
00598         }
00599     }
00600     ESP8266_LOG("\r\ndata8 = %s\r\n", data.c_str());
00601     return data;
00602 }
00603 
00604 bool ESP8266::recvFind(String target, uint32_t timeout)
00605 {
00606     LOG_ENTER;
00607     String data_tmp;
00608     data_tmp = recvString(target, timeout);
00609     if (data_tmp.indexOf(target) != -1) {
00610         return true;
00611     }
00612     return false;
00613 }
00614 
00615 bool ESP8266::recvFindAndFilter(String target, String begin, String end, String &data, uint32_t timeout)
00616 {
00617     LOG_ENTER;
00618     String data_tmp;
00619     data_tmp = recvString(target, timeout);
00620     if (data_tmp.indexOf(target) != -1) {
00621         int32_t index1 = data_tmp.indexOf(begin);
00622         int32_t index2 = data_tmp.indexOf(end);
00623         if (index1 != -1 && index2 != -1) {
00624             index1 += begin.length();
00625             data = data_tmp.substring(index1, index2);
00626             return true;
00627         }
00628     }
00629     data = data_tmp;
00630     return false;
00631 }
00632 
00633 bool ESP8266::eAT(void)
00634 {
00635     LOG_ENTER;
00636     rx_empty();
00637     //m_puart->println(F("AT"));
00638     m_puart->printf("AT\r\n");
00639     return recvFind("OK");
00640 }
00641 
00642 bool ESP8266::eATRST(void)
00643 {
00644     LOG_ENTER;
00645     rx_empty();
00646     //m_puart->println(F("AT+RST"));
00647     m_puart->printf("AT+RST\r\n");
00648     return recvFind("OK");
00649 }
00650 
00651 bool ESP8266::eATGMR(String &version)
00652 {
00653     LOG_ENTER;
00654     rx_empty();
00655     wait_ms(3000);
00656     //m_puart->println(F("AT+GMR"));
00657     m_puart->printf("AT+GMR\r\n");
00658     return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", version, 10000);
00659 }
00660 
00661 bool ESP8266::eATGSLP(uint32_t time)
00662 {
00663     LOG_ENTER;
00664     rx_empty();
00665     //m_puart->print(F("AT+GSLP="));
00666     //m_puart->println(time);
00667     m_puart->printf("AT+GSLP=%u\r\n", time);
00668     return recvFind("OK");
00669 }
00670 
00671 bool ESP8266::eATE(uint8_t mode)
00672 {
00673     LOG_ENTER;
00674     rx_empty();
00675     //m_puart->print(F("ATE"));
00676     //m_puart->println(mode);
00677     m_puart->printf("ATE%d\r\n", mode);
00678     return recvFind("OK");
00679 }
00680 
00681 bool ESP8266::eATRESTORE(void)
00682 {
00683     LOG_ENTER;
00684     rx_empty();
00685     //m_puart->println(F("AT+RESTORE"));
00686     m_puart->printf("AT+RESTORE\r\n");
00687     return recvFind("OK");
00688 }
00689 
00690 bool ESP8266::eATSETUART(uint32_t baudrate,uint8_t pattern)
00691 {
00692     LOG_ENTER;
00693     rx_empty();
00694     if(pattern>3||pattern<1) {
00695         return false;
00696     }
00697     switch(pattern) {
00698         case 1:
00699             //m_puart->print(F("AT+UART="));
00700             m_puart->printf("AT+UART=");
00701             break;
00702         case 2:
00703             //m_puart->print(F("AT+UART_CUR="));
00704             m_puart->printf("AT+UART_CUR=");
00705             break;
00706         case 3:
00707             //m_puart->print(F("AT+UART_DEF="));
00708             m_puart->printf("AT+UART_DEF=");
00709             break;
00710     }
00711     #if 0
00712     m_puart->print(baudrate);
00713     m_puart->print(F(","));
00714     m_puart->print(8);
00715     m_puart->print(F(","));
00716     m_puart->print(1);
00717     m_puart->print(F(","));
00718     m_puart->print(0);
00719     m_puart->print(F(","));
00720     m_puart->println(0);
00721     #else
00722     m_puart->printf("%u,%d,%d,%d,%d\r\n", baudrate, 8, 1, 0, 0);
00723     #endif
00724     if(recvFind("OK",5000)) {
00725         //m_puart->begin(baudrate);
00726         m_puart->baud(baudrate);
00727         return true;
00728     } else {
00729         return false;
00730     }
00731 }
00732 
00733 bool ESP8266::qATCWMODE(uint8_t *mode,uint8_t pattern)
00734 {
00735     LOG_ENTER;
00736     String str_mode;
00737     bool ret;
00738     if (!mode||!pattern) {
00739         return false;
00740     }
00741     rx_empty();
00742     switch(pattern) {
00743         case 1 :
00744             //m_puart->println(F("AT+CWMODE_DEF?"));
00745             m_puart->printf("AT+CWMODE_DEF?\r\n");
00746             break;
00747         case 2:
00748             //m_puart->println(F("AT+CWMODE_CUR?"));
00749             m_puart->printf("AT+CWMODE_CUR?\r\n");
00750             break;
00751         default:
00752             //m_puart->println(F("AT+CWMODE?"));
00753             m_puart->printf("AT+CWMODE?\r\n");
00754     }
00755     ret = recvFindAndFilter("OK", ":", "\r\n\r\nOK", str_mode);
00756     if (ret) {
00757         *mode = (uint8_t)str_mode.toInt();
00758         return true;
00759     } else {
00760         return false;
00761     }
00762 }
00763 
00764 bool ESP8266::eATCWMODE(String &list)
00765 {
00766     LOG_ENTER;
00767     rx_empty();
00768     //m_puart->println(F("AT+CWMODE=?"));
00769     m_puart->printf("AT+CWMODE=?\r\n");
00770     return recvFindAndFilter("OK", "+CWMODE:(", ")\r\n\r\nOK", list);
00771 }
00772 
00773 bool ESP8266::sATCWMODE(uint8_t mode,uint8_t pattern)
00774 {
00775     LOG_ENTER;
00776     if(!pattern) {
00777         return false;
00778     }
00779     String data;
00780     rx_empty();
00781     switch(pattern) {
00782         case 1 :
00783             //m_puart->print(F("AT+CWMODE_DEF="));
00784             m_puart->printf("AT+CWMODE_DEF=");
00785             break;
00786         case 2:
00787             //m_puart->print(F("AT+CWMODE_CUR="));
00788             m_puart->printf("AT+CWMODE_CUR=");
00789             break;
00790         default:
00791             //m_puart->print(F("AT+CWMODE="));
00792             m_puart->printf("AT+CWMODE=");
00793     }
00794     //m_puart->println(mode);
00795     m_puart->printf("%d\r\n", mode);
00796     data = recvString("OK", "no change");
00797 
00798     if (data.indexOf("OK") != -1 || data.indexOf("no change") != -1) {
00799         return true;
00800     }
00801     return false;
00802 }
00803 
00804 
00805 bool ESP8266::qATCWJAP(String &ssid,uint8_t pattern)
00806 {
00807     LOG_ENTER;
00808     bool ret;
00809     if (!pattern) {
00810         return false;
00811     }
00812     rx_empty();
00813     switch(pattern) {
00814         case 1 :
00815             //m_puart->println(F("AT+CWJAP_DEF?"));
00816             m_puart->printf("AT+CWJAP_DEF?\r\n");
00817             break;
00818         case 2:
00819             //m_puart->println(F("AT+CWJAP_CUR?"));
00820             m_puart->printf("AT+CWJAP_CUR?\r\n");
00821             break;
00822         default:
00823             //m_puart->println(F("AT+CWJAP?"));
00824             m_puart->printf("AT+CWJAP?\r\n");
00825     }
00826     ssid = recvString("OK", "No AP");
00827     if (ssid.indexOf("OK") != -1 || ssid.indexOf("No AP") != -1) {
00828         return true;
00829     }
00830     return false;
00831 
00832 }
00833 
00834 bool ESP8266::sATCWJAP(String ssid, String pwd, uint8_t pattern)
00835 {
00836     LOG_ENTER;
00837     String data;
00838     if (!pattern) {
00839         return false;
00840     }
00841     rx_empty();
00842     switch(pattern) {
00843         case 1 :
00844             //m_puart->print(F("AT+CWJAP_DEF=\""));
00845             m_puart->printf("AT+CWJAP_DEF=\"");
00846             break;
00847         case 2:
00848             //m_puart->print(F("AT+CWJAP_CUR=\""));
00849             m_puart->printf("AT+CWJAP_CUR=\"");
00850             break;
00851         default:
00852             //m_puart->print(F("AT+CWJAP=\""));
00853             m_puart->printf("AT+CWJAP=\"");
00854     }
00855 #if 0
00856     m_puart->print(ssid);
00857     m_puart->print(F("\",\""));
00858     m_puart->print(pwd);
00859     m_puart->println(F("\""));
00860 #else
00861     //TODO:
00862     m_puart->printf("%s\",\"%s\"\r\n", ssid.c_str(), pwd.c_str());
00863 #endif
00864     data = recvString("OK", "FAIL", 20000);
00865     if (data.indexOf("OK") != -1) {
00866         return true;
00867     }
00868     return false;
00869 }
00870 
00871 bool ESP8266::eATCWLAP(String &list)
00872 {
00873     LOG_ENTER;
00874     String data;
00875     rx_empty();
00876     //m_puart->println(F("AT+CWLAP"));
00877     m_puart->printf("AT+CWLAP\r\n");
00878     return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list, 15000);
00879 }
00880 
00881 bool ESP8266::eATCWQAP(void)
00882 {
00883     LOG_ENTER;
00884     String data;
00885     rx_empty();
00886     //m_puart->println(F("AT+CWQAP"));
00887     m_puart->printf("AT+CWQAP\r\n");
00888     return recvFind("OK");
00889 }
00890 
00891 bool ESP8266::qATCWSAP(String &List,uint8_t pattern)
00892 {
00893     LOG_ENTER;
00894     if (!pattern) {
00895         return false;
00896     }
00897     rx_empty();
00898     switch(pattern) {
00899         case 1 :
00900             //m_puart->println(F("AT+CWSAP_DEF?"));
00901             m_puart->printf("AT+CWSAP_DEF?\r\n");
00902             break;
00903         case 2:
00904             //m_puart->println(F("AT+CWSAP_CUR?"));
00905             m_puart->printf("AT+CWSAP_CUR?\r\n");
00906             break;
00907         default:
00908             //m_puart->println(F("AT+CWSAP?"));
00909             m_puart->printf("AT+CWSAP?\r\n");
00910     }
00911     return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", List,10000);
00912 }
00913 
00914 bool ESP8266::sATCWSAP(String ssid, String pwd, uint8_t chl, uint8_t ecn,uint8_t pattern)
00915 {
00916     LOG_ENTER;
00917     String data;
00918     if (!pattern) {
00919         return false;
00920     }
00921     rx_empty();
00922     switch(pattern) {
00923         case 1 :
00924             //m_puart->print(F("AT+CWSAP_DEF=\""));
00925             m_puart->printf("AT+CWSAP_DEF=\"");
00926             break;
00927         case 2:
00928             //m_puart->print(F("AT+CWSAP_CUR=\""));
00929             m_puart->printf("AT+CWSAP_CUR=\"");
00930             break;
00931         default:
00932             //m_puart->print(F("AT+CWSAP=\""));
00933             m_puart->printf("AT+CWSAP=\"");
00934     }
00935     #if 0
00936     m_puart->print(ssid);
00937     m_puart->print(F("\",\""));
00938     m_puart->print(pwd);
00939     m_puart->print(F("\","));
00940     m_puart->print(chl);
00941     m_puart->print(F(","));
00942     m_puart->println(ecn);
00943     #else
00944     m_puart->printf("%s\",\"%s\",%d,%d\r\n", ssid.c_str(), pwd.c_str(), chl, ecn);
00945     #endif
00946     data = recvString("OK", "ERROR", 5000);
00947     if (data.indexOf("OK") != -1) {
00948         return true;
00949     }
00950     return false;
00951 }
00952 
00953 bool ESP8266::eATCWLIF(String &list)
00954 {
00955     LOG_ENTER;
00956     String data;
00957     rx_empty();
00958     //m_puart->println(F("AT+CWLIF"));
00959     m_puart->printf("AT+CWLIF\r\n");
00960     return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list);
00961 }
00962 
00963 bool ESP8266::qATCWDHCP(String &List,uint8_t pattern)
00964 {
00965     LOG_ENTER;
00966     if (!pattern) {
00967         return false;
00968     }
00969     rx_empty();
00970     switch(pattern) {
00971         case 1 :
00972             //m_puart->println(F("AT+CWDHCP_DEF?"));
00973             m_puart->printf("AT+CWDHCP_DEF?\r\n");
00974             break;
00975         case 2:
00976             //m_puart->println(F("AT+CWDHCP_CUR?"));
00977             m_puart->printf("AT+CWDHCP_CUR?\r\n");
00978             break;
00979         default:
00980             //m_puart->println(F("AT+CWDHCP?"));
00981             m_puart->printf("AT+CWDHCP?\r\n");
00982     }
00983 
00984     return recvFindAndFilter("OK", "\r\r\n", "\r\nOK", List,10000);
00985 
00986 }
00987 
00988 
00989 bool ESP8266::sATCWDHCP(uint8_t mode, uint8_t en, uint8_t pattern)
00990 {
00991     LOG_ENTER;
00992     String data;
00993     if (!pattern) {
00994         return false;
00995     }
00996     rx_empty();
00997     switch(pattern) {
00998         case 1 :
00999             //m_puart->print(F("AT+CWDHCP_DEF="));
01000             m_puart->printf("AT+CWDHCP_DEF=");
01001             break;
01002         case 2:
01003             //m_puart->print(F("AT+CWDHCP_CUR="));
01004             m_puart->printf("AT+CWDHCP_CUR=");
01005             break;
01006         default:
01007             //m_puart->print(F("AT+CWDHCP="));
01008             m_puart->printf("AT+CWDHCP=");
01009     }
01010     #if 0
01011     m_puart->print(mode);
01012     m_puart->print(F(","));
01013     m_puart->println(en);
01014     #else
01015     m_puart->printf("%d,%d\r\n", mode, en);
01016     #endif
01017     data = recvString("OK", "ERROR", 2000);
01018 
01019     if (data.indexOf("OK") != -1) {
01020         return true;
01021     }
01022     return false;
01023 }
01024 
01025 
01026 bool ESP8266::eATCWAUTOCONN(uint8_t en)
01027 {
01028     LOG_ENTER;
01029     rx_empty();
01030     if(en>1||en<0) {
01031         return false;
01032     }
01033     #if 0
01034     m_puart->print(F("AT+CWAUTOCONN="));
01035     m_puart->println(en);
01036     #else
01037     m_puart->printf("AT+CWAUTOCONN=%d\r\n", en);
01038     #endif
01039     return recvFind("OK");
01040 
01041 }
01042 
01043 bool ESP8266::qATCIPSTAMAC(String &mac,uint8_t pattern)
01044 {
01045     LOG_ENTER;
01046     rx_empty();
01047     if (!pattern) {
01048         return false;
01049     }
01050     switch(pattern) {
01051         case 1 :
01052             //m_puart->println(F("AT+CIPSTAMAC_DEF?"));
01053             m_puart->printf("AT+CIPSTAMAC_DEF?\r\n");
01054             break;
01055         case 2:
01056             //m_puart->println(F("AT+CIPSTAMAC_CUR?"));
01057             m_puart->printf("AT+CIPSTAMAC_CUR?\r\n");
01058             break;
01059         default:
01060             //m_puart->println(F("AT+CIPSTAMAC?"));
01061             m_puart->printf("AT+CIPSTAMAC?\r\n");
01062     }
01063     return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", mac,2000);
01064 
01065 }
01066 
01067 
01068 
01069 bool ESP8266::eATCIPSTAMAC(String mac,uint8_t pattern)
01070 {
01071     LOG_ENTER;
01072     rx_empty();
01073     if (!pattern) {
01074         return false;
01075     }
01076     switch(pattern) {
01077         case 1 :
01078             //m_puart->print(F("AT+CIPSTAMAC_DEF="));
01079             m_puart->printf("AT+CIPSTAMAC_DEF=");
01080             break;
01081         case 2:
01082             //m_puart->print(F("AT+CIPSTAMAC_CUR="));
01083             m_puart->printf("AT+CIPSTAMAC_CUR=");
01084             break;
01085         default:
01086             //m_puart->print(F("AT+CIPSTAMAC="));
01087             m_puart->printf("AT+CIPSTAMAC=");
01088     }
01089     #if 0
01090     m_puart->print(F("\""));
01091     m_puart->print(mac);
01092     m_puart->println(F("\""));
01093     #else
01094     m_puart->printf("\"%s\"\r\n", mac.c_str());
01095     #endif
01096     return recvFind("OK");
01097 
01098 }
01099 
01100 bool ESP8266::qATCIPSTAIP(String &ip,uint8_t pattern)
01101 {
01102     LOG_ENTER;
01103     rx_empty();
01104     if (!pattern) {
01105         return false;
01106     }
01107     switch(pattern) {
01108         case 1 :
01109             //m_puart->println(F("AT+CIPSTA_DEF?"));
01110             m_puart->printf("AT+CIPSTA_DEF?\r\n");
01111             break;
01112         case 2:
01113             //m_puart->println(F("AT+CIPSTA_CUR?"));
01114             m_puart->printf("AT+CIPSTA_CUR?\r\n");
01115             break;
01116         default:
01117             //m_puart->println(F("AT+CIPSTA?"));
01118             m_puart->printf("AT+CIPSTA?\r\n");
01119     }
01120     return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", ip,2000);
01121 
01122 }
01123 
01124 bool ESP8266::eATCIPSTAIP(String ip,String gateway,String netmask,uint8_t pattern)
01125 {
01126     LOG_ENTER;
01127     rx_empty();
01128     if (!pattern) {
01129         return false;
01130     }
01131     switch(pattern) {
01132         case 1 :
01133             //m_puart->print(F("AT+CIPSTA_DEF="));
01134             m_puart->printf("AT+CIPSTA_DEF=");
01135             break;
01136         case 2:
01137             //m_puart->print(F("AT+CIPSTA_CUR="));
01138             m_puart->printf("AT+CIPSTA_CUR=");
01139             break;
01140         default:
01141             //m_puart->print(F("AT+CIPSTA="));
01142             m_puart->printf("AT+CIPSTA=");
01143     }
01144     #if 0
01145     m_puart->print(F("\""));
01146     m_puart->print(ip);
01147     m_puart->print(F("\",\""));
01148     m_puart->print(gateway);
01149     m_puart->print(F("\",\""));
01150     m_puart->print(netmask);
01151     m_puart->println(F("\""));
01152     #else
01153     m_puart->printf("\"%s\",\"%s\",\"%s\"\r\n", ip.c_str(), gateway.c_str(), netmask.c_str());
01154     #endif
01155     return recvFind("OK");
01156 
01157 }
01158 
01159 
01160 bool ESP8266::qATCIPAP(String &ip,uint8_t pattern)
01161 {
01162     LOG_ENTER;
01163     rx_empty();
01164     if (!pattern) {
01165         return false;
01166     }
01167     switch(pattern) {
01168         case 1 :
01169             //m_puart->println(F("AT+CIPAP_DEF?"));
01170             m_puart->printf("AT+CIPAP_DEF?\r\n");
01171             break;
01172         case 2:
01173             //m_puart->println(F("AT+CIPAP_CUR?"));
01174             m_puart->printf("AT+CIPAP_CUR?\r\n");
01175             break;
01176         default:
01177             //m_puart->println(F("AT+CIPAP?"));
01178             m_puart->printf("AT+CIPAP?\r\n");
01179     }
01180     return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", ip,2000);
01181 
01182 }
01183 
01184 
01185 bool ESP8266::eATCIPAP(String ip,uint8_t pattern)
01186 {
01187     LOG_ENTER;
01188     rx_empty();
01189     if (!pattern) {
01190         return false;
01191     }
01192     switch(pattern) {
01193         case 1 :
01194             //m_puart->print(F("AT+CIPAP_DEF="));
01195             m_puart->printf("AT+CIPAP_DEF=");
01196             break;
01197         case 2:
01198             //m_puart->print(F("AT+CIPAP_CUR="));
01199             m_puart->printf("AT+CIPAP_CUR=");
01200             break;
01201         default:
01202             //m_puart->print(F("AT+CIPAP="));
01203             m_puart->printf("AT+CIPAP=");
01204     }
01205     #if 0
01206     m_puart->print(F("\""));
01207     m_puart->print(ip);
01208     m_puart->println(F("\""));
01209     #else
01210     m_puart->printf("\"%s\"\r\n", ip.c_str());
01211     #endif
01212     return recvFind("OK");
01213 
01214 }
01215 
01216 
01217 bool ESP8266::eCWSTARTSMART(uint8_t type)
01218 {
01219     LOG_ENTER;
01220     rx_empty();
01221     #if 0
01222     m_puart->print(F("AT+CWSTARTSMART="));
01223     m_puart->println(type);
01224     #else
01225     m_puart->printf("AT+CWSTARTSMART=%d\r\n", type);
01226     #endif
01227     return recvFind("OK");
01228 }
01229 
01230 bool ESP8266::eCWSTOPSMART(void)
01231 {
01232     LOG_ENTER;
01233     rx_empty();
01234     //m_puart->println(F("AT+CWSTOPSMART"));
01235     m_puart->printf("AT+CWSTOPSMART\r\n");
01236     return recvFind("OK");
01237 }
01238 
01239 bool ESP8266::eATCIPSTATUS(String &list)
01240 {
01241     LOG_ENTER;
01242     String data;
01243     //delay(100);
01244     wait_ms(100);
01245     rx_empty();
01246     //m_puart->println(F("AT+CIPSTATUS"));
01247     m_puart->printf("AT+CIPSTATUS\r\n");
01248     return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list);
01249 }
01250 
01251 bool ESP8266::sATCIPSTARTSingle(String type, String addr, uint32_t port)
01252 {
01253     LOG_ENTER;
01254     String data;
01255     rx_empty();
01256     #if 0
01257     m_puart->print(F("AT+CIPSTART=\""));
01258     m_puart->print(type);
01259     m_puart->print(F("\",\""));
01260     m_puart->print(addr);
01261     m_puart->print(F("\","));
01262     m_puart->println(port);
01263     #else
01264     m_puart->printf("AT+CIPSTART=\"%s\",\"%s\",%u\r\n", type.c_str(), addr.c_str(), port);
01265     #endif
01266     data = recvString("OK", "ERROR", "ALREADY CONNECT", 10000);
01267     if (data.indexOf("OK") != -1 || data.indexOf("ALREADY CONNECT") != -1) {
01268         return true;
01269     }
01270     return false;
01271 }
01272 
01273 bool ESP8266::sATCIPSTARTMultiple(uint8_t mux_id, String type, String addr, uint32_t port)
01274 {
01275     LOG_ENTER;
01276     String data;
01277     rx_empty();
01278     #if 0
01279     m_puart->print(F("AT+CIPSTART="));
01280     m_puart->print(mux_id);
01281     m_puart->print(F(",\""));
01282     m_puart->print(type);
01283     m_puart->print(F("\",\""));
01284     m_puart->print(addr);
01285     m_puart->print(F("\","));
01286     m_puart->println(port);
01287     #else
01288     m_puart->printf("AT+CIPSTART=%d,\"%s\",\"%s\",%u\r\n", mux_id, type.c_str(), addr.c_str(), port);
01289     #endif
01290     data = recvString("OK", "ERROR", "ALREADY CONNECT", 10000);
01291     if (data.indexOf("OK") != -1 || data.indexOf("ALREADY CONNECT") != -1) {
01292         return true;
01293     }
01294     return false;
01295 }
01296 
01297 bool ESP8266::sATCIPSENDSingle(const uint8_t *buffer, uint32_t len)
01298 {
01299     LOG_ENTER;
01300     rx_empty();
01301     #if 0
01302     m_puart->print(F("AT+CIPSEND="));
01303     m_puart->println(len);
01304     #else
01305     m_puart->printf("AT+CIPSEND=%u\r\n", len);
01306     #endif
01307     if (recvFind(">", 5000)) {
01308         rx_empty();
01309         for (uint32_t i = 0; i < len; i++) {
01310             //m_puart->write(buffer[i]);
01311             m_puart->putc(buffer[i]);
01312         }
01313         return recvFind("SEND OK", 10000);
01314     }
01315     return false;
01316 }
01317 
01318 bool ESP8266::sATCIPSENDMultiple(uint8_t mux_id, const uint8_t *buffer, uint32_t len)
01319 {
01320     LOG_ENTER;
01321     rx_empty();
01322     #if 0
01323     m_puart->print(F("AT+CIPSEND="));
01324     m_puart->print(mux_id);
01325     m_puart->print(F(","));
01326     m_puart->println(len);
01327     #else
01328     m_puart->printf("AT+CIPSEND=%d,%u\r\n", mux_id, len);
01329     #endif
01330     if (recvFind(">", 5000)) {
01331         rx_empty();
01332         for (uint32_t i = 0; i < len; i++) {
01333             //m_puart->write(buffer[i]);
01334             m_puart->putc(buffer[i]);
01335         }
01336         return recvFind("SEND OK", 10000);
01337     }
01338     return false;
01339 }
01340 
01341 bool ESP8266::sATCIPSENDSingleFromFlash(const uint8_t *buffer, uint32_t len)
01342 {
01343     LOG_ENTER;
01344     rx_empty();
01345     #if 0
01346     m_puart->print(F("AT+CIPSEND="));
01347     m_puart->println(len);
01348     #else
01349     m_puart->printf("AT+CIPSEND=%u\r\n", len);
01350     #endif
01351     if (recvFind(">", 5000)) {
01352         rx_empty();
01353         for (uint32_t i = 0; i < len; i++) {
01354             //m_puart->write((char) pgm_read_byte(&buffer[i]));
01355             m_puart->putc(buffer[i]);
01356         }
01357         return recvFind("SEND OK", 10000);
01358     }
01359     return false;
01360 }
01361 
01362 bool ESP8266::sATCIPSENDMultipleFromFlash(uint8_t mux_id, const uint8_t *buffer, uint32_t len)
01363 {
01364     LOG_ENTER;
01365     rx_empty();
01366     #if 0
01367     m_puart->print(F("AT+CIPSEND="));
01368     m_puart->print(mux_id);
01369     m_puart->print(F(","));
01370     m_puart->println(len);
01371     #else
01372     m_puart->printf("AT+CIPSEND=%d,%u\r\n", mux_id, len);
01373     #endif
01374     if (recvFind(">", 5000)) {
01375         rx_empty();
01376         for (uint32_t i = 0; i < len; i++) {
01377             //m_puart->write((char) pgm_read_byte(&buffer[i]));
01378             m_puart->putc(buffer[i]);
01379         }
01380         return recvFind("SEND OK", 10000);
01381     }
01382     return false;
01383 }
01384 
01385 bool ESP8266::sATCIPCLOSEMulitple(uint8_t mux_id)
01386 {
01387     LOG_ENTER;
01388     String data;
01389     rx_empty();
01390     #if 0
01391     m_puart->print(F("AT+CIPCLOSE="));
01392     m_puart->println(mux_id);
01393     #else
01394     m_puart->printf("AT+CIPCLOSE=%d\r\n", mux_id);
01395     #endif
01396     data = recvString("OK", "link is not", 5000);
01397     if (data.indexOf("OK") != -1 || data.indexOf("link is not") != -1) {
01398         return true;
01399     }
01400     return false;
01401 }
01402 
01403 bool ESP8266::eATCIPCLOSESingle(void)
01404 {
01405     LOG_ENTER;
01406     rx_empty();
01407     //m_puart->println(F("AT+CIPCLOSE"));
01408     m_puart->printf("AT+CIPCLOSE\r\n");
01409     return recvFind("OK", 5000);
01410 }
01411 
01412 bool ESP8266::eATCIFSR(String &list)
01413 {
01414     LOG_ENTER;
01415     rx_empty();
01416     //m_puart->println(F("AT+CIFSR"));
01417     m_puart->printf("AT+CIFSR\r\n");
01418     return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list);
01419 }
01420 
01421 bool ESP8266::sATCIPMUX(uint8_t mode)
01422 {
01423     LOG_ENTER;
01424     String data;
01425     rx_empty();
01426     #if 0
01427     m_puart->print(F("AT+CIPMUX="));
01428     m_puart->println(mode);
01429     #else
01430     m_puart->printf("AT+CIPMUX=%d\r\n", mode);
01431     #endif
01432     data = recvString("OK", "Link is builded");
01433     if (data.indexOf("OK") != -1) {
01434         return true;
01435     }
01436     return false;
01437 }
01438 
01439 bool ESP8266::sATCIPSERVER(uint8_t mode, uint32_t port)
01440 {
01441     LOG_ENTER;
01442     String data;
01443     if (mode) {
01444         rx_empty();
01445         #if 0
01446         m_puart->print(F("AT+CIPSERVER=1,"));
01447         m_puart->println(port);
01448         #else
01449         m_puart->printf("AT+CIPSERVER=1,%u\r\n", port);
01450         #endif
01451         data = recvString("OK", "no change");
01452         if (data.indexOf("OK") != -1 || data.indexOf("no change") != -1) {
01453             return true;
01454         }
01455         return false;
01456     } else {
01457         rx_empty();
01458         //m_puart->println(F("AT+CIPSERVER=0"));
01459         m_puart->printf("AT+CIPSERVER=0\r\n");
01460         return recvFind("\r\r\n");
01461     }
01462 }
01463 
01464 bool ESP8266::sATCIPMODE(uint8_t mode)
01465 {
01466     LOG_ENTER;
01467     String data;
01468     if(mode>1||mode<0) {
01469         return false;
01470     }
01471     rx_empty();
01472     #if 0
01473     m_puart->print(F("AT+CIPMODE="));
01474     m_puart->println(mode);
01475     #else
01476     m_puart->printf("AT+CIPMODE=%d\r\n", mode);
01477     #endif
01478     data = recvString("OK", "Link is builded",2000);
01479     if (data.indexOf("OK") != -1 ) {
01480         return true;
01481     }
01482     return false;
01483 }
01484 
01485 bool ESP8266::eATSAVETRANSLINK(uint8_t mode,String ip,uint32_t port)
01486 {
01487     LOG_ENTER;
01488     String data;
01489     rx_empty();
01490     #if 0
01491     m_puart->print(F("AT+SAVETRANSLINK="));
01492     m_puart->print(mode);
01493     m_puart->print(F(",\""));
01494     m_puart->print(ip);
01495     m_puart->print(F("\","));
01496     m_puart->println(port);
01497     #else
01498     m_puart->printf("AT+SAVETRANSLINK=%d,\"%s\",%u\r\n", mode, ip.c_str(), port);
01499     #endif
01500     data = recvString("OK", "ERROR",2000);
01501     if (data.indexOf("OK") != -1 ) {
01502         return true;
01503     }
01504     return false;
01505 }
01506 
01507 bool ESP8266::eATPING(String ip)
01508 {
01509     LOG_ENTER;
01510     rx_empty();
01511     #if 0
01512     m_puart->print(F("AT+PING="));
01513     m_puart->print(F("\""));
01514     m_puart->print(ip);
01515     m_puart->println(F("\""));
01516     #else
01517     m_puart->printf("AT+PING=\"%s\"\r\n", ip.c_str());
01518     #endif
01519     return recvFind("OK",2000);
01520 }
01521 
01522 bool ESP8266::sATCIPSTO(uint32_t timeout)
01523 {
01524     LOG_ENTER;
01525     rx_empty();
01526     #if 0
01527     m_puart->print(F("AT+CIPSTO="));
01528     m_puart->println(timeout);
01529     #else
01530     m_puart->printf("AT+CIPSTO=%u\r\n", timeout);
01531     #endif
01532     return recvFind("OK");
01533 }