pool for scheduler

This reverts commit b99b0140ae.

.clang-tidy.hash

@@ -1 +1 @@
-6af8b429b94191fe8e239fcb3b73f7982d0266cb5b05ffbc81edaeac1bc8c273
+32b0db73b3ae01ba18c9cbb1dabbd8156bc14dded500471919bd0a3dc33916e0

.github/workflows/auto-label-pr.yml

@@ -63,11 +63,7 @@ jobs:
               'needs-docs',
               'needs-codeowners',
               'too-big',
-              'labeller-recheck',
-              'bugfix',
-              'new-feature',
-              'breaking-change',
-              'code-quality'
+              'labeller-recheck'
             ];
 
             const DOCS_PR_PATTERNS = [
@@ -345,31 +341,6 @@ jobs:
               return labels;
             }
 
-            // Strategy: PR Template Checkbox detection
-            async function detectPRTemplateCheckboxes() {
-              const labels = new Set();
-              const prBody = context.payload.pull_request.body || '';
-
-              console.log('Checking PR template checkboxes...');
-
-              // Check for checked checkboxes in the "Types of changes" section
-              const checkboxPatterns = [
-                { pattern: /- \[x\] Bugfix \(non-breaking change which fixes an issue\)/i, label: 'bugfix' },
-                { pattern: /- \[x\] New feature \(non-breaking change which adds functionality\)/i, label: 'new-feature' },
-                { pattern: /- \[x\] Breaking change \(fix or feature that would cause existing functionality to not work as expected\)/i, label: 'breaking-change' },
-                { pattern: /- \[x\] Code quality improvements to existing code or addition of tests/i, label: 'code-quality' }
-              ];
-
-              for (const { pattern, label } of checkboxPatterns) {
-                if (pattern.test(prBody)) {
-                  console.log(`Found checked checkbox for: ${label}`);
-                  labels.add(label);
-                }
-              }
-
-              return labels;
-            }
-
             // Strategy: Requirements detection
             async function detectRequirements(allLabels) {
               const labels = new Set();
@@ -380,7 +351,7 @@ jobs:
               }
 
               // Check for missing docs
-              if (allLabels.has('new-component') || allLabels.has('new-platform') || allLabels.has('new-feature')) {
+              if (allLabels.has('new-component') || allLabels.has('new-platform')) {
                 const prBody = context.payload.pull_request.body || '';
                 const hasDocsLink = DOCS_PR_PATTERNS.some(pattern => pattern.test(prBody));
 
@@ -564,8 +535,7 @@ jobs:
               dashboardLabels,
               actionsLabels,
               codeOwnerLabels,
-              testLabels,
-              checkboxLabels
+              testLabels
             ] = await Promise.all([
               detectMergeBranch(),
               detectComponentPlatforms(apiData),
@@ -576,8 +546,7 @@ jobs:
               detectDashboardChanges(),
               detectGitHubActionsChanges(),
               detectCodeOwner(),
-              detectTests(),
-              detectPRTemplateCheckboxes()
+              detectTests()
             ]);
 
             // Combine all labels
@@ -591,8 +560,7 @@ jobs:
               ...dashboardLabels,
               ...actionsLabels,
               ...codeOwnerLabels,
-              ...testLabels,
-              ...checkboxLabels
+              ...testLabels
             ]);
 
             // Detect requirements based on all other labels

.github/workflows/ci.yml

@@ -281,7 +281,7 @@ jobs:
             pio_cache_key: tidyesp32-idf
           - id: clang-tidy
             name: Run script/clang-tidy for ZEPHYR
-            options: --environment nrf52-tidy --grep USE_ZEPHYR --grep USE_NRF52
+            options: --environment nrf52-tidy --grep USE_ZEPHYR
             pio_cache_key: tidy-zephyr
             ignore_errors: false
 

.pre-commit-config.yaml

@@ -11,7 +11,7 @@ ci:
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version.
-    rev: v0.12.7
+    rev: v0.12.5
     hooks:
       # Run the linter.
       - id: ruff

CODEOWNERS

@@ -155,7 +155,6 @@ esphome/components/esp32_rmt/* @jesserockz
 esphome/components/esp32_rmt_led_strip/* @jesserockz
 esphome/components/esp8266/* @esphome/core
 esphome/components/esp_ldo/* @clydebarrow
-esphome/components/espnow/* @jesserockz
 esphome/components/ethernet_info/* @gtjadsonsantos
 esphome/components/event/* @nohat
 esphome/components/event_emitter/* @Rapsssito
@@ -473,7 +472,7 @@ esphome/components/tlc5971/* @IJIJI
 esphome/components/tm1621/* @Philippe12
 esphome/components/tm1637/* @glmnet
 esphome/components/tm1638/* @skykingjwc
-esphome/components/tm1651/* @mrtoy-me
+esphome/components/tm1651/* @freekode
 esphome/components/tmp102/* @timsavage
 esphome/components/tmp1075/* @sybrenstuvel
 esphome/components/tmp117/* @Azimath

esphome/__main__.py

@@ -464,6 +464,13 @@ def command_vscode(args):
 
 
 def command_compile(args, config):
+    # Set memory analysis options in config
+    if args.analyze_memory:
+        config.setdefault(CONF_ESPHOME, {})["analyze_memory"] = True
+
+    if args.memory_report:
+        config.setdefault(CONF_ESPHOME, {})["memory_report_file"] = args.memory_report
+
     exit_code = write_cpp(config)
     if exit_code != 0:
         return exit_code
@@ -843,6 +850,17 @@ def parse_args(argv):
         help="Only generate source code, do not compile.",
         action="store_true",
     )
+    parser_compile.add_argument(
+        "--analyze-memory",
+        help="Analyze and display memory usage by component after compilation.",
+        action="store_true",
+    )
+    parser_compile.add_argument(
+        "--memory-report",
+        help="Save memory analysis report to a file (supports .json or .txt).",
+        type=str,
+        metavar="FILE",
+    )
 
     parser_upload = subparsers.add_parser(
         "upload",

esphome/automation.py

@@ -391,7 +391,8 @@ async def build_action(full_config, template_arg, args):
     )
     action_id = full_config[CONF_TYPE_ID]
     builder = registry_entry.coroutine_fun
-    return await builder(config, action_id, template_arg, args)
+    ret = await builder(config, action_id, template_arg, args)
+    return ret
 
 
 async def build_action_list(config, templ, arg_type):
@@ -408,7 +409,8 @@ async def build_condition(full_config, template_arg, args):
     )
     action_id = full_config[CONF_TYPE_ID]
     builder = registry_entry.coroutine_fun
-    return await builder(config, action_id, template_arg, args)
+    ret = await builder(config, action_id, template_arg, args)
+    return ret
 
 
 async def build_condition_list(config, templ, args):

esphome/components/adc/__init__.py

@@ -1,6 +1,6 @@
 from esphome import pins
 import esphome.codegen as cg
-from esphome.components.esp32 import VARIANT_ESP32P4, get_esp32_variant
+from esphome.components.esp32 import get_esp32_variant
 from esphome.components.esp32.const import (
     VARIANT_ESP32,
     VARIANT_ESP32C2,
@@ -140,16 +140,6 @@ ESP32_VARIANT_ADC1_PIN_TO_CHANNEL = {
         9: adc_channel_t.ADC_CHANNEL_8,
         10: adc_channel_t.ADC_CHANNEL_9,
     },
-    VARIANT_ESP32P4: {
-        16: adc_channel_t.ADC_CHANNEL_0,
-        17: adc_channel_t.ADC_CHANNEL_1,
-        18: adc_channel_t.ADC_CHANNEL_2,
-        19: adc_channel_t.ADC_CHANNEL_3,
-        20: adc_channel_t.ADC_CHANNEL_4,
-        21: adc_channel_t.ADC_CHANNEL_5,
-        22: adc_channel_t.ADC_CHANNEL_6,
-        23: adc_channel_t.ADC_CHANNEL_7,
-    },
 }
 
 # pin to adc2 channel mapping
@@ -208,14 +198,6 @@ ESP32_VARIANT_ADC2_PIN_TO_CHANNEL = {
         19: adc_channel_t.ADC_CHANNEL_8,
         20: adc_channel_t.ADC_CHANNEL_9,
     },
-    VARIANT_ESP32P4: {
-        49: adc_channel_t.ADC_CHANNEL_0,
-        50: adc_channel_t.ADC_CHANNEL_1,
-        51: adc_channel_t.ADC_CHANNEL_2,
-        52: adc_channel_t.ADC_CHANNEL_3,
-        53: adc_channel_t.ADC_CHANNEL_4,
-        54: adc_channel_t.ADC_CHANNEL_5,
-    },
 }
 
 
@@ -267,11 +249,6 @@ def validate_adc_pin(value):
             {CONF_ANALOG: True, CONF_INPUT: True}, internal=True
         )(value)
 
-    if CORE.is_nrf52:
-        return pins.gpio_pin_schema(
-            {CONF_ANALOG: True, CONF_INPUT: True}, internal=True
-        )(value)
-
     raise NotImplementedError
 
 
@@ -288,6 +265,5 @@ FILTER_SOURCE_FILES = filter_source_files_from_platform(
             PlatformFramework.RTL87XX_ARDUINO,
             PlatformFramework.LN882X_ARDUINO,
         },
-        "adc_sensor_zephyr.cpp": {PlatformFramework.NRF52_ZEPHYR},
     }
 )

esphome/components/adc/adc_sensor.h

@@ -13,10 +13,6 @@
 #include "hal/adc_types.h"  // This defines ADC_CHANNEL_MAX
 #endif                      // USE_ESP32
 
-#ifdef USE_ZEPHYR
-#include <zephyr/drivers/adc.h>
-#endif
-
 namespace esphome {
 namespace adc {
 
@@ -42,15 +38,15 @@ enum class SamplingMode : uint8_t {
 
 const LogString *sampling_mode_to_str(SamplingMode mode);
 
-template<typename T> class Aggregator {
+class Aggregator {
  public:
   Aggregator(SamplingMode mode);
-  void add_sample(T value);
-  T aggregate();
+  void add_sample(uint32_t value);
+  uint32_t aggregate();
 
  protected:
-  T aggr_{0};
-  uint8_t samples_{0};
+  uint32_t aggr_{0};
+  uint32_t samples_{0};
   SamplingMode mode_{SamplingMode::AVG};
 };
 
@@ -73,11 +69,6 @@ class ADCSensor : public sensor::Sensor, public PollingComponent, public voltage
   /// @return A float representing the setup priority.
   float get_setup_priority() const override;
 
-#ifdef USE_ZEPHYR
-  /// Set the ADC channel to be used by the ADC sensor.
-  /// @param channel Pointer to an adc_dt_spec structure representing the ADC channel.
-  void set_adc_channel(const adc_dt_spec *channel) { this->channel_ = channel; }
-#endif
   /// Set the GPIO pin to be used by the ADC sensor.
   /// @param pin Pointer to an InternalGPIOPin representing the ADC input pin.
   void set_pin(InternalGPIOPin *pin) { this->pin_ = pin; }
@@ -145,8 +136,8 @@ class ADCSensor : public sensor::Sensor, public PollingComponent, public voltage
   adc_oneshot_unit_handle_t adc_handle_{nullptr};
   adc_cali_handle_t calibration_handle_{nullptr};
   adc_atten_t attenuation_{ADC_ATTEN_DB_0};
-  adc_channel_t channel_{};
-  adc_unit_t adc_unit_{};
+  adc_channel_t channel_;
+  adc_unit_t adc_unit_;
   struct SetupFlags {
     uint8_t init_complete : 1;
     uint8_t config_complete : 1;
@@ -160,10 +151,6 @@ class ADCSensor : public sensor::Sensor, public PollingComponent, public voltage
 #ifdef USE_RP2040
   bool is_temperature_{false};
 #endif  // USE_RP2040
-
-#ifdef USE_ZEPHYR
-  const struct adc_dt_spec *channel_ = nullptr;
-#endif
 };
 
 }  // namespace adc

esphome/components/adc/adc_sensor_common.cpp

@@ -18,15 +18,15 @@ const LogString *sampling_mode_to_str(SamplingMode mode) {
   return LOG_STR("unknown");
 }
 
-template<typename T> Aggregator<T>::Aggregator(SamplingMode mode) {
+Aggregator::Aggregator(SamplingMode mode) {
   this->mode_ = mode;
   // set to max uint if mode is "min"
   if (mode == SamplingMode::MIN) {
-    this->aggr_ = std::numeric_limits<T>::max();
+    this->aggr_ = UINT32_MAX;
   }
 }
 
-template<typename T> void Aggregator<T>::add_sample(T value) {
+void Aggregator::add_sample(uint32_t value) {
   this->samples_ += 1;
 
   switch (this->mode_) {
@@ -47,7 +47,7 @@ template<typename T> void Aggregator<T>::add_sample(T value) {
   }
 }
 
-template<typename T> T Aggregator<T>::aggregate() {
+uint32_t Aggregator::aggregate() {
   if (this->mode_ == SamplingMode::AVG) {
     if (this->samples_ == 0) {
       return this->aggr_;
@@ -59,12 +59,6 @@ template<typename T> T Aggregator<T>::aggregate() {
   return this->aggr_;
 }
 
-#ifdef USE_ZEPHYR
-template class Aggregator<int32_t>;
-#else
-template class Aggregator<uint32_t>;
-#endif
-
 void ADCSensor::update() {
   float value_v = this->sample();
   ESP_LOGV(TAG, "'%s': Voltage=%.4fV", this->get_name().c_str(), value_v);

esphome/components/adc/adc_sensor_esp32.cpp

@@ -72,9 +72,10 @@ void ADCSensor::setup() {
   // Initialize ADC calibration
   if (this->calibration_handle_ == nullptr) {
     adc_cali_handle_t handle = nullptr;
+    esp_err_t err;
 
 #if USE_ESP32_VARIANT_ESP32C3 || USE_ESP32_VARIANT_ESP32C5 || USE_ESP32_VARIANT_ESP32C6 || \
-    USE_ESP32_VARIANT_ESP32S3 || USE_ESP32_VARIANT_ESP32H2 || USE_ESP32_VARIANT_ESP32P4
+    USE_ESP32_VARIANT_ESP32S3 || USE_ESP32_VARIANT_ESP32H2
     // RISC-V variants and S3 use curve fitting calibration
     adc_cali_curve_fitting_config_t cali_config = {};  // Zero initialize first
 #if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 3, 0)
@@ -152,7 +153,7 @@ float ADCSensor::sample() {
 }
 
 float ADCSensor::sample_fixed_attenuation_() {
-  auto aggr = Aggregator<uint32_t>(this->sampling_mode_);
+  auto aggr = Aggregator(this->sampling_mode_);
 
   for (uint8_t sample = 0; sample < this->sample_count_; sample++) {
     int raw;
@@ -186,7 +187,7 @@ float ADCSensor::sample_fixed_attenuation_() {
       ESP_LOGW(TAG, "ADC calibration conversion failed with error %d, disabling calibration", err);
       if (this->calibration_handle_ != nullptr) {
 #if USE_ESP32_VARIANT_ESP32C3 || USE_ESP32_VARIANT_ESP32C5 || USE_ESP32_VARIANT_ESP32C6 || \
-    USE_ESP32_VARIANT_ESP32S3 || USE_ESP32_VARIANT_ESP32H2 || USE_ESP32_VARIANT_ESP32P4
+    USE_ESP32_VARIANT_ESP32S3 || USE_ESP32_VARIANT_ESP32H2
         adc_cali_delete_scheme_curve_fitting(this->calibration_handle_);
 #else   // Other ESP32 variants use line fitting calibration
         adc_cali_delete_scheme_line_fitting(this->calibration_handle_);
@@ -219,7 +220,7 @@ float ADCSensor::sample_autorange_() {
     if (this->calibration_handle_ != nullptr) {
       // Delete old calibration handle
 #if USE_ESP32_VARIANT_ESP32C3 || USE_ESP32_VARIANT_ESP32C5 || USE_ESP32_VARIANT_ESP32C6 || \
-    USE_ESP32_VARIANT_ESP32S3 || USE_ESP32_VARIANT_ESP32H2 || USE_ESP32_VARIANT_ESP32P4
+    USE_ESP32_VARIANT_ESP32S3 || USE_ESP32_VARIANT_ESP32H2
       adc_cali_delete_scheme_curve_fitting(this->calibration_handle_);
 #else
       adc_cali_delete_scheme_line_fitting(this->calibration_handle_);
@@ -231,7 +232,7 @@ float ADCSensor::sample_autorange_() {
     adc_cali_handle_t handle = nullptr;
 
 #if USE_ESP32_VARIANT_ESP32C3 || USE_ESP32_VARIANT_ESP32C5 || USE_ESP32_VARIANT_ESP32C6 || \
-    USE_ESP32_VARIANT_ESP32S3 || USE_ESP32_VARIANT_ESP32H2 || USE_ESP32_VARIANT_ESP32P4
+    USE_ESP32_VARIANT_ESP32S3 || USE_ESP32_VARIANT_ESP32H2
     adc_cali_curve_fitting_config_t cali_config = {};
 #if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 3, 0)
     cali_config.chan = this->channel_;
@@ -260,7 +261,7 @@ float ADCSensor::sample_autorange_() {
       ESP_LOGW(TAG, "ADC read failed in autorange with error %d", err);
       if (handle != nullptr) {
 #if USE_ESP32_VARIANT_ESP32C3 || USE_ESP32_VARIANT_ESP32C5 || USE_ESP32_VARIANT_ESP32C6 || \
-    USE_ESP32_VARIANT_ESP32S3 || USE_ESP32_VARIANT_ESP32H2 || USE_ESP32_VARIANT_ESP32P4
+    USE_ESP32_VARIANT_ESP32S3 || USE_ESP32_VARIANT_ESP32H2
         adc_cali_delete_scheme_curve_fitting(handle);
 #else
         adc_cali_delete_scheme_line_fitting(handle);
@@ -280,7 +281,7 @@ float ADCSensor::sample_autorange_() {
       }
       // Clean up calibration handle
 #if USE_ESP32_VARIANT_ESP32C3 || USE_ESP32_VARIANT_ESP32C5 || USE_ESP32_VARIANT_ESP32C6 || \
-    USE_ESP32_VARIANT_ESP32S3 || USE_ESP32_VARIANT_ESP32H2 || USE_ESP32_VARIANT_ESP32P4
+    USE_ESP32_VARIANT_ESP32S3 || USE_ESP32_VARIANT_ESP32H2
       adc_cali_delete_scheme_curve_fitting(handle);
 #else
       adc_cali_delete_scheme_line_fitting(handle);

esphome/components/adc/adc_sensor_esp8266.cpp

@@ -37,7 +37,7 @@ void ADCSensor::dump_config() {
 }
 
 float ADCSensor::sample() {
-  auto aggr = Aggregator<uint32_t>(this->sampling_mode_);
+  auto aggr = Aggregator(this->sampling_mode_);
 
   for (uint8_t sample = 0; sample < this->sample_count_; sample++) {
     uint32_t raw = 0;

esphome/components/adc/adc_sensor_libretiny.cpp

@@ -30,7 +30,7 @@ void ADCSensor::dump_config() {
 
 float ADCSensor::sample() {
   uint32_t raw = 0;
-  auto aggr = Aggregator<uint32_t>(this->sampling_mode_);
+  auto aggr = Aggregator(this->sampling_mode_);
 
   if (this->output_raw_) {
     for (uint8_t sample = 0; sample < this->sample_count_; sample++) {

esphome/components/adc/adc_sensor_rp2040.cpp

@@ -41,7 +41,7 @@ void ADCSensor::dump_config() {
 
 float ADCSensor::sample() {
   uint32_t raw = 0;
-  auto aggr = Aggregator<uint32_t>(this->sampling_mode_);
+  auto aggr = Aggregator(this->sampling_mode_);
 
   if (this->is_temperature_) {
     adc_set_temp_sensor_enabled(true);

esphome/components/adc/adc_sensor_zephyr.cpp

@@ -1,207 +0,0 @@
-
-#include "adc_sensor.h"
-#ifdef USE_ZEPHYR
-#include "esphome/core/log.h"
-
-#include "hal/nrf_saadc.h"
-
-namespace esphome {
-namespace adc {
-
-static const char *const TAG = "adc.zephyr";
-
-void ADCSensor::setup() {
-  if (!adc_is_ready_dt(this->channel_)) {
-    ESP_LOGE(TAG, "ADC controller device %s not ready", this->channel_->dev->name);
-    return;
-  }
-
-  auto err = adc_channel_setup_dt(this->channel_);
-  if (err < 0) {
-    ESP_LOGE(TAG, "Could not setup channel %s (%d)", this->channel_->dev->name, err);
-    return;
-  }
-}
-
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
-static const LogString *gain_to_str(enum adc_gain gain) {
-  switch (gain) {
-    case ADC_GAIN_1_6:
-      return LOG_STR("1/6");
-    case ADC_GAIN_1_5:
-      return LOG_STR("1/5");
-    case ADC_GAIN_1_4:
-      return LOG_STR("1/4");
-    case ADC_GAIN_1_3:
-      return LOG_STR("1/3");
-    case ADC_GAIN_2_5:
-      return LOG_STR("2/5");
-    case ADC_GAIN_1_2:
-      return LOG_STR("1/2");
-    case ADC_GAIN_2_3:
-      return LOG_STR("2/3");
-    case ADC_GAIN_4_5:
-      return LOG_STR("4/5");
-    case ADC_GAIN_1:
-      return LOG_STR("1");
-    case ADC_GAIN_2:
-      return LOG_STR("2");
-    case ADC_GAIN_3:
-      return LOG_STR("3");
-    case ADC_GAIN_4:
-      return LOG_STR("4");
-    case ADC_GAIN_6:
-      return LOG_STR("6");
-    case ADC_GAIN_8:
-      return LOG_STR("8");
-    case ADC_GAIN_12:
-      return LOG_STR("12");
-    case ADC_GAIN_16:
-      return LOG_STR("16");
-    case ADC_GAIN_24:
-      return LOG_STR("24");
-    case ADC_GAIN_32:
-      return LOG_STR("32");
-    case ADC_GAIN_64:
-      return LOG_STR("64");
-    case ADC_GAIN_128:
-      return LOG_STR("128");
-  }
-  return LOG_STR("undefined gain");
-}
-
-static const LogString *reference_to_str(enum adc_reference reference) {
-  switch (reference) {
-    case ADC_REF_VDD_1:
-      return LOG_STR("VDD");
-    case ADC_REF_VDD_1_2:
-      return LOG_STR("VDD/2");
-    case ADC_REF_VDD_1_3:
-      return LOG_STR("VDD/3");
-    case ADC_REF_VDD_1_4:
-      return LOG_STR("VDD/4");
-    case ADC_REF_INTERNAL:
-      return LOG_STR("INTERNAL");
-    case ADC_REF_EXTERNAL0:
-      return LOG_STR("External, input 0");
-    case ADC_REF_EXTERNAL1:
-      return LOG_STR("External, input 1");
-  }
-  return LOG_STR("undefined reference");
-}
-
-static const LogString *input_to_str(uint8_t input) {
-  switch (input) {
-    case NRF_SAADC_INPUT_AIN0:
-      return LOG_STR("AIN0");
-    case NRF_SAADC_INPUT_AIN1:
-      return LOG_STR("AIN1");
-    case NRF_SAADC_INPUT_AIN2:
-      return LOG_STR("AIN2");
-    case NRF_SAADC_INPUT_AIN3:
-      return LOG_STR("AIN3");
-    case NRF_SAADC_INPUT_AIN4:
-      return LOG_STR("AIN4");
-    case NRF_SAADC_INPUT_AIN5:
-      return LOG_STR("AIN5");
-    case NRF_SAADC_INPUT_AIN6:
-      return LOG_STR("AIN6");
-    case NRF_SAADC_INPUT_AIN7:
-      return LOG_STR("AIN7");
-    case NRF_SAADC_INPUT_VDD:
-      return LOG_STR("VDD");
-    case NRF_SAADC_INPUT_VDDHDIV5:
-      return LOG_STR("VDDHDIV5");
-  }
-  return LOG_STR("undefined input");
-}
-#endif  // ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
-
-void ADCSensor::dump_config() {
-  LOG_SENSOR("", "ADC Sensor", this);
-  LOG_PIN("  Pin: ", this->pin_);
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
-  ESP_LOGV(TAG,
-           "  Name: %s\n"
-           "  Channel: %d\n"
-           "  vref_mv: %d\n"
-           "  Resolution %d\n"
-           "  Oversampling %d",
-           this->channel_->dev->name, this->channel_->channel_id, this->channel_->vref_mv, this->channel_->resolution,
-           this->channel_->oversampling);
-
-  ESP_LOGV(TAG,
-           "  Gain: %s\n"
-           "  reference: %s\n"
-           "  acquisition_time: %d\n"
-           "  differential %s",
-           LOG_STR_ARG(gain_to_str(this->channel_->channel_cfg.gain)),
-           LOG_STR_ARG(reference_to_str(this->channel_->channel_cfg.reference)),
-           this->channel_->channel_cfg.acquisition_time, YESNO(this->channel_->channel_cfg.differential));
-  if (this->channel_->channel_cfg.differential) {
-    ESP_LOGV(TAG,
-             "  Positive: %s\n"
-             "  Negative: %s",
-             LOG_STR_ARG(input_to_str(this->channel_->channel_cfg.input_positive)),
-             LOG_STR_ARG(input_to_str(this->channel_->channel_cfg.input_negative)));
-  } else {
-    ESP_LOGV(TAG, "  Positive: %s", LOG_STR_ARG(input_to_str(this->channel_->channel_cfg.input_positive)));
-  }
-#endif
-
-  LOG_UPDATE_INTERVAL(this);
-}
-
-float ADCSensor::sample() {
-  auto aggr = Aggregator<int32_t>(this->sampling_mode_);
-  int err;
-  for (uint8_t sample = 0; sample < this->sample_count_; sample++) {
-    int16_t buf = 0;
-    struct adc_sequence sequence = {
-        .buffer = &buf,
-        /* buffer size in bytes, not number of samples */
-        .buffer_size = sizeof(buf),
-    };
-    int32_t val_raw;
-
-    err = adc_sequence_init_dt(this->channel_, &sequence);
-    if (err < 0) {
-      ESP_LOGE(TAG, "Could sequence init %s (%d)", this->channel_->dev->name, err);
-      return 0.0;
-    }
-
-    err = adc_read(this->channel_->dev, &sequence);
-    if (err < 0) {
-      ESP_LOGE(TAG, "Could not read %s (%d)", this->channel_->dev->name, err);
-      return 0.0;
-    }
-
-    val_raw = (int32_t) buf;
-    if (!this->channel_->channel_cfg.differential) {
-      // https://github.com/adafruit/Adafruit_nRF52_Arduino/blob/0ed4d9ffc674ae407be7cacf5696a02f5e789861/cores/nRF5/wiring_analog_nRF52.c#L222
-      if (val_raw < 0) {
-        val_raw = 0;
-      }
-    }
-    aggr.add_sample(val_raw);
-  }
-
-  int32_t val_mv = aggr.aggregate();
-
-  if (this->output_raw_) {
-    return val_mv;
-  }
-
-  err = adc_raw_to_millivolts_dt(this->channel_, &val_mv);
-  /* conversion to mV may not be supported, skip if not */
-  if (err < 0) {
-    ESP_LOGE(TAG, "Value in mV not available %s (%d)", this->channel_->dev->name, err);
-    return 0.0;
-  }
-
-  return val_mv / 1000.0f;
-}
-
-}  // namespace adc
-}  // namespace esphome
-#endif

esphome/components/adc/sensor.py

@@ -3,12 +3,6 @@ import logging
 import esphome.codegen as cg
 from esphome.components import sensor, voltage_sampler
 from esphome.components.esp32 import get_esp32_variant
-from esphome.components.nrf52.const import AIN_TO_GPIO, EXTRA_ADC
-from esphome.components.zephyr import (
-    zephyr_add_overlay,
-    zephyr_add_prj_conf,
-    zephyr_add_user,
-)
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_ATTENUATION,
@@ -17,7 +11,6 @@ from esphome.const import (
     CONF_PIN,
     CONF_RAW,
     DEVICE_CLASS_VOLTAGE,
-    PLATFORM_NRF52,
     STATE_CLASS_MEASUREMENT,
     UNIT_VOLT,
 )
@@ -67,10 +60,6 @@ ADCSensor = adc_ns.class_(
     "ADCSensor", sensor.Sensor, cg.PollingComponent, voltage_sampler.VoltageSampler
 )
 
-CONF_NRF_SAADC = "nrf_saadc"
-
-adc_dt_spec = cg.global_ns.class_("adc_dt_spec")
-
 CONFIG_SCHEMA = cv.All(
     sensor.sensor_schema(
         ADCSensor,
@@ -86,7 +75,6 @@ CONFIG_SCHEMA = cv.All(
             cv.SplitDefault(CONF_ATTENUATION, esp32="0db"): cv.All(
                 cv.only_on_esp32, _attenuation
             ),
-            cv.OnlyWith(CONF_NRF_SAADC, PLATFORM_NRF52): cv.declare_id(adc_dt_spec),
             cv.Optional(CONF_SAMPLES, default=1): cv.int_range(min=1, max=255),
             cv.Optional(CONF_SAMPLING_MODE, default="avg"): _sampling_mode,
         }
@@ -95,8 +83,6 @@ CONFIG_SCHEMA = cv.All(
     validate_config,
 )
 
-CONF_ADC_CHANNEL_ID = "adc_channel_id"
-
 
 async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
@@ -107,7 +93,7 @@ async def to_code(config):
         cg.add_define("USE_ADC_SENSOR_VCC")
     elif config[CONF_PIN] == "TEMPERATURE":
         cg.add(var.set_is_temperature())
-    elif not CORE.is_nrf52 or config[CONF_PIN][CONF_NUMBER] not in EXTRA_ADC:
+    else:
         pin = await cg.gpio_pin_expression(config[CONF_PIN])
         cg.add(var.set_pin(pin))
 
@@ -136,41 +122,3 @@ async def to_code(config):
         ):
             chan = ESP32_VARIANT_ADC2_PIN_TO_CHANNEL[variant][pin_num]
             cg.add(var.set_channel(adc_unit_t.ADC_UNIT_2, chan))
-
-    elif CORE.is_nrf52:
-        CORE.data.setdefault(CONF_ADC_CHANNEL_ID, 0)
-        channel_id = CORE.data[CONF_ADC_CHANNEL_ID]
-        CORE.data[CONF_ADC_CHANNEL_ID] = channel_id + 1
-        zephyr_add_prj_conf("ADC", True)
-        nrf_saadc = config[CONF_NRF_SAADC]
-        rhs = cg.RawExpression(
-            f"ADC_DT_SPEC_GET_BY_IDX(DT_PATH(zephyr_user), {channel_id})"
-        )
-        adc = cg.new_Pvariable(nrf_saadc, rhs)
-        cg.add(var.set_adc_channel(adc))
-        gain = "ADC_GAIN_1_6"
-        pin_number = config[CONF_PIN][CONF_NUMBER]
-        if pin_number == "VDDHDIV5":
-            gain = "ADC_GAIN_1_2"
-        if isinstance(pin_number, int):
-            GPIO_TO_AIN = {v: k for k, v in AIN_TO_GPIO.items()}
-            pin_number = GPIO_TO_AIN[pin_number]
-        zephyr_add_user("io-channels", f"<&adc {channel_id}>")
-        zephyr_add_overlay(
-            f"""
-&adc {{
-    #address-cells = <1>;
-    #size-cells = <0>;
-
-    channel@{channel_id} {{
-        reg = <{channel_id}>;
-        zephyr,gain = "{gain}";
-        zephyr,reference = "ADC_REF_INTERNAL";
-        zephyr,acquisition-time = <ADC_ACQ_TIME_DEFAULT>;
-        zephyr,input-positive = <NRF_SAADC_{pin_number}>;
-        zephyr,resolution = <14>;
-        zephyr,oversampling = <8>;
-    }};
-}};
-"""
-        )

esphome/components/alarm_control_panel/__init__.py

@@ -301,7 +301,8 @@ async def alarm_action_disarm_to_code(config, action_id, template_arg, args):
 )
 async def alarm_action_pending_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, paren)
+    var = cg.new_Pvariable(action_id, template_arg, paren)
+    return var
 
 
 @automation.register_action(
@@ -309,7 +310,8 @@ async def alarm_action_pending_to_code(config, action_id, template_arg, args):
 )
 async def alarm_action_trigger_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, paren)
+    var = cg.new_Pvariable(action_id, template_arg, paren)
+    return var
 
 
 @automation.register_action(
@@ -317,7 +319,8 @@ async def alarm_action_trigger_to_code(config, action_id, template_arg, args):
 )
 async def alarm_action_chime_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, paren)
+    var = cg.new_Pvariable(action_id, template_arg, paren)
+    return var
 
 
 @automation.register_action(
@@ -330,7 +333,8 @@ async def alarm_action_chime_to_code(config, action_id, template_arg, args):
 )
 async def alarm_action_ready_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, paren)
