Changeset 177 for rtos_arduino/trunk/arduino_lib
- Timestamp:
- Mar 28, 2016, 2:12:01 PM (8 years ago)
- Location:
- rtos_arduino/trunk/arduino_lib/libraries/ESP8266_Arudino_AT
- Files:
-
- 3 deleted
- 2 edited
Legend:
- Unmodified
- Added
- Removed
-
rtos_arduino/trunk/arduino_lib/libraries/ESP8266_Arudino_AT/ESP8266.cpp
r143 r177 2 2 * @file ESP8266.cpp 3 3 * @brief The implementation of class ESP8266. 4 * @author Wu Pengfei<pengfei.wu@itead.cc> 4 * @author Wu Pengfei<pengfei.wu@itead.cc>, Shinya Honda<honda@ertl.jp> 5 5 * @date 2015.02 6 6 * … … 26 26 #define LOG_OUTPUT_DEBUG_PREFIX (1) 27 27 28 #define MUXID_ANY 255 29 #define MUXID_SINGLE 0 30 28 31 #ifdef TOPPERS_WITH_ARDUINO 29 32 #define WAIT_TIMEOUT delay(1); … … 50 53 } while(0) 51 54 55 ESP8266_RingBuffer::ESP8266_RingBuffer(void) 56 { 57 free(); 58 buffer = NULL; 59 } 60 61 void ESP8266_RingBuffer::init(void) 62 { 63 free(); 64 if(buffer!=NULL) { 65 ::free(buffer); 66 buffer = NULL; 67 } 68 } 69 70 bool ESP8266_RingBuffer::write(uint8_t c) 71 { 72 if (len == ESP8266_RINGBUFFER_SIZE) {return false;} 73 74 if (buffer == NULL) { 75 buffer = (uint8_t*)malloc(ESP8266_RINGBUFFER_SIZE); 76 if(buffer == NULL) {return false;} 77 } 78 79 buffer[tail++] = c; 80 len++; 81 82 if (tail == ESP8266_RINGBUFFER_SIZE) { 83 tail = 0; 84 } 85 return true; 86 } 87 88 uint8_t ESP8266_RingBuffer::read(void) 89 { 90 uint8_t c; 91 if (len == 0) {return 0;} 92 c = buffer[head++]; 93 len--; 94 if (head == ESP8266_RINGBUFFER_SIZE) { 95 head = 0; 96 } 97 return c; 98 } 99 100 101 uint32_t ESP8266_RingBuffer::copy(uint8_t *pdata, uint32_t size) 102 { 103 uint32_t ret; 104 uint32_t pdata_index = 0; 105 106 /* copy size */ 107 ret = (len < size)? len : size; 108 109 while((pdata_index < ret)) { 110 pdata[pdata_index++] = buffer[head++]; 111 if (head == ESP8266_RINGBUFFER_SIZE) { 112 head = 0; 113 } 114 } 115 116 len -= ret; 117 118 return ret; 119 } 120 121 uint8_t ESP8266_RingBuffer::peek(void) 122 { 123 if (len == 0) {return 0;} 124 return buffer[head]; 125 } 126 127 void ESP8266::initialize_status(void) 128 { 129 wifi_status = ESP8266_STATUS_DISCONNECTED; 130 connection_bitmap = 0; 131 mux_mode = false; 132 rx_cmd = ""; 133 for(int i = 0; i < ESP8266_NUM_CONNECTION; i++){ 134 rx_buffer[i].init(); 135 } 136 } 137 52 138 #ifdef ESP8266_USE_SOFTWARE_SERIAL 53 void ESP8266::begin(SoftwareSerial &uart, uint32_t baud) 54 { 139 int ESP8266::begin(SoftwareSerial &uart, uint32_t baud) 140 #else /* !ESP8266_USE_SOFTWARE_SERIAL */ 141 int ESP8266::begin(HardwareSerial &uart, uint32_t baud) 142 #endif /* ESP8266_USE_SOFTWARE_SERIAL */ 143 { 144 String version; 145 55 146 m_puart = &uart; 56 147 m_baud = baud; 57 148 m_puart->begin(baud); 149 initialize_status(); 58 150 rx_empty(); 59 } 60 #else 61 void ESP8266::begin(HardwareSerial &uart, uint32_t baud) 62 { 63 m_puart = &uart; 64 m_baud = baud; 65 m_puart->begin(baud); 66 rx_empty(); 67 } 68 #endif 151 152 if (!kick()) { 153 return 1; 154 } 155 156 eATGMR(version); 157 if(version.indexOf(ESP8266_SUPPORT_VERSION) == -1) { 158 return 2; 159 } 160 161 return 0; 162 } 69 163 70 164 bool ESP8266::kick(void) … … 76 170 { 77 171 unsigned long start; 172 initialize_status(); 78 173 if (eATRST()) { 79 174 m_puart->end(); … … 102 197 { 103 198 uint8_t mode; 104 if (!qATCWMODE (&mode)) {199 if (!qATCWMODE_CUR(&mode)) { 105 200 return false; 106 201 } 107 if (mode == 1) {202 if (mode == ESP8266_WMODE_STATION) { 108 203 return true; 109 204 } else { 110 if (sATCWMODE (1) && restart()) {205 if (sATCWMODE_CUR(ESP8266_WMODE_STATION) && restart()) { 111 206 return true; 112 207 } else { … … 119 214 { 120 215 uint8_t mode; 121 if (!qATCWMODE (&mode)) {216 if (!qATCWMODE_CUR(&mode)) { 122 217 return false; 123 218 } 124 if (mode == 2) {219 if (mode == ESP8266_WMODE_SOFTAP) { 125 220 return true; 126 221 } else { 127 if (sATCWMODE (2) && restart()) {222 if (sATCWMODE_CUR(ESP8266_WMODE_SOFTAP) && restart()) { 128 223 return true; 129 224 } else { … … 136 231 { 137 232 uint8_t mode; 138 if (!qATCWMODE (&mode)) {233 if (!qATCWMODE_CUR(&mode)) { 139 234 return false; 140 235 } 141 if (mode == 3) {236 if (mode == ESP8266_WMODE_AP_STATION) { 142 237 return true; 143 238 } else { 144 if (sATCWMODE (3) && restart()) {239 if (sATCWMODE_CUR(ESP8266_WMODE_AP_STATION) && restart()) { 145 240 return true; 146 241 } else { … … 159 254 bool ESP8266::joinAP(String ssid, String pwd) 160 255 { 161 return sATCWJAP (ssid, pwd);256 return sATCWJAP_CUR(ssid, pwd); 162 257 } 163 258 … … 169 264 bool ESP8266::setSoftAPParam(String ssid, String pwd, uint8_t chl, uint8_t ecn) 170 265 { 171 return sATCWSAP (ssid, pwd, chl, ecn);266 return sATCWSAP_CUR(ssid, pwd, chl, ecn); 172 267 } 173 268 … … 189 284 { 190 285 String list; 286 int32_t index_start = -1; 287 int32_t index_end = -1; 288 191 289 eATCIFSR(list); 192 return list; 290 index_start = list.indexOf('\"'); 291 index_end = list.indexOf('\"', list.indexOf('\"')+1); 292 if ((index_start != -1) && (index_end != -1)) { 293 return list.substring(index_start+1, index_end); 294 } 295 return ""; 193 296 } 194 297 195 298 bool ESP8266::enableMUX(void) 196 299 { 197 return sATCIPMUX(1); 300 if (sATCIPMUX(1)) { 301 mux_mode = true; 302 return true; 303 } 304 return false; 198 305 } 199 306 200 307 bool ESP8266::disableMUX(void) 201 308 { 202 return sATCIPMUX(0); 309 if (sATCIPMUX(0)){ 310 mux_mode = false; 311 return true; 312 } 313 return false; 203 314 } 204 315 205 316 bool ESP8266::createTCP(String addr, uint32_t port) 206 317 { 207 return sATCIPSTARTSingle("TCP", addr, port); 318 bool ret; 319 if (mux_mode) return false; 320 321 if((ret = sATCIPSTARTSingle("TCP", addr, port))) { 322 connection_bitmap = 1; 323 } 324 return ret; 208 325 } 209 326 210 327 bool ESP8266::releaseTCP(void) 211 328 { 212 return eATCIPCLOSESingle(); 329 bool ret; 330 331 if (mux_mode) return false; 332 if((ret = eATCIPCLOSESingle())) { 333 connection_bitmap = 0; 334 rx_buffer[MUXID_SINGLE].free(); 335 } 336 return ret; 213 337 } 214 338 215 339 bool ESP8266::registerUDP(String addr, uint32_t port) 216 340 { 217 return sATCIPSTARTSingle("UDP", addr, port); 341 bool ret; 342 if (mux_mode) return false; 343 if((ret = sATCIPSTARTSingle("UDP", addr, port))) { 344 connection_bitmap = 1; 345 } 346 return ret; 218 347 } 219 348 220 349 bool ESP8266::unregisterUDP(void) 221 350 { 222 return eATCIPCLOSESingle(); 351 bool ret; 352 if (mux_mode) return false; 353 if((ret = eATCIPCLOSESingle())) { 354 connection_bitmap = 0; 355 rx_buffer[MUXID_SINGLE].free(); 356 } 357 return ret; 223 358 } 224 359 225 360 bool ESP8266::createTCP(uint8_t mux_id, String addr, uint32_t port) 226 361 { 227 return sATCIPSTARTMultiple(mux_id, "TCP", addr, port); 362 bool ret; 363 if (!(mux_id < ESP8266_NUM_CONNECTION)) return false; 364 if (!mux_mode) return false; 365 366 if((ret = sATCIPSTARTMultiple(mux_id, "TCP", addr, port))) { 367 connection_bitmap |= 1 << mux_id; 368 } 369 return ret; 228 370 } 229 371 230 372 bool ESP8266::releaseTCP(uint8_t mux_id) 231 373 { 232 return sATCIPCLOSEMulitple(mux_id); 374 bool ret; 375 if (!(mux_id < ESP8266_NUM_CONNECTION)) return false; 376 if (!mux_mode) return false; 377 378 if ((ret = sATCIPCLOSEMulitple(mux_id))) { 379 connection_bitmap &= ~(1 << mux_id); 380 rx_buffer[mux_id].free(); 381 } 382 return ret; 233 383 } 234 384 235 385 bool ESP8266::registerUDP(uint8_t mux_id, String addr, uint32_t port) 236 386 { 237 return sATCIPSTARTMultiple(mux_id, "UDP", addr, port); 387 bool ret; 388 if (!(mux_id < ESP8266_NUM_CONNECTION)) return false; 389 if (!mux_mode) return false; 390 391 if ((ret = sATCIPSTARTMultiple(mux_id, "UDP", addr, port))) { 392 connection_bitmap |= 1 << mux_id; 393 } 394 return ret; 238 395 } 239 396 240 397 bool ESP8266::unregisterUDP(uint8_t mux_id) 241 398 { 242 return sATCIPCLOSEMulitple(mux_id); 399 bool ret; 400 if (!(mux_id < ESP8266_NUM_CONNECTION)) return false; 401 if (!mux_mode) return false; 402 403 if ((ret = sATCIPCLOSEMulitple(mux_id))) { 404 connection_bitmap &= ~(1 << mux_id); 405 rx_buffer[mux_id].free(); 406 } 407 return ret; 243 408 } 244 409 245 410 bool ESP8266::setTCPServerTimeout(uint32_t timeout) 246 411 { 412 if (!mux_mode) return false; 247 413 return sATCIPSTO(timeout); 248 414 } … … 250 416 bool ESP8266::startTCPServer(uint32_t port) 251 417 { 418 if (!mux_mode) return false; 252 419 if (sATCIPSERVER(1, port)) { 253 420 return true; … … 259 426 { 260 427 sATCIPSERVER(0); 261 restart();262 428 return false; 263 429 } … … 265 431 bool ESP8266::startServer(uint32_t port) 266 432 { 433 if (!mux_mode) return false; 267 434 return startTCPServer(port); 268 435 } … … 275 442 bool ESP8266::send(const uint8_t *buffer, uint32_t len) 276 443 { 444 if (mux_mode) return 0; 277 445 return sATCIPSENDSingle(buffer, len); 278 446 } … … 280 448 bool ESP8266::send(uint8_t mux_id, const uint8_t *buffer, uint32_t len) 281 449 { 450 if (!mux_mode) return false; 282 451 return sATCIPSENDMultiple(mux_id, buffer, len); 283 452 } … … 285 454 bool ESP8266::send(String &str) 286 455 { 456 if (mux_mode) return 0; 287 457 return sATCIPSENDSingle(str); 288 458 } … … 290 460 bool ESP8266::send(uint8_t mux_id, String &str) 291 461 { 462 if (!mux_mode) return false; 463 if (!(mux_id < ESP8266_NUM_CONNECTION)) return false; 464 292 465 return sATCIPSENDMultiple(mux_id, str); 293 466 } … … 295 468 uint32_t ESP8266::recv(uint8_t *buffer, uint32_t buffer_size, uint32_t timeout) 296 469 { 297 return recvPkg(buffer, buffer_size, NULL, timeout, NULL); 470 if (mux_mode) return 0; 471 return recvPkg(buffer, buffer_size, timeout, 0, NULL); 298 472 } 299 473 300 474 uint32_t ESP8266::recv(uint8_t mux_id, uint8_t *buffer, uint32_t buffer_size, uint32_t timeout) 301 475 { 302 uint8_t id; 303 uint32_t ret; 304 ret = recvPkg(buffer, buffer_size, NULL, timeout, &id); 305 if (ret > 0 && id == mux_id) { 306 return ret; 307 } 476 if (!mux_mode) return false; 477 if (!(mux_id < ESP8266_NUM_CONNECTION)) return false; 478 479 return recvPkg(buffer, buffer_size, timeout, mux_id, NULL); 480 } 481 482 uint32_t ESP8266::recv(uint8_t *coming_mux_id, uint8_t *buffer, uint32_t buffer_size, uint32_t timeout) 483 { 484 if (!mux_mode) return false; 485 return recvPkg(buffer, buffer_size, timeout, MUXID_ANY, coming_mux_id); 486 } 487 488 bool ESP8266::isDataAvailable(uint8_t mux_id) 489 { 490 if (!mux_mode) return false; 491 if (!(mux_id < ESP8266_NUM_CONNECTION)) return false; 492 493 if(rx_buffer[mux_id].length() > 0) return true; 494 rx_update(); 495 if(rx_buffer[mux_id].length() > 0) return true; 308 496 return 0; 309 497 } 310 498 311 uint32_t ESP8266::recv(uint8_t *coming_mux_id, uint8_t *buffer, uint32_t buffer_size, uint32_t timeout) 312 { 313 return recvPkg(buffer, buffer_size, NULL, timeout, coming_mux_id); 314 } 315 316 int ESP8266::dataAvailable(void) 317 { 318 return (m_puart->available() > 0)? 1 : 0; 319 } 320 499 bool ESP8266::isDataAvailable(void) 500 { 501 if (mux_mode) { 502 for(int i = 0; i < ESP8266_NUM_CONNECTION; i++){ 503 if(rx_buffer[i].length() > 0) return true; 504 } 505 rx_update(); 506 for(int i = 0; i < ESP8266_NUM_CONNECTION; i++){ 507 if(rx_buffer[i].length() > 0) return true; 508 } 509 } 510 else { 511 /* single mode */ 512 if(rx_buffer[0].length() > 0) return true; 513 rx_update(); 514 if(rx_buffer[0].length() > 0) return true; 515 } 516 return false; 517 } 518 519 bool ESP8266::isConnected(void) 520 { 521 if (mux_mode) return false; 522 rx_update(); 523 return (connection_bitmap == 1); 524 } 525 526 bool ESP8266::isConnected(uint8_t mux_id) 527 { 528 if (!mux_mode) return false; 529 if (!(mux_id < ESP8266_NUM_CONNECTION)) return false; 530 rx_update(); 531 return ((connection_bitmap & (1<<mux_id)) != 0); 532 } 533 534 bool ESP8266::getMuxCStatus(uint8_t *mux_id_ptn) 535 { 536 if (!mux_mode) return false; 537 rx_update(); 538 *mux_id_ptn = connection_bitmap; 539 return true; 540 } 541 321 542 /*----------------------------------------------------------------------------*/ 322 543 /* +IPD,<id>,<len>:<data> */ 323 544 /* +IPD,<len>:<data> */ 324 545 325 uint32_t ESP8266::recvPkg(uint8_t *buffer, uint32_t buffer_size, uint32_t *data_len, uint32_t timeout, uint8_t *coming_mux_id) 546 uint32_t ESP8266::recvPkg(uint8_t *buffer, uint32_t buffer_size, uint32_t timeout, 547 uint8_t mux_id, uint8_t *coming_mux_id) 548 { 549 char a; 550 unsigned long start; 551 uint32_t ret; 552 uint32_t recv_mux_id = 0; 553 554 /* 555 * Try to recive data from rx_buffer 556 */ 557 if (mux_id == MUXID_ANY) { 558 for(int i = 0; i < ESP8266_NUM_CONNECTION; i++){ 559 if(rx_buffer[i].length() > 0) { 560 recv_mux_id = i; 561 *coming_mux_id = i; 562 break; 563 } 564 } 565 } 566 else { 567 recv_mux_id = mux_id; 568 } 569 570 if(rx_buffer[recv_mux_id].length() > 0) { 571 return rx_buffer[recv_mux_id].copy(buffer, buffer_size); 572 } 573 574 /* 575 * Try to recive data from uart 576 */ 577 start = millis(); 578 while (millis() - start < timeout) { 579 while(m_puart->available() > 0) { 580 a = m_puart->read(); 581 rx_cmd += a; 582 if (rx_cmd.indexOf("+IPD,") != -1) { 583 if((ret = recvIPD(timeout - (millis() - start), buffer, buffer_size, 584 mux_id, coming_mux_id)) > 0) { 585 rx_cmd = ""; 586 return ret; 587 } 588 } else { 589 recvAsyncdata(); 590 } 591 } 592 WAIT_TIMEOUT; 593 } 594 return 0; 595 } 596 597 /* 598 * call after read +IPD, 599 * +IPD,<id>,<len>:<data> 600 * +IPD,<len>:<data> 601 */ 602 uint32_t ESP8266::recvIPD(uint32_t timeout, uint8_t *buffer, uint32_t buffer_size, 603 uint8_t mux_id, uint8_t *coming_mux_id) 326 604 { 327 605 String data; 328 606 char a; 329 int32_t index_PIPDcomma = -1;607 unsigned long start; 330 608 int32_t index_colon = -1; /* : */ 331 609 int32_t index_comma = -1; /* , */ … … 334 612 bool has_data = false; 335 613 uint32_t ret; 336 unsigned long start;337 614 uint32_t i; 338 339 if (buffer == NULL) { 340 return 0; 341 } 342 615 ESP8266_RingBuffer *p_rx_buffer; 616 343 617 start = millis(); 344 while (millis() - start < timeout) { 618 while (millis() - start < timeout) { 345 619 if(m_puart->available() > 0) { 346 620 a = m_puart->read(); 347 621 data += a; 348 }else{ 349 WAIT_TIMEOUT; 350 } 351 352 index_PIPDcomma = data.indexOf("+IPD,"); 353 if (index_PIPDcomma != -1) { 354 index_colon = data.indexOf(':', index_PIPDcomma + 5); 355 if (index_colon != -1) { 356 index_comma = data.indexOf(',', index_PIPDcomma + 5); 357 /* +IPD,id,len:data */ 358 if (index_comma != -1 && index_comma < index_colon) { 359 id = data.substring(index_PIPDcomma + 5, index_comma).toInt(); 360 if (id < 0 || id > 4) { 622 if((index_colon = data.indexOf(':')) != -1) { 623 if(((index_comma = data.indexOf(',')) != -1) && index_comma < index_colon) { 624 /* +IPD,id,len:data */ 625 id = data.substring(0, index_comma).toInt(); 626 if (id < 0 || id > (ESP8266_NUM_CONNECTION-1)) { 361 627 return 0; 362 628 } … … 365 631 return 0; 366 632 } 367 } else { /* +IPD,len:data */ 368 len = data.substring(index_PIPDcomma + 5, index_colon).toInt(); 633 } 634 else { 635 /* +IPD,len:data */ 636 len = data.substring(0, index_colon).toInt(); 637 id = 0; 369 638 if (len <= 0) { 370 639 return 0; … … 375 644 } 376 645 } 646 else { 647 WAIT_TIMEOUT; 648 } 377 649 } 378 650 379 651 if (has_data) { 380 i = 0; 381 ret = (uint32_t)len > buffer_size ? buffer_size : len; 382 start = millis(); 383 while (millis() - start < 3000) { 384 while(m_puart->available() > 0 && i < ret) { 385 a = m_puart->read(); 386 buffer[i++] = a; 652 p_rx_buffer = (id == -1)? &rx_buffer[0] : &rx_buffer[id]; 653 if (buffer == NULL || ((mux_id != MUXID_ANY) && (id != mux_id))) { 654 /* Store in rx_buffer */ 655 start = millis(); 656 i = 0; 657 while (millis() - start < 3000) { 658 while((m_puart->available() > 0) && (i < (uint32_t)len)) { 659 a = m_puart->read(); 660 p_rx_buffer->write(a); 661 i++; 662 } 663 if (i == (uint32_t)len) { 664 return len; 665 } 666 WAIT_TIMEOUT 667 } 668 return 0; 669 } 670 else { 671 /* Store in buffer */ 672 i = 0; 673 ret = ((uint32_t)len > buffer_size) ? buffer_size : len; 674 start = millis(); 675 while ((millis() - start) < 3000) { 676 while((m_puart->available() > 0) && (i < (uint32_t)len)) { 677 a = m_puart->read(); 678 if(i < buffer_size) { 679 buffer[i] = a; 680 } else { 681 p_rx_buffer->write(a); 682 } 683 i++; 684 } 685 if (i == (uint32_t)len) { 686 if (mux_id == MUXID_ANY) { 687 *coming_mux_id = id; 688 } 689 return ret; 690 } 691 WAIT_TIMEOUT; 387 692 } 388 if (i == ret) { 389 rx_empty(); 390 if (data_len) { 391 *data_len = len; 392 } 393 if (index_comma != -1 && coming_mux_id) { 394 *coming_mux_id = id; 395 } 396 return ret; 397 } 398 WAIT_TIMEOUT 399 } 400 } 693 } 694 } 695 401 696 return 0; 402 697 } … … 409 704 } 410 705 411 String ESP8266::recvString(String target, uint32_t timeout) 412 { 413 String data; 706 void ESP8266::recvAsyncdata(uint32_t timeout) 707 { 708 int index; 709 int id; 710 711 if (rx_cmd.indexOf("+IPD,") != -1) { 712 if(recvIPD(timeout) > 0) { 713 rx_cmd = ""; 714 } 715 } else if (rx_cmd.indexOf("CLOSED") != -1) { 716 if ((index = rx_cmd.indexOf(",CLOSED")) != -1) { 717 /* <link ID>,CLOSED */ 718 id = rx_cmd.substring(index-1, index).toInt(); 719 connection_bitmap &= ~(1 << id); 720 } else { 721 connection_bitmap = 0; 722 } 723 rx_cmd = ""; 724 } else if ((index = rx_cmd.indexOf(",CONNECT")) != -1) { 725 /* <link ID>,CONNECT */ 726 id = rx_cmd.substring(index-1, index).toInt(); 727 connection_bitmap |= (1 << id); 728 rx_cmd = ""; 729 } else if ((index = rx_cmd.indexOf("WIFI CONNECTED")) != -1) { 730 wifi_status = ESP8266_STATUS_CONNECTED; 731 rx_cmd = ""; 732 } else if ((index = rx_cmd.indexOf("WIFI GOT IP")) != -1) { 733 wifi_status = ESP8266_STATUS_GOTIP; 734 rx_cmd = ""; 735 } else if ((index = rx_cmd.indexOf("WIFI DISCONNECT")) != -1) { 736 wifi_status = ESP8266_STATUS_DISCONNECTED; 737 rx_cmd = ""; 738 } 739 } 740 741 void ESP8266::rx_update(void) 742 { 743 char a; 744 745 while(m_puart->available() > 0) { 746 a = m_puart->read(); 747 rx_cmd += a; 748 recvAsyncdata(3000); 749 } 750 } 751 752 int ESP8266::recvString(String target1, String target2, String target3, uint32_t timeout) 753 { 414 754 char a; 415 755 unsigned long start = millis(); 416 756 while (millis() - start < timeout) { 417 while (m_puart->available() > 0) {757 while (m_puart->available() > 0) { 418 758 a = m_puart->read(); 419 if(a == '\0') continue; 420 data += a; 421 } 422 if (data.indexOf(target) != -1) { 423 break; 424 } 425 WAIT_TIMEOUT 426 } 427 return data; 428 } 429 430 String ESP8266::recvString(String target1, String target2, uint32_t timeout) 431 { 432 String data; 433 char a; 434 unsigned long start = millis(); 435 while (millis() - start < timeout) { 436 while(m_puart->available() > 0) { 437 a = m_puart->read(); 438 if(a == '\0') continue; 439 data += a; 440 } 441 if (data.indexOf(target1) != -1) { 442 break; 443 } else if (data.indexOf(target2) != -1) { 444 break; 445 } 446 WAIT_TIMEOUT 447 } 448 return data; 449 } 450 451 String ESP8266::recvString(String target1, String target2, String target3, uint32_t timeout) 452 { 453 String data; 454 char a; 455 unsigned long start = millis(); 456 while (millis() - start < timeout) { 457 while(m_puart->available() > 0) { 458 a = m_puart->read(); 459 if(a == '\0') continue; 460 data += a; 461 } 462 if (data.indexOf(target1) != -1) { 463 break; 464 } else if (data.indexOf(target2) != -1) { 465 break; 466 } else if (data.indexOf(target3) != -1) { 467 break; 468 } 469 WAIT_TIMEOUT 470 } 471 return data; 759 rx_cmd += a; 760 if (rx_cmd.indexOf(target1) != -1) { 761 return 1; 762 } else if ((target2.length() != 0 ) && (rx_cmd.indexOf(target2) != -1)) { 763 return 2; 764 } else if ((target3.length() != 0 ) && (rx_cmd.indexOf(target3) != -1)) { 765 return 3; 766 } else { 767 recvAsyncdata(timeout - (millis() - start)); 768 } 769 } 770 WAIT_TIMEOUT; 771 } 772 return -1; 472 773 } 473 774 474 775 bool ESP8266::recvFind(String target, uint32_t timeout) 475 776 { 476 String data_tmp; 477 data_tmp = recvString(target, timeout); 478 if (data_tmp.indexOf(target) != -1) { 479 return true; 480 } 481 return false; 777 int ret; 778 779 ret = recvString(target, "", "", timeout); 780 if (ret != -1) rx_cmd = ""; 781 return (ret == 1); 482 782 } 483 783 484 784 bool ESP8266::recvFindAndFilter(String target, String begin, String end, String &data, uint32_t timeout) 485 785 { 486 String data_tmp; 487 data_tmp = recvString(target, timeout); 488 if (data_tmp.indexOf(target) != -1) { 489 int32_t index1 = data_tmp.indexOf(begin); 490 int32_t index2 = data_tmp.indexOf(end); 786 if (recvString(target, "", "", timeout) == 1) { 787 int32_t index1 = rx_cmd.indexOf(begin); 788 int32_t index2 = rx_cmd.indexOf(end); 491 789 if (index1 != -1 && index2 != -1) { 492 790 index1 += begin.length(); 493 data = data_tmp.substring(index1, index2); 791 data = rx_cmd.substring(index1, index2); 792 rx_cmd = ""; 494 793 return true; 495 794 } … … 501 800 bool ESP8266::eAT(void) 502 801 { 503 rx_empty();504 802 m_puart->println("AT"); 505 803 return recvFind("OK"); … … 508 806 bool ESP8266::eATRST(void) 509 807 { 510 rx_empty();511 808 m_puart->println("AT+RST"); 512 809 return recvFind("OK"); … … 515 812 bool ESP8266::eATGMR(String &version) 516 813 { 517 rx_empty();518 814 m_puart->println("AT+GMR"); 519 815 return recvFindAndFilter("OK", "\r\r\n", "\r\nOK", version); 520 816 } 521 522 bool ESP8266::qATCWMODE (uint8_t *mode)817 /* checked */ 818 bool ESP8266::qATCWMODE_CUR(uint8_t *mode) 523 819 { 524 820 String str_mode; … … 527 823 return false; 528 824 } 529 rx_empty(); 530 m_puart->println("AT+CWMODE?"); 531 ret = recvFindAndFilter("OK", "+CWMODE:", "\r\n\r\nOK", str_mode); 825 m_puart->println("AT+CWMODE_CUR?"); 826 ret = recvFindAndFilter("OK", "+CWMODE_CUR:", "\r\n\r\nOK", str_mode); 532 827 if (ret) { 533 828 *mode = (uint8_t)str_mode.toInt(); … … 537 832 } 538 833 } 539 540 bool ESP8266::sATCWMODE (uint8_t mode)541 { 542 String data;543 rx_empty();544 m_puart->print("AT+CWMODE =");834 /* checked */ 835 bool ESP8266::sATCWMODE_CUR(uint8_t mode) 836 { 837 int ret; 838 839 m_puart->print("AT+CWMODE_CUR="); 545 840 m_puart->println(mode); 546 547 data = recvString("OK", "no change"); 548 if (data.indexOf("OK") != -1 || data.indexOf("no change") != -1) { 549 return true; 550 } 551 return false; 552 } 553 554 bool ESP8266::sATCWJAP(String ssid, String pwd) 555 { 556 String data; 557 rx_empty(); 841 842 ret = recvString("OK", "ERROR", ""); 843 if (ret != -1) rx_cmd = ""; 844 return (ret == 1); 845 } 846 /* checked */ 847 bool ESP8266::sATCWJAP_CUR(String ssid, String pwd) 848 { 849 int ret; 850 558 851 m_puart->print("AT+CWJAP=\""); 559 852 m_puart->print(ssid); … … 562 855 m_puart->println("\""); 563 856 564 data = recvString("OK", "FAIL", 10000); 565 if (data.indexOf("OK") != -1) { 566 return true; 567 } 568 return false; 857 ret = recvString("OK", "FAIL", "", 10000); 858 if (ret != -1) rx_cmd = ""; 859 return (ret == 1); 569 860 } 570 861 571 862 bool ESP8266::eATCWLAP(String &list) 572 863 { 573 String data;574 rx_empty();575 864 m_puart->println("AT+CWLAP"); 576 865 return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list, 10000); … … 579 868 bool ESP8266::eATCWQAP(void) 580 869 { 581 String data;582 rx_empty();583 870 m_puart->println("AT+CWQAP"); 584 871 return recvFind("OK"); 585 872 } 586 587 bool ESP8266::sATCWSAP (String ssid, String pwd, uint8_t chl, uint8_t ecn)588 { 589 String data;590 rx_empty();591 m_puart->print("AT+CWSAP =\"");873 /* checked */ 874 bool ESP8266::sATCWSAP_CUR(String ssid, String pwd, uint8_t chl, uint8_t ecn) 875 { 876 int ret; 877 878 m_puart->print("AT+CWSAP_CUR=\""); 592 879 m_puart->print(ssid); 593 880 m_puart->print("\",\""); … … 598 885 m_puart->println(ecn); 599 886 600 data = recvString("OK", "ERROR", 5000); 601 if (data.indexOf("OK") != -1) { 602 return true; 603 } 604 return false; 887 ret = recvString("OK", "ERROR", "", 5000); 888 if (ret != -1) rx_cmd = ""; 889 return (ret == 1); 605 890 } 606 891 607 892 bool ESP8266::eATCWLIF(String &list) 608 893 { 609 String data;610 rx_empty();611 894 m_puart->println("AT+CWLIF"); 612 895 return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list); 613 896 } 897 614 898 bool ESP8266::eATCIPSTATUS(String &list) 615 899 { 616 String data;617 delay(100);618 rx_empty();619 900 m_puart->println("AT+CIPSTATUS"); 620 901 return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list); 621 902 } 903 622 904 bool ESP8266::sATCIPSTARTSingle(String type, String addr, uint32_t port) 623 905 { 624 String data;625 rx_empty();906 int ret; 907 626 908 m_puart->print("AT+CIPSTART=\""); 627 909 m_puart->print(type); … … 631 913 m_puart->println(port); 632 914 633 data = recvString("OK", "ERROR", "ALREADY CONNECT", 10000); 634 if (data.indexOf("OK") != -1 || data.indexOf("ALREADY CONNECT") != -1) { 635 return true; 636 } 637 return false; 638 } 915 ret = recvString("OK", "ERROR", "ALREADY CONNECT", 10000); 916 if (ret != -1) rx_cmd = ""; 917 return (ret == 1 || ret == 3); 918 } 919 639 920 bool ESP8266::sATCIPSTARTMultiple(uint8_t mux_id, String type, String addr, uint32_t port) 640 921 { 641 String data;642 rx_empty();922 int ret; 923 643 924 m_puart->print("AT+CIPSTART="); 644 925 m_puart->print(mux_id); … … 650 931 m_puart->println(port); 651 932 652 data = recvString("OK", "ERROR", "ALREADY CONNECT", 10000); 653 if (data.indexOf("OK") != -1 || data.indexOf("ALREADY CONNECT") != -1) { 654 return true; 655 } 656 return false; 657 } 933 ret = recvString("OK", "ERROR", "ALREADY CONNECT", 10000); 934 if (ret != -1) rx_cmd = ""; 935 return ((ret == 1)||(ret == 3)); 936 } 937 658 938 bool ESP8266::sATCIPSENDSingle(const uint8_t *buffer, uint32_t len) 659 939 { 660 rx_empty();661 940 m_puart->print("AT+CIPSEND="); 662 941 m_puart->println(len); 663 942 if (recvFind(">", 5000)) { 664 rx_empty();665 943 for (uint32_t i = 0; i < len; i++) { 666 944 m_puart->write(buffer[i]); … … 670 948 return false; 671 949 } 950 672 951 bool ESP8266::sATCIPSENDMultiple(uint8_t mux_id, const uint8_t *buffer, uint32_t len) 673 952 { 674 rx_empty();675 953 m_puart->print("AT+CIPSEND="); 676 954 m_puart->print(mux_id); … … 678 956 m_puart->println(len); 679 957 if (recvFind(">", 5000)) { 680 rx_empty();681 958 for (uint32_t i = 0; i < len; i++) { 682 959 m_puart->write(buffer[i]); … … 686 963 return false; 687 964 } 965 688 966 bool ESP8266::sATCIPSENDSingle(String &str) 689 967 { 690 rx_empty();691 968 m_puart->print("AT+CIPSEND="); 692 969 m_puart->println(str.length()); 693 970 if (recvFind(">", 5000)) { 694 rx_empty();695 971 for (uint32_t i = 0; i < str.length(); i++) { 696 972 m_puart->write(str.charAt(i)); … … 700 976 return false; 701 977 } 978 702 979 bool ESP8266::sATCIPSENDMultiple(uint8_t mux_id, String &str) 703 980 { 704 rx_empty();705 981 m_puart->print("AT+CIPSEND="); 706 982 m_puart->print(mux_id); … … 708 984 m_puart->println(str.length()); 709 985 if (recvFind(">", 5000)) { 710 rx_empty();711 986 for (uint32_t i = 0; i < str.length(); i++) { 712 987 m_puart->write(str.charAt(i)); … … 716 991 return false; 717 992 } 993 718 994 bool ESP8266::sATCIPCLOSEMulitple(uint8_t mux_id) 719 995 { 720 String data;721 rx_empty();996 int ret; 997 722 998 m_puart->print("AT+CIPCLOSE="); 723 999 m_puart->println(mux_id); 724 1000 725 data = recvString("OK", "link is not", 5000); 726 if (data.indexOf("OK") != -1 || data.indexOf("link is not") != -1) { 727 return true; 728 } 729 return false; 730 } 1001 ret = recvString("OK", "link is not", "", 5000); 1002 if (ret != -1) rx_cmd = ""; 1003 return ((ret == 1) || (ret == 2)); 1004 } 1005 731 1006 bool ESP8266::eATCIPCLOSESingle(void) 732 1007 { 733 rx_empty();734 1008 m_puart->println("AT+CIPCLOSE"); 735 1009 return recvFind("OK", 5000); 736 1010 } 1011 737 1012 bool ESP8266::eATCIFSR(String &list) 738 1013 { 739 rx_empty();740 1014 m_puart->println("AT+CIFSR"); 741 1015 return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list); 742 1016 } 1017 /* checked */ 743 1018 bool ESP8266::sATCIPMUX(uint8_t mode) 744 1019 { 745 String data;746 rx_empty();1020 int ret; 1021 747 1022 m_puart->print("AT+CIPMUX="); 748 1023 m_puart->println(mode); 749 1024 750 data = recvString("OK", "Link is builded"); 751 if (data.indexOf("OK") != -1) { 752 return true; 753 } 754 return false; 755 } 1025 ret = recvString("OK", "ERROR", ""); 1026 if (ret != -1) rx_cmd = ""; 1027 return (ret == 1); 1028 } 1029 756 1030 bool ESP8266::sATCIPSERVER(uint8_t mode, uint32_t port) 757 1031 { 758 String data; 1032 int ret; 1033 759 1034 if (mode) { 760 rx_empty();761 1035 m_puart->print("AT+CIPSERVER=1,"); 762 m_puart->println(port); 763 764 data = recvString("OK", "no change"); 765 if (data.indexOf("OK") != -1 || data.indexOf("no change") != -1) { 766 return true; 767 } 768 return false; 1036 m_puart->println(port); 1037 ret = recvString("OK", "ERROR", ""); 1038 if (ret != -1) rx_cmd = ""; 1039 return (ret == 1); 769 1040 } else { 770 rx_empty();771 1041 m_puart->println("AT+CIPSERVER=0"); 772 return recvFind("\r\r\n"); 1042 ret = recvString("OK", "ERROR", ""); 1043 if (ret != -1) rx_cmd = ""; 1044 return (ret == 1); 773 1045 } 774 1046 } 775 1047 bool ESP8266::sATCIPSTO(uint32_t timeout) 776 1048 { 777 rx_empty();778 1049 m_puart->print("AT+CIPSTO="); 779 1050 m_puart->println(timeout); -
rtos_arduino/trunk/arduino_lib/libraries/ESP8266_Arudino_AT/ESP8266.h
r143 r177 26 26 #include "Arduino.h" 27 27 28 29 28 //#define ESP8266_USE_SOFTWARE_SERIAL 30 29 30 #define ESP8266_SUPPORT_VERSION "AT version:0.25" 31 32 #define ESP8266_NUM_CONNECTION 5 31 33 32 34 #ifdef ESP8266_USE_SOFTWARE_SERIAL 33 35 #include "SoftwareSerial.h" 34 #endif 35 36 #endif /* ESP8266_USE_SOFTWARE_SERIAL */ 37 38 #define ESP8266_CONNECTION_OPEN 0x01 39 #define ESP8266_CONNECTION_CLOSE 0x02 40 41 #define ESP8266_CONNECTION_TCP 0x01 42 #define ESP8266_CONNECTION_UDP 0x02 43 44 #define ESP8266_CONNECTION_CLIENT 0x01 45 #define ESP8266_CONNECTION_SERVER 0x02 46 47 #define ESP8266_STATUS_GOTIP 0x02 48 #define ESP8266_STATUS_CONNECTED 0x03 49 #define ESP8266_STATUS_DISCONNECTED 0x04 50 51 #define ESP8266_WMODE_STATION 0x01 52 #define ESP8266_WMODE_SOFTAP 0x02 53 #define ESP8266_WMODE_AP_STATION 0x03 54 55 struct esp8266_connection_status 56 { 57 uint8_t connection_type; 58 uint8_t protocol_type; 59 }; 60 61 #define ESP8266_RINGBUFFER_SIZE 512 62 63 class ESP8266_RingBuffer 64 { 65 public: 66 ESP8266_RingBuffer(void); 67 void init(void); 68 void free(void) {len = head = tail = 0;}; 69 bool write(uint8_t c); 70 uint8_t read(void); 71 uint32_t copy(uint8_t *pdata, uint32_t size); 72 uint8_t peek(void); 73 bool available(void) {return (len > 0);}; 74 bool isFull(void) {return (len == ESP8266_RINGBUFFER_SIZE);}; 75 uint32_t length(void) {return len;}; 76 77 private: 78 uint8_t *buffer; 79 uint32_t head; 80 uint32_t tail; 81 uint32_t len; 82 }; 36 83 37 84 /** … … 41 88 public: 42 89 43 #ifdef ESP8266_USE_SOFTWARE_SERIAL44 90 /* 45 91 * Begin. … … 48 94 * @param baud - the buad rate to communicate with ESP8266(default:115200). 49 95 * 50 * @warning parameter baud depends on the AT firmware. 115200 is an common value. 51 */ 52 void begin(SoftwareSerial &uart, uint32_t baud = 115200); 96 * @retval 0 : Success 97 * @retval 1 : Can not communicate ESP8266 98 * @retval 2 : Firmware Version mismatch. 99 * 100 * @warning parameter baud depends on the AT firmware. 115200 is an common value. 101 */ 102 #ifdef ESP8266_USE_SOFTWARE_SERIAL 103 int begin(SoftwareSerial &uart, uint32_t baud = 115200); 53 104 #else /* HardwareSerial */ 54 /* 55 * Begin. 56 * 57 * @param uart - an reference of HardwareSerial object. 58 * @param baud - the buad rate to communicate with ESP8266(default:115200). 59 * 60 * @warning parameter baud depends on the AT firmware. 115200 is an common value. 61 */ 62 void begin(HardwareSerial &uart, uint32_t baud = 115200); 63 #endif 64 105 int begin(HardwareSerial &uart, uint32_t baud = 115200); 106 #endif /* ESP8266_USE_SOFTWARE_SERIAL */ 65 107 66 108 /** … … 176 218 */ 177 219 String getLocalIP(void); 178 220 179 221 /** 180 222 * Enable IP MUX(multiple connection mode). … … 390 432 */ 391 433 uint32_t recv(uint8_t mux_id, uint8_t *buffer, uint32_t buffer_size, uint32_t timeout = 1000); 392 434 393 435 /** 394 436 * Receive data from all of TCP or UDP builded already in multiple mode. … … 404 446 */ 405 447 uint32_t recv(uint8_t *coming_mux_id, uint8_t *buffer, uint32_t buffer_size, uint32_t timeout = 1000); 406 407 /** 408 * Check data is available. 409 * 410 * @return 1 : data is available, 0 : data is not available 411 */ 412 int dataAvailable(void); 413 448 449 /** 450 * Check data is available in specific connection. 451 * 452 * @param mux_id - the identifier of this TCP(available value: 0 - 4). 453 * @return true - data is available. 454 * @return false - data is not available. 455 */ 456 bool isDataAvailable(uint8_t mux_id); 457 458 /** 459 * Check data is available in any connection. 460 * 461 * @return true - data is available. 462 * @return false - data is not available. 463 */ 464 bool isDataAvailable(void); 465 466 /** 467 * Check connection is opned in single mode. 468 * 469 * @return true - opend. 470 * @return false - closed. 471 */ 472 bool isConnected(void); 473 474 /** 475 * Check specific connection is opned in multiple mode. 476 * 477 * @return true - opend. 478 * @return false - closed. 479 */ 480 bool isConnected(uint8_t mux_id); 481 482 /** 483 * Get connection link status 484 * 485 * @return true - success. 486 * @return false - error. 487 */ 488 bool getMuxCStatus(uint8_t *mux_id_ptn); 489 490 /** 491 * 492 */ 493 ESP8266_RingBuffer rx_buffer[ESP8266_NUM_CONNECTION]; 494 414 495 private: 415 496 … … 418 499 */ 419 500 void rx_empty(void); 420 501 421 502 /* 422 * Recvive data from uart. Return all received data if target found or timeout. 423 */ 424 String recvString(String target, uint32_t timeout = 1000); 425 426 /* 427 * Recvive data from uart. Return all received data if one of target1 and target2 found or timeout. 428 */ 429 String recvString(String target1, String target2, uint32_t timeout = 1000); 430 503 * Read all data in UART RX. 504 */ 505 void rx_update(void); 506 431 507 /* 432 508 * Recvive data from uart. Return all received data if one of target1, target2 and target3 found or timeout. 433 509 */ 434 StringrecvString(String target1, String target2, String target3, uint32_t timeout = 1000);510 int recvString(String target1, String target2, String target3, uint32_t timeout = 1000); 435 511 436 512 /* … … 440 516 441 517 /* 442 * Recvive data from uart and search first target and cut out the substring between begin and end(excluding begin and end self). 518 * Recvive data from uart and search first target and cut out the substring between begin and end(excluding begin and end self). a 443 519 * Return true if target found, false for timeout. 444 520 */ … … 454 530 * @param coming_mux_id - in single connection mode, should be NULL and not NULL in multiple. 455 531 */ 456 uint32_t recvPkg(uint8_t *buffer, uint32_t buffer_size, uint32_t *data_len, uint32_t timeout, uint8_t *coming_mux_id); 457 532 uint32_t recvPkg(uint8_t *buffer, uint32_t buffer_size, uint32_t timeout, uint8_t mux_id, uint8_t *coming_mux_id); 458 533 459 534 bool eAT(void); … … 461 536 bool eATGMR(String &version); 462 537 463 bool qATCWMODE (uint8_t *mode);464 bool sATCWMODE (uint8_t mode);465 bool sATCWJAP (String ssid, String pwd);538 bool qATCWMODE_CUR(uint8_t *mode); 539 bool sATCWMODE_CUR(uint8_t mode); 540 bool sATCWJAP_CUR(String ssid, String pwd); 466 541 bool eATCWLAP(String &list); 467 542 bool eATCWQAP(void); 468 bool sATCWSAP (String ssid, String pwd, uint8_t chl, uint8_t ecn);543 bool sATCWSAP_CUR(String ssid, String pwd, uint8_t chl, uint8_t ecn); 469 544 bool eATCWLIF(String &list); 470 545 … … 482 557 bool sATCIPSERVER(uint8_t mode, uint32_t port = 333); 483 558 bool sATCIPSTO(uint32_t timeout); 484 485 /* 486 * +IPD,len:data 487 * +IPD,id,len:data 488 */ 559 560 void initialize_status(void); 561 562 uint32_t recvIPD(uint32_t timeout, uint8_t *buffer = NULL, uint32_t buffer_size = 0, 563 uint8_t mux_id = 0, uint8_t *coming_mux_id = NULL); 564 565 void recvAsyncdata(uint32_t timeout = 0); 489 566 490 567 #ifdef ESP8266_USE_SOFTWARE_SERIAL … … 494 571 #endif 495 572 uint32_t m_baud; 573 574 uint8_t wifi_status; 575 bool mux_mode; 576 uint8_t connection_bitmap; 577 esp8266_connection_status connection_status[ESP8266_NUM_CONNECTION]; 578 579 String rx_cmd; 496 580 }; 497 581
Note:
See TracChangeset
for help on using the changeset viewer.