wifi_provisioner.cpp

Go to the documentation of this file.

#include "sensesp.h"
 
#include "wifi_provisioner.h"
 
#include <esp_wifi.h>
 
#include "sensesp_app.h"
 
namespace sensesp {
 
// Wifi config portal timeout (seconds). The smaller the value, the faster
// the device will attempt to reconnect. If set too small, it might
// become impossible to actually configure the Wifi settings in the captive
// portal.
#ifndef WIFI_CONFIG_PORTAL_TIMEOUT
#define WIFI_CONFIG_PORTAL_TIMEOUT 180
#endif
 
// Network configuration logic:
// 1. Use hard-coded hostname and WiFi credentials by default
// 2. If the hostname or credentials have been changed in WiFiManager or
//    the web UI, use the updated values.
// 3. If the hard-coded hostname is changed, use that instead of the saved one.
//    (But keep using the saved WiFi credentials!)
 
WiFiProvisioner::WiFiProvisioner(const String& config_path,
                                 const String& client_ssid,
                                 const String& client_password,
                                 const String& ap_ssid,
                                 const String& ap_password)
    : FileSystemSaveable{config_path}, Resettable(0) {
  bool config_loaded = load();
 
  if (!config_loaded) {
    if (ap_ssid != "" && ap_password != "") {
      this->ap_settings_.enabled_ = true;
      this->ap_settings_.ssid_ = ap_ssid;
      this->ap_settings_.password_ = ap_password;
    } else {
      this->ap_settings_.enabled_ = false;
    }
  }
 
  if (!config_loaded && client_ssid != "" && client_password != "") {
    ClientSSIDConfig preset_client_config = {client_ssid, client_password,
                                             true};
    client_settings_.push_back(preset_client_config);
    client_enabled_ = true;
  }
 
  init_wifi();
}
 
WiFiProvisioner::WiFiProvisioner(
    const String& config_path,
    const std::vector<ClientSSIDConfig>& client_configs, const String& ap_ssid,
    const String& ap_password)
    : FileSystemSaveable{config_path}, Resettable(0) {
  bool config_loaded = load();
 
  if (!config_loaded) {
    if (ap_ssid != "" && ap_password != "") {
      this->ap_settings_.enabled_ = true;
      this->ap_settings_.ssid_ = ap_ssid;
      this->ap_settings_.password_ = ap_password;
    } else {
      this->ap_settings_.enabled_ = false;
    }
  }
 
  if (!config_loaded) {
    // Seed the preset client list, skipping incomplete entries and honoring
    // the kMaxNumClientConfigs cap.
    for (const ClientSSIDConfig& config : client_configs) {
      if (client_settings_.size() >= kMaxNumClientConfigs) {
        break;
      }
      if (config.ssid_ == "" || config.password_ == "") {
        continue;
      }
      client_settings_.push_back(config);
    }
    client_enabled_ = !client_settings_.empty();
  }
 
  init_wifi();
}
 
void WiFiProvisioner::init_wifi() {
  // Fill in the rest of the client settings array with empty configs
  int num_fill = kMaxNumClientConfigs - client_settings_.size();
  for (int i = 0; i < num_fill; i++) {
    client_settings_.push_back(ClientSSIDConfig());
  }
 
  ESP_LOGD(__FILENAME__, "Enabling WiFi provisioner");
 
  // Hate to do this, but Raspberry Pi AP setup is going to be much more
  // complicated with enforced WPA2. BAD Raspberry Pi! BAD!
  WiFi.setMinSecurity(WIFI_AUTH_WPA_PSK);
 
  // Try setting hostname already here.
  String hostname = SensESPBaseApp::get_hostname();
  WiFi.setHostname(hostname.c_str());
 
  // Start WiFi with a bogus SSID to initialize the network stack but
  // don't connect to any network.
  WiFi.begin("0", "0", 0, nullptr, false);
 
  // If both saved AP settings and saved client settings
  // are available, start in STA+AP mode.
 
  if (this->ap_settings_.enabled_ && this->client_enabled_ == true) {
    WiFi.mode(WIFI_AP_STA);
    start_access_point();
    start_client_autoconnect();
  }
 
  // If saved AP settings are available, use them.
 
  else if (this->ap_settings_.enabled_) {
    WiFi.mode(WIFI_AP);
    start_access_point();
  }
 
  // If saved client settings are available, use them.
 
  else if (this->client_enabled_) {
    WiFi.mode(WIFI_STA);
    start_client_autoconnect();
  }
 
  if (this->ap_settings_.enabled_ &&
      this->ap_settings_.captive_portal_enabled_) {
    dns_server_ = std::unique_ptr<DNSServer>(new DNSServer());
 
    dns_server_->setErrorReplyCode(DNSReplyCode::NoError);
    dns_server_->start(53, "*", WiFi.softAPIP());
 
    event_loop()->onRepeat(1, [this]() { dns_server_->processNextRequest(); });
  }
}
 
WiFiProvisioner::~WiFiProvisioner() {
  if (dns_server_) {
    dns_server_->stop();
  }
 
  // Stop WiFi
  WiFi.disconnect(true);
}
 
void WiFiProvisioner::start_access_point() {
  String hostname = SensESPBaseApp::get_hostname();
  WiFi.setHostname(hostname.c_str());
 
  ESP_LOGI(__FILENAME__, "Starting access point %s",
           ap_settings_.ssid_.c_str());
 
  bool result =
      WiFi.softAP(ap_settings_.ssid_.c_str(), ap_settings_.password_.c_str(),
                  ap_settings_.channel_, ap_settings_.hidden_);
 
  if (!result) {
    ESP_LOGE(__FILENAME__, "Failed to start access point.");
    return;
  }
}
 
void WiFiProvisioner::start_client_autoconnect() {
  String hostname = SensESPBaseApp::get_hostname();
  WiFi.setHostname(hostname.c_str());
 
  // set up WiFi in regular STA (client) mode
  auto reconnect_cb = [this]() {
    static uint32_t attempt_num = 0;
    static uint32_t current_config_idx = 0;
    static int last_applied_idx = -1;
 
    int num_configs = client_settings_.size();
 
    if (WiFi.status() == WL_CONNECTED) {
      attempt_num = 0;
      current_config_idx = 0;
      return;
    }
 
    // First check if any of the client settings are defined
    if (num_configs == 0) {
      ESP_LOGW(__FILENAME__,
               "No client settings defined. Leaving WiFi client disconnected.");
      return;
    }
 
    uint32_t prev_config_idx = current_config_idx;
 
    ClientSSIDConfig config;
 
    // Get next valid client config
    for (current_config_idx = current_config_idx;
         current_config_idx < prev_config_idx + num_configs;
         current_config_idx++) {
      config = client_settings_[current_config_idx % num_configs];
      if (config.ssid_ != "" && config.password_ != "") {
        break;
      }
    }
 
    ESP_LOGD(__FILENAME__, "Current client config index: %d",
             current_config_idx);
    ESP_LOGD(__FILENAME__, "Attempt number: %d", attempt_num);
    ESP_LOGD(__FILENAME__, "Config SSID: %s", config.ssid_.c_str());
 
    // If no valid client config found, leave WiFi client disconnected
    if (config.ssid_ == "" || config.password_ == "") {
      ESP_LOGW(
          __FILENAME__,
          "No valid client settings found. Leaving WiFi client disconnected.");
      return;
    }
 
    ESP_LOGI(__FILENAME__,
             "Connecting to wifi SSID %s (connection attempt #%d).",
             config.ssid_.c_str(), attempt_num);
 
    if (!config.use_dhcp_) {
      ESP_LOGI(__FILENAME__, "Using static IP address: %s",
               config.ip_.toString().c_str());
      // Arduino-ESP32 signature:
      //   WiFi.config(local_ip, gateway, subnet, dns1, dns2).
      // The pre-refactor code passed (ip, dns, gateway, netmask) which
      // silently set gateway=dns, subnet=gateway and dns1=netmask — a
      // long-standing bug that broke every saved static-IP config.
      WiFi.config(config.ip_, config.gateway_, config.netmask_,
                  config.dns_server_);
    }
    // The ESP32 STA rejects a new config (ESP_ERR_WIFI_STATE, "sta is
    // connecting, cannot set config") while it is still connecting or
    // auto-reconnecting to the previous SSID, so switching networks needs the
    // in-progress attempt dropped first. Only disconnect when the target config
    // actually changes; re-applying the same config (a single network, or a
    // list with one valid slot) must leave a slow association running rather
    // than restart it every cycle.
    int applied_idx = static_cast<int>(current_config_idx % num_configs);
    if (applied_idx != last_applied_idx) {
      WiFi.disconnect(false);
    }
    WiFi.begin(config.ssid_.c_str(), config.password_.c_str());
    last_applied_idx = applied_idx;
    attempt_num++;
    current_config_idx++;  // Move to the next config for the next attempt
  };
 
  // Perform an initial connection without a delay.
  reconnect_cb();
 
  // Launch a separate onRepeat event to (re-)establish WiFi connection.
  // Attempts are spaced 20 s apart: when staying on the same network this lets
  // a slow association finish; when failing over it bounds how long a missing
  // network is tried before the next configured AP.
  event_loop()->onRepeat(20000, reconnect_cb);
}
 
bool WiFiProvisioner::to_json(JsonObject& root) {
  JsonObject apSettingsJson = root["apSettings"].to<JsonObject>();
  ap_settings_.as_json(apSettingsJson);
 
  JsonObject clientSettingsJson = root["clientSettings"].to<JsonObject>();
  clientSettingsJson["enabled"] = client_enabled_;
  JsonArray clientConfigsJson = clientSettingsJson["settings"].to<JsonArray>();
  int num_serialized = 0;
  for (auto& config : client_settings_) {
    if (num_serialized++ >= kMaxNumClientConfigs) {
      break;
    }
    JsonObject clientConfigJson = clientConfigsJson.add<JsonObject>();
    config.as_json(clientConfigJson);
  }
  return true;
}
 
bool WiFiProvisioner::from_json(const JsonObject& config) {
  if (config["hostname"].is<String>()) {
    // deal with the legacy Json format
    String hostname = config["hostname"].as<String>();
    SensESPBaseApp::get()->get_hostname_observable()->set(hostname);
 
    if (config["ssid"].is<String>()) {
      String ssid = config["ssid"].as<String>();
      String password = config["password"].as<String>();
 
      if (config["ap_mode"].is<String>()) {
        if (config["ap_mode"].as<String>() == "Access Point" ||
            config["ap_mode"].as<String>() == "Hotspot") {
          ap_settings_ = {true, ssid, password};
        } else {
          ClientSSIDConfig client_settings = {ssid, password};
          client_settings_.clear();
          client_settings_.push_back(client_settings);
          client_enabled_ = true;
        }
      }
    }
  } else {
    // Either an empty config or a new-style config
    if (config["apSettings"].is<JsonVariant>()) {
      ap_settings_ = AccessPointSettings::from_json(config["apSettings"]);
    } else {
      ap_settings_ = AccessPointSettings(true);
    }
    if (config["clientSettings"].is<JsonVariant>()) {
      const JsonObject& client_settings_json = config["clientSettings"];
      client_enabled_ = client_settings_json["enabled"] | false;
      client_settings_.clear();
      const JsonArray& client_settings_json_array =
          client_settings_json["settings"];
      for (const JsonObject& cfg_json : client_settings_json_array) {
        client_settings_.push_back(ClientSSIDConfig::from_json(cfg_json));
      }
      if (client_settings_.size() == 0) {
        client_enabled_ = false;
      }
    }
  }
  // Fill in the rest of the client settings array with empty configs
  while (client_settings_.size() < kMaxNumClientConfigs) {
    client_settings_.push_back(ClientSSIDConfig());
  }
 
  return true;
}
 
void WiFiProvisioner::reset() {
  ESP_LOGI(__FILENAME__, "Resetting WiFi SSID settings");
 
  clear();
  WiFi.disconnect(true);
  // On ESP32, disconnect does not erase previous credentials. Let's connect
  // to a bogus network instead
  WiFi.begin("0", "0", 0, nullptr, false);
}
 
void WiFiProvisioner::start_wifi_scan() {
  // Scan fails if WiFi is connecting. Disconnect to allow scanning.
  if (WiFi.status() != WL_CONNECTED) {
    ESP_LOGD(__FILENAME__,
             "WiFi is not connected. Disconnecting to allow scanning.");
    WiFi.disconnect();
  }
  ESP_LOGI(__FILENAME__, "Starting WiFi network scan");
  int result = WiFi.scanNetworks(true);
  if (result == WIFI_SCAN_FAILED) {
    ESP_LOGE(__FILENAME__, "WiFi scan failed to start");
  }
}
 
int16_t WiFiProvisioner::get_wifi_scan_results(
    std::vector<WiFiNetworkInfo>& ssid_list) {
  int num_networks = WiFi.scanComplete();
  if (num_networks == WIFI_SCAN_RUNNING) {
    return WIFI_SCAN_RUNNING;
  }
  if (num_networks == WIFI_SCAN_FAILED) {
    return WIFI_SCAN_FAILED;
  }
  ssid_list.clear();
  for (int i = 0; i < num_networks; i++) {
    WiFiNetworkInfo info(WiFi.SSID(i), WiFi.RSSI(i), WiFi.encryptionType(i),
                         WiFi.BSSID(i), WiFi.channel(i));
    ssid_list.push_back(info);
  }
 
  return num_networks;
}
 
}  // namespace sensesp