esphome 2025.7.4__py3-none-any.whl → 2025.8.0__py3-none-any.whl

esphome/components/remote_base/__init__.py

@@ -1062,12 +1062,11 @@ def validate_raw_alternating(value):
     last_negative = None
     for i, val in enumerate(value):
         this_negative = val < 0
-        if i != 0:
-            if this_negative == last_negative:
-                raise cv.Invalid(
-                    f"Values must alternate between being positive and negative, please see index {i} and {i + 1}",
-                    [i],
-                )
+        if i != 0 and this_negative == last_negative:
+            raise cv.Invalid(
+                f"Values must alternate between being positive and negative, please see index {i} and {i + 1}",
+                [i],
+            )
         last_negative = this_negative
     return value
 

esphome/components/remote_receiver/remote_receiver_esp32.cpp

@@ -38,7 +38,6 @@ static bool IRAM_ATTR HOT rmt_callback(rmt_channel_handle_t channel, const rmt_r
 }
 
 void RemoteReceiverComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   rmt_rx_channel_config_t channel;
   memset(&channel, 0, sizeof(channel));
   channel.clk_src = RMT_CLK_SRC_DEFAULT;

esphome/components/remote_receiver/remote_receiver_esp8266.cpp

@@ -31,7 +31,6 @@ void IRAM_ATTR HOT RemoteReceiverComponentStore::gpio_intr(RemoteReceiverCompone
 }
 
 void RemoteReceiverComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   this->pin_->setup();
   auto &s = this->store_;
   s.filter_us = this->filter_us_;

esphome/components/remote_receiver/remote_receiver_libretiny.cpp

@@ -31,7 +31,6 @@ void IRAM_ATTR HOT RemoteReceiverComponentStore::gpio_intr(RemoteReceiverCompone
 }
 
 void RemoteReceiverComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   this->pin_->setup();
   auto &s = this->store_;
   s.filter_us = this->filter_us_;

esphome/components/remote_transmitter/__init__.py

@@ -13,6 +13,7 @@ from esphome.const import (
     CONF_PIN,
     CONF_RMT_SYMBOLS,
     CONF_USE_DMA,
+    CONF_VALUE,
     PlatformFramework,
 )
 from esphome.core import CORE
@@ -22,11 +23,17 @@ AUTO_LOAD = ["remote_base"]
 CONF_EOT_LEVEL = "eot_level"
 CONF_ON_TRANSMIT = "on_transmit"
 CONF_ON_COMPLETE = "on_complete"
+CONF_TRANSMITTER_ID = remote_base.CONF_TRANSMITTER_ID
 
 remote_transmitter_ns = cg.esphome_ns.namespace("remote_transmitter")
 RemoteTransmitterComponent = remote_transmitter_ns.class_(
     "RemoteTransmitterComponent", remote_base.RemoteTransmitterBase, cg.Component
 )
+DigitalWriteAction = remote_transmitter_ns.class_(
+    "DigitalWriteAction",
+    automation.Action,
+    cg.Parented.template(RemoteTransmitterComponent),
+)
 
 MULTI_CONF = True
 CONFIG_SCHEMA = cv.Schema(
@@ -63,6 +70,25 @@ CONFIG_SCHEMA = cv.Schema(
     }
 ).extend(cv.COMPONENT_SCHEMA)
 
+DIGITAL_WRITE_ACTION_SCHEMA = cv.maybe_simple_value(
+    {
+        cv.GenerateID(CONF_TRANSMITTER_ID): cv.use_id(RemoteTransmitterComponent),
+        cv.Required(CONF_VALUE): cv.templatable(cv.boolean),
+    },
+    key=CONF_VALUE,
+)
+
+
+@automation.register_action(
+    "remote_transmitter.digital_write", DigitalWriteAction, DIGITAL_WRITE_ACTION_SCHEMA
+)
+async def digital_write_action_to_code(config, action_id, template_arg, args):
+    var = cg.new_Pvariable(action_id, template_arg)
+    await cg.register_parented(var, config[CONF_TRANSMITTER_ID])
+    template_ = await cg.templatable(config[CONF_VALUE], args, bool)
+    cg.add(var.set_value(template_))
+    return var
+
 
 async def to_code(config):
     pin = await cg.gpio_pin_expression(config[CONF_PIN])

