ESPWifiClient.hxx

Go to the documentation of this file.

 
#ifndef _UTILS_ESPWIFICLIENT_HXX_
#define _UTILS_ESPWIFICLIENT_HXX_
 
extern "C" {
#include "ets_sys.h"
#include <ip_addr.h>
#include <user_interface.h>
#include <osapi.h>
#include <espconn.h>
}
 
#include "utils/Singleton.hxx"
#include "utils/Hub.hxx"
#include "utils/GridConnectHub.hxx"
 
class ESPWifiClient : public Singleton<ESPWifiClient>, private HubPort
{
public:
    ESPWifiClient(const string &ssid, const string &password, CanHubFlow *hub,
        const string &hostname, int port, unsigned send_buf_size,
        std::function<void()> connect_callback)
        : HubPort(hub->service())
        , host_(hostname)
        , port_(port)
        , sendPending_(0)
        , sendBlocked_(0)
        , timerPending_(0)
        , sendBuf_((uint8_t*)malloc(send_buf_size))
        , bufSize_(send_buf_size)
        , hub_(hub)
        , gcHub_(hub_->service())
        , connectCallback_(std::move(connect_callback))
    {
 
        wifi_set_opmode_current(STATION_MODE);
        memcpy(&stationConfig_.ssid, ssid.c_str(), ssid.size() + 1);
        memcpy(&stationConfig_.password, password.c_str(), password.size() + 1);
        wifi_station_set_config(&stationConfig_);
        wifi_set_event_handler_cb(&static_wifi_callback);
        wifi_station_connect(); // may be avoided if the constructor is still
                                // called in the user_init.
    }
 
    static void static_wifi_callback(System_Event_t *evt)
    {
        os_printf("%s: %d\n", __FUNCTION__, evt->event);
 
        switch (evt->event)
        {
            case EVENT_STAMODE_CONNECTED:
            {
                os_printf("connect to ssid %s, channel %d\n",
                    evt->event_info.connected.ssid,
                    evt->event_info.connected.channel);
                break;
            }
 
            case EVENT_STAMODE_DISCONNECTED:
            {
                os_printf("disconnect from ssid %s, reason %d\n",
                    evt->event_info.disconnected.ssid,
                    evt->event_info.disconnected.reason);
 
                system_deep_sleep_set_option(0);
                system_deep_sleep(60 * 1000 * 1000); // 60 seconds
                break;
            }
 
            case EVENT_STAMODE_GOT_IP:
            {
                /*
                os_printf("ip:" IPSTR ",mask:" IPSTR ",gw:" IPSTR,
                    IP2STR(evt->event_info.got_ip.ip),
                    IP2STR(evt->event_info.got_ip.mask),
                    IP2STR(evt->event_info.got_ip.gw));
                    os_printf("\n");*/
 
                Singleton<ESPWifiClient>::instance()->do_dns_lookup();
                break;
            }
 
            default:
            {
                break;
            }
        }
    }
 
    void do_dns_lookup()
    {
        espconn_gethostbyname(&conn_, host_.c_str(), &targetIp_, dns_done);
    }
 
    static void dns_done(const char *name, ip_addr_t *ipaddr, void *arg)
    {
        if (ipaddr == NULL)
        {
            os_printf("DNS lookup failed\n");
            wifi_station_disconnect();
            return;
        }
        Singleton<ESPWifiClient>::instance()->do_connect(ipaddr);
    }
 
    void do_connect(ip_addr_t *ipaddr)
    {
        os_printf("Connecting to %s:%d...\n", host_.c_str(), port_);
 
        conn_.type = ESPCONN_TCP;
        conn_.state = ESPCONN_NONE;
        conn_.proto.tcp = &tcp_;
        conn_.proto.tcp->local_port = espconn_port();
        conn_.proto.tcp->remote_port = port_;
        memcpy(conn_.proto.tcp->remote_ip, &ipaddr->addr, 4);
 
        espconn_regist_connectcb(&conn_, static_tcp_connected);
        espconn_regist_disconcb(&conn_, static_tcp_disconnected);
 
        espconn_connect(&conn_);
    }
 
