net_cc32xx/CC32xxWiFi.hxx

Go to the documentation of this file.

 
#ifndef _FREERTOS_DRIVERS_NET_C32XX_CC32XXWIFI_HXX_
#define _FREERTOS_DRIVERS_NET_C32XX_CC32XXWIFI_HXX_
 
#include <functional>
#include <vector>
#include <string>
 
#include "os/OS.hxx"
#include "utils/Singleton.hxx"
#include "utils/format_utils.hxx"
#include "freertos_drivers/common/WifiDefs.hxx"
 
class CC32xxSocket;
class NetworkSpace;
 
class CC32xxWiFiInterface
{
public:
    enum SecurityType
    {
        SEC_OPEN, 
        SEC_WEP,  
        SEC_WPA2, 
    };
 
protected:
    virtual ~CC32xxWiFiInterface()
    {
    }
 
    virtual void wlan_setup_ap(const char *ssid, const char *security_key,
                               SecurityType security_type) = 0;
 
    virtual int wlan_profile_del(int index) = 0;
};
 
class CC32xxWiFi : public CC32xxWiFiInterface, public Singleton<CC32xxWiFi>
{
public:
 
    static constexpr int PROFILE_DELETE_ALL = 0xFF;
 
    static constexpr int NUM_PROFILES = 7;
 
    static constexpr unsigned IPPROTO_TCP_TLS = 254;
 
    static constexpr unsigned SO_SIMPLELINK_SD = 65537;
    
    struct WlanEvent;
 
    struct NetAppEvent;
 
    struct SockEvent;
 
    struct SockTriggerEvent;
 
    struct HttpServerEvent;
 
    struct HttpServerResponse;
 
    struct NetAppRequest;
 
    struct NetAppResponse;
 
    struct FatalErrorEvent;
    
    enum WlanConnectionPolicy {
        WLAN_CONNECTION_NO_CHANGE,
        WLAN_CONNECTION_SCAN,
        WLAN_CONNECTION_FAST_RECONNECT
    };
    
    enum WlanPowerPolicy
    {
        WLAN_NORMAL_POLICY,      
        WLAN_LOW_LATENCY_POLICY, 
        WLAN_LOW_POWER_POLICY,   
        WLAN_ALWAYS_ON_POLICY,   
        WLAN_NO_CHANGE_POLICY,   
    };
 
    struct WlanNetworkEntry
    {
        string ssid; 
        SecurityType sec_type; 
        int rssi; 
    };
 
    using PostFunction = std::function<void(uint16_t handle,
        uint32_t content_length, const uint8_t *md, size_t md_len,
        const uint8_t *payload, size_t payload_len, bool has_more)>;
 
    CC32xxWiFi();
 
    ~CC32xxWiFi()
    {
    }
 
    void test_mode_start();
 
    void start(WlanRole role = WlanRole::STA,
        WlanPowerPolicy power_policy = WLAN_NO_CHANGE_POLICY,
        WlanConnectionPolicy connection_policy = WLAN_CONNECTION_NO_CHANGE);
 
    void stop();
 
    bool is_started()
    {
        return started;
    }
 
    WlanConnectResult wlan_connect(const char *ssid, const char *security_key,
                                   SecurityType security_type);
 
    void wlan_disconnect();
 
    void wlan_wps_pbc_initiate();
 
    void wlan_setup_ap(const char *ssid, const char *security_key,
                       SecurityType security_type) override;
 
    void wlan_get_ap_config(string *ssid, SecurityType *security_type);
 
    int wlan_get_ap_station_count();
 
    bool wlan_ready()
    {
        return (connected || wlanRole == WlanRole::AP) && ipAcquired;
    }
 
    WlanRole wlan_role()
    {
        return wlanRole;
    }
 
    void wlan_set_role(WlanRole new_role);
 
    WlanState wlan_startup_state()
    {
        if (!connected && wlanRole != WlanRole::AP)
        {
            if (securityFailure)
            {
                return WlanState::WRONG_PASSWORD;
            }
            return WlanState::NOT_ASSOCIATED;
        }
        if (!ipAcquired)
        {
            return WlanState::NO_IP;
        }
        return WlanState::OK;
    }
 
#ifdef GTEST
    void TEST_set_state(
        bool conn, bool has_ip, bool wrong_password, const string &ssid)
    {
        connected = conn ? 1 : 0;
        ipAcquired = has_ip ? 1 : 0;
        securityFailure = wrong_password ? 1 : 0;
        strcpy(this->ssid, ssid.c_str());
    }
 
    void TEST_set_ip(uint32_t ip)
    {
        ipAddress = ip;
    }
#endif
 
    void connecting_update_blinker();
 
