KBF-32 implement wifi::sta

include/kbf/internal/wifi.h

@@ -8,6 +8,8 @@ namespace kbf::wifi::internal {
     extern bool initialized;
 
     extern Mode mode;
+
+    void setMode(Mode m);
 }
 
 #endif //KBF_INTERNAL_WIFI_H

include/kbf/wifi.h

@@ -49,7 +49,7 @@ namespace kbf::wifi {
 
     struct APInfo {
         std::string ssid;
-        uint8_t rssi;
+        int8_t rssi;
     };
 
     namespace sta {
@@ -57,7 +57,7 @@ namespace kbf::wifi {
 
         void stop();
 
-        bool connect(std::string ssid, std::string password, bool async = false, int maxRetry = 3);
+        bool connect(std::string ssid, std::string password, bool async = false, int maxAttempts = 3);
 
         void disconnect();
 

include/kbf/wifi_legacy.h

@@ -21,7 +21,7 @@ using std::vector;
  *
  * @deprecated use kbf::wifi instead
  */
-namespace kbf::wifi {
+namespace kbf::wifi_legacy {
     /** @brief Tag used for logging */
     static constexpr const char *TAG = "kbf::wifi";
 
@@ -32,7 +32,7 @@ namespace kbf::wifi {
     /**
      * @brief Starts WiFi in soft-AP mode.
      *
-     * @see #kbf::wifi::AP::create()
+     * @see #kbf::wifi_legacy::AP::create()
      *
      * @param ap AP pointer
      */
@@ -41,7 +41,7 @@ namespace kbf::wifi {
     /**
      * @brief Starts WiFi in STA mode.
      *
-     * @param sta STA pointer; if nullptr, kbf::wifi::STA::create() will be called.
+     * @param sta STA pointer; if nullptr, kbf::wifi_legacy::STA::create() will be called.
      */
     void start(shared_ptr<STA> sta = nullptr);
 
@@ -104,18 +104,18 @@ namespace kbf::wifi {
      * @brief WiFi station (STA) mode.
      */
     class STA {
-        /** @see #kbf::wifi::start() */
-        friend void kbf::wifi::start(shared_ptr<STA>);
+        /** @see #kbf::wifi_legacy::start() */
+        friend void kbf::wifi_legacy::start(shared_ptr<STA>);
 
-        /** @see #kbf::wifi::start() */
-        friend void kbf::wifi::start(shared_ptr<AP>, shared_ptr<STA>);
+        /** @see #kbf::wifi_legacy::start() */
+        friend void kbf::wifi_legacy::start(shared_ptr<AP>, shared_ptr<STA>);
 
-        /** @see #kbf::wifi::stop() */
-        friend void kbf::wifi::stop();
+        /** @see #kbf::wifi_legacy::stop() */
+        friend void kbf::wifi_legacy::stop();
 
     public:
         /** @brief Tag used for logging. */
-        static constexpr const char *TAG = "kbf::wifi::STA";
+        static constexpr const char *TAG = "kbf::wifi_legacy::STA";
 
         /**
          * @brief Creates STA instance.
@@ -123,7 +123,7 @@ namespace kbf::wifi {
          * @note WiFi requires NVS. If NVS hasn't been initialized yet, the constructor will call #kbf::nvs::init()
          * and try again.
          *
-         * @see #kbf::wifi::start()
+         * @see #kbf::wifi_legacy::start()
          *
          * @return shared_ptr<STA>
          */
@@ -250,24 +250,24 @@ namespace kbf::wifi {
     /**
      * @brief WiFi Software-enabled AccessPoint (AP) mode
      *
-     * To start AP, use the #create() method to create an instance of this class, then pass it to #kbf::wifi::start().
+     * To start AP, use the #create() method to create an instance of this class, then pass it to #kbf::wifi_legacy::start().
      */
     class AP {
-        /** @see #kbf::wifi::start() */
-        friend void kbf::wifi::start(shared_ptr<AP>);
+        /** @see #kbf::wifi_legacy::start() */
+        friend void kbf::wifi_legacy::start(shared_ptr<AP>);
 
-        /** @see #kbf::wifi::start() */
-        friend void kbf::wifi::start(shared_ptr<AP>, shared_ptr<STA>);
+        /** @see #kbf::wifi_legacy::start() */
+        friend void kbf::wifi_legacy::start(shared_ptr<AP>, shared_ptr<STA>);
 
-        /** @see #kbf::wifi::stop() */
-        friend void kbf::wifi::stop();
+        /** @see #kbf::wifi_legacy::stop() */
+        friend void kbf::wifi_legacy::stop();
 
-        /** @see #kbf::wifi::stopAP() */
-        friend void kbf::wifi::stopAP();
+        /** @see #kbf::wifi_legacy::stopAP() */
+        friend void kbf::wifi_legacy::stopAP();
 
     public:
         /** @brief Tag used for logging. */
-        static constexpr const char *TAG = "kbf::wifi::AP";
+        static constexpr const char *TAG = "kbf::wifi_legacy::AP";
 
         /**
          * @brief Creates an instance of the class.

src/wifi/ap.cpp

@@ -43,7 +43,11 @@ const std::string &ap::ssid() { return ::ssid; }
 
 const std::string &ap::password() { return ::password; }
 
-void ap::start(std::string ssid, std::string password, net::IP ip, net::IP netmask) {
+void (*ap::onConnect)(STA &) = nullptr;
+
+void (*ap::onDisconnect)(STA &) = nullptr;
+
+void ap::start(string ssid, string password, net::IP ip, net::IP netmask) {
     ESP_LOGI(TAG, "%s(%s, <omitted>, %s, %s)", __func__, ssid.c_str(), ip.str().c_str(), netmask.str().c_str());
 
     if (internal::mode == Mode::AP || internal::mode == Mode::DUAL) throw exception::InvalidMode();
@@ -55,99 +59,105 @@ void ap::start(std::string ssid, std::string password, net::IP ip, net::IP netma
     initDhcp(ip, netmask);
     registerEventHandlers();
 
-    std::move(ssid.begin(), ssid.end(), ::ssid);
-    std::move(password.begin(), password.end(), ::password);
+    ::ssid     = std::move(ssid);
+    ::password = std::move(password);
+
+    std::copy(::ssid.begin(), ::ssid.end() + 1, std::begin(apConfig.ssid));
+    std::copy(::password.begin(), ::password.end() + 1, std::begin(apConfig.password));
 
     apConfig.ssid_len       = ::ssid.length();
     apConfig.max_connection = 5; // TODO use Kconfig
     apConfig.authmode       = WIFI_AUTH_WPA2_PSK; // TODO use AUTH_OPEN if no password is provided
 
     wifi_config_t config = {.ap = apConfig};
-    CHECK(esp_wifi_set_config(WIFI_IF_AP, &config));
 
     if (internal::mode == Mode::OFF) {
         CHECK(esp_wifi_set_mode(WIFI_MODE_AP));
+        CHECK(esp_wifi_set_config(WIFI_IF_AP, &config));
         CHECK(esp_wifi_start());
-        internal::mode = Mode::AP;
+        internal::setMode(Mode::AP);
     } else {
         CHECK(esp_wifi_set_mode(WIFI_MODE_APSTA));
-        internal::mode = Mode::DUAL;
+        CHECK(esp_wifi_set_config(WIFI_IF_AP, &config));
+        internal::setMode(Mode::DUAL);
     }
 }
 
 void ap::stop() {
     ESP_LOGI(TAG, "%s()", __func__);
 
-    if (internal::mode != Mode::AP && internal::mode != Mode::DUAL) {
-        throw wifi::exception::InvalidMode();
-    }
+    if (internal::mode != Mode::AP && internal::mode != Mode::DUAL) throw wifi::exception::InvalidMode();
 
-    esp_netif_destroy(interface);
     unregisterEventHandlers();
 
     if (internal::mode == Mode::DUAL) {
         CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
-        internal::mode = Mode::STA;
+        internal::setMode(Mode::STA);
     } else {
         CHECK(esp_wifi_stop());
-        internal::mode = Mode::OFF;
+        internal::setMode(Mode::OFF);
     }
+
+    esp_netif_destroy(interface);
 }
 
-void initDhcp(const net::IP &ip, const net::IP &netmask) {
-    ESP_LOGI(TAG, "%s()", __func__);
+namespace {
+    void initDhcp(const net::IP &ip, const net::IP &netmask) {
+        ESP_LOGI(TAG, "%s()", __func__);
 
-    if (dhcpInit) {
-        ESP_LOGI(TAG, "DHCP already initialized");
-        return;
-    }
+        if (dhcpInit) {
+            // TODO do something with this; DHCP will fail silently if interface is already up
+            ESP_LOGI(TAG, "DHCP already initialized");
+            return;
+        }
 
-    esp_netif_ip_info_t ipInfo;
-    IP4_ADDR(&ipInfo.ip, ip[0], ip[1], ip[2], ip[3]);
-    IP4_ADDR(&ipInfo.gw, ip[0], ip[1], ip[2], ip[3]);
-    IP4_ADDR(&ipInfo.netmask, netmask[0], netmask[1], netmask[2], netmask[3]);
+        esp_netif_ip_info_t ipInfo;
+        IP4_ADDR(&ipInfo.ip, ip[0], ip[1], ip[2], ip[3]);
+        IP4_ADDR(&ipInfo.gw, ip[0], ip[1], ip[2], ip[3]);
+        IP4_ADDR(&ipInfo.netmask, netmask[0], netmask[1], netmask[2], netmask[3]);
 
-    CHECK(esp_netif_dhcps_stop(interface));
-    CHECK(esp_netif_set_ip_info(interface, &ipInfo));
-    CHECK(esp_netif_dhcps_start(interface));
+        CHECK(esp_netif_dhcps_stop(interface));
+        CHECK(esp_netif_set_ip_info(interface, &ipInfo));
+        CHECK(esp_netif_dhcps_start(interface));
 
-    dhcpInit = true;
-}
+        dhcpInit = true;
+    }
 
-void registerEventHandlers() {
-    ESP_LOGI(TAG, "%s()", __func__);
+    void registerEventHandlers() {
+        ESP_LOGI(TAG, "%s()", __func__);
 
-    CHECK(esp_event_handler_instance_register(
-            WIFI_EVENT, WIFI_EVENT_AP_STACONNECTED, &handleConnect, nullptr, &connectHandler
-    ));
-    CHECK(esp_event_handler_instance_register(
-            WIFI_EVENT, WIFI_EVENT_AP_STADISCONNECTED, &handleDisconnect, nullptr, &disconnectHandler
-    ));
-}
+        CHECK(esp_event_handler_instance_register(
+                WIFI_EVENT, WIFI_EVENT_AP_STACONNECTED, &handleConnect, nullptr, &connectHandler
+        ));
+        CHECK(esp_event_handler_instance_register(
+                WIFI_EVENT, WIFI_EVENT_AP_STADISCONNECTED, &handleDisconnect, nullptr, &disconnectHandler
+        ));
+    }
 
-void unregisterEventHandlers() {
-    ESP_LOGI(TAG, "%s()", __func__);
+    void unregisterEventHandlers() {
+        ESP_LOGI(TAG, "%s()", __func__);
 
-    CHECK(esp_event_handler_instance_unregister(WIFI_EVENT, WIFI_EVENT_AP_STACONNECTED, &connectHandler));
-    CHECK(esp_event_handler_instance_unregister(WIFI_EVENT, WIFI_EVENT_AP_STADISCONNECTED, &disconnectHandler));
-    CHECK(esp_event_handler_unregister(WIFI_EVENT, WIFI_EVENT_AP_STACONNECTED, &handleConnect));
-    CHECK(esp_event_handler_unregister(WIFI_EVENT, WIFI_EVENT_AP_STADISCONNECTED, &handleDisconnect));
-}
+        CHECK(esp_event_handler_instance_unregister(WIFI_EVENT, WIFI_EVENT_AP_STACONNECTED, &connectHandler));
+        CHECK(esp_event_handler_instance_unregister(WIFI_EVENT, WIFI_EVENT_AP_STADISCONNECTED, &disconnectHandler));
+        CHECK(esp_event_handler_unregister(WIFI_EVENT, WIFI_EVENT_AP_STACONNECTED, &handleConnect));
+        CHECK(esp_event_handler_unregister(WIFI_EVENT, WIFI_EVENT_AP_STADISCONNECTED, &handleDisconnect));
+    }
 
-void handleConnect(void *, esp_event_base_t, int32_t, void *data) {
-    ESP_LOGI(TAG, "%s()", __func__);
+    void handleConnect(void *, esp_event_base_t, int32_t, void *data) {
+        ESP_LOGI(TAG, "%s()", __func__);
 
-    if (ap::onConnect) {
-        auto sta = STA(*static_cast<wifi_event_ap_staconnected_t *>(data));
-        ap::onConnect(sta);
+        if (ap::onConnect) {
+            auto sta = STA(*static_cast<wifi_event_ap_staconnected_t *>(data));
+            ap::onConnect(sta);
+        }
     }
-}
 
-void handleDisconnect(void *, esp_event_base_t, int32_t, void *data) {
-    ESP_LOGI(TAG, "%s()", __func__);
+    void handleDisconnect(void *, esp_event_base_t, int32_t, void *data) {
+        ESP_LOGI(TAG, "%s()", __func__);
 
-    if (ap::onDisconnect) {
-        auto sta = STA(*static_cast<wifi_event_ap_staconnected_t *>(data));
-        ap::onDisconnect(sta);
+        if (ap::onDisconnect) {
+            auto sta = STA(*static_cast<wifi_event_ap_staconnected_t *>(data));
+            ap::onDisconnect(sta);
+        }
     }
 }

src/wifi/sta.cpp

@@ -1 +1,244 @@
 #include "kbf/wifi.h"
+
+#include <esp_log.h>
+#include <esp_wifi.h>
+
+#define KBF_INTERNAL
+
+#include "kbf/internal/wifi.h"
+#include "kbf/macros.h"
+#include "kbf/exception.h"
+#include "kbf/rtos.h"
+
+using namespace kbf;
+using namespace kbf::wifi;
+using std::string;
+using std::vector;
+
+constexpr const char *const TAG = "kbf::wifi::sta";
+
+namespace {
+    string ssid;
+    string password;
+
+    int retryNum                           = 0;
+    int retryMax                           = 0;
+
+    bool         connected;
+    kbf::net::IP ip; // NOLINT(cert-err58-cpp)
+
+    kbf::rtos::EventGroup event; // NOLINT(cert-err58-cpp)
+    const int             CONNECT_FINISHED = 0;
+
+    esp_netif_obj     *interface = nullptr;
+    wifi_sta_config_t staConfig  = {};
+
+    esp_event_handler_instance_t connectHandler    = {};
+    esp_event_handler_instance_t ipHandler         = {};
+    esp_event_handler_instance_t disconnectHandler = {};
+    esp_event_handler_instance_t scanDoneHandler   = {};
+
+    void handleConnect(void *, esp_event_base_t, int32_t, void *);
+
+    void handleDisconnect(void *, esp_event_base_t, int32_t, void *);
+
+    void handleIp(void *, esp_event_base_t, int32_t, void *);
+
+    void handleScanDone(void *, esp_event_base_t, int32_t, void *);
+
+    void registerEventHandlers();
+
+    void unregisterEventHandlers();
+}
+
+bool sta::connected() { return ::connected; }
+
+const string &sta::ssid() { return ::ssid; }
+
+const string &sta::password() { return ::password; }
+
+const net::IP &sta::ip() { return ::ip; }
+
+void (*sta::onConnect)() = nullptr;
+
+void (*sta::onIp)() = nullptr;
+
+void (*sta::onDisconnect)() = nullptr;
+
+void (*sta::onScanDone)(vector<APInfo> &apList, void *data) = nullptr;
+
+void sta::start() {
+    ESP_LOGI(TAG, "%s()", __func__);
+
+    if (internal::mode == Mode::STA || internal::mode == Mode::DUAL) throw exception::InvalidMode();
+
+    internal::init();
+    interface = esp_netif_create_default_wifi_sta();
+    registerEventHandlers();
+
+    staConfig.pmf_cfg = {true, false};
+    wifi_config_t config = {.sta = staConfig};
+
+    if (internal::mode == Mode::OFF) {
+        CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
+        CHECK(esp_wifi_set_config(WIFI_IF_STA, &config));
+        CHECK(esp_wifi_start());
+        internal::setMode(Mode::STA);
+    } else {
+        CHECK(esp_wifi_set_mode(WIFI_MODE_APSTA));
+        CHECK(esp_wifi_set_config(WIFI_IF_STA, &config));
+        internal::setMode(Mode::DUAL);
+    }
+}
+
+void sta::stop() {
+    ESP_LOGI(TAG, "%s()", __func__);
+
+    if (internal::mode != Mode::STA && internal::mode != Mode::DUAL) throw wifi::exception::InvalidMode();
+
+    unregisterEventHandlers();
+
+    if (internal::mode == Mode::DUAL) {
+        CHECK(esp_wifi_set_mode(WIFI_MODE_AP));
+        internal::setMode(Mode::AP);
+    } else {
+        CHECK(esp_wifi_stop());
+        internal::setMode(Mode::OFF);
+    }
+
+    ::connected = false;
+    esp_netif_destroy(interface);
+}
+
+bool sta::connect(string ssid, string password, bool async, int maxAttempts) {
+    ESP_LOGI(TAG, "%s(%s, <omitted>, %d, %d)", __func__, ssid.c_str(), async, maxAttempts);
+
+    if (internal::mode != Mode::STA && internal::mode != Mode::DUAL) throw wifi::exception::InvalidMode();
+
+    retryNum = 0;
+    retryMax = maxAttempts;
+
+    event.clear();
+
+    ::ssid     = std::move(ssid);
+    ::password = std::move(password);
+
+    std::copy(::ssid.begin(), ::ssid.end() + 1, std::begin(staConfig.ssid));
+    std::copy(::password.begin(), ::password.end() + 1, std::begin(staConfig.password));
+
+    wifi_config_t config = {.sta = staConfig};
+    CHECK(esp_wifi_set_config(WIFI_IF_STA, &config));
+    CHECK(esp_wifi_connect());
+
+    if (!async) {
+        // TODO set timeout for the case when we don't get an IP address
+        event.waitForBit(CONNECT_FINISHED);
+    }
+
+    return true;
+}
+
+void sta::disconnect() {
+    ESP_LOGI(TAG, "%s()", __func__);
+
+    retryMax    = 0;
+    ::connected = false;
+    CHECK(esp_wifi_disconnect());
+}
+
+void sta::startScan(void *data) {
+    ESP_LOGI(TAG, "%s()", __func__);
+
+    if (!onScanDone) { ESP_LOGW(TAG, "%s: onScanDone not set", __func__); }
+
+    CHECK(esp_event_handler_instance_register(WIFI_EVENT, WIFI_EVENT_SCAN_DONE, &handleScanDone, data,
+                                              &scanDoneHandler));
+
+    CHECK(esp_wifi_scan_start(nullptr, false));
+}
+
+namespace {
+    void registerEventHandlers() {
+        ESP_LOGI(TAG, "%s()", __func__);
+
+        CHECK(esp_event_handler_instance_register(
+                WIFI_EVENT, WIFI_EVENT_STA_CONNECTED, &handleConnect, nullptr, &connectHandler));
+        CHECK(esp_event_handler_instance_register(
+                WIFI_EVENT, WIFI_EVENT_STA_DISCONNECTED, &handleDisconnect, nullptr, &disconnectHandler));
+        CHECK(esp_event_handler_instance_register(
+                IP_EVENT, IP_EVENT_STA_GOT_IP, &handleIp, nullptr, &ipHandler));
+    }
+
+    void unregisterEventHandlers() {
+        ESP_LOGI(TAG, "%s()", __func__);
+
+        CHECK(esp_event_handler_instance_unregister(WIFI_EVENT, WIFI_EVENT_STA_CONNECTED, &connectHandler));
+        CHECK(esp_event_handler_instance_unregister(WIFI_EVENT, WIFI_EVENT_STA_DISCONNECTED, &disconnectHandler));
+        CHECK(esp_event_handler_instance_unregister(IP_EVENT, IP_EVENT_STA_GOT_IP, &ipHandler));
+
+        // TODO these are supposed to be deprecated and should not be necessary
+        // however, handleDisconnect will be called on wifi stop unless unregistered; IDF bug?
+        CHECK(esp_event_handler_unregister(WIFI_EVENT, WIFI_EVENT_STA_CONNECTED, &handleConnect));
+        CHECK(esp_event_handler_unregister(WIFI_EVENT, WIFI_EVENT_STA_DISCONNECTED, &handleDisconnect));
+        CHECK(esp_event_handler_unregister(IP_EVENT, IP_EVENT_STA_GOT_IP, &handleIp));
+    }
+
+    void handleConnect(void *, esp_event_base_t, int32_t, void *) {
+        ESP_LOGI(TAG, "%s()", __func__);
+
+        ::connected = true;
+        if (sta::onConnect) sta::onConnect();
+    }
+
+    void handleDisconnect(void *, esp_event_base_t, int32_t, void *) {
+        ESP_LOGI(TAG, "%s()", __func__);
+
+        if (retryNum++ < retryMax) {
+            ESP_LOGI(TAG, "reconnecting, attempt %d / %d", retryNum, retryMax);
+            CHECK(esp_wifi_connect());
+        } else {
+            ESP_LOGI(TAG, "disconnected");
+            ::connected = false;
+            if (sta::onDisconnect) sta::onDisconnect();
+            event.setBit(CONNECT_FINISHED);
+        }
+    }
+
+    void handleIp(void *, esp_event_base_t, int32_t, void *data) {
+        ESP_LOGI(TAG, "%s()", __func__);
+
+        auto eventData = static_cast<ip_event_got_ip_t *>(data);
+        ::ip = net::IP(eventData->ip_info.ip);
+
+        if (sta::onIp) sta::onIp();
+        retryNum = 0;
+
+        event.setBit(CONNECT_FINISHED);
+    }
+
+    void handleScanDone(void *data, esp_event_base_t, int32_t, void *) {
+        ESP_LOGI(TAG, "%s()", __func__);
+
+        CHECK(esp_event_handler_instance_unregister(WIFI_EVENT, WIFI_EVENT_SCAN_DONE, &scanDoneHandler));
+        CHECK(esp_event_handler_unregister(WIFI_EVENT, WIFI_EVENT_SCAN_DONE, &::handleScanDone));
+
+        if (!sta::onScanDone) {
+            ESP_LOGW(TAG, "%s: onScanDone not set", __func__);
+            return;
+        }
+
+        uint16_t size;
+        esp_wifi_scan_get_ap_num(&size);
+        wifi_ap_record_t apRecords[size];
+        esp_wifi_scan_get_ap_records(&size, apRecords);
+
+        vector<APInfo> result;
+
+        for (int i = 0; i < size; i++) {
+            APInfo apInfo = {reinterpret_cast<char *>(apRecords[i].ssid), apRecords[i].rssi};
+            result.push_back(apInfo);
+        }
+
+        sta::onScanDone(result, data);
+    }
+}

src/wifi/wifi.cpp

@@ -10,16 +10,23 @@
 #include "kbf/nvs.h"
 #include "kbf/macros.h"
 
-
 using namespace kbf;
 using namespace kbf::wifi;
+using std::string;
 
 bool internal::initialized = false;
 
 Mode internal::mode = Mode::OFF;
 
+static constexpr const char *const TAG = "kbf::wifi";
+
 void internal::init() {
-    if (initialized) return;
+    ESP_LOGI(TAG, "internal::%s()", __func__);
+
+    if (initialized) {
+        ESP_LOGI(TAG, "already initialized");
+        return;
+    }
 
     CHECK(esp_netif_init());
     CHECK(esp_event_loop_create_default());
@@ -35,3 +42,29 @@ void internal::init() {
 
     initialized = true;
 }
+
+void internal::setMode(Mode m) {
+    ESP_LOGI(TAG, "internal::%s(%d)", __func__, (int) m);
+    internal::mode = m;
+}
+
+Mode wifi::mode() { return internal::mode; }
+
+void dual::start(string ssid, std::string password, net::IP ip, net::IP netmask) {
+    ESP_LOGI(TAG, "%s()", __func__);
+
+    sta::start();
+    ap::start(std::move(ssid), std::move(password), ip, netmask);
+}
+
+void wifi::stop() {
+    ESP_LOGI(TAG, "%s()", __func__);
+
+    // TODO stop all at once
+    if (internal::mode == Mode::STA || internal::mode == Mode::DUAL) {
+        sta::stop();
+    }
+    if (internal::mode == Mode::AP) {
+        ap::stop();
+    }
+}

src/wifi_legacy/ap.cpp

@@ -4,7 +4,7 @@
 
 using namespace kbf;
 
-wifi::AP::AP(string ssid, string password, net::IP ip, net::IP netmask) :
+wifi_legacy::AP::AP(string ssid, string password, net::IP ip, net::IP netmask) :
         ssid(std::move(ssid)), password(std::move(password)), ip(ip), netmask(netmask) {
     ESP_LOGI(TAG, "AP()");
 
@@ -16,13 +16,13 @@ wifi::AP::AP(string ssid, string password, net::IP ip, net::IP netmask) :
     config.authmode       = WIFI_AUTH_WPA2_PSK; // TODO use AUTH_OPEN if no password is provided
 }
 
-wifi::AP::~AP() {
+wifi_legacy::AP::~AP() {
     ESP_LOGI(TAG, "~AP()");
     unregisterEventHandlers();
 }
 
-shared_ptr<wifi::AP>
-wifi::AP::create(const string &ssid, const string &password, const net::IP &ip, const net::IP &netmask) {
+shared_ptr<wifi_legacy::AP>
+wifi_legacy::AP::create(const string &ssid, const string &password, const net::IP &ip, const net::IP &netmask) {
     if (password.length() < 8) {
         ABORT("WiFi password needs to be at least 8 characters long.");
     }
@@ -31,14 +31,14 @@ wifi::AP::create(const string &ssid, const string &password, const net::IP &ip,
     return shared_ptr<AP>(ap);
 }
 
-void wifi::AP::init() {
+void wifi_legacy::AP::init() {
     netif = esp_netif_create_default_wifi_ap();
 
     setupDhcp();
     registerEventHandlers();
 }
 
-void wifi::AP::setupDhcp() {
+void wifi_legacy::AP::setupDhcp() {
     ESP_LOGD(TAG, "setupDhcp()");
 
     // TODO this should only be run once, before bringing up the interface for the first time; if the interface is already up, DHCP seems to fail silently
@@ -52,7 +52,7 @@ void wifi::AP::setupDhcp() {
     CHECK(esp_netif_dhcps_start(netif));
 }
 
-void wifi::AP::registerEventHandlers() {
+void wifi_legacy::AP::registerEventHandlers() {
     ESP_LOGD(TAG, "registerEventHandlers()");
     CHECK(esp_event_handler_instance_register(
             WIFI_EVENT, WIFI_EVENT_AP_START, &handleStart, this, &startHandler
@@ -68,7 +68,7 @@ void wifi::AP::registerEventHandlers() {
     ));
 }
 
-void wifi::AP::unregisterEventHandlers() {
+void wifi_legacy::AP::unregisterEventHandlers() {
     ESP_LOGD(TAG, "unregisterEventHandlers()");
 
     CHECK(esp_event_handler_instance_unregister(WIFI_EVENT, WIFI_EVENT_AP_START, &startHandler));
@@ -83,19 +83,19 @@ void wifi::AP::unregisterEventHandlers() {
     CHECK(esp_event_handler_unregister(WIFI_EVENT, WIFI_EVENT_AP_STADISCONNECTED, &handleDisconnect));
 }
 
-void wifi::AP::handleStart(void *arg, esp_event_base_t, int32_t, void *) {
+void wifi_legacy::AP::handleStart(void *arg, esp_event_base_t, int32_t, void *) {
     ESP_LOGD(TAG, "handleStart()");
     auto ap = static_cast<AP *>(arg);
     if (ap->onStart) ap->onStart();
 }
 
-void wifi::AP::handleStop(void *arg, esp_event_base_t, int32_t, void *) {
+void wifi_legacy::AP::handleStop(void *arg, esp_event_base_t, int32_t, void *) {
     ESP_LOGD(TAG, "handleStop()");
     auto ap = static_cast<AP *>(arg);
     if (ap->onStop) ap->onStop();
 }
 
-void wifi::AP::handleConnect(void *arg, esp_event_base_t, int32_t, void *eventData) {
+void wifi_legacy::AP::handleConnect(void *arg, esp_event_base_t, int32_t, void *eventData) {
     ESP_LOGD(TAG, "handleConnect()");
     auto ap  = static_cast<AP *>(arg);
     auto sta = STA(*static_cast<wifi_event_ap_staconnected_t *>(eventData));
@@ -109,7 +109,7 @@ void wifi::AP::handleConnect(void *arg, esp_event_base_t, int32_t, void *eventDa
     ap->stations.insert(std::pair<int, STA>(sta.aid, sta));
 }
 
-void wifi::AP::handleDisconnect(void *arg, esp_event_base_t, int32_t, void *eventData) {
+void wifi_legacy::AP::handleDisconnect(void *arg, esp_event_base_t, int32_t, void *eventData) {
     ESP_LOGD(TAG, "handleDisconnect()");
     auto ap  = static_cast<AP *>(arg);
     auto aid = (static_cast<wifi_event_ap_stadisconnected_t *>(eventData))->aid;
@@ -118,4 +118,4 @@ void wifi::AP::handleDisconnect(void *arg, esp_event_base_t, int32_t, void *even
     ap->stations.erase(aid);
 }
 
-wifi::AP::STA::STA(wifi_event_ap_staconnected_t &eventData) : aid(eventData.aid), mac(eventData.mac) {}
+wifi_legacy::AP::STA::STA(wifi_event_ap_staconnected_t &eventData) : aid(eventData.aid), mac(eventData.mac) {}

src/wifi_legacy/driver.cpp

@@ -17,7 +17,7 @@
 
 using std::shared_ptr;
 
-using namespace kbf::wifi;
+using namespace kbf::wifi_legacy;
 
 static shared_ptr<AP>  s_ap  = nullptr;
 static shared_ptr<STA> s_sta = nullptr;
@@ -43,7 +43,7 @@ static void init() {
     initialized = true;
 }
 
-void kbf::wifi::start(shared_ptr<AP> ap) {
+void kbf::wifi_legacy::start(shared_ptr<AP> ap) {
     ESP_LOGI(TAG, "starting AP mode");
 
     init();
@@ -57,7 +57,7 @@ void kbf::wifi::start(shared_ptr<AP> ap) {
     CHECK(esp_wifi_start());
 }
 
-void kbf::wifi::start(shared_ptr<STA> sta) {
+void kbf::wifi_legacy::start(shared_ptr<STA> sta) {
     ESP_LOGI(TAG, "starting STA mode");
 
     init();
@@ -75,7 +75,7 @@ void kbf::wifi::start(shared_ptr<STA> sta) {
     CHECK(esp_wifi_start());
 }
 
-void kbf::wifi::start(shared_ptr<AP> ap, shared_ptr<STA> sta) {
+void kbf::wifi_legacy::start(shared_ptr<AP> ap, shared_ptr<STA> sta) {
     ESP_LOGI(TAG, "starting dual mode");
 
     init();
@@ -94,7 +94,7 @@ void kbf::wifi::start(shared_ptr<AP> ap, shared_ptr<STA> sta) {
     CHECK(esp_wifi_start());
 }
 
-void kbf::wifi::stop() {
+void kbf::wifi_legacy::stop() {
     auto err = esp_wifi_stop();
     if (err == ESP_ERR_WIFI_NOT_INIT) {
         ESP_LOGW(TAG, "stop(): wifi not initialized");
@@ -113,7 +113,7 @@ void kbf::wifi::stop() {
     }
 }
 
-void kbf::wifi::stopAP() {
+void kbf::wifi_legacy::stopAP() {
     if (s_ap) {
         esp_netif_destroy(s_ap->netif);
         s_ap = nullptr;
@@ -126,14 +126,14 @@ void kbf::wifi::stopAP() {
     }
 }
 
-shared_ptr<kbf::wifi::AP> kbf::wifi::getAP() {
+shared_ptr<kbf::wifi_legacy::AP> kbf::wifi_legacy::getAP() {
     return s_ap;
 }
 
-shared_ptr<kbf::wifi::STA> kbf::wifi::getSTA() {
+shared_ptr<kbf::wifi_legacy::STA> kbf::wifi_legacy::getSTA() {
     return s_sta;
 }
 
-bool kbf::wifi::isRunning() {
+bool kbf::wifi_legacy::isRunning() {
     return s_sta != nullptr || s_ap != nullptr;
 }

src/wifi_legacy/sta.cpp

@@ -5,27 +5,27 @@
 
 using namespace kbf;
 
-wifi::STA::STA() {
+wifi_legacy::STA::STA() {
     ESP_LOGI(TAG, "STA()");
     config.pmf_cfg = {true, false};
 }
 
-wifi::STA::~STA() {
+wifi_legacy::STA::~STA() {
     ESP_LOGI(TAG, "~STA()");
     unregisterEventHandlers();
 }
 
-shared_ptr<wifi::STA> wifi::STA::create() {
+shared_ptr<wifi_legacy::STA> wifi_legacy::STA::create() {
     return shared_ptr<STA>(new STA());
 }
 
-void wifi::STA::init() {
+void wifi_legacy::STA::init() {
     netif = esp_netif_create_default_wifi_sta();
     registerEventHandlers();
 }
 
 
-void wifi::STA::registerEventHandlers() {
+void wifi_legacy::STA::registerEventHandlers() {
     ESP_LOGD(TAG, "registerEventHandlers");
 
     CHECK(esp_event_handler_instance_register(
@@ -41,7 +41,7 @@ void wifi::STA::registerEventHandlers() {
             IP_EVENT, IP_EVENT_STA_GOT_IP, &handleGotIp, this, &gotIpHandler));
 }
 
-void wifi::STA::unregisterEventHandlers() {
+void wifi_legacy::STA::unregisterEventHandlers() {
     ESP_LOGD(TAG, "unregisterEventHandlers");
 
     CHECK(esp_event_handler_instance_unregister(WIFI_EVENT, WIFI_EVENT_STA_START, &startHandler));
@@ -59,7 +59,7 @@ void wifi::STA::unregisterEventHandlers() {
     CHECK(esp_event_handler_unregister(IP_EVENT, IP_EVENT_STA_GOT_IP, &handleGotIp));
 }
 
-void wifi::STA::connect(const string &ssid, const string &password, int maxRetryAttempts) {
+void wifi_legacy::STA::connect(const string &ssid, const string &password, int maxRetryAttempts) {
     ESP_LOGI(TAG, "connect()");
 
     wifi_config_t wifiConfig = {.sta = config};
@@ -76,31 +76,31 @@ void wifi::STA::connect(const string &ssid, const string &password, int maxRetry
     CHECK(esp_wifi_connect());
 }
 
-void wifi::STA::disconnect() {
+void wifi_legacy::STA::disconnect() {
     ESP_LOGI(TAG, "disconnect()");
     retryMax = 0;
     CHECK(esp_wifi_disconnect());
 }
 
-void wifi::STA::handleStart(void *, esp_event_base_t, int32_t, void *) {
+void wifi_legacy::STA::handleStart(void *, esp_event_base_t, int32_t, void *) {
     ESP_LOGD(TAG, "handleStart()");
     auto instance = getSTA();
     if (instance->onStart) instance->onStart();
 }
 
-void wifi::STA::handleStop(void *, esp_event_base_t, int32_t, void *) {
+void wifi_legacy::STA::handleStop(void *, esp_event_base_t, int32_t, void *) {
     ESP_LOGD(TAG, "handleStop()");
     auto instance = getSTA();
     if (instance->onStop) instance->onStop();
 }
 
-void wifi::STA::handleConnect(void *, esp_event_base_t, int32_t, void *) {
+void wifi_legacy::STA::handleConnect(void *, esp_event_base_t, int32_t, void *) {
     ESP_LOGD(TAG, "handleConnect()");
     auto instance = getSTA();
     if (instance->onConnect) instance->onConnect();
 }
 
-void wifi::STA::handleDisconnect(void *, esp_event_base_t, int32_t, void *) {
+void wifi_legacy::STA::handleDisconnect(void *, esp_event_base_t, int32_t, void *) {
     ESP_LOGD(TAG, "handleDisconnect()");
     auto instance = getSTA();
 
@@ -118,7 +118,7 @@ void wifi::STA::handleDisconnect(void *, esp_event_base_t, int32_t, void *) {
     }
 }
 
-void wifi::STA::handleScanDone(void *data, esp_event_base_t, int32_t, void *) {
+void wifi_legacy::STA::handleScanDone(void *data, esp_event_base_t, int32_t, void *) {
     ESP_LOGD(TAG, "handleScanDone()");
     auto instance = getSTA();
 
@@ -145,7 +145,7 @@ void wifi::STA::handleScanDone(void *data, esp_event_base_t, int32_t, void *) {
     instance->onScanDone(result, data);
 }
 
-void wifi::STA::handleGotIp(void *, esp_event_base_t, int32_t, void *pEventData) {
+void wifi_legacy::STA::handleGotIp(void *, esp_event_base_t, int32_t, void *pEventData) {
     ESP_LOGD(TAG, "handleGotIp()");
     auto instance  = getSTA();
     auto eventData = static_cast<ip_event_got_ip_t *>(pEventData);
@@ -155,7 +155,7 @@ void wifi::STA::handleGotIp(void *, esp_event_base_t, int32_t, void *pEventData)
     instance->retryNum = 0;
 }
 
-void wifi::STA::startScan(void *data) {
+void wifi_legacy::STA::startScan(void *data) {
     ESP_LOGD(TAG, "startScan()");
 
     if (!onScanDone) { ESP_LOGW(TAG, "startScan: onScanDone not set"); }

test/test_http.cpp

@@ -22,7 +22,7 @@ std::atomic<bool> asyncFinished = {false};
 std::atomic<int> state;
 
 TEST_CASE("HTTP GET, POST, 404, 405", "[kbf_http]") {
-    wifi::start();
+    wifi_legacy::start();
     auto server = http::Server();
     TEST_ASSERT_FALSE(server.isRunning())
 
@@ -82,11 +82,11 @@ TEST_CASE("HTTP GET, POST, 404, 405", "[kbf_http]") {
     TEST_ASSERT_EQUAL_STRING("bar", response->body.c_str());
 
     server.stop();
-    wifi::stop();
+    wifi_legacy::stop();
 }
 
 TEST_CASE("HTTP custom headers", "[kbf_http]") {
-    wifi::start();
+    wifi_legacy::start();
     auto server = http::Server();
 
     http::Response (*handleContentTypeTest)(const http::Request &, void *) = {[](const http::Request &request, void *) {
@@ -123,11 +123,11 @@ TEST_CASE("HTTP custom headers", "[kbf_http]") {
     TEST_ASSERT_EQUAL_STRING("OK", response->body.data());
 
     server.stop();
-    wifi::stop();
+    wifi_legacy::stop();
 }
 
 TEST_CASE("HTTP JSON request / response", "[kbf_http]") {
-    wifi::start();
+    wifi_legacy::start();
 
     static const string testKey   = "key";
     static const string testValue = "value";
@@ -162,11 +162,11 @@ TEST_CASE("HTTP JSON request / response", "[kbf_http]") {
 //    TEST_ASSERT_NULL(response->json());
 
     server.stop();
-    wifi::stop();
+    wifi_legacy::stop();
 }
 
 TEST_CASE("HTTP timeout", "[kbf_http]") {
-    wifi::start();
+    wifi_legacy::start();
 
     auto server = http::Server();
     http::Response (*handler)(const http::Request &, void *) = {[](const http::Request &request, void *) {
@@ -193,11 +193,11 @@ TEST_CASE("HTTP timeout", "[kbf_http]") {
     TEST_ASSERT_TRUE(caught);
     TEST_ASSERT_EQUAL(2, state);
 
-    wifi::stop();
+    wifi_legacy::stop();
 }
 
 TEST_CASE("HTTP onResponseSent", "[kbf_http]") {
-    wifi::start();
+    wifi_legacy::start();
     auto server = http::Server();
     state = 0;
 
@@ -220,11 +220,11 @@ TEST_CASE("HTTP onResponseSent", "[kbf_http]") {
     TEST_ASSERT_EQUAL(2, state);
 
     server.stop();
-    wifi::stop();
+    wifi_legacy::stop();
 }
 
 TEST_CASE("HTTP Client errors", "[kbf_http]") {
-    wifi::start();
+    wifi_legacy::start();
 
     auto server = http::Server();
     http::Response (*testGet)(const http::Request &, void *) = {[](const http::Request &request, void *) {
@@ -255,7 +255,7 @@ TEST_CASE("HTTP Client errors", "[kbf_http]") {
     }
     TEST_ASSERT_TRUE(caught);
 
-    wifi::stop();
+    wifi_legacy::stop();
 }
 
 TEST_CASE("HTTP CORS", "[notimplemented]") {

test/test_https.cpp

@@ -13,7 +13,7 @@ using namespace std;
 using nlohmann::json;
 
 TEST_CASE("HTTPS GET", "[kbf_http]") {
-    wifi::start();
+    wifi_legacy::start();
     auto server = http::Server();
     TEST_ASSERT_FALSE(server.isRunning())
 
@@ -31,13 +31,13 @@ TEST_CASE("HTTPS GET", "[kbf_http]") {
     TEST_ASSERT_EQUAL_STRING("OK", response->body.c_str());
 
     server.stop();
-    wifi::stop();
+    wifi_legacy::stop();
 }
 
 // TODO KBF-22 fix async test
 static rtos::EventGroup eventGroup;
 TEST_CASE("HTTPS async", "[broken]") {
-    wifi::start();
+    wifi_legacy::start();
 
     http::Response (*handleRequest)(const http::Request &, void *) = {[](const http::Request &request, void *) {
         auto response = http::Response("OK");
@@ -61,5 +61,5 @@ TEST_CASE("HTTPS async", "[broken]") {
     TEST_ASSERT_EQUAL(1, eventGroup.getBit(0));
 
     server.stop();
-    wifi::stop();
+    wifi_legacy::stop();
 }

test/test_net.cpp

@@ -81,7 +81,7 @@ static shared_ptr<kbf::UART> setupUart() {
 }
 
 void mdnsMaster() {
-    wifi::start(wifi::AP::create(KBF_TEST_MDNS_SSID, KBF_TEST_MDNS_PASS));
+    wifi_legacy::start(wifi_legacy::AP::create(KBF_TEST_MDNS_SSID, KBF_TEST_MDNS_PASS));
     auto mdns = new net::MDNS();
     mdns->setHostname(KBF_TEST_MDNS_MASTER);
 
@@ -92,12 +92,12 @@ void mdnsMaster() {
     TEST_ASSERT_EQUAL_STRING("192.168.4.2", ip->str().c_str());
 
     delete mdns;
-    wifi::stop();
+    wifi_legacy::stop();
 }
 
 void mdnsSlave() {
-    wifi::start();
-    auto sta = wifi::getSTA();
+    wifi_legacy::start();
+    auto sta = wifi_legacy::getSTA();
     eventGroup.clear();
 
     sta->onIp = {[]() {
@@ -120,15 +120,15 @@ void mdnsSlave() {
     sta->connect(KBF_TEST_MDNS_SSID, KBF_TEST_MDNS_PASS);
 
     eventGroup.waitForBit(0);
-    wifi::stop();
+    wifi_legacy::stop();
 }
 
 TEST_CASE_MULTIPLE_DEVICES("mDNS", "[kbf_net]", mdnsMaster, mdnsSlave)
 
 void mdnsServiceMaster() {
     eventGroup.clear();
-    wifi::start(wifi::AP::create(KBF_TEST_MDNS_SSID, KBF_TEST_MDNS_PASS));
-    wifi::getAP()->onDisconnect = {[](wifi::AP::STA &) {
+    wifi_legacy::start(wifi_legacy::AP::create(KBF_TEST_MDNS_SSID, KBF_TEST_MDNS_PASS));
+    wifi_legacy::getAP()->onDisconnect = {[](wifi_legacy::AP::STA &) {
         eventGroup.setBit(0);
     }};
 
@@ -140,17 +140,17 @@ void mdnsServiceMaster() {
 
     TEST_ASSERT_TRUE(eventGroup.waitForBit(0, 20000));
     delete mdns;
-    wifi::stop();
+    wifi_legacy::stop();
 }
 
 void mdnsServiceSlave() {
     eventGroup.clear();
-    wifi::start();
-    wifi::getSTA()->connect(KBF_TEST_MDNS_SSID, KBF_TEST_MDNS_PASS);
-    wifi::getSTA()->onIp         = {[]() {
+    wifi_legacy::start();
+    wifi_legacy::getSTA()->connect(KBF_TEST_MDNS_SSID, KBF_TEST_MDNS_PASS);
+    wifi_legacy::getSTA()->onIp         = {[]() {
         eventGroup.setBit(0);
     }};
-    wifi::getSTA()->onDisconnect = {[]() {
+    wifi_legacy::getSTA()->onDisconnect = {[]() {
         TEST_ASSERT_EQUAL_STRING("", "connection error");
     }};
 
@@ -194,7 +194,7 @@ void mdnsServiceSlave() {
     TEST_ASSERT_EQUAL_STRING(KBF_TEST_SERVICE3_INST, results[0].instanceName.c_str());
 
     delete mdns;
-    wifi::stop();
+    wifi_legacy::stop();
 }
 
 TEST_CASE_MULTIPLE_DEVICES("mDNS", "[kbf_net]", mdnsServiceMaster, mdnsServiceSlave)

test/test_web_service.cpp

@@ -37,7 +37,7 @@ public:
 };
 
 TEST_CASE("WebService", "[kbf_web_service]") {
-    wifi::start();
+    wifi_legacy::start();
 
     auto webService = WebService();
     webService.controller<CounterController>();
@@ -66,7 +66,7 @@ TEST_CASE("WebService", "[kbf_web_service]") {
     TEST_ASSERT_EQUAL_STRING("bar", response->body.c_str());
 
     webService.stop();
-    wifi::stop();
+    wifi_legacy::stop();
 }
 
 class HeaderToParamMiddleware : public WebService::Middleware {
@@ -117,7 +117,7 @@ public:
 };
 
 TEST_CASE("WebService Middleware", "[kbf_web_service]") {
-    wifi::start();
+    wifi_legacy::start();
 
     auto webService = WebService();
     webService.controller<EchoController>();
@@ -136,5 +136,5 @@ TEST_CASE("WebService Middleware", "[kbf_web_service]") {
     TEST_ASSERT_EQUAL_STRING("oof", response->headers.at("X-Response").c_str());
 
     webService.stop();
-    wifi::stop();
+    wifi_legacy::stop();
 }

test/wifi/test_wifi.cpp

@@ -44,12 +44,18 @@ static void singleSlave() {
     event.clear();
 
     wifi::sta::onConnect    = {[]() { TEST_ASSERT_EQUAL(0, state++); }};
-    wifi::sta::onIp         = {[]() { TEST_ASSERT_EQUAL(1, state++); }};
-    wifi::sta::onDisconnect = {[]() { event.setBit(0); }};
+    wifi::sta::onIp         = {[]() {
+        TEST_ASSERT_EQUAL(1, state++);
+        event.setBit(0);
+    }};
+    wifi::sta::onDisconnect = {[]() { TEST_FAIL(); }};
     wifi::sta::start();
 
     wifi::sta::connect(TEST_SSID, WIFI_PASS);
     TEST_ASSERT_EQUAL(2, state);
+    TEST_ASSERT_TRUE(wifi::sta::connected());
+    TEST_ASSERT_EQUAL_STRING(TEST_SSID, wifi::sta::ssid().c_str());
+    TEST_ASSERT_EQUAL_STRING(WIFI_PASS, wifi::sta::password().c_str());
 
     event.waitForBit(0);
     TEST_ASSERT_EQUAL(2, state);
@@ -81,8 +87,11 @@ static void asyncSlave() {
     event.clear();
 
     wifi::sta::onConnect    = {[]() { TEST_ASSERT_EQUAL(0, state++); }};
-    wifi::sta::onIp         = {[]() { TEST_ASSERT_EQUAL(1, state++); }};
-    wifi::sta::onDisconnect = {[]() { event.setBit(0); }};
+    wifi::sta::onIp         = {[]() {
+        TEST_ASSERT_EQUAL(1, state++);
+        event.setBit(0);
+    }};
+    wifi::sta::onDisconnect = {[]() { TEST_FAIL(); }};
     wifi::sta::start();
 
     wifi::sta::connect(TEST_SSID, WIFI_PASS, true);
@@ -101,7 +110,7 @@ static void dualMaster() {
 
     wifi::ap::onConnect     = {[](wifi::STA &) {
         TEST_ASSERT_EQUAL(0, state++);
-        wifi::sta::connect(SLAVE_SSID, WIFI_PASS);
+        wifi::sta::connect(SLAVE_SSID, WIFI_PASS, true);
     }};
     wifi::sta::onConnect    = {[]() {
         TEST_ASSERT_EQUAL(1, state++);

test/wifi/test_wifi_legacy.cpp

@@ -44,7 +44,7 @@ TEST_CASE("WiFi legacy STA mode reconnect", "[kbf_wifi_legacy]") {
     using namespace kbf;
 
     state = 0;
-    auto sta = wifi::STA::create();
+    auto sta = wifi_legacy::STA::create();
     sta->onStart        = {[]() { TEST_ASSERT_EQUAL(0, state++); }};
     sta->onConnect      = fail;
     sta->onIp           = fail;
@@ -54,7 +54,7 @@ TEST_CASE("WiFi legacy STA mode reconnect", "[kbf_wifi_legacy]") {
         return true;
     }};
     sta->onDisconnect   = {[]() { TEST_ASSERT_EQUAL(3, state++); }};
-    wifi::start(sta);
+    wifi_legacy::start(sta);
 
     waitForState(1, 1);
     TEST_ASSERT_EQUAL(1, state);
@@ -65,14 +65,14 @@ TEST_CASE("WiFi legacy STA mode reconnect", "[kbf_wifi_legacy]") {
     kbf::sleep(5000);
     TEST_ASSERT_EQUAL(4, state);
 
-    wifi::stop();
+    wifi_legacy::stop();
 }
 
 TEST_CASE("WiFi legacy STA mode reconnect cancel", "[kbf_wifi_legacy]") {
     using namespace kbf;
 
-    wifi::start(wifi::STA::create());
-    auto sta = wifi::getSTA();
+    wifi_legacy::start(wifi_legacy::STA::create());
+    auto sta = wifi_legacy::getSTA();
 
     state = 0;
     sta->onStart        = {[]() { TEST_ASSERT_EQUAL(0, state++); }};
@@ -95,25 +95,25 @@ TEST_CASE("WiFi legacy STA mode reconnect cancel", "[kbf_wifi_legacy]") {
     kbf::sleep(5000);
     TEST_ASSERT_EQUAL(3, state);
 
-    wifi::stop();
+    wifi_legacy::stop();
 }
 
 void wifiSingleMaster() {
     using namespace kbf;
 
-    wifi::start(wifi::AP::create(KBF_TEST_WIFI_SSID, KBF_TEST_WIFI_PASS));
-    auto ap = wifi::getAP();
+    wifi_legacy::start(wifi_legacy::AP::create(KBF_TEST_WIFI_SSID, KBF_TEST_WIFI_PASS));
+    auto ap = wifi_legacy::getAP();
     TEST_ASSERT_EQUAL_STRING(KBF_TEST_WIFI_SSID, ap->ssid.c_str());
     TEST_ASSERT_EQUAL_STRING(KBF_TEST_WIFI_PASS, ap->password.c_str());
 
     state = 0;
     ap->onStart      = {[]() { TEST_ASSERT_EQUAL(0, state++); }};
-    ap->onConnect    = {[](wifi::AP::STA &) { TEST_ASSERT_EQUAL(1, state++); }};
-    ap->onDisconnect = {[](wifi::AP::STA &) { TEST_ASSERT_EQUAL(2, state++); }};
+    ap->onConnect    = {[](wifi_legacy::AP::STA &) { TEST_ASSERT_EQUAL(1, state++); }};
+    ap->onDisconnect = {[](wifi_legacy::AP::STA &) { TEST_ASSERT_EQUAL(2, state++); }};
     ap->onStop       = {[]() { TEST_ASSERT_EQUAL(3, state++); }};
 
     waitForState(3, 30);
-    wifi::stop();
+    wifi_legacy::stop();
 
     waitForState(4, 1);
     TEST_ASSERT_EQUAL(4, state);
@@ -122,8 +122,8 @@ void wifiSingleMaster() {
 void wifiSingleSlave() {
     using namespace kbf;
 
-    wifi::start(wifi::STA::create());
-    auto sta = wifi::getSTA();
+    wifi_legacy::start(wifi_legacy::STA::create());
+    auto sta = wifi_legacy::getSTA();
 
     state = 0;
     sta->onStart      = {[]() { TEST_ASSERT_EQUAL(0, state++); }};
@@ -144,7 +144,7 @@ void wifiSingleSlave() {
 
     waitForState(4, 1);
     TEST_ASSERT_EQUAL(4, state);
-    wifi::stop();
+    wifi_legacy::stop();
 
     waitForState(5, 1);
     TEST_ASSERT_EQUAL(5, state);
@@ -155,80 +155,80 @@ TEST_CASE_MULTIPLE_DEVICES("WiFi legacy AP <--> STA", "[kbf_wifi_legacy]", wifiS
 void wifiDualMaster() {
     using namespace kbf;
 
-    auto ap  = wifi::AP::create(KBF_TEST_WIFI_DUAL_MASTER_SSID, KBF_TEST_WIFI_PASS);
-    auto sta = wifi::STA::create();
+    auto ap  = wifi_legacy::AP::create(KBF_TEST_WIFI_DUAL_MASTER_SSID, KBF_TEST_WIFI_PASS);
+    auto sta = wifi_legacy::STA::create();
 
     state = 0;
     ap->onStart       = {[]() {
         TEST_ASSERT_EQUAL(0, state++);
     }};
-    ap->onConnect     = {[](wifi::AP::STA &) {
+    ap->onConnect     = {[](wifi_legacy::AP::STA &) {
         TEST_ASSERT_EQUAL(1, state++);
-        auto sta = wifi::getSTA();
+        auto sta = wifi_legacy::getSTA();
         sta->connect(KBF_TEST_WIFI_DUAL_SLAVE_SSID, KBF_TEST_WIFI_PASS);
     }};
     sta->onConnect    = {[]() {
         TEST_ASSERT_EQUAL(2, state++);
-        auto sta = wifi::getSTA();
+        auto sta = wifi_legacy::getSTA();
         sta->disconnect();
     }};
     sta->onDisconnect = {[]() {
         TEST_ASSERT_EQUAL(3, state++);
     }};
-    ap->onDisconnect  = {[](wifi::AP::STA &) {
+    ap->onDisconnect  = {[](wifi_legacy::AP::STA &) {
         TEST_ASSERT_EQUAL(4, state++);
     }};
 
-    wifi::start(ap, sta);
+    wifi_legacy::start(ap, sta);
     waitForState(5, 30);
-    wifi::stop();
+    wifi_legacy::stop();
 }
 
 void wifiDualSlave() {
     using namespace kbf;
 
-    auto ap  = wifi::AP::create(KBF_TEST_WIFI_DUAL_SLAVE_SSID, KBF_TEST_WIFI_PASS);
-    auto sta = wifi::STA::create();
+    auto ap  = wifi_legacy::AP::create(KBF_TEST_WIFI_DUAL_SLAVE_SSID, KBF_TEST_WIFI_PASS);
+    auto sta = wifi_legacy::STA::create();
 
     state = 0;
     ap->onStart       = {[]() {
         TEST_ASSERT_EQUAL(0, state++);
-        auto sta = wifi::getSTA();
+        auto sta = wifi_legacy::getSTA();
         sta->connect(KBF_TEST_WIFI_DUAL_MASTER_SSID, KBF_TEST_WIFI_PASS);
     }};
     sta->onConnect    = {[]() {
         TEST_ASSERT_EQUAL(1, state++);
     }};
-    ap->onConnect     = {[](wifi::AP::STA &) {
+    ap->onConnect     = {[](wifi_legacy::AP::STA &) {
         TEST_ASSERT_EQUAL(2, state++);
     }};
-    ap->onDisconnect  = {[](wifi::AP::STA &) {
+    ap->onDisconnect  = {[](wifi_legacy::AP::STA &) {
         TEST_ASSERT_EQUAL(3, state++);
-        auto sta = wifi::getSTA();
+        auto sta = wifi_legacy::getSTA();
         sta->disconnect();
     }};
     sta->onDisconnect = {[]() {
         TEST_ASSERT_EQUAL(4, state++);
     }};
 
-    wifi::start(ap, sta);
+    wifi_legacy::start(ap, sta);
     waitForState(5, 30);
-    wifi::stop();
+    wifi_legacy::stop();
 }
 
 TEST_CASE_MULTIPLE_DEVICES("WiFi legacy AP+STA <--> AP+STA", "[kbf_wifi_legacy]", wifiDualMaster, wifiDualSlave)
 
 void wifiScanMaster() {
     using namespace kbf;
-    auto ap = wifi::AP::create(KBF_TEST_WIFI_SSID, KBF_TEST_WIFI_PASS);
+    auto ap = wifi_legacy::AP::create(KBF_TEST_WIFI_SSID, KBF_TEST_WIFI_PASS);
     state = 0;
-    ap->onDisconnect = {[](wifi::AP::STA &) {
+    ap->onDisconnect = {[](wifi_legacy::AP::STA &) {
         TEST_ASSERT_EQUAL(0, state++);
     }};
 
-    wifi::start(ap);
+    wifi_legacy::start(ap);
     waitForState(1, 30);
-    wifi::stop();
+    wifi_legacy::stop();
 }
 
 void wifiScanSlave() {
@@ -236,9 +236,9 @@ void wifiScanSlave() {
     using std::vector;
 
     state = 0;
-    wifi::start();
-    auto sta = wifi::getSTA();
-    sta->onScanDone = {[](vector<wifi::APInfo> &apList, void *data) {
+    wifi_legacy::start();
+    auto sta = wifi_legacy::getSTA();
+    sta->onScanDone = {[](vector<wifi_legacy::APInfo> &apList, void *data) {
         TEST_ASSERT_EQUAL(0, state++);
 
         TEST_ASSERT_EQUAL_STRING("foobar!", (char *) data);
@@ -252,7 +252,7 @@ void wifiScanSlave() {
             }
         }
         TEST_ASSERT_TRUE(found)
-        wifi::getSTA()->connect(KBF_TEST_WIFI_SSID, KBF_TEST_WIFI_PASS);
+        wifi_legacy::getSTA()->connect(KBF_TEST_WIFI_SSID, KBF_TEST_WIFI_PASS);
     }};
     sta->onConnect  = {[]() {
         TEST_ASSERT_EQUAL(1, state++);
@@ -260,7 +260,7 @@ void wifiScanSlave() {
 
     sta->startScan((void *) "foobar!");
     waitForState(2, 30);
-    wifi::stop();
+    wifi_legacy::stop();
 }
 
 TEST_CASE_MULTIPLE_DEVICES("WiFi legacy scan", "[kbf_wifi_legacy]", wifiScanMaster, wifiScanSlave)
@@ -271,14 +271,14 @@ void wifiIpMaster() {
     using namespace kbf;
     eventGroup = rtos::EventGroup();
 
-    auto ap = wifi::AP::create(KBF_TEST_WIFI_SSID, KBF_TEST_WIFI_PASS, net::IP("192.168.1.1"));
-    ap->onDisconnect = {[](wifi::AP::STA &) {
+    auto ap = wifi_legacy::AP::create(KBF_TEST_WIFI_SSID, KBF_TEST_WIFI_PASS, net::IP("192.168.1.1"));
+    ap->onDisconnect = {[](wifi_legacy::AP::STA &) {
         eventGroup.setBit(0);
     }};
-    wifi::start(ap);
+    wifi_legacy::start(ap);
 
     eventGroup.waitForBit(0);
-    wifi::stop();
+    wifi_legacy::stop();
 }
 
 void wifiIpSlave() {
@@ -286,10 +286,10 @@ void wifiIpSlave() {
     using namespace std;
     eventGroup = rtos::EventGroup();
 
-    wifi::start();
-    auto sta = wifi::getSTA();
+    wifi_legacy::start();
+    auto sta = wifi_legacy::getSTA();
     sta->onIp = {[]() {
-        auto ip = wifi::getSTA()->ip();
+        auto ip = wifi_legacy::getSTA()->ip();
         eventGroup.setBit(0);
         TEST_ASSERT_EQUAL(192, ip[0]);
         TEST_ASSERT_EQUAL(168, ip[1]);
@@ -299,7 +299,7 @@ void wifiIpSlave() {
     sta->connect(KBF_TEST_WIFI_SSID, KBF_TEST_WIFI_PASS);
 
     eventGroup.waitForBit(0);
-    wifi::stop();
+    wifi_legacy::stop();
 }
 
 TEST_CASE_MULTIPLE_DEVICES("WiFi legacy custom IP address", "[kbf_wifi_legacy]", wifiIpMaster, wifiIpSlave)
@@ -310,30 +310,30 @@ void wifiModeSwitchMaster() {
     using namespace kbf;
     eventGroup = rtos::EventGroup();
 
-    auto ap = wifi::AP::create(
+    auto ap = wifi_legacy::AP::create(
             KBF_TEST_WIFI_DUAL_MASTER_SSID,
             KBF_TEST_WIFI_PASS,
             net::IP("192.168.1.1")
     );
-    ap->onConnect = {[](wifi::AP::STA &) {
-        wifi::getSTA()->connect(KBF_TEST_WIFI_DUAL_SLAVE_SSID, KBF_TEST_WIFI_PASS);
+    ap->onConnect = {[](wifi_legacy::AP::STA &) {
+        wifi_legacy::getSTA()->connect(KBF_TEST_WIFI_DUAL_SLAVE_SSID, KBF_TEST_WIFI_PASS);
     }};
 
     delete client;
     client = new http::Client();
 
-    auto sta = wifi::STA::create();
+    auto sta = wifi_legacy::STA::create();
     sta->onIp = {[]() {
-        wifi::stopAP();
+        wifi_legacy::stopAP();
         kbf::sleep(1000);
         auto response = client->get("http://192.168.2.1/");
         TEST_ASSERT_EQUAL(200, response->status);
         eventGroup.setBit(0);
     }};
 
-    wifi::start(ap, sta);
+    wifi_legacy::start(ap, sta);
     eventGroup.waitForBit(0);
-    wifi::stop();
+    wifi_legacy::stop();
 }
 
 class TestController : public kbf::WebService::Controller {
@@ -353,23 +353,23 @@ void wifiModeSwitchSlave() {
     using namespace std;
     eventGroup = rtos::EventGroup();
 
-    auto ap = wifi::AP::create(
+    auto ap = wifi_legacy::AP::create(
             KBF_TEST_WIFI_DUAL_SLAVE_SSID,
             KBF_TEST_WIFI_PASS,
             net::IP("192.168.2.1")
     );
-    ap->onDisconnect = {[](wifi::AP::STA &) {
+    ap->onDisconnect = {[](wifi_legacy::AP::STA &) {
         eventGroup.setBit(1);
     }};
 
-    auto sta = wifi::STA::create();
+    auto sta = wifi_legacy::STA::create();
     sta->onReconnecting = {[](int, int) {
         return false;
     }};
     sta->onDisconnect   = {[]() {
         eventGroup.setBit(2);
     }};
-    wifi::start(ap, sta);
+    wifi_legacy::start(ap, sta);
 
     auto webService = WebService();
     webService.controller<TestController>();
@@ -379,7 +379,7 @@ void wifiModeSwitchSlave() {
 
     eventGroup.waitForBit(0);
     kbf::sleep(1000);
-    wifi::stop();
+    wifi_legacy::stop();
 }
 
 TEST_CASE_MULTIPLE_DEVICES("WiFi legacy mode switching", "[kbf_wifi_legacy]", wifiModeSwitchMaster, wifiModeSwitchSlave)
@@ -387,14 +387,14 @@ TEST_CASE_MULTIPLE_DEVICES("WiFi legacy mode switching", "[kbf_wifi_legacy]", wi
 TEST_CASE("WiFi legacy state handling", "[kbf_wifi_legacy]") {
     using namespace kbf;
 
-    wifi::stop();
-    TEST_ASSERT_FALSE(wifi::isRunning())
-    wifi::start();
+    wifi_legacy::stop();
+    TEST_ASSERT_FALSE(wifi_legacy::isRunning())
+    wifi_legacy::start();
     kbf::sleep(1000);
 
-    TEST_ASSERT_TRUE(wifi::isRunning())
-    wifi::stop();
+    TEST_ASSERT_TRUE(wifi_legacy::isRunning())
+    wifi_legacy::stop();
     kbf::sleep(1000);
-    TEST_ASSERT_FALSE(wifi::isRunning())
-    wifi::stop();
+    TEST_ASSERT_FALSE(wifi_legacy::isRunning())
+    wifi_legacy::stop();
 }

test/wifi/test_wifi_modeswitch.cpp

@@ -14,8 +14,10 @@
 #define MASTER_SSID   "kbf_test_wifi_master"
 #define SLAVE_SSID    "kbf_test_wifi_slave"
 #define WIFI_PASS     "Pas$w0Rd1337"
+#define MASTER_IP     "192.168.1.1"
 #define MASTER_AP     "http://192.168.1.1/ping"
 #define MASTER_STA    "http://192.168.2.2/ping"
+#define SLAVE_IP      "192.168.2.1"
 #define SLAVE_AP      "http://192.168.2.1/ping"
 #define SLAVE_STA     "http://192.168.1.2/ping"
 #define PING_RESPONSE "P0NG"
@@ -44,15 +46,21 @@ protected:
 static auto client = new http::Client(); // NOLINT(cert-err58-cpp)
 
 static void pingOK(const string &url, int id) {
+    ESP_LOGI(__func__, "%d", id);
+
     const auto response = client->get(url + "?id=" + std::to_string(id));
     TEST_ASSERT_EQUAL(200, response->status);
     TEST_ASSERT_EQUAL_STRING(PING_RESPONSE, response->body.c_str());
+
+    ESP_LOGI(__func__, "success");
 }
 
 static void pingFail(const string &url) {
+    ESP_LOGI(__func__, "start");
     try {
         client->get(url);
     } catch (http::exception::ConnectionError &) {
+        ESP_LOGI(__func__, "success");
         return;
     }
     TEST_FAIL();
@@ -81,7 +89,7 @@ void master() {
     ESP_LOGI(TAG, "0 - starting AP");
     wifi::ap::onDisconnect  = fail;
     wifi::sta::onDisconnect = fail;
-    wifi::ap::start(MASTER_SSID, WIFI_PASS);
+    wifi::ap::start(MASTER_SSID, WIFI_PASS, net::IP(MASTER_IP));
     TEST_ASSERT_EQUAL(wifi::Mode::AP, wifi::mode());
     pingService.start();
 
@@ -105,7 +113,7 @@ void master() {
     waitForPing(7);
 
     ESP_LOGI(TAG, "4 - master switches to STA, slave is DUAL");
-    kbf::sleep(100); // wait for slave to disable onDisconnect
+    kbf::sleep(1000); // wait for slave to disable onDisconnect
     wifi::ap::stop();
     TEST_ASSERT_EQUAL(wifi::Mode::STA, wifi::mode());
     pingOK(SLAVE_AP, 8);
@@ -145,7 +153,7 @@ void slave() {
     pingFail(MASTER_STA);
 
     ESP_LOGI(TAG, "2 - master is AP, slave switches to DUAL");
-    wifi::ap::start(SLAVE_SSID, WIFI_PASS);
+    wifi::ap::start(SLAVE_SSID, WIFI_PASS, net::IP(SLAVE_IP));
     TEST_ASSERT_EQUAL(wifi::Mode::DUAL, wifi::mode());
     pingOK(MASTER_AP, 2);
     waitForPing(3);
@@ -172,11 +180,11 @@ void slave() {
 
     ESP_LOGI(TAG, "finished");
     wifi::ap::onDisconnect = nullptr;
-    kbf::sleep(100); // wait for master to disable onDisconnect
+    kbf::sleep(1000); // wait for master to disable onDisconnect
 
     pingService.stop();
     wifi::stop();
     TEST_ASSERT_EQUAL(wifi::Mode::OFF, wifi::mode());
 }
 
-TEST_CASE_MULTIPLE_DEVICES("WiFi mode STA to DUAL", "[kbf_wifi]", master, slave);
+TEST_CASE_MULTIPLE_DEVICES("WiFi mode switching", "[kbf_wifi]", master, slave);