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

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

モード変更時は，先にリブートする様変更．
File size: 28.4 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#include "rca.h"
33#define WAIT_TIMEOUT delay(1);
34#define ENTER_CRITICAL wai_sem(ESP8266_SEM);
35#define LEAVE_CRITICAL sig_sem(ESP8266_SEM);
36#else /* !TOPPERS_WITH_ARDUINO */
37#define WAIT_TIMEOUT
38#define ENTER_CRITICAL
39#define LEAVE_CRITICAL
40#endif /* TOPPERS_WITH_ARDUINO */
41
42#ifdef TOPPERS_WITH_ARDUINO
43#define WAIT_TIMEOUT delay(1);
44#else /* !TOPPERS_WITH_ARDUINO */
45#define WAIT_TIMEOUT
46#endif /* TOPPERS_WITH_ARDUINO */
47
48#define logDebug(arg)\
49 do {\
50 if (LOG_OUTPUT_DEBUG)\
51 {\
52 if (LOG_OUTPUT_DEBUG_PREFIX)\
53 {\
54 Serial.print("[LOG Debug: ");\
55 Serial.print((const char*)__FILE__);\
56 Serial.print(",");\
57 Serial.print((unsigned int)__LINE__);\
58 Serial.print(",");\
59 Serial.print((const char*)__FUNCTION__);\
60 Serial.print("] ");\
61 }\
62 Serial.print(arg);\
63 }\
64 } while(0)
65
66ESP8266_RingBuffer::ESP8266_RingBuffer(void)
67{
68 free();
69 buffer = NULL;
70}
71
72void ESP8266_RingBuffer::init(void)
73{
74 free();
75 if(buffer!=NULL) {
76 ::free(buffer);
77 buffer = NULL;
78 }
79}
80
81bool ESP8266_RingBuffer::write(uint8_t c)
82{
83 if (len == ESP8266_RINGBUFFER_SIZE) {return false;}
84
85 if (buffer == NULL) {
86 buffer = (uint8_t*)malloc(ESP8266_RINGBUFFER_SIZE);
87 if(buffer == NULL) {return false;}
88 }
89
90 buffer[tail++] = c;
91 len++;
92
93 if (tail == ESP8266_RINGBUFFER_SIZE) {
94 tail = 0;
95 }
96 return true;
97}
98
99uint8_t ESP8266_RingBuffer::read(void)
100{
101 uint8_t c;
102 if (len == 0) {return 0;}
103 c = buffer[head++];
104 len--;
105 if (head == ESP8266_RINGBUFFER_SIZE) {
106 head = 0;
107 }
108 return c;
109}
110
111uint32_t ESP8266_RingBuffer::copy(uint8_t *pdata, uint32_t size)
112{
113 uint32_t ret;
114 uint32_t pdata_index = 0;
115
116 /* copy size */
117 ret = (len < size)? len : size;
118
119 while((pdata_index < ret)) {
120 pdata[pdata_index++] = buffer[head++];
121 if (head == ESP8266_RINGBUFFER_SIZE) {
122 head = 0;
123 }
124 }
125
126 len -= ret;
127
128 return ret;
129}
130
131uint8_t ESP8266_RingBuffer::peek(void)
132{
133 if (len == 0) {return 0;}
134 return buffer[head];
135}
136
137void ESP8266::initialize_status(void)
138{
139 wifi_status = ESP8266_STATUS_DISCONNECTED;
140 connection_bitmap = 0;
141 mux_mode = false;
142 rx_cmd = "";
143 for(int i = 0; i < ESP8266_NUM_CONNECTION; i++){
144 rx_buffer[i].init();
145 }
146}
147
148#ifdef ESP8266_USE_SOFTWARE_SERIAL
149int ESP8266::begin(SoftwareSerial &uart, uint32_t baud)
150#else /* !ESP8266_USE_SOFTWARE_SERIAL */
151int ESP8266::begin(HardwareSerial &uart, uint32_t baud)
152#endif /* ESP8266_USE_SOFTWARE_SERIAL */
153{
154 String version;
155 int ret = 0;
156
157 ENTER_CRITICAL;
158 m_puart = &uart;
159 m_baud = baud;
160 m_puart->begin(baud);
161 initialize_status();
162 rx_empty();
163
164 if (eAT()) {
165 eATGMR(version);
166 if(version.indexOf(ESP8266_SUPPORT_VERSION) == -1) {
167 ret = 2;
168 }
169 }
170 else {
171 ret = 1;
172 }
173 LEAVE_CRITICAL;
174
175 return ret;
176}
177
178bool ESP8266::kick(void)
179{
180 bool ret;
181
182 ENTER_CRITICAL;
183 ret = eAT();
184 LEAVE_CRITICAL;
185
186 return ret;
187}
188
189bool ESP8266::_restart(void)
190{
191 unsigned long start;
192 bool ret = false;
193
194 initialize_status();
195 if (eATRST()) {
196 m_puart->end();
197 delay(2000);
198 m_puart->begin(m_baud);
199 start = millis();
200 while (millis() - start < 3000) {
201 if (eAT()) {
202 delay(1500); /* Waiting for stable */
203 ret = true;
204 }
205 delay(100);
206 }
207 }
208
209 return ret;
210}
211
212bool ESP8266::restart(void)
213{
214 bool ret;
215
216 ENTER_CRITICAL;
217 ret = _restart();
218 LEAVE_CRITICAL;
219
220 return ret;
221}
222
223String ESP8266::getVersion(void)
224{
225 String version;
226
227 ENTER_CRITICAL;
228 eATGMR(version);
229 LEAVE_CRITICAL;
230
231 return version;
232}
233
234bool ESP8266::setOprToStation(void)
235{
236 uint8_t mode;
237 bool ret = false;
238
239 ENTER_CRITICAL;
240 if (qATCWMODE_CUR(&mode)) {
241 if (mode == ESP8266_WMODE_STATION) {
242 ret = true;
243 } else {
244 if (_restart() && sATCWMODE_CUR(ESP8266_WMODE_STATION)) {
245 ret = true;
246 }
247 }
248 }
249 LEAVE_CRITICAL;
250
251 return ret;
252}
253
254bool ESP8266::setOprToSoftAP(void)
255{
256 uint8_t mode;
257 bool ret = false;
258
259 ENTER_CRITICAL;
260 if (qATCWMODE_CUR(&mode)) {
261 if (mode == ESP8266_WMODE_SOFTAP) {
262 ret = true;
263 } else {
264 if (_restart() && sATCWMODE_CUR(ESP8266_WMODE_SOFTAP)) {
265 ret = true;
266 }
267 }
268 }
269 LEAVE_CRITICAL;
270
271 return ret;
272}
273
274bool ESP8266::setOprToStationSoftAP(void)
275{
276 uint8_t mode;
277 bool ret = false;
278
279 ENTER_CRITICAL;
280 if (qATCWMODE_CUR(&mode)) {
281 if (mode == ESP8266_WMODE_AP_STATION) {
282 ret = true;
283 } else {
284 if (_restart() && sATCWMODE_CUR(ESP8266_WMODE_AP_STATION)) {
285 ret = true;
286 }
287 }
288 }
289 LEAVE_CRITICAL;
290
291 return ret;
292}
293
294String ESP8266::getAPList(void)
295{
296 String list;
297
298 ENTER_CRITICAL;
299 eATCWLAP(list);
300 LEAVE_CRITICAL;
301
302 return list;
303}
304
305bool ESP8266::joinAP(String ssid, String pwd)
306{
307 bool ret;
308
309 ENTER_CRITICAL;
310 ret = sATCWJAP_CUR(ssid, pwd);
311 LEAVE_CRITICAL;
312
313 return ret;
314}
315
316bool ESP8266::leaveAP(void)
317{
318 bool ret;
319
320 ENTER_CRITICAL;
321 ret = eATCWQAP();
322 LEAVE_CRITICAL;
323
324 return ret;
325}
326
327bool ESP8266::setSoftAPParam(String ssid, String pwd, uint8_t chl, uint8_t ecn)
328{
329 bool ret;
330
331 ENTER_CRITICAL;
332 ret = sATCWSAP_CUR(ssid, pwd, chl, ecn);
333 LEAVE_CRITICAL;
334
335 return ret;
336}
337
338String ESP8266::getJoinedDeviceIP(void)
339{
340 String list;
341
342 ENTER_CRITICAL;
343 eATCWLIF(list);
344 LEAVE_CRITICAL;
345
346 return list;
347}
348
349String ESP8266::getIPStatus(void)
350{
351 String list;
352
353 ENTER_CRITICAL;
354 eATCIPSTATUS(list);
355 LEAVE_CRITICAL;
356
357 return list;
358}
359
360String ESP8266::getLocalIP(void)
361{
362 String list = "";
363 int32_t index_start = -1;
364 int32_t index_end = -1;
365
366 ENTER_CRITICAL;
367 eATCIFSR(list);
368 index_start = list.indexOf('\"');
369 index_end = list.indexOf('\"', list.indexOf('\"')+1);
370 if ((index_start != -1) && (index_end != -1)) {
371 list = list.substring(index_start+1, index_end);
372 }
373 LEAVE_CRITICAL;
374
375 return list;
376}
377
378bool ESP8266::enableMUX(void)
379{
380 bool ret = false;
381
382 ENTER_CRITICAL;
383 if (sATCIPMUX(1)) {
384 mux_mode = true;
385 ret = true;
386 }
387 LEAVE_CRITICAL;
388
389 return ret;
390}
391
392bool ESP8266::disableMUX(void)
393{
394 bool ret = false;
395
396 ENTER_CRITICAL;
397 if (sATCIPMUX(0)){
398 mux_mode = false;
399 ret = true;
400 }
401 LEAVE_CRITICAL;
402
403 return ret;
404}
405
406bool ESP8266::createTCP(String addr, uint32_t port)
407{
408 bool ret = false;
409 if (mux_mode) return false;
410
411 ENTER_CRITICAL;
412 if((ret = sATCIPSTARTSingle("TCP", addr, port))) {
413 connection_bitmap = 1;
414 }
415 LEAVE_CRITICAL;
416
417 return ret;
418}
419
420bool ESP8266::releaseTCP(void)
421{
422 bool ret = false;
423 if (mux_mode) return false;
424
425 ENTER_CRITICAL;
426 if((ret = eATCIPCLOSESingle())) {
427 connection_bitmap = 0;
428 rx_buffer[MUXID_SINGLE].free();
429 }
430 LEAVE_CRITICAL;
431
432 return ret;
433}
434
435bool ESP8266::registerUDP(String addr, uint32_t port)
436{
437 bool ret = false;
438 if (mux_mode) return false;
439
440 ENTER_CRITICAL;
441 if((ret = sATCIPSTARTSingle("UDP", addr, port))) {
442 connection_bitmap = 1;
443 }
444 LEAVE_CRITICAL;
445
446 return ret;
447}
448
449bool ESP8266::unregisterUDP(void)
450{
451 bool ret = false;
452 if (mux_mode) return false;
453
454 ENTER_CRITICAL;
455 if((ret = eATCIPCLOSESingle())) {
456 connection_bitmap = 0;
457 rx_buffer[MUXID_SINGLE].free();
458 }
459 LEAVE_CRITICAL;
460
461 return ret;
462}
463
464bool ESP8266::createTCP(uint8_t mux_id, String addr, uint32_t port)
465{
466 bool ret = false;
467 if (!(mux_id < ESP8266_NUM_CONNECTION)) return false;
468 if (!mux_mode) return false;
469
470 ENTER_CRITICAL;
471 if((ret = sATCIPSTARTMultiple(mux_id, "TCP", addr, port))) {
472 connection_bitmap |= 1 << mux_id;
473 }
474 LEAVE_CRITICAL;
475
476 return ret;
477}
478
479bool ESP8266::releaseTCP(uint8_t mux_id)
480{
481 bool ret;
482 if (!(mux_id < ESP8266_NUM_CONNECTION)) return false;
483 if (!mux_mode) return false;
484
485 ENTER_CRITICAL;
486 if ((ret = sATCIPCLOSEMulitple(mux_id))) {
487 connection_bitmap &= ~(1 << mux_id);
488 rx_buffer[mux_id].free();
489 }
490 LEAVE_CRITICAL;
491
492 return ret;
493}
494
495bool ESP8266::registerUDP(uint8_t mux_id, String addr, uint32_t port)
496{
497 bool ret;
498 if (!(mux_id < ESP8266_NUM_CONNECTION)) return false;
499 if (!mux_mode) return false;
500
501 ENTER_CRITICAL;
502 if ((ret = sATCIPSTARTMultiple(mux_id, "UDP", addr, port))) {
503 connection_bitmap |= 1 << mux_id;
504 }
505 LEAVE_CRITICAL;
506
507 return ret;
508}
509
510bool ESP8266::unregisterUDP(uint8_t mux_id)
511{
512 bool ret;
513 if (!(mux_id < ESP8266_NUM_CONNECTION)) return false;
514 if (!mux_mode) return false;
515
516 ENTER_CRITICAL;
517 if ((ret = sATCIPCLOSEMulitple(mux_id))) {
518 connection_bitmap &= ~(1 << mux_id);
519 rx_buffer[mux_id].free();
520 }
521 LEAVE_CRITICAL;
522
523 return ret;
524}
525
526bool ESP8266::setTCPServerTimeout(uint32_t timeout)
527{
528 bool ret;
529 if (!mux_mode) return false;
530
531 ENTER_CRITICAL;
532 ret = sATCIPSTO(timeout);
533 LEAVE_CRITICAL;
534
535 return ret;
536}
537
538bool ESP8266::startTCPServer(uint32_t port)
539{
540 bool ret = false;
541 if (!mux_mode) return false;
542
543 ENTER_CRITICAL;
544 ret = sATCIPSERVER(1, port);
545 LEAVE_CRITICAL;
546
547 return ret;
548}
549
550bool ESP8266::stopTCPServer(void)
551{
552 bool ret = false;
553
554 ENTER_CRITICAL;
555 ret = sATCIPSERVER(0);
556 LEAVE_CRITICAL;
557
558 return ret;
559}
560
561bool ESP8266::startServer(uint32_t port)
562{
563 bool ret = false;
564 if (!mux_mode) return false;
565
566 ret = startTCPServer(port);
567
568 return ret;
569}
570
571bool ESP8266::stopServer(void)
572{
573 bool ret;
574
575 ret = stopTCPServer();
576
577 return ret;
578}
579
580bool ESP8266::send(const uint8_t *buffer, uint32_t len)
581{
582 bool ret;
583 if (mux_mode) return false;
584
585 ENTER_CRITICAL;
586 ret = sATCIPSENDSingle(buffer, len);
587 LEAVE_CRITICAL;
588
589 return ret;
590}
591
592bool ESP8266::send(uint8_t mux_id, const uint8_t *buffer, uint32_t len)
593{
594 bool ret;
595 if (!mux_mode) return false;
596
597 ENTER_CRITICAL;
598 ret = sATCIPSENDMultiple(mux_id, buffer, len);
599 LEAVE_CRITICAL;
600
601 return ret;
602}
603
604bool ESP8266::send(String &str)
605{
606 bool ret;
607 if (mux_mode) return 0;
608
609 ENTER_CRITICAL;
610 ret = sATCIPSENDSingle(str);
611 LEAVE_CRITICAL;
612
613 return ret;
614}
615
616bool ESP8266::send(uint8_t mux_id, String &str)
617{
618 bool ret;
619 if (!mux_mode) return false;
620 if (!(mux_id < ESP8266_NUM_CONNECTION)) return false;
621
622 ENTER_CRITICAL;
623 ret = sATCIPSENDMultiple(mux_id, str);
624 LEAVE_CRITICAL;
625
626 return ret;
627}
628
629uint32_t ESP8266::recv(uint8_t *buffer, uint32_t buffer_size, uint32_t timeout)
630{
631 uint32_t ret;
632 if (mux_mode) return 0;
633
634 ENTER_CRITICAL;
635 ret = recvPkg(buffer, buffer_size, timeout, 0, NULL);
636 LEAVE_CRITICAL;
637
638 return ret;
639}
640
641uint32_t ESP8266::recv(uint8_t mux_id, uint8_t *buffer, uint32_t buffer_size, uint32_t timeout)
642{
643 uint32_t ret;
644 if (!mux_mode) return false;
645 if (!(mux_id < ESP8266_NUM_CONNECTION)) return false;
646
647 ENTER_CRITICAL;
648 ret = recvPkg(buffer, buffer_size, timeout, mux_id, NULL);
649 LEAVE_CRITICAL;
650
651 return ret;
652}
653
654uint32_t ESP8266::recv(uint8_t *coming_mux_id, uint8_t *buffer, uint32_t buffer_size, uint32_t timeout)
655{
656 uint32_t ret;
657 if (!mux_mode) return false;
658
659 ENTER_CRITICAL;
660 ret = recvPkg(buffer, buffer_size, timeout, MUXID_ANY, coming_mux_id);
661 LEAVE_CRITICAL;
662
663 return ret;
664}
665
666bool ESP8266::isDataAvailable(uint8_t mux_id)
667{
668 bool ret;
669 if (!mux_mode) return false;
670 if (!(mux_id < ESP8266_NUM_CONNECTION)) return false;
671
672 ENTER_CRITICAL;
673 if(rx_buffer[mux_id].length() > 0) ret = true;
674 if (ret == false) {
675 rx_update();
676 if(rx_buffer[mux_id].length() > 0) ret = true;
677 }
678 LEAVE_CRITICAL;
679
680 return ret;
681}
682
683bool ESP8266::isDataAvailable(void)
684{
685 bool ret = false;
686
687 ENTER_CRITICAL;
688 if (mux_mode) {
689 for(int i = 0; i < ESP8266_NUM_CONNECTION; i++){
690 if(rx_buffer[i].length() > 0) ret = true;
691 }
692 if (ret == false) {
693 rx_update();
694 for(int i = 0; i < ESP8266_NUM_CONNECTION; i++){
695 if(rx_buffer[i].length() > 0) ret = true;
696 }
697 }
698 }
699 else {
700 /* single mode */
701 if(rx_buffer[0].length() > 0) ret = true;
702 if (ret == false) {
703 rx_update();
704 if(rx_buffer[0].length() > 0) ret = true;
705 }
706 }
707 LEAVE_CRITICAL;
708
709 return ret;
710}
711
712bool ESP8266::isConnected(void)
713{
714 bool ret;
715 if (mux_mode) return false;
716
717 ENTER_CRITICAL;
718 rx_update();
719 ret = (connection_bitmap == 1);
720 LEAVE_CRITICAL;
721
722 return ret;
723}
724
725bool ESP8266::isConnected(uint8_t mux_id)
726{
727 bool ret;
728 if (!mux_mode) return false;
729 if (!(mux_id < ESP8266_NUM_CONNECTION)) return false;
730
731 ENTER_CRITICAL;
732 rx_update();
733 ret = ((connection_bitmap & (1<<mux_id)) != 0);
734 LEAVE_CRITICAL;
735
736 return ret;
737}
738
739bool ESP8266::getMuxCStatus(uint8_t *mux_id_ptn)
740{
741 if (!mux_mode) return false;
742
743 ENTER_CRITICAL;
744 rx_update();
745 *mux_id_ptn = connection_bitmap;
746 LEAVE_CRITICAL;
747
748 return true;
749}
750
751/*----------------------------------------------------------------------------*/
752/* +IPD,<id>,<len>:<data> */
753/* +IPD,<len>:<data> */
754
755uint32_t ESP8266::recvPkg(uint8_t *buffer, uint32_t buffer_size, uint32_t timeout,
756 uint8_t mux_id, uint8_t *coming_mux_id)
757{
758 char a;
759 unsigned long start;
760 uint32_t ret;
761 uint32_t recv_mux_id = 0;
762
763 /*
764 * Try to recive data from rx_buffer
765 */
766 if (mux_id == MUXID_ANY) {
767 for(int i = 0; i < ESP8266_NUM_CONNECTION; i++){
768 if(rx_buffer[i].length() > 0) {
769 recv_mux_id = i;
770 *coming_mux_id = i;
771 break;
772 }
773 }
774 }
775 else {
776 recv_mux_id = mux_id;
777 }
778
779 if(rx_buffer[recv_mux_id].length() > 0) {
780 return rx_buffer[recv_mux_id].copy(buffer, buffer_size);
781 }
782
783 /*
784 * Try to recive data from uart
785 */
786 start = millis();
787 while (millis() - start < timeout) {
788 while(m_puart->available() > 0) {
789 a = m_puart->read();
790 rx_cmd += a;
791 if (rx_cmd.indexOf("+IPD,") != -1) {
792 ret = recvIPD(timeout - (millis() - start), buffer, buffer_size,
793 mux_id, coming_mux_id);
794 rx_cmd = "";
795 return ret;
796 } else {
797 recvAsyncdata();
798 }
799 }
800 WAIT_TIMEOUT;
801 }
802 return 0;
803}
804
805/*
806 * call after read +IPD,
807 * +IPD,<id>,<len>:<data>
808 * +IPD,<len>:<data>
809 */
810uint32_t ESP8266::recvIPD(uint32_t timeout, uint8_t *buffer, uint32_t buffer_size,
811 uint8_t mux_id, uint8_t *coming_mux_id)
812{
813 String data;
814 char a;
815 unsigned long start;
816 int32_t index_colon = -1; /* : */
817 int32_t index_comma = -1; /* , */
818 int32_t len = -1;
819 int8_t id = -1;
820 bool has_data = false;
821 uint32_t ret;
822 uint32_t i;
823 ESP8266_RingBuffer *p_rx_buffer;
824
825 start = millis();
826 while (millis() - start < timeout) {
827 if(m_puart->available() > 0) {
828 a = m_puart->read();
829 data += a;
830 if((index_colon = data.indexOf(':')) != -1) {
831 if(((index_comma = data.indexOf(',')) != -1) && index_comma < index_colon) {
832 /* +IPD,id,len:data */
833 id = data.substring(0, index_comma).toInt();
834 if (id < 0 || id > (ESP8266_NUM_CONNECTION-1)) {
835 return 0;
836 }
837 len = data.substring(index_comma + 1, index_colon).toInt();
838 if (len <= 0) {
839 return 0;
840 }
841 }
842 else {
843 /* +IPD,len:data */
844 len = data.substring(0, index_colon).toInt();
845 id = 0;
846 if (len <= 0) {
847 return 0;
848 }
849 }
850 has_data = true;
851 break;
852 }
853 }
854 else {
855 WAIT_TIMEOUT;
856 }
857 }
858
859 if (has_data) {
860 p_rx_buffer = (id == -1)? &rx_buffer[0] : &rx_buffer[id];
861 if (buffer == NULL || ((mux_id != MUXID_ANY) && (id != mux_id))) {
862 /* Store in rx_buffer */
863 start = millis();
864 i = 0;
865 while (millis() - start < 3000) {
866 while((m_puart->available() > 0) && (i < (uint32_t)len)) {
867 a = m_puart->read();
868 p_rx_buffer->write(a);
869 i++;
870 }
871 if (i == (uint32_t)len) {
872 /* id != mux_id */
873 return 0;
874 }
875 WAIT_TIMEOUT;
876 }
877 return 0;
878 }
879 else {
880 /* Store in buffer */
881 i = 0;
882 ret = ((uint32_t)len > buffer_size) ? buffer_size : len;
883 start = millis();
884 while ((millis() - start) < 3000) {
885 while((m_puart->available() > 0) && (i < (uint32_t)len)) {
886 a = m_puart->read();
887 if(i < buffer_size) {
888 buffer[i] = a;
889 } else {
890 p_rx_buffer->write(a);
891 }
892 i++;
893 }
894 if (i == (uint32_t)len) {
895 if (mux_id == MUXID_ANY) {
896 *coming_mux_id = id;
897 }
898 return ret;
899 }
900 WAIT_TIMEOUT;
901 }
902 }
903 return i;
904 }
905
906 return 0;
907}
908
909void ESP8266::rx_empty(void)
910{
911 while(m_puart->available() > 0) {
912 m_puart->read();
913 }
914}
915
916void ESP8266::recvAsyncdata(uint32_t timeout)
917{
918 int index;
919 int id;
920
921 if (rx_cmd.indexOf("+IPD,") != -1) {
922 recvIPD(timeout);
923 rx_cmd = "";
924 } else if (rx_cmd.indexOf("CLOSED") != -1) {
925 if ((index = rx_cmd.indexOf(",CLOSED")) != -1) {
926 /* <link ID>,CLOSED */
927 id = rx_cmd.substring(index-1, index).toInt();
928 connection_bitmap &= ~(1 << id);
929 } else {
930 connection_bitmap = 0;
931 }
932 rx_cmd = "";
933 } else if ((index = rx_cmd.indexOf(",CONNECT")) != -1) {
934 /* <link ID>,CONNECT */
935 id = rx_cmd.substring(index-1, index).toInt();
936 connection_bitmap |= (1 << id);
937 rx_cmd = "";
938 } else if ((index = rx_cmd.indexOf("WIFI CONNECTED")) != -1) {
939 wifi_status = ESP8266_STATUS_CONNECTED;
940 rx_cmd = "";
941 } else if ((index = rx_cmd.indexOf("WIFI GOT IP")) != -1) {
942 wifi_status = ESP8266_STATUS_GOTIP;
943 rx_cmd = "";
944 } else if ((index = rx_cmd.indexOf("WIFI DISCONNECT")) != -1) {
945 wifi_status = ESP8266_STATUS_DISCONNECTED;
946 rx_cmd = "";
947 }
948}
949
950void ESP8266::rx_update(void)
951{
952 char a;
953
954 while(m_puart->available() > 0) {
955 a = m_puart->read();
956 rx_cmd += a;
957 recvAsyncdata(3000);
958 }
959}
960
961int ESP8266::recvString(String target1, String target2, String target3, uint32_t timeout)
962{
963 char a;
964 unsigned long start = millis();
965 while (millis() - start < timeout) {
966 while (m_puart->available() > 0) {
967 a = m_puart->read();
968 rx_cmd += a;
969 if (rx_cmd.indexOf(target1) != -1) {
970 return 1;
971 } else if ((target2.length() != 0 ) && (rx_cmd.indexOf(target2) != -1)) {
972 return 2;
973 } else if ((target3.length() != 0 ) && (rx_cmd.indexOf(target3) != -1)) {
974 return 3;
975 } else {
976 recvAsyncdata(timeout - (millis() - start));
977 }
978 }
979 WAIT_TIMEOUT;
980 }
981 return -1;
982}
983
984bool ESP8266::recvFind(String target, uint32_t timeout)
985{
986 int ret;
987
988 ret = recvString(target, "", "", timeout);
989 if (ret != -1) rx_cmd = "";
990 return (ret == 1);
991}
992
993bool ESP8266::recvFindAndFilter(String target, String begin, String end, String &data, uint32_t timeout)
994{
995 if (recvString(target, "", "", timeout) == 1) {
996 int32_t index1 = rx_cmd.indexOf(begin);
997 int32_t index2 = rx_cmd.indexOf(end);
998 if (index1 != -1 && index2 != -1) {
999 index1 += begin.length();
1000 data = rx_cmd.substring(index1, index2);
1001 rx_cmd = "";
1002 return true;
1003 }
1004 }
1005 data = "";
1006 return false;
1007}
1008
1009bool ESP8266::eAT(void)
1010{
1011 rx_update();
1012 m_puart->println("AT");
1013 return recvFind("OK");
1014}
1015
1016bool ESP8266::eATRST(void)
1017{
1018 rx_update();
1019 m_puart->println("AT+RST");
1020 return recvFind("OK");
1021}
1022
1023bool ESP8266::eATGMR(String &version)
1024{
1025 rx_update();
1026 m_puart->println("AT+GMR");
1027 return recvFindAndFilter("OK", "\r\r\n", "\r\nOK", version);
1028}
1029/* checked */
1030bool ESP8266::qATCWMODE_CUR(uint8_t *mode)
1031{
1032 String str_mode;
1033 bool ret;
1034 if (!mode) {
1035 return false;
1036 }
1037 rx_update();
1038 m_puart->println("AT+CWMODE_CUR?");
1039 ret = recvFindAndFilter("OK", "+CWMODE_CUR:", "\r\n\r\nOK", str_mode);
1040 if (ret) {
1041 *mode = (uint8_t)str_mode.toInt();
1042 return true;
1043 } else {
1044 return false;
1045 }
1046}
1047/* checked */
1048bool ESP8266::sATCWMODE_CUR(uint8_t mode)
1049{
1050 int ret;
1051
1052 rx_update();
1053 m_puart->print("AT+CWMODE_CUR=");
1054 m_puart->println(mode);
1055
1056 ret = recvString("OK", "ERROR", "");
1057 if (ret != -1) rx_cmd = "";
1058 return (ret == 1);
1059}
1060/* checked */
1061bool ESP8266::sATCWJAP_CUR(String ssid, String pwd)
1062{
1063 int ret;
1064
1065 rx_update();
1066 m_puart->print("AT+CWJAP_CUR=\"");
1067 m_puart->print(ssid);
1068 m_puart->print("\",\"");
1069 m_puart->print(pwd);
1070 m_puart->println("\"");
1071
1072 ret = recvString("OK", "FAIL", "", 10000);
1073 if (ret != -1) rx_cmd = "";
1074 return (ret == 1);
1075}
1076
1077bool ESP8266::eATCWLAP(String &list)
1078{
1079 rx_update();
1080 m_puart->println("AT+CWLAP");
1081 return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list, 10000);
1082}
1083
1084bool ESP8266::eATCWQAP(void)
1085{
1086 rx_update();
1087 m_puart->println("AT+CWQAP");
1088 return recvFind("OK");
1089}
1090/* checked */
1091bool ESP8266::sATCWSAP_CUR(String ssid, String pwd, uint8_t chl, uint8_t ecn)
1092{
1093 int ret;
1094
1095 rx_update();
1096 m_puart->print("AT+CWSAP_CUR=\"");
1097 m_puart->print(ssid);
1098 m_puart->print("\",\"");
1099 m_puart->print(pwd);
1100 m_puart->print("\",");
1101 m_puart->print(chl);
1102 m_puart->print(",");
1103 m_puart->println(ecn);
1104
1105 ret = recvString("OK", "ERROR", "", 5000);
1106 if (ret != -1) rx_cmd = "";
1107 return (ret == 1);
1108}
1109
1110bool ESP8266::eATCWLIF(String &list)
1111{
1112 rx_update();
1113 m_puart->println("AT+CWLIF");
1114 return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list);
1115}
1116
1117bool ESP8266::eATCIPSTATUS(String &list)
1118{
1119 rx_update();
1120 m_puart->println("AT+CIPSTATUS");
1121 return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list);
1122}
1123
1124bool ESP8266::sATCIPSTARTSingle(String type, String addr, uint32_t port)
1125{
1126 int ret;
1127
1128 rx_update();
1129 m_puart->print("AT+CIPSTART=\"");
1130 m_puart->print(type);
1131 m_puart->print("\",\"");
1132 m_puart->print(addr);
1133 m_puart->print("\",");
1134 m_puart->println(port);
1135
1136 ret = recvString("OK", "ERROR", "ALREADY CONNECT", 10000);
1137 if (ret != -1) rx_cmd = "";
1138 return (ret == 1 || ret == 3);
1139}
1140
1141bool ESP8266::sATCIPSTARTMultiple(uint8_t mux_id, String type, String addr, uint32_t port)
1142{
1143 int ret;
1144
1145 rx_update();
1146 m_puart->print("AT+CIPSTART=");
1147 m_puart->print(mux_id);
1148 m_puart->print(",\"");
1149 m_puart->print(type);
1150 m_puart->print("\",\"");
1151 m_puart->print(addr);
1152 m_puart->print("\",");
1153 m_puart->println(port);
1154
1155 ret = recvString("OK", "ERROR", "ALREADY CONNECT", 10000);
1156 if (ret != -1) rx_cmd = "";
1157 return ((ret == 1)||(ret == 3));
1158}
1159
1160bool ESP8266::sATCIPSENDSingle(const uint8_t *buffer, uint32_t len)
1161{
1162 bool ret;
1163 rx_update();
1164 m_puart->print("AT+CIPSEND=");
1165 m_puart->println(len);
1166 if (recvFind(">", 5000)) {
1167 for (uint32_t i = 0; i < len; i++) {
1168 m_puart->write(buffer[i]);
1169 }
1170 ret = recvFind("SEND OK", 10000);
1171 return ret;
1172 }
1173
1174 return false;
1175}
1176
1177bool ESP8266::sATCIPSENDMultiple(uint8_t mux_id, const uint8_t *buffer, uint32_t len)
1178{
1179 rx_update();
1180 m_puart->print("AT+CIPSEND=");
1181 m_puart->print(mux_id);
1182 m_puart->print(",");
1183 m_puart->println(len);
1184 if (recvFind(">", 5000)) {
1185 for (uint32_t i = 0; i < len; i++) {
1186 m_puart->write(buffer[i]);
1187 }
1188 return recvFind("SEND OK", 10000);
1189 }
1190 return false;
1191}
1192
1193bool ESP8266::sATCIPSENDSingle(String &str)
1194{
1195 rx_update();
1196 m_puart->print("AT+CIPSEND=");
1197 m_puart->println(str.length());
1198 if (recvFind(">", 5000)) {
1199 for (uint32_t i = 0; i < str.length(); i++) {
1200 m_puart->write(str.charAt(i));
1201 }
1202 return recvFind("SEND OK", 10000);
1203 }
1204 return false;
1205}
1206
1207bool ESP8266::sATCIPSENDMultiple(uint8_t mux_id, String &str)
1208{
1209 rx_update();
1210 m_puart->print("AT+CIPSEND=");
1211 m_puart->print(mux_id);
1212 m_puart->print(",");
1213 m_puart->println(str.length());
1214 if (recvFind(">", 5000)) {
1215 for (uint32_t i = 0; i < str.length(); i++) {
1216 m_puart->write(str.charAt(i));
1217 }
1218 return recvFind("SEND OK", 10000);
1219 }
1220 return false;
1221}
1222
1223bool ESP8266::sATCIPCLOSEMulitple(uint8_t mux_id)
1224{
1225 int ret;
1226
1227 rx_update();
1228 m_puart->print("AT+CIPCLOSE=");
1229 m_puart->println(mux_id);
1230
1231 ret = recvString("OK", "link is not", "", 5000);
1232 if (ret != -1) rx_cmd = "";
1233 return ((ret == 1) || (ret == 2));
1234}
1235
1236bool ESP8266::eATCIPCLOSESingle(void)
1237{
1238 int ret;
1239
1240 Serial.println(rx_cmd);
1241 rx_update();
1242 m_puart->println("AT+CIPCLOSE");
1243 ret = recvString("OK", "ERROR", "", 5000);
1244 if (ret != -1) rx_cmd = "";
1245 return ((ret == 1) || (ret == 2));
1246}
1247
1248bool ESP8266::eATCIFSR(String &list)
1249{
1250 rx_update();
1251 m_puart->println("AT+CIFSR");
1252 return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list);
1253}
1254/* checked */
1255bool ESP8266::sATCIPMUX(uint8_t mode)
1256{
1257 int ret;
1258
1259 rx_update();
1260 m_puart->print("AT+CIPMUX=");
1261 m_puart->println(mode);
1262
1263 ret = recvString("OK", "ERROR", "");
1264 if (ret != -1) rx_cmd = "";
1265 return (ret == 1);
1266}
1267
1268bool ESP8266::sATCIPSERVER(uint8_t mode, uint32_t port)
1269{
1270 int ret;
1271
1272 if (mode) {
1273 rx_update();
1274 m_puart->print("AT+CIPSERVER=1,");
1275 m_puart->println(port);
1276 ret = recvString("OK", "ERROR", "");
1277 if (ret != -1) rx_cmd = "";
1278 return (ret == 1);
1279 } else {
1280 rx_update();
1281 m_puart->println("AT+CIPSERVER=0");
1282 ret = recvString("OK", "ERROR", "");
1283 if (ret != -1) rx_cmd = "";
1284 return (ret == 1);
1285 }
1286}
1287bool ESP8266::sATCIPSTO(uint32_t timeout)
1288{
1289 rx_update();
1290 m_puart->print("AT+CIPSTO=");
1291 m_puart->println(timeout);
1292 return recvFind("OK");
1293}
1294
Note: See TracBrowser for help on using the repository browser.