Diff: ESP8266.cpp

Revision:

9:dec2cf52b744

Parent:

8:60d15efb4a1f

Child:

10:002615561b0b

--- a/ESP8266.cpp	Sat Feb 07 00:57:05 2015 +0000
+++ b/ESP8266.cpp	Sat Feb 07 05:24:08 2015 +0000
@@ -43,7 +43,7 @@
         start = millis();
         while (millis() - start < 3000) {
             if (eAT()) {
-                delay(500);
+                delay(1500); /* Waiting for stable */
                 return true;
             }
             delay(100);
@@ -85,130 +85,221 @@
 
 String ESP8266::getAPList(void)
 {
-    return "";
+    String list;
+    eATCWLAP(list);
+    return list;
 }
 
 bool ESP8266::joinAP(String ssid, String pwd)
 {
-    return false;
+    return sATCWJAP(ssid, pwd);
 }
 
 bool ESP8266::leaveAP(void)
 {
-    return false;
+    return eATCWQAP();
 }
 
 bool ESP8266::setSoftAPParam(String ssid, String pwd, uint8_t chl, uint8_t ecn)
 {
-    return false;
+    return sATCWSAP(ssid, pwd, chl, ecn);
 }
 
 String ESP8266::getJoinedDeviceIP(void)
 {
-    return "";
+    String list;
+    eATCWLIF(list);
+    return list;
 }
 
 String ESP8266::getIPStatus(void)
 {
-    return "";
+    String list;
+    eATCIPSTATUS(list);
+    return list;
 }
 
 String ESP8266::getLocalIP(void)
 {
-    return "";
+    String list;
+    eATCIFSR(list);
+    return list;
 }
 
 bool ESP8266::enableMUX(void)
 {
-    return false;
+    return sATCIPMUX(1);
 }
 
 bool ESP8266::disableMUX(void)
 {
-    return false;
+    return sATCIPMUX(0);
 }
 
 bool ESP8266::createTCP(String addr, uint32_t port)
 {
-    return false;
+    return sATCIPSTARTSingle("TCP", addr, port);
 }
 
 bool ESP8266::releaseTCP(void)
 {
-    return false;
+    return eATCIPCLOSESingle();
 }
 
 bool ESP8266::registerUDP(String addr, uint32_t port)
 {
-    return false;
+    return sATCIPSTARTSingle("UDP", addr, port);
 }
 
 bool ESP8266::unregisterUDP(void)
 {
-    return false;
+    return eATCIPCLOSESingle();
 }
 
 bool ESP8266::createTCP(uint8_t mux_id, String addr, uint32_t port)
 {
-    return false;
+    return sATCIPSTARTMultiple(mux_id, "TCP", addr, port);
 }
 
 bool ESP8266::releaseTCP(uint8_t mux_id)
 {
-    return false;
+    return sATCIPCLOSEMulitple(mux_id);
 }
 
 bool ESP8266::registerUDP(uint8_t mux_id, String addr, uint32_t port)
 {
-    return false;
+    return sATCIPSTARTMultiple(mux_id, "UDP", addr, port);
 }
 
 bool ESP8266::unregisterUDP(uint8_t mux_id)
 {
-    return false;
+    return sATCIPCLOSEMulitple(mux_id);
 }
 
 bool ESP8266::setTCPServerTimeout(uint32_t timeout)
 {
-    return false;
+    return sATCIPSTO(timeout);
 }
 
 bool ESP8266::startTCPServer(uint32_t port)
 {
+    if (enableMUX() && sATCIPSERVER(1, port)) {
+        return true;
+    }
     return false;
 }
 
 bool ESP8266::stopTCPServer(void)
 {
+    sATCIPSERVER(0);
+    restart();
     return false;
 }
 
 bool ESP8266::send(const uint8_t *buffer, uint32_t len)
 {
-    return false;
+    return sATCIPSENDSingle(buffer, len);
+}
+
+bool ESP8266::send(uint8_t mux_id, const uint8_t *buffer, uint32_t len)
+{
+    return sATCIPSENDMultiple(mux_id, buffer, len);
+}
+
+uint32_t ESP8266::recv(uint8_t *buffer, uint32_t buffer_size, uint32_t timeout)
+{
+    return recvPkg(buffer, buffer_size, NULL, timeout, NULL);
 }
 
-bool ESP8266::send(uint8_t mux_id, const char *buffer, uint32_t len)
+uint32_t ESP8266::recv(uint8_t mux_id, uint8_t *buffer, uint32_t buffer_size, uint32_t timeout)
 {
-    return false;
+    uint8_t id;
+    uint32_t ret;
+    ret = recvPkg(buffer, buffer_size, NULL, timeout, &id);
+    if (ret > 0 && id == mux_id) {
+        return ret;
+    }
+    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);
 }
 
