kbf/src/wifi/driver.cpp

#include "kbf/wifi.h"

#include <utility>
#include <memory>

#include <freertos/FreeRTOS.h>
#include <freertos/event_groups.h>
#include <esp_log.h>
#include <esp_err.h>
#include <esp_event.h>
#include <esp_netif.h>
#include <esp_wifi.h>
#include <nvs_flash.h>

#include "kbf/macros.h"
#include "kbf/nvs.h"

using std::shared_ptr;

using namespace kbf::wifi;

static shared_ptr<AP>  s_ap  = nullptr;
static shared_ptr<STA> s_sta = nullptr;

static bool initialized = false;

static void init() {
    if (initialized) return;

    CHECK(esp_netif_init());
    CHECK(esp_event_loop_create_default());

    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
    auto err = esp_wifi_init(&cfg);
    if (err == ESP_ERR_NVS_NOT_INITIALIZED) {
        ESP_LOGI(TAG, "NVS not initialized");
        kbf::nvs::init();
        CHECK(esp_wifi_init(&cfg));
    } else {
        CHECK(err);
    }

    initialized = true;
}

void kbf::wifi::start(shared_ptr<AP> ap) {
    ESP_LOGI(TAG, "starting AP mode");

    init();

    s_ap = std::move(ap);
    s_ap->netif = esp_netif_create_default_wifi_ap();
    s_ap->registerEventHandlers();

    wifi_config_t config = {.ap = s_ap->config};
    CHECK(esp_wifi_set_mode(WIFI_MODE_AP));
    CHECK(esp_wifi_set_config(WIFI_IF_AP, &config));
    CHECK(esp_wifi_start());
}

void kbf::wifi::start(shared_ptr<STA> sta) {
    ESP_LOGI(TAG, "starting STA mode");

    init();

    if (sta == nullptr) {
        s_sta = STA::create();
    } else {
        s_sta = std::move(sta);
    }

    s_sta->netif = esp_netif_create_default_wifi_sta();
    s_sta->registerEventHandlers();

    wifi_config_t config = {.sta = s_sta->config};
    CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
    CHECK(esp_wifi_set_config(WIFI_IF_STA, &config));
    CHECK(esp_wifi_start());
}

void kbf::wifi::start(shared_ptr<AP>, shared_ptr<STA>) {
    ABORT("not implemented");
}

void kbf::wifi::stop() {
    CHECK(esp_wifi_stop());

    if (s_ap) {
        esp_netif_destroy(s_ap->netif);
        s_ap = nullptr;
    }

    if (s_sta) {
        esp_netif_destroy(s_sta->netif);
        s_sta = nullptr;
    }
}

shared_ptr<kbf::wifi::AP> kbf::wifi::getAP() {
    return s_ap;
}

shared_ptr<kbf::wifi::STA> kbf::wifi::getSTA() {
    return s_sta;
}