Merge remote-tracking branch 'upstream/dev' into add_api_stats

.github/actions/build-image/action.yaml

@@ -47,7 +47,7 @@ runs:
 
     - name: Build and push to ghcr by digest
       id: build-ghcr
-      uses: docker/build-push-action@v6.18.0
+      uses: docker/build-push-action@v6.17.0
       env:
         DOCKER_BUILD_SUMMARY: false
         DOCKER_BUILD_RECORD_UPLOAD: false
@@ -73,7 +73,7 @@ runs:
 
     - name: Build and push to dockerhub by digest
       id: build-dockerhub
-      uses: docker/build-push-action@v6.18.0
+      uses: docker/build-push-action@v6.17.0
       env:
         DOCKER_BUILD_SUMMARY: false
         DOCKER_BUILD_RECORD_UPLOAD: false

CODEOWNERS

@@ -139,7 +139,6 @@ esphome/components/es7210/* @kahrendt
 esphome/components/es7243e/* @kbx81
 esphome/components/es8156/* @kbx81
 esphome/components/es8311/* @kahrendt @kroimon
-esphome/components/es8388/* @P4uLT
 esphome/components/esp32/* @esphome/core
 esphome/components/esp32_ble/* @Rapsssito @jesserockz
 esphome/components/esp32_ble_client/* @jesserockz

esphome/__main__.py

@@ -593,20 +593,15 @@ def command_update_all(args):
         middle_text = f" {middle_text} "
         width = len(click.unstyle(middle_text))
         half_line = "=" * ((twidth - width) // 2)
-        safe_print(f"{half_line}{middle_text}{half_line}")
+        click.echo(f"{half_line}{middle_text}{half_line}")
 
     for f in files:
-        safe_print(f"Updating {color(AnsiFore.CYAN, f)}")
-        safe_print("-" * twidth)
-        safe_print()
-        if CORE.dashboard:
-            rc = run_external_process(
-                "esphome", "--dashboard", "run", f, "--no-logs", "--device", "OTA"
-            )
-        else:
-            rc = run_external_process(
-                "esphome", "run", f, "--no-logs", "--device", "OTA"
-            )
+        print(f"Updating {color(AnsiFore.CYAN, f)}")
+        print("-" * twidth)
+        print()
+        rc = run_external_process(
+            "esphome", "--dashboard", "run", f, "--no-logs", "--device", "OTA"
+        )
         if rc == 0:
             print_bar(f"[{color(AnsiFore.BOLD_GREEN, 'SUCCESS')}] {f}")
             success[f] = True
@@ -614,17 +609,17 @@ def command_update_all(args):
             print_bar(f"[{color(AnsiFore.BOLD_RED, 'ERROR')}] {f}")
             success[f] = False
 
-        safe_print()
-        safe_print()
-        safe_print()
+        print()
+        print()
+        print()
 
     print_bar(f"[{color(AnsiFore.BOLD_WHITE, 'SUMMARY')}]")
     failed = 0
     for f in files:
         if success[f]:
-            safe_print(f"  - {f}: {color(AnsiFore.GREEN, 'SUCCESS')}")
+            print(f"  - {f}: {color(AnsiFore.GREEN, 'SUCCESS')}")
         else:
-            safe_print(f"  - {f}: {color(AnsiFore.BOLD_RED, 'FAILED')}")
+            print(f"  - {f}: {color(AnsiFore.BOLD_RED, 'FAILED')}")
             failed += 1
     return failed
 

esphome/components/a4988/a4988.cpp

@@ -7,7 +7,7 @@ namespace a4988 {
 static const char *const TAG = "a4988.stepper";
 
 void A4988::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up A4988...");
   if (this->sleep_pin_ != nullptr) {
     this->sleep_pin_->setup();
     this->sleep_pin_->digital_write(false);

esphome/components/absolute_humidity/absolute_humidity.cpp

@@ -7,7 +7,7 @@ namespace absolute_humidity {
 static const char *const TAG = "absolute_humidity.sensor";
 
 void AbsoluteHumidityComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup for '%s'", this->get_name().c_str());
+  ESP_LOGCONFIG(TAG, "Setting up absolute humidity '%s'...", this->get_name().c_str());
 
   ESP_LOGD(TAG, "  Added callback for temperature '%s'", this->temperature_sensor_->get_name().c_str());
   this->temperature_sensor_->add_on_state_callback([this](float state) { this->temperature_callback_(state); });

esphome/components/adc/adc_sensor_esp32.cpp

@@ -22,7 +22,7 @@ static const int ADC_MAX = (1 << SOC_ADC_RTC_MAX_BITWIDTH) - 1;
 static const int ADC_HALF = (1 << SOC_ADC_RTC_MAX_BITWIDTH) >> 1;
 
 void ADCSensor::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup for '%s'...", this->get_name().c_str());
+  ESP_LOGCONFIG(TAG, "Setting up ADC '%s'...", this->get_name().c_str());
 
   if (this->channel1_ != ADC1_CHANNEL_MAX) {
     adc1_config_width(ADC_WIDTH_MAX_SOC_BITS);

esphome/components/adc/adc_sensor_esp8266.cpp

@@ -17,7 +17,7 @@ namespace adc {
 static const char *const TAG = "adc.esp8266";
 
 void ADCSensor::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup for '%s'...", this->get_name().c_str());
+  ESP_LOGCONFIG(TAG, "Setting up ADC '%s'...", this->get_name().c_str());
 #ifndef USE_ADC_SENSOR_VCC
   this->pin_->setup();
 #endif

esphome/components/adc/adc_sensor_libretiny.cpp

@@ -9,7 +9,7 @@ namespace adc {
 static const char *const TAG = "adc.libretiny";
 
 void ADCSensor::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup for '%s'...", this->get_name().c_str());
+  ESP_LOGCONFIG(TAG, "Setting up ADC '%s'...", this->get_name().c_str());
 #ifndef USE_ADC_SENSOR_VCC
   this->pin_->setup();
 #endif  // !USE_ADC_SENSOR_VCC

esphome/components/adc/adc_sensor_rp2040.cpp

@@ -14,7 +14,7 @@ namespace adc {
 static const char *const TAG = "adc.rp2040";
 
 void ADCSensor::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup for '%s'...", this->get_name().c_str());
+  ESP_LOGCONFIG(TAG, "Setting up ADC '%s'...", this->get_name().c_str());
   static bool initialized = false;
   if (!initialized) {
     adc_init();

esphome/components/adc128s102/adc128s102.cpp

@@ -9,7 +9,7 @@ static const char *const TAG = "adc128s102";
 float ADC128S102::get_setup_priority() const { return setup_priority::HARDWARE; }
 
 void ADC128S102::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up adc128s102");
   this->spi_setup();
 }
 

esphome/components/ads1115/ads1115.cpp

@@ -10,13 +10,15 @@ static const uint8_t ADS1115_REGISTER_CONVERSION = 0x00;
 static const uint8_t ADS1115_REGISTER_CONFIG = 0x01;
 
 void ADS1115Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up ADS1115...");
   uint16_t value;
   if (!this->read_byte_16(ADS1115_REGISTER_CONVERSION, &value)) {
     this->mark_failed();
     return;
   }
 
+  ESP_LOGCONFIG(TAG, "Configuring ADS1115...");
+
   uint16_t config = 0;
   // Clear single-shot bit
   //        0b0xxxxxxxxxxxxxxx
@@ -66,10 +68,10 @@ void ADS1115Component::setup() {
   this->prev_config_ = config;
 }
 void ADS1115Component::dump_config() {
-  ESP_LOGCONFIG(TAG, "ADS1115:");
+  ESP_LOGCONFIG(TAG, "Setting up ADS1115...");
   LOG_I2C_DEVICE(this);
   if (this->is_failed()) {
-    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+    ESP_LOGE(TAG, "Communication with ADS1115 failed!");
   }
 }
 float ADS1115Component::request_measurement(ADS1115Multiplexer multiplexer, ADS1115Gain gain,

esphome/components/ads1118/ads1118.cpp

@@ -8,7 +8,7 @@ static const char *const TAG = "ads1118";
 static const uint8_t ADS1118_DATA_RATE_860_SPS = 0b111;
 
 void ADS1118::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up ads1118");
   this->spi_setup();
 
   this->config_ = 0;

esphome/components/ags10/ags10.cpp

@@ -23,7 +23,7 @@ static const uint16_t ZP_CURRENT = 0x0000;
 static const uint16_t ZP_DEFAULT = 0xFFFF;
 
 void AGS10Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up ags10...");
 
   auto version = this->read_version_();
   if (version) {
@@ -65,7 +65,7 @@ void AGS10Component::dump_config() {
     case NONE:
       break;
     case COMMUNICATION_FAILED:
-      ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+      ESP_LOGE(TAG, "Communication with AGS10 failed!");
       break;
     case CRC_CHECK_FAILED:
       ESP_LOGE(TAG, "The crc check failed");

esphome/components/aht10/aht10.cpp

@@ -15,7 +15,6 @@
 #include "aht10.h"
 #include "esphome/core/log.h"
 #include "esphome/core/hal.h"
-#include "esphome/core/helpers.h"
 
 namespace esphome {
 namespace aht10 {
@@ -35,59 +34,57 @@ static const uint8_t AHT10_INIT_ATTEMPTS = 10;
 
 static const uint8_t AHT10_STATUS_BUSY = 0x80;
 
-static const float AHT10_DIVISOR = 1048576.0f;  // 2^20, used for temperature and humidity calculations
-
 void AHT10Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
-
   if (this->write(AHT10_SOFTRESET_CMD, sizeof(AHT10_SOFTRESET_CMD)) != i2c::ERROR_OK) {
-    ESP_LOGE(TAG, "Reset failed");
+    ESP_LOGE(TAG, "Reset AHT10 failed!");
   }
   delay(AHT10_SOFTRESET_DELAY);
 
   i2c::ErrorCode error_code = i2c::ERROR_INVALID_ARGUMENT;
   switch (this->variant_) {
     case AHT10Variant::AHT20:
+      ESP_LOGCONFIG(TAG, "Setting up AHT20");
       error_code = this->write(AHT20_INITIALIZE_CMD, sizeof(AHT20_INITIALIZE_CMD));
       break;
     case AHT10Variant::AHT10:
+      ESP_LOGCONFIG(TAG, "Setting up AHT10");
       error_code = this->write(AHT10_INITIALIZE_CMD, sizeof(AHT10_INITIALIZE_CMD));
       break;
   }
   if (error_code != i2c::ERROR_OK) {
-    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+    ESP_LOGE(TAG, "Communication with AHT10 failed!");
     this->mark_failed();
     return;
   }
-  uint8_t cal_attempts = 0;
   uint8_t data = AHT10_STATUS_BUSY;
+  int cal_attempts = 0;
   while (data & AHT10_STATUS_BUSY) {
     delay(AHT10_DEFAULT_DELAY);
     if (this->read(&data, 1) != i2c::ERROR_OK) {
-      ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+      ESP_LOGE(TAG, "Communication with AHT10 failed!");
       this->mark_failed();
       return;
     }
     ++cal_attempts;
     if (cal_attempts > AHT10_INIT_ATTEMPTS) {
-      ESP_LOGE(TAG, "Initialization timed out");
+      ESP_LOGE(TAG, "AHT10 initialization timed out!");
       this->mark_failed();
       return;
     }
   }
   if ((data & 0x68) != 0x08) {  // Bit[6:5] = 0b00, NORMAL mode and Bit[3] = 0b1, CALIBRATED
-    ESP_LOGE(TAG, "Initialization failed");
+    ESP_LOGE(TAG, "AHT10 initialization failed!");
     this->mark_failed();
     return;
   }
 
-  ESP_LOGV(TAG, "Initialization complete");
+  ESP_LOGV(TAG, "AHT10 initialization");
 }
 
 void AHT10Component::restart_read_() {
   if (this->read_count_ == AHT10_ATTEMPTS) {
     this->read_count_ = 0;
-    this->status_set_error("Reading timed out");
+    this->status_set_error("Measurements reading timed-out!");
     return;
   }
   this->read_count_++;
@@ -100,24 +97,24 @@ void AHT10Component::read_data_() {
     ESP_LOGD(TAG, "Read attempt %d at %ums", this->read_count_, (unsigned) (millis() - this->start_time_));
   }
   if (this->read(data, 6) != i2c::ERROR_OK) {
-    this->status_set_warning("Read failed, will retry");
+    this->status_set_warning("AHT10 read failed, retrying soon");
     this->restart_read_();
     return;
   }
 
   if ((data[0] & 0x80) == 0x80) {  // Bit[7] = 0b1, device is busy
-    ESP_LOGD(TAG, "Device busy, will retry");
+    ESP_LOGD(TAG, "AHT10 is busy, waiting...");
     this->restart_read_();
     return;
   }
   if (data[1] == 0x0 && data[2] == 0x0 && (data[3] >> 4) == 0x0) {
-    // Invalid humidity (0x0)
+    // Unrealistic humidity (0x0)
     if (this->humidity_sensor_ == nullptr) {
-      ESP_LOGV(TAG, "Invalid humidity (reading not required)");
+      ESP_LOGV(TAG, "ATH10 Unrealistic humidity (0x0), but humidity is not required");
     } else {
-      ESP_LOGD(TAG, "Invalid humidity, retrying...");
+      ESP_LOGD(TAG, "ATH10 Unrealistic humidity (0x0), retrying...");
       if (this->write(AHT10_MEASURE_CMD, sizeof(AHT10_MEASURE_CMD)) != i2c::ERROR_OK) {
-        this->status_set_warning(ESP_LOG_MSG_COMM_FAIL);
+        this->status_set_warning("Communication with AHT10 failed!");
       }
       this->restart_read_();
       return;
@@ -126,17 +123,22 @@ void AHT10Component::read_data_() {
   if (this->read_count_ > 1) {
     ESP_LOGD(TAG, "Success at %ums", (unsigned) (millis() - this->start_time_));
   }
-  uint32_t raw_temperature = encode_uint24(data[3] & 0xF, data[4], data[5]);
-  uint32_t raw_humidity = encode_uint24(data[1], data[2], data[3]) >> 4;
+  uint32_t raw_temperature = ((data[3] & 0x0F) << 16) | (data[4] << 8) | data[5];
+  uint32_t raw_humidity = ((data[1] << 16) | (data[2] << 8) | data[3]) >> 4;
 
   if (this->temperature_sensor_ != nullptr) {
-    float temperature = ((200.0f * static_cast<float>(raw_temperature)) / AHT10_DIVISOR) - 50.0f;
+    float temperature = ((200.0f * (float) raw_temperature) / 1048576.0f) - 50.0f;
     this->temperature_sensor_->publish_state(temperature);
   }
   if (this->humidity_sensor_ != nullptr) {
-    float humidity = raw_humidity == 0 ? NAN : static_cast<float>(raw_humidity) * 100.0f / AHT10_DIVISOR;
+    float humidity;
+    if (raw_humidity == 0) {  // unrealistic value
+      humidity = NAN;
+    } else {
+      humidity = (float) raw_humidity * 100.0f / 1048576.0f;
+    }
     if (std::isnan(humidity)) {
-      ESP_LOGW(TAG, "Invalid humidity reading (0%%), ");
+      ESP_LOGW(TAG, "Invalid humidity! Sensor reported 0%% Hum");
     }
     this->humidity_sensor_->publish_state(humidity);
   }
@@ -148,7 +150,7 @@ void AHT10Component::update() {
     return;
   this->start_time_ = millis();
   if (this->write(AHT10_MEASURE_CMD, sizeof(AHT10_MEASURE_CMD)) != i2c::ERROR_OK) {
-    this->status_set_warning(ESP_LOG_MSG_COMM_FAIL);
+    this->status_set_warning("Communication with AHT10 failed!");
     return;
   }
   this->restart_read_();
@@ -160,7 +162,7 @@ void AHT10Component::dump_config() {
   ESP_LOGCONFIG(TAG, "AHT10:");
   LOG_I2C_DEVICE(this);
   if (this->is_failed()) {
-    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+    ESP_LOGE(TAG, "Communication with AHT10 failed!");
   }
   LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
   LOG_SENSOR("  ", "Humidity", this->humidity_sensor_);

esphome/components/aic3204/aic3204.cpp

@@ -17,7 +17,7 @@ static const char *const TAG = "aic3204";
   }
 
 void AIC3204::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up AIC3204...");
 
   // Set register page to 0
   ERROR_CHECK(this->write_byte(AIC3204_PAGE_CTRL, 0x00), "Set page 0 failed");
@@ -113,7 +113,7 @@ void AIC3204::dump_config() {
   LOG_I2C_DEVICE(this);
 
   if (this->is_failed()) {
-    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+    ESP_LOGE(TAG, "Communication with AIC3204 failed");
   }
 }
 

esphome/components/am2315c/am2315c.cpp

@@ -90,7 +90,7 @@ bool AM2315C::convert_(uint8_t *data, float &humidity, float &temperature) {
 }
 
 void AM2315C::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up AM2315C...");
 
   // get status
   uint8_t status = 0;
@@ -188,7 +188,7 @@ void AM2315C::dump_config() {
   ESP_LOGCONFIG(TAG, "AM2315C:");
   LOG_I2C_DEVICE(this);
   if (this->is_failed()) {
-    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+    ESP_LOGE(TAG, "Communication with AM2315C failed!");
   }
   LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
   LOG_SENSOR("  ", "Humidity", this->humidity_sensor_);

esphome/components/am2320/am2320.cpp

@@ -34,7 +34,7 @@ void AM2320Component::update() {
   this->status_clear_warning();
 }
 void AM2320Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up AM2320...");
   uint8_t data[8];
   data[0] = 0;
   data[1] = 4;
@@ -47,7 +47,7 @@ void AM2320Component::dump_config() {
   ESP_LOGD(TAG, "AM2320:");
   LOG_I2C_DEVICE(this);
   if (this->is_failed()) {
-    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+    ESP_LOGE(TAG, "Communication with AM2320 failed!");
   }
   LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
   LOG_SENSOR("  ", "Humidity", this->humidity_sensor_);

esphome/components/apds9306/apds9306.cpp

@@ -54,7 +54,7 @@ enum {  // APDS9306 registers
   }
 
 void APDS9306::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up APDS9306...");
 
   uint8_t id;
   if (!this->read_byte(APDS9306_PART_ID, &id)) {  // Part ID register
@@ -97,7 +97,7 @@ void APDS9306::dump_config() {
   if (this->is_failed()) {
     switch (this->error_code_) {
       case COMMUNICATION_FAILED:
-        ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+        ESP_LOGE(TAG, "Communication with APDS9306 failed!");
         break;
       case WRONG_ID:
         ESP_LOGE(TAG, "APDS9306 has invalid id!");

esphome/components/apds9960/apds9960.cpp

@@ -15,7 +15,7 @@ static const char *const TAG = "apds9960";
 #define APDS9960_WRITE_BYTE(reg, value) APDS9960_ERROR_CHECK(this->write_byte(reg, value));
 
 void APDS9960::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up APDS9960...");
   uint8_t id;
   if (!this->read_byte(0x92, &id)) {  // ID register
     this->error_code_ = COMMUNICATION_FAILED;
@@ -141,7 +141,7 @@ void APDS9960::dump_config() {
   if (this->is_failed()) {
     switch (this->error_code_) {
       case COMMUNICATION_FAILED:
-        ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+        ESP_LOGE(TAG, "Communication with APDS9960 failed!");
         break;
       case WRONG_ID:
         ESP_LOGE(TAG, "APDS9960 has invalid id!");

esphome/components/api/api_connection.cpp

@@ -3,6 +3,9 @@
 #include <cerrno>
 #include <cinttypes>
 #include <utility>
+#include <algorithm>
+#include <map>
+#include <string>
 #include "esphome/components/network/util.h"
 #include "esphome/core/application.h"
 #include "esphome/core/entity_base.h"
@@ -85,6 +88,9 @@ void APIConnection::start() {
   // This ensures the first ping happens after the keepalive period
   this->next_ping_retry_ = this->last_traffic_ + KEEPALIVE_TIMEOUT_MS;
 
+  // Pass stats collection to the helper for detailed timing
+  this->helper_->set_section_stats(&this->section_stats_);
+
   APIError err = this->helper_->init();
   if (err != APIError::OK) {
     on_fatal_error();
@@ -111,6 +117,9 @@ APIConnection::~APIConnection() {
 }
 
 void APIConnection::loop() {
+  // Measure total time for entire loop function
+  const uint32_t loop_start_time = millis();
+
   if (this->remove_)
     return;
 
@@ -128,7 +137,16 @@ void APIConnection::loop() {
     return;
   }
 
+  const uint32_t now = millis();
+  uint32_t start_time;
+  uint32_t duration;
+
+  // Section: Helper Loop
+  start_time = millis();
   APIError err = this->helper_->loop();
+  duration = millis() - start_time;
+  this->section_stats_["helper_loop"].record_time(duration);
+
   if (err != APIError::OK) {
     on_fatal_error();
     ESP_LOGW(TAG, "%s: Socket operation failed: %s errno=%d", this->client_combined_info_.c_str(),
@@ -136,48 +154,64 @@ void APIConnection::loop() {
     return;
   }
 
-  // Check if socket has data ready before attempting to read
-  if (this->helper_->is_socket_ready()) {
-    ReadPacketBuffer buffer;
-    err = this->helper_->read_packet(&buffer);
-    if (err == APIError::WOULD_BLOCK) {
-      // pass
-    } else if (err != APIError::OK) {
-      on_fatal_error();
-      if (err == APIError::SOCKET_READ_FAILED && errno == ECONNRESET) {
-        ESP_LOGW(TAG, "%s: Connection reset", this->client_combined_info_.c_str());
-      } else if (err == APIError::CONNECTION_CLOSED) {
-        ESP_LOGW(TAG, "%s: Connection closed", this->client_combined_info_.c_str());
-      } else {
-        ESP_LOGW(TAG, "%s: Reading failed: %s errno=%d", this->client_combined_info_.c_str(), api_error_to_str(err),
-                 errno);
-      }
-      return;
+  // Section: Read Packet
+  start_time = millis();
+  ReadPacketBuffer buffer;
+  err = this->helper_->read_packet(&buffer);
+  duration = millis() - start_time;
+  this->section_stats_["read_packet"].record_time(duration);
+
+  if (err == APIError::WOULD_BLOCK) {
+    // pass
+  } else if (err != APIError::OK) {
+    on_fatal_error();
+    if (err == APIError::SOCKET_READ_FAILED && errno == ECONNRESET) {
+      ESP_LOGW(TAG, "%s: Connection reset", this->client_combined_info_.c_str());
+    } else if (err == APIError::CONNECTION_CLOSED) {
+      ESP_LOGW(TAG, "%s: Connection closed", this->client_combined_info_.c_str());
     } else {
-      this->last_traffic_ = App.get_loop_component_start_time();
-      // read a packet
-      if (buffer.data_len > 0) {
-        this->read_message(buffer.data_len, buffer.type, &buffer.container[buffer.data_offset]);
-      } else {
-        this->read_message(0, buffer.type, nullptr);
-      }
-      if (this->remove_)
-        return;
+      ESP_LOGW(TAG, "%s: Reading failed: %s errno=%d", this->client_combined_info_.c_str(), api_error_to_str(err),
+               errno);
     }
+    return;
+  } else {
+    this->last_traffic_ = App.get_loop_component_start_time();
+
+    // Section: Process Message
+    start_time = millis();
+    if (buffer.data_len > 0) {
+      this->read_message(buffer.data_len, buffer.type, &buffer.container[buffer.data_offset]);
+    } else {
+      this->read_message(0, buffer.type, nullptr);
+    }
+    duration = millis() - start_time;
+    this->section_stats_["process_message"].record_time(duration);
+
+    if (this->remove_)
+      return;
   }
 
+  // Section: Process Queue
+  start_time = millis();
   if (!this->deferred_message_queue_.empty() && this->helper_->can_write_without_blocking()) {
     this->deferred_message_queue_.process_queue();
   }
+  duration = millis() - start_time;
+  this->section_stats_["process_queue"].record_time(duration);
 
+  // Section: Iterator Advance
+  start_time = millis();
   if (!this->list_entities_iterator_.completed())
     this->list_entities_iterator_.advance();
   if (!this->initial_state_iterator_.completed() && this->list_entities_iterator_.completed())
     this->initial_state_iterator_.advance();
+  duration = millis() - start_time;
+  this->section_stats_["iterator_advance"].record_time(duration);
 
+  // Section: Keepalive
+  start_time = millis();
   static uint8_t max_ping_retries = 60;
   static uint16_t ping_retry_interval = 1000;
-  const uint32_t now = App.get_loop_component_start_time();
   if (this->sent_ping_) {
     // Disconnect if not responded within 2.5*keepalive
     if (now - this->last_traffic_ > (KEEPALIVE_TIMEOUT_MS * 5) / 2) {
@@ -203,8 +237,12 @@ void APIConnection::loop() {
       }
     }
   }
+  duration = millis() - start_time;
+  this->section_stats_["keepalive"].record_time(duration);
 
 #ifdef USE_ESP32_CAMERA
+  // Section: Camera
+  start_time = millis();
   if (this->image_reader_.available() && this->helper_->can_write_without_blocking()) {
     // Message will use 8 more bytes than the minimum size, and typical
     // MTU is 1500. Sometimes users will see as low as 1460 MTU.
@@ -243,8 +281,12 @@ void APIConnection::loop() {
       this->image_reader_.return_image();
     }
   }
+  duration = millis() - start_time;
+  this->section_stats_["camera"].record_time(duration);
 #endif
 
+  // Section: State Subscriptions
+  start_time = millis();
   if (state_subs_at_ != -1) {
     const auto &subs = this->parent_->get_state_subs();
     if (state_subs_at_ >= (int) subs.size()) {
@@ -260,6 +302,24 @@ void APIConnection::loop() {
       }
     }
   }
+  duration = millis() - start_time;
+  this->section_stats_["state_subs"].record_time(duration);
+
+  // Log stats periodically
+  if (this->stats_enabled_) {
+    // If next_stats_log_ is 0, initialize it
+    if (this->next_stats_log_ == 0) {
+      this->next_stats_log_ = now + this->stats_log_interval_;
+    } else if (now >= this->next_stats_log_) {
+      this->log_section_stats_();
+      this->reset_section_stats_();
+      this->next_stats_log_ = now + this->stats_log_interval_;
+    }
+  }
+
+  // Record total loop execution time
+  const uint32_t total_loop_duration = millis() - loop_start_time;
+  this->section_stats_["total_loop"].record_time(total_loop_duration);
 }
 
 std::string get_default_unique_id(const std::string &component_type, EntityBase *entity) {
@@ -1636,8 +1696,14 @@ bool APIConnection::try_to_clear_buffer(bool log_out_of_space) {
     return false;
   if (this->helper_->can_write_without_blocking())
     return true;
+
+  // Track try_to_clear_buffer time
+  const uint32_t start_time = millis();
   delay(0);
   APIError err = this->helper_->loop();
+  const uint32_t duration = millis() - start_time;
+  this->section_stats_["try_to_clear_buffer"].record_time(duration);
+
   if (err != APIError::OK) {
     on_fatal_error();
     ESP_LOGW(TAG, "%s: Socket operation failed: %s errno=%d", this->client_combined_info_.c_str(),
@@ -1652,11 +1718,17 @@ bool APIConnection::try_to_clear_buffer(bool log_out_of_space) {
   return false;
 }
 bool APIConnection::send_buffer(ProtoWriteBuffer buffer, uint32_t message_type) {
+  // Track send_buffer time
+  const uint32_t start_time = millis();
+
   if (!this->try_to_clear_buffer(message_type != 29)) {  // SubscribeLogsResponse
     return false;
   }
 
+  uint32_t write_start = millis();
   APIError err = this->helper_->write_protobuf_packet(message_type, buffer);
+  uint32_t write_duration = millis() - write_start;
+  this->section_stats_["write_packet"].record_time(write_duration);
   if (err == APIError::WOULD_BLOCK)
     return false;
   if (err != APIError::OK) {
@@ -1669,6 +1741,11 @@ bool APIConnection::send_buffer(ProtoWriteBuffer buffer, uint32_t message_type)
     }
     return false;
   }
+
+  // Measure total send_buffer function time
+  uint32_t total_duration = millis() - start_time;
+  this->section_stats_["send_buffer_total"].record_time(total_duration);
+
   // Do not set last_traffic_ on send
   return true;
 }
@@ -1685,6 +1762,90 @@ void APIConnection::on_fatal_error() {
   this->remove_ = true;
 }
 
+void APIConnection::log_section_stats_() {
+  const char *STATS_TAG = "api.stats";
+  ESP_LOGI(STATS_TAG, "Logging API section stats now (current time: %" PRIu32 ", scheduled time: %" PRIu32 ")",
+           millis(), this->next_stats_log_);
+  ESP_LOGI(STATS_TAG, "Stats collection status: enabled=%d, sections=%zu", this->stats_enabled_,
+           this->section_stats_.size());
+
+  // Check if we have minimal data
+  bool has_data = false;
+  for (const auto &it : this->section_stats_) {
+    if (it.second.get_period_count() > 0) {
+      has_data = true;
+      break;
+    }
+  }
+
+  if (has_data) {
+    size_t helper_count = 0;
+    size_t read_count = 0;
+    size_t total_count = 0;
+    if (this->section_stats_.count("helper_loop") > 0)
+      helper_count = this->section_stats_["helper_loop"].get_period_count();
+    if (this->section_stats_.count("read_packet") > 0)
+      read_count = this->section_stats_["read_packet"].get_period_count();
+    if (this->section_stats_.count("total_loop") > 0)
+      total_count = this->section_stats_["total_loop"].get_period_count();
+
+    ESP_LOGI(STATS_TAG, "Record count for key sections: helper_loop=%zu, read_packet=%zu, total_loop=%zu", helper_count,
+             read_count, total_count);
+  }
+
+  ESP_LOGI(STATS_TAG, "API Connection Section Runtime Statistics");
+  ESP_LOGI(STATS_TAG, "Period stats (last %" PRIu32 "ms):", this->stats_log_interval_);
+
+  // First collect stats we want to display
+  std::vector<std::pair<std::string, const APISectionStats *>> stats_to_display;
+
+  for (const auto &it : this->section_stats_) {
+    const APISectionStats &stats = it.second;
+    if (stats.get_period_count() > 0) {
+      stats_to_display.push_back({it.first, &stats});
+    }
+  }
+
+  // Sort by period runtime (descending)
+  std::sort(stats_to_display.begin(), stats_to_display.end(), [](const auto &a, const auto &b) {
+    return a.second->get_period_time_ms() > b.second->get_period_time_ms();
+  });
+
+  // Log top components by period runtime
+  for (const auto &it : stats_to_display) {
+    const std::string &section = it.first;
+    const APISectionStats *stats = it.second;
+
+    ESP_LOGI(STATS_TAG, "  %s: count=%" PRIu32 ", avg=%.2fms, max=%" PRIu32 "ms, total=%" PRIu32 "ms", section.c_str(),
+             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(STATS_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 auto &a, const auto &b) { return a.second->get_total_time_ms() > b.second->get_total_time_ms(); });
+
+  for (const auto &it : stats_to_display) {
+    const std::string &section = it.first;
+    const APISectionStats *stats = it.second;
+
+    ESP_LOGI(STATS_TAG, "  %s: count=%" PRIu32 ", avg=%.2fms, max=%" PRIu32 "ms, total=%" PRIu32 "ms", section.c_str(),
+             stats->get_total_count(), stats->get_total_avg_time_ms(), stats->get_total_max_time_ms(),
+             stats->get_total_time_ms());
+  }
+
+  ESP_LOGD(STATS_TAG, "Resetting API section stats, sections count: %zu", this->section_stats_.size());
+}
+
+void APIConnection::reset_section_stats_() {
+  for (auto &it : this->section_stats_) {
+    it.second.reset_period_stats();
+  }
+}
+
 }  // namespace api
 }  // namespace esphome
 #endif

esphome/components/api/api_connection.h

@@ -9,8 +9,12 @@
 #include "esphome/core/application.h"
 #include "esphome/core/component.h"
 #include "esphome/core/entity_base.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 #include <vector>
+#include <map>
+#include <string>
 
 namespace esphome {
 namespace api {
@@ -64,6 +68,9 @@ class APIConnection : public APIServerConnection {
   APIConnection(std::unique_ptr<socket::Socket> socket, APIServer *parent);
   virtual ~APIConnection();
 
+  // Use the APISectionStats from api_frame_helper.h to avoid duplication
+  using APISectionStats = ::esphome::api::APISectionStats;
+
   void start();
   void loop();
 
@@ -556,6 +563,14 @@ class APIConnection : public APIServerConnection {
   InitialStateIterator initial_state_iterator_;
   ListEntitiesIterator list_entities_iterator_;
   int state_subs_at_ = -1;
+
+  // API loop section performance statistics
+  std::map<std::string, APISectionStats> section_stats_;
+  uint32_t stats_log_interval_{60000};  // 60 seconds default
+  uint32_t next_stats_log_{0};
+  bool stats_enabled_{true};
+  void log_section_stats_();
+  void reset_section_stats_();
 };
 
 }  // namespace api

esphome/components/api/api_frame_helper.cpp

@@ -111,7 +111,12 @@ APIError APIFrameHelper::write_raw_(const struct iovec *iov, int iovcnt) {
   }
 
   // Try to send directly if no buffered data
+  uint32_t write_start = millis();
   ssize_t sent = this->socket_->writev(iov, iovcnt);
+  uint32_t write_duration = millis() - write_start;
+  if (write_duration > 0 && section_stats_) {
+    (*section_stats_)["write_packet.socket_writev"].record_time(write_duration);
+  }
 
   if (sent == -1) {
     if (errno == EWOULDBLOCK || errno == EAGAIN) {
@@ -160,7 +165,12 @@ APIError APIFrameHelper::try_send_tx_buf_() {
     SendBuffer &front_buffer = this->tx_buf_.front();
 
     // Try to send the remaining data in this buffer
+    uint32_t write_start = millis();
     ssize_t sent = this->socket_->write(front_buffer.current_data(), front_buffer.remaining());
+    uint32_t write_duration = millis() - write_start;
+    if (write_duration > 0 && section_stats_) {
+      (*section_stats_)["send_buffer_total.socket_write"].record_time(write_duration);
+    }
 
     if (sent == -1) {
       if (errno != EWOULDBLOCK && errno != EAGAIN) {
@@ -311,7 +321,12 @@ APIError APINoiseFrameHelper::try_read_frame_(ParsedFrame *frame) {
   if (rx_header_buf_len_ < 3) {
     // no header information yet
     uint8_t to_read = 3 - rx_header_buf_len_;
+    uint32_t socket_start = millis();
     ssize_t received = this->socket_->read(&rx_header_buf_[rx_header_buf_len_], to_read);
+    uint32_t socket_duration = millis() - socket_start;
+    if (socket_duration > 0 && section_stats_) {
+      (*section_stats_)["read_packet.socket_read_header"].record_time(socket_duration);
+    }
     if (received == -1) {
       if (errno == EWOULDBLOCK || errno == EAGAIN) {
         return APIError::WOULD_BLOCK;
@@ -352,13 +367,23 @@ APIError APINoiseFrameHelper::try_read_frame_(ParsedFrame *frame) {
 
   // reserve space for body
   if (rx_buf_.size() != msg_size) {
+    uint32_t resize_start = millis();
     rx_buf_.resize(msg_size);
+    uint32_t resize_duration = millis() - resize_start;
+    if (resize_duration > 0 && section_stats_) {
+      (*section_stats_)["read_packet.buffer_resize"].record_time(resize_duration);
+    }
   }
 
   if (rx_buf_len_ < msg_size) {
     // more data to read
     uint16_t to_read = msg_size - rx_buf_len_;
+    uint32_t socket_start = millis();
     ssize_t received = this->socket_->read(&rx_buf_[rx_buf_len_], to_read);
+    uint32_t socket_duration = millis() - socket_start;
+    if (socket_duration > 0 && section_stats_) {
+      (*section_stats_)["read_packet.socket_read_body"].record_time(socket_duration);
+    }
     if (received == -1) {
       if (errno == EWOULDBLOCK || errno == EAGAIN) {
         return APIError::WOULD_BLOCK;
@@ -554,7 +579,15 @@ void APINoiseFrameHelper::send_explicit_handshake_reject_(const std::string &rea
 APIError APINoiseFrameHelper::read_packet(ReadPacketBuffer *buffer) {
   int err;
   APIError aerr;
+  uint32_t start_time, duration;
+
+  // Track state_action timing
+  start_time = millis();
   aerr = state_action_();
+  duration = millis() - start_time;
+  if (duration > 0 && section_stats_) {
+    (*section_stats_)["read_packet.state_action"].record_time(duration);
+  }
   if (aerr != APIError::OK) {
     return aerr;
   }
@@ -563,15 +596,27 @@ APIError APINoiseFrameHelper::read_packet(ReadPacketBuffer *buffer) {
     return APIError::WOULD_BLOCK;
   }
 
+  // Track frame reading timing
+  start_time = millis();
   ParsedFrame frame;
   aerr = try_read_frame_(&frame);
+  duration = millis() - start_time;
+  if (duration > 0 && section_stats_) {
+    (*section_stats_)["read_packet.try_read_frame"].record_time(duration);
+  }
   if (aerr != APIError::OK)
     return aerr;
 
+  // Track decryption timing
+  start_time = millis();
   NoiseBuffer mbuf;
   noise_buffer_init(mbuf);
   noise_buffer_set_inout(mbuf, frame.msg.data(), frame.msg.size(), frame.msg.size());
   err = noise_cipherstate_decrypt(recv_cipher_, &mbuf);
+  duration = millis() - start_time;
+  if (duration > 0 && section_stats_) {
+    (*section_stats_)["read_packet.decrypt"].record_time(duration);
+  }
   if (err != 0) {
     state_ = State::FAILED;
     HELPER_LOG("noise_cipherstate_decrypt failed: %s", noise_err_to_str(err).c_str());
@@ -831,15 +876,17 @@ APIError APIPlaintextFrameHelper::try_read_frame_(ParsedFrame *frame) {
 
   // read header
   while (!rx_header_parsed_) {
-    // Now that we know when the socket is ready, we can read up to 3 bytes
-    // into the rx_header_buf_ before we have to switch back to reading
-    // one byte at a time to ensure we don't read past the message and
-    // into the next one.
-
-    // Read directly into rx_header_buf_ at the current position
-    // Try to get to at least 3 bytes total (indicator + 2 varint bytes), then read one byte at a time
-    ssize_t received =
-        this->socket_->read(&rx_header_buf_[rx_header_buf_pos_], rx_header_buf_pos_ < 3 ? 3 - rx_header_buf_pos_ : 1);
+    uint8_t data;
+    // Reading one byte at a time is fastest in practice for ESP32 when
+    // there is no data on the wire (which is the common case).
+    // This results in faster failure detection compared to
+    // attempting to read multiple bytes at once.
+    uint32_t socket_start = millis();
+    ssize_t received = this->socket_->read(&data, 1);
+    uint32_t socket_duration = millis() - socket_start;
+    if (socket_duration > 0 && section_stats_) {
+      (*section_stats_)["read_packet.socket_read_header"].record_time(socket_duration);
+    }
     if (received == -1) {
       if (errno == EWOULDBLOCK || errno == EAGAIN) {
         return APIError::WOULD_BLOCK;
@@ -853,46 +900,51 @@ APIError APIPlaintextFrameHelper::try_read_frame_(ParsedFrame *frame) {
       return APIError::CONNECTION_CLOSED;
     }
 
-    // If this was the first read, validate the indicator byte
-    if (rx_header_buf_pos_ == 0 && received > 0) {
-      if (rx_header_buf_[0] != 0x00) {
+    // Successfully read a byte
+
+    // Process byte according to current buffer position
+    if (rx_header_buf_pos_ == 0) {  // Case 1: First byte (indicator byte)
+      if (data != 0x00) {
         state_ = State::FAILED;
-        HELPER_LOG("Bad indicator byte %u", rx_header_buf_[0]);
+        HELPER_LOG("Bad indicator byte %u", data);
         return APIError::BAD_INDICATOR;
       }
+      // We don't store the indicator byte, just increment position
+      rx_header_buf_pos_ = 1;  // Set to 1 directly
+      continue;                // Need more bytes before we can parse
     }
 
-    rx_header_buf_pos_ += received;
-
-    // Check for buffer overflow
-    if (rx_header_buf_pos_ >= sizeof(rx_header_buf_)) {
+    // Check buffer overflow before storing
+    if (rx_header_buf_pos_ == 5) {  // Case 2: Buffer would overflow (5 bytes is max allowed)
       state_ = State::FAILED;
       HELPER_LOG("Header buffer overflow");
       return APIError::BAD_DATA_PACKET;
     }
 
-    // Need at least 3 bytes total (indicator + 2 varint bytes) before trying to parse
-    if (rx_header_buf_pos_ < 3) {
-      continue;
+    // Store byte in buffer (adjust index to account for skipped indicator byte)
+    rx_header_buf_[rx_header_buf_pos_ - 1] = data;
+
+    // Increment position after storing
+    rx_header_buf_pos_++;
+
+    // Case 3: If we only have one varint byte, we need more
+    if (rx_header_buf_pos_ == 2) {  // Have read indicator + 1 byte
+      continue;                     // Need more bytes before we can parse
     }
 
     // At this point, we have at least 3 bytes total:
-    //   - Validated indicator byte (0x00) stored at position 0
+    //   - Validated indicator byte (0x00) but not stored
     //   - At least 2 bytes in the buffer for the varints
     // Buffer layout:
-    //   [0]: indicator byte (0x00)
-    //   [1-3]: Message size varint (variable length)
+    //   First 1-3 bytes: Message size varint (variable length)
     //     - 2 bytes would only allow up to 16383, which is less than noise's UINT16_MAX (65535)
     //     - 3 bytes allows up to 2097151, ensuring we support at least as much as noise
-    //   [2-5]: Message type varint (variable length)
+    //   Remaining 1-2 bytes: Message type varint (variable length)
     // We now attempt to parse both varints. If either is incomplete,
     // we'll continue reading more bytes.
 
-    // Skip indicator byte at position 0
-    uint8_t varint_pos = 1;
     uint32_t consumed = 0;
-
-    auto msg_size_varint = ProtoVarInt::parse(&rx_header_buf_[varint_pos], rx_header_buf_pos_ - varint_pos, &consumed);
+    auto msg_size_varint = ProtoVarInt::parse(&rx_header_buf_[0], rx_header_buf_pos_ - 1, &consumed);
     if (!msg_size_varint.has_value()) {
       // not enough data there yet
       continue;
@@ -906,10 +958,7 @@ APIError APIPlaintextFrameHelper::try_read_frame_(ParsedFrame *frame) {
     }
     rx_header_parsed_len_ = msg_size_varint->as_uint16();
 
-    // Move to next varint position
-    varint_pos += consumed;
-
-    auto msg_type_varint = ProtoVarInt::parse(&rx_header_buf_[varint_pos], rx_header_buf_pos_ - varint_pos, &consumed);
+    auto msg_type_varint = ProtoVarInt::parse(&rx_header_buf_[consumed], rx_header_buf_pos_ - 1 - consumed, &consumed);
     if (!msg_type_varint.has_value()) {
       // not enough data there yet
       continue;
@@ -927,13 +976,23 @@ APIError APIPlaintextFrameHelper::try_read_frame_(ParsedFrame *frame) {
 
   // reserve space for body
   if (rx_buf_.size() != rx_header_parsed_len_) {
+    uint32_t resize_start = millis();
     rx_buf_.resize(rx_header_parsed_len_);
+    uint32_t resize_duration = millis() - resize_start;
+    if (resize_duration > 0 && section_stats_) {
+      (*section_stats_)["read_packet.buffer_resize"].record_time(resize_duration);
+    }
   }
 
   if (rx_buf_len_ < rx_header_parsed_len_) {
     // more data to read
     uint16_t to_read = rx_header_parsed_len_ - rx_buf_len_;
+    uint32_t socket_start = millis();
     ssize_t received = this->socket_->read(&rx_buf_[rx_buf_len_], to_read);
+    uint32_t socket_duration = millis() - socket_start;
+    if (socket_duration > 0 && section_stats_) {
+      (*section_stats_)["read_packet.socket_read_body"].record_time(socket_duration);
+    }
     if (received == -1) {
       if (errno == EWOULDBLOCK || errno == EAGAIN) {
         return APIError::WOULD_BLOCK;
@@ -967,13 +1026,20 @@ APIError APIPlaintextFrameHelper::try_read_frame_(ParsedFrame *frame) {
 }
 APIError APIPlaintextFrameHelper::read_packet(ReadPacketBuffer *buffer) {
   APIError aerr;
+  uint32_t start_time, duration;
 
   if (state_ != State::DATA) {
     return APIError::WOULD_BLOCK;
   }
 
+  // Track frame reading timing
+  start_time = millis();
   ParsedFrame frame;
   aerr = try_read_frame_(&frame);
+  duration = millis() - start_time;
+  if (duration > 0 && section_stats_) {
+    (*section_stats_)["read_packet.try_read_frame"].record_time(duration);
+  }
   if (aerr != APIError::OK) {
     if (aerr == APIError::BAD_INDICATOR) {
       // Make sure to tell the remote that we don't

esphome/components/api/api_frame_helper.h

@@ -13,11 +13,71 @@
 
 #include "api_noise_context.h"
 #include "esphome/components/socket/socket.h"
-#include "esphome/core/application.h"
+#include <map>
+#include <string>
 
 namespace esphome {
 namespace api {
 
+// Forward declaration from api_connection.h
+class APIConnection;
+
+// Stats class definition (copied from api_connection.h to avoid circular dependency)
+class APISectionStats {
+ public:
+  APISectionStats()
+      : period_count_(0),
+        total_count_(0),
+        period_time_ms_(0),
+        total_time_ms_(0),
+        period_max_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;
+  }
+
+  // Getters for period stats
+  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 ? static_cast<float>(this->period_time_ms_) / this->period_count_ : 0.0f;
+  }
+
+  // Getters for total stats
+  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 ? static_cast<float>(this->total_time_ms_) / this->total_count_ : 0.0f;
+  }
+
+ private:
+  uint32_t period_count_;
+  uint32_t total_count_;
+  uint32_t period_time_ms_;
+  uint32_t total_time_ms_;
+  uint32_t period_max_time_ms_;
+  uint32_t total_max_time_ms_;
+};
+
 class ProtoWriteBuffer;
 
 struct ReadPacketBuffer {
@@ -86,13 +146,13 @@ class APIFrameHelper {
   }
   // Give this helper a name for logging
   void set_log_info(std::string info) { info_ = std::move(info); }
+  // Set stats collection for detailed timing
+  void set_section_stats(std::map<std::string, APISectionStats> *stats) { section_stats_ = stats; }
   virtual APIError write_protobuf_packet(uint16_t type, ProtoWriteBuffer buffer) = 0;
   // Get the frame header padding required by this protocol
   virtual uint8_t frame_header_padding() = 0;
   // Get the frame footer size required by this protocol
   virtual uint8_t frame_footer_size() = 0;
-  // Check if socket has data ready to read
-  bool is_socket_ready() const { return socket_ != nullptr && socket_->ready(); }
 
  protected:
   // Struct for holding parsed frame data
@@ -163,6 +223,9 @@ class APIFrameHelper {
 
   // Common initialization for both plaintext and noise protocols
   APIError init_common_();
+
+  // Stats collection pointer - shared from APIConnection
+  std::map<std::string, APISectionStats> *section_stats_{nullptr};
 };
 
 #ifdef USE_API_NOISE
@@ -233,14 +296,14 @@ class APIPlaintextFrameHelper : public APIFrameHelper {
  protected:
   APIError try_read_frame_(ParsedFrame *frame);
   // Fixed-size header buffer for plaintext protocol:
-  // We now store the indicator byte + the two varints.
+  // We only need space for the two varints since we validate the indicator byte separately.
   // To match noise protocol's maximum message size (UINT16_MAX = 65535), we need:
-  // 1 byte for indicator + 3 bytes for message size varint (supports up to 2097151) + 2 bytes for message type varint
+  // 3 bytes for message size varint (supports up to 2097151) + 2 bytes for message type varint
   //
   // While varints could theoretically be up to 10 bytes each for 64-bit values,
   // attempting to process messages with headers that large would likely crash the
   // ESP32 due to memory constraints.
-  uint8_t rx_header_buf_[6];  // 1 byte indicator + 5 bytes for varints (3 for size + 2 for type)
+  uint8_t rx_header_buf_[5];  // 5 bytes for varints (3 for size + 2 for type)
   uint8_t rx_header_buf_pos_ = 0;
   bool rx_header_parsed_ = false;
   uint16_t rx_header_parsed_type_ = 0;

esphome/components/api/api_server.cpp

@@ -27,7 +27,7 @@ APIServer *global_api_server = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-c
 APIServer::APIServer() { global_api_server = this; }
 
 void APIServer::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up Home Assistant API server...");
   this->setup_controller();
 
 #ifdef USE_API_NOISE
@@ -43,7 +43,7 @@ void APIServer::setup() {
   }
 #endif
 
-  this->socket_ = socket::socket_ip_loop_monitored(SOCK_STREAM, 0);  // monitored for incoming connections
+  this->socket_ = socket::socket_ip(SOCK_STREAM, 0);
   if (this->socket_ == nullptr) {
     ESP_LOGW(TAG, "Could not create socket");
     this->mark_failed();
@@ -112,20 +112,18 @@ void APIServer::setup() {
 }
 
 void APIServer::loop() {
-  // Accept new clients only if the socket has incoming connections
-  if (this->socket_->ready()) {
-    while (true) {
-      struct sockaddr_storage source_addr;
-      socklen_t addr_len = sizeof(source_addr);
-      auto sock = this->socket_->accept_loop_monitored((struct sockaddr *) &source_addr, &addr_len);
-      if (!sock)
-        break;
-      ESP_LOGD(TAG, "Accepted %s", sock->getpeername().c_str());
+  // Accept new clients
+  while (true) {
+    struct sockaddr_storage source_addr;
+    socklen_t addr_len = sizeof(source_addr);
+    auto sock = this->socket_->accept((struct sockaddr *) &source_addr, &addr_len);
+    if (!sock)
+      break;
+    ESP_LOGD(TAG, "Accepted %s", sock->getpeername().c_str());
 
-      auto *conn = new APIConnection(std::move(sock), this);
-      this->clients_.emplace_back(conn);
-      conn->start();
-    }
+    auto *conn = new APIConnection(std::move(sock), this);
+    this->clients_.emplace_back(conn);
+    conn->start();
   }
 
   // Process clients and remove disconnected ones in a single pass
@@ -157,7 +155,7 @@ void APIServer::loop() {
     const uint32_t now = millis();
     if (!this->is_connected()) {
       if (now - this->last_connected_ > this->reboot_timeout_) {
-        ESP_LOGE(TAG, "No client connected; rebooting");
+        ESP_LOGE(TAG, "No client connected to API. Rebooting...");
         App.reboot();
       }
       this->status_set_warning();

esphome/components/as3935/as3935.cpp

@@ -7,7 +7,7 @@ namespace as3935 {
 static const char *const TAG = "as3935";
 
 void AS3935Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up AS3935...");
 
   this->irq_pin_->setup();
   LOG_PIN("  IRQ Pin: ", this->irq_pin_);

esphome/components/as5600/as5600.cpp

@@ -23,7 +23,7 @@ static const uint8_t REGISTER_AGC = 0x1A;        // 8 bytes  / R
 static const uint8_t REGISTER_MAGNITUDE = 0x1B;  // 16 bytes / R
 
 void AS5600Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up AS5600...");
 
   if (!this->read_byte(REGISTER_STATUS).has_value()) {
     this->mark_failed();
@@ -91,7 +91,7 @@ void AS5600Component::dump_config() {
   LOG_I2C_DEVICE(this);
 
   if (this->is_failed()) {
-    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+    ESP_LOGE(TAG, "Communication with AS5600 failed!");
     return;
   }
 

esphome/components/as7341/as7341.cpp

@@ -8,7 +8,7 @@ namespace as7341 {
 static const char *const TAG = "as7341";
 
 void AS7341Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up AS7341...");
   LOG_I2C_DEVICE(this);
 
   // Verify device ID
@@ -38,7 +38,7 @@ void AS7341Component::dump_config() {
   ESP_LOGCONFIG(TAG, "AS7341:");
   LOG_I2C_DEVICE(this);
   if (this->is_failed()) {
-    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+    ESP_LOGE(TAG, "Communication with AS7341 failed!");
   }
   LOG_UPDATE_INTERVAL(this);
   ESP_LOGCONFIG(TAG, "  Gain: %u", get_gain());

esphome/components/at581x/at581x.cpp

@@ -71,7 +71,7 @@ bool AT581XComponent::i2c_read_reg(uint8_t addr, uint8_t &data) {
   return this->read_register(addr, &data, 1) == esphome::i2c::NO_ERROR;
 }
 
-void AT581XComponent::setup() { ESP_LOGCONFIG(TAG, "Running setup"); }
+void AT581XComponent::setup() { ESP_LOGCONFIG(TAG, "Setting up AT581X..."); }
 void AT581XComponent::dump_config() { LOG_I2C_DEVICE(this); }
 #define ARRAY_SIZE(X) (sizeof(X) / sizeof((X)[0]))
 bool AT581XComponent::i2c_write_config() {

esphome/components/atm90e26/atm90e26.cpp

@@ -41,7 +41,7 @@ void ATM90E26Component::update() {
 }
 
 void ATM90E26Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up ATM90E26 Component...");
   this->spi_setup();
 
   uint16_t mmode = 0x422;  // default values for everything but L/N line current gains
@@ -135,7 +135,7 @@ void ATM90E26Component::dump_config() {
   ESP_LOGCONFIG("", "ATM90E26:");
   LOG_PIN("  CS Pin: ", this->cs_);
   if (this->is_failed()) {
-    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+    ESP_LOGE(TAG, "Communication with ATM90E26 failed!");
   }
   LOG_UPDATE_INTERVAL(this);
   LOG_SENSOR("  ", "Voltage A", this->voltage_sensor_);

esphome/components/atm90e32/atm90e32.cpp

@@ -108,7 +108,7 @@ void ATM90E32Component::update() {
 }
 
 void ATM90E32Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up ATM90E32 Component...");
   this->spi_setup();
 
   uint16_t mmode0 = 0x87;  // 3P4W 50Hz
@@ -217,7 +217,7 @@ void ATM90E32Component::dump_config() {
   ESP_LOGCONFIG("", "ATM90E32:");
   LOG_PIN("  CS Pin: ", this->cs_);
   if (this->is_failed()) {
-    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+    ESP_LOGE(TAG, "Communication with ATM90E32 failed!");
   }
   LOG_UPDATE_INTERVAL(this);
   LOG_SENSOR("  ", "Voltage A", this->phase_[PHASEA].voltage_sensor_);

esphome/components/axs15231/touchscreen/axs15231_touchscreen.cpp

@@ -17,7 +17,7 @@ constexpr static const uint8_t AXS_READ_TOUCHPAD[11] = {0xb5, 0xab, 0xa5, 0x5a,
   }
 
 void AXS15231Touchscreen::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up AXS15231 Touchscreen...");
   if (this->reset_pin_ != nullptr) {
     this->reset_pin_->setup();
     this->reset_pin_->digital_write(false);

esphome/components/beken_spi_led_strip/led_strip.cpp

@@ -119,7 +119,7 @@ void spi_dma_tx_finish_callback(unsigned int param) {
 }
 
 void BekenSPILEDStripLightOutput::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up Beken SPI LED Strip...");
 
   size_t buffer_size = this->get_buffer_size_();
   size_t dma_buffer_size = (buffer_size * 8) + (2 * 64);

esphome/components/bh1750/bh1750.cpp

@@ -38,7 +38,7 @@ MTreg:
 */
 
 void BH1750Sensor::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup for '%s'", this->name_.c_str());
