EspWifi.h

Go to the documentation of this file.

 
#pragma once
 
// Suppress pedantic warnings for ESP-IDF headers
#ifdef __cplusplus
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpedantic"
#endif
 
// ESP-IDF C headers must be wrapped in extern "C" for C++ compatibility
#ifdef __cplusplus
extern "C" {
#endif
 
#include "esp_event.h"
#include "esp_mesh.h"
#include "esp_netif.h"
#include "esp_smartconfig.h"
#include "esp_wifi.h"
// WPS not available on ESP32-C6
// #include "esp_wps.h"
#include "lwip/err.h"
#include "lwip/sys.h"
#include "nvs_flash.h"
 
#ifdef __cplusplus
}
#endif
 
// Restore warnings after ESP-IDF headers
#ifdef __cplusplus
#pragma GCC diagnostic pop
#endif
 
// C++ headers
#include "BaseWifi.h"
#include "mcu/esp32/utils/EspTypes_Base.h"
#include "utils/PlatformMutex.h"
#include <atomic>
#include <memory>
#include <queue>
 
struct EspWifiAdvancedConfig {
  // Power management
  bool enable_power_save;         
  wifi_ps_type_t power_save_type; 
  uint16_t listen_interval;       
  // Performance tuning
  uint8_t tx_power;           
  wifi_bandwidth_t bandwidth; 
  bool enable_ampdu_rx;       
  bool enable_ampdu_tx;       
  // Advanced features
  bool enable_fast_connect;    
  bool enable_pmf_required;    
  bool enable_wpa3_transition; 
  bool enable_11r;             
  bool enable_11k;             
  bool enable_11v;             
  // Enterprise features
  bool enable_enterprise;             
  std::string enterprise_username;    
  std::string enterprise_password;    
  std::string enterprise_ca_cert;     
  std::string enterprise_client_cert; 
  std::string enterprise_client_key;  
  // Mesh networking
  bool enable_mesh;             
  uint8_t mesh_max_layer;       
  uint16_t mesh_max_connection; 
  // Smart config and provisioning
  bool enable_smartconfig;             
  smartconfig_type_t smartconfig_type; 
  // WPS not available on ESP32-C6
  // bool enable_wps;                     /**< Enable WPS */
  // wps_type_t wps_type;                 /**< WPS type */
};
 
class EspWifi : public BaseWifi {
public:
  explicit EspWifi(const EspWifiAdvancedConfig* advanced_config = nullptr);
 
  virtual ~EspWifi();
 
  // ========== BaseWifi Interface Implementation ==========
 
  // Initialization and Configuration
  hf_wifi_err_t Initialize(hf_wifi_mode_t mode) noexcept override;
  hf_wifi_err_t Deinitialize() noexcept override;
  bool IsInitialized() const noexcept override;
  hf_wifi_err_t SetMode(hf_wifi_mode_t mode) noexcept override;
  hf_wifi_mode_t GetMode() const noexcept override;
 
  // Station Mode Operations
  hf_wifi_err_t ConfigureStation(const hf_wifi_station_config_t& config) noexcept override;
  hf_wifi_err_t Connect(uint32_t timeout_ms = 0) noexcept override;
  hf_wifi_err_t Disconnect() noexcept override;
  bool IsConnected() const noexcept override;
  int8_t GetRssi() const noexcept override;
  hf_wifi_err_t GetIpInfo(hf_wifi_ip_info_t& ip_info) const noexcept override;
 
  // Access Point Mode Operations
  hf_wifi_err_t ConfigureAccessPoint(const hf_wifi_ap_config_t& config) noexcept override;
  hf_wifi_err_t StartAccessPoint() noexcept override;
  hf_wifi_err_t StopAccessPoint() noexcept override;
  bool IsAccessPointActive() const noexcept override;
  int GetConnectedStationCount() const noexcept override;
 
  // Network Scanning
  hf_wifi_err_t StartScan(bool show_hidden = false, bool passive = false,
                          uint32_t max_scan_time_ms = 0) noexcept override;
  hf_wifi_err_t GetScanResults(std::vector<hf_wifi_network_info_t>& networks,
                               uint16_t max_networks = 0) noexcept override;
  bool IsScanning() const noexcept override;
 
  // State and Status
  hf_wifi_state_t GetState() const noexcept override;
  std::string GetConnectedSsid() const noexcept override;
  hf_wifi_err_t GetConnectedBssid(uint8_t bssid[6]) const noexcept override;
 
  // Power Management
  hf_wifi_err_t SetPowerSave(hf_wifi_power_save_t mode) noexcept override;
  hf_wifi_power_save_t GetPowerSave() const noexcept override;
 
  // Event Handling
  hf_wifi_err_t RegisterEventCallback(hf_wifi_event_callback_t callback) noexcept override;
  hf_wifi_err_t UnregisterEventCallback() noexcept override;
 
  // Utility Functions
  hf_wifi_err_t GetMacAddress(uint8_t mac[6], uint8_t interface = 0) const noexcept override;
  hf_wifi_err_t SetMacAddress(const uint8_t mac[6], uint8_t interface = 0) noexcept override;
  uint8_t GetChannel() const noexcept override;
  hf_wifi_err_t SetChannel(uint8_t channel) noexcept override;
 
  // ========== ESP32-Specific Extensions ==========
 
  hf_wifi_err_t SetAdvancedConfig(const EspWifiAdvancedConfig& config);
 
  hf_wifi_err_t GetAdvancedConfig(EspWifiAdvancedConfig& config) const;
 
  hf_wifi_err_t EnableWpa3Transition(bool enable);
 
  hf_wifi_err_t ConfigureRoaming(bool enable_11k, bool enable_11r, bool enable_11v);
 
