├── library.json ├── README.md ├── ESP8266_Lib.h └── ESP8266.cpp /library.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "BlynkESP8266", 3 | "keywords": "wifi, wi-fi, http, web, server, client", 4 | "description": "", 5 | "repository": 6 | { 7 | "type": "git", 8 | "url": "https://github.com/vshymanskyy/BlynkESP8266.git" 9 | }, 10 | "frameworks": "arduino", 11 | "platforms": "*" 12 | } 13 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | @mainpage 2 | 3 | # WeeESP8266 4 | 5 | An ESP8266 library for Arduino providing an easy-to-use way to manipulate ESP8266. 6 | 7 | # Source 8 | 9 | Source can be download at . 10 | 11 | You can clone it by: 12 | 13 | git clone https://github.com/itead/ITEADLIB_Arduino_WeeESP8266.git 14 | 15 | # Documentation 16 | 17 | Online API documentation can be reached at . 18 | 19 | Offline API documentation can be found under directory 20 | [doc](https://github.com/itead/ITEADLIB_Arduino_WeeESP8266/tree/master/doc). 21 | 22 | # How to get started 23 | 24 | On the home page of API documentation, the tabs of Examples, Classes and Modules 25 | will be useful for Arduino lovers. 26 | 27 | # API List 28 | 29 | bool kick (void) : Verify ESP8266 whether live or not. 30 | 31 | bool restart (void) : Restart ESP8266 by "AT+RST". 32 | 33 | String getVersion (void) : Get the version of AT Command Set. 34 | 35 | bool setOprToStation (void) : Set operation mode to staion. 36 | 37 | bool setOprToSoftAP (void) : Set operation mode to softap. 38 | 39 | bool setOprToStationSoftAP (void) : Set operation mode to station + softap. 40 | 41 | uint8_t getOprMode(void) : Get the operation mode. 42 | 43 | String getAPList (void) : Search available AP list and return it. 44 | 45 | bool joinAP (String ssid, String pwd) : Join in AP. 46 | 47 | bool leaveAP (void) : Leave AP joined before. 48 | 49 | bool setSoftAPParam (String ssid, String pwd, uint8_t chl=7, uint8_t ecn=4) : Set SoftAP parameters. 50 | 51 | String getJoinedDeviceIP (void) : Get the IP list of devices connected to SoftAP. 52 | 53 | String getIPStatus (void) : Get the current status of connection(UDP and TCP). 54 | 55 | String getLocalIP (void) : Get the IP address of ESP8266. 56 | 57 | bool enableMUX (void) : Enable IP MUX(multiple connection mode). 58 | 59 | bool disableMUX (void) : Disable IP MUX(single connection mode). 60 | 61 | bool createTCP (String addr, uint32_t port) : Create TCP connection in single mode. 62 | 63 | bool releaseTCP (void) : Release TCP connection in single mode. 64 | 65 | bool registerUDP (String addr, uint32_t port) : Register UDP port number in single mode. 66 | 67 | bool unregisterUDP (void) : Unregister UDP port number in single mode. 68 | 69 | bool createTCP (uint8_t mux_id, String addr, uint32_t port) : Create TCP connection in multiple mode. 70 | 71 | bool releaseTCP (uint8_t mux_id) : Release TCP connection in multiple mode. 72 | 73 | bool registerUDP (uint8_t mux_id, String addr, uint32_t port) : Register UDP port number in multiple mode. 74 | 75 | bool unregisterUDP (uint8_t mux_id) : Unregister UDP port number in multiple mode. 76 | 77 | bool setTCPServerTimeout (uint32_t timeout=180) : Set the timeout of TCP Server. 78 | 79 | bool startServer (uint32_t port=333) ： Start Server(Only in multiple mode). 80 | 81 | bool stopServer (void) : Stop Server(Only in multiple mode). 82 | 83 | bool startTCPServer (uint32_t port=333) : Start TCP Server(Only in multiple mode). 84 | 85 | bool stopTCPServer (void) : Stop TCP Server(Only in multiple mode). 86 | 87 | bool send (const uint8_t *buffer, uint32_t len) : Send data based on TCP or UDP builded already in single mode. 88 | 89 | bool send (uint8_t mux_id, const uint8_t *buffer, uint32_t len) : Send data based on one of TCP or UDP builded already in multiple mode. 90 | 91 | bool sendFromFlash (const uint8_t *buffer, uint32_t len) : Send data based on TCP or UDP builded already in single mode. 92 | 93 | bool sendFromFlash (uint8_t mux_id, const uint8_t *buffer, uint32_t len) : Send data based on one of TCP or UDP builded already in multiple mode. 94 | 95 | uint32_t recv (uint8_t *buffer, uint32_t buffer_size, uint32_t timeout=1000) : Receive data from TCP or UDP builded already in single mode. 96 | 97 | uint32_t recv (uint8_t mux_id, uint8_t *buffer, uint32_t buffer_size, uint32_t timeout=1000) : Receive data from one of TCP or UDP builded already in multiple mode. 98 | 99 | uint32_t recv (uint8_t *coming_mux_id, uint8_t *buffer, uint32_t buffer_size, uint32_t timeout=1000) : Receive data from all of TCP or UDP builded already in multiple mode. 100 | 101 | 102 | # Mainboard Requires 103 | 104 | - RAM: not less than 2KBytes 105 | - Serial: one serial (HardwareSerial or SoftwareSerial) at least 106 | 107 | # Suppported Mainboards 108 | 109 | - Arduino UNO and its derivatives 110 | - Arduino MEGA and its derivatives 111 | - [Iteaduino UNO](http://imall.iteadstudio.com/im130312001.html) 112 | - [WBoard Pro](http://imall.iteadstudio.com/im141125005.html) 113 | 114 | # Select the version of ESP8266 AT Firmware 115 | 116 | At present, this library supports ESP8266 AT 0.18 version and 0.22 version. You 117 | can select one of them to fit your module by modifing this line in `ESP8266.h`: 118 | 119 | #define USER_SEL_VERSION VERSION_18 120 | 121 | If you want to select 0.22 version, it should be like below after modification: 122 | 123 | #define USER_SEL_VERSION VERSION_22 124 | 125 | 126 | # Using SoftwareSerial 127 | 128 | If you want to use SoftwareSerial to communicate with ESP8266, you need to modify 129 | the line in file `ESP8266.h`: 130 | 131 | //#define ESP8266_USE_SOFTWARE_SERIAL 132 | 133 | After modification, it should be: 134 | 135 | #define ESP8266_USE_SOFTWARE_SERIAL 136 | 137 | 138 | # Hardware Connection 139 | 140 | WeeESP8266 library only needs an uart for hardware connection. All communications 141 | are done via uart. In each example, you must specify the uart used by mainboard 142 | to communicate with ESP8266 flashed AT firmware. 143 | 144 | ## MEGA and WBoard Pro 145 | 146 | For MEGA and WBoard Pro, `Serial1` will be used if you create an object (named wifi) 147 | of class ESP8266 in your code like this: 148 | 149 | #include "ESP8266.h" 150 | ESP8266 wifi(Serial1); 151 | 152 | The connection should be like these: 153 | 154 | ESP8266_TX->RX1(D19) 155 | ESP8266_RX->TX1(D18) 156 | ESP8266_CH_PD->3.3V 157 | ESP8266_VCC->3.3V 158 | ESP8266_GND->GND 159 | 160 | ## UNO 161 | 162 | To use SoftwareSerial, `mySerial` will be used if you create an object (named wifi) 163 | of class ESP8266 in your code like this: 164 | 165 | #include "ESP8266.h" 166 | #include 167 | 168 | SoftwareSerial mySerial(3, 2); /* RX:D3, TX:D2 */ 169 | ESP8266 wifi(mySerial); 170 | 171 | The connection should be like these: 172 | 173 | ESP8266_TX->RX(D3) 174 | ESP8266_RX->TX(D2) 175 | ESP8266_CH_PD->3.3V 176 | ESP8266_VCC->3.3V 177 | ESP8266_GND->GND 178 | 179 | # Attention 180 | 181 | The size of data from ESP8266 is too big for arduino sometimes, so the library can't 182 | receive the whole buffer because the size of the hardware serial buffer which is 183 | defined in HardwareSerial.h is too small. 184 | 185 | Open the file from `\arduino\hardware\arduino\avr\cores\arduino\HardwareSerial.h`. 186 | See the follow line in the HardwareSerial.h file. 187 | 188 | #define SERIAL_BUFFER_SIZE 64 189 | 190 | The default size of the buffer is 64. Change it into a bigger number, like 256 or more. 191 | 192 | 193 | ------------------------------------------------------------------------------- 194 | 195 | # The End! 196 | 197 | ------------------------------------------------------------------------------- 198 | -------------------------------------------------------------------------------- /ESP8266_Lib.h: -------------------------------------------------------------------------------- 1 | /** 2 | * @file ESP8266.h 3 | * @brief The definition of class ESP8266. 4 | * @author Wu Pengfei 5 | * @date 2015.02 6 | * 7 | * @par Copyright: 8 | * Copyright (c) 2015 ITEAD Intelligent Systems Co., Ltd. \n\n 9 | * This program is free software; you can redistribute it and/or 10 | * modify it under the terms of the GNU General Public License as 11 | * published by the Free Software Foundation; either version 2 of 12 | * the License, or (at your option) any later version. \n\n 13 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 14 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 15 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 16 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 17 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 18 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 19 | * THE SOFTWARE. 20 | */ 21 | #ifndef __ESP8266_H__ 22 | #define __ESP8266_H__ 23 | 24 | #include "Arduino.h" 25 | 26 | #define VERSION_18 0X18 27 | #define VERSION_22 0X22 28 | #define DEFAULT_PATTERN 3 29 | 30 | /** 31 | * You can modify the macro to choose a different version 32 | */ 33 | 34 | #define USER_SEL_VERSION VERSION_22 35 | 36 | /** 37 | * Provide an easy-to-use way to manipulate ESP8266. 38 | */ 39 | class ESP8266 { 40 | public: 41 | 42 | typedef void (*onData)(uint8_t mux_id, uint32_t len, void* ptr); 43 | 44 | /* 45 | * Constuctor. 46 | * 47 | * @param uart - an pointer of Serial object. 48 | * @warning parameter baud depends on the AT firmware. 9600 is an common value. 49 | */ 50 | 51 | ESP8266(Stream* uart = &Serial); 52 | 53 | Stream* getUart() { return m_puart; } 54 | 55 | 56 | void setOnData(onData cbk, void* ptr) { 57 | m_onData = cbk; 58 | m_onDataPtr = ptr; 59 | } 60 | 61 | void run(); 62 | 63 | /** 64 | * Verify ESP8266 whether live or not. 65 | * 66 | * Actually, this method will send command "AT" to ESP8266 and waiting for "OK". 67 | * 68 | * @retval true - alive. 69 | * @retval false - dead. 70 | */ 71 | bool kick(void); 72 | 73 | /** 74 | * Restart ESP8266 by "AT+RST". 75 | * 76 | * This method will take 3 seconds or more. 77 | * 78 | * @retval true - success. 79 | * @retval false - failure. 80 | */ 81 | bool restart(void); 82 | 83 | /** 84 | * Get the version of AT Command Set. 85 | * 86 | * @return the string of version. 87 | */ 88 | String getVersion(void); 89 | 90 | /** 91 | * Start function of deep sleep. 92 | * 93 | * @param time - the sleep time. 94 | * @retval true - success. 95 | * @retval false - failure. 96 | * @note the feature requires hardware support. 97 | */ 98 | bool deepSleep(uint32_t time); 99 | 100 | /** 101 | * Switch the echo function. 102 | * 103 | * @param mode - 1 start echo -0 stop echo 104 | * @retval true - success. 105 | * @retval false - failure. 106 | * 107 | */ 108 | bool setEcho(uint8_t mode); 109 | 110 | /** 111 | * Restore factory. 112 | * @retval true - success. 113 | * @retval false - failure. 114 | * @note The operation can lead to restart the machine. 115 | */ 116 | bool restore(void); 117 | 118 | /** 119 | * Set up a serial port configuration. 120 | * 121 | * @param pattern -1 send "AT+UART=", -2 send "AT+UART_CUR=", -3 send "AT+UART_DEF=". 122 | * @param baudrate - the uart baudrate. 123 | * @retval true - success. 124 | * @retval false - failure. 125 | * @note Only allows baud rate design, for the other parameters:databits- 8,stopbits -1,parity -0,flow control -0 . 126 | */ 127 | bool setUart(uint32_t baudrate,uint8_t pattern); 128 | 129 | /** 130 | * Set operation mode to station. 131 | * 132 | * @param pattern1 -1, send "AT+CWMODE_DEF?",-2,send "AT+CWMODE_CUR?",-3,send "AT+CWMODE?". 133 | * @param pattern2 -1, send "AT+CWMODE_DEF=",-2,send "AT+CWMODE_CUR=",-3,send "AT+CWMODE=". 134 | * @retval true - success. 135 | * @retval false - failure. 136 | * 137 | */ 138 | bool setOprToStation(uint8_t pattern1=DEFAULT_PATTERN,uint8_t pattern2=DEFAULT_PATTERN); 139 | 140 | /** 141 | * Get the model values list. 142 | * 143 | * @return the list of model. 144 | */ 145 | String getWifiModeList(void); 146 | 147 | /** 148 | * Set operation mode to softap. 149 | * @param pattern1 -1, send "AT+CWMODE_DEF?",-2,send "AT+CWMODE_CUR?",-3,send "AT+CWMODE?". 150 | * @param pattern2 -1, send "AT+CWMODE_DEF=",-2,send "AT+CWMODE_CUR=",-3,send "AT+CWMODE=". 151 | * 152 | * @retval true - success. 153 | * @retval false - failure. 154 | */ 155 | bool setOprToSoftAP(uint8_t pattern1=DEFAULT_PATTERN,uint8_t pattern2=DEFAULT_PATTERN); 156 | 157 | /** 158 | * Set operation mode to station + softap. 159 | * @param pattern1 -1, send "AT+CWMODE_DEF?",-2,send "AT+CWMODE_CUR?",-3,send "AT+CWMODE?". 160 | * @param pattern2 -1, send "AT+CWMODE_DEF=",-2,send "AT+CWMODE_CUR=",-3,send "AT+CWMODE=". 161 | * 162 | * @retval true - success. 163 | * @retval false - failure. 164 | */ 165 | bool setOprToStationSoftAP(uint8_t pattern1=DEFAULT_PATTERN,uint8_t pattern2=DEFAULT_PATTERN); 166 | 167 | /** 168 | * Get the operation mode. 169 | * @param pattern1 -1, send "AT+CWMODE_DEF?",-2,send "AT+CWMODE_CUR?",-3,send "AT+CWMODE?". 170 | * 171 | * @retval 0 - failure. 172 | * @retval 1 - mode Station. 173 | * @retval 2 - mode AP. 174 | * @retval 3 - mode AP + station. 175 | */ 176 | uint8_t getOprMode(uint8_t pattern1=DEFAULT_PATTERN); 177 | 178 | /** 179 | * Search available AP list and return it. 180 | * 181 | * @return the list of available APs. 182 | * @note This method will occupy a lot of memeory(hundreds of Bytes to a couple of KBytes). 183 | * Do not call this method unless you must and ensure that your board has enough memery left. 184 | */ 185 | String getAPList(void); 186 | 187 | /** 188 | * Search and returns the current connect AP. 189 | * 190 | * @param pattern -1, send "AT+CWJAP_DEF?",-2,send "AT+CWJAP_CUR?",-3,send "AT+CWJAP?". 191 | * @return the ssid of AP connected now. 192 | */ 193 | String getNowConecAp(uint8_t pattern=DEFAULT_PATTERN); 194 | 195 | /** 196 | * Join in AP. 197 | * 198 | * @param pattern -1 send "AT+CWJAP_DEF=" -2 send "AT+CWJAP_CUR=" -3 send "AT+CWJAP=". 199 | * @param ssid - SSID of AP to join in. 200 | * @param pwd - Password of AP to join in. 201 | * @retval true - success. 202 | * @retval false - failure. 203 | * @note This method will take a couple of seconds. 204 | */ 205 | bool joinAP(String ssid, String pwd,uint8_t pattern=DEFAULT_PATTERN); 206 | 207 | /** 208 | * Leave AP joined before. 209 | * 210 | * @retval true - success. 211 | * @retval false - failure. 212 | */ 213 | bool leaveAP(void); 214 | 215 | /** 216 | * Set SoftAP parameters. 217 | * 218 | * @param pattern -1 send "AT+CWSAP_DEF=" -2 send "AT+CWSAP_CUR=" -3 send "AT+CWSAP=". 219 | * @param ssid - SSID of SoftAP. 220 | * @param pwd - PASSWORD of SoftAP. 221 | * @param chl - the channel (1 - 13, default: 7). 222 | * @param ecn - the way of encrypstion (0 - OPEN, 1 - WEP, 223 | * 2 - WPA_PSK, 3 - WPA2_PSK, 4 - WPA_WPA2_PSK, default: 4). 224 | * @retval true - success. 225 | * @retval false - failure. 226 | * @note This method should not be called when station mode. 227 | */ 228 | bool setSoftAPParam(String ssid, String pwd, uint8_t chl = 7, uint8_t ecn = 4,uint8_t pattern=DEFAULT_PATTERN); 229 | 230 | /** 231 | * get SoftAP parameters. 232 | * 233 | * @param pattern -1 send "AT+CWSAP_DEF?" -2 send "AT+CWSAP_CUR?" -3 send "AT+CWSAP?". 234 | * @note This method should not be called when station mode. 235 | */ 236 | String getSoftAPParam(uint8_t pattern=DEFAULT_PATTERN); 237 | 238 | /** 239 | * Get the IP list of devices connected to SoftAP. 240 | * 241 | * @return the list of IP. 242 | * @note This method should not be called when station mode. 243 | */ 244 | String getJoinedDeviceIP(void); 245 | 246 | /** 247 | * Get the current state of DHCP. 248 | * 249 | * @param pattern -1 send "AT+CWDHCP_DEF?" -2 send "AT+CWDHCP_CUR?" -3 send "AT+CWDHCP?". 250 | * @return the state of DHCP. 251 | * 252 | */ 253 | String getDHCP(uint8_t pattern=DEFAULT_PATTERN); 254 | 255 | /** 256 | * Set the state of DHCP. 257 | * @param pattern -1 send "AT+CWDHCP_DEF=" -2 send "AT+CWDHCP_CUR=" -3 send "AT+CWDHCP=". 258 | * @param mode - set ap or set station or set ap + station. 259 | * @param en - 0 disable DHCP - 1 enable DHCP. 260 | * @retval true - success. 261 | * @retval false - failure. 262 | */ 263 | bool setDHCP(uint8_t mode, uint8_t en, uint8_t pattern=DEFAULT_PATTERN); 264 | 265 | /** 266 | * make boot automatically connected. 267 | * @param en -1 enable -0 disable. 268 | * @retval true - success. 269 | * @retval false - failure. 270 | */ 271 | bool setAutoConnect(uint8_t en); 272 | 273 | /** 274 | * Get the station's MAC address. 275 | * @param pattern -1 send "AT+CIPSTAMAC_DEF?=" -2 send "AT+CIPSTAMAC_CUR?" -3 send "AT+CIPSTAMAC?". 276 | * @return mac address. 277 | * @note This method should not be called when ap mode. 278 | */ 279 | String getStationMac(uint8_t pattern=DEFAULT_PATTERN); 280 | 281 | /** 282 | * Set the station's MAC address. 283 | * @param pattern -1 send "AT+CIPSTAMAC_DEF=" -2 send "AT+CIPSTAMAC_CUR=" -3 send "AT+CIPSTAMAC=". 284 | * @param mac - the mac address of station. 285 | * @retval true - success. 286 | * @retval false - failure. 287 | */ 288 | bool setStationMac(String mac,uint8_t pattern=DEFAULT_PATTERN); 289 | 290 | /** 291 | * Get the station's IP. 292 | * @param pattern -1 send "AT+CIPSTA_DEF?" -2 send "AT+CIPSTA_CUR?" -3 send "AT+CIPSTA?". 293 | * @return the station's IP. 294 | * @note This method should not be called when ap mode. 295 | */ 296 | String getStationIp(uint8_t pattern=DEFAULT_PATTERN); 297 | 298 | /** 299 | * Set the station's IP. 300 | * @param pattern -1 send "AT+CIPSTA_DEF=" -2 send "AT+CIPSTA_CUR=" -3 send "AT+CIPSTA=". 301 | * @param ip - the ip of station. 302 | * @param gateway -the gateway of station. 303 | * @param netmask -the netmask of station. 304 | * @retval true - success. 305 | * @retval false - failure. 306 | * @note This method should not be called when ap mode. 307 | */ 308 | bool setStationIp(String ip,String gateway,String netmask,uint8_t pattern=DEFAULT_PATTERN); 309 | 310 | /** 311 | * Get the AP's IP. 312 | * @param pattern -1 send "AT+CIPAP_DEF?" -2 send "AT+CIPAP_CUR?" -3 send "AT+CIPAP?". 313 | * @return ap's ip. 314 | * @note This method should not be called when station mode. 315 | * 316 | */ 317 | String getAPIp(uint8_t pattern=DEFAULT_PATTERN); 318 | 319 | /** 320 | * Set the AP IP. 321 | * @param pattern -1 send "AT+CIPAP_DEF=" -2 send "AT+CIPAP_CUR=" -3 send "AT+CIPAP=". 322 | * @param ip - the ip of AP. 323 | * @retval true - success. 324 | * @retval false - failure. 325 | * @note This method should not be called when station mode. 326 | */ 327 | bool setAPIp(String ip,uint8_t pattern=DEFAULT_PATTERN); 328 | 329 | /** 330 | * start smartconfig. 331 | * @param type -1:ESP_TOUCH -2:AirKiss. 332 | * @retval true - success. 333 | * @retval false - failure. 334 | */ 335 | bool startSmartConfig(uint8_t type); 336 | 337 | /** 338 | * stop smartconfig. 339 | * 340 | * @retval true - success. 341 | * @retval false - failure. 342 | */ 343 | bool stopSmartConfig(void); 344 | 345 | /** 346 | * Get the current status of connection(UDP and TCP). 347 | * 348 | * @return the status. 349 | */ 350 | String getIPStatus(void); 351 | 352 | /** 353 | * Get the IP address of ESP8266. 354 | * 355 | * @return the IP list. 356 | */ 357 | String getLocalIP(void); 358 | 359 | /** 360 | * Enable IP MUX(multiple connection mode). 361 | * 362 | * In multiple connection mode, a couple of TCP and UDP communication can be builded. 363 | * They can be distinguished by the identifier of TCP or UDP named mux_id. 364 | * 365 | * @retval true - success. 366 | * @retval false - failure. 367 | */ 368 | bool enableMUX(void); 369 | 370 | /** 371 | * Disable IP MUX(single connection mode). 372 | * 373 | * In single connection mode, only one TCP or UDP communication can be builded. 374 | * 375 | * @retval true - success. 376 | * @retval false - failure. 377 | */ 378 | bool disableMUX(void); 379 | 380 | /** 381 | * Create TCP connection in single mode. 382 | * 383 | * @param addr - the IP or domain name of the target host. 384 | * @param port - the port number of the target host. 385 | * @retval true - success. 386 | * @retval false - failure. 387 | */ 388 | bool createTCP(String addr, uint32_t port); 389 | 390 | /** 391 | * Release TCP connection in single mode. 392 | * 393 | * @retval true - success. 394 | * @retval false - failure. 395 | */ 396 | bool releaseTCP(void); 397 | 398 | /** 399 | * Register UDP port number in single mode. 400 | * 401 | * @param addr - the IP or domain name of the target host. 402 | * @param port - the port number of the target host. 403 | * @retval true - success. 404 | * @retval false - failure. 405 | */ 406 | bool registerUDP(String addr, uint32_t port); 407 | 408 | /** 409 | * Unregister UDP port number in single mode. 410 | * 411 | * @retval true - success. 412 | * @retval false - failure. 413 | */ 414 | bool unregisterUDP(void); 415 | 416 | /** 417 | * Create TCP connection in multiple mode. 418 | * 419 | * @param mux_id - the identifier of this TCP(available value: 0 - 4). 420 | * @param addr - the IP or domain name of the target host. 421 | * @param port - the port number of the target host. 422 | * @retval true - success. 423 | * @retval false - failure. 424 | */ 425 | bool createTCP(uint8_t mux_id, String addr, uint32_t port); 426 | 427 | /** 428 | * Release TCP connection in multiple mode. 429 | * 430 | * @param mux_id - the identifier of this TCP(available value: 0 - 4). 431 | * @retval true - success. 432 | * @retval false - failure. 433 | */ 434 | bool releaseTCP(uint8_t mux_id); 435 | 436 | /** 437 | * Register UDP port number in multiple mode. 438 | * 439 | * @param mux_id - the identifier of this TCP(available value: 0 - 4). 440 | * @param addr - the IP or domain name of the target host. 441 | * @param port - the port number of the target host. 442 | * @retval true - success. 443 | * @retval false - failure. 444 | */ 445 | bool registerUDP(uint8_t mux_id, String addr, uint32_t port); 446 | 447 | /** 448 | * Unregister UDP port number in multiple mode. 449 | * 450 | * @param mux_id - the identifier of this TCP(available value: 0 - 4). 451 | * @retval true - success. 452 | * @retval false - failure. 453 | */ 454 | bool unregisterUDP(uint8_t mux_id); 455 | 456 | /** 457 | * Set the timeout of TCP Server. 458 | * 459 | * @param timeout - the duration for timeout by second(0 ~ 28800, default:180). 460 | * @retval true - success. 461 | * @retval false - failure. 462 | */ 463 | bool setTCPServerTimeout(uint32_t timeout = 180); 464 | 465 | /** 466 | * Start TCP Server(Only in multiple mode). 467 | * 468 | * After started, user should call method: getIPStatus to know the status of TCP connections. 469 | * The methods of receiving data can be called for user's any purpose. After communication, 470 | * release the TCP connection is needed by calling method: releaseTCP with mux_id. 471 | * 472 | * @param port - the port number to listen(default: 333). 473 | * @retval true - success. 474 | * @retval false - failure. 475 | * 476 | * @see String getIPStatus(void); 477 | * @see uint32_t recv(uint8_t *coming_mux_id, uint8_t *buffer, uint32_t len, uint32_t timeout); 478 | * @see bool releaseTCP(uint8_t mux_id); 479 | */ 480 | bool startTCPServer(uint32_t port = 333); 481 | 482 | /** 483 | * Stop TCP Server(Only in multiple mode). 484 | * 485 | * @retval true - success. 486 | * @retval false - failure. 487 | */ 488 | bool stopTCPServer(void); 489 | 490 | /** 491 | *Set the module transfer mode 492 | * 493 | * @retval true - success. 494 | * @retval false - failure. 495 | */ 496 | bool setCIPMODE(uint8_t mode); 497 | 498 | /** 499 | * Start Server(Only in multiple mode). 500 | * 501 | * @param port - the port number to listen(default: 333). 502 | * @retval true - success. 503 | * @retval false - failure. 504 | * 505 | * @see String getIPStatus(void); 506 | * @see uint32_t recv(uint8_t *coming_mux_id, uint8_t *buffer, uint32_t len, uint32_t timeout); 507 | */ 508 | bool startServer(uint32_t port = 333); 509 | 510 | /** 511 | * Stop Server(Only in multiple mode). 512 | * 513 | * @retval true - success. 514 | * @retval false - failure. 515 | */ 516 | bool stopServer(void); 517 | /** 518 | * Save the passthrough links 519 | * 520 | * @retval true - success. 521 | * @retval false - failure. 522 | */ 523 | bool saveTransLink (uint8_t mode,String ip,uint32_t port); 524 | 525 | /** 526 | * PING COMMAND. 527 | * 528 | * @retval true - success. 529 | * @retval false - failure. 530 | */ 531 | bool setPing(String ip); 532 | 533 | /** 534 | * Send data based on TCP or UDP builded already in single mode. 535 | * 536 | * @param buffer - the buffer of data to send. 537 | * @param len - the length of data to send. 538 | * @retval true - success. 539 | * @retval false - failure. 540 | */ 541 | bool send(const uint8_t *buffer, uint32_t len); 542 | 543 | /** 544 | * Send data based on one of TCP or UDP builded already in multiple mode. 545 | * 546 | * @param mux_id - the identifier of this TCP(available value: 0 - 4). 547 | * @param buffer - the buffer of data to send. 548 | * @param len - the length of data to send. 549 | * @retval true - success. 550 | * @retval false - failure. 551 | */ 552 | bool send(uint8_t mux_id, const uint8_t *buffer, uint32_t len); 553 | 554 | /** 555 | * Send data based on TCP or UDP builded already in single mode. 556 | * 557 | * @param buffer - the buffer of data to send from flash memeory. 558 | * @param len - the length of data to send. 559 | * @retval true - success. 560 | * @retval false - failure. 561 | */ 562 | bool sendFromFlash(const uint8_t *buffer, uint32_t len); 563 | 564 | /** 565 | * Send data based on one of TCP or UDP builded already in multiple mode. 566 | * 567 | * @param mux_id - the identifier of this TCP(available value: 0 - 4). 568 | * @param buffer - the buffer of data to send from flash memeory. 569 | * @param len - the length of data to send. 570 | * @retval true - success. 571 | * @retval false - failure. 572 | */ 573 | bool sendFromFlash(uint8_t mux_id, const uint8_t *buffer, uint32_t len); 574 | 575 | private: 576 | 577 | /* 578 | * Empty the buffer or UART RX. 579 | */ 580 | void rx_empty(void); 581 | 582 | /* 583 | * Recvive data from uart. Return all received data if target found or timeout. 584 | */ 585 | String recvString(String target, uint32_t timeout = 1000); 586 | 587 | /* 588 | * Recvive data from uart. Return all received data if one of target1 and target2 found or timeout. 589 | */ 590 | String recvString(String target1, String target2, uint32_t timeout = 1000); 591 | 592 | /* 593 | * Recvive data from uart. Return all received data if one of target1, target2 and target3 found or timeout. 594 | */ 595 | String recvString(String target1, String target2, String target3, uint32_t timeout = 1000); 596 | 597 | /* 598 | * Recvive data from uart and search first target. Return true if target found, false for timeout. 599 | */ 600 | bool recvFind(String target, uint32_t timeout = 1000); 601 | 602 | /* 603 | * Recvive data from uart and search first target and cut out the substring between begin and end(excluding begin and end self). 604 | * Return true if target found, false for timeout. 605 | */ 606 | bool recvFindAndFilter(String target, String begin, String end, String &data, uint32_t timeout = 1000); 607 | 608 | /* 609 | * Receive a package from uart. 610 | * 611 | * @param buffer - the buffer storing data. 612 | * @param buffer_size - guess what! 613 | * @param data_len - the length of data actually received(maybe more than buffer_size, the remained data will be abandoned). 614 | * @param timeout - the duration waitting data comming. 615 | * @param coming_mux_id - in single connection mode, should be NULL and not NULL in multiple. 616 | */ 617 | uint32_t checkIPD(String& data); 618 | 619 | 620 | bool eAT(void); 621 | bool eATRST(void); 622 | bool eATGMR(String &version); 623 | bool eATGSLP(uint32_t time); 624 | bool eATE(uint8_t mode); 625 | bool eATRESTORE(void); 626 | bool eATSETUART(uint32_t baudrate,uint8_t pattern); 627 | 628 | bool qATCWMODE(uint8_t *mode,uint8_t pattern=3); 629 | bool eATCWMODE(String &list) ; 630 | bool sATCWMODE(uint8_t mode,uint8_t pattern=3); 631 | bool qATCWJAP(String &ssid,uint8_t pattern=3) ; 632 | bool sATCWJAP(String ssid, String pwd,uint8_t pattern=3); 633 | bool eATCWLAP(String &list); 634 | bool eATCWQAP(void); 635 | bool qATCWSAP(String &List,uint8_t pattern=3); 636 | bool sATCWSAP(String ssid, String pwd, uint8_t chl, uint8_t ecn,uint8_t pattern=3); 637 | bool eATCWLIF(String &list); 638 | bool qATCWDHCP(String &List,uint8_t pattern=3); 639 | bool sATCWDHCP(uint8_t mode, uint8_t en, uint8_t pattern=3); 640 | bool eATCWAUTOCONN(uint8_t en); 641 | bool qATCIPSTAMAC(String &mac,uint8_t pattern=3); 642 | bool eATCIPSTAMAC(String mac,uint8_t pattern=3); 643 | bool qATCIPSTAIP(String &ip,uint8_t pattern=3); 644 | bool eATCIPSTAIP(String ip,String gateway,String netmask,uint8_t pattern=3); 645 | bool qATCIPAP(String &ip,uint8_t pattern=3); 646 | bool eATCIPAP(String ip,uint8_t pattern=3); 647 | bool eCWSTARTSMART(uint8_t type); 648 | bool eCWSTOPSMART(void); 649 | 650 | 651 | bool eATCIPSTATUS(String &list); 652 | bool sATCIPSTARTSingle(String type, String addr, uint32_t port); 653 | bool sATCIPSTARTMultiple(uint8_t mux_id, String type, String addr, uint32_t port); 654 | bool sATCIPSENDSingle(const uint8_t *buffer, uint32_t len); 655 | bool sATCIPSENDMultiple(uint8_t mux_id, const uint8_t *buffer, uint32_t len); 656 | bool sATCIPSENDSingleFromFlash(const uint8_t *buffer, uint32_t len); 657 | bool sATCIPSENDMultipleFromFlash(uint8_t mux_id, const uint8_t *buffer, uint32_t len); 658 | bool sATCIPCLOSEMulitple(uint8_t mux_id); 659 | bool eATCIPCLOSESingle(void); 660 | bool eATCIFSR(String &list); 661 | bool sATCIPMUX(uint8_t mode); 662 | bool sATCIPSERVER(uint8_t mode, uint32_t port = 333); 663 | bool sATCIPMODE(uint8_t mode); 664 | bool eATSAVETRANSLINK(uint8_t mode,String ip,uint32_t port); 665 | bool eATPING(String ip); 666 | bool sATCIPSTO(uint32_t timeout); 667 | 668 | /* 669 | * +IPD,len:data 670 | * +IPD,id,len:data 671 | */ 672 | 673 | Stream *m_puart; /* The UART to communicate with ESP8266 */ 674 | onData m_onData; 675 | void* m_onDataPtr; 676 | }; 677 | 678 | #endif /* #ifndef __ESP8266_H__ */ 679 | 680 | -------------------------------------------------------------------------------- /ESP8266.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * @file ESP8266.cpp 3 | * @brief The implementation of class ESP8266. 4 | * @author Wu Pengfei 5 | * @date 2015.02 6 | * 7 | * @par Copyright: 8 | * Copyright (c) 2015 ITEAD Intelligent Systems Co., Ltd. \n\n 9 | * This program is free software; you can redistribute it and/or 10 | * modify it under the terms of the GNU General Public License as 11 | * published by the Free Software Foundation; either version 2 of 12 | * the License, or (at your option) any later version. \n\n 13 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 14 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 15 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 16 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 17 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 18 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 19 | * THE SOFTWARE. 20 | */ 21 | #include "ESP8266_Lib.h" 22 | #include 23 | 24 | ESP8266::ESP8266(Stream *uart) 25 | : m_puart(uart) 26 | { 27 | m_onData = NULL; 28 | m_onDataPtr = NULL; 29 | } 30 | 31 | bool ESP8266::kick(void) 32 | { 33 | return eAT(); 34 | } 35 | 36 | bool ESP8266::restart(void) 37 | { 38 | unsigned long start; 39 | if (eATRST()) { 40 | delay(2000); 41 | start = millis(); 42 | while (millis() - start < 3000) { 43 | if (eAT()) { 44 | delay(1500); /* Waiting for stable */ 45 | return true; 46 | } 47 | delay(100); 48 | } 49 | } 50 | return false; 51 | } 52 | 53 | String ESP8266::getVersion(void) 54 | { 55 | String version; 56 | eATGMR(version); 57 | return version; 58 | } 59 | 60 | bool ESP8266::setEcho(uint8_t mode) 61 | { 62 | return eATE(mode); 63 | } 64 | 65 | bool ESP8266::restore(void) 66 | { 67 | return eATRESTORE(); 68 | } 69 | bool ESP8266::setUart(uint32_t baudrate,uint8_t pattern) 70 | { 71 | return eATSETUART(baudrate,pattern); 72 | } 73 | 74 | bool ESP8266::deepSleep(uint32_t time) 75 | { 76 | return eATGSLP(time); 77 | } 78 | 79 | 80 | bool ESP8266::setOprToStation(uint8_t pattern1,uint8_t pattern2) 81 | { 82 | uint8_t mode; 83 | if (!qATCWMODE(&mode,pattern1)) { 84 | return false; 85 | } 86 | if (mode == 1) { 87 | return true; 88 | } else { 89 | if (sATCWMODE(1,pattern2)){ 90 | return true; 91 | } else { 92 | return false; 93 | } 94 | } 95 | } 96 | String ESP8266::getWifiModeList(void) 97 | { 98 | String list; 99 | eATCWMODE(list); 100 | return list; 101 | } 102 | bool ESP8266::setOprToSoftAP(uint8_t pattern1,uint8_t pattern2) 103 | { 104 | uint8_t mode; 105 | if (!qATCWMODE(&mode,pattern1)) { 106 | return false; 107 | } 108 | if (mode == 2) { 109 | return true; 110 | } else { 111 | if (sATCWMODE(2,pattern2) ){ 112 | return true; 113 | } else { 114 | return false; 115 | } 116 | } 117 | } 118 | 119 | bool ESP8266::setOprToStationSoftAP(uint8_t pattern1,uint8_t pattern2) 120 | { 121 | uint8_t mode; 122 | if (!qATCWMODE(&mode,pattern1)) { 123 | return false; 124 | } 125 | if (mode == 3) { 126 | return true; 127 | } else { 128 | if (sATCWMODE(3,pattern2) ){ 129 | return true; 130 | } else { 131 | return false; 132 | } 133 | } 134 | } 135 | 136 | uint8_t ESP8266::getOprMode(uint8_t pattern1) 137 | { 138 | uint8_t mode; 139 | if (!qATCWMODE(&mode,pattern1)) { 140 | return 0; 141 | } else { 142 | return mode; 143 | } 144 | } 145 | 146 | String ESP8266::getNowConecAp(uint8_t pattern) 147 | { 148 | String ssid; 149 | qATCWJAP(ssid,pattern); 150 | return ssid; 151 | } 152 | 153 | 154 | String ESP8266::getAPList(void) 155 | { 156 | String list; 157 | eATCWLAP(list); 158 | return list; 159 | } 160 | 161 | bool ESP8266::joinAP(String ssid, String pwd,uint8_t pattern) 162 | { 163 | return sATCWJAP(ssid, pwd,pattern); 164 | } 165 | 166 | bool ESP8266::leaveAP(void) 167 | { 168 | return eATCWQAP(); 169 | } 170 | 171 | String ESP8266::getSoftAPParam(uint8_t pattern) 172 | { 173 | String list; 174 | qATCWSAP(list,pattern); 175 | return list; 176 | } 177 | 178 | 179 | 180 | bool ESP8266::setSoftAPParam(String ssid, String pwd, uint8_t chl, uint8_t ecn,uint8_t pattern) 181 | { 182 | return sATCWSAP(ssid, pwd, chl, ecn,pattern); 183 | } 184 | 185 | String ESP8266::getJoinedDeviceIP(void) 186 | { 187 | String list; 188 | eATCWLIF(list); 189 | return list; 190 | } 191 | 192 | String ESP8266::getDHCP(uint8_t pattern) 193 | { 194 | String dhcp; 195 | qATCWDHCP(dhcp,pattern); 196 | return dhcp; 197 | } 198 | bool ESP8266::setDHCP(uint8_t mode, uint8_t en, uint8_t pattern) 199 | { 200 | return sATCWDHCP(mode, en, pattern); 201 | } 202 | 203 | bool ESP8266::setAutoConnect(uint8_t en) 204 | { 205 | return eATCWAUTOCONN(en); 206 | } 207 | String ESP8266::getStationMac(uint8_t pattern) 208 | { 209 | String mac; 210 | qATCIPSTAMAC(mac,pattern); 211 | return mac; 212 | } 213 | 214 | 215 | bool ESP8266::setStationMac(String mac,uint8_t pattern) 216 | { 217 | return eATCIPSTAMAC(mac,pattern); 218 | } 219 | 220 | String ESP8266::getStationIp(uint8_t pattern) 221 | { 222 | String ip; 223 | qATCIPSTAIP(ip,pattern); 224 | return ip; 225 | } 226 | 227 | bool ESP8266::setStationIp(String ip,String gateway,String netmask,uint8_t pattern) 228 | { 229 | return eATCIPSTAIP(ip,gateway,netmask,pattern); 230 | } 231 | 232 | String ESP8266::getAPIp(uint8_t pattern) 233 | { 234 | String ip; 235 | qATCIPAP(ip,pattern); 236 | return ip; 237 | } 238 | 239 | bool ESP8266::setAPIp(String ip,uint8_t pattern) 240 | { 241 | return eATCIPAP(ip,pattern); 242 | } 243 | 244 | bool ESP8266::startSmartConfig(uint8_t type) 245 | { 246 | return eCWSTARTSMART(type); 247 | } 248 | 249 | bool ESP8266::stopSmartConfig(void) 250 | { 251 | return eCWSTOPSMART(); 252 | } 253 | 254 | 255 | 256 | 257 | String ESP8266::getIPStatus(void) 258 | { 259 | String list; 260 | eATCIPSTATUS(list); 261 | return list; 262 | } 263 | 264 | String ESP8266::getLocalIP(void) 265 | { 266 | String list; 267 | eATCIFSR(list); 268 | return list; 269 | } 270 | 271 | bool ESP8266::enableMUX(void) 272 | { 273 | return sATCIPMUX(1); 274 | } 275 | 276 | bool ESP8266::disableMUX(void) 277 | { 278 | return sATCIPMUX(0); 279 | } 280 | 281 | bool ESP8266::createTCP(String addr, uint32_t port) 282 | { 283 | return sATCIPSTARTSingle("TCP", addr, port); 284 | } 285 | 286 | bool ESP8266::releaseTCP(void) 287 | { 288 | return eATCIPCLOSESingle(); 289 | } 290 | 291 | bool ESP8266::registerUDP(String addr, uint32_t port) 292 | { 293 | return sATCIPSTARTSingle("UDP", addr, port); 294 | } 295 | 296 | bool ESP8266::unregisterUDP(void) 297 | { 298 | return eATCIPCLOSESingle(); 299 | } 300 | 301 | bool ESP8266::createTCP(uint8_t mux_id, String addr, uint32_t port) 302 | { 303 | return sATCIPSTARTMultiple(mux_id, "TCP", addr, port); 304 | } 305 | 306 | bool ESP8266::releaseTCP(uint8_t mux_id) 307 | { 308 | return sATCIPCLOSEMulitple(mux_id); 309 | } 310 | 311 | bool ESP8266::registerUDP(uint8_t mux_id, String addr, uint32_t port) 312 | { 313 | return sATCIPSTARTMultiple(mux_id, "UDP", addr, port); 314 | } 315 | 316 | bool ESP8266::unregisterUDP(uint8_t mux_id) 317 | { 318 | return sATCIPCLOSEMulitple(mux_id); 319 | } 320 | 321 | bool ESP8266::setTCPServerTimeout(uint32_t timeout) 322 | { 323 | return sATCIPSTO(timeout); 324 | } 325 | 326 | bool ESP8266::startTCPServer(uint32_t port) 327 | { 328 | if (sATCIPSERVER(1, port)) { 329 | return true; 330 | } 331 | return false; 332 | } 333 | 334 | bool ESP8266::stopTCPServer(void) 335 | { 336 | sATCIPSERVER(0); 337 | restart(); 338 | return false; 339 | } 340 | 341 | bool ESP8266::setCIPMODE(uint8_t mode) 342 | { 343 | return sATCIPMODE(mode); 344 | } 345 | 346 | bool ESP8266::saveTransLink (uint8_t mode,String ip,uint32_t port) 347 | { 348 | return eATSAVETRANSLINK(mode,ip,port); 349 | } 350 | 351 | bool ESP8266::setPing(String ip) 352 | { 353 | return eATPING(ip); 354 | } 355 | 356 | 357 | 358 | 359 | bool ESP8266::startServer(uint32_t port) 360 | { 361 | return startTCPServer(port); 362 | } 363 | 364 | bool ESP8266::stopServer(void) 365 | { 366 | return stopTCPServer(); 367 | } 368 | 369 | bool ESP8266::send(const uint8_t *buffer, uint32_t len) 370 | { 371 | return sATCIPSENDSingle(buffer, len); 372 | } 373 | 374 | bool ESP8266::sendFromFlash(uint8_t mux_id, const uint8_t *buffer, uint32_t len) 375 | { 376 | return sATCIPSENDMultipleFromFlash(mux_id, buffer, len); 377 | } 378 | 379 | bool ESP8266::sendFromFlash(const uint8_t *buffer, uint32_t len) 380 | { 381 | return sATCIPSENDSingleFromFlash(buffer, len); 382 | } 383 | 384 | bool ESP8266::send(uint8_t mux_id, const uint8_t *buffer, uint32_t len) 385 | { 386 | return sATCIPSENDMultiple(mux_id, buffer, len); 387 | } 388 | 389 | void ESP8266::run() 390 | { 391 | rx_empty(); 392 | } 393 | 394 | /*----------------------------------------------------------------------------*/ 395 | /* +IPD,,: */ 396 | /* +IPD,: */ 397 | 398 | uint32_t ESP8266::checkIPD(String& data) 399 | { 400 | //Serial.print("### check: "); 401 | //Serial.println(data); 402 | 403 | int32_t index_PIPDcomma = -1; 404 | int32_t index_colon = -1; /* : */ 405 | int32_t index_comma = -1; /* , */ 406 | int32_t len = -1; 407 | int8_t id = -1; 408 | { // Just for easier diffing 409 | index_PIPDcomma = data.indexOf("+IPD,"); 410 | if (index_PIPDcomma != -1) { 411 | index_colon = data.indexOf(':', index_PIPDcomma + 5); 412 | if (index_colon != -1) { 413 | index_comma = data.indexOf(',', index_PIPDcomma + 5); 414 | /* +IPD,id,len:data */ 415 | if (index_comma != -1 && index_comma < index_colon) { 416 | id = data.substring(index_PIPDcomma + 5, index_comma).toInt(); 417 | if (id < 0 || id > 4) { 418 | return 0; 419 | } 420 | len = data.substring(index_comma + 1, index_colon).toInt(); 421 | if (len <= 0) { 422 | return 0; 423 | } 424 | } else { /* +IPD,len:data */ 425 | len = data.substring(index_PIPDcomma + 5, index_colon).toInt(); 426 | if (len <= 0) { 427 | return 0; 428 | } 429 | } 430 | if (m_onData) { 431 | m_onData(id, len, m_onDataPtr); 432 | } 433 | return len; 434 | } 435 | } 436 | } 437 | return 0; 438 | } 439 | 440 | void ESP8266::rx_empty(void) 441 | { 442 | String data; 443 | char a; 444 | unsigned long start = millis(); 445 | while (millis() - start < 10) { 446 | if (m_puart->available()) { 447 | a = m_puart->read(); 448 | if(a == '\0') continue; 449 | data += a; 450 | if (checkIPD(data)) { 451 | data = ""; 452 | } 453 | start = millis(); 454 | } 455 | } 456 | } 457 | 458 | String ESP8266::recvString(String target, uint32_t timeout) 459 | { 460 | String data; 461 | char a; 462 | unsigned long start = millis(); 463 | while (millis() - start < timeout) { 464 | while(m_puart->available() > 0) { 465 | a = m_puart->read(); 466 | if(a == '\0') continue; 467 | data += a; 468 | if (data.indexOf(target) != -1) { 469 | return data; 470 | } else if (checkIPD(data)) { 471 | data = ""; 472 | } 473 | } 474 | } 475 | 476 | return data; 477 | } 478 | 479 | String ESP8266::recvString(String target1, String target2, uint32_t timeout) 480 | { 481 | String data; 482 | char a; 483 | unsigned long start = millis(); 484 | while (millis() - start < timeout) { 485 | while(m_puart->available() > 0) { 486 | a = m_puart->read(); 487 | if(a == '\0') continue; 488 | data += a; 489 | if (data.indexOf(target1) != -1) { 490 | return data; 491 | } else if (data.indexOf(target2) != -1) { 492 | return data; 493 | } else if (checkIPD(data)) { 494 | data = ""; 495 | } 496 | } 497 | } 498 | return data; 499 | } 500 | 501 | String ESP8266::recvString(String target1, String target2, String target3, uint32_t timeout) 502 | { 503 | String data; 504 | char a; 505 | unsigned long start = millis(); 506 | while (millis() - start < timeout) { 507 | while(m_puart->available() > 0) { 508 | a = m_puart->read(); 509 | if(a == '\0') continue; 510 | data += a; 511 | 512 | if (data.indexOf(target1) != -1) { 513 | return data; 514 | } else if (data.indexOf(target2) != -1) { 515 | return data; 516 | } else if (data.indexOf(target3) != -1) { 517 | return data; 518 | } else if (checkIPD(data)) { 519 | data = ""; 520 | } 521 | } 522 | } 523 | return data; 524 | } 525 | 526 | bool ESP8266::recvFind(String target, uint32_t timeout) 527 | { 528 | String data_tmp; 529 | data_tmp = recvString(target, timeout); 530 | if (data_tmp.indexOf(target) != -1) { 531 | return true; 532 | } 533 | return false; 534 | } 535 | 536 | bool ESP8266::recvFindAndFilter(String target, String begin, String end, String &data, uint32_t timeout) 537 | { 538 | String data_tmp; 539 | data_tmp = recvString(target, timeout); 540 | if (data_tmp.indexOf(target) != -1) { 541 | int32_t index1 = data_tmp.indexOf(begin); 542 | int32_t index2 = data_tmp.indexOf(end); 543 | if (index1 != -1 && index2 != -1) { 544 | index1 += begin.length(); 545 | data = data_tmp.substring(index1, index2); 546 | return true; 547 | } else if (index2 != -1) { 548 | data = data_tmp.substring(0, index2); 549 | return true; 550 | } 551 | index1 = data.indexOf("\r\n\r\nOK"); 552 | if (index1 != -1) { 553 | data = data_tmp.substring(0, index1); 554 | } 555 | index1 = data.indexOf("\r\nOK"); 556 | if (index1 != -1) { 557 | data = data_tmp.substring(0, index1); 558 | } 559 | } 560 | 561 | data = data_tmp; 562 | return false; 563 | } 564 | 565 | bool ESP8266::eAT(void) 566 | { 567 | rx_empty(); 568 | m_puart->println(F("AT")); 569 | return recvFind("OK"); 570 | } 571 | 572 | bool ESP8266::eATRST(void) 573 | { 574 | rx_empty(); 575 | m_puart->println(F("AT+RST")); 576 | return recvFind("OK"); 577 | } 578 | 579 | bool ESP8266::eATGMR(String &version) 580 | { 581 | rx_empty(); 582 | delay(3000); 583 | m_puart->println(F("AT+GMR")); 584 | return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", version,10000); 585 | } 586 | 587 | bool ESP8266::eATGSLP(uint32_t time) 588 | { 589 | rx_empty(); 590 | m_puart->print(F("AT+GSLP=")); 591 | m_puart->println(time); 592 | return recvFind("OK"); 593 | } 594 | 595 | 596 | bool ESP8266::eATE(uint8_t mode) 597 | { 598 | rx_empty(); 599 | m_puart->print(F("ATE")); 600 | m_puart->println(mode); 601 | return recvFind("OK"); 602 | } 603 | 604 | bool ESP8266::eATRESTORE(void) 605 | { 606 | rx_empty(); 607 | m_puart->println(F("AT+RESTORE")); 608 | return recvFind("OK"); 609 | } 610 | 611 | 612 | bool ESP8266::eATSETUART(uint32_t baudrate,uint8_t pattern) 613 | { 614 | rx_empty(); 615 | if(pattern>3||pattern<1){ 616 | return false; 617 | } 618 | switch(pattern){ 619 | case 1: 620 | m_puart->print(F("AT+UART=")); 621 | break; 622 | case 2: 623 | m_puart->print(F("AT+UART_CUR=")); 624 | break; 625 | case 3: 626 | m_puart->print(F("AT+UART_DEF=")); 627 | break; 628 | } 629 | m_puart->print(baudrate); 630 | m_puart->print(F(",")); 631 | m_puart->print(8); 632 | m_puart->print(F(",")); 633 | m_puart->print(1); 634 | m_puart->print(F(",")); 635 | m_puart->print(0); 636 | m_puart->print(F(",")); 637 | m_puart->println(0); 638 | if(recvFind("OK",5000)){ 639 | return true; 640 | } 641 | else{ 642 | return false; 643 | } 644 | 645 | } 646 | 647 | 648 | bool ESP8266::qATCWMODE(uint8_t *mode,uint8_t pattern) 649 | { 650 | String str_mode; 651 | bool ret; 652 | if (!mode||!pattern) { 653 | return false; 654 | } 655 | rx_empty(); 656 | switch(pattern) 657 | { 658 | case 1 : 659 | m_puart->println(F("AT+CWMODE_DEF?")); 660 | break; 661 | case 2: 662 | m_puart->println(F("AT+CWMODE_CUR?")); 663 | break; 664 | default: 665 | m_puart->println(F("AT+CWMODE?")); 666 | } 667 | ret = recvFindAndFilter("OK", ":", "\r\n\r\nOK", str_mode); 668 | if (ret) { 669 | *mode = (uint8_t)str_mode.toInt(); 670 | return true; 671 | } else { 672 | return false; 673 | } 674 | } 675 | bool ESP8266::eATCWMODE(String &list) 676 | { 677 | rx_empty(); 678 | m_puart->println(F("AT+CWMODE=?")); 679 | return recvFindAndFilter("OK", "+CWMODE:(", ")\r\n\r\nOK", list); 680 | } 681 | 682 | bool ESP8266::sATCWMODE(uint8_t mode,uint8_t pattern) 683 | { 684 | if(!pattern){ 685 | return false; 686 | } 687 | String data; 688 | rx_empty(); 689 | switch(pattern) 690 | { 691 | case 1 : 692 | m_puart->print(F("AT+CWMODE_DEF=")); 693 | break; 694 | case 2: 695 | m_puart->print(F("AT+CWMODE_CUR=")); 696 | break; 697 | default: 698 | m_puart->print(F("AT+CWMODE=")); 699 | } 700 | m_puart->println(mode); 701 | data = recvString("OK", "no change"); 702 | 703 | if (data.indexOf("OK") != -1 || data.indexOf("no change") != -1) { 704 | return true; 705 | } 706 | return false; 707 | } 708 | 709 | 710 | bool ESP8266::qATCWJAP(String &ssid,uint8_t pattern) 711 | { 712 | 713 | bool ret; 714 | if (!pattern) { 715 | return false; 716 | } 717 | rx_empty(); 718 | switch(pattern) 719 | { 720 | case 1 : 721 | m_puart->println(F("AT+CWJAP_DEF?")); 722 | break; 723 | case 2: 724 | m_puart->println(F("AT+CWJAP_CUR?")); 725 | break; 726 | default: 727 | m_puart->println(F("AT+CWJAP?")); 728 | } 729 | ssid = recvString("OK", "No AP"); 730 | if (ssid.indexOf("OK") != -1 || ssid.indexOf("No AP") != -1) { 731 | return true; 732 | } 733 | return false; 734 | 735 | } 736 | 737 | bool ESP8266::sATCWJAP(String ssid, String pwd,uint8_t pattern) 738 | { 739 | String data; 740 | if (!pattern) { 741 | return false; 742 | } 743 | rx_empty(); 744 | switch(pattern) 745 | { 746 | case 1 : 747 | m_puart->print(F("AT+CWJAP_DEF=\"")); 748 | 749 | break; 750 | case 2: 751 | m_puart->print(F("AT+CWJAP_CUR=\"")); 752 | break; 753 | default: 754 | m_puart->print(F("AT+CWJAP=\"")); 755 | } 756 | 757 | m_puart->print(ssid); 758 | m_puart->print(F("\",\"")); 759 | m_puart->print(pwd); 760 | m_puart->println(F("\"")); 761 | 762 | data = recvString("OK", "FAIL", 10000); 763 | if (data.indexOf("OK") != -1) { 764 | return true; 765 | } 766 | return false; 767 | } 768 | 769 | bool ESP8266::eATCWLAP(String &list) 770 | { 771 | String data; 772 | rx_empty(); 773 | m_puart->println(F("AT+CWLAP")); 774 | return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list, 15000); 775 | } 776 | 777 | 778 | 779 | 780 | bool ESP8266::eATCWQAP(void) 781 | { 782 | String data; 783 | rx_empty(); 784 | m_puart->println(F("AT+CWQAP")); 785 | return recvFind("OK"); 786 | } 787 | 788 | 789 | bool ESP8266::qATCWSAP(String &List,uint8_t pattern) 790 | { 791 | if (!pattern) { 792 | return false; 793 | } 794 | rx_empty(); 795 | switch(pattern) 796 | { 797 | case 1 : 798 | m_puart->println(F("AT+CWSAP_DEF?")); 799 | 800 | break; 801 | case 2: 802 | m_puart->println(F("AT+CWSAP_CUR?")); 803 | break; 804 | default: 805 | m_puart->println(F("AT+CWSAP?")); 806 | } 807 | return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", List,10000); 808 | 809 | } 810 | 811 | bool ESP8266::sATCWSAP(String ssid, String pwd, uint8_t chl, uint8_t ecn,uint8_t pattern) 812 | { 813 | String data; 814 | if (!pattern) { 815 | return false; 816 | } 817 | rx_empty(); 818 | switch(pattern){ 819 | case 1 : 820 | m_puart->print(F("AT+CWSAP_DEF=\"")); 821 | 822 | break; 823 | case 2: 824 | m_puart->print(F("AT+CWSAP_CUR=\"")); 825 | break; 826 | default: 827 | m_puart->print(F("AT+CWSAP=\"")); 828 | 829 | } 830 | m_puart->print(ssid); 831 | m_puart->print(F("\",\"")); 832 | m_puart->print(pwd); 833 | m_puart->print(F("\",")); 834 | m_puart->print(chl); 835 | m_puart->print(F(",")); 836 | m_puart->println(ecn); 837 | 838 | data = recvString("OK", "ERROR", 5000); 839 | if (data.indexOf("OK") != -1) { 840 | return true; 841 | } 842 | return false; 843 | } 844 | 845 | bool ESP8266::eATCWLIF(String &list) 846 | { 847 | String data; 848 | rx_empty(); 849 | m_puart->println(F("AT+CWLIF")); 850 | return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list); 851 | } 852 | 853 | bool ESP8266::qATCWDHCP(String &List,uint8_t pattern) 854 | { 855 | if (!pattern) { 856 | return false; 857 | } 858 | rx_empty(); 859 | switch(pattern) 860 | { 861 | case 1 : 862 | m_puart->println(F("AT+CWDHCP_DEF?")); 863 | break; 864 | case 2: 865 | m_puart->println(F("AT+CWDHCP_CUR?")); 866 | break; 867 | default: 868 | m_puart->println(F("AT+CWDHCP?")); 869 | } 870 | 871 | return recvFindAndFilter("OK", "\r\r\n", "\r\nOK", List,10000); 872 | 873 | } 874 | 875 | 876 | bool ESP8266::sATCWDHCP(uint8_t mode, uint8_t en, uint8_t pattern) 877 | { 878 | String data; 879 | if (!pattern) { 880 | return false; 881 | } 882 | rx_empty(); 883 | switch(pattern){ 884 | case 1 : 885 | m_puart->print(F("AT+CWDHCP_DEF=")); 886 | 887 | break; 888 | case 2: 889 | m_puart->print(F("AT+CWDHCP_CUR=")); 890 | break; 891 | default: 892 | m_puart->print(F("AT+CWDHCP=")); 893 | 894 | } 895 | m_puart->print(mode); 896 | m_puart->print(F(",")); 897 | m_puart->println(en); 898 | data = recvString("OK", "ERROR", 2000); 899 | 900 | if (data.indexOf("OK") != -1) { 901 | return true; 902 | } 903 | return false; 904 | } 905 | 906 | 907 | bool ESP8266::eATCWAUTOCONN(uint8_t en) 908 | { 909 | 910 | rx_empty(); 911 | if(en>1||en<0){ 912 | return false; 913 | } 914 | m_puart->print(F("AT+CWAUTOCONN=")); 915 | m_puart->println(en); 916 | return recvFind("OK"); 917 | 918 | } 919 | 920 | bool ESP8266::qATCIPSTAMAC(String &mac,uint8_t pattern) 921 | { 922 | 923 | rx_empty(); 924 | if (!pattern) { 925 | return false; 926 | } 927 | switch(pattern){ 928 | case 1 : 929 | m_puart->println(F("AT+CIPSTAMAC_DEF?")); 930 | 931 | break; 932 | case 2: 933 | m_puart->println(F("AT+CIPSTAMAC_CUR?")); 934 | break; 935 | default: 936 | m_puart->println(F("AT+CIPSTAMAC?")); 937 | 938 | } 939 | return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", mac,2000); 940 | 941 | } 942 | 943 | 944 | 945 | bool ESP8266::eATCIPSTAMAC(String mac,uint8_t pattern) 946 | { 947 | 948 | rx_empty(); 949 | if (!pattern) { 950 | return false; 951 | } 952 | switch(pattern){ 953 | case 1 : 954 | m_puart->print(F("AT+CIPSTAMAC_DEF=")); 955 | 956 | break; 957 | case 2: 958 | m_puart->print(F("AT+CIPSTAMAC_CUR=")); 959 | break; 960 | default: 961 | m_puart->print(F("AT+CIPSTAMAC=")); 962 | 963 | } 964 | m_puart->print(F("\"")); 965 | m_puart->print(mac); 966 | m_puart->println(F("\"")); 967 | return recvFind("OK"); 968 | 969 | } 970 | 971 | bool ESP8266::qATCIPSTAIP(String &ip,uint8_t pattern) 972 | { 973 | 974 | rx_empty(); 975 | if (!pattern) { 976 | return false; 977 | } 978 | switch(pattern){ 979 | case 1 : 980 | m_puart->println(F("AT+CIPSTA_DEF?")); 981 | 982 | break; 983 | case 2: 984 | m_puart->println(F("AT+CIPSTA_CUR?")); 985 | break; 986 | default: 987 | m_puart->println(F("AT+CIPSTA?")); 988 | 989 | } 990 | return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", ip,2000); 991 | 992 | } 993 | 994 | bool ESP8266::eATCIPSTAIP(String ip,String gateway,String netmask,uint8_t pattern) 995 | { 996 | 997 | rx_empty(); 998 | if (!pattern) { 999 | return false; 1000 | } 1001 | switch(pattern){ 1002 | case 1 : 1003 | m_puart->print(F("AT+CIPSTA_DEF=")); 1004 | 1005 | break; 1006 | case 2: 1007 | m_puart->print(F("AT+CIPSTA_CUR=")); 1008 | break; 1009 | default: 1010 | m_puart->print(F("AT+CIPSTA=")); 1011 | 1012 | } 1013 | m_puart->print(F("\"")); 1014 | m_puart->print(ip); 1015 | m_puart->print(F("\",\"")); 1016 | m_puart->print(gateway); 1017 | m_puart->print(F("\",\"")); 1018 | m_puart->print(netmask); 1019 | m_puart->println(F("\"")); 1020 | return recvFind("OK"); 1021 | 1022 | } 1023 | 1024 | 1025 | bool ESP8266::qATCIPAP(String &ip,uint8_t pattern) 1026 | { 1027 | 1028 | rx_empty(); 1029 | if (!pattern) { 1030 | return false; 1031 | } 1032 | switch(pattern){ 1033 | case 1 : 1034 | m_puart->println(F("AT+CIPAP_DEF?")); 1035 | 1036 | break; 1037 | case 2: 1038 | m_puart->println(F("AT+CIPAP_CUR?")); 1039 | break; 1040 | default: 1041 | m_puart->println(F("AT+CIPAP?")); 1042 | 1043 | } 1044 | return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", ip,2000); 1045 | 1046 | } 1047 | 1048 | 1049 | bool ESP8266::eATCIPAP(String ip,uint8_t pattern) 1050 | { 1051 | 1052 | rx_empty(); 1053 | if (!pattern) { 1054 | return false; 1055 | } 1056 | switch(pattern){ 1057 | case 1 : 1058 | m_puart->print(F("AT+CIPAP_DEF=")); 1059 | 1060 | break; 1061 | case 2: 1062 | m_puart->print(F("AT+CIPAP_CUR=")); 1063 | break; 1064 | default: 1065 | m_puart->print(F("AT+CIPAP=")); 1066 | 1067 | } 1068 | m_puart->print(F("\"")); 1069 | m_puart->print(ip); 1070 | m_puart->println(F("\"")); 1071 | return recvFind("OK"); 1072 | 1073 | } 1074 | 1075 | 1076 | bool ESP8266::eCWSTARTSMART(uint8_t type) 1077 | { 1078 | rx_empty(); 1079 | m_puart->print(F("AT+CWSTARTSMART=")); 1080 | m_puart->println(type); 1081 | return recvFind("OK"); 1082 | } 1083 | 1084 | bool ESP8266::eCWSTOPSMART(void) 1085 | { 1086 | rx_empty(); 1087 | m_puart->println(F("AT+CWSTOPSMART")); 1088 | return recvFind("OK"); 1089 | } 1090 | 1091 | bool ESP8266::eATCIPSTATUS(String &list) 1092 | { 1093 | String data; 1094 | delay(100); 1095 | rx_empty(); 1096 | m_puart->println(F("AT+CIPSTATUS")); 1097 | return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list); 1098 | } 1099 | bool ESP8266::sATCIPSTARTSingle(String type, String addr, uint32_t port) 1100 | { 1101 | String data; 1102 | rx_empty(); 1103 | m_puart->print(F("AT+CIPSTART=\"")); 1104 | m_puart->print(type); 1105 | m_puart->print(F("\",\"")); 1106 | m_puart->print(addr); 1107 | m_puart->print(F("\",")); 1108 | m_puart->println(port); 1109 | 1110 | data = recvString("OK", "ERROR", "ALREADY CONNECT", 10000); 1111 | if (data.indexOf("OK") != -1 || data.indexOf("ALREADY CONNECT") != -1) { 1112 | return true; 1113 | } 1114 | return false; 1115 | } 1116 | bool ESP8266::sATCIPSTARTMultiple(uint8_t mux_id, String type, String addr, uint32_t port) 1117 | { 1118 | String data; 1119 | rx_empty(); 1120 | m_puart->print(F("AT+CIPSTART=")); 1121 | m_puart->print(mux_id); 1122 | m_puart->print(F(",\"")); 1123 | m_puart->print(type); 1124 | m_puart->print(F("\",\"")); 1125 | m_puart->print(addr); 1126 | m_puart->print(F("\",")); 1127 | m_puart->println(port); 1128 | 1129 | data = recvString("OK", "ERROR", "ALREADY CONNECT", 10000); 1130 | if (data.indexOf("OK") != -1 || data.indexOf("ALREADY CONNECT") != -1) { 1131 | return true; 1132 | } 1133 | return false; 1134 | } 1135 | bool ESP8266::sATCIPSENDSingle(const uint8_t *buffer, uint32_t len) 1136 | { 1137 | rx_empty(); 1138 | m_puart->print(F("AT+CIPSEND=")); 1139 | m_puart->println(len); 1140 | if (recvFind(">", 5000)) { 1141 | rx_empty(); 1142 | for (uint32_t i = 0; i < len; i++) { 1143 | m_puart->write(buffer[i]); 1144 | } 1145 | return recvFind("SEND OK", 10000); 1146 | } 1147 | return false; 1148 | } 1149 | bool ESP8266::sATCIPSENDMultiple(uint8_t mux_id, const uint8_t *buffer, uint32_t len) 1150 | { 1151 | rx_empty(); 1152 | m_puart->print(F("AT+CIPSEND=")); 1153 | m_puart->print(mux_id); 1154 | m_puart->print(F(",")); 1155 | m_puart->println(len); 1156 | if (recvFind(">", 5000)) { 1157 | rx_empty(); 1158 | for (uint32_t i = 0; i < len; i++) { 1159 | m_puart->write(buffer[i]); 1160 | } 1161 | return recvFind("SEND OK", 10000); 1162 | } 1163 | return false; 1164 | } 1165 | bool ESP8266::sATCIPSENDSingleFromFlash(const uint8_t *buffer, uint32_t len) 1166 | { 1167 | rx_empty(); 1168 | m_puart->print(F("AT+CIPSEND=")); 1169 | m_puart->println(len); 1170 | if (recvFind(">", 5000)) { 1171 | rx_empty(); 1172 | for (uint32_t i = 0; i < len; i++) { 1173 | m_puart->write((char) pgm_read_byte(&buffer[i])); 1174 | } 1175 | return recvFind("SEND OK", 10000); 1176 | } 1177 | return false; 1178 | } 1179 | bool ESP8266::sATCIPSENDMultipleFromFlash(uint8_t mux_id, const uint8_t *buffer, uint32_t len) 1180 | { 1181 | rx_empty(); 1182 | m_puart->print(F("AT+CIPSEND=")); 1183 | m_puart->print(mux_id); 1184 | m_puart->print(F(",")); 1185 | m_puart->println(len); 1186 | if (recvFind(">", 5000)) { 1187 | rx_empty(); 1188 | for (uint32_t i = 0; i < len; i++) { 1189 | m_puart->write((char) pgm_read_byte(&buffer[i])); 1190 | } 1191 | return recvFind("SEND OK", 10000); 1192 | } 1193 | return false; 1194 | } 1195 | bool ESP8266::sATCIPCLOSEMulitple(uint8_t mux_id) 1196 | { 1197 | String data; 1198 | rx_empty(); 1199 | m_puart->print(F("AT+CIPCLOSE=")); 1200 | m_puart->println(mux_id); 1201 | 1202 | data = recvString("OK", "link is not", 5000); 1203 | if (data.indexOf("OK") != -1 || data.indexOf("link is not") != -1) { 1204 | return true; 1205 | } 1206 | return false; 1207 | } 1208 | bool ESP8266::eATCIPCLOSESingle(void) 1209 | { 1210 | rx_empty(); 1211 | m_puart->println(F("AT+CIPCLOSE")); 1212 | return recvFind("OK", 5000); 1213 | } 1214 | bool ESP8266::eATCIFSR(String &list) 1215 | { 1216 | rx_empty(); 1217 | m_puart->println(F("AT+CIFSR")); 1218 | return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list); 1219 | } 1220 | bool ESP8266::sATCIPMUX(uint8_t mode) 1221 | { 1222 | String data; 1223 | rx_empty(); 1224 | m_puart->print(F("AT+CIPMUX=")); 1225 | m_puart->println(mode); 1226 | 1227 | data = recvString("OK", "Link is builded"); 1228 | if (data.indexOf("OK") != -1) { 1229 | return true; 1230 | } 1231 | return false; 1232 | } 1233 | bool ESP8266::sATCIPSERVER(uint8_t mode, uint32_t port) 1234 | { 1235 | String data; 1236 | if (mode) { 1237 | rx_empty(); 1238 | m_puart->print(F("AT+CIPSERVER=1,")); 1239 | m_puart->println(port); 1240 | 1241 | data = recvString("OK", "no change"); 1242 | if (data.indexOf("OK") != -1 || data.indexOf("no change") != -1) { 1243 | return true; 1244 | } 1245 | return false; 1246 | } else { 1247 | rx_empty(); 1248 | m_puart->println(F("AT+CIPSERVER=0")); 1249 | return recvFind("\r\r\n"); 1250 | } 1251 | } 1252 | 1253 | 1254 | bool ESP8266::sATCIPMODE(uint8_t mode) 1255 | { 1256 | String data; 1257 | if(mode>1||mode<0){ 1258 | return false; 1259 | } 1260 | rx_empty(); 1261 | m_puart->print(F("AT+CIPMODE=")); 1262 | m_puart->println(mode); 1263 | 1264 | data = recvString("OK", "Link is builded",2000); 1265 | if (data.indexOf("OK") != -1 ) { 1266 | return true; 1267 | } 1268 | return false; 1269 | } 1270 | 1271 | 1272 | 1273 | 1274 | bool ESP8266::eATSAVETRANSLINK(uint8_t mode,String ip,uint32_t port) 1275 | { 1276 | 1277 | String data; 1278 | rx_empty(); 1279 | m_puart->print(F("AT+SAVETRANSLINK=")); 1280 | m_puart->print(mode); 1281 | m_puart->print(F(",\"")); 1282 | m_puart->print(ip); 1283 | m_puart->print(F("\",")); 1284 | m_puart->println(port); 1285 | data = recvString("OK", "ERROR",2000); 1286 | if (data.indexOf("OK") != -1 ) { 1287 | return true; 1288 | } 1289 | return false; 1290 | } 1291 | 1292 | 1293 | 1294 | bool ESP8266::eATPING(String ip) 1295 | { 1296 | rx_empty(); 1297 | m_puart->print(F("AT+PING=")); 1298 | m_puart->print(F("\"")); 1299 | m_puart->print(ip); 1300 | m_puart->println(F("\"")); 1301 | return recvFind("OK",2000); 1302 | } 1303 | 1304 | 1305 | 1306 | bool ESP8266::sATCIPSTO(uint32_t timeout) 1307 | { 1308 | rx_empty(); 1309 | m_puart->print(F("AT+CIPSTO=")); 1310 | m_puart->println(timeout); 1311 | return recvFind("OK"); 1312 | } 1313 | 1314 | --------------------------------------------------------------------------------