Merge branch 'dev' into less_than_64_do_not_calc

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

.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.17.0
+      uses: docker/build-push-action@v6.18.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.17.0
+      uses: docker/build-push-action@v6.18.0
       env:
         DOCKER_BUILD_SUMMARY: false
         DOCKER_BUILD_RECORD_UPLOAD: false

CODEOWNERS

@@ -139,6 +139,7 @@ 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/components/a4988/a4988.cpp

@@ -7,7 +7,7 @@ namespace a4988 {
 static const char *const TAG = "a4988.stepper";
 
 void A4988::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up A4988...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   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, "Setting up absolute humidity '%s'...", this->get_name().c_str());
+  ESP_LOGCONFIG(TAG, "Running setup for '%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, "Setting up ADC '%s'...", this->get_name().c_str());
+  ESP_LOGCONFIG(TAG, "Running setup for '%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, "Setting up ADC '%s'...", this->get_name().c_str());
+  ESP_LOGCONFIG(TAG, "Running setup for '%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, "Setting up ADC '%s'...", this->get_name().c_str());
+  ESP_LOGCONFIG(TAG, "Running setup for '%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, "Setting up ADC '%s'...", this->get_name().c_str());
+  ESP_LOGCONFIG(TAG, "Running setup for '%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, "Setting up adc128s102");
+  ESP_LOGCONFIG(TAG, "Running setup");
   this->spi_setup();
 }
 

esphome/components/ads1115/ads1115.cpp

@@ -10,7 +10,7 @@ static const uint8_t ADS1115_REGISTER_CONVERSION = 0x00;
 static const uint8_t ADS1115_REGISTER_CONFIG = 0x01;
 
 void ADS1115Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up ADS1115...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   uint16_t value;
   if (!this->read_byte_16(ADS1115_REGISTER_CONVERSION, &value)) {
     this->mark_failed();
@@ -68,7 +68,7 @@ void ADS1115Component::setup() {
   this->prev_config_ = config;
 }
 void ADS1115Component::dump_config() {
-  ESP_LOGCONFIG(TAG, "Setting up ADS1115...");
+  ESP_LOGCONFIG(TAG, "ADS1115:");
   LOG_I2C_DEVICE(this);
   if (this->is_failed()) {
     ESP_LOGE(TAG, "Communication with ADS1115 failed!");

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, "Setting up ads1118");
+  ESP_LOGCONFIG(TAG, "Running setup");
   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, "Setting up ags10...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   auto version = this->read_version_();
   if (version) {

esphome/components/aht10/aht10.cpp

@@ -15,6 +15,7 @@
 #include "aht10.h"
 #include "esphome/core/log.h"
 #include "esphome/core/hal.h"
+#include "esphome/core/helpers.h"
 
 namespace esphome {
 namespace aht10 {
@@ -34,57 +35,59 @@ 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 AHT10 failed!");
+    ESP_LOGE(TAG, "Reset 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, "Communication with AHT10 failed!");
+    ESP_LOGE(TAG, "Communication 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, "Communication with AHT10 failed!");
+      ESP_LOGE(TAG, "Communication failed");
       this->mark_failed();
       return;
     }
     ++cal_attempts;
     if (cal_attempts > AHT10_INIT_ATTEMPTS) {
-      ESP_LOGE(TAG, "AHT10 initialization timed out!");
+      ESP_LOGE(TAG, "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, "AHT10 initialization failed!");
+    ESP_LOGE(TAG, "Initialization failed");
     this->mark_failed();
     return;
   }
 
-  ESP_LOGV(TAG, "AHT10 initialization");
+  ESP_LOGV(TAG, "Initialization complete");
 }
 
 void AHT10Component::restart_read_() {
   if (this->read_count_ == AHT10_ATTEMPTS) {
     this->read_count_ = 0;
-    this->status_set_error("Measurements reading timed-out!");
+    this->status_set_error("Reading timed out");
     return;
   }
   this->read_count_++;
@@ -97,24 +100,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("AHT10 read failed, retrying soon");
+    this->status_set_warning("Read failed, will retry");
     this->restart_read_();
     return;
   }
 
   if ((data[0] & 0x80) == 0x80) {  // Bit[7] = 0b1, device is busy
-    ESP_LOGD(TAG, "AHT10 is busy, waiting...");
+    ESP_LOGD(TAG, "Device busy, will retry");
     this->restart_read_();
     return;
   }
   if (data[1] == 0x0 && data[2] == 0x0 && (data[3] >> 4) == 0x0) {
-    // Unrealistic humidity (0x0)
+    // Invalid humidity (0x0)
     if (this->humidity_sensor_ == nullptr) {
-      ESP_LOGV(TAG, "ATH10 Unrealistic humidity (0x0), but humidity is not required");
+      ESP_LOGV(TAG, "Invalid humidity (reading not required)");
     } else {
-      ESP_LOGD(TAG, "ATH10 Unrealistic humidity (0x0), retrying...");
+      ESP_LOGD(TAG, "Invalid humidity, retrying...");
       if (this->write(AHT10_MEASURE_CMD, sizeof(AHT10_MEASURE_CMD)) != i2c::ERROR_OK) {
-        this->status_set_warning("Communication with AHT10 failed!");
+        this->status_set_warning("Communication failed");
       }
       this->restart_read_();
       return;
@@ -123,22 +126,17 @@ void AHT10Component::read_data_() {
   if (this->read_count_ > 1) {
     ESP_LOGD(TAG, "Success at %ums", (unsigned) (millis() - this->start_time_));
   }
-  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;
+  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;
 
   if (this->temperature_sensor_ != nullptr) {
-    float temperature = ((200.0f * (float) raw_temperature) / 1048576.0f) - 50.0f;
+    float temperature = ((200.0f * static_cast<float>(raw_temperature)) / AHT10_DIVISOR) - 50.0f;
     this->temperature_sensor_->publish_state(temperature);
   }
   if (this->humidity_sensor_ != nullptr) {
-    float humidity;
-    if (raw_humidity == 0) {  // unrealistic value
-      humidity = NAN;
-    } else {
-      humidity = (float) raw_humidity * 100.0f / 1048576.0f;
-    }
+    float humidity = raw_humidity == 0 ? NAN : static_cast<float>(raw_humidity) * 100.0f / AHT10_DIVISOR;
     if (std::isnan(humidity)) {
-      ESP_LOGW(TAG, "Invalid humidity! Sensor reported 0%% Hum");
+      ESP_LOGW(TAG, "Invalid humidity reading (0%%), ");
     }
     this->humidity_sensor_->publish_state(humidity);
   }
@@ -150,7 +148,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("Communication with AHT10 failed!");
+    this->status_set_warning("Communication failed");
     return;
   }
   this->restart_read_();
@@ -162,7 +160,7 @@ void AHT10Component::dump_config() {
   ESP_LOGCONFIG(TAG, "AHT10:");
   LOG_I2C_DEVICE(this);
   if (this->is_failed()) {
-    ESP_LOGE(TAG, "Communication with AHT10 failed!");
+    ESP_LOGE(TAG, "Communication 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, "Setting up AIC3204...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   // Set register page to 0
   ERROR_CHECK(this->write_byte(AIC3204_PAGE_CTRL, 0x00), "Set page 0 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, "Setting up AM2315C...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   // get status
   uint8_t status = 0;

esphome/components/am2320/am2320.cpp

@@ -34,7 +34,7 @@ void AM2320Component::update() {
   this->status_clear_warning();
 }
 void AM2320Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up AM2320...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   uint8_t data[8];
   data[0] = 0;
   data[1] = 4;

esphome/components/apds9306/apds9306.cpp

@@ -54,7 +54,7 @@ enum {  // APDS9306 registers
   }
 
 void APDS9306::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up APDS9306...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   uint8_t id;
   if (!this->read_byte(APDS9306_PART_ID, &id)) {  // Part ID register

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, "Setting up APDS9960...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   uint8_t id;
   if (!this->read_byte(0x92, &id)) {  // ID register
     this->error_code_ = COMMUNICATION_FAILED;

esphome/components/api/api_connection.cpp

@@ -135,31 +135,35 @@ void APIConnection::loop() {
              api_error_to_str(err), errno);
     return;
   }
-  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;
-  } 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_)
+
+  // 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;
+    } 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;
+    }
   }
 
   if (!this->deferred_message_queue_.empty() && this->helper_->can_write_without_blocking()) {

esphome/components/api/api_frame_helper.h

@@ -13,6 +13,7 @@
 
 #include "api_noise_context.h"
 #include "esphome/components/socket/socket.h"
+#include "esphome/core/application.h"
 
 namespace esphome {
 namespace api {
@@ -90,6 +91,8 @@ class APIFrameHelper {
   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

esphome/components/api/api_pb2.cpp

@@ -782,7 +782,7 @@ bool ConnectResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
 }
 void ConnectResponse::encode(ProtoWriteBuffer buffer) const { buffer.encode_bool(1, this->invalid_password); }
 void ConnectResponse::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_bool_field(total_size, 1, this->invalid_password, false);
+  total_size += 2;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ConnectResponse::dump_to(std::string &out) const {
@@ -1200,9 +1200,7 @@ void BinarySensorStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(3, this->missing_state);
 }
 void BinarySensorStateResponse::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
-  ProtoSize::add_bool_field(total_size, 1, this->state, false);
-  ProtoSize::add_bool_field(total_size, 1, this->missing_state, false);
+  total_size += 9;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BinarySensorStateResponse::dump_to(std::string &out) const {
@@ -1412,11 +1410,7 @@ void CoverStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_enum<enums::CoverOperation>(5, this->current_operation);
 }
 void CoverStateResponse::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
-  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->legacy_state), false);
-  ProtoSize::add_fixed_field<4>(total_size, 1, this->position != 0.0f, false);
-  ProtoSize::add_fixed_field<4>(total_size, 1, this->tilt != 0.0f, false);
-  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->current_operation), false);
+  total_size += 27;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void CoverStateResponse::dump_to(std::string &out) const {
@@ -1502,14 +1496,7 @@ void CoverCommandRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(8, this->stop);
 }
 void CoverCommandRequest::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
-  ProtoSize::add_bool_field(total_size, 1, this->has_legacy_command, false);
-  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->legacy_command), false);
-  ProtoSize::add_bool_field(total_size, 1, this->has_position, false);
-  ProtoSize::add_fixed_field<4>(total_size, 1, this->position != 0.0f, false);
-  ProtoSize::add_bool_field(total_size, 1, this->has_tilt, false);
-  ProtoSize::add_fixed_field<4>(total_size, 1, this->tilt != 0.0f, false);
-  ProtoSize::add_bool_field(total_size, 1, this->stop, false);
+  total_size += 29;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void CoverCommandRequest::dump_to(std::string &out) const {
@@ -2835,9 +2822,7 @@ void SensorStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(3, this->missing_state);
 }
 void SensorStateResponse::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
-  ProtoSize::add_fixed_field<4>(total_size, 1, this->state != 0.0f, false);
-  ProtoSize::add_bool_field(total_size, 1, this->missing_state, false);
+  total_size += 12;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void SensorStateResponse::dump_to(std::string &out) const {
@@ -3003,8 +2988,7 @@ void SwitchStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(2, this->state);
 }
 void SwitchStateResponse::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
-  ProtoSize::add_bool_field(total_size, 1, this->state, false);
+  total_size += 7;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void SwitchStateResponse::dump_to(std::string &out) const {
@@ -3046,8 +3030,7 @@ void SwitchCommandRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(2, this->state);
 }
 void SwitchCommandRequest::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
-  ProtoSize::add_bool_field(total_size, 1, this->state, false);
+  total_size += 7;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void SwitchCommandRequest::dump_to(std::string &out) const {
@@ -3251,8 +3234,7 @@ void SubscribeLogsRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(2, this->dump_config);
 }
 void SubscribeLogsRequest::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->level), false);
-  ProtoSize::add_bool_field(total_size, 1, this->dump_config, false);
+  total_size += 8;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void SubscribeLogsRequest::dump_to(std::string &out) const {
@@ -3356,7 +3338,7 @@ bool NoiseEncryptionSetKeyResponse::decode_varint(uint32_t field_id, ProtoVarInt
 }
 void NoiseEncryptionSetKeyResponse::encode(ProtoWriteBuffer buffer) const { buffer.encode_bool(1, this->success); }
 void NoiseEncryptionSetKeyResponse::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_bool_field(total_size, 1, this->success, false);
+  total_size += 2;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void NoiseEncryptionSetKeyResponse::dump_to(std::string &out) const {
@@ -3617,7 +3599,7 @@ bool GetTimeResponse::decode_32bit(uint32_t field_id, Proto32Bit value) {
 }
 void GetTimeResponse::encode(ProtoWriteBuffer buffer) const { buffer.encode_fixed32(1, this->epoch_seconds); }
 void GetTimeResponse::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_fixed_field<4>(total_size, 1, this->epoch_seconds != 0, false);
+  total_size += 5;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void GetTimeResponse::dump_to(std::string &out) const {
@@ -4108,8 +4090,7 @@ void CameraImageRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(2, this->stream);
 }
 void CameraImageRequest::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_bool_field(total_size, 1, this->single, false);
-  ProtoSize::add_bool_field(total_size, 1, this->stream, false);
+  total_size += 4;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void CameraImageRequest::dump_to(std::string &out) const {
@@ -5098,9 +5079,7 @@ void NumberStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(3, this->missing_state);
 }
 void NumberStateResponse::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
-  ProtoSize::add_fixed_field<4>(total_size, 1, this->state != 0.0f, false);
-  ProtoSize::add_bool_field(total_size, 1, this->missing_state, false);
+  total_size += 12;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void NumberStateResponse::dump_to(std::string &out) const {
@@ -5141,8 +5120,7 @@ void NumberCommandRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_float(2, this->state);
 }
 void NumberCommandRequest::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
-  ProtoSize::add_fixed_field<4>(total_size, 1, this->state != 0.0f, false);
+  total_size += 10;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void NumberCommandRequest::dump_to(std::string &out) const {
@@ -5541,8 +5519,7 @@ void SirenStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(2, this->state);
 }
 void SirenStateResponse::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
-  ProtoSize::add_bool_field(total_size, 1, this->state, false);
+  total_size += 7;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void SirenStateResponse::dump_to(std::string &out) const {
@@ -5844,8 +5821,7 @@ void LockStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_enum<enums::LockState>(2, this->state);
 }
 void LockStateResponse::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
-  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->state), false);
+  total_size += 11;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void LockStateResponse::dump_to(std::string &out) const {
@@ -6052,7 +6028,7 @@ bool ButtonCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
 }
 void ButtonCommandRequest::encode(ProtoWriteBuffer buffer) const { buffer.encode_fixed32(1, this->key); }
 void ButtonCommandRequest::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
+  total_size += 5;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ButtonCommandRequest::dump_to(std::string &out) const {
@@ -6298,10 +6274,7 @@ void MediaPlayerStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(4, this->muted);
 }
 void MediaPlayerStateResponse::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
-  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->state), false);
-  ProtoSize::add_fixed_field<4>(total_size, 1, this->volume != 0.0f, false);
-  ProtoSize::add_bool_field(total_size, 1, this->muted, false);
+  total_size += 18;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void MediaPlayerStateResponse::dump_to(std::string &out) const {
@@ -6461,7 +6434,7 @@ void SubscribeBluetoothLEAdvertisementsRequest::encode(ProtoWriteBuffer buffer)
   buffer.encode_uint32(1, this->flags);
 }
 void SubscribeBluetoothLEAdvertisementsRequest::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_uint32_field(total_size, 1, this->flags, false);
+  total_size += 6;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void SubscribeBluetoothLEAdvertisementsRequest::dump_to(std::string &out) const {
@@ -6770,10 +6743,7 @@ void BluetoothDeviceRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint32(4, this->address_type);
 }
 void BluetoothDeviceRequest::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_uint64_field(total_size, 1, this->address, false);
-  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->request_type), false);
-  ProtoSize::add_bool_field(total_size, 1, this->has_address_type, false);
-  ProtoSize::add_uint32_field(total_size, 1, this->address_type, false);
+  total_size += 25;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BluetoothDeviceRequest::dump_to(std::string &out) const {
@@ -6828,10 +6798,7 @@ void BluetoothDeviceConnectionResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_int32(4, this->error);
 }
 void BluetoothDeviceConnectionResponse::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_uint64_field(total_size, 1, this->address, false);
-  ProtoSize::add_bool_field(total_size, 1, this->connected, false);
-  ProtoSize::add_uint32_field(total_size, 1, this->mtu, false);
-  ProtoSize::add_int32_field(total_size, 1, this->error, false);
+  total_size += 25;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BluetoothDeviceConnectionResponse::dump_to(std::string &out) const {
@@ -6870,7 +6837,7 @@ bool BluetoothGATTGetServicesRequest::decode_varint(uint32_t field_id, ProtoVarI
 }
 void BluetoothGATTGetServicesRequest::encode(ProtoWriteBuffer buffer) const { buffer.encode_uint64(1, this->address); }
 void BluetoothGATTGetServicesRequest::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_uint64_field(total_size, 1, this->address, false);
+  total_size += 11;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BluetoothGATTGetServicesRequest::dump_to(std::string &out) const {
@@ -7133,7 +7100,7 @@ void BluetoothGATTGetServicesDoneResponse::encode(ProtoWriteBuffer buffer) const
   buffer.encode_uint64(1, this->address);
 }
 void BluetoothGATTGetServicesDoneResponse::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_uint64_field(total_size, 1, this->address, false);
+  total_size += 11;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BluetoothGATTGetServicesDoneResponse::dump_to(std::string &out) const {
@@ -7165,8 +7132,7 @@ void BluetoothGATTReadRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint32(2, this->handle);
 }
 void BluetoothGATTReadRequest::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_uint64_field(total_size, 1, this->address, false);
-  ProtoSize::add_uint32_field(total_size, 1, this->handle, false);
+  total_size += 17;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BluetoothGATTReadRequest::dump_to(std::string &out) const {
@@ -7321,8 +7287,7 @@ void BluetoothGATTReadDescriptorRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint32(2, this->handle);
 }
 void BluetoothGATTReadDescriptorRequest::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_uint64_field(total_size, 1, this->address, false);
-  ProtoSize::add_uint32_field(total_size, 1, this->handle, false);
+  total_size += 17;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BluetoothGATTReadDescriptorRequest::dump_to(std::string &out) const {
@@ -7418,9 +7383,7 @@ void BluetoothGATTNotifyRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(3, this->enable);
 }
 void BluetoothGATTNotifyRequest::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_uint64_field(total_size, 1, this->address, false);
-  ProtoSize::add_uint32_field(total_size, 1, this->handle, false);
-  ProtoSize::add_bool_field(total_size, 1, this->enable, false);
+  total_size += 19;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BluetoothGATTNotifyRequest::dump_to(std::string &out) const {
@@ -7584,9 +7547,7 @@ void BluetoothGATTErrorResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_int32(3, this->error);
 }
 void BluetoothGATTErrorResponse::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_uint64_field(total_size, 1, this->address, false);
-  ProtoSize::add_uint32_field(total_size, 1, this->handle, false);
-  ProtoSize::add_int32_field(total_size, 1, this->error, false);
+  total_size += 23;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BluetoothGATTErrorResponse::dump_to(std::string &out) const {
@@ -7628,8 +7589,7 @@ void BluetoothGATTWriteResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint32(2, this->handle);
 }
 void BluetoothGATTWriteResponse::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_uint64_field(total_size, 1, this->address, false);
-  ProtoSize::add_uint32_field(total_size, 1, this->handle, false);
+  total_size += 17;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BluetoothGATTWriteResponse::dump_to(std::string &out) const {
@@ -7666,8 +7626,7 @@ void BluetoothGATTNotifyResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint32(2, this->handle);
 }
 void BluetoothGATTNotifyResponse::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_uint64_field(total_size, 1, this->address, false);
-  ProtoSize::add_uint32_field(total_size, 1, this->handle, false);
+  total_size += 17;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BluetoothGATTNotifyResponse::dump_to(std::string &out) const {
@@ -7709,9 +7668,7 @@ void BluetoothDevicePairingResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_int32(3, this->error);
 }
 void BluetoothDevicePairingResponse::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_uint64_field(total_size, 1, this->address, false);
-  ProtoSize::add_bool_field(total_size, 1, this->paired, false);
-  ProtoSize::add_int32_field(total_size, 1, this->error, false);
+  total_size += 19;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BluetoothDevicePairingResponse::dump_to(std::string &out) const {
@@ -7757,9 +7714,7 @@ void BluetoothDeviceUnpairingResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_int32(3, this->error);
 }
 void BluetoothDeviceUnpairingResponse::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_uint64_field(total_size, 1, this->address, false);
-  ProtoSize::add_bool_field(total_size, 1, this->success, false);
-  ProtoSize::add_int32_field(total_size, 1, this->error, false);
+  total_size += 19;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BluetoothDeviceUnpairingResponse::dump_to(std::string &out) const {
@@ -7812,9 +7767,7 @@ void BluetoothDeviceClearCacheResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_int32(3, this->error);
 }
 void BluetoothDeviceClearCacheResponse::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_uint64_field(total_size, 1, this->address, false);
-  ProtoSize::add_bool_field(total_size, 1, this->success, false);
-  ProtoSize::add_int32_field(total_size, 1, this->error, false);
+  total_size += 19;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BluetoothDeviceClearCacheResponse::dump_to(std::string &out) const {
@@ -7855,8 +7808,7 @@ void BluetoothScannerStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_enum<enums::BluetoothScannerMode>(2, this->mode);
 }
 void BluetoothScannerStateResponse::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->state), false);
-  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->mode), false);
+  total_size += 12;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BluetoothScannerStateResponse::dump_to(std::string &out) const {
@@ -7886,7 +7838,7 @@ void BluetoothScannerSetModeRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_enum<enums::BluetoothScannerMode>(1, this->mode);
 }
 void BluetoothScannerSetModeRequest::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->mode), false);