esphome/components/remote_transmitter/automation.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "esphome/components/remote_transmitter/remote_transmitter.h"
+#include "esphome/core/automation.h"
+#include "esphome/core/component.h"
+#include "esphome/core/helpers.h"
+
+namespace esphome {
+namespace remote_transmitter {
+
+template<typename... Ts> class DigitalWriteAction : public Action<Ts...>, public Parented<RemoteTransmitterComponent> {
+ public:
+  TEMPLATABLE_VALUE(bool, value)
+  void play(Ts... x) override { this->parent_->digital_write(this->value_.value(x...)); }
+};
+
+}  // namespace remote_transmitter
+}  // namespace esphome

esphome/components/remote_transmitter/remote_transmitter.h

@@ -30,10 +30,11 @@ class RemoteTransmitterComponent : public remote_base::RemoteTransmitterBase,
 
   void set_carrier_duty_percent(uint8_t carrier_duty_percent) { this->carrier_duty_percent_ = carrier_duty_percent; }
 
+  void digital_write(bool value);
+
 #if defined(USE_ESP32)
   void set_with_dma(bool with_dma) { this->with_dma_ = with_dma; }
   void set_eot_level(bool eot_level) { this->eot_level_ = eot_level; }
-  void digital_write(bool value);
 #endif
 
   Trigger<> *get_transmit_trigger() const { return this->transmit_trigger_; };

esphome/components/remote_transmitter/remote_transmitter_esp32.cpp

@@ -11,7 +11,6 @@ namespace remote_transmitter {
 static const char *const TAG = "remote_transmitter";
 
 void RemoteTransmitterComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   this->inverted_ = this->pin_->is_inverted();
   this->configure_rmt_();
 }

esphome/components/remote_transmitter/remote_transmitter_esp8266.cpp

@@ -73,6 +73,8 @@ void RemoteTransmitterComponent::space_(uint32_t usec) {
   this->target_time_ += usec;
 }
 
+void RemoteTransmitterComponent::digital_write(bool value) { this->pin_->digital_write(value); }
+
 void RemoteTransmitterComponent::send_internal(uint32_t send_times, uint32_t send_wait) {
   ESP_LOGD(TAG, "Sending remote code");
   uint32_t on_time, off_time;

esphome/components/remote_transmitter/remote_transmitter_libretiny.cpp

@@ -75,6 +75,8 @@ void RemoteTransmitterComponent::space_(uint32_t usec) {
   this->target_time_ += usec;
 }
 
+void RemoteTransmitterComponent::digital_write(bool value) { this->pin_->digital_write(value); }
+
 void RemoteTransmitterComponent::send_internal(uint32_t send_times, uint32_t send_wait) {
   ESP_LOGD(TAG, "Sending remote code");
   uint32_t on_time, off_time;

esphome/components/resampler/speaker/__init__.py

@@ -90,11 +90,10 @@ async def to_code(config):
 
     if task_stack_in_psram := config.get(CONF_TASK_STACK_IN_PSRAM):
         cg.add(var.set_task_stack_in_psram(task_stack_in_psram))
-        if task_stack_in_psram:
-            if config[CONF_TASK_STACK_IN_PSRAM]:
-                esp32.add_idf_sdkconfig_option(
-                    "CONFIG_SPIRAM_ALLOW_STACK_EXTERNAL_MEMORY", True
-                )
+        if task_stack_in_psram and config[CONF_TASK_STACK_IN_PSRAM]:
+            esp32.add_idf_sdkconfig_option(
+                "CONFIG_SPIRAM_ALLOW_STACK_EXTERNAL_MEMORY", True
+            )
 
     cg.add(var.set_target_bits_per_sample(config[CONF_BITS_PER_SAMPLE]))
     cg.add(var.set_target_sample_rate(config[CONF_SAMPLE_RATE]))

esphome/components/rf_bridge/__init__.py

@@ -136,8 +136,7 @@ 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])
-    var = cg.new_Pvariable(action_id, template_args, paren)
-    return var
+    return cg.new_Pvariable(action_id, template_args, paren)
 
 
 @automation.register_action(
@@ -149,8 +148,7 @@ async def rf_bridge_start_advanced_sniffing_to_code(
     config, action_id, template_args, args
 ):
     paren = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_args, paren)
