EspTypes_WiFi.h

Go to the documentation of this file.

 
#pragma once
 
#include "EspTypes_Base.h"
 
#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"
#include "esp_wifi_types.h"
// WPS not available on ESP32-C6
// #include "esp_wps.h"
#include "lwip/ip_addr.h"
 
#ifdef __cplusplus
}
#endif
 
//==============================================================================
// ESP32 WIFI CONSTANTS
//==============================================================================
 
static constexpr size_t HF_ESP_WIFI_SSID_MAX_LEN = 32;
 
static constexpr size_t HF_ESP_WIFI_PASSWORD_MAX_LEN = 64;
 
static constexpr uint16_t HF_ESP_WIFI_SCAN_MAX_RESULTS = 20;
 
static constexpr hf_timeout_ms_t HF_ESP_WIFI_CONNECT_TIMEOUT_DEFAULT = 10000;
 
static constexpr hf_timeout_ms_t HF_ESP_WIFI_SCAN_TIMEOUT_DEFAULT = 5000;
 
static constexpr uint16_t HF_ESP_WIFI_BEACON_INTERVAL_DEFAULT = 100;
 
static constexpr uint8_t HF_ESP_WIFI_MAX_CONNECTIONS_DEFAULT = 4;
 
static constexpr uint8_t HF_ESP_WIFI_CHANNEL_MIN = 1;
static constexpr uint8_t HF_ESP_WIFI_CHANNEL_MAX = 14;
 
static constexpr uint8_t HF_ESP_WIFI_TX_POWER_MIN = 0;
static constexpr uint8_t HF_ESP_WIFI_TX_POWER_MAX = 20;
 
//==============================================================================
// ESP32 WIFI TYPE MAPPINGS
//==============================================================================
 
enum class hf_esp_wifi_auth_mode_t : uint8_t {
  OPEN = WIFI_AUTH_OPEN,                       
  WEP = WIFI_AUTH_WEP,                         
  WPA_PSK = WIFI_AUTH_WPA_PSK,                 
  WPA2_PSK = WIFI_AUTH_WPA2_PSK,               
  WPA_WPA2_PSK = WIFI_AUTH_WPA_WPA2_PSK,       
  WPA2_ENTERPRISE = WIFI_AUTH_WPA2_ENTERPRISE, 
  WPA3_PSK = WIFI_AUTH_WPA3_PSK,               
  WPA2_WPA3_PSK = WIFI_AUTH_WPA2_WPA3_PSK,     
  WAPI_PSK = WIFI_AUTH_WAPI_PSK                
};
 
enum class hf_esp_wifi_mode_t : uint8_t {
  NULL_MODE = WIFI_MODE_NULL, 
  STA = WIFI_MODE_STA,        
  AP = WIFI_MODE_AP,          
  APSTA = WIFI_MODE_APSTA     
};
 
enum class hf_esp_wifi_power_save_t : uint8_t {
  NONE = WIFI_PS_NONE,           
  MIN_MODEM = WIFI_PS_MIN_MODEM, 
  MAX_MODEM = WIFI_PS_MAX_MODEM  
};
 
enum class hf_esp_wifi_bandwidth_t : uint8_t {
  HT20 = WIFI_BW_HT20, 
  HT40 = WIFI_BW_HT40  
};
 
enum class hf_esp_wifi_sort_method_t : uint8_t {
  SIGNAL = WIFI_CONNECT_AP_BY_SIGNAL,    
  SECURITY = WIFI_CONNECT_AP_BY_SECURITY 
};
 
enum class hf_esp_wifi_scan_method_t : uint8_t {
  FAST = WIFI_FAST_SCAN,              
  ALL_CHANNEL = WIFI_ALL_CHANNEL_SCAN 
};
 
//==============================================================================
// ESP32 WIFI STRUCTURES
//==============================================================================
 
struct HfEspWifiStats {
  uint32_t tx_packets;         
  uint32_t rx_packets;         
  uint32_t tx_bytes;           
  uint32_t rx_bytes;           
  uint32_t tx_errors;          
  uint32_t rx_errors;          
  uint32_t tx_retries;         
  uint32_t rx_missed;          
  int8_t noise_floor;          
  uint8_t channel_utilization; 
};
 
struct HfEspWifiCalibration {
  bool rf_cal_valid;         
  bool phy_cal_valid;        
  uint32_t rf_cal_data[32];  
  uint32_t phy_cal_data[16]; 
};
 
