File content as of revision 6:18eb2d9fb2ac:

/**
 * @file ESP8266.cpp
 * @brief The implementation of class ESP8266. 
 * @author Wu Pengfei<pengfei.wu@itead.cc> 
 * @date 2015.02
 * 
 * @par Copyright:
 * Copyright (c) 2015 ITEAD Intelligent Systems Co., Ltd. \n\n
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of
 * the License, or (at your option) any later version. \n\n
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#include "ESP8266.h"
#include "log.h"

ESP8266::ESP8266(ArduinoSerial &uart): m_puart(&uart)
{
    m_puart->begin(9600);
    m_puart->flush();
    m_puart->setTimeout(1000);
    logDebug("Create Instance ok");
}


bool ESP8266::kick(void)
{
    return eAT();
}

bool ESP8266::restart(void)
{
    unsigned long start;
    if (eATRST()) {
        delay(2000);
        start = millis();
        while (millis() - start < 3000) {
            if (eAT()) {
                delay(500);
                return true;
            }
            delay(100);
        }
    }
    return false;
}

String ESP8266::getVersion(void)
{
    String version;
    eATGMR(version);
    return version;
}

bool ESP8266::setOprToStation(void)
{
    if (sATCWMODE(1) && restart()) {
        return true;
    }
    return false;
}

bool ESP8266::setOprToSoftAP(void)
{
    if (sATCWMODE(2) && restart()) {
        return true;
    }
    return false;
}

bool ESP8266::setOprToStationSoftAP(void)
{
    if (sATCWMODE(3) && restart()) {
        return true;
    }
    return false;
}

String ESP8266::getAPList(void)
{
    return "";
}

bool ESP8266::joinAP(String ssid, String pwd)
{
    return false;
}

bool ESP8266::leaveAP(void)
{
    return false;
}

bool ESP8266::setSoftAPParam(String ssid, String pwd, uint8_t chl, uint8_t ecn)
{
    return false;
}

String ESP8266::getJoinedDeviceIP(void)
{
    return "";
}

String ESP8266::getIPStatus(void)
{
    return "";
}

String ESP8266::getLocalIP(void)
{
    return "";
}

bool ESP8266::enableMUX(void)
{
    return false;
}

bool ESP8266::disableMUX(void)
{
    return false;
}

bool ESP8266::createTCP(String addr, uint32_t port)
{
    return false;
}

bool ESP8266::releaseTCP(void)
{
    return false;
}

bool ESP8266::registerUDP(String addr, uint32_t port)
{
    return false;
}

bool ESP8266::unregisterUDP(void)
{
    return false;
}

bool ESP8266::createTCP(uint8_t mux_id, String addr, uint32_t port)
{
    return false;
}

bool ESP8266::releaseTCP(uint8_t mux_id)
{
    return false;
}

bool ESP8266::registerUDP(uint8_t mux_id, String addr, uint32_t port)
{
    return false;
}

bool ESP8266::unregisterUDP(uint8_t mux_id)
{
    return false;
}

bool ESP8266::setTCPServerTimeout(uint32_t timeout)
{
    return false;
}

bool ESP8266::startTCPServer(uint32_t port)
{
    return false;
}

bool ESP8266::stopTCPServer(void)
{
    return false;
}

bool ESP8266::send(const uint8_t *buffer, uint32_t len)
{
    return false;
}

bool ESP8266::send(uint8_t mux_id, const char *buffer, uint32_t len)
{
    return false;
}

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)
{
    return false;
}

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;
    char a;
    unsigned long start = millis();
    while (millis() - start < timeout) {
        while(m_puart->available() > 0) {
            a = m_puart->readChr();
            data += a;
        }
        if (data.indexOf(target) != -1) {
            break;
        }   
    }
    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->readChr();
            data += a;
        }
        if (data.indexOf(target1) != -1) {
            break;
        } else if (data.indexOf(target2) != -1) {
            break;
        }
    }
    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->readChr();
            data += a;
        }
        if (data.indexOf(target1) != -1) {
            break;
        } else if (data.indexOf(target2) != -1) {
            break;
        } else if (data.indexOf(target3) != -1) {
            break;
        }
    }
    return data;
}

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;
}

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 (index1 != -1 && index2 != -1) {
            index1 += begin.length();
            data = data_tmp.substring(index1, index2);
            return true;
        }
    }
    data = "";
    return false;
}

bool ESP8266::eAT(void)
{
    m_puart->flush();
    m_puart->println("AT");
    return recvFind("OK");
}

bool ESP8266::eATRST(void) 
{
    m_puart->flush();
    m_puart->println("AT+RST");
    return recvFind("OK");
}

bool ESP8266::eATGMR(String &version)
{
    m_puart->flush();
    m_puart->println("AT+GMR");
    return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", version); 
}


bool ESP8266::sATCWMODE(uint8_t mode)
{
    String data;
    m_puart->flush();
    m_puart->print("AT+CWMODE=");
    m_puart->println(mode);
    return recvFind("OK");
}

bool ESP8266::sATCWJAP(String ssid, String pwd)
{
    String data;
    m_puart->flush();
    m_puart->print("AT+CWJAP=\"");
    m_puart->print(ssid);
    m_puart->print("\",\"");
    m_puart->print(pwd);
    m_puart->println("\"");
    
    data = recvString("OK", "FAIL", 10000);
    if (data.indexOf("OK") != -1) {
        return true;
    }
    return false;
}

bool ESP8266::eATCWLAP(String &list)
{
    String data;
    m_puart->flush();
    m_puart->println("AT+CWLAP");
    return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list, 10000);
}

bool ESP8266::eATCWQAP(void)
{
    String data;
    m_puart->flush();
    m_puart->println("AT+CWQAP");
    return recvFind("OK");
}

bool ESP8266::sATCWSAP(String ssid, String pwd, uint8_t chl, uint8_t ecn)
{
    String data;
    m_puart->flush();
    m_puart->print("AT+CWSAP=\"");
    m_puart->print(ssid);
    m_puart->print("\",\"");
    m_puart->print(pwd);
    m_puart->print("\",");
    m_puart->print(chl);
    m_puart->print(",");
    m_puart->println(ecn);
    
    data = recvString("OK", "ERROR", 5000);
    if (data.indexOf("OK") != -1) {
        return true;
    }
    return false;
}

bool ESP8266::eATCWLIF(String &list)
{
    String data;
    m_puart->flush();
    m_puart->println("AT+CWLIF");
    return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list);
}
bool ESP8266::eATCIPSTATUS(String &list)
{
    String data;
    m_puart->flush();
    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;
    m_puart->flush();
    m_puart->print("AT+CIPSTART=\"");
    m_puart->print(type);
    m_puart->print("\",\"");
    m_puart->print(addr);
    m_puart->print("\",");
    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;
}
bool ESP8266::sATCIPSTARTMultiple(uint8_t mux_id, String type, String addr, uint32_t port)
{
    String data;
    m_puart->flush();
    m_puart->print("AT+CIPSTART=");
    m_puart->print(mux_id);
    m_puart->print(",\"");
    m_puart->print(type);
    m_puart->print("\",\"");
    m_puart->print(addr);
    m_puart->print("\",");
    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;
}
bool ESP8266::sATCIPSENDSingle(uint8_t *buffer, uint32_t len)
{
    return false;
}
bool ESP8266::sATCIPSENDMultiple(uint8_t mux_id, uint8_t *buffer, uint32_t len)
{
    return false;
}
bool ESP8266::sATCIPCLOSEMulitple(uint8_t mux_id)
{
    return false;
}
bool ESP8266::eATCIPCLOSESingle(void)
{
    return false;
}
bool ESP8266::eATCIFSR(String &list)
{
    return false;
}
bool ESP8266::sATCIPMUX(uint8_t mode)
{
    return false;
}
bool ESP8266::sATCIPSERVER(uint8_t mode, uint32_t port)
{
    return false;
}
bool ESP8266::sATCIPSTO(uint32_t timeout)
{
    return false;
}