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

esphome/components/rp2040/gpio.cpp

@@ -8,7 +8,7 @@ namespace rp2040 {
 
 static const char *const TAG = "rp2040";
 
-static int IRAM_ATTR flags_to_mode(gpio::Flags flags, uint8_t pin) {
+static int flags_to_mode(gpio::Flags flags, uint8_t pin) {
   if (flags == gpio::FLAG_INPUT) {  // NOLINT(bugprone-branch-clone)
     return INPUT;
   } else if (flags == gpio::FLAG_OUTPUT) {
@@ -25,14 +25,16 @@ static int IRAM_ATTR flags_to_mode(gpio::Flags flags, uint8_t pin) {
 }
 
 struct ISRPinArg {
+  uint32_t mask;
   uint8_t pin;
   bool inverted;
 };
 
 ISRInternalGPIOPin RP2040GPIOPin::to_isr() const {
   auto *arg = new ISRPinArg{};  // NOLINT(cppcoreguidelines-owning-memory)
-  arg->pin = pin_;
-  arg->inverted = inverted_;
+  arg->pin = this->pin_;
+  arg->inverted = this->inverted_;
+  arg->mask = 1 << this->pin_;
   return ISRInternalGPIOPin((void *) arg);
 }
 
@@ -81,21 +83,36 @@ void RP2040GPIOPin::detach_interrupt() const { detachInterrupt(pin_); }
 using namespace rp2040;
 
 bool IRAM_ATTR ISRInternalGPIOPin::digital_read() {
-  auto *arg = reinterpret_cast<ISRPinArg *>(arg_);
-  return bool(digitalRead(arg->pin)) != arg->inverted;  // NOLINT
+  auto *arg = reinterpret_cast<ISRPinArg *>(this->arg_);
+  return bool(sio_hw->gpio_in & arg->mask) != arg->inverted;
 }
+
 void IRAM_ATTR ISRInternalGPIOPin::digital_write(bool value) {
-  auto *arg = reinterpret_cast<ISRPinArg *>(arg_);
-  digitalWrite(arg->pin, value != arg->inverted ? 1 : 0);  // NOLINT
+  auto *arg = reinterpret_cast<ISRPinArg *>(this->arg_);
+  if (value != arg->inverted) {
+    sio_hw->gpio_set = arg->mask;
+  } else {
+    sio_hw->gpio_clr = arg->mask;
+  }
 }
+
 void IRAM_ATTR ISRInternalGPIOPin::clear_interrupt() {
   // TODO: implement
   // auto *arg = reinterpret_cast<ISRPinArg *>(arg_);
   // GPIO_REG_WRITE(GPIO_STATUS_W1TC_ADDRESS, 1UL << arg->pin);
 }
+
 void IRAM_ATTR ISRInternalGPIOPin::pin_mode(gpio::Flags flags) {
-  auto *arg = reinterpret_cast<ISRPinArg *>(arg_);
-  pinMode(arg->pin, flags_to_mode(flags, arg->pin));  // NOLINT
+  auto *arg = reinterpret_cast<ISRPinArg *>(this->arg_);
+  if (flags & gpio::FLAG_OUTPUT) {
+    sio_hw->gpio_oe_set = arg->mask;
+  } else if (flags & gpio::FLAG_INPUT) {
+    sio_hw->gpio_oe_clr = arg->mask;
+    hw_write_masked(&padsbank0_hw->io[arg->pin],
+                    (bool_to_bit(flags & gpio::FLAG_PULLUP) << PADS_BANK0_GPIO0_PUE_LSB) |
+                        (bool_to_bit(flags & gpio::FLAG_PULLDOWN) << PADS_BANK0_GPIO0_PDE_LSB),
+                    PADS_BANK0_GPIO0_PUE_BITS | PADS_BANK0_GPIO0_PDE_BITS);
+  }
 }
 
 }  // namespace esphome

esphome/components/rp2040/preferences.cpp

@@ -87,7 +87,7 @@ class RP2040Preferences : public ESPPreferences {
   RP2040Preferences() : eeprom_sector_(&_EEPROM_start) {}
   void setup() {
     s_flash_storage = new uint8_t[RP2040_FLASH_STORAGE_SIZE];  // NOLINT
-    ESP_LOGVV(TAG, "Loading preferences from flash...");
+    ESP_LOGVV(TAG, "Loading preferences from flash");
     memcpy(s_flash_storage, this->eeprom_sector_, RP2040_FLASH_STORAGE_SIZE);
   }
 
@@ -114,7 +114,7 @@ class RP2040Preferences : public ESPPreferences {
     if (s_prevent_write)
       return false;
 
-    ESP_LOGD(TAG, "Saving preferences to flash...");
+    ESP_LOGD(TAG, "Saving");
 
     {
       InterruptLock lock;
@@ -129,7 +129,7 @@ class RP2040Preferences : public ESPPreferences {
   }
 
   bool reset() override {
-    ESP_LOGD(TAG, "Cleaning up preferences in flash...");
+    ESP_LOGD(TAG, "Erasing storage");
     {
       InterruptLock lock;
       ::rp2040.idleOtherCore();

esphome/components/rp2040_pio_led_strip/led_strip.cpp

@@ -40,7 +40,7 @@ void RP2040PIOLEDStripLightOutput::dma_write_complete_handler_() {
 }
 
 void RP2040PIOLEDStripLightOutput::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up RP2040 LED Strip...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   size_t buffer_size = this->get_buffer_size_();
 
@@ -138,7 +138,7 @@ void RP2040PIOLEDStripLightOutput::setup() {
 }
 
 void RP2040PIOLEDStripLightOutput::write_state(light::LightState *state) {
-  ESP_LOGVV(TAG, "Writing state...");
+  ESP_LOGVV(TAG, "Writing state");
 
   if (this->is_failed()) {
     ESP_LOGW(TAG, "Light is in failed state, not writing state.");
@@ -199,12 +199,15 @@ light::ESPColorView RP2040PIOLEDStripLightOutput::get_view_internal(int32_t inde
 }
 
 void RP2040PIOLEDStripLightOutput::dump_config() {
-  ESP_LOGCONFIG(TAG, "RP2040 PIO LED Strip Light Output:");
-  ESP_LOGCONFIG(TAG, "  Pin: GPIO%d", this->pin_);
-  ESP_LOGCONFIG(TAG, "  Number of LEDs: %d", this->num_leds_);
-  ESP_LOGCONFIG(TAG, "  RGBW: %s", YESNO(this->is_rgbw_));
-  ESP_LOGCONFIG(TAG, "  RGB Order: %s", rgb_order_to_string(this->rgb_order_));
-  ESP_LOGCONFIG(TAG, "  Max Refresh Rate: %f Hz", this->max_refresh_rate_);
+  ESP_LOGCONFIG(TAG,
+                "RP2040 PIO LED Strip Light Output:\n"
+                "  Pin: GPIO%d\n"
+                "  Number of LEDs: %d\n"
+                "  RGBW: %s\n"
+                "  RGB Order: %s\n"
+                "  Max Refresh Rate: %f Hz",
+                this->pin_, this->num_leds_, YESNO(this->is_rgbw_), rgb_order_to_string(this->rgb_order_),
+                this->max_refresh_rate_);
 }
 
 float RP2040PIOLEDStripLightOutput::get_setup_priority() const { return setup_priority::HARDWARE; }

esphome/components/rp2040_pio_led_strip/light.py

@@ -173,7 +173,7 @@ RGB_ORDERS = {
 CHIPSET_TIMINGS = {
     "WS2812": LEDStripTimings(20, 40, 46, 34),
     "WS2812B": LEDStripTimings(23, 49, 46, 26),
-    "SK6812": LEDStripTimings(17, 52, 34, 34),
+    "SK6812": LEDStripTimings(20, 54, 38, 38),
     "SM16703": LEDStripTimings(17, 52, 52, 17),
 }
 

esphome/components/rp2040_pwm/rp2040_pwm.cpp

@@ -17,7 +17,7 @@ namespace rp2040_pwm {
 static const char *const TAG = "rp2040_pwm";
 
 void RP2040PWM::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up RP2040 PWM Output...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   this->setup_pwm_();
 }

esphome/components/rpi_dpi_rgb/rpi_dpi_rgb.cpp

@@ -6,7 +6,7 @@ namespace esphome {
 namespace rpi_dpi_rgb {
 
 void RpiDpiRgb::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up RPI_DPI_RGB");
+  ESP_LOGCONFIG(TAG, "Running setup");
   this->reset_display_();
   esp_lcd_rgb_panel_config_t config{};
   config.flags.fb_in_psram = 1;

esphome/components/rtttl/rtttl.cpp

@@ -27,15 +27,17 @@ inline double deg2rad(double degrees) {
 }
 
 void Rtttl::dump_config() {
-  ESP_LOGCONFIG(TAG, "Rtttl:");
-  ESP_LOGCONFIG(TAG, "  Gain: %f", gain_);
+  ESP_LOGCONFIG(TAG,
+                "Rtttl:\n"
+                "  Gain: %f",
+                this->gain_);
 }
 
 void Rtttl::play(std::string rtttl) {
   if (this->state_ != State::STATE_STOPPED && this->state_ != State::STATE_STOPPING) {
     int pos = this->rtttl_.find(':');
     auto name = this->rtttl_.substr(0, pos);
-    ESP_LOGW(TAG, "RTTTL Component is already playing: %s", name.c_str());
+    ESP_LOGW(TAG, "Already playing: %s", name.c_str());
     return;
   }
 
@@ -49,11 +51,11 @@ void Rtttl::play(std::string rtttl) {
   uint8_t num;
 
   // Get name
-  this->position_ = rtttl_.find(':');
+  this->position_ = this->rtttl_.find(':');
 
   // it's somewhat documented to be up to 10 characters but let's be a bit flexible here
   if (this->position_ == std::string::npos || this->position_ > 15) {
-    ESP_LOGE(TAG, "Missing ':' when looking for name.");
+    ESP_LOGE(TAG, "Unable to determine name; missing ':'");
     return;
   }
 
@@ -203,7 +205,7 @@ void Rtttl::loop() {
   if (this->output_ != nullptr && millis() - this->last_note_ < this->note_duration_)
     return;
 #endif
-  if (!this->rtttl_[position_]) {
+  if (!this->rtttl_[this->position_]) {
     this->finish_();
     return;
   }
@@ -271,7 +273,7 @@ void Rtttl::loop() {
     scale = this->default_octave_;
 
   if (scale < 4 || scale > 7) {
-    ESP_LOGE(TAG, "Octave out of valid range. Should be between 4 and 7. (Octave: %d)", scale);
+    ESP_LOGE(TAG, "Octave must be between 4 and 7 (it is %d)", scale);
     this->finish_();
     return;
   }
@@ -281,7 +283,7 @@ void Rtttl::loop() {
   if (note) {
     auto note_index = (scale - 4) * 12 + note;
     if (note_index < 0 || note_index >= (int) sizeof(NOTES)) {
-      ESP_LOGE(TAG, "Note out of valid range (note: %d, scale: %d, index: %d, max: %d)", note, scale, note_index,
+      ESP_LOGE(TAG, "Note out of range (note: %d, scale: %d, index: %d, max: %d)", note, scale, note_index,
                (int) sizeof(NOTES));
       this->finish_();
       return;
@@ -387,7 +389,7 @@ static const LogString *state_to_string(State state) {
 void Rtttl::set_state_(State state) {
   State old_state = this->state_;
   this->state_ = state;
-  ESP_LOGD(TAG, "State changed from %s to %s", LOG_STR_ARG(state_to_string(old_state)),
+  ESP_LOGV(TAG, "State changed from %s to %s", LOG_STR_ARG(state_to_string(old_state)),
            LOG_STR_ARG(state_to_string(state)));
 }
 

esphome/components/safe_mode/button/safe_mode_button.cpp

@@ -13,7 +13,7 @@ void SafeModeButton::set_safe_mode(SafeModeComponent *safe_mode_component) {
 }
 
 void SafeModeButton::press_action() {
-  ESP_LOGI(TAG, "Restarting device in safe mode...");
+  ESP_LOGI(TAG, "Restarting in safe mode");
   this->safe_mode_component_->set_safe_mode_pending(true);
 
   // Let MQTT settle a bit

esphome/components/safe_mode/safe_mode.cpp

@@ -16,17 +16,18 @@ static const char *const TAG = "safe_mode";
 
 void SafeModeComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "Safe Mode:");
-  ESP_LOGCONFIG(TAG, "  Boot considered successful after %" PRIu32 " seconds",
-                this->safe_mode_boot_is_good_after_ / 1000);  // because milliseconds
-  ESP_LOGCONFIG(TAG, "  Invoke after %u boot attempts", this->safe_mode_num_attempts_);
-  ESP_LOGCONFIG(TAG, "  Remain in safe mode for %" PRIu32 " seconds",
+  ESP_LOGCONFIG(TAG,
+                "  Boot considered successful after %" PRIu32 " seconds\n"
+                "  Invoke after %u boot attempts\n"
+                "  Remain for %" PRIu32 " seconds",
+                this->safe_mode_boot_is_good_after_ / 1000,  // because milliseconds
+                this->safe_mode_num_attempts_,
                 this->safe_mode_enable_time_ / 1000);  // because milliseconds
 
   if (this->safe_mode_rtc_value_ > 1 && this->safe_mode_rtc_value_ != SafeModeComponent::ENTER_SAFE_MODE_MAGIC) {
     auto remaining_restarts = this->safe_mode_num_attempts_ - this->safe_mode_rtc_value_;
     if (remaining_restarts) {
-      ESP_LOGW(TAG, "Last reset occurred too quickly; safe mode will be invoked in %" PRIu32 " restarts",
-               remaining_restarts);
+      ESP_LOGW(TAG, "Last reset occurred too quickly; will be invoked in %" PRIu32 " restarts", remaining_restarts);
     } else {
       ESP_LOGW(TAG, "SAFE MODE IS ACTIVE");
     }
@@ -48,7 +49,7 @@ void SafeModeComponent::set_safe_mode_pending(const bool &pending) {
   uint32_t current_rtc = this->read_rtc_();
 
   if (pending && current_rtc != SafeModeComponent::ENTER_SAFE_MODE_MAGIC) {
-    ESP_LOGI(TAG, "Device will enter safe mode on next boot");
+    ESP_LOGI(TAG, "Device will enter on next boot");
     this->write_rtc_(SafeModeComponent::ENTER_SAFE_MODE_MAGIC);
   }
 
@@ -83,7 +84,7 @@ bool SafeModeComponent::should_enter_safe_mode(uint8_t num_attempts, uint32_t en
     this->clean_rtc();
 
     if (!is_manual_safe_mode) {
-      ESP_LOGE(TAG, "Boot loop detected. Proceeding to safe mode");
+      ESP_LOGE(TAG, "Boot loop detected. Proceeding");
     }
 
     this->status_set_error();

esphome/components/safe_mode/switch/safe_mode_switch.cpp

@@ -17,7 +17,7 @@ void SafeModeSwitch::write_state(bool state) {
   this->publish_state(false);
 
   if (state) {
-    ESP_LOGI(TAG, "Restarting device in safe mode...");
+    ESP_LOGI(TAG, "Restarting in safe mode");
     this->safe_mode_component_->set_safe_mode_pending(true);
 
     // Let MQTT settle a bit

esphome/components/scd30/scd30.cpp

@@ -26,7 +26,7 @@ static const uint16_t SCD30_CMD_TEMPERATURE_OFFSET = 0x5403;
 static const uint16_t SCD30_CMD_SOFT_RESET = 0xD304;
 
 void SCD30Component::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up scd30...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
 #ifdef USE_ESP8266
   Wire.setClockStretchLimit(150000);
@@ -122,16 +122,16 @@ void SCD30Component::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 FIRMWARE_IDENTIFICATION_FAILED:
         ESP_LOGW(TAG, "Unable to read sensor firmware version");
         break;
       default:
-        ESP_LOGW(TAG, "Unknown setup error!");
+        ESP_LOGW(TAG, "Unknown setup error");
         break;
     }
   }
@@ -140,10 +140,13 @@ void SCD30Component::dump_config() {
   } else {
     ESP_LOGCONFIG(TAG, "  Altitude compensation: %dm", this->altitude_compensation_);
   }
-  ESP_LOGCONFIG(TAG, "  Automatic self calibration: %s", ONOFF(this->enable_asc_));
-  ESP_LOGCONFIG(TAG, "  Ambient pressure compensation: %dmBar", this->ambient_pressure_compensation_);
-  ESP_LOGCONFIG(TAG, "  Temperature offset: %.2f °C", this->temperature_offset_);
-  ESP_LOGCONFIG(TAG, "  Update interval: %ds", this->update_interval_);
+  ESP_LOGCONFIG(TAG,
+                "  Automatic self calibration: %s\n"
+                "  Ambient pressure compensation: %dmBar\n"
+                "  Temperature offset: %.2f °C\n"
+                "  Update interval: %ds",
+                ONOFF(this->enable_asc_), this->ambient_pressure_compensation_, this->temperature_offset_,
+                this->update_interval_);
   LOG_SENSOR("  ", "CO2", this->co2_sensor_);
   LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
   LOG_SENSOR("  ", "Humidity", this->humidity_sensor_);

esphome/components/scd4x/scd4x.cpp

@@ -27,7 +27,7 @@ static const uint16_t SCD41_ID = 0x1408;
 static const uint16_t SCD40_ID = 0x440;
 
 void SCD4XComponent::setup() {
-  ESP_LOGCONFIG(TAG, "Setting up scd4x...");
+  ESP_LOGCONFIG(TAG, "Running setup");
   // the sensor needs 1000 ms to enter the idle state
   this->set_timeout(1000, [this]() {
     this->status_clear_error();
@@ -96,16 +96,16 @@ void SCD4XComponent::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 firmware version");
         break;
       default:
-        ESP_LOGW(TAG, "Unknown setup error!");
+        ESP_LOGW(TAG, "Unknown setup error");
         break;
     }
   }
@@ -115,11 +115,15 @@ void SCD4XComponent::dump_config() {
                   this->ambient_pressure_source_->get_name().c_str());
   } else {
     if (this->ambient_pressure_compensation_) {
-      ESP_LOGCONFIG(TAG, "  Altitude compensation disabled");
-      ESP_LOGCONFIG(TAG, "  Ambient pressure compensation: %dmBar", this->ambient_pressure_);
+      ESP_LOGCONFIG(TAG,
+                    "  Altitude compensation disabled\n"
+                    "  Ambient pressure compensation: %dmBar",
+                    this->ambient_pressure_);
     } else {
-      ESP_LOGCONFIG(TAG, "  Ambient pressure compensation disabled");
-      ESP_LOGCONFIG(TAG, "  Altitude compensation: %dm", this->altitude_compensation_);
+      ESP_LOGCONFIG(TAG,
+                    "  Ambient pressure compensation disabled\n"
+                    "  Altitude compensation: %dm",
+                    this->altitude_compensation_);
     }
   }
   switch (this->measurement_mode_) {

esphome/components/sdl/display.py

@@ -8,16 +8,28 @@ from esphome.const import (
     CONF_HEIGHT,
     CONF_ID,
     CONF_LAMBDA,
+    CONF_POSITION,
     CONF_WIDTH,
+    CONF_X,
+    CONF_Y,
     PLATFORM_HOST,
 )
 
 sdl_ns = cg.esphome_ns.namespace("sdl")
 Sdl = sdl_ns.class_("Sdl", display.Display, cg.Component)
+sdl_window_flags = cg.global_ns.enum("SDL_WindowFlags")
 
 
 CONF_SDL_OPTIONS = "sdl_options"
 CONF_SDL_ID = "sdl_id"
+CONF_WINDOW_OPTIONS = "window_options"
+WINDOW_OPTIONS = (
+    "borderless",
+    "always_on_top",
+    "fullscreen",
+    "skip_taskbar",
+    "resizable",
+)
 
 
 def get_sdl_options(value):
@@ -29,6 +41,10 @@ def get_sdl_options(value):
         raise cv.Invalid("Unable to run sdl2-config - have you installed sdl2?") from e
 
 
+def get_window_options():
+    return {cv.Optional(option, default=False): cv.boolean for option in WINDOW_OPTIONS}
+
+
 CONFIG_SCHEMA = cv.All(
     display.FULL_DISPLAY_SCHEMA.extend(
         cv.Schema(
@@ -44,6 +60,17 @@ CONFIG_SCHEMA = cv.All(
                         }
                     ),
                 ),
+                cv.Optional(CONF_WINDOW_OPTIONS): cv.Schema(
+                    {
+                        cv.Optional(CONF_POSITION): cv.Schema(
+                            {
+                                cv.Required(CONF_X): cv.int_,
+                                cv.Required(CONF_Y): cv.int_,
+                            }
+                        ),
+                        **get_window_options(),
+                    }
+                ),
             }
         )
     ),
@@ -65,6 +92,19 @@ async def to_code(config):
         (width, height) = dimensions
         cg.add(var.set_dimensions(width, height))
 
+    if window_options := config.get(CONF_WINDOW_OPTIONS):
+        create_flags = 0
+        for option in WINDOW_OPTIONS:
+            value = window_options.get(option, False)
+            if value:
+                create_flags = create_flags | getattr(
+                    sdl_window_flags, "SDL_WINDOW_" + option.upper()
+                )
+        cg.add(var.set_window_options(create_flags))
+
+        if position := window_options.get(CONF_POSITION):
+            cg.add(var.set_position(position[CONF_X], position[CONF_Y]))
+
     if lamb := config.get(CONF_LAMBDA):
         lambda_ = await cg.process_lambda(
             lamb, [(display.DisplayRef, "it")], return_type=cg.void

esphome/components/sdl/sdl_esphome.cpp

@@ -8,8 +8,8 @@ namespace sdl {
 void Sdl::setup() {
   ESP_LOGD(TAG, "Starting setup");
   SDL_Init(SDL_INIT_VIDEO);
-  this->window_ = SDL_CreateWindow(App.get_name().c_str(), SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
-                                   this->width_, this->height_, SDL_WINDOW_RESIZABLE);
+  this->window_ = SDL_CreateWindow(App.get_name().c_str(), this->pos_x_, this->pos_y_, this->width_, this->height_,
+                                   this->window_options_);
   this->renderer_ = SDL_CreateRenderer(this->window_, -1, SDL_RENDERER_SOFTWARE);
   SDL_RenderSetLogicalSize(this->renderer_, this->width_, this->height_);
   this->texture_ =

esphome/components/sdl/sdl_esphome.h

@@ -28,6 +28,11 @@ class Sdl : public display::Display {
     this->width_ = width;
     this->height_ = height;
   }
+  void set_window_options(uint32_t window_options) { this->window_options_ = window_options; }
+  void set_position(uint16_t pos_x, uint16_t pos_y) {
+    this->pos_x_ = pos_x;
+    this->pos_y_ = pos_y;
+  }
   int get_width() override { return this->width_; }
   int get_height() override { return this->height_; }
   float get_setup_priority() const override { return setup_priority::HARDWARE; }
@@ -49,6 +54,9 @@ class Sdl : public display::Display {
   void redraw_(SDL_Rect &rect);
   int width_{};
   int height_{};
+  uint32_t window_options_{0};
+  int pos_x_{SDL_WINDOWPOS_UNDEFINED};
+  int pos_y_{SDL_WINDOWPOS_UNDEFINED};
   SDL_Renderer *renderer_{};
   SDL_Window *window_{};
   SDL_Texture *texture_{};

esphome/components/sdm_meter/sdm_meter.cpp

@@ -1,5 +1,6 @@
 #include "sdm_meter.h"
 #include "sdm_meter_registers.h"
+#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
 namespace esphome {
@@ -84,8 +85,10 @@ void SDMMeter::on_modbus_data(const std::vector<uint8_t> &data) {
 
 void SDMMeter::update() { this->send(MODBUS_CMD_READ_IN_REGISTERS, 0, MODBUS_REGISTER_COUNT); }
 void SDMMeter::dump_config() {
-  ESP_LOGCONFIG(TAG, "SDM Meter:");
-  ESP_LOGCONFIG(TAG, "  Address: 0x%02X", this->address_);
+  ESP_LOGCONFIG(TAG,
+                "SDM Meter:\n"
+                "  Address: 0x%02X",
+                this->address_);
   for (uint8_t i = 0; i < 3; i++) {
     auto phase = this->phases_[i];
     if (!phase.setup)

esphome/components/sdp3x/sdp3x.cpp

@@ -1,7 +1,7 @@
 #include "sdp3x.h"
-#include "esphome/core/log.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 namespace esphome {
 namespace sdp3x {
@@ -17,31 +17,31 @@ static const uint16_t SDP3X_STOP_MEAS = 0x3FF9;
 void SDP3XComponent::update() { this->read_pressure_(); }
 
 void SDP3XComponent::setup() {
-  ESP_LOGD(TAG, "Setting up SDP3X...");
+  ESP_LOGCONFIG(TAG, "Running setup");
 
   if (!this->write_command(SDP3X_STOP_MEAS)) {
-    ESP_LOGW(TAG, "Stop SDP3X failed!");  // This sometimes fails for no good reason
+    ESP_LOGW(TAG, "Stop failed");  // This sometimes fails for no good reason
   }
 
   if (!this->write_command(SDP3X_SOFT_RESET)) {
-    ESP_LOGW(TAG, "Soft Reset SDP3X failed!");  // This sometimes fails for no good reason
+    ESP_LOGW(TAG, "Soft Reset failed");  // This sometimes fails for no good reason
   }
 
   this->set_timeout(20, [this] {
     if (!this->write_command(SDP3X_READ_ID1)) {
-      ESP_LOGE(TAG, "Read ID1 SDP3X failed!");
+      ESP_LOGE(TAG, "Read ID1 failed");
       this->mark_failed();
       return;
     }
     if (!this->write_command(SDP3X_READ_ID2)) {
-      ESP_LOGE(TAG, "Read ID2 SDP3X failed!");
+      ESP_LOGE(TAG, "Read ID2 failed");
       this->mark_failed();
       return;
     }
 
     uint16_t data[6];
     if (!this->read_data(data, 6)) {
-      ESP_LOGE(TAG, "Read ID SDP3X failed!");
+      ESP_LOGE(TAG, "Read ID failed");
       this->mark_failed();
       return;
     }
@@ -79,18 +79,18 @@ void SDP3XComponent::setup() {
     }
 
     if (!this->write_command(measurement_mode_ == DP_AVG ? SDP3X_START_DP_AVG : SDP3X_START_MASS_FLOW_AVG)) {
-      ESP_LOGE(TAG, "Start Measurements SDP3X failed!");
+      ESP_LOGE(TAG, "Start Measurements failed");
       this->mark_failed();
       return;
     }
-    ESP_LOGCONFIG(TAG, "SDP3X started!");
+    ESP_LOGCONFIG(TAG, "started");
   });
 }
 void SDP3XComponent::dump_config() {
   LOG_SENSOR("  ", "SDP3X", this);
   LOG_I2C_DEVICE(this);
   if (this->is_failed()) {
-    ESP_LOGE(TAG, "  Connection with SDP3X failed!");
+    ESP_LOGE(TAG, "  Connection with failed");
   }
   LOG_UPDATE_INTERVAL(this);
 }
@@ -98,7 +98,7 @@ void SDP3XComponent::dump_config() {
 void SDP3XComponent::read_pressure_() {
   uint16_t data[3];
   if (!this->read_data(data, 3)) {
-    ESP_LOGW(TAG, "Couldn't read SDP3X data!");
+    ESP_LOGW(TAG, "Couldn't read data");
     this->status_set_warning();
     return;
   }

esphome/components/sds011/sds011.cpp

@@ -67,9 +67,11 @@ void SDS011Component::set_working_state(bool working_state) {
 }
 
 void SDS011Component::dump_config() {
-  ESP_LOGCONFIG(TAG, "SDS011:");
-  ESP_LOGCONFIG(TAG, "  Update Interval: %u min", this->update_interval_min_);
-  ESP_LOGCONFIG(TAG, "  RX-only mode: %s", ONOFF(this->rx_mode_only_));
+  ESP_LOGCONFIG(TAG,
+                "SDS011:\n"
+                "  Update Interval: %u min\n"
+                "  RX-only mode: %s",
+                this->update_interval_min_, ONOFF(this->rx_mode_only_));
   LOG_SENSOR("  ", "PM2.5", this->pm_2_5_sensor_);
   LOG_SENSOR("  ", "PM10.0", this->pm_10_0_sensor_);
   this->check_uart_settings(9600);
@@ -180,9 +182,6 @@ void SDS011Component::parse_data_() {
   }
 }
 
-uint16_t SDS011Component::get_16_bit_uint_(uint8_t start_index) const {
-  return (uint16_t(this->data_[start_index + 1]) << 8) | uint16_t(this->data_[start_index]);
-}
 void SDS011Component::set_update_interval_min(uint8_t update_interval_min) {
   this->update_interval_min_ = update_interval_min;
 }

esphome/components/sds011/sds011.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "esphome/core/component.h"
+#include "esphome/core/helpers.h"
 #include "esphome/components/sensor/sensor.h"
 #include "esphome/components/uart/uart.h"
 
@@ -32,7 +33,9 @@ class SDS011Component : public Component, public uart::UARTDevice {
   uint8_t sds011_checksum_(const uint8_t *command_data, uint8_t length) const;
   optional<bool> check_byte_() const;
   void parse_data_();
-  uint16_t get_16_bit_uint_(uint8_t start_index) const;
+  uint16_t get_16_bit_uint_(uint8_t start_index) const {
+    return encode_uint16(this->data_[start_index + 1], this->data_[start_index]);
+  }
 
   sensor::Sensor *pm_2_5_sensor_{nullptr};
   sensor::Sensor *pm_10_0_sensor_{nullptr};