struct HfEspWifiPerformanceConfig {
  bool enable_ampdu_rx; 
  bool enable_ampdu_tx; 
  uint8_t ampdu_rx_num; 
  uint8_t ampdu_tx_num; 
  bool enable_amsdu;    
  uint16_t rx_ba_win;   
  uint16_t tx_ba_win;   
  bool enable_csi;      
  bool enable_ftm;      
};
 
//==============================================================================
// ESP32 WIFI UTILITY FUNCTIONS
//==============================================================================
 
#ifdef __cplusplus
 
inline wifi_auth_mode_t hfWifiSecurityToEspAuthMode(hf_wifi_security_t security) {
  switch (security) {
  case hf_wifi_security_t::HF_WIFI_SECURITY_OPEN:
    return WIFI_AUTH_OPEN;
  case hf_wifi_security_t::HF_WIFI_SECURITY_WEP:
    return WIFI_AUTH_WEP;
  case hf_wifi_security_t::HF_WIFI_SECURITY_WPA_PSK:
    return WIFI_AUTH_WPA_PSK;
  case hf_wifi_security_t::HF_WIFI_SECURITY_WPA2_PSK:
    return WIFI_AUTH_WPA2_PSK;
  case hf_wifi_security_t::HF_WIFI_SECURITY_WPA_WPA2_PSK:
    return WIFI_AUTH_WPA_WPA2_PSK;
  case hf_wifi_security_t::HF_WIFI_SECURITY_WPA2_ENTERPRISE:
    return WIFI_AUTH_WPA2_ENTERPRISE;
  case hf_wifi_security_t::HF_WIFI_SECURITY_WPA3_PSK:
    return WIFI_AUTH_WPA3_PSK;
  case hf_wifi_security_t::HF_WIFI_SECURITY_WPA2_WPA3_PSK:
    return WIFI_AUTH_WPA2_WPA3_PSK;
  case hf_wifi_security_t::HF_WIFI_SECURITY_WAPI_PSK:
    return WIFI_AUTH_WAPI_PSK;
  default:
    return WIFI_AUTH_OPEN;
  }
}
 
inline hf_wifi_security_t espAuthModeTohf_wifi_security_t(wifi_auth_mode_t auth_mode) {
  switch (auth_mode) {
  case WIFI_AUTH_OPEN:
    return hf_wifi_security_t::HF_WIFI_SECURITY_OPEN;
  case WIFI_AUTH_WEP:
    return hf_wifi_security_t::HF_WIFI_SECURITY_WEP;
  case WIFI_AUTH_WPA_PSK:
    return hf_wifi_security_t::HF_WIFI_SECURITY_WPA_PSK;
  case WIFI_AUTH_WPA2_PSK:
    return hf_wifi_security_t::HF_WIFI_SECURITY_WPA2_PSK;
  case WIFI_AUTH_WPA_WPA2_PSK:
    return hf_wifi_security_t::HF_WIFI_SECURITY_WPA_WPA2_PSK;
  case WIFI_AUTH_WPA2_ENTERPRISE:
    return hf_wifi_security_t::HF_WIFI_SECURITY_WPA2_ENTERPRISE;
  case WIFI_AUTH_WPA3_PSK:
    return hf_wifi_security_t::HF_WIFI_SECURITY_WPA3_PSK;
  case WIFI_AUTH_WPA2_WPA3_PSK:
    return hf_wifi_security_t::HF_WIFI_SECURITY_WPA2_WPA3_PSK;
  case WIFI_AUTH_WAPI_PSK:
    return hf_wifi_security_t::HF_WIFI_SECURITY_WAPI_PSK;
  default:
    return hf_wifi_security_t::HF_WIFI_SECURITY_OPEN;
  }
}
 
inline wifi_mode_t hfWifiModeToEspMode(hf_wifi_mode_t mode) {
  switch (mode) {
  case hf_wifi_mode_t::HF_WIFI_MODE_STATION:
    return WIFI_MODE_STA;
  case hf_wifi_mode_t::HF_WIFI_MODE_ACCESS_POINT:
    return WIFI_MODE_AP;
  case hf_wifi_mode_t::HF_WIFI_MODE_STATION_AP:
    return WIFI_MODE_APSTA;
  case hf_wifi_mode_t::HF_WIFI_MODE_DISABLED:
    return WIFI_MODE_NULL;
  default:
    return WIFI_MODE_NULL;
  }
}
 
