[wifi] Add "blind_connect" and "bulk_connect" to avoid a network scan and speedup connection/reduce energy footprint

[dewi-ny-je]

Component name

wifi

Link to component documentation on our website

https://esphome.io/components/wifi

Describe the enhancement

Disclaimer Analysis and proposal down below obtained with thelp of Gemini 2.5 Pro and chatGPT o3.

Previous discussion in esphome/esphome#9947

Currently, when fast_connect is not enabled, ESPHome will perform a full Wi-Fi scan before attempting to connect to any of the known networks (single or multiple, depending on settings).

Start Connection: The process begins in the WiFiComponent::start() function. After some initial setup, it checks if fast_connect_ is enabled.

Initiate Scan: Since fast_connect_ is false, the code proceeds to the else block, which immediately calls this->start_scanning(). This function initiates a scan for all available Wi-Fi networks in the vicinity.

Process Scan Results: Once the scan is complete, the check_scanning_finished() function is executed. This function does the following:

It iterates through all the networks discovered during the scan.

It compares each discovered network against the list of networks provided in the configuration to find matches.

The matching networks are then sorted. The primary sorting criterion is the network's priority (if set), and the secondary criterion is the signal strength (RSSI). The network with the highest priority and/or best signal is placed at the top of the list.

Attempt Connection: The device then attempts to connect to the best-matching network from the sorted scan results. It uses the specific details from the scan (like the BSSID and channel) combined with the credentials (like the password) from your configuration.

I tested it personally and I can confirm it takes a long time to connect to one of the known network, even if I know for sure they are available. This adds a significant delay in connection time.

I asked chatgpt o4-mini-high for:

I upload three files related to the wifi component of ESPhome. Can you modify them by introducing a new option "blind_connect" according to which, when fast_connect is not enabled, the networks provided are tested in sequence, with a configurable delay in milliseconds configured by "blind_connect_delay", to determine the lack of response?

Also add a third option "bulk_connect" which does not perform a full scan, but sends a connection packet to all provided preconfigured networks at the same time, picking the first one to reply to complete the connection process.

and I got:

init.py:

@@ top of file, after existing CONF_* imports add:
+CONF_BLIND_CONNECT      = "blind_connect"
+CONF_BLIND_CONNECT_DELAY = "blind_connect_delay"
+CONF_BULK_CONNECT       = "bulk_connect"
@@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_FAST_CONNECT, default=False): cv.boolean,
+            cv.Optional(CONF_BLIND_CONNECT, default=False): cv.boolean,
+            cv.Optional(CONF_BLIND_CONNECT_DELAY, default="5000ms"): cv.positive_time_period_milliseconds,
+            cv.Optional(CONF_BULK_CONNECT, default=False): cv.boolean,
             cv.Optional(CONF_USE_ADDRESS): cv.string_strict,
             ...
         }
@@ def to_code(config):
     cg.add(var.set_passive_scan(config[CONF_PASSIVE_SCAN]))
+    cg.add(var.set_blind_connect(config[CONF_BLIND_CONNECT]))
+    cg.add(var.set_blind_connect_delay(config[CONF_BLIND_CONNECT_DELAY]))
+    cg.add(var.set_bulk_connect(config[CONF_BULK_CONNECT]))
     if CONF_OUTPUT_POWER in config:
         cg.add(var.set_output_power(config[CONF_OUTPUT_POWER]))

wifi_component.h:

