[wifi] Change priority type from float to int8_t

This reverts commit fbc3413ed9.

esphome/analyze_memory/cli.py

@@ -1,6 +1,7 @@
 """CLI interface for memory analysis with report generation."""
 
 from collections import defaultdict
+import json
 import sys
 
 from . import (
@@ -283,6 +284,28 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
 
         return "\n".join(lines)
 
+    def to_json(self) -> str:
+        """Export analysis results as JSON."""
+        data = {
+            "components": {
+                name: {
+                    "text": mem.text_size,
+                    "rodata": mem.rodata_size,
+                    "data": mem.data_size,
+                    "bss": mem.bss_size,
+                    "flash_total": mem.flash_total,
+                    "ram_total": mem.ram_total,
+                    "symbol_count": mem.symbol_count,
+                }
+                for name, mem in self.components.items()
+            },
+            "totals": {
+                "flash": sum(c.flash_total for c in self.components.values()),
+                "ram": sum(c.ram_total for c in self.components.values()),
+            },
+        }
+        return json.dumps(data, indent=2)
+
     def dump_uncategorized_symbols(self, output_file: str | None = None) -> None:
         """Dump uncategorized symbols for analysis."""
         # Sort by size descending

esphome/components/esp32_ble_client/ble_client_base.cpp

@@ -389,8 +389,7 @@ bool BLEClientBase::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
       if (this->conn_id_ != param->search_res.conn_id)
         return false;
       this->service_count_++;
-      if (this->connection_type_ == espbt::ConnectionType::V3_WITHOUT_CACHE ||
-          this->connection_type_ == espbt::ConnectionType::V3_WITH_CACHE) {
+      if (this->connection_type_ == espbt::ConnectionType::V3_WITHOUT_CACHE) {
         // V3 clients don't need services initialized since
         // as they use the ESP APIs to get services.
         break;

esphome/components/esp32_ble_server/ble_server_automations.cpp

@@ -15,7 +15,10 @@ Trigger<std::vector<uint8_t>, uint16_t> *BLETriggers::create_characteristic_on_w
   Trigger<std::vector<uint8_t>, uint16_t> *on_write_trigger =  // NOLINT(cppcoreguidelines-owning-memory)
       new Trigger<std::vector<uint8_t>, uint16_t>();
   characteristic->on_write([on_write_trigger](std::span<const uint8_t> data, uint16_t id) {
-    // Convert span to vector for trigger
+    // Convert span to vector for trigger - copy is necessary because:
+    // 1. Trigger stores the data for use in automation actions that execute later
+    // 2. The span is only valid during this callback (points to temporary BLE stack data)
+    // 3. User lambdas in automations need persistent data they can access asynchronously
     on_write_trigger->trigger(std::vector<uint8_t>(data.begin(), data.end()), id);
   });
   return on_write_trigger;
@@ -27,7 +30,10 @@ Trigger<std::vector<uint8_t>, uint16_t> *BLETriggers::create_descriptor_on_write
   Trigger<std::vector<uint8_t>, uint16_t> *on_write_trigger =  // NOLINT(cppcoreguidelines-owning-memory)
       new Trigger<std::vector<uint8_t>, uint16_t>();
   descriptor->on_write([on_write_trigger](std::span<const uint8_t> data, uint16_t id) {
-    // Convert span to vector for trigger
+    // Convert span to vector for trigger - copy is necessary because:
+    // 1. Trigger stores the data for use in automation actions that execute later
+    // 2. The span is only valid during this callback (points to temporary BLE stack data)
+    // 3. User lambdas in automations need persistent data they can access asynchronously
     on_write_trigger->trigger(std::vector<uint8_t>(data.begin(), data.end()), id);
   });
   return on_write_trigger;

esphome/components/openthread/__init__.py

@@ -174,9 +174,6 @@ FINAL_VALIDATE_SCHEMA = _final_validate
 async def to_code(config):
     cg.add_define("USE_OPENTHREAD")
 
-    # OpenThread uses esp_vfs_eventfd which requires VFS select support
-    require_vfs_select()
-
     # OpenThread SRP needs access to mDNS services after setup
     enable_mdns_storage()
 

esphome/components/wifi/__init__.py

@@ -188,7 +188,7 @@ WIFI_NETWORK_STA = WIFI_NETWORK_BASE.extend(
     {
         cv.Optional(CONF_BSSID): cv.mac_address,
         cv.Optional(CONF_HIDDEN): cv.boolean,
-        cv.Optional(CONF_PRIORITY, default=0.0): cv.float_,
+        cv.Optional(CONF_PRIORITY, default=0): cv.int_range(min=-128, max=127),
         cv.Optional(CONF_EAP): EAP_AUTH_SCHEMA,
     }
 )

esphome/components/wifi/wifi_component.cpp

@@ -675,7 +675,7 @@ void WiFiComponent::start_connecting(const WiFiAP &ap, bool two) {
   }
 
   ESP_LOGI(TAG,
-           "Connecting to " LOG_SECRET("'%s'") " " LOG_SECRET("(%s)") " (priority %.1f, attempt %u/%u in phase %s)...",
+           "Connecting to " LOG_SECRET("'%s'") " " LOG_SECRET("(%s)") " (priority %d, attempt %u/%u in phase %s)...",
            ap.get_ssid().c_str(), ap.get_bssid().has_value() ? bssid_formatted.c_str() : LOG_STR_LITERAL("any"),
            priority, this->num_retried_ + 1, get_max_retries_for_phase(this->retry_phase_),
            LOG_STR_ARG(retry_phase_to_log_string(this->retry_phase_)));
@@ -812,7 +812,7 @@ void WiFiComponent::print_connect_params_() {
                 wifi_gateway_ip_().str().c_str(), wifi_dns_ip_(0).str().c_str(), wifi_dns_ip_(1).str().c_str());
 #ifdef ESPHOME_LOG_HAS_VERBOSE
   if (const WiFiAP *config = this->get_selected_sta_(); config && config->get_bssid().has_value()) {
-    ESP_LOGV(TAG, "  Priority: %.1f", this->get_sta_priority(*config->get_bssid()));
+    ESP_LOGV(TAG, "  Priority: %d", this->get_sta_priority(*config->get_bssid()));
   }
 #endif
 #ifdef USE_WIFI_11KV_SUPPORT
@@ -933,8 +933,7 @@ __attribute__((noinline)) static void log_scan_result(const WiFiScanResult &res)
     ESP_LOGI(TAG, "- '%s' %s" LOG_SECRET("(%s) ") "%s", res.get_ssid().c_str(),
              res.get_is_hidden() ? LOG_STR_LITERAL("(HIDDEN) ") : LOG_STR_LITERAL(""), bssid_s,
              LOG_STR_ARG(get_signal_bars(res.get_rssi())));
-    ESP_LOGD(TAG, "  Channel: %2u, RSSI: %3d dB, Priority: %4.1f", res.get_channel(), res.get_rssi(),
-             res.get_priority());
+    ESP_LOGD(TAG, "  Channel: %2u, RSSI: %3d dB, Priority: %4d", res.get_channel(), res.get_rssi(), res.get_priority());
   } else {
     ESP_LOGD(TAG, "- " LOG_SECRET("'%s'") " " LOG_SECRET("(%s) ") "%s", res.get_ssid().c_str(), bssid_s,
              LOG_STR_ARG(get_signal_bars(res.get_rssi())));
@@ -1063,6 +1062,9 @@ void WiFiComponent::check_connecting_finished() {
     this->state_ = WIFI_COMPONENT_STATE_STA_CONNECTED;
     this->num_retried_ = 0;
 
+    // Reset all priorities if they're all the same (can't differentiate)
+    this->reset_priorities_if_all_same_();
+
 #ifdef USE_WIFI_FAST_CONNECT
     this->save_fast_connect_settings_();
 #endif
@@ -1291,6 +1293,27 @@ bool WiFiComponent::transition_to_phase_(WiFiRetryPhase new_phase) {
   return false;  // Did not start scan, can proceed with connection
 }
 
+/// Reset all BSSID priorities to 0 if they're all identical (can't differentiate)
+/// Called when starting a fresh connection attempt or after successful connection
+void WiFiComponent::reset_priorities_if_all_same_() {
+  if (this->sta_priorities_.empty()) {
+    return;
+  }
+
+  int8_t first_priority = this->sta_priorities_[0].priority;
+  for (const auto &pri : this->sta_priorities_) {
+    if (pri.priority != first_priority) {
+      return;  // Not all same, nothing to do
+    }
+  }
+
+  // All priorities are identical, reset to 0
+  ESP_LOGD(TAG, "Resetting all BSSID priorities (all identical)");
+  for (auto &pri : this->sta_priorities_) {
+    pri.priority = 0;
+  }
+}
+
 /// Log failed connection attempt and decrease BSSID priority to avoid repeated failures
 /// This function identifies which BSSID was attempted (from scan results or config),
 /// decreases its priority by 1.0 to discourage future attempts, and logs the change.
@@ -1321,8 +1344,9 @@ void WiFiComponent::log_and_adjust_priority_for_failed_connect_() {
   }
 
   // Decrease priority to avoid repeatedly trying the same failed BSSID
-  float old_priority = this->get_sta_priority(failed_bssid.value());
-  float new_priority = old_priority - 1.0f;
+  int8_t old_priority = this->get_sta_priority(failed_bssid.value());
+  int8_t new_priority =
+      (old_priority > std::numeric_limits<int8_t>::min()) ? (old_priority - 1) : std::numeric_limits<int8_t>::min();
   this->set_sta_priority(failed_bssid.value(), new_priority);
 
   // Get SSID for logging
@@ -1333,8 +1357,12 @@ void WiFiComponent::log_and_adjust_priority_for_failed_connect_() {
     ssid = config->get_ssid();
   }
 
-  ESP_LOGD(TAG, "Failed " LOG_SECRET("'%s'") " " LOG_SECRET("(%s)") ", priority %.1f → %.1f", ssid.c_str(),
+  ESP_LOGD(TAG, "Failed " LOG_SECRET("'%s'") " " LOG_SECRET("(%s)") ", priority %d → %d", ssid.c_str(),
            format_mac_address_pretty(failed_bssid.value().data()).c_str(), old_priority, new_priority);
+
+  // After adjusting priority, check if all priorities are now identical
+  // If so, reset them all to 0 to start fresh
+  this->reset_priorities_if_all_same_();
 }
 
 /// Handle target advancement or retry counter increment when staying in the same phase

esphome/components/wifi/wifi_component.h

@@ -157,7 +157,7 @@ class WiFiAP {
   void set_eap(optional<EAPAuth> eap_auth);
 #endif  // USE_WIFI_WPA2_EAP
   void set_channel(optional<uint8_t> channel);
-  void set_priority(float priority) { priority_ = priority; }
+  void set_priority(int8_t priority) { priority_ = priority; }
   void set_manual_ip(optional<ManualIP> manual_ip);
   void set_hidden(bool hidden);
   const std::string &get_ssid() const;
@@ -167,7 +167,7 @@ class WiFiAP {
   const optional<EAPAuth> &get_eap() const;
 #endif  // USE_WIFI_WPA2_EAP
   const optional<uint8_t> &get_channel() const;
-  float get_priority() const { return priority_; }
+  int8_t get_priority() const { return priority_; }
   const optional<ManualIP> &get_manual_ip() const;
   bool get_hidden() const;
 
@@ -179,8 +179,8 @@ class WiFiAP {
   optional<EAPAuth> eap_;
 #endif  // USE_WIFI_WPA2_EAP
   optional<ManualIP> manual_ip_;
-  float priority_{0};
   optional<uint8_t> channel_;
+  int8_t priority_{0};
   bool hidden_{false};
 };
 
@@ -198,17 +198,17 @@ class WiFiScanResult {
   int8_t get_rssi() const;
   bool get_with_auth() const;
   bool get_is_hidden() const;
-  float get_priority() const { return priority_; }
-  void set_priority(float priority) { priority_ = priority; }
+  int8_t get_priority() const { return priority_; }
+  void set_priority(int8_t priority) { priority_ = priority; }
 
   bool operator==(const WiFiScanResult &rhs) const;
 
  protected:
   bssid_t bssid_;
-  std::string ssid_;
-  float priority_{0.0f};
   uint8_t channel_;
   int8_t rssi_;
+  std::string ssid_;
+  int8_t priority_{0};
   bool matches_{false};
   bool with_auth_;
   bool is_hidden_;
@@ -216,7 +216,7 @@ class WiFiScanResult {
 
 struct WiFiSTAPriority {
   bssid_t bssid;
-  float priority;
+  int8_t priority;
 };
 
 enum WiFiPowerSaveMode : uint8_t {
@@ -324,14 +324,14 @@ class WiFiComponent : public Component {
     }
     return false;
   }
-  float get_sta_priority(const bssid_t bssid) {
+  int8_t get_sta_priority(const bssid_t bssid) {
     for (auto &it : this->sta_priorities_) {
       if (it.bssid == bssid)
         return it.priority;
     }
-    return 0.0f;
+    return 0;
   }
-  void set_sta_priority(const bssid_t bssid, float priority) {
+  void set_sta_priority(const bssid_t bssid, int8_t priority) {
     for (auto &it : this->sta_priorities_) {
       if (it.bssid == bssid) {
         it.priority = priority;
@@ -390,6 +390,8 @@ class WiFiComponent : public Component {
   int8_t find_next_hidden_sta_(int8_t start_index, bool include_explicit_hidden = true);
   /// Log failed connection and decrease BSSID priority to avoid repeated attempts
   void log_and_adjust_priority_for_failed_connect_();
+  /// Reset all BSSID priorities to 0 if they're all identical (can't differentiate)
+  void reset_priorities_if_all_same_();
   /// Advance to next target (AP/SSID) within current phase, or increment retry counter
   /// Called when staying in the same phase after a failed connection attempt
   void advance_to_next_target_or_increment_retry_();

esphome/core/scheduler.h

@@ -94,10 +94,9 @@ class Scheduler {
     } name_;
     uint32_t interval;
     // Split time to handle millis() rollover. The scheduler combines the 32-bit millis()
-    // with a 16-bit rollover counter to create a 48-bit time space (using 32+16 bits).
-    // This is intentionally limited to 48 bits, not stored as a full 64-bit value.
-    // With 49.7 days per 32-bit rollover, the 16-bit counter supports
-    // 49.7 days × 65536 = ~8900 years. This ensures correct scheduling
+    // with a 16-bit rollover counter to create a 48-bit time space (stored as 64-bit
+    // for compatibility). With 49.7 days per 32-bit rollover, the 16-bit counter
+    // supports 49.7 days × 65536 = ~8900 years. This ensures correct scheduling
     // even when devices run for months. Split into two fields for better memory
     // alignment on 32-bit systems.
     uint32_t next_execution_low_;  // Lower 32 bits of execution time (millis value)

esphome/platformio_api.py

@@ -408,7 +408,8 @@ class IDEData:
 def analyze_memory_usage(config: dict[str, Any]) -> None:
     """Analyze memory usage by component after compilation."""
     # Lazy import to avoid overhead when not needed
-    from esphome.analyze_memory import MemoryAnalyzer
+    from esphome.analyze_memory.cli import MemoryAnalyzerCLI
+    from esphome.analyze_memory.helpers import get_esphome_components
 
     idedata = get_idedata(config)
 
@@ -435,8 +436,6 @@ def analyze_memory_usage(config: dict[str, Any]) -> None:
     external_components = set()
 
     # Get the list of built-in ESPHome components
-    from esphome.analyze_memory import get_esphome_components
-
     builtin_components = get_esphome_components()
 
     # Special non-component keys that appear in configs
@@ -457,7 +456,9 @@ def analyze_memory_usage(config: dict[str, Any]) -> None:
     _LOGGER.debug("Detected external components: %s", external_components)
 
     # Create analyzer and run analysis
-    analyzer = MemoryAnalyzer(elf_path, objdump_path, readelf_path, external_components)
+    analyzer = MemoryAnalyzerCLI(
+        elf_path, objdump_path, readelf_path, external_components
+    )
     analyzer.analyze()
 
     # Generate and print report

tests/integration/fixtures/api_user_services_union.yaml

@@ -0,0 +1,59 @@
+esphome:
+  name: test-user-services-union
+  friendly_name: Test User Services Union Storage
+
+esp32:
+  board: esp32dev
+  framework:
+    type: esp-idf
+
+logger:
+  level: DEBUG
+
+wifi:
+  ssid: "test"
+  password: "password"
+
+api:
+  actions:
+    # Test service with no arguments
+    - action: test_no_args
+      then:
+        - logger.log: "No args service called"
+
+    # Test service with one argument
+    - action: test_one_arg
+      variables:
+        value: int
+      then:
+        - logger.log:
+            format: "One arg service: %d"
+            args: [value]
+
+    # Test service with multiple arguments of different types
+    - action: test_multi_args
+      variables:
+        int_val: int
+        float_val: float
+        str_val: string
+        bool_val: bool
+      then:
+        - logger.log:
+            format: "Multi args: %d, %.2f, %s, %d"
+            args: [int_val, float_val, str_val.c_str(), bool_val]
+
+    # Test service with max typical arguments
+    - action: test_many_args
+      variables:
+        arg1: int
+        arg2: int
+        arg3: int
+        arg4: string
+        arg5: float
+      then:
+        - logger.log: "Many args service called"
+
+binary_sensor:
+  - platform: template
+    name: "Test Binary Sensor"
+    id: test_sensor