File content as of revision 28:c25aff31dcc5:

#include "ESP8266.h"


ESP8266::ESP8266(PinName tx, PinName rx):m_esp_uart(tx, rx) {
}

int ESP8266::getChannelID(void) {
    return m_chl_id;
}

bool ESP8266::begin(void)
{
    m_esp_uart.begin(9600);
    m_esp_uart.flush();
    m_esp_uart.setTimeout(5000);
    m_esp_uart.println("AT+RST");
    return m_esp_uart.find("eady");
}


bool ESP8266::init(uint8_t mode, String ssid, String pwd, uint8_t chl, uint8_t ecn)
{
    if (mode == ESP8266_MODE_STA)
    {   
        bool b = confMode(mode);
        if (!b)
        {
            return false;
        }
        reset();
        confJAP(ssid, pwd);
    }
    else if (mode == ESP8266_MODE_SAP)
    {
        bool b = confMode(mode);
        if (!b)
        {
            return false;
        }
        reset();
        confSAP(ssid, pwd, chl, ecn);
    }
    else if (mode == ESP8266_MODE_STA_SAP)
    {
        bool b = confMode(mode);
        if (!b)
        {
            return false;
        }
        reset();
        confJAP(ssid, pwd);
        confSAP(ssid, pwd, chl, ecn);
    }
    
    return true;
}


bool ESP8266::ipConfig(uint8_t type, String addr, int port, uint8_t mux, uint8_t id)
{
    bool result = false;
    if (mux == 0 )
    {
        confMux(mux);
        
        long timeStart = millis();
        while (1)
        {
            long time0 = millis();
            if (time0 - timeStart > 5000)
            {
                break;
            }
        }
        result = newMux(type, addr, port);
    }
    else if (mux == 1)
    {
        confMux(mux);
        long timeStart = millis();
        while (1)
        {
            long time0 = millis();
            if (time0 - timeStart > 5000)
            {
                break;
            }
        }
        result = newMux(id, type, addr, port);
    }
    return result;
}


int ESP8266::recvData(char *buf)
{
    String data = "";
    if (m_esp_uart.available()>0)
    {
        
        unsigned long start;
        start = millis();
        char c0 = m_esp_uart.readChr();
        if (c0 == '+')
        {
            
            while (millis()-start<5000) 
            {
                if (m_esp_uart.available()>0)
                {
                    char c = m_esp_uart.readChr();
                    data += c;
                }
                if (data.indexOf("\nOK")!=-1)
                {
                    break;
                }
            }

            int sLen = strlen(data.c_str());
            int i,j;
            for (i = 0; i <= sLen; i++)
            {
                if (data[i] == ':')
                {
                    break;
                }
                
            }
            bool found = false;
            for (j = 4; j <= i; j++)
            {
                if (data[j] == ',')
                {
                    found = true;
                    break;
                }
                
            }
            int iSize;
            if(found ==true)
            {
            String _id = data.substring(4, j);
            m_chl_id = _id.toInt();
            String _size = data.substring(j+1, i);
            iSize = _size.toInt();
            
            String str = data.substring(i+1, i+1+iSize);
            strcpy(buf, str.c_str());   
            
                        
            }
            else
            {           
            String _size = data.substring(4, i);
            iSize = _size.toInt();
            
            
            String str = data.substring(i+1, i+1+iSize);
            strcpy(buf, str.c_str());
            
            }
            return iSize;
        }
    }
    
    return 0;
}


void ESP8266::reset(void)
{
    m_esp_uart.println("AT+RST");
    unsigned long start;
    start = millis();
    while (millis()-start<5000) {                            
        if(m_esp_uart.find("eady")==true)
        {
           break;
        }
    }
}


String ESP8266::showMode()
{
    String data;
    m_esp_uart.println("AT+CWMODE?");  
    unsigned long start;
    start = millis();
    while (millis()-start<2000) {
     if(m_esp_uart.available()>0)
     {
     char a =m_esp_uart.readChr();
     data=data+a;
     }
     if (data.indexOf("OK")!=-1)
     {
         break;
     }
  }
    if(data.indexOf("1")!=-1)
    {
        return "Station";
    }else if(data.indexOf("2")!=-1)
    {
            return "AP";
    }else if(data.indexOf("3")!=-1)
    {
         return "AP+Station";
    }else{
        return "Invalid Mode!";
    }
}