-uint32_t ESP8266::recv(uint8_t *buffer, uint32_t len, uint32_t timeout)
-{
-    return false;
-}
+/*----------------------------------------------------------------------------*/
 
-uint32_t ESP8266::recv(uint8_t mux_id, uint8_t *buffer, uint32_t len, uint32_t timeout)
+uint32_t ESP8266::recvPkg(uint8_t *buffer, uint8_t buffer_size, uint32_t *data_len, uint32_t timeout, uint8_t *coming_mux_id)
 {
-    return false;
+    String data;
+    char a;
+    int32_t index_PIPDcomma = -1;
+    int32_t index_colon = -1; /* : */
+    int32_t index_comma = -1; /* , */
+    int8_t id;
+    int32_t len;
+    bool has_data = false;
+    
+    unsigned long start = millis();
+    while (millis() - start < timeout) {
+        while(m_puart->available() > 0) {
+            a = m_puart->readChr();
+            data += a;
+        }
+        
+        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);
+                if (index_comma != -1) { /* +IPD,id,len:data */
+                    id = data.substring(index_PIPDcomma + 5, index_comma).toInt();
+                    if (id < 0 || id > 4) {
+                        return 0;
+                    }
+                    len = data.substring(index_comma + 1, index_colon).toInt();
+                    if (len <= 0) {
+                        return 0;
+                    }
+                    
+                } else { /* +IPD,len:data */
+                    len = data.substring(index_PIPDcomma + 5, index_colon).toInt();
+                    if (len <= 0) {
+                        return 0;
+                    }
+                }
+                has_data = true;
+                break;
+            }
+        }
+    }
+    
+    if (has_data) {
+        start = millis();
+        while (millis() - start < timeout) {
+            while(m_puart->available() > 0) {
+                a = m_puart->readChr();
+                data += a;
+            }
+            if (data.length() >= index_colon + 1 + len) {
+                if (data_len) {
+                    *data_len = len;    
+                }
+                if (index_comma != -1 && coming_mux_id) {
+                    *coming_mux_id = id;
+                }
+                uint32_t ret = len > buffer_size ? buffer_size : len;
+                memcpy(buffer, 
+                    data.substring(index_colon + 1, index_colon + 1 + len).c_str(), 
+                    ret);
+                return ret;
+            }
+        }
+    }
+    
+    return 0;
 }
 
-uint32_t ESP8266::recv(uint8_t *coming_mux_id, uint8_t *buffer, uint32_t len, uint32_t timeout)
-{
-    return false;
-}
-
-
 String ESP8266::recvString(String target, uint32_t timeout)
 {
     String data;
@@ -432,7 +523,7 @@
     }
     return false;
 }
-bool ESP8266::sATCIPSENDSingle(uint8_t *buffer, uint32_t len)
+bool ESP8266::sATCIPSENDSingle(const uint8_t *buffer, uint32_t len)
 {
     m_puart->flush();
     m_puart->print("AT+CIPSEND=");
@@ -446,7 +537,7 @@
     }
     return false;
 }
-bool ESP8266::sATCIPSENDMultiple(uint8_t mux_id, uint8_t *buffer, uint32_t len)
+bool ESP8266::sATCIPSENDMultiple(uint8_t mux_id, const uint8_t *buffer, uint32_t len)
 {
     m_puart->flush();
     m_puart->print("AT+CIPSEND=");