+    var = cg.new_Pvariable(action_id, template_arg, paren)
+    return var
 
 
 @automation.register_condition(
@@ -348,3 +352,4 @@ async def alarm_control_panel_is_armed_to_code(
 @coroutine_with_priority(100.0)
 async def to_code(config):
     cg.add_global(alarm_control_panel_ns.using)
+    cg.add_define("USE_ALARM_CONTROL_PANEL")

esphome/components/animation/__init__.py

@@ -34,20 +34,17 @@ SetFrameAction = animation_ns.class_(
     "AnimationSetFrameAction", automation.Action, cg.Parented.template(Animation_)
 )
 
-CONFIG_SCHEMA = cv.All(
-    espImage.IMAGE_SCHEMA.extend(
-        {
-            cv.Required(CONF_ID): cv.declare_id(Animation_),
-            cv.Optional(CONF_LOOP): cv.All(
-                {
-                    cv.Optional(CONF_START_FRAME, default=0): cv.positive_int,
-                    cv.Optional(CONF_END_FRAME): cv.positive_int,
-                    cv.Optional(CONF_REPEAT): cv.positive_int,
-                }
-            ),
-        },
-    ),
-    espImage.validate_settings,
+CONFIG_SCHEMA = espImage.IMAGE_SCHEMA.extend(
+    {
+        cv.Required(CONF_ID): cv.declare_id(Animation_),
+        cv.Optional(CONF_LOOP): cv.All(
+            {
+                cv.Optional(CONF_START_FRAME, default=0): cv.positive_int,
+                cv.Optional(CONF_END_FRAME): cv.positive_int,
+                cv.Optional(CONF_REPEAT): cv.positive_int,
+            }
+        ),
+    },
 )
 
 

esphome/components/api/__init__.py

@@ -122,6 +122,8 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_CUSTOM_SERVICES, default=False): cv.boolean,
             cv.Optional(CONF_HOMEASSISTANT_SERVICES, default=False): cv.boolean,
             cv.Optional(CONF_HOMEASSISTANT_STATES, default=False): cv.boolean,
+            cv.Optional(CONF_HOMEASSISTANT_SERVICES, default=False): cv.boolean,
+            cv.Optional(CONF_HOMEASSISTANT_STATES, default=False): cv.boolean,
             cv.Optional(CONF_ON_CLIENT_CONNECTED): automation.validate_automation(
                 single=True
             ),

esphome/components/api/api.proto

@@ -419,7 +419,7 @@ message ListEntitiesFanResponse {
   bool disabled_by_default = 9;
   string icon = 10 [(field_ifdef) = "USE_ENTITY_ICON"];
   EntityCategory entity_category = 11;
-  repeated string supported_preset_modes = 12 [(container_pointer) = "std::set"];
+  repeated string supported_preset_modes = 12;
   uint32 device_id = 13 [(field_ifdef) = "USE_DEVICES"];
 }
 // Deprecated in API version 1.6 - only used in deprecated fields
@@ -500,7 +500,7 @@ message ListEntitiesLightResponse {
   string name = 3;
   reserved 4; // Deprecated: was string unique_id
 
-  repeated ColorMode supported_color_modes = 12 [(container_pointer) = "std::set<light::ColorMode>"];
+  repeated ColorMode supported_color_modes = 12;
   // next four supports_* are for legacy clients, newer clients should use color modes
   // Deprecated in API version 1.6
   bool legacy_supports_brightness = 5 [deprecated=true];
@@ -966,7 +966,7 @@ message ListEntitiesClimateResponse {
 
   bool supports_current_temperature = 5;
   bool supports_two_point_target_temperature = 6;
-  repeated ClimateMode supported_modes = 7 [(container_pointer) = "std::set<climate::ClimateMode>"];
+  repeated ClimateMode supported_modes = 7;
   float visual_min_temperature = 8;
   float visual_max_temperature = 9;
   float visual_target_temperature_step = 10;
@@ -975,11 +975,11 @@ message ListEntitiesClimateResponse {
   // Deprecated in API version 1.5
   bool legacy_supports_away = 11 [deprecated=true];
   bool supports_action = 12;
-  repeated ClimateFanMode supported_fan_modes = 13 [(container_pointer) = "std::set<climate::ClimateFanMode>"];
-  repeated ClimateSwingMode supported_swing_modes = 14 [(container_pointer) = "std::set<climate::ClimateSwingMode>"];
-  repeated string supported_custom_fan_modes = 15 [(container_pointer) = "std::set"];
-  repeated ClimatePreset supported_presets = 16 [(container_pointer) = "std::set<climate::ClimatePreset>"];
-  repeated string supported_custom_presets = 17 [(container_pointer) = "std::set"];
+  repeated ClimateFanMode supported_fan_modes = 13;
+  repeated ClimateSwingMode supported_swing_modes = 14;
+  repeated string supported_custom_fan_modes = 15;
+  repeated ClimatePreset supported_presets = 16;
+  repeated string supported_custom_presets = 17;
   bool disabled_by_default = 18;
   string icon = 19 [(field_ifdef) = "USE_ENTITY_ICON"];
   EntityCategory entity_category = 20;
@@ -1119,7 +1119,7 @@ message ListEntitiesSelectResponse {
   reserved 4; // Deprecated: was string unique_id
 
   string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON"];
-  repeated string options = 6 [(container_pointer) = "std::vector"];
+  repeated string options = 6;
   bool disabled_by_default = 7;
   EntityCategory entity_category = 8;
   uint32 device_id = 9 [(field_ifdef) = "USE_DEVICES"];
@@ -1297,9 +1297,6 @@ enum MediaPlayerState {
   MEDIA_PLAYER_STATE_IDLE = 1;
   MEDIA_PLAYER_STATE_PLAYING = 2;
   MEDIA_PLAYER_STATE_PAUSED = 3;
-  MEDIA_PLAYER_STATE_ANNOUNCING = 4;
-  MEDIA_PLAYER_STATE_OFF = 5;
-  MEDIA_PLAYER_STATE_ON = 6;
 }
 enum MediaPlayerCommand {
   MEDIA_PLAYER_COMMAND_PLAY = 0;
@@ -1307,15 +1304,6 @@ enum MediaPlayerCommand {
   MEDIA_PLAYER_COMMAND_STOP = 2;
   MEDIA_PLAYER_COMMAND_MUTE = 3;
   MEDIA_PLAYER_COMMAND_UNMUTE = 4;
-  MEDIA_PLAYER_COMMAND_TOGGLE = 5;
-  MEDIA_PLAYER_COMMAND_VOLUME_UP = 6;
-  MEDIA_PLAYER_COMMAND_VOLUME_DOWN = 7;
-  MEDIA_PLAYER_COMMAND_ENQUEUE = 8;
-  MEDIA_PLAYER_COMMAND_REPEAT_ONE = 9;
-  MEDIA_PLAYER_COMMAND_REPEAT_OFF = 10;
-  MEDIA_PLAYER_COMMAND_CLEAR_PLAYLIST = 11;
-  MEDIA_PLAYER_COMMAND_TURN_ON = 12;
-  MEDIA_PLAYER_COMMAND_TURN_OFF = 13;
 }
 enum MediaPlayerFormatPurpose {
   MEDIA_PLAYER_FORMAT_PURPOSE_DEFAULT = 0;
@@ -1350,8 +1338,6 @@ message ListEntitiesMediaPlayerResponse {
   repeated MediaPlayerSupportedFormat supported_formats = 9;
 
   uint32 device_id = 10 [(field_ifdef) = "USE_DEVICES"];
-
-  uint32 feature_flags = 11;
 }
 message MediaPlayerStateResponse {
   option (id) = 64;
@@ -1482,39 +1468,21 @@ message BluetoothGATTGetServicesRequest {
 }
 
 message BluetoothGATTDescriptor {
-  repeated uint64 uuid = 1 [(fixed_array_size) = 2, (fixed_array_skip_zero) = true];
+  repeated uint64 uuid = 1 [(fixed_array_size) = 2];
   uint32 handle = 2;
-
-  // New field for efficient UUID (v1.12+)
-  // Only one of uuid or short_uuid will be set.
-  // short_uuid is used for both 16-bit and 32-bit UUIDs with v1.12+ clients.
-  // 128-bit UUIDs always use the uuid field for backwards compatibility.
-  uint32 short_uuid = 3;  // 16-bit or 32-bit UUID
 }
 
 message BluetoothGATTCharacteristic {
-  repeated uint64 uuid = 1 [(fixed_array_size) = 2, (fixed_array_skip_zero) = true];
+  repeated uint64 uuid = 1 [(fixed_array_size) = 2];
   uint32 handle = 2;
   uint32 properties = 3;
   repeated BluetoothGATTDescriptor descriptors = 4;
-
-  // New field for efficient UUID (v1.12+)
-  // Only one of uuid or short_uuid will be set.
-  // short_uuid is used for both 16-bit and 32-bit UUIDs with v1.12+ clients.
-  // 128-bit UUIDs always use the uuid field for backwards compatibility.
-  uint32 short_uuid = 5;  // 16-bit or 32-bit UUID
 }
 
 message BluetoothGATTService {
-  repeated uint64 uuid = 1 [(fixed_array_size) = 2, (fixed_array_skip_zero) = true];
+  repeated uint64 uuid = 1 [(fixed_array_size) = 2];
   uint32 handle = 2;
   repeated BluetoothGATTCharacteristic characteristics = 3;
-
-  // New field for efficient UUID (v1.12+)
-  // Only one of uuid or short_uuid will be set.
-  // short_uuid is used for both 16-bit and 32-bit UUIDs with v1.12+ clients.
-  // 128-bit UUIDs always use the uuid field for backwards compatibility.
-  uint32 short_uuid = 4;  // 16-bit or 32-bit UUID
 }
 
 message BluetoothGATTGetServicesResponse {
@@ -1523,7 +1491,7 @@ message BluetoothGATTGetServicesResponse {
   option (ifdef) = "USE_BLUETOOTH_PROXY";
 
   uint64 address = 1;
-  repeated BluetoothGATTService services = 2;
+  repeated BluetoothGATTService services = 2 [(fixed_array_size) = 1];
 }
 
 message BluetoothGATTGetServicesDoneResponse {
@@ -1621,10 +1589,7 @@ message BluetoothConnectionsFreeResponse {
 
   uint32 free = 1;
   uint32 limit = 2;
-  repeated uint64 allocated = 3 [
-    (fixed_array_size_define) = "BLUETOOTH_PROXY_MAX_CONNECTIONS",
-    (fixed_array_skip_zero) = true
-  ];
+  repeated uint64 allocated = 3;
 }
 
 message BluetoothGATTErrorResponse {
@@ -1869,7 +1834,7 @@ message VoiceAssistantConfigurationResponse {
   option (ifdef) = "USE_VOICE_ASSISTANT";
 
   repeated VoiceAssistantWakeWord available_wake_words = 1;
-  repeated string active_wake_words = 2 [(container_pointer) = "std::vector"];
+  repeated string active_wake_words = 2;
   uint32 max_active_wake_words = 3;
 }
 

esphome/components/api/api_connection.cpp

@@ -112,7 +112,8 @@ void APIConnection::start() {
   APIError err = this->helper_->init();
   if (err != APIError::OK) {
     on_fatal_error();
-    this->log_warning_("Helper init failed", err);
+    ESP_LOGW(TAG, "%s: Helper init failed %s errno=%d", this->get_client_combined_info().c_str(), api_error_to_str(err),
+             errno);
     return;
   }
   this->client_info_.peername = helper_->getpeername();
@@ -143,7 +144,8 @@ void APIConnection::loop() {
   APIError err = this->helper_->loop();
   if (err != APIError::OK) {
     on_fatal_error();
-    this->log_socket_operation_failed_(err);
+    ESP_LOGW(TAG, "%s: Socket operation failed %s errno=%d", this->get_client_combined_info().c_str(),
+             api_error_to_str(err), errno);
     return;
   }
 
@@ -159,7 +161,8 @@ void APIConnection::loop() {
         break;
       } else if (err != APIError::OK) {
         on_fatal_error();
-        this->log_warning_("Reading failed", err);
+        ESP_LOGW(TAG, "%s: Reading failed %s errno=%d", this->get_client_combined_info().c_str(), api_error_to_str(err),
+                 errno);
         return;
       } else {
         this->last_traffic_ = now;
@@ -410,7 +413,8 @@ uint16_t APIConnection::try_send_fan_info(EntityBase *entity, APIConnection *con
   msg.supports_speed = traits.supports_speed();
   msg.supports_direction = traits.supports_direction();
   msg.supported_speed_count = traits.supported_speed_count();
-  msg.supported_preset_modes = &traits.supported_preset_modes_for_api_();
+  for (auto const &preset : traits.supported_preset_modes())
+    msg.supported_preset_modes.push_back(preset);
   return fill_and_encode_entity_info(fan, msg, ListEntitiesFanResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
 void APIConnection::fan_command(const FanCommandRequest &msg) {
@@ -466,7 +470,8 @@ uint16_t APIConnection::try_send_light_info(EntityBase *entity, APIConnection *c
   auto *light = static_cast<light::LightState *>(entity);
   ListEntitiesLightResponse msg;
   auto traits = light->get_traits();
-  msg.supported_color_modes = &traits.get_supported_color_modes_for_api_();
+  for (auto mode : traits.get_supported_color_modes())
+    msg.supported_color_modes.push_back(static_cast<enums::ColorMode>(mode));
   if (traits.supports_color_capability(light::ColorCapability::COLOR_TEMPERATURE) ||
       traits.supports_color_capability(light::ColorCapability::COLD_WARM_WHITE)) {
     msg.min_mireds = traits.get_min_mireds();
@@ -652,7 +657,8 @@ uint16_t APIConnection::try_send_climate_info(EntityBase *entity, APIConnection
   msg.supports_current_humidity = traits.get_supports_current_humidity();
   msg.supports_two_point_target_temperature = traits.get_supports_two_point_target_temperature();
   msg.supports_target_humidity = traits.get_supports_target_humidity();
-  msg.supported_modes = &traits.get_supported_modes_for_api_();
+  for (auto mode : traits.get_supported_modes())
+    msg.supported_modes.push_back(static_cast<enums::ClimateMode>(mode));
   msg.visual_min_temperature = traits.get_visual_min_temperature();
   msg.visual_max_temperature = traits.get_visual_max_temperature();
   msg.visual_target_temperature_step = traits.get_visual_target_temperature_step();
@@ -660,11 +666,16 @@ uint16_t APIConnection::try_send_climate_info(EntityBase *entity, APIConnection
   msg.visual_min_humidity = traits.get_visual_min_humidity();
   msg.visual_max_humidity = traits.get_visual_max_humidity();
   msg.supports_action = traits.get_supports_action();
-  msg.supported_fan_modes = &traits.get_supported_fan_modes_for_api_();
-  msg.supported_custom_fan_modes = &traits.get_supported_custom_fan_modes_for_api_();
-  msg.supported_presets = &traits.get_supported_presets_for_api_();
-  msg.supported_custom_presets = &traits.get_supported_custom_presets_for_api_();
-  msg.supported_swing_modes = &traits.get_supported_swing_modes_for_api_();
+  for (auto fan_mode : traits.get_supported_fan_modes())
+    msg.supported_fan_modes.push_back(static_cast<enums::ClimateFanMode>(fan_mode));
+  for (auto const &custom_fan_mode : traits.get_supported_custom_fan_modes())
+    msg.supported_custom_fan_modes.push_back(custom_fan_mode);
+  for (auto preset : traits.get_supported_presets())
+    msg.supported_presets.push_back(static_cast<enums::ClimatePreset>(preset));
+  for (auto const &custom_preset : traits.get_supported_custom_presets())
+    msg.supported_custom_presets.push_back(custom_preset);
+  for (auto swing_mode : traits.get_supported_swing_modes())
+    msg.supported_swing_modes.push_back(static_cast<enums::ClimateSwingMode>(swing_mode));
   return fill_and_encode_entity_info(climate, msg, ListEntitiesClimateResponse::MESSAGE_TYPE, conn, remaining_size,
                                      is_single);
 }
@@ -870,7 +881,8 @@ uint16_t APIConnection::try_send_select_info(EntityBase *entity, APIConnection *
                                              bool is_single) {
   auto *select = static_cast<select::Select *>(entity);
   ListEntitiesSelectResponse msg;
-  msg.options = &select->traits.get_options();
+  for (const auto &option : select->traits.get_options())
+    msg.options.push_back(option);
   return fill_and_encode_entity_info(select, msg, ListEntitiesSelectResponse::MESSAGE_TYPE, conn, remaining_size,
                                      is_single);
 }
@@ -996,7 +1008,6 @@ uint16_t APIConnection::try_send_media_player_info(EntityBase *entity, APIConnec
   ListEntitiesMediaPlayerResponse msg;
   auto traits = media_player->get_traits();
   msg.supports_pause = traits.get_supports_pause();
-  msg.feature_flags = traits.get_feature_flags();
   for (auto &supported_format : traits.get_supported_formats()) {
     msg.supported_formats.emplace_back();
     auto &media_format = msg.supported_formats.back();
@@ -1105,8 +1116,10 @@ void APIConnection::bluetooth_gatt_notify(const BluetoothGATTNotifyRequest &msg)
 
 bool APIConnection::send_subscribe_bluetooth_connections_free_response(
     const SubscribeBluetoothConnectionsFreeRequest &msg) {
-  bluetooth_proxy::global_bluetooth_proxy->send_connections_free(this);
-  return true;
+  BluetoothConnectionsFreeResponse resp;
+  resp.free = bluetooth_proxy::global_bluetooth_proxy->get_bluetooth_connections_free();
+  resp.limit = bluetooth_proxy::global_bluetooth_proxy->get_bluetooth_connections_limit();
+  return this->send_message(resp, BluetoothConnectionsFreeResponse::MESSAGE_TYPE);
 }
 
 void APIConnection::bluetooth_scanner_set_mode(const BluetoothScannerSetModeRequest &msg) {
@@ -1183,7 +1196,9 @@ bool APIConnection::send_voice_assistant_get_configuration_response(const VoiceA
       resp_wake_word.trained_languages.push_back(lang);
     }
   }
-  resp.active_wake_words = &config.active_wake_words;
+  for (auto &wake_word_id : config.active_wake_words) {
+    resp.active_wake_words.push_back(wake_word_id);
+  }
   resp.max_active_wake_words = config.max_active_wake_words;
   return this->send_message(resp, VoiceAssistantConfigurationResponse::MESSAGE_TYPE);
 }
@@ -1361,7 +1376,7 @@ bool APIConnection::send_hello_response(const HelloRequest &msg) {
 
   HelloResponse resp;
   resp.api_version_major = 1;
-  resp.api_version_minor = 12;
+  resp.api_version_minor = 10;
   // Temporary string for concatenation - will be valid during send_message call
   std::string server_info = App.get_name() + " (esphome v" ESPHOME_VERSION ")";
   resp.set_server_info(StringRef(server_info));
@@ -1535,7 +1550,8 @@ bool APIConnection::try_to_clear_buffer(bool log_out_of_space) {
   APIError err = this->helper_->loop();
   if (err != APIError::OK) {
     on_fatal_error();
-    this->log_socket_operation_failed_(err);
+    ESP_LOGW(TAG, "%s: Socket operation failed %s errno=%d", this->get_client_combined_info().c_str(),
+             api_error_to_str(err), errno);
     return false;
   }
   if (this->helper_->can_write_without_blocking())
@@ -1555,7 +1571,8 @@ bool APIConnection::send_buffer(ProtoWriteBuffer buffer, uint8_t message_type) {
     return false;
   if (err != APIError::OK) {
     on_fatal_error();
-    this->log_warning_("Packet write failed", err);
+    ESP_LOGW(TAG, "%s: Packet write failed %s errno=%d", this->get_client_combined_info().c_str(),
+             api_error_to_str(err), errno);
     return false;
   }
   // Do not set last_traffic_ on send
@@ -1640,8 +1657,6 @@ void APIConnection::process_batch_() {
     return;
   }
 
-  // Get shared buffer reference once to avoid multiple calls
-  auto &shared_buf = this->parent_->get_shared_buffer_ref();
   size_t num_items = this->deferred_batch_.size();
 
   // Fast path for single message - allocate exact size needed
@@ -1652,7 +1667,8 @@ void APIConnection::process_batch_() {
     uint16_t payload_size =
         item.creator(item.entity, this, std::numeric_limits<uint16_t>::max(), true, item.message_type);
 
-    if (payload_size > 0 && this->send_buffer(ProtoWriteBuffer{&shared_buf}, item.message_type)) {
+    if (payload_size > 0 &&
+        this->send_buffer(ProtoWriteBuffer{&this->parent_->get_shared_buffer_ref()}, item.message_type)) {
 #ifdef HAS_PROTO_MESSAGE_DUMP
       // Log messages after send attempt for VV debugging
       // It's safe to use the buffer for logging at this point regardless of send result
@@ -1679,18 +1695,20 @@ void APIConnection::process_batch_() {
   const uint8_t footer_size = this->helper_->frame_footer_size();
 
   // Initialize buffer and tracking variables
-  shared_buf.clear();
+  this->parent_->get_shared_buffer_ref().clear();
 
   // Pre-calculate exact buffer size needed based on message types
-  uint32_t total_estimated_size = num_items * (header_padding + footer_size);
+  uint32_t total_estimated_size = 0;
   for (size_t i = 0; i < this->deferred_batch_.size(); i++) {
     const auto &item = this->deferred_batch_[i];
     total_estimated_size += item.estimated_size;
   }
 
   // Calculate total overhead for all messages
+  uint32_t total_overhead = (header_padding + footer_size) * num_items;
+
   // Reserve based on estimated size (much more accurate than 24-byte worst-case)
-  shared_buf.reserve(total_estimated_size);
+  this->parent_->get_shared_buffer_ref().reserve(total_estimated_size + total_overhead);
   this->flags_.batch_first_message = true;
 
   size_t items_processed = 0;
@@ -1732,7 +1750,7 @@ void APIConnection::process_batch_() {
     remaining_size -= payload_size;
     // Calculate where the next message's header padding will start
     // Current buffer size + footer space (that prepare_message_buffer will add for this message)
-    current_offset = shared_buf.size() + footer_size;
+    current_offset = this->parent_->get_shared_buffer_ref().size() + footer_size;
   }
 
   if (items_processed == 0) {
@@ -1742,15 +1760,17 @@ void APIConnection::process_batch_() {
 
   // Add footer space for the last message (for Noise protocol MAC)
   if (footer_size > 0) {
+    auto &shared_buf = this->parent_->get_shared_buffer_ref();
     shared_buf.resize(shared_buf.size() + footer_size);
   }
 
   // Send all collected packets
-  APIError err = this->helper_->write_protobuf_packets(ProtoWriteBuffer{&shared_buf},
+  APIError err = this->helper_->write_protobuf_packets(ProtoWriteBuffer{&this->parent_->get_shared_buffer_ref()},
                                                        std::span<const PacketInfo>(packet_info, packet_count));
   if (err != APIError::OK && err != APIError::WOULD_BLOCK) {
     on_fatal_error();
-    this->log_warning_("Batch write failed", err);
+    ESP_LOGW(TAG, "%s: Batch write failed %s errno=%d", this->get_client_combined_info().c_str(), api_error_to_str(err),
+             errno);
   }
 
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -1828,11 +1848,5 @@ void APIConnection::process_state_subscriptions_() {
 }
 #endif  // USE_API_HOMEASSISTANT_STATES
 
-void APIConnection::log_warning_(const char *message, APIError err) {
-  ESP_LOGW(TAG, "%s: %s %s errno=%d", this->get_client_combined_info().c_str(), message, api_error_to_str(err), errno);
-}
-
-void APIConnection::log_socket_operation_failed_(APIError err) { this->log_warning_("Socket operation failed", err); }
-
 }  // namespace esphome::api
 #endif

esphome/components/api/api_connection.h

@@ -235,13 +235,6 @@ class APIConnection : public APIServerConnection {
            this->is_authenticated();
   }
   uint8_t get_log_subscription_level() const { return this->flags_.log_subscription; }
-
-  // Get client API version for feature detection
-  bool client_supports_api_version(uint16_t major, uint16_t minor) const {
-    return this->client_api_version_major_ > major ||
-           (this->client_api_version_major_ == major && this->client_api_version_minor_ >= minor);
-  }
-
   void on_fatal_error() override;
 #ifdef USE_API_PASSWORD
   void on_unauthenticated_access() override;
@@ -307,7 +300,7 @@ class APIConnection : public APIServerConnection {
 
 #ifdef USE_API_HOMEASSISTANT_STATES
   void process_state_subscriptions_();
-#endif
+#endif  // USE_API_HOMEASSISTANT_STATES
 
   // Non-template helper to encode any ProtoMessage
   static uint16_t encode_message_to_buffer(ProtoMessage &msg, uint8_t message_type, APIConnection *conn,
@@ -743,11 +736,6 @@ class APIConnection : public APIServerConnection {
     this->deferred_batch_.add_item_front(entity, MessageCreator(function_ptr), message_type, estimated_size);
     return this->schedule_batch_();
   }
-
-  // Helper function to log API errors with errno
-  void log_warning_(const char *message, APIError err);
-  // Specific helper for duplicated error message
-  void log_socket_operation_failed_(APIError err);
 };
 
 }  // namespace esphome::api

esphome/components/api/api_options.proto

@@ -28,32 +28,4 @@ extend google.protobuf.FieldOptions {
     optional string field_ifdef = 1042;
     optional uint32 fixed_array_size = 50007;
     optional bool no_zero_copy = 50008 [default=false];
-    optional bool fixed_array_skip_zero = 50009 [default=false];
-    optional string fixed_array_size_define = 50010;
-
-    // container_pointer: Zero-copy optimization for repeated fields.
-    //
-    // When container_pointer is set on a repeated field, the generated message will
-    // store a pointer to an existing container instead of copying the data into the
-    // message's own repeated field. This eliminates heap allocations and improves performance.
-    //
-    // Requirements for safe usage:
-    // 1. The source container must remain valid until the message is encoded
-    // 2. Messages must be encoded immediately (which ESPHome does by default)
-    // 3. The container type must match the field type exactly
-    //
-    // Supported container types:
-    // - "std::vector<T>" for most repeated fields
-    // - "std::set<T>" for unique/sorted data
-    // - Full type specification required for enums (e.g., "std::set<climate::ClimateMode>")
-    //
-    // Example usage in .proto file:
-    //   repeated string supported_modes = 12 [(container_pointer) = "std::set"];
-    //   repeated ColorMode color_modes = 13 [(container_pointer) = "std::set<light::ColorMode>"];
-    //
-    // The corresponding C++ code must provide const reference access to a container
-    // that matches the specified type and remains valid during message encoding.
-    // This is typically done through methods returning const T& or special accessor
-    // methods like get_options() or supported_modes_for_api_().
-    optional string container_pointer = 50001;
 }

esphome/components/api/api_pb2.cpp

@@ -331,7 +331,7 @@ void ListEntitiesFanResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(10, this->icon_ref_);
 #endif
   buffer.encode_uint32(11, static_cast<uint32_t>(this->entity_category));
-  for (const auto &it : *this->supported_preset_modes) {
+  for (auto &it : this->supported_preset_modes) {
     buffer.encode_string(12, it, true);
   }
 #ifdef USE_DEVICES
@@ -351,8 +351,8 @@ void ListEntitiesFanResponse::calculate_size(ProtoSize &size) const {
   size.add_length(1, this->icon_ref_.size());
 #endif
   size.add_uint32(1, static_cast<uint32_t>(this->entity_category));
-  if (!this->supported_preset_modes->empty()) {
-    for (const auto &it : *this->supported_preset_modes) {
+  if (!this->supported_preset_modes.empty()) {
+    for (const auto &it : this->supported_preset_modes) {
       size.add_length_force(1, it.size());
     }
   }
@@ -447,7 +447,7 @@ void ListEntitiesLightResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id_ref_);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name_ref_);
-  for (const auto &it : *this->supported_color_modes) {
+  for (auto &it : this->supported_color_modes) {
     buffer.encode_uint32(12, static_cast<uint32_t>(it), true);
   }
   buffer.encode_float(9, this->min_mireds);
@@ -468,8 +468,8 @@ void ListEntitiesLightResponse::calculate_size(ProtoSize &size) const {
   size.add_length(1, this->object_id_ref_.size());
   size.add_fixed32(1, this->key);
   size.add_length(1, this->name_ref_.size());
-  if (!this->supported_color_modes->empty()) {
-    for (const auto &it : *this->supported_color_modes) {
+  if (!this->supported_color_modes.empty()) {
+    for (const auto &it : this->supported_color_modes) {
       size.add_uint32_force(1, static_cast<uint32_t>(it));
     }
   }
@@ -1064,26 +1064,26 @@ void ListEntitiesClimateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(3, this->name_ref_);
   buffer.encode_bool(5, this->supports_current_temperature);
   buffer.encode_bool(6, this->supports_two_point_target_temperature);
-  for (const auto &it : *this->supported_modes) {
+  for (auto &it : this->supported_modes) {
     buffer.encode_uint32(7, static_cast<uint32_t>(it), true);
   }
   buffer.encode_float(8, this->visual_min_temperature);
   buffer.encode_float(9, this->visual_max_temperature);
   buffer.encode_float(10, this->visual_target_temperature_step);
   buffer.encode_bool(12, this->supports_action);
-  for (const auto &it : *this->supported_fan_modes) {
+  for (auto &it : this->supported_fan_modes) {
     buffer.encode_uint32(13, static_cast<uint32_t>(it), true);
   }
-  for (const auto &it : *this->supported_swing_modes) {
+  for (auto &it : this->supported_swing_modes) {
     buffer.encode_uint32(14, static_cast<uint32_t>(it), true);
   }
-  for (const auto &it : *this->supported_custom_fan_modes) {
+  for (auto &it : this->supported_custom_fan_modes) {
     buffer.encode_string(15, it, true);
   }
-  for (const auto &it : *this->supported_presets) {
+  for (auto &it : this->supported_presets) {
     buffer.encode_uint32(16, static_cast<uint32_t>(it), true);
   }
-  for (const auto &it : *this->supported_custom_presets) {
+  for (auto &it : this->supported_custom_presets) {
     buffer.encode_string(17, it, true);
   }
   buffer.encode_bool(18, this->disabled_by_default);
@@ -1106,8 +1106,8 @@ void ListEntitiesClimateResponse::calculate_size(ProtoSize &size) const {
   size.add_length(1, this->name_ref_.size());
   size.add_bool(1, this->supports_current_temperature);
   size.add_bool(1, this->supports_two_point_target_temperature);
-  if (!this->supported_modes->empty()) {
-    for (const auto &it : *this->supported_modes) {
+  if (!this->supported_modes.empty()) {
+    for (const auto &it : this->supported_modes) {
       size.add_uint32_force(1, static_cast<uint32_t>(it));
     }
   }
@@ -1115,28 +1115,28 @@ void ListEntitiesClimateResponse::calculate_size(ProtoSize &size) const {
   size.add_float(1, this->visual_max_temperature);
   size.add_float(1, this->visual_target_temperature_step);
   size.add_bool(1, this->supports_action);
-  if (!this->supported_fan_modes->empty()) {
-    for (const auto &it : *this->supported_fan_modes) {
+  if (!this->supported_fan_modes.empty()) {
+    for (const auto &it : this->supported_fan_modes) {
       size.add_uint32_force(1, static_cast<uint32_t>(it));
     }
   }
-  if (!this->supported_swing_modes->empty()) {
-    for (const auto &it : *this->supported_swing_modes) {
+  if (!this->supported_swing_modes.empty()) {
+    for (const auto &it : this->supported_swing_modes) {
       size.add_uint32_force(1, static_cast<uint32_t>(it));
     }
   }
-  if (!this->supported_custom_fan_modes->empty()) {
-    for (const auto &it : *this->supported_custom_fan_modes) {
+  if (!this->supported_custom_fan_modes.empty()) {
+    for (const auto &it : this->supported_custom_fan_modes) {
       size.add_length_force(1, it.size());
     }
   }
-  if (!this->supported_presets->empty()) {
-    for (const auto &it : *this->supported_presets) {
+  if (!this->supported_presets.empty()) {
+    for (const auto &it : this->supported_presets) {
       size.add_uint32_force(2, static_cast<uint32_t>(it));
     }
   }
-  if (!this->supported_custom_presets->empty()) {
-    for (const auto &it : *this->supported_custom_presets) {
+  if (!this->supported_custom_presets.empty()) {
+    for (const auto &it : this->supported_custom_presets) {
       size.add_length_force(2, it.size());
     }
   }
@@ -1371,7 +1371,7 @@ void ListEntitiesSelectResponse::encode(ProtoWriteBuffer buffer) const {
 #ifdef USE_ENTITY_ICON
   buffer.encode_string(5, this->icon_ref_);
 #endif
-  for (const auto &it : *this->options) {
+  for (auto &it : this->options) {
     buffer.encode_string(6, it, true);
   }
   buffer.encode_bool(7, this->disabled_by_default);
@@ -1387,8 +1387,8 @@ void ListEntitiesSelectResponse::calculate_size(ProtoSize &size) const {
 #ifdef USE_ENTITY_ICON
   size.add_length(1, this->icon_ref_.size());
 #endif
-  if (!this->options->empty()) {
-    for (const auto &it : *this->options) {
+  if (!this->options.empty()) {
+    for (const auto &it : this->options) {
       size.add_length_force(1, it.size());
     }
   }
@@ -1725,7 +1725,6 @@ void ListEntitiesMediaPlayerResponse::encode(ProtoWriteBuffer buffer) const {
 #ifdef USE_DEVICES
   buffer.encode_uint32(10, this->device_id);
 #endif
-  buffer.encode_uint32(11, this->feature_flags);
 }
 void ListEntitiesMediaPlayerResponse::calculate_size(ProtoSize &size) const {
   size.add_length(1, this->object_id_ref_.size());
@@ -1741,7 +1740,6 @@ void ListEntitiesMediaPlayerResponse::calculate_size(ProtoSize &size) const {
 #ifdef USE_DEVICES
   size.add_uint32(1, this->device_id);
 #endif
-  size.add_uint32(1, this->feature_flags);
 }
 void MediaPlayerStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_fixed32(1, this->key);
@@ -1888,72 +1886,52 @@ bool BluetoothGATTGetServicesRequest::decode_varint(uint32_t field_id, ProtoVarI
   return true;
 }
 void BluetoothGATTDescriptor::encode(ProtoWriteBuffer buffer) const {
-  if (this->uuid[0] != 0 || this->uuid[1] != 0) {
-    buffer.encode_uint64(1, this->uuid[0], true);
-    buffer.encode_uint64(1, this->uuid[1], true);
-  }
+  buffer.encode_uint64(1, this->uuid[0], true);
+  buffer.encode_uint64(1, this->uuid[1], true);
   buffer.encode_uint32(2, this->handle);
-  buffer.encode_uint32(3, this->short_uuid);
 }
 void BluetoothGATTDescriptor::calculate_size(ProtoSize &size) const {
-  if (this->uuid[0] != 0 || this->uuid[1] != 0) {
-    size.add_uint64_force(1, this->uuid[0]);
-    size.add_uint64_force(1, this->uuid[1]);
-  }
+  size.add_uint64_force(1, this->uuid[0]);
+  size.add_uint64_force(1, this->uuid[1]);
   size.add_uint32(1, this->handle);
-  size.add_uint32(1, this->short_uuid);
 }
 void BluetoothGATTCharacteristic::encode(ProtoWriteBuffer buffer) const {
-  if (this->uuid[0] != 0 || this->uuid[1] != 0) {
-    buffer.encode_uint64(1, this->uuid[0], true);
-    buffer.encode_uint64(1, this->uuid[1], true);
-  }
+  buffer.encode_uint64(1, this->uuid[0], true);
+  buffer.encode_uint64(1, this->uuid[1], true);
   buffer.encode_uint32(2, this->handle);
   buffer.encode_uint32(3, this->properties);
   for (auto &it : this->descriptors) {
     buffer.encode_message(4, it, true);
   }
-  buffer.encode_uint32(5, this->short_uuid);
 }
 void BluetoothGATTCharacteristic::calculate_size(ProtoSize &size) const {
-  if (this->uuid[0] != 0 || this->uuid[1] != 0) {
-    size.add_uint64_force(1, this->uuid[0]);
-    size.add_uint64_force(1, this->uuid[1]);
-  }
+  size.add_uint64_force(1, this->uuid[0]);
+  size.add_uint64_force(1, this->uuid[1]);
   size.add_uint32(1, this->handle);
   size.add_uint32(1, this->properties);
   size.add_repeated_message(1, this->descriptors);
-  size.add_uint32(1, this->short_uuid);
 }
 void BluetoothGATTService::encode(ProtoWriteBuffer buffer) const {
-  if (this->uuid[0] != 0 || this->uuid[1] != 0) {
-    buffer.encode_uint64(1, this->uuid[0], true);
-    buffer.encode_uint64(1, this->uuid[1], true);
-  }
+  buffer.encode_uint64(1, this->uuid[0], true);
+  buffer.encode_uint64(1, this->uuid[1], true);
   buffer.encode_uint32(2, this->handle);
   for (auto &it : this->characteristics) {
     buffer.encode_message(3, it, true);
   }
-  buffer.encode_uint32(4, this->short_uuid);
 }
 void BluetoothGATTService::calculate_size(ProtoSize &size) const {
-  if (this->uuid[0] != 0 || this->uuid[1] != 0) {
-    size.add_uint64_force(1, this->uuid[0]);
-    size.add_uint64_force(1, this->uuid[1]);
-  }
+  size.add_uint64_force(1, this->uuid[0]);
+  size.add_uint64_force(1, this->uuid[1]);
   size.add_uint32(1, this->handle);
   size.add_repeated_message(1, this->characteristics);
-  size.add_uint32(1, this->short_uuid);
 }
 void BluetoothGATTGetServicesResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint64(1, this->address);
-  for (auto &it : this->services) {
-    buffer.encode_message(2, it, true);
-  }
+  buffer.encode_message(2, this->services[0], true);
 }
 void BluetoothGATTGetServicesResponse::calculate_size(ProtoSize &size) const {
   size.add_uint64(1, this->address);
-  size.add_repeated_message(1, this->services);
+  size.add_message_object_force(1, this->services[0]);
 }
 void BluetoothGATTGetServicesDoneResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint64(1, this->address);
@@ -2073,17 +2051,15 @@ void BluetoothGATTNotifyDataResponse::calculate_size(ProtoSize &size) const {
 void BluetoothConnectionsFreeResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint32(1, this->free);
   buffer.encode_uint32(2, this->limit);
-  for (const auto &it : this->allocated) {
-    if (it != 0) {
-      buffer.encode_uint64(3, it, true);
-    }
+  for (auto &it : this->allocated) {
+    buffer.encode_uint64(3, it, true);
   }
 }
 void BluetoothConnectionsFreeResponse::calculate_size(ProtoSize &size) const {
   size.add_uint32(1, this->free);
   size.add_uint32(1, this->limit);
-  for (const auto &it : this->allocated) {
-    if (it != 0) {
+  if (!this->allocated.empty()) {
+    for (const auto &it : this->allocated) {
       size.add_uint64_force(1, it);
     }
   }
@@ -2356,15 +2332,15 @@ void VoiceAssistantConfigurationResponse::encode(ProtoWriteBuffer buffer) const
   for (auto &it : this->available_wake_words) {
     buffer.encode_message(1, it, true);
   }
-  for (const auto &it : *this->active_wake_words) {
+  for (auto &it : this->active_wake_words) {
     buffer.encode_string(2, it, true);
   }
   buffer.encode_uint32(3, this->max_active_wake_words);
 }
 void VoiceAssistantConfigurationResponse::calculate_size(ProtoSize &size) const {
   size.add_repeated_message(1, this->available_wake_words);
-  if (!this->active_wake_words->empty()) {
-    for (const auto &it : *this->active_wake_words) {
+  if (!this->active_wake_words.empty()) {
+    for (const auto &it : this->active_wake_words) {
       size.add_length_force(1, it.size());
     }
   }

esphome/components/api/api_pb2.h

@@ -6,7 +6,6 @@
 #include "esphome/core/string_ref.h"
 
 #include "proto.h"
-#include "api_pb2_includes.h"
 
 namespace esphome::api {
 
@@ -150,9 +149,6 @@ enum MediaPlayerState : uint32_t {
   MEDIA_PLAYER_STATE_IDLE = 1,
   MEDIA_PLAYER_STATE_PLAYING = 2,
   MEDIA_PLAYER_STATE_PAUSED = 3,
-  MEDIA_PLAYER_STATE_ANNOUNCING = 4,
-  MEDIA_PLAYER_STATE_OFF = 5,
-  MEDIA_PLAYER_STATE_ON = 6,
 };
 enum MediaPlayerCommand : uint32_t {
   MEDIA_PLAYER_COMMAND_PLAY = 0,
@@ -160,15 +156,6 @@ enum MediaPlayerCommand : uint32_t {
   MEDIA_PLAYER_COMMAND_STOP = 2,
   MEDIA_PLAYER_COMMAND_MUTE = 3,
   MEDIA_PLAYER_COMMAND_UNMUTE = 4,
-  MEDIA_PLAYER_COMMAND_TOGGLE = 5,
-  MEDIA_PLAYER_COMMAND_VOLUME_UP = 6,
-  MEDIA_PLAYER_COMMAND_VOLUME_DOWN = 7,
-  MEDIA_PLAYER_COMMAND_ENQUEUE = 8,
-  MEDIA_PLAYER_COMMAND_REPEAT_ONE = 9,
-  MEDIA_PLAYER_COMMAND_REPEAT_OFF = 10,
-  MEDIA_PLAYER_COMMAND_CLEAR_PLAYLIST = 11,
-  MEDIA_PLAYER_COMMAND_TURN_ON = 12,
-  MEDIA_PLAYER_COMMAND_TURN_OFF = 13,
 };
 enum MediaPlayerFormatPurpose : uint32_t {
   MEDIA_PLAYER_FORMAT_PURPOSE_DEFAULT = 0,
@@ -708,7 +695,7 @@ class ListEntitiesFanResponse : public InfoResponseProtoMessage {
   bool supports_speed{false};
   bool supports_direction{false};
   int32_t supported_speed_count{0};
-  const std::set<std::string> *supported_preset_modes{};
+  std::vector<std::string> supported_preset_modes{};
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -773,7 +760,7 @@ class ListEntitiesLightResponse : public InfoResponseProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "list_entities_light_response"; }
 #endif
-  const std::set<light::ColorMode> *supported_color_modes{};
+  std::vector<enums::ColorMode> supported_color_modes{};
   float min_mireds{0.0f};
   float max_mireds{0.0f};
   std::vector<std::string> effects{};
@@ -1324,16 +1311,16 @@ class ListEntitiesClimateResponse : public InfoResponseProtoMessage {
 #endif
   bool supports_current_temperature{false};
   bool supports_two_point_target_temperature{false};
-  const std::set<climate::ClimateMode> *supported_modes{};
+  std::vector<enums::ClimateMode> supported_modes{};
   float visual_min_temperature{0.0f};
   float visual_max_temperature{0.0f};
   float visual_target_temperature_step{0.0f};
   bool supports_action{false};
-  const std::set<climate::ClimateFanMode> *supported_fan_modes{};
-  const std::set<climate::ClimateSwingMode> *supported_swing_modes{};
-  const std::set<std::string> *supported_custom_fan_modes{};
-  const std::set<climate::ClimatePreset> *supported_presets{};
-  const std::set<std::string> *supported_custom_presets{};
+  std::vector<enums::ClimateFanMode> supported_fan_modes{};
+  std::vector<enums::ClimateSwingMode> supported_swing_modes{};
+  std::vector<std::string> supported_custom_fan_modes{};
+  std::vector<enums::ClimatePreset> supported_presets{};
+  std::vector<std::string> supported_custom_presets{};
   float visual_current_temperature_step{0.0f};
   bool supports_current_humidity{false};
   bool supports_target_humidity{false};
@@ -1480,7 +1467,7 @@ class ListEntitiesSelectResponse : public InfoResponseProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "list_entities_select_response"; }
 #endif
-  const std::vector<std::string> *options{};
+  std::vector<std::string> options{};
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -1696,13 +1683,12 @@ class MediaPlayerSupportedFormat : public ProtoMessage {
 class ListEntitiesMediaPlayerResponse : public InfoResponseProtoMessage {
  public:
   static constexpr uint8_t MESSAGE_TYPE = 63;
-  static constexpr uint8_t ESTIMATED_SIZE = 80;
+  static constexpr uint8_t ESTIMATED_SIZE = 76;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "list_entities_media_player_response"; }
 #endif
   bool supports_pause{false};
   std::vector<MediaPlayerSupportedFormat> supported_formats{};
-  uint32_t feature_flags{0};
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -1857,7 +1843,6 @@ class BluetoothGATTDescriptor : public ProtoMessage {
  public:
   std::array<uint64_t, 2> uuid{};
   uint32_t handle{0};
-  uint32_t short_uuid{0};
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -1872,7 +1857,6 @@ class BluetoothGATTCharacteristic : public ProtoMessage {
   uint32_t handle{0};
   uint32_t properties{0};
   std::vector<BluetoothGATTDescriptor> descriptors{};
-  uint32_t short_uuid{0};
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -1886,7 +1870,6 @@ class BluetoothGATTService : public ProtoMessage {
   std::array<uint64_t, 2> uuid{};
   uint32_t handle{0};
   std::vector<BluetoothGATTCharacteristic> characteristics{};
-  uint32_t short_uuid{0};
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -1898,12 +1881,12 @@ class BluetoothGATTService : public ProtoMessage {
 class BluetoothGATTGetServicesResponse : public ProtoMessage {
  public:
   static constexpr uint8_t MESSAGE_TYPE = 71;
-  static constexpr uint8_t ESTIMATED_SIZE = 38;
+  static constexpr uint8_t ESTIMATED_SIZE = 21;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "bluetooth_gatt_get_services_response"; }
 #endif
   uint64_t address{0};
-  std::vector<BluetoothGATTService> services{};
+  std::array<BluetoothGATTService, 1> services{};
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -2076,13 +2059,13 @@ class SubscribeBluetoothConnectionsFreeRequest : public ProtoMessage {
 class BluetoothConnectionsFreeResponse : public ProtoMessage {
  public:
   static constexpr uint8_t MESSAGE_TYPE = 81;
-  static constexpr uint8_t ESTIMATED_SIZE = 20;
+  static constexpr uint8_t ESTIMATED_SIZE = 16;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "bluetooth_connections_free_response"; }
 #endif
   uint32_t free{0};
   uint32_t limit{0};
-  std::array<uint64_t, BLUETOOTH_PROXY_MAX_CONNECTIONS> allocated{};
+  std::vector<uint64_t> allocated{};
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -2456,7 +2439,7 @@ class VoiceAssistantConfigurationResponse : public ProtoMessage {
   const char *message_name() const override { return "voice_assistant_configuration_response"; }
 #endif
   std::vector<VoiceAssistantWakeWord> available_wake_words{};
-  const std::vector<std::string> *active_wake_words{};
+  std::vector<std::string> active_wake_words{};
   uint32_t max_active_wake_words{0};
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;

esphome/components/api/api_pb2_dump.cpp

@@ -383,12 +383,6 @@ template<> const char *proto_enum_to_string<enums::MediaPlayerState>(enums::Medi
       return "MEDIA_PLAYER_STATE_PLAYING";
     case enums::MEDIA_PLAYER_STATE_PAUSED:
       return "MEDIA_PLAYER_STATE_PAUSED";
-    case enums::MEDIA_PLAYER_STATE_ANNOUNCING:
-      return "MEDIA_PLAYER_STATE_ANNOUNCING";
-    case enums::MEDIA_PLAYER_STATE_OFF:
-      return "MEDIA_PLAYER_STATE_OFF";
-    case enums::MEDIA_PLAYER_STATE_ON:
-      return "MEDIA_PLAYER_STATE_ON";
     default:
       return "UNKNOWN";
   }
@@ -405,24 +399,6 @@ template<> const char *proto_enum_to_string<enums::MediaPlayerCommand>(enums::Me
       return "MEDIA_PLAYER_COMMAND_MUTE";
     case enums::MEDIA_PLAYER_COMMAND_UNMUTE:
       return "MEDIA_PLAYER_COMMAND_UNMUTE";
-    case enums::MEDIA_PLAYER_COMMAND_TOGGLE:
-      return "MEDIA_PLAYER_COMMAND_TOGGLE";
-    case enums::MEDIA_PLAYER_COMMAND_VOLUME_UP:
-      return "MEDIA_PLAYER_COMMAND_VOLUME_UP";
-    case enums::MEDIA_PLAYER_COMMAND_VOLUME_DOWN:
-      return "MEDIA_PLAYER_COMMAND_VOLUME_DOWN";
-    case enums::MEDIA_PLAYER_COMMAND_ENQUEUE:
-      return "MEDIA_PLAYER_COMMAND_ENQUEUE";
-    case enums::MEDIA_PLAYER_COMMAND_REPEAT_ONE:
-      return "MEDIA_PLAYER_COMMAND_REPEAT_ONE";
-    case enums::MEDIA_PLAYER_COMMAND_REPEAT_OFF:
-      return "MEDIA_PLAYER_COMMAND_REPEAT_OFF";
-    case enums::MEDIA_PLAYER_COMMAND_CLEAR_PLAYLIST:
-      return "MEDIA_PLAYER_COMMAND_CLEAR_PLAYLIST";
-    case enums::MEDIA_PLAYER_COMMAND_TURN_ON:
-      return "MEDIA_PLAYER_COMMAND_TURN_ON";
-    case enums::MEDIA_PLAYER_COMMAND_TURN_OFF:
-      return "MEDIA_PLAYER_COMMAND_TURN_OFF";
     default:
       return "UNKNOWN";
   }
@@ -838,7 +814,7 @@ void ListEntitiesFanResponse::dump_to(std::string &out) const {
   dump_field(out, "icon", this->icon_ref_);
 #endif
   dump_field(out, "entity_category", static_cast<enums::EntityCategory>(this->entity_category));
-  for (const auto &it : *this->supported_preset_modes) {
+  for (const auto &it : this->supported_preset_modes) {
     dump_field(out, "supported_preset_modes", it, 4);
   }
 #ifdef USE_DEVICES
@@ -881,7 +857,7 @@ void ListEntitiesLightResponse::dump_to(std::string &out) const {
   dump_field(out, "object_id", this->object_id_ref_);
   dump_field(out, "key", this->key);
   dump_field(out, "name", this->name_ref_);
-  for (const auto &it : *this->supported_color_modes) {
+  for (const auto &it : this->supported_color_modes) {
     dump_field(out, "supported_color_modes", static_cast<enums::ColorMode>(it), 4);
   }
   dump_field(out, "min_mireds", this->min_mireds);
@@ -1197,26 +1173,26 @@ void ListEntitiesClimateResponse::dump_to(std::string &out) const {
   dump_field(out, "name", this->name_ref_);
   dump_field(out, "supports_current_temperature", this->supports_current_temperature);
   dump_field(out, "supports_two_point_target_temperature", this->supports_two_point_target_temperature);
-  for (const auto &it : *this->supported_modes) {
+  for (const auto &it : this->supported_modes) {
     dump_field(out, "supported_modes", static_cast<enums::ClimateMode>(it), 4);
   }
   dump_field(out, "visual_min_temperature", this->visual_min_temperature);
   dump_field(out, "visual_max_temperature", this->visual_max_temperature);
   dump_field(out, "visual_target_temperature_step", this->visual_target_temperature_step);
   dump_field(out, "supports_action", this->supports_action);
-  for (const auto &it : *this->supported_fan_modes) {
+  for (const auto &it : this->supported_fan_modes) {
     dump_field(out, "supported_fan_modes", static_cast<enums::ClimateFanMode>(it), 4);
   }
-  for (const auto &it : *this->supported_swing_modes) {
+  for (const auto &it : this->supported_swing_modes) {
     dump_field(out, "supported_swing_modes", static_cast<enums::ClimateSwingMode>(it), 4);
   }
-  for (const auto &it : *this->supported_custom_fan_modes) {
+  for (const auto &it : this->supported_custom_fan_modes) {
     dump_field(out, "supported_custom_fan_modes", it, 4);
   }
-  for (const auto &it : *this->supported_presets) {
+  for (const auto &it : this->supported_presets) {
     dump_field(out, "supported_presets", static_cast<enums::ClimatePreset>(it), 4);
   }
-  for (const auto &it : *this->supported_custom_presets) {
+  for (const auto &it : this->supported_custom_presets) {
     dump_field(out, "supported_custom_presets", it, 4);
   }
   dump_field(out, "disabled_by_default", this->disabled_by_default);
@@ -1329,7 +1305,7 @@ void ListEntitiesSelectResponse::dump_to(std::string &out) const {
 #ifdef USE_ENTITY_ICON
   dump_field(out, "icon", this->icon_ref_);
 #endif
-  for (const auto &it : *this->options) {
+  for (const auto &it : this->options) {
     dump_field(out, "options", it, 4);
   }
   dump_field(out, "disabled_by_default", this->disabled_by_default);
@@ -1490,7 +1466,6 @@ void ListEntitiesMediaPlayerResponse::dump_to(std::string &out) const {
 #ifdef USE_DEVICES
   dump_field(out, "device_id", this->device_id);
 #endif
-  dump_field(out, "feature_flags", this->feature_flags);
 }
 void MediaPlayerStateResponse::dump_to(std::string &out) const {
   MessageDumpHelper helper(out, "MediaPlayerStateResponse");
@@ -1561,7 +1536,6 @@ void BluetoothGATTDescriptor::dump_to(std::string &out) const {
     dump_field(out, "uuid", it, 4);
   }
   dump_field(out, "handle", this->handle);
-  dump_field(out, "short_uuid", this->short_uuid);
 }
 void BluetoothGATTCharacteristic::dump_to(std::string &out) const {
   MessageDumpHelper helper(out, "BluetoothGATTCharacteristic");
@@ -1575,7 +1549,6 @@ void BluetoothGATTCharacteristic::dump_to(std::string &out) const {
     it.dump_to(out);
     out.append("\n");
   }
-  dump_field(out, "short_uuid", this->short_uuid);
 }
 void BluetoothGATTService::dump_to(std::string &out) const {
   MessageDumpHelper helper(out, "BluetoothGATTService");
@@ -1588,7 +1561,6 @@ void BluetoothGATTService::dump_to(std::string &out) const {
     it.dump_to(out);
     out.append("\n");
   }
-  dump_field(out, "short_uuid", this->short_uuid);
 }
 void BluetoothGATTGetServicesResponse::dump_to(std::string &out) const {
   MessageDumpHelper helper(out, "BluetoothGATTGetServicesResponse");
@@ -1797,7 +1769,7 @@ void VoiceAssistantConfigurationResponse::dump_to(std::string &out) const {
     it.dump_to(out);
     out.append("\n");
   }
-  for (const auto &it : *this->active_wake_words) {
+  for (const auto &it : this->active_wake_words) {
     dump_field(out, "active_wake_words", it, 4);
   }
   dump_field(out, "max_active_wake_words", this->max_active_wake_words);

esphome/components/api/api_pb2_includes.h

@@ -1,34 +0,0 @@
-#pragma once
-
-#include "esphome/core/defines.h"
-
-// This file provides includes needed by the generated protobuf code
-// when using pointer optimizations for component-specific types
-
-#ifdef USE_CLIMATE
-#include "esphome/components/climate/climate_mode.h"
-#include "esphome/components/climate/climate_traits.h"
-#endif
-
-#ifdef USE_LIGHT
-#include "esphome/components/light/light_traits.h"
-#endif
-
-#ifdef USE_FAN
-#include "esphome/components/fan/fan_traits.h"
-#endif
-
-#ifdef USE_SELECT
-#include "esphome/components/select/select_traits.h"
-#endif
-
-// Standard library includes that might be needed
-#include <set>
-#include <vector>
-#include <string>
-
-namespace esphome::api {
-
-// This file only provides includes, no actual code
-
-}  // namespace esphome::api

esphome/components/binary_sensor/__init__.py

@@ -516,7 +516,6 @@ def binary_sensor_schema(
     icon: str = cv.UNDEFINED,
     entity_category: str = cv.UNDEFINED,
     device_class: str = cv.UNDEFINED,
-    filters: list = cv.UNDEFINED,
 ) -> cv.Schema:
     schema = {}
 
@@ -528,7 +527,6 @@ def binary_sensor_schema(
         (CONF_ICON, icon, cv.icon),
         (CONF_ENTITY_CATEGORY, entity_category, cv.entity_category),
         (CONF_DEVICE_CLASS, device_class, validate_device_class),
-        (CONF_FILTERS, filters, validate_filters),
     ]:
         if default is not cv.UNDEFINED:
             schema[cv.Optional(key, default=default)] = validator
@@ -654,6 +652,7 @@ async def binary_sensor_is_off_to_code(config, condition_id, template_arg, args)
 
 @coroutine_with_priority(100.0)
 async def to_code(config):
+    cg.add_define("USE_BINARY_SENSOR")
     cg.add_global(binary_sensor_ns.using)
 
 

esphome/components/ble_client/__init__.py

@@ -175,7 +175,8 @@ BLE_REMOVE_BOND_ACTION_SCHEMA = cv.Schema(
 )
 async def ble_disconnect_to_code(config, action_id, template_arg, args):
     parent = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, parent)
+    var = cg.new_Pvariable(action_id, template_arg, parent)
+    return var
 
 
 @automation.register_action(
@@ -183,7 +184,8 @@ async def ble_disconnect_to_code(config, action_id, template_arg, args):
 )
 async def ble_connect_to_code(config, action_id, template_arg, args):
     parent = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, parent)
+    var = cg.new_Pvariable(action_id, template_arg, parent)
+    return var
 
 
 @automation.register_action(
@@ -280,7 +282,9 @@ async def passkey_reply_to_code(config, action_id, template_arg, args):
 )
 async def remove_bond_to_code(config, action_id, template_arg, args):
     parent = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, parent)
+    var = cg.new_Pvariable(action_id, template_arg, parent)
+
+    return var
 
 
 async def to_code(config):

esphome/components/bluetooth_proxy/__init__.py

@@ -87,10 +87,6 @@ async def to_code(config):
     cg.add(var.set_active(config[CONF_ACTIVE]))
     await esp32_ble_tracker.register_raw_ble_device(var, config)
 
-    # Define max connections for protobuf fixed array
-    connection_count = len(config.get(CONF_CONNECTIONS, []))
-    cg.add_define("BLUETOOTH_PROXY_MAX_CONNECTIONS", connection_count)
-
     for connection_conf in config.get(CONF_CONNECTIONS, []):
         connection_var = cg.new_Pvariable(connection_conf[CONF_ID])
         await cg.register_component(connection_var, connection_conf)

esphome/components/bluetooth_proxy/bluetooth_connection.cpp

@@ -24,84 +24,11 @@ static void fill_128bit_uuid_array(std::array<uint64_t, 2> &out, esp_bt_uuid_t u
            ((uint64_t) uuid.uuid.uuid128[1] << 8) | ((uint64_t) uuid.uuid.uuid128[0]);
 }
 
-// Helper to fill UUID in the appropriate format based on client support and UUID type
-static void fill_gatt_uuid(std::array<uint64_t, 2> &uuid_128, uint32_t &short_uuid, const esp_bt_uuid_t &uuid,
-                           bool use_efficient_uuids) {
-  if (!use_efficient_uuids || uuid.len == ESP_UUID_LEN_128) {
-    // Use 128-bit format for old clients or when UUID is already 128-bit
-    fill_128bit_uuid_array(uuid_128, uuid);
-  } else if (uuid.len == ESP_UUID_LEN_16) {
-    short_uuid = uuid.uuid.uuid16;
-  } else if (uuid.len == ESP_UUID_LEN_32) {
-    short_uuid = uuid.uuid.uuid32;
-  }
-}
-
-// Constants for size estimation
-static constexpr uint8_t SERVICE_OVERHEAD_LEGACY = 25;     // UUID(20) + handle(4) + overhead(1)
-static constexpr uint8_t SERVICE_OVERHEAD_EFFICIENT = 10;  // UUID(6) + handle(4)
-static constexpr uint8_t CHAR_SIZE_128BIT = 35;            // UUID(20) + handle(4) + props(4) + overhead(7)
-static constexpr uint8_t DESC_SIZE_128BIT = 25;            // UUID(20) + handle(4) + overhead(1)
-static constexpr uint8_t DESC_SIZE_16BIT = 10;             // UUID(6) + handle(4)
-static constexpr uint8_t DESC_PER_CHAR = 1;                // Assume 1 descriptor per characteristic
-
-// Helper to estimate service size before fetching all data
-/**
- * Estimate the size of a Bluetooth service based on the number of characteristics and UUID format.
- *
- * @param char_count The number of characteristics in the service.
- * @param use_efficient_uuids Whether to use efficient UUIDs (16-bit or 32-bit) for newer APIVersions.
- * @return The estimated size of the service in bytes.
- *
- * This function calculates the size of a Bluetooth service by considering:
- * - A service overhead, which depends on whether efficient UUIDs are used.
- * - The size of each characteristic, assuming 128-bit UUIDs for safety.
- * - The size of descriptors, assuming one 128-bit descriptor per characteristic.
- */
-static size_t estimate_service_size(uint16_t char_count, bool use_efficient_uuids) {
-  size_t service_overhead = use_efficient_uuids ? SERVICE_OVERHEAD_EFFICIENT : SERVICE_OVERHEAD_LEGACY;
-  // Always assume 128-bit UUIDs for characteristics to be safe
-  size_t char_size = CHAR_SIZE_128BIT;
-  // Assume one 128-bit descriptor per characteristic
-  size_t desc_size = DESC_SIZE_128BIT * DESC_PER_CHAR;
-
-  return service_overhead + (char_size + desc_size) * char_count;
-}
-
-bool BluetoothConnection::supports_efficient_uuids_() const {
-  auto *api_conn = this->proxy_->get_api_connection();
-  return api_conn && api_conn->client_supports_api_version(1, 12);
-}
-
 void BluetoothConnection::dump_config() {
   ESP_LOGCONFIG(TAG, "BLE Connection:");
   BLEClientBase::dump_config();
 }
 
-void BluetoothConnection::update_allocated_slot_(uint64_t find_value, uint64_t set_value) {
-  auto &allocated = this->proxy_->connections_free_response_.allocated;
-  auto *it = std::find(allocated.begin(), allocated.end(), find_value);
-  if (it != allocated.end()) {
-    *it = set_value;
-  }
-}
-
-void BluetoothConnection::set_address(uint64_t address) {
-  // If we're clearing an address (disconnecting), update the pre-allocated message
-  if (address == 0 && this->address_ != 0) {
-    this->proxy_->connections_free_response_.free++;
-    this->update_allocated_slot_(this->address_, 0);
-  }
-  // If we're setting a new address (connecting), update the pre-allocated message
-  else if (address != 0 && this->address_ == 0) {
-    this->proxy_->connections_free_response_.free--;
-    this->update_allocated_slot_(0, address);
-  }
-
-  // Call parent implementation to actually set the address
-  BLEClientBase::set_address(address);
-}
-
 void BluetoothConnection::loop() {
   BLEClientBase::loop();
 
@@ -130,7 +57,7 @@ void BluetoothConnection::reset_connection_(esp_err_t reason) {
 }
 
 void BluetoothConnection::send_service_for_discovery_() {
-  if (this->send_service_ >= this->service_count_) {
+  if (this->send_service_ == this->service_count_) {
     this->send_service_ = DONE_SENDING_SERVICES;
     this->proxy_->send_gatt_services_done(this->address_);
     if (this->connection_type_ == espbt::ConnectionType::V3_WITH_CACHE ||
@@ -143,181 +70,119 @@ void BluetoothConnection::send_service_for_discovery_() {
   // Early return if no API connection
   auto *api_conn = this->proxy_->get_api_connection();
   if (api_conn == nullptr) {
-    this->send_service_ = DONE_SENDING_SERVICES;
     return;
   }
 
-  // Check if client supports efficient UUIDs
-  bool use_efficient_uuids = this->supports_efficient_uuids_();
+  // Send next service
+  esp_gattc_service_elem_t service_result;
+  uint16_t service_count = 1;
+  esp_gatt_status_t service_status = esp_ble_gattc_get_service(this->gattc_if_, this->conn_id_, nullptr,
+                                                               &service_result, &service_count, this->send_service_);
+  this->send_service_++;
 
-  // Prepare response
-  api::BluetoothGATTGetServicesResponse resp;
-  resp.address = this->address_;
-
-  // Dynamic batching based on actual size
-  // Conservative MTU limit for API messages (accounts for WPA3 overhead)
-  static constexpr size_t MAX_PACKET_SIZE = 1360;
-
-  // Keep running total of actual message size
-  size_t current_size = 0;
-  api::ProtoSize size;
-  resp.calculate_size(size);
-  current_size = size.get_size();
-
-  while (this->send_service_ < this->service_count_) {
-    esp_gattc_service_elem_t service_result;
-    uint16_t service_count = 1;
-    esp_gatt_status_t service_status = esp_ble_gattc_get_service(this->gattc_if_, this->conn_id_, nullptr,
-                                                                 &service_result, &service_count, this->send_service_);
-
-    if (service_status != ESP_GATT_OK || service_count == 0) {
-      ESP_LOGE(TAG, "[%d] [%s] esp_ble_gattc_get_service %s, status=%d, service_count=%d, offset=%d",
-               this->connection_index_, this->address_str().c_str(),
-               service_status != ESP_GATT_OK ? "error" : "missing", service_status, service_count, this->send_service_);
-      this->send_service_ = DONE_SENDING_SERVICES;
-      return;
-    }
-
-    // Get the number of characteristics BEFORE adding to response
-    uint16_t total_char_count = 0;
-    esp_gatt_status_t char_count_status =
-        esp_ble_gattc_get_attr_count(this->gattc_if_, this->conn_id_, ESP_GATT_DB_CHARACTERISTIC,
-                                     service_result.start_handle, service_result.end_handle, 0, &total_char_count);
-
-    if (char_count_status != ESP_GATT_OK) {
-      ESP_LOGE(TAG, "[%d] [%s] Error getting characteristic count, status=%d", this->connection_index_,
-               this->address_str().c_str(), char_count_status);
-      this->send_service_ = DONE_SENDING_SERVICES;
-      return;
-    }
-
-    // If this service likely won't fit, send current batch (unless it's the first)
-    size_t estimated_size = estimate_service_size(total_char_count, use_efficient_uuids);
-    if (!resp.services.empty() && (current_size + estimated_size > MAX_PACKET_SIZE)) {
-      // This service likely won't fit, send current batch
-      break;
-    }
-
-    // Now add the service since we know it will likely fit
-    resp.services.emplace_back();
-    auto &service_resp = resp.services.back();
-
-    fill_gatt_uuid(service_resp.uuid, service_resp.short_uuid, service_result.uuid, use_efficient_uuids);
-
-    service_resp.handle = service_result.start_handle;
-
-    if (total_char_count > 0) {
-      // Reserve space and process characteristics
-      service_resp.characteristics.reserve(total_char_count);
-      uint16_t char_offset = 0;
-      esp_gattc_char_elem_t char_result;
-      while (true) {  // characteristics
-        uint16_t char_count = 1;
-        esp_gatt_status_t char_status =
-            esp_ble_gattc_get_all_char(this->gattc_if_, this->conn_id_, service_result.start_handle,
-                                       service_result.end_handle, &char_result, &char_count, char_offset);
-        if (char_status == ESP_GATT_INVALID_OFFSET || char_status == ESP_GATT_NOT_FOUND) {
-          break;
-        }
-        if (char_status != ESP_GATT_OK) {
-          ESP_LOGE(TAG, "[%d] [%s] esp_ble_gattc_get_all_char error, status=%d", this->connection_index_,
-                   this->address_str().c_str(), char_status);
-          this->send_service_ = DONE_SENDING_SERVICES;
-          return;
-        }
-        if (char_count == 0) {
-          break;
-        }
-
-        service_resp.characteristics.emplace_back();
-        auto &characteristic_resp = service_resp.characteristics.back();
-
-        fill_gatt_uuid(characteristic_resp.uuid, characteristic_resp.short_uuid, char_result.uuid, use_efficient_uuids);
-
-        characteristic_resp.handle = char_result.char_handle;
-        characteristic_resp.properties = char_result.properties;
-        char_offset++;
-
-        // Get the number of descriptors directly with one call
-        uint16_t total_desc_count = 0;
-        esp_gatt_status_t desc_count_status = esp_ble_gattc_get_attr_count(
-            this->gattc_if_, this->conn_id_, ESP_GATT_DB_DESCRIPTOR, 0, 0, char_result.char_handle, &total_desc_count);
-
-        if (desc_count_status != ESP_GATT_OK) {
-          ESP_LOGE(TAG, "[%d] [%s] Error getting descriptor count for char handle %d, status=%d",
-                   this->connection_index_, this->address_str().c_str(), char_result.char_handle, desc_count_status);
-          this->send_service_ = DONE_SENDING_SERVICES;
-          return;
-        }
-        if (total_desc_count == 0) {
-          // No descriptors, continue to next characteristic
-          continue;
-        }
-
-        // Reserve space and process descriptors
-        characteristic_resp.descriptors.reserve(total_desc_count);
-        uint16_t desc_offset = 0;
-        esp_gattc_descr_elem_t desc_result;
-        while (true) {  // descriptors
-          uint16_t desc_count = 1;
-          esp_gatt_status_t desc_status = esp_ble_gattc_get_all_descr(
-              this->gattc_if_, this->conn_id_, char_result.char_handle, &desc_result, &desc_count, desc_offset);
-          if (desc_status == ESP_GATT_INVALID_OFFSET || desc_status == ESP_GATT_NOT_FOUND) {
-            break;
-          }
-          if (desc_status != ESP_GATT_OK) {
-            ESP_LOGE(TAG, "[%d] [%s] esp_ble_gattc_get_all_descr error, status=%d", this->connection_index_,
-                     this->address_str().c_str(), desc_status);
-            this->send_service_ = DONE_SENDING_SERVICES;
-            return;
-          }
-          if (desc_count == 0) {
-            break;  // No more descriptors
-          }
-
-          characteristic_resp.descriptors.emplace_back();
-          auto &descriptor_resp = characteristic_resp.descriptors.back();
-
-          fill_gatt_uuid(descriptor_resp.uuid, descriptor_resp.short_uuid, desc_result.uuid, use_efficient_uuids);
-
-          descriptor_resp.handle = desc_result.handle;
-          desc_offset++;
-        }
-      }
-    }  // end if (total_char_count > 0)
-
-    // Calculate the actual size of just this service
-    api::ProtoSize service_sizer;
-    service_resp.calculate_size(service_sizer);
-    size_t service_size = service_sizer.get_size() + 1;  // +1 for field tag
-
-    // Check if adding this service would exceed the limit
-    if (current_size + service_size > MAX_PACKET_SIZE) {
-      // We would go over - pop the last service if we have more than one
-      if (resp.services.size() > 1) {
-        resp.services.pop_back();
-        ESP_LOGD(TAG, "[%d] [%s] Service %d would exceed limit (current: %d + service: %d > %d), sending current batch",
-                 this->connection_index_, this->address_str().c_str(), this->send_service_, current_size, service_size,
-                 MAX_PACKET_SIZE);
-        // Don't increment send_service_ - we'll retry this service in next batch
-      } else {
-        // This single service is too large, but we have to send it anyway
-        ESP_LOGV(TAG, "[%d] [%s] Service %d is too large (%d bytes) but sending anyway", this->connection_index_,
-                 this->address_str().c_str(), this->send_service_, service_size);
-        // Increment so we don't get stuck
-        this->send_service_++;
-      }
-      // Send what we have
-      break;
-    }
-
-    // Now we know we're keeping this service, add its size
-    current_size += service_size;
-    // Successfully added this service, increment counter
-    this->send_service_++;
+  if (service_status != ESP_GATT_OK || service_count == 0) {
+    ESP_LOGE(TAG, "[%d] [%s] esp_ble_gattc_get_service %s, status=%d, service_count=%d, offset=%d",
+             this->connection_index_, this->address_str().c_str(), service_status != ESP_GATT_OK ? "error" : "missing",
+             service_status, service_count, this->send_service_ - 1);
+    return;
   }
 
-  // Send the message with dynamically batched services
+  api::BluetoothGATTGetServicesResponse resp;
+  resp.address = this->address_;
+  auto &service_resp = resp.services[0];
+  fill_128bit_uuid_array(service_resp.uuid, service_result.uuid);
+  service_resp.handle = service_result.start_handle;
+
+  // Get the number of characteristics directly with one call
+  uint16_t total_char_count = 0;
+  esp_gatt_status_t char_count_status =
+      esp_ble_gattc_get_attr_count(this->gattc_if_, this->conn_id_, ESP_GATT_DB_CHARACTERISTIC,
+                                   service_result.start_handle, service_result.end_handle, 0, &total_char_count);
+
+  if (char_count_status != ESP_GATT_OK) {
+    ESP_LOGW(TAG, "[%d] [%s] Error getting characteristic count, status=%d", this->connection_index_,
+             this->address_str().c_str(), char_count_status);
+    return;
+  }
+
+  if (total_char_count == 0) {
+    // No characteristics, just send the service response
+    api_conn->send_message(resp, api::BluetoothGATTGetServicesResponse::MESSAGE_TYPE);
+    return;
+  }
+
+  // Reserve space and process characteristics
+  service_resp.characteristics.reserve(total_char_count);
+  uint16_t char_offset = 0;
+  esp_gattc_char_elem_t char_result;
+  while (true) {  // characteristics
+    uint16_t char_count = 1;
+    esp_gatt_status_t char_status =
+        esp_ble_gattc_get_all_char(this->gattc_if_, this->conn_id_, service_result.start_handle,
+                                   service_result.end_handle, &char_result, &char_count, char_offset);
+    if (char_status == ESP_GATT_INVALID_OFFSET || char_status == ESP_GATT_NOT_FOUND) {
+      break;
+    }
+    if (char_status != ESP_GATT_OK) {
+      ESP_LOGE(TAG, "[%d] [%s] esp_ble_gattc_get_all_char error, status=%d", this->connection_index_,
+               this->address_str().c_str(), char_status);
+      return;
+    }
+    if (char_count == 0) {
+      break;
+    }
+
+    service_resp.characteristics.emplace_back();
+    auto &characteristic_resp = service_resp.characteristics.back();
+    fill_128bit_uuid_array(characteristic_resp.uuid, char_result.uuid);
+    characteristic_resp.handle = char_result.char_handle;
+    characteristic_resp.properties = char_result.properties;
+    char_offset++;
+
+    // Get the number of descriptors directly with one call
+    uint16_t total_desc_count = 0;
+    esp_gatt_status_t desc_count_status = esp_ble_gattc_get_attr_count(
+        this->gattc_if_, this->conn_id_, ESP_GATT_DB_DESCRIPTOR, 0, 0, char_result.char_handle, &total_desc_count);
+
+    if (desc_count_status != ESP_GATT_OK) {
+      ESP_LOGW(TAG, "[%d] [%s] Error getting descriptor count for char handle %d, status=%d", this->connection_index_,
+               this->address_str().c_str(), char_result.char_handle, desc_count_status);
+      return;
+    }
+    if (total_desc_count == 0) {
+      // No descriptors, continue to next characteristic
+      continue;
+    }
+
+    // Reserve space and process descriptors
+    characteristic_resp.descriptors.reserve(total_desc_count);
+    uint16_t desc_offset = 0;
+    esp_gattc_descr_elem_t desc_result;
+    while (true) {  // descriptors
+      uint16_t desc_count = 1;
+      esp_gatt_status_t desc_status = esp_ble_gattc_get_all_descr(
+          this->gattc_if_, this->conn_id_, char_result.char_handle, &desc_result, &desc_count, desc_offset);
+      if (desc_status == ESP_GATT_INVALID_OFFSET || desc_status == ESP_GATT_NOT_FOUND) {
+        break;
+      }
+      if (desc_status != ESP_GATT_OK) {
+        ESP_LOGE(TAG, "[%d] [%s] esp_ble_gattc_get_all_descr error, status=%d", this->connection_index_,
+                 this->address_str().c_str(), desc_status);
+        return;
+      }
+      if (desc_count == 0) {
+        break;  // No more descriptors
+      }
+
+      characteristic_resp.descriptors.emplace_back();
+      auto &descriptor_resp = characteristic_resp.descriptors.back();
+      fill_128bit_uuid_array(descriptor_resp.uuid, desc_result.uuid);
+      descriptor_resp.handle = desc_result.handle;
+      desc_offset++;
+    }
+  }
+
+  // Send the message (we already checked api_conn is not null at the beginning)
   api_conn->send_message(resp, api::BluetoothGATTGetServicesResponse::MESSAGE_TYPE);
 }
 

esphome/components/bluetooth_proxy/bluetooth_connection.h

@@ -24,15 +24,11 @@ class BluetoothConnection : public esp32_ble_client::BLEClientBase {
 
   esp_err_t notify_characteristic(uint16_t handle, bool enable);
 
-  void set_address(uint64_t address) override;
-
  protected:
   friend class BluetoothProxy;
 
-  bool supports_efficient_uuids_() const;
   void send_service_for_discovery_();
   void reset_connection_(esp_err_t reason);
-  void update_allocated_slot_(uint64_t find_value, uint64_t set_value);
 
   // Memory optimized layout for 32-bit systems
   // Group 1: Pointers (4 bytes each, naturally aligned)

esphome/components/bluetooth_proxy/bluetooth_proxy.cpp

@@ -35,9 +35,6 @@ void BluetoothProxy::setup() {
   // Don't pre-allocate pool - let it grow only if needed in busy environments
   // Many devices in quiet areas will never need the overflow pool
 
-  this->connections_free_response_.limit = this->connections_.size();
-  this->connections_free_response_.free = this->connections_.size();
-
   this->parent_->add_scanner_state_callback([this](esp32_ble_tracker::ScannerState state) {
     if (this->api_connection_ != nullptr) {
       this->send_bluetooth_scanner_state_(state);
@@ -137,6 +134,20 @@ void BluetoothProxy::dump_config() {
                 YESNO(this->active_), this->connections_.size());
 }
 
+int BluetoothProxy::get_bluetooth_connections_free() {
+  int free = 0;
+  for (auto *connection : this->connections_) {
+    if (connection->address_ == 0) {
+      free++;
+      ESP_LOGV(TAG, "[%d] Free connection", connection->get_connection_index());
+    } else {
+      ESP_LOGV(TAG, "[%d] Used connection by [%s]", connection->get_connection_index(),
+               connection->address_str().c_str());
+    }
+  }
+  return free;
+}
+
 void BluetoothProxy::loop() {
   if (!api::global_api_server->is_connected() || this->api_connection_ == nullptr) {
     for (auto *connection : this->connections_) {
@@ -428,13 +439,17 @@ void BluetoothProxy::send_device_connection(uint64_t address, bool connected, ui
   this->api_connection_->send_message(call, api::BluetoothDeviceConnectionResponse::MESSAGE_TYPE);
 }
 void BluetoothProxy::send_connections_free() {
-  if (this->api_connection_ != nullptr) {
-    this->send_connections_free(this->api_connection_);
+  if (this->api_connection_ == nullptr)
+    return;
+  api::BluetoothConnectionsFreeResponse call;
+  call.free = this->get_bluetooth_connections_free();
+  call.limit = this->get_bluetooth_connections_limit();
+  for (auto *connection : this->connections_) {
+    if (connection->address_ != 0) {
+      call.allocated.push_back(connection->address_);
+    }
   }
-}
-
-void BluetoothProxy::send_connections_free(api::APIConnection *api_connection) {
-  api_connection->send_message(this->connections_free_response_, api::BluetoothConnectionsFreeResponse::MESSAGE_TYPE);
+  this->api_connection_->send_message(call, api::BluetoothConnectionsFreeResponse::MESSAGE_TYPE);
 }
 
 void BluetoothProxy::send_gatt_services_done(uint64_t address) {

esphome/components/bluetooth_proxy/bluetooth_proxy.h

@@ -49,7 +49,6 @@ enum BluetoothProxySubscriptionFlag : uint32_t {
 };
 
 class BluetoothProxy : public esp32_ble_tracker::ESPBTDeviceListener, public Component {
-  friend class BluetoothConnection;  // Allow connection to update connections_free_response_
  public:
   BluetoothProxy();
 #ifdef USE_ESP32_BLE_DEVICE
@@ -75,13 +74,15 @@ class BluetoothProxy : public esp32_ble_tracker::ESPBTDeviceListener, public Com
   void bluetooth_gatt_send_services(const api::BluetoothGATTGetServicesRequest &msg);
   void bluetooth_gatt_notify(const api::BluetoothGATTNotifyRequest &msg);
 
+  int get_bluetooth_connections_free();
+  int get_bluetooth_connections_limit() { return this->connections_.size(); }
+
   void subscribe_api_connection(api::APIConnection *api_connection, uint32_t flags);
   void unsubscribe_api_connection(api::APIConnection *api_connection);
   api::APIConnection *get_api_connection() { return this->api_connection_; }
 
   void send_device_connection(uint64_t address, bool connected, uint16_t mtu = 0, esp_err_t error = ESP_OK);
   void send_connections_free();
-  void send_connections_free(api::APIConnection *api_connection);
   void send_gatt_services_done(uint64_t address);
   void send_gatt_error(uint64_t address, uint16_t handle, esp_err_t error);
   void send_device_pairing(uint64_t address, bool paired, esp_err_t error = ESP_OK);
@@ -148,9 +149,6 @@ class BluetoothProxy : public esp32_ble_tracker::ESPBTDeviceListener, public Com
   // Group 3: 4-byte types
   uint32_t last_advertisement_flush_time_{0};
 
-  // Pre-allocated response message - always ready to send
-  api::BluetoothConnectionsFreeResponse connections_free_response_;
-
   // Group 4: 1-byte types grouped together
   bool active_;
   uint8_t advertisement_count_{0};

esphome/components/button/__init__.py

@@ -137,3 +137,4 @@ async def button_press_to_code(config, action_id, template_arg, args):
 @coroutine_with_priority(100.0)
 async def to_code(config):
     cg.add_global(button_ns.using)
+    cg.add_define("USE_BUTTON")

esphome/components/climate/__init__.py

@@ -519,4 +519,5 @@ async def climate_control_to_code(config, action_id, template_arg, args):
 
 @coroutine_with_priority(100.0)
 async def to_code(config):
+    cg.add_define("USE_CLIMATE")
     cg.add_global(climate_ns.using)

esphome/components/climate/climate_traits.h

@@ -5,13 +5,6 @@
 #include <set>
 
 namespace esphome {
-
-#ifdef USE_API
-namespace api {
-class APIConnection;
-}  // namespace api
-#endif
-
 namespace climate {
 
 /** This class contains all static data for climate devices.
@@ -180,23 +173,6 @@ class ClimateTraits {
   void set_visual_max_humidity(float visual_max_humidity) { this->visual_max_humidity_ = visual_max_humidity; }
 
  protected:
-#ifdef USE_API
-  // The API connection is a friend class to access internal methods
-  friend class api::APIConnection;
-  // These methods return references to internal data structures.
-  // They are used by the API to avoid copying data when encoding messages.
-  // Warning: Do not use these methods outside of the API connection code.
-  // They return references to internal data that can be invalidated.
-  const std::set<ClimateMode> &get_supported_modes_for_api_() const { return this->supported_modes_; }
-  const std::set<ClimateFanMode> &get_supported_fan_modes_for_api_() const { return this->supported_fan_modes_; }
-  const std::set<std::string> &get_supported_custom_fan_modes_for_api_() const {
-    return this->supported_custom_fan_modes_;
-  }
-  const std::set<climate::ClimatePreset> &get_supported_presets_for_api_() const { return this->supported_presets_; }
-  const std::set<std::string> &get_supported_custom_presets_for_api_() const { return this->supported_custom_presets_; }
-  const std::set<ClimateSwingMode> &get_supported_swing_modes_for_api_() const { return this->supported_swing_modes_; }
-#endif
-
   void set_mode_support_(climate::ClimateMode mode, bool supported) {
     if (supported) {
       this->supported_modes_.insert(mode);

esphome/components/cover/__init__.py

@@ -265,4 +265,5 @@ async def cover_control_to_code(config, action_id, template_arg, args):
 
 @coroutine_with_priority(100.0)
 async def to_code(config):
+    cg.add_define("USE_COVER")
     cg.add_global(cover_ns.using)

esphome/components/datetime/__init__.py

@@ -164,6 +164,7 @@ async def register_datetime(var, config):
     cg.add(getattr(cg.App, f"register_{entity_type}")(var))
     CORE.register_platform_component(entity_type, var)
     await setup_datetime_core_(var, config)
+    cg.add_define(f"USE_DATETIME_{config[CONF_TYPE]}")
 
 
 async def new_datetime(config, *args):
@@ -174,6 +175,7 @@ async def new_datetime(config, *args):
 
 @coroutine_with_priority(100.0)
 async def to_code(config):
+    cg.add_define("USE_DATETIME")
     cg.add_global(datetime_ns.using)
 
 

esphome/components/debug/__init__.py

@@ -1,5 +1,4 @@
 import esphome.codegen as cg
-from esphome.components.zephyr import zephyr_add_prj_conf
 from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
 from esphome.const import (
@@ -11,7 +10,6 @@ from esphome.const import (
     CONF_LOOP_TIME,
     PlatformFramework,
 )
-from esphome.core import CORE
 
 CODEOWNERS = ["@OttoWinter"]
 DEPENDENCIES = ["logger"]
@@ -46,8 +44,6 @@ CONFIG_SCHEMA = cv.All(
 
 
 async def to_code(config):
-    if CORE.using_zephyr:
-        zephyr_add_prj_conf("HWINFO", True)
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
 
@@ -66,6 +62,5 @@ FILTER_SOURCE_FILES = filter_source_files_from_platform(
             PlatformFramework.RTL87XX_ARDUINO,
             PlatformFramework.LN882X_ARDUINO,
         },
-        "debug_zephyr.cpp": {PlatformFramework.NRF52_ZEPHYR},
     }
 )

esphome/components/debug/debug_zephyr.cpp

@@ -1,281 +0,0 @@
-#include "debug_component.h"
-#ifdef USE_ZEPHYR
-#include <climits>
-#include "esphome/core/log.h"
-#include <zephyr/drivers/hwinfo.h>
-#include <hal/nrf_power.h>
-#include <cstdint>
-
-#define BOOTLOADER_VERSION_REGISTER NRF_TIMER2->CC[0]
-
-namespace esphome {
-namespace debug {
-
-static const char *const TAG = "debug";
-constexpr std::uintptr_t MBR_PARAM_PAGE_ADDR = 0xFFC;
-constexpr std::uintptr_t MBR_BOOTLOADER_ADDR = 0xFF8;
-
-static void show_reset_reason(std::string &reset_reason, bool set, const char *reason) {
-  if (!set) {
-    return;
-  }
-  if (!reset_reason.empty()) {
-    reset_reason += ", ";
-  }
-  reset_reason += reason;
-}
-
-inline uint32_t read_mem_u32(uintptr_t addr) {
-  return *reinterpret_cast<volatile uint32_t *>(addr);  // NOLINT(performance-no-int-to-ptr)
-}
-
-std::string DebugComponent::get_reset_reason_() {
-  uint32_t cause;
-  auto ret = hwinfo_get_reset_cause(&cause);
-  if (ret) {
-    ESP_LOGE(TAG, "Unable to get reset cause: %d", ret);
-    return "";
-  }
-  std::string reset_reason;
-
-  show_reset_reason(reset_reason, cause & RESET_PIN, "External pin");
-  show_reset_reason(reset_reason, cause & RESET_SOFTWARE, "Software reset");
-  show_reset_reason(reset_reason, cause & RESET_BROWNOUT, "Brownout (drop in voltage)");
-  show_reset_reason(reset_reason, cause & RESET_POR, "Power-on reset (POR)");
-  show_reset_reason(reset_reason, cause & RESET_WATCHDOG, "Watchdog timer expiration");
-  show_reset_reason(reset_reason, cause & RESET_DEBUG, "Debug event");
-  show_reset_reason(reset_reason, cause & RESET_SECURITY, "Security violation");
-  show_reset_reason(reset_reason, cause & RESET_LOW_POWER_WAKE, "Waking up from low power mode");
-  show_reset_reason(reset_reason, cause & RESET_CPU_LOCKUP, "CPU lock-up detected");
-  show_reset_reason(reset_reason, cause & RESET_PARITY, "Parity error");
-  show_reset_reason(reset_reason, cause & RESET_PLL, "PLL error");
-  show_reset_reason(reset_reason, cause & RESET_CLOCK, "Clock error");
-  show_reset_reason(reset_reason, cause & RESET_HARDWARE, "Hardware reset");
-  show_reset_reason(reset_reason, cause & RESET_USER, "User reset");
-  show_reset_reason(reset_reason, cause & RESET_TEMPERATURE, "Temperature reset");
-
-  ESP_LOGD(TAG, "Reset Reason: %s", reset_reason.c_str());
-  return reset_reason;
-}
-
-uint32_t DebugComponent::get_free_heap_() { return INT_MAX; }
-
-void DebugComponent::get_device_info_(std::string &device_info) {
-  std::string supply = "Main supply status: ";
-  if (nrf_power_mainregstatus_get(NRF_POWER) == NRF_POWER_MAINREGSTATUS_NORMAL) {
-    supply += "Normal voltage.";
-  } else {
-    supply += "High voltage.";
-  }
-  ESP_LOGD(TAG, "%s", supply.c_str());
-  device_info += "|" + supply;
-
-  std::string reg0 = "Regulator stage 0: ";
-  if (nrf_power_mainregstatus_get(NRF_POWER) == NRF_POWER_MAINREGSTATUS_HIGH) {
-    reg0 += nrf_power_dcdcen_vddh_get(NRF_POWER) ? "DC/DC" : "LDO";
-    reg0 += ", ";
-    switch (NRF_UICR->REGOUT0 & UICR_REGOUT0_VOUT_Msk) {
-      case (UICR_REGOUT0_VOUT_DEFAULT << UICR_REGOUT0_VOUT_Pos):
-        reg0 += "1.8V (default)";
-        break;
-      case (UICR_REGOUT0_VOUT_1V8 << UICR_REGOUT0_VOUT_Pos):
-        reg0 += "1.8V";
-        break;
-      case (UICR_REGOUT0_VOUT_2V1 << UICR_REGOUT0_VOUT_Pos):
-        reg0 += "2.1V";
-        break;
-      case (UICR_REGOUT0_VOUT_2V4 << UICR_REGOUT0_VOUT_Pos):
-        reg0 += "2.4V";
-        break;
-      case (UICR_REGOUT0_VOUT_2V7 << UICR_REGOUT0_VOUT_Pos):
-        reg0 += "2.7V";
-        break;
-      case (UICR_REGOUT0_VOUT_3V0 << UICR_REGOUT0_VOUT_Pos):
-        reg0 += "3.0V";
-        break;
-      case (UICR_REGOUT0_VOUT_3V3 << UICR_REGOUT0_VOUT_Pos):
-        reg0 += "3.3V";
-        break;
-      default:
-        reg0 += "???V";
-    }
-  } else {
-    reg0 += "disabled";
-  }
-  ESP_LOGD(TAG, "%s", reg0.c_str());
-  device_info += "|" + reg0;
-
-  std::string reg1 = "Regulator stage 1: ";
-  reg1 += nrf_power_dcdcen_get(NRF_POWER) ? "DC/DC" : "LDO";
-  ESP_LOGD(TAG, "%s", reg1.c_str());
-  device_info += "|" + reg1;
-
-  std::string usb_power = "USB power state: ";
-  if (nrf_power_usbregstatus_vbusdet_get(NRF_POWER)) {
-    if (nrf_power_usbregstatus_outrdy_get(NRF_POWER)) {
-      /**< From the power viewpoint, USB is ready for working. */
-      usb_power += "ready";
-    } else {
-      /**< The USB power is detected, but USB power regulator is not ready. */
-      usb_power += "connected (regulator is not ready)";
-    }
-  } else {
-    /**< No power on USB lines detected. */
-    usb_power += "disconected";
-  }
-  ESP_LOGD(TAG, "%s", usb_power.c_str());
-  device_info += "|" + usb_power;
-
-  bool enabled;
-  nrf_power_pof_thr_t pof_thr;
-
-  pof_thr = nrf_power_pofcon_get(NRF_POWER, &enabled);
-  std::string pof = "Power-fail comparator: ";
-  if (enabled) {
-    switch (pof_thr) {
-      case POWER_POFCON_THRESHOLD_V17:
-        pof += "1.7V";
-        break;
-      case POWER_POFCON_THRESHOLD_V18:
-        pof += "1.8V";
-        break;
-      case POWER_POFCON_THRESHOLD_V19:
-        pof += "1.9V";
-        break;
-      case POWER_POFCON_THRESHOLD_V20:
-        pof += "2.0V";
-        break;
-      case POWER_POFCON_THRESHOLD_V21:
-        pof += "2.1V";
-        break;
-      case POWER_POFCON_THRESHOLD_V22:
-        pof += "2.2V";
-        break;
-      case POWER_POFCON_THRESHOLD_V23:
-        pof += "2.3V";
-        break;
-      case POWER_POFCON_THRESHOLD_V24:
-        pof += "2.4V";
-        break;
-      case POWER_POFCON_THRESHOLD_V25:
-        pof += "2.5V";
-        break;
-      case POWER_POFCON_THRESHOLD_V26:
-        pof += "2.6V";
-        break;
-      case POWER_POFCON_THRESHOLD_V27:
-        pof += "2.7V";
-        break;
-      case POWER_POFCON_THRESHOLD_V28:
-        pof += "2.8V";
-        break;
-    }
-
-    if (nrf_power_mainregstatus_get(NRF_POWER) == NRF_POWER_MAINREGSTATUS_HIGH) {
-      pof += ", VDDH: ";
-      switch (nrf_power_pofcon_vddh_get(NRF_POWER)) {
-        case NRF_POWER_POFTHRVDDH_V27:
-          pof += "2.7V";
-          break;
-        case NRF_POWER_POFTHRVDDH_V28:
-          pof += "2.8V";
-          break;
-        case NRF_POWER_POFTHRVDDH_V29:
-          pof += "2.9V";
-          break;
-        case NRF_POWER_POFTHRVDDH_V30:
-          pof += "3.0V";
-          break;
-        case NRF_POWER_POFTHRVDDH_V31:
-          pof += "3.1V";
-          break;
-        case NRF_POWER_POFTHRVDDH_V32:
-          pof += "3.2V";
-          break;
-        case NRF_POWER_POFTHRVDDH_V33:
-          pof += "3.3V";
-          break;
-        case NRF_POWER_POFTHRVDDH_V34:
-          pof += "3.4V";
-          break;
-        case NRF_POWER_POFTHRVDDH_V35:
-          pof += "3.5V";
-          break;
-        case NRF_POWER_POFTHRVDDH_V36:
-          pof += "3.6V";
-          break;
-        case NRF_POWER_POFTHRVDDH_V37:
-          pof += "3.7V";
-          break;
-        case NRF_POWER_POFTHRVDDH_V38:
-          pof += "3.8V";
-          break;
-        case NRF_POWER_POFTHRVDDH_V39:
-          pof += "3.9V";
-          break;
-        case NRF_POWER_POFTHRVDDH_V40:
-          pof += "4.0V";
-          break;
-        case NRF_POWER_POFTHRVDDH_V41:
-          pof += "4.1V";
-          break;
-        case NRF_POWER_POFTHRVDDH_V42:
-          pof += "4.2V";
-          break;
-      }
-    }
-  } else {
-    pof += "disabled";
-  }
-  ESP_LOGD(TAG, "%s", pof.c_str());
-  device_info += "|" + pof;
-
-  auto package = [](uint32_t value) {
-    switch (value) {
-      case 0x2004:
-        return "QIxx - 7x7 73-pin aQFN";
-      case 0x2000:
-        return "QFxx - 6x6 48-pin QFN";
-      case 0x2005:
-        return "CKxx - 3.544 x 3.607 WLCSP";
-    }
-    return "Unspecified";
-  };
-
-  ESP_LOGD(TAG, "Code page size: %u, code size: %u, device id: 0x%08x%08x", NRF_FICR->CODEPAGESIZE, NRF_FICR->CODESIZE,
-           NRF_FICR->DEVICEID[1], NRF_FICR->DEVICEID[0]);
-  ESP_LOGD(TAG, "Encryption root: 0x%08x%08x%08x%08x, Identity Root: 0x%08x%08x%08x%08x", NRF_FICR->ER[0],
-           NRF_FICR->ER[1], NRF_FICR->ER[2], NRF_FICR->ER[3], NRF_FICR->IR[0], NRF_FICR->IR[1], NRF_FICR->IR[2],
-           NRF_FICR->IR[3]);
-  ESP_LOGD(TAG, "Device address type: %s, address: %s", (NRF_FICR->DEVICEADDRTYPE & 0x1 ? "Random" : "Public"),
-           get_mac_address_pretty().c_str());
-  ESP_LOGD(TAG, "Part code: nRF%x, version: %c%c%c%c, package: %s", NRF_FICR->INFO.PART,
-           NRF_FICR->INFO.VARIANT >> 24 & 0xFF, NRF_FICR->INFO.VARIANT >> 16 & 0xFF, NRF_FICR->INFO.VARIANT >> 8 & 0xFF,
-           NRF_FICR->INFO.VARIANT & 0xFF, package(NRF_FICR->INFO.PACKAGE));
-  ESP_LOGD(TAG, "RAM: %ukB, Flash: %ukB, production test: %sdone", NRF_FICR->INFO.RAM, NRF_FICR->INFO.FLASH,
-           (NRF_FICR->PRODTEST[0] == 0xBB42319F ? "" : "not "));
-  ESP_LOGD(
-      TAG, "GPIO as NFC pins: %s, GPIO as nRESET pin: %s",
-      YESNO((NRF_UICR->NFCPINS & UICR_NFCPINS_PROTECT_Msk) == (UICR_NFCPINS_PROTECT_NFC << UICR_NFCPINS_PROTECT_Pos)),
-      YESNO(((NRF_UICR->PSELRESET[0] & UICR_PSELRESET_CONNECT_Msk) !=
-             (UICR_PSELRESET_CONNECT_Connected << UICR_PSELRESET_CONNECT_Pos)) ||
-            ((NRF_UICR->PSELRESET[1] & UICR_PSELRESET_CONNECT_Msk) !=
-             (UICR_PSELRESET_CONNECT_Connected << UICR_PSELRESET_CONNECT_Pos))));
-
-#ifdef USE_BOOTLOADER_MCUBOOT
-  ESP_LOGD(TAG, "bootloader: mcuboot");
-#else
-  ESP_LOGD(TAG, "bootloader: Adafruit, version %u.%u.%u", (BOOTLOADER_VERSION_REGISTER >> 16) & 0xFF,
-           (BOOTLOADER_VERSION_REGISTER >> 8) & 0xFF, BOOTLOADER_VERSION_REGISTER & 0xFF);
-  ESP_LOGD(TAG, "MBR bootloader addr 0x%08x, UICR bootloader addr 0x%08x", read_mem_u32(MBR_BOOTLOADER_ADDR),
-           NRF_UICR->NRFFW[0]);
-  ESP_LOGD(TAG, "MBR param page addr 0x%08x, UICR param page addr 0x%08x", read_mem_u32(MBR_PARAM_PAGE_ADDR),
-           NRF_UICR->NRFFW[1]);
-#endif
-}
-
-void DebugComponent::update_platform_() {}
-
-}  // namespace debug
-}  // namespace esphome
-#endif

esphome/components/debug/sensor.py

@@ -1,7 +1,6 @@
 import esphome.codegen as cg
 from esphome.components import sensor
 from esphome.components.esp32 import CONF_CPU_FREQUENCY
-from esphome.components.psram import DOMAIN as PSRAM_DOMAIN
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_BLOCK,
@@ -55,7 +54,7 @@ CONFIG_SCHEMA = {
     ),
     cv.Optional(CONF_PSRAM): cv.All(
         cv.only_on_esp32,
-        cv.requires_component(PSRAM_DOMAIN),
+        cv.requires_component("psram"),
         sensor.sensor_schema(
             unit_of_measurement=UNIT_BYTES,
             icon=ICON_COUNTER,

esphome/components/esp32/__init__.py

@@ -76,7 +76,6 @@ CONF_ASSERTION_LEVEL = "assertion_level"
 CONF_COMPILER_OPTIMIZATION = "compiler_optimization"
 CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES = "enable_idf_experimental_features"
 CONF_ENABLE_LWIP_ASSERT = "enable_lwip_assert"
-CONF_EXECUTE_FROM_PSRAM = "execute_from_psram"
 CONF_RELEASE = "release"
 
 ASSERTION_LEVELS = {
@@ -314,7 +313,7 @@ def _format_framework_espidf_version(
 RECOMMENDED_ARDUINO_FRAMEWORK_VERSION = cv.Version(3, 2, 1)
 # The platform-espressif32 version to use for arduino frameworks
 #  - https://github.com/pioarduino/platform-espressif32/releases
-ARDUINO_PLATFORM_VERSION = cv.Version(54, 3, 21, "2")
+ARDUINO_PLATFORM_VERSION = cv.Version(54, 3, 21)
 
 # The default/recommended esp-idf framework version
 #  - https://github.com/espressif/esp-idf/releases
@@ -323,7 +322,7 @@ RECOMMENDED_ESP_IDF_FRAMEWORK_VERSION = cv.Version(5, 4, 2)
 # The platformio/espressif32 version to use for esp-idf frameworks
 #  - https://github.com/platformio/platform-espressif32/releases
 #  - https://api.registry.platformio.org/v3/packages/platformio/platform/espressif32
-ESP_IDF_PLATFORM_VERSION = cv.Version(54, 3, 21, "2")
+ESP_IDF_PLATFORM_VERSION = cv.Version(54, 3, 21)
 
 # List based on https://registry.platformio.org/tools/platformio/framework-espidf/versions
 SUPPORTED_PLATFORMIO_ESP_IDF_5X = [
@@ -469,10 +468,10 @@ def _parse_platform_version(value):
     try:
         ver = cv.Version.parse(cv.version_number(value))
         if ver.major >= 50:  # a pioarduino version
-            release = f"{ver.major}.{ver.minor:02d}.{ver.patch:02d}"
-            if ver.extra:
-                release += f"-{ver.extra}"
-            return f"https://github.com/pioarduino/platform-espressif32/releases/download/{release}/platform-espressif32.zip"
+            if "-" in value:
+                # maybe a release candidate?...definitely not our default, just use it as-is...
+                return f"https://github.com/pioarduino/platform-espressif32/releases/download/{value}/platform-espressif32.zip"
+            return f"https://github.com/pioarduino/platform-espressif32/releases/download/{ver.major}.{ver.minor:02d}.{ver.patch:02d}/platform-espressif32.zip"
         # if platform version is a valid version constraint, prefix the default package
         cv.platformio_version_constraint(value)
         return f"platformio/espressif32@{value}"
@@ -520,59 +519,32 @@ def _detect_variant(value):
 
 
 def final_validate(config):
-    # Imported locally to avoid circular import issues
-    from esphome.components.psram import DOMAIN as PSRAM_DOMAIN
+    if not (
+        pio_options := fv.full_config.get()[CONF_ESPHOME].get(CONF_PLATFORMIO_OPTIONS)
+    ):
+        # Not specified or empty
+        return config
+
+    pio_flash_size_key = "board_upload.flash_size"
+    pio_partitions_key = "board_build.partitions"
+    if CONF_PARTITIONS in config and pio_partitions_key in pio_options:
+        raise cv.Invalid(
+            f"Do not specify '{pio_partitions_key}' in '{CONF_PLATFORMIO_OPTIONS}' with '{CONF_PARTITIONS}' in esp32"
+        )
+
+    if pio_flash_size_key in pio_options:
+        raise cv.Invalid(
+            f"Please specify {CONF_FLASH_SIZE} within esp32 configuration only"
+        )
 
-    errs = []
-    full_config = fv.full_config.get()
-    if pio_options := full_config[CONF_ESPHOME].get(CONF_PLATFORMIO_OPTIONS):
-        pio_flash_size_key = "board_upload.flash_size"
-        pio_partitions_key = "board_build.partitions"
-        if CONF_PARTITIONS in config and pio_partitions_key in pio_options:
-            errs.append(
-                cv.Invalid(
-                    f"Do not specify '{pio_partitions_key}' in '{CONF_PLATFORMIO_OPTIONS}' with '{CONF_PARTITIONS}' in esp32"
-                )
-            )
-        if pio_flash_size_key in pio_options:
-            errs.append(
-                cv.Invalid(
-                    f"Please specify {CONF_FLASH_SIZE} within esp32 configuration only"
-                )
-            )
     if (
         config[CONF_VARIANT] != VARIANT_ESP32
         and CONF_ADVANCED in (conf_fw := config[CONF_FRAMEWORK])
         and CONF_IGNORE_EFUSE_MAC_CRC in conf_fw[CONF_ADVANCED]
     ):
-        errs.append(
-            cv.Invalid(
-                f"'{CONF_IGNORE_EFUSE_MAC_CRC}' is not supported on {config[CONF_VARIANT]}",
-                path=[CONF_FRAMEWORK, CONF_ADVANCED, CONF_IGNORE_EFUSE_MAC_CRC],
-            )
+        raise cv.Invalid(
+            f"{CONF_IGNORE_EFUSE_MAC_CRC} is not supported on {config[CONF_VARIANT]}"
         )
-    if (
-        config.get(CONF_FRAMEWORK, {})
-        .get(CONF_ADVANCED, {})
-        .get(CONF_EXECUTE_FROM_PSRAM)
-    ):
-        if config[CONF_VARIANT] != VARIANT_ESP32S3:
-            errs.append(
-                cv.Invalid(
-                    f"'{CONF_EXECUTE_FROM_PSRAM}' is only supported on {VARIANT_ESP32S3} variant",
-                    path=[CONF_FRAMEWORK, CONF_ADVANCED, CONF_EXECUTE_FROM_PSRAM],
-                )
-            )
-        if PSRAM_DOMAIN not in full_config:
-            errs.append(
-                cv.Invalid(
-                    f"'{CONF_EXECUTE_FROM_PSRAM}' requires PSRAM to be configured",
-                    path=[CONF_FRAMEWORK, CONF_ADVANCED, CONF_EXECUTE_FROM_PSRAM],
-                )
-            )
-
-    if errs:
-        raise cv.MultipleInvalid(errs)
 
     return config
 
@@ -655,7 +627,6 @@ ESP_IDF_FRAMEWORK_SCHEMA = cv.All(
                     cv.Optional(
                         CONF_ENABLE_LWIP_CHECK_THREAD_SAFETY, default=True
                     ): cv.boolean,
-                    cv.Optional(CONF_EXECUTE_FROM_PSRAM): cv.boolean,
                 }
             ),
             cv.Optional(CONF_COMPONENTS, default=[]): cv.ensure_list(
@@ -821,9 +792,6 @@ async def to_code(config):
             add_idf_sdkconfig_option("CONFIG_LWIP_DNS_SUPPORT_MDNS_QUERIES", False)
         if not advanced.get(CONF_ENABLE_LWIP_BRIDGE_INTERFACE, False):
             add_idf_sdkconfig_option("CONFIG_LWIP_BRIDGEIF_MAX_PORTS", 0)
-        if advanced.get(CONF_EXECUTE_FROM_PSRAM, False):
-            add_idf_sdkconfig_option("CONFIG_SPIRAM_FETCH_INSTRUCTIONS", True)
-            add_idf_sdkconfig_option("CONFIG_SPIRAM_RODATA", True)
 
         # Apply LWIP core locking for better socket performance
         # This is already enabled by default in Arduino framework, where it provides
@@ -924,7 +892,7 @@ def get_arduino_partition_csv(flash_size):
     eeprom_partition_start = app1_partition_start + app_partition_size
     spiffs_partition_start = eeprom_partition_start + eeprom_partition_size
 
-    return f"""\
+    partition_csv = f"""\
 nvs,      data, nvs,     0x9000, 0x5000,
 otadata,  data, ota,     0xE000, 0x2000,
 app0,     app,  ota_0,   0x{app0_partition_start:X}, 0x{app_partition_size:X},
@@ -932,18 +900,20 @@ app1,     app,  ota_1,   0x{app1_partition_start:X}, 0x{app_partition_size:X},
 eeprom,   data, 0x99,    0x{eeprom_partition_start:X}, 0x{eeprom_partition_size:X},
 spiffs,   data, spiffs,  0x{spiffs_partition_start:X}, 0x{spiffs_partition_size:X}
 """
+    return partition_csv
 
 
 def get_idf_partition_csv(flash_size):
     app_partition_size = APP_PARTITION_SIZES[flash_size]
 
-    return f"""\
+    partition_csv = f"""\
 otadata,  data, ota,     ,        0x2000,
 phy_init, data, phy,     ,        0x1000,
 app0,     app,  ota_0,   ,        0x{app_partition_size:X},
 app1,     app,  ota_1,   ,        0x{app_partition_size:X},
 nvs,      data, nvs,     ,        0x6D000,
 """
+    return partition_csv
 
 
 def _format_sdkconfig_val(value: SdkconfigValueType) -> str:

esphome/components/esp32/gpio.py

@@ -187,7 +187,8 @@ def validate_supports(value):
             "Open-drain only works with output mode", [CONF_MODE, CONF_OPEN_DRAIN]
         )
 
-    return _esp32_validations[variant].usage_validation(value)
+    value = _esp32_validations[variant].usage_validation(value)
+    return value
 
 
 # https://docs.espressif.com/projects/esp-idf/en/v3.3.5/api-reference/peripherals/gpio.html#_CPPv416gpio_drive_cap_t

esphome/components/esp32/gpio_esp32_h2.py

@@ -2,7 +2,6 @@ import logging
 
 import esphome.config_validation as cv
 from esphome.const import CONF_INPUT, CONF_MODE, CONF_NUMBER
-from esphome.pins import check_strapping_pin
 
 _ESP32H2_SPI_FLASH_PINS = {6, 7, 15, 16, 17, 18, 19, 20, 21}
 
@@ -16,6 +15,13 @@ _LOGGER = logging.getLogger(__name__)
 def esp32_h2_validate_gpio_pin(value):
     if value < 0 or value > 27:
         raise cv.Invalid(f"Invalid pin number: {value} (must be 0-27)")
+    if value in _ESP32H2_STRAPPING_PINS:
+        _LOGGER.warning(
+            "GPIO%d is a Strapping PIN and should be avoided.\n"
+            "Attaching external pullup/down resistors to strapping pins can cause unexpected failures.\n"
+            "See https://esphome.io/guides/faq.html#why-am-i-getting-a-warning-about-strapping-pins",
+            value,
+        )
     if value in _ESP32H2_SPI_FLASH_PINS:
         _LOGGER.warning(
             "GPIO%d is reserved for SPI Flash communication on some ESP32-H2 chip variants.\n"
@@ -43,5 +49,4 @@ def esp32_h2_validate_supports(value):
     if is_input:
         # All ESP32 pins support input mode
         pass
-    check_strapping_pin(value, _ESP32H2_STRAPPING_PINS, _LOGGER)
     return value

esphome/components/esp32/gpio_esp32_p4.py

@@ -2,7 +2,6 @@ import logging
 
 import esphome.config_validation as cv
 from esphome.const import CONF_INPUT, CONF_MODE, CONF_NUMBER
-from esphome.pins import check_strapping_pin
 
 _ESP32P4_USB_JTAG_PINS = {24, 25}
 
@@ -14,6 +13,13 @@ _LOGGER = logging.getLogger(__name__)
 def esp32_p4_validate_gpio_pin(value):
     if value < 0 or value > 54:
         raise cv.Invalid(f"Invalid pin number: {value} (must be 0-54)")
+    if value in _ESP32P4_STRAPPING_PINS:
+        _LOGGER.warning(
+            "GPIO%d is a Strapping PIN and should be avoided.\n"
+            "Attaching external pullup/down resistors to strapping pins can cause unexpected failures.\n"
+            "See https://esphome.io/guides/faq.html#why-am-i-getting-a-warning-about-strapping-pins",
+            value,
+        )
     if value in _ESP32P4_USB_JTAG_PINS:
         _LOGGER.warning(
             "GPIO%d is reserved for the USB-Serial-JTAG interface.\n"
@@ -34,5 +40,4 @@ def esp32_p4_validate_supports(value):
     if is_input:
         # All ESP32 pins support input mode
         pass
-    check_strapping_pin(value, _ESP32P4_STRAPPING_PINS, _LOGGER)
     return value

esphome/components/esp32/post_build.py.script

@@ -1,11 +1,10 @@
-Import("env")  # noqa: F821
-
-import itertools  # noqa: E402
-import json  # noqa: E402
-import os  # noqa: E402
-import pathlib  # noqa: E402
-import shutil  # noqa: E402
+Import("env")
 
+import os
+import json
+import shutil
+import pathlib
+import itertools
 
 def merge_factory_bin(source, target, env):
     """
@@ -26,9 +25,7 @@ def merge_factory_bin(source, target, env):
         try:
             with flasher_args_path.open() as f:
                 flash_data = json.load(f)
-            for addr, fname in sorted(
-                flash_data["flash_files"].items(), key=lambda kv: int(kv[0], 16)
-            ):
+            for addr, fname in sorted(flash_data["flash_files"].items(), key=lambda kv: int(kv[0], 16)):
                 file_path = pathlib.Path(fname)
                 if file_path.exists():
                     sections.append((addr, str(file_path)))
@@ -43,27 +40,20 @@ def merge_factory_bin(source, target, env):
         if flash_images:
             print("Using FLASH_EXTRA_IMAGES from PlatformIO environment")
             # flatten any nested lists
-            flat = list(
-                itertools.chain.from_iterable(
-                    x if isinstance(x, (list, tuple)) else [x] for x in flash_images
-                )
-            )
+            flat = list(itertools.chain.from_iterable(
+                x if isinstance(x, (list, tuple)) else [x] for x in flash_images
+            ))
             entries = [env.subst(x) for x in flat]
             for i in range(0, len(entries) - 1, 2):
                 addr, fname = entries[i], entries[i + 1]
                 if isinstance(fname, (list, tuple)):
-                    print(
-                        f"Warning: Skipping malformed FLASH_EXTRA_IMAGES entry: {fname}"
-                    )
+                    print(f"Warning: Skipping malformed FLASH_EXTRA_IMAGES entry: {fname}")
                     continue
                 file_path = pathlib.Path(str(fname))
                 if file_path.exists():
-                    sections.append((addr, file_path))
+                    sections.append((addr, str(file_path)))
                 else:
                     print(f"Info: {file_path.name} not found — skipping")
-        if sections:
-            # Append main firmware to sections
-            sections.append(("0x10000", firmware_path))
 
     # 3. Final fallback: guess standard image locations
     if not sections:
@@ -72,11 +62,11 @@ def merge_factory_bin(source, target, env):
             ("0x0", build_dir / "bootloader" / "bootloader.bin"),
             ("0x8000", build_dir / "partition_table" / "partition-table.bin"),
             ("0xe000", build_dir / "ota_data_initial.bin"),
-            ("0x10000", firmware_path),
+            ("0x10000", firmware_path)
         ]
         for addr, file_path in guesses:
             if file_path.exists():
-                sections.append((addr, file_path))
+                sections.append((addr, str(file_path)))
             else:
                 print(f"Info: {file_path.name} not found — skipping")
 
@@ -86,25 +76,21 @@ def merge_factory_bin(source, target, env):
         return
 
     output_path = firmware_path.with_suffix(".factory.bin")
-    python_exe = f'"{env.subst("$PYTHONEXE")}"'
     cmd = [
-        python_exe,
-        "-m",
-        "esptool",
-        "--chip",
-        chip,
+        "--chip", chip,
         "merge_bin",
-        "--flash_size",
-        flash_size,
-        "--output",
-        str(output_path),
+        "--flash_size", flash_size,
+        "--output", str(output_path)
     ]
     for addr, file_path in sections:
-        cmd += [addr, str(file_path)]
+        cmd += [addr, file_path]
 
     print(f"Merging binaries into {output_path}")
     result = env.Execute(
-        env.VerboseAction(" ".join(cmd), "Merging binaries with esptool")
+        env.VerboseAction(
+            f"{env.subst('$PYTHONEXE')} -m esptool " + " ".join(cmd),
+            "Merging binaries with esptool"
+        )
     )
 
     if result == 0:
@@ -112,7 +98,6 @@ def merge_factory_bin(source, target, env):
     else:
         print(f"Error: esptool merge_bin failed with code {result}")
 
-
 def esp32_copy_ota_bin(source, target, env):
     """
     Copy the main firmware to a .ota.bin file for compatibility with ESPHome OTA tools.
@@ -122,7 +107,6 @@ def esp32_copy_ota_bin(source, target, env):
     shutil.copyfile(firmware_name, new_file_name)
     print(f"Copied firmware to {new_file_name}")
 
-
 # Run merge first, then ota copy second
-env.AddPostAction("$BUILD_DIR/${PROGNAME}.bin", merge_factory_bin)  # noqa: F821
-env.AddPostAction("$BUILD_DIR/${PROGNAME}.bin", esp32_copy_ota_bin)  # noqa: F821
+env.AddPostAction("$BUILD_DIR/${PROGNAME}.bin", merge_factory_bin)
+env.AddPostAction("$BUILD_DIR/${PROGNAME}.bin", esp32_copy_ota_bin)

esphome/components/esp32_ble/ble.cpp

@@ -468,8 +468,6 @@ void ESP32BLE::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_pa
     // Ignore these GAP events as they are not relevant for our use case
     case ESP_GAP_BLE_UPDATE_CONN_PARAMS_EVT:
     case ESP_GAP_BLE_SET_PKT_LENGTH_COMPLETE_EVT:
-    case ESP_GAP_BLE_PHY_UPDATE_COMPLETE_EVT:       // BLE 5.0 PHY update complete
-    case ESP_GAP_BLE_CHANNEL_SELECT_ALGORITHM_EVT:  // BLE 5.0 channel selection algorithm
       return;
 
     default:

esphome/components/esp32_ble_client/ble_client_base.cpp

@@ -5,28 +5,10 @@
 
 #ifdef USE_ESP32
 
-#include <esp_gap_ble_api.h>
-#include <esp_gatt_defs.h>
-
 namespace esphome {
 namespace esp32_ble_client {
 
 static const char *const TAG = "esp32_ble_client";
-
-// Intermediate connection parameters for standard operation
-// ESP-IDF defaults (12.5-15ms) are too slow for stable connections through WiFi-based BLE proxies,
-// causing disconnections. These medium parameters balance responsiveness with bandwidth usage.
-static const uint16_t MEDIUM_MIN_CONN_INTERVAL = 0x08;  // 8 * 1.25ms = 10ms
-static const uint16_t MEDIUM_MAX_CONN_INTERVAL = 0x0A;  // 10 * 1.25ms = 12.5ms
-// The timeout value was increased from 6s to 8s to address stability issues observed
-// in certain BLE devices when operating through WiFi-based BLE proxies. The longer
-// timeout reduces the likelihood of disconnections during periods of high latency.
-static const uint16_t MEDIUM_CONN_TIMEOUT = 800;  // 800 * 10ms = 8s
-
-// Fastest connection parameters for devices with short discovery timeouts
-static const uint16_t FAST_MIN_CONN_INTERVAL = 0x06;  // 6 * 1.25ms = 7.5ms (BLE minimum)
-static const uint16_t FAST_MAX_CONN_INTERVAL = 0x06;  // 6 * 1.25ms = 7.5ms
-static const uint16_t FAST_CONN_TIMEOUT = 1000;       // 1000 * 10ms = 10s
 static const esp_bt_uuid_t NOTIFY_DESC_UUID = {
     .len = ESP_UUID_LEN_16,
     .uuid =
@@ -147,7 +129,6 @@ void BLEClientBase::connect() {
   ESP_LOGI(TAG, "[%d] [%s] 0x%02x Attempting BLE connection", this->connection_index_, this->address_str_.c_str(),
            this->remote_addr_type_);
   this->paired_ = false;
-
   auto ret = esp_ble_gattc_open(this->gattc_if_, this->remote_bda_, this->remote_addr_type_, true);
   if (ret) {
     ESP_LOGW(TAG, "[%d] [%s] esp_ble_gattc_open error, status=%d", this->connection_index_, this->address_str_.c_str(),
@@ -155,34 +136,6 @@ void BLEClientBase::connect() {
     this->set_state(espbt::ClientState::IDLE);
   } else {
     this->set_state(espbt::ClientState::CONNECTING);
-
-    // Always set connection parameters to ensure stable operation
-    // Use FAST for V3_WITHOUT_CACHE (devices that need lowest latency)
-    // Use MEDIUM for all other connections (balanced performance)
-    uint16_t min_interval, max_interval, timeout;
-    const char *param_type;
-
-    if (this->connection_type_ == espbt::ConnectionType::V3_WITHOUT_CACHE) {
-      min_interval = FAST_MIN_CONN_INTERVAL;
-      max_interval = FAST_MAX_CONN_INTERVAL;
-      timeout = FAST_CONN_TIMEOUT;
-      param_type = "fast";
-    } else {
-      min_interval = MEDIUM_MIN_CONN_INTERVAL;
-      max_interval = MEDIUM_MAX_CONN_INTERVAL;
-      timeout = MEDIUM_CONN_TIMEOUT;
-      param_type = "medium";
-    }
-
-    auto param_ret = esp_ble_gap_set_prefer_conn_params(this->remote_bda_, min_interval, max_interval,
-                                                        0,  // latency: 0
-                                                        timeout);
-    if (param_ret != ESP_OK) {
-      ESP_LOGW(TAG, "[%d] [%s] esp_ble_gap_set_prefer_conn_params failed: %d", this->connection_index_,
-               this->address_str_.c_str(), param_ret);
-    } else {
-      ESP_LOGD(TAG, "[%d] [%s] Set %s conn params", this->connection_index_, this->address_str_.c_str(), param_type);
-    }
   }
 }
 
@@ -325,14 +278,12 @@ bool BLEClientBase::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
                  this->address_str_.c_str(), ret);
       }
       this->set_state(espbt::ClientState::CONNECTED);
-      ESP_LOGI(TAG, "[%d] [%s] Connection open", this->connection_index_, this->address_str_.c_str());
       if (this->connection_type_ == espbt::ConnectionType::V3_WITH_CACHE) {
-        ESP_LOGI(TAG, "[%d] [%s] Using cached services", this->connection_index_, this->address_str_.c_str());
+        ESP_LOGI(TAG, "[%d] [%s] Connected", this->connection_index_, this->address_str_.c_str());
         // only set our state, subclients might have more stuff to do yet.
         this->state_ = espbt::ClientState::ESTABLISHED;
         break;
       }
-      ESP_LOGD(TAG, "[%d] [%s] Searching for services", this->connection_index_, this->address_str_.c_str());
       esp_ble_gattc_search_service(esp_gattc_if, param->cfg_mtu.conn_id, nullptr);
       break;
     }
@@ -345,15 +296,8 @@ bool BLEClientBase::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
     case ESP_GATTC_DISCONNECT_EVT: {
       if (!this->check_addr(param->disconnect.remote_bda))
         return false;
-      // Check if we were disconnected while waiting for service discovery
-      if (param->disconnect.reason == ESP_GATT_CONN_TERMINATE_PEER_USER &&
-          this->state_ == espbt::ClientState::CONNECTED) {
-        ESP_LOGW(TAG, "[%d] [%s] Disconnected by remote during service discovery", this->connection_index_,
-                 this->address_str_.c_str());
-      } else {
-        ESP_LOGD(TAG, "[%d] [%s] ESP_GATTC_DISCONNECT_EVT, reason 0x%02x", this->connection_index_,
-                 this->address_str_.c_str(), param->disconnect.reason);
-      }
+      ESP_LOGD(TAG, "[%d] [%s] ESP_GATTC_DISCONNECT_EVT, reason %d", this->connection_index_,
+               this->address_str_.c_str(), param->disconnect.reason);
       this->release_services();
       this->set_state(espbt::ClientState::IDLE);
       break;
@@ -409,22 +353,7 @@ bool BLEClientBase::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
         ESP_LOGV(TAG, "[%d] [%s]  start_handle: 0x%x  end_handle: 0x%x", this->connection_index_,
                  this->address_str_.c_str(), svc->start_handle, svc->end_handle);
       }
-      ESP_LOGI(TAG, "[%d] [%s] Service discovery complete", this->connection_index_, this->address_str_.c_str());
-
-      // For non-cached connections, restore to medium connection parameters after service discovery
-      // This balances performance with bandwidth usage after the critical discovery phase
-      if (this->connection_type_ == espbt::ConnectionType::V3_WITHOUT_CACHE) {
-        esp_ble_conn_update_params_t conn_params = {{0}};
-        memcpy(conn_params.bda, this->remote_bda_, sizeof(esp_bd_addr_t));
-        conn_params.min_int = MEDIUM_MIN_CONN_INTERVAL;
-        conn_params.max_int = MEDIUM_MAX_CONN_INTERVAL;
-        conn_params.latency = 0;
-        conn_params.timeout = MEDIUM_CONN_TIMEOUT;
-        ESP_LOGD(TAG, "[%d] [%s] Restored medium conn params after service discovery", this->connection_index_,
-                 this->address_str_.c_str());
-        esp_ble_gap_update_conn_params(&conn_params);
-      }
-
+      ESP_LOGI(TAG, "[%d] [%s] Connected", this->connection_index_, this->address_str_.c_str());
       this->state_ = espbt::ClientState::ESTABLISHED;
       break;
     }

esphome/components/esp32_ble_client/ble_client_base.h

@@ -48,7 +48,7 @@ class BLEClientBase : public espbt::ESPBTClient, public Component {
 
   void set_auto_connect(bool auto_connect) { this->auto_connect_ = auto_connect; }
 
-  virtual void set_address(uint64_t address) {
+  void set_address(uint64_t address) {
     this->address_ = address;
     this->remote_bda_[0] = (address >> 40) & 0xFF;
     this->remote_bda_[1] = (address >> 32) & 0xFF;

esphome/components/esp32_ble_server/__init__.py

@@ -628,4 +628,5 @@ async def ble_server_descriptor_set_value(config, action_id, template_arg, args)
 )
 async def ble_server_characteristic_notify(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, paren)
+    var = cg.new_Pvariable(action_id, template_arg, paren)
+    return var

esphome/components/esp32_touch/esp32_touch_v1.cpp

@@ -201,13 +201,15 @@ void IRAM_ATTR ESP32TouchComponent::touch_isr_handler(void *arg) {
     touch_pad_t pad = child->get_touch_pad();
 
     // Read current value using ISR-safe API
-    // IMPORTANT: ESP-IDF v5.4 regression - touch_pad_read_filtered() is no longer ISR-safe
-    // In ESP-IDF v5.3 and earlier it was ISR-safe, but ESP-IDF v5.4 added mutex protection that causes:
-    // "assert failed: xQueueSemaphoreTake queue.c:1718"
-    // We must use raw values even when filter is enabled as a workaround.
-    // Users should adjust thresholds to compensate for the lack of IIR filtering.
-    // See: https://github.com/espressif/esp-idf/issues/17045
-    uint32_t value = touch_ll_read_raw_data(pad);
+    uint32_t value;
+    if (component->iir_filter_enabled_()) {
+      uint16_t temp_value = 0;
+      touch_pad_read_filtered(pad, &temp_value);
+      value = temp_value;
+    } else {
+      // Use low-level HAL function when filter is not enabled
+      value = touch_ll_read_raw_data(pad);
+    }
 
     // Skip pads that aren’t in the trigger mask
     if (((mask >> pad) & 1) == 0) {

esphome/components/espnow/__init__.py

@@ -1,320 +0,0 @@
-from esphome import automation, core
-import esphome.codegen as cg
-from esphome.components import wifi
-from esphome.components.udp import CONF_ON_RECEIVE
-import esphome.config_validation as cv
-from esphome.const import (
-    CONF_ADDRESS,
-    CONF_CHANNEL,
-    CONF_DATA,
-    CONF_ENABLE_ON_BOOT,
-    CONF_ID,
-    CONF_ON_ERROR,
-    CONF_TRIGGER_ID,
-    CONF_WIFI,
-)
-from esphome.core import CORE, HexInt
-from esphome.types import ConfigType
-
-CODEOWNERS = ["@jesserockz"]
-
-byte_vector = cg.std_vector.template(cg.uint8)
-peer_address_t = cg.std_ns.class_("array").template(cg.uint8, 6)
-
-espnow_ns = cg.esphome_ns.namespace("espnow")
-ESPNowComponent = espnow_ns.class_("ESPNowComponent", cg.Component)
-
-# Handler interfaces that other components can use to register callbacks
-ESPNowReceivedPacketHandler = espnow_ns.class_("ESPNowReceivedPacketHandler")
-ESPNowUnknownPeerHandler = espnow_ns.class_("ESPNowUnknownPeerHandler")
-ESPNowBroadcastedHandler = espnow_ns.class_("ESPNowBroadcastedHandler")
-
-ESPNowRecvInfo = espnow_ns.class_("ESPNowRecvInfo")
-ESPNowRecvInfoConstRef = ESPNowRecvInfo.operator("const").operator("ref")
-
-SendAction = espnow_ns.class_("SendAction", automation.Action)
-SetChannelAction = espnow_ns.class_("SetChannelAction", automation.Action)
-AddPeerAction = espnow_ns.class_("AddPeerAction", automation.Action)
-DeletePeerAction = espnow_ns.class_("DeletePeerAction", automation.Action)
-
-ESPNowHandlerTrigger = automation.Trigger.template(
-    ESPNowRecvInfoConstRef,
-    cg.uint8.operator("const").operator("ptr"),
-    cg.uint8,
-)
-
-OnUnknownPeerTrigger = espnow_ns.class_(
-    "OnUnknownPeerTrigger", ESPNowHandlerTrigger, ESPNowUnknownPeerHandler
-)
-OnReceiveTrigger = espnow_ns.class_(
-    "OnReceiveTrigger", ESPNowHandlerTrigger, ESPNowReceivedPacketHandler
-)
-OnBroadcastedTrigger = espnow_ns.class_(
-    "OnBroadcastedTrigger", ESPNowHandlerTrigger, ESPNowBroadcastedHandler
-)
-
-
-CONF_AUTO_ADD_PEER = "auto_add_peer"
-CONF_PEERS = "peers"
-CONF_ON_SENT = "on_sent"
-CONF_ON_UNKNOWN_PEER = "on_unknown_peer"
-CONF_ON_BROADCAST = "on_broadcast"
-CONF_CONTINUE_ON_ERROR = "continue_on_error"
-CONF_WAIT_FOR_SENT = "wait_for_sent"
-
-MAX_ESPNOW_PACKET_SIZE = 250  # Maximum size of the payload in bytes
-
-
-def _validate_unknown_peer(config):
-    if config[CONF_AUTO_ADD_PEER] and config.get(CONF_ON_UNKNOWN_PEER):
-        raise cv.Invalid(
-            f"'{CONF_ON_UNKNOWN_PEER}' cannot be used when '{CONF_AUTO_ADD_PEER}' is enabled.",
-            path=[CONF_ON_UNKNOWN_PEER],
-        )
-    return config
-
-
-CONFIG_SCHEMA = cv.All(
-    cv.Schema(
-        {
-            cv.GenerateID(): cv.declare_id(ESPNowComponent),
-            cv.OnlyWithout(CONF_CHANNEL, CONF_WIFI): wifi.validate_channel,
-            cv.Optional(CONF_ENABLE_ON_BOOT, default=True): cv.boolean,
-            cv.Optional(CONF_AUTO_ADD_PEER, default=False): cv.boolean,
-            cv.Optional(CONF_PEERS): cv.ensure_list(cv.mac_address),
-            cv.Optional(CONF_ON_UNKNOWN_PEER): automation.validate_automation(
-                {
-                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(OnUnknownPeerTrigger),
-                },
-                single=True,
-            ),
-            cv.Optional(CONF_ON_RECEIVE): automation.validate_automation(
-                {
-                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(OnReceiveTrigger),
-                    cv.Optional(CONF_ADDRESS): cv.mac_address,
-                }
-            ),
-            cv.Optional(CONF_ON_BROADCAST): automation.validate_automation(
-                {
-                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(OnBroadcastedTrigger),
-                    cv.Optional(CONF_ADDRESS): cv.mac_address,
-                }
-            ),
-        },
-    ).extend(cv.COMPONENT_SCHEMA),
-    cv.only_on_esp32,
-    _validate_unknown_peer,
-)
-
-
-async def _trigger_to_code(config):
-    if address := config.get(CONF_ADDRESS):
-        address = address.parts
-    trigger = cg.new_Pvariable(config[CONF_TRIGGER_ID], address)
-    await automation.build_automation(
-        trigger,
-        [
-            (ESPNowRecvInfoConstRef, "info"),
-            (cg.uint8.operator("const").operator("ptr"), "data"),
-            (cg.uint8, "size"),
-        ],
-        config,
-    )
-    return trigger
-
-
-async def to_code(config):
-    print(config)
-    var = cg.new_Pvariable(config[CONF_ID])
-    await cg.register_component(var, config)
-
-    if CORE.using_arduino:
-        cg.add_library("WiFi", None)
-
-    cg.add_define("USE_ESPNOW")
-    if wifi_channel := config.get(CONF_CHANNEL):
-        cg.add(var.set_wifi_channel(wifi_channel))
-
-    cg.add(var.set_auto_add_peer(config[CONF_AUTO_ADD_PEER]))
-
-    for peer in config.get(CONF_PEERS, []):
-        cg.add(var.add_peer(peer.parts))
-
-    if on_receive := config.get(CONF_ON_UNKNOWN_PEER):
-        trigger = await _trigger_to_code(on_receive)
-        cg.add(var.register_unknown_peer_handler(trigger))
-
-    for on_receive in config.get(CONF_ON_RECEIVE, []):
-        trigger = await _trigger_to_code(on_receive)
-        cg.add(var.register_received_handler(trigger))
-
-    for on_receive in config.get(CONF_ON_BROADCAST, []):
-        trigger = await _trigger_to_code(on_receive)
-        cg.add(var.register_broadcasted_handler(trigger))
-
-
-# ========================================== A C T I O N S ================================================
-
-
-def validate_peer(value):
-    if isinstance(value, cv.Lambda):
-        return cv.returning_lambda(value)
-    return cv.mac_address(value)
-
-
-def _validate_raw_data(value):
-    if isinstance(value, str):
-        if len(value) >= MAX_ESPNOW_PACKET_SIZE:
-            raise cv.Invalid(
-                f"'{CONF_DATA}' must be less than {MAX_ESPNOW_PACKET_SIZE} characters long, got {len(value)}"
-            )
-        return value
-    if isinstance(value, list):
-        if len(value) > MAX_ESPNOW_PACKET_SIZE:
-            raise cv.Invalid(
-                f"'{CONF_DATA}' must be less than {MAX_ESPNOW_PACKET_SIZE} bytes long, got {len(value)}"
-            )
-        return cv.Schema([cv.hex_uint8_t])(value)
-    raise cv.Invalid(
-        f"'{CONF_DATA}' must either be a string wrapped in quotes or a list of bytes"
-    )
-
-
-async def register_peer(var, config, args):
-    peer = config[CONF_ADDRESS]
-    if isinstance(peer, core.MACAddress):
-        peer = [HexInt(p) for p in peer.parts]
-
-    template_ = await cg.templatable(peer, args, peer_address_t, peer_address_t)
-    cg.add(var.set_address(template_))
-
-
-PEER_SCHEMA = cv.Schema(
-    {
-        cv.GenerateID(): cv.use_id(ESPNowComponent),
-        cv.Required(CONF_ADDRESS): cv.templatable(cv.mac_address),
-    }
-)
-
-SEND_SCHEMA = PEER_SCHEMA.extend(
-    {
-        cv.Required(CONF_DATA): cv.templatable(_validate_raw_data),
-        cv.Optional(CONF_ON_SENT): automation.validate_action_list,
-        cv.Optional(CONF_ON_ERROR): automation.validate_action_list,
-        cv.Optional(CONF_WAIT_FOR_SENT, default=True): cv.boolean,
-        cv.Optional(CONF_CONTINUE_ON_ERROR, default=True): cv.boolean,
-    }
-)
-
-
-def _validate_send_action(config):
-    if not config[CONF_WAIT_FOR_SENT] and not config[CONF_CONTINUE_ON_ERROR]:
-        raise cv.Invalid(
-            f"'{CONF_CONTINUE_ON_ERROR}' cannot be false if '{CONF_WAIT_FOR_SENT}' is false as the automation will not wait for the failed result.",
-            path=[CONF_CONTINUE_ON_ERROR],
-        )
-    return config
-
-
-SEND_SCHEMA.add_extra(_validate_send_action)
-
-
-@automation.register_action(
-    "espnow.send",
-    SendAction,
-    SEND_SCHEMA,
-)
-@automation.register_action(
-    "espnow.broadcast",
-    SendAction,
-    cv.maybe_simple_value(
-        SEND_SCHEMA.extend(
-            {
-                cv.Optional(CONF_ADDRESS, default="FF:FF:FF:FF:FF:FF"): cv.mac_address,
-            }
-        ),
-        key=CONF_DATA,
-    ),
-)
-async def send_action(
-    config: ConfigType,
-    action_id: core.ID,
-    template_arg: cg.TemplateArguments,
-    args: list[tuple],
-):
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-
-    await register_peer(var, config, args)
-
-    data = config.get(CONF_DATA, [])
-    if isinstance(data, str):
-        data = [cg.RawExpression(f"'{c}'") for c in data]
-    templ = await cg.templatable(data, args, byte_vector, byte_vector)
-    cg.add(var.set_data(templ))
-
-    cg.add(var.set_wait_for_sent(config[CONF_WAIT_FOR_SENT]))
-    cg.add(var.set_continue_on_error(config[CONF_CONTINUE_ON_ERROR]))
-
-    if on_sent_config := config.get(CONF_ON_SENT):
-        actions = await automation.build_action_list(on_sent_config, template_arg, args)
-        cg.add(var.add_on_sent(actions))
-    if on_error_config := config.get(CONF_ON_ERROR):
-        actions = await automation.build_action_list(
-            on_error_config, template_arg, args
-        )
-        cg.add(var.add_on_error(actions))
-    return var
-
-
-@automation.register_action(
-    "espnow.peer.add",
-    AddPeerAction,
-    cv.maybe_simple_value(
-        PEER_SCHEMA,
-        key=CONF_ADDRESS,
-    ),
-)
-@automation.register_action(
-    "espnow.peer.delete",
-    DeletePeerAction,
-    cv.maybe_simple_value(
-        PEER_SCHEMA,
-        key=CONF_ADDRESS,
-    ),
-)
-async def peer_action(
-    config: ConfigType,
-    action_id: core.ID,
-    template_arg: cg.TemplateArguments,
-    args: list[tuple],
-):
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-    await register_peer(var, config, args)
-
-    return var
-
-
-@automation.register_action(
-    "espnow.set_channel",
-    SetChannelAction,
-    cv.maybe_simple_value(
-        {
-            cv.GenerateID(): cv.use_id(ESPNowComponent),
-            cv.Required(CONF_CHANNEL): cv.templatable(wifi.validate_channel),
-        },
-        key=CONF_CHANNEL,
-    ),
-)
-async def channel_action(
-    config: ConfigType,
-    action_id: core.ID,
-    template_arg: cg.TemplateArguments,
-    args: list[tuple],
-):
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-    template_ = await cg.templatable(config[CONF_CHANNEL], args, cg.uint8)
-    cg.add(var.set_channel(template_))
-    return var

esphome/components/espnow/automation.h

@@ -1,175 +0,0 @@
-#pragma once
-
-#ifdef USE_ESP32
-
-#include "espnow_component.h"
-
-#include "esphome/core/automation.h"
-#include "esphome/core/base_automation.h"
-
-namespace esphome::espnow {
-
-template<typename... Ts> class SendAction : public Action<Ts...>, public Parented<ESPNowComponent> {
-  TEMPLATABLE_VALUE(peer_address_t, address);
-  TEMPLATABLE_VALUE(std::vector<uint8_t>, data);
-
- public:
-  void add_on_sent(const std::vector<Action<Ts...> *> &actions) {
-    this->sent_.add_actions(actions);
-    if (this->flags_.wait_for_sent) {
-      this->sent_.add_action(new LambdaAction<Ts...>([this](Ts... x) { this->play_next_(x...); }));
-    }
-  }
-  void add_on_error(const std::vector<Action<Ts...> *> &actions) {
-    this->error_.add_actions(actions);
-    if (this->flags_.wait_for_sent) {
-      this->error_.add_action(new LambdaAction<Ts...>([this](Ts... x) {
-        if (this->flags_.continue_on_error) {
-          this->play_next_(x...);
-        } else {
-          this->stop_complex();
-        }
-      }));
-    }
-  }
-
-  void set_wait_for_sent(bool wait_for_sent) { this->flags_.wait_for_sent = wait_for_sent; }
-  void set_continue_on_error(bool continue_on_error) { this->flags_.continue_on_error = continue_on_error; }
-
-  void play_complex(Ts... x) override {
-    this->num_running_++;
-    send_callback_t send_callback = [this, x...](esp_err_t status) {
-      if (status == ESP_OK) {
-        if (this->sent_.empty() && this->flags_.wait_for_sent) {
-          this->play_next_(x...);
-        } else if (!this->sent_.empty()) {
-          this->sent_.play(x...);
-        }
-      } else {
-        if (this->error_.empty() && this->flags_.wait_for_sent) {
-          if (this->flags_.continue_on_error) {
-            this->play_next_(x...);
-          } else {
-            this->stop_complex();
-          }
-        } else if (!this->error_.empty()) {
-          this->error_.play(x...);
-        }
-      }
-    };
-    peer_address_t address = this->address_.value(x...);
-    std::vector<uint8_t> data = this->data_.value(x...);
-    esp_err_t err = this->parent_->send(address.data(), data, send_callback);
-    if (err != ESP_OK) {
-      send_callback(err);
-    } else if (!this->flags_.wait_for_sent) {
-      this->play_next_(x...);
-    }
-  }
-
-  void play(Ts... x) override { /* ignore - see play_complex */
-  }
-
-  void stop() override {
-    this->sent_.stop();
-    this->error_.stop();
-  }
-
- protected:
-  ActionList<Ts...> sent_;
-  ActionList<Ts...> error_;
-
-  struct {
-    uint8_t wait_for_sent : 1;      // Wait for the send operation to complete before continuing automation
-    uint8_t continue_on_error : 1;  // Continue automation even if the send operation fails
-    uint8_t reserved : 6;           // Reserved for future use
-  } flags_{0};
-};
-
-template<typename... Ts> class AddPeerAction : public Action<Ts...>, public Parented<ESPNowComponent> {
-  TEMPLATABLE_VALUE(peer_address_t, address);
-
- public:
-  void play(Ts... x) override {
-    peer_address_t address = this->address_.value(x...);
-    this->parent_->add_peer(address.data());
-  }
-};
-
-template<typename... Ts> class DeletePeerAction : public Action<Ts...>, public Parented<ESPNowComponent> {
-  TEMPLATABLE_VALUE(peer_address_t, address);
-
- public:
-  void play(Ts... x) override {
-    peer_address_t address = this->address_.value(x...);
-    this->parent_->del_peer(address.data());
-  }
-};
-
-template<typename... Ts> class SetChannelAction : public Action<Ts...>, public Parented<ESPNowComponent> {
- public:
-  TEMPLATABLE_VALUE(uint8_t, channel)
-  void play(Ts... x) override {
-    if (this->parent_->is_wifi_enabled()) {
-      return;
-    }
-    this->parent_->set_wifi_channel(this->channel_.value(x...));
-    this->parent_->apply_wifi_channel();
-  }
-};
-
-class OnReceiveTrigger : public Trigger<const ESPNowRecvInfo &, const uint8_t *, uint8_t>,
-                         public ESPNowReceivedPacketHandler {
- public:
-  explicit OnReceiveTrigger(std::array<uint8_t, ESP_NOW_ETH_ALEN> address) : has_address_(true) {
-    memcpy(this->address_, address.data(), ESP_NOW_ETH_ALEN);
-  }
-
-  explicit OnReceiveTrigger() : has_address_(false) {}
-
-  bool on_received(const ESPNowRecvInfo &info, const uint8_t *data, uint8_t size) override {
-    bool match = !this->has_address_ || (memcmp(this->address_, info.src_addr, ESP_NOW_ETH_ALEN) == 0);
-    if (!match)
-      return false;
-
-    this->trigger(info, data, size);
-    return false;  // Return false to continue processing other internal handlers
-  }
-
- protected:
-  bool has_address_{false};
-  const uint8_t *address_[ESP_NOW_ETH_ALEN];
-};
-class OnUnknownPeerTrigger : public Trigger<const ESPNowRecvInfo &, const uint8_t *, uint8_t>,
-                             public ESPNowUnknownPeerHandler {
- public:
-  bool on_unknown_peer(const ESPNowRecvInfo &info, const uint8_t *data, uint8_t size) override {
-    this->trigger(info, data, size);
-    return false;  // Return false to continue processing other internal handlers
-  }
-};
-class OnBroadcastedTrigger : public Trigger<const ESPNowRecvInfo &, const uint8_t *, uint8_t>,
-                             public ESPNowBroadcastedHandler {
- public:
-  explicit OnBroadcastedTrigger(std::array<uint8_t, ESP_NOW_ETH_ALEN> address) : has_address_(true) {
-    memcpy(this->address_, address.data(), ESP_NOW_ETH_ALEN);
-  }
-  explicit OnBroadcastedTrigger() : has_address_(false) {}
-
-  bool on_broadcasted(const ESPNowRecvInfo &info, const uint8_t *data, uint8_t size) override {
-    bool match = !this->has_address_ || (memcmp(this->address_, info.src_addr, ESP_NOW_ETH_ALEN) == 0);
-    if (!match)
-      return false;
-
-    this->trigger(info, data, size);
-    return false;  // Return false to continue processing other internal handlers
-  }
-
- protected:
-  bool has_address_{false};
-  const uint8_t *address_[ESP_NOW_ETH_ALEN];
-};
-
-}  // namespace esphome::espnow
-
-#endif  // USE_ESP32

esphome/components/espnow/espnow_component.cpp

@@ -1,468 +0,0 @@
-#include "espnow_component.h"
-
-#ifdef USE_ESP32
-
-#include "espnow_err.h"
-
-#include "esphome/core/defines.h"
-#include "esphome/core/log.h"
-
-#include <esp_event.h>
-#include <esp_mac.h>
-#include <esp_now.h>
-#include <esp_random.h>
-#include <esp_wifi.h>
-#include <cstring>
-#include <memory>
-
-#ifdef USE_WIFI
-#include "esphome/components/wifi/wifi_component.h"
-#endif
-
-namespace esphome::espnow {
-
-static constexpr const char *TAG = "espnow";
-
-static const esp_err_t CONFIG_ESPNOW_WAKE_WINDOW = 50;
-static const esp_err_t CONFIG_ESPNOW_WAKE_INTERVAL = 100;
-
-ESPNowComponent *global_esp_now = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
-
-static const LogString *espnow_error_to_str(esp_err_t error) {
-  switch (error) {
-    case ESP_ERR_ESPNOW_FAILED:
-      return LOG_STR("ESPNow is in fail mode");
-    case ESP_ERR_ESPNOW_OWN_ADDRESS:
-      return LOG_STR("Message to your self");
-    case ESP_ERR_ESPNOW_DATA_SIZE:
-      return LOG_STR("Data size to large");
-    case ESP_ERR_ESPNOW_PEER_NOT_SET:
-      return LOG_STR("Peer address not set");
-    case ESP_ERR_ESPNOW_PEER_NOT_PAIRED:
-      return LOG_STR("Peer address not paired");
-    case ESP_ERR_ESPNOW_NOT_INIT:
-      return LOG_STR("Not init");
-    case ESP_ERR_ESPNOW_ARG:
-      return LOG_STR("Invalid argument");
-    case ESP_ERR_ESPNOW_INTERNAL:
-      return LOG_STR("Internal Error");
-    case ESP_ERR_ESPNOW_NO_MEM:
-      return LOG_STR("Our of memory");
-    case ESP_ERR_ESPNOW_NOT_FOUND:
-      return LOG_STR("Peer not found");
-    case ESP_ERR_ESPNOW_IF:
-      return LOG_STR("Interface does not match");
-    case ESP_OK:
-      return LOG_STR("OK");
-    case ESP_NOW_SEND_FAIL:
-      return LOG_STR("Failed");
-    default:
-      return LOG_STR("Unknown Error");
-  }
-}
-
-std::string peer_str(uint8_t *peer) {
-  if (peer == nullptr || peer[0] == 0) {
-    return "[Not Set]";
-  } else if (memcmp(peer, ESPNOW_BROADCAST_ADDR, ESP_NOW_ETH_ALEN) == 0) {
-    return "[Broadcast]";
-  } else if (memcmp(peer, ESPNOW_MULTICAST_ADDR, ESP_NOW_ETH_ALEN) == 0) {
-    return "[Multicast]";
-  } else {
-    return format_mac_address_pretty(peer);
-  }
-}
-
-#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 5, 0)
-void on_send_report(const esp_now_send_info_t *info, esp_now_send_status_t status)
-#else
-void on_send_report(const uint8_t *mac_addr, esp_now_send_status_t status)
-#endif
-{
-  // Allocate an event from the pool
-  ESPNowPacket *packet = global_esp_now->receive_packet_pool_.allocate();
-  if (packet == nullptr) {
-    // No events available - queue is full or we're out of memory
-    global_esp_now->receive_packet_queue_.increment_dropped_count();
-    return;
-  }
-
-// Load new packet data (replaces previous packet)
-#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 5, 0)
-  packet->load_sent_data(info->des_addr, status);
-#else
-  packet->load_sent_data(mac_addr, status);
-#endif
-
-  // Push the packet to the queue
-  global_esp_now->receive_packet_queue_.push(packet);
-  // Push always because we're the only producer and the pool ensures we never exceed queue size
-}
-
-void on_data_received(const esp_now_recv_info_t *info, const uint8_t *data, int size) {
-  // Allocate an event from the pool
-  ESPNowPacket *packet = global_esp_now->receive_packet_pool_.allocate();
-  if (packet == nullptr) {
-    // No events available - queue is full or we're out of memory
-    global_esp_now->receive_packet_queue_.increment_dropped_count();
-    return;
-  }
-
-  // Load new packet data (replaces previous packet)
-  packet->load_received_data(info, data, size);
-
-  // Push the packet to the queue
-  global_esp_now->receive_packet_queue_.push(packet);
-  // Push always because we're the only producer and the pool ensures we never exceed queue size
-}
-
-ESPNowComponent::ESPNowComponent() { global_esp_now = this; }
-
-void ESPNowComponent::dump_config() {
-  uint32_t version = 0;
-  esp_now_get_version(&version);
-
-  ESP_LOGCONFIG(TAG, "espnow:");
-  if (this->is_disabled()) {
-    ESP_LOGCONFIG(TAG, "  Disabled");
-    return;
-  }
-  ESP_LOGCONFIG(TAG,
-                "  Own address: %s\n"
-                "  Version: v%" PRIu32 "\n"
-                "  Wi-Fi channel: %d",
-                format_mac_address_pretty(this->own_address_).c_str(), version, this->wifi_channel_);
-#ifdef USE_WIFI
-  ESP_LOGCONFIG(TAG, "  Wi-Fi enabled: %s", YESNO(this->is_wifi_enabled()));
-#endif
-}
-
-bool ESPNowComponent::is_wifi_enabled() {
-#ifdef USE_WIFI
-  return wifi::global_wifi_component != nullptr && !wifi::global_wifi_component->is_disabled();
-#else
-  return false;
-#endif
-}
-
-void ESPNowComponent::setup() {
-  if (this->enable_on_boot_) {
-    this->enable_();
-  } else {
-    this->state_ = ESPNOW_STATE_DISABLED;
-  }
-}
-
-void ESPNowComponent::enable() {
-  if (this->state_ != ESPNOW_STATE_ENABLED)
-    return;
-
-  ESP_LOGD(TAG, "Enabling");
-  this->state_ = ESPNOW_STATE_OFF;
-
-  this->enable_();
-}
-
-void ESPNowComponent::enable_() {
-  if (!this->is_wifi_enabled()) {
-    esp_event_loop_create_default();
-
-    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
-
-    ESP_ERROR_CHECK(esp_wifi_init(&cfg));
-    ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
-    ESP_ERROR_CHECK(esp_wifi_set_storage(WIFI_STORAGE_RAM));
-    ESP_ERROR_CHECK(esp_wifi_set_ps(WIFI_PS_NONE));
-    ESP_ERROR_CHECK(esp_wifi_start());
-    ESP_ERROR_CHECK(esp_wifi_disconnect());
-
-    this->apply_wifi_channel();
-  }
-#ifdef USE_WIFI
-  else {
-    this->wifi_channel_ = wifi::global_wifi_component->get_wifi_channel();
-  }
-#endif
-
-  esp_err_t err = esp_now_init();
-  if (err != ESP_OK) {
-    ESP_LOGE(TAG, "esp_now_init failed: %s", esp_err_to_name(err));
-    this->mark_failed();
-    return;
-  }
-
-  err = esp_now_register_recv_cb(on_data_received);
-  if (err != ESP_OK) {
-    ESP_LOGE(TAG, "esp_now_register_recv_cb failed: %s", esp_err_to_name(err));
-    this->mark_failed();
-    return;
-  }
-
-  err = esp_now_register_send_cb(on_send_report);
-  if (err != ESP_OK) {
-    ESP_LOGE(TAG, "esp_now_register_recv_cb failed: %s", esp_err_to_name(err));
-    this->mark_failed();
-    return;
-  }
-
-  esp_wifi_get_mac(WIFI_IF_STA, this->own_address_);
-
-#ifdef USE_DEEP_SLEEP
-  esp_now_set_wake_window(CONFIG_ESPNOW_WAKE_WINDOW);
-  esp_wifi_connectionless_module_set_wake_interval(CONFIG_ESPNOW_WAKE_INTERVAL);
-#endif
-
-  for (auto peer : this->peers_) {
-    this->add_peer(peer.address);
-  }
-  this->state_ = ESPNOW_STATE_ENABLED;
-}
-
-void ESPNowComponent::disable() {
-  if (this->state_ == ESPNOW_STATE_DISABLED)
-    return;
-
-  ESP_LOGD(TAG, "Disabling");
-  this->state_ = ESPNOW_STATE_DISABLED;
-
-  esp_now_unregister_recv_cb();
-  esp_now_unregister_send_cb();
-
-  for (auto peer : this->peers_) {
-    this->del_peer(peer.address);
-  }
-
-  esp_err_t err = esp_now_deinit();
-  if (err != ESP_OK) {
-    ESP_LOGE(TAG, "esp_now_deinit failed! 0x%x", err);
-  }
-}
-
-void ESPNowComponent::apply_wifi_channel() {
-  if (this->state_ == ESPNOW_STATE_DISABLED) {
-    ESP_LOGE(TAG, "Cannot set channel when ESPNOW disabled");
-    this->mark_failed();
-    return;
-  }
-
-  if (this->is_wifi_enabled()) {
-    ESP_LOGE(TAG, "Cannot set channel when Wi-Fi enabled");
-    this->mark_failed();
-    return;
-  }
-
-  ESP_LOGI(TAG, "Channel set to %d.", this->wifi_channel_);
-  esp_wifi_set_promiscuous(true);
-  esp_wifi_set_channel(this->wifi_channel_, WIFI_SECOND_CHAN_NONE);
-  esp_wifi_set_promiscuous(false);
-}
-
-void ESPNowComponent::loop() {
-#ifdef USE_WIFI
-  if (wifi::global_wifi_component != nullptr && wifi::global_wifi_component->is_connected()) {
-    int32_t new_channel = wifi::global_wifi_component->get_wifi_channel();
-    if (new_channel != this->wifi_channel_) {
-      ESP_LOGI(TAG, "Wifi Channel is changed from %d to %d.", this->wifi_channel_, new_channel);
-      this->wifi_channel_ = new_channel;
-    }
-  }
-#endif
-
-  // Process received packets
-  ESPNowPacket *packet = this->receive_packet_queue_.pop();
-  while (packet != nullptr) {
-    switch (packet->type_) {
-      case ESPNowPacket::RECEIVED: {
-        const ESPNowRecvInfo info = packet->get_receive_info();
-        if (!esp_now_is_peer_exist(info.src_addr)) {
-          if (this->auto_add_peer_) {
-            this->add_peer(info.src_addr);
-          } else {
-            for (auto *handler : this->unknown_peer_handlers_) {
-              if (handler->on_unknown_peer(info, packet->packet_.receive.data, packet->packet_.receive.size))
-                break;  // If a handler returns true, stop processing further handlers
-            }
-          }
-        }
-        // Intentionally left as if instead of else in case the peer is added above
-        if (esp_now_is_peer_exist(info.src_addr)) {
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
-          ESP_LOGV(TAG, "<<< [%s -> %s] %s", format_mac_address_pretty(info.src_addr).c_str(),
-                   format_mac_address_pretty(info.des_addr).c_str(),
-                   format_hex_pretty(packet->packet_.receive.data, packet->packet_.receive.size).c_str());
-#endif
-          if (memcmp(info.des_addr, ESPNOW_BROADCAST_ADDR, ESP_NOW_ETH_ALEN) == 0) {
-            for (auto *handler : this->broadcasted_handlers_) {
-              if (handler->on_broadcasted(info, packet->packet_.receive.data, packet->packet_.receive.size))
-                break;  // If a handler returns true, stop processing further handlers
-            }
-          } else {
-            for (auto *handler : this->received_handlers_) {
-              if (handler->on_received(info, packet->packet_.receive.data, packet->packet_.receive.size))
-                break;  // If a handler returns true, stop processing further handlers
-            }
-          }
-        }
-        break;
-      }
-      case ESPNowPacket::SENT: {
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
-        ESP_LOGV(TAG, ">>> [%s] %s", format_mac_address_pretty(packet->packet_.sent.address).c_str(),
-                 LOG_STR_ARG(espnow_error_to_str(packet->packet_.sent.status)));
-#endif
-        if (this->current_send_packet_ != nullptr) {
-          this->current_send_packet_->callback_(packet->packet_.sent.status);
-          this->send_packet_pool_.release(this->current_send_packet_);
-          this->current_send_packet_ = nullptr;  // Reset current packet after sending
-        }
-        break;
-      }
-      default:
-        break;
-    }
-    // Return the packet to the pool
-    this->receive_packet_pool_.release(packet);
-    packet = this->receive_packet_queue_.pop();
-  }
-
-  // Process sending packet queue
-  if (this->current_send_packet_ == nullptr) {
-    this->send_();
-  }
-
-  // Log dropped received packets periodically
-  uint16_t received_dropped = this->receive_packet_queue_.get_and_reset_dropped_count();
-  if (received_dropped > 0) {
-    ESP_LOGW(TAG, "Dropped %u received packets due to buffer overflow", received_dropped);
-  }
-
-  // Log dropped send packets periodically
-  uint16_t send_dropped = this->send_packet_queue_.get_and_reset_dropped_count();
-  if (send_dropped > 0) {
-    ESP_LOGW(TAG, "Dropped %u send packets due to buffer overflow", send_dropped);
-  }
-}
-
-esp_err_t ESPNowComponent::send(const uint8_t *peer_address, const uint8_t *payload, size_t size,
-                                const send_callback_t &callback) {
-  if (this->state_ != ESPNOW_STATE_ENABLED) {
-    return ESP_ERR_ESPNOW_NOT_INIT;
-  } else if (this->is_failed()) {
-    return ESP_ERR_ESPNOW_FAILED;
-  } else if (peer_address == 0ULL) {
-    return ESP_ERR_ESPNOW_PEER_NOT_SET;
-  } else if (memcmp(peer_address, this->own_address_, ESP_NOW_ETH_ALEN) == 0) {
-    return ESP_ERR_ESPNOW_OWN_ADDRESS;
-  } else if (size > ESP_NOW_MAX_DATA_LEN) {
-    return ESP_ERR_ESPNOW_DATA_SIZE;
-  } else if (!esp_now_is_peer_exist(peer_address)) {
-    if (memcmp(peer_address, ESPNOW_BROADCAST_ADDR, ESP_NOW_ETH_ALEN) == 0 || this->auto_add_peer_) {
-      esp_err_t err = this->add_peer(peer_address);
-      if (err != ESP_OK) {
-        return err;
-      }
-    } else {
-      return ESP_ERR_ESPNOW_PEER_NOT_PAIRED;
-    }
-  }
-  // Allocate a packet from the pool
-  ESPNowSendPacket *packet = this->send_packet_pool_.allocate();
-  if (packet == nullptr) {
-    this->send_packet_queue_.increment_dropped_count();
-    ESP_LOGE(TAG, "Failed to allocate send packet from pool");
-    this->status_momentary_warning("send-packet-pool-full");
-    return ESP_ERR_ESPNOW_NO_MEM;
-  }
-  // Load the packet data
-  packet->load_data(peer_address, payload, size, callback);
-  // Push the packet to the send queue
-  this->send_packet_queue_.push(packet);
-  return ESP_OK;
-}
-
-void ESPNowComponent::send_() {
-  ESPNowSendPacket *packet = this->send_packet_queue_.pop();
-  if (packet == nullptr) {
-    return;  // No packets to send
-  }
-
-  this->current_send_packet_ = packet;
-  esp_err_t err = esp_now_send(packet->address_, packet->data_, packet->size_);
-  if (err != ESP_OK) {
-    ESP_LOGE(TAG, "Failed to send packet to %s - %s", format_mac_address_pretty(packet->address_).c_str(),
-             LOG_STR_ARG(espnow_error_to_str(err)));
-    if (packet->callback_ != nullptr) {
-      packet->callback_(err);
-    }
-    this->status_momentary_warning("send-failed");
-    this->send_packet_pool_.release(packet);
-    this->current_send_packet_ = nullptr;  // Reset current packet
-    return;
-  }
-}
-
-esp_err_t ESPNowComponent::add_peer(const uint8_t *peer) {
-  if (this->state_ != ESPNOW_STATE_ENABLED || this->is_failed()) {
-    return ESP_ERR_ESPNOW_NOT_INIT;
-  }
-
-  if (memcmp(peer, this->own_address_, ESP_NOW_ETH_ALEN) == 0) {
-    this->mark_failed();
-    return ESP_ERR_INVALID_MAC;
-  }
-
-  if (!esp_now_is_peer_exist(peer)) {
-    esp_now_peer_info_t peer_info = {};
-    memset(&peer_info, 0, sizeof(esp_now_peer_info_t));
-    peer_info.ifidx = WIFI_IF_STA;
-    memcpy(peer_info.peer_addr, peer, ESP_NOW_ETH_ALEN);
-    esp_err_t err = esp_now_add_peer(&peer_info);
-
-    if (err != ESP_OK) {
-      ESP_LOGE(TAG, "Failed to add peer %s - %s", format_mac_address_pretty(peer).c_str(),
-               LOG_STR_ARG(espnow_error_to_str(err)));
-      this->status_momentary_warning("peer-add-failed");
-      return err;
-    }
-  }
-  bool found = false;
-  for (auto &it : this->peers_) {
-    if (it == peer) {
-      found = true;
-      break;
-    }
-  }
-  if (!found) {
-    ESPNowPeer new_peer;
-    memcpy(new_peer.address, peer, ESP_NOW_ETH_ALEN);
-    this->peers_.push_back(new_peer);
-  }
-
-  return ESP_OK;
-}
-
-esp_err_t ESPNowComponent::del_peer(const uint8_t *peer) {
-  if (this->state_ != ESPNOW_STATE_ENABLED || this->is_failed()) {
-    return ESP_ERR_ESPNOW_NOT_INIT;
-  }
-  if (esp_now_is_peer_exist(peer)) {
-    esp_err_t err = esp_now_del_peer(peer);
-    if (err != ESP_OK) {
-      ESP_LOGE(TAG, "Failed to delete peer %s - %s", format_mac_address_pretty(peer).c_str(),
-               LOG_STR_ARG(espnow_error_to_str(err)));
-      this->status_momentary_warning("peer-del-failed");
-      return err;
-    }
-  }
-  for (auto it = this->peers_.begin(); it != this->peers_.end(); ++it) {
-    if (*it == peer) {
-      this->peers_.erase(it);
-      break;
-    }
-  }
-  return ESP_OK;
-}
-
-}  // namespace esphome::espnow
-
-#endif  // USE_ESP32

esphome/components/espnow/espnow_component.h

@@ -1,182 +0,0 @@
-#pragma once
-
-#include "esphome/core/automation.h"
-#include "esphome/core/component.h"
-
-#ifdef USE_ESP32
-
-#include "esphome/core/event_pool.h"
-#include "esphome/core/lock_free_queue.h"
-#include "espnow_packet.h"
-
-#include <esp_idf_version.h>
-
-#include <esp_mac.h>
-#include <esp_now.h>
-
-#include <array>
-#include <map>
-#include <memory>
-#include <string>
-#include <vector>
-
-namespace esphome::espnow {
-
-// Maximum size of the ESPNow event queue - must be power of 2 for lock-free queue
-static constexpr size_t MAX_ESP_NOW_SEND_QUEUE_SIZE = 16;
-static constexpr size_t MAX_ESP_NOW_RECEIVE_QUEUE_SIZE = 16;
-
-using peer_address_t = std::array<uint8_t, ESP_NOW_ETH_ALEN>;
-
-enum class ESPNowTriggers : uint8_t {
-  TRIGGER_NONE = 0,
-  ON_NEW_PEER = 1,
-  ON_RECEIVED = 2,
-  ON_BROADCASTED = 3,
-  ON_SUCCEED = 10,
-  ON_FAILED = 11,
-};
-
-enum ESPNowState : uint8_t {
-  /** Nothing has been initialized yet. */
-  ESPNOW_STATE_OFF = 0,
-  /** ESPNOW is disabled. */
-  ESPNOW_STATE_DISABLED,
-  /** ESPNOW is enabled. */
-  ESPNOW_STATE_ENABLED,
-};
-
-struct ESPNowPeer {
-  uint8_t address[ESP_NOW_ETH_ALEN];  // MAC address of the peer
-
-  bool operator==(const ESPNowPeer &other) const { return memcmp(this->address, other.address, ESP_NOW_ETH_ALEN) == 0; }
-  bool operator==(const uint8_t *other) const { return memcmp(this->address, other, ESP_NOW_ETH_ALEN) == 0; }
-};
-
-/// Handler interface for receiving ESPNow packets from unknown peers
-/// Components should inherit from this class to handle incoming ESPNow data
-class ESPNowUnknownPeerHandler {
- public:
-  /// Called when an ESPNow packet is received from an unknown peer
-  /// @param info Information about the received packet (sender MAC, etc.)
-  /// @param data Pointer to the received data payload
-  /// @param size Size of the received data in bytes
-  /// @return true if the packet was handled, false otherwise
-  virtual bool on_unknown_peer(const ESPNowRecvInfo &info, const uint8_t *data, uint8_t size) = 0;
-};
-
-/// Handler interface for receiving ESPNow packets
-/// Components should inherit from this class to handle incoming ESPNow data
-class ESPNowReceivedPacketHandler {
- public:
-  /// Called when an ESPNow packet is received
-  /// @param info Information about the received packet (sender MAC, etc.)
-  /// @param data Pointer to the received data payload
-  /// @param size Size of the received data in bytes
-  /// @return true if the packet was handled, false otherwise
-  virtual bool on_received(const ESPNowRecvInfo &info, const uint8_t *data, uint8_t size) = 0;
-};
-/// Handler interface for receiving broadcasted ESPNow packets
-/// Components should inherit from this class to handle incoming ESPNow data
-class ESPNowBroadcastedHandler {
- public:
-  /// Called when a broadcasted ESPNow packet is received
-  /// @param info Information about the received packet (sender MAC, etc.)
-  /// @param data Pointer to the received data payload
-  /// @param size Size of the received data in bytes
-  /// @return true if the packet was handled, false otherwise
-  virtual bool on_broadcasted(const ESPNowRecvInfo &info, const uint8_t *data, uint8_t size) = 0;
-};
-
-class ESPNowComponent : public Component {
- public:
-  ESPNowComponent();
-  void setup() override;
-  void loop() override;
-  void dump_config() override;
-
-  float get_setup_priority() const override { return setup_priority::LATE; }
-
-  // Add a peer to the internal list of peers
-  void add_peer(peer_address_t address) {
-    ESPNowPeer peer;
-    memcpy(peer.address, address.data(), ESP_NOW_ETH_ALEN);
-    this->peers_.push_back(peer);
-  }
-  // Add a peer with the esp_now api and add to the internal list if doesnt exist already
-  esp_err_t add_peer(const uint8_t *peer);
-  // Remove a peer with the esp_now api and remove from the internal list if exists
-  esp_err_t del_peer(const uint8_t *peer);
-
-  void set_wifi_channel(uint8_t channel) { this->wifi_channel_ = channel; }
-  void apply_wifi_channel();
-
-  void set_auto_add_peer(bool value) { this->auto_add_peer_ = value; }
-
-  void enable();
-  void disable();
-  bool is_disabled() const { return this->state_ == ESPNOW_STATE_DISABLED; };
-  void set_enable_on_boot(bool enable_on_boot) { this->enable_on_boot_ = enable_on_boot; }
-  bool is_wifi_enabled();
-
-  /// @brief Queue a packet to be sent to a specific peer address.
-  /// This method will add the packet to the internal queue and
-  /// call the callback when the packet is sent.
-  /// Only one packet will be sent at any given time and the next one will not be sent until
-  /// the previous one has been acknowledged or failed.
-  /// @param peer_address MAC address of the peer to send the packet to
-  /// @param payload Data payload to send
-  /// @param callback Callback to call when the send operation is complete
-  /// @return ESP_OK on success, or an error code on failure
-  esp_err_t send(const uint8_t *peer_address, const std::vector<uint8_t> &payload,
-                 const send_callback_t &callback = nullptr) {
-    return this->send(peer_address, payload.data(), payload.size(), callback);
-  }
-  esp_err_t send(const uint8_t *peer_address, const uint8_t *payload, size_t size,
-                 const send_callback_t &callback = nullptr);
-
-  void register_received_handler(ESPNowReceivedPacketHandler *handler) { this->received_handlers_.push_back(handler); }
-  void register_unknown_peer_handler(ESPNowUnknownPeerHandler *handler) {
-    this->unknown_peer_handlers_.push_back(handler);
-  }
-  void register_broadcasted_handler(ESPNowBroadcastedHandler *handler) {
-    this->broadcasted_handlers_.push_back(handler);
-  }
-
- protected:
-  friend void on_data_received(const esp_now_recv_info_t *info, const uint8_t *data, int size);
-#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 5, 0)
-  friend void on_send_report(const esp_now_send_info_t *info, esp_now_send_status_t status);
-#else
-  friend void on_send_report(const uint8_t *mac_addr, esp_now_send_status_t status);
-#endif
-
-  void enable_();
-  void send_();
-
-  std::vector<ESPNowUnknownPeerHandler *> unknown_peer_handlers_;
-  std::vector<ESPNowReceivedPacketHandler *> received_handlers_;
-  std::vector<ESPNowBroadcastedHandler *> broadcasted_handlers_;
-
-  std::vector<ESPNowPeer> peers_{};
-
-  uint8_t own_address_[ESP_NOW_ETH_ALEN]{0};
-  LockFreeQueue<ESPNowPacket, MAX_ESP_NOW_RECEIVE_QUEUE_SIZE> receive_packet_queue_{};
-  EventPool<ESPNowPacket, MAX_ESP_NOW_RECEIVE_QUEUE_SIZE> receive_packet_pool_{};
-
-  LockFreeQueue<ESPNowSendPacket, MAX_ESP_NOW_SEND_QUEUE_SIZE> send_packet_queue_{};
-  EventPool<ESPNowSendPacket, MAX_ESP_NOW_SEND_QUEUE_SIZE> send_packet_pool_{};
-  ESPNowSendPacket *current_send_packet_{nullptr};  // Currently sending packet, nullptr if none
-
-  uint8_t wifi_channel_{0};
-  ESPNowState state_{ESPNOW_STATE_OFF};
-
-  bool auto_add_peer_{false};
-  bool enable_on_boot_{true};
-};
-
-extern ESPNowComponent *global_esp_now;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
-
-}  // namespace esphome::espnow
-
-#endif  // USE_ESP32

esphome/components/espnow/espnow_err.h

@@ -1,19 +0,0 @@
-#pragma once
-
-#ifdef USE_ESP32
-
-#include <esp_err.h>
-#include <esp_now.h>
-
-namespace esphome::espnow {
-
-static const esp_err_t ESP_ERR_ESPNOW_CMP_BASE = (ESP_ERR_ESPNOW_BASE + 20);
-static const esp_err_t ESP_ERR_ESPNOW_FAILED = (ESP_ERR_ESPNOW_CMP_BASE + 1);
-static const esp_err_t ESP_ERR_ESPNOW_OWN_ADDRESS = (ESP_ERR_ESPNOW_CMP_BASE + 2);
-static const esp_err_t ESP_ERR_ESPNOW_DATA_SIZE = (ESP_ERR_ESPNOW_CMP_BASE + 3);
-static const esp_err_t ESP_ERR_ESPNOW_PEER_NOT_SET = (ESP_ERR_ESPNOW_CMP_BASE + 4);
-static const esp_err_t ESP_ERR_ESPNOW_PEER_NOT_PAIRED = (ESP_ERR_ESPNOW_CMP_BASE + 5);
-
-}  // namespace esphome::espnow
-
-#endif  // USE_ESP32

esphome/components/espnow/espnow_packet.h

@@ -1,166 +0,0 @@
-#pragma once
-
-#ifdef USE_ESP32
-
-#include "espnow_err.h"
-
-#include <cstdint>
-#include <cstring>
-#include <functional>
-#include <memory>
-#include <vector>
-
-#include <esp_err.h>
-#include <esp_idf_version.h>
-#include <esp_now.h>
-
-namespace esphome::espnow {
-
-static const uint8_t ESPNOW_BROADCAST_ADDR[ESP_NOW_ETH_ALEN] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
-static const uint8_t ESPNOW_MULTICAST_ADDR[ESP_NOW_ETH_ALEN] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE};
-
-struct WifiPacketRxControl {
-  int8_t rssi;         // Received Signal Strength Indicator (RSSI) of packet, unit: dBm
-  uint32_t timestamp;  // Timestamp in microseconds when the packet was received, precise only if modem sleep or
-                       // light sleep is not enabled
-};
-
-struct ESPNowRecvInfo {
-  uint8_t src_addr[ESP_NOW_ETH_ALEN]; /**< Source address of ESPNOW packet */
-  uint8_t des_addr[ESP_NOW_ETH_ALEN]; /**< Destination address of ESPNOW packet */
-  wifi_pkt_rx_ctrl_t *rx_ctrl;        /**< Rx control info of ESPNOW packet */
-};
-
-using send_callback_t = std::function<void(esp_err_t)>;
-
-class ESPNowPacket {
- public:
-  // NOLINTNEXTLINE(readability-identifier-naming)
-  enum esp_now_packet_type_t : uint8_t {
-    RECEIVED,
-    SENT,
-  };
-
-  // Constructor for received data
-  ESPNowPacket(const esp_now_recv_info_t *info, const uint8_t *data, int size) {
-    this->init_received_data_(info, data, size);
-  };
-
-#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 5, 0)
-  // Constructor for sent data
-  ESPNowPacket(const esp_now_send_info_t *info, esp_now_send_status_t status) {
-    this->init_sent_data(info->src_addr, status);
-  }
-#else
-  // Constructor for sent data
-  ESPNowPacket(const uint8_t *mac_addr, esp_now_send_status_t status) { this->init_sent_data_(mac_addr, status); }
-#endif
-
-  // Default constructor for pre-allocation in pool
-  ESPNowPacket() {}
-
-  void release() {}
-
-  void load_received_data(const esp_now_recv_info_t *info, const uint8_t *data, int size) {
-    this->type_ = RECEIVED;
-    this->init_received_data_(info, data, size);
-  }
-
-  void load_sent_data(const uint8_t *mac_addr, esp_now_send_status_t status) {
-    this->type_ = SENT;
-    this->init_sent_data_(mac_addr, status);
-  }
-
-  // Disable copy to prevent double-delete
-  ESPNowPacket(const ESPNowPacket &) = delete;
-  ESPNowPacket &operator=(const ESPNowPacket &) = delete;
-
-  union {
-    // NOLINTNEXTLINE(readability-identifier-naming)
-    struct received_data {
-      ESPNowRecvInfo info;                 // Information about the received packet
-      uint8_t data[ESP_NOW_MAX_DATA_LEN];  // Data received in the packet
-      uint8_t size;                        // Size of the received data
-      WifiPacketRxControl rx_ctrl;         // Status of the received packet
-    } receive;
-
-    // NOLINTNEXTLINE(readability-identifier-naming)
-    struct sent_data {
-      uint8_t address[ESP_NOW_ETH_ALEN];
-      esp_now_send_status_t status;
-    } sent;
-  } packet_;
-
-  esp_now_packet_type_t type_;
-
-  esp_now_packet_type_t type() const { return this->type_; }
-  const ESPNowRecvInfo &get_receive_info() const { return this->packet_.receive.info; }
-
- private:
-  void init_received_data_(const esp_now_recv_info_t *info, const uint8_t *data, int size) {
-    memcpy(this->packet_.receive.info.src_addr, info->src_addr, ESP_NOW_ETH_ALEN);
-    memcpy(this->packet_.receive.info.des_addr, info->des_addr, ESP_NOW_ETH_ALEN);
-    memcpy(this->packet_.receive.data, data, size);
-    this->packet_.receive.size = size;
-
-    this->packet_.receive.rx_ctrl.rssi = info->rx_ctrl->rssi;
-    this->packet_.receive.rx_ctrl.timestamp = info->rx_ctrl->timestamp;
-
-    this->packet_.receive.info.rx_ctrl = reinterpret_cast<wifi_pkt_rx_ctrl_t *>(&this->packet_.receive.rx_ctrl);
-  }
-
-  void init_sent_data_(const uint8_t *mac_addr, esp_now_send_status_t status) {
-    memcpy(this->packet_.sent.address, mac_addr, ESP_NOW_ETH_ALEN);
-    this->packet_.sent.status = status;
-  }
-};
-
-class ESPNowSendPacket {
- public:
-  ESPNowSendPacket(const uint8_t *peer_address, const uint8_t *payload, size_t size, const send_callback_t &&callback)
-      : callback_(callback) {
-    this->init_data_(peer_address, payload, size);
-  }
-  ESPNowSendPacket(const uint8_t *peer_address, const uint8_t *payload, size_t size) {
-    this->init_data_(peer_address, payload, size);
-  }
-
-  // Default constructor for pre-allocation in pool
-  ESPNowSendPacket() {}
-
-  void release() {}
-
-  // Disable copy to prevent double-delete
-  ESPNowSendPacket(const ESPNowSendPacket &) = delete;
-  ESPNowSendPacket &operator=(const ESPNowSendPacket &) = delete;
-
-  void load_data(const uint8_t *peer_address, const uint8_t *payload, size_t size, const send_callback_t &callback) {
-    this->init_data_(peer_address, payload, size);
-    this->callback_ = callback;
-  }
-
-  void load_data(const uint8_t *peer_address, const uint8_t *payload, size_t size) {
-    this->init_data_(peer_address, payload, size);
-    this->callback_ = nullptr;  // Reset callback
-  }
-
-  uint8_t address_[ESP_NOW_ETH_ALEN]{0};   // MAC address of the peer to send the packet to
-  uint8_t data_[ESP_NOW_MAX_DATA_LEN]{0};  // Data to send
-  uint8_t size_{0};                        // Size of the data to send, must be <= ESP_NOW_MAX_DATA_LEN
-  send_callback_t callback_{nullptr};      // Callback to call when the send operation is complete
-
- private:
-  void init_data_(const uint8_t *peer_address, const uint8_t *payload, size_t size) {
-    memcpy(this->address_, peer_address, ESP_NOW_ETH_ALEN);
-    if (size > ESP_NOW_MAX_DATA_LEN) {
-      this->size_ = 0;
-      return;
-    }
-    this->size_ = size;
-    memcpy(this->data_, payload, this->size_);
-  }
-};
-
-}  // namespace esphome::espnow
-
-#endif  // USE_ESP32

esphome/components/event/__init__.py

@@ -145,4 +145,5 @@ async def event_fire_to_code(config, action_id, template_arg, args):
 
 @coroutine_with_priority(100.0)
 async def to_code(config):
+    cg.add_define("USE_EVENT")
     cg.add_global(event_ns.using)

esphome/components/fan/__init__.py

@@ -400,4 +400,5 @@ async def fan_is_on_off_to_code(config, condition_id, template_arg, args):
 
 @coroutine_with_priority(100.0)
 async def to_code(config):
+    cg.add_define("USE_FAN")
     cg.add_global(fan_ns.using)

esphome/components/fan/fan_traits.h

@@ -4,13 +4,6 @@
 #pragma once
 
 namespace esphome {
-
-#ifdef USE_API
-namespace api {
-class APIConnection;
-}  // namespace api
-#endif
-
 namespace fan {
 
 class FanTraits {
@@ -43,15 +36,6 @@ class FanTraits {
   bool supports_preset_modes() const { return !this->preset_modes_.empty(); }
 
  protected:
-#ifdef USE_API
-  // The API connection is a friend class to access internal methods
-  friend class api::APIConnection;
-  // This method returns a reference to the internal preset modes set.
-  // It is used by the API to avoid copying data when encoding messages.
-  // Warning: Do not use this method outside of the API connection code.
-  // It returns a reference to internal data that can be invalidated.
-  const std::set<std::string> &supported_preset_modes_for_api_() const { return this->preset_modes_; }
-#endif
   bool oscillation_{false};
   bool speed_{false};
   bool direction_{false};

esphome/components/gps/gps.cpp

@@ -52,7 +52,7 @@ void GPS::update() {
 void GPS::loop() {
   while (this->available() > 0 && !this->has_time_) {
     if (!this->tiny_gps_.encode(this->read())) {
-      continue;
+      return;
     }
     if (this->tiny_gps_.location.isUpdated()) {
       this->latitude_ = this->tiny_gps_.location.lat();

esphome/components/haier/climate.py

@@ -330,7 +330,8 @@ HAIER_HON_BASE_ACTION_SCHEMA = automation.maybe_simple_id(
 )
 async def display_action_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, paren)
+    var = cg.new_Pvariable(action_id, template_arg, paren)
+    return var
 
 
 @automation.register_action(
@@ -341,7 +342,8 @@ async def display_action_to_code(config, action_id, template_arg, args):
 )
 async def beeper_action_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, paren)
+    var = cg.new_Pvariable(action_id, template_arg, paren)
+    return var
 
 
 # Start self cleaning or steri-cleaning action action
@@ -357,7 +359,8 @@ async def beeper_action_to_code(config, action_id, template_arg, args):
 )
 async def start_cleaning_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, paren)
+    var = cg.new_Pvariable(action_id, template_arg, paren)
+    return var
 
 
 # Set vertical airflow direction action
@@ -414,7 +417,8 @@ async def haier_set_horizontal_airflow_to_code(config, action_id, template_arg,
 )
 async def health_action_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, paren)
+    var = cg.new_Pvariable(action_id, template_arg, paren)
+    return var
 
 
 @automation.register_action(
@@ -428,7 +432,8 @@ async def health_action_to_code(config, action_id, template_arg, args):
 )
 async def power_action_to_code(config, action_id, template_arg, args):
     paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, paren)
+    var = cg.new_Pvariable(action_id, template_arg, paren)
+    return var
 
 
 def _final_validate(config):

esphome/components/heatpumpir/climate.py

@@ -126,6 +126,6 @@ async def to_code(config):
     cg.add(var.set_max_temperature(config[CONF_MAX_TEMPERATURE]))
     cg.add(var.set_min_temperature(config[CONF_MIN_TEMPERATURE]))
 
-    cg.add_library("tonia/HeatpumpIR", "1.0.37")
-    if CORE.is_libretiny or CORE.is_esp32:
+    cg.add_library("tonia/HeatpumpIR", "1.0.35")
+    if CORE.is_libretiny:
         CORE.add_platformio_option("lib_ignore", "IRremoteESP8266")

esphome/components/i2c/i2c_bus_esp_idf.cpp

@@ -159,7 +159,7 @@ void IDFI2CBus::dump_config() {
         if (s.second) {
           ESP_LOGCONFIG(TAG, "Found device at address 0x%02X", s.first);
         } else {
-          ESP_LOGE(TAG, "Unknown error at address 0x%02X", s.first);
+          ESP_LOGCONFIG(TAG, "Unknown error at address 0x%02X", s.first);
         }
       }
     }

esphome/components/image/__init__.py

@@ -108,24 +108,6 @@ class ImageEncoder:
         :return:
         """
 
-    @classmethod
-    def is_endian(cls) -> bool:
-        """
-        Check if the image encoder supports endianness configuration
-        """
-        return getattr(cls, "set_big_endian", None) is not None
-
-    @classmethod
-    def get_options(cls) -> list[str]:
-        """
-        Get the available options for this image encoder
-        """
-        options = [*OPTIONS]
-        if not cls.is_endian():
-            options.remove(CONF_BYTE_ORDER)
-        options.append(CONF_RAW_DATA_ID)
-        return options
-
 
 def is_alpha_only(image: Image):
     """
@@ -464,14 +446,13 @@ def validate_type(image_types):
     return validate
 
 
-def validate_settings(value, path=()):
+def validate_settings(value):
     """
     Validate the settings for a single image configuration.
     """
     conf_type = value[CONF_TYPE]
     type_class = IMAGE_TYPE[conf_type]
-
-    transparency = value.get(CONF_TRANSPARENCY, CONF_OPAQUE).lower()
+    transparency = value[CONF_TRANSPARENCY].lower()
     if transparency not in type_class.allow_config:
         raise cv.Invalid(
             f"Image format '{conf_type}' cannot have transparency: {transparency}"
@@ -483,10 +464,11 @@ def validate_settings(value, path=()):
         and CONF_INVERT_ALPHA not in type_class.allow_config
     ):
         raise cv.Invalid("No alpha channel to invert")
-    if value.get(CONF_BYTE_ORDER) is not None and not type_class.is_endian():
+    if value.get(CONF_BYTE_ORDER) is not None and not callable(
+        getattr(type_class, "set_big_endian", None)
+    ):
         raise cv.Invalid(
-            f"Image format '{conf_type}' does not support byte order configuration",
-            path=path,
+            f"Image format '{conf_type}' does not support byte order configuration"
         )
     if file := value.get(CONF_FILE):
         file = Path(file)
@@ -497,7 +479,7 @@ def validate_settings(value, path=()):
                 Image.open(file)
             except UnidentifiedImageError as exc:
                 raise cv.Invalid(
-                    f"File can't be opened as image: {file.absolute()}", path=path
+                    f"File can't be opened as image: {file.absolute()}"
                 ) from exc
     return value
 
@@ -517,10 +499,6 @@ OPTIONS_SCHEMA = {
     cv.Optional(CONF_INVERT_ALPHA, default=False): cv.boolean,
     cv.Optional(CONF_BYTE_ORDER): cv.one_of("BIG_ENDIAN", "LITTLE_ENDIAN", upper=True),
     cv.Optional(CONF_TRANSPARENCY, default=CONF_OPAQUE): validate_transparency(),
-}
-
-DEFAULTS_SCHEMA = {
-    **OPTIONS_SCHEMA,
     cv.Optional(CONF_TYPE): validate_type(IMAGE_TYPE),
 }
 
@@ -532,61 +510,47 @@ IMAGE_SCHEMA_NO_DEFAULTS = {
     **{cv.Optional(key): OPTIONS_SCHEMA[key] for key in OPTIONS},
 }
 
-IMAGE_SCHEMA = cv.Schema(
+BASE_SCHEMA = cv.Schema(
     {
         **IMAGE_ID_SCHEMA,
         **OPTIONS_SCHEMA,
+    }
+).add_extra(validate_settings)
+
+IMAGE_SCHEMA = BASE_SCHEMA.extend(
+    {
         cv.Required(CONF_TYPE): validate_type(IMAGE_TYPE),
     }
 )
 
 
-def apply_defaults(image, defaults, path):
-    """
-    Apply defaults to an image configuration
-    """
-    type = image.get(CONF_TYPE, defaults.get(CONF_TYPE))
-    if type is None:
-        raise cv.Invalid(
-            "Type is required either in the image config or in the defaults", path=path
-        )
-    type_class = IMAGE_TYPE[type]
-    config = {
-        **{key: image.get(key, defaults.get(key)) for key in type_class.get_options()},
-        **{key.schema: image[key.schema] for key in IMAGE_ID_SCHEMA},
-        CONF_TYPE: image.get(CONF_TYPE, defaults.get(CONF_TYPE)),
-    }
-    validate_settings(config, path)
-    return config
-
-
 def validate_defaults(value):
     """
-    Apply defaults to the images in the configuration and flatten to a single list.
+    Validate the options for images with defaults
     """
     defaults = value[CONF_DEFAULTS]
     result = []
-    # Apply defaults to the images: list and add the list entries to the result
-    for index, image in enumerate(value.get(CONF_IMAGES, [])):
-        result.append(apply_defaults(image, defaults, [CONF_IMAGES, index]))
-
-    # Apply defaults to images under the type keys and add them to the result
-    for image_type, type_config in value.items():
-        type_upper = image_type.upper()
-        if type_upper not in IMAGE_TYPE:
-            continue
-        type_class = IMAGE_TYPE[type_upper]
-        if isinstance(type_config, list):
-            # If the type is a list, apply defaults to each entry
-            for index, image in enumerate(type_config):
-                result.append(apply_defaults(image, defaults, [image_type, index]))
-        else:
-            # Handle transparency options for the type
-            for trans_type in set(type_class.allow_config).intersection(type_config):
-                for index, image in enumerate(type_config[trans_type]):
-                    result.append(
-                        apply_defaults(image, defaults, [image_type, trans_type, index])
-                    )
+    for index, image in enumerate(value[CONF_IMAGES]):
+        type = image.get(CONF_TYPE, defaults.get(CONF_TYPE))
+        if type is None:
+            raise cv.Invalid(
+                "Type is required either in the image config or in the defaults",
+                path=[CONF_IMAGES, index],
+            )
+        type_class = IMAGE_TYPE[type]
+        # A default byte order should be simply ignored if the type does not support it
+        available_options = [*OPTIONS]
+        if (
+            not callable(getattr(type_class, "set_big_endian", None))
+            and CONF_BYTE_ORDER not in image
+        ):
+            available_options.remove(CONF_BYTE_ORDER)
+        config = {
+            **{key: image.get(key, defaults.get(key)) for key in available_options},
+            **{key.schema: image[key.schema] for key in IMAGE_ID_SCHEMA},
+        }
+        validate_settings(config)
+        result.append(config)
     return result
 
 
@@ -598,20 +562,16 @@ def typed_image_schema(image_type):
         cv.Schema(
             {
                 cv.Optional(t.lower()): cv.ensure_list(
-                    {
-                        **IMAGE_ID_SCHEMA,
-                        **{
-                            cv.Optional(key): OPTIONS_SCHEMA[key]
-                            for key in OPTIONS
-                            if key != CONF_TRANSPARENCY
-                        },
-                        cv.Optional(
-                            CONF_TRANSPARENCY, default=t
-                        ): validate_transparency((t,)),
-                        cv.Optional(CONF_TYPE, default=image_type): validate_type(
-                            (image_type,)
-                        ),
-                    }
+                    BASE_SCHEMA.extend(
+                        {
+                            cv.Optional(
+                                CONF_TRANSPARENCY, default=t
+                            ): validate_transparency((t,)),
+                            cv.Optional(CONF_TYPE, default=image_type): validate_type(
+                                (image_type,)
+                            ),
+                        }
+                    )
                 )
                 for t in IMAGE_TYPE[image_type].allow_config.intersection(
                     TRANSPARENCY_TYPES
@@ -620,44 +580,46 @@ def typed_image_schema(image_type):
         ),
         # Allow a default configuration with no transparency preselected
         cv.ensure_list(
-            {
-                **IMAGE_SCHEMA_NO_DEFAULTS,
-                cv.Optional(CONF_TYPE, default=image_type): validate_type(
-                    (image_type,)
-                ),
-            }
+            BASE_SCHEMA.extend(
+                {
+                    cv.Optional(
+                        CONF_TRANSPARENCY, default=CONF_OPAQUE
+                    ): validate_transparency(),
+                    cv.Optional(CONF_TYPE, default=image_type): validate_type(
+                        (image_type,)
+                    ),
+                }
+            )
         ),
     )
 
 
 # The config schema can be a (possibly empty) single list of images,
-# or a dictionary with optional keys `defaults:`, `images:` and the image types
+# or a dictionary of image types each with a list of images
+# or a dictionary with keys `defaults:` and `images:`
 
 
-def _config_schema(value):
-    if isinstance(value, list) or (
-        isinstance(value, dict) and (CONF_ID in value or CONF_FILE in value)
-    ):
-        return cv.ensure_list(cv.All(IMAGE_SCHEMA, validate_settings))(value)
-    if not isinstance(value, dict):
+def _config_schema(config):
+    if isinstance(config, list):
+        return cv.Schema([IMAGE_SCHEMA])(config)
+    if not isinstance(config, dict):
         raise cv.Invalid(
-            "Badly formed image configuration, expected a list or a dictionary",
+            "Badly formed image configuration, expected a list or a dictionary"
         )
-    return cv.All(
-        cv.Schema(
-            {
-                cv.Optional(CONF_DEFAULTS, default={}): DEFAULTS_SCHEMA,
-                cv.Optional(CONF_IMAGES, default=[]): cv.ensure_list(
-                    {
-                        **IMAGE_SCHEMA_NO_DEFAULTS,
-                        cv.Optional(CONF_TYPE): validate_type(IMAGE_TYPE),
-                    }
-                ),
-                **{cv.Optional(t.lower()): typed_image_schema(t) for t in IMAGE_TYPE},
-            }
-        ),
-        validate_defaults,
-    )(value)
+    if CONF_DEFAULTS in config or CONF_IMAGES in config:
+        return validate_defaults(
+            cv.Schema(
+                {
+                    cv.Required(CONF_DEFAULTS): OPTIONS_SCHEMA,
+                    cv.Required(CONF_IMAGES): cv.ensure_list(IMAGE_SCHEMA_NO_DEFAULTS),
+                }
+            )(config)
+        )
+    if CONF_ID in config or CONF_FILE in config:
+        return cv.ensure_list(IMAGE_SCHEMA)([config])
+    return cv.Schema(
+        {cv.Optional(t.lower()): typed_image_schema(t) for t in IMAGE_TYPE}
+    )(config)
 
 
 CONFIG_SCHEMA = _config_schema
@@ -706,7 +668,7 @@ async def write_image(config, all_frames=False):
         else Image.Dither.FLOYDSTEINBERG
     )
     type = config[CONF_TYPE]
-    transparency = config.get(CONF_TRANSPARENCY, CONF_OPAQUE)
+    transparency = config[CONF_TRANSPARENCY]
     invert_alpha = config[CONF_INVERT_ALPHA]
     frame_count = 1
     if all_frames:
@@ -737,9 +699,14 @@ async def write_image(config, all_frames=False):
 
 
 async def to_code(config):
-    # By now the config should be a simple list.
-    for entry in config:
-        prog_arr, width, height, image_type, trans_value, _ = await write_image(entry)
+    if isinstance(config, list):
+        for entry in config:
+            await to_code(entry)
+    elif CONF_ID not in config:
+        for entry in config.values():
+            await to_code(entry)
+    else:
+        prog_arr, width, height, image_type, trans_value, _ = await write_image(config)
         cg.new_Pvariable(
-            entry[CONF_ID], prog_arr, width, height, image_type, trans_value
+            config[CONF_ID], prog_arr, width, height, image_type, trans_value
         )

esphome/components/light/__init__.py

@@ -285,4 +285,5 @@ async def new_light(config, *args):
 
 @coroutine_with_priority(100.0)
 async def to_code(config):
+    cg.add_define("USE_LIGHT")
     cg.add_global(light_ns.using)

esphome/components/light/effects.py

@@ -353,9 +353,10 @@ async def addressable_lambda_effect_to_code(config, effect_id):
         (bool, "initial_run"),
     ]
     lambda_ = await cg.process_lambda(config[CONF_LAMBDA], args, return_type=cg.void)
-    return cg.new_Pvariable(
+    var = cg.new_Pvariable(
         effect_id, config[CONF_NAME], lambda_, config[CONF_UPDATE_INTERVAL]
     )
+    return var
 
 
 @register_addressable_effect(

esphome/components/light/light_traits.h

@@ -5,13 +5,6 @@
 #include <set>
 
 namespace esphome {
-
-#ifdef USE_API
-namespace api {
-class APIConnection;
-}  // namespace api
-#endif
-
 namespace light {
 
 /// This class is used to represent the capabilities of a light.
@@ -59,16 +52,6 @@ class LightTraits {
   void set_max_mireds(float max_mireds) { this->max_mireds_ = max_mireds; }
 
  protected:
-#ifdef USE_API
-  // The API connection is a friend class to access internal methods
-  friend class api::APIConnection;
-  // This method returns a reference to the internal color modes set.
-  // It is used by the API to avoid copying data when encoding messages.
-  // Warning: Do not use this method outside of the API connection code.
-  // It returns a reference to internal data that can be invalidated.
-  const std::set<ColorMode> &get_supported_color_modes_for_api_() const { return this->supported_color_modes_; }
-#endif
-
   std::set<ColorMode> supported_color_modes_{};
   float min_mireds_{0};
   float max_mireds_{0};

esphome/components/lock/__init__.py

@@ -158,3 +158,4 @@ async def lock_is_off_to_code(config, condition_id, template_arg, args):
 @coroutine_with_priority(100.0)
 async def to_code(config):
     cg.add_global(lock_ns.using)
+    cg.add_define("USE_LOCK")

esphome/components/lvgl/__init__.py

@@ -4,7 +4,6 @@ from esphome.automation import build_automation, register_action, validate_autom
 import esphome.codegen as cg
 from esphome.components.const import CONF_COLOR_DEPTH, CONF_DRAW_ROUNDING
 from esphome.components.display import Display
-from esphome.components.psram import DOMAIN as PSRAM_DOMAIN
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_AUTO_CLEAR_ENABLED,
@@ -220,7 +219,7 @@ def final_validation(configs):
                     draw_rounding, config[CONF_DRAW_ROUNDING]
                 )
         buffer_frac = config[CONF_BUFFER_SIZE]
-        if CORE.is_esp32 and buffer_frac > 0.5 and PSRAM_DOMAIN not in global_config:
+        if CORE.is_esp32 and buffer_frac > 0.5 and "psram" not in global_config:
             LOGGER.warning("buffer_size: may need to be reduced without PSRAM")
         for image_id in lv_images_used:
             path = global_config.get_path_for_id(image_id)[:-1]

esphome/components/lvgl/automation.py

@@ -85,7 +85,8 @@ async def action_to_code(
     async with LambdaContext(parameters=args, where=action_id) as context:
         for widget in widgets:
             await action(widget)
-    return cg.new_Pvariable(action_id, template_arg, await context.get_lambda())
+    var = cg.new_Pvariable(action_id, template_arg, await context.get_lambda())
+    return var
 
 
 async def update_to_code(config, action_id, template_arg, args):
@@ -353,7 +354,8 @@ async def widget_focus(config, action_id, template_arg, args):
 
         if config[CONF_FREEZE]:
             lv.group_focus_freeze(group, True)
-        return cg.new_Pvariable(action_id, template_arg, await context.get_lambda())
+        var = cg.new_Pvariable(action_id, template_arg, await context.get_lambda())
+        return var
 
 
 @automation.register_action(

esphome/components/lvgl/lv_validation.py

@@ -271,7 +271,8 @@ padding = LValidator(padding_validator, int32, retmapper=literal)
 
 
 def zoom_validator(value):
-    return cv.float_range(0.1, 10.0)(value)
+    value = cv.float_range(0.1, 10.0)(value)
+    return value
 
 
 def zoom_retmapper(value):

esphome/components/lvgl/styles.py

@@ -66,7 +66,8 @@ async def style_update_to_code(config, action_id, template_arg, args):
     async with LambdaContext(parameters=args, where=action_id) as context:
         await style_set(style, config)
 
-    return cg.new_Pvariable(action_id, template_arg, await context.get_lambda())
+    var = cg.new_Pvariable(action_id, template_arg, await context.get_lambda())
+    return var
 
 
 async def theme_to_code(config):

esphome/components/lvgl/widgets/__init__.py

@@ -189,7 +189,7 @@ class Widget:
         for matrix buttons
         :return:
         """
-        return
+        return None
 
     def get_max(self):
         return self.type.get_max(self.config)

esphome/components/lvgl/widgets/buttonmatrix.py

@@ -193,7 +193,7 @@ class ButtonMatrixType(WidgetType):
     async def to_code(self, w: Widget, config):
         lvgl_components_required.add("BUTTONMATRIX")
         if CONF_ROWS not in config:
-            return
+            return []
         text_list, ctrl_list, width_list, key_list = await get_button_data(
             config[CONF_ROWS], w
         )

esphome/components/lvgl/widgets/tileview.py

@@ -15,7 +15,7 @@ from ..defines import (
     TILE_DIRECTIONS,
     literal,
 )
-from ..lv_validation import animated, lv_int, lv_pct
+from ..lv_validation import animated, lv_int
 from ..lvcode import lv, lv_assign, lv_expr, lv_obj, lv_Pvariable
 from ..schemas import container_schema
 from ..types import LV_EVENT, LvType, ObjUpdateAction, lv_obj_t, lv_obj_t_ptr
@@ -41,8 +41,8 @@ TILEVIEW_SCHEMA = cv.Schema(
             container_schema(
                 obj_spec,
                 {
-                    cv.Required(CONF_ROW): cv.positive_int,
-                    cv.Required(CONF_COLUMN): cv.positive_int,
+                    cv.Required(CONF_ROW): lv_int,
+                    cv.Required(CONF_COLUMN): lv_int,
                     cv.GenerateID(): cv.declare_id(lv_tile_t),
                     cv.Optional(CONF_DIR, default="ALL"): TILE_DIRECTIONS.several_of,
                 },
@@ -63,29 +63,21 @@ class TileviewType(WidgetType):
         )
 
     async def to_code(self, w: Widget, config: dict):
-        tiles = config[CONF_TILES]
-        for tile_conf in tiles:
+        for tile_conf in config.get(CONF_TILES, ()):
             w_id = tile_conf[CONF_ID]
             tile_obj = lv_Pvariable(lv_obj_t, w_id)
             tile = Widget.create(w_id, tile_obj, tile_spec, tile_conf)
             dirs = tile_conf[CONF_DIR]
             if isinstance(dirs, list):
                 dirs = "|".join(dirs)
-            row_pos = tile_conf[CONF_ROW]
-            col_pos = tile_conf[CONF_COLUMN]
             lv_assign(
                 tile_obj,
-                lv_expr.tileview_add_tile(w.obj, col_pos, row_pos, literal(dirs)),
+                lv_expr.tileview_add_tile(
+                    w.obj, tile_conf[CONF_COLUMN], tile_conf[CONF_ROW], literal(dirs)
+                ),
             )
-            # Bugfix for LVGL 8.x
-            lv_obj.set_pos(tile_obj, lv_pct(col_pos * 100), lv_pct(row_pos * 100))
             await set_obj_properties(tile, tile_conf)
             await add_widgets(tile, tile_conf)
-        if tiles:
-            # Set the first tile as active
-            lv_obj.set_tile_id(
-                w.obj, tiles[0][CONF_COLUMN], tiles[0][CONF_ROW], literal("LV_ANIM_OFF")
-            )
 
 
 tileview_spec = TileviewType()

esphome/components/media_player/__init__.py

@@ -7,8 +7,6 @@ from esphome.const import (
     CONF_ID,
     CONF_ON_IDLE,
     CONF_ON_STATE,
-    CONF_ON_TURN_OFF,
-    CONF_ON_TURN_ON,
     CONF_TRIGGER_ID,
     CONF_VOLUME,
 )
@@ -60,12 +58,6 @@ VolumeDownAction = media_player_ns.class_(
 VolumeSetAction = media_player_ns.class_(
     "VolumeSetAction", automation.Action, cg.Parented.template(MediaPlayer)
 )
-TurnOnAction = media_player_ns.class_(
-    "TurnOnAction", automation.Action, cg.Parented.template(MediaPlayer)
-)
-TurnOffAction = media_player_ns.class_(
-    "TurnOffAction", automation.Action, cg.Parented.template(MediaPlayer)
-)
 
 CONF_ANNOUNCEMENT = "announcement"
 CONF_ON_PLAY = "on_play"
@@ -80,16 +72,12 @@ PauseTrigger = media_player_ns.class_("PauseTrigger", automation.Trigger.templat
 AnnoucementTrigger = media_player_ns.class_(
     "AnnouncementTrigger", automation.Trigger.template()
 )
-OnTrigger = media_player_ns.class_("OnTrigger", automation.Trigger.template())
-OffTrigger = media_player_ns.class_("OffTrigger", automation.Trigger.template())
 IsIdleCondition = media_player_ns.class_("IsIdleCondition", automation.Condition)
 IsPausedCondition = media_player_ns.class_("IsPausedCondition", automation.Condition)
 IsPlayingCondition = media_player_ns.class_("IsPlayingCondition", automation.Condition)
 IsAnnouncingCondition = media_player_ns.class_(
     "IsAnnouncingCondition", automation.Condition
 )
-IsOnCondition = media_player_ns.class_("IsOnCondition", automation.Condition)
-IsOffCondition = media_player_ns.class_("IsOffCondition", automation.Condition)
 
 
 async def setup_media_player_core_(var, config):
@@ -109,12 +97,6 @@ async def setup_media_player_core_(var, config):
     for conf in config.get(CONF_ON_ANNOUNCEMENT, []):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
         await automation.build_automation(trigger, [], conf)
-    for conf in config.get(CONF_ON_TURN_ON, []):
-        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
-        await automation.build_automation(trigger, [], conf)
-    for conf in config.get(CONF_ON_TURN_OFF, []):
-        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
-        await automation.build_automation(trigger, [], conf)
 
 
 async def register_media_player(var, config):
@@ -158,16 +140,6 @@ _MEDIA_PLAYER_SCHEMA = cv.ENTITY_BASE_SCHEMA.extend(
                 cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(AnnoucementTrigger),
             }
         ),
-        cv.Optional(CONF_ON_TURN_ON): automation.validate_automation(
-            {
-                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(OnTrigger),
-            }
-        ),
-        cv.Optional(CONF_ON_TURN_OFF): automation.validate_automation(
-            {
-                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(OffTrigger),
-            }
-        ),
     }
 )
 
@@ -246,12 +218,6 @@ async def media_player_play_media_action(config, action_id, template_arg, args):
 @automation.register_action(
     "media_player.volume_down", VolumeDownAction, MEDIA_PLAYER_ACTION_SCHEMA
 )
-@automation.register_action(
-    "media_player.turn_on", TurnOnAction, MEDIA_PLAYER_ACTION_SCHEMA
-)
-@automation.register_action(
-    "media_player.turn_off", TurnOffAction, MEDIA_PLAYER_ACTION_SCHEMA
-)
 async def media_player_action(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
     await cg.register_parented(var, config[CONF_ID])
@@ -272,12 +238,6 @@ async def media_player_action(config, action_id, template_arg, args):
 @automation.register_condition(
     "media_player.is_announcing", IsAnnouncingCondition, MEDIA_PLAYER_CONDITION_SCHEMA
 )
-@automation.register_condition(
-    "media_player.is_on", IsOnCondition, MEDIA_PLAYER_CONDITION_SCHEMA
-)
-@automation.register_condition(
-    "media_player.is_off", IsOffCondition, MEDIA_PLAYER_CONDITION_SCHEMA
-)
 async def media_player_condition(config, action_id, template_arg, args):
     var = cg.new_Pvariable(action_id, template_arg)
     await cg.register_parented(var, config[CONF_ID])

esphome/components/media_player/automation.h

@@ -28,10 +28,6 @@ template<typename... Ts>
 using VolumeUpAction = MediaPlayerCommandAction<MediaPlayerCommand::MEDIA_PLAYER_COMMAND_VOLUME_UP, Ts...>;
 template<typename... Ts>
 using VolumeDownAction = MediaPlayerCommandAction<MediaPlayerCommand::MEDIA_PLAYER_COMMAND_VOLUME_DOWN, Ts...>;
-template<typename... Ts>
-using TurnOnAction = MediaPlayerCommandAction<MediaPlayerCommand::MEDIA_PLAYER_COMMAND_TURN_ON, Ts...>;
-template<typename... Ts>
-using TurnOffAction = MediaPlayerCommandAction<MediaPlayerCommand::MEDIA_PLAYER_COMMAND_TURN_OFF, Ts...>;
 
 template<typename... Ts> class PlayMediaAction : public Action<Ts...>, public Parented<MediaPlayer> {
   TEMPLATABLE_VALUE(std::string, media_url)
@@ -70,8 +66,6 @@ using IdleTrigger = MediaPlayerStateTrigger<MediaPlayerState::MEDIA_PLAYER_STATE
 using PlayTrigger = MediaPlayerStateTrigger<MediaPlayerState::MEDIA_PLAYER_STATE_PLAYING>;
 using PauseTrigger = MediaPlayerStateTrigger<MediaPlayerState::MEDIA_PLAYER_STATE_PAUSED>;
 using AnnouncementTrigger = MediaPlayerStateTrigger<MediaPlayerState::MEDIA_PLAYER_STATE_ANNOUNCING>;
-using OnTrigger = MediaPlayerStateTrigger<MediaPlayerState::MEDIA_PLAYER_STATE_ON>;
-using OffTrigger = MediaPlayerStateTrigger<MediaPlayerState::MEDIA_PLAYER_STATE_OFF>;
 
 template<typename... Ts> class IsIdleCondition : public Condition<Ts...>, public Parented<MediaPlayer> {
  public:
@@ -93,15 +87,5 @@ template<typename... Ts> class IsAnnouncingCondition : public Condition<Ts...>,
   bool check(Ts... x) override { return this->parent_->state == MediaPlayerState::MEDIA_PLAYER_STATE_ANNOUNCING; }
 };
 
-template<typename... Ts> class IsOnCondition : public Condition<Ts...>, public Parented<MediaPlayer> {
- public:
-  bool check(Ts... x) override { return this->parent_->state == MediaPlayerState::MEDIA_PLAYER_STATE_ON; }
-};
-
-template<typename... Ts> class IsOffCondition : public Condition<Ts...>, public Parented<MediaPlayer> {
- public:
-  bool check(Ts... x) override { return this->parent_->state == MediaPlayerState::MEDIA_PLAYER_STATE_OFF; }
-};
-
 }  // namespace media_player
 }  // namespace esphome

esphome/components/media_player/media_player.cpp

@@ -9,10 +9,6 @@ static const char *const TAG = "media_player";
 
 const char *media_player_state_to_string(MediaPlayerState state) {
   switch (state) {
-    case MEDIA_PLAYER_STATE_ON:
-      return "ON";
-    case MEDIA_PLAYER_STATE_OFF:
-      return "OFF";
     case MEDIA_PLAYER_STATE_IDLE:
       return "IDLE";
     case MEDIA_PLAYER_STATE_PLAYING:
@@ -22,7 +18,6 @@ const char *media_player_state_to_string(MediaPlayerState state) {
     case MEDIA_PLAYER_STATE_ANNOUNCING:
       return "ANNOUNCING";
     case MEDIA_PLAYER_STATE_NONE:
-      return "NONE";
     default:
       return "UNKNOWN";
   }
@@ -54,10 +49,6 @@ const char *media_player_command_to_string(MediaPlayerCommand command) {
       return "REPEAT_OFF";
     case MEDIA_PLAYER_COMMAND_CLEAR_PLAYLIST:
       return "CLEAR_PLAYLIST";
-    case MEDIA_PLAYER_COMMAND_TURN_ON:
-      return "TURN_ON";
-    case MEDIA_PLAYER_COMMAND_TURN_OFF:
-      return "TURN_OFF";
     default:
       return "UNKNOWN";
   }
@@ -119,10 +110,6 @@ MediaPlayerCall &MediaPlayerCall::set_command(const std::string &command) {
     this->set_command(MEDIA_PLAYER_COMMAND_UNMUTE);
   } else if (str_equals_case_insensitive(command, "TOGGLE")) {
     this->set_command(MEDIA_PLAYER_COMMAND_TOGGLE);
-  } else if (str_equals_case_insensitive(command, "TURN_ON")) {
-    this->set_command(MEDIA_PLAYER_COMMAND_TURN_ON);
-  } else if (str_equals_case_insensitive(command, "TURN_OFF")) {
-    this->set_command(MEDIA_PLAYER_COMMAND_TURN_OFF);
   } else {
     ESP_LOGW(TAG, "'%s' - Unrecognized command %s", this->parent_->get_name().c_str(), command.c_str());
   }

esphome/components/media_player/media_player.h

@@ -6,40 +6,12 @@
 namespace esphome {
 namespace media_player {
 
-enum MediaPlayerEntityFeature : uint32_t {
-  PAUSE = 1 << 0,
-  SEEK = 1 << 1,
-  VOLUME_SET = 1 << 2,
-  VOLUME_MUTE = 1 << 3,
-  PREVIOUS_TRACK = 1 << 4,
-  NEXT_TRACK = 1 << 5,
-
-  TURN_ON = 1 << 7,
-  TURN_OFF = 1 << 8,
-  PLAY_MEDIA = 1 << 9,
-  VOLUME_STEP = 1 << 10,
-  SELECT_SOURCE = 1 << 11,
-  STOP = 1 << 12,
-  CLEAR_PLAYLIST = 1 << 13,
-  PLAY = 1 << 14,
-  SHUFFLE_SET = 1 << 15,
-  SELECT_SOUND_MODE = 1 << 16,
-  BROWSE_MEDIA = 1 << 17,
-  REPEAT_SET = 1 << 18,
-  GROUPING = 1 << 19,
-  MEDIA_ANNOUNCE = 1 << 20,
-  MEDIA_ENQUEUE = 1 << 21,
-  SEARCH_MEDIA = 1 << 22,
-};
-
 enum MediaPlayerState : uint8_t {
   MEDIA_PLAYER_STATE_NONE = 0,
   MEDIA_PLAYER_STATE_IDLE = 1,
   MEDIA_PLAYER_STATE_PLAYING = 2,
   MEDIA_PLAYER_STATE_PAUSED = 3,
-  MEDIA_PLAYER_STATE_ANNOUNCING = 4,
-  MEDIA_PLAYER_STATE_OFF = 5,
-  MEDIA_PLAYER_STATE_ON = 6,
+  MEDIA_PLAYER_STATE_ANNOUNCING = 4
 };
 const char *media_player_state_to_string(MediaPlayerState state);
 
@@ -56,8 +28,6 @@ enum MediaPlayerCommand : uint8_t {
   MEDIA_PLAYER_COMMAND_REPEAT_ONE = 9,
   MEDIA_PLAYER_COMMAND_REPEAT_OFF = 10,
   MEDIA_PLAYER_COMMAND_CLEAR_PLAYLIST = 11,
-  MEDIA_PLAYER_COMMAND_TURN_ON = 12,
-  MEDIA_PLAYER_COMMAND_TURN_OFF = 13,
 };
 const char *media_player_command_to_string(MediaPlayerCommand command);
 
@@ -81,31 +51,14 @@ class MediaPlayerTraits {
   MediaPlayerTraits() = default;
 
   void set_supports_pause(bool supports_pause) { this->supports_pause_ = supports_pause; }
-  bool get_supports_pause() const { return this->supports_pause_; }
 
-  void set_supports_turn_off_on(bool supports_turn_off_on) { this->supports_turn_off_on_ = supports_turn_off_on; }
-  bool get_supports_turn_off_on() const { return this->supports_turn_off_on_; }
+  bool get_supports_pause() const { return this->supports_pause_; }
 
   std::vector<MediaPlayerSupportedFormat> &get_supported_formats() { return this->supported_formats_; }
 
-  uint32_t get_feature_flags() const {
-    uint32_t flags = 0;
-    flags |= MediaPlayerEntityFeature::PLAY_MEDIA | MediaPlayerEntityFeature::BROWSE_MEDIA |
-             MediaPlayerEntityFeature::STOP | MediaPlayerEntityFeature::VOLUME_SET |
-             MediaPlayerEntityFeature::VOLUME_MUTE | MediaPlayerEntityFeature::MEDIA_ANNOUNCE;
-    if (this->get_supports_pause()) {
-      flags |= MediaPlayerEntityFeature::PAUSE | MediaPlayerEntityFeature::PLAY;
-    }
-    if (this->get_supports_turn_off_on()) {
-      flags |= MediaPlayerEntityFeature::TURN_OFF | MediaPlayerEntityFeature::TURN_ON;
-    }
-    return flags;
-  }
-
  protected:
-  std::vector<MediaPlayerSupportedFormat> supported_formats_{};
   bool supports_pause_{false};
-  bool supports_turn_off_on_{false};
+  std::vector<MediaPlayerSupportedFormat> supported_formats_{};
 };
 
 class MediaPlayerCall {

esphome/components/midea/ir_transmitter.h

@@ -54,15 +54,15 @@ class IrFollowMeData : public IrData {
   void set_fahrenheit(bool val) { this->set_mask_(2, val, 32); }
 
  protected:
-  inline static constexpr uint8_t MIN_TEMP_C = 0;
-  inline static constexpr uint8_t MAX_TEMP_C = 37;
+  static const uint8_t MIN_TEMP_C = 0;
+  static const uint8_t MAX_TEMP_C = 37;
 
   // see
   // https://github.com/crankyoldgit/IRremoteESP8266/blob/9bdf8abcb465268c5409db99dc83a26df64c7445/src/ir_Midea.h#L116
-  inline static constexpr uint8_t MIN_TEMP_F = 32;
+  static const uint8_t MIN_TEMP_F = 32;
   // see
   // https://github.com/crankyoldgit/IRremoteESP8266/blob/9bdf8abcb465268c5409db99dc83a26df64c7445/src/ir_Midea.h#L117
-  inline static constexpr uint8_t MAX_TEMP_F = 99;
+  static const uint8_t MAX_TEMP_F = 99;
 };
 
 class IrSpecialData : public IrData {

esphome/components/mipi_dsi/display.py

@@ -57,8 +57,7 @@ from esphome.final_validate import full_config
 
 from . import mipi_dsi_ns, models
 
-# Currently only ESP32-P4 is supported, so esp_ldo and psram are required
-DEPENDENCIES = ["esp32", "esp_ldo", "psram"]
+DEPENDENCIES = ["esp32"]
 DOMAIN = "mipi_dsi"
 
 LOGGER = logging.getLogger(DOMAIN)

esphome/components/mipi_spi/display.py

@@ -25,7 +25,6 @@ from esphome.components.mipi import (
     power_of_two,
     requires_buffer,
 )
-from esphome.components.psram import DOMAIN as PSRAM_DOMAIN
 from esphome.components.spi import TYPE_OCTAL, TYPE_QUAD, TYPE_SINGLE
 import esphome.config_validation as cv
 from esphome.config_validation import ALLOW_EXTRA
@@ -293,7 +292,7 @@ def _final_validate(config):
         # If no drawing methods are configured, and LVGL is not enabled, show a test card
         config[CONF_SHOW_TEST_CARD] = True
 
-    if PSRAM_DOMAIN not in global_config and CONF_BUFFER_SIZE not in config:
+    if "psram" not in global_config and CONF_BUFFER_SIZE not in config:
         if not requires_buffer(config):
             return config  # No buffer needed, so no need to set a buffer size
         # If PSRAM is not enabled, choose a small buffer size by default

esphome/components/mqtt/__init__.py

@@ -312,13 +312,14 @@ CONFIG_SCHEMA = cv.All(
 def exp_mqtt_message(config):
     if config is None:
         return cg.optional(cg.TemplateArguments(MQTTMessage))
-    return cg.StructInitializer(
+    exp = cg.StructInitializer(
         MQTTMessage,
         ("topic", config[CONF_TOPIC]),
         ("payload", config.get(CONF_PAYLOAD, "")),
         ("qos", config[CONF_QOS]),
         ("retain", config[CONF_RETAIN]),
     )
+    return exp
 
 
 @coroutine_with_priority(40.0)

esphome/components/nrf52/__init__.py

@@ -124,9 +124,7 @@ async def to_code(config: ConfigType) -> None:
         ],
     )
 
-    if config[KEY_BOOTLOADER] == BOOTLOADER_MCUBOOT:
-        cg.add_define("USE_BOOTLOADER_MCUBOOT")
-    else:
+    if config[KEY_BOOTLOADER] == BOOTLOADER_ADAFRUIT:
         # make sure that firmware.zip is created
         # for Adafruit_nRF52_Bootloader
         cg.add_platformio_option("board_upload.protocol", "nrfutil")

esphome/components/nrf52/const.py

@@ -2,17 +2,3 @@ BOOTLOADER_ADAFRUIT = "adafruit"
 BOOTLOADER_ADAFRUIT_NRF52_SD132 = "adafruit_nrf52_sd132"
 BOOTLOADER_ADAFRUIT_NRF52_SD140_V6 = "adafruit_nrf52_sd140_v6"
 BOOTLOADER_ADAFRUIT_NRF52_SD140_V7 = "adafruit_nrf52_sd140_v7"
-EXTRA_ADC = [
-    "VDD",
-    "VDDHDIV5",
-]
-AIN_TO_GPIO = {
-    "AIN0": 2,
-    "AIN1": 3,
-    "AIN2": 4,
-    "AIN3": 5,
-    "AIN4": 28,
-    "AIN5": 29,
-    "AIN6": 30,
-    "AIN7": 31,
-}

esphome/components/nrf52/gpio.py

@@ -2,23 +2,12 @@ from esphome import pins
 import esphome.codegen as cg
 from esphome.components.zephyr.const import zephyr_ns
 import esphome.config_validation as cv
-from esphome.const import (
-    CONF_ANALOG,
-    CONF_ID,
-    CONF_INVERTED,
-    CONF_MODE,
-    CONF_NUMBER,
-    PLATFORM_NRF52,
-)
-
-from .const import AIN_TO_GPIO, EXTRA_ADC
+from esphome.const import CONF_ID, CONF_INVERTED, CONF_MODE, CONF_NUMBER, PLATFORM_NRF52
 
 ZephyrGPIOPin = zephyr_ns.class_("ZephyrGPIOPin", cg.InternalGPIOPin)
 
 
 def _translate_pin(value):
-    if value in AIN_TO_GPIO:
-        return AIN_TO_GPIO[value]
     if isinstance(value, dict) or value is None:
         raise cv.Invalid(
             "This variable only supports pin numbers, not full pin schemas "
@@ -39,33 +28,18 @@ def _translate_pin(value):
 
 
 def validate_gpio_pin(value):
-    if value in EXTRA_ADC:
-        return value
     value = _translate_pin(value)
     if value < 0 or value > (32 + 16):
         raise cv.Invalid(f"NRF52: Invalid pin number: {value}")
     return value
 
 
-def validate_supports(value):
-    num = value[CONF_NUMBER]
-    mode = value[CONF_MODE]
-    is_analog = mode[CONF_ANALOG]
-    if is_analog:
-        if num in EXTRA_ADC:
-            return value
-        if num not in AIN_TO_GPIO.values():
-            raise cv.Invalid(f"Cannot use {num} as analog pin")
-    return value
-
-
 NRF52_PIN_SCHEMA = cv.All(
     pins.gpio_base_schema(
         ZephyrGPIOPin,
         validate_gpio_pin,
-        modes=pins.GPIO_STANDARD_MODES + (CONF_ANALOG,),
+        modes=pins.GPIO_STANDARD_MODES,
     ),
-    validate_supports,
 )
 
 

esphome/components/number/__init__.py

@@ -323,6 +323,7 @@ async def number_in_range_to_code(config, condition_id, template_arg, args):
 
 @coroutine_with_priority(100.0)
 async def to_code(config):
+    cg.add_define("USE_NUMBER")
     cg.add_global(number_ns.using)
 
 

esphome/components/one_wire/__init__.py

@@ -18,12 +18,13 @@ def one_wire_device_schema():
 
     :return: The 1-wire device schema, `extend` this in your config schema.
     """
-    return cv.Schema(
+    schema = cv.Schema(
         {
             cv.GenerateID(CONF_ONE_WIRE_ID): cv.use_id(OneWireBus),
             cv.Optional(CONF_ADDRESS): cv.hex_uint64_t,
         }
     )
+    return schema
 
 
 async def register_one_wire_device(var, config):

esphome/components/openthread/openthread.cpp

@@ -1,9 +1,6 @@
 #include "esphome/core/defines.h"
 #ifdef USE_OPENTHREAD
 #include "openthread.h"
-#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 5, 0)
-#include "esp_openthread.h"
-#endif
 
 #include <freertos/portmacro.h>
 
@@ -31,6 +28,18 @@ OpenThreadComponent *global_openthread_component =  // NOLINT(cppcoreguidelines-
 
 OpenThreadComponent::OpenThreadComponent() { global_openthread_component = this; }
 
+OpenThreadComponent::~OpenThreadComponent() {
+  auto lock = InstanceLock::try_acquire(100);
+  if (!lock) {
+    ESP_LOGW(TAG, "Failed to acquire OpenThread lock in destructor, leaking memory");
+    return;
+  }
+  otInstance *instance = lock->get_instance();
+  otSrpClientClearHostAndServices(instance);
+  otSrpClientBuffersFreeAllServices(instance);
+  global_openthread_component = nullptr;
+}
+
 bool OpenThreadComponent::is_connected() {
   auto lock = InstanceLock::try_acquire(100);
   if (!lock) {
@@ -190,33 +199,6 @@ void *OpenThreadSrpComponent::pool_alloc_(size_t size) {
 
 void OpenThreadSrpComponent::set_mdns(esphome::mdns::MDNSComponent *mdns) { this->mdns_ = mdns; }
 
-bool OpenThreadComponent::teardown() {
-  if (!this->teardown_started_) {
-    this->teardown_started_ = true;
-    ESP_LOGD(TAG, "Clear Srp");
-    auto lock = InstanceLock::try_acquire(100);
-    if (!lock) {
-      ESP_LOGW(TAG, "Failed to acquire OpenThread lock during teardown, leaking memory");
-      return true;
-    }
-    otInstance *instance = lock->get_instance();
-    otSrpClientClearHostAndServices(instance);
-    otSrpClientBuffersFreeAllServices(instance);
-    global_openthread_component = nullptr;
-#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 5, 0)
-    ESP_LOGD(TAG, "Exit main loop ");
-    int error = esp_openthread_mainloop_exit();
-    if (error != ESP_OK) {
-      ESP_LOGW(TAG, "Failed attempt to stop main loop %d", error);
-      this->teardown_complete_ = true;
-    }
-#else
-    this->teardown_complete_ = true;
-#endif
-  }
-  return this->teardown_complete_;
-}
-
 }  // namespace openthread
 }  // namespace esphome
 

esphome/components/openthread/openthread.h

@@ -21,7 +21,6 @@ class OpenThreadComponent : public Component {
   OpenThreadComponent();
   ~OpenThreadComponent();
   void setup() override;
-  bool teardown() override;
   float get_setup_priority() const override { return setup_priority::WIFI; }
 
   bool is_connected();
@@ -31,8 +30,6 @@ class OpenThreadComponent : public Component {
 
  protected:
   std::optional<otIp6Address> get_omr_address_(InstanceLock &lock);
-  bool teardown_started_{false};
-  bool teardown_complete_{false};
 };
 
 extern OpenThreadComponent *global_openthread_component;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)

esphome/components/openthread/openthread_esp.cpp

@@ -143,13 +143,10 @@ void OpenThreadComponent::ot_main() {
   esp_openthread_launch_mainloop();
 
   // Clean up
-  esp_openthread_deinit();
   esp_openthread_netif_glue_deinit();
   esp_netif_destroy(openthread_netif);
 
   esp_vfs_eventfd_unregister();
-  this->teardown_complete_ = true;
-  vTaskDelete(NULL);
 }
 
 network::IPAddresses OpenThreadComponent::get_ip_addresses() {

esphome/components/output/__init__.py

@@ -43,8 +43,6 @@ FloatOutputPtr = FloatOutput.operator("ptr")
 TurnOffAction = output_ns.class_("TurnOffAction", automation.Action)
 TurnOnAction = output_ns.class_("TurnOnAction", automation.Action)
 SetLevelAction = output_ns.class_("SetLevelAction", automation.Action)
-SetMinPowerAction = output_ns.class_("SetMinPowerAction", automation.Action)
-SetMaxPowerAction = output_ns.class_("SetMaxPowerAction", automation.Action)
 
 
 async def setup_output_platform_(obj, config):
@@ -106,42 +104,6 @@ async def output_set_level_to_code(config, action_id, template_arg, args):
     return var
 
 
-@automation.register_action(
-    "output.set_min_power",
-    SetMinPowerAction,
-    cv.Schema(
-        {
-            cv.Required(CONF_ID): cv.use_id(FloatOutput),
-            cv.Required(CONF_MIN_POWER): cv.templatable(cv.percentage),
-        }
-    ),
-)
-async def output_set_min_power_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_arg, paren)
-    template_ = await cg.templatable(config[CONF_MIN_POWER], args, float)
-    cg.add(var.set_min_power(template_))
-    return var
-
-
-@automation.register_action(
-    "output.set_max_power",
-    SetMaxPowerAction,
-    cv.Schema(
-        {
-            cv.Required(CONF_ID): cv.use_id(FloatOutput),
-            cv.Required(CONF_MAX_POWER): cv.templatable(cv.percentage),
-        }
-    ),
-)
-async def output_set_max_power_to_code(config, action_id, template_arg, args):
-    paren = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_arg, paren)
-    template_ = await cg.templatable(config[CONF_MAX_POWER], args, float)
-    cg.add(var.set_max_power(template_))
-    return var
-
-
 async def to_code(config):
     cg.add_define("USE_OUTPUT")
     cg.add_global(output_ns.using)

esphome/components/output/automation.h

@@ -40,29 +40,5 @@ template<typename... Ts> class SetLevelAction : public Action<Ts...> {
   FloatOutput *output_;
 };
 
-template<typename... Ts> class SetMinPowerAction : public Action<Ts...> {
- public:
-  SetMinPowerAction(FloatOutput *output) : output_(output) {}
-
-  TEMPLATABLE_VALUE(float, min_power)
-
-  void play(Ts... x) override { this->output_->set_min_power(this->min_power_.value(x...)); }
-
- protected:
-  FloatOutput *output_;
-};
-
-template<typename... Ts> class SetMaxPowerAction : public Action<Ts...> {
- public:
-  SetMaxPowerAction(FloatOutput *output) : output_(output) {}
-
-  TEMPLATABLE_VALUE(float, max_power)
-
-  void play(Ts... x) override { this->output_->set_max_power(this->max_power_.value(x...)); }
-
- protected:
-  FloatOutput *output_;
-};
-
 }  // namespace output
 }  // namespace esphome

esphome/components/packages/__init__.py

@@ -186,7 +186,8 @@ def _process_package(package_config, config):
         package_config = _process_base_package(package_config)
     if isinstance(package_config, dict):
         recursive_package = do_packages_pass(package_config)
-    return merge_config(recursive_package, config)
+    config = merge_config(recursive_package, config)
+    return config
 
 
 def do_packages_pass(config: dict):

esphome/components/pmwcs3/sensor.py

@@ -114,7 +114,8 @@ PMWCS3_CALIBRATION_SCHEMA = cv.Schema(
 )
 async def pmwcs3_calibration_to_code(config, action_id, template_arg, args):
     parent = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_arg, parent)
+    var = cg.new_Pvariable(action_id, template_arg, parent)
+    return var
 
 
 PMWCS3_NEW_I2C_ADDRESS_SCHEMA = cv.maybe_simple_value(

esphome/components/psram/__init__.py

@@ -28,13 +28,12 @@ from esphome.core import CORE
 import esphome.final_validate as fv
 
 CODEOWNERS = ["@esphome/core"]
-DOMAIN = "psram"
 
 DEPENDENCIES = [PLATFORM_ESP32]
 
 _LOGGER = logging.getLogger(__name__)
 
-psram_ns = cg.esphome_ns.namespace(DOMAIN)
+psram_ns = cg.esphome_ns.namespace("psram")
 PsramComponent = psram_ns.class_("PsramComponent", cg.Component)
 
 TYPE_QUAD = "quad"

esphome/components/rf_bridge/__init__.py

@@ -136,7 +136,8 @@ RFBRIDGE_ID_SCHEMA = cv.Schema({cv.GenerateID(): cv.use_id(RFBridgeComponent)})
 @automation.register_action("rf_bridge.learn", RFBridgeLearnAction, RFBRIDGE_ID_SCHEMA)
 async def rf_bridge_learnx_to_code(config, action_id, template_args, args):
     paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_args, paren)
+    var = cg.new_Pvariable(action_id, template_args, paren)
+    return var
 
 
 @automation.register_action(
@@ -148,7 +149,8 @@ async def rf_bridge_start_advanced_sniffing_to_code(
     config, action_id, template_args, args
 ):
     paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_args, paren)
+    var = cg.new_Pvariable(action_id, template_args, paren)
+    return var
 
 
 @automation.register_action(
@@ -160,7 +162,8 @@ async def rf_bridge_stop_advanced_sniffing_to_code(
     config, action_id, template_args, args
 ):
     paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_args, paren)
+    var = cg.new_Pvariable(action_id, template_args, paren)
+    return var
 
 
 @automation.register_action(
@@ -172,7 +175,8 @@ async def rf_bridge_start_bucket_sniffing_to_code(
     config, action_id, template_args, args
 ):
     paren = await cg.get_variable(config[CONF_ID])
-    return cg.new_Pvariable(action_id, template_args, paren)
+    var = cg.new_Pvariable(action_id, template_args, paren)
+    return var
 
 
 RFBRIDGE_SEND_ADVANCED_CODE_SCHEMA = cv.Schema(