    static void static_tcp_connected(void *arg)
    {
        os_printf("%s\n", __FUNCTION__);
        Singleton<ESPWifiClient>::instance()->tcp_connected();
    }
 
    void tcp_connected()
    {
        gcAdapter_.reset(
            GCAdapterBase::CreateGridConnectAdapter(&gcHub_, hub_, false));
        espconn_regist_recvcb(&conn_, static_data_received);
        espconn_regist_sentcb(&conn_, static_data_sent);
        gcHub_.register_port(this);
        connectCallback_();
    }
 
    static void static_tcp_disconnected(void *arg)
    {
        os_printf("%s\n", __FUNCTION__);
        Singleton<ESPWifiClient>::instance()->tcp_disconnected();
    }
 
    void tcp_disconnected()
    {
        gcHub_.unregister_port(this);
        gcAdapter_->shutdown();
        wifi_station_disconnect();
    }
 
    static void static_data_received(void *arg, char *pdata, unsigned short len)
    {
        Singleton<ESPWifiClient>::instance()->data_received(pdata, len);
    }
 
    static void static_data_sent(void *arg)
    {
        Singleton<ESPWifiClient>::instance()->data_sent();
    }
 
    void data_received(char *pdata, unsigned short len)
    {
        auto *b = gcHub_.alloc();
        b->data()->skipMember_ = this;
        b->data()->assign(pdata, len);
        gcHub_.send(b);
    }
 
private:
    Action entry() override
    {
        if (sendPending_)
        {
            sendBlocked_ = 1;
            // Will call again once the wifi notification comes back.
            return wait();
        }
        if (message()->data()->size() > bufSize_)
        {
            if (bufEnd_ > 0)
            {
                // Cannot copy the data to the buffer. Must send separately.
                send_buffer();
                return again();
            }
            else
            {
                sendPending_ = 1;
                sendBlocked_ = 1; // will cause notify.
                espconn_sent(&conn_, (uint8 *)message()->data()->data(),
                    message()->data()->size());
                return wait_and_call(STATE(send_done));
            }
        }
        if (message()->data()->size() > bufSize_ - bufEnd_)
        {
            // Doesn't fit into the current buffer.
            send_buffer();
            return again();
        }
        // Copies the data into the buffer.
        memcpy(sendBuf_ + bufEnd_, message()->data()->data(),
            message()->data()->size());
        bufEnd_ += message()->data()->size();
        release();
        // Decides whether to send off the buffer now.
        if (!queue_empty())
        {
            // let's process more of the queue
            return exit();
        }
        if (!timerPending_)
        {
            timerPending_ = 1;
            bufferTimer_.start(MSEC_TO_NSEC(3));
        }
        return exit();
    }
 
    void timeout()
    {
        timerPending_ = 0;
        if (!sendPending_) {
            send_buffer();
        }
    }
 
    Action send_done()
    {
        return release_and_exit();
    }
 
    void send_buffer()
    {
        espconn_sent(&conn_, sendBuf_, bufEnd_);
        sendPending_ = 1;
    }
 
    void data_sent()
    {
        sendPending_ = 0;
        bufEnd_ = 0;
        if (sendBlocked_)
        {
            sendBlocked_ = 0;
            notify();
        }
    }
 
    class BufferTimer : public ::Timer
    {
    public:
        BufferTimer(ESPWifiClient *parent)
            : Timer(parent->service()->executor()->active_timers())
            , parent_(parent)
        {
        }
 
        long long timeout() override
        {
            parent_->timeout();
            return NONE;
        }
    private:
        ESPWifiClient *parent_; 
    } bufferTimer_{this}; 
 
    struct station_config stationConfig_;
    struct espconn conn_;
    esp_tcp tcp_;
 
    ip_addr_t targetIp_;
    string host_;
    int port_;
    uint16_t sendPending_ : 1;
    uint16_t sendBlocked_ : 1;
    uint16_t timerPending_ : 1;
 
    uint16_t bufEnd_ : 16;
    uint8_t *sendBuf_;
    unsigned bufSize_;
    CanHubFlow *hub_;
    HubFlow gcHub_;
    std::unique_ptr<GCAdapterBase> gcAdapter_;
    std::function<void()> connectCallback_;
};
 
#endif // _UTILS_ESPWIFICLIENT_HXX_