@@ class WiFiComponent : public Component {
   public:
     // ... existing public API ...
     void set_fast_connect(bool fast_connect);
+    void set_blind_connect(bool blind);
+    void set_blind_connect_delay(uint32_t ms);
+    void set_bulk_connect(bool bulk);
@@ protected:
     // ... existing helpers ...
+    void start_blind_connect_();
+    void start_bulk_connect_();
@@ private:
     bool fast_connect_{false};
+    bool blind_connect_{false};
+    uint32_t blind_connect_delay_{5000};
+    bool bulk_connect_{false};
     bool trying_loaded_ap_{false};
     bool retry_hidden_{false};
     bool has_ap_{false};

wifi_component.cpp:

@@ WiFiComponent::setup() {
     cg.add(var.set_passive_scan(config[CONF_PASSIVE_SCAN]));
+    cg.add(var.set_blind_connect(config[CONF_BLIND_CONNECT]));
+    cg.add(var.set_blind_connect_delay(config[CONF_BLIND_CONNECT_DELAY]));
+    cg.add(var.set_bulk_connect(config[CONF_BULK_CONNECT]));
     if CONF_OUTPUT_POWER ...

--- a/wifi_component.cpp
+++ b/wifi_component.cpp
@@ // public API:
 void WiFiComponent::set_fast_connect(bool fast_connect) { this->fast_connect_ = fast_connect; }
+void WiFiComponent::set_blind_connect(bool blind) { this->blind_connect_ = blind; }
+void WiFiComponent::set_blind_connect_delay(uint32_t ms) { this->blind_connect_delay_ = ms; }
+void WiFiComponent::set_bulk_connect(bool bulk) { this->bulk_connect_ = bulk; }

 void WiFiComponent::start_scanning() {
-  this->action_started_ = millis();
-  ESP_LOGD(TAG, "Starting scan");
-  this->wifi_scan_start_(this->passive_scan_);
-  this->state_ = WIFI_COMPONENT_STATE_STA_SCANNING;
+  this->action_started_ = millis();
+  // bulk_connect skips scan, fires all connect packets at once
+  if (this->bulk_connect_) {
+    ESP_LOGD(TAG, "Starting bulk connect to all configured networks");
+    this->start_bulk_connect_();
+    return;
+  }
+  // blind_connect tries each network in turn, with a short timeout
+  if (this->blind_connect_) {
+    ESP_LOGD(TAG, "Starting blind connect (per-AP timeout %ums)", this->blind_connect_delay_);
+    this->start_blind_connect_();
+    return;
+  }
+  ESP_LOGD(TAG, "Starting scan");
+  this->wifi_scan_start_(this->passive_scan_);
+  this->state_ = WIFI_COMPONENT_STATE_STA_SCANNING;
 }

@@ void WiFiComponent::retry_connect() {
+  // if blind_connect is enabled, just cycle AP-by-AP with a short delay
+  if (this->blind_connect_ && !this->fast_connect_) {
+    delay(this->blind_connect_delay_);
+    this->ap_index_ = (this->ap_index_ + 1) % this->sta_.size();
+    this->selected_ap_ = this->sta_[this->ap_index_];
+    ESP_LOGI(TAG, "Blind connect: trying next AP '%s'", this->selected_ap_.get_ssid().c_str());
+    this->num_retried_ = 0;
+    this->error_from_callback_ = false;
+    this->start_connecting(this->selected_ap_, false);
+    return;
+  }
   // ... existing retry logic follows ...

@@ void WiFiComponent::check_connecting_finished() {
   auto status = this->wifi_sta_connect_status_();
+  uint32_t now = millis();
+  // blind_connect mode: timeout per-AP is blind_connect_delay_ instead of 30s
+  if (this->blind_connect_
+      && (this->state_ == WIFI_COMPONENT_STATE_STA_CONNECTING || this->state_ == WIFI_COMPONENT_STATE_STA_CONNECTING_2)
+      && now - this->action_started_ > this->blind_connect_delay_) {
+    ESP_LOGW(TAG, "Blind connect to '%s' timed out", this->selected_ap_.get_ssid().c_str());
+    this->retry_connect();
+    return;
+  }
   if (status == WiFiSTAConnectStatus::CONNECTED) {
     // ... existing success path ...
   }

@@ // ========== PRIVATE HELPERS ==========
+void WiFiComponent::start_blind_connect_() {
+  this->ap_index_ = 0;
+  this->selected_ap_ = this->sta_[this->ap_index_];
+  ESP_LOGI(TAG, "Blind connect: first try '%s'", this->selected_ap_.get_ssid().c_str());
+  this->start_connecting(this->selected_ap_, false);
+}

+void WiFiComponent::start_bulk_connect_() {
+  // send a connect attempt to each AP back-to-back
+  for (auto &ap : this->sta_) {
+    ESP_LOGV(TAG, "Bulk connect: probing '%s'", ap.get_ssid().c_str());
+    this->wifi_sta_connect_(ap);
+  }
+  // wait for any to succeed
+  this->state_ = WIFI_COMPONENT_STATE_STA_CONNECTING;
+  this->action_started_ = millis();
+}

Its remarks:

With these changes:

blind_connect (blind_connect: true) will, instead of doing a full scan, sequentially try each configured network, waiting only blind_connect_delay ms for a response before moving on.

bulk_connect (bulk_connect: true) will fire off connect packets to all networks immediately and bind to whichever one answers first.

Both options are mutually exclusive to the standard scan flow and only take effect when fast_connect is off.

You can now add to your ESPHome YAML:

wifi:
  networks:
    - ssid: "Office"
      password: "..."
    - ssid: "Home"
      password: "..."
  blind_connect: true
  blind_connect_delay: 2000ms
  # bulk_connect: true   # instead of blind_connect

Use cases

blind_connect allows to reduce connection time as much as possible while maintaining the preset priorities, assuming the networks provided are known to be available. This also reduces energy consumption as much as possible.
bulk_connect trades the maintaining of the priorities set in exchange for tolerance to missing networks.

Anything else?

No response

[github-actions[bot]]

🏷️ I've automatically added the component: wifi label to help categorize this feature request.

[dewi-ny-je]

Thinking back about it I'm wondering how a blind connect or bulk connect could work without even telling which WiFi channel and frequency have to be used...
I guess it's more complex than what I thought, but it's likely doable and it would still bring significant energy and time savings

[dewi-ny-je]

Gemini flash 2.5 confirms that while not strictly needed, to get the best speedup specifying the bssid and the WiFi channel would be preferred. Without them (ok, providing the bssid is already possible in esphome) a shorter scan for the network specified would be automatically performed by the framework.

[jesserockz]

I'm not sure I get the difference between fast_connect and this?

[dewi-ny-je]

I'm on holiday, when I'm back I'll prepare a flowchart for the three settings

[dewi-ny-je]

current fast_connect

• if there is a connection saved, use it and connect to it directly ("blindly")
• if not, perform a slow and energy intensive scan (10-15 seconds)
• match the result of the scan with the (one or more) networks provided in the config and connect.

Issue: assuming there are multiple suitable networks (think of a home with one router per floor) and if for any reason the strongest one once fails (reboot, update, power loss), ESPhome will connect to the second best, and SAVE IT, and use it forever until that one fails. If the fallback is (for example) the main central router at home (the one less likely to fail, typically), ESPhome will keep connecting at lower speed to a non optimal router.

blind_connect

• connect directly to the highest priority network from the config (basically, the one we KNOW it's the best, if available).
• if not reached in 10 seconds, connect directly to the second best one from the config
• and so on

It avoids falling in the case where ESPhome gets stuck to a worse network just because the best one failed once, and it does this without needing a scan, so that in best case scenario it's as fast as fast_connect.
Let's see it as a "controlled fast_connect" where we tell ESPhome which networks to use and in which order, without saving the last working one.

In a usual case for homes, where two or three networks are present at most at any spot inside the house, this modality is the most energy efficient because even if the first network is not reachable, connecting to the second one takes less time than doing a scan.

bulk_connect

• send connection packets to all network saved in the config
• the first one to reply wins.

This ensures the shortest possible connection time, but it loses the control of the priorities: while unlikely, a slower but faster to reply network will get used first. However, this cuts the connection time AND power consumption