source: rtos_arduino/trunk/arduino_lib/libraries/ESP8266_Arudino_AT/ESP8266.cpp@ 177

Last change on this file since 177 was 177, checked in by ertl-honda, 8 years ago

実装と乖離してきたため削除．
File size: 24.9 KB
Line 
1/**
2 * @file ESP8266.cpp
3 * @brief The implementation of class ESP8266.
4 * @author Wu Pengfei<pengfei.wu@itead.cc>, Shinya Honda<honda@ertl.jp>
5 * @date 2015.02
6 *
7 * @par Copyright:
8 * Copyright (c) 2015 ITEAD Intelligent Systems Co., Ltd. \n\n
9 * Copyright (C) 2015 Embedded and Real-Time Systems Laboratory
10 * Graduate School of Information Science, Nagoya Univ., JAPAN \n\n
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License as
13 * published by the Free Software Foundation; either version 2 of
14 * the License, or (at your option) any later version. \n\n
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 * THE SOFTWARE.
22 */
23#include "ESP8266.h"
24
25#define LOG_OUTPUT_DEBUG (1)
26#define LOG_OUTPUT_DEBUG_PREFIX (1)
27
28#define MUXID_ANY 255
29#define MUXID_SINGLE 0
30
31#ifdef TOPPERS_WITH_ARDUINO
32#define WAIT_TIMEOUT delay(1);
33#else /* !TOPPERS_WITH_ARDUINO */
34#define WAIT_TIMEOUT
35#endif /* TOPPERS_WITH_ARDUINO */
36
37#define logDebug(arg)\
38 do {\
39 if (LOG_OUTPUT_DEBUG)\
40 {\
41 if (LOG_OUTPUT_DEBUG_PREFIX)\
42 {\
43 Serial.print("[LOG Debug: ");\
44 Serial.print((const char*)__FILE__);\
45 Serial.print(",");\
46 Serial.print((unsigned int)__LINE__);\
47 Serial.print(",");\
48 Serial.print((const char*)__FUNCTION__);\
49 Serial.print("] ");\
50 }\
51 Serial.print(arg);\
52 }\
53 } while(0)
54
55ESP8266_RingBuffer::ESP8266_RingBuffer(void)
56{
57 free();
58 buffer = NULL;
59}
60
61void ESP8266_RingBuffer::init(void)
62{
63 free();
64 if(buffer!=NULL) {
65 ::free(buffer);
66 buffer = NULL;
67 }
68}
69
70bool 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
88uint8_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
101uint32_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
121uint8_t ESP8266_RingBuffer::peek(void)
122{
123 if (len == 0) {return 0;}
124 return buffer[head];
125}
126
127void 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
138#ifdef ESP8266_USE_SOFTWARE_SERIAL
139int ESP8266::begin(SoftwareSerial &uart, uint32_t baud)
140#else /* !ESP8266_USE_SOFTWARE_SERIAL */
141int ESP8266::begin(HardwareSerial &uart, uint32_t baud)
142#endif /* ESP8266_USE_SOFTWARE_SERIAL */
143{
144 String version;
145
146 m_puart = &uart;
147 m_baud = baud;
148 m_puart->begin(baud);
149 initialize_status();
150 rx_empty();
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}
163
164bool ESP8266::kick(void)
165{
166 return eAT();
167}
168
169bool ESP8266::restart(void)
170{
171 unsigned long start;
172 initialize_status();
173 if (eATRST()) {
174 m_puart->end();
175 delay(2000);
176 m_puart->begin(m_baud);
177 start = millis();
178 while (millis() - start < 3000) {
179 if (eAT()) {
180 delay(1500); /* Waiting for stable */
181 return true;
182 }
183 delay(100);
184 }
185 }
186 return false;
187}
188
189String ESP8266::getVersion(void)
190{
191 String version;
192 eATGMR(version);
193 return version;
194}
195
196bool ESP8266::setOprToStation(void)
197{
198 uint8_t mode;
199 if (!qATCWMODE_CUR(&mode)) {
200 return false;
201 }
202 if (mode == ESP8266_WMODE_STATION) {
203 return true;
204 } else {
205 if (sATCWMODE_CUR(ESP8266_WMODE_STATION) && restart()) {
206 return true;
207 } else {
208 return false;
209 }
210 }
211}
212
213bool ESP8266::setOprToSoftAP(void)
214{
215 uint8_t mode;
216 if (!qATCWMODE_CUR(&mode)) {
217 return false;
218 }
219 if (mode == ESP8266_WMODE_SOFTAP) {
220 return true;
221 } else {
222 if (sATCWMODE_CUR(ESP8266_WMODE_SOFTAP) && restart()) {
223 return true;
224 } else {
225 return false;
226 }
227 }
228}
229
230bool ESP8266::setOprToStationSoftAP(void)
231{
232 uint8_t mode;
233 if (!qATCWMODE_CUR(&mode)) {
234 return false;
235 }
236 if (mode == ESP8266_WMODE_AP_STATION) {
237 return true;
238 } else {
239 if (sATCWMODE_CUR(ESP8266_WMODE_AP_STATION) && restart()) {
240 return true;
241 } else {
242 return false;
243 }
244 }
245}
246
247String ESP8266::getAPList(void)
248{
249 String list;
250 eATCWLAP(list);
251 return list;
252}
253
254bool ESP8266::joinAP(String ssid, String pwd)
255{
256 return sATCWJAP_CUR(ssid, pwd);
257}
258
259bool ESP8266::leaveAP(void)
260{
261 return eATCWQAP();
262}
263
264bool ESP8266::setSoftAPParam(String ssid, String pwd, uint8_t chl, uint8_t ecn)
265{
266 return sATCWSAP_CUR(ssid, pwd, chl, ecn);
267}
268
269String ESP8266::getJoinedDeviceIP(void)
270{
271 String list;
272 eATCWLIF(list);
273 return list;
274}
275
276String ESP8266::getIPStatus(void)
277{
278 String list;
279 eATCIPSTATUS(list);
280 return list;
281}
282
283String ESP8266::getLocalIP(void)
284{
285 String list;
286 int32_t index_start = -1;
287 int32_t index_end = -1;
288
289 eATCIFSR(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 "";
296}
297
298bool ESP8266::enableMUX(void)
299{
300 if (sATCIPMUX(1)) {
301 mux_mode = true;
302 return true;
303 }
304 return false;
305}
306
307bool ESP8266::disableMUX(void)
308{
309 if (sATCIPMUX(0)){
310 mux_mode = false;
311 return true;
312 }
313 return false;
314}
315
316bool ESP8266::createTCP(String addr, uint32_t port)
317{
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;
325}
326
327bool ESP8266::releaseTCP(void)
328{
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;
337}
338
339bool ESP8266::registerUDP(String addr, uint32_t port)
340{
341 bool ret;
342 if (mux_mode) return false;
343 if((ret = sATCIPSTARTSingle("UDP", addr, port))) {
344 connection_bitmap = 1;
345 }
346 return ret;
347}
348
349bool ESP8266::unregisterUDP(void)
350{
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;
358}
359
360bool ESP8266::createTCP(uint8_t mux_id, String addr, uint32_t port)
361{
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;
370}
371
372bool ESP8266::releaseTCP(uint8_t mux_id)
373{
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;
383}
384
385bool ESP8266::registerUDP(uint8_t mux_id, String addr, uint32_t port)
386{
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;
395}
396
397bool ESP8266::unregisterUDP(uint8_t mux_id)
398{
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;
408}
409
410bool ESP8266::setTCPServerTimeout(uint32_t timeout)
411{
412 if (!mux_mode) return false;
413 return sATCIPSTO(timeout);
414}
415
416bool ESP8266::startTCPServer(uint32_t port)
417{
418 if (!mux_mode) return false;
419 if (sATCIPSERVER(1, port)) {
420 return true;
421 }
422 return false;
423}
424
425bool ESP8266::stopTCPServer(void)
426{
427 sATCIPSERVER(0);
428 return false;
429}
430
431bool ESP8266::startServer(uint32_t port)
432{
433 if (!mux_mode) return false;
434 return startTCPServer(port);
435}
436
437bool ESP8266::stopServer(void)
438{
439 return stopTCPServer();
440}
441
442bool ESP8266::send(const uint8_t *buffer, uint32_t len)
443{
444 if (mux_mode) return 0;
445 return sATCIPSENDSingle(buffer, len);
446}
447
448bool ESP8266::send(uint8_t mux_id, const uint8_t *buffer, uint32_t len)
449{
450 if (!mux_mode) return false;
451 return sATCIPSENDMultiple(mux_id, buffer, len);
452}
453
454bool ESP8266::send(String &str)
455{
456 if (mux_mode) return 0;
457 return sATCIPSENDSingle(str);
458}
459
460bool ESP8266::send(uint8_t mux_id, String &str)
461{
462 if (!mux_mode) return false;
463 if (!(mux_id < ESP8266_NUM_CONNECTION)) return false;
464
465 return sATCIPSENDMultiple(mux_id, str);
466}
467
468uint32_t ESP8266::recv(uint8_t *buffer, uint32_t buffer_size, uint32_t timeout)
469{
470 if (mux_mode) return 0;
471 return recvPkg(buffer, buffer_size, timeout, 0, NULL);
472}
473
474uint32_t ESP8266::recv(uint8_t mux_id, uint8_t *buffer, uint32_t buffer_size, uint32_t timeout)
475{
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
482uint32_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
488bool 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;
496 return 0;
497}
498
499bool 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
519bool ESP8266::isConnected(void)
520{
521 if (mux_mode) return false;
522 rx_update();
523 return (connection_bitmap == 1);
524}
525
526bool 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
534bool 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
542/*----------------------------------------------------------------------------*/
543/* +IPD,<id>,<len>:<data> */
544/* +IPD,<len>:<data> */
545
546uint32_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 */
602uint32_t ESP8266::recvIPD(uint32_t timeout, uint8_t *buffer, uint32_t buffer_size,
603 uint8_t mux_id, uint8_t *coming_mux_id)
604{
605 String data;
606 char a;
607 unsigned long start;
608 int32_t index_colon = -1; /* : */
609 int32_t index_comma = -1; /* , */
610 int32_t len = -1;
611 int8_t id = -1;
612 bool has_data = false;
613 uint32_t ret;
614 uint32_t i;
615 ESP8266_RingBuffer *p_rx_buffer;
616
617 start = millis();
618 while (millis() - start < timeout) {
619 if(m_puart->available() > 0) {
620 a = m_puart->read();
621 data += a;
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)) {
627 return 0;
628 }
629 len = data.substring(index_comma + 1, index_colon).toInt();
630 if (len <= 0) {
631 return 0;
632 }
633 }
634 else {
635 /* +IPD,len:data */
636 len = data.substring(0, index_colon).toInt();
637 id = 0;
638 if (len <= 0) {
639 return 0;
640 }
641 }
642 has_data = true;
643 break;
644 }
645 }
646 else {
647 WAIT_TIMEOUT;
648 }
649 }
650
651 if (has_data) {
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;
692 }
693 }
694 }
695
696 return 0;
697}
698
699void ESP8266::rx_empty(void)
700{
701 while(m_puart->available() > 0) {
702 m_puart->read();
703 }
704}
705
706void 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
741void 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
752int ESP8266::recvString(String target1, String target2, String target3, uint32_t timeout)
753{
754 char a;
755 unsigned long start = millis();
756 while (millis() - start < timeout) {
757 while (m_puart->available() > 0) {
758 a = m_puart->read();
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;
773}
774
775bool ESP8266::recvFind(String target, uint32_t timeout)
776{
777 int ret;
778
779 ret = recvString(target, "", "", timeout);
780 if (ret != -1) rx_cmd = "";
781 return (ret == 1);
782}
783
784bool ESP8266::recvFindAndFilter(String target, String begin, String end, String &data, uint32_t timeout)
785{
786 if (recvString(target, "", "", timeout) == 1) {
787 int32_t index1 = rx_cmd.indexOf(begin);
788 int32_t index2 = rx_cmd.indexOf(end);
789 if (index1 != -1 && index2 != -1) {
790 index1 += begin.length();
791 data = rx_cmd.substring(index1, index2);
792 rx_cmd = "";
793 return true;
794 }
795 }
796 data = "";
797 return false;
798}
799
800bool ESP8266::eAT(void)
801{
802 m_puart->println("AT");
803 return recvFind("OK");
804}
805
806bool ESP8266::eATRST(void)
807{
808 m_puart->println("AT+RST");
809 return recvFind("OK");
810}
811
812bool ESP8266::eATGMR(String &version)
813{
814 m_puart->println("AT+GMR");
815 return recvFindAndFilter("OK", "\r\r\n", "\r\nOK", version);
816}
817/* checked */
818bool ESP8266::qATCWMODE_CUR(uint8_t *mode)
819{
820 String str_mode;
821 bool ret;
822 if (!mode) {
823 return false;
824 }
825 m_puart->println("AT+CWMODE_CUR?");
826 ret = recvFindAndFilter("OK", "+CWMODE_CUR:", "\r\n\r\nOK", str_mode);
827 if (ret) {
828 *mode = (uint8_t)str_mode.toInt();
829 return true;
830 } else {
831 return false;
832 }
833}
834/* checked */
835bool ESP8266::sATCWMODE_CUR(uint8_t mode)
836{
837 int ret;
838
839 m_puart->print("AT+CWMODE_CUR=");
840 m_puart->println(mode);
841
842 ret = recvString("OK", "ERROR", "");
843 if (ret != -1) rx_cmd = "";
844 return (ret == 1);
845}
846/* checked */
847bool ESP8266::sATCWJAP_CUR(String ssid, String pwd)
848{
849 int ret;
850
851 m_puart->print("AT+CWJAP=\"");
852 m_puart->print(ssid);
853 m_puart->print("\",\"");
854 m_puart->print(pwd);
855 m_puart->println("\"");
856
857 ret = recvString("OK", "FAIL", "", 10000);
858 if (ret != -1) rx_cmd = "";
859 return (ret == 1);
860}
861
862bool ESP8266::eATCWLAP(String &list)
863{
864 m_puart->println("AT+CWLAP");
865 return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list, 10000);
866}
867
868bool ESP8266::eATCWQAP(void)
869{
870 m_puart->println("AT+CWQAP");
871 return recvFind("OK");
872}
873/* checked */
874bool 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=\"");
879 m_puart->print(ssid);
880 m_puart->print("\",\"");
881 m_puart->print(pwd);
882 m_puart->print("\",");
883 m_puart->print(chl);
884 m_puart->print(",");
885 m_puart->println(ecn);
886
887 ret = recvString("OK", "ERROR", "", 5000);
888 if (ret != -1) rx_cmd = "";
889 return (ret == 1);
890}
891
892bool ESP8266::eATCWLIF(String &list)
893{
894 m_puart->println("AT+CWLIF");
895 return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list);
896}
897
898bool ESP8266::eATCIPSTATUS(String &list)
899{
900 m_puart->println("AT+CIPSTATUS");
901 return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list);
902}
903
904bool ESP8266::sATCIPSTARTSingle(String type, String addr, uint32_t port)
905{
906 int ret;
907
908 m_puart->print("AT+CIPSTART=\"");
909 m_puart->print(type);
910 m_puart->print("\",\"");
911 m_puart->print(addr);
912 m_puart->print("\",");
913 m_puart->println(port);
914
915 ret = recvString("OK", "ERROR", "ALREADY CONNECT", 10000);
916 if (ret != -1) rx_cmd = "";
917 return (ret == 1 || ret == 3);
918}
919
920bool ESP8266::sATCIPSTARTMultiple(uint8_t mux_id, String type, String addr, uint32_t port)
921{
922 int ret;
923
924 m_puart->print("AT+CIPSTART=");
925 m_puart->print(mux_id);
926 m_puart->print(",\"");
927 m_puart->print(type);
928 m_puart->print("\",\"");
929 m_puart->print(addr);
930 m_puart->print("\",");
931 m_puart->println(port);
932
933 ret = recvString("OK", "ERROR", "ALREADY CONNECT", 10000);
934 if (ret != -1) rx_cmd = "";
935 return ((ret == 1)||(ret == 3));
936}
937
938bool ESP8266::sATCIPSENDSingle(const uint8_t *buffer, uint32_t len)
939{
940 m_puart->print("AT+CIPSEND=");
941 m_puart->println(len);
942 if (recvFind(">", 5000)) {
943 for (uint32_t i = 0; i < len; i++) {
944 m_puart->write(buffer[i]);
945 }
946 return recvFind("SEND OK", 10000);
947 }
948 return false;
949}
950
951bool ESP8266::sATCIPSENDMultiple(uint8_t mux_id, const uint8_t *buffer, uint32_t len)
952{
953 m_puart->print("AT+CIPSEND=");
954 m_puart->print(mux_id);
955 m_puart->print(",");
956 m_puart->println(len);
957 if (recvFind(">", 5000)) {
958 for (uint32_t i = 0; i < len; i++) {
959 m_puart->write(buffer[i]);
960 }
961 return recvFind("SEND OK", 10000);
962 }
963 return false;
964}
965
966bool ESP8266::sATCIPSENDSingle(String &str)
967{
968 m_puart->print("AT+CIPSEND=");
969 m_puart->println(str.length());
970 if (recvFind(">", 5000)) {
971 for (uint32_t i = 0; i < str.length(); i++) {
972 m_puart->write(str.charAt(i));
973 }
974 return recvFind("SEND OK", 10000);
975 }
976 return false;
977}
978
979bool ESP8266::sATCIPSENDMultiple(uint8_t mux_id, String &str)
980{
981 m_puart->print("AT+CIPSEND=");
982 m_puart->print(mux_id);
983 m_puart->print(",");
984 m_puart->println(str.length());
985 if (recvFind(">", 5000)) {
986 for (uint32_t i = 0; i < str.length(); i++) {
987 m_puart->write(str.charAt(i));
988 }
989 return recvFind("SEND OK", 10000);
990 }
991 return false;
992}
993
994bool ESP8266::sATCIPCLOSEMulitple(uint8_t mux_id)
995{
996 int ret;
997
998 m_puart->print("AT+CIPCLOSE=");
999 m_puart->println(mux_id);
1000
1001 ret = recvString("OK", "link is not", "", 5000);
1002 if (ret != -1) rx_cmd = "";
1003 return ((ret == 1) || (ret == 2));
1004}
1005
1006bool ESP8266::eATCIPCLOSESingle(void)
1007{
1008 m_puart->println("AT+CIPCLOSE");
1009 return recvFind("OK", 5000);
1010}
1011
1012bool ESP8266::eATCIFSR(String &list)
1013{
1014 m_puart->println("AT+CIFSR");
1015 return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list);
1016}
1017/* checked */
1018bool ESP8266::sATCIPMUX(uint8_t mode)
1019{
1020 int ret;
1021
1022 m_puart->print("AT+CIPMUX=");
1023 m_puart->println(mode);
1024
1025 ret = recvString("OK", "ERROR", "");
1026 if (ret != -1) rx_cmd = "";
1027 return (ret == 1);
1028}
1029
1030bool ESP8266::sATCIPSERVER(uint8_t mode, uint32_t port)
1031{
1032 int ret;
1033
1034 if (mode) {
1035 m_puart->print("AT+CIPSERVER=1,");
1036 m_puart->println(port);
1037 ret = recvString("OK", "ERROR", "");
1038 if (ret != -1) rx_cmd = "";
1039 return (ret == 1);
1040 } else {
1041 m_puart->println("AT+CIPSERVER=0");
1042 ret = recvString("OK", "ERROR", "");
1043 if (ret != -1) rx_cmd = "";
1044 return (ret == 1);
1045 }
1046}
1047bool ESP8266::sATCIPSTO(uint32_t timeout)
1048{
1049 m_puart->print("AT+CIPSTO=");
1050 m_puart->println(timeout);
1051 return recvFind("OK");
1052}
1053
Note: See TracBrowser for help on using the repository browser.