bool ESP8266::confMode(uint8_t mode)
{
    String data;
     m_esp_uart.print("AT+CWMODE=");  
     m_esp_uart.println(String(mode));
     unsigned long start;
    start = millis();
    while (millis()-start<2000) {
      if(m_esp_uart.available()>0)
      {
      char mode =m_esp_uart.readChr();
      data=data+mode;
      }
      if (data.indexOf("OK")!=-1 || data.indexOf("no change")!=-1)
      {
          return true;
      }
      if (data.indexOf("ERROR")!=-1 || data.indexOf("busy")!=-1)
      {
          return false;
      }
      
   }
     return false;     
}

String ESP8266::showAP(void)
{
    String data;
    m_esp_uart.flush();
    m_esp_uart.print("AT+CWLAP\r\n");  
    delay(5000);
    
    unsigned long start;
    start = millis();
    while (millis()-start<8000) {
   if(m_esp_uart.available()>0)
   {
     char a =m_esp_uart.readChr();
     data=data+a;
   }
     if (data.indexOf("OK")!=-1 || data.indexOf("ERROR")!=-1 )
     {
         break;
     }
  }
    if(data.indexOf("ERROR")!=-1)
    {
        return "ERROR";
    }
    else{
       char head[4] = {0x0D,0x0A};   
       char tail[7] = {0x0D,0x0A,0x0D,0x0A};        
       data.replace("AT+CWLAP","");
       data.replace("OK","");
       data.replace("+CWLAP","ESP8266");
       data.replace(tail,"");
       data.replace(head,"");

        return data;
        }
 }

String ESP8266::showJAP(void)
{
    bool ret = false;
    m_esp_uart.flush();
    m_esp_uart.println("AT+CWJAP?");  
    
    String data;
    unsigned long start;
    start = millis();
    while (millis()-start < 3000) {
        while(m_esp_uart.available() > 0) {
            char a = m_esp_uart.readChr();
            data += a;
            //printf("%c", a);
        }      
        if (data.indexOf("OK") != -1) {
            ret = true;
            break;
        } else if (data.indexOf("ERROR") != -1) {
            ret = false;
            break;
        }     
    }
    if (ret) {
        int index1 = data.indexOf(":\"");
        int index2 = data.indexOf("\"\r\n");
        if (index1 != -1 && index2 != -1) {
            return data.substring(index1 + 2, index2);
        } else {
            return "not found";
        }
    } else {
        return "null";
    }  
}

bool ESP8266::confJAP(String ssid , String pwd)
{
    
    m_esp_uart.print("AT+CWJAP=");
    m_esp_uart.print("\"");     //"ssid"
    m_esp_uart.print(ssid);
    m_esp_uart.print("\"");

    m_esp_uart.print(",");

    m_esp_uart.print("\"");      //"pwd"
    m_esp_uart.print(pwd);
    m_esp_uart.println("\"");


    unsigned long start;
    start = millis();
    while (millis()-start<3000) {                            
        if(m_esp_uart.find("OK")==true)
        {
           return true;
           
        }
    }
    return false;
}

bool ESP8266::quitAP(void)
{
    m_esp_uart.println("AT+CWQAP");
    unsigned long start;
    start = millis();
    while (millis()-start<3000) {                            
        if(m_esp_uart.find("OK")==true)
        {
           return true;
           
        }
    }
    return false;

}

String ESP8266::showSAP()
{
    m_esp_uart.println("AT+CWSAP?");  
      String data;
      unsigned long start;
    start = millis();
    while (millis()-start<3000) {
       if(m_esp_uart.available()>0)
       {
       char a =m_esp_uart.readChr();
       data=data+a;
       }
       if (data.indexOf("OK")!=-1 || data.indexOf("ERROR")!=-1 )
       {
           break;
       }
    }
      char head[4] = {0x0D,0x0A};   
      char tail[7] = {0x0D,0x0A,0x0D,0x0A};        
      data.replace("AT+CWSAP?","");
      data.replace("+CWSAP","mySAP");
      data.replace("OK","");
      data.replace(tail,"");
      data.replace(head,"");
      
          return data;
}