+  total_size += 6;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void BluetoothScannerSetModeRequest::dump_to(std::string &out) const {
@@ -7917,8 +7869,7 @@ void SubscribeVoiceAssistantRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint32(2, this->flags);
 }
 void SubscribeVoiceAssistantRequest::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_bool_field(total_size, 1, this->subscribe, false);
-  ProtoSize::add_uint32_field(total_size, 1, this->flags, false);
+  total_size += 8;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void SubscribeVoiceAssistantRequest::dump_to(std::string &out) const {
@@ -7965,9 +7916,7 @@ void VoiceAssistantAudioSettings::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_float(3, this->volume_multiplier);
 }
 void VoiceAssistantAudioSettings::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_uint32_field(total_size, 1, this->noise_suppression_level, false);
-  ProtoSize::add_uint32_field(total_size, 1, this->auto_gain, false);
-  ProtoSize::add_fixed_field<4>(total_size, 1, this->volume_multiplier != 0.0f, false);
+  total_size += 17;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void VoiceAssistantAudioSettings::dump_to(std::string &out) const {
@@ -8082,8 +8031,7 @@ void VoiceAssistantResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(2, this->error);
 }
 void VoiceAssistantResponse::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_uint32_field(total_size, 1, this->port, false);
-  ProtoSize::add_bool_field(total_size, 1, this->error, false);
+  total_size += 8;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void VoiceAssistantResponse::dump_to(std::string &out) const {
@@ -8382,7 +8330,7 @@ bool VoiceAssistantAnnounceFinished::decode_varint(uint32_t field_id, ProtoVarIn
 }
 void VoiceAssistantAnnounceFinished::encode(ProtoWriteBuffer buffer) const { buffer.encode_bool(1, this->success); }
 void VoiceAssistantAnnounceFinished::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_bool_field(total_size, 1, this->success, false);
+  total_size += 2;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void VoiceAssistantAnnounceFinished::dump_to(std::string &out) const {
@@ -8709,8 +8657,7 @@ void AlarmControlPanelStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_enum<enums::AlarmControlPanelState>(2, this->state);
 }
 void AlarmControlPanelStateResponse::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
-  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->state), false);
+  total_size += 11;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void AlarmControlPanelStateResponse::dump_to(std::string &out) const {
@@ -9168,11 +9115,7 @@ void DateStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint32(5, this->day);
 }
 void DateStateResponse::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