-    return var
+    return cg.new_Pvariable(action_id, template_args, paren)
 
 
 @automation.register_action(
@@ -162,8 +160,7 @@ async def rf_bridge_stop_advanced_sniffing_to_code(
     config, action_id, template_args, args
 ):
     paren = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_args, paren)
-    return var
+    return cg.new_Pvariable(action_id, template_args, paren)
 
 
 @automation.register_action(
@@ -175,8 +172,7 @@ async def rf_bridge_start_bucket_sniffing_to_code(
     config, action_id, template_args, args
 ):
     paren = await cg.get_variable(config[CONF_ID])
-    var = cg.new_Pvariable(action_id, template_args, paren)
-    return var
+    return cg.new_Pvariable(action_id, template_args, paren)
 
 
 RFBRIDGE_SEND_ADVANCED_CODE_SCHEMA = cv.Schema(

esphome/components/rotary_encoder/rotary_encoder.cpp

@@ -129,8 +129,6 @@ void IRAM_ATTR HOT RotaryEncoderSensorStore::gpio_intr(RotaryEncoderSensorStore
 }
 
 void RotaryEncoderSensor::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup for '%s'", this->name_.c_str());
-
   int32_t initial_value = 0;
   switch (this->restore_mode_) {
     case ROTARY_ENCODER_RESTORE_DEFAULT_ZERO:

esphome/components/rp2040/__init__.py

@@ -16,6 +16,7 @@ from esphome.const import (
     KEY_TARGET_FRAMEWORK,
     KEY_TARGET_PLATFORM,
     PLATFORM_RP2040,
+    ThreadModel,
 )
 from esphome.core import CORE, EsphomeError, coroutine_with_priority
 from esphome.helpers import copy_file_if_changed, mkdir_p, read_file, write_file
@@ -171,6 +172,7 @@ async def to_code(config):
     cg.set_cpp_standard("gnu++20")
     cg.add_define("ESPHOME_BOARD", config[CONF_BOARD])
     cg.add_define("ESPHOME_VARIANT", "RP2040")
+    cg.add_define(ThreadModel.SINGLE)
 
     cg.add_platformio_option("extra_scripts", ["post:post_build.py"])
 
@@ -204,7 +206,7 @@ def add_pio_file(component: str, key: str, data: str):
         cv.validate_id_name(key)
     except cv.Invalid as e:
         raise EsphomeError(
-            f"[{component}] Invalid PIO key: {key}. Allowed characters: [{ascii_letters}{digits}_]\nPlease report an issue https://github.com/esphome/issues"
+            f"[{component}] Invalid PIO key: {key}. Allowed characters: [{ascii_letters}{digits}_]\nPlease report an issue https://github.com/esphome/esphome/issues"
         ) from e
     CORE.data[KEY_RP2040][KEY_PIO_FILES][key] = data
 

esphome/components/rp2040_pio_led_strip/led_strip.cpp

@@ -40,8 +40,6 @@ void RP2040PIOLEDStripLightOutput::dma_write_complete_handler_() {
 }
 
 void RP2040PIOLEDStripLightOutput::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
-
   size_t buffer_size = this->get_buffer_size_();
 
   RAMAllocator<uint8_t> allocator;

esphome/components/rp2040_pio_led_strip/light.py

@@ -125,8 +125,7 @@ writezero:
 
 def time_to_cycles(time_us):
     cycles_per_us = 57.5
-    cycles = round(float(time_us) * cycles_per_us)
-    return cycles
+    return round(float(time_us) * cycles_per_us)
 
 
 CONF_PIO = "pio"

esphome/components/rp2040_pwm/rp2040_pwm.cpp

@@ -16,11 +16,7 @@ namespace rp2040_pwm {
 
 static const char *const TAG = "rp2040_pwm";
 
-void RP2040PWM::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
-
-  this->setup_pwm_();
-}
+void RP2040PWM::setup() { this->setup_pwm_(); }
 
 void RP2040PWM::setup_pwm_() {
   pwm_config config = pwm_get_default_config();

esphome/components/rpi_dpi_rgb/display.py

@@ -2,6 +2,18 @@ from esphome import pins
 import esphome.codegen as cg
 from esphome.components import display
 from esphome.components.esp32 import const, only_on_variant
+from esphome.components.mipi import (
+    CONF_DE_PIN,
+    CONF_HSYNC_BACK_PORCH,
+    CONF_HSYNC_FRONT_PORCH,
+    CONF_HSYNC_PULSE_WIDTH,
+    CONF_PCLK_FREQUENCY,
+    CONF_PCLK_INVERTED,
+    CONF_PCLK_PIN,
+    CONF_VSYNC_BACK_PORCH,
+    CONF_VSYNC_FRONT_PORCH,
+    CONF_VSYNC_PULSE_WIDTH,
+)
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_BLUE,
@@ -27,18 +39,6 @@ from esphome.const import (
 
 DEPENDENCIES = ["esp32"]
 
-CONF_DE_PIN = "de_pin"
-CONF_PCLK_PIN = "pclk_pin"
-
-CONF_HSYNC_FRONT_PORCH = "hsync_front_porch"
-CONF_HSYNC_PULSE_WIDTH = "hsync_pulse_width"
-CONF_HSYNC_BACK_PORCH = "hsync_back_porch"
-CONF_VSYNC_FRONT_PORCH = "vsync_front_porch"
-CONF_VSYNC_PULSE_WIDTH = "vsync_pulse_width"
-CONF_VSYNC_BACK_PORCH = "vsync_back_porch"
-CONF_PCLK_FREQUENCY = "pclk_frequency"
-CONF_PCLK_INVERTED = "pclk_inverted"
-
 rpi_dpi_rgb_ns = cg.esphome_ns.namespace("rpi_dpi_rgb")
 RPI_DPI_RGB = rpi_dpi_rgb_ns.class_("RpiDpiRgb", display.Display, cg.Component)
 ColorOrder = display.display_ns.enum("ColorMode")
@@ -140,7 +140,6 @@ async def to_code(config):
     cg.add(var.set_vsync_front_porch(config[CONF_VSYNC_FRONT_PORCH]))
     cg.add(var.set_pclk_inverted(config[CONF_PCLK_INVERTED]))
     cg.add(var.set_pclk_frequency(config[CONF_PCLK_FREQUENCY]))
-    index = 0
     dpins = []
     if CONF_RED in config[CONF_DATA_PINS]:
         red_pins = config[CONF_DATA_PINS][CONF_RED]
@@ -158,10 +157,9 @@ async def to_code(config):
         dpins = dpins[8:16] + dpins[0:8]
     else:
         dpins = config[CONF_DATA_PINS]
-    for pin in dpins:
+    for index, pin in enumerate(dpins):
         data_pin = await cg.gpio_pin_expression(pin)
         cg.add(var.add_data_pin(data_pin, index))
-        index += 1
 
     if enable_pin := config.get(CONF_ENABLE_PIN):
         enable = await cg.gpio_pin_expression(enable_pin)

esphome/components/rpi_dpi_rgb/rpi_dpi_rgb.cpp

@@ -6,7 +6,6 @@ namespace esphome {
 namespace rpi_dpi_rgb {
 
 void RpiDpiRgb::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   this->reset_display_();
   esp_lcd_rgb_panel_config_t config{};
   config.flags.fb_in_psram = 1;
@@ -23,7 +22,6 @@ void RpiDpiRgb::setup() {
   config.timings.flags.pclk_active_neg = this->pclk_inverted_;
   config.timings.pclk_hz = this->pclk_frequency_;
   config.clk_src = LCD_CLK_SRC_PLL160M;
-  config.psram_trans_align = 64;
   size_t data_pin_count = sizeof(this->data_pins_) / sizeof(this->data_pins_[0]);
   for (size_t i = 0; i != data_pin_count; i++) {
     config.data_gpio_nums[i] = this->data_pins_[i]->get_pin();
@@ -42,7 +40,6 @@ void RpiDpiRgb::setup() {
   }
   ESP_ERROR_CHECK(esp_lcd_panel_reset(this->handle_));
   ESP_ERROR_CHECK(esp_lcd_panel_init(this->handle_));
-  ESP_LOGCONFIG(TAG, "RPI_DPI_RGB setup complete");
 }
 void RpiDpiRgb::loop() {
   if (this->handle_ != nullptr)

esphome/components/runtime_stats/__init__.py

@@ -0,0 +1,34 @@
+"""
+Runtime statistics component for ESPHome.
+"""
+
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.const import CONF_ID
+
+CODEOWNERS = ["@bdraco"]
+
+CONF_LOG_INTERVAL = "log_interval"
+
+runtime_stats_ns = cg.esphome_ns.namespace("runtime_stats")
+RuntimeStatsCollector = runtime_stats_ns.class_("RuntimeStatsCollector")
+
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(): cv.declare_id(RuntimeStatsCollector),
+        cv.Optional(
+            CONF_LOG_INTERVAL, default="60s"
+        ): cv.positive_time_period_milliseconds,
+    }
+)
+
+
+async def to_code(config):
+    """Generate code for the runtime statistics component."""
+    # Define USE_RUNTIME_STATS when this component is used
+    cg.add_define("USE_RUNTIME_STATS")
+
+    # Create the runtime stats instance (constructor sets global_runtime_stats)
+    var = cg.new_Pvariable(config[CONF_ID])
+
+    cg.add(var.set_log_interval(config[CONF_LOG_INTERVAL]))

esphome/components/runtime_stats/runtime_stats.cpp

@@ -0,0 +1,102 @@
+#include "runtime_stats.h"
+
+#ifdef USE_RUNTIME_STATS
+
+#include "esphome/core/component.h"
+#include <algorithm>
+
+namespace esphome {
+
+namespace runtime_stats {
+
+RuntimeStatsCollector::RuntimeStatsCollector() : log_interval_(60000), next_log_time_(0) {
+  global_runtime_stats = this;
+}
+
+void RuntimeStatsCollector::record_component_time(Component *component, uint32_t duration_ms, uint32_t current_time) {
+  if (component == nullptr)
+    return;
+
+  // Check if we have cached the name for this component
+  auto name_it = this->component_names_cache_.find(component);
+  if (name_it == this->component_names_cache_.end()) {
+    // First time seeing this component, cache its name
+    const char *source = component->get_component_source();
+    this->component_names_cache_[component] = source;
+    this->component_stats_[source].record_time(duration_ms);
+  } else {
+    this->component_stats_[name_it->second].record_time(duration_ms);
+  }
+
+  if (this->next_log_time_ == 0) {
+    this->next_log_time_ = current_time + this->log_interval_;
+    return;
+  }
+}
+
+void RuntimeStatsCollector::log_stats_() {
+  ESP_LOGI(TAG, "Component Runtime Statistics");
+  ESP_LOGI(TAG, "Period stats (last %" PRIu32 "ms):", this->log_interval_);
+
+  // First collect stats we want to display
+  std::vector<ComponentStatPair> stats_to_display;
+
+  for (const auto &it : this->component_stats_) {
+    const ComponentRuntimeStats &stats = it.second;
+    if (stats.get_period_count() > 0) {
+      ComponentStatPair pair = {it.first, &stats};
+      stats_to_display.push_back(pair);
+    }
+  }
+
+  // Sort by period runtime (descending)
+  std::sort(stats_to_display.begin(), stats_to_display.end(), std::greater<ComponentStatPair>());
+
+  // Log top components by period runtime
+  for (const auto &it : stats_to_display) {
+    const char *source = it.name;
+    const ComponentRuntimeStats *stats = it.stats;
+
+    ESP_LOGI(TAG, "  %s: count=%" PRIu32 ", avg=%.2fms, max=%" PRIu32 "ms, total=%" PRIu32 "ms", source,
+             stats->get_period_count(), stats->get_period_avg_time_ms(), stats->get_period_max_time_ms(),
+             stats->get_period_time_ms());
+  }
+
+  // Log total stats since boot
+  ESP_LOGI(TAG, "Total stats (since boot):");
+
+  // Re-sort by total runtime for all-time stats
+  std::sort(stats_to_display.begin(), stats_to_display.end(),
+            [](const ComponentStatPair &a, const ComponentStatPair &b) {
+              return a.stats->get_total_time_ms() > b.stats->get_total_time_ms();
+            });
+
+  for (const auto &it : stats_to_display) {
+    const char *source = it.name;
+    const ComponentRuntimeStats *stats = it.stats;
+
+    ESP_LOGI(TAG, "  %s: count=%" PRIu32 ", avg=%.2fms, max=%" PRIu32 "ms, total=%" PRIu32 "ms", source,
+             stats->get_total_count(), stats->get_total_avg_time_ms(), stats->get_total_max_time_ms(),
+             stats->get_total_time_ms());
+  }
+}
+
+void RuntimeStatsCollector::process_pending_stats(uint32_t current_time) {
+  if (this->next_log_time_ == 0)
+    return;
+
+  if (current_time >= this->next_log_time_) {
+    this->log_stats_();
+    this->reset_stats_();
+    this->next_log_time_ = current_time + this->log_interval_;
+  }
+}
+
+}  // namespace runtime_stats
+
+runtime_stats::RuntimeStatsCollector *global_runtime_stats =
+    nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+
+}  // namespace esphome
+
+#endif  // USE_RUNTIME_STATS

esphome/components/runtime_stats/runtime_stats.h

@@ -0,0 +1,132 @@
+#pragma once
+
+#include "esphome/core/defines.h"
+
+#ifdef USE_RUNTIME_STATS
+
+#include <map>
+#include <vector>
+#include <cstdint>
+#include <cstring>
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+
+class Component;  // Forward declaration
+
+namespace runtime_stats {
+
+static const char *const TAG = "runtime_stats";
+
+class ComponentRuntimeStats {
+ public:
+  ComponentRuntimeStats()
+      : period_count_(0),
+        period_time_ms_(0),
+        period_max_time_ms_(0),
+        total_count_(0),
+        total_time_ms_(0),
+        total_max_time_ms_(0) {}
+
+  void record_time(uint32_t duration_ms) {
+    // Update period counters
+    this->period_count_++;
+    this->period_time_ms_ += duration_ms;
+    if (duration_ms > this->period_max_time_ms_)
+      this->period_max_time_ms_ = duration_ms;
+
+    // Update total counters
+    this->total_count_++;
+    this->total_time_ms_ += duration_ms;
+    if (duration_ms > this->total_max_time_ms_)
+      this->total_max_time_ms_ = duration_ms;
+  }
+
+  void reset_period_stats() {
+    this->period_count_ = 0;
+    this->period_time_ms_ = 0;
+    this->period_max_time_ms_ = 0;
+  }
+
+  // Period stats (reset each logging interval)
+  uint32_t get_period_count() const { return this->period_count_; }
+  uint32_t get_period_time_ms() const { return this->period_time_ms_; }
+  uint32_t get_period_max_time_ms() const { return this->period_max_time_ms_; }
+  float get_period_avg_time_ms() const {
+    return this->period_count_ > 0 ? this->period_time_ms_ / static_cast<float>(this->period_count_) : 0.0f;
+  }
+
+  // Total stats (persistent until reboot)
+  uint32_t get_total_count() const { return this->total_count_; }
+  uint32_t get_total_time_ms() const { return this->total_time_ms_; }
+  uint32_t get_total_max_time_ms() const { return this->total_max_time_ms_; }
+  float get_total_avg_time_ms() const {
+    return this->total_count_ > 0 ? this->total_time_ms_ / static_cast<float>(this->total_count_) : 0.0f;
+  }
+
+ protected:
+  // Period stats (reset each logging interval)
+  uint32_t period_count_;
+  uint32_t period_time_ms_;
+  uint32_t period_max_time_ms_;
+
+  // Total stats (persistent until reboot)
+  uint32_t total_count_;
+  uint32_t total_time_ms_;
+  uint32_t total_max_time_ms_;
+};
+
+// For sorting components by run time
+struct ComponentStatPair {
+  const char *name;
+  const ComponentRuntimeStats *stats;
+
+  bool operator>(const ComponentStatPair &other) const {
+    // Sort by period time as that's what we're displaying in the logs
+    return stats->get_period_time_ms() > other.stats->get_period_time_ms();
+  }
+};
+
+class RuntimeStatsCollector {
+ public:
+  RuntimeStatsCollector();
+
+  void set_log_interval(uint32_t log_interval) { this->log_interval_ = log_interval; }
+  uint32_t get_log_interval() const { return this->log_interval_; }
+
+  void record_component_time(Component *component, uint32_t duration_ms, uint32_t current_time);
+
+  // Process any pending stats printing (should be called after component loop)
+  void process_pending_stats(uint32_t current_time);
+
+ protected:
+  void log_stats_();
+
+  void reset_stats_() {
+    for (auto &it : this->component_stats_) {
+      it.second.reset_period_stats();
+    }
+  }
+
+  // Use const char* keys for efficiency
+  // Custom comparator for const char* keys in map
+  // Without this, std::map would compare pointer addresses instead of string contents,
+  // causing identical component names at different addresses to be treated as different keys
+  struct CStrCompare {
+    bool operator()(const char *a, const char *b) const { return std::strcmp(a, b) < 0; }
+  };
+  std::map<const char *, ComponentRuntimeStats, CStrCompare> component_stats_;
+  std::map<Component *, const char *> component_names_cache_;
+  uint32_t log_interval_;
+  uint32_t next_log_time_;
+};
+
+}  // namespace runtime_stats
+
+extern runtime_stats::RuntimeStatsCollector
+    *global_runtime_stats;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+
+}  // namespace esphome
+
+#endif  // USE_RUNTIME_STATS

esphome/components/scd30/scd30.cpp

@@ -26,8 +26,6 @@ static const uint16_t SCD30_CMD_TEMPERATURE_OFFSET = 0x5403;
 static const uint16_t SCD30_CMD_SOFT_RESET = 0xD304;
 
 void SCD30Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
-
 #ifdef USE_ESP8266
   Wire.setClockStretchLimit(150000);
 #endif

esphome/components/scd30/sensor.py

@@ -3,6 +3,7 @@ import esphome.codegen as cg
 from esphome.components import i2c, sensirion_common, sensor
 import esphome.config_validation as cv
 from esphome.const import (
+    CONF_ALTITUDE_COMPENSATION,
     CONF_AMBIENT_PRESSURE_COMPENSATION,
     CONF_AUTOMATIC_SELF_CALIBRATION,
     CONF_CO2,
@@ -35,8 +36,6 @@ ForceRecalibrationWithReference = scd30_ns.class_(
     "ForceRecalibrationWithReference", automation.Action
 )
 
-CONF_ALTITUDE_COMPENSATION = "altitude_compensation"
-
 CONFIG_SCHEMA = (
     cv.Schema(
         {

esphome/components/scd4x/scd4x.cpp

@@ -27,7 +27,6 @@ static const uint16_t SCD4X_CMD_GET_FEATURESET = 0x202f;
 static const float SCD4X_TEMPERATURE_OFFSET_MULTIPLIER = (1 << 16) / 175.0f;
 
 void SCD4XComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
   // the sensor needs 1000 ms to enter the idle state
   this->set_timeout(1000, [this]() {
     this->status_clear_error();