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

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

R2CAでの排他制御のサポート
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 (sATCWMODE_CUR(ESP8266_WMODE_STATION) && _restart()) {
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 (sATCWMODE_CUR(ESP8266_WMODE_SOFTAP) && _restart()) {
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 (sATCWMODE_CUR(ESP8266_WMODE_AP_STATION) && restart()) {
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 if((ret = recvIPD(timeout - (millis() - start), buffer, buffer_size,
793 mux_id, coming_mux_id)) != 0) {
794 rx_cmd = "";
795 return ret;
796 }
797 } else {
798 recvAsyncdata();
799 }
800 }
801 WAIT_TIMEOUT;
802 }
803 return 0;
804}
805
806/*
807 * call after read +IPD,
808 * +IPD,<id>,<len>:<data>
809 * +IPD,<len>:<data>
810 */
811uint32_t ESP8266::recvIPD(uint32_t timeout, uint8_t *buffer, uint32_t buffer_size,
812 uint8_t mux_id, uint8_t *coming_mux_id)
813{
814 String data;
815 char a;
816 unsigned long start;
817 int32_t index_colon = -1; /* : */
818 int32_t index_comma = -1; /* , */
819 int32_t len = -1;
820 int8_t id = -1;
821 bool has_data = false;
822 uint32_t ret;
823 uint32_t i;
824 ESP8266_RingBuffer *p_rx_buffer;
825
826 start = millis();
827 while (millis() - start < timeout) {
828 if(m_puart->available() > 0) {
829 a = m_puart->read();
830 data += a;
831 if((index_colon = data.indexOf(':')) != -1) {
832 if(((index_comma = data.indexOf(',')) != -1) && index_comma < index_colon) {
833 /* +IPD,id,len:data */
834 id = data.substring(0, index_comma).toInt();
835 if (id < 0 || id > (ESP8266_NUM_CONNECTION-1)) {
836 return 0;
837 }
838 len = data.substring(index_comma + 1, index_colon).toInt();
839 if (len <= 0) {
840 return 0;
841 }
842 }
843 else {
844 /* +IPD,len:data */
845 len = data.substring(0, index_colon).toInt();
846 id = 0;
847 if (len <= 0) {
848 return 0;
849 }
850 }
851 has_data = true;
852 break;
853 }
854 }
855 else {
856 WAIT_TIMEOUT;
857 }
858 }
859
860 if (has_data) {
861 p_rx_buffer = (id == -1)? &rx_buffer[0] : &rx_buffer[id];
862 if (buffer == NULL || ((mux_id != MUXID_ANY) && (id != mux_id))) {
863 /* Store in rx_buffer */
864 start = millis();
865 i = 0;
866 while (millis() - start < 3000) {
867 while((m_puart->available() > 0) && (i < (uint32_t)len)) {
868 a = m_puart->read();
869 p_rx_buffer->write(a);
870 i++;
871 }
872 if (i == (uint32_t)len) {
873 return len;
874 }
875 WAIT_TIMEOUT
876 }
877 return i;
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 if(recvIPD(timeout) != 0) {
923 rx_cmd = "";
924 }
925 } else if (rx_cmd.indexOf("CLOSED") != -1) {
926 if ((index = rx_cmd.indexOf(",CLOSED")) != -1) {
927 /* <link ID>,CLOSED */
928 id = rx_cmd.substring(index-1, index).toInt();
929 connection_bitmap &= ~(1 << id);
930 } else {
931 connection_bitmap = 0;
932 }
933 rx_cmd = "";
934 } else if ((index = rx_cmd.indexOf(",CONNECT")) != -1) {
935 /* <link ID>,CONNECT */
936 id = rx_cmd.substring(index-1, index).toInt();
937 connection_bitmap |= (1 << id);
938 rx_cmd = "";
939 } else if ((index = rx_cmd.indexOf("WIFI CONNECTED")) != -1) {
940 wifi_status = ESP8266_STATUS_CONNECTED;
941 rx_cmd = "";
942 } else if ((index = rx_cmd.indexOf("WIFI GOT IP")) != -1) {
943 wifi_status = ESP8266_STATUS_GOTIP;
944 rx_cmd = "";
945 } else if ((index = rx_cmd.indexOf("WIFI DISCONNECT")) != -1) {
946 wifi_status = ESP8266_STATUS_DISCONNECTED;
947 rx_cmd = "";
948 }
949}
950
951void ESP8266::rx_update(void)
952{
953 char a;
954
955 while(m_puart->available() > 0) {
956 a = m_puart->read();
957 rx_cmd += a;
958 recvAsyncdata(3000);
959 }
960}
961
962int ESP8266::recvString(String target1, String target2, String target3, uint32_t timeout)
963{
964 char a;
965 unsigned long start = millis();
966 while (millis() - start < timeout) {
967 while (m_puart->available() > 0) {
968 a = m_puart->read();
969 rx_cmd += a;
970 if (rx_cmd.indexOf(target1) != -1) {
971 return 1;
972 } else if ((target2.length() != 0 ) && (rx_cmd.indexOf(target2) != -1)) {
973 return 2;
974 } else if ((target3.length() != 0 ) && (rx_cmd.indexOf(target3) != -1)) {
975 return 3;
976 } else {
977 recvAsyncdata(timeout - (millis() - start));
978 }
979 }
980 WAIT_TIMEOUT;
981 }
982 return -1;
983}
984
985bool ESP8266::recvFind(String target, uint32_t timeout)
986{
987 int ret;
988
989 ret = recvString(target, "", "", timeout);
990 if (ret != -1) rx_cmd = "";
991 return (ret == 1);
992}
993
994bool ESP8266::recvFindAndFilter(String target, String begin, String end, String &data, uint32_t timeout)
995{
996 if (recvString(target, "", "", timeout) == 1) {
997 int32_t index1 = rx_cmd.indexOf(begin);
998 int32_t index2 = rx_cmd.indexOf(end);
999 if (index1 != -1 && index2 != -1) {
1000 index1 += begin.length();
1001 data = rx_cmd.substring(index1, index2);
1002 rx_cmd = "";
1003 return true;
1004 }
1005 }
1006 data = "";
1007 return false;
1008}
1009
1010bool ESP8266::eAT(void)
1011{
1012 rx_update();
1013 m_puart->println("AT");
1014 return recvFind("OK");
1015}
1016
1017bool ESP8266::eATRST(void)
1018{
1019 rx_update();
1020 m_puart->println("AT+RST");
1021 return recvFind("OK");
1022}
1023
1024bool ESP8266::eATGMR(String &version)
1025{
1026 rx_update();
1027 m_puart->println("AT+GMR");
1028 return recvFindAndFilter("OK", "\r\r\n", "\r\nOK", version);
1029}
1030/* checked */
1031bool ESP8266::qATCWMODE_CUR(uint8_t *mode)
1032{
1033 String str_mode;
1034 bool ret;
1035 if (!mode) {
1036 return false;
1037 }
1038 rx_update();
1039 m_puart->println("AT+CWMODE_CUR?");
1040 ret = recvFindAndFilter("OK", "+CWMODE_CUR:", "\r\n\r\nOK", str_mode);
1041 if (ret) {
1042 *mode = (uint8_t)str_mode.toInt();
1043 return true;
1044 } else {
1045 return false;
1046 }
1047}
1048/* checked */
1049bool ESP8266::sATCWMODE_CUR(uint8_t mode)
1050{
1051 int ret;
1052
1053 rx_update();
1054 m_puart->print("AT+CWMODE_CUR=");
1055 m_puart->println(mode);
1056
1057 ret = recvString("OK", "ERROR", "");
1058 if (ret != -1) rx_cmd = "";
1059 return (ret == 1);
1060}
1061/* checked */
1062bool ESP8266::sATCWJAP_CUR(String ssid, String pwd)
1063{
1064 int ret;
1065
1066 rx_update();
1067 m_puart->print("AT+CWJAP_CUR=\"");
1068 m_puart->print(ssid);
1069 m_puart->print("\",\"");
1070 m_puart->print(pwd);
1071 m_puart->println("\"");
1072
1073 ret = recvString("OK", "FAIL", "", 10000);
1074 if (ret != -1) rx_cmd = "";
1075 return (ret == 1);
1076}
1077
1078bool ESP8266::eATCWLAP(String &list)
1079{
1080 rx_update();
1081 m_puart->println("AT+CWLAP");
1082 return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list, 10000);
1083}
1084
1085bool ESP8266::eATCWQAP(void)
1086{
1087 rx_update();
1088 m_puart->println("AT+CWQAP");
1089 return recvFind("OK");
1090}
1091/* checked */
1092bool ESP8266::sATCWSAP_CUR(String ssid, String pwd, uint8_t chl, uint8_t ecn)
1093{
1094 int ret;
1095
1096 rx_update();
1097 m_puart->print("AT+CWSAP_CUR=\"");
1098 m_puart->print(ssid);
1099 m_puart->print("\",\"");
1100 m_puart->print(pwd);
1101 m_puart->print("\",");
1102 m_puart->print(chl);
1103 m_puart->print(",");
1104 m_puart->println(ecn);
1105
1106 ret = recvString("OK", "ERROR", "", 5000);
1107 if (ret != -1) rx_cmd = "";
1108 return (ret == 1);
1109}
1110
1111bool ESP8266::eATCWLIF(String &list)
1112{
1113 rx_update();
1114 m_puart->println("AT+CWLIF");
1115 return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list);
1116}
1117
1118bool ESP8266::eATCIPSTATUS(String &list)
1119{
1120 rx_update();
1121 m_puart->println("AT+CIPSTATUS");
1122 return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list);
1123}
1124
1125bool ESP8266::sATCIPSTARTSingle(String type, String addr, uint32_t port)
1126{
1127 int ret;
1128
1129 rx_update();
1130 m_puart->print("AT+CIPSTART=\"");
1131 m_puart->print(type);
1132 m_puart->print("\",\"");
1133 m_puart->print(addr);
1134 m_puart->print("\",");
1135 m_puart->println(port);
1136
1137 ret = recvString("OK", "ERROR", "ALREADY CONNECT", 10000);
1138 if (ret != -1) rx_cmd = "";
1139 return (ret == 1 || ret == 3);
1140}
1141
1142bool ESP8266::sATCIPSTARTMultiple(uint8_t mux_id, String type, String addr, uint32_t port)
1143{
1144 int ret;
1145
1146 rx_update();
1147 m_puart->print("AT+CIPSTART=");
1148 m_puart->print(mux_id);
1149 m_puart->print(",\"");
1150 m_puart->print(type);
1151 m_puart->print("\",\"");
1152 m_puart->print(addr);
1153 m_puart->print("\",");
1154 m_puart->println(port);
1155
1156 ret = recvString("OK", "ERROR", "ALREADY CONNECT", 10000);
1157 if (ret != -1) rx_cmd = "";
1158 return ((ret == 1)||(ret == 3));
1159}
1160
1161bool ESP8266::sATCIPSENDSingle(const uint8_t *buffer, uint32_t len)
1162{
1163 bool ret;
1164 rx_update();
1165 m_puart->print("AT+CIPSEND=");
1166 m_puart->println(len);
1167 if (recvFind(">", 5000)) {
1168 for (uint32_t i = 0; i < len; i++) {
1169 m_puart->write(buffer[i]);
1170 }
1171 ret = recvFind("SEND OK", 10000);
1172 return ret;
1173 }
1174
1175 return false;
1176}
1177
1178bool ESP8266::sATCIPSENDMultiple(uint8_t mux_id, const uint8_t *buffer, uint32_t len)
1179{
1180 rx_update();
1181 m_puart->print("AT+CIPSEND=");
1182 m_puart->print(mux_id);
1183 m_puart->print(",");
1184 m_puart->println(len);
1185 if (recvFind(">", 5000)) {
1186 for (uint32_t i = 0; i < len; i++) {
1187 m_puart->write(buffer[i]);
1188 }
1189 return recvFind("SEND OK", 10000);
1190 }
1191 return false;
1192}
1193
1194bool ESP8266::sATCIPSENDSingle(String &str)
1195{
1196 rx_update();
1197 m_puart->print("AT+CIPSEND=");
1198 m_puart->println(str.length());
1199 if (recvFind(">", 5000)) {
1200 for (uint32_t i = 0; i < str.length(); i++) {
1201 m_puart->write(str.charAt(i));
1202 }
1203 return recvFind("SEND OK", 10000);
1204 }
1205 return false;
1206}
1207
1208bool ESP8266::sATCIPSENDMultiple(uint8_t mux_id, String &str)
1209{
1210 rx_update();
1211 m_puart->print("AT+CIPSEND=");
1212 m_puart->print(mux_id);
1213 m_puart->print(",");
1214 m_puart->println(str.length());
1215 if (recvFind(">", 5000)) {
1216 for (uint32_t i = 0; i < str.length(); i++) {
1217 m_puart->write(str.charAt(i));
1218 }
1219 return recvFind("SEND OK", 10000);
1220 }
1221 return false;
1222}
1223
1224bool ESP8266::sATCIPCLOSEMulitple(uint8_t mux_id)
1225{
1226 int ret;
1227
1228 rx_update();
1229 m_puart->print("AT+CIPCLOSE=");
1230 m_puart->println(mux_id);
1231
1232 ret = recvString("OK", "link is not", "", 5000);
1233 if (ret != -1) rx_cmd = "";
1234 return ((ret == 1) || (ret == 2));
1235}
1236
1237bool ESP8266::eATCIPCLOSESingle(void)
1238{
1239 int ret;
1240
1241 Serial.println(rx_cmd);
1242 rx_update();
1243 m_puart->println("AT+CIPCLOSE");
1244 ret = recvString("OK", "ERROR", "", 5000);
1245 if (ret != -1) rx_cmd = "";
1246 return ((ret == 1) || (ret == 2));
1247}
1248
1249bool ESP8266::eATCIFSR(String &list)
1250{
1251 rx_update();
1252 m_puart->println("AT+CIFSR");
1253 return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list);
1254}
1255/* checked */
1256bool ESP8266::sATCIPMUX(uint8_t mode)
1257{
1258 int ret;
1259
1260 rx_update();
1261 m_puart->print("AT+CIPMUX=");
1262 m_puart->println(mode);
1263
1264 ret = recvString("OK", "ERROR", "");
1265 if (ret != -1) rx_cmd = "";
1266 return (ret == 1);
1267}
1268
1269bool ESP8266::sATCIPSERVER(uint8_t mode, uint32_t port)
1270{
1271 int ret;
1272
1273 if (mode) {
1274 rx_update();
1275 m_puart->print("AT+CIPSERVER=1,");
1276 m_puart->println(port);
1277 ret = recvString("OK", "ERROR", "");
1278 if (ret != -1) rx_cmd = "";
1279 return (ret == 1);
1280 } else {
1281 rx_update();
1282 m_puart->println("AT+CIPSERVER=0");
1283 ret = recvString("OK", "ERROR", "");
1284 if (ret != -1) rx_cmd = "";
1285 return (ret == 1);
1286 }
1287}
1288bool ESP8266::sATCIPSTO(uint32_t timeout)
1289{
1290 rx_update();
1291 m_puart->print("AT+CIPSTO=");
1292 m_puart->println(timeout);
1293 return recvFind("OK");
1294}
1295
Note: See TracBrowser for help on using the repository browser.