-  ProtoSize::add_bool_field(total_size, 1, this->missing_state, false);
-  ProtoSize::add_uint32_field(total_size, 1, this->year, false);
-  ProtoSize::add_uint32_field(total_size, 1, this->month, false);
-  ProtoSize::add_uint32_field(total_size, 1, this->day, false);
+  total_size += 25;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void DateStateResponse::dump_to(std::string &out) const {
@@ -9239,10 +9182,7 @@ void DateCommandRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint32(4, this->day);
 }
 void DateCommandRequest::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
-  ProtoSize::add_uint32_field(total_size, 1, this->year, false);
-  ProtoSize::add_uint32_field(total_size, 1, this->month, false);
-  ProtoSize::add_uint32_field(total_size, 1, this->day, false);
+  total_size += 23;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void DateCommandRequest::dump_to(std::string &out) const {
@@ -9409,11 +9349,7 @@ void TimeStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint32(5, this->second);
 }
 void TimeStateResponse::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
-  ProtoSize::add_bool_field(total_size, 1, this->missing_state, false);
-  ProtoSize::add_uint32_field(total_size, 1, this->hour, false);
-  ProtoSize::add_uint32_field(total_size, 1, this->minute, false);
-  ProtoSize::add_uint32_field(total_size, 1, this->second, false);
+  total_size += 25;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void TimeStateResponse::dump_to(std::string &out) const {
@@ -9480,10 +9416,7 @@ void TimeCommandRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint32(4, this->second);
 }
 void TimeCommandRequest::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
