esphome 2025.5.1__py3-none-any.whl → 2025.6.0b1__py3-none-any.whl

esphome/__main__.py

@@ -134,6 +134,7 @@ def get_port_type(port):
 
 
 def run_miniterm(config, port, args):
+    from aioesphomeapi import LogParser
     import serial
 
     from esphome import platformio_api
@@ -158,6 +159,7 @@ def run_miniterm(config, port, args):
         ser.dtr = False
         ser.rts = False
 
+    parser = LogParser()
     tries = 0
     while tries < 5:
         try:
@@ -174,8 +176,7 @@ def run_miniterm(config, port, args):
                         .decode("utf8", "backslashreplace")
                     )
                     time_str = datetime.now().time().strftime("[%H:%M:%S]")
-                    message = time_str + line
-                    safe_print(message)
+                    safe_print(parser.parse_line(line, time_str))
 
                     backtrace_state = platformio_api.process_stacktrace(
                         config, line, backtrace_state=backtrace_state
@@ -593,15 +594,20 @@ def command_update_all(args):
         middle_text = f" {middle_text} "
         width = len(click.unstyle(middle_text))
         half_line = "=" * ((twidth - width) // 2)
-        click.echo(f"{half_line}{middle_text}{half_line}")
+        safe_print(f"{half_line}{middle_text}{half_line}")
 
     for f in files:
-        print(f"Updating {color(AnsiFore.CYAN, f)}")
-        print("-" * twidth)
-        print()
-        rc = run_external_process(
-            "esphome", "--dashboard", "run", f, "--no-logs", "--device", "OTA"
-        )
+        safe_print(f"Updating {color(AnsiFore.CYAN, f)}")
+        safe_print("-" * twidth)
+        safe_print()
+        if CORE.dashboard:
+            rc = run_external_process(
+                "esphome", "--dashboard", "run", f, "--no-logs", "--device", "OTA"
+            )
+        else:
+            rc = run_external_process(
+                "esphome", "run", f, "--no-logs", "--device", "OTA"
+            )
         if rc == 0:
             print_bar(f"[{color(AnsiFore.BOLD_GREEN, 'SUCCESS')}] {f}")
             success[f] = True
@@ -609,17 +615,17 @@ def command_update_all(args):
             print_bar(f"[{color(AnsiFore.BOLD_RED, 'ERROR')}] {f}")
             success[f] = False
 
-        print()
-        print()
-        print()
+        safe_print()
+        safe_print()
+        safe_print()
 
     print_bar(f"[{color(AnsiFore.BOLD_WHITE, 'SUMMARY')}]")
     failed = 0
     for f in files:
         if success[f]:
-            print(f"  - {f}: {color(AnsiFore.GREEN, 'SUCCESS')}")
+            safe_print(f"  - {f}: {color(AnsiFore.GREEN, 'SUCCESS')}")
         else:
-            print(f"  - {f}: {color(AnsiFore.BOLD_RED, 'FAILED')}")
+            safe_print(f"  - {f}: {color(AnsiFore.BOLD_RED, 'FAILED')}")
             failed += 1
     return failed
 

esphome/components/a4988/a4988.cpp

@@ -7,7 +7,7 @@ namespace a4988 {
 static const char *const TAG = "a4988.stepper";
 
 void A4988::setup() {
-  ESP_LOGCONFIG(TAG, "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); });
@@ -40,9 +40,11 @@ void AbsoluteHumidityComponent::dump_config() {
       break;
   }
 
-  ESP_LOGCONFIG(TAG, "Sources");
-  ESP_LOGCONFIG(TAG, "  Temperature: '%s'", this->temperature_sensor_->get_name().c_str());
-  ESP_LOGCONFIG(TAG, "  Relative Humidity: '%s'", this->humidity_sensor_->get_name().c_str());
+  ESP_LOGCONFIG(TAG,
+                "Sources\n"
+                "  Temperature: '%s'\n"
+                "  Relative Humidity: '%s'",
+                this->temperature_sensor_->get_name().c_str(), this->humidity_sensor_->get_name().c_str());
 }
 
 float AbsoluteHumidityComponent::get_setup_priority() const { return setup_priority::DATA; }

esphome/components/ac_dimmer/ac_dimmer.cpp

@@ -214,8 +214,10 @@ void AcDimmer::dump_config() {
   ESP_LOGCONFIG(TAG, "AcDimmer:");
   LOG_PIN("  Output Pin: ", this->gate_pin_);
   LOG_PIN("  Zero-Cross Pin: ", this->zero_cross_pin_);
-  ESP_LOGCONFIG(TAG, "   Min Power: %.1f%%", this->store_.min_power / 10.0f);
-  ESP_LOGCONFIG(TAG, "   Init with half cycle: %s", YESNO(this->init_with_half_cycle_));
+  ESP_LOGCONFIG(TAG,
+                "   Min Power: %.1f%%\n"
+                "   Init with half cycle: %s",
+                this->store_.min_power / 10.0f, YESNO(this->init_with_half_cycle_));
   if (method_ == DIM_METHOD_LEADING_PULSE) {
     ESP_LOGCONFIG(TAG, "   Method: leading pulse");
   } else if (method_ == DIM_METHOD_LEADING) {

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);
@@ -77,8 +77,10 @@ void ADCSensor::dump_config() {
         break;
     }
   }
-  ESP_LOGCONFIG(TAG, "  Samples: %i", this->sample_count_);
-  ESP_LOGCONFIG(TAG, "  Sampling mode: %s", LOG_STR_ARG(sampling_mode_to_str(this->sampling_mode_)));
+  ESP_LOGCONFIG(TAG,
+                "  Samples: %i\n"
+                "  Sampling mode: %s",
+                this->sample_count_, LOG_STR_ARG(sampling_mode_to_str(this->sampling_mode_)));
   LOG_UPDATE_INTERVAL(this);
 }
 

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
@@ -30,8 +30,10 @@ void ADCSensor::dump_config() {
 #else
   LOG_PIN("  Pin: ", this->pin_);
 #endif  // USE_ADC_SENSOR_VCC
-  ESP_LOGCONFIG(TAG, "  Samples: %i", this->sample_count_);
-  ESP_LOGCONFIG(TAG, "  Sampling mode: %s", LOG_STR_ARG(sampling_mode_to_str(this->sampling_mode_)));
+  ESP_LOGCONFIG(TAG,
+                "  Samples: %i\n"
+                "  Sampling mode: %s",
+                this->sample_count_, LOG_STR_ARG(sampling_mode_to_str(this->sampling_mode_)));
   LOG_UPDATE_INTERVAL(this);
 }
 

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
@@ -22,8 +22,10 @@ void ADCSensor::dump_config() {
 #else   // USE_ADC_SENSOR_VCC
   LOG_PIN("  Pin: ", this->pin_);
 #endif  // USE_ADC_SENSOR_VCC
-  ESP_LOGCONFIG(TAG, "  Samples: %i", this->sample_count_);
-  ESP_LOGCONFIG(TAG, "  Sampling mode: %s", LOG_STR_ARG(sampling_mode_to_str(this->sampling_mode_)));
+  ESP_LOGCONFIG(TAG,
+                "  Samples: %i\n"
+                "  Sampling mode: %s",
+                this->sample_count_, LOG_STR_ARG(sampling_mode_to_str(this->sampling_mode_)));
   LOG_UPDATE_INTERVAL(this);
 }
 

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();
@@ -33,8 +33,10 @@ void ADCSensor::dump_config() {
     LOG_PIN("  Pin: ", this->pin_);
 #endif  // USE_ADC_SENSOR_VCC
   }
-  ESP_LOGCONFIG(TAG, "  Samples: %i", this->sample_count_);
-  ESP_LOGCONFIG(TAG, "  Sampling mode: %s", LOG_STR_ARG(sampling_mode_to_str(this->sampling_mode_)));
+  ESP_LOGCONFIG(TAG,
+                "  Samples: %i\n"
+                "  Sampling mode: %s",
+                this->sample_count_, LOG_STR_ARG(sampling_mode_to_str(this->sampling_mode_)));
   LOG_UPDATE_INTERVAL(this);
 }
 

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/ade7880/ade7880.cpp

@@ -177,11 +177,14 @@ void ADE7880::dump_config() {
     LOG_SENSOR("    ", "Power Factor", this->channel_a_->power_factor);
     LOG_SENSOR("    ", "Forward Active Energy", this->channel_a_->forward_active_energy);
     LOG_SENSOR("    ", "Reverse Active Energy", this->channel_a_->reverse_active_energy);
-    ESP_LOGCONFIG(TAG, "    Calibration:");
-    ESP_LOGCONFIG(TAG, "     Current: %" PRId32, this->channel_a_->current_gain_calibration);
-    ESP_LOGCONFIG(TAG, "     Voltage: %" PRId32, this->channel_a_->voltage_gain_calibration);
-    ESP_LOGCONFIG(TAG, "     Power: %" PRId32, this->channel_a_->power_gain_calibration);
-    ESP_LOGCONFIG(TAG, "     Phase Angle: %u", this->channel_a_->phase_angle_calibration);
+    ESP_LOGCONFIG(TAG,
+                  "    Calibration:\n"
+                  "     Current: %" PRId32 "\n"
+                  "     Voltage: %" PRId32 "\n"
+                  "     Power: %" PRId32 "\n"
+                  "     Phase Angle: %u",
+                  this->channel_a_->current_gain_calibration, this->channel_a_->voltage_gain_calibration,
+                  this->channel_a_->power_gain_calibration, this->channel_a_->phase_angle_calibration);
   }
 
   if (this->channel_b_ != nullptr) {
@@ -193,11 +196,14 @@ void ADE7880::dump_config() {
     LOG_SENSOR("    ", "Power Factor", this->channel_b_->power_factor);
     LOG_SENSOR("    ", "Forward Active Energy", this->channel_b_->forward_active_energy);
     LOG_SENSOR("    ", "Reverse Active Energy", this->channel_b_->reverse_active_energy);
-    ESP_LOGCONFIG(TAG, "    Calibration:");
-    ESP_LOGCONFIG(TAG, "     Current: %" PRId32, this->channel_b_->current_gain_calibration);
-    ESP_LOGCONFIG(TAG, "     Voltage: %" PRId32, this->channel_b_->voltage_gain_calibration);
-    ESP_LOGCONFIG(TAG, "     Power: %" PRId32, this->channel_b_->power_gain_calibration);
-    ESP_LOGCONFIG(TAG, "     Phase Angle: %u", this->channel_b_->phase_angle_calibration);
+    ESP_LOGCONFIG(TAG,
+                  "    Calibration:\n"
+                  "     Current: %" PRId32 "\n"
+                  "     Voltage: %" PRId32 "\n"
+                  "     Power: %" PRId32 "\n"
+                  "     Phase Angle: %u",
+                  this->channel_b_->current_gain_calibration, this->channel_b_->voltage_gain_calibration,
+                  this->channel_b_->power_gain_calibration, this->channel_b_->phase_angle_calibration);
   }
 
   if (this->channel_c_ != nullptr) {
@@ -209,18 +215,23 @@ void ADE7880::dump_config() {
     LOG_SENSOR("    ", "Power Factor", this->channel_c_->power_factor);
     LOG_SENSOR("    ", "Forward Active Energy", this->channel_c_->forward_active_energy);
     LOG_SENSOR("    ", "Reverse Active Energy", this->channel_c_->reverse_active_energy);
-    ESP_LOGCONFIG(TAG, "    Calibration:");
-    ESP_LOGCONFIG(TAG, "     Current: %" PRId32, this->channel_c_->current_gain_calibration);
-    ESP_LOGCONFIG(TAG, "     Voltage: %" PRId32, this->channel_c_->voltage_gain_calibration);
-    ESP_LOGCONFIG(TAG, "     Power: %" PRId32, this->channel_c_->power_gain_calibration);
-    ESP_LOGCONFIG(TAG, "     Phase Angle: %u", this->channel_c_->phase_angle_calibration);
+    ESP_LOGCONFIG(TAG,
+                  "    Calibration:\n"
+                  "     Current: %" PRId32 "\n"
+                  "     Voltage: %" PRId32 "\n"
+                  "     Power: %" PRId32 "\n"
+                  "     Phase Angle: %u",
+                  this->channel_c_->current_gain_calibration, this->channel_c_->voltage_gain_calibration,
+                  this->channel_c_->power_gain_calibration, this->channel_c_->phase_angle_calibration);
   }
 
   if (this->channel_n_ != nullptr) {
     ESP_LOGCONFIG(TAG, "  Neutral:");
     LOG_SENSOR("    ", "Current", this->channel_n_->current);
-    ESP_LOGCONFIG(TAG, "    Calibration:");
-    ESP_LOGCONFIG(TAG, "     Current: %" PRId32, this->channel_n_->current_gain_calibration);
+    ESP_LOGCONFIG(TAG,
+                  "    Calibration:\n"
+                  "     Current: %" PRId32,
+                  this->channel_n_->current_gain_calibration);
   }
 
   LOG_I2C_DEVICE(this);

esphome/components/ade7953_base/ade7953_base.cpp

@@ -58,15 +58,18 @@ void ADE7953::dump_config() {
   LOG_SENSOR("  ", "Active Power B Sensor", this->active_power_b_sensor_);
   LOG_SENSOR("  ", "Rective Power A Sensor", this->reactive_power_a_sensor_);
   LOG_SENSOR("  ", "Reactive Power B Sensor", this->reactive_power_b_sensor_);
-  ESP_LOGCONFIG(TAG, "  USE_ACC_ENERGY_REGS: %d", this->use_acc_energy_regs_);
-  ESP_LOGCONFIG(TAG, "  PGA_V_8: 0x%X", pga_v_);
-  ESP_LOGCONFIG(TAG, "  PGA_IA_8: 0x%X", pga_ia_);
-  ESP_LOGCONFIG(TAG, "  PGA_IB_8: 0x%X", pga_ib_);
-  ESP_LOGCONFIG(TAG, "  VGAIN_32: 0x%08jX", (uintmax_t) vgain_);
-  ESP_LOGCONFIG(TAG, "  AIGAIN_32: 0x%08jX", (uintmax_t) aigain_);
-  ESP_LOGCONFIG(TAG, "  BIGAIN_32: 0x%08jX", (uintmax_t) bigain_);
-  ESP_LOGCONFIG(TAG, "  AWGAIN_32: 0x%08jX", (uintmax_t) awgain_);
-  ESP_LOGCONFIG(TAG, "  BWGAIN_32: 0x%08jX", (uintmax_t) bwgain_);
+  ESP_LOGCONFIG(TAG,
+                "  USE_ACC_ENERGY_REGS: %d\n"
+                "  PGA_V_8: 0x%X\n"
+                "  PGA_IA_8: 0x%X\n"
+                "  PGA_IB_8: 0x%X\n"
+                "  VGAIN_32: 0x%08jX\n"
+                "  AIGAIN_32: 0x%08jX\n"
+                "  BIGAIN_32: 0x%08jX\n"
+                "  AWGAIN_32: 0x%08jX\n"
+                "  BWGAIN_32: 0x%08jX",
+                this->use_acc_energy_regs_, pga_v_, pga_ia_, pga_ib_, (uintmax_t) vgain_, (uintmax_t) aigain_,
+                (uintmax_t) bigain_, (uintmax_t) awgain_, (uintmax_t) bwgain_);
 }
 
 #define ADE_PUBLISH_(name, val, factor) \

esphome/components/ade7953_i2c/ade7953_i2c.cpp

@@ -1,6 +1,6 @@
 #include "ade7953_i2c.h"
-#include "esphome/core/log.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 namespace esphome {
 namespace ade7953_i2c {

esphome/components/ade7953_spi/ade7953_spi.cpp

@@ -1,6 +1,6 @@
 #include "ade7953_spi.h"
-#include "esphome/core/log.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 namespace esphome {
 namespace ade7953_spi {

esphome/components/ads1115/ads1115.cpp

@@ -10,15 +10,13 @@ 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();
     return;
   }
 
-  ESP_LOGCONFIG(TAG, "Configuring ADS1115...");
-
   uint16_t config = 0;
   // Clear single-shot bit
   //        0b0xxxxxxxxxxxxxxx
@@ -68,10 +66,10 @@ 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!");
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
 }
 float ADS1115Component::request_measurement(ADS1115Multiplexer multiplexer, ADS1115Gain gain,

esphome/components/ads1118/ads1118.cpp

@@ -1,4 +1,5 @@
 #include "ads1118.h"
+#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
 namespace esphome {
@@ -8,7 +9,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

@@ -1,4 +1,5 @@
 #include "ags10.h"
+#include "esphome/core/helpers.h"
 
 #include <cinttypes>
 
@@ -23,7 +24,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) {
@@ -65,7 +66,7 @@ void AGS10Component::dump_config() {
     case NONE:
       break;
     case COMMUNICATION_FAILED:
-      ESP_LOGE(TAG, "Communication with AGS10 failed!");
+      ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
       break;
     case CRC_CHECK_FAILED:
       ESP_LOGE(TAG, "The crc check failed");

esphome/components/aht10/aht10.cpp

@@ -13,8 +13,9 @@
 // results making successive requests; the current implementation makes 3 attempts with a delay of 30ms each time.
 
 #include "aht10.h"
-#include "esphome/core/log.h"
 #include "esphome/core/hal.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.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, ESP_LOG_MSG_COMM_FAIL);
     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, ESP_LOG_MSG_COMM_FAIL);
       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(ESP_LOG_MSG_COMM_FAIL);
       }
       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(ESP_LOG_MSG_COMM_FAIL);
     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, ESP_LOG_MSG_COMM_FAIL);
   }
   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");
@@ -113,7 +113,7 @@ void AIC3204::dump_config() {
   LOG_I2C_DEVICE(this);
 
   if (this->is_failed()) {
-    ESP_LOGE(TAG, "Communication with AIC3204 failed");
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
 }
 

esphome/components/alarm_control_panel/__init__.py

@@ -235,6 +235,7 @@ async def register_alarm_control_panel(var, config):
     if not CORE.has_id(config[CONF_ID]):
         var = cg.Pvariable(config[CONF_ID], var)
     cg.add(cg.App.register_alarm_control_panel(var))
+    CORE.register_platform_component("alarm_control_panel", var)
     await setup_alarm_control_panel_core_(var, config)
 
 

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;
@@ -188,7 +188,7 @@ void AM2315C::dump_config() {
   ESP_LOGCONFIG(TAG, "AM2315C:");
   LOG_I2C_DEVICE(this);
   if (this->is_failed()) {
-    ESP_LOGE(TAG, "Communication with AM2315C failed!");
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
   LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
   LOG_SENSOR("  ", "Humidity", this->humidity_sensor_);

esphome/components/am2320/am2320.cpp

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

esphome/components/am43/am43_base.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include "esphome/core/log.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 namespace esphome {
 namespace am43 {