Changeset 189 for rtos_arduino/trunk


Ignore:
Timestamp:
Mar 30, 2016, 8:40:35 AM (8 years ago)
Author:
ertl-honda
Message:

Thinkgspeakのサポート

Location:
rtos_arduino/trunk/arduino_lib/libraries
Files:
68 added
3 edited

Legend:

Unmodified
Added
Removed

  • rtos_arduino/trunk/arduino_lib/libraries/ESP8266_Arudino_AT/Client_ESP8266.h

    r187 r189  
    2020
    2121#include "ESP8266.h"
     22#include "IPAddress.h"
     23#include "Client.h"
    2224
    2325class ESP8266Client: public Client, public ESP8266 {
    … …  
    3234     */
    3335    int connect(IPAddress ip, uint16_t port) {
     36        if (isConnected()) return 1;
    3437        String ip_str;
    3538        ip_str.concat(ip[0]); ip_str.concat(".");
    … …  
    4144   
    4245    int connect(const char *host, uint16_t port) {
     46        if (isConnected()) return 1;
    4347        String ip_str(host);
    4448        return (createTCP(ip_str, port))? 1 : 0;
    … …  
    5155        return 0;
    5256    };
    53    
     57
    5458    size_t write(const uint8_t *buf, size_t size){
    5559        if(send(buf, size)){
    … …  
    8084   
    8185    void flush(){};
    82     void stop(){releaseTCP();};
     86    void stop(){ if (isConnected()) { releaseTCP(); }}
    8387    uint8_t connected(){return (isConnected())? 1 : 0;};
    8488    operator bool(){return isConnected();};

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

    r177 r189  
    3131#ifdef TOPPERS_WITH_ARDUINO
    3232#define WAIT_TIMEOUT delay(1);
     33#define ENTER_CRITICAL
     34#define LEAVE_CRITICAL
     35#else /* !TOPPERS_WITH_ARDUINO */
     36#define WAIT_TIMEOUT
     37#define ENTER_CRITICAL
     38#define LEAVE_CRITICAL
     39#endif /* TOPPERS_WITH_ARDUINO */
     40
     41
     42#ifdef TOPPERS_WITH_ARDUINO
     43#define WAIT_TIMEOUT delay(1);
    3344#else /* !TOPPERS_WITH_ARDUINO */
    3445#define WAIT_TIMEOUT
    … …  
    98109}
    99110
    100 
    101111uint32_t ESP8266_RingBuffer::copy(uint8_t *pdata, uint32_t size)
    102112{
    … …  
    143153{
    144154    String version;
    145    
     155    int ret = 0;
     156   
     157    ENTER_CRITICAL;
    146158    m_puart = &uart;
    147159    m_baud = baud;
    … …  
    150162    rx_empty();
    151163   
    152     if (!kick()) {
    153         return 1;
    154     }
    155    
    156     eATGMR(version);
    157     if(version.indexOf(ESP8266_SUPPORT_VERSION) == -1) {
    158         return 2;
    159     }
    160    
    161     return 0;
     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;
    162176}
    163177
    164178bool ESP8266::kick(void)
    165179{
    166     return eAT();
    167 }
    168 
    169 bool ESP8266::restart(void)
     180    bool ret;
     181   
     182    ENTER_CRITICAL;
     183    ret = eAT();
     184    LEAVE_CRITICAL;
     185   
     186    return ret;
     187}
     188
     189bool ESP8266::_restart(void)
    170190{
    171191    unsigned long start;
     192    bool ret = false;
     193   
    172194    initialize_status();
    173195    if (eATRST()) {
    … …  
    179201            if (eAT()) {
    180202                delay(1500); /* Waiting for stable */
    181                 return true;
     203                ret = true;
    182204            }
    183205            delay(100);
    184206        }
    185207    }
    186     return false;
     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;
    187221}
    188222
    … …  
    190224{
    191225    String version;
     226   
     227    ENTER_CRITICAL;
    192228    eATGMR(version);
     229    LEAVE_CRITICAL;
     230   
    193231    return version;
    194232}
    … …  
    197235{
    198236    uint8_t mode;
    199     if (!qATCWMODE_CUR(&mode)) {
    200         return false;
    201     }
    202     if (mode == ESP8266_WMODE_STATION) {
    203         return true;
    204     } else {
    205         if (sATCWMODE_CUR(ESP8266_WMODE_STATION) && restart()) {
    206             return true;
     237    bool ret = false;
     238
     239    ENTER_CRITICAL;
     240    if (qATCWMODE_CUR(&mode)) {
     241        if (mode == ESP8266_WMODE_STATION) {
     242            ret = true;
    207243        } else {
    208             return false;
    209         }
    210     }
     244            if (sATCWMODE_CUR(ESP8266_WMODE_STATION) && _restart()) {
     245                ret = true;
     246            }
     247        }
     248    }
     249    LEAVE_CRITICAL;
     250   
     251    return ret;
    211252}
    212253
    … …  
    214255{
    215256    uint8_t mode;
    216     if (!qATCWMODE_CUR(&mode)) {
    217         return false;
    218     }
    219     if (mode == ESP8266_WMODE_SOFTAP) {
    220         return true;
    221     } else {
    222         if (sATCWMODE_CUR(ESP8266_WMODE_SOFTAP) && restart()) {
    223             return true;
     257    bool ret = false;
     258
     259    ENTER_CRITICAL;
     260    if (qATCWMODE_CUR(&mode)) {
     261        if (mode == ESP8266_WMODE_SOFTAP) {
     262            ret = true;
    224263        } else {
    225             return false;
    226         }
    227     }
     264            if (sATCWMODE_CUR(ESP8266_WMODE_SOFTAP) && _restart()) {
     265                ret = true;
     266            }
     267        }
     268    }
     269    LEAVE_CRITICAL;
     270
     271    return ret;
    228272}
    229273
    … …  
    231275{
    232276    uint8_t mode;
    233     if (!qATCWMODE_CUR(&mode)) {
    234         return false;
    235     }
    236     if (mode == ESP8266_WMODE_AP_STATION) {
    237         return true;
    238     } else {
    239         if (sATCWMODE_CUR(ESP8266_WMODE_AP_STATION) && restart()) {
    240             return true;
     277    bool ret = false;
     278
     279    ENTER_CRITICAL;
     280    if (qATCWMODE_CUR(&mode)) {
     281        if (mode == ESP8266_WMODE_AP_STATION) {
     282            ret = true;
    241283        } else {
    242             return false;
    243         }
    244     }
     284            if (sATCWMODE_CUR(ESP8266_WMODE_AP_STATION) && restart()) {
     285                ret = true;
     286            }
     287        }
     288    }
     289    LEAVE_CRITICAL;
     290
     291    return ret;   
    245292}
    246293
    … …  
    248295{
    249296    String list;
     297   
     298    ENTER_CRITICAL;
    250299    eATCWLAP(list);
     300    LEAVE_CRITICAL;
     301   
    251302    return list;
    252303}
    … …  
    254305bool ESP8266::joinAP(String ssid, String pwd)
    255306{
    256     return sATCWJAP_CUR(ssid, pwd);
     307    bool ret;
     308
     309    ENTER_CRITICAL;
     310    ret = sATCWJAP_CUR(ssid, pwd);
     311    LEAVE_CRITICAL;
     312   
     313    return ret;
    257314}
    258315
    259316bool ESP8266::leaveAP(void)
    260317{
    261     return eATCWQAP();
     318    bool ret;
     319
     320    ENTER_CRITICAL;
     321    ret = eATCWQAP();
     322    LEAVE_CRITICAL;
     323   
     324    return ret;
    262325}
    263326
    264327bool ESP8266::setSoftAPParam(String ssid, String pwd, uint8_t chl, uint8_t ecn)
    265328{
    266     return sATCWSAP_CUR(ssid, pwd, chl, ecn);
     329    bool ret;
     330
     331    ENTER_CRITICAL;
     332    ret = sATCWSAP_CUR(ssid, pwd, chl, ecn);
     333    LEAVE_CRITICAL;
     334   
     335    return ret;
    267336}
    268337
    … …  
    270339{
    271340    String list;
     341
     342    ENTER_CRITICAL;
    272343    eATCWLIF(list);
     344    LEAVE_CRITICAL;
     345   
    273346    return list;
    274347}
    … …  
    277350{
    278351    String list;
     352
     353    ENTER_CRITICAL;
    279354    eATCIPSTATUS(list);
     355    LEAVE_CRITICAL;
     356   
    280357    return list;
    281358}
    … …  
    283360String ESP8266::getLocalIP(void)
    284361{
    285     String list;
     362    String list = "";
    286363    int32_t index_start = -1;
    287364    int32_t index_end = -1;
    288    
     365
     366    ENTER_CRITICAL;
    289367    eATCIFSR(list);
    290368    index_start = list.indexOf('\"');
    291369    index_end   = list.indexOf('\"', list.indexOf('\"')+1);
    292370    if ((index_start !=  -1) && (index_end != -1)) {
    293         return list.substring(index_start+1, index_end);
    294     }
    295     return "";
     371        list = list.substring(index_start+1, index_end);
     372    }
     373    LEAVE_CRITICAL;
     374   
     375    return list;
    296376}
    297377
    298378bool ESP8266::enableMUX(void)
    299379{
     380    bool ret = false;
     381
     382    ENTER_CRITICAL;
    300383    if (sATCIPMUX(1)) {
    301384        mux_mode = true;
    302         return true;
    303       }
    304     return false;
     385        ret = true;
     386    }
     387    LEAVE_CRITICAL;
     388   
     389    return ret;
    305390}
    306391
    307392bool ESP8266::disableMUX(void)
    308393{
     394    bool ret = false;
     395
     396    ENTER_CRITICAL;
    309397    if (sATCIPMUX(0)){
    310398        mux_mode = false;
    311         return true;
    312     }
    313     return false;
     399        ret = true;
     400    }
     401    LEAVE_CRITICAL;
     402   
     403    return ret;
    314404}
    315405
    316406bool ESP8266::createTCP(String addr, uint32_t port)
    317407{
    318     bool ret;
     408    bool ret = false;
    319409    if (mux_mode) return false;
    320410
     411    ENTER_CRITICAL;
    321412    if((ret = sATCIPSTARTSingle("TCP", addr, port))) {
    322413        connection_bitmap = 1;
    323414    }
     415    LEAVE_CRITICAL;
     416   
    324417    return ret;
    325418}
    … …  
    327420bool ESP8266::releaseTCP(void)
    328421{
    329     bool ret;
    330    
    331     if (mux_mode) return false;   
     422    bool ret = false;   
     423    if (mux_mode) return false;
     424
     425    ENTER_CRITICAL;
    332426    if((ret = eATCIPCLOSESingle())) {
    333427        connection_bitmap = 0;
    334428        rx_buffer[MUXID_SINGLE].free();
    335429    }
     430    LEAVE_CRITICAL;
     431   
    336432    return ret;   
    337433}
    … …  
    339435bool ESP8266::registerUDP(String addr, uint32_t port)
    340436{
    341     bool ret;
     437    bool ret = false;
    342438    if (mux_mode) return false;
     439
     440    ENTER_CRITICAL;
    343441    if((ret = sATCIPSTARTSingle("UDP", addr, port))) {
    344442        connection_bitmap = 1;
    345     }   
     443    }
     444    LEAVE_CRITICAL;
     445   
    346446    return ret;
    347447}
    … …  
    349449bool ESP8266::unregisterUDP(void)
    350450{
    351     bool ret;
     451    bool ret = false;
    352452    if (mux_mode) return false;
     453
     454    ENTER_CRITICAL;
    353455    if((ret = eATCIPCLOSESingle())) {
    354456        connection_bitmap = 0;
    355457        rx_buffer[MUXID_SINGLE].free();
    356     }   
     458    }
     459    LEAVE_CRITICAL;
     460   
    357461    return ret;   
    358462}
    … …  
    360464bool ESP8266::createTCP(uint8_t mux_id, String addr, uint32_t port)
    361465{
    362     bool ret;
     466    bool ret = false;
    363467    if (!(mux_id < ESP8266_NUM_CONNECTION)) return false;
    364468    if (!mux_mode) return false;
    365    
     469
     470    ENTER_CRITICAL;   
    366471    if((ret = sATCIPSTARTMultiple(mux_id, "TCP", addr, port))) {
    367472        connection_bitmap |= 1 << mux_id;
    368473    }
     474    LEAVE_CRITICAL;
     475   
    369476    return ret;
    370477}
    … …  
    375482    if (!(mux_id < ESP8266_NUM_CONNECTION)) return false;
    376483    if (!mux_mode) return false;
    377    
     484
     485    ENTER_CRITICAL;
    378486    if ((ret = sATCIPCLOSEMulitple(mux_id))) {
    379487        connection_bitmap &= ~(1 << mux_id);
    380488        rx_buffer[mux_id].free();
    381489    }
     490    LEAVE_CRITICAL;
     491   
    382492    return ret;
    383493}
    … …  
    388498    if (!(mux_id < ESP8266_NUM_CONNECTION)) return false;
    389499    if (!mux_mode) return false;
    390    
     500
     501    ENTER_CRITICAL;
    391502    if ((ret = sATCIPSTARTMultiple(mux_id, "UDP", addr, port))) {
    392503        connection_bitmap |= 1 << mux_id;
    393504    }
     505    LEAVE_CRITICAL;
     506   
    394507    return ret;
    395508}
    … …  
    400513    if (!(mux_id < ESP8266_NUM_CONNECTION)) return false;
    401514    if (!mux_mode) return false;
    402    
     515
     516    ENTER_CRITICAL;
    403517    if ((ret = sATCIPCLOSEMulitple(mux_id))) {
    404518        connection_bitmap &= ~(1 << mux_id);
    405519        rx_buffer[mux_id].free();
    406520    }
     521    LEAVE_CRITICAL;
     522   
    407523    return ret;   
    408524}
    … …  
    410526bool ESP8266::setTCPServerTimeout(uint32_t timeout)
    411527{
     528    bool ret;
    412529    if (!mux_mode) return false;
    413     return sATCIPSTO(timeout);
     530
     531    ENTER_CRITICAL;
     532    ret = sATCIPSTO(timeout);
     533    LEAVE_CRITICAL;
     534   
     535    return ret;
    414536}
    415537
    416538bool ESP8266::startTCPServer(uint32_t port)
    417539{
     540    bool ret = false;
    418541    if (!mux_mode) return false;
    419     if (sATCIPSERVER(1, port)) {
    420         return true;
    421     }
    422     return false;
     542
     543    ENTER_CRITICAL;
     544    ret = sATCIPSERVER(1, port);
     545    LEAVE_CRITICAL;
     546   
     547    return ret;
    423548}
    424549
    425550bool ESP8266::stopTCPServer(void)
    426551{
    427     sATCIPSERVER(0);
    428     return false;
     552    bool ret = false;
     553   
     554    ENTER_CRITICAL;
     555    ret = sATCIPSERVER(0);
     556    LEAVE_CRITICAL;
     557   
     558    return ret;
    429559}
    430560
    431561bool ESP8266::startServer(uint32_t port)
    432562{
    433     if (!mux_mode) return false;   
    434     return startTCPServer(port);
     563    bool ret = false;   
     564    if (!mux_mode) return false;
     565   
     566    ENTER_CRITICAL;
     567    ret = startTCPServer(port);
     568    LEAVE_CRITICAL;
     569   
     570    return ret;
    435571}
    436572
    437573bool ESP8266::stopServer(void)
    438574{
    439     return stopTCPServer();
     575    bool ret;
     576
     577    ENTER_CRITICAL;
     578    ret = stopTCPServer();
     579    LEAVE_CRITICAL;
     580   
     581    return ret;
    440582}
    441583
    442584bool ESP8266::send(const uint8_t *buffer, uint32_t len)
    443585{
     586    bool ret;
     587    if (mux_mode) return false;
     588
     589    ENTER_CRITICAL;
     590    ret = sATCIPSENDSingle(buffer, len);
     591    LEAVE_CRITICAL;
     592   
     593    return ret;
     594}
     595
     596bool ESP8266::send(uint8_t mux_id, const uint8_t *buffer, uint32_t len)
     597{
     598    bool ret;
     599    if (!mux_mode) return false;
     600
     601    ENTER_CRITICAL;
     602    ret = sATCIPSENDMultiple(mux_id, buffer, len);
     603    LEAVE_CRITICAL;
     604   
     605    return ret;
     606}
     607
     608bool ESP8266::send(String &str)
     609{
     610    bool ret;
    444611    if (mux_mode) return 0;
    445     return sATCIPSENDSingle(buffer, len);
    446 }
    447 
    448 bool ESP8266::send(uint8_t mux_id, const uint8_t *buffer, uint32_t len)
    449 {
    450     if (!mux_mode) return false;
    451     return sATCIPSENDMultiple(mux_id, buffer, len);
    452 }
    453 
    454 bool ESP8266::send(String &str)
    455 {
    456     if (mux_mode) return 0;
    457     return sATCIPSENDSingle(str);
     612
     613    ENTER_CRITICAL;
     614    ret = sATCIPSENDSingle(str);
     615    LEAVE_CRITICAL;
     616   
     617    return ret;
    458618}
    459619
    460620bool ESP8266::send(uint8_t mux_id, String &str)
    461621{
     622    bool ret;
    462623    if (!mux_mode) return false;
    463624    if (!(mux_id < ESP8266_NUM_CONNECTION)) return false;
    464    
    465     return sATCIPSENDMultiple(mux_id, str);
     625
     626    ENTER_CRITICAL;
     627    ret = sATCIPSENDMultiple(mux_id, str);
     628    LEAVE_CRITICAL;
     629   
     630    return ret;
    466631}
    467632
    468633uint32_t ESP8266::recv(uint8_t *buffer, uint32_t buffer_size, uint32_t timeout)
    469634{
     635    uint32_t ret;
    470636    if (mux_mode) return 0;
    471     return recvPkg(buffer, buffer_size, timeout, 0, NULL);
     637
     638    ENTER_CRITICAL;
     639    ret = recvPkg(buffer, buffer_size, timeout, 0, NULL);
     640    LEAVE_CRITICAL;
     641   
     642    return ret;
    472643}
    473644
    474645uint32_t ESP8266::recv(uint8_t mux_id, uint8_t *buffer, uint32_t buffer_size, uint32_t timeout)
    475646{
     647    uint32_t ret;
    476648    if (!mux_mode) return false;
    477649    if (!(mux_id < ESP8266_NUM_CONNECTION)) return false;
    478    
    479     return recvPkg(buffer, buffer_size, timeout, mux_id, NULL);
     650
     651    ENTER_CRITICAL;
     652    ret = recvPkg(buffer, buffer_size, timeout, mux_id, NULL);
     653    LEAVE_CRITICAL;
     654   
     655    return ret;
    480656}
    481657
    482658uint32_t ESP8266::recv(uint8_t *coming_mux_id, uint8_t *buffer, uint32_t buffer_size, uint32_t timeout)
    483659{
     660    uint32_t ret;
    484661    if (!mux_mode) return false;
    485     return recvPkg(buffer, buffer_size, timeout, MUXID_ANY, coming_mux_id);
     662
     663    ENTER_CRITICAL;
     664    ret = recvPkg(buffer, buffer_size, timeout, MUXID_ANY, coming_mux_id);
     665    LEAVE_CRITICAL;
     666   
     667    return ret;
    486668}
    487669
    488670bool ESP8266::isDataAvailable(uint8_t mux_id)
    489671{
     672    bool ret;
    490673    if (!mux_mode) return false;
    491674    if (!(mux_id < ESP8266_NUM_CONNECTION)) return false;
    492675
    493     if(rx_buffer[mux_id].length() > 0) return true;
    494     rx_update();
    495     if(rx_buffer[mux_id].length() > 0) return true;
    496     return 0;
     676    ENTER_CRITICAL;
     677    if(rx_buffer[mux_id].length() > 0) ret = true;
     678    if (ret == false) {
     679        rx_update();
     680        if(rx_buffer[mux_id].length() > 0) ret = true;
     681    }   
     682    LEAVE_CRITICAL;
     683       
     684    return ret;
    497685}
    498686
    499687bool ESP8266::isDataAvailable(void)
    500688{
     689    bool ret = false;
     690
     691    ENTER_CRITICAL;
    501692    if (mux_mode) {
    502693        for(int i = 0; i < ESP8266_NUM_CONNECTION; i++){
    503             if(rx_buffer[i].length() > 0) return true;
    504         }
    505         rx_update();
    506         for(int i = 0; i < ESP8266_NUM_CONNECTION; i++){
    507             if(rx_buffer[i].length() > 0) return true;
     694            if(rx_buffer[i].length() > 0) ret = true;
     695        }
     696        if (ret == false) {
     697            rx_update();
     698            for(int i = 0; i < ESP8266_NUM_CONNECTION; i++){
     699                if(rx_buffer[i].length() > 0) ret = true;
     700            }
    508701        }
    509702    }
    510703    else {
    511704        /* single mode */
    512         if(rx_buffer[0].length() > 0) return true;
    513         rx_update();
    514         if(rx_buffer[0].length() > 0) return true;       
    515     }
    516     return false;
     705        if(rx_buffer[0].length() > 0) ret = true;
     706        if (ret == false) {
     707            rx_update();
     708            if(rx_buffer[0].length() > 0) ret = true;
     709        }
     710    }
     711    LEAVE_CRITICAL;
     712   
     713    return ret;
    517714}
    518715
    519716bool ESP8266::isConnected(void)
    520717{
    521     if (mux_mode) return false;   
    522     rx_update();
    523     return (connection_bitmap == 1);
     718    bool ret;
     719    if (mux_mode) return false;
     720   
     721    ENTER_CRITICAL;
     722    rx_update();
     723    ret = (connection_bitmap == 1);
     724    LEAVE_CRITICAL;
     725   
     726    return ret;
    524727}
    525728
    526729bool ESP8266::isConnected(uint8_t mux_id)
    527730{
     731    bool ret;
    528732    if (!mux_mode) return false;   
    529733    if (!(mux_id < ESP8266_NUM_CONNECTION)) return false;
    530     rx_update();
    531     return ((connection_bitmap & (1<<mux_id)) != 0);
     734
     735    ENTER_CRITICAL;
     736    rx_update();
     737    ret = ((connection_bitmap & (1<<mux_id)) != 0);
     738    LEAVE_CRITICAL;
     739   
     740    return ret;
    532741}
    533742
    534743bool ESP8266::getMuxCStatus(uint8_t *mux_id_ptn)
    535744{
    536     if (!mux_mode) return false;   
     745    if (!mux_mode) return false;
     746
     747    ENTER_CRITICAL;
    537748    rx_update();
    538749    *mux_id_ptn = connection_bitmap;
     750    LEAVE_CRITICAL;
     751   
    539752    return true;
    540753}
    … …  
    582795            if (rx_cmd.indexOf("+IPD,") != -1) {
    583796                if((ret = recvIPD(timeout - (millis() - start), buffer, buffer_size,
    584                                   mux_id, coming_mux_id)) > 0) {
     797                                  mux_id, coming_mux_id)) != 0) {
    585798                    rx_cmd = "";
    586799                    return ret;
    … …  
    614827    uint32_t i;
    615828    ESP8266_RingBuffer *p_rx_buffer;
    616      
     829
    617830    start = millis();
    618831    while (millis() - start < timeout) {       
    … …  
    665878                }
    666879                WAIT_TIMEOUT
    667             }           
    668             return 0;
     880            }
     881            return i;
    669882        }
    670883        else {
    … …  
    691904                WAIT_TIMEOUT;
    692905            }
    693         }       
     906        }
     907        return i;
    694908    }
    695909   
    … …  
    710924
    711925    if (rx_cmd.indexOf("+IPD,") != -1) {
    712         if(recvIPD(timeout) > 0) {
     926        if(recvIPD(timeout) != 0) {
    713927            rx_cmd = "";
    714928        }
    … …  
    755969    unsigned long start = millis();
    756970    while (millis() - start < timeout) {
    757         while (m_puart->available() > 0) {           
     971        while (m_puart->available() > 0) {
    758972            a = m_puart->read();
    759973            rx_cmd += a;
    … …  
    8001014bool ESP8266::eAT(void)
    8011015{
     1016    rx_update();
    8021017    m_puart->println("AT");
    8031018    return recvFind("OK");
    … …  
    8061021bool ESP8266::eATRST(void)
    8071022{
     1023    rx_update();
    8081024    m_puart->println("AT+RST");
    8091025    return recvFind("OK");
    … …  
    8121028bool ESP8266::eATGMR(String &version)
    8131029{
     1030    rx_update();
    8141031    m_puart->println("AT+GMR");
    8151032    return recvFindAndFilter("OK", "\r\r\n", "\r\nOK", version);
    … …  
    8231040        return false;
    8241041    }
     1042    rx_update();
    8251043    m_puart->println("AT+CWMODE_CUR?");
    8261044    ret = recvFindAndFilter("OK", "+CWMODE_CUR:", "\r\n\r\nOK", str_mode);
    … …  
    8361054{
    8371055    int ret;
    838    
     1056
     1057    rx_update();
    8391058    m_puart->print("AT+CWMODE_CUR=");
    8401059    m_puart->println(mode);
    … …  
    8491068    int ret;
    8501069   
    851     m_puart->print("AT+CWJAP=\"");
     1070    rx_update();
     1071    m_puart->print("AT+CWJAP_CUR=\"");
    8521072    m_puart->print(ssid);
    8531073    m_puart->print("\",\"");
    … …  
    8621082bool ESP8266::eATCWLAP(String &list)
    8631083{
     1084    rx_update();
    8641085    m_puart->println("AT+CWLAP");
    8651086    return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list, 10000);
    … …  
    8681089bool ESP8266::eATCWQAP(void)
    8691090{
     1091    rx_update();
    8701092    m_puart->println("AT+CWQAP");
    8711093    return recvFind("OK");
    … …  
    8761098    int ret;
    8771099   
     1100    rx_update();
    8781101    m_puart->print("AT+CWSAP_CUR=\"");
    8791102    m_puart->print(ssid);
    … …  
    8921115bool ESP8266::eATCWLIF(String &list)
    8931116{
     1117    rx_update();
    8941118    m_puart->println("AT+CWLIF");
    8951119    return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list);
    … …  
    8981122bool ESP8266::eATCIPSTATUS(String &list)
    8991123{
     1124    rx_update();
    9001125    m_puart->println("AT+CIPSTATUS");
    9011126    return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list);
    … …  
    9051130{
    9061131    int ret;
    907    
     1132
     1133    rx_update();
    9081134    m_puart->print("AT+CIPSTART=\"");
    9091135    m_puart->print(type);
    … …  
    9211147{
    9221148    int ret;
    923    
     1149
     1150    rx_update();
    9241151    m_puart->print("AT+CIPSTART=");
    9251152    m_puart->print(mux_id);
    … …  
    9381165bool ESP8266::sATCIPSENDSingle(const uint8_t *buffer, uint32_t len)
    9391166{
     1167    bool ret;
     1168    rx_update();
    9401169    m_puart->print("AT+CIPSEND=");
    9411170    m_puart->println(len);
    … …  
    9441173            m_puart->write(buffer[i]);
    9451174        }
    946         return recvFind("SEND OK", 10000);
    947     }
     1175        ret = recvFind("SEND OK", 10000);
     1176        return ret;
     1177    }
     1178   
    9481179    return false;
    9491180}
    … …  
    9511182bool ESP8266::sATCIPSENDMultiple(uint8_t mux_id, const uint8_t *buffer, uint32_t len)
    9521183{
     1184    rx_update();
    9531185    m_puart->print("AT+CIPSEND=");
    9541186    m_puart->print(mux_id);
    … …  
    9661198bool ESP8266::sATCIPSENDSingle(String &str)
    9671199{
     1200    rx_update();
    9681201    m_puart->print("AT+CIPSEND=");
    9691202    m_puart->println(str.length());
    … …  
    9791212bool ESP8266::sATCIPSENDMultiple(uint8_t mux_id, String &str)
    9801213{
     1214    rx_update();
    9811215    m_puart->print("AT+CIPSEND=");
    9821216    m_puart->print(mux_id);
    … …  
    9961230    int ret;
    9971231   
     1232    rx_update();
    9981233    m_puart->print("AT+CIPCLOSE=");
    9991234    m_puart->println(mux_id);
    … …  
    10061241bool ESP8266::eATCIPCLOSESingle(void)
    10071242{
     1243    int ret;
     1244   
     1245    Serial.println(rx_cmd);
     1246    rx_update();
    10081247    m_puart->println("AT+CIPCLOSE");
    1009     return recvFind("OK", 5000);
     1248    ret = recvString("OK", "ERROR", "", 5000);
     1249    if (ret != -1) rx_cmd = "";
     1250    return ((ret == 1) || (ret == 2));
    10101251}
    10111252
    10121253bool ESP8266::eATCIFSR(String &list)
    10131254{
     1255    rx_update();
    10141256    m_puart->println("AT+CIFSR");
    10151257    return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list);
    … …  
    10191261{
    10201262    int ret;
    1021    
     1263
     1264    rx_update();
    10221265    m_puart->print("AT+CIPMUX=");
    10231266    m_puart->println(mode);
    … …  
    10331276   
    10341277    if (mode) {
     1278        rx_update();
    10351279        m_puart->print("AT+CIPSERVER=1,");
    10361280        m_puart->println(port);       
    … …  
    10391283        return (ret == 1);
    10401284    } else {
     1285        rx_update();
    10411286        m_puart->println("AT+CIPSERVER=0");
    10421287        ret = recvString("OK", "ERROR", "");
    … …  
    10471292bool ESP8266::sATCIPSTO(uint32_t timeout)
    10481293{
     1294    rx_update();
    10491295    m_puart->print("AT+CIPSTO=");
    10501296    m_puart->println(timeout);

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

    r183 r189  
    5959};
    6060
    61 #define ESP8266_RINGBUFFER_SIZE  512
     61#define ESP8266_RINGBUFFER_SIZE  1024
    6262
    6363class ESP8266_RingBuffer
    … …  
    559559
    560560    void recvAsyncdata(uint32_t timeout = 0);
     561
     562    /**
     563     * Restart ESP8266 by "AT+RST".
     564     *
     565     * This method will take 3 seconds or more.
     566     *
     567     * @retval true - success.
     568     * @retval false - failure.
     569     */
     570    bool _restart(void);   
    561571   
    562572#ifdef ESP8266_USE_SOFTWARE_SERIAL
Note: See TracChangeset for help on using the changeset viewer.