Added NVS

Author: howroyd

main/CMakeLists.txt

@@ -2,6 +2,7 @@ idf_component_register(SRCS
                             "wrappers/task.cpp"
                             "wrappers/netif.cpp"
                             "wrappers/eventgroup.cpp"
+                            "wrappers/nvs.cpp"
                             "wifi.cpp"
                             "smartconfig.cpp"
                             "main.cpp"

main/main.cpp

@@ -1,41 +1,42 @@
 #include "driver/gpio.h"
 #include "esp_log.h"
 #include "esp_system.h"
-#include "freertos/FreeRTOS.h"
-#include "nvs_flash.h"
 
 #include <vector>
 
 #include "smartconfig.hpp"
 #include "wifi.hpp"
+#include "wrappers/nvs.hpp"
 #include "wrappers/queue.hpp"
 #include "wrappers/task.hpp"
 
 static const char *TAG = "main";
 
 #define ESP_INTR_FLAG_DEFAULT 0
 
-static auto gpio_evt_queue = queue::make_queue<uint32_t>(10);
+static auto gpio_evt_queue = queue::make_queue<gpio_num_t>(10);
 
 static void IRAM_ATTR gpio_isr_handler(void *arg)
 {
-    uint32_t gpio_num = (uint32_t)arg;
-    xQueueSendFromISR(gpio_evt_queue->get(), &gpio_num, NULL);
+    gpio_num_t gpio_num = *reinterpret_cast<const gpio_num_t *>(arg);
+    auto success = gpio_evt_queue->send_from_isr(gpio_num);
+    ESP_DRAM_LOGD("gpio_isr_handler", "GPIO[%d] ISR: %s", gpio_num, success ? "success" : "failure");
 }
 
 static void gpio_task_example(void *arg)
 {
     using SmartConfig = sc::SmartConfig::Shared;
 
-    uint32_t io_num{};
     std::vector<SmartConfig> instances;
+    wifi::Wifi::nvs_ssid_erase();
+    wifi::Wifi::nvs_password_erase();
     auto wifiobj{wifi::Wifi::get_shared()};
 
     while (true)
     {
-        if (xQueueReceive(gpio_evt_queue->get(), &io_num, portMAX_DELAY))
+        if (const auto result = gpio_evt_queue->receive())
         {
-            ESP_LOGI(TAG, "GPIO[%lu] intr, val: %d", io_num, gpio_get_level((gpio_num_t)io_num));
+            ESP_LOGI(TAG, "GPIO[%d] intr, val: %d", result.item, gpio_get_level(result.item));
 
             if (instances.size() >= 5)
             {
@@ -55,8 +56,8 @@ static void gpio_task_example(void *arg)
 {
     ESP_LOGI(TAG, "GPIO task started");
 
-    constexpr auto pin = GPIO_NUM_34;
-    constexpr auto pinmask = 1ULL << pin;
+    static constexpr auto pin = GPIO_NUM_34;
+    static constexpr auto pinmask = 1ULL << pin;
 
     // zero-initialize the config structure.
     gpio_config_t io_conf = {};
@@ -70,21 +71,19 @@ static void gpio_task_example(void *arg)
     gpio_config(&io_conf);
 
     // start gpio task
-    xTaskCreate(gpio_task_example, "gpio_task_example", 4096, nullptr, 10, NULL);
+    auto gpio_task = task::make_task(gpio_task_example, "gpio_task_example", 4096, nullptr, 10);
 
     // install gpio isr service
     gpio_install_isr_service(ESP_INTR_FLAG_DEFAULT);
     // hook isr handler for specific gpio pin
-    gpio_isr_handler_add(pin, gpio_isr_handler, (void *)pin);
+    gpio_isr_handler_add(pin, gpio_isr_handler, const_cast<gpio_num_t *>(&pin));
 
     while (true)
         vTaskDelay(portMAX_DELAY);
 }
 
 int main()
 {
-    ESP_ERROR_CHECK(nvs_flash_init());
-
     auto gpio_task_handle = task::make_task(gpio_task, "gpio_task", 4096, nullptr, 3);
 
     vTaskDelay(portMAX_DELAY);
@@ -93,6 +92,7 @@ int main()
 
 extern "C" void app_main(void)
 {
+    ESP_ERROR_CHECK(nvs::initialise_nvs());
     const int ret = main();
     ESP_LOGE(TAG, "main() returned %d", ret);
 }

main/smartconfig.cpp

@@ -10,6 +10,22 @@ namespace sc
     task::Task SmartConfig::taskhandle{};
     eventgroup::Eventgroup SmartConfig::event_group{};
 
+    [[nodiscard]] wifi_config_t ssid_pswd_to_config(const smartconfig_event_got_ssid_pswd_t &evt)
+    {
+        wifi_config_t wifi_config{};
+
+        std::copy(evt.ssid, evt.ssid + std::min(sizeof(evt.ssid), sizeof(wifi_config.sta.ssid)), wifi_config.sta.ssid);
+        std::copy(evt.password, evt.password + std::min(sizeof(evt.password), sizeof(wifi_config.sta.password)), wifi_config.sta.password);
+
+        if (evt.bssid_set)
+        {
+            wifi_config.sta.bssid_set = evt.bssid_set;
+            std::copy(evt.bssid, evt.bssid + std::min(sizeof(evt.bssid), sizeof(wifi_config.sta.bssid)), wifi_config.sta.bssid);
+        }
+
+        return wifi_config;
+    }
+
     SmartConfig::EventHandlers::handle_success_t SmartConfig::EventHandlers::handle_sc_event(SmartConfig::EventHandlers::args_t args)
     {
         switch (args.event_id)
@@ -24,42 +40,27 @@ namespace sc
         {
             ESP_LOGI(TAG, "Got SSID and password");
 
-            const smartconfig_event_got_ssid_pswd_t *const evt = reinterpret_cast<const smartconfig_event_got_ssid_pswd_t *>(args.event_data);
-            wifi_config_t wifi_config{};
+            wifi_config_t wifi_config{ssid_pswd_to_config(*reinterpret_cast<const smartconfig_event_got_ssid_pswd_t *>(args.event_data))};
+
+            const auto [ssidview, passwordview] = wifi::config_to_ssidpasswordview(wifi_config);
+            ESP_LOGI(TAG, "SSID:%.*s", ssidview.size(), ssidview.data());
+            ESP_LOGI(TAG, "PASSWORD:%.*s", passwordview.size(), passwordview.data());
 
-            std::copy(evt->ssid, evt->ssid + std::min(sizeof(evt->ssid), sizeof(wifi_config.sta.ssid)), wifi_config.sta.ssid);
-            std::copy(evt->password, evt->password + std::min(sizeof(evt->password), sizeof(wifi_config.sta.password)), wifi_config.sta.password);
-            if (evt->bssid_set)
+            if (ssidview.empty() or passwordview.empty())
             {
-                wifi_config.sta.bssid_set = evt->bssid_set;
-                std::copy(evt->bssid, evt->bssid + std::min(sizeof(evt->bssid), sizeof(wifi_config.sta.bssid)), wifi_config.sta.bssid);
+                ESP_LOGW(TAG, "SSID or password is empty");
+                return handle_success_t::FAIL;
             }
 
-            std::string_view ssid_view(reinterpret_cast<const char *>(wifi_config.sta.ssid), sizeof(wifi_config.sta.ssid));
-            std::string_view password_view(reinterpret_cast<const char *>(wifi_config.sta.password), sizeof(wifi_config.sta.password));
-
-            ESP_LOGI(TAG, "SSID:%.*s", ssid_view.size(), ssid_view.data());
-            ESP_LOGI(TAG, "PASSWORD:%.*s", password_view.size(), password_view.data());
-
-            if (SC_TYPE_ESPTOUCH_V2 == evt->type)
+            if (not wifiobj->reconnect_to(wifi_config))
             {
-                uint8_t rvd_data[33]{};
-                ESP_ERROR_CHECK(esp_smartconfig_get_rvd_data(rvd_data, sizeof(rvd_data)));
-                ESP_LOGI(TAG, "RVD_DATA:");
-                for (const auto i : rvd_data)
-                {
-                    printf("%02x ", i);
-                }
-                printf("\n");
+                ESP_LOGW(TAG, "Failed to reconnect");
+                return handle_success_t::FAIL;
             }
-
-            ESP_ERROR_CHECK(esp_wifi_disconnect());
-            ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wifi_config));
-            esp_wifi_connect();
             break;
         }
         case SC_EVENT_SEND_ACK_DONE:
-            xEventGroupSetBits(event_group.get(), ESPTOUCH_DONE_BIT);
+            eventgroup::set_bits(event_group, ESPTOUCH_DONE_BIT);
             break;
         [[unlikely]] default:
             ESP_LOGW(TAG, "Unhandled SC_EVENT %d", args.event_id);
@@ -72,10 +73,26 @@ namespace sc
     {
         while (true)
         {
-            const auto uxBits = xEventGroupWaitBits(event_group.get(), ESPTOUCH_DONE_BIT, true, false, portMAX_DELAY);
+            // const auto uxBits = xEventGroupWaitBits(event_group.get(), ESPTOUCH_DONE_BIT, true, false, portMAX_DELAY);
+            const auto bits = eventgroup::wait_bits(event_group, ESPTOUCH_DONE_BIT, true, false, portMAX_DELAY);
 
-            if (uxBits & ESPTOUCH_DONE_BIT)
+            // if (uxBits & ESPTOUCH_DONE_BIT)
+            if (bits)
             {
+                const auto [ssidview, passwordview] = wifi::config_to_ssidpasswordview(wifiobj->config());
+
+                if (ssidview.empty() or passwordview.empty()) [[unlikely]]
+                {
+                    ESP_LOGE(TAG, "SSID or password is empty!");
+                }
+                else
+                {
+                    ESP_LOGI(TAG, "Saving creds to NVS");
+
+                    wifiobj->nvs_ssid(ssidview);
+                    wifiobj->nvs_password(passwordview);
+                }
+
                 ESP_LOGI(TAG, "Done!");
                 esp_smartconfig_stop();
                 state = state_t::DONE;

main/smartconfig.hpp

@@ -2,9 +2,7 @@
 
 #include "esp_event.h"
 #include "esp_log.h"
-#include "esp_netif.h"
 #include "esp_smartconfig.h"
-#include "esp_wifi.h"
 #include "freertos/FreeRTOS.h"
 
 #include "singleton.hpp"
@@ -75,6 +73,7 @@ namespace sc
             ESP_ERROR_CHECK(esp_smartconfig_start(smartconfigcfg.get()));
             state = state_t::STARTED;
         }
+
         SmartConfig(const SmartConfig &) = delete;
         SmartConfig &operator=(const SmartConfig &) = delete;
 
@@ -89,6 +88,7 @@ namespace sc
             enum class handle_success_t
             {
                 OK,
+                FAIL,
                 UNHANDLED
             };
 

main/wifi.cpp

@@ -3,9 +3,16 @@
 namespace wifi
 {
 
+    SsidPasswordView config_to_ssidpasswordview(const wifi_config_t &config)
+    {
+        return {std::string_view(reinterpret_cast<const char *>(config.sta.ssid), sizeof(config.sta.ssid)),
+                std::string_view(reinterpret_cast<const char *>(config.sta.password), sizeof(config.sta.password))};
+    }
+
     state_t Wifi::state{state_t::IDLE};
     netif::Netif Wifi::sta_netif;
     std::unique_ptr<wifi_init_config_t> Wifi::wifiinitcfg{new wifi_init_config_t(WIFI_INIT_CONFIG_DEFAULT())};
+    nvs::Nvs Wifi::storage{nvs::make_nvs(TAG, NVS_READWRITE)};
     task::Task Wifi::taskhandle{};
     eventgroup::Eventgroup Wifi::event_group{};
 

main/wifi.hpp

@@ -1,6 +1,5 @@
 #pragma once
 
-#include "esp_event.h"
 #include "esp_log.h"
 #include "esp_netif.h"
 #include "esp_smartconfig.h"
@@ -11,8 +10,13 @@
 #include "singleton.hpp"
 #include "wrappers/eventgroup.hpp"
 #include "wrappers/netif.hpp"
+#include "wrappers/nvs.hpp"
 #include "wrappers/task.hpp"
 
+#include <algorithm>
+#include <string_view>
+#include <utility>
+
 namespace wifi
 {
 
@@ -29,6 +33,9 @@ namespace wifi
 
     static constexpr auto CONNECTED_BIT{BIT0};
 
+    using SsidPasswordView = std::pair<std::string_view, std::string_view>;
+    SsidPasswordView config_to_ssidpasswordview(const wifi_config_t &config);
+
     class Wifi : public Singleton<Wifi> // NOTE: CRTP
     {
         friend Singleton<Wifi>; // NOTE: So Singleton can use our private/protected constructor
@@ -63,11 +70,70 @@ namespace wifi
 
         static state_t get_state() { return state; }
 
+        std::string nvs_ssid() const
+        {
+            return nvs::get_string(storage, "ssid");
+        }
+        bool nvs_ssid(std::string_view ssid)
+        {
+            return nvs::set_string(storage, "ssid", ssid);
+        }
+        static bool nvs_ssid_erase()
+        {
+            return nvs::erase_key(storage, "ssid");
+        }
+        std::string nvs_password() const
+        {
+            return nvs::get_string(storage, "password");
+        }
+        bool nvs_password(std::string_view password)
+        {
+            return nvs::set_string(storage, "password", password);
+        }
+        static bool nvs_password_erase()
+        {
+            return nvs::erase_key(storage, "password");
+        }
+
+        bool reconnect_to(wifi_config_t &wifi_config)
+        {
+            auto status = esp_wifi_disconnect();
+            if (ESP_OK != status)
+            {
+                ESP_LOGW(TAG, "Failed to disconnect: %s", esp_err_to_name(status));
+                return false;
+            }
+
+            status = esp_wifi_set_config(WIFI_IF_STA, &wifi_config);
+            if (ESP_OK != status)
+            {
+                ESP_LOGW(TAG, "Failed to set config: %s", esp_err_to_name(status));
+                return false;
+            }
+
+            status = esp_wifi_connect();
+            if (ESP_OK != status)
+            {
+                ESP_LOGW(TAG, "Failed to connect: %s", esp_err_to_name(status));
+                return false;
+            }
+
+            return true;
+        }
+
+        auto config() const
+        {
+            wifi_config_t wifi_config{};
+            esp_wifi_get_config(WIFI_IF_STA, &wifi_config);
+            return wifi_config;
+        }
+
     protected:
         static constexpr const char *const TAG{"Wifi"};
         static state_t state;
         static netif::Netif sta_netif;
         static std::unique_ptr<wifi_init_config_t> wifiinitcfg;
+        static nvs::Nvs storage;
 
         Wifi()
         {
@@ -86,7 +152,6 @@ namespace wifi
             ESP_ERROR_CHECK(esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &EventHandlers::event_handler, nullptr));
             ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, &EventHandlers::event_handler, nullptr));
 
-            // wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
             ESP_ERROR_CHECK(esp_wifi_init(wifiinitcfg.get()));
 
             ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
@@ -95,6 +160,19 @@ namespace wifi
             event_group = eventgroup::make_eventgroup();
 
             state = state_t::STARTED;
+
+            const auto ssid = nvs_ssid();
+            const auto password = nvs_password();
+
+            if (not ssid.empty() and not password.empty())
+            {
+                ESP_LOGI(TAG, "Connecting to %s", ssid.c_str());
+                wifi_config_t wifi_config{};
+                std::copy(ssid.begin(), ssid.end(), wifi_config.sta.ssid);
+                std::copy(password.begin(), password.end(), wifi_config.sta.password);
+                ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wifi_config));
+                ESP_ERROR_CHECK(esp_wifi_connect());
+            }
         }
 
         struct EventHandlers
@@ -139,7 +217,7 @@ namespace wifi
 
         static task::Task taskhandle;
         [[noreturn]] static void taskfn(void *param);
-        static constexpr auto taskstacksize = 896 * sizeof(int);
+        static constexpr auto taskstacksize = 640 * sizeof(int);
 
         static eventgroup::Eventgroup event_group;
     };