bool ESP8266::confSAP(String ssid , String pwd , uint8_t chl , uint8_t ecn)
{
    m_esp_uart.print("AT+CWSAP=");  
    m_esp_uart.print("\"");     //"ssid"
    m_esp_uart.print(ssid);
    m_esp_uart.print("\"");

    m_esp_uart.print(",");

    m_esp_uart.print("\"");      //"pwd"
    m_esp_uart.print(pwd);
    m_esp_uart.print("\"");

    m_esp_uart.print(",");
    m_esp_uart.print(String(chl));

    m_esp_uart.print(",");
    m_esp_uart.println(String(ecn));
    unsigned long start;
    start = millis();
    while (millis()-start<3000) {                            
        if(m_esp_uart.find("OK")==true )
        {
           return true;
        }
     }
     
     return false;

}


String ESP8266::showStatus(void)
{
    m_esp_uart.println("AT+CIPSTATUS");  
      String data;
    unsigned long start;
    start = millis();
    while (millis()-start<3000) {
       if(m_esp_uart.available()>0)
       {
       char a =m_esp_uart.readChr();
       data=data+a;
       }
       if (data.indexOf("OK")!=-1)
       {
           break;
       }
    }

          char head[4] = {0x0D,0x0A};   
          char tail[7] = {0x0D,0x0A,0x0D,0x0A};        
          data.replace("AT+CIPSTATUS","");
          data.replace("OK","");
          data.replace(tail,"");
          data.replace(head,"");
          
          return data;
}

String ESP8266::showMux(void)
{
    String data;
    m_esp_uart.println("AT+CIPMUX?");  

      unsigned long start;
    start = millis();
    while (millis()-start<3000) {
       if(m_esp_uart.available()>0)
       {
       char a =m_esp_uart.readChr();
       data=data+a;
       }
       if (data.indexOf("OK")!=-1)
       {
           break;
       }
    }
          char head[4] = {0x0D,0x0A};   
          char tail[7] = {0x0D,0x0A,0x0D,0x0A};        
          data.replace("AT+CIPMUX?","");
          data.replace("+CIPMUX","showMux");
          data.replace("OK","");
          data.replace(tail,"");
          data.replace(head,"");
          
          return data;
}

bool ESP8266::confMux(int mux)
{
    m_esp_uart.print("AT+CIPMUX=");
    m_esp_uart.println(mux);           
    unsigned long start;
    start = millis();
    while (millis()-start<3000) {                            
        if(m_esp_uart.find("OK")==true )
        {
           return true;
        }
     }
     
     return false;
}

bool ESP8266::newMux(uint8_t type, String addr, int port)

{
    String data;
    m_esp_uart.flush();
    m_esp_uart.print("AT+CIPSTART=");
    if(ESP8266_COMM_TCP == type) {
        m_esp_uart.print("\"TCP\"");
    } else if (ESP8266_COMM_UDP == type) {
        m_esp_uart.print("\"UDP\"");
    }
    m_esp_uart.print(",");
    m_esp_uart.print("\"");
    m_esp_uart.print(addr);
    m_esp_uart.print("\"");
    m_esp_uart.print(",");
    m_esp_uart.println(String(port));
    unsigned long start;
    start = millis();
    while (millis()-start<10000) { 
     if(m_esp_uart.available()>0)
     {
     char a =m_esp_uart.readChr();
     data=data+a;
     }
     if (data.indexOf("OK")!=-1 || data.indexOf("ALREAY CONNECT")!=-1 || data.indexOf("ERROR")!=-1)
     {
         return true;
     }
  }
  return false;
}

bool ESP8266::newMux( uint8_t id, uint8_t type, String addr, int port)
{
    m_esp_uart.print("AT+CIPSTART=");
    m_esp_uart.print("\"");
    m_esp_uart.print(String(id));
    m_esp_uart.print("\"");
    if(ESP8266_COMM_TCP == type) {
        m_esp_uart.print("\"TCP\"");
    } else if (ESP8266_COMM_UDP == type) {
        m_esp_uart.print("\"UDP\"");
    }
    m_esp_uart.print(",");
    m_esp_uart.print("\"");
    m_esp_uart.print(addr);
    m_esp_uart.print("\"");
    m_esp_uart.print(",");
    m_esp_uart.println(String(port));
    String data;
    unsigned long start;
    start = millis();
    while (millis()-start<3000) { 
     if(m_esp_uart.available()>0)
     {
     char a =m_esp_uart.readChr();
     data=data+a;
     }
     if (data.indexOf("OK")!=-1 || data.indexOf("ALREAY CONNECT")!=-1 )
     {
         return true;
     }
  }
  return false;
  

}