  hf_wifi_err_t ConfigureEnterprise(const std::string& username, const std::string& password,
                                    const std::string& ca_cert = "",
                                    const std::string& client_cert = "",
                                    const std::string& client_key = "");
 
  hf_wifi_err_t StartSmartConfig(smartconfig_type_t type = SC_TYPE_ESPTOUCH,
                                 uint32_t timeout_ms = 60000);
 
  hf_wifi_err_t StopSmartConfig();
 
  // WPS not available on ESP32-C6
  // /**
  //  * @brief Start WPS provisioning
  //  * @param type WPS type
  //  * @param timeout_ms Provisioning timeout in milliseconds
  //  * @return hf_wifi_err_t::WIFI_SUCCESS on success, error code otherwise
  //  */
  // hf_wifi_err_t StartWps(wps_type_t type = WPS_TYPE_PBC, uint32_t timeout_ms = 120000);
 
  // /**
  //  * @brief Stop WPS provisioning
  //  * @return hf_wifi_err_t::WIFI_SUCCESS on success, error code otherwise
  //  */
  // hf_wifi_err_t StopWps();
 
  hf_wifi_err_t InitMesh(const uint8_t mesh_id[6], uint8_t max_layer = 6,
                         uint16_t max_connection = 10);
 
  hf_wifi_err_t StartMeshRoot();
 
  hf_wifi_err_t StartMeshChild();
 
  hf_wifi_err_t StopMesh();
 
  hf_wifi_err_t GetStatistics(wifi_pkt_rx_ctrl_t& stats) const;
 
  hf_wifi_err_t SetTxPower(uint8_t power);
 
  int8_t GetTxPower() const;
 
  hf_wifi_err_t SetBandwidth(wifi_bandwidth_t bandwidth);
 
  wifi_bandwidth_t GetBandwidth() const;
 
  hf_wifi_err_t PerformCalibration();
 
  hf_wifi_err_t GetConnectionInfo(wifi_ap_record_t& info) const;
 
private:
  // ========== Internal State Management ==========
 
  mutable PlatformMutex m_mutex;            
  std::atomic<bool> m_initialized;      
  std::atomic<bool> m_enabled;          
  std::atomic<hf_wifi_mode_t> m_mode;   
  std::atomic<hf_wifi_state_t> m_state; 
  // Configuration storage
  hf_wifi_station_config_t m_sta_config;   
  hf_wifi_ap_config_t m_ap_config;         
  EspWifiAdvancedConfig m_advanced_config; 
  // ESP-IDF handles
  esp_netif_t* m_sta_netif;                          
  esp_netif_t* m_ap_netif;                           
  EventGroupHandle_t m_event_group;                  
  esp_event_handler_instance_t m_wifi_event_handler; 
  esp_event_handler_instance_t m_ip_event_handler;   
  // Event handling
  hf_wifi_event_callback_t m_event_callback;                   
  hf_wifi_scan_callback_t m_scan_callback;                     
  void* m_event_user_data;                                     
  void* m_scan_user_data;                                      
  std::queue<std::pair<hf_wifi_event_t, void*>> m_event_queue; 
  mutable PlatformMutex m_event_mutex;                             
  // Scan results
  std::vector<hf_wifi_network_info_t> m_scan_results; 
  std::atomic<bool> m_scanning;                       
  mutable PlatformMutex m_scan_mutex;                     
  // Connection state
  std::atomic<bool> m_connected;  
  std::atomic<bool> m_ap_active;  
  std::atomic<int8_t> m_rssi;     
  std::atomic<uint8_t> m_channel; 
  // Advanced features state
  std::atomic<bool> m_smartconfig_active; 
  // std::atomic<bool> m_wps_active;         /**< WPS active */
  std::atomic<bool> m_mesh_active; 
  // ========== Internal Helper Methods ==========
 
  hf_wifi_err_t InitNetif();
 
  hf_wifi_err_t DeinitNetif();
 
  hf_wifi_err_t RegisterEventHandlers();
 
  hf_wifi_err_t UnregisterEventHandlers();
 
  wifi_mode_t ConvertToEspMode(hf_wifi_mode_t mode) const;
 
  hf_wifi_mode_t ConvertFromEspMode(wifi_mode_t mode) const;
 
  wifi_auth_mode_t ConvertToEspAuthMode(hf_wifi_security_t security) const;
 
  hf_wifi_security_t ConvertFromEspAuthMode(wifi_auth_mode_t auth_mode) const;
 
  hf_wifi_err_t ConvertEspError(esp_err_t esp_err) const;
 
  static void wifiEventHandler(void* arg, esp_event_base_t event_base, int32_t event_id,
                               void* event_data);
 
  static void ipEventHandler(void* arg, esp_event_base_t event_base, int32_t event_id,
                             void* event_data);
 
  static void smartconfigEventHandler(void* arg, esp_event_base_t event_base, int32_t event_id,
                                      void* event_data);
 
  void handleWifiEvent(int32_t event_id, void* event_data);
 
  void handleIpEvent(int32_t event_id, void* event_data);
 
  void handleSmartconfigEvent(int32_t event_id, void* event_data);
 
  void NotifyEventCallback(hf_wifi_event_t event, void* event_data);
 
  void UpdateState(hf_wifi_state_t new_state);
 
  hf_wifi_err_t ApplyAdvancedConfig();
 
  bool ValidateConfig(const hf_wifi_station_config_t& config) const;
 
  bool ValidateApConfig(const hf_wifi_ap_config_t& config) const;
 
  // Prevent copying
  EspWifi(const EspWifi&) = delete;
  EspWifi& operator=(const EspWifi&) = delete;
};