inline hf_wifi_mode_t espModeTohf_wifi_mode_t(wifi_mode_t mode) {
  switch (mode) {
  case WIFI_MODE_STA:
    return hf_wifi_mode_t::HF_WIFI_MODE_STATION;
  case WIFI_MODE_AP:
    return hf_wifi_mode_t::HF_WIFI_MODE_ACCESS_POINT;
  case WIFI_MODE_APSTA:
    return hf_wifi_mode_t::HF_WIFI_MODE_STATION_AP;
  case WIFI_MODE_NULL:
    return hf_wifi_mode_t::HF_WIFI_MODE_DISABLED;
  default:
    return hf_wifi_mode_t::HF_WIFI_MODE_DISABLED;
  }
}
 
inline wifi_ps_type_t hfWifiPowerSaveToEspPowerSave(hf_wifi_power_save_t power_save) {
  switch (power_save) {
  case hf_wifi_power_save_t::HF_WIFI_POWER_SAVE_NONE:
    return WIFI_PS_NONE;
  case hf_wifi_power_save_t::HF_WIFI_POWER_SAVE_MIN_MODEM:
    return WIFI_PS_MIN_MODEM;
  case hf_wifi_power_save_t::HF_WIFI_POWER_SAVE_MAX_MODEM:
    return WIFI_PS_MAX_MODEM;
  default:
    return WIFI_PS_NONE;
  }
}
 
inline hf_wifi_power_save_t espPowerSaveTohf_wifi_power_save_t(wifi_ps_type_t power_save) {
  switch (power_save) {
  case WIFI_PS_NONE:
    return hf_wifi_power_save_t::HF_WIFI_POWER_SAVE_NONE;
  case WIFI_PS_MIN_MODEM:
    return hf_wifi_power_save_t::HF_WIFI_POWER_SAVE_MIN_MODEM;
  case WIFI_PS_MAX_MODEM:
    return hf_wifi_power_save_t::HF_WIFI_POWER_SAVE_MAX_MODEM;
  default:
    return hf_wifi_power_save_t::HF_WIFI_POWER_SAVE_NONE;
  }
}
 
inline hf_wifi_err_t espErrorToHfWifiError(esp_err_t esp_err) {
  switch (esp_err) {
  case ESP_OK:
    return hf_wifi_err_t::WIFI_SUCCESS;
  case ESP_ERR_INVALID_ARG:
    return hf_wifi_err_t::WIFI_ERR_INVALID_PARAM;
  case ESP_ERR_INVALID_STATE:
    return hf_wifi_err_t::WIFI_ERR_FAILURE;
  case ESP_ERR_NO_MEM:
    return hf_wifi_err_t::WIFI_ERR_NO_MEMORY;
  case ESP_ERR_TIMEOUT:
    return hf_wifi_err_t::WIFI_ERR_TIMEOUT;
  case ESP_ERR_WIFI_NOT_INIT:
    return hf_wifi_err_t::WIFI_ERR_NOT_INITIALIZED;
  case ESP_ERR_WIFI_NOT_STARTED:
    return hf_wifi_err_t::WIFI_ERR_NOT_INITIALIZED;
  case ESP_ERR_WIFI_CONN:
    return hf_wifi_err_t::WIFI_ERR_CONNECTION_FAILED;
  case ESP_ERR_WIFI_SSID:
    return hf_wifi_err_t::WIFI_ERR_INVALID_SSID;
  case ESP_ERR_WIFI_PASSWORD:
    return hf_wifi_err_t::WIFI_ERR_INVALID_PASSWORD;
  case ESP_ERR_WIFI_TIMEOUT:
    return hf_wifi_err_t::WIFI_ERR_TIMEOUT;
  case ESP_ERR_WIFI_WAKE_FAIL:
    return hf_wifi_err_t::WIFI_ERR_FAILURE;
  case ESP_ERR_WIFI_WOULD_BLOCK:
    return hf_wifi_err_t::WIFI_ERR_TIMEOUT;
  default:
    return hf_wifi_err_t::WIFI_ERR_FAILURE;
  }
}
 
inline uint32_t lwipIpToUint32(const ip4_addr_t& ip_addr) {
  return ip_addr.addr;
}
 
inline ip4_addr_t uint32ToLwipIp(uint32_t ip_uint32) {
  ip4_addr_t ip_addr;
  ip_addr.addr = ip_uint32;
  return ip_addr;
}
 
inline bool isValidWifiChannel(uint8_t channel) {
  return (channel >= HF_ESP_WIFI_CHANNEL_MIN && channel <= HF_ESP_WIFI_CHANNEL_MAX);
}
 