bool ESP8266::send(String str)
{
    m_esp_uart.flush();
    m_esp_uart.print("AT+CIPSEND=");
    m_esp_uart.println(str.length());
    unsigned long start;
    start = millis();
    bool found = false;
    while (millis()-start<5000) {                            
        if(m_esp_uart.find(">")==true )
        {
            found = true;
           break;
        }
     }
     if(found)
        m_esp_uart.print(str);
    else
    {
        closeMux();
        return false;
    }


    String data;
    start = millis();
    while (millis()-start<5000) {
     if(m_esp_uart.available()>0)
     {
     char a =m_esp_uart.readChr();
     data=data+a;
     }
     if (data.indexOf("SEND OK")!=-1)
     {
         return true;
     }
  }
  return false;
}

bool ESP8266::send(uint8_t id, String str)
{
    m_esp_uart.print("AT+CIPSEND=");

    m_esp_uart.print(String(id));
    m_esp_uart.print(",");
    m_esp_uart.println(str.length());
    unsigned long start;
    start = millis();
    bool found = false;
    while (millis()-start<5000) {                          
        if(m_esp_uart.find(">")==true )
        {
            found = true;
           break;
        }
     }
     if(found)
        m_esp_uart.print(str);
    else
    {
        closeMux(id);
        return false;
    }


    String data;
    start = millis();
    while (millis()-start<5000) {
     if(m_esp_uart.available()>0)
     {
     char a =m_esp_uart.readChr();
     data=data+a;
     }
     if (data.indexOf("SEND OK")!=-1)
     {
         return true;
     }
  }
  return false;
}


void ESP8266::closeMux(void)
{
    m_esp_uart.println("AT+CIPCLOSE");

    String data;
    unsigned long start;
    start = millis();
    while (millis()-start<3000) {
     if(m_esp_uart.available()>0)
     {
     char a =m_esp_uart.readChr();
     data=data+a;
     }
     if (data.indexOf("Linked")!=-1 || data.indexOf("ERROR")!=-1 || data.indexOf("we must restart")!=-1)
     {
         break;
     }
  }
}

void ESP8266::closeMux(uint8_t id)
{
    m_esp_uart.print("AT+CIPCLOSE=");
    m_esp_uart.println(String(id));
    String data;
    unsigned long start;
    start = millis();
    while (millis()-start<3000) {
     if(m_esp_uart.available()>0)
     {
     char a =m_esp_uart.readChr();
     data=data+a;
     }
     if (data.indexOf("OK")!=-1 || data.indexOf("Link is not")!=-1 || data.indexOf("Cant close")!=-1)
     {
         break;
     }
  }

}

String ESP8266::showIP(void)
{
    bool ret = false;
    m_esp_uart.flush();
    m_esp_uart.println("AT+CIFSR");  
    
    String data;
    unsigned long start;
    start = millis();
    while (millis()-start < 3000) {
        while(m_esp_uart.available() > 0) {
            char a = m_esp_uart.readChr();
            data += a;
        }
        if (data.indexOf("OK") != -1) {
            ret = true;
            break;
        } else if (data.indexOf("ERROR") != -1) {
            ret = false;
            break;
        }
    }

    if (ret) {
        int index1 = data.indexOf("\r\n");
        int index2 = data.indexOf("\r\n\r\nOK");
        if (index1 != -1 && index2 != -1) {
            return data.substring(index1 + strlen("\r\n"), index2);
        } else {
            return "not found";
        }
    } else {
        return "null";
    }  
}

bool ESP8266::confServer(uint8_t mode, int port)
{
    m_esp_uart.print("AT+CIPSERVER=");  
    m_esp_uart.print(String(mode));
    m_esp_uart.print(",");
    m_esp_uart.println(String(port));

    String data;
    unsigned long start;
    start = millis();
    bool found = false;
    while (millis()-start<3000) {
     if(m_esp_uart.available()>0)
     {
     char a =m_esp_uart.readChr();
     data=data+a;
     }
     if (data.indexOf("OK")!=-1 || data.indexOf("no charge")!=-1)
     {
        found = true;
         break;
     }
  }
  m_esp_uart.flush();
  return found;
}