+  ESP_LOGCONFIG(TAG, "Setting up BH1750 '%s'...", this->name_.c_str());
   uint8_t turn_on = BH1750_COMMAND_POWER_ON;
   if (this->write(&turn_on, 1) != i2c::ERROR_OK) {
     this->mark_failed();
@@ -118,7 +118,7 @@ void BH1750Sensor::dump_config() {
   LOG_SENSOR("", "BH1750", this);
   LOG_I2C_DEVICE(this);
   if (this->is_failed()) {
-    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL_FOR, this->get_name().c_str());
+    ESP_LOGE(TAG, "Communication with BH1750 failed!");
   }
 
   LOG_UPDATE_INTERVAL(this);

esphome/components/bluetooth_proxy/bluetooth_proxy.cpp

@@ -4,9 +4,6 @@
 #include "esphome/core/macros.h"
 #include "esphome/core/application.h"
 
-#include <algorithm>
-#include <cinttypes>
-
 #ifdef USE_ESP32
 
 namespace esphome {
@@ -49,16 +46,9 @@ bool BluetoothProxy::parse_device(const esp32_ble_tracker::ESPBTDevice &device)
   if (!api::global_api_server->is_connected() || this->api_connection_ == nullptr || this->raw_advertisements_)
     return false;
 
-  // Measure time for processing single device
-  const uint32_t start_time = millis();
-
   ESP_LOGV(TAG, "Proxying packet from %s - %s. RSSI: %d dB", device.get_name().c_str(), device.address_str().c_str(),
            device.get_rssi());
   this->send_api_packet_(device);
-
-  const uint32_t duration = millis() - start_time;
-  this->section_stats_["parse_device"].record_time(duration);
-
   return true;
 }
 
@@ -72,9 +62,6 @@ bool BluetoothProxy::parse_devices(esp_ble_gap_cb_param_t::ble_scan_result_evt_p
   if (!api::global_api_server->is_connected() || this->api_connection_ == nullptr || !this->raw_advertisements_)
     return false;
 
-  // Measure time for processing batch of devices
-  const uint32_t start_time = millis();
-
   // Get the batch buffer reference
   auto &batch_buffer = get_batch_buffer();
 
@@ -106,9 +93,6 @@ bool BluetoothProxy::parse_devices(esp_ble_gap_cb_param_t::ble_scan_result_evt_p
     this->flush_pending_advertisements();
   }
 
-  const uint32_t duration = millis() - start_time;
-  this->section_stats_["parse_devices"].record_time(duration);
-
   return true;
 }
 
@@ -117,52 +101,12 @@ void BluetoothProxy::flush_pending_advertisements() {
   if (batch_buffer.empty() || !api::global_api_server->is_connected() || this->api_connection_ == nullptr)
     return;
 
-  // Measure time for flushing advertisements
-  const uint32_t start_time = millis();
-
-  // Track the batch size for analysis
-  size_t batch_size = batch_buffer.size();
-
-  // Measure swap operation
-  uint32_t swap_start = millis();
   api::BluetoothLERawAdvertisementsResponse resp;
   resp.advertisements.swap(batch_buffer);
-  uint32_t swap_duration = millis() - swap_start;
-  if (swap_duration > 0) {
-    this->section_stats_["flush_swap"].record_time(swap_duration);
-  }
-
-  // Measure API send operation
-  uint32_t send_start = millis();
   this->api_connection_->send_bluetooth_le_raw_advertisements_response(resp);
-  uint32_t send_duration = millis() - send_start;
-  this->section_stats_["flush_api_send"].record_time(send_duration);
-
-  const uint32_t duration = millis() - start_time;
-  this->section_stats_["flush_advertisements"].record_time(duration);
-
-  // Log if this was a particularly slow flush
-  if (duration > 10) {
-    ESP_LOGW(TAG, "Slow flush: %dms for %d advertisements", duration, batch_size);
-  }
-
-  // Track average advertisements per flush
-  static uint32_t total_ads_flushed = 0;
-  static uint32_t total_flushes = 0;
-  total_ads_flushed += batch_size;
-  total_flushes++;
-
-  if (total_flushes % 100 == 0) {
-    float avg_ads_per_flush = static_cast<float>(total_ads_flushed) / total_flushes;
-    ESP_LOGD(TAG, "Avg advertisements per flush: %.2f (total: %d ads in %d flushes)", avg_ads_per_flush,
-             total_ads_flushed, total_flushes);
-  }
 }
 
 void BluetoothProxy::send_api_packet_(const esp32_ble_tracker::ESPBTDevice &device) {
-  // Measure time for sending API packet
-  const uint32_t start_time = millis();
-
   api::BluetoothLEAdvertisementResponse resp;
   resp.address = device.address_uint64();
   resp.address_type = device.get_address_type();
@@ -198,9 +142,6 @@ void BluetoothProxy::send_api_packet_(const esp32_ble_tracker::ESPBTDevice &devi
   }
 
   this->api_connection_->send_bluetooth_le_advertisement(resp);
-
-  const uint32_t duration = millis() - start_time;
-  this->section_stats_["send_api_packet"].record_time(duration);
 }
 
 void BluetoothProxy::dump_config() {
@@ -208,8 +149,6 @@ void BluetoothProxy::dump_config() {
   ESP_LOGCONFIG(TAG, "  Active: %s", YESNO(this->active_));
   ESP_LOGCONFIG(TAG, "  Connections: %d", this->connections_.size());
   ESP_LOGCONFIG(TAG, "  Raw advertisements: %s", YESNO(this->raw_advertisements_));
-  ESP_LOGCONFIG(TAG, "  Stats enabled: %s", YESNO(this->stats_enabled_));
-  ESP_LOGCONFIG(TAG, "  Stats interval: %" PRIu32 "ms", this->stats_log_interval_);
 }
 
 int BluetoothProxy::get_bluetooth_connections_free() {
@@ -227,9 +166,6 @@ int BluetoothProxy::get_bluetooth_connections_free() {
 }
 
 void BluetoothProxy::loop() {
-  // Measure total time for entire loop function
-  const uint32_t loop_start_time = millis();
-
   if (!api::global_api_server->is_connected() || this->api_connection_ == nullptr) {
     for (auto *connection : this->connections_) {
       if (connection->get_address() != 0) {
@@ -239,28 +175,17 @@ void BluetoothProxy::loop() {
     return;
   }
 
-  const uint32_t now = millis();
-  uint32_t start_time;
-  uint32_t duration;
-
-  // Section: Flush advertisements
+  // Flush any pending BLE advertisements that have been accumulated but not yet sent
   if (this->raw_advertisements_) {
     static uint32_t last_flush_time = 0;
-    uint32_t app_time = App.get_loop_component_start_time();
+    uint32_t now = App.get_loop_component_start_time();
 
     // Flush accumulated advertisements every 100ms
-    if (app_time - last_flush_time >= 100) {
-      start_time = millis();
+    if (now - last_flush_time >= 100) {
       this->flush_pending_advertisements();
-      duration = millis() - start_time;
-      this->section_stats_["loop_flush_ads"].record_time(duration);
-      last_flush_time = app_time;
+      last_flush_time = now;
     }
   }
-
-  // Section: Service discovery
-  start_time = millis();
-  bool did_service_discovery = false;
   for (auto *connection : this->connections_) {
     if (connection->send_service_ == connection->service_count_) {
       connection->send_service_ = DONE_SENDING_SERVICES;
@@ -269,9 +194,7 @@ void BluetoothProxy::loop() {
           connection->connection_type_ == espbt::ConnectionType::V3_WITHOUT_CACHE) {
         connection->release_services();
       }
-      did_service_discovery = true;
     } else if (connection->send_service_ >= 0) {
-      did_service_discovery = true;
       esp_gattc_service_elem_t service_result;
       uint16_t service_count = 1;
       esp_gatt_status_t service_status =
@@ -380,27 +303,6 @@ void BluetoothProxy::loop() {
       this->api_connection_->send_bluetooth_gatt_get_services_response(resp);
     }
   }
-
-  if (did_service_discovery) {
-    duration = millis() - start_time;
-    this->section_stats_["service_discovery"].record_time(duration);
-  }
-
-  // Log stats periodically
-  if (this->stats_enabled_) {
-    // If next_stats_log_ is 0, initialize it
-    if (this->next_stats_log_ == 0) {
-      this->next_stats_log_ = now + this->stats_log_interval_;
-    } else if (now >= this->next_stats_log_) {
-      this->log_section_stats_();
-      this->reset_section_stats_();
-      this->next_stats_log_ = now + this->stats_log_interval_;
-    }
-  }
-
-  // Record total loop execution time
-  const uint32_t total_loop_duration = millis() - loop_start_time;
-  this->section_stats_["total_loop"].record_time(total_loop_duration);
 }
 
 esp32_ble_tracker::AdvertisementParserType BluetoothProxy::get_advertisement_parser_type() {
@@ -435,9 +337,6 @@ BluetoothConnection *BluetoothProxy::get_connection_(uint64_t address, bool rese
 }
 
 void BluetoothProxy::bluetooth_device_request(const api::BluetoothDeviceRequest &msg) {
-  // Measure time for processing device requests
-  const uint32_t start_time = millis();
-
   switch (msg.request_type) {
     case api::enums::BLUETOOTH_DEVICE_REQUEST_TYPE_CONNECT_V3_WITH_CACHE:
     case api::enums::BLUETOOTH_DEVICE_REQUEST_TYPE_CONNECT_V3_WITHOUT_CACHE:
@@ -559,9 +458,6 @@ void BluetoothProxy::bluetooth_device_request(const api::BluetoothDeviceRequest
       break;
     }
   }
-
-  const uint32_t duration = millis() - start_time;
-  this->section_stats_["device_request"].record_time(duration);
 }
 
 void BluetoothProxy::bluetooth_gatt_read(const api::BluetoothGATTReadRequest &msg) {
@@ -744,74 +640,6 @@ void BluetoothProxy::bluetooth_scanner_set_mode(bool active) {
       true);  // Set this to true to automatically start scanning again when it has cleaned up.
 }
 
-void BluetoothProxy::log_section_stats_() {
-  const char *STATS_TAG = "bluetooth_proxy.stats";
-  ESP_LOGI(STATS_TAG,
-           "Logging Bluetooth Proxy section stats now (current time: %" PRIu32 ", scheduled time: %" PRIu32 ")",
-           millis(), this->next_stats_log_);
-  ESP_LOGI(STATS_TAG, "Stats collection status: enabled=%d, sections=%zu", this->stats_enabled_,
-           this->section_stats_.size());
-
-  // Check if we have minimal data
-  bool has_data = false;
-  for (const auto &it : this->section_stats_) {
-    if (it.second.get_period_count() > 0) {
-      has_data = true;
-      break;
-    }
-  }
-
-  if (!has_data) {
-    ESP_LOGI(STATS_TAG, "No stats data collected in this period");
-    return;
-  }
-
-  ESP_LOGI(STATS_TAG, "Bluetooth Proxy Section Runtime Statistics");
-  ESP_LOGI(STATS_TAG, "Period stats (last %" PRIu32 "ms):", this->stats_log_interval_);
-
-  // First collect stats we want to display
-  std::vector<std::pair<std::string, const BluetoothProxySectionStats *>> stats_to_display;
-
-  for (const auto &it : this->section_stats_) {
-    const BluetoothProxySectionStats &stats = it.second;
-    if (stats.get_period_count() > 0) {
-      stats_to_display.push_back({it.first, &stats});
-    }
-  }
-
-  // Sort by period runtime (descending)
-  std::sort(stats_to_display.begin(), stats_to_display.end(), [](const auto &a, const auto &b) {
-    return a.second->get_period_time_ms() > b.second->get_period_time_ms();
-  });
-
-  // Log top sections by period runtime
-  for (const auto &it : stats_to_display) {
-    const std::string &section_name = it.first;
-    const BluetoothProxySectionStats &stats = *it.second;
-
-    ESP_LOGI(STATS_TAG, "  %-25s: count=%-6" PRIu32 " runtime=%-8" PRIu32 "ms avg=%-6.2fms max=%-6" PRIu32 "ms",
-             section_name.c_str(), stats.get_period_count(), stats.get_period_time_ms(), stats.get_period_avg_time_ms(),
-             stats.get_period_max_time_ms());
-  }
-
-  // Log total accumulated stats
-  ESP_LOGI(STATS_TAG, "Total accumulated stats:");
-  for (const auto &it : stats_to_display) {
-    const std::string &section_name = it.first;
-    const BluetoothProxySectionStats &stats = *it.second;
-
-    ESP_LOGI(STATS_TAG, "  %-25s: count=%-8" PRIu32 " runtime=%-10" PRIu32 "ms avg=%-6.2fms max=%-6" PRIu32 "ms",
-             section_name.c_str(), stats.get_total_count(), stats.get_total_time_ms(), stats.get_total_avg_time_ms(),
-             stats.get_total_max_time_ms());
-  }
-}
-
-void BluetoothProxy::reset_section_stats_() {
-  for (auto &it : this->section_stats_) {
-    it.second.reset_period_stats();
-  }
-}
-
 BluetoothProxy *global_bluetooth_proxy = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
 }  // namespace bluetooth_proxy

esphome/components/bluetooth_proxy/bluetooth_proxy.h

@@ -4,7 +4,6 @@
 
 #include <map>
 #include <vector>
-#include <string>
 
 #include "esphome/components/api/api_connection.h"
 #include "esphome/components/api/api_pb2.h"
@@ -13,8 +12,6 @@
 #include "esphome/core/automation.h"
 #include "esphome/core/component.h"
 #include "esphome/core/defines.h"
-#include "esphome/core/helpers.h"
-#include "esphome/core/log.h"
 
 #include "bluetooth_connection.h"
 
@@ -28,62 +25,6 @@ static const esp_err_t ESP_GATT_NOT_CONNECTED = -1;
 
 using namespace esp32_ble_client;
 
-// Stats class for tracking section performance
-class BluetoothProxySectionStats {
- public:
-  BluetoothProxySectionStats()
-      : period_count_(0),
-        total_count_(0),
-        period_time_ms_(0),
-        total_time_ms_(0),
-        period_max_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;
-  }
-
-  // Getters for period stats
-  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 ? static_cast<float>(this->period_time_ms_) / this->period_count_ : 0.0f;
-  }
-
-  // Getters for total stats
-  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 ? static_cast<float>(this->total_time_ms_) / this->total_count_ : 0.0f;
-  }
-
- private:
-  uint32_t period_count_;
-  uint32_t total_count_;
-  uint32_t period_time_ms_;
-  uint32_t total_time_ms_;
-  uint32_t period_max_time_ms_;
-  uint32_t total_max_time_ms_;
-};
-
 // Legacy versions:
 // Version 1: Initial version without active connections
 // Version 2: Support for active connections
@@ -198,14 +139,6 @@ class BluetoothProxy : public esp32_ble_tracker::ESPBTDeviceListener, public Com
   std::vector<BluetoothConnection *> connections_{};
   api::APIConnection *api_connection_{nullptr};
   bool raw_advertisements_{false};
-
-  // Performance statistics tracking
-  std::map<std::string, BluetoothProxySectionStats> section_stats_;
-  uint32_t stats_log_interval_{60000};  // 60 seconds default
-  uint32_t next_stats_log_{0};
-  bool stats_enabled_{true};
-  void log_section_stats_();
-  void reset_section_stats_();
 };
 
 extern BluetoothProxy *global_bluetooth_proxy;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)

esphome/components/bme280_base/bme280_base.cpp

@@ -88,7 +88,7 @@ const char *oversampling_to_str(BME280Oversampling oversampling) {  // NOLINT
 }
 
 void BME280Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up BME280...");
   uint8_t chip_id = 0;
 
   // Mark as not failed before initializing. Some devices will turn off sensors to save on batteries
@@ -182,7 +182,7 @@ void BME280Component::dump_config() {
   ESP_LOGCONFIG(TAG, "BME280:");
   switch (this->error_code_) {
     case COMMUNICATION_FAILED:
-      ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+      ESP_LOGE(TAG, "Communication with BME280 failed!");
       break;
     case WRONG_CHIP_ID:
       ESP_LOGE(TAG, "BME280 has wrong chip ID! Is it a BME280?");

esphome/components/bme680/bme680.cpp

@@ -71,7 +71,7 @@ static const char *iir_filter_to_str(BME680IIRFilter filter) {
 }
 
 void BME680Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up BME680...");
   uint8_t chip_id;
   if (!this->read_byte(BME680_REGISTER_CHIPID, &chip_id) || chip_id != 0x61) {
     this->mark_failed();
@@ -215,7 +215,7 @@ void BME680Component::dump_config() {
   ESP_LOGCONFIG(TAG, "BME680:");
   LOG_I2C_DEVICE(this);
   if (this->is_failed()) {
-    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+    ESP_LOGE(TAG, "Communication with BME680 failed!");
   }
   ESP_LOGCONFIG(TAG, "  IIR Filter: %s", iir_filter_to_str(this->iir_filter_));
   LOG_UPDATE_INTERVAL(this);
@@ -307,7 +307,7 @@ void BME680Component::read_data_() {
       this->humidity_sensor_->publish_state(NAN);
     if (this->gas_resistance_sensor_ != nullptr)
       this->gas_resistance_sensor_->publish_state(NAN);
-    ESP_LOGW(TAG, ESP_LOG_MSG_COMM_FAIL);
+    ESP_LOGW(TAG, "Communication with BME680 failed!");
     this->status_set_warning();
     return;
   }

esphome/components/bme680_bsec/bme680_bsec.cpp

@@ -15,7 +15,7 @@ std::vector<BME680BSECComponent *>
 uint8_t BME680BSECComponent::work_buffer_[BSEC_MAX_WORKBUFFER_SIZE] = {0};
 
 void BME680BSECComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup for '%s'", this->device_id_.c_str());
+  ESP_LOGCONFIG(TAG, "Setting up BME680(%s) via BSEC...", this->device_id_.c_str());
 
   uint8_t new_idx = BME680BSECComponent::instances.size();
   BME680BSECComponent::instances.push_back(this);

esphome/components/bme68x_bsec2/bme68x_bsec2.cpp

@@ -21,7 +21,7 @@ static const char *const TAG = "bme68x_bsec2.sensor";
 static const std::string IAQ_ACCURACY_STATES[4] = {"Stabilizing", "Uncertain", "Calibrating", "Calibrated"};
 
 void BME68xBSEC2Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up BME68X via BSEC2...");
 
   this->bsec_status_ = bsec_init_m(&this->bsec_instance_);
   if (this->bsec_status_ != BSEC_OK) {

esphome/components/bmi160/bmi160.cpp

@@ -119,7 +119,7 @@ const float GRAVITY_EARTH = 9.80665f;
 void BMI160Component::internal_setup_(int stage) {
   switch (stage) {
     case 0:
-      ESP_LOGCONFIG(TAG, "Running setup");
+      ESP_LOGCONFIG(TAG, "Setting up BMI160...");
       uint8_t chipid;
       if (!this->read_byte(BMI160_REGISTER_CHIPID, &chipid) || (chipid != 0b11010001)) {
         this->mark_failed();
@@ -189,7 +189,7 @@ void BMI160Component::dump_config() {
   ESP_LOGCONFIG(TAG, "BMI160:");
   LOG_I2C_DEVICE(this);
   if (this->is_failed()) {
-    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+    ESP_LOGE(TAG, "Communication with BMI160 failed!");
   }
   LOG_UPDATE_INTERVAL(this);
   LOG_SENSOR("  ", "Acceleration X", this->accel_x_sensor_);

esphome/components/bmp085/bmp085.cpp

@@ -20,7 +20,7 @@ void BMP085Component::update() {
   this->set_timeout("temperature", 5, [this]() { this->read_temperature_(); });
 }
 void BMP085Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up BMP085...");
   uint8_t data[22];
   if (!this->read_bytes(BMP085_REGISTER_AC1_H, data, 22)) {
     this->mark_failed();

esphome/components/bmp280_base/bmp280_base.cpp

@@ -57,7 +57,7 @@ static const char *iir_filter_to_str(BMP280IIRFilter filter) {
 }
 
 void BMP280Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up BMP280...");
   uint8_t chip_id = 0;
 
   // Read the chip id twice, to work around a bug where the first read is 0.
@@ -132,7 +132,7 @@ void BMP280Component::dump_config() {
   ESP_LOGCONFIG(TAG, "BMP280:");
   switch (this->error_code_) {
     case COMMUNICATION_FAILED:
-      ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+      ESP_LOGE(TAG, "Communication with BMP280 failed!");
       break;
     case WRONG_CHIP_ID:
       ESP_LOGE(TAG, "BMP280 has wrong chip ID! Is it a BME280?");

esphome/components/bmp3xx_base/bmp3xx_base.cpp

@@ -70,7 +70,7 @@ static const LogString *iir_filter_to_str(IIRFilter filter) {
 
 void BMP3XXComponent::setup() {
   this->error_code_ = NONE;
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up BMP3XX...");
   // Call the Device base class "initialise" function
   if (!reset()) {
     ESP_LOGE(TAG, "Failed to reset BMP3XX...");
@@ -154,7 +154,7 @@ void BMP3XXComponent::dump_config() {
     case NONE:
       break;
     case ERROR_COMMUNICATION_FAILED:
-      ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+      ESP_LOGE(TAG, "Communication with BMP3XX failed!");
       break;
     case ERROR_WRONG_CHIP_ID:
       ESP_LOGE(

esphome/components/bmp581/bmp581.cpp

@@ -122,7 +122,7 @@ void BMP581Component::setup() {
    */
 
   this->error_code_ = NONE;
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up BMP581...");
 
   ////////////////////
   // 1) Soft reboot //

esphome/components/bp1658cj/bp1658cj.cpp

@@ -15,7 +15,7 @@ static const uint8_t BP1658CJ_ADDR_START_5CH = 0x30;
 static const uint8_t BP1658CJ_DELAY = 2;
 
 void BP1658CJ::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up BP1658CJ Output Component...");
   this->data_pin_->setup();
   this->data_pin_->digital_write(false);
   this->clock_pin_->setup();

esphome/components/bp5758d/bp5758d.cpp

@@ -20,7 +20,7 @@ static const uint8_t BP5758D_ALL_DATA_CHANNEL_ENABLEMENT = 0b00011111;
 static const uint8_t BP5758D_DELAY = 2;
 
 void BP5758D::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up BP5758D Output Component...");
   this->data_pin_->setup();
   this->data_pin_->digital_write(false);
   delayMicroseconds(BP5758D_DELAY);

esphome/components/canbus/canbus.cpp

@@ -7,7 +7,7 @@ namespace canbus {
 static const char *const TAG = "canbus";
 
 void Canbus::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up Canbus...");
   if (!this->setup_internal()) {
     ESP_LOGE(TAG, "setup error!");
     this->mark_failed();

esphome/components/cap1188/cap1188.cpp

@@ -8,7 +8,7 @@ namespace cap1188 {
 static const char *const TAG = "cap1188";
 
 void CAP1188Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up CAP1188...");
 
   // Reset device using the reset pin
   if (this->reset_pin_ != nullptr) {

esphome/components/captive_portal/captive_portal.cpp

@@ -29,7 +29,7 @@ void CaptivePortal::handle_config(AsyncWebServerRequest *request) {
 void CaptivePortal::handle_wifisave(AsyncWebServerRequest *request) {
   std::string ssid = request->arg("ssid").c_str();
   std::string psk = request->arg("psk").c_str();
-  ESP_LOGI(TAG, "Requested WiFi Settings Change:");
+  ESP_LOGI(TAG, "Captive Portal Requested WiFi Settings Change:");
   ESP_LOGI(TAG, "  SSID='%s'", ssid.c_str());
   ESP_LOGI(TAG, "  Password=" LOG_SECRET("'%s'"), psk.c_str());
   wifi::global_wifi_component->save_wifi_sta(ssid, psk);

esphome/components/ccs811/ccs811.cpp

@@ -163,7 +163,7 @@ void CCS811Component::dump_config() {
   if (this->is_failed()) {
     switch (this->error_code_) {
       case COMMUNICATION_FAILED:
-        ESP_LOGW(TAG, ESP_LOG_MSG_COMM_FAIL);
+        ESP_LOGW(TAG, "Communication failed! Is the sensor connected?");
         break;
       case INVALID_ID:
         ESP_LOGW(TAG, "Sensor reported an invalid ID. Is this a CCS811?");

esphome/components/cd74hc4067/cd74hc4067.cpp

@@ -10,7 +10,7 @@ static const char *const TAG = "cd74hc4067";
 float CD74HC4067Component::get_setup_priority() const { return setup_priority::DATA; }
 
 void CD74HC4067Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up CD74HC4067...");
 
   this->pin_s0_->setup();
   this->pin_s1_->setup();

esphome/components/ch422g/ch422g.cpp

@@ -14,7 +14,7 @@ static const uint8_t CH422G_REG_OUT_UPPER = 0x23;    // write reg for output bit
 static const char *const TAG = "ch422g";
 
 void CH422GComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up CH422G...");
   // set outputs before mode
   this->write_outputs_();
   // Set mode and check for errors
@@ -37,7 +37,7 @@ void CH422GComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "CH422G:");
   LOG_I2C_DEVICE(this)
   if (this->is_failed()) {
-    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+    ESP_LOGE(TAG, "Communication with CH422G failed!");
   }
 }
 

esphome/components/chsc6x/chsc6x_touchscreen.cpp

@@ -4,7 +4,7 @@ namespace esphome {
 namespace chsc6x {
 
 void CHSC6XTouchscreen::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up CHSC6X Touchscreen...");
   if (this->interrupt_pin_ != nullptr) {
     this->interrupt_pin_->setup();
     this->attach_interrupt_(this->interrupt_pin_, gpio::INTERRUPT_FALLING_EDGE);

esphome/components/cm1106/cm1106.cpp

@@ -20,10 +20,10 @@ uint8_t cm1106_checksum(const uint8_t *response, size_t len) {
 }
 
 void CM1106Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up CM1106...");
   uint8_t response[8] = {0};
   if (!this->cm1106_write_command_(C_M1106_CMD_GET_CO2, sizeof(C_M1106_CMD_GET_CO2), response, sizeof(response))) {
-    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+    ESP_LOGE(TAG, "Communication with CM1106 failed!");
     this->mark_failed();
     return;
   }
@@ -104,7 +104,7 @@ void CM1106Component::dump_config() {
   LOG_SENSOR("  ", "CO2", this->co2_sensor_);
   this->check_uart_settings(9600);
   if (this->is_failed()) {
-    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+    ESP_LOGE(TAG, "Communication with CM1106 failed!");
   }
 }
 

esphome/components/cs5460a/cs5460a.cpp

@@ -52,7 +52,7 @@ bool CS5460AComponent::softreset_() {
 }
 
 void CS5460AComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up CS5460A...");
 
   float current_full_scale = (pga_gain_ == CS5460A_PGA_GAIN_10X) ? 0.25 : 0.10;
   float voltage_full_scale = 0.25;

esphome/components/cse7761/cse7761.cpp

@@ -42,7 +42,7 @@ static const uint8_t CSE7761_CMD_ENABLE_WRITE = 0xE5;  // Enable write operation
 enum CSE7761 { RMS_IAC, RMS_IBC, RMS_UC, POWER_PAC, POWER_PBC, POWER_SC, ENERGY_AC, ENERGY_BC };
 
 void CSE7761Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up CSE7761...");
   this->write_(CSE7761_SPECIAL_COMMAND, CSE7761_CMD_RESET);
   uint16_t syscon = this->read_(0x00, 2);  // Default 0x0A04
   if ((0x0A04 == syscon) && this->chip_init_()) {
@@ -57,7 +57,7 @@ void CSE7761Component::setup() {
 void CSE7761Component::dump_config() {
   ESP_LOGCONFIG(TAG, "CSE7761:");
   if (this->is_failed()) {
-    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+    ESP_LOGE(TAG, "Communication with CSE7761 failed!");
   }
   LOG_UPDATE_INTERVAL(this);
   this->check_uart_settings(38400, 1, uart::UART_CONFIG_PARITY_EVEN, 8);

esphome/components/cst226/touchscreen/cst226_touchscreen.cpp

@@ -6,7 +6,7 @@ namespace cst226 {
 static const char *const TAG = "cst226.touchscreen";
 
 void CST226Touchscreen::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up CST226 Touchscreen...");
   if (this->reset_pin_ != nullptr) {
     this->reset_pin_->setup();
     this->reset_pin_->digital_write(true);

esphome/components/cst816/touchscreen/cst816_touchscreen.cpp

@@ -38,7 +38,7 @@ void CST816Touchscreen::continue_setup_() {
 }
 
 void CST816Touchscreen::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up CST816 Touchscreen...");
   if (this->reset_pin_ != nullptr) {
     this->reset_pin_->setup();
     this->reset_pin_->digital_write(true);

esphome/components/dac7678/dac7678_output.cpp

@@ -20,7 +20,7 @@ static const uint8_t DAC7678_REG_INTERNAL_REF_0 = 0x80;
 static const uint8_t DAC7678_REG_INTERNAL_REF_1 = 0x90;
 
 void DAC7678Output::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up DAC7678OutputComponent...");
 
   ESP_LOGV(TAG, "Resetting device...");
 

esphome/components/dallas_temp/dallas_temp.cpp

@@ -70,7 +70,7 @@ bool DallasTemperatureSensor::read_scratch_pad_() {
 }
 
 void DallasTemperatureSensor::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "setting up Dallas temperature sensor...");
   if (!this->check_address_())
     return;
   if (!this->read_scratch_pad_())
@@ -80,7 +80,7 @@ void DallasTemperatureSensor::setup() {
 
   if ((this->address_ & 0xff) == DALLAS_MODEL_DS18S20) {
     // DS18S20 doesn't support resolution.
-    ESP_LOGW(TAG, "DS18S20 doesn't support setting resolution");
+    ESP_LOGW(TAG, "DS18S20 doesn't support setting resolution.");
     return;
   }
 
@@ -125,6 +125,7 @@ bool DallasTemperatureSensor::check_scratch_pad_() {
             crc8(this->scratch_pad_, 8));
 #endif
   if (!chksum_validity) {
+    ESP_LOGW(TAG, "'%s' - Scratch pad checksum invalid!", this->get_name().c_str());
     this->status_set_warning("scratch pad checksum invalid");
     ESP_LOGD(TAG, "Scratch pad: %02X.%02X.%02X.%02X.%02X.%02X.%02X.%02X.%02X (%02X)", this->scratch_pad_[0],
              this->scratch_pad_[1], this->scratch_pad_[2], this->scratch_pad_[3], this->scratch_pad_[4],

esphome/components/deep_sleep/deep_sleep_component.cpp

@@ -10,20 +10,20 @@ static const char *const TAG = "deep_sleep";
 bool global_has_deep_sleep = false;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
 void DeepSleepComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up Deep Sleep...");
   global_has_deep_sleep = true;
 
   const optional<uint32_t> run_duration = get_run_duration_();
   if (run_duration.has_value()) {
-    ESP_LOGI(TAG, "Scheduling in %" PRIu32 " ms", *run_duration);
+    ESP_LOGI(TAG, "Scheduling Deep Sleep to start in %" PRIu32 " ms", *run_duration);
     this->set_timeout(*run_duration, [this]() { this->begin_sleep(); });
   } else {
-    ESP_LOGD(TAG, "Not scheduling; no run duration configured");
+    ESP_LOGD(TAG, "Not scheduling Deep Sleep, as no run duration is configured.");
   }
 }
 
 void DeepSleepComponent::dump_config() {
-  ESP_LOGCONFIG(TAG, "Deep sleep:");
+  ESP_LOGCONFIG(TAG, "Setting up Deep Sleep...");
   if (this->sleep_duration_.has_value()) {
     uint32_t duration = *this->sleep_duration_ / 1000;
     ESP_LOGCONFIG(TAG, "  Sleep Duration: %" PRIu32 " ms", duration);
@@ -57,7 +57,7 @@ void DeepSleepComponent::begin_sleep(bool manual) {
     return;
   }
 
-  ESP_LOGI(TAG, "Beginning sleep");
+  ESP_LOGI(TAG, "Beginning Deep Sleep");
   if (this->sleep_duration_.has_value()) {
     ESP_LOGI(TAG, "Sleeping for %" PRId64 "us", *this->sleep_duration_);
   }

esphome/components/deep_sleep/deep_sleep_esp32.cpp

@@ -59,7 +59,7 @@ bool DeepSleepComponent::prepare_to_sleep_() {
     // Defer deep sleep until inactive
     if (!this->next_enter_deep_sleep_) {
       this->status_set_warning();
-      ESP_LOGW(TAG, "Waiting for wakeup pin state change");
+      ESP_LOGW(TAG, "Waiting wakeup pin state change to enter deep sleep...");
     }
     this->next_enter_deep_sleep_ = true;
     return false;

esphome/components/demo/__init__.py

@@ -1,22 +1,14 @@
 import esphome.codegen as cg
 from esphome.components import (
-    alarm_control_panel,
     binary_sensor,
-    button,
     climate,
     cover,
-    datetime,
-    event,
     fan,
     light,
-    lock,
     number,
-    select,
     sensor,
     switch,
-    text,
     text_sensor,
-    valve,
 )
 import esphome.config_validation as cv
 from esphome.const import (
@@ -28,9 +20,7 @@ from esphome.const import (
     CONF_INVERTED,
     CONF_MAX_VALUE,
     CONF_MIN_VALUE,
-    CONF_MODE,
     CONF_NAME,
-    CONF_OPTIONS,
     CONF_OUTPUT_ID,
     CONF_SENSORS,
     CONF_STATE_CLASS,
@@ -41,11 +31,9 @@ from esphome.const import (
     CONF_UNIT_OF_MEASUREMENT,
     DEVICE_CLASS_ENERGY,
     DEVICE_CLASS_HUMIDITY,
-    DEVICE_CLASS_IDENTIFY,
     DEVICE_CLASS_MOISTURE,
     DEVICE_CLASS_MOTION,
     DEVICE_CLASS_TEMPERATURE,
-    DEVICE_CLASS_UPDATE,
     ICON_BLUETOOTH,
     ICON_BLUR,
     ICON_THERMOMETER,
@@ -57,68 +45,38 @@ from esphome.const import (
 )
 
 AUTO_LOAD = [
-    "alarm_control_panel",
     "binary_sensor",
-    "button",
     "climate",
     "cover",
-    "datetime",
-    "event",
     "fan",
     "light",
-    "lock",
     "number",
-    "select",
     "sensor",
     "switch",
-    "text",
     "text_sensor",
-    "valve",
 ]
 
 demo_ns = cg.esphome_ns.namespace("demo")
-DemoAlarmControlPanel = demo_ns.class_(
-    "DemoAlarmControlPanel", alarm_control_panel.AlarmControlPanel, cg.Component
-)
-DemoAlarmControlPanelType = demo_ns.enum("DemoAlarmControlPanelType", is_class=True)
 DemoBinarySensor = demo_ns.class_(
     "DemoBinarySensor", binary_sensor.BinarySensor, cg.PollingComponent
 )
-DemoButton = demo_ns.class_("DemoButton", button.Button)
 DemoClimate = demo_ns.class_("DemoClimate", climate.Climate, cg.Component)
 DemoClimateType = demo_ns.enum("DemoClimateType", is_class=True)
 DemoCover = demo_ns.class_("DemoCover", cover.Cover, cg.Component)
 DemoCoverType = demo_ns.enum("DemoCoverType", is_class=True)
-DemoDate = demo_ns.class_("DemoDate", datetime.DateEntity, cg.Component)
-DemoDateTime = demo_ns.class_("DemoDateTime", datetime.DateTimeEntity, cg.Component)
-DemoTime = demo_ns.class_("DemoTime", datetime.TimeEntity, cg.Component)
-DemoEvent = demo_ns.class_("DemoEvent", event.Event, cg.Component)
 DemoFan = demo_ns.class_("DemoFan", fan.Fan, cg.Component)
 DemoFanType = demo_ns.enum("DemoFanType", is_class=True)
 DemoLight = demo_ns.class_("DemoLight", light.LightOutput, cg.Component)
 DemoLightType = demo_ns.enum("DemoLightType", is_class=True)
-DemoLock = demo_ns.class_("DemoLock", lock.Lock, cg.Component)
-DemoLockType = demo_ns.enum("DemoLockType", is_class=True)
 DemoNumber = demo_ns.class_("DemoNumber", number.Number, cg.Component)
 DemoNumberType = demo_ns.enum("DemoNumberType", is_class=True)
-DemoSelect = demo_ns.class_("DemoSelect", select.Select, cg.Component)
-DemoSelectType = demo_ns.enum("DemoSelectType", is_class=True)
 DemoSensor = demo_ns.class_("DemoSensor", sensor.Sensor, cg.PollingComponent)
 DemoSwitch = demo_ns.class_("DemoSwitch", switch.Switch, cg.Component)
-DemoText = demo_ns.class_("DemoText", text.Text, cg.Component)
-DemoTextType = demo_ns.enum("DemoTextType", is_class=True)
 DemoTextSensor = demo_ns.class_(
     "DemoTextSensor", text_sensor.TextSensor, cg.PollingComponent
 )
-DemoValve = demo_ns.class_("DemoValve", valve.Valve)
-DemoValveType = demo_ns.enum("DemoValveType", is_class=True)
 
 
-ALARM_CONTROL_PANEL_TYPES = {
-    1: DemoAlarmControlPanelType.TYPE_1,
-    2: DemoAlarmControlPanelType.TYPE_2,
-    3: DemoAlarmControlPanelType.TYPE_3,
-}
 CLIMATE_TYPES = {
     1: DemoClimateType.TYPE_1,
     2: DemoClimateType.TYPE_2,
@@ -145,67 +103,21 @@ LIGHT_TYPES = {
     6: DemoLightType.TYPE_6,
     7: DemoLightType.TYPE_7,
 }
-LOCK_TYPES = {
-    1: DemoLockType.TYPE_1,
-    2: DemoLockType.TYPE_2,
-}
 NUMBER_TYPES = {
     1: DemoNumberType.TYPE_1,
     2: DemoNumberType.TYPE_2,
     3: DemoNumberType.TYPE_3,
 }
-TEXT_TYPES = {
-    1: DemoTextType.TYPE_1,
-    2: DemoTextType.TYPE_2,
-}
-VALVE_TYPES = {
-    1: DemoValveType.TYPE_1,
-    2: DemoValveType.TYPE_2,
-}
 
 
-CONF_ALARM_CONTROL_PANELS = "alarm_control_panels"
-CONF_BUTTONS = "buttons"
 CONF_CLIMATES = "climates"
 CONF_COVERS = "covers"
-CONF_DATETIMES = "datetimes"
 CONF_FANS = "fans"
 CONF_LIGHTS = "lights"
-CONF_LOCKS = "locks"
 CONF_NUMBERS = "numbers"
-CONF_SELECTS = "selects"
-CONF_TEXTS = "texts"
-CONF_VALVES = "valves"
 
 CONFIG_SCHEMA = cv.Schema(
     {
-        cv.Optional(
-            CONF_ALARM_CONTROL_PANELS,
-            default=[
-                {
-                    CONF_NAME: "Demo Alarm Control Panel",
-                    CONF_TYPE: 1,
-                },
-                {
-                    CONF_NAME: "Demo Alarm Control Panel Code",
-                    CONF_TYPE: 2,
-                },
-                {
-                    CONF_NAME: "Demo Alarm Control Panel Code to Arm",
-                    CONF_TYPE: 3,
-                },
-            ],
-        ): [
-            alarm_control_panel.alarm_control_panel_schema(
-                DemoAlarmControlPanel
-            ).extend(
-                {
-                    cv.Required(CONF_TYPE): cv.enum(
-                        ALARM_CONTROL_PANEL_TYPES, int=True
-                    ),
-                }
-            )
-        ],
         cv.Optional(
             CONF_BINARY_SENSORS,
             default=[
@@ -223,21 +135,6 @@ CONFIG_SCHEMA = cv.Schema(
                 cv.polling_component_schema("60s")
             )
         ],
-        cv.Optional(
-            CONF_BUTTONS,
-            default=[
-                {
-                    CONF_NAME: "Demo Update Button",
-                    CONF_DEVICE_CLASS: DEVICE_CLASS_UPDATE,
-                },
-                {
-                    CONF_NAME: "Demo Button Identify",
-                    CONF_DEVICE_CLASS: DEVICE_CLASS_IDENTIFY,
-                },
-            ],
-        ): [
-            button.button_schema(DemoButton),
-        ],
         cv.Optional(
             CONF_CLIMATES,
             default=[
@@ -294,20 +191,6 @@ CONFIG_SCHEMA = cv.Schema(
                 }
             )
         ],
-        cv.Optional(
-            CONF_DATETIMES,
-            default=[
-                {CONF_NAME: "Demo DateTime", CONF_TYPE: "DATETIME"},
-                {CONF_NAME: "Demo Date", CONF_TYPE: "DATE"},
-                {CONF_NAME: "Demo Time", CONF_TYPE: "TIME"},
-            ],
-        ): [
-            cv.Any(
-                datetime.date_schema(DemoDate),
-                datetime.datetime_schema(DemoDateTime),
-                datetime.time_schema(DemoTime),
-            )
-        ],
         cv.Optional(
             CONF_FANS,
             default=[
@@ -379,19 +262,6 @@ CONFIG_SCHEMA = cv.Schema(
                 }
             )
         ],
-        cv.Optional(
-            CONF_LOCKS,
-            default=[
-                {CONF_NAME: "Demo Lock", CONF_TYPE: 1},
-                {CONF_NAME: "Demo Lock and Open", CONF_TYPE: 2},
-            ],
-        ): [
-            lock.lock_schema(DemoLock).extend(
-                {
-                    cv.Required(CONF_TYPE): cv.enum(LOCK_TYPES, int=True),
-                }
-            )
-        ],
         cv.Optional(
             CONF_NUMBERS,
             default=[
@@ -429,25 +299,6 @@ CONFIG_SCHEMA = cv.Schema(
                 }
             )
         ],
-        cv.Optional(
-            CONF_SELECTS,
-            default=[
-                {
-                    CONF_NAME: "Demo Select 1",
-                    CONF_OPTIONS: ["Option 1", "Option 2", "Option 3"],
-                },
-                {
-                    CONF_NAME: "Demo Select 2",
-                    CONF_OPTIONS: ["Option A", "Option B", "Option C"],
-                },
-            ],
-        ): [
-            select.select_schema(DemoSelect).extend(
-                {
-                    cv.Required(CONF_OPTIONS): cv.ensure_list(cv.string_strict),
-                }
-            )
-        ],
         cv.Optional(
             CONF_SENSORS,
             default=[
@@ -504,19 +355,6 @@ CONFIG_SCHEMA = cv.Schema(
                 },
             ],
         ): [switch.switch_schema(DemoSwitch).extend(cv.COMPONENT_SCHEMA)],
-        cv.Optional(
-            CONF_TEXTS,
-            default=[
-                {CONF_NAME: "Demo Text 1", CONF_MODE: "TEXT", CONF_TYPE: 1},
-                {CONF_NAME: "Demo Text 2", CONF_MODE: "PASSWORD", CONF_TYPE: 2},
-            ],
-        ): [
-            text.text_schema(DemoText).extend(
-                {
-                    cv.Required(CONF_TYPE): cv.enum(TEXT_TYPES, int=True),
-                }
-            )
-        ],
         cv.Optional(
             CONF_TEXT_SENSORS,
             default=[
@@ -533,36 +371,15 @@ CONFIG_SCHEMA = cv.Schema(
                 cv.polling_component_schema("60s")
             )
         ],
-        cv.Optional(
-            CONF_VALVES,
-            default=[
-                {CONF_NAME: "Demo Valve 1", CONF_TYPE: 1},
-                {CONF_NAME: "Demo Valve 2", CONF_TYPE: 2},
-            ],
-        ): [
-            valve.valve_schema(DemoValve).extend(
-                {
-                    cv.Required(CONF_TYPE): cv.enum(VALVE_TYPES, int=True),
-                }
-            )
-        ],
     }
 )
 
 
 async def to_code(config):
-    for conf in config[CONF_ALARM_CONTROL_PANELS]:
-        var = await alarm_control_panel.new_alarm_control_panel(conf)
-        cg.add(var.set_type(conf[CONF_TYPE]))
-        await cg.register_component(var, conf)
-
     for conf in config[CONF_BINARY_SENSORS]:
         var = await binary_sensor.new_binary_sensor(conf)
         await cg.register_component(var, conf)
 
-    for conf in config[CONF_BUTTONS]:
-        await button.new_button(conf)
-
     for conf in config[CONF_CLIMATES]:
         var = await climate.new_climate(conf)
         await cg.register_component(var, conf)
@@ -573,10 +390,6 @@ async def to_code(config):
         await cg.register_component(var, conf)
         cg.add(var.set_type(conf[CONF_TYPE]))
 
-    for conf in config[CONF_DATETIMES]:
-        var = await datetime.new_datetime(conf)
-        await cg.register_component(var, conf)
-
     for conf in config[CONF_FANS]:
         var = await fan.new_fan(conf)
         await cg.register_component(var, conf)
@@ -587,11 +400,6 @@ async def to_code(config):
         await cg.register_component(var, conf)
         cg.add(var.set_type(conf[CONF_TYPE]))
 
-    for conf in config[CONF_LOCKS]:
-        var = await lock.new_lock(conf)
-        if conf[CONF_TYPE] == 2:
-            cg.add(var.traits.set_supports_open(True))
-
     for conf in config[CONF_NUMBERS]:
         var = await number.new_number(
             conf,
@@ -602,10 +410,6 @@ async def to_code(config):
         await cg.register_component(var, conf)
         cg.add(var.set_type(conf[CONF_TYPE]))
 
-    for conf in config[CONF_SELECTS]:
-        var = await select.new_select(conf, options=conf[CONF_OPTIONS])
-        await cg.register_component(var, conf)
-
     for conf in config[CONF_SENSORS]:
         var = await sensor.new_sensor(conf)
         await cg.register_component(var, conf)
@@ -614,16 +418,6 @@ async def to_code(config):
         var = await switch.new_switch(conf)
         await cg.register_component(var, conf)
 
-    for conf in config[CONF_TEXTS]:
-        var = await text.new_text(conf)
-        await cg.register_component(var, conf)
-        if conf[CONF_TYPE] == 2:
-            cg.add(var.traits.set_mode(text.TextMode.TEXT_MODE_PASSWORD))
-
     for conf in config[CONF_TEXT_SENSORS]:
         var = await text_sensor.new_text_sensor(conf)
         await cg.register_component(var, conf)
-
-    for conf in config[CONF_VALVES]:
-        var = await valve.new_valve(conf)
-        cg.add(var.set_type(conf[CONF_TYPE]))

esphome/components/demo/demo_alarm_control_panel.h

@@ -1,65 +0,0 @@
-#pragma once
-
-#include "esphome/components/alarm_control_panel/alarm_control_panel.h"
-#include "esphome/core/component.h"
-
-namespace esphome {
-namespace demo {
-
-using namespace alarm_control_panel;
-
-enum class DemoAlarmControlPanelType {
-  TYPE_1,
-  TYPE_2,
-  TYPE_3,
-};
-
-class DemoAlarmControlPanel : public AlarmControlPanel, public Component {
- public:
-  void setup() override {}
-
-  uint32_t get_supported_features() const override { return ACP_FEAT_ARM_AWAY | ACP_FEAT_TRIGGER; }
-
-  bool get_requires_code() const override { return this->type_ != DemoAlarmControlPanelType::TYPE_1; }
-
-  bool get_requires_code_to_arm() const override { return this->type_ == DemoAlarmControlPanelType::TYPE_3; }
-
-  void set_type(DemoAlarmControlPanelType type) { this->type_ = type; }
-
- protected:
-  void control(const AlarmControlPanelCall &call) override {
-    auto state = call.get_state().value_or(ACP_STATE_DISARMED);
-    switch (state) {
-      case ACP_STATE_ARMED_AWAY:
-        if (this->get_requires_code_to_arm() && call.get_code().has_value()) {
-          if (call.get_code().value() != "1234") {
-            this->status_momentary_error("Invalid code", 5000);
-            return;
-          }
-        }
-        this->publish_state(ACP_STATE_ARMED_AWAY);
-        break;
-      case ACP_STATE_DISARMED:
-        if (this->get_requires_code() && call.get_code().has_value()) {
-          if (call.get_code().value() != "1234") {
-            this->status_momentary_error("Invalid code", 5000);
-            return;
-          }
-        }
-        this->publish_state(ACP_STATE_DISARMED);
-        return;
-      case ACP_STATE_TRIGGERED:
-        this->publish_state(ACP_STATE_TRIGGERED);
-        return;
-      case ACP_STATE_PENDING:
-        this->publish_state(ACP_STATE_PENDING);
-        return;
-      default:
-        break;
-    }
-  }
-  DemoAlarmControlPanelType type_{};
-};
-
-}  // namespace demo
-}  // namespace esphome

esphome/components/demo/demo_button.h

@@ -1,15 +0,0 @@
-#pragma once
-
-#include "esphome/components/button/button.h"
-#include "esphome/core/log.h"
-
-namespace esphome {
-namespace demo {
-
-class DemoButton : public button::Button {
- protected:
-  void press_action() override {}
-};
-
-}  // namespace demo
-}  // namespace esphome

esphome/components/demo/demo_date.h

@@ -1,34 +0,0 @@
-#pragma once
-
-#include "esphome/core/defines.h"
-
-#ifdef USE_DATETIME_DATE
-
-#include "esphome/components/datetime/date_entity.h"
-#include "esphome/core/component.h"
-
-namespace esphome {
-namespace demo {
-
-class DemoDate : public datetime::DateEntity, public Component {
- public:
-  void setup() override {
-    this->year_ = 2038;
-    this->month_ = 01;
-    this->day_ = 19;
-    this->publish_state();
-  }
-
- protected:
-  void control(const datetime::DateCall &call) override {
-    this->year_ = call.get_year().value_or(this->year_);
-    this->month_ = call.get_month().value_or(this->month_);
-    this->day_ = call.get_day().value_or(this->day_);
-    this->publish_state();
-  }
-};
-
-}  // namespace demo
-}  // namespace esphome
-
-#endif

esphome/components/demo/demo_datetime.h

@@ -1,40 +0,0 @@
-#pragma once
-
-#include "esphome/core/defines.h"
-
-#ifdef USE_DATETIME_DATETIME
-
-#include "esphome/components/datetime/datetime_entity.h"
-#include "esphome/core/component.h"
-
-namespace esphome {
-namespace demo {
-
-class DemoDateTime : public datetime::DateTimeEntity, public Component {
- public:
-  void setup() override {
-    this->year_ = 2038;
-    this->month_ = 01;
-    this->day_ = 19;
-    this->hour_ = 3;
-    this->minute_ = 14;
-    this->second_ = 8;
-    this->publish_state();
-  }
-
- protected:
-  void control(const datetime::DateTimeCall &call) override {
-    this->year_ = call.get_year().value_or(this->year_);
-    this->month_ = call.get_month().value_or(this->month_);
-    this->day_ = call.get_day().value_or(this->day_);
-    this->hour_ = call.get_hour().value_or(this->hour_);
-    this->minute_ = call.get_minute().value_or(this->minute_);
-    this->second_ = call.get_second().value_or(this->second_);
-    this->publish_state();
-  }
-};
-
-}  // namespace demo
-}  // namespace esphome
-
-#endif

esphome/components/demo/demo_lock.h

@@ -1,17 +0,0 @@
-#pragma once
-
-#include "esphome/components/lock/lock.h"
-
-namespace esphome {
-namespace demo {
-
-class DemoLock : public lock::Lock {
- protected:
-  void control(const lock::LockCall &call) override {
-    auto state = *call.get_state();
-    this->publish_state(state);
-  }
-};
-
-}  // namespace demo
-}  // namespace esphome

esphome/components/demo/demo_select.h

@@ -1,15 +0,0 @@
-#pragma once
-
-#include "esphome/components/select/select.h"
-#include "esphome/core/component.h"
-
-namespace esphome {
-namespace demo {
-
-class DemoSelect : public select::Select, public Component {
- protected:
-  void control(const std::string &value) override { this->publish_state(value); }
-};
-
-}  // namespace demo
-}  // namespace esphome

esphome/components/demo/demo_text.h

@@ -1,18 +0,0 @@
-#pragma once
-
-#include "esphome/components/text/text.h"
-#include "esphome/core/component.h"
-
-namespace esphome {
-namespace demo {
-
-class DemoText : public text::Text, public Component {
- public:
-  void setup() override { this->publish_state("I am a text entity"); }
-
- protected:
-  void control(const std::string &value) override { this->publish_state(value); }
-};
-
-}  // namespace demo
-}  // namespace esphome

esphome/components/demo/demo_time.h

@@ -1,34 +0,0 @@
-#pragma once
-
-#include "esphome/core/defines.h"
-
-#ifdef USE_DATETIME_TIME
-
-#include "esphome/components/datetime/time_entity.h"
-#include "esphome/core/component.h"
-
-namespace esphome {
-namespace demo {
-
-class DemoTime : public datetime::TimeEntity, public Component {
- public:
-  void setup() override {
-    this->hour_ = 3;
-    this->minute_ = 14;
-    this->second_ = 8;
-    this->publish_state();
-  }
-
- protected:
-  void control(const datetime::TimeCall &call) override {
-    this->hour_ = call.get_hour().value_or(this->hour_);
-    this->minute_ = call.get_minute().value_or(this->minute_);
-    this->second_ = call.get_second().value_or(this->second_);
-    this->publish_state();
-  }
-};
-
-}  // namespace demo
-}  // namespace esphome
-
-#endif

esphome/components/demo/demo_valve.h

@@ -1,54 +0,0 @@
-#pragma once
-
-#include "esphome/components/valve/valve.h"
-
-namespace esphome {
-namespace demo {
-
-enum class DemoValveType {
-  TYPE_1,
-  TYPE_2,
-};
-
-class DemoValve : public valve::Valve {
- public:
-  valve::ValveTraits get_traits() override {
-    valve::ValveTraits traits;
-    if (this->type_ == DemoValveType::TYPE_2) {
-      traits.set_supports_position(true);
-      traits.set_supports_toggle(true);
-      traits.set_supports_stop(true);
-    }
-    return traits;
-  }
-
-  void set_type(DemoValveType type) { this->type_ = type; }
-
- protected:
-  void control(const valve::ValveCall &call) override {
-    if (call.get_position().has_value()) {
-      this->position = *call.get_position();
-      this->publish_state();
-      return;
-    } else if (call.get_toggle().has_value()) {
-      if (call.get_toggle().value()) {
-        if (this->position == valve::VALVE_OPEN) {
-          this->position = valve::VALVE_CLOSED;
-          this->publish_state();
-        } else {
-          this->position = valve::VALVE_OPEN;
-          this->publish_state();
-        }
-      }
-      return;
-    } else if (call.get_stop()) {
-      this->current_operation = valve::VALVE_OPERATION_IDLE;
-      this->publish_state();  // Keep the current position
-      return;
-    }
-  }
-  DemoValveType type_{};
-};
-
-}  // namespace demo
-}  // namespace esphome

esphome/components/dht/dht.cpp

@@ -8,19 +8,25 @@ namespace dht {
 static const char *const TAG = "dht";
 
 void DHT::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up DHT...");
   this->pin_->digital_write(true);
   this->pin_->setup();
   this->pin_->digital_write(true);
 }
-
 void DHT::dump_config() {
   ESP_LOGCONFIG(TAG, "DHT:");
   LOG_PIN("  Pin: ", this->pin_);
-  ESP_LOGCONFIG(TAG, "  %sModel: %s", this->is_auto_detect_ ? "Auto-detected " : "",
-                this->model_ == DHT_MODEL_DHT11 ? "DHT11" : "DHT22 or equivalent");
-  ESP_LOGCONFIG(TAG, "  Internal pull-up: %s", ONOFF(this->pin_->get_flags() & gpio::FLAG_PULLUP));
+  if (this->is_auto_detect_) {
+    ESP_LOGCONFIG(TAG, "  Auto-detected model: %s", this->model_ == DHT_MODEL_DHT11 ? "DHT11" : "DHT22");
+  } else if (this->model_ == DHT_MODEL_DHT11) {
+    ESP_LOGCONFIG(TAG, "  Model: DHT11");
+  } else {
+    ESP_LOGCONFIG(TAG, "  Model: DHT22 (or equivalent)");
+  }
+  ESP_LOGCONFIG(TAG, "  Internal Pull-up: %s", ONOFF(this->pin_->get_flags() & gpio::FLAG_PULLUP));
+
   LOG_UPDATE_INTERVAL(this);
+
   LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
   LOG_SENSOR("  ", "Humidity", this->humidity_sensor_);
 }
@@ -40,7 +46,7 @@ void DHT::update() {
   }
 
   if (success) {
-    ESP_LOGD(TAG, "Temperature %.1f°C Humidity %.1f%%", temperature, humidity);
+    ESP_LOGD(TAG, "Got Temperature=%.1f°C Humidity=%.1f%%", temperature, humidity);
 
     if (this->temperature_sensor_ != nullptr)
       this->temperature_sensor_->publish_state(temperature);
@@ -48,8 +54,11 @@ void DHT::update() {
       this->humidity_sensor_->publish_state(humidity);
     this->status_clear_warning();
   } else {
-    ESP_LOGW(TAG, "Invalid readings! Check pin number and pull-up resistor%s.",
-             this->is_auto_detect_ ? " and try manually specifying the model" : "");
+    const char *str = "";
+    if (this->is_auto_detect_) {
+      str = " and consider manually specifying the DHT model using the model option";
+    }
+    ESP_LOGW(TAG, "Invalid readings! Please check your wiring (pull-up resistor, pin number)%s.", str);
     if (this->temperature_sensor_ != nullptr)
       this->temperature_sensor_->publish_state(NAN);
     if (this->humidity_sensor_ != nullptr)
@@ -59,12 +68,10 @@ void DHT::update() {
 }
 
 float DHT::get_setup_priority() const { return setup_priority::DATA; }
-
 void DHT::set_dht_model(DHTModel model) {
   this->model_ = model;
   this->is_auto_detect_ = model == DHT_MODEL_AUTO_DETECT;
 }
-
 bool HOT IRAM_ATTR DHT::read_sensor_(float *temperature, float *humidity, bool report_errors) {
   *humidity = NAN;
   *temperature = NAN;
@@ -114,9 +121,9 @@ bool HOT IRAM_ATTR DHT::read_sensor_(float *temperature, float *humidity, bool r
       while (!this->pin_->digital_read()) {
         if (micros() - start_time > 90) {
           if (i < 0) {
-            error_code = 1;  // line didn't clear
+            error_code = 1;
           } else {
-            error_code = 2;  // rising edge for bit i timeout
+            error_code = 2;
           }
           break;
         }
@@ -132,9 +139,9 @@ bool HOT IRAM_ATTR DHT::read_sensor_(float *temperature, float *humidity, bool r
         end_time = micros();
         if (end_time - start_time > 90) {
           if (i < 0) {
-            error_code = 3;  // requesting data failed
+            error_code = 3;
           } else {
-            error_code = 4;  // falling edge for bit i timeout
+            error_code = 4;
           }
           break;
         }
@@ -159,9 +166,22 @@ bool HOT IRAM_ATTR DHT::read_sensor_(float *temperature, float *humidity, bool r
   if (!report_errors && error_code != 0)
     return false;
 
-  if (error_code) {
-    ESP_LOGW(TAG, ESP_LOG_MSG_COMM_FAIL);
-    return false;
+  switch (error_code) {
+    case 1:
+      ESP_LOGW(TAG, "Waiting for DHT communication to clear failed!");
+      return false;
+    case 2:
+      ESP_LOGW(TAG, "Rising edge for bit %d failed!", i);
+      return false;
+    case 3:
+      ESP_LOGW(TAG, "Requesting data from DHT failed!");
+      return false;
+    case 4:
+      ESP_LOGW(TAG, "Falling edge for bit %d failed!", i);
+      return false;
+    case 0:
+    default:
+      break;
   }
 
   ESP_LOGVV(TAG,
@@ -186,15 +206,15 @@ bool HOT IRAM_ATTR DHT::read_sensor_(float *temperature, float *humidity, bool r
     if (checksum_a == data[4]) {
       // Data format: 8bit integral RH data + 8bit decimal RH data + 8bit integral T data + 8bit decimal T data + 8bit
       // check sum - some models always have 0 in the decimal part
-      const uint16_t raw_temperature = static_cast<uint16_t>(data[2]) * 10 + (data[3] & 0x7F);
-      *temperature = static_cast<float>(raw_temperature) / 10.0f;
+      const uint16_t raw_temperature = uint16_t(data[2]) * 10 + (data[3] & 0x7F);
+      *temperature = raw_temperature / 10.0f;
       if ((data[3] & 0x80) != 0) {
         // negative
         *temperature *= -1;
       }
 
-      const uint16_t raw_humidity = static_cast<uint16_t>(data[0]) * 10 + data[1];
-      *humidity = static_cast<float>(raw_humidity) / 10.0f;
+      const uint16_t raw_humidity = uint16_t(data[0]) * 10 + data[1];
+      *humidity = raw_humidity / 10.0f;
     } else {
       // For compatibility with DHT11 models which might only use 2 bytes checksums, only use the data from these two
       // bytes
@@ -202,8 +222,8 @@ bool HOT IRAM_ATTR DHT::read_sensor_(float *temperature, float *humidity, bool r
       *humidity = data[0];
     }
   } else {
-    uint16_t raw_humidity = encode_uint16(data[0], data[1]);
-    uint16_t raw_temperature = encode_uint16(data[2], data[3]);
+    uint16_t raw_humidity = (uint16_t(data[0] & 0xFF) << 8) | (data[1] & 0xFF);
+    uint16_t raw_temperature = (uint16_t(data[2] & 0xFF) << 8) | (data[3] & 0xFF);
 
     if (raw_temperature & 0x8000) {
       if (!(raw_temperature & 0x4000))
@@ -214,23 +234,24 @@ bool HOT IRAM_ATTR DHT::read_sensor_(float *temperature, float *humidity, bool r
 
     if (raw_temperature == 1 && raw_humidity == 10) {
       if (report_errors) {
-        ESP_LOGW(TAG, "Invalid data");
+        ESP_LOGW(TAG, "Invalid temperature+humidity! Sensor reported 1°C and 1%% Hum");
       }
       return false;
     }
 
-    *humidity = static_cast<float>(raw_humidity) * 0.1f;
-    if (*humidity > 100.0f)
+    *humidity = raw_humidity * 0.1f;
+    if (*humidity > 100)
       *humidity = NAN;
-    *temperature = static_cast<int16_t>(raw_temperature) * 0.1f;
+    *temperature = int16_t(raw_temperature) * 0.1f;
   }
 
   if (*temperature == 0.0f && (*humidity == 1.0f || *humidity == 2.0f)) {
     if (report_errors) {
-      ESP_LOGW(TAG, "Invalid data");
+      ESP_LOGW(TAG, "DHT reports invalid data. Is the update interval too high or the sensor damaged?");
     }
     return false;
   }
+
   return true;
 }
 

esphome/components/dht12/dht12.cpp

@@ -34,7 +34,7 @@ void DHT12Component::update() {
   this->status_clear_warning();
 }
 void DHT12Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up DHT12...");
   uint8_t data[5];
   if (!this->read_data_(data)) {
     this->mark_failed();
@@ -45,7 +45,7 @@ void DHT12Component::dump_config() {
   ESP_LOGD(TAG, "DHT12:");
   LOG_I2C_DEVICE(this);
   if (this->is_failed()) {
-    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+    ESP_LOGE(TAG, "Communication with DHT12 failed!");
   }
   LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
   LOG_SENSOR("  ", "Humidity", this->humidity_sensor_);

esphome/components/dps310/dps310.cpp

@@ -12,7 +12,7 @@ void DPS310Component::setup() {
   auto timer = DPS310_INIT_TIMEOUT;
   uint8_t reg = 0;
 
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up DPS310...");
   // first, reset the sensor
   if (!this->write_byte(DPS310_REG_RESET, DPS310_CMD_RESET)) {
     this->mark_failed();
@@ -91,7 +91,7 @@ void DPS310Component::dump_config() {
   ESP_LOGCONFIG(TAG, "  Revision ID: %u", (this->prod_rev_id_ >> 4) & 0x0F);
   LOG_I2C_DEVICE(this);
   if (this->is_failed()) {
-    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+    ESP_LOGE(TAG, "Communication with DPS310 failed!");
   }
   LOG_UPDATE_INTERVAL(this);
   LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);

esphome/components/ds1307/ds1307.cpp

@@ -10,7 +10,7 @@ namespace ds1307 {
 static const char *const TAG = "ds1307";
 
 void DS1307Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up DS1307...");
   if (!this->read_rtc_()) {
     this->mark_failed();
   }
@@ -22,7 +22,7 @@ void DS1307Component::dump_config() {
   ESP_LOGCONFIG(TAG, "DS1307:");
   LOG_I2C_DEVICE(this);
   if (this->is_failed()) {
-    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+    ESP_LOGE(TAG, "Communication with DS1307 failed!");
   }
   ESP_LOGCONFIG(TAG, "  Timezone: '%s'", this->timezone_.c_str());
 }

esphome/components/duty_cycle/duty_cycle_sensor.cpp

@@ -8,7 +8,7 @@ namespace duty_cycle {
 static const char *const TAG = "duty_cycle";
 
 void DutyCycleSensor::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup for '%s'", this->get_name().c_str());
+  ESP_LOGCONFIG(TAG, "Setting up Duty Cycle Sensor '%s'...", this->get_name().c_str());
   this->pin_->setup();
   this->store_.pin = this->pin_->to_isr();
   this->store_.last_level = this->pin_->digital_read();

esphome/components/ee895/ee895.cpp

@@ -16,7 +16,7 @@ static const uint16_t PRESSURE_ADDRESS = 0x04B0;
 
 void EE895Component::setup() {
   uint16_t crc16_check = 0;
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up EE895...");
   write_command_(SERIAL_NUMBER, 8);
   uint8_t serial_number[20];
   this->read(serial_number, 20);
@@ -35,7 +35,7 @@ void EE895Component::dump_config() {
   LOG_I2C_DEVICE(this);
   switch (this->error_code_) {
     case COMMUNICATION_FAILED:
-      ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+      ESP_LOGE(TAG, "Communication with EE895 failed!");
       break;
     case CRC_CHECK_FAILED:
       ESP_LOGE(TAG, "The crc check failed");

esphome/components/ektf2232/touchscreen/ektf2232.cpp

@@ -16,7 +16,7 @@ static const uint8_t GET_Y_RES[4] = {0x53, 0x63, 0x00, 0x00};
 static const uint8_t GET_POWER_STATE_CMD[4] = {0x53, 0x50, 0x00, 0x01};
 
 void EKTF2232Touchscreen::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up EKT2232 Touchscreen...");
   this->interrupt_pin_->pin_mode(gpio::FLAG_INPUT | gpio::FLAG_PULLUP);
   this->interrupt_pin_->setup();
 

esphome/components/emc2101/emc2101.cpp

@@ -57,7 +57,7 @@ static const uint8_t EMC2101_POLARITY_BIT = 1 << 4;
 float Emc2101Component::get_setup_priority() const { return setup_priority::HARDWARE; }
 
 void Emc2101Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up Emc2101 sensor...");
 
   // make sure we're talking to the right chip
   uint8_t chip_id = reg(EMC2101_REGISTER_WHOAMI).get();
@@ -94,7 +94,7 @@ void Emc2101Component::dump_config() {
   ESP_LOGCONFIG(TAG, "Emc2101 component:");
   LOG_I2C_DEVICE(this);
   if (this->is_failed()) {
-    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+    ESP_LOGE(TAG, "Communication with EMC2101 failed!");
   }
   ESP_LOGCONFIG(TAG, "  Mode: %s", this->dac_mode_ ? "DAC" : "PWM");
   if (this->dac_mode_) {
@@ -110,7 +110,7 @@ void Emc2101Component::set_duty_cycle(float value) {
   uint8_t duty_cycle = remap(value, 0.0f, 1.0f, (uint8_t) 0, this->max_output_value_);
   ESP_LOGD(TAG, "Setting duty fan setting to %02X", duty_cycle);
   if (!this->write_byte(EMC2101_REGISTER_FAN_SETTING, duty_cycle)) {
-    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+    ESP_LOGE(TAG, "Communication with EMC2101 failed!");
     this->status_set_warning();
     return;
   }
@@ -119,7 +119,7 @@ void Emc2101Component::set_duty_cycle(float value) {
 float Emc2101Component::get_duty_cycle() {
   uint8_t duty_cycle;
   if (!this->read_byte(EMC2101_REGISTER_FAN_SETTING, &duty_cycle)) {
-    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+    ESP_LOGE(TAG, "Communication with EMC2101 failed!");
     this->status_set_warning();
     return NAN;
   }
@@ -129,7 +129,7 @@ float Emc2101Component::get_duty_cycle() {
 float Emc2101Component::get_internal_temperature() {
   uint8_t temperature;
   if (!this->read_byte(EMC2101_REGISTER_INTERNAL_TEMP, &temperature)) {
-    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+    ESP_LOGE(TAG, "Communication with EMC2101 failed!");
     this->status_set_warning();
     return NAN;
   }
@@ -141,7 +141,7 @@ float Emc2101Component::get_external_temperature() {
   uint8_t lsb, msb;
   if (!this->read_byte(EMC2101_REGISTER_EXTERNAL_TEMP_MSB, &msb) ||
       !this->read_byte(EMC2101_REGISTER_EXTERNAL_TEMP_LSB, &lsb)) {
-    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+    ESP_LOGE(TAG, "Communication with EMC2101 failed!");
     this->status_set_warning();
     return NAN;
   }
@@ -155,7 +155,7 @@ float Emc2101Component::get_speed() {
   // Read **LSB** first to match 'Data Read Interlock' behavior from 6.1 of datasheet
   uint8_t lsb, msb;
   if (!this->read_byte(EMC2101_REGISTER_TACH_LSB, &lsb) || !this->read_byte(EMC2101_REGISTER_TACH_MSB, &msb)) {
-    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+    ESP_LOGE(TAG, "Communication with EMC2101 failed!");
     this->status_set_warning();
     return NAN;
   }

esphome/components/ens160_base/ens160_base.cpp

@@ -49,7 +49,7 @@ static const uint8_t ENS160_DATA_STATUS_NEWGPR = 0x01;
 static const uint8_t ENS160_DATA_AQI = 0x07;
 
 void ENS160Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up ENS160...");
 
   // check part_id
   uint16_t part_id;
@@ -279,7 +279,7 @@ void ENS160Component::dump_config() {
 
   switch (this->error_code_) {
     case COMMUNICATION_FAILED:
-      ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+      ESP_LOGE(TAG, "Communication failed! Is the sensor connected?");
       break;
     case READ_FAILED:
       ESP_LOGE(TAG, "Error reading from register");

esphome/components/ens210/ens210.cpp

@@ -87,7 +87,7 @@ static uint32_t crc7(uint32_t value) {
 }
 
 void ENS210Component::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up ENS210...");
   uint8_t data[2];
   uint16_t part_id = 0;
   // Reset
@@ -163,7 +163,7 @@ void ENS210Component::update() {
 
     // Read T_VAL and H_VAL
     if (!this->read_bytes(ENS210_REGISTER_T_VAL, data, 6)) {
-      ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+      ESP_LOGE(TAG, "Communication with ENS210 failed!");
       this->status_set_warning();
       return;
     }

esphome/components/es7210/es7210.cpp

@@ -36,7 +36,7 @@ void ES7210::dump_config() {
 }
 
 void ES7210::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up ES7210...");
 
   // Software reset
   ES7210_ERROR_FAILED(this->write_byte(ES7210_RESET_REG00, 0xff));

esphome/components/es7243e/es7243e.cpp

@@ -34,7 +34,7 @@ void ES7243E::dump_config() {
 }
 
 void ES7243E::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up ES7243E...");
 
   ES7243E_ERROR_FAILED(this->write_byte(ES7243E_CLOCK_MGR_REG01, 0x3A));
   ES7243E_ERROR_FAILED(this->write_byte(ES7243E_RESET_REG00, 0x80));

esphome/components/es8156/es8156.cpp

@@ -17,7 +17,7 @@ static const char *const TAG = "es8156";
   }
 
 void ES8156::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up ES8156...");
 
   ES8156_ERROR_FAILED(this->write_byte(ES8156_REG02_SCLK_MODE, 0x04));
   ES8156_ERROR_FAILED(this->write_byte(ES8156_REG20_ANALOG_SYS1, 0x2A));

esphome/components/es8311/es8311.cpp

@@ -22,7 +22,7 @@ static const char *const TAG = "es8311";
   }
 
 void ES8311::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up ES8311...");
 
   // Reset
   ES8311_ERROR_FAILED(this->write_byte(ES8311_REG00_RESET, 0x1F));

esphome/components/es8388/audio_dac.py

@@ -1,26 +0,0 @@
-import esphome.codegen as cg
-from esphome.components import i2c
-from esphome.components.audio_dac import AudioDac
-import esphome.config_validation as cv
-from esphome.const import CONF_ID
-
-CODEOWNERS = ["@P4uLT"]
-CONF_ES8388_ID = "es8388_id"
-
-es8388_ns = cg.esphome_ns.namespace("es8388")
-
-ES8388 = es8388_ns.class_("ES8388", AudioDac, cg.Component, i2c.I2CDevice)
-
-DEPENDENCIES = ["i2c"]
-
-CONFIG_SCHEMA = (
-    cv.Schema({cv.GenerateID(): cv.declare_id(ES8388)})
-    .extend(cv.COMPONENT_SCHEMA)
-    .extend(i2c.i2c_device_schema(0x10))
-)
-
-
-async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
-    await cg.register_component(var, config)
-    await i2c.register_i2c_device(var, config)

esphome/components/es8388/es8388.cpp

@@ -1,289 +0,0 @@
-#include "es8388.h"
-
-#include <cinttypes>
-#include "esphome/core/hal.h"
-#include "esphome/core/log.h"
-
-namespace esphome {
-namespace es8388 {
-
-static const char *const TAG = "es8388";
-
-// Mark the component as failed; use only in setup
-#define ES8388_ERROR_FAILED(func) \
-  if (!(func)) { \
-    this->mark_failed(); \
-    return; \
-  }
-
-// Return false; use outside of setup
-#define ES8388_ERROR_CHECK(func) \
-  if (!(func)) { \
-    return false; \
-  }
-
-void ES8388::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
-
-  // mute DAC
-  this->set_mute_state_(true);
-
-  // I2S worker mode
-  ES8388_ERROR_FAILED(this->write_byte(ES8388_MASTERMODE, 0x00));
-
-  /* Chip Control and Power Management */
-  ES8388_ERROR_FAILED(this->write_byte(ES8388_CONTROL2, 0x50));
-  // normal all and power up all
-  ES8388_ERROR_FAILED(this->write_byte(ES8388_CHIPPOWER, 0x00));
-
-  // vmidsel/500k
-  // EnRef=0,Play&Record Mode,(0x17-both of mic&play)
-  ES8388_ERROR_FAILED(this->write_byte(ES8388_CONTROL1, 0x12));
-
-  // i2s 16 bits
-  ES8388_ERROR_FAILED(this->write_byte(ES8388_DACCONTROL1, 0x18));
-  // sample freq 256
-  // DACFsMode,SINGLE SPEED; DACFsRatio,256
-  ES8388_ERROR_FAILED(this->write_byte(ES8388_DACCONTROL2, 0x02));
-  // 0x00 audio on LIN1&RIN1,  0x09 LIN2&RIN2
-  ES8388_ERROR_FAILED(this->write_byte(ES8388_DACCONTROL16, 0x00));
-  // only left DAC to left mixer enable 0db
-  ES8388_ERROR_FAILED(this->write_byte(ES8388_DACCONTROL17, 0x90));
-  // only right DAC to right mixer enable 0db
-  ES8388_ERROR_FAILED(this->write_byte(ES8388_DACCONTROL20, 0x90));
-  // set internal ADC and DAC use the same LRCK clock, ADC LRCK as internal LRCK
-  ES8388_ERROR_FAILED(this->write_byte(ES8388_DACCONTROL21, 0x80));
-  // vroi=0 - 1.5k VREF to analog output resistance (default)
-  ES8388_ERROR_FAILED(this->write_byte(ES8388_DACCONTROL23, 0x00));
-
-  // power down adc and line in
-  ES8388_ERROR_FAILED(this->write_byte(ES8388_ADCPOWER, 0xFF));
-
-  //@nightdav
-  ES8388_ERROR_FAILED(
-      this->write_byte(ES8388_ADCCONTROL1, 0x00));  // +21dB : recommended value for ALC & voice recording
-
-  // set to Mono Right
-  ES8388_ERROR_FAILED(this->write_byte(ES8388_ADCCONTROL3, 0x02));
-
-  // I2S 16 Bits length and I2S serial audio data format
-  ES8388_ERROR_FAILED(this->write_byte(ES8388_ADCCONTROL4, 0x0d));
-  // ADCFsMode,singel SPEED,RATIO=256
-  ES8388_ERROR_FAILED(this->write_byte(ES8388_ADCCONTROL5, 0x02));
-
-  // ADC Volume
-  ES8388_ERROR_FAILED(this->write_byte(ES8388_ADCCONTROL8, 0x00));
-  ES8388_ERROR_FAILED(this->write_byte(ES8388_ADCCONTROL9, 0x00));
-
-  //@nightDav
-  // ALC Config (as recommended by ES8388 user guide for voice recording)
-
-  // Reg 0x12 = 0xe2 (ALC enable, PGA Max. Gain=23.5dB, Min. Gain=0dB)
-  ES8388_ERROR_FAILED(this->write_byte(ES8388_ADCCONTROL10, 0xe2));
-
-  // Reg 0x13 = 0xa0 (ALC Target=-1.5dB, ALC Hold time =0 mS)
-  ES8388_ERROR_FAILED(this->write_byte(ES8388_ADCCONTROL11, 0xa0));
-  // Reg 0x14 = 0x12(Decay time =820uS , Attack time = 416 uS)
-  ES8388_ERROR_FAILED(this->write_byte(ES8388_ADCCONTROL12, 0x12));
-
-  // Reg 0x15 = 0x06(ALC mode)
-  ES8388_ERROR_FAILED(this->write_byte(ES8388_ADCCONTROL13, 0x06));
-
-  // Reg 0x16 = 0xc3(nose gate = -40.5dB, NGG = 0x01(mute ADC))
-  ES8388_ERROR_FAILED(this->write_byte(ES8388_ADCCONTROL14, 0xc3));
-
-  // Power on ADC
-  ES8388_ERROR_FAILED(this->write_byte(ES8388_DACCONTROL21, 0x80));
-
-  // Start state machine
-  ES8388_ERROR_FAILED(this->write_byte(ES8388_CHIPPOWER, 0xF0));
-  delay(1);
-  ES8388_ERROR_FAILED(this->write_byte(ES8388_CHIPPOWER, 0x00));
-
-  // DAC volume max
-  // Set initial volume
-  // this->set_volume(0.75);  // 0.75 = 0xBF = 0dB
-
-  this->set_mute_state_(false);
-
-  // unmute ADC with fade in
-  ES8388_ERROR_FAILED(this->write_byte(ES8388_ADCCONTROL7, 0x60));
-  // unmute DAC with fade in
-  ES8388_ERROR_FAILED(this->write_byte(ES8388_DACCONTROL3, 0x20));
-
-  // Power on ADC, Enable LIN&RIN, Power off MICBIAS, set int1lp to low power mode
-  ES8388_ERROR_FAILED(this->write_byte(ES8388_ADCPOWER, 0x09));
-
-#ifdef USE_SELECT
-  if (this->dac_output_select_ != nullptr) {
-    auto dac_power = this->get_dac_power();
-    if (dac_power.has_value()) {
-      auto dac_power_str = this->dac_output_select_->at(dac_power.value());
-      if (dac_power_str.has_value()) {
-        this->dac_output_select_->publish_state(dac_power_str.value());
-      } else {
-        ESP_LOGW(TAG, "Unknown DAC output power value: %d", dac_power.value());
-      }
-    }
-  }
-  if (this->adc_input_mic_select_ != nullptr) {
-    auto mic_input = this->get_mic_input();
-    if (mic_input.has_value()) {
-      auto mic_input_str = this->adc_input_mic_select_->at(mic_input.value());
-      if (mic_input_str.has_value()) {
-        this->adc_input_mic_select_->publish_state(mic_input_str.value());
-      } else {
-        ESP_LOGW(TAG, "Unknown ADC input mic value: %d", mic_input.value());
-      }
-    }
-  }
-#endif
-}
-
-void ES8388::dump_config() {
-  ESP_LOGCONFIG(TAG, "ES8388 Audio Codec:");
-  LOG_I2C_DEVICE(this);
-#ifdef USE_SELECT
-  LOG_SELECT("  ", "DacOutputSelect", this->dac_output_select_);
-  LOG_SELECT("  ", "ADCInputMicSelect", this->adc_input_mic_select_);
-#endif
-
-  if (this->is_failed()) {
-    ESP_LOGCONFIG(TAG, "  Failed to initialize");
-    return;
-  }
-}
-
-bool ES8388::set_volume(float volume) {
-  volume = clamp(volume, 0.0f, 1.0f);
-  uint8_t value = remap<uint8_t, float>(volume, 0.0f, 1.0f, -96, 0);
-  ESP_LOGD(TAG, "Setting ES8388_DACCONTROL4 / ES8388_DACCONTROL5 to 0x%02X (volume: %f)", value, volume);
-  ES8388_ERROR_CHECK(this->write_byte(ES8388_DACCONTROL4, value));
-  ES8388_ERROR_CHECK(this->write_byte(ES8388_DACCONTROL5, value));
-
-  return true;
-}
-
-float ES8388::volume() {
-  uint8_t value;
-  ES8388_ERROR_CHECK(this->read_byte(ES8388_DACCONTROL4, &value));
-  return remap<float, uint8_t>(value, -96, 0, 0.0f, 1.0f);
-}
-
-bool ES8388::set_mute_state_(bool mute_state) {
-  uint8_t value = 0;
-
-  this->is_muted_ = mute_state;
-
-  ES8388_ERROR_CHECK(this->read_byte(ES8388_DACCONTROL3, &value));
-  ESP_LOGV(TAG, "Read ES8388_DACCONTROL3: 0x%02X", value);
-
-  if (mute_state) {
-    value = 0x3C;
-  }
-
-  ESP_LOGV(TAG, "Setting ES8388_DACCONTROL3 to 0x%02X (muted: %s)", value, YESNO(mute_state));
-  return this->write_byte(ES8388_DACCONTROL3, value);
-}
-
-// Set dac power output
-bool ES8388::set_dac_output(DacOutputLine line) {
-  uint8_t reg_out1 = 0;
-  uint8_t reg_out2 = 0;
-  uint8_t dac_power = 0;
-
-  // 0x00: -30dB , 0x1E: 0dB
-  switch (line) {
-    case DAC_OUTPUT_LINE1:
-      reg_out1 = 0x1E;
-      dac_power = ES8388_DAC_OUTPUT_LOUT1_ROUT1;
-      break;
-    case DAC_OUTPUT_LINE2:
-      reg_out2 = 0x1E;
-      dac_power = ES8388_DAC_OUTPUT_LOUT2_ROUT2;
-      break;
-    case DAC_OUTPUT_BOTH:
-      reg_out1 = 0x1E;
-      reg_out2 = 0x1E;
-      dac_power = ES8388_DAC_OUTPUT_BOTH;
-      break;
-    default:
-      ESP_LOGE(TAG, "Unknown DAC output line: %d", line);
-      return false;
-  };
-
-  ESP_LOGV(TAG, "Setting ES8388_DACPOWER to 0x%02X", dac_power);
-  ESP_LOGV(TAG, "Setting ES8388_DACCONTROL24 / ES8388_DACCONTROL25 to 0x%02X", reg_out1);
-  ESP_LOGV(TAG, "Setting ES8388_DACCONTROL26 / ES8388_DACCONTROL27  to 0x%02X", reg_out2);
-
-  ES8388_ERROR_CHECK(this->write_byte(ES8388_DACCONTROL24, reg_out1));  // LOUT1VOL
-  ES8388_ERROR_CHECK(this->write_byte(ES8388_DACCONTROL25, reg_out1));  // ROUT1VOL
-  ES8388_ERROR_CHECK(this->write_byte(ES8388_DACCONTROL26, reg_out2));  // LOUT2VOL
-  ES8388_ERROR_CHECK(this->write_byte(ES8388_DACCONTROL27, reg_out2));  // ROUT1VOL
-
-  return this->write_byte(ES8388_DACPOWER, dac_power);
-}
-
-optional<DacOutputLine> ES8388::get_dac_power() {
-  uint8_t dac_power;
-  if (!this->read_byte(ES8388_DACPOWER, &dac_power)) {
-    this->status_momentary_warning("Failed to read ES8388_DACPOWER");
-    return {};
-  }
-  switch (dac_power) {
-    case ES8388_DAC_OUTPUT_LOUT1_ROUT1:
-      return DAC_OUTPUT_LINE1;
-    case ES8388_DAC_OUTPUT_LOUT2_ROUT2:
-      return DAC_OUTPUT_LINE2;
-    case ES8388_DAC_OUTPUT_BOTH:
-      return DAC_OUTPUT_BOTH;
-    default:
-      return {};
-  }
-}
-
-// Set ADC input MIC
-bool ES8388::set_adc_input_mic(AdcInputMicLine line) {
-  uint8_t mic_input = 0;
-
-  switch (line) {
-    case ADC_INPUT_MIC_LINE1:
-      mic_input = ES8388_ADC_INPUT_LINPUT1_RINPUT1;
-      break;
-    case ADC_INPUT_MIC_LINE2:
-      mic_input = ES8388_ADC_INPUT_LINPUT2_RINPUT2;
-      break;
-    case ADC_INPUT_MIC_DIFFERENCE:
-      mic_input = ES8388_ADC_INPUT_DIFFERENCE;
-      break;
-    default:
-      ESP_LOGE(TAG, "Unknown ADC input mic line: %d", line);
-      return false;
-  }
-
-  ESP_LOGV(TAG, "Setting ES8388_ADCCONTROL2 to 0x%02X", mic_input);
-  ES8388_ERROR_CHECK(this->write_byte(ES8388_ADCCONTROL2, mic_input));
-
-  return true;
-}
-
-optional<AdcInputMicLine> ES8388::get_mic_input() {
-  uint8_t mic_input;
-  if (!this->read_byte(ES8388_ADCCONTROL2, &mic_input)) {
-    this->status_momentary_warning("Failed to read ES8388_ADCCONTROL2");
-    return {};
-  }
-  switch (mic_input) {
-    case ES8388_ADC_INPUT_LINPUT1_RINPUT1:
-      return ADC_INPUT_MIC_LINE1;
-    case ES8388_ADC_INPUT_LINPUT2_RINPUT2:
-      return ADC_INPUT_MIC_LINE2;
-    case ES8388_ADC_INPUT_DIFFERENCE:
-      return ADC_INPUT_MIC_DIFFERENCE;
-    default:
-      return {};
-  };
-}
-
-}  // namespace es8388
-}  // namespace esphome

esphome/components/es8388/es8388.h

@@ -1,81 +0,0 @@
-#pragma once
-
-#include <map>
-
-#include "esphome/components/audio_dac/audio_dac.h"
-#include "esphome/components/i2c/i2c.h"
-#include "esphome/core/component.h"
-#ifdef USE_SELECT
-#include "esphome/components/select/select.h"
-#endif
-
-#include "es8388_const.h"
-
-namespace esphome {
-namespace es8388 {
-
-enum DacOutputLine : uint8_t {
-  DAC_OUTPUT_LINE1,
-  DAC_OUTPUT_LINE2,
-  DAC_OUTPUT_BOTH,
-};
-
-enum AdcInputMicLine : uint8_t {
-  ADC_INPUT_MIC_LINE1,
-  ADC_INPUT_MIC_LINE2,
-  ADC_INPUT_MIC_DIFFERENCE,
-};
-
-class ES8388 : public audio_dac::AudioDac, public Component, public i2c::I2CDevice {
-#ifdef USE_SELECT
-  SUB_SELECT(dac_output)
-  SUB_SELECT(adc_input_mic)
-#endif
-
- public:
-  /////////////////////////
-  // Component overrides //
-  /////////////////////////
-
-  void setup() override;
-  float get_setup_priority() const override { return setup_priority::DATA; }
-  void dump_config() override;
-
-  ////////////////////////
-  // AudioDac overrides //
-  ////////////////////////
-
-  /// @brief Writes the volume out to the DAC
-  /// @param volume floating point between 0.0 and 1.0
-  /// @return True if successful and false otherwise
-  bool set_volume(float volume) override;
-
-  /// @brief Gets the current volume out from the DAC
-  /// @return floating point between 0.0 and 1.0
-  float volume() override;
-
-  /// @brief Disables mute for audio out
-  /// @return True if successful and false otherwise
-  bool set_mute_off() override { return this->set_mute_state_(false); }
-
-  /// @brief Enables mute for audio out
-  /// @return True if successful and false otherwise
-  bool set_mute_on() override { return this->set_mute_state_(true); }
-
-  bool is_muted() override { return this->is_muted_; }
-
-  optional<DacOutputLine> get_dac_power();
-  optional<AdcInputMicLine> get_mic_input();
-
-  bool set_dac_output(DacOutputLine line);
-  bool set_adc_input_mic(AdcInputMicLine line);
-
- protected:
-  /// @brief Mutes or unmutes the DAC audio out
-  /// @param mute_state True to mute, false to unmute
-  /// @return True if successful and false otherwise
-  bool set_mute_state_(bool mute_state);
-};
-
-}  // namespace es8388
-}  // namespace esphome

esphome/components/es8388/es8388_const.h

@@ -1,83 +0,0 @@
-#pragma once
-#include <cstdint>
-
-namespace esphome {
-namespace es8388 {
-
-/* ES8388 register */
-static const uint8_t ES8388_CONTROL1 = 0x00;
-static const uint8_t ES8388_CONTROL2 = 0x01;
-
-static const uint8_t ES8388_CHIPPOWER = 0x02;
-
-static const uint8_t ES8388_ADCPOWER = 0x03;
-static const uint8_t ES8388_DACPOWER = 0x04;
-
-static const uint8_t ES8388_CHIPLOPOW1 = 0x05;
-static const uint8_t ES8388_CHIPLOPOW2 = 0x06;
-
-static const uint8_t ES8388_ANAVOLMANAG = 0x07;
-
-static const uint8_t ES8388_MASTERMODE = 0x08;
-
-/* ADC */
-static const uint8_t ES8388_ADCCONTROL1 = 0x09;
-static const uint8_t ES8388_ADCCONTROL2 = 0x0a;
-static const uint8_t ES8388_ADCCONTROL3 = 0x0b;
-static const uint8_t ES8388_ADCCONTROL4 = 0x0c;
-static const uint8_t ES8388_ADCCONTROL5 = 0x0d;
-static const uint8_t ES8388_ADCCONTROL6 = 0x0e;
-static const uint8_t ES8388_ADCCONTROL7 = 0x0f;
-static const uint8_t ES8388_ADCCONTROL8 = 0x10;
-static const uint8_t ES8388_ADCCONTROL9 = 0x11;
-static const uint8_t ES8388_ADCCONTROL10 = 0x12;
-static const uint8_t ES8388_ADCCONTROL11 = 0x13;
-static const uint8_t ES8388_ADCCONTROL12 = 0x14;
-static const uint8_t ES8388_ADCCONTROL13 = 0x15;
-static const uint8_t ES8388_ADCCONTROL14 = 0x16;
-/* DAC */
-static const uint8_t ES8388_DACCONTROL1 = 0x17;
-static const uint8_t ES8388_DACCONTROL2 = 0x18;
-static const uint8_t ES8388_DACCONTROL3 = 0x19;
-static const uint8_t ES8388_DACCONTROL4 = 0x1a;
-static const uint8_t ES8388_DACCONTROL5 = 0x1b;
-static const uint8_t ES8388_DACCONTROL6 = 0x1c;
-static const uint8_t ES8388_DACCONTROL7 = 0x1d;
-static const uint8_t ES8388_DACCONTROL8 = 0x1e;
-static const uint8_t ES8388_DACCONTROL9 = 0x1f;
-static const uint8_t ES8388_DACCONTROL10 = 0x20;
-static const uint8_t ES8388_DACCONTROL11 = 0x21;
-static const uint8_t ES8388_DACCONTROL12 = 0x22;
-static const uint8_t ES8388_DACCONTROL13 = 0x23;
-static const uint8_t ES8388_DACCONTROL14 = 0x24;
-static const uint8_t ES8388_DACCONTROL15 = 0x25;
-static const uint8_t ES8388_DACCONTROL16 = 0x26;
-static const uint8_t ES8388_DACCONTROL17 = 0x27;
-static const uint8_t ES8388_DACCONTROL18 = 0x28;
-static const uint8_t ES8388_DACCONTROL19 = 0x29;
-static const uint8_t ES8388_DACCONTROL20 = 0x2a;
-static const uint8_t ES8388_DACCONTROL21 = 0x2b;
-static const uint8_t ES8388_DACCONTROL22 = 0x2c;
-static const uint8_t ES8388_DACCONTROL23 = 0x2d;
-static const uint8_t ES8388_DACCONTROL24 = 0x2e;
-static const uint8_t ES8388_DACCONTROL25 = 0x2f;
-static const uint8_t ES8388_DACCONTROL26 = 0x30;
-static const uint8_t ES8388_DACCONTROL27 = 0x31;
-static const uint8_t ES8388_DACCONTROL28 = 0x32;
-static const uint8_t ES8388_DACCONTROL29 = 0x33;
-static const uint8_t ES8388_DACCONTROL30 = 0x34;
-
-static const uint8_t ES8388_DAC_OUTPUT_NONE = 0xC0;  // ALL DAC DOWN
-
-static const uint8_t ES8388_DAC_OUTPUT_LOUT1_ROUT1 = 0x30;
-static const uint8_t ES8388_DAC_OUTPUT_LOUT2_ROUT2 = 0x0C;
-static const uint8_t ES8388_DAC_OUTPUT_BOTH = 0x3C;
-
-static const uint8_t ES8388_ADC_INPUT_LINPUT1_RINPUT1 = 0x00;
-static const uint8_t ES8388_ADC_INPUT_MIC1 = 0x05;
-static const uint8_t ES8388_ADC_INPUT_MIC2 = 0x06;
-static const uint8_t ES8388_ADC_INPUT_LINPUT2_RINPUT2 = 0x50;
-static const uint8_t ES8388_ADC_INPUT_DIFFERENCE = 0xf0;
-
-}  // namespace es8388
-}  // namespace esphome

esphome/components/es8388/select/__init__.py

@@ -1,47 +0,0 @@
-import esphome.codegen as cg
-from esphome.components import select
-import esphome.config_validation as cv
-from esphome.const import ENTITY_CATEGORY_CONFIG, ICON_CHIP  # noqa: F401
-
-from ..audio_dac import CONF_ES8388_ID, ES8388, es8388_ns
-
-CONF_DAC_OUTPUT = "dac_output"
-CONF_ADC_INPUT_MIC = "adc_input_mic"
-
-DacOutputSelect = es8388_ns.class_("DacOutputSelect", select.Select)
-ADCInputMicSelect = es8388_ns.class_("ADCInputMicSelect", select.Select)
-
-CONFIG_SCHEMA = cv.All(
-    {
-        cv.GenerateID(CONF_ES8388_ID): cv.use_id(ES8388),
-        cv.Optional(CONF_DAC_OUTPUT): select.select_schema(
-            DacOutputSelect,
-            entity_category=ENTITY_CATEGORY_CONFIG,
-            icon=ICON_CHIP,
-        ),
-        cv.Optional(CONF_ADC_INPUT_MIC): select.select_schema(
-            ADCInputMicSelect,
-            entity_category=ENTITY_CATEGORY_CONFIG,
-            icon=ICON_CHIP,
-        ),
-    }
-)
-
-
-async def to_code(config):
-    parent = await cg.get_variable(config[CONF_ES8388_ID])
-    if dac_output_config := config.get(CONF_DAC_OUTPUT):
-        s = await select.new_select(
-            dac_output_config,
-            options=["LINE1", "LINE2", "BOTH"],
-        )
-        await cg.register_parented(s, parent)
-        cg.add(parent.set_dac_output_select(s))
-
-    if adc_input_mic_config := config.get(CONF_ADC_INPUT_MIC):
-        s = await select.new_select(
-            adc_input_mic_config,
-            options=["LINE1", "LINE2", "DIFFERENCE"],
-        )
-        await cg.register_parented(s, parent)
-        cg.add(parent.set_adc_input_mic_select(s))

esphome/components/es8388/select/adc_input_mic_select.cpp

@@ -1,12 +0,0 @@
-#include "adc_input_mic_select.h"
-
-namespace esphome {
-namespace es8388 {
-
-void ADCInputMicSelect::control(const std::string &value) {
-  this->publish_state(value);
-  this->parent_->set_adc_input_mic(static_cast<AdcInputMicLine>(this->index_of(value).value()));
-}
-
-}  // namespace es8388
-}  // namespace esphome

esphome/components/es8388/select/adc_input_mic_select.h

@@ -1,15 +0,0 @@
-#pragma once
-
-#include "esphome/components/es8388/es8388.h"
-#include "esphome/components/select/select.h"
-
-namespace esphome {
-namespace es8388 {
-
-class ADCInputMicSelect : public select::Select, public Parented<ES8388> {
- protected:
-  void control(const std::string &value) override;
-};
-
-}  // namespace es8388
-}  // namespace esphome

esphome/components/es8388/select/dac_output_select.cpp

@@ -1,12 +0,0 @@
-#include "dac_output_select.h"
-
-namespace esphome {
-namespace es8388 {
-
-void DacOutputSelect::control(const std::string &value) {
-  this->publish_state(value);
-  this->parent_->set_dac_output(static_cast<DacOutputLine>(this->index_of(value).value()));
-}
-
-}  // namespace es8388
-}  // namespace esphome

esphome/components/es8388/select/dac_output_select.h

@@ -1,15 +0,0 @@
-#pragma once
-
-#include "esphome/components/es8388/es8388.h"
-#include "esphome/components/select/select.h"
-
-namespace esphome {
-namespace es8388 {
-
-class DacOutputSelect : public select::Select, public Parented<ES8388> {
- protected:
-  void control(const std::string &value) override;
-};
-
-}  // namespace es8388
-}  // namespace esphome

esphome/components/esp32/boards.py

@@ -2,6 +2,7 @@ from .const import (
     VARIANT_ESP32,
     VARIANT_ESP32C2,
     VARIANT_ESP32C3,
+    VARIANT_ESP32C5,
     VARIANT_ESP32C6,
     VARIANT_ESP32H2,
     VARIANT_ESP32P4,
@@ -1339,7 +1340,17 @@ ESP32_BOARD_PINS = {
 }
 
 """
-BOARDS generated with script/generate-esp32-boards.py
+BOARDS generated with:
+
+git clone https://github.com/platformio/platform-espressif32
+for x in platform-espressif32/boards/*.json; do
+  mcu=$(jq -r .build.mcu <"$x");
+  name=$(jq -r .name <"$x");
+  fname=$(basename "$x")
+  board="${fname%.*}"
+  variant=$(echo "$mcu" | tr '[:lower:]' '[:upper:]')
+  echo "    \"$board\": {\"name\": \"$name\", \"variant\": VARIANT_${variant},},"
+done | sort
 """
 
 BOARDS = {
@@ -1351,10 +1362,6 @@ BOARDS = {
         "name": "Adafruit pyCamera S3",
         "variant": VARIANT_ESP32S3,
     },
-    "adafruit_feather_esp32_v2": {
-        "name": "Adafruit Feather ESP32 V2",
-        "variant": VARIANT_ESP32,
-    },
     "adafruit_feather_esp32c6": {
         "name": "Adafruit Feather ESP32-C6",
         "variant": VARIANT_ESP32C6,
@@ -1387,6 +1394,10 @@ BOARDS = {
         "name": "Adafruit Feather ESP32-S3 TFT",
         "variant": VARIANT_ESP32S3,
     },
+    "adafruit_feather_esp32_v2": {
+        "name": "Adafruit Feather ESP32 V2",
+        "variant": VARIANT_ESP32,
+    },
     "adafruit_funhouse_esp32s2": {
         "name": "Adafruit FunHouse",
         "variant": VARIANT_ESP32S2,
@@ -1411,14 +1422,14 @@ BOARDS = {
         "name": "Adafruit Metro ESP32-S3",
         "variant": VARIANT_ESP32S3,
     },
-    "adafruit_qtpy_esp32": {
-        "name": "Adafruit QT Py ESP32",
-        "variant": VARIANT_ESP32,
-    },
     "adafruit_qtpy_esp32c3": {
         "name": "Adafruit QT Py ESP32-C3",
         "variant": VARIANT_ESP32C3,
     },
+    "adafruit_qtpy_esp32": {
+        "name": "Adafruit QT Py ESP32",
+        "variant": VARIANT_ESP32,
+    },
     "adafruit_qtpy_esp32s2": {
         "name": "Adafruit QT Py ESP32-S2",
         "variant": VARIANT_ESP32S2,
@@ -1467,14 +1478,14 @@ BOARDS = {
         "name": "Smart Bee Data Logger",
         "variant": VARIANT_ESP32S3,
     },
-    "bee_motion": {
-        "name": "Smart Bee Motion",
-        "variant": VARIANT_ESP32S2,
-    },
     "bee_motion_mini": {
         "name": "Smart Bee Motion Mini",
         "variant": VARIANT_ESP32C3,
     },
+    "bee_motion": {
+        "name": "Smart Bee Motion",
+        "variant": VARIANT_ESP32S2,
+    },
     "bee_motion_s3": {
         "name": "Smart Bee Motion S3",
         "variant": VARIANT_ESP32S3,
@@ -1507,10 +1518,6 @@ BOARDS = {
         "name": "D-duino-32",
         "variant": VARIANT_ESP32,
     },
-    "deneyapkart": {
-        "name": "Deneyap Kart",
-        "variant": VARIANT_ESP32,
-    },
     "deneyapkart1A": {
         "name": "Deneyap Kart 1A",
         "variant": VARIANT_ESP32,
@@ -1523,6 +1530,10 @@ BOARDS = {
         "name": "Deneyap Kart G",
         "variant": VARIANT_ESP32C3,
     },
+    "deneyapkart": {
+        "name": "Deneyap Kart",
+        "variant": VARIANT_ESP32,
+    },
     "deneyapmini": {
         "name": "Deneyap Mini",
         "variant": VARIANT_ESP32S2,
@@ -1563,8 +1574,8 @@ BOARDS = {
         "name": "Seeed Studio Edgebox-ESP-100",
         "variant": VARIANT_ESP32S3,
     },
-    "esp-wrover-kit": {
-        "name": "Espressif ESP-WROVER-KIT",
+    "esp320": {
+        "name": "Electronic SweetPeas ESP320",
         "variant": VARIANT_ESP32,
     },
     "esp32-c2-devkitm-1": {
@@ -1583,6 +1594,10 @@ BOARDS = {
         "name": "Ai-Thinker ESP-C3-M1-I-Kit",
         "variant": VARIANT_ESP32C3,
     },
+    "esp32-c5-devkitc-1": {
+        "name": "Espressif ESP32-C5-DevKitC-1",
+        "variant": VARIANT_ESP32C5,
+    },
     "esp32-c6-devkitc-1": {
         "name": "Espressif ESP32-C6-DevKitC-1",
         "variant": VARIANT_ESP32C6,
@@ -1591,10 +1606,26 @@ BOARDS = {
         "name": "Espressif ESP32-C6-DevKitM-1",
         "variant": VARIANT_ESP32C6,
     },
+    "esp32cam": {
+        "name": "AI Thinker ESP32-CAM",
+        "variant": VARIANT_ESP32,
+    },
     "esp32-devkitlipo": {
         "name": "OLIMEX ESP32-DevKit-LiPo",
         "variant": VARIANT_ESP32,
     },
+    "esp32dev": {
+        "name": "Espressif ESP32 Dev Module",
+        "variant": VARIANT_ESP32,
+    },
+    "esp32doit-devkit-v1": {
+        "name": "DOIT ESP32 DEVKIT V1",
+        "variant": VARIANT_ESP32,
+    },
+    "esp32doit-espduino": {
+        "name": "DOIT ESPduino32",
+        "variant": VARIANT_ESP32,
+    },
     "esp32-evb": {
         "name": "OLIMEX ESP32-EVB",
         "variant": VARIANT_ESP32,
@@ -1619,14 +1650,14 @@ BOARDS = {
         "name": "Espressif ESP32-PICO-DevKitM-2",
         "variant": VARIANT_ESP32,
     },
-    "esp32-poe": {
-        "name": "OLIMEX ESP32-PoE",
-        "variant": VARIANT_ESP32,
-    },
     "esp32-poe-iso": {
         "name": "OLIMEX ESP32-PoE-ISO",
         "variant": VARIANT_ESP32,
     },
+    "esp32-poe": {
+        "name": "OLIMEX ESP32-PoE",
+        "variant": VARIANT_ESP32,
+    },
     "esp32-pro": {
         "name": "OLIMEX ESP32-PRO",
         "variant": VARIANT_ESP32,
@@ -1643,46 +1674,6 @@ BOARDS = {
         "name": "Espressif ESP32-S2-Saola-1",
         "variant": VARIANT_ESP32S2,
     },
-    "esp32-s3-devkitc-1": {
-        "name": "Espressif ESP32-S3-DevKitC-1-N8 (8 MB QD, No PSRAM)",
-        "variant": VARIANT_ESP32S3,
-    },
-    "esp32-s3-devkitm-1": {
-        "name": "Espressif ESP32-S3-DevKitM-1",
-        "variant": VARIANT_ESP32S3,
-    },
-    "esp32-solo1": {
-        "name": "Espressif Generic ESP32-solo1 4M Flash",
-        "variant": VARIANT_ESP32,
-    },
-    "esp320": {
-        "name": "Electronic SweetPeas ESP320",
-        "variant": VARIANT_ESP32,
-    },
-    "esp32cam": {
-        "name": "AI Thinker ESP32-CAM",
-        "variant": VARIANT_ESP32,
-    },
-    "esp32dev": {
-        "name": "Espressif ESP32 Dev Module",
-        "variant": VARIANT_ESP32,
-    },
-    "esp32doit-devkit-v1": {
-        "name": "DOIT ESP32 DEVKIT V1",
-        "variant": VARIANT_ESP32,
-    },
-    "esp32doit-espduino": {
-        "name": "DOIT ESPduino32",
-        "variant": VARIANT_ESP32,
-    },
-    "esp32s3_120_16_8-qio_opi": {
-        "name": "ESP32-S3 16MB QIO, 8MB OPI PSRAM",
-        "variant": VARIANT_ESP32S3,
-    },
-    "esp32s3_powerfeather": {
-        "name": "ESP32-S3 PowerFeather",
-        "variant": VARIANT_ESP32S3,
-    },
     "esp32s3box": {
         "name": "Espressif ESP32-S3-Box",
         "variant": VARIANT_ESP32S3,
@@ -1691,10 +1682,26 @@ BOARDS = {
         "name": "ESP32S3 CAM LCD",
         "variant": VARIANT_ESP32S3,
     },
+    "esp32-s3-devkitc-1": {
+        "name": "Espressif ESP32-S3-DevKitC-1-N8 (8 MB QD, No PSRAM)",
+        "variant": VARIANT_ESP32S3,
+    },
+    "esp32-s3-devkitm-1": {
+        "name": "Espressif ESP32-S3-DevKitM-1",
+        "variant": VARIANT_ESP32S3,
+    },
+    "esp32s3_powerfeather": {
+        "name": "ESP32-S3 PowerFeather",
+        "variant": VARIANT_ESP32S3,
+    },
     "esp32s3usbotg": {
         "name": "Espressif ESP32-S3-USB-OTG",
         "variant": VARIANT_ESP32S3,
     },
+    "esp32-solo1": {
+        "name": "Espressif Generic ESP32-solo1 4M Flash",
+        "variant": VARIANT_ESP32,
+    },
     "esp32thing": {
         "name": "SparkFun ESP32 Thing",
         "variant": VARIANT_ESP32,
@@ -1719,6 +1726,10 @@ BOARDS = {
         "name": "ESPino32",
         "variant": VARIANT_ESP32,
     },
+    "esp-wrover-kit": {
+        "name": "Espressif ESP-WROVER-KIT",
+        "variant": VARIANT_ESP32,
+    },
     "etboard": {
         "name": "ETBoard",
         "variant": VARIANT_ESP32,
@@ -1747,14 +1758,6 @@ BOARDS = {
         "name": "Franzininho WiFi MSC",
         "variant": VARIANT_ESP32S2,
     },
-    "freenove_esp32_s3_wroom": {
-        "name": "Freenove ESP32-S3 WROOM N8R8 (8MB Flash / 8MB PSRAM)",
-        "variant": VARIANT_ESP32S3,
-    },
-    "freenove_esp32_wrover": {
-        "name": "Freenove ESP32-Wrover",
-        "variant": VARIANT_ESP32,
-    },
     "frogboard": {
         "name": "Frog Board ESP32",
         "variant": VARIANT_ESP32,
@@ -1771,10 +1774,6 @@ BOARDS = {
         "name": "Heltec WiFi Kit 32 (V3)",
         "variant": VARIANT_ESP32S3,
     },
-    "heltec_wifi_kit_32_v2": {
-        "name": "Heltec WiFi Kit 32 (V2)",
-        "variant": VARIANT_ESP32,
-    },
     "heltec_wifi_lora_32": {
         "name": "Heltec WiFi LoRa 32",
         "variant": VARIANT_ESP32,
@@ -1787,14 +1786,14 @@ BOARDS = {
         "name": "Heltec WiFi LoRa 32 (V3)",
         "variant": VARIANT_ESP32S3,
     },
-    "heltec_wireless_stick": {
-        "name": "Heltec Wireless Stick",
-        "variant": VARIANT_ESP32,
-    },
     "heltec_wireless_stick_lite": {
         "name": "Heltec Wireless Stick Lite",
         "variant": VARIANT_ESP32,
     },
+    "heltec_wireless_stick": {
+        "name": "Heltec Wireless Stick",
+        "variant": VARIANT_ESP32,
+    },
     "honeylemon": {
         "name": "HONEYLemon",
         "variant": VARIANT_ESP32,
@@ -1807,14 +1806,6 @@ BOARDS = {
         "name": "Hornbill ESP32 Minima",
         "variant": VARIANT_ESP32,
     },
-    "huidu_hd_wf2": {
-        "name": "Huidu HD-WF2",
-        "variant": VARIANT_ESP32S3,
-    },
-    "huidu_hd_wf4": {
-        "name": "Huidu HD-WF4",
-        "variant": VARIANT_ESP32S3,
-    },
     "imbrios-logsens-v1p1": {
         "name": "Imbrios LogSens V1P1",
         "variant": VARIANT_ESP32,
@@ -1847,10 +1838,6 @@ BOARDS = {
         "name": "ArtronShop IOXESP32PS",
         "variant": VARIANT_ESP32,
     },
-    "jczn_2432s028r": {
-        "name": "ESP32-2432S028R CYD",
-        "variant": VARIANT_ESP32,
-    },
     "kb32-ft": {
         "name": "MakerAsia KB32-FT",
         "variant": VARIANT_ESP32,
@@ -1875,10 +1862,6 @@ BOARDS = {
         "name": "LilyGo T-Display-S3",
         "variant": VARIANT_ESP32S3,
     },
-    "lilygo-t3-s3": {
-        "name": "LilyGo T3-S3",
-        "variant": VARIANT_ESP32S3,
-    },
     "lionbit": {
         "name": "Lion:Bit Dev Board",
         "variant": VARIANT_ESP32,
@@ -1887,14 +1870,14 @@ BOARDS = {
         "name": "Lion:Bit S3 STEM Dev Board",
         "variant": VARIANT_ESP32S3,
     },
-    "lolin32": {
-        "name": "WEMOS LOLIN32",
-        "variant": VARIANT_ESP32,
-    },
     "lolin32_lite": {
         "name": "WEMOS LOLIN32 Lite",
         "variant": VARIANT_ESP32,
     },
+    "lolin32": {
+        "name": "WEMOS LOLIN32",
+        "variant": VARIANT_ESP32,
+    },
     "lolin_c3_mini": {
         "name": "WEMOS LOLIN C3 Mini",
         "variant": VARIANT_ESP32C3,
@@ -1915,30 +1898,26 @@ BOARDS = {
         "name": "WEMOS LOLIN S2 PICO",
         "variant": VARIANT_ESP32S2,
     },
-    "lolin_s3": {
-        "name": "WEMOS LOLIN S3",
-        "variant": VARIANT_ESP32S3,
-    },
     "lolin_s3_mini": {
         "name": "WEMOS LOLIN S3 Mini",
         "variant": VARIANT_ESP32S3,
     },
-    "lolin_s3_mini_pro": {
-        "name": "WEMOS LOLIN S3 Mini Pro",
+    "lolin_s3": {
+        "name": "WEMOS LOLIN S3",
         "variant": VARIANT_ESP32S3,
     },
     "lolin_s3_pro": {
         "name": "WEMOS LOLIN S3 PRO",
         "variant": VARIANT_ESP32S3,
     },
-    "lopy": {
-        "name": "Pycom LoPy",
-        "variant": VARIANT_ESP32,
-    },
     "lopy4": {
         "name": "Pycom LoPy4",
         "variant": VARIANT_ESP32,
     },
+    "lopy": {
+        "name": "Pycom LoPy",
+        "variant": VARIANT_ESP32,
+    },
     "m5stack-atom": {
         "name": "M5Stack-ATOM",
         "variant": VARIANT_ESP32,
@@ -1947,16 +1926,16 @@ BOARDS = {
         "name": "M5Stack AtomS3",
         "variant": VARIANT_ESP32S3,
     },
-    "m5stack-core-esp32": {
-        "name": "M5Stack Core ESP32",
+    "m5stack-core2": {
+        "name": "M5Stack Core2",
         "variant": VARIANT_ESP32,
     },
     "m5stack-core-esp32-16M": {
         "name": "M5Stack Core ESP32 16M",
         "variant": VARIANT_ESP32,
     },
-    "m5stack-core2": {
-        "name": "M5Stack Core2",
+    "m5stack-core-esp32": {
+        "name": "M5Stack Core ESP32",
         "variant": VARIANT_ESP32,
     },
     "m5stack-coreink": {
@@ -1975,6 +1954,10 @@ BOARDS = {
         "name": "M5Stack GREY ESP32",
         "variant": VARIANT_ESP32,
     },
+    "m5stack_paper": {
+        "name": "M5Stack Paper",
+        "variant": VARIANT_ESP32,
+    },
     "m5stack-stamps3": {
         "name": "M5Stack StampS3",
         "variant": VARIANT_ESP32S3,
@@ -1987,10 +1970,6 @@ BOARDS = {
         "name": "M5Stack Timer CAM",
         "variant": VARIANT_ESP32,
     },
-    "m5stack_paper": {
-        "name": "M5Stack Paper",
-        "variant": VARIANT_ESP32,
-    },
     "m5stamp-pico": {
         "name": "M5Stamp-Pico",
         "variant": VARIANT_ESP32,
@@ -2059,14 +2038,14 @@ BOARDS = {
         "name": "Node32s",
         "variant": VARIANT_ESP32,
     },
-    "nodemcu-32s": {
-        "name": "NodeMCU-32S",
-        "variant": VARIANT_ESP32,
-    },
     "nodemcu-32s2": {
         "name": "Ai-Thinker NodeMCU-32S2 (ESP-12K)",
         "variant": VARIANT_ESP32S2,
     },
+    "nodemcu-32s": {
+        "name": "NodeMCU-32S",
+        "variant": VARIANT_ESP32,
+    },
     "nscreen-32": {
         "name": "YeaCreate NSCREEN-32",
         "variant": VARIANT_ESP32,
@@ -2115,22 +2094,10 @@ BOARDS = {
         "name": "RoboHeart Hercules",
         "variant": VARIANT_ESP32,
     },
-    "rymcu-esp32-s3-devkitc-1": {
-        "name": "RYMCU ESP32-S3-DevKitC-1-N8R2 (8 MB QD, 2 MB PSRAM)",
-        "variant": VARIANT_ESP32S3,
-    },
-    "s_odi_ultra": {
-        "name": "S.ODI Ultra v1",
-        "variant": VARIANT_ESP32,
-    },
     "seeed_xiao_esp32c3": {
         "name": "Seeed Studio XIAO ESP32C3",
         "variant": VARIANT_ESP32C3,
     },
-    "seeed_xiao_esp32c6": {
-        "name": "Seeed Studio XIAO ESP32C6",
-        "variant": VARIANT_ESP32C6,
-    },
     "seeed_xiao_esp32s3": {
         "name": "Seeed Studio XIAO ESP32S3",
         "variant": VARIANT_ESP32S3,
@@ -2147,38 +2114,34 @@ BOARDS = {
         "name": "SG-O AirMon",
         "variant": VARIANT_ESP32,
     },
-    "sparkfun_esp32_iot_redboard": {
-        "name": "SparkFun ESP32 IoT RedBoard",
+    "s_odi_ultra": {
+        "name": "S.ODI Ultra v1",
         "variant": VARIANT_ESP32,
     },
     "sparkfun_esp32c6_thing_plus": {
         "name": "Sparkfun ESP32-C6 Thing Plus",
         "variant": VARIANT_ESP32C6,
     },
+    "sparkfun_esp32_iot_redboard": {
+        "name": "SparkFun ESP32 IoT RedBoard",
+        "variant": VARIANT_ESP32,
+    },
     "sparkfun_esp32micromod": {
         "name": "SparkFun ESP32 MicroMod",
         "variant": VARIANT_ESP32,
     },
+    "sparkfun_esp32s2_thing_plus_c": {
+        "name": "SparkFun ESP32 Thing Plus C",
+        "variant": VARIANT_ESP32,
+    },
     "sparkfun_esp32s2_thing_plus": {
         "name": "SparkFun ESP32-S2 Thing Plus",
         "variant": VARIANT_ESP32S2,
     },
-    "sparkfun_esp32s2_thing_plus_c": {
-        "name": "SparkFun ESP32 Thing Plus C",
-        "variant": VARIANT_ESP32,
-    },
-    "sparkfun_esp32s3_thing_plus": {
-        "name": "SPARKFUN_ESP32S3_THING_PLUS",
-        "variant": VARIANT_ESP32S3,
-    },
     "sparkfun_lora_gateway_1-channel": {
         "name": "SparkFun LoRa Gateway 1-Channel",
         "variant": VARIANT_ESP32,
     },
-    "sparkfun_qwiic_pocket_esp32c6": {
-        "name": "SparkFun ESP32-C6 Qwiic Pocket",
-        "variant": VARIANT_ESP32C6,
-    },
     "tamc_termod_s3": {
         "name": "TAMC Termod S3",
         "variant": VARIANT_ESP32S3,
@@ -2187,10 +2150,6 @@ BOARDS = {
         "name": "Unexpected Maker TinyPICO",
         "variant": VARIANT_ESP32,
     },
-    "trueverit-iot-driver": {
-        "name": "Trueverit ESP32 Universal IoT Driver",
-        "variant": VARIANT_ESP32,
-    },
     "trueverit-iot-driver-mk2": {
         "name": "Trueverit ESP32 Universal IoT Driver MK II",
         "variant": VARIANT_ESP32,
@@ -2199,28 +2158,20 @@ BOARDS = {
         "name": "Trueverit ESP32 Universal IoT Driver MK III",
         "variant": VARIANT_ESP32,
     },
-    "ttgo-lora32-v1": {
-        "name": "TTGO LoRa32-OLED V1",
+    "trueverit-iot-driver": {
+        "name": "Trueverit ESP32 Universal IoT Driver",
         "variant": VARIANT_ESP32,
     },
-    "ttgo-lora32-v2": {
-        "name": "TTGO LoRa32-OLED V2",
+    "ttgo-lora32-v1": {
+        "name": "TTGO LoRa32-OLED V1",
         "variant": VARIANT_ESP32,
     },
     "ttgo-lora32-v21": {
         "name": "TTGO LoRa32-OLED v2.1.6",
         "variant": VARIANT_ESP32,
     },
-    "ttgo-t-beam": {
-        "name": "TTGO T-Beam",
-        "variant": VARIANT_ESP32,
-    },
-    "ttgo-t-oi-plus": {
-        "name": "TTGO T-OI PLUS RISC-V ESP32-C3",
-        "variant": VARIANT_ESP32C3,
-    },
-    "ttgo-t-watch": {
-        "name": "TTGO T-Watch",
+    "ttgo-lora32-v2": {
+        "name": "TTGO LoRa32-OLED V2",
         "variant": VARIANT_ESP32,
     },
     "ttgo-t1": {
@@ -2235,6 +2186,18 @@ BOARDS = {
         "name": "TTGO T7 V1.4 Mini32",
         "variant": VARIANT_ESP32,
     },
+    "ttgo-t-beam": {
+        "name": "TTGO T-Beam",
+        "variant": VARIANT_ESP32,
+    },
+    "ttgo-t-oi-plus": {
+        "name": "TTGO T-OI PLUS RISC-V ESP32-C3",
+        "variant": VARIANT_ESP32C3,
+    },
+    "ttgo-t-watch": {
+        "name": "TTGO T-Watch",
+        "variant": VARIANT_ESP32,
+    },
     "turta_iot_node": {
         "name": "Turta IoT Node",
         "variant": VARIANT_ESP32,
@@ -2307,17 +2270,9 @@ BOARDS = {
         "name": "SQFMI Watchy v2.0",
         "variant": VARIANT_ESP32,
     },
-    "waveshare_esp32_s3_zero": {
-        "name": "Waveshare ESP32-S3-Zero",
-        "variant": VARIANT_ESP32S3,
-    },
-    "waveshare_esp32s3_touch_lcd_128": {
-        "name": "Waveshare ESP32-S3-Touch-LCD-1.28 (16 MB QD, 2MB PSRAM)",
-        "variant": VARIANT_ESP32S3,
-    },
-    "weactstudio_esp32c3coreboard": {
-        "name": "WeAct Studio ESP32C3CoreBoard",
-        "variant": VARIANT_ESP32C3,
+    "wemosbat": {
+        "name": "WeMos WiFi and Bluetooth Battery",
+        "variant": VARIANT_ESP32,
     },
     "wemos_d1_mini32": {
         "name": "WEMOS D1 MINI ESP32",
@@ -2327,10 +2282,6 @@ BOARDS = {
         "name": "WEMOS D1 R32",
         "variant": VARIANT_ESP32,
     },
-    "wemosbat": {
-        "name": "WeMos WiFi and Bluetooth Battery",
-        "variant": VARIANT_ESP32,
-    },
     "wesp32": {
         "name": "Silicognition wESP32",
         "variant": VARIANT_ESP32,
@@ -2339,14 +2290,14 @@ BOARDS = {
         "name": "Widora AIR",
         "variant": VARIANT_ESP32,
     },
-    "wifiduino32": {
-        "name": "Blinker WiFiduino32",
-        "variant": VARIANT_ESP32,
-    },
     "wifiduino32c3": {
         "name": "Blinker WiFiduinoV2 (ESP32-C3)",
         "variant": VARIANT_ESP32C3,
     },
+    "wifiduino32": {
+        "name": "Blinker WiFiduino32",
+        "variant": VARIANT_ESP32,
+    },
     "wifiduino32s3": {
         "name": "Blinker WiFiduino32S3",
         "variant": VARIANT_ESP32S3,
@@ -2355,32 +2306,12 @@ BOARDS = {
         "name": "Pycom WiPy3",
         "variant": VARIANT_ESP32,
     },
-    "ws_esp32_s3_matrix": {
-        "name": "Waveshare ESP32-S3-Matrix",
-        "variant": VARIANT_ESP32S3,
-    },
     "wt32-eth01": {
         "name": "Wireless-Tag WT32-ETH01 Ethernet Module",
         "variant": VARIANT_ESP32,
     },
-    "wt32-sc01-plus": {
-        "name": "wt32-sc01-plus",
-        "variant": VARIANT_ESP32S3,
-    },
     "xinabox_cw02": {
         "name": "XinaBox CW02",
         "variant": VARIANT_ESP32,
     },
-    "yb_esp32s3_amp_v2": {
-        "name": "YelloByte YB-ESP32-S3-AMP (Rev.2)",
-        "variant": VARIANT_ESP32S3,
-    },
-    "yb_esp32s3_amp_v3": {
-        "name": "YelloByte YB-ESP32-S3-AMP (Rev.3)",
-        "variant": VARIANT_ESP32S3,
-    },
-    "yb_esp32s3_eth": {
-        "name": "YelloByte YB-ESP32-S3-ETH",
-        "variant": VARIANT_ESP32S3,
-    },
 }

esphome/components/esp32_ble/ble.cpp

@@ -28,7 +28,7 @@ static RAMAllocator<BLEEvent> EVENT_ALLOCATOR(  // NOLINT(cppcoreguidelines-avoi
 
 void ESP32BLE::setup() {
   global_ble = this;
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up BLE...");
 
   if (!ble_pre_setup_()) {
     ESP_LOGE(TAG, "BLE could not be prepared for configuration");

esphome/components/esp32_dac/esp32_dac.cpp

@@ -20,7 +20,7 @@ static constexpr uint8_t DAC0_PIN = 25;
 static const char *const TAG = "esp32_dac";
 
 void ESP32DAC::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up ESP32 DAC Output...");
   this->pin_->setup();
   this->turn_off();
 

esphome/components/esp32_rmt_led_strip/led_strip.cpp

@@ -22,7 +22,7 @@ static const uint8_t RMT_CLK_DIV = 2;
 #endif
 
 void ESP32RMTLEDStripLightOutput::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
+  ESP_LOGCONFIG(TAG, "Setting up ESP32 LED Strip...");
 
   size_t buffer_size = this->get_buffer_size_();