Changeset 177 for rtos_arduino

Timestamp:

Mar 28, 2016, 2:12:01 PM (8 years ago)

Author:

ertl-honda

Message:

実装と乖離してきたため削除．

Location:

rtos_arduino/trunk/arduino_lib/libraries/ESP8266_Arudino_AT

Files:

• ESP8266.cpp (modified) (38 diffs)
• ESP8266.h (modified) (12 diffs)
• doc (deleted)
• doxygen.doxy (deleted)
• doxygen.h (deleted)

rtos_arduino/trunk/arduino_lib/libraries/ESP8266_Arudino_AT/ESP8266.cpp

@@ -2 +2 @@
  * @file ESP8266.cpp
  * @brief The implementation of class ESP8266. 
- * @author Wu Pengfei<pengfei.wu@itead.cc> 
+ * @author Wu Pengfei<pengfei.wu@itead.cc>, Shinya Honda<honda@ertl.jp> 
  * @date 2015.02
  * 
@@ -26 +26 @@
 #define LOG_OUTPUT_DEBUG_PREFIX     (1)
 
+#define MUXID_ANY 255
+#define MUXID_SINGLE 0
+
 #ifdef TOPPERS_WITH_ARDUINO
 #define WAIT_TIMEOUT delay(1);
@@ -50 +53 @@
     } while(0)
 
+ESP8266_RingBuffer::ESP8266_RingBuffer(void)
+{
+    free(); 
+    buffer = NULL;
+}
+
+void ESP8266_RingBuffer::init(void)
+{
+    free();
+    if(buffer!=NULL) {
+        ::free(buffer);
+        buffer = NULL;
+    }
+}
+
+bool ESP8266_RingBuffer::write(uint8_t c)
+{
+    if (len == ESP8266_RINGBUFFER_SIZE) {return false;}  
+
+    if (buffer == NULL) {
+        buffer = (uint8_t*)malloc(ESP8266_RINGBUFFER_SIZE);
+        if(buffer == NULL) {return false;}
+    }
+
+    buffer[tail++] = c;
+    len++;
+
+    if (tail == ESP8266_RINGBUFFER_SIZE) {
+        tail = 0;
+    }
+    return true;
+}
+
+uint8_t ESP8266_RingBuffer::read(void)
+{
+    uint8_t c;
+    if (len == 0) {return 0;}
+    c = buffer[head++];
+    len--;
+    if (head == ESP8266_RINGBUFFER_SIZE) {
+        head = 0;
+    }
+    return c;
+}
+
+
+uint32_t ESP8266_RingBuffer::copy(uint8_t *pdata, uint32_t size)
+{
+    uint32_t ret;
+    uint32_t pdata_index = 0;
+
+    /* copy size */
+    ret = (len < size)? len : size;
+    
+    while((pdata_index < ret)) {
+        pdata[pdata_index++] = buffer[head++];
+        if (head == ESP8266_RINGBUFFER_SIZE) {
+            head = 0;
+        }
+    }
+
+    len -= ret;
+
+    return ret;
+}
+
+uint8_t ESP8266_RingBuffer::peek(void)
+{
+    if (len == 0) {return 0;}    
+    return buffer[head];
+}
+
+void ESP8266::initialize_status(void)
+{
+    wifi_status = ESP8266_STATUS_DISCONNECTED;
+    connection_bitmap = 0;
+    mux_mode = false;
+    rx_cmd = "";
+    for(int i = 0; i < ESP8266_NUM_CONNECTION; i++){
+        rx_buffer[i].init();
+    }
+}
+
 #ifdef ESP8266_USE_SOFTWARE_SERIAL
-void ESP8266::begin(SoftwareSerial &uart, uint32_t baud)
-{
+int ESP8266::begin(SoftwareSerial &uart, uint32_t baud)
+#else /* !ESP8266_USE_SOFTWARE_SERIAL */
+int ESP8266::begin(HardwareSerial &uart, uint32_t baud)
+#endif /* ESP8266_USE_SOFTWARE_SERIAL */
+{
+    String version;
+    
     m_puart = &uart;
     m_baud = baud;
     m_puart->begin(baud);
+    initialize_status();
     rx_empty();
-}
-#else
-void ESP8266::begin(HardwareSerial &uart, uint32_t baud)
-{
-    m_puart = &uart;
-    m_baud = baud;
-    m_puart->begin(baud);
-    rx_empty();
-}
-#endif
+    
+    if (!kick()) {
+        return 1;
+    }
+    
+    eATGMR(version);
+    if(version.indexOf(ESP8266_SUPPORT_VERSION) == -1) {
+        return 2;
+    }
+    
+    return 0;
+}
 
 bool ESP8266::kick(void)