    CountryCode wlan_country_code_get();
 
    int wlan_country_code_set(CountryCode cc, bool restart = false);
 
    void wlan_set_scan_params(int mask, int min_rssi);
    
    int wlan_profile_add(const char *ssid, SecurityType sec_type,
                         const char *key, unsigned priority);
 
    int wlan_profile_del(const char *ssid);
 
    int wlan_profile_del(int index) override;
 
    int wlan_profile_get(int index, char ssid[], SecurityType *sec_type,
                         uint32_t *priority);
 
    bool wlan_profile_test_none();
 
    int wlan_power_policy_set(WlanPowerPolicy wpp);
 
    int wlan_power_policy_get(WlanPowerPolicy *wpp);
 
    void wlan_connection_policy_set(WlanConnectionPolicy policy);
    
    int wlan_network_list_get(WlanNetworkEntry *entries, size_t count);
 
    void wlan_rescan();
    
    void wlan_mac(uint8_t mac[6]);
 
    void wlan_set_mac(uint8_t mac[6]);
 
    uint32_t wlan_ip()
    {
        return ipAcquired ? ipAddress : 0;
    }
 
    const char *wlan_ssid()
    {
        ssid[32] = '\0';
        return ssid;
    }
 
    int wlan_rssi()
    {
        // the RSSI value is only reliable when associatedd
        return wlan_startup_state() == WlanState::NOT_ASSOCIATED ? 0 : rssi;
    }
 
    void set_ip_acquired_callback(std::function<void(bool)> callback)
    {
        ipAcquiredCallback_ = callback;
    }
 
    void run_on_network_thread(std::function<void()> callback);
 
    void add_http_get_token_callback(
        const char *token_name, std::function<std::string()> callback)
    {
        OSMutexLock l(&lock_);
        httpGetTokenCallbacks_.emplace_back(token_name, std::move(callback));
    }
 
    void add_http_post_callback(const char *uri, PostFunction callback)
    {
        OSMutexLock l(&lock_);
        httpPostCallbacks_.emplace_back(uri, std::move(callback));
    }
 
    bool get_post_data(uint16_t handle, void *buf, size_t *len);
 
    void send_post_respose(uint16_t handle, uint16_t http_status = 204,
        const string &redirect = "");
 
    void wlan_event_handler(WlanEvent *event);
 
    void net_app_event_handler(NetAppEvent *event);
 
    void sock_event_handler(SockEvent *event);
 
    void trigger_event_handler(SockTriggerEvent *event);
 
    void http_server_callback(HttpServerEvent *event,
                              HttpServerResponse *response);
 
    void netapp_request_callback(
        NetAppRequest *request, NetAppResponse *response);
 
    void fatal_error_callback(FatalErrorEvent* event);
 
    static std::string get_version();
 
private:
    friend class ::NetworkSpace;
 
    static uint8_t security_type_to_simplelink(SecurityType sec_type);
 
    static SecurityType security_type_from_simplelink(uint8_t sec_type);
 
    static SecurityType security_type_from_scan(unsigned sec_type);
    
    void set_default_state();
 
    static void* wlan_task_entry(void *context)
    {
        instance()->wlan_task();
        return nullptr;
    }
 
    void wlan_task();
 
    void select_wakeup();
 
    void fd_remove(int16_t sd);
 
    void fd_set_read(int16_t sd);
 
    void fd_set_write(int16_t sd);
 
    string http_get_ip_address()
    {
        return ipv4_to_string(ipAddress);
    }
 
    uint32_t ipAddress; 
    char ssid[33]; 
    std::function<void(bool)> ipAcquiredCallback_;
 
    std::vector<std::function<void()> > callbacks_;
 
    std::vector<std::pair<const char *, std::function<std::string()>>>
        httpGetTokenCallbacks_;
 
    std::vector<std::pair<const char *, PostFunction>> httpPostCallbacks_;
 
    OSMutex lock_;
 
    int wakeup; 
    int16_t rssi; 
    WlanRole wlanRole; 
    WlanPowerPolicy wlanPowerPolicy; 
    WlanConnectionPolicy connectionPolicy; 
    unsigned started          : 1; 
    unsigned connected        : 1; 
    unsigned connectionFailed : 1; 
    unsigned ipAcquired       : 1; 
    unsigned ipLeased         : 1; 
    unsigned smartConfigStart : 1; 
    unsigned securityFailure  : 1; 
    friend class CC32xxSocket;
 
    DISALLOW_COPY_AND_ASSIGN(CC32xxWiFi);
};
 
#endif /* _FREERTOS_DRIVERS_NET_C32XX_CC32XXWIFI_HXX_ */