inline bool isValidWifiTxPower(uint8_t tx_power) {
  return (tx_power >= HF_ESP_WIFI_TX_POWER_MIN && tx_power <= HF_ESP_WIFI_TX_POWER_MAX);
}
 
inline bool isValidSsid(const std::string& ssid) {
  return (!ssid.empty() && ssid.length() <= HF_ESP_WIFI_SSID_MAX_LEN);
}
 
inline bool isValidWifiPassword(const std::string& password, hf_wifi_security_t security) {
  if (security == hf_wifi_security_t::HF_WIFI_SECURITY_OPEN) {
    return password.empty();
  }
 
  if (security == hf_wifi_security_t::HF_WIFI_SECURITY_WEP) {
    // WEP key length constants
    static constexpr size_t WEP_KEY_64_BIT_ASCII = 5;   // 64-bit WEP ASCII key
    static constexpr size_t WEP_KEY_128_BIT_ASCII = 13; // 128-bit WEP ASCII key
    static constexpr size_t WEP_KEY_128_BIT_HEX = 16;   // 128-bit WEP hexadecimal key
    static constexpr size_t WEP_KEY_152_BIT_ASCII = 29; // 152-bit WEP ASCII key
 
    size_t len = password.length();
    return (len == WEP_KEY_64_BIT_ASCII || len == WEP_KEY_128_BIT_ASCII ||
            len == WEP_KEY_128_BIT_HEX || len == WEP_KEY_152_BIT_ASCII);
  }
 
  // WPA/WPA2/WPA3 passwords must be 8-63 characters
  return (password.length() >= 8 && password.length() <= 63);
}
 
inline void espScanRecordToHfNetworkInfo(const wifi_ap_record_t& scan_record,
                                         hf_wifi_network_info_t& network_info) {
  network_info.ssid = std::string(reinterpret_cast<const char*>(scan_record.ssid));
  std::memcpy(network_info.bssid, scan_record.bssid, 6);
  network_info.security = espAuthModeTohf_wifi_security_t(scan_record.authmode);
  network_info.rssi = scan_record.rssi;
  network_info.channel = scan_record.primary;
  network_info.hidden = (network_info.ssid.empty());
}
 
inline void hfStationConfigToEspConfig(const hf_wifi_station_config_t& hf_config,
                                       wifi_sta_config_t& esp_config) {
  std::memset(&esp_config, 0, sizeof(esp_config));
 
  // Copy SSID
  std::strncpy(reinterpret_cast<char*>(esp_config.ssid), hf_config.ssid.c_str(),
               sizeof(esp_config.ssid) - 1);
 
  // Copy password
  std::strncpy(reinterpret_cast<char*>(esp_config.password), hf_config.password.c_str(),
               sizeof(esp_config.password) - 1);
 
  // Copy BSSID if set
  if (hf_config.bssid_set) {
    std::memcpy(esp_config.bssid, hf_config.bssid, 6);
    esp_config.bssid_set = true;
  }
 
  // Set channel
  esp_config.channel = hf_config.channel;
 
  // Set scan method
  esp_config.scan_method = static_cast<wifi_scan_method_t>(hf_config.scan_method);
 
  // Set sort method
  esp_config.sort_method = static_cast<wifi_sort_method_t>(hf_config.sort_method);
 
  // Set thresholds
  esp_config.threshold.rssi = hf_config.threshold_rssi;
  esp_config.threshold.authmode = hfWifiSecurityToEspAuthMode(hf_config.threshold_authmode);
}
 
inline void hfApConfigToEspConfig(const hf_wifi_ap_config_t& hf_config,
                                  wifi_ap_config_t& esp_config) {
  std::memset(&esp_config, 0, sizeof(esp_config));
 
  // Copy SSID
  std::strncpy(reinterpret_cast<char*>(esp_config.ssid), hf_config.ssid.c_str(),
               sizeof(esp_config.ssid) - 1);
  esp_config.ssid_len = hf_config.ssid_len;
 
  // Copy password
  std::strncpy(reinterpret_cast<char*>(esp_config.password), hf_config.password.c_str(),
               sizeof(esp_config.password) - 1);
 
  // Set other parameters
  esp_config.channel = hf_config.channel;
  esp_config.authmode = hfWifiSecurityToEspAuthMode(hf_config.authmode);
  esp_config.ssid_hidden = hf_config.ssid_hidden;
  esp_config.max_connection = hf_config.max_connection;
  esp_config.beacon_interval = hf_config.beacon_interval;
}
 
#endif // __cplusplus