@@ -76 +170 @@
 {
     unsigned long start;
+    initialize_status();
     if (eATRST()) {
         m_puart->end();
@@ -102 +197 @@
 {
     uint8_t mode;
-    if (!qATCWMODE(&mode)) {
+    if (!qATCWMODE_CUR(&mode)) {
         return false;
     }
-    if (mode == 1) {
+    if (mode == ESP8266_WMODE_STATION) {
         return true;
     } else {
-        if (sATCWMODE(1) && restart()) {
+        if (sATCWMODE_CUR(ESP8266_WMODE_STATION) && restart()) {
             return true;
         } else {
@@ -119 +214 @@
 {
     uint8_t mode;
-    if (!qATCWMODE(&mode)) {
+    if (!qATCWMODE_CUR(&mode)) {
         return false;
     }
-    if (mode == 2) {
+    if (mode == ESP8266_WMODE_SOFTAP) {
         return true;
     } else {
-        if (sATCWMODE(2) && restart()) {
+        if (sATCWMODE_CUR(ESP8266_WMODE_SOFTAP) && restart()) {
             return true;
         } else {
@@ -136 +231 @@
 {
     uint8_t mode;
-    if (!qATCWMODE(&mode)) {
+    if (!qATCWMODE_CUR(&mode)) {
         return false;
     }
-    if (mode == 3) {
+    if (mode == ESP8266_WMODE_AP_STATION) {
         return true;
     } else {
-        if (sATCWMODE(3) && restart()) {
+        if (sATCWMODE_CUR(ESP8266_WMODE_AP_STATION) && restart()) {
             return true;
         } else {
@@ -159 +254 @@
 bool ESP8266::joinAP(String ssid, String pwd)
 {
-    return sATCWJAP(ssid, pwd);
+    return sATCWJAP_CUR(ssid, pwd);
 }
 
@@ -169 +264 @@
 bool ESP8266::setSoftAPParam(String ssid, String pwd, uint8_t chl, uint8_t ecn)
 {
-    return sATCWSAP(ssid, pwd, chl, ecn);
+    return sATCWSAP_CUR(ssid, pwd, chl, ecn);
 }
 
@@ -189 +284 @@
 {
     String list;
+    int32_t index_start = -1;
+    int32_t index_end = -1;
+    
     eATCIFSR(list);
-    return list;
+    index_start = list.indexOf('\"');
+    index_end   = list.indexOf('\"', list.indexOf('\"')+1);
+    if ((index_start !=  -1) && (index_end != -1)) {
+        return list.substring(index_start+1, index_end);
+    }
+    return "";
 }
 
 bool ESP8266::enableMUX(void)
 {
-    return sATCIPMUX(1);
+    if (sATCIPMUX(1)) {
+        mux_mode = true;
+        return true;
+      }
+    return false;
 }
 
 bool ESP8266::disableMUX(void)
 {
-    return sATCIPMUX(0);
+    if (sATCIPMUX(0)){
+        mux_mode = false;
+        return true;
+    }
+    return false;
 }
 
 bool ESP8266::createTCP(String addr, uint32_t port)
 {
-    return sATCIPSTARTSingle("TCP", addr, port);
+    bool ret;
+    if (mux_mode) return false;
+
+    if((ret = sATCIPSTARTSingle("TCP", addr, port))) {
+        connection_bitmap = 1;
+    }
+    return ret;
 }
 
 bool ESP8266::releaseTCP(void)
 {
-    return eATCIPCLOSESingle();
+    bool ret;
+    
+    if (mux_mode) return false;    
+    if((ret = eATCIPCLOSESingle())) {
+        connection_bitmap = 0;
+        rx_buffer[MUXID_SINGLE].free();
+    }
+    return ret;    
 }
 
 bool ESP8266::registerUDP(String addr, uint32_t port)
 {
-    return sATCIPSTARTSingle("UDP", addr, port);
+    bool ret;
+    if (mux_mode) return false;
+    if((ret = sATCIPSTARTSingle("UDP", addr, port))) {
+        connection_bitmap = 1;
+    }    
+    return ret;
 }
 
 bool ESP8266::unregisterUDP(void)
 {
-    return eATCIPCLOSESingle();
+    bool ret;
+    if (mux_mode) return false;
+    if((ret = eATCIPCLOSESingle())) {
+        connection_bitmap = 0;
+        rx_buffer[MUXID_SINGLE].free();
+    }    
+    return ret;    
 }
 
 bool ESP8266::createTCP(uint8_t mux_id, String addr, uint32_t port)
 {
-    return sATCIPSTARTMultiple(mux_id, "TCP", addr, port);
+    bool ret;
+    if (!(mux_id < ESP8266_NUM_CONNECTION)) return false;
+    if (!mux_mode) return false;
+    
+    if((ret = sATCIPSTARTMultiple(mux_id, "TCP", addr, port))) {
+        connection_bitmap |= 1 << mux_id;
+    }
+    return ret;
 }
 
 bool ESP8266::releaseTCP(uint8_t mux_id)
 {
-    return sATCIPCLOSEMulitple(mux_id);
+    bool ret;
+    if (!(mux_id < ESP8266_NUM_CONNECTION)) return false;
+    if (!mux_mode) return false;
+    
+    if ((ret = sATCIPCLOSEMulitple(mux_id))) {
+        connection_bitmap &= ~(1 << mux_id);
+        rx_buffer[mux_id].free();
+    }
+    return ret;
 }
 
 bool ESP8266::registerUDP(uint8_t mux_id, String addr, uint32_t port)
 {
-    return sATCIPSTARTMultiple(mux_id, "UDP", addr, port);
+    bool ret;
+    if (!(mux_id < ESP8266_NUM_CONNECTION)) return false;
+    if (!mux_mode) return false;
+    
+    if ((ret = sATCIPSTARTMultiple(mux_id, "UDP", addr, port))) {
+        connection_bitmap |= 1 << mux_id;
+    }
+    return ret;
 }
 
 bool ESP8266::unregisterUDP(uint8_t mux_id)
 {
-    return sATCIPCLOSEMulitple(mux_id);
+    bool ret;    
+    if (!(mux_id < ESP8266_NUM_CONNECTION)) return false;
+    if (!mux_mode) return false;
+    
+    if ((ret = sATCIPCLOSEMulitple(mux_id))) {
+        connection_bitmap &= ~(1 << mux_id);
+        rx_buffer[mux_id].free();
+    }
+    return ret;    
 }
 
 bool ESP8266::setTCPServerTimeout(uint32_t timeout)
 {
+    if (!mux_mode) return false;
     return sATCIPSTO(timeout);
 }
@@ -250 +416 @@
 bool ESP8266::startTCPServer(uint32_t port)
 {
+    if (!mux_mode) return false;
     if (sATCIPSERVER(1, port)) {
         return true;
@@ -259 +426 @@
 {
     sATCIPSERVER(0);
-    restart();
     return false;
 }
@@ -265 +431 @@
 bool ESP8266::startServer(uint32_t port)
 {
+    if (!mux_mode) return false;    
     return startTCPServer(port);
 }
@@ -275 +442 @@
 bool ESP8266::send(const uint8_t *buffer, uint32_t len)
 {
+    if (mux_mode) return 0;
     return sATCIPSENDSingle(buffer, len);
 }
@@ -280 +448 @@
 bool ESP8266::send(uint8_t mux_id, const uint8_t *buffer, uint32_t len)
 {
+    if (!mux_mode) return false;
     return sATCIPSENDMultiple(mux_id, buffer, len);
 }
@@ -285 +454 @@
 bool ESP8266::send(String &str)
 {
+    if (mux_mode) return 0;
     return sATCIPSENDSingle(str);
 }
@@ -290 +460 @@
 bool ESP8266::send(uint8_t mux_id, String &str)
 {
+    if (!mux_mode) return false;
+    if (!(mux_id < ESP8266_NUM_CONNECTION)) return false;
+    
     return sATCIPSENDMultiple(mux_id, str);
 }
@@ -295 +468 @@
 uint32_t ESP8266::recv(uint8_t *buffer, uint32_t buffer_size, uint32_t timeout)
 {
-    return recvPkg(buffer, buffer_size, NULL, timeout, NULL);
+    if (mux_mode) return 0;
+    return recvPkg(buffer, buffer_size, timeout, 0, NULL);
 }
 
 uint32_t ESP8266::recv(uint8_t mux_id, uint8_t *buffer, uint32_t buffer_size, uint32_t timeout)
 {
-    uint8_t id;
-    uint32_t ret;
-    ret = recvPkg(buffer, buffer_size, NULL, timeout, &id);
-    if (ret > 0 && id == mux_id) {
-        return ret;
-    }
+    if (!mux_mode) return false;
+    if (!(mux_id < ESP8266_NUM_CONNECTION)) return false;
+    
+    return recvPkg(buffer, buffer_size, timeout, mux_id, NULL);
+}
+
+uint32_t ESP8266::recv(uint8_t *coming_mux_id, uint8_t *buffer, uint32_t buffer_size, uint32_t timeout)
+{
+    if (!mux_mode) return false;
+    return recvPkg(buffer, buffer_size, timeout, MUXID_ANY, coming_mux_id);
+}
+
+bool ESP8266::isDataAvailable(uint8_t mux_id)
+{
+    if (!mux_mode) return false;
+    if (!(mux_id < ESP8266_NUM_CONNECTION)) return false;
+
+    if(rx_buffer[mux_id].length() > 0) return true;
+    rx_update();
+    if(rx_buffer[mux_id].length() > 0) return true;
     return 0;
 }
 
-uint32_t ESP8266::recv(uint8_t *coming_mux_id, uint8_t *buffer, uint32_t buffer_size, uint32_t timeout)
-{
-    return recvPkg(buffer, buffer_size, NULL, timeout, coming_mux_id);
-}
-
-int ESP8266::dataAvailable(void)
-{
-    return (m_puart->available() > 0)? 1 : 0;
-}
-            
+bool ESP8266::isDataAvailable(void)
+{
+    if (mux_mode) {
+        for(int i = 0; i < ESP8266_NUM_CONNECTION; i++){
+            if(rx_buffer[i].length() > 0) return true;
+        }
+        rx_update();
+        for(int i = 0; i < ESP8266_NUM_CONNECTION; i++){
+            if(rx_buffer[i].length() > 0) return true;
+        }
+    }
+    else {
+        /* single mode */
+        if(rx_buffer[0].length() > 0) return true;
+        rx_update();
+        if(rx_buffer[0].length() > 0) return true;        
+    }
+    return false;
+}
+
+bool ESP8266::isConnected(void)
+{
+    if (mux_mode) return false;    
+    rx_update();
+    return (connection_bitmap == 1);
+}
+
+bool ESP8266::isConnected(uint8_t mux_id)
+{
+    if (!mux_mode) return false;    
+    if (!(mux_id < ESP8266_NUM_CONNECTION)) return false;
+    rx_update();
+    return ((connection_bitmap & (1<<mux_id)) != 0);
+}
+
+bool ESP8266::getMuxCStatus(uint8_t *mux_id_ptn)
+{
+    if (!mux_mode) return false;    
+    rx_update();
+    *mux_id_ptn = connection_bitmap;
+    return true;
+}
+
 /*----------------------------------------------------------------------------*/
 /* +IPD,<id>,<len>:<data> */
 /* +IPD,<len>:<data> */
 
-uint32_t ESP8266::recvPkg(uint8_t *buffer, uint32_t buffer_size, uint32_t *data_len, uint32_t timeout, uint8_t *coming_mux_id)
+uint32_t ESP8266::recvPkg(uint8_t *buffer, uint32_t buffer_size, uint32_t timeout,
+                          uint8_t mux_id, uint8_t *coming_mux_id)
+{    
+    char a;
+    unsigned long start;
+    uint32_t ret;
+    uint32_t recv_mux_id = 0;
+    
+    /*
+     * Try to recive data from rx_buffer
+     */
+    if (mux_id == MUXID_ANY) {
+        for(int i = 0; i < ESP8266_NUM_CONNECTION; i++){
+            if(rx_buffer[i].length() > 0) {
+                recv_mux_id = i;
+                *coming_mux_id = i;
+                break;
+            }
+        }
+    }
+    else {
+        recv_mux_id = mux_id;
+    }
+    
+    if(rx_buffer[recv_mux_id].length() > 0) {
+        return rx_buffer[recv_mux_id].copy(buffer, buffer_size);
+    }
+
+    /*
+     * Try to recive data from uart
+     */    
+    start = millis();
+    while (millis() - start < timeout) {
+        while(m_puart->available() > 0) {            
+            a = m_puart->read();
+            rx_cmd += a;
+            if (rx_cmd.indexOf("+IPD,") != -1) {
+                if((ret = recvIPD(timeout - (millis() - start), buffer, buffer_size,
+                                  mux_id, coming_mux_id)) > 0) {
+                    rx_cmd = "";
+                    return ret;
+                }
+            } else {
+                recvAsyncdata();
+            }
+        }
+        WAIT_TIMEOUT;
+    }
+    return 0;
+}
+
+/*
+ * call after read  +IPD,
+ * +IPD,<id>,<len>:<data>
+ * +IPD,<len>:<data>
+ */
+uint32_t ESP8266::recvIPD(uint32_t timeout, uint8_t *buffer, uint32_t buffer_size,
+                          uint8_t mux_id, uint8_t *coming_mux_id)
 {
     String data;
     char a;
-    int32_t index_PIPDcomma = -1;
+    unsigned long start;
     int32_t index_colon = -1; /* : */
     int32_t index_comma = -1; /* , */
@@ -334 +612 @@
     bool has_data = false;
     uint32_t ret;
-    unsigned long start;
     uint32_t i;
-    
-    if (buffer == NULL) {
-        return 0;
-    }
-    
+    ESP8266_RingBuffer *p_rx_buffer;
+      
     start = millis();
-    while (millis() - start < timeout) {
+    while (millis() - start < timeout) {        
         if(m_puart->available() > 0) {
             a = m_puart->read();
             data += a;
-        }else{
-            WAIT_TIMEOUT;
-        }
-        
-        index_PIPDcomma = data.indexOf("+IPD,");
-        if (index_PIPDcomma != -1) {
-            index_colon = data.indexOf(':', index_PIPDcomma + 5);
-            if (index_colon != -1) {
-                index_comma = data.indexOf(',', index_PIPDcomma + 5);
-                /* +IPD,id,len:data */
-                if (index_comma != -1 && index_comma < index_colon) { 
-                    id = data.substring(index_PIPDcomma + 5, index_comma).toInt();
-                    if (id < 0 || id > 4) {
+            if((index_colon = data.indexOf(':')) != -1) {
+                if(((index_comma = data.indexOf(',')) != -1) && index_comma < index_colon) {
+                    /* +IPD,id,len:data */
+                    id = data.substring(0, index_comma).toInt();
+                    if (id < 0 || id > (ESP8266_NUM_CONNECTION-1)) {
                         return 0;
                     }
@@ -365 +631 @@
                         return 0;
                     }
-                } else { /* +IPD,len:data */
-                    len = data.substring(index_PIPDcomma + 5, index_colon).toInt();
+                }
+                else {
+                    /* +IPD,len:data */
+                    len = data.substring(0, index_colon).toInt();
+                    id = 0;
                     if (len <= 0) {
                         return 0;
@@ -375 +644 @@
             }
         }
+        else {
+            WAIT_TIMEOUT;
+        }
     }
     
     if (has_data) {
-        i = 0;
-        ret = (uint32_t)len > buffer_size ? buffer_size : len;
-        start = millis();
-        while (millis() - start < 3000) {
-            while(m_puart->available() > 0 && i < ret) {
-                a = m_puart->read();
-                buffer[i++] = a;
+        p_rx_buffer = (id == -1)? &rx_buffer[0] : &rx_buffer[id];
+        if (buffer == NULL || ((mux_id != MUXID_ANY) && (id != mux_id))) {
+            /* Store in rx_buffer */        
+            start = millis();
+            i = 0;
+            while (millis() - start < 3000) {
+                while((m_puart->available() > 0) && (i < (uint32_t)len)) {
+                    a = m_puart->read();
+                    p_rx_buffer->write(a);
+                    i++;
+                }
+                if (i == (uint32_t)len) {
+                    return len;
+                }
+                WAIT_TIMEOUT
+            }            
+            return 0;
+        }
+        else {
+            /* Store in buffer */
+            i = 0;
+            ret = ((uint32_t)len > buffer_size) ? buffer_size : len;
+            start = millis();
+            while ((millis() - start) < 3000) {
+                while((m_puart->available() > 0) && (i < (uint32_t)len)) {                    
+                    a = m_puart->read();
+                    if(i < buffer_size) {
+                        buffer[i] = a;
+                    } else {
+                        p_rx_buffer->write(a);
+                    }
+                    i++;
+                }
+                if (i == (uint32_t)len) {
+                    if (mux_id == MUXID_ANY) {
+                        *coming_mux_id = id;
+                    }
+                    return ret;
+                }
+                WAIT_TIMEOUT;
             }
-            if (i == ret) {
-                rx_empty();
-                if (data_len) {
-                    *data_len = len;    
-                }
-                if (index_comma != -1 && coming_mux_id) {
-                    *coming_mux_id = id;
-                }
-                return ret;
-            }
-            WAIT_TIMEOUT
-        }
-    }
+        }        
+    }
+    
     return 0;
 }
@@ -409 +704 @@
 }
 
-String ESP8266::recvString(String target, uint32_t timeout)
-{
-    String data;
+void ESP8266::recvAsyncdata(uint32_t timeout)
+{
+    int index;
+    int id;
+
+    if (rx_cmd.indexOf("+IPD,") != -1) {
+        if(recvIPD(timeout) > 0) {
+            rx_cmd = "";
+        }
+    } else if (rx_cmd.indexOf("CLOSED") != -1) {
+        if ((index = rx_cmd.indexOf(",CLOSED")) != -1) {
+            /* <link ID>,CLOSED */
+            id = rx_cmd.substring(index-1, index).toInt();
+            connection_bitmap &= ~(1 << id);
+        } else {
+            connection_bitmap = 0;                
+        }
+        rx_cmd = "";
+    } else if ((index = rx_cmd.indexOf(",CONNECT")) != -1) {
+        /* <link ID>,CONNECT */
+        id = rx_cmd.substring(index-1, index).toInt();
+        connection_bitmap |= (1 << id);
+        rx_cmd = "";
+    } else if ((index = rx_cmd.indexOf("WIFI CONNECTED")) != -1) {
+        wifi_status = ESP8266_STATUS_CONNECTED;
+        rx_cmd = "";
+    } else if ((index = rx_cmd.indexOf("WIFI GOT IP")) != -1) {
+        wifi_status = ESP8266_STATUS_GOTIP;
+        rx_cmd = "";        
+    } else if ((index = rx_cmd.indexOf("WIFI DISCONNECT")) != -1) {
+        wifi_status = ESP8266_STATUS_DISCONNECTED;
+        rx_cmd = "";        
+    }    
+}
+
+void ESP8266::rx_update(void)
+{
+    char a;
+    
+    while(m_puart->available() > 0) {
+        a = m_puart->read();
+        rx_cmd += a;
+        recvAsyncdata(3000);
+    }
+}
+
+int ESP8266::recvString(String target1, String target2, String target3, uint32_t timeout)
+{
     char a;
     unsigned long start = millis();
     while (millis() - start < timeout) {
-        while(m_puart->available() > 0) {
+        while (m_puart->available() > 0) {            
             a = m_puart->read();
-            if(a == '\0') continue;
-            data += a;
-        }
-        if (data.indexOf(target) != -1) {
-            break;
-        }
-        WAIT_TIMEOUT
-    }
-    return data;
-}
-
-String ESP8266::recvString(String target1, String target2, uint32_t timeout)
-{
-    String data;
-    char a;
-    unsigned long start = millis();
-    while (millis() - start < timeout) {
-        while(m_puart->available() > 0) {
-            a = m_puart->read();
-            if(a == '\0') continue;
-            data += a;
-        }
-        if (data.indexOf(target1) != -1) {
-            break;
-        } else if (data.indexOf(target2) != -1) {
-            break;
-        }
-        WAIT_TIMEOUT
-    }
-    return data;
-}
-
-String ESP8266::recvString(String target1, String target2, String target3, uint32_t timeout)
-{
-    String data;
-    char a;
-    unsigned long start = millis();
-    while (millis() - start < timeout) {
-        while(m_puart->available() > 0) {
-            a = m_puart->read();
-            if(a == '\0') continue;
-            data += a;
-        }
-        if (data.indexOf(target1) != -1) {
-            break;
-        } else if (data.indexOf(target2) != -1) {
-            break;
-        } else if (data.indexOf(target3) != -1) {
-            break;
-        }
-        WAIT_TIMEOUT
-    }
-    return data;
+            rx_cmd += a;
+            if (rx_cmd.indexOf(target1) != -1) {
+                return 1;
+            } else if ((target2.length() != 0 ) && (rx_cmd.indexOf(target2) != -1)) {
+                return 2;
+            } else if ((target3.length() != 0 ) && (rx_cmd.indexOf(target3) != -1)) {
+                return 3;
+            } else {
+                recvAsyncdata(timeout - (millis() - start));
+            }
+        }
+        WAIT_TIMEOUT;
+    }
+    return -1;
 }
 
 bool ESP8266::recvFind(String target, uint32_t timeout)
 {
-    String data_tmp;
-    data_tmp = recvString(target, timeout);
-    if (data_tmp.indexOf(target) != -1) {
-        return true;
-    }
-    return false;
+    int ret;
+    
+    ret = recvString(target, "", "", timeout);
+    if (ret != -1) rx_cmd = "";
+    return (ret == 1);
 }
 
 bool ESP8266::recvFindAndFilter(String target, String begin, String end, String &data, uint32_t timeout)
 {
-    String data_tmp;
-    data_tmp = recvString(target, timeout);
-    if (data_tmp.indexOf(target) != -1) {
-        int32_t index1 = data_tmp.indexOf(begin);
-        int32_t index2 = data_tmp.indexOf(end);
+    if (recvString(target, "", "", timeout) == 1) {
+        int32_t index1 = rx_cmd.indexOf(begin);
+        int32_t index2 = rx_cmd.indexOf(end);
         if (index1 != -1 && index2 != -1) {
             index1 += begin.length();
-            data = data_tmp.substring(index1, index2);
+            data = rx_cmd.substring(index1, index2);
+            rx_cmd = "";
             return true;
         }
@@ -501 +800 @@
 bool ESP8266::eAT(void)
 {
-    rx_empty();
     m_puart->println("AT");
     return recvFind("OK");
@@ -508 +806 @@
 bool ESP8266::eATRST(void) 
 {
-    rx_empty();
     m_puart->println("AT+RST");
     return recvFind("OK");
@@ -515 +812 @@
 bool ESP8266::eATGMR(String &version)
 {
-    rx_empty();
     m_puart->println("AT+GMR");
     return recvFindAndFilter("OK", "\r\r\n", "\r\nOK", version); 
 }
-
-bool ESP8266::qATCWMODE(uint8_t *mode) 
+/* checked */
+bool ESP8266::qATCWMODE_CUR(uint8_t *mode) 
 {
     String str_mode;
@@ -527 +823 @@
         return false;
     }
-    rx_empty();
-    m_puart->println("AT+CWMODE?");
-    ret = recvFindAndFilter("OK", "+CWMODE:", "\r\n\r\nOK", str_mode); 
+    m_puart->println("AT+CWMODE_CUR?");
+    ret = recvFindAndFilter("OK", "+CWMODE_CUR:", "\r\n\r\nOK", str_mode); 
     if (ret) {
         *mode = (uint8_t)str_mode.toInt();
@@ -537 +832 @@
     }
 }
-
-bool ESP8266::sATCWMODE(uint8_t mode)
-{
-    String data;
-    rx_empty();
-    m_puart->print("AT+CWMODE=");
+/* checked */
+bool ESP8266::sATCWMODE_CUR(uint8_t mode)
+{
+    int ret;
+    
+    m_puart->print("AT+CWMODE_CUR=");
     m_puart->println(mode);
-    
-    data = recvString("OK", "no change");
-    if (data.indexOf("OK") != -1 || data.indexOf("no change") != -1) {
-        return true;
-    }
-    return false;
-}
-
-bool ESP8266::sATCWJAP(String ssid, String pwd)
-{
-    String data;
-    rx_empty();
+
+    ret = recvString("OK", "ERROR", "");
+    if (ret != -1) rx_cmd = "";
+    return (ret == 1);
+}
+/* checked */
+bool ESP8266::sATCWJAP_CUR(String ssid, String pwd)
+{
+    int ret;
+    
     m_puart->print("AT+CWJAP=\"");
     m_puart->print(ssid);
@@ -562 +855 @@
     m_puart->println("\"");
     
-    data = recvString("OK", "FAIL", 10000);
-    if (data.indexOf("OK") != -1) {
-        return true;
-    }
-    return false;
+    ret = recvString("OK", "FAIL", "", 10000);
+    if (ret != -1) rx_cmd = "";
+    return (ret == 1);
 }
 
 bool ESP8266::eATCWLAP(String &list)
 {
-    String data;
-    rx_empty();
     m_puart->println("AT+CWLAP");
     return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list, 10000);
@@ -579 +868 @@
 bool ESP8266::eATCWQAP(void)
 {
-    String data;
-    rx_empty();
     m_puart->println("AT+CWQAP");
     return recvFind("OK");
 }
-
-bool ESP8266::sATCWSAP(String ssid, String pwd, uint8_t chl, uint8_t ecn)
-{
-    String data;
-    rx_empty();
-    m_puart->print("AT+CWSAP=\"");
+/* checked */
+bool ESP8266::sATCWSAP_CUR(String ssid, String pwd, uint8_t chl, uint8_t ecn)
+{
+    int ret;
+    
+    m_puart->print("AT+CWSAP_CUR=\"");
     m_puart->print(ssid);
     m_puart->print("\",\"");
@@ -598 +885 @@
     m_puart->println(ecn);
     
-    data = recvString("OK", "ERROR", 5000);
-    if (data.indexOf("OK") != -1) {
-        return true;
-    }
-    return false;
+    ret = recvString("OK", "ERROR", "", 5000);
+    if (ret != -1) rx_cmd = "";
+    return (ret == 1);
 }
 
 bool ESP8266::eATCWLIF(String &list)
 {
-    String data;
-    rx_empty();
     m_puart->println("AT+CWLIF");
     return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list);
 }
+
 bool ESP8266::eATCIPSTATUS(String &list)
 {
-    String data;
-    delay(100);
-    rx_empty();
     m_puart->println("AT+CIPSTATUS");
     return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list);
 }
+
 bool ESP8266::sATCIPSTARTSingle(String type, String addr, uint32_t port)
 {
-    String data;
-    rx_empty();
+    int ret;
+    
     m_puart->print("AT+CIPSTART=\"");
     m_puart->print(type);
@@ -631 +913 @@
     m_puart->println(port);
     
-    data = recvString("OK", "ERROR", "ALREADY CONNECT", 10000);
-    if (data.indexOf("OK") != -1 || data.indexOf("ALREADY CONNECT") != -1) {
-        return true;
-    }
-    return false;
-}
+    ret = recvString("OK", "ERROR", "ALREADY CONNECT", 10000);
+    if (ret != -1) rx_cmd = "";
+    return (ret == 1 || ret == 3);
+}
+
 bool ESP8266::sATCIPSTARTMultiple(uint8_t mux_id, String type, String addr, uint32_t port)
 {
-    String data;
-    rx_empty();
+    int ret;
+    
     m_puart->print("AT+CIPSTART=");
     m_puart->print(mux_id);
@@ -650 +931 @@
     m_puart->println(port);
     
-    data = recvString("OK", "ERROR", "ALREADY CONNECT", 10000);
-    if (data.indexOf("OK") != -1 || data.indexOf("ALREADY CONNECT") != -1) {
-        return true;
-    }
-    return false;
-}
+    ret = recvString("OK", "ERROR", "ALREADY CONNECT", 10000);
+    if (ret != -1) rx_cmd = "";
+    return ((ret == 1)||(ret == 3));
+}
+
 bool ESP8266::sATCIPSENDSingle(const uint8_t *buffer, uint32_t len)
 {
-    rx_empty();
     m_puart->print("AT+CIPSEND=");
     m_puart->println(len);
     if (recvFind(">", 5000)) {
-        rx_empty();
         for (uint32_t i = 0; i < len; i++) {
             m_puart->write(buffer[i]);
@@ -670 +948 @@
     return false;
 }
+
 bool ESP8266::sATCIPSENDMultiple(uint8_t mux_id, const uint8_t *buffer, uint32_t len)
 {
-    rx_empty();
     m_puart->print("AT+CIPSEND=");
     m_puart->print(mux_id);
@@ -678 +956 @@
     m_puart->println(len);
     if (recvFind(">", 5000)) {
-        rx_empty();
         for (uint32_t i = 0; i < len; i++) {
             m_puart->write(buffer[i]);
@@ -686 +963 @@
     return false;
 }
+
 bool ESP8266::sATCIPSENDSingle(String &str)
 {
-    rx_empty();
     m_puart->print("AT+CIPSEND=");
     m_puart->println(str.length());
     if (recvFind(">", 5000)) {
-        rx_empty();
         for (uint32_t i = 0; i < str.length(); i++) {
             m_puart->write(str.charAt(i));
@@ -700 +976 @@
     return false;
 }
+
 bool ESP8266::sATCIPSENDMultiple(uint8_t mux_id, String &str)
 {
-    rx_empty();
     m_puart->print("AT+CIPSEND=");
     m_puart->print(mux_id);
@@ -708 +984 @@
     m_puart->println(str.length());
     if (recvFind(">", 5000)) {
-        rx_empty();
         for (uint32_t i = 0; i < str.length(); i++) {
             m_puart->write(str.charAt(i));
@@ -716 +991 @@
     return false;
 }
+
 bool ESP8266::sATCIPCLOSEMulitple(uint8_t mux_id)
 {
-    String data;
-    rx_empty();
+    int ret;
+    
     m_puart->print("AT+CIPCLOSE=");
     m_puart->println(mux_id);
     
-    data = recvString("OK", "link is not", 5000);
-    if (data.indexOf("OK") != -1 || data.indexOf("link is not") != -1) {
-        return true;
-    }
-    return false;
-}
+    ret = recvString("OK", "link is not", "", 5000);
+    if (ret != -1) rx_cmd = "";
+    return ((ret == 1) || (ret == 2));
+}
+
 bool ESP8266::eATCIPCLOSESingle(void)
 {
-    rx_empty();
     m_puart->println("AT+CIPCLOSE");
     return recvFind("OK", 5000);
 }
+
 bool ESP8266::eATCIFSR(String &list)
 {
-    rx_empty();
     m_puart->println("AT+CIFSR");
     return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list);
 }
+/* checked */
 bool ESP8266::sATCIPMUX(uint8_t mode)
 {
-    String data;
-    rx_empty();
+    int ret;
+    
     m_puart->print("AT+CIPMUX=");
     m_puart->println(mode);
     
-    data = recvString("OK", "Link is builded");
-    if (data.indexOf("OK") != -1) {
-        return true;
-    }
-    return false;
-}
+    ret = recvString("OK", "ERROR", "");
+    if (ret != -1) rx_cmd = "";
+    return (ret == 1);    
+}
+
 bool ESP8266::sATCIPSERVER(uint8_t mode, uint32_t port)
 {
-    String data;
+    int ret;
+    
     if (mode) {
-        rx_empty();
         m_puart->print("AT+CIPSERVER=1,");
-        m_puart->println(port);
-        
-        data = recvString("OK", "no change");
-        if (data.indexOf("OK") != -1 || data.indexOf("no change") != -1) {
-            return true;
-        }
-        return false;
+        m_puart->println(port);        
+        ret = recvString("OK", "ERROR", "");
+        if (ret != -1) rx_cmd = "";
+        return (ret == 1);
     } else {
-        rx_empty();
         m_puart->println("AT+CIPSERVER=0");
-        return recvFind("\r\r\n");
+        ret = recvString("OK", "ERROR", "");
+        if (ret != -1) rx_cmd = "";
+        return (ret == 1);        
     }
 }
 bool ESP8266::sATCIPSTO(uint32_t timeout)
 {
-    rx_empty();
     m_puart->print("AT+CIPSTO=");
     m_puart->println(timeout);

rtos_arduino/trunk/arduino_lib/libraries/ESP8266_Arudino_AT/ESP8266.h

@@ -26 +26 @@
 #include "Arduino.h"
 
-
 //#define ESP8266_USE_SOFTWARE_SERIAL
 
+#define ESP8266_SUPPORT_VERSION "AT version:0.25"
+
+#define ESP8266_NUM_CONNECTION 5
 
 #ifdef ESP8266_USE_SOFTWARE_SERIAL
 #include "SoftwareSerial.h"
-#endif
-
+#endif /* ESP8266_USE_SOFTWARE_SERIAL */
+
+#define ESP8266_CONNECTION_OPEN     0x01
+#define ESP8266_CONNECTION_CLOSE    0x02
+
+#define ESP8266_CONNECTION_TCP      0x01
+#define ESP8266_CONNECTION_UDP      0x02
+
+#define ESP8266_CONNECTION_CLIENT   0x01
+#define ESP8266_CONNECTION_SERVER   0x02
+
+#define ESP8266_STATUS_GOTIP        0x02
+#define ESP8266_STATUS_CONNECTED    0x03
+#define ESP8266_STATUS_DISCONNECTED 0x04
+
+#define ESP8266_WMODE_STATION       0x01
+#define ESP8266_WMODE_SOFTAP        0x02
+#define ESP8266_WMODE_AP_STATION    0x03
+
+struct esp8266_connection_status
+{
+    uint8_t connection_type;
+    uint8_t protocol_type;
+};
+
+#define ESP8266_RINGBUFFER_SIZE  512
+
+class ESP8266_RingBuffer
+{
+  public:
+    ESP8266_RingBuffer(void);
+    void init(void);
+    void free(void) {len = head = tail = 0;};
+    bool write(uint8_t c);
+    uint8_t read(void);
+    uint32_t copy(uint8_t *pdata, uint32_t size);
+    uint8_t peek(void);
+    bool available(void) {return (len > 0);};
+    bool isFull(void) {return (len == ESP8266_RINGBUFFER_SIZE);};
+    uint32_t length(void) {return len;};
+    
+  private:
+    uint8_t *buffer;
+    uint32_t head;
+    uint32_t tail;
+    uint32_t len;
+};
 
 /**
@@ -41 +88 @@
  public:
 
-#ifdef ESP8266_USE_SOFTWARE_SERIAL
     /*
      * Begin.
@@ -48 +94 @@
      * @param baud - the buad rate to communicate with ESP8266(default:115200). 
      *
-     * @warning parameter baud depends on the AT firmware. 115200 is an common value. 
-     */
-    void begin(SoftwareSerial &uart, uint32_t baud = 115200);
+     * @retval 0 : Success
+     * @retval 1 : Can not communicate ESP8266
+     * @retval 2 : Firmware Version mismatch.
+     *      
+     * @warning parameter baud depends on the AT firmware. 115200 is an common value.
+     */
+#ifdef ESP8266_USE_SOFTWARE_SERIAL    
+    int begin(SoftwareSerial &uart, uint32_t baud = 115200);
 #else /* HardwareSerial */
-    /*
-     * Begin.
-     *
-     * @param uart - an reference of HardwareSerial object. 
-     * @param baud - the buad rate to communicate with ESP8266(default:115200). 
-     *
-     * @warning parameter baud depends on the AT firmware. 115200 is an common value. 
-     */
-    void begin(HardwareSerial &uart, uint32_t baud = 115200);
-#endif
-    
+    int begin(HardwareSerial &uart, uint32_t baud = 115200);
+#endif /* ESP8266_USE_SOFTWARE_SERIAL */
     
     /** 
@@ -176 +218 @@
      */
     String getLocalIP(void);
-    
+
     /**
      * Enable IP MUX(multiple connection mode). 
@@ -390 +432 @@
      */
     uint32_t recv(uint8_t mux_id, uint8_t *buffer, uint32_t buffer_size, uint32_t timeout = 1000);
-    
+
     /**
      * Receive data from all of TCP or UDP builded already in multiple mode. 
@@ -404 +446 @@
      */
     uint32_t recv(uint8_t *coming_mux_id, uint8_t *buffer, uint32_t buffer_size, uint32_t timeout = 1000);
-
-    /**
-     * Check data is available.
-     *
-     * @return 1 : data is available, 0 : data is not available
-     */
-    int dataAvailable(void);
-
+    
+    /**
+     * Check data is available in specific connection.
+     * 
+     * @param mux_id - the identifier of this TCP(available value: 0 - 4).      
+     * @return true - data is available.
+     * @return false - data is not available.
+     */
+    bool isDataAvailable(uint8_t mux_id);
+
+    /**
+     * Check data is available in any connection.
+     *
+     * @return true - data is available.
+     * @return false - data is not available.
+     */
+    bool isDataAvailable(void);
+
+    /**
+     * Check connection is opned in single mode. 
+     *
+     * @return true  - opend.
+     * @return false - closed.
+     */
+    bool isConnected(void);
+
+    /**
+     * Check specific connection is opned in multiple mode. 
+     *
+     * @return true  - opend.
+     * @return false - closed.
+     */
+    bool isConnected(uint8_t mux_id);
+
+    /**
+     * Get connection link status
+     *
+     * @return true  - success.
+     * @return false - error.
+     */    
+    bool getMuxCStatus(uint8_t *mux_id_ptn);
+
+    /**
+     *  
+     */ 
+    ESP8266_RingBuffer rx_buffer[ESP8266_NUM_CONNECTION];
+    
  private:
 
@@ -418 +499 @@
      */
     void rx_empty(void);
- 
+
     /* 
-     * Recvive data from uart. Return all received data if target found or timeout. 
-     */
-    String recvString(String target, uint32_t timeout = 1000);
-    
-    /* 
-     * Recvive data from uart. Return all received data if one of target1 and target2 found or timeout. 
-     */
-    String recvString(String target1, String target2, uint32_t timeout = 1000);
-    
+     * Read all data in UART RX.
+     */
+    void rx_update(void);    
+     
     /* 
      * Recvive data from uart. Return all received data if one of target1, target2 and target3 found or timeout. 
      */
-    String recvString(String target1, String target2, String target3, uint32_t timeout = 1000);
+    int recvString(String target1, String target2, String target3, uint32_t timeout = 1000);
     
     /* 
@@ -440 +516 @@
     
     /* 
-     * Recvive data from uart and search first target and cut out the substring between begin and end(excluding begin and end self). 
+     * Recvive data from uart and search first target and cut out the substring between begin and end(excluding begin and end self). a
      * Return true if target found, false for timeout.
      */
@@ -454 +530 @@
      * @param coming_mux_id - in single connection mode, should be NULL and not NULL in multiple. 
      */
-    uint32_t recvPkg(uint8_t *buffer, uint32_t buffer_size, uint32_t *data_len, uint32_t timeout, uint8_t *coming_mux_id);
-    
+    uint32_t recvPkg(uint8_t *buffer, uint32_t buffer_size, uint32_t timeout, uint8_t mux_id, uint8_t *coming_mux_id);
     
     bool eAT(void);
@@ -461 +536 @@
     bool eATGMR(String &version);
     
-    bool qATCWMODE(uint8_t *mode);
-    bool sATCWMODE(uint8_t mode);
-    bool sATCWJAP(String ssid, String pwd);
+    bool qATCWMODE_CUR(uint8_t *mode);
+    bool sATCWMODE_CUR(uint8_t mode);
+    bool sATCWJAP_CUR(String ssid, String pwd);
     bool eATCWLAP(String &list);
     bool eATCWQAP(void);
-    bool sATCWSAP(String ssid, String pwd, uint8_t chl, uint8_t ecn);
+    bool sATCWSAP_CUR(String ssid, String pwd, uint8_t chl, uint8_t ecn);
     bool eATCWLIF(String &list);
     
@@ -482 +557 @@
     bool sATCIPSERVER(uint8_t mode, uint32_t port = 333);
     bool sATCIPSTO(uint32_t timeout);
-    
-    /*
-     * +IPD,len:data
-     * +IPD,id,len:data
-     */
+
+    void initialize_status(void);
+    
+    uint32_t recvIPD(uint32_t timeout, uint8_t *buffer = NULL, uint32_t buffer_size = 0,
+                     uint8_t mux_id = 0, uint8_t *coming_mux_id = NULL);
+
+    void recvAsyncdata(uint32_t timeout = 0);
     
 #ifdef ESP8266_USE_SOFTWARE_SERIAL
@@ -494 +571 @@
 #endif
     uint32_t m_baud;
+
+    uint8_t wifi_status;
+    bool    mux_mode;
+    uint8_t connection_bitmap;
+    esp8266_connection_status connection_status[ESP8266_NUM_CONNECTION];
+
+    String rx_cmd;
 };