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

esphome/components/seeed_mr24hpc1/seeed_mr24hpc1.cpp

@@ -1,5 +1,6 @@
 #include "seeed_mr24hpc1.h"
 
+#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
 #include <utility>
@@ -61,7 +62,7 @@ void MR24HPC1Component::dump_config() {
 
 // Initialisation functions
 void MR24HPC1Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up MR24HPC1...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   this->check_uart_settings(115200);
 
   if (this->custom_mode_number_ != nullptr) {
@@ -533,7 +534,7 @@ void MR24HPC1Component::r24_frame_parse_work_status_(uint8_t *data) {
       this->custom_mode_number_->publish_state(0);
     }
     if (this->custom_mode_end_text_sensor_ != nullptr) {
-      this->custom_mode_end_text_sensor_->publish_state("Setup in progress...");
+      this->custom_mode_end_text_sensor_->publish_state("Setup in progress");
     }
   } else if (data[FRAME_COMMAND_WORD_INDEX] == 0x81) {
     ESP_LOGD(TAG, "Reply: get radar init status 0x%02X", data[FRAME_DATA_INDEX]);

esphome/components/seeed_mr60bha2/seeed_mr60bha2.cpp

@@ -1,4 +1,5 @@
 #include "seeed_mr60bha2.h"
+#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
 #include <cinttypes>

esphome/components/seeed_mr60fda2/seeed_mr60fda2.cpp

@@ -1,4 +1,5 @@
 #include "seeed_mr60fda2.h"
+#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
 #include <cinttypes>
@@ -30,7 +31,7 @@ void MR60FDA2Component::dump_config() {
 
 // Initialisation functions
 void MR60FDA2Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up MR60FDA2...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   this->check_uart_settings(115200);
 
   this->current_frame_locate_ = LOCATE_FRAME_HEADER;
@@ -335,7 +336,7 @@ void MR60FDA2Component::set_install_height(uint8_t index) {
 
 void MR60FDA2Component::set_height_threshold(uint8_t index) {
   uint8_t send_data[13] = {0x01, 0x00, 0x00, 0x00, 0x04, 0x0E, 0x08, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00};
-  float_to_bytes(INSTALL_HEIGHT[index], &send_data[8]);
+  float_to_bytes(HEIGHT_THRESHOLD[index], &send_data[8]);
   send_data[12] = calculate_checksum(send_data + 8, 4);
   this->write_array(send_data, 13);
   ESP_LOGV(TAG, "SEND HEIGHT THRESHOLD: %s", format_hex_pretty(send_data, 13).c_str());

esphome/components/selec_meter/selec_meter.cpp

@@ -1,5 +1,6 @@
 #include "selec_meter.h"
 #include "selec_meter_registers.h"
+#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
 namespace esphome {
@@ -83,8 +84,10 @@ void SelecMeter::on_modbus_data(const std::vector<uint8_t> &data) {
 
 void SelecMeter::update() { this->send(MODBUS_CMD_READ_IN_REGISTERS, 0, MODBUS_REGISTER_COUNT); }
 void SelecMeter::dump_config() {
-  ESP_LOGCONFIG(TAG, "SELEC Meter:");
-  ESP_LOGCONFIG(TAG, "  Address: 0x%02X", this->address_);
+  ESP_LOGCONFIG(TAG,
+                "SELEC Meter:\n"
+                "  Address: 0x%02X",
+                this->address_);
   LOG_SENSOR("  ", "Total Active Energy", this->total_active_energy_sensor_);
   LOG_SENSOR("  ", "Import Active Energy", this->import_active_energy_sensor_);
   LOG_SENSOR("  ", "Export Active Energy", this->export_active_energy_sensor_);

esphome/components/select/__init__.py

@@ -111,6 +111,7 @@ async def register_select(var, config, *, options: list[str]):
     if not CORE.has_id(config[CONF_ID]):
         var = cg.Pvariable(config[CONF_ID], var)
     cg.add(cg.App.register_select(var))
+    CORE.register_platform_component("select", var)
     await setup_select_core_(var, config, options=options)
 
 

esphome/components/sen0321/sen0321.cpp

@@ -8,7 +8,7 @@ namespace sen0321_sensor {
 static const char *const TAG = "sen0321_sensor.sensor";
 
 void Sen0321Sensor::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up sen0321...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   if (!this->write_byte(SENSOR_MODE_REGISTER, SENSOR_MODE_AUTO)) {
     ESP_LOGW(TAG, "Error setting measurement mode.");
     this->mark_failed();
@@ -21,7 +21,7 @@ void Sen0321Sensor::dump_config() {
   ESP_LOGCONFIG(TAG, "DF Robot Ozone Sensor sen0321:");
   LOG_I2C_DEVICE(this);
   if (this->is_failed()) {
-    ESP_LOGE(TAG, "Communication with sen0321 failed!");
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
   LOG_UPDATE_INTERVAL(this);
 }

esphome/components/sen21231/sen21231.cpp

@@ -12,7 +12,7 @@ void Sen21231Sensor::dump_config() {
   ESP_LOGCONFIG(TAG, "SEN21231:");
   LOG_I2C_DEVICE(this);
   if (this->is_failed()) {
-    ESP_LOGE(TAG, "Communication with SEN21231 failed!");
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
   ESP_LOGI(TAG, "SEN21231: %s", this->is_failed() ? "FAILED" : "OK");
   LOG_UPDATE_INTERVAL(this);

esphome/components/sen5x/sen5x.cpp

@@ -30,7 +30,7 @@ static const int8_t SEN5X_MIN_INDEX_VALUE = 1 * SEN5X_INDEX_SCALE_FACTOR;     //
 static const int16_t SEN5X_MAX_INDEX_VALUE = 500 * SEN5X_INDEX_SCALE_FACTOR;  // must be adjusted by the scale factor
 
 void SEN5XComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up sen5x...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   // the sensor needs 1000 ms to enter the idle state
   this->set_timeout(1000, [this]() {
@@ -245,10 +245,10 @@ void SEN5XComponent::dump_config() {
   if (this->is_failed()) {
     switch (this->error_code_) {
       case COMMUNICATION_FAILED:
-        ESP_LOGW(TAG, "Communication failed! Is the sensor connected?");
+        ESP_LOGW(TAG, ESP_LOG_MSG_COMM_FAIL);
         break;
       case MEASUREMENT_INIT_FAILED:
-        ESP_LOGW(TAG, "Measurement Initialization failed!");
+        ESP_LOGW(TAG, "Measurement Initialization failed");
         break;
       case SERIAL_NUMBER_IDENTIFICATION_FAILED:
         ESP_LOGW(TAG, "Unable to read sensor serial id");
@@ -260,13 +260,16 @@ void SEN5XComponent::dump_config() {
         ESP_LOGW(TAG, "Unable to read sensor firmware version");
         break;
       default:
-        ESP_LOGW(TAG, "Unknown setup error!");
+        ESP_LOGW(TAG, "Unknown setup error");
         break;
     }
   }
-  ESP_LOGCONFIG(TAG, "  Productname: %s", this->product_name_.c_str());
-  ESP_LOGCONFIG(TAG, "  Firmware version: %d", this->firmware_version_);
-  ESP_LOGCONFIG(TAG, "  Serial number %02d.%02d.%02d", serial_number_[0], serial_number_[1], serial_number_[2]);
+  ESP_LOGCONFIG(TAG,
+                "  Productname: %s\n"
+                "  Firmware version: %d\n"
+                "  Serial number %02d.%02d.%02d",
+                this->product_name_.c_str(), this->firmware_version_, serial_number_[0], serial_number_[1],
+                serial_number_[2]);
   if (this->auto_cleaning_interval_.has_value()) {
     ESP_LOGCONFIG(TAG, "  Auto cleaning interval %" PRId32 " seconds", auto_cleaning_interval_.value());
   }

esphome/components/sensirion_common/i2c_sensirion.cpp

@@ -1,6 +1,7 @@
 #include "i2c_sensirion.h"
-#include "esphome/core/log.h"
 #include "esphome/core/hal.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 #include <cinttypes>
 
 namespace esphome {

esphome/components/sensirion_common/i2c_sensirion.h

@@ -1,5 +1,6 @@
 #pragma once
 #include "esphome/components/i2c/i2c.h"
+#include "esphome/core/helpers.h"
 
 #include <vector>
 

esphome/components/sensor/__init__.py

@@ -43,8 +43,10 @@ from esphome.const import (
     CONF_WINDOW_SIZE,
     DEVICE_CLASS_APPARENT_POWER,
     DEVICE_CLASS_AQI,
+    DEVICE_CLASS_AREA,
     DEVICE_CLASS_ATMOSPHERIC_PRESSURE,
     DEVICE_CLASS_BATTERY,
+    DEVICE_CLASS_BLOOD_GLUCOSE_CONCENTRATION,
     DEVICE_CLASS_CARBON_DIOXIDE,
     DEVICE_CLASS_CARBON_MONOXIDE,
     DEVICE_CLASS_CONDUCTIVITY,
@@ -56,6 +58,7 @@ from esphome.const import (
     DEVICE_CLASS_DURATION,
     DEVICE_CLASS_EMPTY,
     DEVICE_CLASS_ENERGY,
+    DEVICE_CLASS_ENERGY_DISTANCE,
     DEVICE_CLASS_ENERGY_STORAGE,
     DEVICE_CLASS_FREQUENCY,
     DEVICE_CLASS_GAS,
@@ -77,6 +80,7 @@ from esphome.const import (
     DEVICE_CLASS_PRECIPITATION,
     DEVICE_CLASS_PRECIPITATION_INTENSITY,
     DEVICE_CLASS_PRESSURE,
+    DEVICE_CLASS_REACTIVE_ENERGY,
     DEVICE_CLASS_REACTIVE_POWER,
     DEVICE_CLASS_SIGNAL_STRENGTH,
     DEVICE_CLASS_SOUND_PRESSURE,
@@ -92,6 +96,7 @@ from esphome.const import (
     DEVICE_CLASS_VOLUME_STORAGE,
     DEVICE_CLASS_WATER,
     DEVICE_CLASS_WEIGHT,
+    DEVICE_CLASS_WIND_DIRECTION,
     DEVICE_CLASS_WIND_SPEED,
     ENTITY_CATEGORY_CONFIG,
 )
@@ -104,8 +109,10 @@ CODEOWNERS = ["@esphome/core"]
 DEVICE_CLASSES = [
     DEVICE_CLASS_APPARENT_POWER,
     DEVICE_CLASS_AQI,
+    DEVICE_CLASS_AREA,
     DEVICE_CLASS_ATMOSPHERIC_PRESSURE,
     DEVICE_CLASS_BATTERY,
+    DEVICE_CLASS_BLOOD_GLUCOSE_CONCENTRATION,
     DEVICE_CLASS_CARBON_DIOXIDE,
     DEVICE_CLASS_CARBON_MONOXIDE,
     DEVICE_CLASS_CONDUCTIVITY,
@@ -117,6 +124,7 @@ DEVICE_CLASSES = [
     DEVICE_CLASS_DURATION,
     DEVICE_CLASS_EMPTY,
     DEVICE_CLASS_ENERGY,
+    DEVICE_CLASS_ENERGY_DISTANCE,
     DEVICE_CLASS_ENERGY_STORAGE,
     DEVICE_CLASS_FREQUENCY,
     DEVICE_CLASS_GAS,
@@ -138,6 +146,7 @@ DEVICE_CLASSES = [
     DEVICE_CLASS_PRECIPITATION,
     DEVICE_CLASS_PRECIPITATION_INTENSITY,
     DEVICE_CLASS_PRESSURE,
+    DEVICE_CLASS_REACTIVE_ENERGY,
     DEVICE_CLASS_REACTIVE_POWER,
     DEVICE_CLASS_SIGNAL_STRENGTH,
     DEVICE_CLASS_SOUND_PRESSURE,
@@ -153,11 +162,11 @@ DEVICE_CLASSES = [
     DEVICE_CLASS_VOLUME_STORAGE,
     DEVICE_CLASS_WATER,
     DEVICE_CLASS_WEIGHT,
+    DEVICE_CLASS_WIND_DIRECTION,
     DEVICE_CLASS_WIND_SPEED,
 ]
 
 _LOGGER = logging.getLogger(__name__)
-
 sensor_ns = cg.esphome_ns.namespace("sensor")
 StateClasses = sensor_ns.enum("StateClass")
 STATE_CLASSES = {
@@ -830,6 +839,7 @@ async def register_sensor(var, config):
     if not CORE.has_id(config[CONF_ID]):
         var = cg.Pvariable(config[CONF_ID], var)
     cg.add(cg.App.register_sensor(var))
+    CORE.register_platform_component("sensor", var)
     await setup_sensor_core_(var, config)
 
 

esphome/components/sensor/filter.h

@@ -3,9 +3,9 @@
 #include <queue>
 #include <utility>
 #include <vector>
+#include "esphome/core/automation.h"
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"
-#include "esphome/core/automation.h"
 
 namespace esphome {
 namespace sensor {

esphome/components/sensor/sensor.h

@@ -1,9 +1,9 @@
 #pragma once
 
-#include "esphome/core/log.h"
 #include "esphome/core/component.h"
 #include "esphome/core/entity_base.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 #include "esphome/components/sensor/filter.h"
 
 #include <vector>
@@ -13,13 +13,17 @@ namespace sensor {
 
 #define LOG_SENSOR(prefix, type, obj) \
   if ((obj) != nullptr) { \
-    ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, LOG_STR_LITERAL(type), (obj)->get_name().c_str()); \
+    ESP_LOGCONFIG(TAG, \
+                  "%s%s '%s'\n" \
+                  "%s  State Class: '%s'\n" \
+                  "%s  Unit of Measurement: '%s'\n" \
+                  "%s  Accuracy Decimals: %d", \
+                  prefix, LOG_STR_LITERAL(type), (obj)->get_name().c_str(), prefix, \
+                  state_class_to_string((obj)->get_state_class()).c_str(), prefix, \
+                  (obj)->get_unit_of_measurement().c_str(), prefix, (obj)->get_accuracy_decimals()); \
     if (!(obj)->get_device_class().empty()) { \
       ESP_LOGCONFIG(TAG, "%s  Device Class: '%s'", prefix, (obj)->get_device_class().c_str()); \
     } \
-    ESP_LOGCONFIG(TAG, "%s  State Class: '%s'", prefix, state_class_to_string((obj)->get_state_class()).c_str()); \
-    ESP_LOGCONFIG(TAG, "%s  Unit of Measurement: '%s'", prefix, (obj)->get_unit_of_measurement().c_str()); \
-    ESP_LOGCONFIG(TAG, "%s  Accuracy Decimals: %d", prefix, (obj)->get_accuracy_decimals()); \
     if (!(obj)->get_icon().empty()) { \
       ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon().c_str()); \
     } \

esphome/components/servo/servo.cpp

@@ -11,12 +11,15 @@ static const char *const TAG = "servo";
 uint32_t global_servo_id = 1911044085ULL;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
 void Servo::dump_config() {
-  ESP_LOGCONFIG(TAG, "Servo:");
-  ESP_LOGCONFIG(TAG, "  Idle Level: %.1f%%", this->idle_level_ * 100.0f);
-  ESP_LOGCONFIG(TAG, "  Min Level: %.1f%%", this->min_level_ * 100.0f);
-  ESP_LOGCONFIG(TAG, "  Max Level: %.1f%%", this->max_level_ * 100.0f);
-  ESP_LOGCONFIG(TAG, "  auto detach time: %" PRIu32 " ms", this->auto_detach_time_);
-  ESP_LOGCONFIG(TAG, "  run duration: %" PRIu32 " ms", this->transition_length_);
+  ESP_LOGCONFIG(TAG,
+                "Servo:\n"
+                "  Idle Level: %.1f%%\n"
+                "  Min Level: %.1f%%\n"
+                "  Max Level: %.1f%%\n"
+                "  Auto-detach time: %" PRIu32 " ms\n"
+                "  Run duration: %" PRIu32 " ms",
+                this->idle_level_ * 100.0f, this->min_level_ * 100.0f, this->max_level_ * 100.0f,
+                this->auto_detach_time_, this->transition_length_);
 }
 
 void Servo::setup() {
@@ -41,7 +44,7 @@ void Servo::loop() {
     if (millis() - this->start_millis_ > this->auto_detach_time_) {
       this->detach();
       this->start_millis_ = 0;
-      ESP_LOGD(TAG, "Servo detached on auto_detach_time");
+      ESP_LOGD(TAG, "Detached on auto_detach_time");
     }
   }
   if (this->target_value_ != this->current_value_ && this->state_ == STATE_ATTACHED) {
@@ -63,7 +66,7 @@ void Servo::loop() {
   if (this->target_value_ == this->current_value_ && this->state_ == STATE_ATTACHED) {
     this->state_ = STATE_TARGET_REACHED;
     this->start_millis_ = millis();  // set current stamp for potential auto_detach_time_ check
-    ESP_LOGD(TAG, "Servo reached target");
+    ESP_LOGD(TAG, "Reached target");
   }
 }
 
@@ -78,7 +81,7 @@ void Servo::write(float value) {
   this->source_value_ = this->current_value_;
   this->state_ = STATE_ATTACHED;
   this->start_millis_ = millis();
-  ESP_LOGD(TAG, "Servo new target: %f", value);
+  ESP_LOGD(TAG, "New target: %f", value);
 }
 
 void Servo::internal_write(float value) {

esphome/components/servo/servo.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include "esphome/core/component.h"
 #include "esphome/core/automation.h"
+#include "esphome/core/component.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/preferences.h"
 #include "esphome/components/output/float_output.h"

esphome/components/sfa30/sfa30.cpp

@@ -11,7 +11,7 @@ static const uint16_t SFA30_CMD_START_CONTINUOUS_MEASUREMENTS = 0x0006;
 static const uint16_t SFA30_CMD_READ_MEASUREMENT = 0x0327;
 
 void SFA30Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up sfa30...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   // Serial Number identification
   uint16_t raw_device_marking[16];

esphome/components/sgp30/sgp30.cpp

@@ -33,7 +33,7 @@ const uint32_t SHORTEST_BASELINE_STORE_INTERVAL = 3600;
 const uint32_t MAXIMUM_STORAGE_DIFF = 50;
 
 void SGP30Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up SGP30...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   // Serial Number identification
   uint16_t raw_serial_number[3];
@@ -232,27 +232,29 @@ void SGP30Component::dump_config() {
   if (this->is_failed()) {
     switch (this->error_code_) {
       case COMMUNICATION_FAILED:
-        ESP_LOGW(TAG, "Communication failed! Is the sensor connected?");
+        ESP_LOGW(TAG, ESP_LOG_MSG_COMM_FAIL);
         break;
       case MEASUREMENT_INIT_FAILED:
-        ESP_LOGW(TAG, "Measurement Initialization failed!");
+        ESP_LOGW(TAG, "Measurement Initialization failed");
         break;
       case INVALID_ID:
         ESP_LOGW(TAG, "Sensor reported an invalid ID. Is this an SGP30?");
         break;
       case UNSUPPORTED_ID:
-        ESP_LOGW(TAG, "Sensor reported an unsupported ID (SGPC3).");
+        ESP_LOGW(TAG, "Sensor reported an unsupported ID (SGPC3)");
         break;
       default:
-        ESP_LOGW(TAG, "Unknown setup error!");
+        ESP_LOGW(TAG, "Unknown setup error");
         break;
     }
   } else {
     ESP_LOGCONFIG(TAG, "  Serial number: %" PRIu64, this->serial_number_);
     if (this->eco2_baseline_ != 0x0000 && this->tvoc_baseline_ != 0x0000) {
-      ESP_LOGCONFIG(TAG, "  Baseline:");
-      ESP_LOGCONFIG(TAG, "    eCO2 Baseline: 0x%04X", this->eco2_baseline_);
-      ESP_LOGCONFIG(TAG, "    TVOC Baseline: 0x%04X", this->tvoc_baseline_);
+      ESP_LOGCONFIG(TAG,
+                    "  Baseline:\n"
+                    "    eCO2 Baseline: 0x%04X\n"
+                    "    TVOC Baseline: 0x%04X",
+                    this->eco2_baseline_, this->tvoc_baseline_);
     } else {
       ESP_LOGCONFIG(TAG, "  Baseline: No baseline configured");
     }

esphome/components/sgp4x/sgp4x.cpp

@@ -9,34 +9,34 @@ namespace sgp4x {
 static const char *const TAG = "sgp4x";
 
 void SGP4xComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up SGP4x...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   // Serial Number identification
   uint16_t raw_serial_number[3];
   if (!this->get_register(SGP4X_CMD_GET_SERIAL_ID, raw_serial_number, 3, 1)) {
-    ESP_LOGE(TAG, "Failed to read serial number");
+    ESP_LOGE(TAG, "Get serial number failed");
     this->error_code_ = SERIAL_NUMBER_IDENTIFICATION_FAILED;
     this->mark_failed();
     return;
   }
   this->serial_number_ = (uint64_t(raw_serial_number[0]) << 24) | (uint64_t(raw_serial_number[1]) << 16) |
                          (uint64_t(raw_serial_number[2]));
-  ESP_LOGD(TAG, "Serial Number: %" PRIu64, this->serial_number_);
+  ESP_LOGD(TAG, "Serial number: %" PRIu64, this->serial_number_);
 
   // Featureset identification for future use
-  uint16_t raw_featureset;
-  if (!this->get_register(SGP4X_CMD_GET_FEATURESET, raw_featureset, 1)) {
-    ESP_LOGD(TAG, "raw_featureset write_command_ failed");
+  uint16_t featureset;
+  if (!this->get_register(SGP4X_CMD_GET_FEATURESET, featureset, 1)) {
+    ESP_LOGD(TAG, "Get feature set failed");
     this->mark_failed();
     return;
   }
-  this->featureset_ = raw_featureset;
-  if ((this->featureset_ & 0x1FF) == SGP40_FEATURESET) {
-    sgp_type_ = SGP40;
-    self_test_time_ = SPG40_SELFTEST_TIME;
-    measure_time_ = SGP40_MEASURE_TIME;
+  featureset &= 0x1FF;
+  if (featureset == SGP40_FEATURESET) {
+    this->sgp_type_ = SGP40;
+    this->self_test_time_ = SPG40_SELFTEST_TIME;
+    this->measure_time_ = SGP40_MEASURE_TIME;
     if (this->nox_sensor_) {
-      ESP_LOGE(TAG, "Measuring NOx requires a SGP41 sensor but a SGP40 sensor is detected");
+      ESP_LOGE(TAG, "SGP41 required for NOx");
       // disable the sensor
       this->nox_sensor_->set_disabled_by_default(true);
       // make sure it's not visible in HA
@@ -45,20 +45,17 @@ void SGP4xComponent::setup() {
       // remove pointer to sensor
       this->nox_sensor_ = nullptr;
     }
+  } else if (featureset == SGP41_FEATURESET) {
+    this->sgp_type_ = SGP41;
+    this->self_test_time_ = SPG41_SELFTEST_TIME;
+    this->measure_time_ = SGP41_MEASURE_TIME;
   } else {
-    if ((this->featureset_ & 0x1FF) == SGP41_FEATURESET) {
-      sgp_type_ = SGP41;
-      self_test_time_ = SPG41_SELFTEST_TIME;
-      measure_time_ = SGP41_MEASURE_TIME;
-    } else {
-      ESP_LOGD(TAG, "Product feature set failed 0x%0X , expecting 0x%0X", uint16_t(this->featureset_ & 0x1FF),
-               SGP40_FEATURESET);
-      this->mark_failed();
-      return;
-    }
+    ESP_LOGD(TAG, "Unknown feature set 0x%0X", featureset);
+    this->mark_failed();
+    return;
   }
 
-  ESP_LOGD(TAG, "Product version: 0x%0X", uint16_t(this->featureset_ & 0x1FF));
+  ESP_LOGD(TAG, "Version 0x%0X", featureset);
 
   if (this->store_baseline_) {
     // Hash with compilation time and serial number
@@ -70,7 +67,7 @@ void SGP4xComponent::setup() {
     if (this->pref_.load(&this->voc_baselines_storage_)) {
       this->voc_state0_ = this->voc_baselines_storage_.state0;
       this->voc_state1_ = this->voc_baselines_storage_.state1;
-      ESP_LOGI(TAG, "Loaded VOC baseline state0: 0x%04" PRIX32 ", state1: 0x%04" PRIX32,
+      ESP_LOGV(TAG, "Loaded VOC baseline state0: 0x%04" PRIX32 ", state1: 0x%04" PRIX32,
                this->voc_baselines_storage_.state0, voc_baselines_storage_.state1);
     }
 
@@ -78,7 +75,7 @@ void SGP4xComponent::setup() {
     this->seconds_since_last_store_ = 0;
 
     if (this->voc_baselines_storage_.state0 > 0 && this->voc_baselines_storage_.state1 > 0) {
-      ESP_LOGI(TAG, "Setting VOC baseline from save state0: 0x%04" PRIX32 ", state1: 0x%04" PRIX32,
+      ESP_LOGV(TAG, "Setting VOC baseline from save state0: 0x%04" PRIX32 ", state1: 0x%04" PRIX32,
                this->voc_baselines_storage_.state0, voc_baselines_storage_.state1);
       voc_algorithm_.set_states(this->voc_baselines_storage_.state0, this->voc_baselines_storage_.state1);
     }
@@ -110,39 +107,29 @@ void SGP4xComponent::setup() {
   limit the amount of communication done over wifi for power consumption or to keep the
   number of records reported from being overwhelming.
   */
-  ESP_LOGD(TAG, "Component requires sampling of 1Hz, setting up background sampler");
+  ESP_LOGV(TAG, "Component requires sampling of 1Hz, setting up background sampler");
   this->set_interval(1000, [this]() { this->take_sample(); });
 }
 
 void SGP4xComponent::self_test_() {
-  ESP_LOGD(TAG, "Self-test started");
+  ESP_LOGD(TAG, "Starting self-test");
   if (!this->write_command(SGP4X_CMD_SELF_TEST)) {
     this->error_code_ = COMMUNICATION_FAILED;
-    ESP_LOGD(TAG, "Self-test communication failed");
+    ESP_LOGD(TAG, ESP_LOG_MSG_COMM_FAIL);
     this->mark_failed();
   }
 
-  this->set_timeout(self_test_time_, [this]() {
-    uint16_t reply;
-    if (!this->read_data(reply)) {
+  this->set_timeout(this->self_test_time_, [this]() {
+    uint16_t reply = 0;
+    if (!this->read_data(reply) || (reply != 0xD400)) {
       this->error_code_ = SELF_TEST_FAILED;
-      ESP_LOGD(TAG, "Self-test read_data_ failed");
+      ESP_LOGW(TAG, "Self-test failed (0x%X)", reply);
       this->mark_failed();
       return;
     }
 
-    if (reply == 0xD400) {
-      this->self_test_complete_ = true;
-      ESP_LOGD(TAG, "Self-test completed");
-      return;
-    } else {
-      this->error_code_ = SELF_TEST_FAILED;
-      ESP_LOGD(TAG, "Self-test failed 0x%X", reply);
-      return;
-    }
-
-    ESP_LOGD(TAG, "Self-test failed 0x%X", reply);
-    this->mark_failed();
+    this->self_test_complete_ = true;
+    ESP_LOGD(TAG, "Self-test complete");
   });
 }
 
@@ -150,7 +137,7 @@ void SGP4xComponent::update_gas_indices_() {
   this->voc_index_ = this->voc_algorithm_.process(this->voc_sraw_);
   if (this->nox_sensor_ != nullptr)
     this->nox_index_ = this->nox_algorithm_.process(this->nox_sraw_);
-  ESP_LOGV(TAG, "VOC = %" PRId32 ", NOx = %" PRId32, this->voc_index_, this->nox_index_);
+  ESP_LOGV(TAG, "VOC: %" PRId32 ", NOx: %" PRId32, this->voc_index_, this->nox_index_);
   // Store baselines after defined interval or if the difference between current and stored baseline becomes too
   // much
   if (this->store_baseline_ && this->seconds_since_last_store_ > SHORTEST_BASELINE_STORE_INTERVAL) {
@@ -162,18 +149,18 @@ void SGP4xComponent::update_gas_indices_() {
       this->voc_baselines_storage_.state1 = this->voc_state1_;
 
       if (this->pref_.save(&this->voc_baselines_storage_)) {
-        ESP_LOGI(TAG, "Stored VOC baseline state0: 0x%04" PRIX32 " ,state1: 0x%04" PRIX32,
+        ESP_LOGV(TAG, "Stored VOC baseline state0: 0x%04" PRIX32 ", state1: 0x%04" PRIX32,
                  this->voc_baselines_storage_.state0, this->voc_baselines_storage_.state1);
       } else {
-        ESP_LOGW(TAG, "Could not store VOC baselines");
+        ESP_LOGW(TAG, "Storing VOC baselines failed");
       }
     }
   }
 
   if (this->samples_read_ < this->samples_to_stabilize_) {
     this->samples_read_++;
-    ESP_LOGD(TAG, "Sensor has not collected enough samples yet. (%d/%d) VOC index is: %" PRIu32, this->samples_read_,
-             this->samples_to_stabilize_, this->voc_index_);
+    ESP_LOGD(TAG, "Stabilizing (%d/%d); VOC index: %" PRIu32, this->samples_read_, this->samples_to_stabilize_,
+             this->voc_index_);
   }
 }
 
@@ -182,7 +169,7 @@ void SGP4xComponent::measure_raw_() {
   static uint32_t nox_conditioning_start = millis();
 
   if (!this->self_test_complete_) {
-    ESP_LOGD(TAG, "Self-test not yet complete");
+    ESP_LOGW(TAG, "Self-test incomplete");
     return;
   }
   if (this->humidity_sensor_ != nullptr) {
@@ -270,37 +257,38 @@ void SGP4xComponent::update() {
 void SGP4xComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "SGP4x:");
   LOG_I2C_DEVICE(this);
-  ESP_LOGCONFIG(TAG, "  store_baseline: %d", this->store_baseline_);
+  ESP_LOGCONFIG(TAG, "  Store baseline: %s", YESNO(this->store_baseline_));
 
   if (this->is_failed()) {
     switch (this->error_code_) {
       case COMMUNICATION_FAILED:
-        ESP_LOGW(TAG, "Communication failed! Is the sensor connected?");
+        ESP_LOGW(TAG, ESP_LOG_MSG_COMM_FAIL);
         break;
       case SERIAL_NUMBER_IDENTIFICATION_FAILED:
-        ESP_LOGW(TAG, "Get Serial number failed.");
+        ESP_LOGW(TAG, "Get serial number failed");
         break;
       case SELF_TEST_FAILED:
-        ESP_LOGW(TAG, "Self test failed.");
+        ESP_LOGW(TAG, "Self-test failed");
         break;
-
       default:
-        ESP_LOGW(TAG, "Unknown setup error!");
+        ESP_LOGW(TAG, "Unknown error");
         break;
     }
   } else {
-    ESP_LOGCONFIG(TAG, "  Type: %s", sgp_type_ == SGP41 ? "SGP41" : "SPG40");
-    ESP_LOGCONFIG(TAG, "  Serial number: %" PRIu64, this->serial_number_);
-    ESP_LOGCONFIG(TAG, "  Minimum Samples: %f", GasIndexAlgorithm_INITIAL_BLACKOUT);
+    ESP_LOGCONFIG(TAG,
+                  "  Type: %s\n"
+                  "  Serial number: %" PRIu64 "\n"
+                  "  Minimum Samples: %f",
+                  sgp_type_ == SGP41 ? "SGP41" : "SPG40", this->serial_number_, GasIndexAlgorithm_INITIAL_BLACKOUT);
   }
   LOG_UPDATE_INTERVAL(this);
 
+  ESP_LOGCONFIG(TAG, "  Compensation:");
   if (this->humidity_sensor_ != nullptr || this->temperature_sensor_ != nullptr) {
-    ESP_LOGCONFIG(TAG, "  Compensation:");
     LOG_SENSOR("    ", "Temperature Source:", this->temperature_sensor_);
     LOG_SENSOR("    ", "Humidity Source:", this->humidity_sensor_);
   } else {
-    ESP_LOGCONFIG(TAG, "  Compensation: No source configured");
+    ESP_LOGCONFIG(TAG, "    No source configured");
   }
   LOG_SENSOR("  ", "VOC", this->voc_sensor_);
   LOG_SENSOR("  ", "NOx", this->nox_sensor_);

esphome/components/sgp4x/sgp4x.h

@@ -115,7 +115,6 @@ class SGP4xComponent : public PollingComponent, public sensor::Sensor, public se
 
   SgpType sgp_type_{SGP40};
   uint64_t serial_number_;
-  uint16_t featureset_;
 
   bool self_test_complete_;
   uint16_t self_test_time_;