-  ProtoSize::add_uint32_field(total_size, 1, this->hour, false);
-  ProtoSize::add_uint32_field(total_size, 1, this->minute, false);
-  ProtoSize::add_uint32_field(total_size, 1, this->second, false);
+  total_size += 23;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void TimeCommandRequest::dump_to(std::string &out) const {
@@ -9850,9 +9783,7 @@ void ValveStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_enum<enums::ValveOperation>(3, this->current_operation);
 }
 void ValveStateResponse::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
-  ProtoSize::add_fixed_field<4>(total_size, 1, this->position != 0.0f, false);
-  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->current_operation), false);
+  total_size += 16;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ValveStateResponse::dump_to(std::string &out) const {
@@ -9909,10 +9840,7 @@ void ValveCommandRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_bool(4, this->stop);
 }
 void ValveCommandRequest::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
-  ProtoSize::add_bool_field(total_size, 1, this->has_position, false);
-  ProtoSize::add_fixed_field<4>(total_size, 1, this->position != 0.0f, false);
-  ProtoSize::add_bool_field(total_size, 1, this->stop, false);
+  total_size += 14;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void ValveCommandRequest::dump_to(std::string &out) const {
@@ -10067,9 +9995,7 @@ void DateTimeStateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_fixed32(3, this->epoch_seconds);
 }
 void DateTimeStateResponse::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
