esphome 2025.8.4__py3-none-any.whl → 2025.9.0b1__py3-none-any.whl

esphome/components/sgp30/sgp30.cpp

@@ -1,9 +1,11 @@
 #include "sgp30.h"
-#include <cinttypes>
 #include "esphome/core/application.h"
 #include "esphome/core/hal.h"
+#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
+#include <cinttypes>
+
 namespace esphome {
 namespace sgp30 {
 
@@ -39,9 +41,8 @@ void SGP30Component::setup() {
     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_);
+  this->serial_number_ = encode_uint24(raw_serial_number[0], raw_serial_number[1], raw_serial_number[2]);
+  ESP_LOGD(TAG, "Serial number: %" PRIu64, this->serial_number_);
 
   // Featureset identification for future use
   uint16_t raw_featureset;
@@ -61,11 +62,11 @@ void SGP30Component::setup() {
     this->mark_failed();
     return;
   }
-  ESP_LOGD(TAG, "Product version: 0x%0X", uint16_t(this->featureset_ & 0x1FF));
+  ESP_LOGV(TAG, "Product version: 0x%0X", uint16_t(this->featureset_ & 0x1FF));
 
   // Sensor initialization
   if (!this->write_command(SGP30_CMD_IAQ_INIT)) {
-    ESP_LOGE(TAG, "Sensor sgp30_iaq_init failed.");
+    ESP_LOGE(TAG, "sgp30_iaq_init failed");
     this->error_code_ = MEASUREMENT_INIT_FAILED;
     this->mark_failed();
     return;
@@ -123,7 +124,7 @@ void SGP30Component::read_iaq_baseline_() {
       uint16_t eco2baseline = (raw_data[0]);
       uint16_t tvocbaseline = (raw_data[1]);
 
-      ESP_LOGI(TAG, "Current eCO2 baseline: 0x%04X, TVOC baseline: 0x%04X", eco2baseline, tvocbaseline);
+      ESP_LOGI(TAG, "Baselines: eCO2: 0x%04X, TVOC: 0x%04X", eco2baseline, tvocbaseline);
       if (eco2baseline != this->eco2_baseline_ || tvocbaseline != this->tvoc_baseline_) {
         this->eco2_baseline_ = eco2baseline;
         this->tvoc_baseline_ = tvocbaseline;
@@ -142,7 +143,7 @@ void SGP30Component::read_iaq_baseline_() {
           this->baselines_storage_.eco2 = this->eco2_baseline_;
           this->baselines_storage_.tvoc = this->tvoc_baseline_;
           if (this->pref_.save(&this->baselines_storage_)) {
-            ESP_LOGI(TAG, "Store eCO2 baseline: 0x%04X, TVOC baseline: 0x%04X", this->baselines_storage_.eco2,
+            ESP_LOGI(TAG, "Store baselines: eCO2: 0x%04X, TVOC: 0x%04X", this->baselines_storage_.eco2,
                      this->baselines_storage_.tvoc);
           } else {
             ESP_LOGW(TAG, "Could not store eCO2 and TVOC baselines");
@@ -164,7 +165,7 @@ void SGP30Component::send_env_data_() {
   if (this->humidity_sensor_ != nullptr)
     humidity = this->humidity_sensor_->state;
   if (std::isnan(humidity) || humidity < 0.0f || humidity > 100.0f) {
-    ESP_LOGW(TAG, "Compensation not possible yet: bad humidity data.");
+    ESP_LOGW(TAG, "Compensation not possible yet: bad humidity data");
     return;
   } else {
     ESP_LOGD(TAG, "External compensation data received: Humidity %0.2f%%", humidity);
@@ -174,7 +175,7 @@ void SGP30Component::send_env_data_() {
     temperature = float(this->temperature_sensor_->state);
   }
   if (std::isnan(temperature) || temperature < -40.0f || temperature > 85.0f) {
-    ESP_LOGW(TAG, "Compensation not possible yet: bad temperature value data.");
+    ESP_LOGW(TAG, "Compensation not possible yet: bad temperature value");
     return;
   } else {
     ESP_LOGD(TAG, "External compensation data received: Temperature %0.2f°C", temperature);
@@ -192,18 +193,17 @@ void SGP30Component::send_env_data_() {
         ((humidity * 0.061121f * std::exp((18.678f - temperature / 234.5f) * (temperature / (257.14f + temperature)))) /
          (273.15f + temperature));
   }
-  uint8_t humidity_full = uint8_t(std::floor(absolute_humidity));
-  uint8_t humidity_dec = uint8_t(std::floor((absolute_humidity - std::floor(absolute_humidity)) * 256));
-  ESP_LOGD(TAG, "Calculated Absolute humidity: %0.3f g/m³ (0x%04X)", absolute_humidity,
-           uint16_t(uint16_t(humidity_full) << 8 | uint16_t(humidity_dec)));
-  uint8_t crc = sht_crc_(humidity_full, humidity_dec);
-  uint8_t data[4];
-  data[0] = SGP30_CMD_SET_ABSOLUTE_HUMIDITY & 0xFF;
-  data[1] = humidity_full;
-  data[2] = humidity_dec;
-  data[3] = crc;
+  uint8_t data[4] = {
+      SGP30_CMD_SET_ABSOLUTE_HUMIDITY & 0xFF,
+      uint8_t(std::floor(absolute_humidity)),                                          // humidity_full
+      uint8_t(std::floor((absolute_humidity - std::floor(absolute_humidity)) * 256)),  // humidity_dec
+      0,
+  };
+  data[3] = crc8(&data[1], 2, 0xFF, sensirion_common::CRC_POLYNOMIAL, true);
+  ESP_LOGD(TAG, "Calculated absolute humidity: %0.3f g/m³ (0x%04X)", absolute_humidity,
+           encode_uint16(data[1], data[2]));
   if (!this->write_bytes(SGP30_CMD_SET_ABSOLUTE_HUMIDITY >> 8, data, 4)) {
-    ESP_LOGE(TAG, "Error sending compensation data.");
+    ESP_LOGE(TAG, "Error sending compensation data");
   }
 }
 
@@ -212,15 +212,14 @@ void SGP30Component::write_iaq_baseline_(uint16_t eco2_baseline, uint16_t tvoc_b
   data[0] = SGP30_CMD_SET_IAQ_BASELINE & 0xFF;
   data[1] = tvoc_baseline >> 8;
   data[2] = tvoc_baseline & 0xFF;
-  data[3] = sht_crc_(data[1], data[2]);
+  data[3] = crc8(&data[1], 2, 0xFF, sensirion_common::CRC_POLYNOMIAL, true);
   data[4] = eco2_baseline >> 8;
   data[5] = eco2_baseline & 0xFF;
-  data[6] = sht_crc_(data[4], data[5]);
+  data[6] = crc8(&data[4], 2, 0xFF, sensirion_common::CRC_POLYNOMIAL, true);
   if (!this->write_bytes(SGP30_CMD_SET_IAQ_BASELINE >> 8, data, 7)) {
-    ESP_LOGE(TAG, "Error applying eCO2 baseline: 0x%04X, TVOC baseline: 0x%04X", eco2_baseline, tvoc_baseline);
+    ESP_LOGE(TAG, "Error applying baselines: eCO2: 0x%04X, TVOC: 0x%04X", eco2_baseline, tvoc_baseline);
   } else {
-    ESP_LOGI(TAG, "Initial baselines applied successfully! eCO2 baseline: 0x%04X, TVOC baseline: 0x%04X", eco2_baseline,
-             tvoc_baseline);
+    ESP_LOGI(TAG, "Initial baselines applied: eCO2: 0x%04X, TVOC: 0x%04X", eco2_baseline, tvoc_baseline);
   }
 }
 
@@ -236,10 +235,10 @@ void SGP30Component::dump_config() {
         ESP_LOGW(TAG, "Measurement Initialization failed");
         break;
       case INVALID_ID:
-        ESP_LOGW(TAG, "Sensor reported an invalid ID. Is this an SGP30?");
+        ESP_LOGW(TAG, "Invalid ID");
         break;
       case UNSUPPORTED_ID:
-        ESP_LOGW(TAG, "Sensor reported an unsupported ID (SGPC3)");
+        ESP_LOGW(TAG, "Unsupported ID");
         break;
       default:
         ESP_LOGW(TAG, "Unknown setup error");
@@ -249,12 +248,12 @@ void SGP30Component::dump_config() {
     ESP_LOGCONFIG(TAG, "  Serial number: %" PRIu64, this->serial_number_);
     if (this->eco2_baseline_ != 0x0000 && this->tvoc_baseline_ != 0x0000) {
       ESP_LOGCONFIG(TAG,
-                    "  Baseline:\n"
-                    "    eCO2 Baseline: 0x%04X\n"
-                    "    TVOC Baseline: 0x%04X",
+                    "  Baselines:\n"
+                    "    eCO2: 0x%04X\n"
+                    "    TVOC: 0x%04X",
                     this->eco2_baseline_, this->tvoc_baseline_);
     } else {
-      ESP_LOGCONFIG(TAG, "  Baseline: No baseline configured");
+      ESP_LOGCONFIG(TAG, "  Baselines not configured");
     }
     ESP_LOGCONFIG(TAG, "  Warm up time: %" PRIu32 "s", this->required_warm_up_time_);
   }
@@ -266,8 +265,8 @@ void SGP30Component::dump_config() {
   ESP_LOGCONFIG(TAG, "Store baseline: %s", YESNO(this->store_baseline_));
   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_);
+    LOG_SENSOR("    ", "Temperature source:", this->temperature_sensor_);
+    LOG_SENSOR("    ", "Humidity source:", this->humidity_sensor_);
   } else {
     ESP_LOGCONFIG(TAG, "  Compensation: No source configured");
   }
@@ -289,7 +288,7 @@ void SGP30Component::update() {
     float eco2 = (raw_data[0]);
     float tvoc = (raw_data[1]);
 
-    ESP_LOGD(TAG, "Got eCO2=%.1fppm TVOC=%.1fppb", eco2, tvoc);
+    ESP_LOGV(TAG, "eCO2=%.1fppm TVOC=%.1fppb", eco2, tvoc);
     if (this->eco2_sensor_ != nullptr)
       this->eco2_sensor_->publish_state(eco2);
     if (this->tvoc_sensor_ != nullptr)

esphome/components/sgp30/sgp30.h

@@ -1,8 +1,8 @@
 #pragma once
 
-#include "esphome/core/component.h"
-#include "esphome/components/sensor/sensor.h"
 #include "esphome/components/sensirion_common/i2c_sensirion.h"
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/core/component.h"
 #include "esphome/core/preferences.h"
 
 #include <cinttypes>
@@ -38,14 +38,16 @@ class SGP30Component : public PollingComponent, public sensirion_common::Sensiri
   void read_iaq_baseline_();
   bool is_sensor_baseline_reliable_();
   void write_iaq_baseline_(uint16_t eco2_baseline, uint16_t tvoc_baseline);
+
   uint64_t serial_number_;
-  uint16_t featureset_;
   uint32_t required_warm_up_time_;
   uint32_t seconds_since_last_store_;
-  SGP30Baselines baselines_storage_;
-  ESPPreferenceObject pref_;
+  uint16_t featureset_;
+  uint16_t eco2_baseline_{0x0000};
+  uint16_t tvoc_baseline_{0x0000};
+  bool store_baseline_;
 
-  enum ErrorCode {
+  enum ErrorCode : uint8_t {
     COMMUNICATION_FAILED,
     MEASUREMENT_INIT_FAILED,
     INVALID_ID,
@@ -53,14 +55,13 @@ class SGP30Component : public PollingComponent, public sensirion_common::Sensiri
     UNKNOWN
   } error_code_{UNKNOWN};
 
+  ESPPreferenceObject pref_;
+  SGP30Baselines baselines_storage_;
+
   sensor::Sensor *eco2_sensor_{nullptr};
   sensor::Sensor *tvoc_sensor_{nullptr};
   sensor::Sensor *eco2_sensor_baseline_{nullptr};
   sensor::Sensor *tvoc_sensor_baseline_{nullptr};
-  uint16_t eco2_baseline_{0x0000};
-  uint16_t tvoc_baseline_{0x0000};
-  bool store_baseline_;
-
   /// Input sensor for humidity and temperature compensation.
   sensor::Sensor *humidity_sensor_{nullptr};
   sensor::Sensor *temperature_sensor_{nullptr};

esphome/components/sgp4x/sgp4x.cpp

@@ -211,7 +211,7 @@ void SGP4xComponent::measure_raw_() {
 
   if (!this->write_command(command, data, 2)) {
     ESP_LOGD(TAG, "write error (%d)", this->last_error_);
-    this->status_set_warning("measurement request failed");
+    this->status_set_warning(LOG_STR("measurement request failed"));
     return;
   }
 
@@ -220,7 +220,7 @@ void SGP4xComponent::measure_raw_() {
     raw_data[1] = 0;
     if (!this->read_data(raw_data, response_words)) {
       ESP_LOGD(TAG, "read error (%d)", this->last_error_);
-      this->status_set_warning("measurement read failed");
+      this->status_set_warning(LOG_STR("measurement read failed"));
       this->voc_index_ = this->nox_index_ = UINT16_MAX;
       return;
     }

esphome/components/shelly_dimmer/light.py

@@ -183,7 +183,7 @@ CONFIG_SCHEMA = (
 )
 
 
-def to_code(config):
+async def to_code(config):
     fw_hex = get_firmware(config[CONF_FIRMWARE])
     fw_major, fw_minor = parse_firmware_version(config[CONF_FIRMWARE][CONF_VERSION])
 
@@ -193,17 +193,17 @@ def to_code(config):
     cg.add_define("USE_SHD_FIRMWARE_MINOR_VERSION", fw_minor)
 
     var = cg.new_Pvariable(config[CONF_OUTPUT_ID])
-    yield cg.register_component(var, config)
+    await cg.register_component(var, config)
     config.pop(
         CONF_UPDATE_INTERVAL
     )  # drop UPDATE_INTERVAL as it does not apply to the light component
 
-    yield light.register_light(var, config)
-    yield uart.register_uart_device(var, config)
+    await light.register_light(var, config)
+    await uart.register_uart_device(var, config)
 
-    nrst_pin = yield cg.gpio_pin_expression(config[CONF_NRST_PIN])
+    nrst_pin = await cg.gpio_pin_expression(config[CONF_NRST_PIN])
     cg.add(var.set_nrst_pin(nrst_pin))
-    boot0_pin = yield cg.gpio_pin_expression(config[CONF_BOOT0_PIN])
+    boot0_pin = await cg.gpio_pin_expression(config[CONF_BOOT0_PIN])
     cg.add(var.set_boot0_pin(boot0_pin))
 
     cg.add(var.set_leading_edge(config[CONF_LEADING_EDGE]))
@@ -217,5 +217,5 @@ def to_code(config):
             continue
 
         conf = config[key]
-        sens = yield sensor.new_sensor(conf)
+        sens = await sensor.new_sensor(conf)
         cg.add(getattr(var, f"set_{key}_sensor")(sens))

esphome/components/sht4x/sht4x.cpp

@@ -65,7 +65,7 @@ void SHT4XComponent::update() {
   // Send command
   if (!this->write_command(MEASURECOMMANDS[this->precision_])) {
     // Warning will be printed only if warning status is not set yet
-    this->status_set_warning("Failed to send measurement command");
+    this->status_set_warning(LOG_STR("Failed to send measurement command"));
     return;
   }
 

esphome/components/sntp/sntp_component.cpp

@@ -14,8 +14,13 @@ namespace sntp {
 
 static const char *const TAG = "sntp";
 
+#if defined(USE_ESP32)
+SNTPComponent *SNTPComponent::instance = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+#endif
+
 void SNTPComponent::setup() {
 #if defined(USE_ESP32)
+  SNTPComponent::instance = this;
   if (esp_sntp_enabled()) {
     esp_sntp_stop();
   }
@@ -25,6 +30,11 @@ void SNTPComponent::setup() {
     esp_sntp_setservername(i++, server.c_str());
   }
   esp_sntp_set_sync_interval(this->get_update_interval());
+  esp_sntp_set_time_sync_notification_cb([](struct timeval *tv) {
+    if (SNTPComponent::instance != nullptr) {
+      SNTPComponent::instance->defer([]() { SNTPComponent::instance->time_synced(); });
+    }
+  });
   esp_sntp_init();
 #else
   sntp_stop();
@@ -34,6 +44,14 @@ void SNTPComponent::setup() {
   for (auto &server : this->servers_) {
     sntp_setservername(i++, server.c_str());
   }
+
+#if defined(USE_ESP8266)
+  settimeofday_cb([this](bool from_sntp) {
+    if (from_sntp)
+      this->time_synced();
+  });
+#endif
+
   sntp_init();
 #endif
 }
@@ -46,7 +64,8 @@ void SNTPComponent::dump_config() {
 }
 void SNTPComponent::update() {
 #if !defined(USE_ESP32)
-  // force resync
+  // Some platforms currently cannot set the sync interval at runtime so we need
+  // to do the re-sync by hand for now.
   if (sntp_enabled()) {
     sntp_stop();
     this->has_time_ = false;
@@ -55,23 +74,31 @@ void SNTPComponent::update() {
 #endif
 }
 void SNTPComponent::loop() {
+// The loop is used to infer whether we have valid time on platforms where we
+// cannot tell whether SNTP has succeeded.
+// One limitation of this approach is that we cannot tell if it was the SNTP
+// component that set the time.
+// ESP-IDF and ESP8266 use callbacks from the SNTP task to trigger the
+// `on_time_sync` trigger on successful sync events.
+#if defined(USE_ESP32) || defined(USE_ESP8266)
+  this->disable_loop();
+#endif
+
   if (this->has_time_)
     return;
 
+  this->time_synced();
+}
+
+void SNTPComponent::time_synced() {
   auto time = this->now();
-  if (!time.is_valid())
+  this->has_time_ = time.is_valid();
+  if (!this->has_time_)
     return;
 
   ESP_LOGD(TAG, "Synchronized time: %04d-%02d-%02d %02d:%02d:%02d", time.year, time.month, time.day_of_month, time.hour,
            time.minute, time.second);
   this->time_sync_callback_.call();
-  this->has_time_ = true;
-
-#ifdef USE_ESP_IDF
-  // On ESP-IDF, time sync is permanent and update() doesn't force resync
-  // Time is now synchronized, no need to check anymore
-  this->disable_loop();
-#endif
 }
 
 }  // namespace sntp

esphome/components/sntp/sntp_component.h

@@ -26,9 +26,16 @@ class SNTPComponent : public time::RealTimeClock {
   void update() override;
   void loop() override;
 
+  void time_synced();
+
  protected:
   std::vector<std::string> servers_;
   bool has_time_{false};
+
+#if defined(USE_ESP32)
+ private:
+  static SNTPComponent *instance;
+#endif
 };
 
 }  // namespace sntp

esphome/components/sound_level/sound_level.cpp

@@ -56,7 +56,7 @@ void SoundLevelComponent::loop() {
     }
   } else {
     if (!this->status_has_warning()) {
-      this->status_set_warning("Microphone isn't running, can't compute statistics");
+      this->status_set_warning(LOG_STR("Microphone isn't running, can't compute statistics"));
 
       // Deallocate buffers, if necessary
       this->stop_();

esphome/components/speaker/__init__.py

@@ -4,7 +4,7 @@ from esphome.components import audio, audio_dac
 import esphome.config_validation as cv
 from esphome.const import CONF_DATA, CONF_ID, CONF_VOLUME
 from esphome.core import CORE
-from esphome.coroutine import coroutine_with_priority
+from esphome.coroutine import CoroPriority, coroutine_with_priority
 
 AUTO_LOAD = ["audio"]
 CODEOWNERS = ["@jesserockz", "@kahrendt"]
@@ -138,7 +138,7 @@ async def speaker_mute_action_to_code(config, action_id, template_arg, args):
     return cg.new_Pvariable(action_id, template_arg, paren)
 
 
-@coroutine_with_priority(100.0)
+@coroutine_with_priority(CoroPriority.CORE)
 async def to_code(config):
     cg.add_global(speaker_ns.using)
     cg.add_define("USE_SPEAKER")

esphome/components/speaker/media_player/__init__.py

@@ -147,7 +147,7 @@ def _read_audio_file_and_type(file_config):
     elif file_source == TYPE_WEB:
         path = _compute_local_file_path(conf_file)
     else:
-        raise cv.Invalid("Unsupported file source.")
+        raise cv.Invalid("Unsupported file source")
 
     with open(path, "rb") as f:
         data = f.read()
@@ -219,7 +219,7 @@ def _validate_supported_local_file(config):
     for file_config in config.get(CONF_FILES, []):
         _, media_file_type = _read_audio_file_and_type(file_config)
         if str(media_file_type) == str(audio.AUDIO_FILE_TYPE_ENUM["NONE"]):
-            raise cv.Invalid("Unsupported local media file.")
+            raise cv.Invalid("Unsupported local media file")
         if not config[CONF_CODEC_SUPPORT_ENABLED] and str(media_file_type) != str(
             audio.AUDIO_FILE_TYPE_ENUM["WAV"]
         ):

esphome/components/speaker/media_player/speaker_media_player.cpp

@@ -55,7 +55,7 @@ void SpeakerMediaPlayer::setup() {
 
   this->media_control_command_queue_ = xQueueCreate(MEDIA_CONTROLS_QUEUE_LENGTH, sizeof(MediaCallCommand));
 
-  this->pref_ = global_preferences->make_preference<VolumeRestoreState>(this->get_object_id_hash());
+  this->pref_ = global_preferences->make_preference<VolumeRestoreState>(this->get_preference_hash());
 
   VolumeRestoreState volume_restore_state;
   if (this->pref_.load(&volume_restore_state)) {

esphome/components/spi/__init__.py

@@ -35,7 +35,7 @@ from esphome.const import (
     PLATFORM_RP2040,
     PlatformFramework,
 )
-from esphome.core import CORE, coroutine_with_priority
+from esphome.core import CORE, CoroPriority, coroutine_with_priority
 import esphome.final_validate as fv
 
 CODEOWNERS = ["@esphome/core", "@clydebarrow"]
@@ -351,7 +351,7 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
-@coroutine_with_priority(1.0)
+@coroutine_with_priority(CoroPriority.BUS)
 async def to_code(configs):
     cg.add_define("USE_SPI")
     cg.add_global(spi_ns.using)

esphome/components/sprinkler/sprinkler.cpp

@@ -81,7 +81,7 @@ void SprinklerControllerNumber::setup() {
   if (!this->restore_value_) {
     value = this->initial_value_;
   } else {
-    this->pref_ = global_preferences->make_preference<float>(this->get_object_id_hash());
+    this->pref_ = global_preferences->make_preference<float>(this->get_preference_hash());
     if (!this->pref_.load(&value)) {
       if (!std::isnan(this->initial_value_)) {
         value = this->initial_value_;

esphome/components/sps30/sps30.cpp

@@ -43,20 +43,20 @@ void SPS30Component::setup() {
       this->serial_number_[i * 2] = static_cast<char>(raw_serial_number[i] >> 8);
       this->serial_number_[i * 2 + 1] = uint16_t(uint16_t(raw_serial_number[i] & 0xFF));
     }
-    ESP_LOGD(TAG, "  Serial Number: '%s'", this->serial_number_);
+    ESP_LOGV(TAG, "  Serial number: %s", this->serial_number_);
 
     bool result;
     if (this->fan_interval_.has_value()) {
       // override default value
-      result = write_command(SPS30_CMD_SET_AUTOMATIC_CLEANING_INTERVAL_SECONDS, this->fan_interval_.value());
+      result = this->write_command(SPS30_CMD_SET_AUTOMATIC_CLEANING_INTERVAL_SECONDS, this->fan_interval_.value());
     } else {
-      result = write_command(SPS30_CMD_SET_AUTOMATIC_CLEANING_INTERVAL_SECONDS);
+      result = this->write_command(SPS30_CMD_SET_AUTOMATIC_CLEANING_INTERVAL_SECONDS);
     }
     if (result) {
       delay(20);
       uint16_t secs[2];
       if (this->read_data(secs, 2)) {
-        fan_interval_ = secs[0] << 16 | secs[1];
+        this->fan_interval_ = secs[0] << 16 | secs[1];
       }
     }
 
@@ -67,7 +67,7 @@ void SPS30Component::setup() {
 }
 
 void SPS30Component::dump_config() {
-  ESP_LOGCONFIG(TAG, "sps30:");
+  ESP_LOGCONFIG(TAG, "SPS30:");
   LOG_I2C_DEVICE(this);
   if (this->is_failed()) {
     switch (this->error_code_) {
@@ -78,16 +78,16 @@ void SPS30Component::dump_config() {
         ESP_LOGW(TAG, "Measurement Initialization failed");
         break;
       case SERIAL_NUMBER_REQUEST_FAILED:
-        ESP_LOGW(TAG, "Unable to request sensor serial number");
+        ESP_LOGW(TAG, "Unable to request serial number");
         break;
       case SERIAL_NUMBER_READ_FAILED:
-        ESP_LOGW(TAG, "Unable to read sensor serial number");
+        ESP_LOGW(TAG, "Unable to read serial number");
         break;
       case FIRMWARE_VERSION_REQUEST_FAILED:
-        ESP_LOGW(TAG, "Unable to request sensor firmware version");
+        ESP_LOGW(TAG, "Unable to request firmware version");
         break;
       case FIRMWARE_VERSION_READ_FAILED:
-        ESP_LOGW(TAG, "Unable to read sensor firmware version");
+        ESP_LOGW(TAG, "Unable to read firmware version");
         break;
       default:
         ESP_LOGW(TAG, "Unknown setup error");
@@ -96,9 +96,9 @@ void SPS30Component::dump_config() {
   }
   LOG_UPDATE_INTERVAL(this);
   ESP_LOGCONFIG(TAG,
-                "  Serial Number: '%s'\n"
+                "  Serial number: %s\n"
                 "  Firmware version v%0d.%0d",
-                this->serial_number_, (raw_firmware_version_ >> 8), uint16_t(raw_firmware_version_ & 0xFF));
+                this->serial_number_, this->raw_firmware_version_ >> 8, this->raw_firmware_version_ & 0xFF);
   LOG_SENSOR("  ", "PM1.0 Weight Concentration", this->pm_1_0_sensor_);
   LOG_SENSOR("  ", "PM2.5 Weight Concentration", this->pm_2_5_sensor_);
   LOG_SENSOR("  ", "PM4 Weight Concentration", this->pm_4_0_sensor_);
@@ -113,15 +113,15 @@ void SPS30Component::dump_config() {
 void SPS30Component::update() {
   /// Check if warning flag active (sensor reconnected?)
   if (this->status_has_warning()) {
-    ESP_LOGD(TAG, "Trying to reconnect");
+    ESP_LOGD(TAG, "Reconnecting");
     if (this->write_command(SPS30_CMD_SOFT_RESET)) {
-      ESP_LOGD(TAG, "Soft-reset successful. Waiting for reconnection in 500 ms");
+      ESP_LOGD(TAG, "Soft-reset successful; waiting 500 ms");
       this->set_timeout(500, [this]() {
         this->start_continuous_measurement_();
         /// Sensor restarted and reading attempt made next cycle
         this->status_clear_warning();
         this->skipped_data_read_cycles_ = 0;
-        ESP_LOGD(TAG, "Reconnect successful. Resuming continuous measurement");
+        ESP_LOGD(TAG, "Reconnected; resuming continuous measurement");
       });
     } else {
       ESP_LOGD(TAG, "Soft-reset failed");
@@ -136,12 +136,12 @@ void SPS30Component::update() {
 
   uint16_t raw_read_status;
   if (!this->read_data(&raw_read_status, 1) || raw_read_status == 0x00) {
-    ESP_LOGD(TAG, "Not ready yet");
+    ESP_LOGD(TAG, "Not ready");
     this->skipped_data_read_cycles_++;
     /// The following logic is required to address the cases when a sensor is quickly replaced before it's marked
     /// as failed so that new sensor is eventually forced to be reinitialized for continuous measurement.
     if (this->skipped_data_read_cycles_ > MAX_SKIPPED_DATA_CYCLES_BEFORE_ERROR) {
-      ESP_LOGD(TAG, "Exceeded max allowed attempts; communication will be reinitialized");
+      ESP_LOGD(TAG, "Exceeded max attempts; will reinitialize");
       this->status_set_warning();
     }
     return;
@@ -211,11 +211,6 @@ void SPS30Component::update() {
 }
 
 bool SPS30Component::start_continuous_measurement_() {
-  uint8_t data[4];
-  data[0] = SPS30_CMD_START_CONTINUOUS_MEASUREMENTS & 0xFF;
-  data[1] = 0x03;
-  data[2] = 0x00;
-  data[3] = sht_crc_(0x03, 0x00);
   if (!this->write_command(SPS30_CMD_START_CONTINUOUS_MEASUREMENTS, SPS30_CMD_START_CONTINUOUS_MEASUREMENTS_ARG)) {
     ESP_LOGE(TAG, "Error initiating measurements");
     return false;
@@ -224,9 +219,9 @@ bool SPS30Component::start_continuous_measurement_() {
 }
 
 bool SPS30Component::start_fan_cleaning() {
-  if (!write_command(SPS30_CMD_START_FAN_CLEANING)) {
+  if (!this->write_command(SPS30_CMD_START_FAN_CLEANING)) {
     this->status_set_warning();
-    ESP_LOGE(TAG, "write error start fan (%d)", this->last_error_);
+    ESP_LOGE(TAG, "Start fan cleaning failed (%d)", this->last_error_);
     return false;
   } else {
     ESP_LOGD(TAG, "Fan auto clean started");

esphome/components/sps30/sps30.h

@@ -30,12 +30,12 @@ class SPS30Component : public PollingComponent, public sensirion_common::Sensiri
   bool start_fan_cleaning();
 
  protected:
-  char serial_number_[17] = {0};  /// Terminating NULL character
   uint16_t raw_firmware_version_;
-  bool start_continuous_measurement_();
+  char serial_number_[17] = {0};  /// Terminating NULL character
   uint8_t skipped_data_read_cycles_ = 0;
+  bool start_continuous_measurement_();
 
-  enum ErrorCode {
+  enum ErrorCode : uint8_t {
     COMMUNICATION_FAILED,
     FIRMWARE_VERSION_REQUEST_FAILED,
     FIRMWARE_VERSION_READ_FAILED,

esphome/components/status_led/__init__.py

@@ -2,7 +2,7 @@ from esphome import pins
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.const import CONF_ID, CONF_PIN
-from esphome.core import coroutine_with_priority
+from esphome.core import CoroPriority, coroutine_with_priority
 
 status_led_ns = cg.esphome_ns.namespace("status_led")
 StatusLED = status_led_ns.class_("StatusLED", cg.Component)
@@ -15,7 +15,7 @@ CONFIG_SCHEMA = cv.Schema(
 ).extend(cv.COMPONENT_SCHEMA)
 
 
-@coroutine_with_priority(80.0)
+@coroutine_with_priority(CoroPriority.STATUS)
 async def to_code(config):
     pin = await cg.gpio_pin_expression(config[CONF_PIN])
     rhs = StatusLED.new(pin)

esphome/components/stepper/__init__.py

@@ -10,7 +10,7 @@ from esphome.const import (
     CONF_SPEED,
     CONF_TARGET,
 )
-from esphome.core import CORE, coroutine_with_priority
+from esphome.core import CORE, CoroPriority, coroutine_with_priority
 
 IS_PLATFORM_COMPONENT = True
 
@@ -178,6 +178,6 @@ async def stepper_set_deceleration_to_code(config, action_id, template_arg, args
     return var
 
 
-@coroutine_with_priority(100.0)
+@coroutine_with_priority(CoroPriority.CORE)
 async def to_code(config):
     cg.add_global(stepper_ns.using)