Esp32WiFiManager.hxx

Go to the documentation of this file.

 
#ifndef _FREERTOS_DRIVERS_ESP32_ESP32WIFIMGR_HXX_
#define _FREERTOS_DRIVERS_ESP32_ESP32WIFIMGR_HXX_
 
#include "freertos_drivers/esp32/Esp32WiFiConfiguration.hxx"
#include "executor/Executor.hxx"
#include "executor/Service.hxx"
#include "executor/StateFlow.hxx"
#include "openlcb/ConfigRepresentation.hxx"
#include "openlcb/ConfiguredTcpConnection.hxx"
#include "utils/ConfigUpdateListener.hxx"
#include "utils/GcTcpHub.hxx"
#include "utils/macros.h"
#include "utils/Singleton.hxx"
 
#include <esp_event.h>
#include <esp_netif.h>
#include <esp_wifi_types.h>
#include <freertos/event_groups.h>
 
namespace openlcb
{
    class SimpleStackBase;
}
 
class Gpio;
class SocketClient;
 
namespace openmrn_arduino
{
 
typedef enum : uint8_t
{
    STATION_INTERFACE = 0,
 
    SOFTAP_INTERFACE,
 
    MAX_NETWORK_INTERFACES
} esp_network_interface_t;
 
typedef std::function<void(esp_network_interface_t
                         , uint32_t)> esp_network_up_callback_t;
 
typedef std::function<void(esp_network_interface_t)> esp_network_down_callback_t;
 
typedef std::function<void(esp_network_interface_t)> esp_network_init_callback_t;
 
typedef std::function<void(time_t)> esp_network_time_callback_t;
 
class Esp32WiFiManager
    : public DefaultConfigUpdateListener
    , public Service
    , public Singleton<Esp32WiFiManager>
{
public:
    Esp32WiFiManager(const char *station_ssid
                   , const char *station_password
                   , openlcb::SimpleStackBase *stack
                   , const WiFiConfiguration &cfg
                   , wifi_mode_t wifi_mode = WIFI_MODE_STA
                   , uint8_t connection_mode = CONN_MODE_UPLINK_BIT
                   , const char *hostname_prefix = "esp32_"
                   , const char *sntp_server = "pool.ntp.org"
                   , const char *timezone = "UTC0"
                   , bool sntp_enabled = false
                   , uint8_t softap_channel = 1
                   , wifi_auth_mode_t softap_auth_mode = WIFI_AUTH_OPEN
                   , const char *softap_ssid = ""
                   , const char *softap_password = ""
    );
 
    ~Esp32WiFiManager();
 
    void display_configuration();
 
    void set_status_led(const Gpio *led = nullptr)
    {
        statusLed_ = led;
    }
 
    ConfigUpdateListener::UpdateAction apply_configuration(
        int fd, bool initial_load, BarrierNotifiable *done) override;
 
    void factory_reset(int fd) override;
 
    static void process_idf_event(void *ctx, esp_event_base_t event_base
                                , int32_t event_id, void *event_data);
 
    void enable_verbose_logging()
    {
        verboseLogging_ = true;
        enable_esp_wifi_logging();
    }
 
    void start_ssid_scan(Notifiable *n);
 
    size_t get_ssid_scan_result_count();
 
    wifi_ap_record_t get_ssid_scan_result(size_t index);
 
    void clear_ssid_scan_results();
 
    void mdns_publish(std::string service, uint16_t port);
 
    void mdns_unpublish(std::string service);
 
    void wait_for_ssid_connect(bool enable)
    {
        waitForStationConnect_ = enable;
    }
 
    void set_tx_power(uint8_t power)
    {
        HASSERT(power >= 8 && power <= 84);
        wifiTXPower_ = power;
    }
 
    void register_network_up_callback(esp_network_up_callback_t callback);
 
    void register_network_down_callback(esp_network_down_callback_t callback);
 
    void register_network_init_callback(esp_network_init_callback_t callback);
 
    void register_network_time_callback(esp_network_time_callback_t callback);
 
    void sync_time(time_t now);
 
    Executor<1> *executor()
    {
        return &executor_;
    }
 
private:
    Esp32WiFiManager();
 
    static void *wifi_manager_task(void *param);
 
    void stop_hub();
 
    void start_hub();
 
    void stop_uplink();
 
    void start_uplink();
 
    void on_uplink_created(int fd, Notifiable *on_exit);
 
    void enable_esp_wifi_logging();
 
    void start_mdns_system();
 
    void on_station_started();
 
    void on_station_connected();
 
    void on_station_disconnected(uint8_t reason);
 
    void on_station_ip_assigned(uint32_t ip_address);
 
    void on_station_ip_lost();
 
    void on_softap_start();
 
    void on_softap_stop();
 
    void on_softap_station_connected(uint8_t mac[6], uint8_t aid);
 
    void on_softap_station_disconnected(uint8_t mac[6], uint8_t aid);
 
    void on_wifi_scan_completed(uint32_t status, uint8_t count);
 
    void configure_sntp();
 
    void reconfigure_wifi_radio_sleep();
    
    void reconfigure_wifi_tx_power();
 
    std::string hostname_;
 
    std::string ssid_;
 
    std::string password_;
 
    const WiFiConfiguration cfg_;
 
    openlcb::SimpleStackBase *stack_;
 
    const Gpio *statusLed_{nullptr};
 
    const wifi_mode_t wifiMode_;
 
    const uint8_t softAPChannel_;
 
    wifi_auth_mode_t softAPAuthMode_;
 
    std::string softAPName_;
 
    std::string softAPPassword_;
 
    const bool sntpEnabled_;
 
    std::string sntpServer_;
 
    std::string timeZone_;
 
    bool sntpConfigured_{false};
 
    int configFd_{-1};
 
    uint32_t configCrc32_{0};
 
    bool waitForStationConnect_{true};
 
    bool verboseLogging_{false};
 
    uint8_t connectionMode_{CONN_MODE_UPLINK_BIT};
 
    uint8_t wifiTXPower_{84};
 
    std::string hubServiceName_;
 
    std::unique_ptr<SocketClient> uplink_;
 
    int uplinkFd_{-1};
 
    Notifiable *uplinkNotifiable_{nullptr};
 
    EventGroupHandle_t wifiStatusEventGroup_;
 
    std::vector<wifi_ap_record_t> ssidScanResults_;
 
    OSMutex ssidScanResultsLock_;
 
    Notifiable *ssidCompleteNotifiable_{nullptr};
 
    OSMutex mdnsInitLock_;
 
    bool mdnsInitialized_{false};
 
    Executor<1> executor_{NO_THREAD()};
 
    std::map<std::string, uint16_t> mdnsDeferredPublish_;
 
    OSMutex networkCallbacksLock_;
 
    std::vector<esp_network_up_callback_t> networkUpCallbacks_;
 
    std::vector<esp_network_down_callback_t> networkDownCallbacks_;
 
    std::vector<esp_network_init_callback_t> networkInitCallbacks_;
 
    std::vector<esp_network_time_callback_t> networkTimeCallbacks_;
 
    static constexpr uint8_t MAX_HOSTNAME_LENGTH = 32;
 
    static constexpr uint8_t CONN_MODE_UPLINK_BIT = BIT(0);
 
    static constexpr uint8_t CONN_MODE_HUB_BIT = BIT(1);
 
    esp_netif_t *espNetIfaces_[MAX_NETWORK_INTERFACES]
    {
        nullptr, nullptr
    };
 
    class UplinkNotifiable : public Notifiable
    {
    public:
        UplinkNotifiable(Esp32WiFiManager *parent) : parent_(parent)
        {
        }
 
        virtual void notify() override
        {
            // if we have a valid notifiable from the uplink forward the notify
            // call, otherwise this method is a no-op.
            if (parent_->uplinkNotifiable_ != nullptr)
            {
                parent_->uplinkNotifiable_->notify();
            }
        }
    private:
        Esp32WiFiManager *parent_;
    };
 
    UplinkNotifiable uplinkNotifiableProxy_{this};
 
    class WiFiStackFlow : public StateFlowBase
    {
    public:
        WiFiStackFlow(Esp32WiFiManager *parent);
    private:
        StateFlowTimer timer_{this};
 
        Esp32WiFiManager * parent_;
 
        uint8_t wifiConnectAttempts_{0};
 
        uint32_t wifiConnectBitMask_;
 
        STATE_FLOW_STATE(startup);
 
        STATE_FLOW_STATE(noop);
 
        STATE_FLOW_STATE(init_interface);
 
        STATE_FLOW_STATE(init_wifi);
 
        STATE_FLOW_STATE(configure_station);
 
        STATE_FLOW_STATE(configure_softap);
 
        STATE_FLOW_STATE(start_wifi);
 
        STATE_FLOW_STATE(wait_for_connect);
 
        STATE_FLOW_STATE(reload);
    };
 
    WiFiStackFlow wifiStackFlow_{this};
 
    DISALLOW_COPY_AND_ASSIGN(Esp32WiFiManager);
};
 
} // namespace openmrn_arduino
 
using openmrn_arduino::Esp32WiFiManager;
using openmrn_arduino::esp_network_interface_t;
using openmrn_arduino::esp_network_up_callback_t;
using openmrn_arduino::esp_network_down_callback_t;
using openmrn_arduino::esp_network_init_callback_t;
using openmrn_arduino::esp_network_time_callback_t;
 
#endif // _FREERTOS_DRIVERS_ESP32_ESP32WIFIMGR_HXX_