-  ProtoSize::add_bool_field(total_size, 1, this->missing_state, false);
-  ProtoSize::add_fixed_field<4>(total_size, 1, this->epoch_seconds != 0, false);
+  total_size += 12;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void DateTimeStateResponse::dump_to(std::string &out) const {
@@ -10110,8 +10036,7 @@ void DateTimeCommandRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_fixed32(2, this->epoch_seconds);
 }
 void DateTimeCommandRequest::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
-  ProtoSize::add_fixed_field<4>(total_size, 1, this->epoch_seconds != 0, false);
+  total_size += 10;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void DateTimeCommandRequest::dump_to(std::string &out) const {
@@ -10393,8 +10318,7 @@ void UpdateCommandRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_enum<enums::UpdateCommand>(2, this->command);
 }
 void UpdateCommandRequest::calculate_size(uint32_t &total_size) const {
-  ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
-  ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->command), false);
+  total_size += 11;  // Pre-calculated maximum size
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void UpdateCommandRequest::dump_to(std::string &out) const {

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, "Setting up Home Assistant API server...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   this->setup_controller();
 
 #ifdef USE_API_NOISE
@@ -43,7 +43,7 @@ void APIServer::setup() {
   }
 #endif
 
-  this->socket_ = socket::socket_ip(SOCK_STREAM, 0);
+  this->socket_ = socket::socket_ip_loop_monitored(SOCK_STREAM, 0);  // monitored for incoming connections
   if (this->socket_ == nullptr) {
     ESP_LOGW(TAG, "Could not create socket");
     this->mark_failed();
@@ -112,18 +112,20 @@ void APIServer::setup() {
 }
 
 void APIServer::loop() {
-  // 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());
+  // 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());
 
-    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

esphome/components/as3935/as3935.cpp

@@ -7,7 +7,7 @@ namespace as3935 {
 static const char *const TAG = "as3935";
 
 void AS3935Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up AS3935...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   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, "Setting up AS5600...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   if (!this->read_byte(REGISTER_STATUS).has_value()) {
     this->mark_failed();

esphome/components/as7341/as7341.cpp

@@ -8,7 +8,7 @@ namespace as7341 {
 static const char *const TAG = "as7341";
 
 void AS7341Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up AS7341...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   LOG_I2C_DEVICE(this);
 
   // Verify device ID

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, "Setting up AT581X..."); }
+void AT581XComponent::setup() { ESP_LOGCONFIG(TAG, "Running setup"); }
 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, "Setting up ATM90E26 Component...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   this->spi_setup();
 
   uint16_t mmode = 0x422;  // default values for everything but L/N line current gains

esphome/components/atm90e32/atm90e32.cpp

@@ -108,7 +108,7 @@ void ATM90E32Component::update() {
 }
 
 void ATM90E32Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up ATM90E32 Component...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   this->spi_setup();
 
   uint16_t mmode0 = 0x87;  // 3P4W 50Hz

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, "Setting up AXS15231 Touchscreen...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   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, "Setting up Beken SPI LED Strip...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   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, "Setting up BH1750 '%s'...", this->name_.c_str());
+  ESP_LOGCONFIG(TAG, "Running setup for '%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();

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, "Setting up BME280...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   uint8_t chip_id = 0;
 
   // Mark as not failed before initializing. Some devices will turn off sensors to save on batteries

esphome/components/bme680/bme680.cpp

@@ -71,7 +71,7 @@ static const char *iir_filter_to_str(BME680IIRFilter filter) {
 }
 
 void BME680Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up BME680...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   uint8_t chip_id;
   if (!this->read_byte(BME680_REGISTER_CHIPID, &chip_id) || chip_id != 0x61) {
     this->mark_failed();

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, "Setting up BME680(%s) via BSEC...", this->device_id_.c_str());
+  ESP_LOGCONFIG(TAG, "Running setup for '%s'", 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, "Setting up BME68X via BSEC2...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   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, "Setting up BMI160...");
+      ESP_LOGCONFIG(TAG, "Running setup");
       uint8_t chipid;
       if (!this->read_byte(BMI160_REGISTER_CHIPID, &chipid) || (chipid != 0b11010001)) {
         this->mark_failed();

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, "Setting up BMP085...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   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, "Setting up BMP280...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   uint8_t chip_id = 0;
 
   // Read the chip id twice, to work around a bug where the first read is 0.

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, "Setting up BMP3XX...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   // Call the Device base class "initialise" function
   if (!reset()) {
     ESP_LOGE(TAG, "Failed to reset BMP3XX...");

esphome/components/bmp581/bmp581.cpp

@@ -122,7 +122,7 @@ void BMP581Component::setup() {
    */
 
   this->error_code_ = NONE;
-  ESP_LOGCONFIG(TAG, "Setting up BMP581...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   ////////////////////
   // 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, "Setting up BP1658CJ Output Component...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   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, "Setting up BP5758D Output Component...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   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, "Setting up Canbus...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   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, "Setting up CAP1188...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   // Reset device using the reset pin
   if (this->reset_pin_ != nullptr) {

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, "Setting up CD74HC4067...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   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, "Setting up CH422G...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   // set outputs before mode
   this->write_outputs_();
   // Set mode and check for errors

esphome/components/chsc6x/chsc6x_touchscreen.cpp

@@ -4,7 +4,7 @@ namespace esphome {
 namespace chsc6x {
 
 void CHSC6XTouchscreen::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up CHSC6X Touchscreen...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   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,7 +20,7 @@ uint8_t cm1106_checksum(const uint8_t *response, size_t len) {
 }
 
 void CM1106Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up CM1106...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   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, "Communication with CM1106 failed!");

esphome/components/cs5460a/cs5460a.cpp

@@ -52,7 +52,7 @@ bool CS5460AComponent::softreset_() {
 }
 
 void CS5460AComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up CS5460A...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   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, "Setting up CSE7761...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   this->write_(CSE7761_SPECIAL_COMMAND, CSE7761_CMD_RESET);
   uint16_t syscon = this->read_(0x00, 2);  // Default 0x0A04
   if ((0x0A04 == syscon) && this->chip_init_()) {

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, "Setting up CST226 Touchscreen...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   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, "Setting up CST816 Touchscreen...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   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, "Setting up DAC7678OutputComponent...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   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, "setting up Dallas temperature sensor...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   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,7 +125,6 @@ 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,7 +10,7 @@ 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, "Setting up Deep Sleep...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   global_has_deep_sleep = true;
 
   const optional<uint32_t> run_duration = get_run_duration_();
@@ -23,7 +23,7 @@ void DeepSleepComponent::setup() {
 }
 
 void DeepSleepComponent::dump_config() {
-  ESP_LOGCONFIG(TAG, "Setting up Deep Sleep...");
+  ESP_LOGCONFIG(TAG, "Deep sleep:");
   if (this->sleep_duration_.has_value()) {
     uint32_t duration = *this->sleep_duration_ / 1000;
     ESP_LOGCONFIG(TAG, "  Sleep Duration: %" PRIu32 " ms", duration);

esphome/components/demo/__init__.py

@@ -1,14 +1,22 @@
 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 (
@@ -20,7 +28,9 @@ 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,
@@ -31,9 +41,11 @@ 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,
@@ -45,38 +57,68 @@ 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,
@@ -103,21 +145,71 @@ 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,
 }
+SELECT_TYPES = {
+    1: DemoSelectType.TYPE_1,
+    2: DemoSelectType.TYPE_2,
+}
+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=[
@@ -135,6 +227,21 @@ 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=[
@@ -191,6 +298,20 @@ 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=[
@@ -262,6 +383,19 @@ 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=[
@@ -299,6 +433,28 @@ CONFIG_SCHEMA = cv.Schema(
                 }
             )
         ],
+        cv.Optional(
+            CONF_SELECTS,
+            default=[
+                {
+                    CONF_NAME: "Demo Select 1",
+                    CONF_OPTIONS: ["Option 1", "Option 2", "Option 3"],
+                    CONF_TYPE: 1,
+                },
+                {
+                    CONF_NAME: "Demo Select 2",
+                    CONF_OPTIONS: ["Option A", "Option B", "Option C"],
+                    CONF_TYPE: 2,
+                },
+            ],
+        ): [
+            select.select_schema(DemoSelect).extend(
+                {
+                    cv.Required(CONF_TYPE): cv.enum(SELECT_TYPES, int=True),
+                    cv.Required(CONF_OPTIONS): cv.ensure_list(cv.string_strict),
+                }
+            )
+        ],
         cv.Optional(
             CONF_SENSORS,
             default=[
@@ -355,6 +511,19 @@ 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=[
@@ -371,15 +540,35 @@ 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)
+        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)
@@ -390,6 +579,10 @@ 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)
@@ -400,6 +593,11 @@ 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,
@@ -410,6 +608,10 @@ 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)
@@ -418,6 +620,16 @@ 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

@@ -0,0 +1,65 @@
+#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

@@ -0,0 +1,15 @@
+#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

@@ -0,0 +1,34 @@
+#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

@@ -0,0 +1,40 @@
+#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

@@ -0,0 +1,17 @@
+#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

@@ -0,0 +1,15 @@
+#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

@@ -0,0 +1,18 @@
+#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

@@ -0,0 +1,34 @@
+#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

@@ -0,0 +1,50 @@
+#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->publish_state(*call.get_position());
+      return;
+    } else if (call.get_toggle().has_value()) {
+      if (call.get_toggle().value()) {
+        if (this->position == valve::VALVE_OPEN) {
+          this->publish_state(valve::VALVE_CLOSED);
+        } else {
+          this->publish_state(valve::VALVE_OPEN);
+        }
+      }
+      return;
+    } else if (call.get_stop()) {
+      this->publish_state(this->position);  // Keep the current position
+      return;
+    }
+  }
+  DemoValveType type_{};
+};
+
+}  // namespace demo
+}  // namespace esphome

esphome/components/dht/dht.cpp

@@ -8,7 +8,7 @@ namespace dht {
 static const char *const TAG = "dht";
 
 void DHT::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up DHT...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   this->pin_->digital_write(true);
   this->pin_->setup();
   this->pin_->digital_write(true);

esphome/components/dht12/dht12.cpp

@@ -34,7 +34,7 @@ void DHT12Component::update() {
   this->status_clear_warning();
 }
 void DHT12Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up DHT12...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   uint8_t data[5];
   if (!this->read_data_(data)) {
     this->mark_failed();

esphome/components/dps310/dps310.cpp

@@ -12,7 +12,7 @@ void DPS310Component::setup() {
   auto timer = DPS310_INIT_TIMEOUT;
   uint8_t reg = 0;
 
-  ESP_LOGCONFIG(TAG, "Setting up DPS310...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   // first, reset the sensor
   if (!this->write_byte(DPS310_REG_RESET, DPS310_CMD_RESET)) {
     this->mark_failed();

esphome/components/ds1307/ds1307.cpp

@@ -10,7 +10,7 @@ namespace ds1307 {
 static const char *const TAG = "ds1307";
 
 void DS1307Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up DS1307...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   if (!this->read_rtc_()) {
     this->mark_failed();
   }

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, "Setting up Duty Cycle Sensor '%s'...", this->get_name().c_str());
+  ESP_LOGCONFIG(TAG, "Running setup for '%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, "Setting up EE895...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   write_command_(SERIAL_NUMBER, 8);
   uint8_t serial_number[20];
   this->read(serial_number, 20);

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, "Setting up EKT2232 Touchscreen...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   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, "Setting up Emc2101 sensor...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   // make sure we're talking to the right chip
   uint8_t chip_id = reg(EMC2101_REGISTER_WHOAMI).get();

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, "Setting up ENS160...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   // check part_id
   uint16_t part_id;

esphome/components/ens210/ens210.cpp

@@ -87,7 +87,7 @@ static uint32_t crc7(uint32_t value) {
 }
 
 void ENS210Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up ENS210...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   uint8_t data[2];
   uint16_t part_id = 0;
   // Reset

esphome/components/es7210/es7210.cpp

@@ -36,7 +36,7 @@ void ES7210::dump_config() {
 }
 
 void ES7210::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up ES7210...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   // 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, "Setting up ES7243E...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   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, "Setting up ES8156...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   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, "Setting up ES8311...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   // Reset
   ES8311_ERROR_FAILED(this->write_byte(ES8311_REG00_RESET, 0x1F));

esphome/components/es8388/audio_dac.py

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,289 @@
+#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

@@ -0,0 +1,81 @@
+#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

@@ -0,0 +1,83 @@
+#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

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,12 @@
+#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

@@ -0,0 +1,15 @@
+#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

@@ -0,0 +1,12 @@
+#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

@@ -0,0 +1,15 @@
+#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_ble/ble.cpp

@@ -28,7 +28,7 @@ static RAMAllocator<BLEEvent> EVENT_ALLOCATOR(  // NOLINT(cppcoreguidelines-avoi
 
 void ESP32BLE::setup() {
   global_ble = this;
-  ESP_LOGCONFIG(TAG, "Setting up BLE...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   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, "Setting up ESP32 DAC Output...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   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, "Setting up ESP32 LED Strip...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   size_t buffer_size = this->get_buffer_size_();
 

esphome/components/esp32_touch/esp32_touch.cpp

@@ -13,7 +13,7 @@ namespace esp32_touch {
 static const char *const TAG = "esp32_touch";
 
 void ESP32TouchComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up ESP32 Touch Hub...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   touch_pad_init();
 // set up and enable/start filtering based on ESP32 variant
 #if defined(USE_ESP32_VARIANT_ESP32S2) || defined(USE_ESP32_VARIANT_ESP32S3)

esphome/components/esp8266_pwm/esp8266_pwm.cpp

@@ -14,7 +14,7 @@ namespace esp8266_pwm {
 static const char *const TAG = "esp8266_pwm";
 
 void ESP8266PWM::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up ESP8266 PWM Output...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   this->pin_->setup();
   this->turn_off();
 }

esphome/components/esphome/ota/ota_esphome.cpp

@@ -26,7 +26,7 @@ void ESPHomeOTAComponent::setup() {
   ota::register_ota_platform(this);
 #endif
 
-  server_ = socket::socket_ip(SOCK_STREAM, 0);
+  server_ = socket::socket_ip_loop_monitored(SOCK_STREAM, 0);  // monitored for incoming connections
   if (server_ == nullptr) {
     ESP_LOGW(TAG, "Could not create socket");
     this->mark_failed();
@@ -100,9 +100,12 @@ void ESPHomeOTAComponent::handle_() {
 #endif
 
   if (client_ == nullptr) {
-    struct sockaddr_storage source_addr;
-    socklen_t addr_len = sizeof(source_addr);
-    client_ = server_->accept((struct sockaddr *) &source_addr, &addr_len);
+    // Check if the server socket is ready before accepting
+    if (this->server_->ready()) {
+      struct sockaddr_storage source_addr;
+      socklen_t addr_len = sizeof(source_addr);
+      client_ = server_->accept((struct sockaddr *) &source_addr, &addr_len);
+    }
   }
   if (client_ == nullptr)
     return;

esphome/components/ethernet/ethernet_component.cpp

@@ -38,7 +38,7 @@ EthernetComponent *global_eth_component;  // NOLINT(cppcoreguidelines-avoid-non-
 EthernetComponent::EthernetComponent() { global_eth_component = this; }
 
 void EthernetComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up Ethernet...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   if (esp_reset_reason() != ESP_RST_DEEPSLEEP) {
     // Delay here to allow power to stabilise before Ethernet is initialized.
     delay(300);  // NOLINT

esphome/components/fastled_base/fastled_light.cpp

@@ -9,7 +9,7 @@ namespace fastled_base {
 static const char *const TAG = "fastled";
 
 void FastLEDLightOutput::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up FastLED light...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   this->controller_->init();
   this->controller_->setLeds(this->leds_, this->num_leds_);
   this->effect_data_ = new uint8_t[this->num_leds_];  // NOLINT

esphome/components/fingerprint_grow/fingerprint_grow.cpp

@@ -57,7 +57,7 @@ void FingerprintGrowComponent::update() {
 }
 
 void FingerprintGrowComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up Grow Fingerprint Reader...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   this->has_sensing_pin_ = (this->sensing_pin_ != nullptr);
   this->has_power_pin_ = (this->sensor_power_pin_ != nullptr);

esphome/components/fs3000/fs3000.cpp

@@ -7,7 +7,7 @@ namespace fs3000 {
 static const char *const TAG = "fs3000";
 
 void FS3000Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up FS3000...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   if (model_ == FIVE) {
     // datasheet gives 9 points to interpolate from for the 1005 model

esphome/components/ft5x06/touchscreen/ft5x06_touchscreen.cpp

@@ -8,7 +8,7 @@ namespace ft5x06 {
 static const char *const TAG = "ft5x06.touchscreen";
 
 void FT5x06Touchscreen::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up FT5x06 Touchscreen...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   if (this->interrupt_pin_ != nullptr) {
     this->interrupt_pin_->setup();
     this->interrupt_pin_->pin_mode(gpio::FLAG_INPUT | gpio::FLAG_PULLUP);